Is there a way to consolidate two interface types while combining the overlapping properties into a union type?

Question

Is there a way to consolidate two interface types while combining the overlapping properties into a union type?

Is there a way to create a type alias, Combine<A, B>, that can merge properties of any two interfaces, A and B, by combining their property types using union?

Let's consider the following two interfaces as an example:

interface Interface1 {
  type: string;
  another: bool;
}

interface Interface2 {
  type: number;
}

If we were to use

Combine<Interface1, Interface2>

, the resulting type should look like this:

type Result = {
  type: string | number;
  another: bool;
}

typescript

Answer 1

Answer №1

Begin by extracting all keys present in set A but not in set B, along with keys from set B that are not found in set A. For overlapping keys, define the union explicitly:

type Combine<A, B> = 
    Omit<A, keyof B> // elements in A not in B
  & Omit<B, keyof A> // elements in B not in A
  & { [K in keyof A & keyof B]: A[K] | B[K] }; // combination of both.

It is worth noting that specifying that certain keys may be absent in one set or the other can be achieved using Partial with the Omit:

type Combine<A, B> = 
    Partial<Omit<A, keyof B>> // potentially elements in A not in B
  & Partial<Omit<B, keyof A>> // possibly elements in B not in A
  & { [K in keyof A & keyof B]: A[K] | B[K] }; // combination of both.

Update: Upon Aaronium's inquiry about utilizing unions, an improved approach has been devised, where T extends any ? X : never is leveraged to expand all keys existing in any element within a union and then consolidate a union of corresponding values across interfaces. This results in a streamlined method:

// retrieves all viable keys from all interfaces within a union.
type AllKeysOf<T> = T extends any ? keyof T : never
// essentially performs T[K], but for unionized T it only yields T[K] for valid key members within the union.
type Get<T, K extends keyof any, Fallback=never> = T extends Record<K, any> ? T[K] : Fallback
// combines a union of interfaces, merging common keys into a union of possibilities.
type Combine<T> = {[K in AllKeysOf<T>]: Get<T,K>}

type TEST = Combine<{a:1} | {a:2, b:10} | {b: 11}>
// TEST = {a: 1|2, b: 10|11}

Keep in mind that adjusting the generic Fallback in Get</code to <code>never will exclude union elements lacking that key. Alternatively, setting it to undefined suggests that keys defined in some interfaces but not all might result in undefined values, resembling optionality. The exact interpretation of these different handling methods largely relies on your specific scenario, so experimentation with both never and undefined is recommended to determine desired behavior.

Answer 2

Begin by extracting all keys present in set A but not in set B, along with keys from set B that are not found in set A. For overlapping keys, define the union explicitly:

type Combine<A, B> = 
    Omit<A, keyof B> // elements in A not in B
  & Omit<B, keyof A> // elements in B not in A
  & { [K in keyof A & keyof B]: A[K] | B[K] }; // combination of both.

It is worth noting that specifying that certain keys may be absent in one set or the other can be achieved using Partial with the Omit:

type Combine<A, B> = 
    Partial<Omit<A, keyof B>> // potentially elements in A not in B
  & Partial<Omit<B, keyof A>> // possibly elements in B not in A
  & { [K in keyof A & keyof B]: A[K] | B[K] }; // combination of both.

Update: Upon Aaronium's inquiry about utilizing unions, an improved approach has been devised, where T extends any ? X : never is leveraged to expand all keys existing in any element within a union and then consolidate a union of corresponding values across interfaces. This results in a streamlined method:

// retrieves all viable keys from all interfaces within a union.
type AllKeysOf<T> = T extends any ? keyof T : never
// essentially performs T[K], but for unionized T it only yields T[K] for valid key members within the union.
type Get<T, K extends keyof any, Fallback=never> = T extends Record<K, any> ? T[K] : Fallback
// combines a union of interfaces, merging common keys into a union of possibilities.
type Combine<T> = {[K in AllKeysOf<T>]: Get<T,K>}

type TEST = Combine<{a:1} | {a:2, b:10} | {b: 11}>
// TEST = {a: 1|2, b: 10|11}

Keep in mind that adjusting the generic Fallback in Get</code to <code>never will exclude union elements lacking that key. Alternatively, setting it to undefined suggests that keys defined in some interfaces but not all might result in undefined values, resembling optionality. The exact interpretation of these different handling methods largely relies on your specific scenario, so experimentation with both never and undefined is recommended to determine desired behavior.

Is there a way to consolidate two interface types while combining the overlapping properties into a union type?

Answer №1

Similar questions

Achieving VS Code/typescript autocomplete functionality without the need to import the library

One potential solution for fixing the error in GetRepository of TypeORM is to check for undefined properties before attempting to access them. This error typically occurs when trying to read properties of an undefined

Instructions on how to post an array by its ID when the value changes in the form, correspond with the ID

Difficulty retrieving information using AngularJS service post selection of item

Obtaining attributes of a class from an object passed into the constructor

Why does the ReactJS MaterialUI Modal fail to update properly?

No members were exported by the module, please export an interface

Property does not exist when dispatching in React Redux within componentDidMount

The React component fails to render when clicking on a Material-UI MenuItem

Best practices for transferring date objects between a frontend developed in JavaScript/TypeScript and a backend built in ASP.net Core 5

An issue with the Pipe searchByType is resulting in an error stating that the property 'type' is not found on the type 'unknown'

Strategies for evaluating a Promise-returning imported function in Jest

What is the best way to include a new attribute in a TypeScript internal object?

Exploring the Node environment setup within Nest.js

What is the best way to filter out specific data fields from console.log in JavaScript?

The element 'PROGRAM_ID' is not recognized within the 'import @metaplex-foundation/mpl-token-metadata' type

Implementing tailwindcss styles in a typescript interface with reactjs

Uploading multiple strings to an Amazon S3 bucket using Node.js by piping a string

The Angular service successfully provides a value, yet it fails to appear on the webpage

Parent Class implementation for dynamic loading of components