Fields have an invisible "never make it undefined" state

[verytactical]

🔎 Search Terms

undefined forever

⏯ Playground Link

https://www.typescriptlang.org/play/?#code/C4TwDgpgBAqgdgZwseATCAzAlnCqAqA9gPIBGANlgG5aFwA8+AfFALxQDeUA2gApQ4oAawghCGKPgC6AWgD8ALkl8pUAD5QArnHTZcqANxQAvlABQoSFADKyNJhx5GLdlz4C4w0eMlSl+FXUtHQd9E3NLaHwACwgAdWiAQ2A2GzsQvSd4JBQMxwISCmpaBi5ExSgARhMmJjMgA

💻 Code

type UnsetUndefinedToOblivion<T> = { [P in keyof T]-?: T[P] | undefined; } 
type SetUndefined<T> = { [P in keyof T]: T[P] | undefined } 
type TheWhat = SetUndefined<UnsetUndefinedToOblivion<{ a?: 1 }>>

🙁 Actual behavior

type TheWhat = {
    a: 1;
}

🙂 Expected behavior

type TheWhat = {
    a: 1 | undefined;
}

Additional information about the issue

Temporary fix:

type UnsetTheUnset<T> = { [P in keyof T & {}]: T[P] }
type TheWhat = SetUndefined<UnsetTheUnset<UnsetUndefinedToOblivion<{ a?: 1 }>>>

[jcalz]

Duplicate of Related to #31025

[verytactical]

@jcalz This is a different issue. Here it's not only removed, it's impossible to even set it afterwards.

[jcalz]

EDIT: Okay, I guess it's not related to #31025, sorry

Ah, yeah, I see. It's probably still related to #31025, since removing undefined is happening at the end of the type manipulation, but you're showing a case where "the end" is much much later than makes any sense.

To be painstakingly explicit about this, you can perform your two steps with an intermediate named type and it still happens:

type AOne = UnsetUndefinedToOblivion<{a?: 1}>
//   ^? type AOne = { a: 1 } // okay

type TheWhat = SetUndefined<AOne>
//   ^? type TheWhat = { a: 1 } // 🙃

Playground

[verytactical]

removing undefined is happening at the end of the type manipulation

Honestly I would never expect that. Thanks for explaining!

It's probably still related to #31025

It's definitely related, because if undefined was never removed along with optionality, it wouldn't be removed at incorrect time :)

[jcalz]

Note that we want undefined to be removed along with optionality, but we want it removed from the input type's property, not from the output type's property. That is, the expectation looks like {[K in keyof T]-?: F<T[K]>} should behave like {[K in keyof T]-?: F<Exclude<T[K], undefined>>} and not like {[K in keyof T]-?: Exclude<F<T[K]>, undefined>} (which is #31025). Unfortunately this behavior has existed for so long that I doubt they can really fix it because I imagine lots of real world code actually depends on it.

But what's going on here is that even {[K in keyof T]-?: Exclude<F<T[K]>, undefined>} doesn't capture the extent of the weirdness. It really looks like the output of the mapped type is decorated with a permanent "no undefined" marker that operates through later type manipulations. Maybe they an at least fix this, since it's so weird.

[Andarist]

I believe this is just a display issue as this works alright:

type UnsetUndefinedToOblivion<T> = { [P in keyof T]-?: T[P] | undefined };
type SetUndefined<T> = { [P in keyof T]: T[P] | undefined };
type TheWhat = SetUndefined<UnsetUndefinedToOblivion<{ a?: 1 }>>;

const theWhat: TheWhat = {
  a: undefined, // ok
};

It's likely a duplicate of #59948 and likely is being fixed by #59957 // EDIT: yep, I just pushed a test case there based on this issue

[jcalz]

Okay, okay this has nothing to do with #31025 then. Sorry! I'll hide my comments (including this one, soon) to cut down on noise.

[typescript-bot]

This issue has been marked as "Duplicate" and has seen no recent activity. It has been automatically closed for house-keeping purposes.