annil 1.1.0 → 1.1.2

package/src/api/DefineComponent/collectOptionsForComponent.ts

@@ -16,7 +16,7 @@ import type {
 import type { EventsConstraint } from "../RootComponent/Events/EventsConstraint";
 import type { PageInstance } from "../RootComponent/Instance/RootComponentInstance";
 import type { SubComponentTrueOptions } from "../SubComponent";
-import type { FinalOptionsForComponent, FuncOptions } from ".";
+import type { FinalOptionsOfComponent, FuncOptions } from ".";
 /**
  * 针对通过 navigateTo传过来的数据解析
  * @param option - option中的url是拼接了encodeURIComponent转码的data对象的,key为INNERMARKER.url
@@ -49,7 +49,7 @@ function onLoadReceivedDataHandle(
  */
 /* istanbul ignore next */
 function onLoadHijack(
-  options: FinalOptionsForComponent,
+  options: FinalOptionsOfComponent,
   before: Func[],
   after: Func[] = [],
 ) {
@@ -70,18 +70,47 @@ function onLoadHijack(
     });
   };
 }
+/**
+ * attached生命周期劫持函数
+ */
+/* istanbul ignore next  */
+function attachedHijack(
+  options: FinalOptionsOfComponent,
+  before: Func[],
+  after: Func[] = [],
+) {
+  /* istanbul ignore next */
+  options.lifetimes ||= {};
+
+  const originalAttached: Func | undefined = options.lifetimes.attached;
+
+  options.lifetimes.attached = function() {
+    before.forEach((func) => {
+      func.call(this, options);
+    });
+
+    originalAttached?.call(this);
+
+    /* istanbul ignore next  */
+    after.forEach((func) => {
+      func.call(this, options);
+    });
+  };
+}
 /**
  * 内部保护字段 即不允许配置的字段名(所有方法下)
  */
-const INNERFIELDS = ["disposer"];
+// const INNERFIELDS = ["disposer"];
 
 /**
  * 报错的形式避免输入字段和内部字段冲突
+ * 保护config下不被配置keys包含的内部预定字段
  */
 /* istanbul ignore next */
-function InternalFieldProtection(methodsConfig: object) {
-  const methodsConfigKeys = Object.keys(methodsConfig);
-  for (const key of INNERFIELDS) {
+function InternalFieldProtection(config: object | undefined, keys: string[]) {
+  if (!config) return;
+  const methodsConfigKeys = Object.keys(config);
+  for (const key of keys) {
     if (methodsConfigKeys.includes(key)) {
       throw Error(`${key}已被内部字段占用`);
     }
@@ -99,7 +128,7 @@ function _funcConfigHandle(methodsConfig: object, configList: Record<string, Fun
 }
 
 function funcConfigHandle(
-  finalOptionsForComponent: FinalOptionsForComponent,
+  finalOptionsForComponent: FinalOptionsOfComponent,
   isPage: boolean | undefined,
   funcOptions: FuncOptions,
 ) {
@@ -138,7 +167,7 @@ function funcFieldsCollect(
 
 // 其他字段加入到componentOptions对应字段配置中
 function otherFieldsHandle(
-  finalOptions: FinalOptionsForComponent,
+  finalOptions: FinalOptionsOfComponent,
   rootComponentOptions: RootComponentTrueOptions,
 ) {
   for (const key in rootComponentOptions) {
@@ -155,14 +184,14 @@ function otherFieldsHandle(
 /**
  * 把events字段配置变成函数放入到componentOptions.methods中
  */
-function eventsHandle(componentOptions: FinalOptionsForComponent, eventsConfig: EventsConstraint) {
+function eventsHandle(componentOptions: FinalOptionsOfComponent, eventsConfig: EventsConstraint) {
   /* istanbul ignore next */
   componentOptions.methods ||= {};
 
   Object.assign(componentOptions.methods, eventsConfig);
 }
 function subComponentsHandle(
-  componentOptions: FinalOptionsForComponent,
+  componentOptions: FinalOptionsOfComponent,
   subComponents: SubComponentTrueOptions[],
   funcOptions: FuncOptions,
 ) {
@@ -186,7 +215,7 @@ function IsFullCustomEvents(
  * 把customEvents字段配置变成函数放入到componentOptions.methods中
  */
 function customEventsHandle(
-  componentOptions: FinalOptionsForComponent,
+  componentOptions: FinalOptionsOfComponent,
   customEventsConfig: CustomEventConstraint,
 ) {
   /* istanbul ignore next */
@@ -206,7 +235,49 @@ function customEventsHandle(
     }
   }
 }
+/**
+ *  触发各个组件的页面load事件
+ */
+/* istanbul ignore next  */
+function triggerCompLoad(this: Instance, props: object) {
+  if (!this.__compLoadList__) return;
+  this.__compLoadList__.forEach((loadFunc) => {
+    loadFunc(props);
+  });
+}
+/* istanbul ignore next  */
+function getPageInstance(pageId: string): Instance {
+  const pagestack = getCurrentPages() as unknown as Instance[];
+  let pageInstance: Instance;
+  pagestack.some((instance) => {
+    if (instance.getPageId() === pageId) {
+      pageInstance = instance;
+
+      return true;
+    }
+
+    return false;
+  });
+
+  // @ts-ignore pagestack中一定赋值了
+  return pageInstance;
+}
+/**
+ * 收集组件pageLifetimes下的load周期函数到页面实例的__loadFunList__
+ */
+/* istanbul ignore next  */
+function collectLoadLifetimesOfComponent(this: Instance, finalOptionsForComponent: FinalOptionsOfComponent) {
+  const loadFunc = finalOptionsForComponent.pageLifetimes?.load;
+
+  console.log(loadFunc, finalOptionsForComponent);
 
+  if (!loadFunc) return;
+
+  const pageInstance = getPageInstance(this.getPageId());
+  const __compLoadList__: Function[] = (pageInstance.__compLoadList__ ||= []);
+
+  __compLoadList__.push(loadFunc.bind(this));
+}
 /**
  * 收集 rootComponentOptions 配置到 finalOptions 和 funcOptions 中
  * @param finalOptions - 收集配置对象
@@ -214,10 +285,18 @@ function customEventsHandle(
  * @param rootComponentOptions - 被收集的源配置对象
  */
 function collectRootComponentOption(
-  finalOptions: FinalOptionsForComponent,
+  finalOptions: FinalOptionsOfComponent,
   funcOptions: FuncOptions,
   rootComponentOptions: RootComponentTrueOptions,
 ) {
+  console.log("-------------------------");
+
+  InternalFieldProtection(rootComponentOptions.customEvents, ["load"]);
+
+  InternalFieldProtection(rootComponentOptions.methods, ["load"]);
+
+  InternalFieldProtection(rootComponentOptions.events, ["load"]);
+
   rootComponentOptions.customEvents && customEventsHandle(finalOptions, rootComponentOptions.customEvents);
 
   delete rootComponentOptions.customEvents;
@@ -239,8 +318,8 @@ function collectRootComponentOption(
 export function collectOptionsForComponent(
   rootComponentOption: RootComponentTrueOptions | undefined,
   subComponentsList: SubComponentTrueOptions[] | undefined,
-): FinalOptionsForComponent {
-  const finalOptionsForComponent: FinalOptionsForComponent = {
+): FinalOptionsOfComponent {
+  const finalOptionsForComponent: FinalOptionsOfComponent = {
     // default options
     options: {
       // addGlobalClass: true,
@@ -273,12 +352,16 @@ export function collectOptionsForComponent(
     funcConfigHandle(finalOptionsForComponent, rootComponentOption?.isPage, funcOptions);
   }
 
-  finalOptionsForComponent.methods && InternalFieldProtection(finalOptionsForComponent.methods);
+  finalOptionsForComponent.methods && InternalFieldProtection(finalOptionsForComponent.methods, ["disposer"]);
 
   // BBeforeCreate在最后面
   finalOptionsForComponent.behaviors!.push(BBeforeCreate);
 
-  onLoadHijack(finalOptionsForComponent, [onLoadReceivedDataHandle, initComputed], []);
+  console.log(finalOptionsForComponent, 999, funcOptions);
+
+  attachedHijack(finalOptionsForComponent, [collectLoadLifetimesOfComponent], []);
+
+  onLoadHijack(finalOptionsForComponent, [onLoadReceivedDataHandle, initComputed], [triggerCompLoad]);
 
   // 框架无法测试页面
   /* istanbul ignore next */

package/src/api/DefineComponent/index.ts

@@ -54,7 +54,7 @@ export type FuncOptions = Record<"pageLifetimes" | "lifetimes" | "watch", Record
 /**
  * 最终传入原生Component的配置项
  */
-export type FinalOptionsForComponent = {
+export type FinalOptionsOfComponent = {
   isPage?: boolean;
   options?: WMComponent.Options;
   properties?: Record<string, any>;
@@ -66,7 +66,7 @@ export type FinalOptionsForComponent = {
   methods?: Record<string, Func> & { __storeConfig__?: Func };
   watch?: Record<string, Func>;
   lifetimes?: LifetimesConstraint;
-  pageLifetimes?: Partial<WMCompPageLifetimes & { load: Func } & WMPageLifetimes>;
+  pageLifetimes?: Partial<WMCompPageLifetimes & { load: (prop: unknown) => void } & WMPageLifetimes>;
 };
 
 export const DefineComponent: DefineComponentConstructor = function(options): any {

package/src/api/RootComponent/Computed/ComputedOption.ts

@@ -2,11 +2,31 @@ import type { DuplicateFieldValidator } from "hry-types/src/Generic/DuplicateFie
 
 import type { ComputedConstraint } from "./ComputedConstraint";
 
-export type ComputedOption<TComputed extends ComputedConstraint, OtherData extends object> = {
+export type ComputedOption<TComputed extends ComputedConstraint, CompareKeys extends PropertyKey> = {
   /**
-   * 计算属性字段,可通过this.data获取其他数据
+   * 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
-    & DuplicateFieldValidator<TComputed, keyof OtherData>;
+    & DuplicateFieldValidator<TComputed, CompareKeys>;
 };

package/src/api/RootComponent/Computed/GetComputedDoc.ts

@@ -5,6 +5,4 @@ import type { ComputedConstraint } from "./ComputedConstraint";
  * @param T - ComputedConstraint
  * @returns object
  */
-export type GetComputedDoc<TComputed extends ComputedConstraint> = TComputed extends unknown
-  ? { [k in keyof TComputed]: ReturnType<TComputed[k]> }
-  : never;
+export type GetComputedDoc<TComputed extends ComputedConstraint> = { [k in keyof TComputed]: ReturnType<TComputed[k]> };

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

@@ -1,12 +1,8 @@
 import { Checking, type Test } from "hry-types";
 import type { ReadonlyDeep } from "hry-types/src/Any/_api";
-import type { DetailedType } from "../../../../types/DetailedType";
 import { RootComponent } from "../..";
 import type { Mock_User } from "../../Properties/test/normalRequired.test";
 
-/**
- * computed字段约束为 [ComputedConstraint](../ComputedConstraint.ts)
- */
 const RootDoc = RootComponent()({
   properties: {
     firstName: String,
@@ -14,10 +10,13 @@ const RootDoc = RootComponent()({
   data: {
     lastName: "lastName",
   },
+  store: {
+    prefix: () => "hry-", // 模拟而已
+  },
   computed: {
     fullName() {
-      // 1 计算属性字段可以通过this.data 引用properties、data
-      return this.data.firstName + this.data.lastName;
+      // 1 计算属性字段可以通过this.data 引用properties、data、store字段
+      return this.data.prefix + this.data.firstName + this.data.lastName;
     },
     user() {
       return {} as Mock_User;
@@ -35,12 +34,16 @@ const RootDoc = RootComponent()({
           lastName: string;
           fullName: string;
           user: Mock_User;
+          prefix: string;
           id_fullName: string;
           readOnly: "str";
         }>,
         Test.Pass
       >;
 
+      // @ts-expect-error  深度只读 不可赋值
+      this.data.user.id = "xxx";
+
       return "str";
     },
   },
@@ -84,16 +87,3 @@ const EmptyComputedFieldDoc = RootComponent()({
 });
 
 Checking<typeof EmptyComputedFieldDoc, { methods: { M1: () => void } }, Test.Pass>;
-
-RootComponent()({
-  isPage: true,
-  properties: {
-    obj: Object as DetailedType<{ name: string; age: number }>,
-  },
-  computed: {
-    age() {
-      // 页面实例对象不添加Null,因为计算属性初始化在onLoad之后(即properties已传入时,且不会传入Null)
-      return this.data.obj.age;
-    },
-  },
-});

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为空对象时