Determine the data type of an object key based on the value of another key within the same

Question

Determine the data type of an object key based on the value of another key within the same

Consider having an Object Type named Options, which consists of two keys:

strategy: a function that takes one parameter of an unknown type
parameter: the same type as the first argument of strategy

The desired functionality is as follows:

type FooParameter = { foo: string }
type BarParameter = { bar: string }

const fooOptions: Options = {
  strategy: (parameter: FooParameter) => {},
  parameter: { foo: 'foo' }
}
const barOptions: Options = {
  strategy: (parameter: BarParameter) => {},
  parameter: { bar: 'bar' }
}

It should be possible for TypeScript to infer the type of fooOptions.parameter from fooOptions.strategy and likewise for barOptions.parameter from barOptions.strategy.

Is this currently achievable with TypeScript?

typescript

Answer 1

Answer №1

To tackle this issue, the most viable approach I can think of is by utilizing a generic type. I highly doubt that there exists a solution where the compiler will validate that parameter is an appropriate argument for strategy without making use of a generic type.

type Options<T> = {
    strategy: (parameter: T) => void,
    parameter: T
}

This implies that when Options is applied in a type annotation, you are required to supply a type parameter:

const fooOptions: Options<FooParameter> = {
    strategy: (parameter: FooParameter) => {},
    parameter: { foo: 'foo' }
}

function useOptions<T>(o: Options<T>): void {
    o.strategy(o.parameter);
}

However, whenever the compiler can deduce the type (i.e. when no type annotation is utilized), it is not mandatory to explicitly define a type for the generic type parameter. Specifically, users of an API like the useOptions function can provide an object literal and benefit from type-checking and type inference:

useOptions({
    strategy: param => {
        let x = param.x; // Automatically inferred as number
        let y = param.y; // Automatically inferred as string

        // Error: Property 'z' does not exist on type '{ x: number, y: string }'
        let z = param.z;
    },
    parameter: { x: 1, y: 'foo' }
});

Keep in mind that the user in this scenario doesn't need to explicitly specify { x: number, y: string } or any equivalent type to utilize the API.

Playground Link

Answer 2

To tackle this issue, the most viable approach I can think of is by utilizing a generic type. I highly doubt that there exists a solution where the compiler will validate that parameter is an appropriate argument for strategy without making use of a generic type.

type Options<T> = {
    strategy: (parameter: T) => void,
    parameter: T
}

This implies that when Options is applied in a type annotation, you are required to supply a type parameter:

const fooOptions: Options<FooParameter> = {
    strategy: (parameter: FooParameter) => {},
    parameter: { foo: 'foo' }
}

function useOptions<T>(o: Options<T>): void {
    o.strategy(o.parameter);
}

However, whenever the compiler can deduce the type (i.e. when no type annotation is utilized), it is not mandatory to explicitly define a type for the generic type parameter. Specifically, users of an API like the useOptions function can provide an object literal and benefit from type-checking and type inference:

useOptions({
    strategy: param => {
        let x = param.x; // Automatically inferred as number
        let y = param.y; // Automatically inferred as string

        // Error: Property 'z' does not exist on type '{ x: number, y: string }'
        let z = param.z;
    },
    parameter: { x: 1, y: 'foo' }
});

Keep in mind that the user in this scenario doesn't need to explicitly specify { x: number, y: string } or any equivalent type to utilize the API.

Playground Link

Determine the data type of an object key based on the value of another key within the same

Answer №1

Similar questions

Using Angular's dependency injection in a project that has been transpiled with Babel

What is the correct way to assign multiple types to a single entity in TypeScript?

Show the user's chosen name in place of their actual identity during a chat

Using TypeScript to implement functional props in React applications

Develop an enhancement for the Date object in Angular 2 using Typescript

Having trouble getting Angular Material's mat-autocomplete to function properly when the application is in

The specified main access point, "@angular/cdk/platform", is lacking in required dependencies

Get an angular xml file by utilizing the response from a C# web API download

Iterate over Observable data, add to an array, and showcase all outcomes from the array in typescript

Describe the TypeScript type for an object with constant keys

Implementing the breadcrumb component within dynamically loaded modules loaded through the router-outlet component

extracting the HTML content from JavaScript and saving it into a standalone file

Error TS2559 occurs when the type '{ children: never[]; }' does not share any properties with the type 'IntrinsicAttributes & { post?: IPost | undefined; }'. This discrepancy in properties causes a type mismatch in the code

"This error message states that the use of an import statement outside a module is not allowed

The value of req.headers('Authorization') has not been defined

Angular - Showing validation messages post successful execution of two functions

When attempting to loop through an Observable that is of type array using *ngFor, the error message "Cannot read property 'subscribe' of undefined

Is there a way to identify the accurate or incorrect array element and modify the component color accordingly?

When implementing JSS with React and TypeScript, certain CSS properties may encounter a `type is unassignable` error

Interacting with a form input by triggering the onChange event