annil 1.6.1 → 1.6.3

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

@@ -1,9 +1,8 @@
 import type { Func } from "hry-types/src/Misc/Func";
 import type { FinalOptionsOfComponent } from "..";
 
-import { deepClone } from "../../../../utils/deepClone";
 import type { ComputedDependence } from "./computedUpdater";
-import { deepProxy } from "./data-tracer";
+import { deepProxy, getProxyOriginalValue } from "./data-tracer";
 
 type ItemCache = {
   dependences: ComputedDependence[];
@@ -11,45 +10,22 @@ type ItemCache = {
   value: unknown;
 };
 
-export type ComputedCache = Record<string, ItemCache>;
+type ComputedId = string;
+
+export type ComputedCache = Record<ComputedId, ItemCache>;
 
 /**
- * 如果依赖列表某项的首个字段值为undefined并且字段为其他计算属性字段 返回false(即被依赖的计算字段写在了依赖他的计算字段后面), 否则返回ComputedInfo。
+ * 如果依赖列表某项的首个字段值为undefined并且字段为其他计算属性字段 返回false(即被依赖的计算字段写在了依赖他的计算字段后面), 否则返回true表示依赖有效。
  */
 function isValidDependences(dependences: ComputedDependence[], computedKeys: string[]): boolean {
   for (const { paths: path, val } of dependences) {
-    // 引用值为undefined时
-    // console.log(path[0]);
     if ((val === undefined) && computedKeys.includes(path[0])) {
       return false;
     }
   }
 
-  return true; // 依赖有效
-}
-
-export function getItemCache(
-  initAllData: object,
-  computedKeys: string[],
-  computedFunc: Func,
-): false | ItemCache {
-  // 当前计算字段的依赖列表
-  const dependences: ComputedDependence[] = [];
-  const initValue = computedFunc.call({ data: deepProxy(initAllData, dependences) });
-
-  if (isValidDependences(dependences, computedKeys)) {
-    return {
-      // 去重 避免 如: ` age(){ return this.data.xxx.num + this.data.xxx.str + this.data.xxx} ` 造成的多个依赖相同情况。应就要一个 xxx
-      dependences: uniqueDependences(dependences),
-      method: computedFunc,
-      value: deepClone(initValue),
-    };
-  } else {
-    /**
-     * 情形1 依赖了其他未初始化的计算属性(不报错) 对应测试文件[NoOptionalProperties.ts](../../../jest/computed/NoOptionalProperties/NoOptionalProperties.test.ts)的copyPropUser字段
-     */
-    return false;
-  }
+  // 依赖有效
+  return true;
 }
 
 /**
@@ -63,24 +39,17 @@ export function getItemCache(
  */
 function uniqueDependences(dependences: ComputedDependence[]): ComputedDependence[] {
   if (dependences.length === 1) return dependences;
-  // console.log(dependences);
-
   for (let f = 0; f < dependences.length; f++) {
     const firstPath = dependences[f].paths.join(".") + ".";
     for (let i = f + 1; i < dependences.length; i++) {
       const curPath = dependences[i].paths.join(".") + ".";
-      // console.log(firstPath,curPath)
       if (firstPath.startsWith(curPath)) {
-        // console.log("删除:", curPath, f);
-
         // 例如 path[0] = 'a.b.c.',curPath = 'a.b.'
         dependences.splice(f, 1);
 
         return uniqueDependences(dependences);
       }
       if (curPath.startsWith(firstPath)) {
-        // console.log("删除:", firstPath, i);
-
         // 例如 curPath = 'a.b.' path[0] = 'a.b.c.',
         dependences.splice(i, 1);
 
@@ -93,43 +62,55 @@ function uniqueDependences(dependences: ComputedDependence[]): ComputedDependenc
 }
 
 /**
- * 把计算属性初始值加入到options.data中返回缓存
+ * 把计算属性初始值加入到options.data中并返回缓存(递归函数)
+ * @param options - 配置选项
+ * @param computedConfig - 计算字段配置
+ * @param initAllData - 初始化时全部的data包含(properties,data,和已经初始化后的computed字段)
+ * @param uninitedkeys - 未初始化的key (默认为所有computedConfig的key)
+ * @param computedCache - 返回的所有计算字段缓存(默认为空对象)
+ * @returns  `computedCache` 计算字段缓存
  */
-export function initComputed(
+export function initComputedAndGetCache(
   options: FinalOptionsOfComponent,
   computedConfig: Record<string, Func>,
-  initAllData: object,
+  initAllData: Record<string, unknown>,
   uninitedkeys: string[] = Object.keys(computedConfig),
   computedCache: ComputedCache = {},
 ): ComputedCache {
-  // 收集依赖 uninitedkeys不受内部2处重新赋值的影响
-
   for (const key of uninitedkeys) {
-    // uninitedkeys 受2处重新赋值的影响
-    const itemCache = getItemCache(initAllData, uninitedkeys, computedConfig[key]);
+    const computedFunc = computedConfig[key];
+    const dependences: ComputedDependence[] = [];
+    // 通过代理data获取计算字段的初始值和依赖
+    let initValue = computedFunc.call({ data: deepProxy(initAllData, dependences) });
 
-    // 去除当前的key 2
+    // 去除当前已初始的计算属性key
     uninitedkeys = uninitedkeys.filter(ele => ele !== key);
 
-    if (itemCache === false) {
-      // 把当前依赖不正确的key放到后面去
-      uninitedkeys.push(key);
-    } else {
-      const dataOpt = options.data;
+    // 验证依赖是否有效
+    if (isValidDependences(dependences, uninitedkeys)) {
+      initValue = getProxyOriginalValue(initValue);
 
-      dataOpt[key] = itemCache.value;
+      // 把计算属性初始值加入到options.data中
+      options.data[key] = initValue;
 
-      // @ts-ignore 隐式索引
-      initAllData[key] = itemCache.value;
+      // 把计算属性初始值加入到initAllData中,后续其他计算属性依赖时会可能会用到
+      initAllData[key] = initValue;
 
-      computedCache[key] = itemCache;
+      computedCache[key] = {
+        dependences: uniqueDependences(dependences),
+        method: computedFunc,
+        value: initValue,
+      };
+    } else {
+      // 把当前依赖不正确的key放到后面去
+      uninitedkeys.push(key);
     }
   }
-  // 看uninitedkey(2处的新值)是否未空，空表示所有依赖收集完毕直接返回
+  // 看uninitedkey是否未空，空表示所有依赖收集完毕直接返回
   if (uninitedkeys.length === 0) {
     return computedCache;
   }
 
   // uninitedkey不为空,递归
-  return initComputed(options, computedConfig, initAllData, uninitedkeys, computedCache);
+  return initComputedAndGetCache(options, computedConfig, initAllData, uninitedkeys, computedCache);
 }

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

@@ -27,7 +27,7 @@ import type { DefineComponentOption } from "..";
 import { BStore } from "../../../behaviors/BStore";
 import { computedWatchHandle } from "./computedWatchHandle";
 
-import type { ComputedCache } from "./computedWatchHandle/initComputed";
+import type { ComputedCache } from "./computedWatchHandle/initComputedAndGetCache";
 import { initStore } from "./initStore";
 
 type InstanceInnerFields = {
@@ -101,13 +101,13 @@ export function isPageCheck(isPage: boolean | undefined) {
   };
 }
 
-function addCloneDataToInstance(this: Instance) {
-  this.cloneData = new Proxy(this.data, {
-    get: <T extends object>(target: T, key: keyof T) => {
-      return deepClone(target)[key];
-    },
-  });
-}
+// function addCloneDataToInstance(this: Instance) {
+//   this.cloneData = new Proxy(this.data, {
+//     get: <T extends object>(target: T, key: keyof T) => {
+//       return deepClone(target)[key];
+//     },
+//   });
+// }
 /**
  * 原生Component会对传入的对象字段匹配的properties字段setData赋值。不符合字段或Page时不会赋值。
  * 此函数为给实例setData赋值,默认传递值与properties相符(ts类型安全)。
@@ -446,11 +446,11 @@ export function assignOptions(
     [isPageCheck(rootComponentOption?.isPage)],
   );
 
-  hijack(
-    finalOptionsForComponent.lifetimes!,
-    "created",
-    [addCloneDataToInstance],
-  );
+  // hijack(
+  //   finalOptionsForComponent.lifetimes!,
+  //   "created",
+  //   [addCloneDataToInstance],
+  // );
 
   // 页面时删除预设的虚拟组件字段
   finalOptionsForComponent.isPage

package/src/api/InstanceInject/instanceConfig.ts

@@ -1,5 +1,7 @@
 /* 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";
 import type { WMComponentOption } from "../../types/OfficialTypeAlias";
 import type { DataConstraint } from "../RootComponent/Data/DataConstraint";
@@ -19,9 +21,16 @@ interface BaseInjectInfo {
 export interface IInjectInfo extends BaseInjectInfo {
 }
 
-export type IInjectData = IInjectInfo["data"] & ReturnTypeInObject<IInjectInfo["store"]>;
+export type IInjectAllData = IfEquals<
+  {},
+  injectData & IInjectStore,
+  {},
+  ComputeIntersection<injectData & IInjectStore>
+>;
 
-export type IInjectStore = StoreConstraint extends IInjectInfo["store"] ? unknown
+type injectData = DataConstraint extends IInjectInfo["data"] ? {} : IInjectInfo["data"];
+
+export type IInjectStore = StoreConstraint extends IInjectInfo["store"] ? {}
   : ReturnTypeInObject<IInjectInfo["store"]>;
 
 export type IInjectMethods = IInjectInfo["methods"];

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

@@ -1,6 +1,6 @@
 import { Checking, type Test } from "hry-types";
-import type { ReadonlyDeep } from "hry-types/src/Any/_api";
-import type { IInjectData } from "../../../InstanceInject/instanceConfig";
+import type { ComputeIntersection } from "hry-types/src/Object/_api";
+import type { IInjectAllData } from "../../../InstanceInject/instanceConfig";
 import { RootComponent } from "../..";
 import type { Mock_User } from "../../Properties/test/normalRequired.test";
 
@@ -31,18 +31,18 @@ const RootDoc = RootComponent()({
       // 3 this.data 类型是深度只读的
       Checking<
         typeof this.data,
-        {
-          firstName: string;
-          lastName: string;
-          mock_User: Mock_User;
-          fullName: string;
-          user: Mock_User;
-          prefix: string;
-          id_fullName: string;
-          readOnly: "str";
-          injectStr: string;
-          injectTheme: "light" | "dark" | undefined;
-        },
+        ComputeIntersection<
+          {
+            firstName: string;
+            lastName: string;
+            mock_User: Mock_User;
+            fullName: string;
+            user: Mock_User;
+            prefix: string;
+            id_fullName: string;
+            readOnly: "str";
+          } & IInjectAllData
+        >,
         Test.Pass
       >;
 
@@ -71,7 +71,7 @@ const noComputedFieldDoc = RootComponent()({
   methods: {
     M1() {
       // 5.1 无computed,this.data中为{}
-      Checking<typeof this.data, ReadonlyDeep<IInjectData>, Test.Pass>;
+      Checking<typeof this.data, IInjectAllData, Test.Pass>;
     },
   },
 });
@@ -86,7 +86,7 @@ const EmptyComputedFieldDoc = RootComponent()({
   methods: {
     M1() {
       // 6.1 computed为{},this.data中为{}
-      Checking<typeof this.data, ReadonlyDeep<IInjectData>, Test.Pass>;
+      Checking<typeof this.data, IInjectAllData, Test.Pass>;
     },
   },
 });

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

@@ -95,22 +95,3 @@ const rootDocNoFields = RootComponent()({});
 
 // 3. 无customEvents字段时,Doc中无customEvents字段
 Checking<typeof rootDocNoFields, {}, Test.Pass>;
-
-// 4 实例中的对象数组都是readOnlyDeep类型,可以传递给自定义做参数
-RootComponent()({
-  properties: {
-    obj: Object as DetailedType<Mock_User>,
-  },
-  data: {
-    obj1: {} as Mock_User,
-    _ddd: {} as Mock_User,
-  },
-  customEvents: mock_customEvents,
-  events: {
-    ddd() {
-      this.obj(this.data.obj!);
-
-      this.obj(this.data.obj1);
-    },
-  },
-});

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

@@ -1,45 +1,14 @@
 import { Checking, type Test } from "hry-types";
-
-import type { ReadonlyDeep } from "hry-types/src/Any/_api";
-import type { IInjectData } from "../../../InstanceInject/instanceConfig";
+import type { IInjectAllData } from "../../../InstanceInject/instanceConfig";
 import { RootComponent } from "../..";
 
-type Gender = "male" | "female";
-
-const RootDoc = RootComponent()({
-  data: {
-    gender: "male" as Gender, // 联合字面量
-    num: 123,
-    _innernalFields: 123, // 内部字段无法在wxml中使用
-  },
-  methods: {
-    foo() {
-      this.cloneData.num = 123;
-
-      Checking<
-        typeof this.data,
-        ReadonlyDeep<{ gender: Gender; num: number; _innernalFields: number } & IInjectData>,
-        Test.Pass
-      >;
-    },
-  },
-});
-
-type RootDocExpected = {
-  gender: Gender;
-  num: number;
-  _innernalFields: number;
-};
-
-Checking<typeof RootDoc["data"], RootDocExpected, Test.Pass>;
-
 // data为空对象时
 const EmptyDataRootDoc = RootComponent()({
   data: {},
   methods: {
     M1() {
-      // 3.1 data为空对象时 this.data为{}类型
-      Checking<typeof this.data, ReadonlyDeep<IInjectData>, Test.Pass>;
+      // 3.1 data为空对象时 this.data为注入数据类型
+      Checking<typeof this.data, IInjectAllData, Test.Pass>;
     },
   },
 });
@@ -53,8 +22,8 @@ Checking<typeof EmptyDataRootDoc, { methods: { M1: () => void } }, Test.Pass>;
 const noDataRootDoc = RootComponent()({
   methods: {
     M1() {
-      // 4.1 data为空对象时 this.data为{}类型
-      Checking<typeof this.data, ReadonlyDeep<IInjectData>, Test.Pass>;
+      // 4.1 data为空对象时 this.data为注入数据类型
+      Checking<typeof this.data, IInjectAllData, Test.Pass>;
     },
   },
 });

package/src/api/RootComponent/Instance/RootComponentInstance.ts

@@ -1,4 +1,3 @@
-import type { ReadonlyDeep } from "hry-types/src/Any/_api";
 import type { IfExtends } from "hry-types/src/Any/IfExtends";
 import type { ComputeIntersection } from "hry-types/src/Object/ComputeIntersection";
 import type { IReactionDisposer } from "mobx";
@@ -6,7 +5,7 @@ import type { IReactionDisposer } from "mobx";
 import type { Assign } from "../../../types/Assign";
 import type { ComputeObject } from "../../../types/ComputeObj";
 import type { WMComponentInstance, WMInstanceMethods, WMPageInstance } from "../../../types/OfficialTypeAlias";
-import type { IInjectData, IInjectMethods } from "../../InstanceInject/instanceConfig";
+import type { IInjectAllData, IInjectMethods } from "../../InstanceInject/instanceConfig";
 import type { CustomEventMethods } from "./CustomEventMethods";
 import type { CustomSetData } from "./CustomSetData";
 export type RootComponentInstance<
@@ -16,7 +15,7 @@ export type RootComponentInstance<
   AllData extends object,
   CustomEventsDoc extends object,
   StoreDoc extends object,
-  instanceData = ComputeObject<Assign<IInjectData, ComputeIntersection<AllData>>>,
+  instanceData = ComputeObject<Assign<IInjectAllData, ComputeIntersection<AllData>>>,
 > =
   // 官方实例属性is  options  dataset等
   & IfExtends<false, TIsPage, WMComponentInstance, WMPageInstance>
@@ -28,8 +27,8 @@ export type RootComponentInstance<
     disposer: { [k in keyof StoreDoc]: IReactionDisposer };
   }>
   & Assign<IInjectMethods, TMethods & CustomEventMethods<CustomEventsDoc>>
-  & { data: ReadonlyDeep<instanceData> }
-  & { cloneData: ComputeObject<Assign<IInjectData, ComputeIntersection<AllData>>> };
+  & { data: instanceData };
+// & { cloneData: ComputeObject<Assign<IInjectData, ComputeIntersection<AllData>>> };
 
 export type ComponentInstance = RootComponentInstance<false, {}, {}, {}, {}, {}>;
 

package/src/api/RootComponent/Instance/test/properties/mormal.test.ts

@@ -1,7 +1,7 @@
 import { Checking, type Test } from "hry-types";
-import type { ReadonlyDeep } from "hry-types/src/Any/ReadonlyDeep";
+import type { ComputeIntersection } from "hry-types/src/Object/ComputeIntersection";
 import { type DetailedType, RootComponent } from "../../../../..";
-import type { IInjectData } from "../../../../InstanceInject/instanceConfig";
+import type { IInjectAllData } from "../../../../InstanceInject/instanceConfig";
 
 // 组件时
 RootComponent()({
@@ -17,7 +17,12 @@ RootComponent()({
       // 组件实例对象格外添加null类型
       Checking<
         typeof this.data,
-        ReadonlyDeep<{ optionalObj: { name: string } | null; obj: object | null } & IInjectData>,
+        ComputeIntersection<
+          {
+            optionalObj: { name: string } | null;
+            obj: object | null;
+          } & IInjectAllData
+        >,
         Test.Pass
       >;
     },
@@ -44,7 +49,7 @@ RootComponent()({
       }, Test.Pass>;
 
       // 页面实例对象不额外添加null
-      Checking<typeof this.data.optionalObj, ReadonlyDeep<{ name: string }>, Test.Pass>;
+      Checking<typeof this.data.optionalObj, { name: string }, Test.Pass>;
 
       // 页面实例对象不额外添加null
       Checking<typeof this.data.obj, object, Test.Pass>;

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

@@ -1,4 +1,3 @@
-import type { ReadonlyDeep } from "hry-types/src/Any/_api";
 import type { IfExtends } from "hry-types/src/Any/IfExtends";
 import type { IsPureObject } from "hry-types/src/Any/IsPureObject";
 import type { NoInfer } from "hry-types/src/Generic/NoInfer";
@@ -20,15 +19,13 @@ type AddFieldsOfObject<
 > = {
   [k in secondKeys]?: (
     // @ts-ignore
-    newValue: ReadonlyDeep<
-      IfExtends<
-        getLastKeys<k>,
-        "**",
-        // @ts-ignore
-        TWatchData[getFirstKeys<k>],
-        // @ts-ignore
-        NonNullable<(Exclude<TWatchData[getFirstKeys<k>], null>)[getLastKeys<k>]>
-      >
+    newValue: IfExtends<
+      getLastKeys<k>,
+      "**",
+      // @ts-ignore
+      TWatchData[getFirstKeys<k>],
+      // @ts-ignore
+      NonNullable<(Exclude<TWatchData[getFirstKeys<k>], null>)[getLastKeys<k>]>
     >,
   ) => void;
 };
@@ -46,7 +43,7 @@ export type ObserversOption<TWatchData extends object, _WatchKeys extends keyof
     NoInfer<
       & {
         [k in _WatchKeys | "**"]?: (
-          newValue: k extends keyof TWatchData ? ReadonlyDeep<TWatchData[k]> : unknown,
+          newValue: k extends keyof TWatchData ? TWatchData[k] : unknown,
         ) => void;
       }
       // 解决单独书写计算书写字段的报错(或许是:ts字面量约束检测提前计算属性key引起的错误提示)

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

@@ -1,5 +1,4 @@
 import { Checking, type Test } from "hry-types";
-import type { ReadonlyDeep } from "hry-types/src/Any/_api";
 
 import type { User } from "../../../../../jest/common";
 import { RootComponent } from "../..";
@@ -10,10 +9,10 @@ RootComponent()({
   },
   observers: {
     obj(a) {
-      Checking<typeof a, ReadonlyDeep<User> | null, Test.Pass>;
+      Checking<typeof a, User | null, Test.Pass>;
     },
     "obj.**"(a) {
-      Checking<typeof a, ReadonlyDeep<User> | null, Test.Pass>;
+      Checking<typeof a, User | null, Test.Pass>;
     },
     "obj.age"(a) {
       Checking<typeof a, number, Test.Pass>;

package/src/api/RootComponent/Properties/test/normalEmpty.test.ts

@@ -1,6 +1,5 @@
 import { Checking, type Test } from "hry-types";
-import type { ReadonlyDeep } from "hry-types/src/Any/_api";
-import type { IInjectData } from "../../../InstanceInject/instanceConfig";
+import type { IInjectAllData } from "../../../InstanceInject/instanceConfig";
 import { RootComponent } from "../..";
 
 /**
@@ -10,8 +9,8 @@ const emptyObj = RootComponent()({
   properties: {},
   methods: {
     foo() {
-      // 1 this.data 为空对象类型
-      Checking<typeof this.data, ReadonlyDeep<IInjectData>, Test.Pass>;
+      // 1 this.data 为注入数据类型
+      Checking<typeof this.data, IInjectAllData, Test.Pass>;
     },
   },
 });
@@ -29,8 +28,8 @@ Checking<typeof emptyObj, {
 const noProperties = RootComponent()({
   methods: {
     foo() {
-      // 3 this.data 为空对象类型
-      Checking<typeof this.data, ReadonlyDeep<IInjectData>, Test.Pass>;
+      // 3 this.data 为注入数据类型
+      Checking<typeof this.data, IInjectAllData, Test.Pass>;
     },
   },
 });

package/src/api/RootComponent/Properties/test/normalOptional.test.ts

@@ -1,7 +1,7 @@
 import { Checking, type Test } from "hry-types";
-import type { ReadonlyDeep } from "hry-types/src/Any/_api";
+import type { ComputeIntersection } from "hry-types/src/Object/_api";
 import type { DetailedType } from "../../../../types/DetailedType";
-import type { IInjectData } from "../../../InstanceInject/instanceConfig";
+import type { IInjectAllData } from "../../../InstanceInject/instanceConfig";
 import { RootComponent } from "../..";
 import { type Mock_User } from "./normalRequired.test";
 
@@ -48,7 +48,7 @@ const OptionalDoc = RootComponent()({
       // 1. 内部this.data中的类型(去除可选)
       Checking<
         typeof this.data,
-        ReadonlyDeep<
+        ComputeIntersection<
           {
             optional_num: number;
             optional_gender: "male" | "female";
@@ -57,7 +57,7 @@ const OptionalDoc = RootComponent()({
             optional_objOrNull: Mock_User | null;
             optional_union: string | number;
             optional_arr: string[];
-          } & IInjectData
+          } & IInjectAllData
         >,
         Test.Pass
       >;

package/src/api/RootComponent/Properties/test/normalRequired.test.ts

@@ -1,8 +1,7 @@
 import { Checking, type Test } from "hry-types";
+import type { ComputeIntersection } from "hry-types/src/Object/ComputeIntersection";
 import type { DetailedType } from "../../../../types/DetailedType";
-
-import type { ReadonlyDeep } from "hry-types/src/Any/_api";
-import type { IInjectData } from "../../../InstanceInject/instanceConfig";
+import type { IInjectAllData } from "../../../InstanceInject/instanceConfig";
 import { RootComponent } from "../..";
 import type { RequiredSingle, RequiredType, RequiredUnion } from "../PropertiesConstraint";
 
@@ -92,10 +91,11 @@ const RequiredDoc = RootComponent()({
   methods: {
     foo() {
       // 1 this.data中的类型(对象类型加null)
-      Checking<typeof this.data, ReadonlyDeep<RequiredTypeExpected & IInjectData>, Test.Pass>;
+      Checking<typeof this.data, ComputeIntersection<RequiredTypeExpected & IInjectAllData>, Test.Pass>;
     },
   },
 });
+
 /**
  * 2 properties配置为必传类型时预期文档类型(与this.data一致)
  */

package/src/api/RootComponent/Watch/WatchOption.ts

@@ -1,4 +1,3 @@
-import type { ReadonlyDeep } from "hry-types/src/Any/_api";
 import type { IfExtends } from "hry-types/src/Any/IfExtends";
 import type { IsPureObject } from "hry-types/src/Any/IsPureObject";
 import type { NoInfer } from "hry-types/src/Generic/NoInfer";
@@ -20,27 +19,22 @@ type AddFieldsOfObject<
 > = {
   [k in secondKeys]?: (
     // @ts-ignore
-    newValue: ReadonlyDeep<
-      IfExtends<
-        getLastKeys<k>,
-        "**",
-        // @ts-ignore
-        Exclude<TWatchData[getFirstKeys<k>], null>,
-        // @ts-ignore
-        NonNullable<(Exclude<TWatchData[getFirstKeys<k>], null>)[getLastKeys<k>]>
-      >
+    newValue: IfExtends<
+      getLastKeys<k>,
+      "**",
+      // @ts-ignore
+      Exclude<TWatchData[getFirstKeys<k>], null>,
+      // @ts-ignore
+      NonNullable<(Exclude<TWatchData[getFirstKeys<k>], null>)[getLastKeys<k>]>
     >,
-    oldValue: ReadonlyDeep<
-      IfExtends<
-        getLastKeys<k>,
-        "**",
-        // @ts-ignore
-        TWatchData[getFirstKeys<k>],
-        // @ts-ignore
-        (Exclude<TWatchData[getFirstKeys<k>], null>)[getLastKeys<k>]
-      >
+    oldValue: IfExtends<
+      getLastKeys<k>,
+      "**",
+      // @ts-ignore
+      TWatchData[getFirstKeys<k>],
+      // @ts-ignore
+      (Exclude<TWatchData[getFirstKeys<k>], null>)[getLastKeys<k>]
     >,
-    // ReadonlyDeep<(Exclude<TWatchData[getFirstKeys<k>], null>)[getLastKeys<k>]>,
   ) => void;
 };
 
@@ -57,9 +51,9 @@ export type WatchOption<TWatchData extends object, _WatchKeys extends keyof TWat
     NoInfer<
       & {
         [k in _WatchKeys]?: (
-          // newValue 去除null 深度只读
-          newValue: ReadonlyDeep<Exclude<TWatchData[k], null>>,
-          oldValue: ReadonlyDeep<TWatchData[k]>,
+          // newValue 去除null
+          newValue: Exclude<TWatchData[k], null>,
+          oldValue: TWatchData[k],
         ) => void;
       }
       // 解决单独书写计算书写字段的报错(猜测是:ts字面量约束检测提前计算属性key引起的错误提示)