Аргумент типа 'строка | номер | boolean» нельзя присвоить параметру типа «никогда». ц2345

TypeScript не может отслеживать корреляции между типами союзов ; если у вас есть один блок кода, такой как ваше тело обратного вызова forEach(), компилятор может проанализировать его только один раз. Если у вас есть несколько выражений в таком блоке кода, которые зависят от одного и того же значения типа объединения, компилятор обычно просто обрабатывает эти выражения как сами типы объединения, но обрабатывает их независимо. Таким образом, функция, зависящая от ключа объединения, станет объединением функций. И аргумент, который зависит от ключа объединения, станет объединением аргументов. Но вы не можете безопасно вызывать объединение функций с объединением аргументов; компилятор будет настаивать на пересечении аргументов . Это тема microsoft/TypeScript#30581.

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

Однако, если вы хотите, чтобы компилятор проверял тип того, что вы делаете, вы можете выполнить довольно большой рефакторинг, чтобы использовать общие индексы в отображаемые типы , как описано в microsoft/TypeScript#47109 .

Этот код уже прошел один раунд такого рефакторинга, но теперь вам нужно сделать это для типа отображения T из ключей заголовка таблицы в конкретный тип поля. Мы должны сохранить FieldHeader общее в K extends keyof TypeMap, чтобы сделать это; это нормально, если FieldHeader<I> по умолчанию является объединением, но мы хотим иметь возможность выбирать конкретное K:

type FieldHeader<I extends Item, K extends keyof TypeMap = keyof TypeMap> = {
  [P in K]: {
    compare: (a: TypeMap[P], b: TypeMap[P]) => number;
    filter: (value: TypeMap[P], input: TypeMap[P]) => boolean;
    get: (item: I) => TypeMap[P] | null | undefined;
    type: P;
  };
}[K];

И теперь ваши типы должны быть универсальными для этого отображения T:

type TableHeader<I extends Item, T extends Record<keyof T, keyof TypeMap>> = {
  [K in keyof T]: FieldHeader<I, T[K]>
}

type Filter<I extends Item, T extends Record<keyof T, keyof TypeMap>> = {
  [K in keyof T]: TypeMap[T[K]];
}

И поэтому вам нужно будет указать это при объявлении переменных этих типов (вы можете использовать служебные функции для вывода вместо ручного указания, но я не буду отвлекаться на этом):

const tableHeader: TableHeader<MyItem, { selected: "boolean" }> = {
  selected: {
    compare: (a, b) => +a - +b,
    filter: (value, input) => value === input,
    get: (video) => video.selected,
    type: 'boolean',
  },
};

const filter: Filter<MyItem, { selected: "boolean" }> = {
  // ts should throw an error here, as type of "selected" should be 'boolean'
  selected: "",

  // also only props of "tableHeader" should be allowed
  foo: 123
}

И, наконец, ваша функция applyFilter() также является универсальной в T, например:

function applyFilter<I extends Item, T extends Record<keyof T, keyof TypeMap>>(
  item: I, tableHeader: TableHeader<I, T>, filter: Filter<I, T>
) {
  (Object.keys(filter) as Array<keyof T>).forEach(<K extends keyof T>(key: K) => {
    const input = filter[key];
    const value = tableHeader[key].get(item);
    if (value != null) tableHeader[key].filter(value, input);
  });
}

Обратите внимание, что нам все еще нужно утверждение типа, чтобы компилятор увидел, что записи filter имеют какое-либо отношение к keyof T, и на самом деле мы не можем использовать Object.entries(), потому что это не позволит нам представить связь между K и Filter<I, T>[K]. Но в остальном это работает; компилятор может видеть, что input относится к типу TypeMap[T[K]], и что value относится к типу TypeMap[T[K]] (после проверки на нулевое значение), и что tableHeader[key].filter относится к типу (value: TypeMap[T[K]], input: TypeMap[T[K]]) => boolean, так что все типы проверяются.

Площадка ссылка на код