Retrieve the keys of a type by analyzing one of its values

Question

Retrieve the keys of a type by analyzing one of its values

My global type definition consists of an object with keys (referred to as a prop) that must be passed by the user as a parameter to myFunction(), and values that are used solely for type checking within my code.

These values can fall into only 3 "possible types" (contained in Possible). Each possible type has its own distinct definition.

I want myFunction() to only accept props whose value's test property is equal to "possible1".

The generic type OnlyPossible1Props<T> demonstrates how I envisioned implementing this, but unfortunately it does not function as intended.

Initially, I encounter an error:

Type 'prop' cannot be used to index type 'T'. (2536)

In addition, instead of returning "abc" | "def" as expected in myFunction(), it returns string | number.

The closest workaround I've managed so far is the section of code that I have commented out. However, along the way, it loses key information because it isn't stored anywhere.

For easier debugging, you can access the type Possible = "possible1" | "possible2" | "possible3"; type ValueBase<T extends Possible, U, V> = { test: T, other1: U, other2: V }; type Value1<T> = ValueBase<"possible1", T, T>; type Value2<T> = ValueBase<"possible2", T, [T, T]>; type Value3<T> = ValueBase<"possible3", T, T[]>; type Definition = { [prop: string]: Value1<any> | Value2<any> | Value3<any> }; interface Example extends Definition { "abc": { test: "possible1", other1: string other2: string }, "def": { test: "possible1", other1: string other2: string }, "ghi": { test: "possible2", other1: string other2: [string, string] }, "jkl": { test: "possible3", other1: string other2: string[] } } // type OnlyPossible1Props<T> = T extends object ? // T[keyof T] extends infer A ? // A extends { test: "possible1" } // ? A : never : never : never; type OnlyPossible1Props<T> = T extends object ? keyof T extends infer prop ? T[prop] extends infer A ? A extends { test: "possible1" } ? prop : never : never : never : never; function myFunction<Prop extends OnlyPossible1Props<Example>>(prop: Prop) { }

typescript generics typescript-generics

Answer 1

Answer №1

When you remove extends Definition from Example, the following code works:

type OnlyPossible1Props<T> = {
    [K in
        { [J in keyof T]: T[J] extends { test: "possible1" } ? J : never }[keyof T]
    ]?: T[K]
};

This results in:

type ExampleOnlyPossible1Props = OnlyPossible1Props<Example>;

// equivalent to:

type ExampleOnlyPossible1Props = {
    abc?: {
        test: "possible1";
        other1: string;
        other2: string;
    };
    def?: {
        test: "possible1";
        other1: string;
        other2: string;
    };
}

(You may want to skip the optional modifier ?).

This gives us:

myFunction({ "abc": { test: "possible1", other1: "foo", other2: "bar" } }) // OK
myFunction({ "def": { test: "possible2", other1: ["a", "b"], other2: "bcd" } }) // Error

By using this approach, we can see how it works on the Example, you can use this alternative method:

type OnlyPossible1Props<T> = {
    [J in keyof T]: T[J] extends { test: "possible1" } ? T[J] : never
}[keyof T];

This will give you a union type that is demonstrated in this

The following works, but only if you remove extends Definition from Example:

type OnlyPossible1Props<T> = {
    [K in
        { [J in keyof T]: T[J] extends { test: "possible1" } ? J : never }[keyof T]
    ]?: T[K]
};

This results in:

type ExampleOnlyPossible1Props = OnlyPossible1Props<Example>;

// equivalent to:

type ExampleOnlyPossible1Props = {
    abc?: {
        test: "possible1";
        other1: string;
        other2: string;
    };
    def?: {
        test: "possible1";
        other1: string;
        other2: string;
    };
}

(You may want to skip the optional modifier ?).

This gives us:

myFunction({ "abc": { test: "possible1", other1: "foo", other2: "bar" } }) // OK
myFunction({ "def": { test: "possible2", other1: ["a", "b"], other2: "bcd" } }) // Error

You can see that in this TypeScript Playground.

The reason this does not work if Example extends Definition is that the index signature on Definition means keyof Example evaluates to string | number, rather than the actual keys of Example. If extends Definition is removed, we get keyof Example as "abc" | "def" | "ghi" | "jkl".

If you want myFunction to accept one of the possible1 props from Example, you can instead use:

type OnlyPossible1Props<T> = {
    [J in keyof T]: T[J] extends { test: "possible1" } ? T[J] : never
}[keyof T];

This gives you a union type that you can see that in this TypeScript Playground:

myFunction({ test: "possible1", other1: "foo", other2: "bar" }) // OK
myFunction({ test: "possible2", other1: ["a", "b"], other2: "bcd" }) // Error

Answer 2

When you remove extends Definition from Example, the following code works:

type OnlyPossible1Props<T> = {
    [K in
        { [J in keyof T]: T[J] extends { test: "possible1" } ? J : never }[keyof T]
    ]?: T[K]
};

This results in:

type ExampleOnlyPossible1Props = OnlyPossible1Props<Example>;

// equivalent to:

type ExampleOnlyPossible1Props = {
    abc?: {
        test: "possible1";
        other1: string;
        other2: string;
    };
    def?: {
        test: "possible1";
        other1: string;
        other2: string;
    };
}

(You may want to skip the optional modifier ?).

This gives us:

myFunction({ "abc": { test: "possible1", other1: "foo", other2: "bar" } }) // OK
myFunction({ "def": { test: "possible2", other1: ["a", "b"], other2: "bcd" } }) // Error

By using this approach, we can see how it works on the Example, you can use this alternative method:

type OnlyPossible1Props<T> = {
    [J in keyof T]: T[J] extends { test: "possible1" } ? T[J] : never
}[keyof T];

This will give you a union type that is demonstrated in this

The following works, but only if you remove extends Definition from Example:

type OnlyPossible1Props<T> = {
    [K in
        { [J in keyof T]: T[J] extends { test: "possible1" } ? J : never }[keyof T]
    ]?: T[K]
};

This results in:

type ExampleOnlyPossible1Props = OnlyPossible1Props<Example>;

// equivalent to:

type ExampleOnlyPossible1Props = {
    abc?: {
        test: "possible1";
        other1: string;
        other2: string;
    };
    def?: {
        test: "possible1";
        other1: string;
        other2: string;
    };
}

(You may want to skip the optional modifier ?).

This gives us:

myFunction({ "abc": { test: "possible1", other1: "foo", other2: "bar" } }) // OK
myFunction({ "def": { test: "possible2", other1: ["a", "b"], other2: "bcd" } }) // Error

You can see that in this TypeScript Playground.

The reason this does not work if Example extends Definition is that the index signature on Definition means keyof Example evaluates to string | number, rather than the actual keys of Example. If extends Definition is removed, we get keyof Example as "abc" | "def" | "ghi" | "jkl".

If you want myFunction to accept one of the possible1 props from Example, you can instead use:

type OnlyPossible1Props<T> = {
    [J in keyof T]: T[J] extends { test: "possible1" } ? T[J] : never
}[keyof T];

This gives you a union type that you can see that in this TypeScript Playground:

myFunction({ test: "possible1", other1: "foo", other2: "bar" }) // OK
myFunction({ test: "possible2", other1: ["a", "b"], other2: "bcd" }) // Error

Answer 3

The following works, but only if you remove extends Definition from Example:

type OnlyPossible1Props<T> = {
    [K in
        { [J in keyof T]: T[J] extends { test: "possible1" } ? J : never }[keyof T]
    ]?: T[K]
};

This results in:

type ExampleOnlyPossible1Props = OnlyPossible1Props<Example>;

// equivalent to:

type ExampleOnlyPossible1Props = {
    abc?: {
        test: "possible1";
        other1: string;
        other2: string;
    };
    def?: {
        test: "possible1";
        other1: string;
        other2: string;
    };
}

(You may want to skip the optional modifier ?).

This gives us:

myFunction({ "abc": { test: "possible1", other1: "foo", other2: "bar" } }) // OK
myFunction({ "def": { test: "possible2", other1: ["a", "b"], other2: "bcd" } }) // Error

You can see that in this TypeScript Playground.

The reason this does not work if Example extends Definition is that the index signature on Definition means keyof Example evaluates to string | number, rather than the actual keys of Example. If extends Definition is removed, we get keyof Example as "abc" | "def" | "ghi" | "jkl".

If you want myFunction to accept one of the possible1 props from Example, you can instead use:

type OnlyPossible1Props<T> = {
    [J in keyof T]: T[J] extends { test: "possible1" } ? T[J] : never
}[keyof T];

This gives you a union type that you can see that in this TypeScript Playground:

myFunction({ test: "possible1", other1: "foo", other2: "bar" }) // OK
myFunction({ test: "possible2", other1: ["a", "b"], other2: "bcd" }) // Error

Retrieve the keys of a type by analyzing one of its values

Answer №1

Similar questions

Encountered an error while trying to install @material-ui/core through npm: Received an unexpected end of JSON input

Alert: The route "/D:/original/22-02-2017/job2.html" specified in [react-router] does not correspond to any existing routes

What is the process for obtaining a flattened tuple type from a tuple comprised of nested tuples?

Trigger a React event using D3.js dispatch

Troubleshooting MeshStandardMaterial problem in Three.js on Mac M1 with Chrome

Utilizing React with .NET 8.0 and Minimal API, the front end is configured to send HTTP requests to its own specific port rather than the

Encountering an undefined property error while using Array.filter in Angular 2

Is there a way to retrieve a compilation of custom directives that have been implemented on the Vue 3 component?

The Vue store array declaration triggers a TS error stating that it is not assignable to a parameter of type never

Issues with Angular ng-bootstrap tabset component not functioning as expected

What are some strategies for distinguishing between callable and newable types?

The required property '0' is not found in the type 'any[]' but it is needed in the type '[{ post_id: string; title: string; }]'

Angular 6 Calendar Template issues with parsing: Unable to link to 'view' as it is not recognized as a valid property of 'div'

What is the best way to mandate the declaration or type of a function in TypeScript?

Errors caused by Typescript transpilation only manifest on the production server

Determine in Typescript if a value is a string or not

Displaying Information in Angular Modal Windows

What could be causing my D3.js stacked bar chart to show inaccurate results?

A practical guide to effectively mocking named exports in Jest using Typescript

The error message in React JS Typescript states: "Cannot assign a string to a parameter that requires a SetStateAction<number>"