Specialized type for extra restriction on enum matching

Question

Specialized type for extra restriction on enum matching

In my current project, I am dealing with two enums named SourceEnum and TargetEnum. Each enum has a corresponding function that is called with specific parameters based on the enum value. The expected parameter types are defined by the type mappings SourceParams and TargetParams.

enum SourceEnum {
  SOURCE_A = 'SOURCE_A',
  SOURCE_B = 'SOURCE_B'
}

enum TargetEnum {
  TARGET_A = 'TARGET_A',
  TARGET_B = 'TARGET_B',
}

interface SourceParams {
  [SourceEnum.SOURCE_A]: { paramA: string };
  [SourceEnum.SOURCE_B]: { paramB: number };
}

interface TargetParams {
  [TargetEnum.TARGET_A]: { paramA: string };
  [TargetEnum.TARGET_B]: { paramB: number };
}

function sourceFn<S extends SourceEnum>(source: S, params: SourceParams[S]) { /* ... */ }

function targetFn<T extends TargetEnum>(target: T, params: TargetParams[T]) { /* ... */ }

I have created a mapping that involves functionality to evaluate a target value for each source value. My goal is to ensure that the params object used in calling sourceFn(x, params) will also be suitable for the call targetFn(mapping[x](), params). To address this requirement, I formulated the following type:

type ConstrainedMapping = {
  [K in SourceEnum]: <T extends TargetEnum>() => (SourceParams[K] extends TargetParams[T] ? T : never) 
};

const mapping: ConstrainedMapping = {
  [SourceEnum.SOURCE_A]: () => TargetEnum.TARGET_A;
  // ...
}

However, setting up the mapping as shown above triggers the following error message:

Type 'TargetEnum.TARGET_A' is not assignable to type '{ paramA: string; } extends TargetParams[T] ? T : never'.

Although my typing seems correct, I cannot grasp why this issue is arising. It appears that TypeScript may struggle with pinpointing the exact enum value at a certain point.

Is there a methodology to accomplish this? I am currently using TypeScript 4.2, but I experimented with versions 4.3 and 4.4-beta as well, all yielding the same outcome. Any solution applicable to 4.2 would be greatly appreciated, although I am open to implementing a future version if necessary.

typescript types typescript-types

Answer 1

Answer №1

Here, the expectation is for Typescript to analyze

<T extends TargetEnum>(): SourceParams[K] extends TargetParams[T] ? T : never;

, where all possible values of T are evaluated and a union is created based on the true conditions.

However, Typescript does not operate in this manner. It treats T as unknown and stops evaluating after replacing { paramA: string; } for SourceParams[K]. The desired distribution only happens with Distributive Conditional Types, so it's necessary to modify the ConstrainedMapping accordingly.

A Distributive Conditional Type is an alias where none of the parameters are restricted. Therefore, for a proper return value declaration, it must have its own separate type definition instead of being embedded within ConstrainedMapping.

type TargetWithMatchingParams<S, T> =
  S extends SourceEnum
    ? T extends TargetEnum
      ? SourceParams[S] extends TargetParams[T]
        ? T
        : never
      : never
    : never;

Since S and T cannot be constrained, more conditions need to be included in the template. Furthermore, the entire TargetEnum cannot be hardcoded directly; it must distribute across an unconstrained parameter in the type alias.

Following this modification, it can now be utilized within ConstrainedMapping:

type ConstrainedMapping = {
  [S in SourceEnum]: () => TargetWithMatchingParams<S, TargetEnum>;
};

It is important to note that the function is no longer generic—a crucial aspect for resolving the issue at hand—and the distribution expected earlier is achieved by passing TargetEnum into TargetWithMatchingParams.

If the scenario is static like the given example, removing () => from the ConstrainedMapping definition and using mapping[x] instead of mapping[x]() could enhance performance and readability.

In conclusion, there are certain limitations associated with this approach:

When using mapping on a generic variable extending SourceEnum, it may cause issues. While

targetFn(mapping[SourceEnum.SOURCE_A](), { paramA: 'foo' })

functions correctly, TypeScript may encounter errors when handling calls such as:

function bar<S extends SourceEnum>(src: S, params: SourceParams[S]) {
  targetFn(mapping[src](), params);
                           ^^^^^^
//                         Argument of type 'SourceParams[S]'
//                           is not assignable to parameter of type
//                           'TargetParams[ConstrainedMapping[S]]'.
}

This highlights TypeScript's inability to fully understand the relationship between SourceParams and TargetParams, resulting in difficulty recognizing valid matches.

In scenarios involving unions of sources and source parameters, unsafe values might not trigger errors. For instance:
```
function baz(src: SourceEnum, params: SourceParams[SourceEnum]) {
  targetFn(mapping(src), params);
}
baz(SourceEnum.SOURCE_A, { paramB: 42 });
```
Even though SOURCE_A and paramB create an invalid combination, TypeScript may not flag this discrepancy due to how unions function.

In summary, ensure that specific enum types are used while calling sourceFn and

targetFn</code, rather than relying on the entire enum. TypeScript lacks the capability to track relationships across distinct variables, so pairing an unknown <code>SourceEnum

with corresponding

SourceParams[SourceEnum]</code may go unchecked, irrespective of any definitions within <code>mapping

.

Answer 2

Here, the expectation is for Typescript to analyze

<T extends TargetEnum>(): SourceParams[K] extends TargetParams[T] ? T : never;

, where all possible values of T are evaluated and a union is created based on the true conditions.

However, Typescript does not operate in this manner. It treats T as unknown and stops evaluating after replacing { paramA: string; } for SourceParams[K]. The desired distribution only happens with Distributive Conditional Types, so it's necessary to modify the ConstrainedMapping accordingly.

A Distributive Conditional Type is an alias where none of the parameters are restricted. Therefore, for a proper return value declaration, it must have its own separate type definition instead of being embedded within ConstrainedMapping.

type TargetWithMatchingParams<S, T> =
  S extends SourceEnum
    ? T extends TargetEnum
      ? SourceParams[S] extends TargetParams[T]
        ? T
        : never
      : never
    : never;

Since S and T cannot be constrained, more conditions need to be included in the template. Furthermore, the entire TargetEnum cannot be hardcoded directly; it must distribute across an unconstrained parameter in the type alias.

Following this modification, it can now be utilized within ConstrainedMapping:

type ConstrainedMapping = {
  [S in SourceEnum]: () => TargetWithMatchingParams<S, TargetEnum>;
};

It is important to note that the function is no longer generic—a crucial aspect for resolving the issue at hand—and the distribution expected earlier is achieved by passing TargetEnum into TargetWithMatchingParams.

If the scenario is static like the given example, removing () => from the ConstrainedMapping definition and using mapping[x] instead of mapping[x]() could enhance performance and readability.

In conclusion, there are certain limitations associated with this approach:

When using mapping on a generic variable extending SourceEnum, it may cause issues. While

targetFn(mapping[SourceEnum.SOURCE_A](), { paramA: 'foo' })

functions correctly, TypeScript may encounter errors when handling calls such as:

function bar<S extends SourceEnum>(src: S, params: SourceParams[S]) {
  targetFn(mapping[src](), params);
                           ^^^^^^
//                         Argument of type 'SourceParams[S]'
//                           is not assignable to parameter of type
//                           'TargetParams[ConstrainedMapping[S]]'.
}

This highlights TypeScript's inability to fully understand the relationship between SourceParams and TargetParams, resulting in difficulty recognizing valid matches.

In scenarios involving unions of sources and source parameters, unsafe values might not trigger errors. For instance:
```
function baz(src: SourceEnum, params: SourceParams[SourceEnum]) {
  targetFn(mapping(src), params);
}
baz(SourceEnum.SOURCE_A, { paramB: 42 });
```
Even though SOURCE_A and paramB create an invalid combination, TypeScript may not flag this discrepancy due to how unions function.

In summary, ensure that specific enum types are used while calling sourceFn and

targetFn</code, rather than relying on the entire enum. TypeScript lacks the capability to track relationships across distinct variables, so pairing an unknown <code>SourceEnum

with corresponding

SourceParams[SourceEnum]</code may go unchecked, irrespective of any definitions within <code>mapping

.

Specialized type for extra restriction on enum matching

Answer №1

Similar questions

Utilizing req.session in an Express application with Angular (written in TypeScript) when deploying the backend and frontend separately on Heroku

Experiencing CORS problem in Ionic 3 when accessing API on device

Having trouble displaying a "SectionList" in "React Native", it's just not cooperating

I encountered an issue while making customizations to my default next.config.js file. Despite attempting various solutions, I consistently encountered an error regarding the invalid src property

Timeout with Promise

What causes the select dropdown to display an empty default in Angular 8 following an HTTP request?

Finding a date from a calendar with a readonly property in Playwright

Enhance Angular Forms: Style Readonly Fields in Grey and Validate Data Retrieval using Typescript

Determine if an element in Angular 6 contains a particular style

"Update your Chart.js to version 3.7.1 to eliminate the vertical scale displaying values on the left

Notify user before exiting the page if there is an unsaved form using TypeScript

Resolving the issue of missing properties from type in a generic object - A step-by-step guide

Exploring Angular: The Dynamic Declaration of object.property in ngModel

The AngularJS 2 TypeScript application has been permanently relocated

The current Angular 11 build seems to lack in producing sufficient Lazy chunk files

When an empty array is returned from a catch statement in an async/await method, TypeScript infers it as never

Creating HTML elements dynamically based on the value of a prop within a React component

Can someone please explain how to prevent Prettier from automatically inserting a new line at the end of my JavaScript file in VS Code?

Swap out the default URL in components with the global constant

Ensure that the form is submitted only after confirming it in the modal with react-hook-form