Creating a TypeScript array consisting of particular strings

Question

Creating a TypeScript array consisting of particular strings

Is it possible to create a data type in which an Array can contain only specific strings from a defined list? For instance:

const foo = "foo";
const bar = "bar';
const baz = "baz':

// acceptable
[foo, bar]

// acceptable 
[foo, bar, baz]

// unacceptable
[foo, foo]

// unacceptable
[foo, bar, bar]

What is the way to achieve this?

typescript

Answer 1

Answer №1

This type of query always excites me, even if the response indicates that the solution may involve some complex steps with uncertain outcomes. That's exactly the case here, so let's dive in and explore!

First, let's create a constraint called NoRepeats<T>, where the output will be T if all property types of T are distinct. If there are two keys with the same property type, then the output will be never:

type NoRepeats<T> = true extends (
  (keyof T) extends (infer K) ? K extends any ? (
    T[K] extends T[Exclude<keyof T, K>] ? true : never
  ) : never : never
) ? "No Repeats Please" : T

This utilizes distributive conditional types to break down keyof T into individual keys K, comparing T[K] with

T[Exclude<keyof T, K>]</code. The goal is to detect if any keys share the same property type. If found, it returns an error message; otherwise, it returns <code>T

.

We can test this behavior using examples:

interface X {a: string, b: number, c: boolean}; // no repeats
declare const x: NoRepeats<X>; // x is of type X

interface Y {a: string, b: number, c: string}; // duplicate string properties
declare const y: NoRepeats<Y>; // y is "No Repeats Please"

When dealing with arrays, we want to focus on tuple-like structures rather than generic arrays due to limitations in TypeScript's type inference capabilities. Let's remove common array keys through the "stripping" method:

type StripTuple<T extends any[]> = Pick<T, Exclude<keyof T, keyof any[]>>

To ensure we only check tuples, not generic arrays:

type NoRepeatTuple<T extends any[]> = 
  number extends T['length'] ? "Must Be Tuple" : NoRepeats<StripTuple<T>>

Testing this approach on tuples and arrays:

declare const z: NoRepeatTuple<[string, number, boolean]>
declare const a: NoRepeatTuple<[string, number, string]>
declare const b: NoRepeatTuple<string[]>

As we continue refining the process, we encounter challenges related to circular constraints when defining exact types. However, by utilizing functions like requireNoRepeats, we can enforce constraints on tuples without repetition:

function requireNoRepeats<V extends "foo" | "bar" | "baz", T extends Array<V>>(
  t: T & NoRepeatTuple<T>
) { }

Although there are intricacies involved in ensuring correct type inference for tuples in TypeScript, we can overcome these obstacles with meticulous testing and creative solutions.

Ultimately, the journey towards achieving such type validations involves thorough exploration and experimentation. It offers insights and knowledge that can prove valuable in various scenarios. Best of luck!

Answer 2

This type of query always excites me, even if the response indicates that the solution may involve some complex steps with uncertain outcomes. That's exactly the case here, so let's dive in and explore!

First, let's create a constraint called NoRepeats<T>, where the output will be T if all property types of T are distinct. If there are two keys with the same property type, then the output will be never:

type NoRepeats<T> = true extends (
  (keyof T) extends (infer K) ? K extends any ? (
    T[K] extends T[Exclude<keyof T, K>] ? true : never
  ) : never : never
) ? "No Repeats Please" : T

This utilizes distributive conditional types to break down keyof T into individual keys K, comparing T[K] with

T[Exclude<keyof T, K>]</code. The goal is to detect if any keys share the same property type. If found, it returns an error message; otherwise, it returns <code>T

.

We can test this behavior using examples:

interface X {a: string, b: number, c: boolean}; // no repeats
declare const x: NoRepeats<X>; // x is of type X

interface Y {a: string, b: number, c: string}; // duplicate string properties
declare const y: NoRepeats<Y>; // y is "No Repeats Please"

When dealing with arrays, we want to focus on tuple-like structures rather than generic arrays due to limitations in TypeScript's type inference capabilities. Let's remove common array keys through the "stripping" method:

type StripTuple<T extends any[]> = Pick<T, Exclude<keyof T, keyof any[]>>

To ensure we only check tuples, not generic arrays:

type NoRepeatTuple<T extends any[]> = 
  number extends T['length'] ? "Must Be Tuple" : NoRepeats<StripTuple<T>>

Testing this approach on tuples and arrays:

declare const z: NoRepeatTuple<[string, number, boolean]>
declare const a: NoRepeatTuple<[string, number, string]>
declare const b: NoRepeatTuple<string[]>

As we continue refining the process, we encounter challenges related to circular constraints when defining exact types. However, by utilizing functions like requireNoRepeats, we can enforce constraints on tuples without repetition:

function requireNoRepeats<V extends "foo" | "bar" | "baz", T extends Array<V>>(
  t: T & NoRepeatTuple<T>
) { }

Although there are intricacies involved in ensuring correct type inference for tuples in TypeScript, we can overcome these obstacles with meticulous testing and creative solutions.

Ultimately, the journey towards achieving such type validations involves thorough exploration and experimentation. It offers insights and knowledge that can prove valuable in various scenarios. Best of luck!

Creating a TypeScript array consisting of particular strings

Answer №1

Similar questions

Transferring the date from an HTML input to a TypeScript file in Angular when the button

What is the process of encapsulating a callback function within another callback function and invoking it from there?

What is the best way to resolve the "unknown" type using AxiosError?

When adjusting the month/year, the Material Date Picker extends beyond its container

Ways to enable validation to be successful despite spaces in between words

When a property is designated as readonly in a TypeScript class, it can still be modified despite its intended

How do I make functions from a specific namespace in a handwritten d.ts file accessible at the module root level?

Is it possible to share a type exclusively among object properties based on the given value?

Using react-google-charts to create visually appealing dual-Y stacked bar charts

Typescript best practice: limiting global variables per file

angular2 the custom template validator is encountering outdated values

Guide on passing a customized component to the title property in Material-UI tooltip

Ensure that the HTTP GET request completes before initializing Angular using the ngOnInit lifecycle hook

When using Vue to bind a data URI to the img src property, I noticed that the image in the browser only updates when there is

What could be the reason for the following error message: "ERROR TypeError: Unable to access 'controls' property of an undefined object"?

Utilizing ControlValueAccessor in various components

How can I extend a third-party JavaScript library in TypeScript using a declaration file?

Experiencing Typescript errors solely when running on GitHub Actions

Using Typescript to define the type for React's useState() setter function whenever

Should I choose JavaScript or TypeScript for Angular 2.0?