Verify in typescript if type A is equal to either type B or type C

Question

Verify in typescript if type A is equal to either type B or type C

Within one specific file, there is a structured code block like the following:

export const _total = {
  a: '',
  b: '',
  c: '',
  d: '',
  e: '',
  f: '',
}
type TotalKeysType = typeof _all;
export type TotalKey = keyof TotalKeysType;

In a separate file, there exists the following code structure:

export const _retain = {
  a: '',
  b: '',
  d: '',
  e: '',
}
type RetainKeysType = typeof _retain;
export type RetainKey = keyof RetainKeysType;

export const _deny = {
  c: '',
  f: '',
}
type DenyKeysType = typeof _deny;
export type DenyKey = keyof DenyKeysType;

Is it possible to utilize Typescript in guaranteeing that the keys specified in _total are always equivalent to the combination of keys from both _retain and _deny? Essentially, ensuring that TotalKey always matches RetainKey | DenyKey.

The intention here is to have the Typescript compiler raise an error if a developer adds a new value (for instance, z) to _total, while neglecting to include z within either _retain or _deny.

typescript types assert typeof keyof

Answer 1

Answer №1

To achieve this, you can create a conditional type that will determine if two types are equal or not by resolving to true when they match, and false otherwise. By implementing code that triggers a compile error when the type is not true, you can ensure synchronization between the types.

If any changes occur in either of the types, a compile error will be thrown, prompting you to update the mismatched type. This approach proves especially handy when tracking modifications to a type within a separate library.

For instance:

type IsExact<T, U> = [T] extends [U] ? [U] extends [T] ? true : false : false;
function assert<T extends true | false>(expectTrue: T) {}

// trigger a compile error if types fall out of sync
assert<IsExact<AllKey, KeepKey | IgnoreKey>>(true);

Though the code may appear lengthy (e.g., managing the any type), it's conveniently packaged in my library found here.

import { assert, IsExact } from "conditional-type-checks";

// define AllKey, KeepKey, IgnoreKey or import them

assert<IsExact<AllKey, KeepKey | IgnoreKey>>(true);

Another Approach

An alternative albeit less elegant method involves creating two objects representing each type and assigning them to one another.

() => {
  let allKeys: AllKey;
  let otherKeys: KeepKey | IgnoreKey;

  // use lambdas to prevent type modification on assignment
  () => allKeys = otherKeys;
  () => otherKeys = allKeys;
};

Answer 2

To achieve this, you can create a conditional type that will determine if two types are equal or not by resolving to true when they match, and false otherwise. By implementing code that triggers a compile error when the type is not true, you can ensure synchronization between the types.

If any changes occur in either of the types, a compile error will be thrown, prompting you to update the mismatched type. This approach proves especially handy when tracking modifications to a type within a separate library.

For instance:

type IsExact<T, U> = [T] extends [U] ? [U] extends [T] ? true : false : false;
function assert<T extends true | false>(expectTrue: T) {}

// trigger a compile error if types fall out of sync
assert<IsExact<AllKey, KeepKey | IgnoreKey>>(true);

Though the code may appear lengthy (e.g., managing the any type), it's conveniently packaged in my library found here.

import { assert, IsExact } from "conditional-type-checks";

// define AllKey, KeepKey, IgnoreKey or import them

assert<IsExact<AllKey, KeepKey | IgnoreKey>>(true);

Another Approach

An alternative albeit less elegant method involves creating two objects representing each type and assigning them to one another.

() => {
  let allKeys: AllKey;
  let otherKeys: KeepKey | IgnoreKey;

  // use lambdas to prevent type modification on assignment
  () => allKeys = otherKeys;
  () => otherKeys = allKeys;
};

Verify in typescript if type A is equal to either type B or type C

Answer №1

Similar questions

Define an object by extracting properties from an array of objects

Issue with TypeScript: Declaring type for objects in an array using .map

An error occurred when trying to access object references within a function

Firestore rule rejecting a request that was meant to be approved

How to Retrieve Inputs from Child Component Form without Prop Passing?

Problem encountered with @HostListener

Guide to setting up react-styleguidist, developing with Create React App, using Typescript, incorporating Material UI, and including

How can TypeScript objects be serialized?

Obtain a tuple of identical length from a function

What is the method for defining a monkey patched class in a TypeScript declarations file?

Utilizing Angular's ngx-bootstrap date range picker for a customized date range filtering system

Material-UI React Native components: Injecting Styles without Props

The type 'HTMLDivElement | null' cannot be assigned to the type 'HTMLDivElement' in this context

Is it considered best practice to include try/catch blocks within the subscribe function in RxJs?

Best practices for applying the Repository pattern within a NestJS application

Using an external module in a Vue SFC: a beginner's guide

Unable to resolve external modules in TypeScript when using node.js

Declaring a function in TypeScript triggers an error notification

Angular HTML Component Refactor causes compatibility issues with BS4 classes

Using Rxjs to reset an observable with combineLatest