Deriving types from object combinations

Question

Deriving types from object combinations

Can the Foo type be 'flattened' to return { A?: string; B? number } in the code snippet below?

type Foo = { A: string } | { B: number }

type Flatten<
  T,
  Keys extends keyof T = T extends any ? keyof T : never,
> = { [K in Keys]?: T[K] }


type Bar = Flatten<Foo> 
// { A?: unknown; B? unknown }, but can it be changed to `{ A?: string; B? number }`?

code

typescript

Answer 1

Answer №1

My interpretation of the Flatten<T> operation is like condensing a union of object types into a single object type, assuming that object types were sealed or "exact" (as mentioned in microsoft/TypeScript#12936) and did not allow extra properties.

Presently, object types are open or extensible, and they permit excess properties. For instance, a value of type {a: string} may have a string-valued property a, along with other properties such as b. The absence of b in the type definition does not mean it's missing. The compiler considers the property at key b in {a: string} to be of type unknown, because it could be anything. Therefore, the b property in {a: string} | {b: number} is also of type unknown. This results in flattening to something like {a?: unknown, b?: unknown}, which is not ideal.

There isn't currently a way to specify that all unspecified keys should be prohibited. You can make use of

Exact<{a: string}> | Exact<{b: number}>

but this does not completely achieve what you desire. If a particular key must be forbidden, the closest solution is to define it as an optional property with a value of never.

The plan here involves collecting all keys from each union member of T:

Determine AllKeys<T> - keys from all union members of T.
Restrict each union member of T by prohibiting unmentioned keys from AllKeys<T>.
Combine the new union members into a single object type.

For example, if T is {a: string} | {b: number}:

AllKeys<T> would be "a" | "b".
Restrictions on unmentioned keys for each member:
- From {a: string} to {a: string; b?: never} to restrict b.
- From {b: number} to {a?: never; b: number} to restrict a.
Merge
```
{a: string; b?: never} | {a?: never; b: number}
```
into a single object type {a?: string; b?: number}.

This explains the implementation approach.

Let's begin with implementing AllKeys<T>:

type AllKeys<T> = T extends unknown ? keyof T : never;

This straightforward conditional type gathers keys from each member of T together.

We then move on to creating ProhibitExtra<T, K>which prohibits any extra keys from K in an object type T:

type ProhibitExtra<T, K extends PropertyKey> =
  T & { [P in Exclude<K, keyof T>]?: never };

This operation includes optional never-typed properties in T for every unmentioned key in

K</code.</p>
<p>Next, we develop <code>ExactifyUnion<T>

to apply ProhibitExtra<T, K> to unions in T, where K is AllKeys<T> for the original T:

type ExactifyUnion<T, K extends PropertyKey = AllKeys<T>> =
  T extends unknown ? ProhibitExtra<T, K> : never

Finally, we create Flatten<T> by utilizing ExactifyUnion<T> to obtain a new union and collapsing it into a single object type:

type Flatten<T> = Omit<ExactifyUnion<T>, never>;

The above method leverages the fact that the Omit utility type does not distribute over unions, making it an easy way to create a non-distributed mapped type.

Let's test our implementation:

type F1 = Flatten<{ a: string } | { b: number }> 
// Type F1 = { a?: string; b?: number }

That aligns with the desired output. It's important to note that when a property is present in all union members, it should not be optional:

type F2 = Flatten<{ a: string } | { a: number }> 
// Type F2 { a: string | number }

A glimpse into handling optional/required properties across different union members:

type F3 = Flatten<
  { a?: string, b: number, c: boolean, d?: Date } |
  { c: string, d?: number, e: boolean, f?: Date }>
/* Type F3 = {
    a?: string;
    b?: number;
    c: string | boolean;
    d?: number | Date;
    e?: boolean;
    f?: Date;
} */

The results look promising!

Check out the Playground link for the code

Answer 2

My interpretation of the Flatten<T> operation is like condensing a union of object types into a single object type, assuming that object types were sealed or "exact" (as mentioned in microsoft/TypeScript#12936) and did not allow extra properties.

Presently, object types are open or extensible, and they permit excess properties. For instance, a value of type {a: string} may have a string-valued property a, along with other properties such as b. The absence of b in the type definition does not mean it's missing. The compiler considers the property at key b in {a: string} to be of type unknown, because it could be anything. Therefore, the b property in {a: string} | {b: number} is also of type unknown. This results in flattening to something like {a?: unknown, b?: unknown}, which is not ideal.

There isn't currently a way to specify that all unspecified keys should be prohibited. You can make use of

Exact<{a: string}> | Exact<{b: number}>

but this does not completely achieve what you desire. If a particular key must be forbidden, the closest solution is to define it as an optional property with a value of never.

The plan here involves collecting all keys from each union member of T:

Determine AllKeys<T> - keys from all union members of T.
Restrict each union member of T by prohibiting unmentioned keys from AllKeys<T>.
Combine the new union members into a single object type.

For example, if T is {a: string} | {b: number}:

AllKeys<T> would be "a" | "b".
Restrictions on unmentioned keys for each member:
- From {a: string} to {a: string; b?: never} to restrict b.
- From {b: number} to {a?: never; b: number} to restrict a.
Merge
```
{a: string; b?: never} | {a?: never; b: number}
```
into a single object type {a?: string; b?: number}.

This explains the implementation approach.

Let's begin with implementing AllKeys<T>:

type AllKeys<T> = T extends unknown ? keyof T : never;

This straightforward conditional type gathers keys from each member of T together.

We then move on to creating ProhibitExtra<T, K>which prohibits any extra keys from K in an object type T:

type ProhibitExtra<T, K extends PropertyKey> =
  T & { [P in Exclude<K, keyof T>]?: never };

This operation includes optional never-typed properties in T for every unmentioned key in

K</code.</p>
<p>Next, we develop <code>ExactifyUnion<T>

to apply ProhibitExtra<T, K> to unions in T, where K is AllKeys<T> for the original T:

type ExactifyUnion<T, K extends PropertyKey = AllKeys<T>> =
  T extends unknown ? ProhibitExtra<T, K> : never

Finally, we create Flatten<T> by utilizing ExactifyUnion<T> to obtain a new union and collapsing it into a single object type:

type Flatten<T> = Omit<ExactifyUnion<T>, never>;

The above method leverages the fact that the Omit utility type does not distribute over unions, making it an easy way to create a non-distributed mapped type.

Let's test our implementation:

type F1 = Flatten<{ a: string } | { b: number }> 
// Type F1 = { a?: string; b?: number }

That aligns with the desired output. It's important to note that when a property is present in all union members, it should not be optional:

type F2 = Flatten<{ a: string } | { a: number }> 
// Type F2 { a: string | number }

A glimpse into handling optional/required properties across different union members:

type F3 = Flatten<
  { a?: string, b: number, c: boolean, d?: Date } |
  { c: string, d?: number, e: boolean, f?: Date }>
/* Type F3 = {
    a?: string;
    b?: number;
    c: string | boolean;
    d?: number | Date;
    e?: boolean;
    f?: Date;
} */

The results look promising!

Check out the Playground link for the code

Answer 3

Answer №2

Here's a simple solution that works nicely:

interface Animal {
  name: string;
  age: number;
}

interface Food {
  type: string;
  quantity: number;
}

type Zoo = Animal | Food;

const myZoo: Zoo = {name: 'Leo', age: 3};

Answer 4

Here's a simple solution that works nicely:

interface Animal {
  name: string;
  age: number;
}

interface Food {
  type: string;
  quantity: number;
}

type Zoo = Animal | Food;

const myZoo: Zoo = {name: 'Leo', age: 3};

Deriving types from object combinations

Answer №1

Answer №2

Similar questions

Discovering if a page can be scrolled in Angular

The parameter type '(value: any) => any[]' does not match the expected parameter type 'string[]'

NGRX reducer avoids generating errors due to incorrect assignments

Angular 2: A guide to resetting dropdown and text values when changing radio button selections

What is the best way to retrieve the current complete URL in a Next.js/Typescript component?

Incorporating a Component with lazy-loading capabilities into the HTML of another Component in Angular 2+

Creating a component in Angular that utilizes multiple nested FormGroups

Utilizing Next.js to create a Higher Order Component (HOC) for fetching data from a REST API using Typescript is proving to be a challenge, as the

Breaking down an array into function arguments in TypeScript/JavaScript

What is the best way to obtain a distinct collection from two arrays that eliminates the second appearance of an element based on a key's value, rather than the first as in the Lodash uniqueBy function?

Issue "Value of type '{}' cannot be assigned to parameter of type 'T | (() => T)'" encountered within a React component containing a type parameter

Combine an array of arrays with its elements reversed within the same array

The function is missing a closing return statement and the return type does not specify 'undefined'

Testing Vue components with Typescript and Jest does not display the expected values in the HTML output

Are you encountering issues with Google Analytics performance on your Aurelia TypeScript project?

"Encountering issues with importing Splitpanes while using VueJs and TypeScript combination

Uncovering the origins of computed object keys in TypeScript

Linking Redux to the highest level of my application is not functioning as expected

Utilizing an Angular Service within the main.ts script

Utilizing Typescript in tandem with an external library through es6 modules