Type to invert optionality of properties

[CzBuCHi]

add new mapped type: Invert<T> ... I do not know, how to explain it in english, so i use code:

// proposal syntax
type Invert<T> = {
 [P in keyof T]?: T[P];
 [P? in keyof T]: T[P];
};

// usage
type Original = {
 first: any;
 second?: any;
}

type Inverted = Invert<Original>;

// type Inverted is threated as if declared like this:
type Inverted = {
 first?: any; // first is optional becasue it was required in Original
 second: any; // second is required becasue it was optional in Original
}

example usage: react defaultProps - to ensure, that all optional props are declared.

type SomeProps = {
 name: string;
 point?: { x: number, y: number };
}

class Some extends React.Component<SomeProps, void> {
 // proposal usage
 static defaultProps: Invert<SomeProps> = {
 // here i get compiler error if do not specify property 'point'
 };

 // current usage (worst)
 static defaultProps: any = {
 // here i dont get any errors at all
 };

 // better
 static defaultProps: Partial<SomeProps> = {
 // here i dont get any errors if i dont specify point
 // but at least get compiler error for typo...
 };

 // even better
 static defaultProps: { name?: string; point: { x: number, y: number } } = {
 // here i get compiler error if do not specify property 'point' and for typo
 // but i was forced to create new type ...
 };
}

priority: really low, almost negative :) - but if it can be done and isnt too hard ...

[saschanaz]

Interesting use case for me, but how about this way:

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

interface DefaultProps {
 point: { x: number, y: number };
}
interface SomeProps extends Optional<DefaultProps> {
 name: string;
}

var x: SomeProps = {
 name: 'abc' // error if missed
};
var y: DefaultProps = {
 point: { x: 0, y: 0 } // error if missed
};

[CzBuCHi]

Yes that will work too ... but in the end u need to define two separated tytes...

[mhegazy]

Duplicate of #13224 and #15012

[CzBuCHi]

Mohamed Hegazy (@mhegazy) i dont think this is a dupe,,.

both #13224 and #15012 are trying to make all properties required:

type Original = {
 first: any;
 second?: any;
}

type Result = {
 first: any;
 second: any;
}

im trying to 'flip' required flag on each property:

type Original = {
 first: any;
 second?: any;
}

type Result = {
 first?: any; // because Original.first was required
 second: any; // because Original.second was not required
}

but if u really think this is a dupe fell free to close it ...

[mhegazy]

do you have a scenario where flipping optionality is required?

[CzBuCHi]

Mohamed Hegazy (@mhegazy) look at my initial message ... bacically to have react component defaults required for optional props.

BTW: I think that i can achieve it by this code: (not tested)

module ISomeProps {
 export interface Req {
 first: any;
 }
 export interface Def {
 second:any;
 }
}
interface ISomeProps extends ISomeProps.Req, Partial<ISomeProps.Def> {}

class Some extends React.Component<ISomeProps, never> {
 static defaultProps: Partial<ISomeProps.Req> & ISomeProps.Def = {
 second: 42
 };
 
 ...
}