annil 1.1.1 → 1.2.0-beta.0

package/src/api/RootComponent/CustomEvents/CustomEventsOption.ts

@@ -1,37 +1,41 @@
 import type { V } from "hry-types";
 import type { CustomEventConstraint } from "./CustomEventConstraint";
 
-/**
- * customEvents字段泛型输入
- */
 export type CustomEventsOption<
   TCustomEvents extends CustomEventConstraint,
-  DuplicateFieldCheck,
+  EventsKeys extends PropertyKey,
 > = {
   /**
-   * 自定义事件
-   * @remarks 使用this.customEventsA 调用
+   * customEvents 定义组件的自定义事件 [类型约束](CustomEventConstraint.ts)
+   * @remarks 通过this.A(123)调用。与events字段重复检测
    * @example
    * ```ts
-   *  {
-   *   // ...
-   *   customEvents: {
-   *     A: Number, // number
-   *     B: [String as DetailedType<"male" | "femal">, Number], // "male" | "femal" | number
-   *     C: {
-   *       detail: String,
-   *       options: {
-   *         bubbles: true,
-   *         composed: true,
-   *         capturePhase: true,
-   *       },
-   *     },
-   *   },
-   * };
+   * {
+   *  customEvents: {
+   *    A: Number, // number
+   *    B: [String as DetailedType<"male" | "femal">, Number], // "male" | "femal" | number
+   *    C: {
+   *      detail: String,
+   *      options: {
+   *        bubbles: true,
+   *        composed: true,
+   *        capturePhase: true,
+   *      },
+   *    },
+   *  },
+   *  methods: {
+   *    M1() {
+   *      // 调用自定义事件
+   *      this.A(123);
+   *      this.B("femal");
+   *      this.C("string");
+   *    },
+   *  },
+   * },
    * ```
    */
   customEvents?:
     & TCustomEvents
     & V.IllegalFieldValidator<TCustomEvents, "bubbles" | "composed" | "capturePhase", 1, "options">
-    & V.DuplicateFieldValidator<TCustomEvents, keyof DuplicateFieldCheck, "与events字段重复">;
+    & V.DuplicateFieldValidator<TCustomEvents, EventsKeys, "与events字段重复">;
 };

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

@@ -5,26 +5,26 @@ import { RootComponent } from "../..";
  */
 RootComponent()({
   customEvents: {
-    // @ts-expect-error options 没有options字段时无需写对象形式,应简写`error1:Boolean`。
+    // @ts-expect-error options 1.1 没有options字段时无需写对象形式,应简写`error1:Boolean`。
     error1: {
       detail: Boolean,
     },
-    // @ts-expect-error options 不可以为空对象 无意义
+    // @ts-expect-error options 1.2 不可以为空对象 无意义
     error2: {
       detail: Boolean,
       options: {},
     },
-    // @ts-expect-error false字段不要写 默认就为false
+    // @ts-expect-error 1.3 false字段不要写 默认就为false
     error3: {
       detail: Boolean,
       options: { bubbles: false },
     },
-    // @ts-expect-error false 字段不要写 默认false
+    // @ts-expect-error 1.4 false 字段不要写 默认false
     error4: {
       detail: Boolean,
       options: { capturePhase: false },
     },
-    // @ts-expect-error composed字段不可以单独开启,必须存在 bubbles或capturePhase字段为true时
+    // @ts-expect-error 1.5 composed字段不可以单独开启,必须存在 bubbles或capturePhase字段为true时
     error5: {
       detail: Boolean,
       options: { composed: true },

package/src/api/RootComponent/CustomEvents/test/normal.test.ts

@@ -61,7 +61,7 @@ const rootDoc = RootComponent()({
 
 type RootDoc = {
   customEvents: {
-    // 简写字段 即类型为事件参数e对象的detail字段类型
+    // 简写字段 值类型为事件参数e的detail类型
     str: string;
     null: null;
     unionStr: "male" | "female";

package/src/api/RootComponent/Data/DataConstraint.ts

@@ -1 +1 @@
-export type DataConstraint = Record<string, any>;
+export type DataConstraint = Record<string, unknown>;

package/src/api/RootComponent/Data/DataOption.ts

@@ -1,19 +1,21 @@
 import type { V } from "hry-types";
 
-export type DataOption<TData extends object, TProperties> = {
+export type DataOption<TData extends object, PropertiesKeys extends PropertyKey> = {
   /**
-   * 可通过函数返回形式引入基于Mobx的响应式数据
+   * 定义实例基本数据,默认下划线(`_`)开头的为内部数据,不会被渲染
+   * @remarks 与properties字段重复校验
    * @example
    * ```ts
    * {
    *   //...
    *   data:{
-   *     reactive_user:() => UserStore.user
+   *      num:123,
+   *      _str:'string' //不会被渲染的内部数据
    *   }
    * }
    * ```
    */
   data?:
     & TData
-    & V.DuplicateFieldValidator<TData, keyof TProperties, "与properties字段重复">;
+    & V.DuplicateFieldValidator<TData, PropertiesKeys, "与properties字段重复">;
 };

package/src/api/RootComponent/Data/GetDataDoc.ts

@@ -1,25 +1,8 @@
-import type { O } from "hry-types";
-import type { IfExtends } from "hry-types/src/Any/IfExtends";
-import type { Func } from "hry-types/src/Misc/Func";
-
 /**
  * 获取data字段文档类型
  * @param TData - `DataConstraint`
- * @param Type - "去掉函数字段" | "返回函数字段" | "函数值类型变为函数返回类型"
  * @returns object
  */
 export type GetDataDoc<
   TData extends object,
-  Type extends "去掉函数字段" | "返回函数字段" | "函数值类型变为函数返回类型" = "函数值类型变为函数返回类型",
-> = IfExtends<
-  Type,
-  "函数值类型变为函数返回类型",
-  O.ReturnTypeInObject<TData>,
-  IfExtends<
-    Type,
-    "去掉函数字段",
-    O.Filter<TData, Func>,
-    // "返回函数字段"
-    O.Select<TData, Func>
-  >
->;
+> = TData;

package/src/api/RootComponent/Data/test/GetDataDoc.test.ts

@@ -1,43 +1,32 @@
 import { Checking, type Test } from "hry-types";
 
-import type { Mock_User } from "../../Properties/test/normalRequired.test";
 import type { GetDataDoc } from "../GetDataDoc";
 
 export const mock_data = {
-  reactiveUser: () => ({} as Mock_User),
+  func: {
+    foo(num: number) {
+      return num + 1;
+    },
+  },
   num: 2,
   str: "str",
 };
 
-type Test1 = GetDataDoc<typeof mock_data, "函数值类型变为函数返回类型">;
+type Test1 = GetDataDoc<typeof mock_data>;
 
-type Test1Expected = { reactiveUser: Mock_User; num: number; str: string };
+type Test1Expected = {
+  func: {
+    foo(num: number): number;
+  };
+  num: number;
+  str: string;
+};
 
 Checking<Test1, Test1Expected, Test.Pass>;
 
-type Test2 = GetDataDoc<typeof mock_data, "去掉函数字段">;
-
-type Test2Expected = { num: number; str: string };
-
-Checking<Test2, Test2Expected, Test.Pass>;
-
-type Test3 = GetDataDoc<typeof mock_data, "返回函数字段">;
-
-type Test3Expected = { reactiveUser: () => Mock_User };
-
-Checking<Test3, Test3Expected, Test.Pass>;
-
 // 测试空对象
-type Test4 = GetDataDoc<{}, "返回函数字段">;
+type Test4 = GetDataDoc<{}>;
 
 type Test4Expected = {};
 
 Checking<Test4, Test4Expected, Test.Pass>;
-
-type Test5 = GetDataDoc<{}, "去掉函数字段">;
-
-Checking<Test5, Test4Expected, Test.Pass>;
-
-type Test6 = GetDataDoc<{}, "返回函数字段">;
-
-Checking<Test6, Test4Expected, Test.Pass>;

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

@@ -1,14 +1,14 @@
 import { RootComponent } from "../..";
 
 /**
- * 1 与properties字段重复
+ * 字段重复
  */
 RootComponent()({
   properties: {
     aaa: String,
   },
   data: {
-    // @ts-expect-error ⚠️与properties字段重复⚠️
+    // @ts-expect-error 1 ⚠️与properties字段重复⚠️
     aaa: 123,
   },
 });

package/src/api/RootComponent/Data/test/normal.test.ts

@@ -3,21 +3,19 @@ import { Checking, type Test } from "hry-types";
 import type { ReadonlyDeep } from "hry-types/src/Any/_api";
 import { RootComponent } from "../..";
 
-/**
- * data字段约束为object,函数类型表示引入的响应式字段(mobx)
- */
+type Gender = "male" | "female";
+
 const RootDoc = RootComponent()({
   data: {
-    gender: <"male" | "female"> "male", // 联合字面量
+    gender: <Gender> "male", // 联合字面量
     num: 123,
     _innernalFields: 123, // 内部字段无法在wxml中使用
   },
   methods: {
     foo() {
-      // 1. data配置类型为函数时,this.data中变为函数返回类型
       Checking<
         typeof this.data,
-        ReadonlyDeep<{ gender: "male" | "female"; num: number; _innernalFields: number }>,
+        ReadonlyDeep<{ gender: Gender; num: number; _innernalFields: number }>,
         Test.Pass
       >;
     },
@@ -25,12 +23,11 @@ const RootDoc = RootComponent()({
 });
 
 type RootDocExpected = {
-  gender: "male" | "female";
+  gender: Gender;
   num: number;
   _innernalFields: number;
 };
 
-// 2. data配置类型为函数时,dataDoc中变为函数返回类型
 Checking<typeof RootDoc["data"], RootDocExpected, Test.Pass>;
 
 // data为空对象时

package/src/api/RootComponent/Events/EventsConstraint.ts

@@ -1,3 +1,5 @@
+// import type { IfExtends } from "hry-types/src/Any/IfExtends";
+import type { IfExtends } from "hry-types/src/Any/_api";
 import type { Select } from "hry-types/src/Object/_api";
 import type { Detail, WMBaseEvent } from "../../../types/OfficialTypeAlias";
 import type { ComponentDoc } from "../../DefineComponent/ReturnType/ComponentDoc";
@@ -16,9 +18,9 @@ type FilterNormalFields<O extends object> = Select<O, Bubbles | Capture, "contai
 
 // 获取冒泡或捕获的事件
 type GetBubblesOrCaptureEventsFromCompDoc<
-  TComponentDocTuple extends ComponentDoc[],
+  ComponentDocList extends ComponentDoc[],
   Result extends CustomEventsDoc = {},
-> = TComponentDocTuple extends [infer Head extends ComponentDoc, ...infer Rest extends ComponentDoc[]]
+> = ComponentDocList extends [infer Head extends ComponentDoc, ...infer Rest extends ComponentDoc[]]
   ? GetBubblesOrCaptureEventsFromCompDoc<
     Rest,
     Result & (FilterNormalFields<Head["customEvents"] & {}>)
@@ -47,23 +49,26 @@ type TransformCustomEventsDocTypeToFunctionTypeAndAddSuffix<T extends CustomEven
 };
 
 // 所有子组件自定义事件(过滤掉非冒泡或捕获)的key加入后缀并把值(detail)转换为函数类型
-type GetAllSubCustomEventsConstraint<TReceivedComponentDoc extends ComponentDoc[] | ComponentDoc> = {} extends
-  TReceivedComponentDoc ? {}
-  : TReceivedComponentDoc extends ComponentDoc[] ? TransformCustomEventsDocTypeToFunctionTypeAndAddSuffix<
-      GetBubblesOrCaptureEventsFromCompDoc<TReceivedComponentDoc>
-    >
-  : ComponentDoc["customEvents"] & {};
+type GetAllSubCustomEventsConstraint<
+  ComponentDocList extends ComponentDoc[],
+  AllCustomEvents extends CustomEventsDoc = GetBubblesOrCaptureEventsFromCompDoc<ComponentDocList>,
+> = IfExtends<
+  {},
+  AllCustomEvents,
+  BaseEvent,
+  TransformCustomEventsDocTypeToFunctionTypeAndAddSuffix<
+    AllCustomEvents
+  >
+>;
+
+type BaseEvent = Record<string, (e: WMBaseEvent) => any>;
 
 /**
- * events字段约束
+ * events字段约束 由自身事件和冒泡的子组件事件组成。带前缀是子组件事件,带后缀(_catch)表示阻止冒泡
  */
-export type EventsConstraint<TReceivedComponentDoc extends ComponentDoc[] | ComponentDoc = {}> = {} extends
-  TReceivedComponentDoc ? Record<string, (e: WMBaseEvent) => any>
-  : TReceivedComponentDoc extends ComponentDoc ? {
-      [k in keyof TReceivedComponentDoc["customEvents"]]?: (
-        e: Exclude<TReceivedComponentDoc["customEvents"][k], CustomEventsTags>,
-      ) => void;
-    }
-  : GetAllSubCustomEventsConstraint<TReceivedComponentDoc>;
-// // 一般事件字段约束
-// & Record<string, (e: WMBaseEvent) => any>;
+export type EventsConstraint<ComponentDocList extends ComponentDoc[] = []> = IfExtends<
+  [],
+  ComponentDocList,
+  BaseEvent,
+  GetAllSubCustomEventsConstraint<ComponentDocList>
+>;

package/src/api/RootComponent/Events/EventsOption.ts

@@ -1,7 +1,55 @@
-import type { V } from "hry-types";
-
-export type EventsOption<TEvents extends object, EventsDoc> = {
-  events?:
-    & TEvents
-    & V.IllegalFieldValidator<TEvents, keyof EventsDoc>;
+export type EventsOption<TEvents extends object> = {
+  /**
+   * 根组件事件字段,当RootComopnent传入组件泛型时,有子组件事件提示
+   *
+   * @example A 无子组件时
+   * ```ts
+   * RootComponent()({
+   *  events: {
+   *    onTap(e) {
+   *      Checking<typeof e, WMBaseEvent, Test.Pass>;
+   *    },
+   *  },
+   * });
+   * ```
+   * @example B
+   * ```ts
+   * type ComponentDocA = {
+   *  customEvents: {
+   *    aaa_str: string;
+   *    aaa_num: number | Bubbles;
+   *  };
+   * };
+   *
+   * type ComponentDocB = {
+   *  customEvents: {
+   *    bbb_str: string;
+   *    bbb_num: number | Capture;
+   *  };
+   * };
+   * RootComponent<[ComponentDocA, ComponentDocB]>()({
+   *  events: {
+   *    // 后缀bubbles表示为子组件的冒泡事件
+   *    aaa_num_bubbles(e) {
+   *      Checking<typeof e.detail, number, Test.Pass>;
+   *    },
+   *    // 后缀加catch表示阻止事件传递,当前组件类型将不会向上传递此事件类型。
+   *    aaa_num_bubbles_catch(e) {
+   *      Checking<typeof e.detail, number, Test.Pass>;
+   *    },
+   *    // 后缀capture表示是捕获事件
+   *    bbb_num_capture(e: Dataset<{ currentTargetDataset: number }, { targetDataset: string }, number>) {
+   *      Checking<typeof e.detail, number, Test.Pass>;
+   *      Checking<typeof e.currentTarget.dataset.currentTargetDataset, number, Test.Pass>;
+   *      Checking<typeof e.target.dataset.targetDataset, string, Test.Pass>;
+   *    },
+   *    // 后缀加catch表示阻止事件传递,由于捕获事件向下阻止,所以当发现捕获事件不触发时应查看上级组件是否有阻止事件。
+   *    bbb_num_capture_catch(e) {
+   *      Checking<typeof e.detail, number, Test.Pass>;
+   *    },
+   *  },
+   * });
+   * ```
+   */
+  events?: TEvents;
 };

package/src/api/RootComponent/Events/test/normal.test.ts

@@ -13,22 +13,22 @@ import { RootComponent } from "../..";
 import type { Bubbles, Capture } from "../../CustomEvents/CustomEventsTag";
 
 /**
- * 1. 事件参数e的类型默认为官方基础类型
+ * 1. 没有子组件时,事件参数e的类型默认为官方基础类型
  */
 RootComponent()({
   events: {
-    aaa(e) {
+    onTap(e) {
       Checking<typeof e, WMBaseEvent, Test.Pass>;
     },
   },
 });
 
 /**
- * 2. 事件参数e可通过WMBaseEvent和WMCustomEvent(多一个detail类型)定义内部类型。
+ * 2. 没有子组件时,事件参数e可通过WMBaseEvent和WMCustomEvent(多一个detail类型)定义内部类型。
  */
 RootComponent()({
   events: {
-    // 通过WMCustomEvent定义detai,mark,CurrentTargetDataset,targetDataset数据类型
+    // 2.1 通过WMCustomEvent定义detai,mark,CurrentTargetDataset,targetDataset数据类型
     customA(
       e: WMCustomEvent<
         { detailData: string },
@@ -47,21 +47,21 @@ RootComponent()({
 
       Checking<typeof e.target.dataset.targetDatasetData, number, Test.Pass>;
     },
-    // 通过Detail定义detai类型
+    // 2.2 通过Detail定义detai类型
     bbb(e: Detail<{ str: string }>) {
       Checking<typeof e.detail.str, string, Test.Pass>;
     },
-    // 通过Mark定义mark类型
+    // 2.3 通过Mark定义mark类型
     ccc(e: Mark<{ id: string }>) {
       const markId = e.mark!.id;
 
       Checking<typeof markId, string, Test.Pass>;
     },
-    // 通过CurrentTargetDataset定义currentTarget.dataset类型
+    // 2.4 通过CurrentTargetDataset定义currentTarget.dataset类型
     ddd(e: CurrentTargetDataset<{ str: string }>) {
       Checking<typeof e.currentTarget.dataset.str, string, Test.Pass>;
     },
-    // 通过TargetDataset定义target.dateset类型
+    // 2.5 通过TargetDataset定义target.dateset类型
     eee(e: TargetDataset<{ str: string }>) {
       Checking<typeof e.target.dataset.str, string, Test.Pass>;
     },
@@ -86,19 +86,19 @@ type ComponentDocB = ComponentDoc<{
 }>;
 
 /**
- * 6. 当传入子组件文档列表时,提供子组件的冒泡和捕获事件的字段提示
+ * 3. 当传入子组件文档列表时,提供子组件的冒泡和捕获事件的字段提示
  */
 const RootDoc = RootComponent<[ComponentDocA, ComponentDocB]>()({
   events: {
-    // 后缀bubbles表示为子组件的冒泡事件
+    // 3.1 后缀bubbles表示为子组件的冒泡事件
     aaa_num_bubbles(e) {
       Checking<typeof e.detail, number, Test.Pass>;
     },
-    // 后缀加catch表示阻止事件传递,当前组件类型将不会向上传递此事件类型。
+    // 3.2 后缀加catch表示阻止事件传递,当前组件类型将不会向上传递此事件类型。
     aaa_num_bubbles_catch(e) {
       Checking<typeof e.detail, number, Test.Pass>;
     },
-    // 后缀capture表示是捕获事件
+    // 3.3 后缀capture表示是捕获事件
     bbb_num_capture(e: Dataset<{ currentTargetDataset: number }, { targetDataset: string }, number>) {
       Checking<typeof e.detail, number, Test.Pass>;
 
@@ -106,7 +106,7 @@ const RootDoc = RootComponent<[ComponentDocA, ComponentDocB]>()({
 
       Checking<typeof e.target.dataset.targetDataset, string, Test.Pass>;
     },
-    // 后缀加catch表示阻止事件传递,由于捕获事件向下阻止,所以当发现捕获事件不触发时应查看上级组件是否有阻止事件。
+    // 3.4 后缀加catch表示阻止事件传递,由于捕获事件向下阻止,所以当发现捕获事件不触发时应查看上级组件是否有阻止事件。
     bbb_num_capture_catch(e) {
       Checking<typeof e.detail, number, Test.Pass>;
     },
@@ -122,11 +122,11 @@ type RootDocExpect = {
   };
 };
 
-// 7 返回EventsDoc正常
+// 4 返回EventsDoc正常
 Checking<typeof RootDoc, RootDocExpect, Test.Pass>;
 
 /**
- * 8 events字段为`{}`时,返回类型中无events字段。
+ * 5 events字段为`{}`时,返回类型中无events字段。
  */
 const EmptyEventsFields = RootComponent<[ComponentDocA, ComponentDocB]>()({
   events: {},
@@ -135,7 +135,7 @@ const EmptyEventsFields = RootComponent<[ComponentDocA, ComponentDocB]>()({
 Checking<typeof EmptyEventsFields, {}, Test.Pass>;
 
 /**
- * 9 没有events字段时,返回类型中无events字段。
+ * 6 没有events字段时,返回类型中无events字段。
  */
 const NoEventsFields = RootComponent<[ComponentDocA, ComponentDocB]>()({});
 

package/src/api/RootComponent/Instance/test/properties/mormal.test.ts

@@ -32,7 +32,7 @@ RootComponent()({
   pageLifetimes: {
     onLoad(data) {
       Checking<typeof data, {
-        optionalObj: {
+        optionalObj?: {
           name: string;
         };
         obj: object;

package/src/api/RootComponent/IsPage/IsPageOption.ts

@@ -1,6 +1,6 @@
 export type IsPageOption<TIsPage extends boolean> = {
   /**
-   * 表示组件是否为页面,可选,默认false
+   * 表示组件是否为页面,默认false,会引起pageLifetimes类型变化
    */
   isPage?: TIsPage;
 };

package/src/api/RootComponent/Lifetimes/LifetimesConstraint.ts

@@ -1,11 +1,14 @@
+import type { ComputeIntersection } from "hry-types/src/Object/ComputeIntersection";
 import type { WMCompLifetimes } from "../../../types/OfficialTypeAlias";
-import type { FinalOptionsForComponent } from "../../DefineComponent";
+import type { FinalOptionsOfComponent } from "../../DefineComponent";
 
 export type LifetimesConstraint = // 官方组件生命周期
-  & WMCompLifetimes["lifetimes"]
-  & {
-    /**
-     * 建立组件时的真正配置对象
-     */
-    beforeCreate?: (options: FinalOptionsForComponent) => void;
-  };
+  ComputeIntersection<
+    & WMCompLifetimes["lifetimes"]
+    & {
+      /**
+       * 建立组件时的真正配置对象
+       */
+      beforeCreate?: (options: FinalOptionsOfComponent) => void;
+    }
+  >;

package/src/api/RootComponent/Lifetimes/LifetimesOption.ts

@@ -2,6 +2,32 @@ import type { LifetimesConstraint } from "./LifetimesConstraint";
 
 export type LifetimesOption<TIsPage extends boolean> = TIsPage extends false // 组件开通lifetimes字段
   ? {
+    /**
+     * 在原生类型上增加了beforeCreate周期
+     * @example
+     * ```ts
+     * RootComponent()({
+     *  lifetimes: {
+     *    beforeCreate(opitons) {
+     *      opitons;//为最终进入Component的配置对象
+     *    },
+     *    created() {
+     *    },
+     *    attached() {
+     *    },
+     *    ready() {
+     *    },
+     *    detached() {
+     *    },
+     *    error(err) {
+     *      err.cause;
+     *    },
+     *    moved() {
+     *    },
+     *  },
+     * });
+     * ```
+     */
     lifetimes?: LifetimesConstraint;
   }
   // 页面关闭lifetimes字段(其实也可以开启)

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

@@ -1,33 +1,23 @@
 import { RootComponent } from "../..";
-/**
- *  1 组件时(无ispage字段或为false),
- */
+
 RootComponent()({
   lifetimes: {
     beforeCreate() {},
-
     created() {},
-
     attached() {},
-
     ready() {},
-
     detached() {},
-
     error(err) {
       err.cause;
     },
     moved() {},
-    // @ts-expect-error  错误的声明周期字段报错
+    // @ts-expect-error  1 错误的声明周期字段报错
     xxx() {},
   },
 });
 
-/**
- *  2. 页面时 不开启lifetimes字段
- */
 RootComponent()({
   isPage: true,
-  // @ts-expect-error 页面时未开启此字段
+  // @ts-expect-error 2 页面时未开启此字段
   lifetimes: {},
 });

package/src/api/RootComponent/Lifetimes/test/normal.test.ts

@@ -5,7 +5,7 @@ import { RootComponent } from "../../../..";
  */
 RootComponent()({
   lifetimes: {
-    // 新增声明周期用于查看实例初始化之前的配置文件
+    // 新增声明周期可用于查看或拓展配置文件
     beforeCreate(opitons) {
       opitons;
     },

package/src/api/RootComponent/Methods/MethodsOption.ts

@@ -6,6 +6,9 @@ export type MethodsOption<
   TMethods extends MethodsConstraint,
   DuplicateField extends PropertyKey,
 > = {
+  /**
+   * 与customEvents和events字段重复检测
+   */
   methods?:
     & TMethods
     & V.DuplicateFieldValidator<TMethods, DuplicateField>;