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

Discovering the Cookie in Angular 2 after it's Been Created

Can you explain the concept of being "well-typed" in TypeScript?

Analyzing a string using an alternative character

What is the command to determine the version of TypeScript being used in the command line interface (CLI)?

What steps should I take to resolve the 'invalid mime type' issue while transmitting an image as a binary string to Stability AI via Express?

The CORS policy specified in next.config.js does not appear to be taking effect for the API request

Encountered an issue in React Native/Typescript where the module 'react-native' does not export the member 'Pressable'.ts(2305)

The phrase 'tsc' is not identified as a valid cmdlet, function, script file, or executable program

Leveraging the Map function with Arrays in TypeScript

The specified argument, 'void', cannot be assigned to a parameter that expects 'SetStateAction | undefined'

Create categories for static array to enable automatic suggestions

Leveraging AWS CDK to seamlessly integrate an established data pipeline into your infrastructure

Incorporating onPause and onResume functionalities into a YouTube video featured on a page built with Ionic 2

Generate a fresh class instance in Typescript by using an existing class instance as the base

Is ngForIn a valid directive in Angular 4?

Enhance the annotation of JS types for arguments with default values

What are the steps for implementing the ReactElement type?

Can you explain the distinction between using get() and valueChanges() in an Angular Firestore query?

The or operator in Typescript does not function properly when used as a generic argument

What causes the Angular child component (navbar) to no longer refresh the view after a route change?