TypeScript中实现泛型属性嵌套数组的穷尽性检查

interface User {
  firstName: string;
  lastName: string;
  age: number;
  gender: string;
}

type Field<T, K extends keyof T> = {
  fieldName: K;
  value: T[K];
};

type FieldsGroupLayout<T> = Array<Array<Field<T, keyof T>>>;

function layout<T>(fields: Array<Field<T, keyof T>>): Array<Field<T, keyof T>> {
  return fields;
}

function field<T, K extends keyof T>(fieldName: K, value: T[K]): Field<T, K> {
  return {
    fieldName,
    value,
  };
}

const form: FieldsGroupLayout<User> = [
  layout([
    field('firstName', 'John'),
    field('lastName', 'Doe'),
  ]),
  layout([
    field('age', 12),
    field('gender', 'Male'),
  ]),
];

// 定义一个更通用的Field类型，其K和V可以是任何PropertyKey和值
type Field<K extends PropertyKey, V> = {
    fieldName: K;
    value: V;
};

// FieldFor<T> 类型，用于从T的每个属性K生成一个Field<K, T[K]>的联合类型
type FieldFor<T> =
    { [K in keyof T]-?: Field<K, T[K]> }[keyof T];

// layout函数，接受一个只读的Field数组，并保持其字面量类型
function layout<T extends readonly Field<any, any>[]>(fields: readonly [...T]) {
    return fields;
}

// field函数，接受字面量K和V，并返回精确的Field<K, V>类型
function field<K extends PropertyKey, V>(fieldName: K, value: V): Field<K, V> {
    return {
        fieldName,
        value,
    };
}

function fieldsGroupLayoutFor<T extends object>() {

    // Missing<T, U> 类型用于计算在类型T中存在，但在U（表单结构）中缺失的字段
    // U[number][number]['fieldName'] 收集了U中所有Field的fieldName字面量类型
    // Exclude<K, ...> 移除了已存在的字段
    // FieldFor<{ ... }> 将剩余的字段转换为Field类型
    type Missing<T extends object, U extends readonly (readonly FieldFor<T>[])[]> =
        FieldFor<{ [K in keyof T as Exclude<K, U[number][number]['fieldName']>]: T[K] }>;

    // 返回的函数，接受表单结构U
    return function <U extends readonly (readonly FieldFor<T>[])[]>(
        // 这里的关键是U的类型注解：
        // U & (Missing<T, U> extends never ? unknown : readonly [Missing<T, U>])
        // 如果Missing<T, U>是never（表示没有缺失字段），则类型为U & unknown，等同于U。
        // 如果Missing<T, U>不是never（表示有缺失字段），则类型为U & readonly [Missing<T, U>]。
        // 这种交叉类型会导致类型不兼容错误，从而强制编译器报错。
        u: U & (Missing<T, U> extends never ? unknown : readonly [Missing<T, U>])
    ) {
        return u as readonly (readonly FieldFor<T>[])[];
    }
}

interface User {
    firstName: string;
    lastName: string;
    age: number;
    gender: string;
}

// 为User类型创建专属的表单布局函数
const fieldsGroupLayoutForUser = fieldsGroupLayoutFor<User>();

// 正确的表单定义：所有User属性都被表示
const form = fieldsGroupLayoutForUser([
    layout([
        field('firstName', 'John'),
        field('lastName', 'Doe'),
    ]),
    layout([
        field('age', 12),
        field('gender', 'Male'),
    ]),
]); // 编译通过，类型正确

// 错误的表单定义：缺少 'age' 字段
const badForm = fieldsGroupLayoutForUser([
    layout([
        field('firstName', 'John'),
        field('lastName', 'Doe'),
    ]),
    layout([
        // field('age', 12), // 故意注释掉 age 字段
        field('gender', 'Male'),
    ]),
]);
// 编译器将在此处报错！
// 错误信息类似：
// Type 'readonly [Field<"firstName", string>]' is not assignable to type 'Field<"age", number>'
// 这表明 'age' 字段缺失，并且期望它是 Field<'age', number> 类型。