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.

Comienza con los ejemplos de extends! de la propuesta y el comportamiento existente de la comprobación de propiedades excesivas descrito para las pruebas de tipos y las props de componentes de React. Define la semántica prevista del operador y sus casos límite, y verifica después que los ejemplos distingan la asignabilidad ordinaria de la comprobación superficial de propiedades excesivas.