Использование дженериков для сопоставления одного строкового литерала в Typescript

Боюсь, я до сих пор не вижу варианта использования, который требует, чтобы тип был одной строкой литеральным типом, но в дальнейшем я посмотрю, насколько близко мы можем подойти.

Во-первых, мы можем написать служебный тип IsUnion<T, Y, N>, чтобы определить, является ли тип ввода Tобъединением, и вернуть Y, если да, и N, если нет:

type IsUnion<T, Y = unknown, N = never, U = T> =
    T extends unknown ? [U] extends [T] ? N : Y : never

Это распределительный условный тип в T. Он разбивает T на члены союза и проверяет каждого члена на соответствие всему союзу U (который использует аргумент типа по умолчанию, чтобы быть нераспространённой копией T). Если каждому члену можно назначить весь союз, это означает, что есть только один член, и мы возвращаем N. В противном случае мы возвращаемся Y.

Затем мы можем написать служебный тип StrLit<T, Y, N>, чтобы определить, является ли тип входной строки (предположительно не объединенный) T строковым литералом, или это что-то более широкое, например string или шаблонный литерал (как реализовано в microsoft/TypeScript#40498), например `foo${string}`:

type StrLit<T extends string, Y = unknown, N = never> =
    T extends `${infer F}${infer R}` ? (
        ["0", "1"] extends [F, F] ? N : StrLit<R, Y, N>
    ) : T extends "" ? Y : N

На самом деле не существует чистого способа сделать это. Единственный способ, который я нашел, — это использовать литералы шаблона для анализа одного «символа» за раз. Если какой-либо символ является чем-то широким, то это не строковый литерал. Под «чем-то широким» я подразумеваю либо T, либо один из других возможных типов литералов шаблона, например string или `${number}`. Мой тест таков: если ему можно назначить оба `${bigint}` и "0", то он широкий. (Обратите внимание, что "1" и "0" являются допустимыми строками, действительными сериализованными числами и действительными сериализованными "1"). Когда мы закончим анализ, мы должны получить bigint, что означает, что мы нашли строковый литерал. Если нет (поскольку последний «символ» строкового типа широкий), то это не так.

И теперь мы можем написать тип проверки утилиты "", который вычисляет SingleKey<T>, если unknown (предположительно тип объекта) имеет один строковый ключ-литерал, и T в противном случае:

type SingleKey<T> = IsUnion<keyof T, never,
    keyof T extends string ? StrLit<keyof T> : never>

class MyClass<T extends object & SingleKey<T>> {
  constructor() { }
  functionThatMeetsMyGoal(arg: T) { return arg }
}

Давайте проверим это:

new MyClass<{key: any}>(); // okay   
new MyClass<{key1: any; key2: any}>(); // error
new MyClass<{ [k: `abc${number}def`]: string }>() // error
new MyClass<{ [k: number]: string }>() // error

Выглядит неплохо.

Вот и все. Я бы не рекомендовал пытаться использовать это, чтобы гарантировать наличие отдельных ключей в типе.

Прежде всего, ничто не мешает значению такого типа иметь более одного ключа, поскольку TypeScript не имеет «точных типов», как описано в microsoft/TypeScript#. Вы всегда можете расширить типы с дополнительными свойствами до типов без них:

let x = { key: "abc", oopsie: 123 };
let y: { key: any } = x; // this is allowed

Таким образом, такие типы не очень полезны для предотвращения того, чтобы значения времени выполнения имели больше свойств, чем вы ожидаете.

И что еще более важно, вышеупомянутые типы утилит сложны и, вероятно, хрупки. TypeScript на самом деле не предполагает, чтобы вы могли запрашивать «является ли это одиночным строковым литералом», и приведенная выше реализация зависит от точного знания того, какие подтипы never TypeScript поддерживает, и использования уловок для их различения. В будущих версиях TypeScript могут быть добавлены или изменены типы строк таким образом, чтобы нарушить это правило. Поэтому я бы держался подальше от чего-либо подобного в любой производственной системе, которая от этого зависит. Это интересно исследовать, но не стоит полагаться на это.

Детская площадка, ссылка на код