我创建了一个功能组件，看起来像这样：

type RootComponentProps = {
  propThatAlwaysExists: string;
};

type ComponentPropsV1 = {
  type: "v1";
  onlyOnV1: string;
  onlyOnV2?: never;
};

type ComponentPropsV2 = {
  type: "v2";
  onlyOnV1?: never;
  onlyOnV2: string;
};

type ComponentProps = RootComponentProps & (
  | ComponentPropsV1
  | ComponentPropsV2
);

export const Component: FC<ComponentProps> = ({
  propThatAlwaysExists,
  type,
  onlyOnV1,
  onlyOnV2,
}) => {
  // do typechecked things, no errors in component body
};

prop?: never类型是我学到的一种允许解构props的技巧，因为TypeScript禁止直接访问任何不***绝对保证***存在的属性，但解构是eslint等代码正确性工具的首选prop访问方法，在我看来，一般来说，代码可读性。
然后，我尝试将这个组件挂载到它的父组件中，父组件会传递大部分这些属性。我最初尝试明确地写出父项：

import { Component } from "./Component";

type RootParentComponentProps = {
  label: string;
  propThatAlwaysExists: string;
};

type ParentComponentPropsV1 = {
  type: "v1";
  onlyOnV1: string;
  onlyOnV2?: never;
};

type ParentComponentPropsV2 = {
  type: "v2";
  onlyOnV1?: never;
  onlyOnV2: string;
};

type ParentComponentProps = RootParentComponentProps & (
  | ParentComponentPropsV1
  | ParentComponentPropsV2
);

export const ParentComponent: FC<ParentComponentProps> = ({
  label,
  type,
  onlyOnV1,
  onlyOnV2,
}) => {
  // some effects, yadda yadda

  return (
    <div>
      <span>{label}</span>
      <Component
        propThatAlwaysExists={propThatAlwaysExists}
        type={type}
        onlyOnV1={onlyOnV1}
        onlyOnV2={onlyOnV2}
      />
    </div>
  );
};

但我得到了一个非常奇怪的错误：

Types of property 'onlyOnV1' are incompatible.
  Type 'string | undefined' is not assignable to type 'undefined'.
    Type 'string' is not assignable to type 'undefined'.ts(2322)

我想这可能是因为TS无法确定类型之间的相同排除，并且意识到我可以干燥一些代码，所以我将ParentComponent的类型定义更改为：

import { Component, ComponentProps } from "./Component";

type RootParentComponentProps = {
  label: string;
};

type ParentComponentProps = RootParentComponentProps & ComponentProps;

然而，错误仍然没有改变。
在这一点上，我认为问题可能是TypeScript实际上失去了属性排他性的上下文，和/或never的严格性实际上意味着never，所以我通过指定onlyOnV1和onlyOnV2创建了一个不可能的props安排，当我创建的联合类型实际上说只有一个属性可以存在时。
为了解决这个问题，我尝试将Component的独占类型从

type ComponentPropsV1 = {
  type: "v1";
  onlyOnV1: string;
  onlyOnV2?: never;
};

type ComponentPropsV2 = {
  type: "v2";
  onlyOnV1?: never;
  onlyOnV2: string;
};

至

type ComponentPropsV1 = {
  type: "v1";
  onlyOnV1: string;
  onlyOnV2: undefined;
};

type ComponentPropsV2 = {
  type: "v2";
  onlyOnV1: undefined;
  onlyOnV2: string;
};

但是错误仍然没有改变，这对我来说就没有意义了。据我所知，这些都是真的：

• TypeScript从ComponentProps的类型中知道onlyOnV1和onlyOnV2具有反向互斥类型，其中如果一个是string，则另一个必须是undefined，反之亦然
• 从ParentComponent传递到Component的类型***完全***是ComponentProps的类型

然而，不知何故，TypeScript发明了一种场景，其中独占联合类型从

{
  type: "v1";
  onlyOnV1: string;
  onlyOnV2: undefined;
} | {
  type: "v2";
  onlyOnV1: undefined;
  onlyOnV2: string;
}

至

{
  type: "v1" | "v2";
  onlyOnV1: string | undefined;
  onlyOnV2: string | undefined;
}

为了对ComponentProps进行类型检查，即使它实际上是ComponentProps。
我是否错误地使用和/或设计了我的联合类型？
有没有什么方法可以在不牺牲Component或ParentComponent的显式性的情况下完成这项工作？