Add alternative to `extends` that performs shallow excess property checking

Search Terms

excess property check exact strict extends

Suggestion

I'm proposing an extends! operator that does excess property checking.

Use Cases

I specifically would like this for testing types. It would be helpful for having a check like
expectTypeOf<{a: 1, b: 1}>().toBeAssignableTo<{a?: 1}>();

Also for type-checking props of React components, TypeScript uses excess property checking:

<Component propExists propDoesntExist />
                      ^^^^^^^^^^^^^^^

so it's not enough to just check Props extends React.ComponentProps<Component> ? true : false to determine TypeScript would give a type error in this scenario.

I'm currently approximating this by doing something similar to:

Props extends React.ComponentProps<Component>
  ? keyof Props extends keyof React.ComponentProps<Component>
    ? true
    : false
  : false;

Examples

// `true`
type Example1 = {a: 1, b: 1} extends {a?: 1} ? true : false;

// `false`
type Example2 = {a: 1, b: 1} extends! {a?: 1} ? true : false;

// `true`
type Example3 = {a: 1} extends! {a?: 1} ? true : false;

// Type 'keyof T' cannot be used to index type 'U'.(2536)
type Example1<T, U> = T extends U ? U[keyof T] : never;
                                      ^^^^^^^
// Okay
type Example2<T, U> = T extends! U ? U[keyof T] : never;

Checklist

My suggestion meets these guidelines:

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

Commencez par les exemples de extends! de la proposition et par le comportement existant de la vérification des propriétés excédentaires décrit pour les tests de types et les props des composants React. Définissez la sémantique prévue de l’opérateur et ses cas limites, puis vérifiez que les exemples distinguent l’assignabilité ordinaire de la vérification superficielle des propriétés excédentaires.