从剩余参数推断的条件元组

Question

是否可以从键/值映射推断元组？

基本上它可能是从联合类型到元组的转换（比如https://github.com/microsoft/TypeScript/issues/13298#issuecomment-482330241）

但我希望有一个更优雅和编译器友好的解决方案，比如手册中建议的元组函数 (http://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-0.html#example-2)

interface ParamMapping {
    a: boolean;
    b: string;
    c: 'foo' | 'bar';
}

declare function param<K extends keyof ParamMapping>(...name: K[]): ParamMapping[K];
// posible solutions:
// declare function param<K extends keyof ParamMapping>(...name: K[]): ParamMapping[...K];
// declare function param<K extends keyof ParamMapping>(...name: K[]): ...ParamMapping[K];
// declare function param<K extends (keyof ParamMapping)[]>(...name: K): for P of K : ParamMapping[K];
declare function param(...name: string[]): unknown[];

// typed as unknown[]
const p1 = param('baz', 'qux');

// *should be* typed as [boolean, string]
const p2 = param('a', 'b');

// *should be* typed as [string, 'foo' | 'bar']
const p3 = param('b', 'c');

// *should be* typed as [boolean, string, 'foo' | 'bar']
const p4 = param('a', 'b', 'c');

Playground here

Answer 1

我认为您想使用mapped tuple types，将第一个重载签名更改为：

declare function param<T extends Array<keyof ParamMapping>>(...name: T): {
    [I in keyof T]: ParamMapping[Extract<T[I], keyof ParamMapping>]
};

这里，name 是 T 类型，它本身就是一个数组或我们需要映射的键元组。如果我们将name 作为类型K[] 用于某些键类型K，那么编译器将不会跟踪顺序，因为K[] 不是元组。请注意，编译器不理解 I 将始终是类似数字的索引，因此我需要编写 Extract<T[I], keyof ParamMapping> 以获取可以索引到 ParamMapping 的内容。

您可以验证它的行为是否符合您的要求：

const p1 = param('baz', 'qux');
// const p1: unknown[]

const p2 = param('a', 'b');
// const p2: [boolean, string]

const p3 = param('b', 'c');
// const p3: [string, "foo" | "bar"]

const p4 = param('a', 'b', 'c');
// const p4: [boolean, string, "foo" | "bar"]

好的，希望对您有所帮助。祝你好运！

Playground link

Answer 2

编辑 我的“解决方案”实际上在很多事情上都错了

这是一个改进的工作示例。在某些部分有点hacky，但它可以完成工作：

// Base interface that can be latter augmented
interface ParamMapping {
    a: boolean;
    b: string; 
    c: 'foo' | 'bar';
}

// handle every other cases as unknown typed
interface ExtendedParamMapping extends ParamMapping {
    [P: string]: unknown;
}

// hack to handle autocomplete on: "foo" | "bar" | string
type UnknownMapping = string & { _?: never }

// Yes. Named like this.
type Jcalz<T> = {
    [I in keyof T]: ExtendedParamMapping[Extract<T[I], keyof ParamMapping>]
};

declare function param<T extends Array<keyof ParamMapping>, U extends T | UnknownMapping[]>(...name: U | T): Jcalz<U>;

const p1 = param('baz', 'qux');
// const p1: [unknown, unknown]

const p2 = param('a', 'b');
// const p2: [boolean, string]

const p3 = param('b', 'c');
// const p3: [string, "foo" | "bar"]

const p4 = param('a', 'b', 'c');
// const p4: [boolean, string, "foo" | "bar"]

const p5 = param('a', 'baz');
// const p6: [boolean, unknown]

const p6 = param('foo', 'c');
// const p4: [unknown, "foo" | "bar"]

Playground link

---

原答案

（作为帖子回答，不要在评论部分充斥代码，因为它解决了我的问题）

我想我已经找到了如何使用 jcalz answer 处理自动完成功能：

interface ParamMapping {
    a: boolean;
    b: string;
    c: 'foo' | 'bar';
}

type UnknownMapping = string & { _?: never }

// Yes. Named like this.
type Jcalz<T> = {
    [I in keyof T]: ParamMapping[Extract<T[I], keyof ParamMapping>]
};

type MappedType<T> = T extends keyof ParamMapping ? Jcalz<T> : unknown;

declare function param<T extends Array<keyof ParamMapping>>(...name: T | UnknownMapping[]): MappedType<T>;
// declare function param(...name: string[]): unknown[]; // not needed anymore

const p1 = param('baz', 'qux');
// const p1: unknown[]
// "basic" string works!

const p2 = param('a', 'b');
// const p2: [boolean, string]
// autocomplete works!

不需要其他重载，原始界面保持不变，并且自动完成工作。 （灵感来自这里https://github.com/microsoft/TypeScript/issues/29729#issuecomment-460346421）

Playground link

我会将jcalz answer 固定为已接受。