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.

Start with the proposal's extends! examples and the existing excess property checking behavior described for type tests and React component props. Define the operator's intended semantics and edge cases, then verify that the examples distinguish ordinary assignability from shallow excess property checking.