annil 1.8.0 → 1.8.2

package/src/api/DefineComponent/normalizeOptions/computedWatchHandle/computedUpdater.ts

@@ -1,6 +1,6 @@
 import { deepEqual } from "../../../../utils/deepEqual";
 import type { Instance } from "../../../RootComponent/Instance/RootComponentInstance";
-import { deepProxy, getProxyOriginalValue } from "./data-tracer";
+import { deepProxy, getOriginalValue } from "./data-tracer";
 import { removeSubDependences } from "./dependencesOptimize";
 import { getPathsValue } from "./getPathsValue";
 
@@ -24,10 +24,9 @@ export function computedUpdater(this: Instance, isUpdated = false): boolean {
     if (changed) {
       const newDependences: ComputedDependence[] = [];
       const newValue = itemCache.method.call({ data: deepProxy(this.data, newDependences) });
-
-      // 更新值不会立即再次进入**函数,而是当前**函数运行完毕后触发**函数,
+      // 更新值不会立即再次进入**函数,而是当前**函数运行完毕后触发**函数,\
       this.setData({
-        [key]: getProxyOriginalValue(newValue),
+        [key]: getOriginalValue(newValue),
       });
 
       isUpdated = true;

package/src/api/DefineComponent/normalizeOptions/computedWatchHandle/data-tracer.ts

@@ -13,9 +13,9 @@ export function deepProxy(
       }
       const val = target[prop];
 
-      // 自身没有但原型链上有的属性不收集依赖
+      // 自身没有但原型链上有的属性不收集依赖,比如数组上的方法 slice map forEach
       if (prop in target && !Object.prototype.hasOwnProperty.call(target, prop)) {
-        return typeof val === "function" ? val.bind(target) : val;
+        return typeof val === "function" ? val.bind(target) : val; // : val 覆盖测试不到.
       }
       removePreviousDependence(dependences, basePath);
 
@@ -25,7 +25,7 @@ export function deepProxy(
 
       // 非对象不代理
       if (typeof val !== "object" || val === null) return val;
-
+      // console.log(val, typeof val);
       return deepProxy(val, dependences, curPath);
     },
     set(_target: object, prop: string) {
@@ -36,17 +36,11 @@ export function deepProxy(
   return new Proxy(data, handler);
 }
 
-export function getProxyOriginalValue(value: { __original__?: unknown }): unknown {
-  if (typeof value !== "object" || value === null) {
+// 如果是代理对象可以从__original__中获取原始值,否则返回自身
+export function getOriginalValue(value: { __original__?: unknown }): unknown {
+  if (typeof value !== "object" || value === null || value.__original__ === undefined) {
     return value;
   }
-  if (value.__original__) return value.__original__;
-
-  const ret = Array.isArray(value) ? [] : {};
-  for (const key in value) {
-    // @ts-ignore 隐式索引
-    ret[key] = getProxyOriginalValue(value[key]);
-  }
 
-  return ret;
+  return value.__original__;
 }

package/src/api/DefineComponent/normalizeOptions/computedWatchHandle/getPropertiesValue.ts

@@ -6,7 +6,7 @@ import type {
 } from "../../../RootComponent/Properties/PropertiesConstraint";
 
 type PropertiesDefaultValue = "" | 0 | [] | null | false;
-
+/* istanbul ignore next */
 function getRequiredSingleValue(
   PropType: RequiredSingle,
 ): PropertiesDefaultValue {
@@ -34,12 +34,10 @@ function IsRequiredSingle(config: PropertiesTypes): config is RequiredSingle {
 function IsRequiredUnion(config: PropertiesTypes): config is RequiredUnion {
   return !Reflect.has(config, "value");
 }
-export function getPropertiesValue(propertiesOpt: PropertiesConstraint | undefined): object | undefined {
-  if (propertiesOpt === undefined) return;
+export function getPropertiesValue(propertiesOpt: PropertiesConstraint): object {
   const result = {};
   for (const key in propertiesOpt) {
     const config = propertiesOpt[key];
-
     if (IsRequiredSingle(config)) {
       // @ts-ignore 隐式索引
       result[key] = getRequiredSingleValue(config);

package/src/api/DefineComponent/normalizeOptions/computedWatchHandle/initComputedAndGetCache.ts

@@ -2,7 +2,7 @@ import type { Func } from "hry-types/src/Misc/Func";
 import type { FinalOptionsOfComponent } from "..";
 
 import type { ComputedDependence } from "./computedUpdater";
-import { deepProxy, getProxyOriginalValue } from "./data-tracer";
+import { deepProxy, getOriginalValue } from "./data-tracer";
 import { removeSubDependences } from "./dependencesOptimize";
 
 type ItemCache = {
@@ -56,7 +56,7 @@ export function initComputedAndGetCache(
 
     // 验证依赖是否有效
     if (isValidDependences(dependences, uninitedkeys)) {
-      initValue = getProxyOriginalValue(initValue);
+      initValue = getOriginalValue(initValue);
 
       // 把计算属性初始值加入到options.data中
       options.data[key] = initValue;

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

@@ -36,6 +36,7 @@ export function customEventsHandle(
 ) {
   const methods = finalOptions.methods;
   const data = finalOptions.data;
+
   for (const key in customEventsConfig) {
     const customEventOptions = customEventsConfig[key];
     if (IsFullCustomEvents(customEventOptions)) {

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

@@ -12,6 +12,7 @@ import type { PageLifetimesOption } from "../../RootComponent/PageLifetimes/Page
 import type { PropertiesConstraint } from "../../RootComponent/Properties/PropertiesConstraint";
 import type { StoreConstraint } from "../../RootComponent/Store/StoreConstraint";
 import type { DefineComponentOption } from "..";
+import { __throttleDebounce__FieldCheck } from "./__throttleDebounce__FieldCheck";
 import { computedWatchHandle } from "./computedWatchHandle";
 import type { ComputedCache } from "./computedWatchHandle/initComputedAndGetCache";
 import { hijack } from "./hijackHandle";
@@ -101,10 +102,15 @@ export function normalizeOptions(
     watch: {},
     observers: {},
   };
+
   if (rootComponentOption && !isEmptyObject(rootComponentOption)) {
+    // 验证配置中是否有内部字段__throttleDebounce__,有则报错,因为在rootComponentOptionHandle中会加入__throttleDebounce__字段到data中
+    __throttleDebounce__FieldCheck(rootComponentOption);
     rootComponentOptionHandle(finalOptionsForComponent, sameFuncOptions, rootComponentOption);
   }
   if (subComponentsOption && !isEmptyObject(subComponentsOption)) {
+    // 验证配置中是否有内部字段__throttleDebounce__,有则报错,因为在rootComponentOptionHandle中会加入__throttleDebounce__字段到data中
+    __throttleDebounce__FieldCheck(subComponentsOption);
     subComponentsOptionHandle(finalOptionsForComponent, subComponentsOption, sameFuncOptions);
   }
   sameFuncOptionsHandle(finalOptionsForComponent, rootComponentOption?.isPage, sameFuncOptions);

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

@@ -3,7 +3,7 @@ import type { FinalOptionsOfComponent } from ".";
 // 内部字段
 const internalFiled = {
   methods: ["disposer", "__computedUpdater__"],
-  data: ["__computedCache__", "__storeConfig__", "__watchOldValue__"],
+  data: ["__computedCache__", "__storeConfig__", "__watchOldValue__"], // "__throttleDebounce__" 放在之前的位置验证
 };
 
 /**

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

@@ -31,7 +31,7 @@ export function sameFuncOptionsHandle(
       _sameFuncOptionsHandle(finalOptionsForComponent.pageLifetimes, funcOptions.pageLifetimes);
     }
   }
-  if (funcOptions.lifetimes) _sameFuncOptionsHandle(finalOptionsForComponent.lifetimes ||= {}, funcOptions.lifetimes);
+  if (funcOptions.lifetimes) _sameFuncOptionsHandle(finalOptionsForComponent.lifetimes, funcOptions.lifetimes);
 
-  if (funcOptions.watch) _sameFuncOptionsHandle(finalOptionsForComponent.watch ||= {}, funcOptions.watch);
+  if (funcOptions.watch) _sameFuncOptionsHandle(finalOptionsForComponent.watch, funcOptions.watch);
 }

package/src/api/SubComponent/SubComponentType.ts

@@ -9,7 +9,8 @@ type _SubComponentType = {
     | boolean
     | symbol
     | null
-    | Record<string, unknown>
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    | Record<string, any>
     | unknown[]
     | CustomEventsTags;
 };

package/src/utils/assertNonNullable.ts

@@ -1,5 +1,10 @@
 import type { IfContains } from "hry-types/src/Any/IfContains";
 
+/**
+ * 使用此函数代替!断言
+ * @param value 类型中必须包含 null 或 undefined
+ * @returns 去除 null 和 undefined 后的类型
+ */
 export function assertNonNullable<T>(
   value: IfContains<T, null | undefined, T, "参数类型必须包含 null 或 undefined">,
 ): NonNullable<T> {

package/src/utils/debounce.ts

@@ -1,14 +1,14 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
 /**
  * 防抖函数
- * 应用在输入框输入时，只有在输入完成并delay后,才会触发搜索
+ * 注意 需要在tsconfig.json的types中添加"node",否则NodeJS.Timeout会报错
+ * 例如 应用在输入框输入时，只有在输入完成并delay后,才会触发搜索,
  * @param func
  * @param delay
  * @returns
  */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function debounce<F extends (...args: any[]) => any>(func: F, delay: number): (...args: Parameters<F>) => void {
-  let timeoutId: any = null; // NodeJS.Timeout | null
+  let timeoutId: NodeJS.Timeout | null = null;
 
   return (...args: Parameters<F>): void => {
     if (timeoutId) {

package/src/utils/deepClone.ts

@@ -1,8 +1,8 @@
 /**
- * 深度克隆 函数相同 原型一致
+ * 数组和普通对象的深度克隆,原型相同
  */
 export function deepClone<T>(value: T): T {
-  if (typeof value !== "object" || value === null || value instanceof RegExp) {
+  if (typeof value !== "object" || value === null) {
     return value;
   }
 

package/src/utils/deepEqual.ts

@@ -1,11 +1,11 @@
 type PlainObject = Record<string, unknown>;
 // 非null的对象类型
-function isNonNullObject(value: unknown): boolean {
+function isNonNullObject(value: unknown): value is PlainObject {
   return value !== null && typeof value === "object";
 }
 
 export function deepEqual(value1: unknown, value2: unknown): boolean {
-  // 2个非对象类型相等或同引用对象的情况。
+  // 两个非对象类型相等或同引用对象的情况。
   if (Object.is(value1, value2)) {
     return true;
   }
@@ -13,18 +13,17 @@ export function deepEqual(value1: unknown, value2: unknown): boolean {
   if (!isNonNullObject(value1) || !isNonNullObject(value2)) {
     return false;
   }
-  // 到此，2个都是对象类型。
-  const _value1 = value1 as PlainObject;
-  const _value2 = value2 as PlainObject;
-  const value1Keys = Object.keys(_value1);
-  const value2Keys = Object.keys(_value2);
+  // 到此两个值都是对象类型。
+  const value1Keys = Object.keys(value1);
+  // 使用Set提高查找效率。
+  const value2KeysSet = new Set(Object.keys(value2));
 
-  if (value1Keys.length !== value2Keys.length) {
+  if (value1Keys.length !== value2KeysSet.size) {
     return false;
   }
 
   for (const key of value1Keys) {
-    if (!value2Keys.includes(key) || !deepEqual(_value1[key], _value2[key])) {
+    if (!value2KeysSet.has(key) || !deepEqual(value1[key], value2[key])) {
       return false;
     }
   }

package/src/utils/isEmptyObject.ts

@@ -1,13 +1,14 @@
 /**
- * 判断一个值是否为空对象 `{}`
+ * 判断一个值是否为空的普通对象 `{}`
+ * 有symblo和非枚举属性的对象会返回 `false`
  */
-export function isEmptyObject(obj: object): boolean {
+export function isEmptyObject(value: unknown): boolean {
   if (
-    typeof obj !== "object" || obj === null || Array.isArray(obj) || obj instanceof Set || obj instanceof Map
-    || obj instanceof WeakSet || obj instanceof WeakMap
+    typeof value !== "object" || value === null || Array.isArray(value) || value instanceof Set || value instanceof Map
+    || value instanceof WeakSet || value instanceof WeakMap
   ) {
     return false;
   }
 
-  return Reflect.ownKeys(obj).length === 0;
+  return Reflect.ownKeys(value).length === 0;
 }