typescript - 从联合类型中提取，其中鉴别器也是联合

Question

我有这样的类型:

enum Type {
  A = 'A',
  B = 'B',
  C = 'C'
}

type Union =
 | {
     type: Type.A | Type.B;
     key1: string
   }
 | {
     type: Type.C;
     key2: string
   }

type EnumToUnionMap = {
  [T in Type]: {
    [k in keyof Extract<Union, {type: T}>]: string
  }
}

我遇到的问题是 typeof EnumToUnionMap[Type.A] 是 never(实际上，它是像 [x: string]: string 这样的通用键签名，但那是因为 Extract<Union, {type: T}> 在 never 是 T 或 Type.A 时返回类型 Type.B )而 typeof EnumToUnionMap[Type.C] 是

{
  type: Type.C,
  key2: string
}

正如预期的那样。
这一切都是有道理的，因为 type 中的 EnumToUnionMap[Type.A] 是 Type.A | Type.B 和 Type.A != (Type.A | Type.B) 所以它们不匹配，我们得到 never 。
基本上我需要做这样的事情:

type EnumToUnionMap = {
  [T in Type]: {
    [k in keyof Extract<Union, T in Union['type']>]: string
  }
}

为什么我需要这样做:
我收到来自具有以下形状的警报端点的响应:

{
 type: Type,
 key1: string,
 key2: string
}

Type.A 和 Type.B 的警报都提供 key1 ，而 Type.C 的警报提供 key2 。
我需要将响应中的键映射到网格中的列名(其中某些警报类型共享一组通用键，但列的显示名称不同):

const columnMap: EnumToUnionMap = {
  [Type.A]: {
    key1: 'Column name'
    // Note that in actuality this object will contain
    // multiple keys (i.e. multiple columns) for a
    // given `Type` so creating a map
    // between `Type -> column name` is not possible.
  },
  [Type.B]: {
    key1: 'Different column name'
  },
  [Type.C]: {
    key2: 'Another column name'
  }
}

这样，我可以执行以下操作:

const toColumnText = (alert) => columnMap[alert.type]

...

if (alert.type === Type.A) {
  const key1ColumnName = toColumnText(alert).key1 // typed as string
  const key2ColumnName = toColumnText(alert).key2 // Typescript warns of undefined key
}

Answer 1

正如您所注意到的，您不能真正使用 the Extract utility type在这里，因为工会成员之间的关系Union和候选类型 {type: T}你拥有的不是简单的可分配性。相反，您要查找成员 U工会Union使得 T extends U["type"] .您可能不得不忘记 TypeScript 提供的实用程序类型，而是自己执行类型操作。
EnumToUnionMap 的一种可能定义这是:

type EnumToUnionMap = { [T in Type]: Union extends infer U ? U extends { type: any } ? (
    T extends U["type"] ? { [K in keyof U as Exclude<K, "type">]: U[K] } : never
) : never : never }

它可能看起来有点令人生畏；让我们确保它至少可以满足您的需求。 IntelliSense 表明它评估为:

/* type EnumToUnionMap = {
    A: { key1: string; };
    B: { key1: string; };
    C: { key2: string; };
} */

看起来挺好的。

现在我们知道它做了你想要的，它是如何做到的？让我们把定义分成几部分并分析每一部分:
type EnumToUnionMap = { [T in Type]: Union extends infer U ? U extends { type: any } ? (
T 扩展 U["type"] ? { [K in keyof U as Exclude]: U[K] } : 从不
) : 从不 : 从不 }

和你的版本一样，我们是 mapping在枚举值上， Type.A , Type.B , 和 Type.C .对于每个这样的枚举值 T ，我们需要拆分 Union加入它的工会成员，并收集我们关心的那个。写作 Union extends infer U ? U extends { type: any } ? ...用途 conditional type inference复制 Union成一个新的类型参数 U ，然后可用于创建 distributive conditional type哪里 U代表 Union的个别工会成员(member).所以从现在开始，每当我们看到 U ，我们只处理 Union 的碎片，不是全部。
type EnumToUnionMap = { [T in Type]: Union extends infer U ? U extends { type: any } ? (
T 扩展 U["type"] ? { [K in keyof U as Exclude]: U[K] } : 从不
) : 从不 : 从不 }

确定哪个工会成员(member) U工会 Union为了选择，我们评估条件类型 T extends U["type"] ? ... : never .支票 T extends U["type"]为真当且仅当 U的 type属性是 T 的父类(super class)型.如 T是 Type.A和 U是 {type: Type.A | Type.B, ...} ，那么这是真的。但如果 T是 Type.A和 U是 {type: Type.C, ...} ，那么这是错误的。通过返回 never当检查为假时，我们只处理 Union 的“正确”成员.
type EnumToUnionMap = { [T in Type]: Union extends infer U ? U extends { type: any } ? (
T 扩展 U["type"] ? { [K in keyof U as Exclude]: U[K] } : 从不
) : 从不 : 从不 }

所以我们找到了合适的工会成员 U ，但我们不想只返回它，因为它仍然包含不受欢迎的 type属性(property)。我们可以返回 Omit<U, "type">使用 the Omit utility type ，但不幸的是，这会导致像 Omit<{type: Type.A | Type.B; key1: string}, "type"> 这样冗长的 IntelliSense而不是理想的 {key1: string} .所以我在这里写我自己的 Omit类型使用 key remapping in mapped types (文档解释了 Omit 的替代方法是如何工作的)。

你去吧； EnumToUnionMap type遍历 Type的每个成员, 提取 Union 的成员谁的 type属性是它的父类(super class)型，省略了 type该成员的属性(property)。
Playground link to code