如何在函数参数依赖运行时值时正确推断互斥联合类型参数？

我定义了以下带类型约束的函数，实现了互斥联合类型，要求调用者只能传递a、b、c、d中的一个属性，不可同时传递。其中部分类型允许可选的onPress，而PropsD要求必须传入onPress：

type AllKeys<T> = T extends unknown ? keyof T : never;
type Id<T> = T extends infer U ? { [K in keyof U]: U[K] } : never;
type _ExclusifyUnion<T, K extends PropertyKey> =
    T extends unknown ? Id<T & Partial<Record<Exclude<K, keyof T>, never>>> : never;
type ExclusifyUnion<T> = _ExclusifyUnion<T, AllKeys<T>>;

type PropsRoot = {
    common: string;
}

type PropsA = PropsRoot & {
    a: number;
    onPress?: () => void;
}

type PropsB =  PropsRoot & {
    b: number;
    onPress?: () => void;
}

type PropsC =  PropsRoot & {
    c: number;
}

type PropsD = PropsRoot & {
    d?: string;
    onPress: () => void;
}

type Props = ExclusifyUnion<PropsA | PropsB  | PropsC | PropsD>;

const fun = (props: Props) => {}

生成的Props类型本质是互斥联合，每个成员会排除其他不允许混合的属性，示例如下：

type Props = {
    common: string;
    a: number;
    onPress?: (() => void) | undefined;
    b?: undefined;
    c?: undefined;
    d?: undefined;
} | {
    common: string;
    b: number;
    onPress?: (() => void) | undefined;
    a?: undefined;
    c?: undefined;
    d?: undefined;
} | {
    common: string;
    c: number;
    a?: undefined;
    onPress?: undefined;
    b?: undefined;
    d?: undefined;
} | {
    // PropsD对应的互斥类型
    common: string;
    onPress: () => void;
    d?: string | undefined;
    a?: undefined;
    b?: undefined;
    c?: undefined;
}

静态场景下类型检查正常，但当参数依赖运行时值时，类型推断会失效，无法匹配到PropsA或PropsD这类具体类型：

const test = true;
// 此处会报错，TypeScript无法推断这是合法的PropsA
fun({common: 'common', a: test ? 2 : undefined, onPress: () => {}});

目前必须显式指定其他互斥属性为undefined才能通过检查，但这会增加调用者的负担：

// 仅显式传入b: undefined才能通过检查
fun({common: 'common', a: test ? 2 : undefined, b: undefined, onPress: () => {}});

有没有更优的类型定义方式，能在保留互斥约束的同时，让运行时条件参数也能正常通过类型检查？

核心问题是当前的互斥类型通过**强制其他属性为undefined**来实现约束，但TypeScript在面对条件表达式时，无法自动推断未显式设置的属性属于"应该为undefined"的范畴。以下是几种可行的优化方案：

方案1：使用判别式联合类型（推荐） #

给每个子类型添加唯一的判别字段（比如type），这是TypeScript处理联合类型最原生、最顺畅的方式：

type PropsRoot = {
    common: string;
}

type PropsA = PropsRoot & {
    type: 'a'; // 唯一判别字段
    a: number;
    onPress?: () => void;
}

type PropsB = PropsRoot & {
    type: 'b';
    b: number;
    onPress?: () => void;
}

type PropsC = PropsRoot & {
    type: 'c';
    c: number;
}

type PropsD = PropsRoot & {
    type: 'd';
    d?: string;
    onPress: () => void;
}

// 直接使用联合类型，无需额外互斥处理
type Props = PropsA | PropsB | PropsC | PropsD;

const fun = (props: Props) => {}

// 现在条件参数可以正常推断
const test = true;
fun({type: 'a', common: 'common', a: test ? 2 : undefined, onPress: () => {}});

这种方式的优势是TypeScript原生支持判别式联合，类型推断效率高，调用者代码更清晰，同时完全满足互斥要求（每个类型的type字段唯一，不可能同时属于多个子类型）。

方案2：优化互斥类型定义，兼容可选属性的条件赋值 #

如果无法添加判别字段，可以调整ExclusifyUnion的逻辑，让未显式设置的属性自动被视为undefined，而非强制要求显式传入：

// 重新定义互斥类型：仅要求存在的属性是唯一的，未声明的属性自动兼容undefined
type ExclusifyUnion<T> = T extends infer U 
  ? U & Partial<Record<Exclude<AllKeys<T>, keyof U>, never>> 
  : never;

type AllKeys<T> = T extends unknown ? keyof T : never;

// 原有的PropsRoot、PropsA/PropsB/PropsC/PropsD定义不变
type PropsRoot = { common: string };
type PropsA = PropsRoot & { a: number; onPress?: () => void };
type PropsB = PropsRoot & { b: number; onPress?: () => void };
type PropsC = PropsRoot & { c: number };
type PropsD = PropsRoot & { d?: string; onPress: () => void };

type Props = ExclusifyUnion<PropsA | PropsB | PropsC | PropsD>;

const fun = (props: Props) => {}

// 现在无需显式传入其他属性为undefined
const test = true;
fun({common: 'common', a: test ? 2 : undefined, onPress: () => {}}); // 正常通过

这个方案的核心是调整了互斥类型的生成逻辑：原来的类型会把所有非当前类型的属性强制声明为undefined（必须显式传入），现在改为允许这些属性隐式为undefined（通过Partial包裹），这样TypeScript在推断时会自动忽略未显式设置的属性，认为它们符合undefined的约束。

方案3：使用函数重载 #

针对不同的子类型定义函数重载，让TypeScript根据传入的参数自动匹配对应的重载签名：

type PropsRoot = { common: string };
type PropsA = PropsRoot & { a: number; onPress?: () => void };
type PropsB = PropsRoot & { b: number; onPress?: () => void };
type PropsC = PropsRoot & { c: number };
type PropsD = PropsRoot & { d?: string; onPress: () => void };

// 定义重载签名
function fun(props: PropsA): void;
function fun(props: PropsB): void;
function fun(props: PropsC): void;
function fun(props: PropsD): void;
// 实现签名（兼容所有类型）
function fun(props: PropsA | PropsB | PropsC | PropsD): void {}

// 条件参数可以正常推断
const test = true;
fun({common: 'common', a: test ? 2 : undefined, onPress: () => {}}); // 正常通过

函数重载的优势是可以针对每个子类型做更精确的约束，同时调用时的类型推断也会优先匹配对应的重载签名，避免了互斥类型的复杂逻辑。

内容的提问来源于stack exchange，提问作者Bertuz