跳到正文

Vue 泛型 props 传给 toRefs 时可能丢失类型推断(1):双侧元组中的泛型可能让条件类型延迟求值

Vue 泛型 props 传给 toRefs 时可能丢失类型推断

  1. 双侧元组中的泛型可能让条件类型延迟求值(当前)
  2. 待定的泛型键会让交集上的索引访问延迟求值
  3. 布尔键映射让 toRefs 的数组字段读成 any
  4. 组件可用类型标注或 getter 暂时绕过推断错误
  5. 逆向映射推断让 toRefs 保留字段类型
  6. 补充内容:LooseRequired 让 props 键必有并保留 undefined
  7. 补充内容:条件求值、赋值和索引访问走不同的检查路径
  8. 补充内容:用泛型上界提前选分支需要额外条件
  9. 补充内容:只改 TypeScript 时需要识别待定索引的数组形状

同一个数组约束,TypeScript 可以拿来检查赋值,也可能在条件类型里暂时用不上。比如 T extends ['a'] 已经足够让 T 赋给 string[],但在 TypeScript 6.0.3 的 --strict 模式下,[T] extends [string[]] ? true : false 仍可能保留。Vue 的 ToRef 正好用了这类双侧元组条件。

具体类型可以比较,泛型条件可能保留

// 判断整个 X 能否赋给 string[]。
type IsStringArray<X> = [X] extends [string[]] ? true : false;

type Strings = IsStringArray<['a']>; // true,['a'] 可以赋给 string[]。
type Numbers = IsStringArray<number[]>; // false,number[] 不能赋给 string[]。

// 对照普通赋值和条件求值。
function inspect<T extends ['a']>(value: T) {
  const array: string[] = value; // 赋值通过,array 是 string[]。
  type FromArray = IsStringArray<typeof array>; // true
  type Pending = IsStringArray<T>; // 仍是 [T] extends [string[]] ? true : false。
}

有了 T extends ['a'] 的约束,value 可以赋给 ['a'],也就可以赋给 string[]。赋值通过以后,array 按它声明的 string[] 来检查,value 的类型仍是 T。所以 FromArray 用具体的 string[] 得到 true,Pending 则把 T 留在条件里。这里的延迟求值发生在类型检查期间。用具体类型实例化条件后,检查器才可能继续选分支。

左右都是简单元组时,检查器还会看直接元素

Note

简单元组是检查器对这一处语法的称呼。它直接写成 [...],至少有一个元素,且没有可选元素或剩余元素。[T] 和 [0, T] 都符合,[]、[T?] 和 [...T] 则走其他检查路径。

把比较目标改成 unknown,可以单独观察元组这一层。两个条件的左边都是 [X],右边只差一对方括号。

// 把整个单元素元组交给 unknown。
type TupleToUnknown<X> = [X] extends unknown ? true : false;
// 把两个单元素元组放在一起比较。
type TupleToTuple<X> = [X] extends [unknown] ? true : false;

function inspectTuples<T extends ['a']>() {
  type Whole = TupleToUnknown<T>; // true
  type Element = TupleToTuple<T>; // 仍是 [T] extends [unknown] ? true : false。
}

type Concrete = TupleToTuple<['a']>; // true

[T] extends unknown 可以直接比较整个元组。无论里面是什么,元组整体都能赋给 unknown。[T] extends [unknown] 会先进入另一层检查。TypeScript 6.0.3 的检查器看到左右直接写成等长的简单元组,就检查两边的直接元素。[T] 的第一个元素就是仍待定的 T,因此检查器先保留条件,尚未走到比较这个元素能否赋给 unknown 的一步。

checker.ts 较大,GitHub 的普通文件预览可能省略源码。查看固定版本的 github.dev 编辑器时,也可以搜索 isSimpleTupleType 和 isDeferredType 定位这段判断。

这项检查也适用于多元素元组。比如 [0, T] extends [0, unknown] 会检查第二个元素,[unknown] extends [T] 会看到右侧待定的 T。如果直接元素是一个形状已知的对象或内层元组,则还要看后续的结构比较。例如 [{ a: T }] extends [{ a: unknown }] 可以得到 true。嵌套对象、元组别名和不同长度的对照见第 7 篇。

方括号让条件比较整个联合类型

X extends string[] 直接比较类型参数,所以传入联合时会分别检查每个成员。[X] extends [string[]] 则对整个联合作一次比较。是否分配和能否立即选分支是两件事,直接元素仍待定时,双侧元组条件还可能延迟。

// 裸类型参数作条件左侧,会对联合成员分别求值。
type CheckEach<X> = X extends string[] ? true : false;
// 元组保留联合整体,由一次比较选分支。
type CheckWhole<X> = [X] extends [string[]] ? true : false;

type Each = CheckEach<string[] | number[]>; // true | false,也就是 boolean。
type Whole = CheckWhole<string[] | number[]>; // false,整个联合不能赋给 string[]。

TypeScript 加上元组的元素检查,让 [X] extends [Y] 和裸类型参数 X extends Y 一样,也能在拿到待定泛型时延迟求值。普通赋值可以使用约束,条件求值还要判断能否选出某个分支,这就是同一个 T 在两条路径上表现不同的原因。TypeScript 对元组比较的处理见检查器中的注释。

可以用类型约束观察条件是否已经确定

ExpectTrue<X> 要求实参能赋给 true。把第一个例子的条件交给它,可以观察目前能保证什么。

// 判断整个 X 能否赋给 string[]。
type IsStringArray<X> = [X] extends [string[]] ? true : false;
// 只接受能赋给 true 的类型。
type ExpectTrue<X extends true> = X;

function inspectConstraint<T extends ['a']>() {
  // @ts-expect-error TS2344,编译器还不能保证该条件得到 true。
  type StillPending = ExpectTrue<IsStringArray<T>>;
}

type Known = ExpectTrue<IsStringArray<['a']>>; // true

去掉 @ts-expect-error 后,TS2344 提示 boolean 无法赋给 true。检查器此时用 true | false 来做约束检查,IsStringArray<T> 本身仍保留原来的条件式。在 TypeScript Playground 选 6.0.3,悬停这个类型也能看到两者的区别。

条件待定时仍可以读取分支共有的字段

true | false 是两个分支都要纳入比较时得到的类型。把同一个条件的分支换成对象,就能看到这条规则也影响属性读取。Result<T> 仍然保留条件,但两个分支都声明了 x,所以可以读取 result.x。

// 根据 X 是否为字符串数组,决定 x 的类型。
type Result<X> = [X] extends [string[]] ? { x: number } : { x: string };

function inspectResult<T extends ['a']>(result: Result<T>) {
  const x = result.x; // number | string
  const withX: { x: number | string } = result; // 赋值通过。
}

type FromArrayResult = Result<['a']>; // { x: number }
type FromOtherResult = Result<number[]>; // { x: string }

检查器用两个候选对象的联合 { x: number } | { x: string } 作为 Result<T> 的约束。在这个联合里,两边都允许读取 x。读到的值可能来自任意一边,所以类型是 number | string。这个约束也足够检查 withX 的赋值。合并分支约束的逻辑见 TypeScript 6.0.3 检查器的 getDefaultConstraintOfConditionalType。

Result<T> 仍然记着哪种 T 对应哪种 x。把 ['a'] 代进去,x 只能是 number。把 number[] 代进去,x 只能是 string。如果把类型定义直接写成 { x: number | string },这份对应关系就丢了。

未确定的直接元素会让双侧简单元组的条件等待

两侧直接写成等长的简单元组时,TypeScript 6.0.3 会检查它们的直接元素。只要 [T] 里的 T 还待定,条件就会保留下来。此时 ExpectTrue 只能拿 true | false 与 true 比较,所以断言失败。

Vue 用这样的元组来检查字段是否已经是 Ref。实际条件左边是 P['options']。为什么索引一个明明声明了的字段,也会得到一个待求值的类型?第 2 篇 用一个和 Vue 无关的交集解释这一步,再把结果交给第 3 篇的 ToRef。