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]

@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]

@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
    };
    
    ...
}