annil 1.0.0

package/src/api/RootComponent/Watch/test/WatchComputed.test.ts

@@ -0,0 +1,38 @@
+import { Checking, type Test } from "hry-types";
+import type { ReadonlyDeep } from "hry-types/src/Any/_api";
+import type { SpecificType } from "../../../../types/SpecificType";
+import { RootComponent } from "../..";
+import { type Mock_User } from "../../Properties/expected/normalRequired";
+
+/**
+ *  1 computed字段时需要手写类型,可悬停鼠标到key查看类型,深度只读
+ */
+RootComponent()({
+  properties: {
+    Pnum: Number,
+    obj: Object as SpecificType<Mock_User>,
+  },
+  data: {
+    DNum: 123,
+  },
+  computed: {
+    CNum() {
+      return this.data.Pnum + this.data.DNum;
+    },
+    Cobj() {
+      return this.data.obj;
+    },
+  },
+  watch: {
+    CNum(newValue: number, oldValue: number) {
+      Checking<number, typeof newValue, Test.Pass>;
+
+      Checking<number, typeof oldValue, Test.Pass>;
+    },
+    Cobj(newValue: ReadonlyDeep<Mock_User>, oldValue: ReadonlyDeep<Mock_User> | null) {
+      Checking<ReadonlyDeep<Mock_User>, typeof newValue, Test.Pass>;
+
+      Checking<ReadonlyDeep<Mock_User> | null, typeof oldValue, Test.Pass>;
+    },
+  },
+});

package/src/api/RootComponent/Watch/test/WatchData.test.ts

@@ -0,0 +1,52 @@
+import { Checking, type Test } from "hry-types";
+
+import type { ReadonlyDeep } from "hry-types/src/Any/_api";
+import { observable } from "mobx";
+import { RootComponent } from "../..";
+import type { Mock_User } from "../../Properties/expected/normalRequired";
+
+const obj = observable({
+  gender: <"male" | "female"> "male",
+});
+
+/**
+ * watch data字段 深度只读
+ */
+RootComponent()({
+  data: {
+    num: 123,
+    obj: {} as Mock_User,
+  },
+  store: {
+    reactiveLiteral: () => obj.gender,
+    reactiveNumber: () => ({} as number),
+    reactiveUser: () => ({} as Mock_User),
+  },
+  watch: {
+    num(newValue, oldValue) {
+      Checking<number, typeof newValue, Test.Pass>;
+
+      Checking<number, typeof oldValue, Test.Pass>;
+    },
+    obj(newValue, oldValue) {
+      Checking<ReadonlyDeep<Mock_User>, typeof newValue, Test.Pass>;
+
+      Checking<ReadonlyDeep<Mock_User>, typeof oldValue, Test.Pass>;
+    },
+    reactiveNumber(newValue: number, oldValue) {
+      Checking<number, typeof newValue, Test.Pass>;
+
+      Checking<number, typeof oldValue, Test.Pass>;
+    },
+    reactiveLiteral(newValue, oldValue) {
+      Checking<"male" | "female", typeof newValue, Test.Pass>;
+
+      Checking<"male" | "female", typeof oldValue, Test.Pass>;
+    },
+    reactiveUser(newValue, oldValue) {
+      Checking<ReadonlyDeep<Mock_User>, typeof newValue, Test.Pass>;
+
+      Checking<ReadonlyDeep<Mock_User>, typeof oldValue, Test.Pass>;
+    },
+  },
+});

package/src/api/RootComponent/Watch/test/WatchProperties.test.ts

@@ -0,0 +1,156 @@
+import { Checking, type Test } from "hry-types";
+
+import type { ReadonlyDeep } from "hry-types/src/Any/_api";
+import { RootComponent } from "../..";
+
+import type { SpecificType } from "../../../..";
+import {
+  type Mock_Cart,
+  mock_requiredTypes,
+  mock_requiredUnion,
+  type Mock_User,
+} from "../../Properties/expected/normalRequired";
+import type { OptionalType } from "../../Properties/PropertiesConstraint";
+const mock_optional = {
+  optional_num: {
+    type: Number,
+    value: 123,
+  },
+  optional_gender: {
+    type: String as SpecificType<"male" | "female">,
+    value: "male" as const,
+  },
+  optional_obj: {
+    type: Object as SpecificType<Mock_User>,
+    value: {
+      id: "id",
+      name: "name",
+      age: 20,
+    },
+  },
+  optional_objOrNull: {
+    type: Object as SpecificType<Mock_User | null>, // 可选类型定义null默认值方可为null
+    value: null,
+  },
+} satisfies Record<string, OptionalType>;
+
+/**
+ * watch properties字段 深度只读, 必传对象字段newValue去除null
+ */
+RootComponent()({
+  properties: {
+    ...mock_requiredTypes,
+    ...mock_requiredUnion,
+    ...mock_optional,
+  },
+  watch: {
+    // 必传单一字段
+    str(newValue, oldValue) {
+      Checking<string, typeof newValue, Test.Pass>;
+
+      Checking<string, typeof oldValue, Test.Pass>;
+    },
+    num(newValue, oldValue) {
+      Checking<number, typeof newValue, Test.Pass>;
+
+      Checking<number, typeof oldValue, Test.Pass>;
+    },
+    bool(newValue, oldValue) {
+      Checking<boolean, typeof newValue, Test.Pass>;
+
+      Checking<boolean, typeof oldValue, Test.Pass>;
+    },
+    arr(newValue, oldValue) {
+      newValue; // readonly ReadonlyDeep<unknown>[]
+
+      oldValue; // readonly ReadonlyDeep<unknown>[]
+
+      // ts中很多不是错误的错误,写 typeof newValue 结果是错误
+      Checking<unknown[], typeof newValue, Test.Fail>;
+
+      // ts中很多不是错误的错误,写 readonly ReadonlyDeep<unknown>[] 结果是正确的
+      Checking<readonly unknown[], readonly ReadonlyDeep<unknown>[], Test.Pass>;
+    },
+    obj(newValue, oldValue) {
+      Checking<object, typeof newValue, Test.Pass>;
+
+      Checking<object | null, typeof oldValue, Test.Pass>;
+    },
+    tuple(newValue, oldValue) {
+      Checking<readonly [string, number, boolean], typeof newValue, Test.Pass>;
+
+      Checking<readonly [string, number, boolean], typeof oldValue, Test.Pass>;
+    },
+    union_str(newValue, oldValue) {
+      Checking<"male" | "female", typeof newValue, Test.Pass>;
+
+      Checking<"male" | "female", typeof oldValue, Test.Pass>;
+    },
+    union_num(newValue, oldValue) {
+      Checking<0 | 1 | 2, typeof newValue, Test.Pass>;
+
+      Checking<0 | 1 | 2, typeof oldValue, Test.Pass>;
+    },
+    union_bool(newValue, oldValue) {
+      Checking<false | true, typeof newValue, Test.Pass>;
+
+      Checking<false | true, typeof oldValue, Test.Pass>;
+    },
+    union_arr(newValue, oldValue) {
+      Checking<readonly number[] | readonly string[], typeof newValue, Test.Pass>;
+
+      Checking<readonly number[] | readonly string[], typeof oldValue, Test.Pass>;
+    },
+    union_obj(newValue, oldValue) {
+      Checking<ReadonlyDeep<Mock_User | Mock_Cart>, typeof newValue, Test.Pass>;
+
+      Checking<ReadonlyDeep<Mock_User | Mock_Cart | null>, typeof oldValue, Test.Pass>;
+    },
+    // 必传多类型联合
+    union_str_num_bool(newValue, oldValue) {
+      Checking<string | number | boolean, typeof newValue, Test.Pass>;
+
+      Checking<string | number | boolean, typeof oldValue, Test.Pass>;
+    },
+    union_literalStr_Literalnum(newValue, oldValue) {
+      Checking<0 | 1 | 2 | "male" | "female", typeof newValue, Test.Pass>;
+
+      Checking<0 | 1 | 2 | "male" | "female", typeof oldValue, Test.Pass>;
+    },
+    union_mockUser_num(newValue, oldValue) {
+      Checking<ReadonlyDeep<number | Mock_User>, typeof newValue, Test.Pass>;
+
+      Checking<ReadonlyDeep<number | Mock_User | null>, typeof oldValue, Test.Pass>;
+    },
+    // 可选字段
+    optional_gender(newValue, oldValue) {
+      Checking<"male" | "female", typeof newValue, Test.Pass>;
+
+      Checking<"male" | "female", typeof oldValue, Test.Pass>;
+    },
+    optional_num(newValue, oldValue) {
+      Checking<number, typeof newValue, Test.Pass>;
+
+      Checking<number, typeof oldValue, Test.Pass>;
+    },
+    optional_obj(newValue, oldValue) {
+      Checking<ReadonlyDeep<Mock_User>, typeof newValue, Test.Pass>;
+
+      Checking<ReadonlyDeep<Mock_User> | null, typeof oldValue, Test.Pass>;
+    },
+    // 对象的二段key
+    "optional_obj.age"(newValue, oldValue) {
+      Checking<number, typeof newValue, Test.Pass>;
+
+      Checking<number | undefined, typeof oldValue, Test.Pass>;
+    },
+    "optional_obj.id"(newValue, oldValue) {
+      Checking<string, typeof newValue, Test.Pass>;
+
+      Checking<string, typeof oldValue, Test.Pass>;
+    },
+
+    "optional_objOrNull.age"() {
+    },
+  },
+});

package/src/api/RootComponent/Watch/test/error.test.ts

@@ -0,0 +1,31 @@
+import { RootComponent } from "../..";
+// 1 没有data可以watch 约束为EmptyObject
+RootComponent()({
+  watch: {
+    // @ts-expect-error 无可监控字段时，约束为EmptyObject,即不可写任何字段
+    xxx() {},
+  },
+});
+
+/**
+ * 2  超出约束字段报错
+ */
+RootComponent()({
+  properties: {
+    num: Number,
+  },
+  data: {
+    str: "123",
+  },
+  computed: {
+    Cnum() {
+      return this.data.num;
+    },
+  },
+  watch: {
+    // @ts-expect-error otherFields不在约束字段(num,str,Cnum)中
+    otherFields() {
+      1;
+    },
+  },
+});

package/src/api/RootComponent/index.ts

@@ -0,0 +1,139 @@
+import type { IfExtends } from "hry-types/src/Any/IfExtends";
+import type { NoInfer } from "hry-types/src/Generic/NoInfer";
+import type { EmptyObject } from "hry-types/src/Misc/EmptyObject";
+import type { Func } from "hry-types/src/Misc/Func";
+import type { ComputeIntersectionDeep } from "hry-types/src/Object/_api";
+import type { WMCompOtherOption } from "../../types/OfficialTypeAlias";
+import type { ComponentDoc } from "../DefineComponent/ReturnType/ComponentDoc";
+import type { ComputedConstraint } from "./Computed/ComputedConstraint";
+import type { ComputedOption } from "./Computed/ComputedOption";
+import type { GetComputedDoc } from "./Computed/GetComputedDoc";
+import type { CustomEventConstraint } from "./CustomEvents/CustomEventConstraint";
+import type { CustomEventsOption } from "./CustomEvents/CustomEventsOption";
+import type { GetCustomEventDoc } from "./CustomEvents/GetCustomEventDoc";
+import type { DataOption } from "./Data/DataOption";
+import type { EventsConstraint } from "./Events/EventsConstraint";
+import type { EventsOption } from "./Events/EventsOption";
+import type { RootComponentInstance } from "./Instance/RootComponentInstance";
+import type { IsPageOption } from "./IsPage/IsPageOption";
+import type { LifetimesOption } from "./Lifetimes/LifetimesOption";
+import type { MethodsConstraint } from "./Methods/MethodsConstraint";
+import type { MethodsOption } from "./Methods/MethodsOption";
+import type { PageLifetimesOption } from "./PageLifetimes/PageLifetimesOption";
+import type { GetPropertiesDoc } from "./Properties/GetPropertiesDoc";
+import type { PropertiesConstraint } from "./Properties/PropertiesConstraint";
+import type { PropertiesOption } from "./Properties/PropertiesOption";
+import type { GeTStoreDoc } from "./Store/GeTStoreDoc";
+import type { StoreConstraint } from "./Store/StoreConstraint";
+import type { StoreOption } from "./Store/StoreOption";
+import type { WatchOption } from "./Watch/WatchOption";
+
+type RootComponentOptions<
+  TReceivedComponentDoc extends object,
+  TEvents extends object,
+  TIsPage extends boolean,
+  TCustomEvents extends CustomEventConstraint,
+  TMethods extends MethodsConstraint,
+  TProperties extends PropertiesConstraint,
+  TData extends object,
+  TStore extends StoreConstraint,
+  TComputed extends Record<string, Func>,
+  EventsDoc extends object,
+  CustomEventsDoc extends object,
+  PropertiesDoc extends object,
+  DataDoc extends object,
+  StoreDoc extends object,
+  ComputedDoc extends object,
+> =
+  & MethodsOption<TMethods, keyof (EventsDoc & CustomEventsDoc)>
+  & PropertiesOption<TProperties>
+  & IsPageOption<TIsPage>
+  & CustomEventsOption<TCustomEvents, EventsDoc>
+  & EventsOption<TEvents, EventsConstraint<TReceivedComponentDoc>>
+  & DataOption<TData, PropertiesDoc>
+  & StoreOption<TStore, PropertiesDoc & DataDoc>
+  & ComputedOption<TComputed, Required<PropertiesDoc> & DataDoc & StoreDoc>
+  & PageLifetimesOption<TIsPage, NoInfer<PropertiesDoc>>
+  & LifetimesOption<TIsPage>
+  & WatchOption<
+    & ComputedDoc
+    & Required<PropertiesDoc>
+    & DataDoc
+    & StoreDoc
+  >
+  & Partial<Omit<WMCompOtherOption, "pageLifetimes">>
+  & ThisType<
+    RootComponentInstance<
+      TIsPage,
+      TMethods,
+      DataDoc,
+      DataDoc & Required<PropertiesDoc> & StoreDoc & ComputedDoc,
+      CustomEventsDoc,
+      StoreDoc
+    >
+  >;
+
+type RootComponentConstructor<TReceivedComponentDoc extends ComponentDoc[] | ComponentDoc> = {
+  <
+    Literal extends
+      | string
+      | number
+      | boolean
+      | null
+      | Literal[]
+      | Record<string, Literal>,
+    // TEvents 不能有默认值 {} 会引起事件参数类型(e)失效
+    TEvents extends EventsConstraint<TReceivedComponentDoc>,
+    TIsPage extends boolean = false,
+    TProperties extends PropertiesConstraint<Literal> = {},
+    TData extends object = {},
+    TStore extends StoreConstraint = {},
+    TComputed extends ComputedConstraint = {},
+    // 页面时自定义事件无意义
+    TCustomEvents extends IfExtends<TIsPage, false, CustomEventConstraint, EmptyObject> = {},
+    TMethods extends MethodsConstraint = {},
+    EventsDoc extends object = IfExtends<EventsConstraint<TReceivedComponentDoc>, TEvents, {}, TEvents>,
+    CustomEventsDoc extends object = GetCustomEventDoc<TCustomEvents>,
+    PropertiesDoc extends object = GetPropertiesDoc<TProperties, TIsPage>,
+    DataDoc extends object = TData,
+    StoreDoc extends object = GeTStoreDoc<TStore>,
+    ComputedDoc extends object = GetComputedDoc<TComputed>,
+  >(
+    options: RootComponentOptions<
+      TReceivedComponentDoc,
+      TEvents,
+      TIsPage,
+      TCustomEvents,
+      TMethods,
+      TProperties,
+      TData,
+      TStore,
+      TComputed,
+      EventsDoc,
+      CustomEventsDoc,
+      PropertiesDoc,
+      DataDoc,
+      StoreDoc,
+      ComputedDoc
+    >,
+  ): // 返回类型 RootComponentDoc
+  ComputeIntersectionDeep<
+    & IfExtends<TIsPage, false, {}, { isPage: true }>
+    & IfExtends<EmptyObject, PropertiesDoc, {}, { properties: PropertiesDoc }>
+    & IfExtends<EmptyObject, DataDoc, {}, { data: DataDoc }>
+    & IfExtends<EmptyObject, StoreDoc, {}, { store: StoreDoc }>
+    & IfExtends<EmptyObject, ComputedDoc, {}, { computed: ComputedDoc }>
+    & IfExtends<EmptyObject, TMethods, {}, { methods: TMethods }>
+    & IfExtends<EmptyObject, EventsDoc, {}, { events: EventsDoc }>
+    & IfExtends<EmptyObject, CustomEventsDoc, {}, { customEvents: CustomEventsDoc }>
+  >;
+};
+
+export function RootComponent<
+  // ComponentDoc表示RootComponent作为单独组件,ComponentDoc[]表示RootComponent作为多个子组件的根组件
+  TReceivedComponentDoc extends ComponentDoc[] | ComponentDoc = {},
+>(): RootComponentConstructor<
+  TReceivedComponentDoc
+> {
+  return (options: any) => options;
+}

package/src/api/SubComponent/SubComponentDoc.ts

@@ -0,0 +1,30 @@
+import type { SelectKeys } from "hry-types/src/Object/_api";
+import type { Composed, CustomEventsTags } from "../RootComponent/CustomEvents/CustomEventsTag";
+
+type _SubComponentDoc = {
+  [k in string]:
+    | string
+    | number
+    | bigint
+    | boolean
+    | symbol
+    | null
+    | Record<string, unknown>
+    | unknown[]
+    | CustomEventsTags;
+};
+
+type _Validator<O, ErrKeys = Exclude<keyof O, SelectKeys<O, Composed, "contains->">>> = [ErrKeys] extends [never]
+  ? _SubComponentDoc
+  : `${ErrKeys & string} 不是穿透事件`;
+
+/**
+ * SubComponent API 返回类型
+ * @remarks 穿透的子组件自定义事件
+ * ```ts
+ * SubComponentDoc = {
+ *  [k in string]: string | number | bigint | boolean | symbol | null | Record<string, unknown> | unknown[] | CustomEventsTags;
+ * };
+ * ```
+ */
+export type SubComponentDoc<O extends _Validator<O> = _SubComponentDoc> = O;

package/src/api/SubComponent/SubComputed/GetSubComputedDoc.ts

@@ -0,0 +1,3 @@
+export type GetSubComputedDoc<TComputed extends AnyObject> = {
+  [k in keyof TComputed]: ReturnType<TComputed[k]>;
+};

package/src/api/SubComponent/SubComputed/SubComputedConstraint.ts

@@ -0,0 +1 @@
+export type SubComputedConstraint<obj extends object> = { [k in keyof obj]?: () => obj[k] };

package/src/api/SubComponent/SubComputed/SubComputedOption.ts

@@ -0,0 +1,10 @@
+import type { V } from "hry-types";
+export type SubComputedOption<
+  TComputed extends object,
+  legal extends Record<PropertyKey, unknown>,
+> = {
+  computed?:
+    & TComputed
+    & V.IllegalFieldValidator<TComputed, keyof legal, 0, "", "重复或无效的字段">;
+  // & ValidatorOfReturnType<TComputed, legal>;
+};

package/src/api/SubComponent/SubComputed/test/error.test.ts

@@ -0,0 +1,50 @@
+import type { ComponentDoc } from "../../../DefineComponent/ReturnType/ComponentDoc";
+import { SubComponent } from "../..";
+
+type OnlyCustomCompDoc = ComponentDoc<{
+  customEvents: { aaa_str: string };
+}>;
+
+// 1 CompDoc的properties为空时,写任何字段都报错
+SubComponent<{}, OnlyCustomCompDoc>()({
+  computed: {
+    // @ts-expect-error ⚠️"重复或无效的字段"⚠️
+    aaa_xxx() {
+      return 1;
+    },
+  },
+});
+
+type OnlyPropsCompDoc = ComponentDoc<{
+  properties: {
+    aaa_str: "a" | "b";
+    aaa_num?: number;
+  };
+}>;
+
+// 2 去除inhrit和data字段后无组件字段约束时,写任何字段都报错
+SubComponent<{}, OnlyPropsCompDoc>()({
+  inherit: {
+    aaa_str: "wxml",
+  },
+  data: {
+    aaa_num: 123,
+  },
+  computed: {
+    // @ts-expect-error ⚠️"重复或无效的字段"⚠️
+    _aaa_xxx() {},
+  },
+});
+
+// 3 类型错误
+SubComponent<{}, OnlyPropsCompDoc>()({
+  inherit: {
+    aaa_str: "wxml",
+  },
+  computed: {
+    // @ts-expect-error  类型错误
+    aaa_num() {
+      return "string";
+    },
+  },
+});

package/src/api/SubComponent/SubComputed/test/normal.test.ts

@@ -0,0 +1,132 @@
+import { Checking, type Test } from "hry-types";
+import type { ReadonlyDeep } from "hry-types/src/Any/_api";
+import type { ComponentDoc } from "../../../DefineComponent/ReturnType/ComponentDoc";
+import type { Mock_User } from "../../../RootComponent/Properties/expected/normalRequired";
+import { SubComponent } from "../..";
+
+type OnlyCustomCompDoc = ComponentDoc<{
+  customEvents: { aaa_str: string };
+}>;
+
+type User = { name: string; age: number };
+
+type Root = {
+  properties: {
+    num: number;
+    user?: User | null;
+  };
+  data: {
+    str: string;
+  };
+  computed: {
+    bool: boolean;
+  };
+};
+
+SubComponent<{}, OnlyCustomCompDoc>()({
+  // 1 CompDoc的properties为空时,可以写{}
+  computed: {},
+});
+
+type OnlyPropsCompDoc = ComponentDoc<{
+  properties: {
+    aaa_str: "a" | "b";
+    aaa_num?: number;
+    aaa_num123: 123;
+    aaa_obj?: Mock_User | null;
+  };
+}>;
+
+SubComponent<Root, OnlyPropsCompDoc>()({
+  inherit: {
+    aaa_num: "num",
+  },
+  data: {
+    aaa_str: "a",
+  },
+  // 2 可写字段为组件去除inherit和data的剩余字段,返回类型应为对应的文档类型
+  computed: {
+    aaa_obj() {
+      return {} as Mock_User | null;
+    },
+    aaa_num123(): 123 {
+      return 123;
+    },
+  },
+});
+
+SubComponent<Root, OnlyPropsCompDoc>()({
+  computed: {
+    aaa_num() {
+      return 123 as number;
+    },
+    aaa_num123(): 123 {
+      return 123;
+    },
+    aaa_str(): "a" {
+      return "a";
+    },
+    aaa_obj() {
+      this.data;
+
+      // 5 this.data
+      Checking<
+        typeof this.data,
+        ReadonlyDeep<{
+          num: number;
+          user: User | null;
+          str: string;
+          bool: boolean;
+          aaa_num: number;
+          aaa_num123: 123;
+          aaa_str: "a";
+          aaa_obj: Mock_User;
+        }>,
+        Test.Pass
+      >;
+
+      return {} as Mock_User;
+    },
+  },
+  lifetimes: {
+    attached() {
+      // 5 this.data 深度只读
+      Checking<
+        typeof this.data,
+        ReadonlyDeep<{
+          num: number;
+          user: User | null;
+          str: string;
+          bool: boolean;
+          aaa_num: number;
+          aaa_num123: 123;
+          aaa_str: "a";
+          aaa_obj: Mock_User;
+        }>,
+        Test.Pass
+      >;
+    },
+  },
+});
+
+// 计算属性可互相引用 ！！！但是没有自动提示！！！
+type CompDoc = ComponentDoc<
+  { properties: { aaa_num: number; aaa_user: User | null; aaa_xxx: number; aaa_age: number } }
+>;
+
+SubComponent<Root, CompDoc>()({
+  data: {
+    aaa_xxx: 123,
+  },
+  computed: {
+    aaa_num(): number {
+      return this.data.aaa_xxx;
+    },
+    aaa_user(): User | null {
+      return this.data.user;
+    },
+    aaa_age(): number {
+      return this.data.aaa_num;
+    },
+  },
+});

package/src/api/SubComponent/SubData/SubDataConstraint.ts

@@ -0,0 +1,10 @@
+/**
+ * 子组件Data字段约束
+ * @returns 当剩余对象不为空对象,约束对象的key为剩余key,类型为剩余key对应的文档类型或函数返回类型。
+ */
+export type SubDataConstraint<
+  O extends object,
+> = {
+  // 加入响应式数据类型
+  [k in (keyof O)]?: O[k];
+};

package/src/api/SubComponent/SubData/SubDataOption.ts

@@ -0,0 +1,13 @@
+import type { V } from "hry-types";
+
+export type SubDataOption<TSubData extends object, legalKeys extends PropertyKey, TPrefix extends string> = {
+  data?:
+    & TSubData
+    & V.IllegalFieldValidator<
+      TSubData,
+      legalKeys | `_${TPrefix}_${string}`,
+      0,
+      "",
+      "⚠️ 子组件无需此字段或与Inherit字段重复 ⚠️"
+    >;
+};