Omit<UnionType, "NonDiscriminatedKey"> cause failure in destructed type

[yarden-app]

🔎 Search Terms

Distributive types, conditional

🕗 Version & Regression Information

Always

⏯ Playground Link

https://www.typescriptlang.org/play/?#code/PTBQIAgIQQwZwJYGMIBcCeAHAphAJtgGYIB2CqCA9iRCOGBjhAIIQC8908ujuzADBAAW8CAEkAIhBgk8EACrkANtlAQWggGRrawCBIRwkAJwQBbUjFTY5vOAAoARtznUIAcl7uImY5RzGGACUEIR+ZiwAjNKyLABMOvbM0QA+8UGgoLwa7BAA3jqSAFwQcKimJADmANw6iqgqJWUVNboQADwAtJ3i0ngEtkK4AET1KsPScNIQZtjwAK7GPJQQ2CRwizwiqBAA8hao7cwANMOSwwB8EADu1J4QjrgyHjLo3thmmBgQlI4AVtgkKhQABfTJ0SB4QwmcyWChuOy6ehZLB8aJsfI6XglYYwSLDWpglFMZhxXIFdTYiC4uIEnRlKzzOA4hmoJl0omQeRCQyrAAeME+KlKQko1ymqG2ewOEF5JEoO1uxgA1qRKpN+TggTZQCRBdg4JgYEhcPLUAB9JWqqqY9R0O16ZjzSqzEioKxUGiUQjU+SolgTe1tMQ7P5MnZWayfVASlZLPWzcRSVArR6yvA6IPZKC5fbkI7HannK6aW3qdNNcpq2rqIkOzN6MTrd0kE0-H1+phQBs6JDUMoPEo5jEU8tjbA44bHHSU1E4vFTmcV6mL2u1BsQADCKhgxiU6EL5FlU2wfK11kGVggADpbwqhsZSh64MQDSwbuRRfMduQppIfH4AQYNevb9jso4OvoBrlPMQJqmgcYfJQABuIwIHgEy+P42CBOgS7odO5Y3neko4ToIK5I467qH2zbSCUrAjm0XQ9J22AAKLGH4xhLre173jhhHlsUK5CSChLgno3K8qegqYMKcCiuKaBStcn6UN+PwykeeCUG+Vq6vqhrGrgVrwaO2a5KwpYQcuzTVuRmQ0WBg7QOSS4icMq5jsoE6iUuVK4viQnqOhk5idREC0QOtkER5EiFpALEQOxqE0NcQw0Ke5TGjszDuH+CWlCsfECY+ikaUochpkoCDKrgeaHCcRYSBMaTDOa6GXLxJEPuRlGRdFEYMeSzHdBAADqlAqlMoinueOpEaVpHGCFSbheRhJAA

💻 Code

//
// Basic type definition //
//
type A =
// Base type A0 has ID and Title
  A0 &
  // Discriminated types(based on 'type' property) from A1 and A2
  (A1 | A2)

type A0 = {
  ID: string;
  Title: string; // <-- I added the "Title" as a measure to ensure that Omit<A,"ID"> won't be an 'any' empty object
}

//
// discrimination types //
//
type A1 = {
  type: "a1";
}

type A2 = {
  type: "a2";
  status: "status";
}

// This example shows that Omit is not working as expected
namespace not_working {
  //
  // Augmentation of "Type A" //
  // It just attempts to rename ID to be id
  //
  type B = Omit<A, "ID"> & {
    id: string;
  }

  //
  // Instance of Type B
  //
  const b: B = {
    Title: "",
    type: "a1",
    id: "",
  };

  // Clearly, it is expected that ...other satisfies A without its ID property.
  const {
    // Destructing to remove "id" property
    id,
    ...other
  } = b;

  const a: A = { // <-- TypeError
    ...other,
    ID: "",
  };
}

// This example shows that without omit it does work
namespace working {
  type B = A & {
    id: string;
  }

  const b: B = {
    ID: "",
    Title: "",
    type: "a1",
    id: "",
  };

  const {
    id,
    ID, // <-- Even when extract A's ID, so ...other should be like Omit<A, "ID" | "_id">
    ...other
  } = b;

  const a: A = { // <-- Works as expected
    ...other,
    ID: "",
  };
}

🙁 Actual behavior

I think that the Omit causes a conditional distributive type to trigger or something.

🙂 Expected behavior

I expect that the code example will work as expected and that the TypeError will not appear in the not_working namespace.

Additional information about the issue

No response

[jcalz]

Duplicate of #47263 and others. Omit<T, K> does not distribute over unions in T. If T is a union you probably don't want to use Omit but a distributed version of it, which you can write yourself in various ways, like

type DistribOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never

or

type DistribOmit<T, K extends PropertyKey> = { [P in keyof T as P extends K ? never : P]: T[P] }

etc

[RyanCavanaugh]

See also #53169

[yarden-app]

@jcalz
IDK. Shouldnt it be that the "Pick" part in Omit be like:

  type __Pick<T, K extends keyof T> = T extends any ? {
    [P in K]: T[P];
  } : never;

Like why would I want it otherwise? the working and non_working example show something that seems to be expected.

Anyway I now understand that even if it is true, then it wouldn't be changed due to being a breaking change.

[RyanCavanaugh]

The current behavior is not super justifiable, but the results in #53188 show how wildly disruptive it would be to change them.