annil 1.0.1 → 1.0.5

package/src/api/DefineComponent/collectOptionsForComponent.ts

@@ -0,0 +1,290 @@
+import type { Func } from "hry-types/src/Misc/_api";
+import { BBeforeCreate } from "../../behaviors/BbeforeCreated";
+import { BComputedAndWatch } from "../../behaviors/BComputedAndWatch";
+import { initComputed } from "../../behaviors/BComputedAndWatch/initComputed";
+import type { Instance } from "../../behaviors/BComputedAndWatch/types";
+import { BStore } from "../../behaviors/BStore";
+import { deepClone } from "../../utils/deepClone";
+import { INNERMARKER } from "../../utils/InnerMarker";
+import { isEmptyObject } from "../../utils/isEmptyObject";
+import type { RootComponentTrueOptions } from "../RootComponent";
+import type {
+  CustomEventConstraint,
+  CustomEvents,
+  FullCustomEvents,
+} from "../RootComponent/CustomEvents/CustomEventConstraint";
+import type { EventsConstraint } from "../RootComponent/Events/EventsConstraint";
+import type { PageInstance } from "../RootComponent/Instance/RootComponentInstance";
+import type { SubComponentTrueOptions } from "../SubComponent";
+import type { FinalOptionsForComponent, FuncOptions } from ".";
+/**
+ * 针对通过 navigateTo传过来的数据解析
+ * @param option - option中的url是拼接了encodeURIComponent转码的data对象的,key为INNERMARKER.url
+ */
+/* istanbul ignore next */
+function onLoadReceivedDataHandle(
+  this: PageInstance,
+  option: Record<typeof INNERMARKER.url, string>,
+) {
+  const innerData: string | undefined = option[INNERMARKER.url];
+  // 未使用自定义的navigateTo
+  if (innerData === undefined) return;
+  const optionData = JSON.parse(decodeURIComponent(innerData));
+
+  // 使用navigateTo
+  for (const key in optionData) {
+    option[key] = optionData[key];
+  }
+
+  // setData会触发计算属性 继承属性等 。
+  this.setData(option as any);
+
+  delete option[INNERMARKER.url];
+
+  Reflect.deleteProperty(this.data, INNERMARKER.url);
+}
+
+/**
+ * onLoad生命周期劫持函数
+ */
+/* istanbul ignore next */
+function onLoadHijack(
+  options: FinalOptionsForComponent,
+  before: Func[],
+  after: Func[] = [],
+) {
+  options.methods ||= {};
+
+  const cloneOpt = deepClone(options);
+  const originalOnLoad: Func | undefined = options.methods.onLoad;
+
+  options.methods.onLoad = function(props: unknown) {
+    before.forEach((func) => {
+      func.call(this, props, cloneOpt);
+    });
+
+    originalOnLoad?.call(this, props);
+
+    after.forEach((func) => {
+      func.call(this, props, cloneOpt);
+    });
+  };
+}
+/**
+ * 内部保护字段 即不允许配置的字段名(所有方法下)
+ */
+const INNERFIELDS = ["disposer"];
+
+/**
+ * 报错的形式避免输入字段和内部字段冲突
+ */
+/* istanbul ignore next */
+function InternalFieldProtection(methodsConfig: object) {
+  const methodsConfigKeys = Object.keys(methodsConfig);
+  for (const key of INNERFIELDS) {
+    if (methodsConfigKeys.includes(key)) {
+      throw Error(`${key}已被内部字段占用`);
+    }
+  }
+}
+/**
+ * 把函数配置放入一个配置中依次运行
+ */
+function _funcConfigHandle(methodsConfig: object, configList: Record<string, Func[]>) {
+  for (const key in configList) {
+    methodsConfig[key] = function(...args: unknown[]) {
+      configList[key].forEach(ele => ele.call(this, ...args));
+    };
+  }
+}
+
+function funcConfigHandle(
+  finalOptionsForComponent: FinalOptionsForComponent,
+  isPage: boolean | undefined,
+  funcOptions: FuncOptions,
+) {
+  // 测试框架无法测试page情形
+  /* istanbul ignore next */
+  if (isPage) {
+    // 页面时 生命周期方法(即 on 开头的方法),(https://developers.weixin.qq.com/miniprogram/dev/framework/custom-component/component.html)
+    funcOptions.pageLifetimes && _funcConfigHandle(finalOptionsForComponent.methods ||= {}, funcOptions.pageLifetimes);
+  } else {
+    // 组件时
+    funcOptions.pageLifetimes
+      && _funcConfigHandle(finalOptionsForComponent.pageLifetimes ||= {}, funcOptions.pageLifetimes);
+  }
+  funcOptions.lifetimes && _funcConfigHandle(finalOptionsForComponent.lifetimes ||= {}, funcOptions.lifetimes);
+
+  funcOptions.watch && _funcConfigHandle(finalOptionsForComponent.watch ||= {}, funcOptions.watch);
+}
+/**
+ * 把配置为函数的字段方法收集到funcConfig中
+ */
+function funcFieldsCollect(
+  options: SubComponentTrueOptions | RootComponentTrueOptions,
+  funcOptions: FuncOptions,
+) {
+  for (const key in funcOptions) {
+    // key = "pageLifetimes" | "lifetimes" | "watch"
+    if (options[key]) {
+      for (const _key in options[key]) {
+        (funcOptions[key][_key] ||= []).push(options[key][_key]);
+      }
+    }
+
+    Reflect.deleteProperty(options, key);
+  }
+}
+
+// 其他字段加入到componentOptions对应字段配置中
+function otherFieldsHandle(
+  finalOptions: FinalOptionsForComponent,
+  rootComponentOptions: RootComponentTrueOptions,
+) {
+  for (const key in rootComponentOptions) {
+    const config = rootComponentOptions[key];
+    if (Array.isArray(config)) {
+      // 好像只有behaviors是数组吧.
+      /* istanbul ignore next */
+      (finalOptions[key] ||= []).push(...config);
+    } else {
+      Object.assign(finalOptions[key] ||= {}, config);
+    }
+  }
+}
+/**
+ * 把events字段配置变成函数放入到componentOptions.methods中
+ */
+function eventsHandle(componentOptions: FinalOptionsForComponent, eventsConfig: EventsConstraint) {
+  /* istanbul ignore next */
+  componentOptions.methods ||= {};
+
+  Object.assign(componentOptions.methods, eventsConfig);
+}
+function subComponentsHandle(
+  componentOptions: FinalOptionsForComponent,
+  subComponents: SubComponentTrueOptions[],
+  funcOptions: FuncOptions,
+) {
+  subComponents.forEach((subOption) => {
+    subOption.events && eventsHandle(componentOptions, subOption.events);
+
+    funcFieldsCollect(subOption, funcOptions);
+
+    otherFieldsHandle(componentOptions, subOption);
+  });
+}
+
+// 类型守卫
+function IsFullCustomEvents(
+  customEventOptions: CustomEvents,
+): customEventOptions is FullCustomEvents {
+  return Object.prototype.toString.call(customEventOptions) === "[object Object]";
+}
+
+/**
+ * 把customEvents字段配置变成函数放入到componentOptions.methods中
+ */
+function customEventsHandle(
+  componentOptions: FinalOptionsForComponent,
+  customEventsConfig: CustomEventConstraint,
+) {
+  /* istanbul ignore next */
+  componentOptions.methods ||= {};
+
+  for (const key in customEventsConfig) {
+    const customEventOptions = customEventsConfig[key];
+
+    if (IsFullCustomEvents(customEventOptions)) {
+      componentOptions.methods[key] = function(this: Instance, detail: unknown) {
+        this.triggerEvent(key, detail, customEventOptions.options);
+      };
+    } else {
+      componentOptions.methods[key] = function(this: Instance, detail: unknown) {
+        this.triggerEvent(key, detail);
+      };
+    }
+  }
+}
+
+/**
+ * 收集 rootComponentOptions 配置到 finalOptions 和 funcOptions 中
+ * @param finalOptions - 收集配置对象
+ * @param funcOptions  - 收集特殊配置对象字段
+ * @param rootComponentOptions - 被收集的源配置对象
+ */
+function collectRootComponentOption(
+  finalOptions: FinalOptionsForComponent,
+  funcOptions: FuncOptions,
+  rootComponentOptions: RootComponentTrueOptions,
+) {
+  rootComponentOptions.customEvents && customEventsHandle(finalOptions, rootComponentOptions.customEvents);
+
+  delete rootComponentOptions.customEvents;
+
+  rootComponentOptions.events && eventsHandle(finalOptions, rootComponentOptions.events);
+
+  delete rootComponentOptions.events;
+
+  funcFieldsCollect(rootComponentOptions, funcOptions);
+
+  otherFieldsHandle(finalOptions, rootComponentOptions);
+}
+/**
+ * 返回一个由rootComponentOption和subComponentsList配置整合的对象
+ * @param rootComponentOption -
+ * @param subComponentsList -
+ * @returns FinalOptionsForComponent
+ */
+export function collectOptionsForComponent(
+  rootComponentOption: RootComponentTrueOptions | undefined,
+  subComponentsList: SubComponentTrueOptions[] | undefined,
+): FinalOptionsForComponent {
+  const finalOptionsForComponent: FinalOptionsForComponent = {
+    // default options
+    options: {
+      // addGlobalClass: true,
+      multipleSlots: true,
+      pureDataPattern: /^_/,
+      virtualHost: true,
+    },
+    // default behaviors
+    behaviors: [BStore, BComputedAndWatch],
+  };
+  /**
+   * 有些字段配置同时存在根组件和子组件当中(如pageLifetimes，lifetimes,watch字段), 且key相同值类型为函数。funcConfig对象用于收集这些配置为数组形式,最终再一起整合进finalOptionsForComponent配置中。即funcConfig是一个临时中介对象。
+   */
+  const funcOptions: FuncOptions = {
+    pageLifetimes: {},
+    lifetimes: {},
+    watch: {},
+  };
+
+  if (rootComponentOption && !isEmptyObject(rootComponentOption)) {
+    collectRootComponentOption(finalOptionsForComponent, funcOptions, rootComponentOption);
+  }
+
+  if (subComponentsList && !isEmptyObject(subComponentsList)) {
+    subComponentsHandle(finalOptionsForComponent, subComponentsList, funcOptions);
+  }
+  // 框架无法测试页面
+  /* istanbul ignore next */
+  if (!isEmptyObject(funcOptions)) {
+    funcConfigHandle(finalOptionsForComponent, rootComponentOption?.isPage, funcOptions);
+  }
+
+  finalOptionsForComponent.methods && InternalFieldProtection(finalOptionsForComponent.methods);
+
+  // BBeforeCreate在最后面
+  finalOptionsForComponent.behaviors!.push(BBeforeCreate);
+
+  onLoadHijack(finalOptionsForComponent, [onLoadReceivedDataHandle, initComputed], []);
+
+  // 框架无法测试页面
+  /* istanbul ignore next */
+  if (finalOptionsForComponent.isPage) {
+    Reflect.deleteProperty(finalOptionsForComponent.options!, "virtualHost");
+  }
+
+  return finalOptionsForComponent;
+}

package/src/api/DefineComponent/index.ts

@@ -1,15 +1,7 @@
 import type { IfExtends } from "hry-types/src/Any/IfExtends";
 import type { Func } from "hry-types/src/Misc/Func";
-import { BBeforeCreate } from "../../behaviors/BbeforeCreated";
-import { BComputedAndWatch } from "../../behaviors/BComputedAndWatch";
-import { initComputed } from "../../behaviors/BComputedAndWatch/initComputed";
-import { BStore } from "../../behaviors/BStore";
 import type { WMComponent, WMCompPageLifetimes, WMPageLifetimes } from "../../types/OfficialTypeAlias";
-import { funcConfigHandle } from "../../utils/funcConfigHandle";
-import { isEmptyObject } from "../../utils/isEmptyObject";
-import { onLoadReceivedDataHandle } from "../../utils/onLoadReceivedDataHandle";
-import { rootComponentFieldHandle } from "../../utils/rootComponentFieldHandle";
-import { subComponentsHandle } from "../../utils/subComponentsHandle";
+
 import type { LifetimesConstraint } from "../RootComponent/Lifetimes/LifetimesConstraint";
 import type { RootComponentDoc } from "../RootComponent/RootComponentDoc";
 import type { SubComponentDoc } from "../SubComponent/SubComponentDoc";
@@ -19,8 +11,10 @@ import type { CreatePageDoc } from "./ReturnType/CreatePageDoc";
 import type { RootComponentOption } from "./RootComponent/RootComponentOption";
 import type { SubComponentsOption } from "./SubComponents/SubComponentsOption";
 
-import { InternalFieldProtection } from "../../utils/InternalFieldProtection";
-import { onLoadHijack } from "../../utils/onLoadHijack";
+import type { RootComponentTrueOptions } from "../RootComponent";
+import { collectOptionsForComponent } from "./collectOptionsForComponent";
+
+type Path = `/${string}`;
 
 type RootOptions<
   TRootComponentDoc extends RootComponentDoc,
@@ -55,19 +49,15 @@ interface DefineComponentConstructor {
  * 临时的函数配置项
  * 把根组件与子组件中配置类型为函数的相同字段配置收集在一起(数组)
  */
-export type FuncConfig = {
-  pageLifetimes?: Record<string, Func[]>;
-  lifetimes?: Record<string, Func[]>;
-  watch?: Record<string, Func[]>;
-};
+export type FuncOptions = Record<"pageLifetimes" | "lifetimes" | "watch", Record<string, Func[]>>;
 
 /**
- * 传入原生Component的配置项
+ * 最终传入原生Component的配置项
  */
-export type ComponentOptions = {
+export type FinalOptionsForComponent = {
   isPage?: boolean;
   options?: WMComponent.Options;
-  properties?: object;
+  properties?: Record<string, any>;
   data?: object;
   store?: object;
   computed?: Record<string, Func>;
@@ -79,71 +69,8 @@ export type ComponentOptions = {
   pageLifetimes?: Partial<WMCompPageLifetimes & { load: Func } & WMPageLifetimes>;
 };
 
-export type Path = `/${string}`;
-
-export type DefineComponentOptions = {
-  path?: Path;
-  name?: string;
-  rootComponent?: RootComponentDoc;
-  subComponents?: SubComponentDoc[];
-};
-
 export const DefineComponent: DefineComponentConstructor = function(options): any {
-  // console.log("------------------------------------------------分割线------------------------------------------------");
-
-  // 最终的配置,默认配置与根组件和子组件列表配置汇集而成。
-  const finalOptions: ComponentOptions = {
-    // default options
-    options: {
-      // addGlobalClass: true,
-      multipleSlots: true,
-      pureDataPattern: /^_/,
-      virtualHost: true,
-    },
-    // default behaviors
-    behaviors: [BStore, BComputedAndWatch],
-  };
-  /**
-   * 有些选项配置是函数,且可能分布在根组件和子组件中,funcConfig 用于收集这些配置,最终再一起整合进finalOptions配置。rootComponentHandle和subComponentsHandle都会收集函数配置到funcConfig中，再由funcConfigHandle整合配置到finalOptions中。
-   */
-  const allFuncConfig: FuncConfig = {};
-
-  if (options.rootComponent && !isEmptyObject(options.rootComponent)) {
-    rootComponentFieldHandle(options.rootComponent, finalOptions, allFuncConfig);
-  }
-
-  if (options.subComponents && !isEmptyObject(options.subComponents)) {
-    subComponentsHandle(finalOptions, options.subComponents, allFuncConfig);
-  }
-  // 框架无法测试页面
-  /* istanbul ignore next */
-  if (!isEmptyObject(allFuncConfig)) {
-    funcConfigHandle(finalOptions, options.rootComponent?.isPage, allFuncConfig);
-  }
-
-  finalOptions.methods && InternalFieldProtection(finalOptions.methods);
-
-  finalOptions.behaviors!.push(BBeforeCreate);
-
-  onLoadHijack(finalOptions, [onLoadReceivedDataHandle, initComputed], []);
-
-  // 框架无法测试页面
-  /* istanbul ignore next */
-  if (finalOptions.isPage) {
-    Reflect.deleteProperty(finalOptions.options!, "virtualHost");
-  }
-
-  Component(finalOptions as any);
-};
-
-export type PageOptions = {
-  path: Path;
-  rootComponent: RootComponentDoc & { isPage: true };
-  subComponents: SubComponentDoc[];
-};
-
-export type CompOptions = {
-  name: string;
-  rootComponent: RootComponentDoc & { isPage: undefined };
-  subComponents: SubComponentDoc[];
+  Component(
+    collectOptionsForComponent(options.rootComponent as RootComponentTrueOptions | undefined, options.subComponents),
+  );
 };

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

@@ -1,6 +1,6 @@
 import { Checking, type Test } from "hry-types";
 import type { ReadonlyDeep } from "hry-types/src/Any/_api";
-import type { SpecificType } from "../../../../types/SpecificType";
+import type { DetailedType } from "../../../../types/DetailedType";
 import { RootComponent } from "../..";
 import type { Mock_User } from "../../Properties/test/normalRequired.test";
 
@@ -88,7 +88,7 @@ Checking<typeof EmptyComputedFieldDoc, { methods: { M1: () => void } }, Test.Pas
 RootComponent()({
   isPage: true,
   properties: {
-    obj: Object as SpecificType<{ name: string; age: number }>,
+    obj: Object as DetailedType<{ name: string; age: number }>,
   },
   computed: {
     age() {

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

@@ -1,6 +1,6 @@
-import type { SpecificType } from "../../../types/SpecificType";
+import type { DetailedType } from "../../../types/DetailedType";
 
-type SimpleCustomeEvents = SpecificType | null;
+type SimpleCustomeEvents = DetailedType | null;
 
 export type SimpleCustomeEventsList = SimpleCustomeEvents[];
 
@@ -43,8 +43,10 @@ export type OptionsFieldsConfigOfCustomEvents =
  * 带options的CustomEvents配置
  */
 export type FullCustomEvents = {
-  detailType: ShortCustomeEvents;
+  detail: ShortCustomeEvents;
   options: OptionsFieldsConfigOfCustomEvents;
 };
 
-export type CustomEventConstraint = Record<string, FullCustomEvents | ShortCustomeEvents>;
+export type CustomEvents = FullCustomEvents | ShortCustomeEvents;
+
+export type CustomEventConstraint = Record<string, CustomEvents>;

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

@@ -17,9 +17,9 @@ export type CustomEventsOption<
    *   // ...
    *   customEvents: {
    *     A: Number, // number
-   *     B: [String as SpecificType<"male" | "femal">, Number], // "male" | "femal" | number
+   *     B: [String as DetailedType<"male" | "femal">, Number], // "male" | "femal" | number
    *     C: {
-   *       detailType: String,
+   *       detail: String,
    *       options: {
    *         bubbles: true,
    *         composed: true,

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

@@ -1,5 +1,5 @@
-import type { InferSpecificType } from "../../../types/InferSpecificType";
-import type { SpecificType } from "../../../types/SpecificType";
+import type { DetailedType } from "../../../types/DetailedType";
+import type { InferDetailedType } from "../../../types/InferDetailedType";
 import type {
   CustomEventConstraint,
   FullCustomEvents,
@@ -8,13 +8,13 @@ import type {
 } from "./CustomEventConstraint";
 import type { AddTagForCustomEventsDoc } from "./CustomEventsTag";
 
-export type GetShortCustomEventsDoc<T extends ShortCustomeEvents> = T extends SpecificType ? InferSpecificType<T>
+export type GetShortCustomEventsDoc<T extends ShortCustomeEvents> = T extends DetailedType ? InferDetailedType<T>
   : T extends null ? null
   : T extends SimpleCustomeEventsList ? GetShortCustomEventsDoc<T[number]>
   : never;
 
 export type GetFullCustomEventsDoc<T extends FullCustomEvents> =
-  | GetShortCustomEventsDoc<T["detailType"]>
+  | GetShortCustomEventsDoc<T["detail"]>
   | AddTagForCustomEventsDoc<T["options"]>;
 
 /**
@@ -23,8 +23,8 @@ export type GetFullCustomEventsDoc<T extends FullCustomEvents> =
  * ```ts
  * customEvents:{
  *   a:Number,
- *   b:{ detailType: String,options:{ bubbles:true } }
- *   c:{ detailType: Number,options:{ bubbles:true, composed:true } }
+ *   b:{ detail: String,options:{ bubbles:true } }
+ *   c:{ detail: Number,options:{ bubbles:true, composed:true } }
  * }
  * //result => {a:number,b:string|()=>'bubbles',c:number | ()=>'composed' }
  * ```
@@ -36,7 +36,7 @@ export type GetCustomEventDoc<T extends CustomEventConstraint> =
     [k in keyof T]: T[k] extends ShortCustomeEvents ? GetShortCustomEventsDoc<T[k]>  
     // 应该写GetFullCustomEventsDoc<T[k]>带鼠标悬停时不是计算结果。所以代码重复了。
       : // @ts-ignore T[k] 一定为 FullCustomEvents 类型
-        | GetShortCustomEventsDoc<T[k]["detailType"]>
+        | GetShortCustomEventsDoc<T[k]["detail"]>
         // 为自定义事件模型加标记,方便识别
         // @ts-ignore T[k] 一定为 FullCustomEvents 类型
         | AddTagForCustomEventsDoc<T[k]["options"]>;

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

@@ -7,26 +7,26 @@ RootComponent()({
   customEvents: {
     // @ts-expect-error options 没有options字段时无需写对象形式,应简写`error1:Boolean`。
     error1: {
-      detailType: Boolean,
+      detail: Boolean,
     },
     // @ts-expect-error options 不可以为空对象 无意义
     error2: {
-      detailType: Boolean,
+      detail: Boolean,
       options: {},
     },
     // @ts-expect-error false字段不要写 默认就为false
     error3: {
-      detailType: Boolean,
+      detail: Boolean,
       options: { bubbles: false },
     },
     // @ts-expect-error false 字段不要写 默认false
     error4: {
-      detailType: Boolean,
+      detail: Boolean,
       options: { capturePhase: false },
     },
     // @ts-expect-error composed字段不可以单独开启,必须存在 bubbles或capturePhase字段为true时
     error5: {
-      detailType: Boolean,
+      detail: Boolean,
       options: { composed: true },
     },
   },
@@ -53,7 +53,7 @@ RootComponent()({
 RootComponent()({
   customEvents: {
     error1: {
-      detailType: String,
+      detail: String,
       options: {
         bubbles: true,
         // @ts-expect-error 非法字段  composed 少了d
@@ -69,7 +69,7 @@ RootComponent()({
 RootComponent()({
   customEvents: {
     error2: {
-      detailType: String,
+      detail: String,
       options: {
         bubbles: true,
         // @ts-expect-error 非法字段  capturePhases 多了 s
@@ -90,7 +90,7 @@ RootComponent()({
   },
   customEvents: {
     bbb: {
-      detailType: null,
+      detail: null,
       options: {
         // @ts-expect-error 非法字段
         bubbleds: false,

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

@@ -1,5 +1,5 @@
 import { Checking, type Test } from "hry-types";
-import { RootComponent, type SpecificType } from "../../../..";
+import { type DetailedType, RootComponent } from "../../../..";
 import type { CustomEventConstraint, FullCustomEvents, ShortCustomeEvents } from "../CustomEventConstraint";
 import type {
   Bubbles,
@@ -16,8 +16,8 @@ import type {
 export const mock_shortCustomEvents = {
   str: String,
   null: null,
-  unionStr: String as SpecificType<"male" | "female">,
-  union: [String, Number as SpecificType<0 | 1 | 2>, null],
+  unionStr: String as DetailedType<"male" | "female">,
+  union: [String, Number as DetailedType<0 | 1 | 2>, null],
 } satisfies Record<string, ShortCustomeEvents>;
 
 /**
@@ -25,27 +25,27 @@ export const mock_shortCustomEvents = {
  */
 export const mock_fullCustomEvents = {
   bubbles: {
-    detailType: String,
+    detail: String,
     options: { bubbles: true },
   },
   capturePhase: {
-    detailType: null,
+    detail: null,
     options: { capturePhase: true },
   },
   bubbles_capturePhase: {
-    detailType: [String, Number],
+    detail: [String, Number],
     options: { bubbles: true, capturePhase: true },
   },
   bubbles_composed: {
-    detailType: String as SpecificType<"male" | "female">,
+    detail: String as DetailedType<"male" | "female">,
     options: { bubbles: true, composed: true },
   },
   capturePhase_composed: {
-    detailType: [String, Number as SpecificType<0 | 1 | 2>, null],
+    detail: [String, Number as DetailedType<0 | 1 | 2>, null],
     options: { capturePhase: true, composed: true },
   },
   bubbles_capturePhase_composed: {
-    detailType: Boolean,
+    detail: Boolean,
     options: { bubbles: true, capturePhase: true, composed: true },
   },
 } satisfies Record<string, FullCustomEvents>;

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

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

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

@@ -46,7 +46,7 @@ type TransformCustomEventsDocTypeToFunctionTypeAndAddSuffix<T extends CustomEven
   ) => void;
 };
 
-// 所有子组件自定义事件(过滤掉非冒泡或捕获)的key加入后缀并把值(detailType)转换为函数类型
+// 所有子组件自定义事件(过滤掉非冒泡或捕获)的key加入后缀并把值(detail)转换为函数类型
 type GetAllSubCustomEventsConstraint<TReceivedComponentDoc extends ComponentDoc[] | ComponentDoc> = {} extends
   TReceivedComponentDoc ? {}
   : TReceivedComponentDoc extends ComponentDoc[] ? TransformCustomEventsDocTypeToFunctionTypeAndAddSuffix<