annil 1.5.8 → 1.5.10

package/src/{behaviors/BComputedAndWatch → api/DefineComponent/assignOptions/computedWatchHandle}/computedUpdater.ts

@@ -1,13 +1,14 @@
+import type { Instance } from "..";
+
 import { deepProxy, unwrap } from "./data-tracer";
 import { getPathsValue } from "./getPathsValue";
 
-import type { ComputedDependence } from "./initComputed";
 import { isEqual } from "./isEqual";
-import type { Instance } from "./types";
+export type ComputedDependence = { paths: string[]; val: unknown };
 
 export function computedUpdater(this: Instance, isUpdated = false): boolean {
-  for (const key in this.__computedCache__) {
-    const itemCache = this.__computedCache__[key];
+  for (const key in this.data.__computedCache__) {
+    const itemCache = this.data.__computedCache__[key];
     let changed = false;
     for (const dep of itemCache.dependences) {
       // getPathsValue返回的是数组
@@ -32,7 +33,7 @@ export function computedUpdater(this: Instance, isUpdated = false): boolean {
       isUpdated = true;
 
       // 更新依赖
-      this.__computedCache__[key].dependences = newDependences;
+      this.data.__computedCache__[key].dependences = newDependences;
 
       // 有一个计算属性更新就重新更新所有计算互相,避免后置依赖导致前置依赖错误
       return computedUpdater.call(this, isUpdated);

package/src/{behaviors/BComputedAndWatch → api/DefineComponent/assignOptions/computedWatchHandle}/data-tracer.ts

@@ -1,4 +1,4 @@
-import type { ComputedDependence } from "./initComputed";
+import type { ComputedDependence } from "./computedUpdater";
 
 export function deepProxy(
   data: object,

package/src/{behaviors/BComputedAndWatch → api/DefineComponent/assignOptions/computedWatchHandle}/getPropertiesValue.ts

@@ -3,11 +3,10 @@ import type {
   PropertiesTypes,
   RequiredSingle,
   RequiredUnion,
-} from "../../api/RootComponent/Properties/PropertiesConstraint";
+} from "../../../RootComponent/Properties/PropertiesConstraint";
 
 type PropertiesDefaultValue = "" | 0 | [] | null | false;
 
-/* istanbul ignore next */
 function getRequiredSingleValue(
   PropType: RequiredSingle,
 ): PropertiesDefaultValue {
@@ -25,7 +24,7 @@ function getRequiredSingleValue(
     default:
       /* istanbul ignore next */
       throw Error(
-        "properties字段类型只能为 String | Number | Array | Object | Boolean",
+        "properties字段类型只能为 String | Number | Array | Object | Boolean ",
       );
   }
 }
@@ -40,7 +39,7 @@ export function getPropertiesValue(propertiesOpt: PropertiesConstraint | undefin
   const result = {};
   for (const key in propertiesOpt) {
     const config = propertiesOpt[key];
-    /* istanbul ignore next */
+
     if (IsRequiredSingle(config)) {
       // @ts-ignore 隐式索引
       result[key] = getRequiredSingleValue(config);

package/src/api/DefineComponent/assignOptions/computedWatchHandle/index.ts

@@ -0,0 +1,110 @@
+import type { Func } from "hry-types/src/Misc/Func";
+import { computedUpdater } from "./computedUpdater";
+import { getPathsValue } from "./getPathsValue";
+import { getPropertiesValue } from "./getPropertiesValue";
+import { initComputed } from "./initComputed";
+import { isEqual } from "./isEqual";
+
+import { deepClone } from "../../../../utils/deepClone";
+import { isEmptyObject } from "../../../../utils/isEmptyObject";
+import type { FinalOptionsOfComponent, Instance } 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));
+  }
+
+  return watchOldValue;
+}
+export function computedWatchHandle(options: FinalOptionsOfComponent) {
+  // 计算属性初始化
+  const computedConfig = options.computed;
+  const rawPropertiesValue = getPropertiesValue(options.properties);
+  if (computedConfig && !isEmptyObject(computedConfig)) {
+    // 此时store已经初始化数据到data了
+
+    const __computedInitCache__ = initComputed(options, computedConfig, { ...options.data, ...rawPropertiesValue });
+
+    options.data.__computedCache__ = __computedInitCache__;
+
+    options.data.__computedStatus__ = "待更新";
+
+    options.methods.__computedUpdater__ = computedUpdater;
+    //    // 把计算属性缓存从方法中带入到实例中,在created周期加入实例后删除
+    //    methodOpt.__computedInitCache__ = () => computedCache;
+  }
+  const observersConfig = options.observers;
+  // 通过observers加入`**`字段来触发计算属性更新
+  const originalFunc = observersConfig["**"] as Func | undefined;
+
+  observersConfig["**"] = function(this: Instance): undefined {
+    const computedStatus = this.data.__computedStatus__;
+
+    // __computedStatus__为undefined表示无计算属性,不处理
+
+    switch (computedStatus) {
+      case "待更新":
+        // 3. 触发来自attached后的setData或properties更新
+        {
+          const isUpdated = this.__computedUpdater__!();
+
+          if (isUpdated) {
+            // 更新了会再次触发自身转到 4
+            this.data.__computedStatus__ = "更新完毕";
+          } else {
+            // 无需更新计算属性
+
+            originalFunc && originalFunc.call(this);
+          }
+        }
+        break;
+      case "更新完毕":
+        {
+          // 4 来自计算属性更新后的自身回调
+          // console.log("来自计算属性更新后的自身回调");
+          this.data.__computedStatus__ = "待更新";
+
+          originalFunc && originalFunc.call(this);
+        }
+        break;
+    }
+    // 没有计算属性时
+    originalFunc && originalFunc.call(this);
+  };
+
+  // watch handle
+  const watchConfig = options.watch;
+
+  if (watchConfig && !isEmptyObject(watchConfig)) {
+    const data = options.data;
+
+    data.__watchOldValue__ = initWatchOldValue({ ...data, ...rawPropertiesValue }, watchConfig);
+
+    const observersConfig = options.observers;
+    for (const key in watchConfig) {
+      const watchHadle = watchConfig[key];
+      const originObserversHandle = observersConfig[key] as Func | undefined;
+
+      // 在监控多个数据时,参数是多个值
+      observersConfig[key] = function(this: Instance, ...newValue: unknown[]) {
+        originObserversHandle && originObserversHandle.call(this, ...newValue);
+
+        const watchOldValue = this.data.__watchOldValue__!;
+        const oldValue = watchOldValue[key];
+
+        if (isEqual(newValue, oldValue)) return;
+        watchOldValue[key] = deepClone(newValue);
+
+        watchHadle.call(this, ...newValue, ...oldValue);
+      };
+    }
+  }
+}

package/src/{behaviors/BComputedAndWatch → api/DefineComponent/assignOptions/computedWatchHandle}/initComputed.ts

@@ -1,11 +1,16 @@
-// import type { ComponentInstance } from "../../api/RootComponent/Instance/RootComponentInstance";
-// import type { IsDependOnOthers } from "./data-tracer";
-
 import type { Func } from "hry-types/src/Misc/Func";
-import type { FinalOptionsOfComponent } from "../../api/DefineComponent/collectOptionsForComponent";
+import type { FinalOptionsOfComponent } from "..";
+
+import type { ComputedDependence } from "./computedUpdater";
 import { deepProxy, unwrap } from "./data-tracer";
-import type { ComputedCache, ItemCache } from "./types";
-export type ComputedDependence = { paths: string[]; val: unknown };
+
+type ItemCache = {
+  dependences: ComputedDependence[];
+  method: Func;
+  value: unknown;
+};
+
+export type ComputedCache = Record<string, ItemCache>;
 
 /**
  * 如果依赖列表某项的首个字段值为undefined并且字段为其他计算属性字段 返回false(即被依赖的计算字段写在了依赖他的计算字段后面), 否则返回ComputedInfo。
@@ -97,6 +102,7 @@ export function initComputed(
   computedCache: ComputedCache = {},
 ): ComputedCache {
   // 收集依赖 uninitedkeys不受内部2处重新赋值的影响
+
   for (const key of uninitedkeys) {
     // uninitedkeys 受2处重新赋值的影响
     const itemCache = getItemCache(initAllData, uninitedkeys, computedConfig[key]);
@@ -108,8 +114,7 @@ export function initComputed(
       // 把当前依赖不正确的key放到后面去
       uninitedkeys.push(key);
     } else {
-      /* istanbul ignore next */
-      const dataOpt = options.data ||= {};
+      const dataOpt = options.data;
 
       dataOpt[key] = itemCache.value;
 

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

@@ -1,47 +1,75 @@
 import type { Func } from "hry-types/src/Misc/_api";
-import { BBeforeCreate } from "../../behaviors/BbeforeCreated";
-import { BComputedAndWatch } from "../../behaviors/BComputedAndWatch";
-import type { ComputedCache, Instance } from "../../behaviors/BComputedAndWatch/types";
-import { BStore } from "../../behaviors/BStore";
-import type { Assign } from "../../types/Assign";
-import type { WMComponent } from "../../types/OfficialTypeAlias";
-import { deepClone } from "../../utils/deepClone";
-import { INNERMARKER } from "../../utils/InnerMarker";
-import { isEmptyObject } from "../../utils/isEmptyObject";
-import { instanceConfig } from "../InstanceInject/instanceConfig";
-import type { RootComponentTrueOptions } from "../RootComponent";
-import type { ComputedConstraint } from "../RootComponent/Computed/ComputedConstraint";
+import { BBeforeCreate } from "../../../behaviors/BbeforeCreated";
+
+import type { Assign } from "../../../types/Assign";
+import type { WMComponent } from "../../../types/OfficialTypeAlias";
+import { deepClone } from "../../../utils/deepClone";
+import { INNERMARKER } from "../../../utils/InnerMarker";
+import { isEmptyObject } from "../../../utils/isEmptyObject";
+import { instanceConfig } from "../../InstanceInject/instanceConfig";
+import type { RootComponentTrueOptions } from "../../RootComponent";
+import type { ComputedConstraint } from "../../RootComponent/Computed/ComputedConstraint";
 import type {
   CustomEventConstraint,
   CustomEvents,
   FullCustomEvents,
-} from "../RootComponent/CustomEvents/CustomEventConstraint";
-import type { DataConstraint } from "../RootComponent/Data/DataConstraint";
-import type { EventsConstraint } from "../RootComponent/Events/EventsConstraint";
-import type { PageInstance } from "../RootComponent/Instance/RootComponentInstance";
-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 { SubComponentTrueOptions } from "../SubComponent";
-import type { DefineComponentOption } from ".";
+} from "../../RootComponent/CustomEvents/CustomEventConstraint";
+import type { DataConstraint } from "../../RootComponent/Data/DataConstraint";
+import type { EventsConstraint } from "../../RootComponent/Events/EventsConstraint";
+import type { ComponentInstance, PageInstance } from "../../RootComponent/Instance/RootComponentInstance";
+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 { SubComponentTrueOptions } from "../../SubComponent";
+import type { DefineComponentOption } from "..";
+
+import { BStore } from "../../../behaviors/BStore";
+import { computedWatchHandle } from "./computedWatchHandle";
+
+import type { ComputedCache } from "./computedWatchHandle/initComputed";
+import { initStore } from "./initStore";
+
+type InstanceInnerFields = {
+  data: OptionsInnerFields["data"];
+  disposer: Record<string, Func>;
+} & OptionsInnerFields["methods"];
+
+export type Instance =
+  & (ComponentInstance | PageInstance)
+  & InstanceInnerFields;
+
 /**
  * 临时的函数配置项
  * 把根组件与子组件中配置类型为函数的相同字段配置收集在一起(数组)
  */
-export type FuncOptions = Record<"pageLifetimes" | "lifetimes" | "watch", Record<string, Func[]>>;
+export type FuncOptions = Record<"pageLifetimes" | "lifetimes" | "watch" | "observers", Record<string, Func[]>>;
+
+export type WatchOldValue = Record<string, unknown[]>;
+
+export type OptionsInnerFields = {
+  data: {
+    __computedStatus__?: "待更新" | "更新完毕";
+    __computedCache__?: ComputedCache;
+    __storeConfig__?: StoreConstraint;
+    __watchOldValue__?: WatchOldValue;
+  };
+  methods: {
+    disposer?: Record<string, Func>;
+    // computedHandle加入
+    __computedUpdater__?: Func;
+  };
+};
 
 /**
  * 最终传入原生Component的配置项
  */
 export type FinalOptionsOfComponent = {
-  data: DataConstraint;
+  data: DataConstraint & OptionsInnerFields["data"];
   observers: Record<string, Func>;
   behaviors: string[];
-  methods: MethodsConstraint & {
-    __computedInitCache__?: () => ComputedCache;
-  };
+  methods: MethodsConstraint & OptionsInnerFields["methods"];
   externalClasses: string[];
   pageLifetimes: PageLifetimesOption<false, object>["pageLifetimes"] & {};
   isPage?: boolean;
@@ -81,7 +109,7 @@ export function isPageCheck(isPage: boolean | undefined) {
  * 1. 使用wx.navigateTo传值的。这种情况无内置字段 option[INNERMARKER.url] 等于 undefined
  * 2. 使用插件提供的navigateTo传值。这种情况 INNERMARKER.url被load周期劫持函数解码后赋值INNERMARKER.url字段为本身,即option[INNERMARKER.url] 等于 INNERMARKER.url
  */
-/* istanbul ignore next: miniprogram-simulate(当前版本 1.6.1) 无法测试页面生命周期 */
+/* istanbul ignore next miniprogram-simulate(当前版本 1.6.1) 无法测试页面生命周期 */
 function onLoadReceivedDataHandle(
   this: PageInstance,
   option: Record<typeof INNERMARKER.url, string>,
@@ -107,7 +135,7 @@ function onLoadReceivedDataHandle(
  * 针对通过 navigateTo传过来的数据对组件load周期传入数据解析
  * @param option - option中的url是拼接了encodeURIComponent转码的data对象的,key为INNERMARKER.url
  */
-/* istanbul ignore next: miniprogram-simulate(当前版本 1.6.1) 无法测试load */
+/* istanbul ignore next miniprogram-simulate(当前版本 1.6.1) 无法测试load */
 function loadReceivedDataHandle(
   this: PageInstance,
   option: Record<typeof INNERMARKER.url, string>,
@@ -173,7 +201,7 @@ function _funcOptionsHandle(config: object, configList: Record<string, Func[]>)
 /**
  * 把函数列表配置放入一个配置中循环一次运行
  */
-function funcOptionsHandle(
+function assignFuncOptions(
   finalOptionsForComponent: FinalOptionsOfComponent,
   isPage: boolean | undefined,
   funcOptions: FuncOptions,
@@ -198,14 +226,13 @@ function funcFieldsCollect(
   options: SubComponentTrueOptions | RootComponentTrueOptions,
   funcOptions: FuncOptions,
 ) {
-  for (const key in funcOptions) {
-    // key = "pageLifetimes" | "lifetimes" | "watch"
-    // @ts-ignore 隐式索引
-    if (options[key]) {
-      // @ts-ignore 隐式索引
-      for (const _key in options[key]) {
-        // @ts-ignore 隐式索引
-        (funcOptions[key][_key] ||= []).push(options[key][_key]);
+  let key: keyof FuncOptions;
+  for (key in funcOptions) {
+    const optionsKeyConfig = options[key];
+    if (optionsKeyConfig) {
+      for (const _key in optionsKeyConfig) {
+        // @ts-ignore
+        (funcOptions[key][_key] ||= []).push(optionsKeyConfig[_key]);
       }
     }
   }
@@ -241,7 +268,7 @@ function otherFieldsHandle(
 function eventsHandle(methods: FinalOptionsOfComponent["methods"], eventsConfig: EventsConstraint) {
   Object.assign(methods, eventsConfig);
 }
-function subComponentsHandle(
+function assignSubComponentsOption(
   componentOptions: FinalOptionsOfComponent,
   subComponents: SubComponentTrueOptions[],
   funcOptions: FuncOptions,
@@ -289,7 +316,7 @@ function customEventsHandle(
  * @param funcOptions  - 收集特殊配置对象字段
  * @param rootComponentOptions - 被收集的源配置对象
  */
-function collectRootComponentOption(
+function assignRootComponentOption(
   finalOptions: FinalOptionsOfComponent,
   funcOptions: FuncOptions,
   rootComponentOptions: RootComponentTrueOptions,
@@ -347,20 +374,23 @@ function merge<Target extends object, Source extends object>(target: Target, sou
  * @param subComponentsList -
  * @returns FinalOptionsForComponent
  */
-export function collectOptionsForComponent(
+export function assignOptions(
   defineComponentOption: DefineComponentOption,
 ): FinalOptionsOfComponent {
   const rootComponentOption = defineComponentOption.rootComponent;
-  const subComponentsList = defineComponentOption.subComponents;
-
-  const finalOptionsForComponent: FinalOptionsOfComponent = merge({ ...deepClone(instanceConfig.injectInfo) }, {
-    observers: {},
-    data: {},
-    methods: {},
-    behaviors: [BStore, BComputedAndWatch],
-    externalClasses: [],
-    pageLifetimes: {},
-  });
+  const subComponentsOption = defineComponentOption.subComponents;
+  // 注入injectInfo和给默认配置(便于后续判断)
+  const finalOptionsForComponent: FinalOptionsOfComponent = merge(
+    { ...deepClone(instanceConfig.injectInfo) },
+    {
+      observers: {},
+      data: {},
+      methods: {},
+      behaviors: [BStore],
+      externalClasses: [],
+      pageLifetimes: {},
+    },
+  );
 
   /**
    * 有些字段配置同时存在根组件和子组件当中(如pageLifetimes，lifetimes,watch字段), 且key相同值类型为函数。funcConfig对象用于收集这些配置为数组形式,最终再一起整合进finalOptionsForComponent配置中。即funcConfig是一个临时中介对象。
@@ -369,20 +399,30 @@ export function collectOptionsForComponent(
     pageLifetimes: {},
     lifetimes: {},
     watch: {},
+    observers: {},
   };
 
   if (rootComponentOption && !isEmptyObject(rootComponentOption)) {
-    collectRootComponentOption(finalOptionsForComponent, funcOptions, rootComponentOption);
+    // 把rootComponentOption配置并入finalOptionsForComponent,其中FuncOptions字段配置收集到funcOptions中
+    assignRootComponentOption(finalOptionsForComponent, funcOptions, rootComponentOption);
   }
 
-  if (subComponentsList && !isEmptyObject(subComponentsList)) {
-    subComponentsHandle(finalOptionsForComponent, subComponentsList, funcOptions);
+  if (subComponentsOption && !isEmptyObject(subComponentsOption)) {
+    // 把subComponentsList配置并入finalOptionsForComponent,其中FuncOptions字段配置收集到funcOptions中
+    assignSubComponentsOption(finalOptionsForComponent, subComponentsOption, funcOptions);
   }
-
-  funcOptionsHandle(finalOptionsForComponent, rootComponentOption?.isPage, funcOptions);
-
-  InternalFieldProtection(finalOptionsForComponent.methods, ["disposer"]);
-
+  // 把收集好的funcOptions并入finalOptionsForComponent
+  assignFuncOptions(finalOptionsForComponent, rootComponentOption?.isPage, funcOptions);
+
+  // 配置与内部字段冲突验证
+  InternalFieldProtection(finalOptionsForComponent.methods, ["disposer", "__computedUpdater__"]);
+
+  InternalFieldProtection(finalOptionsForComponent.data, [
+    "__computedStatus__",
+    "__computedCache__",
+    "__storeConfig__",
+    "__watchOldValue__",
+  ]);
   // 对页面传入参数进行处理 老框架劫持页面methods.onLoad,新框架劫持页面pageLifetimes.load
 
   finalOptionsForComponent.isPage
@@ -394,16 +434,23 @@ export function collectOptionsForComponent(
     [onLoadReceivedDataHandle],
   );
 
+  // 验证isPage字段是否配置正确
   hijack(
     finalOptionsForComponent.lifetimes!,
     "attached",
     [isPageCheck(rootComponentOption?.isPage)],
   );
 
+  // 页面时删除预设的虚拟组件字段
   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);
 

package/src/api/DefineComponent/assignOptions/initStore/index.ts

@@ -0,0 +1,16 @@
+import type mobx from "mobx";
+import type { FinalOptionsOfComponent } from "..";
+export function initStore(finalOptionsForComponent: FinalOptionsOfComponent) {
+  const storeConfig = finalOptionsForComponent.store;
+  if (storeConfig) {
+    const { toJS } = require("mobx") as typeof mobx;
+    for (const key in storeConfig) {
+      finalOptionsForComponent.data[key] = toJS(storeConfig[key]());
+
+      // 把响应式数据配置保留在methods的__storeConfig__字段下带入到组件实例中(不用函数返回方式也可以,但不符合methods字段类型),后续再从原型上删除。
+    }
+    finalOptionsForComponent.data.__storeConfig__ = storeConfig;
+
+    delete finalOptionsForComponent.store;
+  }
+}

package/src/api/DefineComponent/index.ts

@@ -9,9 +9,8 @@ import type { RootComponentOption } from "./RootComponent/RootComponentOption";
 import type { SubComponentsOption } from "./SubComponents/SubComponentsOption";
 
 import type { RootComponentTrueOptions } from "../RootComponent";
-import { collectOptionsForComponent } from "./collectOptionsForComponent";
-
-type Path = `/${string}`;
+import { assignOptions } from "./assignOptions";
+export type Path = `/${string}`;
 
 type RootOptions<
   TRootComponentDoc extends RootComponentDoc,
@@ -53,9 +52,7 @@ export type DefineComponentOption = {
  * 把根组件选项和子组件选项转化为原生Component API选项并执行
  */
 export const DefineComponent: DefineComponentConstructor = function(options): any {
-  // console.log("---------------------------");
-
   Component(
-    collectOptionsForComponent(options as DefineComponentOption) as any,
+    assignOptions(options as DefineComponentOption) as any,
   );
 };

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

@@ -0,0 +1,30 @@
+// import type mobx from "mobx";
+// import type { FinalOptionsOfComponent } from "../collectOptionsForComponent";
+// export function storeDataHandle(options: FinalOptionsOfComponent) {
+//   // 初始化store
+//   const storeConfig = options.store;
+//   if (!storeConfig) return;
+//   const { toJS, comparer, reaction } = require("mobx") as typeof mobx;
+
+//   options.data.__disposer__ = {};
+
+//   for (const key in storeConfig) {
+//     options.data[key] = toJS(storeConfig[key]());
+
+//     options.data.__disposer__[key] = reaction(storeConfig[key], (value: unknown) => {
+
+//       // @ts-ignore  加入到待setData对象中
+//       this.setData({
+//         [key]: toJS(value),
+//       });
+//     }, {
+//       equals: comparer.structural,
+//     });
+
+//     options.methods.disposer = function(key: keyof typeof storeConfig) {
+
+//       this.data.__disposer__[key].call(this);
+//     };
+//   }
+//   delete options.store;
+// }

package/src/api/InstanceInject/instanceConfig.ts

@@ -21,7 +21,8 @@ export interface IInjectInfo extends BaseInjectInfo {
 
 export type IInjectData = IInjectInfo["data"] & ReturnTypeInObject<IInjectInfo["store"]>;
 
-export type IInjectStore = ReturnTypeInObject<IInjectInfo["store"]>;
+export type IInjectStore = StoreConstraint extends IInjectInfo["store"] ? unknown
+  : ReturnTypeInObject<IInjectInfo["store"]>;
 
 export type IInjectMethods = IInjectInfo["methods"];
 

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

@@ -1,6 +1,6 @@
 import type { ComputeIntersection } from "hry-types/src/Object/ComputeIntersection";
 import type { WMCompLifetimes } from "../../../types/OfficialTypeAlias";
-import type { FinalOptionsOfComponent } from "../../DefineComponent/collectOptionsForComponent";
+import type { FinalOptionsOfComponent } from "../../DefineComponent/assignOptions";
 
 export type LifetimesConstraint = // 官方组件生命周期
   ComputeIntersection<

package/src/api/RootComponent/Observers/ObserversOption.ts

@@ -45,8 +45,8 @@ export type ObserversOption<TWatchData extends object, _WatchKeys extends keyof
     // 不加NoInfer会导致只监控计算字段时错误
     NoInfer<
       & {
-        [k in _WatchKeys]?: (
-          newValue: ReadonlyDeep<TWatchData[k]>,
+        [k in _WatchKeys | "**"]?: (
+          newValue: k extends keyof TWatchData ? ReadonlyDeep<TWatchData[k]> : unknown,
         ) => void;
       }
       // 解决单独书写计算书写字段的报错(或许是:ts字面量约束检测提前计算属性key引起的错误提示)

package/src/api/SubComponent/SubComputed/test/normal.test.ts

@@ -67,7 +67,7 @@ SubComponent<Root, OnlyPropsCompDoc>()({
 SubComponent<Root, OnlyPropsCompDoc>()({
   computed: {
     aaa_num() {
-      return 123 as number;
+      return 123;
     },
     aaa_num123(): 123 {
       return 123;
@@ -90,8 +90,8 @@ SubComponent<Root, OnlyPropsCompDoc>()({
             bool: boolean;
             aaa_num: number;
             aaa_num123: 123;
-            aaa_str: "a";
-            aaa_obj: Mock_User;
+            aaa_str: "a" | "b";
+            aaa_obj: Mock_User | null;
           } & IInjectData
         >,
         Test.Pass
@@ -114,8 +114,8 @@ SubComponent<Root, OnlyPropsCompDoc>()({
             bool: boolean;
             aaa_num: number;
             aaa_num123: 123;
-            aaa_str: "a";
-            aaa_obj: Mock_User;
+            aaa_str: "a" | "b";
+            aaa_obj: Mock_User | null;
           } & IInjectData
         >,
         Test.Pass

package/src/api/SubComponent/SubData/test/normal.test.ts

@@ -54,10 +54,10 @@ SubComponent<{}, CompDoc>()({
         typeof this.data,
         ReadonlyDeep<
           {
-            aaa_str: "a";
-            aaa_num: 123;
-            aaa_obj: null;
             _aaa_str: string;
+            aaa_str: "a" | "b";
+            aaa_num: number;
+            aaa_obj: Mock_User | null;
           } & IInjectData
         >,
         Test.Pass

package/src/api/SubComponent/SubInstance/test/normal.test.ts

@@ -63,8 +63,8 @@ SubComponent<RootDoc, CompDoc>()({
             PoptionalObj: Mock_User;
             Dnum: number;
             Cnum: number;
-            // 自身Data
-            aaa_str: "str";
+            // 自身Data类型与CompDoc类型相同
+            aaa_str: string;
           } & IInjectData
         >,
         Test.Pass