Allow conditionally setting optional properties in a mapped type #36126

Activity

1. Roaders commented on Jan 10, 2020

   

   Roaders

   on Jan 10, 2020

   Author

   More actions

   From Daniel Rosenwasser (@DanielRosenwasser) on Twitter:

   You could imagine an intersection of two mapped types - one with optional properties and one with required. I think that might be what you had in mind?

   So from this I imagine a solution like this:

   type Optional<T> = {
       [P in keyof T]?: T[P]
   }
   
   type MapParams<T> = {
       [P in keyof T]: T extends string ? T[P] : Optional<T>[P]
   }
   

   but this still doesn't work. If I do this:

   type Optional<T> = {
       [P in keyof T]?: T[P]
   }
   
   type MapParams<T> = {
       [P in keyof T]: Optional<T>[P];
   }
   

   then the ? in Optional gets converted into T[P] | undefined in MapParams
2. Ryan Cavanaugh (RyanCavanaugh)

   added

   Awaiting More FeedbackThis means we'd like to hear from more people who would be helped by this featureThis means we'd like to hear from more people who would be helped by this feature

   SuggestionAn idea for TypeScriptAn idea for TypeScript

   on Jan 10, 2020
3. jcalz commented on Jan 13, 2020

   

   Joe Calzaretta (jcalz)

   on Jan 13, 2020

   Contributor

   More actions

   Duplicate of #32562
4. jorroll commented on Nov 23, 2020

   

   John (jorroll)

   on Nov 23, 2020

   Last edited by jorroll

   More actions

   I also ran into this limitation. As pointed out #32562, it is possible to workaround this limitation (I'm posting here because I think this issue has a much clearer title/description and is easier to find).

   Here is an ugly but working solution that will hopefully help someone else:

   type PickUndefinedKeys<T> = {
     [K in keyof T]: undefined extends T[K] ? K : never;
   }[keyof T];
   
   type PickRequiredKeys<T> = {
     [K in keyof T]: undefined extends T[K] ? never : K;
   }[keyof T];
   
   type SelectOptional<T extends {}> = Pick<
     T,
     Exclude<PickUndefinedKeys<T>, undefined>
   >;
   
   type SelectRequired<T extends {}> = Pick<
     T,
     Exclude<PickRequiredKeys<T>, undefined>
   >;
   
   // EXAMPLES
   
   type Test1 = SelectOptional<{one?: string; two: number}>;
   // => { one?: string }
   
   type Test2 = SelectRequired<{one?: string; two: number}>
   // => { two: number }

   As a more complex example, say you want to map the types in an object while retaining each property's original optional status:

   interface IPerson {
     name: string
   }
   
   type OptionalNameMap<
     T extends { [key: string]: IPerson | undefined }
   > = {
     [P in Exclude<PickUndefinedKeys<T>, undefined>]?: NonNullable<T[P]>['name'];
   };
   
   type RequiredNameMap<
     T extends { [key: string]: IPerson | undefined }
   > = {
     [P in Exclude<PickRequiredKeys<T>, undefined>]: NonNullable<T[P]>['name'];
   };
   
   type MapNames<T extends { [key: string]: IPerson | undefined }> = RequiredNameMap<T> & OptionalNameMap<T>;
   
   // EXAMPLE
   
   type NameDictionary = MapNames<{one: IPerson, two?: IPerson }>;
   // => { one: string, two?: string | undefined }

   Edit:
   It's worth noting that I don't think this workaround can differentiate between { one?: string } and { one: string | undefined }. In my case, that's fine, but that might be problematic for others.

   🚀React with 🚀1Reacted by Rudomanenko Volodymyr
5. DavideValdo commented on May 17, 2021

   

   Davide Biagini (DavideValdo)

   on May 17, 2021

   Last edited by DavideValdo

   More actions

   I managed to pull this off with some work:

   type TestType = {
     a: SomeInterface;
     b: string;
   };
   
   type Intersection<A, B> = A & B extends infer U
     ? { [P in keyof U]: U[P] }
     : never;
   
   type Matching<T, SomeInterface> = {
     [K in keyof T]: T[K] extends SomeInterface ? K : never;
   }[keyof T];
   
   type NonMatching<T, SomeInterface> = {
     [K in keyof T]: T[K] extends SomeInterface ? never : K;
   }[keyof T];
   
   type DesiredOutcome = Intersection<
     Partial<Pick<TestType, Matching<TestType, SomeInterface>>>,
     Required<Pick<TestType, NonMatching<TestType, SomeInterface>>
   >

   I think it would be confusing to have the logic for adding ? in the right side of a property declaration

   It would be awesome to have this syntax:

   type Optionalize<T> = {
      [P in keyof T](?: T[P] extends SomeInterface): ...;
   } 

   But I guess this is not such a common problem to justify the effort.
6. OoDeLally commented on Apr 1, 2022

   

   Pascal Heitz (OoDeLally)

   on Apr 1, 2022

   More actions

   I was thinking about this, and I have a syntax proposal that doesn't require any parser change:

   type MyKeys = 'optionalKey' | 'requiredKey';
   type Foo = {
      [Key in keyof MyKeys as Key extends 'optionalKey' ? Key | undefined : Key]: string;
   }
   // Result is
   {
     optionalKey?: string;
     requiredKey: string;
   }

   Note that TS already uses such "trick" with never to command not to add the key at all, so I think my proposal is the closest to an existing behavior.

   👍React with 👍7Reacted by Sri Krishna, Max Patiiuk, João Sequeira, Colin McDonnell, Juanra GM, Lance J. and Ilya Semenov
7. ecyrbe commented on Jul 31, 2023

   

   ecyrbe

   on Jul 31, 2023

   More actions

   Here is a proposal syntax leveraging on K in keyof T as syntax but allowing modifiers to be part of brakets :

   type MyKeys = 'optionalKey' | 'requiredKey' | 'readonlyKey' | 'readonlyOptionalKey';
   type Foo = {
      [Key in keyof MyKeys as Key extends 'optionalKey' ? 
                                                Key+? : 
                                              Key extends 'readonlyKey' ? 
                                                Key+readonly :
                                              Key extends 'readonlyOptionalKey ?
                                                Key+?+readonly :
                                              Key
      ]: string;
   }
   // Result is
   {
     optionalKey?: string;
     requiredKey: string;
     readonly readonlyKey: string;
     readonly readonlyOptionalKey?: string;
   }

   if you use '-' instead of '+' it removes the modifier :

   type MyKeys = 'optionalKey' | 'requiredKey' | 'readonlyKey' | 'readonlyOptionalKey';
   type Foo = {
       readonly [Key in keyof MyKeys as Key extends 'requiredKey' ? 
                                                Key-?-readonly : 
                                              Key extends 'readonlyKey' ? 
                                                Key-? :
                                              Key extends 'optionalKey' ?
                                                Key-readonly :
                                              Key
      ]?: string;
   }
   // Result is
   {
     optionalKey?: string;
     requiredKey: string;
     readonly readonlyKey: string;
     readonly readonlyOptionalKey?: string;
   }
8. microsoft

   deleted a comment from Martin Bohgard (mbohgard) on Mar 21, 2024
9. layerok commented on Jun 22, 2024

   

   Rudomanenko Volodymyr (layerok)

   on Jun 22, 2024

   More actions

   By combing PickOptinalProperties and PickRequiredProperties types, I was able to construct a type that makes properties that extend undefined optional

   export type MakeUndefinedPropertiesOptional<T> = Partial<
     Pick<T, PickUndefinedKeys<T>>
   > &
     Pick<T, PickRequiredKeys<T>>;
     
   type Props = {
      params: undefined;
      data: undefined;
   }
   
   const props: MakeUndefinedPropertiesOptional<Props> = {}; // no error
10. joyt commented on Apr 2, 2025

    

    Joy Tao (joyt)

    on Apr 2, 2025

    More actions

    +1 to supporting this in a first-class way. My use case is that I want to map keys of a certain value type to a different value type, while preserving the optional-ness of the properties in the original type:

    // I want to turn this:
    export interface BaseComment {
       creator: UserReference;
       repliers?: UserReference[];
    }
    
    // into this:
    export interface DisplayComment {
       creator: UserID;
       repliers?: UserID[];
    }
    
    // ideally by doing something like
    export type DisplayComment = Display<BaseComment>;

    Currently I have to splice together 2 mapped types to combine both required vs optional keys in order to "preserve" their optional-ness:

    // Found this method from https://type-level-typescript.com/articles/how-to-get-optional-keys-from-object-types
    export type RequiredKeys<T> = keyof {
      [K in keyof T as Omit<T, K> extends T ? never : K]: T[K];
    };
    export type OptionalKeys<T> = keyof {
      [K in keyof T as Omit<T, K> extends T ? K : never]: T[K];
    };
    
    export interface BaseComment {
      creator: UserReference;
      repliers?: UserReference[];
    }
    
    export type ConvertReferenceToID<T> =
      T extends Array<UserReference> ? UserID[] : T extends UserReference ? UserID : T;
    
    export type Display<T> = { [K in RequiredKeys<T>]: ConvertReferenceToID<T[K]> } & {
      [K in OptionalKeys<T>]?: ConvertReferenceToID<T[K]>;
    };
    
    export type DisplayComment = Display<BaseComment>;