Is there a way to restrict an array to only accept distinct string literals?

Question

Is there a way to restrict an array to only accept distinct string literals?

export interface IGUser {
  biography: string;
  id: string;
  ig_id: string;
  followers_count: number;
  follows_count: number;
  media_count: number;
  name: string;
  profile_picture_url: string;
  shopping_product_tag_eligibility: boolean;
  username: string;
  website: string;
}

const values: keyof IGUser = ['biography', ''];

https://i.sstatic.net/WfH8Z.png

Is there a way to restrict the array to only allow one instance of biography?

typescript

Answer 1

Answer №1

If you're looking to remove duplicates in an array, one approach is to utilize a function designed specifically for that purpose. Check out this helpful resource on how to delete duplicate elements from an array: Removing Duplicate Elements From Arrays

Answer 2

If you're looking to remove duplicates in an array, one approach is to utilize a function designed specifically for that purpose. Check out this helpful resource on how to delete duplicate elements from an array: Removing Duplicate Elements From Arrays

Answer 3

Answer №2

Yes, it is feasible but only up to a certain number of keys. Eventually, the computation of that singular array literal type will become too costly due to its reliance on the length of your Union Type (keyof IGUser). This will trigger a "Type instantiation is excessively deep and possibly infinite" error.

Nevertheless, taking inspiration from this response by Mu Tsun Tsai on the topic of Unordered tuple type, I devised the following solution. By utilizing a Mapped Type and Exclude, you can ensure uniqueness of all literals in your array. Essentially, this method calculates all possible valid combinations based on the union of your initial object keys. It's worth noting that this approach prohibits any duplicate literals, not just "biography"

interface IGUser {
  biography: string;
  name: string;
  username: string;
//   id: string;
//   ig_id: string;
//   followers_count: number;
//   follows_count: number;
//   media_count: number;
//   profile_picture_url: string;
//   shopping_product_tag_eligibility: boolean;
//   website: string;
}

type SingleBiographyKeyArray<T extends string, R extends any[] = []> = R | {
    [K in T]: SingleBiographyKeyArray<Exclude<T, K>, [K, ...R]>
}[T];

let values: SingleBiographyKeyArray<keyof IGUser> = []; // valid
values = ["biography"] // valid
values = ["biography", "name", "username"] // valid

values = ["biography", "biography", "name"];
// ~~~ invalid
values = ["biography", "username", "name", "name"];
// ~~~ invalid

TypeScript Playground

Answer 4

Yes, it is feasible but only up to a certain number of keys. Eventually, the computation of that singular array literal type will become too costly due to its reliance on the length of your Union Type (keyof IGUser). This will trigger a "Type instantiation is excessively deep and possibly infinite" error.

Nevertheless, taking inspiration from this response by Mu Tsun Tsai on the topic of Unordered tuple type, I devised the following solution. By utilizing a Mapped Type and Exclude, you can ensure uniqueness of all literals in your array. Essentially, this method calculates all possible valid combinations based on the union of your initial object keys. It's worth noting that this approach prohibits any duplicate literals, not just "biography"

interface IGUser {
  biography: string;
  name: string;
  username: string;
//   id: string;
//   ig_id: string;
//   followers_count: number;
//   follows_count: number;
//   media_count: number;
//   profile_picture_url: string;
//   shopping_product_tag_eligibility: boolean;
//   website: string;
}

type SingleBiographyKeyArray<T extends string, R extends any[] = []> = R | {
    [K in T]: SingleBiographyKeyArray<Exclude<T, K>, [K, ...R]>
}[T];

let values: SingleBiographyKeyArray<keyof IGUser> = []; // valid
values = ["biography"] // valid
values = ["biography", "name", "username"] // valid

values = ["biography", "biography", "name"];
// ~~~ invalid
values = ["biography", "username", "name", "name"];
// ~~~ invalid

TypeScript Playground

Answer 5

Answer №3

If you have a specific set of allowed values, you can achieve this by following the instructions at https://tsplay.dev/NlXgrN

type ValidateUniqueArray<T, A extends T[]> =
  | A extends [infer F, ...infer L]
  ? (L extends Exclude<T, F>[]
    ? [F, ...ValidateUniqueArray<Exclude<T, F>, L>]
    : [F, Exclude<T, F>?]
  ) : [T?, ...unknown[]]
  ;

type ValidateCompleteUniqueArray<T, A extends any[]> =
  | [T] extends [never]
  ? []
  : A extends [infer F, ...infer L]
  ? (F extends T
    ? [F, ...ValidateCompleteUniqueArray<Exclude<T, F>, L>]
    : [T, ...ValidateCompleteUniqueArray<T, L>]
  ) : [T]
  ;

type conforms<T, V> = T extends V ? T : V;

function uniqueArray<T>() {
  return {
    partial<A extends T[]>(a: conforms<A, ValidateUniqueArray<T, A>>): A {
      return a as A;
    },
    complete<A extends T[]>(a: conforms<A, ValidateCompleteUniqueArray<T, A>>): A {
      return a as A;
    },
  }
}

let a1 = uniqueArray<1 | 2 | 3 | 4>().partial([
  1, 2, 3, 4 // all good
])
let a2 = uniqueArray<1 | 2 | 3 | 4>().partial([
  1, 1 // Type '1' is not assignable to type '2 | 3 | 4'.(2322)
])
let a3 = uniqueArray<1 | 2 | 3 | 4>().partial([
  1, 'foo' // Type 'string' is not assignable to type '2 | 1 | 3 | 4'.(2322)
])

let b1 = uniqueArray<1 | 2 | 3 | 4>().complete([
  1, 2, 3, 4 // all good
])
let b2 = uniqueArray<1 | 2 | 3 | 4>().complete([
  1, 2, 3, 1 // Type '1' is not assignable to type '4'.(2322)
])
let b3 = uniqueArray<1 | 2 | 3 | 4>().complete([
  1, 2, 3, 'foo' // error
])
let b4 = uniqueArray<1 | 2 | 3 | 4>().complete([
  1, 2, 3 // Argument of type '[1, 2, 3]' is not assignable to parameter of type '[1, 2, 3, 4]'.
])

Answer 6

If you have a specific set of allowed values, you can achieve this by following the instructions at https://tsplay.dev/NlXgrN

type ValidateUniqueArray<T, A extends T[]> =
  | A extends [infer F, ...infer L]
  ? (L extends Exclude<T, F>[]
    ? [F, ...ValidateUniqueArray<Exclude<T, F>, L>]
    : [F, Exclude<T, F>?]
  ) : [T?, ...unknown[]]
  ;

type ValidateCompleteUniqueArray<T, A extends any[]> =
  | [T] extends [never]
  ? []
  : A extends [infer F, ...infer L]
  ? (F extends T
    ? [F, ...ValidateCompleteUniqueArray<Exclude<T, F>, L>]
    : [T, ...ValidateCompleteUniqueArray<T, L>]
  ) : [T]
  ;

type conforms<T, V> = T extends V ? T : V;

function uniqueArray<T>() {
  return {
    partial<A extends T[]>(a: conforms<A, ValidateUniqueArray<T, A>>): A {
      return a as A;
    },
    complete<A extends T[]>(a: conforms<A, ValidateCompleteUniqueArray<T, A>>): A {
      return a as A;
    },
  }
}

let a1 = uniqueArray<1 | 2 | 3 | 4>().partial([
  1, 2, 3, 4 // all good
])
let a2 = uniqueArray<1 | 2 | 3 | 4>().partial([
  1, 1 // Type '1' is not assignable to type '2 | 3 | 4'.(2322)
])
let a3 = uniqueArray<1 | 2 | 3 | 4>().partial([
  1, 'foo' // Type 'string' is not assignable to type '2 | 1 | 3 | 4'.(2322)
])

let b1 = uniqueArray<1 | 2 | 3 | 4>().complete([
  1, 2, 3, 4 // all good
])
let b2 = uniqueArray<1 | 2 | 3 | 4>().complete([
  1, 2, 3, 1 // Type '1' is not assignable to type '4'.(2322)
])
let b3 = uniqueArray<1 | 2 | 3 | 4>().complete([
  1, 2, 3, 'foo' // error
])
let b4 = uniqueArray<1 | 2 | 3 | 4>().complete([
  1, 2, 3 // Argument of type '[1, 2, 3]' is not assignable to parameter of type '[1, 2, 3, 4]'.
])

Is there a way to restrict an array to only accept distinct string literals?

Answer №1

Answer №2

Answer №3

Similar questions

The Typescript compiler will continue to generate JavaScript code even if there are compilation errors

Angular Ahead-of-Time (AOT) compilation causes multiple route definitions to be

Encountering complications when importing TypeScript declarations

The creation of a Firebase user account with the specified email and password

Assigning to a constrained type with an indexable signature results in failure

Failure of VSCode breakpoints to function properly with TypeScript npm linked package

Mozilla struggles to interpret JSON data

Important notice: It is not possible to assign refs to function components. Any attempt to do so will result in failure. If you intended to assign a ref, consider

Troubleshooting issue with getServerSideProps not functioning in Next.js while utilizing Next-redux-wrapper and TypeScript

Is it possible to showcase a unique date for every item that gets added to a list?

When incorporating an array as a type in Typescript, leverage the keyof keyword for improved

Unable to make custom font work in TailwindCSS and ReactJS project

Angular 2 lacks compatibility with SVG

The vertical scrolling functionality of the MUI DataGrid in Safari may occasionally fail to work

The attribute 'date' is not found within the class 'EmployeeScheduleExceptionModel', however, it is present in the parent class from which it inherits

The callback function inside the .then block of a Promise.all never gets

Exploring the power of Angular 10 components

When debugging in Visual Studio 2013, Typescript variables/fields consistently show up as undefined

Tips for parsing a string object in JSON without a preceding double quote

Why is webpack attempting to package up my testing files?