annil 1.7.4 → 1.7.5-beta.4

package/src/api/DefineComponent/{assignOptions → normalizeOptions}/computedWatchHandle/index.ts

@@ -5,19 +5,17 @@ import { getPropertiesValue } from "./getPropertiesValue";
 import { initComputedAndGetCache } from "./initComputedAndGetCache";
 import { isEqual } from "./isEqual";
 
+import { assertNonNullable } from "../../../../utils/assertNonNullable";
 import { deepClone } from "../../../../utils/deepClone";
 import { isEmptyObject } from "../../../../utils/isEmptyObject";
-import type { FinalOptionsOfComponent, Instance } from "..";
+import type { Instance } from "../../../RootComponent/Instance/RootComponentInstance";
+import type { FinalOptionsOfComponent } from "..";
 
 type WatchOldValue = Record<string, unknown[]>;
 
 function initWatchOldValue(data: FinalOptionsOfComponent["data"], watchConfig: object): WatchOldValue {
   const watchOldValue = {};
   for (const key in watchConfig) {
-    // watchOldValue[key] = deepClone(getPathsValue(data, key));
-
-    // watchOldValue[key] = getPathsValue(data, key);
-
     // @ts-ignore 隐式索引
     watchOldValue[key] = deepClone(getPathsValue(data, key));
   }
@@ -29,7 +27,7 @@ export function computedWatchHandle(options: FinalOptionsOfComponent) {
   const computedConfig = options.computed;
   const rawPropertiesValue = getPropertiesValue(options.properties);
   if (computedConfig && !isEmptyObject(computedConfig)) {
-    // 此时store已经初始化数据到data了
+    // 此时store已经初始化数据到data了(__storeConfig__)
 
     const __computedInitCache__ = initComputedAndGetCache(options, computedConfig, {
       ...options.data,
@@ -50,7 +48,7 @@ export function computedWatchHandle(options: FinalOptionsOfComponent) {
     // 任何setData都会触发计算属性更新(可能依赖数据并没变化)
     this.__computedUpdater__?.();
 
-    originalFunc && originalFunc.call(this);
+    originalFunc?.call(this);
   };
 
   // watch handle
@@ -68,9 +66,9 @@ export function computedWatchHandle(options: FinalOptionsOfComponent) {
 
       // 在监控多个数据时,参数是多个值
       observersConfig[key] = function(this: Instance, ...newValue: unknown[]) {
-        originObserversHandle && originObserversHandle.call(this, ...newValue);
+        originObserversHandle?.call(this, ...newValue);
 
-        const watchOldValue = this.data.__watchOldValue__!;
+        const watchOldValue = assertNonNullable(this.data.__watchOldValue__);
         const oldValue = watchOldValue[key];
 
         if (isEqual(newValue, oldValue)) return;

package/src/api/DefineComponent/{assignOptions → normalizeOptions}/computedWatchHandle/isEqual.ts

@@ -1,5 +1,3 @@
-/* eslint-disable complexity */
-
 function isSameType(a: object, b: object) {
   return Object.prototype.toString.call(a) === Object.prototype.toString.call(b);
 }
@@ -10,6 +8,7 @@ function isSameSize(a: object, b: object) {
 }
 
 // 定义一个辅助函数，用于判断两个函数的代码是否相同
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
 function isSameCode(a: Function, b: Function) {
   // 去除空格比较函数字符串
   return a.toString().split(" ").join("") === b.toString().split(" ").join("");
@@ -46,6 +45,7 @@ export function isEqual(a: unknown, b: unknown) {
 
   // 如果两个值是函数类型，再判断它们的代码是否相同
   if (typeof a === "function") {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
     return isSameCode(a, b as Function);
   }
 

package/src/api/DefineComponent/normalizeOptions/customEventsHandle.ts

@@ -0,0 +1,34 @@
+import type {
+  CustomEventConstraint,
+  CustomEvents,
+  FullCustomEvents,
+} from "../../RootComponent/CustomEvents/CustomEventConstraint";
+import type { Instance } from "../../RootComponent/Instance/RootComponentInstance";
+import type { FinalOptionsOfComponent } from ".";
+// 类型守卫
+function IsFullCustomEvents(
+  customEventOptions: CustomEvents,
+): customEventOptions is FullCustomEvents {
+  return Object.prototype.toString.call(customEventOptions) === "[object Object]";
+}
+/**
+ * 把customEvents字段配置变成函数放入到componentOptions.methods中
+ */
+export function customEventsHandle(
+  methods: FinalOptionsOfComponent["methods"],
+  customEventsConfig: CustomEventConstraint,
+) {
+  for (const key in customEventsConfig) {
+    const customEventOptions = customEventsConfig[key];
+
+    if (IsFullCustomEvents(customEventOptions)) {
+      methods[key] = function(this: Instance, detail: unknown) {
+        this.triggerEvent(key, detail, customEventOptions.options);
+      };
+    } else {
+      methods[key] = function(this: Instance, detail: unknown) {
+        this.triggerEvent(key, detail);
+      };
+    }
+  }
+}

package/src/api/DefineComponent/normalizeOptions/hijackHandle/index.ts

@@ -0,0 +1,26 @@
+import type { Func } from "hry-types/src/Misc/Func";
+import type { FinalOptionsOfComponent } from "..";
+
+/**
+ * 劫持指定配置字段,在原有配置前执行指定函数
+ */
+export function hijack<T extends FinalOptionsOfComponent[keyof FinalOptionsOfComponent]>(
+  config: T,
+  field: keyof T,
+  before: Func[],
+  // after: Func[] = [],
+) {
+  // @ts-ignore 隐式索引
+  const originalFunc: Func | undefined = config[field];
+
+  // @ts-ignore 隐式索引
+  config[field] = function(...args: unknown[]) {
+    before.forEach(func => func.call(this, ...args));
+
+    if (originalFunc) originalFunc.apply(this, args);
+
+    // after.forEach(func => func.call(this, ...args));
+  };
+
+  return;
+}

package/src/api/DefineComponent/normalizeOptions/hijackHandle/isPageCheck.ts

@@ -0,0 +1,22 @@
+import type { Instance, PageInstance } from "../../../RootComponent/Instance/RootComponentInstance";
+
+/**
+ * 劫持attached,根据this.route做判断 isPage值是否正确
+ */
+export function isPageCheck(isPage: boolean | undefined) {
+  return function(this: Instance) {
+    const route = (this as PageInstance).route as string | undefined;
+    if (route && isPage !== true) {
+      // 页面isPage值错误
+      throw Error(
+        `页面 /${route} 中, RootComponent构建页面时,isPage字段值应为 true`,
+      );
+    }
+    if (!route && isPage !== false && isPage !== undefined) {
+      // 组件写了isPage = true
+      throw Error(
+        `组件 ${this.is} 中  RootComponent构建组件时,可不写isPage字段或值为 false`,
+      );
+    }
+  };
+}

package/src/api/DefineComponent/normalizeOptions/hijackHandle/loadReceivedDataHandle.ts

@@ -0,0 +1,25 @@
+/**
+ * 针对通过 navigateTo传过来的数据对组件load周期传入数据解析
+ * @param option - option中的url是拼接了encodeURIComponent转码的data对象的,key为INNERMARKER.url
+ */
+
+import { INNERMARKER } from "../../../../utils/InnerMarker";
+import type { PageInstance } from "../../../RootComponent/Instance/RootComponentInstance";
+
+/* istanbul ignore next miniprogram-simulate(当前版本 1.6.1) 无法测试load */
+export function loadReceivedDataHandle(
+  this: PageInstance,
+  option: Record<typeof INNERMARKER.url, string>,
+) {
+  const innerData: string | undefined = option[INNERMARKER.url];
+  // 未使用自定义的navigateTo
+  if (innerData === undefined) return;
+  // 使用navigateTo API
+  const decodeOption = JSON.parse(decodeURIComponent(innerData));
+
+  for (const key in decodeOption) {
+    option[key] = decodeOption[key];
+  }
+  // 给onLoad劫持函数一个标记,判断在新框架下已经被解析过了
+  option[INNERMARKER.url] = INNERMARKER.url;
+}

package/src/api/DefineComponent/normalizeOptions/hijackHandle/onLoadReceivedDataHandle.ts

@@ -0,0 +1,33 @@
+/**
+ * 原生Component会对传入的对象字段匹配的properties字段setData赋值。不符合字段或Page时不会赋值。
+ * 此函数为给实例setData赋值,默认传递值与properties相符(ts类型安全)。
+ * @param option - 传入onLoad的参数 有以下两种可能
+ * 1. 使用wx.navigateTo传值的。这种情况无内置字段 option[INNERMARKER.url] 等于 undefined
+ * 2. 使用插件提供的navigateTo传值。这种情况 INNERMARKER.url被load周期劫持函数解码后赋值INNERMARKER.url字段为本身,即option[INNERMARKER.url] 等于 INNERMARKER.url
+ */
+
+import { INNERMARKER } from "../../../../utils/InnerMarker";
+import type { PageInstance } from "../../../RootComponent/Instance/RootComponentInstance";
+
+/* istanbul ignore next miniprogram-simulate(当前版本 1.6.1) 无法测试页面生命周期 */
+export function onLoadReceivedDataHandle(
+  this: PageInstance,
+  option: Record<typeof INNERMARKER.url, string>,
+) {
+  const innerData: string | undefined = option[INNERMARKER.url];
+
+  // 情况1为undefined,2为INNERMARKER.url有值但不是本身,说明是老框架。3所以innerData等于 INNERMARKER.url即有组件配置了load(新框架在pageLifetimes.load中提前解析了)
+  if (innerData === undefined) return;
+  if (innerData !== INNERMARKER.url) {
+    // 需要情况2 需要解析
+    const decodeOption = JSON.parse(decodeURIComponent(innerData));
+    for (const key in decodeOption) {
+      option[key] = decodeOption[key];
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+  delete option[INNERMARKER.url];
+
+  this.setData(option);
+}

package/src/api/DefineComponent/normalizeOptions/index.ts

@@ -0,0 +1,142 @@
+import type { Func } from "hry-types/src/Misc/_api";
+import { instanceConfig } from "../../..";
+import { BBeforeCreate } from "../../../behaviors/BbeforeCreated";
+import { BStore } from "../../../behaviors/BStore";
+import { isEmptyObject } from "../../../utils/isEmptyObject";
+import type { ComputedConstraint } from "../../RootComponent/Computed/ComputedConstraint";
+import type { DataConstraint } from "../../RootComponent/Data/DataConstraint";
+import type { LifetimesConstraint } from "../../RootComponent/Lifetimes/LifetimesConstraint";
+import type { MethodsConstraint } from "../../RootComponent/Methods/MethodsConstraint";
+import type { PageLifetimesOption } from "../../RootComponent/PageLifetimes/PageLifetimesOption";
+import type { PropertiesConstraint } from "../../RootComponent/Properties/PropertiesConstraint";
+import type { StoreConstraint } from "../../RootComponent/Store/StoreConstraint";
+import type { DefineComponentOption } from "..";
+import { computedWatchHandle } from "./computedWatchHandle";
+import type { ComputedCache } from "./computedWatchHandle/initComputedAndGetCache";
+import { hijack } from "./hijackHandle";
+import { isPageCheck } from "./hijackHandle/isPageCheck";
+import { loadReceivedDataHandle } from "./hijackHandle/loadReceivedDataHandle";
+import { onLoadReceivedDataHandle } from "./hijackHandle/onLoadReceivedDataHandle";
+import { initStore } from "./initStore";
+import { injectInfoHandler } from "./injectInfoHandler";
+import { InternalFieldProtection } from "./internalFieldProtection";
+import { rootComponentOptionHandle } from "./rootComponentOptionHandle";
+import { sameFuncOptionsHandle } from "./sameFuncOptionsHandle";
+import { subComponentsOptionHandle } from "./subComponentsOptionHandle";
+
+export type WatchOldValue = Record<string, unknown[]>;
+
+export type OptionsInnerFields = {
+  data: {
+    __computedCache__?: ComputedCache;
+    __storeConfig__?: StoreConstraint;
+    __watchOldValue__?: WatchOldValue;
+  };
+  methods: {
+    disposer?: Record<string, Func>;
+    // computedHandle加入
+    __computedUpdater__?: Func;
+  };
+};
+
+/**
+ * 临时的函数配置项
+ * 把根组件与子组件中配置类型为函数的相同字段配置收集在一起(数组)
+ */
+export type SameFuncOptions = Record<"pageLifetimes" | "lifetimes" | "watch" | "observers", Record<string, Func[]>>;
+
+/**
+ * 最终传入原生Component的配置项
+ */
+export type FinalOptionsOfComponent = {
+  data: DataConstraint & OptionsInnerFields["data"];
+  observers: Record<string, Func>;
+  behaviors: string[];
+  methods: MethodsConstraint & OptionsInnerFields["methods"];
+  externalClasses: string[];
+  pageLifetimes: PageLifetimesOption<false, object>["pageLifetimes"] & {};
+  isPage: boolean;
+  options: WechatMiniprogram.Component.ComponentOptions;
+  properties: PropertiesConstraint;
+  store?: StoreConstraint;
+  computed: ComputedConstraint;
+  watch: Record<string, Func>;
+  lifetimes: LifetimesConstraint;
+};
+/**
+ * 把DefineComponentOption转化为原生Component API支持的配置
+ * @param defineComponentOption
+ * @returns  返回符合原生Component API配置
+ */
+export function normalizeOptions(
+  defineComponentOption: DefineComponentOption,
+): FinalOptionsOfComponent {
+  const rootComponentOption = defineComponentOption.rootComponent;
+  const subComponentsOption = defineComponentOption.subComponents;
+  const finalOptionsForComponent: FinalOptionsOfComponent = injectInfoHandler({
+    observers: {},
+    data: {},
+    methods: {},
+    // 加入BStore,处理store字段的behavior
+    behaviors: [BStore],
+    externalClasses: [],
+    pageLifetimes: {},
+    isPage: false,
+    properties: {},
+    computed: {},
+    watch: {},
+    lifetimes: {},
+    options: {},
+  }, instanceConfig.injectInfo);
+
+  /**
+   * 为了更高的效率,在处理rootComponentOption和subComponentsOption数据时,把相同字段配置(pageLifetimes，lifetimes,watch,observers)收集到funcOptions中。
+   * 后续再一起处理这些字段,整合进finalOptionsForComponent配置中。即funcConfig是一个临时中介对象。
+   */
+  const sameFuncOptions: SameFuncOptions = {
+    pageLifetimes: {},
+    lifetimes: {},
+    watch: {},
+    observers: {},
+  };
+  if (rootComponentOption && !isEmptyObject(rootComponentOption)) {
+    rootComponentOptionHandle(finalOptionsForComponent, sameFuncOptions, rootComponentOption);
+  }
+  if (subComponentsOption && !isEmptyObject(subComponentsOption)) {
+    subComponentsOptionHandle(finalOptionsForComponent, subComponentsOption, sameFuncOptions);
+  }
+  sameFuncOptionsHandle(finalOptionsForComponent, rootComponentOption?.isPage, sameFuncOptions);
+
+  // 配置与内部字段冲突验证
+  InternalFieldProtection(finalOptionsForComponent);
+
+  // 对页面传入参数进行处理 老框架劫持页面methods.onLoad,新框架劫持页面pageLifetimes.load
+  if (finalOptionsForComponent.isPage) {
+    hijack(finalOptionsForComponent.pageLifetimes, "load", [loadReceivedDataHandle]);
+  }
+
+  hijack(finalOptionsForComponent.methods, "onLoad", [onLoadReceivedDataHandle]);
+
+  // 验证isPage字段是否配置正确
+  hijack(
+    finalOptionsForComponent.lifetimes,
+    "attached",
+    [isPageCheck(rootComponentOption?.isPage)],
+  );
+
+  // 页面时删除预设的虚拟组件字段
+  if (finalOptionsForComponent.isPage && finalOptionsForComponent.options) {
+    Reflect.deleteProperty(finalOptionsForComponent.options, "virtualHost");
+  }
+
+  // 初始化store数据到data并把store配置放入到data的__storeConfig__下为后续使用
+  initStore(finalOptionsForComponent);
+
+  // 处理computed和watch配置
+  computedWatchHandle(finalOptionsForComponent);
+
+  // BBeforeCreate在最后面,让BeforeCreate生命周期运行在最终建立组件时。
+  finalOptionsForComponent.behaviors.push(BBeforeCreate);
+
+  return finalOptionsForComponent;
+}

package/src/api/DefineComponent/{assignOptions → normalizeOptions}/initStore/index.ts

@@ -3,6 +3,7 @@ import type { FinalOptionsOfComponent } from "..";
 export function initStore(finalOptionsForComponent: FinalOptionsOfComponent) {
   const storeConfig = finalOptionsForComponent.store;
   if (storeConfig) {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
     const { toJS } = require("mobx") as typeof mobx;
     for (const key in storeConfig) {
       finalOptionsForComponent.data[key] = toJS(storeConfig[key]());

package/src/api/DefineComponent/normalizeOptions/injectInfoHandler.ts

@@ -0,0 +1,51 @@
+import type { IInjectInfo } from "../../..";
+import type { FinalOptionsOfComponent } from ".";
+/**
+ * 把injectInfo字段合并到finalOptionsForComponent
+ * @remarks 规则：
+ * 1. behaviors字段 push
+ * 2. 对象字段 没有的话直接赋值，有的话Object.assign
+ * @param finalOptionsForComponent
+ * @param injectInfo
+ * @returns finalOptionsForComponent
+ */
+function mergeOptions(
+  finalOptionsForComponent: FinalOptionsOfComponent,
+  injectInfo: IInjectInfo,
+): FinalOptionsOfComponent {
+  for (const key in injectInfo) {
+    const injectVal = injectInfo[key];
+    if (key in finalOptionsForComponent) {
+      // @ts-ignore
+      const originalVal = finalOptionsForComponent[key];
+      switch (key) {
+        case "behaviors":
+          {
+            // @ts-ignore behaviors 是数组类型
+            finalOptionsForComponent[key].push(...injectVal);
+          }
+          break;
+
+        default:
+          {
+            // @ts-ignore 覆盖目标
+            finalOptionsForComponent[key] = Object.assign(originalVal, injectVal);
+          }
+          break;
+      }
+    } else {
+      // @ts-ignore
+      finalOptionsForComponent[key] = injectVal;
+    }
+  }
+
+  return finalOptionsForComponent;
+}
+export function injectInfoHandler(
+  finalOptionsForComponent: FinalOptionsOfComponent,
+  injectInfo: IInjectInfo | undefined,
+): FinalOptionsOfComponent {
+  if (!injectInfo) return finalOptionsForComponent;
+
+  return mergeOptions(finalOptionsForComponent, injectInfo);
+}

package/src/api/DefineComponent/normalizeOptions/internalFieldProtection.ts

@@ -0,0 +1,26 @@
+import type { FinalOptionsOfComponent } from ".";
+
+// 内部字段
+const internalFiled = {
+  methods: ["disposer", "__computedUpdater__"],
+  data: ["__computedCache__", "__storeConfig__", "__watchOldValue__"],
+};
+
+/**
+ * 报错的形式避免输入字段和内部字段冲突,保证config下不包含内部预定字段(列表)
+ */
+export function InternalFieldProtection(finalOptionsForComponent: FinalOptionsOfComponent) {
+  const methodsFieldKeys = Object.keys(finalOptionsForComponent.methods);
+  const dataFieldKeys = Object.keys(finalOptionsForComponent.data);
+
+  for (const key of methodsFieldKeys) {
+    if (internalFiled.methods.includes(key)) {
+      throw Error(`methods配置中的${key}字段已被内部字段占用`);
+    }
+  }
+  for (const key of dataFieldKeys) {
+    if (internalFiled.data.includes(key)) {
+      throw Error(`data配置中的${key}字段已被内部字段占用`);
+    }
+  }
+}

package/src/api/DefineComponent/normalizeOptions/otherFieldsHandle.ts

@@ -0,0 +1,27 @@
+import type { RootComponentTrueOptions } from "../../RootComponent";
+import type { FinalOptionsOfComponent } from ".";
+
+/**
+ * 其他字段加入到componentOptions对应字段配置中
+ */
+export function otherFieldsHandle(
+  finalOptions: FinalOptionsOfComponent,
+  rootComponentOptions: RootComponentTrueOptions,
+) {
+  for (const key in rootComponentOptions) {
+    // @ts-ignore 隐式索引
+    const config = rootComponentOptions[key];
+    if (Array.isArray(config) === true) {
+      //  "behaviors" || "externalClasses"是数组
+      // @ts-ignore 只有 behaviors 和 externalClasses, 且都默认为[]
+      finalOptions[key].push(...config);
+    } else if (typeof config === "object") {
+      // @ts-ignore 隐式索引
+      Object.assign(finalOptions[key] ||= {}, config);
+    } else {
+      // 函数字段有 根组件有 `export` 子组件无此字段
+      // @ts-ignore 隐式索引
+      finalOptions[key] = config;
+    }
+  }
+}

package/src/api/DefineComponent/normalizeOptions/rootComponentOptionHandle.ts

@@ -0,0 +1,25 @@
+import type { RootComponentTrueOptions } from "../../RootComponent";
+import type { FinalOptionsOfComponent, SameFuncOptions } from ".";
+import { customEventsHandle } from "./customEventsHandle";
+import { otherFieldsHandle } from "./otherFieldsHandle";
+import { sameFuncFieldsCollect } from "./sameFuncFieldsCollect";
+
+/**
+ * 收集 rootComponentOptions 配置到 finalOptions 和 funcOptions 中
+ * @param finalOptions - 收集配置对象
+ * @param funcOptions  - 收集特殊配置对象字段
+ * @param rootComponentOptions - 被收集的源配置对象
+ */
+export function rootComponentOptionHandle(
+  finalOptions: FinalOptionsOfComponent,
+  funcOptions: SameFuncOptions,
+  rootComponentOptions: RootComponentTrueOptions,
+) {
+  if (rootComponentOptions.customEvents) customEventsHandle(finalOptions.methods, rootComponentOptions.customEvents);
+
+  if (rootComponentOptions.events) Object.assign(finalOptions.methods, rootComponentOptions.events);
+
+  sameFuncFieldsCollect(rootComponentOptions, funcOptions);
+
+  otherFieldsHandle(finalOptions, rootComponentOptions);
+}

package/src/api/DefineComponent/normalizeOptions/sameFuncFieldsCollect.ts

@@ -0,0 +1,22 @@
+import type { RootComponentTrueOptions } from "../../RootComponent";
+import type { SubComponentTrueOptions } from "../../SubComponent";
+import type { SameFuncOptions } from ".";
+
+/**
+ * 把配置为函数的字段方法收集到funcOptions中
+ */
+export function sameFuncFieldsCollect(
+  options: SubComponentTrueOptions | RootComponentTrueOptions,
+  funcOptions: SameFuncOptions,
+) {
+  let key: keyof SameFuncOptions;
+  for (key in funcOptions) {
+    const optionsKeyConfig = options[key];
+    if (optionsKeyConfig) {
+      for (const _key in optionsKeyConfig) {
+        // @ts-ignore
+        (funcOptions[key][_key] ||= []).push(optionsKeyConfig[_key]);
+      }
+    }
+  }
+}

package/src/api/DefineComponent/normalizeOptions/sameFuncOptionsHandle.ts

@@ -0,0 +1,37 @@
+import type { Func } from "hry-types/src/Misc/_api";
+import { isEmptyObject } from "../../../utils/isEmptyObject";
+import type { FinalOptionsOfComponent, SameFuncOptions } from ".";
+/**
+ * 把函数配置放入一个配置中依次运行
+ */
+function _sameFuncOptionsHandle(config: object, configList: Record<string, Func[]>) {
+  for (const key in configList) {
+    // @ts-ignore 隐式索引
+    config[key] = function(...args: unknown[]) {
+      configList[key].forEach(ele => ele.call(this, ...args));
+    };
+  }
+}
+/**
+ * 把函数列表配置放入一个配置中循环依次运行
+ */
+export function sameFuncOptionsHandle(
+  finalOptionsForComponent: FinalOptionsOfComponent,
+  isPage: boolean | undefined,
+  funcOptions: SameFuncOptions,
+) {
+  if (isPage) {
+    // 页面时 生命周期方法(即 on 开头的方法),(https://developers.weixin.qq.com/miniprogram/dev/framework/custom-component/component.html)
+    if (!isEmptyObject(funcOptions.pageLifetimes)) {
+      _sameFuncOptionsHandle(finalOptionsForComponent.methods, funcOptions.pageLifetimes);
+    }
+  } else {
+    // 组件时
+    if (!isEmptyObject(funcOptions.pageLifetimes)) {
+      _sameFuncOptionsHandle(finalOptionsForComponent.pageLifetimes, funcOptions.pageLifetimes);
+    }
+  }
+  if (funcOptions.lifetimes) _sameFuncOptionsHandle(finalOptionsForComponent.lifetimes ||= {}, funcOptions.lifetimes);
+
+  if (funcOptions.watch) _sameFuncOptionsHandle(finalOptionsForComponent.watch ||= {}, funcOptions.watch);
+}

package/src/api/DefineComponent/normalizeOptions/subComponentsOptionHandle.ts

@@ -0,0 +1,18 @@
+import type { SubComponentTrueOptions } from "../../SubComponent";
+import type { FinalOptionsOfComponent, SameFuncOptions } from ".";
+import { otherFieldsHandle } from "./otherFieldsHandle";
+import { sameFuncFieldsCollect } from "./sameFuncFieldsCollect";
+
+export function subComponentsOptionHandle(
+  componentOptions: FinalOptionsOfComponent,
+  subComponents: SubComponentTrueOptions[],
+  funcOptions: SameFuncOptions,
+) {
+  subComponents.forEach((subOption) => {
+    if (subOption.events) Object.assign(componentOptions.methods, subOption.events);
+
+    sameFuncFieldsCollect(subOption, funcOptions);
+
+    otherFieldsHandle(componentOptions, subOption);
+  });
+}

package/src/api/InstanceInject/inject.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
 import { observable, runInAction } from "mobx";
 
 // 注入的响应式数据;
@@ -27,6 +28,7 @@ const store = {
 // 声明注入类型 js开发可以忽略
 declare module "../.." {
   interface IInjectInfo {
+    [key: string]: unknown;
     data: typeof data;
     store: typeof store;
     methods: typeof methods;

package/src/api/InstanceInject/instanceConfig.ts

@@ -1,5 +1,3 @@
-/* eslint-disable @typescript-eslint/explicit-member-accessibility */
-
 import type { IfEquals } from "hry-types/src/Any/IfEquals";
 import type { ComputeIntersection } from "hry-types/src/Object/ComputeIntersection";
 import type { ReturnTypeInObject } from "hry-types/src/Object/ReturnTypeInObject";
@@ -10,6 +8,7 @@ import type { StoreConstraint } from "../RootComponent/Store/StoreConstraint";
 
 // 利用继承的多态性 使得IInjectInfo类型可由使用者外部定义
 interface BaseInjectInfo {
+  [key: string]: unknown;
   options?: WMComponentOption;
   methods?: MethodsConstraint;
   data?: DataConstraint;
@@ -17,7 +16,6 @@ interface BaseInjectInfo {
   behaviors?: string[];
 }
 
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
 export interface IInjectInfo extends BaseInjectInfo {
 }
 
@@ -44,7 +42,7 @@ class InstanceConfig {
     return this.info.injectInfo;
   }
   public setInjectInfo(info: IInjectInfo | undefined) {
-    info && (this.info.injectInfo = info);
+    if (info) this.info.injectInfo = info;
   }
 }
 

package/src/api/InstanceInject/test/normal.test.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions */
 import { Checking, type Test } from "hry-types";
 import { RootComponent } from "../../RootComponent";
 

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

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

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

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions */
 import { Checking, type Test } from "hry-types";
 import type { GetComputedDoc } from "../GetComputedDoc";
 

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

@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions */
+/* eslint-disable @typescript-eslint/no-unused-vars */
 import { Checking, type Test } from "hry-types";
 import type { ComputeIntersection } from "hry-types/src/Object/_api";
 import type { IInjectAllData } from "../../../InstanceInject/instanceConfig";