annil 1.7.4 → 1.7.5-beta.4

package/dist/api/InstanceInject/instanceConfig.d.ts

@@ -6,6 +6,7 @@ import type { DataConstraint } from "../RootComponent/Data/DataConstraint";
 import type { MethodsConstraint } from "../RootComponent/Methods/MethodsConstraint";
 import type { StoreConstraint } from "../RootComponent/Store/StoreConstraint";
 interface BaseInjectInfo {
+    [key: string]: unknown;
     options?: WMComponentOption;
     methods?: MethodsConstraint;
     data?: DataConstraint;
@@ -18,6 +19,9 @@ export type IInjectAllData = IfEquals<{}, injectData & IInjectStore, {}, Compute
 type injectData = DataConstraint extends IInjectInfo["data"] ? {} : IInjectInfo["data"];
 export type IInjectStore = StoreConstraint extends IInjectInfo["store"] ? {} : ReturnTypeInObject<IInjectInfo["store"]>;
 export type IInjectMethods = IInjectInfo["methods"];
+/**
+ * 实例配置接口
+ */
 declare class InstanceConfig {
     private info;
     get injectInfo(): IInjectInfo | undefined;

package/dist/api/InstanceInject/instanceConfig.js

@@ -1,3 +1,6 @@
+/**
+ * 实例配置接口
+ */
 class InstanceConfig {
     constructor() {
         this.info = {};
@@ -6,7 +9,8 @@ class InstanceConfig {
         return this.info.injectInfo;
     }
     setInjectInfo(info) {
-        info && (this.info.injectInfo = info);
+        if (info)
+            this.info.injectInfo = info;
     }
 }
 export const instanceConfig = new InstanceConfig();

package/dist/api/InstanceInject/instanceConfig.js.map

@@ -1 +1 @@
-{"version":3,"file":"instanceConfig.js","sourceRoot":"","sources":["../../../src/api/InstanceInject/instanceConfig.ts"],"names":[],"mappings":"AAwCA,MAAM,cAAc;IAApB;QACU,SAAI,GAAiC,EAAE,CAAC;IAOlD,CAAC;IANC,IAAW,UAAU;QACnB,OAAO,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC;IAC9B,CAAC;IACM,aAAa,CAAC,IAA6B;QAChD,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC;IACxC,CAAC;CACF;AAED,MAAM,CAAC,MAAM,cAAc,GAAG,IAAI,cAAc,EAAE,CAAC"}
+{"version":3,"file":"instanceConfig.js","sourceRoot":"","sources":["../../../src/api/InstanceInject/instanceConfig.ts"],"names":[],"mappings":"AAmCA;;GAEG;AACH,MAAM,cAAc;IAApB;QACU,SAAI,GAAiC,EAAE,CAAC;IAOlD,CAAC;IANC,IAAW,UAAU;QACnB,OAAO,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC;IAC9B,CAAC;IACM,aAAa,CAAC,IAA6B;QAChD,IAAI,IAAI;YAAE,IAAI,CAAC,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;IACxC,CAAC;CACF;AAED,MAAM,CAAC,MAAM,cAAc,GAAG,IAAI,cAAc,EAAE,CAAC"}

package/dist/api/RootComponent/Computed/ComputedConstraint.d.ts

@@ -1 +1,4 @@
-export type ComputedConstraint = Record<string, () => any>;
+/**
+ * RootComponent API Computed 字段约束
+ */
+export type ComputedConstraint = Record<string, () => void>;

package/dist/api/RootComponent/Computed/ComputedOption.d.ts

@@ -1,5 +1,28 @@
 import type { DuplicateFieldValidator } from "hry-types/src/Generic/DuplicateFieldValidator";
 import type { ComputedConstraint } from "./ComputedConstraint";
 export type ComputedOption<TComputed extends ComputedConstraint, CompareKeys extends PropertyKey, Instance extends object> = {
+    /**
+     * computed字段, [类型约束ComputedConstraint](ComputedConstraint.ts)
+     * @remarks
+     *
+     * 函数体内,可通过this.data获取实例其他数据(依赖),setData发生时,若数据(依赖)发生变化则重新运行函数体并setData。
+     *
+     * 带重复字段检测(与properties、data、store字段比较)
+     *
+     * @example
+     *
+     * ```ts
+     * {
+     *  data:{
+     *     count:1
+     *  },
+     *  computed:{
+     *     return this.data.count + 1
+     *  }
+  
+     * }
+     *
+     * ```
+     */
     computed?: TComputed & ThisType<Instance> & DuplicateFieldValidator<TComputed, CompareKeys>;
 };

package/dist/api/RootComponent/Computed/GetComputedDoc.d.ts

@@ -1,4 +1,9 @@
 import type { ComputedConstraint } from "./ComputedConstraint";
+/**
+ * 获取computed字段文档类型
+ * @param T - ComputedConstraint
+ * @returns object
+ */
 export type GetComputedDoc<TComputed extends ComputedConstraint> = {
     [k in keyof TComputed]: ReturnType<TComputed[k]>;
 };

package/dist/api/RootComponent/CustomEvents/CustomEventConstraint.d.ts

@@ -27,6 +27,9 @@ export type BubblesComposedOption = BubblesConfig & ComposedCongifg & NonCapture
 export type CaptureComposedOption = CaptureConfig & ComposedCongifg & NonBubblesConfig;
 export type BubblesCaptureComposedOption = BubblesConfig & ComposedCongifg & CaptureConfig;
 export type OptionsFieldsConfigOfCustomEvents = BubblesOption | CaptureOption | BubblesCaptureOption | BubblesComposedOption | CaptureComposedOption | BubblesCaptureComposedOption;
+/**
+ * 带options的CustomEvents配置
+ */
 export type FullCustomEvents = {
     detail: ShortCustomeEvents;
     options: OptionsFieldsConfigOfCustomEvents;

package/dist/api/RootComponent/CustomEvents/CustomEventsOption.d.ts

@@ -1,5 +1,34 @@
 import type { G } from "hry-types";
 import type { CustomEventConstraint } from "./CustomEventConstraint";
 export type CustomEventsOption<TCustomEvents extends CustomEventConstraint, EventsKeys extends PropertyKey> = {
+    /**
+     * 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,
+     *      },
+     *    },
+     *  },
+     *  methods: {
+     *    M1() {
+     *      // 调用自定义事件
+     *      this.A(123);
+     *      this.B("femal");
+     *      this.C("string");
+     *    },
+     *  },
+     * },
+     * ```
+     */
     customEvents?: TCustomEvents & G.IllegalFieldValidator<TCustomEvents, "bubbles" | "composed" | "capturePhase", 1, "options"> & G.DuplicateFieldValidator<TCustomEvents, EventsKeys, "与events字段重复">;
 };

package/dist/api/RootComponent/CustomEvents/GetCustomEventDoc.d.ts

@@ -4,6 +4,19 @@ import type { CustomEventConstraint, FullCustomEvents, ShortCustomeEvents, Simpl
 import type { AddTagForCustomEventsDoc } from "./CustomEventsTag";
 export type GetShortCustomEventsDoc<T extends ShortCustomeEvents> = T extends DetailedType ? InferDetailedType<T> : T extends null ? null : T extends undefined ? undefined : T extends SimpleCustomeEventsList ? GetShortCustomEventsDoc<T[number]> : never;
 export type GetFullCustomEventsDoc<T extends FullCustomEvents> = GetShortCustomEventsDoc<T["detail"]> | AddTagForCustomEventsDoc<T["options"]>;
+/**
+ * 获取自定义事件的文档
+ * demo
+ * ```ts
+ * customEvents:{
+ *   a:Number,
+ *   b:{ detail: String,options:{ bubbles:true } }
+ *   c:{ detail: Number,options:{ bubbles:true, composed:true } }
+ * }
+ * //result => {a:number,b:string|()=>'bubbles',c:number | ()=>'composed' }
+ * ```
+ * @returns object
+ */
 export type GetCustomEventDoc<T extends CustomEventConstraint> = {
     [k in keyof T]: T[k] extends ShortCustomeEvents ? GetShortCustomEventsDoc<T[k]> : GetShortCustomEventsDoc<T[k]["detail"]> | AddTagForCustomEventsDoc<T[k]["options"]>;
 };

package/dist/api/RootComponent/Data/DataOption.d.ts

@@ -1,4 +1,18 @@
 import type { G } from "hry-types";
 export type DataOption<TData extends object, PropertiesKeys extends PropertyKey> = {
+    /**
+     * 定义实例基本数据,默认下划线(`_`)开头的为内部数据,不会被渲染
+     * @remarks 与properties字段重复校验
+     * @example
+     * ```ts
+     * {
+     *   //...
+     *   data:{
+     *      num:123,
+     *      _str:'string' //不会被渲染的内部数据
+     *   }
+     * }
+     * ```
+     */
     data?: TData & G.DuplicateFieldValidator<TData, PropertiesKeys, "与properties字段重复">;
 };

package/dist/api/RootComponent/Events/EventsConstraint.d.ts

@@ -11,7 +11,10 @@ type TransformCustomEventsDocTypeToFunctionTypeAndAddSuffix<T extends CustomEven
     [k in keyof T as _AddSuffixForKey<k & string, Extract<T[k], CustomEventsTags>>]?: (detail: Detail<Exclude<T[k], CustomEventsTags>>) => void;
 };
 type GetAllSubCustomEventsConstraint<ComponentDocList extends ComponentDoc[], AllCustomEvents extends CustomEventsDoc = GetBubblesOrCaptureEventsFromCompDoc<ComponentDocList>> = IfExtends<{}, AllCustomEvents, BaseEvent, TransformCustomEventsDocTypeToFunctionTypeAndAddSuffix<AllCustomEvents>>;
-type BaseEvent = Record<string, (e: WMBaseEvent) => any>;
+type BaseEvent = Record<string, (e: WMBaseEvent) => unknown>;
+/**
+ * events字段约束 由自身事件和冒泡的子组件事件组成。带前缀是子组件事件,带后缀(_catch)表示阻止冒泡
+ */
 export type EventsConstraint<ComponentDocList extends ComponentDoc[] = []> = IfExtends<[
 ], ComponentDocList, BaseEvent, GetAllSubCustomEventsConstraint<ComponentDocList>>;
 export {};

package/dist/api/RootComponent/Events/EventsOption.d.ts

@@ -1,3 +1,55 @@
 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/dist/api/RootComponent/Instance/CustomSetData.d.ts

@@ -2,6 +2,12 @@ import type { O } from "hry-types";
 import type { IfExtends } from "hry-types/src/Any/IfExtends";
 import type { EmptyObject } from "hry-types/src/Misc/EmptyObject";
 import type { AddSubObjectKey } from "hry-types/src/Object/AddSubObjectKey";
+/**
+ * 重写实例的setData类型
+ */
 export type CustomSetData<TData extends object> = {
+    /**
+     * setData只可以对自身data中非响应式数据字段进行设置
+     */
     setData(options: IfExtends<{}, TData, EmptyObject, O.ComputeIntersectionDeep<Partial<AddSubObjectKey<TData>>>>, callback?: () => void): void;
 };

package/dist/api/RootComponent/Instance/RootComponentInstance.d.ts

@@ -1,9 +1,11 @@
 import type { IfExtends } from "hry-types/src/Any/IfExtends";
 import type { ComputeIntersection } from "hry-types/src/Object/ComputeIntersection";
 import type { IReactionDisposer } from "mobx";
+import type { Func } from "hry-types/src/Misc/Func";
 import type { Assign } from "../../../types/Assign";
 import type { ComputeObject } from "../../../types/ComputeObj";
 import type { WMComponentInstance, WMInstanceMethods, WMPageInstance } from "../../../types/OfficialTypeAlias";
+import type { OptionsInnerFields } from "../../DefineComponent/normalizeOptions";
 import type { IInjectAllData, IInjectMethods } from "../../InstanceInject/instanceConfig";
 import type { CustomEventMethods } from "./CustomEventMethods";
 import type { CustomSetData } from "./CustomSetData";
@@ -16,3 +18,10 @@ export type RootComponentInstance<TIsPage extends boolean, TMethods extends obje
 };
 export type ComponentInstance = RootComponentInstance<false, {}, {}, {}, {}, {}>;
 export type PageInstance = RootComponentInstance<true, {}, {}, {}, {}, {}>;
+type InstanceInnerFields = {
+    data: OptionsInnerFields["data"];
+    disposer: Record<string, Func>;
+    cloneData: OptionsInnerFields["data"];
+} & OptionsInnerFields["methods"];
+export type Instance = (ComponentInstance | PageInstance) & InstanceInnerFields;
+export {};

package/dist/api/RootComponent/IsPage/IsPageOption.d.ts

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

package/dist/api/RootComponent/Lifetimes/LifetimesConstraint.d.ts

@@ -1,6 +1,9 @@
 import type { ComputeIntersection } from "hry-types/src/Object/ComputeIntersection";
 import type { WMCompLifetimes } from "../../../types/OfficialTypeAlias";
-import type { FinalOptionsOfComponent } from "../../DefineComponent/assignOptions";
+import type { FinalOptionsOfComponent } from "../../DefineComponent/normalizeOptions";
 export type LifetimesConstraint = ComputeIntersection<WMCompLifetimes["lifetimes"] & {
-    beforeCreate?: (this: void, options: FinalOptionsOfComponent) => void;
+    /**
+     * 建立组件时的真正配置对象
+     */
+    beforeCreate?: (this: undefined, options: FinalOptionsOfComponent) => void;
 }>;

package/dist/api/RootComponent/Lifetimes/LifetimesOption.d.ts

@@ -1,4 +1,30 @@
 import type { LifetimesConstraint } from "./LifetimesConstraint";
 export type LifetimesOption = {
+    /**
+     * 在原生类型上增加了beforeCreate周期
+     * @example
+     * ```ts
+     * RootComponent()({
+     *  lifetimes: {
+     *    beforeCreate(opitons) {
+     *      opitons;//为最终进入Component的配置对象
+     *    },
+     *    created() {
+     *    },
+     *    attached() {
+     *    },
+     *    ready() {
+     *    },
+     *    detached() {
+     *    },
+     *    error(err) {
+     *      err.cause;
+     *    },
+     *    moved() {
+     *    },
+     *  },
+     * });
+     * ```
+     */
     lifetimes?: LifetimesConstraint;
 };

package/dist/api/RootComponent/Methods/MethodsOption.d.ts

@@ -1,5 +1,8 @@
 import type { G } from "hry-types";
 import type { MethodsConstraint } from "./MethodsConstraint";
 export type MethodsOption<TMethods extends MethodsConstraint, DuplicateField extends PropertyKey> = {
+    /**
+     * 与customEvents和events字段重复检测
+     */
     methods?: TMethods & G.DuplicateFieldValidator<TMethods, DuplicateField>;
 };

package/dist/api/RootComponent/Observers/ObserversOption.d.ts

@@ -10,6 +10,10 @@ type AddFieldsOfObject<TWatchData extends object, _WatchKeys extends keyof TWatc
     [k in secondKeys]?: (newValue: IfExtends<getLastKeys<k>, "**", TWatchData[getFirstKeys<k>], NonNullable<(Exclude<TWatchData[getFirstKeys<k>], null>)[getLastKeys<k>]>>) => void;
 };
 export type ObserversOption<TWatchData extends object, _WatchKeys extends keyof TWatchData = keyof TWatchData> = {
+    /**
+     * 监控所有data字段,值变化时(JSON.stringify判断)运行watch函数,一参为最新值,二参为变化前值。
+     * 对象数据可通过`obj.xxx:`监控具体字段(只加入了一级字段类型提示)
+     */
     observers?: IfExtends<{}, TWatchData, EmptyObject, NoInfer<{
         [k in _WatchKeys | "**"]?: (newValue: k extends keyof TWatchData ? TWatchData[k] : unknown) => void;
     } & {

package/dist/api/RootComponent/PageLifetimes/PageLifetimesOption.d.ts

@@ -3,10 +3,21 @@ import type { ComputeIntersection } from "hry-types/src/Object/ComputeIntersecti
 import type { WMCompPageLifetimes, WMPageLifetimes } from "../../../types/OfficialTypeAlias";
 export type PageLifetimesOption<TIsPage extends boolean, PropertiesDoc extends object> = IfExtends<TIsPage, false, {
     pageLifetimes?: ComputeIntersection<Partial<WMCompPageLifetimes> & {
+        /**
+         * 周期发生在组件attached之后,页面onLoad之前,要求组件为同步组件
+         * 最低基础库： `3.0.2`
+         */
         load?: (props?: object) => void;
     }>;
 }, {
+    /**
+     * 官方要求写入methods中的页面生命周期
+     */
     pageLifetimes?: ComputeIntersection<Partial<Omit<WMPageLifetimes, "onLoad">> & {
+        /** 生命周期回调—监听页面加载
+         *
+         * 页面加载时触发。一个页面只会调用一次，可以在 onLoad 的参数中获取Properties定义的数据。
+         */
         onLoad?: (props: PropertiesDoc) => void | Promise<void>;
     }>;
 }>;

package/dist/api/RootComponent/Properties/GetOptionalDoc.d.ts

@@ -2,6 +2,9 @@ import type { IfExtends } from "hry-types/src/Any/IfExtends";
 import type { AddNullForObject } from "../../../types/AddNullForObject";
 import type { InferDetailedType } from "../../../types/InferDetailedType";
 import type { OptionalType } from "./PropertiesConstraint";
+/**
+ * 获取properties可传字段文档类型
+ */
 export type GetOptionalDoc<TOptionalProperties extends Record<string, OptionalType>, TIsPage extends boolean> = {
     -readonly [k in keyof TOptionalProperties]?: IfExtends<unknown, TOptionalProperties[k]["optionalTypes"], IfExtends<false, TIsPage, AddNullForObject<InferDetailedType<TOptionalProperties[k]["type"]>>, InferDetailedType<TOptionalProperties[k]["type"]>>, IfExtends<false, TIsPage, AddNullForObject<InferDetailedType<TOptionalProperties[k]["type"]> | InferDetailedType<(TOptionalProperties[k]["optionalTypes"] & {})[number]>>, InferDetailedType<TOptionalProperties[k]["type"]> | InferDetailedType<(TOptionalProperties[k]["optionalTypes"] & {})[number]>>>;
 };

package/dist/api/RootComponent/Properties/GetPropertiesDoc.d.ts

@@ -4,5 +4,8 @@ import type { GetOptionalDoc } from "./GetOptionalDoc";
 import type { GetRequiredDoc } from "./GetRequiredDoc";
 import type { OptionalType, PropertiesConstraint } from "./PropertiesConstraint";
 type _GetPropertiesDoc<TProperties extends PropertiesConstraint, TIsPage extends boolean, OptionalDoc extends object = GetOptionalDoc<Select<TProperties, OptionalType>, TIsPage>, RequiredDoc extends object = GetRequiredDoc<Omit<TProperties, keyof OptionalDoc>, TIsPage>> = ComputeIntersection<OptionalDoc & RequiredDoc>;
+/**
+ * properties字段的文档类型
+ */
 export type GetPropertiesDoc<TProperties extends PropertiesConstraint, TisPage extends boolean> = _GetPropertiesDoc<TProperties, TisPage>;
 export {};

package/dist/api/RootComponent/Properties/GetRequiredDoc.d.ts

@@ -2,6 +2,10 @@ import type { IfExtends } from "hry-types/src/Any/IfExtends";
 import type { AddNullForObject } from "../../../types/AddNullForObject";
 import type { InferDetailedType } from "../../../types/InferDetailedType";
 import type { RequiredSingle, RequiredType } from "./PropertiesConstraint";
+/**
+ * 获取properties必传字段的文档类型
+ * @remarks 小程序中必传字段如果是object,默认类型为null,所以组件文档对象类型要联合上null类型
+ */
 export type GetRequiredDoc<TProperties extends Record<string, RequiredType>, TIsPage extends boolean> = {
     -readonly [k in keyof TProperties]: IfExtends<TProperties[k], RequiredSingle, IfExtends<false, TIsPage, AddNullForObject<InferDetailedType<TProperties[k]>>, InferDetailedType<TProperties[k]>>, IfExtends<false, TIsPage, AddNullForObject<InferDetailedType<TProperties[k]["type"]> | InferDetailedType<TProperties[k]["optionalTypes"][number]>>, InferDetailedType<TProperties[k]["type"]> | InferDetailedType<TProperties[k]["optionalTypes"][number]>>>;
 };

package/dist/api/RootComponent/Properties/PropertiesConstraint.d.ts

@@ -1,14 +1,32 @@
 import type { DetailedType } from "../../../types/DetailedType";
+/**
+ * properties 必传(单一)类型
+ */
 export type RequiredSingle = DetailedType;
+/**
+ * properties 必传(联合)类型
+ */
 export type RequiredUnion = {
     type: DetailedType;
     optionalTypes: DetailedType[];
 };
+/**
+ * properties 必传类型
+ */
 export type RequiredType = RequiredUnion | RequiredSingle;
+/**
+ * properties 选传类型
+ */
 export type OptionalType = {
     type: DetailedType;
     value: unknown;
     optionalTypes?: DetailedType[];
 };
+/**
+ * Properties 字段类型
+ */
 export type PropertiesTypes = OptionalType | RequiredType;
+/**
+ * RootComponent API properties 字段约束
+ */
 export type PropertiesConstraint = Record<string, PropertiesTypes>;

package/dist/api/RootComponent/Properties/PropertiesOption.d.ts

@@ -3,6 +3,16 @@ import type { Validators } from "../../../types/Validators";
 import type { PropertiesConstraint } from "./PropertiesConstraint";
 import type { PropertiesValueValidator } from "./PropertiesValueValidator";
 export type PropertiesOption<TProperties extends PropertiesConstraint> = {
+    /**
+     * 可通过 as DetailedType<anyType> 书写任意类型
+     * @remarks
+     *
+     * 禁用observable字段(watch代替)
+     *
+     * 简写或对象写法(无value字段)时为必传属性(组件时必传对象实际类型加入null,页面不加),对象写法有value字段为可选属性.
+     *
+     * 有value类型检测和非法字段检测(例如value写出values)
+     */
     properties?: TProperties & Validators<[
         PropertiesValueValidator<TProperties>,
         G.IllegalFieldValidator<TProperties, "value" | "type" | "optionalTypes", 1>

package/dist/api/RootComponent/Properties/PropertiesValueValidator.d.ts

@@ -1,6 +1,10 @@
 import type { EmptyObject } from "hry-types/src/Misc/EmptyObject";
 import type { NonReadonly } from "hry-types/src/Object/NonReadonly";
 import type { InferDetailedType } from "../../../types/InferDetailedType";
+/**
+ * 验证properties的value类型是否正确
+ * @returns unknown | `{ value: () => "⚠️类型错误⚠️" }`
+ */
 export type PropertiesValueValidator<TProperties, Result = {
     [k in keyof TProperties as TProperties[k] extends {
         type: infer R;

package/dist/api/RootComponent/RootComponentDoc.d.ts

@@ -18,5 +18,24 @@ type _RootComponentDoc = {
     export?: () => void;
 };
 type _Validator<O, Doc, ErrKeys = Exclude<keyof O, keyof Doc>> = [ErrKeys] extends [never] ? Doc : `错误的字段${ErrKeys & string}`;
+/**
+ * RootComponent Api 返回的类型
+ * ```ts
+ * isPage?: boolean;
+ * properties?: object;
+ * data?: object;
+ * computed?: object;
+ * customEvents?: object;
+ * methods?: object;
+ * events?: object;
+ * store?: object;
+ * watch?: Record<string, AnyFunction>;
+ * lifetimes?: LifetimesConstraint;
+ * pageLifetimes?: Partial<WMCompPageLifetimes & { load: AnyFunction }> | Partial<WMPageLifetimes>;
+ * export?:AnyFunction
+ * externalClasses?: string[];
+ * };
+ * ```
+ */
 export type RootComponentDoc<O extends _Validator<O, _RootComponentDoc> = _RootComponentDoc> = O;
 export {};

package/dist/api/RootComponent/Store/StoreOption.d.ts

@@ -1,5 +1,17 @@
 import type { G } from "hry-types";
 import type { StoreConstraint } from "./StoreConstraint";
 export type StoreOption<TStore extends StoreConstraint, TDuplicateKeys extends PropertyKey> = {
+    /**
+     * 全局响应式数据字段,全局store对应数据变化实例对应数据自动setData。与properties和data字段有重复检测
+     * @example
+     * ```ts
+     * {
+     *   //...
+     *   store: {
+     *     responsiveData: () => sroreX.str,
+     *   },
+     * }
+     * ```
+     */
     store?: TStore & G.DuplicateFieldValidator<TStore, TDuplicateKeys, "字段重复">;
 };

package/dist/api/RootComponent/Watch/WatchOption.d.ts

@@ -10,6 +10,10 @@ type AddFieldsOfObject<TWatchData extends object, _WatchKeys extends keyof TWatc
     [k in secondKeys]?: (newValue: IfExtends<getLastKeys<k>, "**", Exclude<TWatchData[getFirstKeys<k>], null>, NonNullable<(Exclude<TWatchData[getFirstKeys<k>], null>)[getLastKeys<k>]>>, oldValue: IfExtends<getLastKeys<k>, "**", TWatchData[getFirstKeys<k>], (Exclude<TWatchData[getFirstKeys<k>], null>)[getLastKeys<k>]>) => void;
 };
 export type WatchOption<TWatchData extends object, _WatchKeys extends keyof TWatchData = keyof TWatchData> = {
+    /**
+     * 监控所有data字段,值变化时(JSON.stringify判断)运行watch函数,一参为最新值,二参为变化前值。
+     * 对象数据可通过`obj.xxx:`监控具体字段(只加入了一级字段类型提示)
+     */
     watch?: IfExtends<{}, TWatchData, EmptyObject, NoInfer<{
         [k in _WatchKeys]?: (newValue: Exclude<TWatchData[k], null>, oldValue: TWatchData[k]) => void;
     } & {

package/dist/api/RootComponent/index.d.ts

@@ -34,25 +34,23 @@ import type { WatchOption } from "./Watch/WatchOption";
 type RootComponentOptions<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> & EventsOption<TEvents> & CustomEventsOption<TCustomEvents, keyof EventsDoc> & DataOption<TData, keyof PropertiesDoc> & StoreOption<TStore, keyof (PropertiesDoc & DataDoc)> & ComputedOption<TComputed, keyof (PropertiesDoc & DataDoc & StoreDoc), {
     data: ComputeObject<DataDoc & Required<PropertiesDoc> & StoreDoc & ComputedDoc & IInjectAllData>;
 }> & PageLifetimesOption<TIsPage, PropertiesDoc> & LifetimesOption & WatchOption<ComputedDoc & Required<PropertiesDoc> & DataDoc & StoreDoc & IInjectStore> & Partial<Omit<WMCompOtherOption, "pageLifetimes" | "definitionFilter" | "observers">> & ObserversOption<ComputedDoc & Required<PropertiesDoc> & DataDoc & StoreDoc & IInjectStore> & ThisType<RootComponentInstance<TIsPage, TMethods, DataDoc, DataDoc & Required<PropertiesDoc> & StoreDoc & ComputedDoc, CustomEventsDoc, StoreDoc>>;
-type RootComponentConstructor<TComponentDocList extends ComponentDoc[]> = {
-    <TEvents extends EventsConstraint<TComponentDocList>, TIsPage extends boolean = false, const TProperties extends PropertiesConstraint = {}, TData extends object = {}, TStore extends StoreConstraint = {}, TComputed extends ComputedConstraint = {}, TCustomEvents extends IfExtends<TIsPage, false, CustomEventConstraint, EmptyObject> = {}, TMethods extends MethodsConstraint = {}, EventsDoc extends object = IfExtends<EventsConstraint<TComponentDocList>, 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<TEvents, TIsPage, TCustomEvents, TMethods, TProperties, TData, TStore, TComputed, EventsDoc, CustomEventsDoc, PropertiesDoc, DataDoc, StoreDoc, ComputedDoc>): ComputeIntersection<IfExtends<TIsPage, false, {}, {
-        isPage: true;
-    }> & IfExtends<EmptyObject, PropertiesDoc, {}, {
-        properties: PropertiesDoc;
-    }> & IfExtends<EmptyObject, DataDoc, {}, {
-        data: DataDoc;
-    }> & IfExtends<EmptyObject, StoreDoc, {}, {
-        store: ComputeObject<StoreDoc>;
-    }> & IfExtends<EmptyObject, ComputedDoc, {}, {
-        computed: ComputedDoc;
-    }> & IfExtends<EmptyObject, TMethods, {}, {
-        methods: TMethods;
-    }> & IfExtends<EmptyObject, EventsDoc, {}, {
-        events: EventsDoc;
-    }> & IfExtends<EmptyObject, CustomEventsDoc, {}, {
-        customEvents: ComputeObject<CustomEventsDoc>;
-    }>>;
-};
+type RootComponentConstructor<TComponentDocList extends ComponentDoc[]> = <TEvents extends EventsConstraint<TComponentDocList>, TIsPage extends boolean = false, const TProperties extends PropertiesConstraint = {}, TData extends object = {}, TStore extends StoreConstraint = {}, TComputed extends ComputedConstraint = {}, TCustomEvents extends IfExtends<TIsPage, false, CustomEventConstraint, EmptyObject> = {}, TMethods extends MethodsConstraint = {}, EventsDoc extends object = IfExtends<EventsConstraint<TComponentDocList>, 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<TEvents, TIsPage, TCustomEvents, TMethods, TProperties, TData, TStore, TComputed, EventsDoc, CustomEventsDoc, PropertiesDoc, DataDoc, StoreDoc, ComputedDoc>) => ComputeIntersection<IfExtends<TIsPage, false, {}, {
+    isPage: true;
+}> & IfExtends<EmptyObject, PropertiesDoc, {}, {
+    properties: PropertiesDoc;
+}> & IfExtends<EmptyObject, DataDoc, {}, {
+    data: DataDoc;
+}> & IfExtends<EmptyObject, StoreDoc, {}, {
+    store: ComputeObject<StoreDoc>;
+}> & IfExtends<EmptyObject, ComputedDoc, {}, {
+    computed: ComputedDoc;
+}> & IfExtends<EmptyObject, TMethods, {}, {
+    methods: TMethods;
+}> & IfExtends<EmptyObject, EventsDoc, {}, {
+    events: EventsDoc;
+}> & IfExtends<EmptyObject, CustomEventsDoc, {}, {
+    customEvents: ComputeObject<CustomEventsDoc>;
+}>>;
 export declare function RootComponent<TComponentDocList extends ComponentDoc[] = []>(): RootComponentConstructor<TComponentDocList>;
 export type RootComponentTrueOptions = {
     isPage?: boolean;

package/dist/api/RootComponent/index.js

@@ -1,4 +1,5 @@
 export function RootComponent() {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     return (options) => options;
 }
 //# sourceMappingURL=index.js.map

package/dist/api/RootComponent/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/api/RootComponent/index.ts"],"names":[],"mappings":"AA2IA,MAAM,UAAU,aAAa;IAM3B,OAAO,CAAC,OAAY,EAAE,EAAE,CAAC,OAAO,CAAC;AACnC,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/api/RootComponent/index.ts"],"names":[],"mappings":"AAyIA,MAAM,UAAU,aAAa;IAM3B,8DAA8D;IAC9D,OAAO,CAAC,OAAY,EAAE,EAAE,CAAC,OAAO,CAAC;AACnC,CAAC"}

package/dist/api/SubComponent/SubComponentDoc.d.ts

@@ -4,5 +4,14 @@ 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;
 export {};

package/dist/api/SubComponent/SubData/SubDataConstraint.d.ts

@@ -1,3 +1,7 @@
+/**
+ * 子组件Data字段约束
+ * @returns 当剩余对象不为空对象,约束对象的key为剩余key,类型为剩余key对应的文档类型.
+ */
 export type SubDataConstraint<TComponentDoc extends object> = {
     [k in keyof TComponentDoc]?: TComponentDoc[k];
 };

package/dist/api/SubComponent/SubData/SubDataOption.d.ts

@@ -1,4 +1,8 @@
 import type { G } from "hry-types";
 export type SubDataOption<TSubData extends object, legalKeys extends PropertyKey> = {
+    /**
+     * 可写子组件所需数据和内部公共数据
+     * 非法字段检测和与Inherit字段的重复检测
+     */
     data?: TSubData & G.IllegalFieldValidator<TSubData, legalKeys, 0, "", "子组件无需此字段或与Inherit字段重复">;
 };