跳到正文

Vue 泛型 props 传给 toRefs 时可能丢失类型推断(3):布尔键映射让 toRefs 的数组字段读成 any

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

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

选择器的 options 在声明里是 readonly Option<Value>[]。直接读 props.options 可以得到这个类型,toRefs(props).options.value 却读成了 any。两个变化依次发生:布尔键映射先让 P['options'] 保留为类型索引,随后 ToRef 无法用这个待定索引选出分支。第 2 篇的索引对照展示了第一步,第 1 篇的公共字段例子解释了为什么条件待定还可以读 .value。

以下推导使用 Vue 3.6.0-rc.15 和 TypeScript 6.0.3,普通组件和 Vapor 组件都能复现。总览的代码工作区可以直接观察这一组类型。

defineProps 把原始字段和布尔键映射取交集

设置选择器在 <script setup generic="Value extends string | number"> 中声明 Props。搬到普通 TypeScript 里,同一份声明可以写成下面的泛型接口。

type Option<Value> = { label: string; value: Value };

interface SelectorProps<Value extends string | number> {
  options: readonly Option<Value>[];
  value: Value;
}

defineProps<SelectorProps<Value>>() 只传类型实参,走 Vue 的第三条重载。下面是它的返回类型和 DefineProps 的声明。另两条重载接收运行时参数,可查看三个重载与运行时选项的类型推导弹窗。

export function defineProps<TypeProps>(): DefineProps<
  LooseRequired<TypeProps>,
  BooleanKey<TypeProps>
>

export type DefineProps<T, BKeys extends keyof T> = Readonly<T> & {
  readonly [K in BKeys]-?: boolean
}

这次调用把同一个 SelectorProps<Value> 分别交给 LooseRequired 和 BooleanKey,再把两份结果传给 DefineProps。

  1. LooseRequired 用映射类型让已声明的键必有,并从原类型复制字段值。选择器的 options 和 value 本来都是必有字段,这一步仍能保留 readonly Option<Value>[] 和 Value。补充内容里的 LooseRequired 展开
  2. BooleanKey 逐个检查字段值,只返回符合布尔 prop 条件的键名。轮到 options 时,检查的是整个数组,得到 never。轮到 value 时,检查的是 Value extends boolean | undefined,在这个泛型组件体里仍待定。所以 'value' 是否入选还没算完。普通布尔 prop 的完整筛选和读取类型
  3. DefineProps 左边保留原始字段并设为只读。右边用 BKeys 决定要声明哪些字段,再要求这些字段必有且值为 boolean。此时 BKeys 来自第二步的待定结果,所以右边是键仍待定的映射。交集也因此带上了泛型标记。前三个类型见 Vue 3.6.0-rc.15 的声明。

把宏的结果记作 P。直接读取 props.options 时,检查器还是能从左边查到 readonly Option<Value>[]。P['options'] 则和第 2 篇的 Props<K>['options']一样,在类型位置被保留下来。接下来 ToRefs 恰好使用了这种索引。

toRefs 的逐键映射把未求值的条件带入 ToRef

调用 toRefs(props) 时,Vue 会为当时可枚举的属性生成 Ref。发布版的映射类型 ToRefs<T> 按键取出 T[K],再交给 ToRef。可对照 Vue 的可枚举属性说明和 3.6.0-rc.15 的类型声明。

export type ToRefs<T = any> = {
  [K in keyof T]: ToRef<T[K]>
}

源码里的 ToRefs<T> 用 T 指整个对象。这里给宏的返回类型起名 P,用 X 指传给 ToRef 的单个字段类型。轮到 options 时,X 就是 P['options']。

[X] extends [Ref] 比较之前,先看右侧的 Ref 长什么样。下面的 Vue 原始声明省略了符号成员的源码注释。T 表示读取 .value 的类型,S 表示写入参数的类型,RefSymbol 是用来区分 Ref 的符号键。裸写 Ref 时,两个类型参数默认都是 any。

export interface Ref<T = any, S = T> {
  get value(): T
  set value(_: S)
  [RefSymbol]: true
}
// 观察单个字段类型能否赋给 Ref。
type IsRef<X> = [X] extends [Ref] ? true : false;

function inspect<Value extends string | number>() {
  const props = defineProps<SelectorProps<Value>>(); // 原对象与布尔字段映射的交集。
  const array = props.options; // readonly Option<Value>[]
  type P = typeof props;
  type Indexed = P['options']; // 保留对交集的索引。

  type ByValue = IsRef<typeof array>; // false
  type ByKey = IsRef<Indexed>; // 仍保留 [Indexed] extends [Ref] 的条件。
}

上面的探针只返回真假。Vue 的 ToRef 用同一个条件选择返回类型,真分支保留已有 Ref,假分支才包装。

// vuejs/core/packages/reactivity/src/ref.ts:502
export type ToRef<T> = IfAny<T, Ref<T>, [T] extends [Ref] ? T : Ref<T>>

最外层的 IfAny 判断输入已经是 any 时该怎么处理。

// vuejs/core/packages/shared/src/typeUtils.ts:13
export type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N

如果 T 是 any,1 & T 仍是 any,0 能赋给它,结果选 Y。这里的 Y 是 Ref<T>。例如 T 是字符串时,1 & string 得到 never,条件改选 N。直接去掉 IfAny,只留下面的 [T] extends [Ref],本例仍会得到 TS7006。

布尔键筛选留下了第一个待定条件。现在把 P['options'] 代进 ToRef<T>,得到 [P['options']] extends [Ref]。检查器比较两个单元素元组时,发现左侧的直接元素仍是待计算的泛型索引,于是这个条件也被保留。真分支保留原输入,按「它符合 Ref」读取 .value。假分支则包装成 Ref<P['options']>。

这里把 P['options'] 简称为 Indexed。条件保留时,读取结果的 .value 会用到两个分支的类型。

  • 真分支仍然返回 Indexed,这里可以用「它符合 Ref」这条约束。这相当于用 Indexed & Ref<any, any> 查询属性。Indexed 本身没有提供可读的 value,这一支的 .value 从 Ref<any, any> 取得 any。
  • 假分支返回 Ref<Indexed>,所以 .value 是 Indexed。

从这两个候选读取 .value,联合 any | Indexed 化简为 any。把条件右边换成 Ref<unknown, any> 也能验证 any 的来源。条件仍待定,但真分支提供 unknown,联合后的 .value 也随之变成 unknown。

把 Code Lab 里报错的那一行写成三行,第一次读到 any 的是 optionsRef.value。TypeScript 6.0.3 此时仍能识别 optionsRef 的 Ref 结构。

const optionsRef = toRefs(props).options;
const items = optionsRef.value; // any
items.find(item => item.value === props.value); // item 报 TS7006

正常数组的 .find() 会用函数签名给回调参数提供上下文类型。这里的 .find 也是 any,没有签名可以提供 item 的类型,noImplicitAny 因此在 item 上报出 TS7006。

替换两个字段可以确认类型丢失从哪里触发

固定 toRefs(props).options.value.find(...),只在选择器的声明里换 value 或 options 的类型。表中 T 指 T extends string | number 的泛型,Option<T> 的选项值仍然用 T。两个相关的 Vue 类型判断如下。第一处决定 value 会不会留下待定的布尔键,第二处决定 options 要不要包装。

type BooleanKey<T, K extends keyof T = keyof T> = K extends any
  ? T[K] extends boolean | undefined
    ? T[K] extends never | undefined
      ? never
      : K
    : never
  : never

export type ToRef<T> = IfAny<T, Ref<T>, [T] extends [Ref] ? T : Ref<T>>

四行数据都用 Vue 3.6.0-rc.15 和 TypeScript 6.0.3 检查下面这条调用。

toRefs(props).options.value.find(item => item.value === props.value);
value 的类型 options 的类型 .find() 的 item
T readonly Option<T>[] 隐式 any
T readonly string[] 隐式 any
string | number readonly Option<T>[] Option<T>
string | number readonly string[] string

只把 options 换成普通字符串数组,value 的布尔键判断仍然待定,所以第二行也报错。把 value 换成已经明确的 string | number 后,BooleanKey 可以立即排除它。右边的映射不再带着待定的键,ToRef 可以按数组类型包装 options,即使元素仍然是 Option<T>。

从布尔键到 find 回调的类型推导

图中用琥珀色标出仍待求值的类型。待定信息从对 value 的布尔判断出发,经过交集进入 P['options'],最后让 ToRef 保留两个分支。

原始泛型 props 经 LooseRequired、BooleanKey、DefineProps、ToRefs 和 ToRef 的类型变化,琥珀色标出待求值,读取 value 后得到 any

两种修复都让原来的 ToRef 收到能判断的字段类型。第 4 篇 在组件侧把数组类型交给它。第 5 篇 从 defineProps() 的返回类型入手,让每个字段独立计算。P['options'] 因此能化简成 readonly Option<Value>[]。即使 Value 还没有具体实参,ToRef 也能根据数组的外层形状选择包装分支。各版本的声明和复现见布尔键声明和报错位置的演变弹窗和最小复现与编译记录弹窗。

布尔键声明和报错位置的演变

Vue 3.2.46 连直接读取 props.options 都会报错。到了 Vue 3.3.0,复现只剩 toRefs(props) 这一路报错。

布尔键筛选从 Vue 3.2 延续到 Vue 3.6

第一条关键变化发生在 3.2.46。3.2.45 将原有类型设为只读。3.2.46 则拆出可能是布尔键的字段、去掉这些字段的 undefined,再与剩下的字段合起来。让类型和布尔 prop 缺省时的行为一致是这次改动的目的。

// Vue 3.2.45
export function defineProps<TypeProps>(): Readonly<TypeProps>

// Vue 3.2.46
export function defineProps<TypeProps>(): Readonly<
  Omit<TypeProps, BooleanKey<TypeProps>> & {
    [K in keyof Pick<TypeProps, BooleanKey<TypeProps>>]-?: NotUndefined<
      TypeProps[K]
    >
  }
>

Vue 3.3.0 把完整的字段放回交集左侧。Vue 3.3.9 再让左侧先过 LooseRequired,把普通可选字段也表示为键必有、值可以是 undefined。下面是 3.3.9 的两个相关声明。这条宏签名在 3.4.0 也沿用。

export function defineProps<TypeProps>(): DefineProps<
  LooseRequired<TypeProps>,
  BooleanKey<TypeProps>
>

export type DefineProps<T, BKeys extends keyof T> = Readonly<T> & {
  readonly [K in BKeys]-?: boolean
}

变化随后集中到 BooleanKey。3.5.25 仍通过双侧元组比较每个字段。3.5.26 增加了内层判断,排除只有 never 或 undefined 的字段。这是布尔键修复提交里的差异。

// Vue 3.5.25
type BooleanKey<T, K extends keyof T = keyof T> = K extends any
  ? [T[K]] extends [boolean | undefined]
    ? K
    : never
  : never

// Vue 3.5.26
type BooleanKey<T, K extends keyof T = keyof T> = K extends any
  ? T[K] extends boolean | undefined
    ? T[K] extends never | undefined
      ? never
      : K
    : never
  : never

从 3.5.26 到 3.5.45 的 20 个发布标签都保留了这条排除分支,Vue 3.6.0-rc.15 也沿用了它。

Vue 3.2.46 引入布尔键筛选时就出现了 TS7006

把同一份 repro.ts 放进各版本的独立目录,固定使用 TypeScript 6.0.3 和 --strict,只换 Vue 的发布包。第 15 行直接读 props.options,第 16 行读 toRefs(props).options.value,第 17 行改用标注后的 normalized。

Vue 版本 检查结果
3.2.0、3.2.45 通过
3.2.46、3.2.47 第 15、16 行的回调都报 TS7006,同时出现字段缺失的 TS2339 和赋值失败的 TS2739
3.3.0、3.3.9 仅第 16 行报 TS7006
3.4.0、3.4.38 仅第 16 行报 TS7006
3.5.25、3.5.26 仅第 16 行报 TS7006

ToRefs 和 ToRef 在 3.2.45 就已经逐个字段判断是否要包装成 Ref,到了 3.2.46,两份类型的主体一致。3.2.46 改的是 defineProps<Props<T>>() 的返回类型。它用 Omit 和 Pick 按布尔键拆分字段,再把两部分拼回去。泛型 value 是否属于布尔键还待求值,检查器在拼回的类型上无法确认 options 存在,所以直接读取时就报错,紧接着 .find() 的回调也失去类型。

在 3.2.46 的发布声明里,只把纯类型重载的返回值换回 Readonly<TypeProps>,同一份 repro.ts 就能通过。这个对照继续使用 3.2.46 原有的 toRefs() 声明。

Vue 3.3.0 的 DefineProps 把完整的 Readonly<T> 保留在交集左侧,直接读 props.options 又能拿到数组。交集仍会进入 toRefs() 的逐字段条件判断,于是从 3.3.0 开始,复现只剩第 16 行报错,这也就是现在看到的现象。3.5.25 和 3.5.26 的诊断完全相同,说明后来对 never 和 undefined 的排除没有改变这份复现的结果。

Vue 3.5.45 的普通组件,以及 Vue 3.6.0-rc.15 的普通组件和 Vapor 组件,都用 TypeScript 6.0.3 和 vue-tsc 3.3.14 检查,结果都是 TS7006。给局部 props 加上 Readonly<Props> 标注后,三组都通过。用 TypeScript 7.0.2 检查普通 .ts 复现也会得到 TS7006,该版本搭配这版 vue-tsc 检查 SFC 时则在加载编译器入口时退出。

defineProps 的三个重载与运行时选项

下面的三条签名对应三种调用形状。数组和对象写法都传值参数,第三条在尖括号里传类型参数,圆括号为空。一次调用会匹配其中一条。

defineProps 的三个重载按入参区分

下面是 Vue 3.6.0-rc.15 的 defineProps 源码,省略了文件头的导入和说明注释。

// vuejs/core/packages/runtime-core/src/apiSetupHelpers.ts:78-97
// overload 1: runtime props w/ array
export function defineProps<PropNames extends string = string>(
  props: PropNames[],
): Prettify<Readonly<{ [key in PropNames]?: any }>>
// overload 2: runtime props w/ object
export function defineProps<
  PP extends ComponentObjectPropsOptions = ComponentObjectPropsOptions,
>(props: PP): Prettify<Readonly<ExtractPropTypes<PP>>>
// overload 3: typed-based declaration
export function defineProps<TypeProps>(): DefineProps<
  LooseRequired<TypeProps>,
  BooleanKey<TypeProps>
>
// implementation
export function defineProps() {
  if (__DEV__) {
    warnRuntimeUsage(`defineProps`)
  }
  return null as any
}
  • defineProps(['enabled']) 只传字段名。第一个重载把数组成员作为键,得到可选的只读 enabled,字段值类型是 any。

  • defineProps({ enabled: Boolean }) 传运行时选项对象。第二个重载把该对象推断为 PP,由 ExtractPropTypes<PP> 得出子组件读取的类型。这里的 enabled 是 boolean。

  • defineProps<Props>() 只传类型参数。第三个重载把 Props 代入 TypeProps,返回 DefineProps<LooseRequired<Props>, BooleanKey<Props>>。本文报错的设置选择器走这条重载。

末尾的同名函数是运行时占位,开发环境直接调用会警告,返回值是 null。正常编译的 <script setup> 会把宏调用改写成对组件 props 的读取。

ExtractPropTypes 推断字段,Prettify 展开类型提示

对象写法的返回类型从里往外看。最里面的 ExtractPropTypes<O> 接收运行时 props 选项对象的类型,输出子组件实际读到的字段类型。手里已有 options 变量时,可以写 ExtractPropTypes<typeof options>。下面是 Vue 的定义,省略了两行与编辑器提示有关的注释。

// vuejs/core/packages/runtime-core/src/componentProps.ts
export type ExtractPropTypes<O> = {
  [K in keyof Pick<O, RequiredKeys<O>>]: O[K] extends { default: any }
    ? Exclude<InferPropType<O[K]>, undefined>
    : InferPropType<O[K]>
} & {
  [K in keyof Pick<O, OptionalKeys<O>>]?: InferPropType<O[K]>
}

RequiredKeys 和 OptionalKeys 把字段分成必有和可选两组,InferPropType 从每个字段的配置推断值类型。以 defineProps({ enabled: Boolean, hint: String, size: { type: Number, default: 16 } }) 为例,ExtractPropTypes 得到 { enabled: boolean; size: number } & { hint?: string }。父组件可以省略 enabled 和 size,子组件会读到 false 和 16,所以这两个字段在结果里必有。hint 保持可选。

接着,Readonly 把属性设为只读,最外层的 Prettify<T> 把已有的对象类型逐个字段重新映射一遍。

// vuejs/core/packages/shared/src/typeUtils.ts:1
export type Prettify<T> = { [K in keyof T]: T[K] } & {}

编辑器可以把上面的交集显示成一个对象类型 { readonly enabled: boolean; readonly size: number; readonly hint?: string | undefined }。展开时保留字段的值类型、只读和可选修饰符。第一条重载也用 Prettify 展开结果,它的字段来自字符串数组,值类型直接是 any。

泛型 props 的最小复现与编译记录

打开原文件 repro.ts

把 repro.ts 放到一个安装了 Vue 和 TypeScript 的空目录,用下列命令只做类型检查。预期仅直接对宏返回值调用 toRefs() 的那一行报 TS7006。

npm install -D vue@3.6.0-rc.15 typescript@6.0.3
npx tsc --strict --noEmit --skipLibCheck --module esnext --moduleResolution bundler repro.ts

复测历史版本时,只替换安装命令里的 Vue 版本。每个版本使用独立目录,沿用同一份 repro.ts 和 tsc 命令。

各版本的 tsc 输出
Vue 3.2.0 / TypeScript 6.0.3
(无诊断,退出码 0)

Vue 3.2.45 / TypeScript 6.0.3
(无诊断,退出码 0)

Vue 3.2.46 / TypeScript 6.0.3
repro.ts(13,9): error TS2739: Type 'Readonly<Omit<Props<T>, [T] extends [boolean | undefined] ? "value" : never> & { [K in keyof Pick<Props<T>, [T] extends [boolean | undefined] ? "value" : never>]-?: NotUndefined<...>; }>' is missing the following properties from type 'Readonly<Props<T>>': options, value
repro.ts(15,9): error TS2339: Property 'options' does not exist on type 'Readonly<Omit<Props<T>, [T] extends [boolean | undefined] ? "value" : never> & { [K in keyof Pick<Props<T>, [T] extends [boolean | undefined] ? "value" : never>]-?: NotUndefined<...>; }>'.
repro.ts(15,22): error TS7006: Parameter 'item' implicitly has an 'any' type.
repro.ts(15,51): error TS2339: Property 'value' does not exist on type 'Readonly<Omit<Props<T>, [T] extends [boolean | undefined] ? "value" : never> & { [K in keyof Pick<Props<T>, [T] extends [boolean | undefined] ? "value" : never>]-?: NotUndefined<...>; }>'.
repro.ts(16,17): error TS2339: Property 'options' does not exist on type 'ToRefs<Readonly<Omit<Props<T>, [T] extends [boolean | undefined] ? "value" : never> & { [K in keyof Pick<Props<T>, [T] extends [boolean | undefined] ? "value" : never>]-?: NotUndefined<...>; }>>'.
repro.ts(16,36): error TS7006: Parameter 'item' implicitly has an 'any' type.
repro.ts(16,65): error TS2339: Property 'value' does not exist on type 'Readonly<Omit<Props<T>, [T] extends [boolean | undefined] ? "value" : never> & { [K in keyof Pick<Props<T>, [T] extends [boolean | undefined] ? "value" : never>]-?: NotUndefined<...>; }>'.
repro.ts(17,70): error TS2339: Property 'value' does not exist on type 'Readonly<Omit<Props<T>, [T] extends [boolean | undefined] ? "value" : never> & { [K in keyof Pick<Props<T>, [T] extends [boolean | undefined] ? "value" : never>]-?: NotUndefined<...>; }>'.

Vue 3.2.47 / TypeScript 6.0.3
repro.ts(13,9): error TS2739: Type 'Readonly<Omit<Props<T>, [T] extends [boolean | undefined] ? "value" : never> & { [K in keyof Pick<Props<T>, [T] extends [boolean | undefined] ? "value" : never>]-?: NotUndefined<...>; }>' is missing the following properties from type 'Readonly<Props<T>>': options, value
repro.ts(15,9): error TS2339: Property 'options' does not exist on type 'Readonly<Omit<Props<T>, [T] extends [boolean | undefined] ? "value" : never> & { [K in keyof Pick<Props<T>, [T] extends [boolean | undefined] ? "value" : never>]-?: NotUndefined<...>; }>'.
repro.ts(15,22): error TS7006: Parameter 'item' implicitly has an 'any' type.
repro.ts(15,51): error TS2339: Property 'value' does not exist on type 'Readonly<Omit<Props<T>, [T] extends [boolean | undefined] ? "value" : never> & { [K in keyof Pick<Props<T>, [T] extends [boolean | undefined] ? "value" : never>]-?: NotUndefined<...>; }>'.
repro.ts(16,17): error TS2339: Property 'options' does not exist on type 'ToRefs<Readonly<Omit<Props<T>, [T] extends [boolean | undefined] ? "value" : never> & { [K in keyof Pick<Props<T>, [T] extends [boolean | undefined] ? "value" : never>]-?: NotUndefined<...>; }>>'.
repro.ts(16,36): error TS7006: Parameter 'item' implicitly has an 'any' type.
repro.ts(16,65): error TS2339: Property 'value' does not exist on type 'Readonly<Omit<Props<T>, [T] extends [boolean | undefined] ? "value" : never> & { [K in keyof Pick<Props<T>, [T] extends [boolean | undefined] ? "value" : never>]-?: NotUndefined<...>; }>'.
repro.ts(17,70): error TS2339: Property 'value' does not exist on type 'Readonly<Omit<Props<T>, [T] extends [boolean | undefined] ? "value" : never> & { [K in keyof Pick<Props<T>, [T] extends [boolean | undefined] ? "value" : never>]-?: NotUndefined<...>; }>'.

Vue 3.3.0 / TypeScript 6.0.3
repro.ts(16,36): error TS7006: Parameter 'item' implicitly has an 'any' type.

Vue 3.3.9 / TypeScript 6.0.3
repro.ts(16,36): error TS7006: Parameter 'item' implicitly has an 'any' type.

Vue 3.4.0 / TypeScript 6.0.3
repro.ts(16,36): error TS7006: Parameter 'item' implicitly has an 'any' type.

Vue 3.4.38 / TypeScript 6.0.3
repro.ts(16,36): error TS7006: Parameter 'item' implicitly has an 'any' type.

Vue 3.5.25 / TypeScript 6.0.3
repro.ts(16,36): error TS7006: Parameter 'item' implicitly has an 'any' type.

Vue 3.5.26 / TypeScript 6.0.3
repro.ts(16,36): error TS7006: Parameter 'item' implicitly has an 'any' type.

Vue 3.6.0-rc.15 / TypeScript 7.0.2
repro.ts(16,36): error TS7006: Parameter 'item' implicitly has an 'any' type.
Vue 3.5.45 / TypeScript 6.0.3
repro.ts(16,36): error TS7006: Parameter 'item' implicitly has an 'any' type.
Vue 3.6.0-rc.15 / TypeScript 6.0.3
repro.ts(16,36): error TS7006: Parameter 'item' implicitly has an 'any' type.

下面的对照只保留条件类型和映射类型,用同样的命令检查 without-vue.ts。直接读取和无条件包装的两行可推导出 string。保留已有 Box 的分支让第三行报 TS2571 和 TS7006。

逐键筛选布尔字段的对照实验
type Box<T> = { value: T };
type AsBox<T> = [T] extends [Box<unknown>] ? T : Box<T>;
type Flags<T> = { [K in keyof T]: T[K] extends boolean | undefined ? K : never }[keyof T];
type Props<T> = { options: readonly string[]; selected: T };
type WithFlags<P> = Readonly<P> & { readonly [K in Flags<P>]-?: boolean };

declare function boxFields<P>(props: P): { [K in keyof P]: AsBox<P[K]> };
declare function wrapFields<P>(props: P): { [K in keyof P]: Box<P[K]> };

function compare<T extends string | number>(props: WithFlags<Props<T>>) {
  props.options.find(item => item.length > 0);
  wrapFields(props).options.value.find(item => item.length > 0);
  boxFields(props).options.value.find(item => item.length > 0);
}