@feng3d/reactivity 1.0.4 → 1.0.5

package/src/baseHandlers.ts

@@ -1,220 +1,220 @@
-import { arrayInstrumentations } from './arrayInstrumentations';
-import { reactive, reactiveMap } from './reactive';
-import { isRef } from './ref';
-import { ITERATE_KEY, ReactiveFlags, TrackOpTypes, TriggerOpTypes } from './shared/constants';
-import { hasChanged, hasOwn, isArray, isIntegerKey, isObject, isSymbol, makeMap, Target, toRaw } from './shared/general';
-import { PropertyReactivity } from './property';
-
-/**
- * 基础响应式处理器。
- */
-class BaseReactiveHandler implements ProxyHandler<Target>
-{
-    /**
-     * 获取对象的属性值。
-     *
-     * @param target 对象本身
-     * @param key 属性名
-     * @param receiver 代理对象
-     * @returns
-     */
-    get(target: Target, key: string | symbol, receiver: object): any
-    {
-        //
-        if (key === ReactiveFlags.IS_REACTIVE) // 判断是否为响应式对象
-        {
-            return true;
-        }
-        else if (key === ReactiveFlags.RAW) // 获取原始对象
-        {
-            if (
-                receiver
-                === reactiveMap.get(target)
-                // receiver is not the reactive proxy, but has the same prototype
-                // this means the receiver is a user proxy of the reactive proxy
-                || Object.getPrototypeOf(target) === Object.getPrototypeOf(receiver)
-            )
-            {
-                return target;
-            }
-            // early return undefined
-
-            return;
-        }
-
-        const targetIsArray = isArray(target);
-
-        let fn: Function | undefined;
-        if (targetIsArray && (fn = arrayInstrumentations[key]))
-        {
-            return fn;
-        }
-        if (key === 'hasOwnProperty')
-        {
-            return hasOwnProperty;
-        }
-
-        const res = Reflect.get(
-            target,
-            key,
-            isRef(target) ? target : receiver,
-        );
-
-        if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key))
-        {
-            return res;
-        }
-
-        //
-        PropertyReactivity.track(target, TrackOpTypes.GET, key as any);
-
-        // 如果是 ref，则返回 ref.value
-        if (isRef(res))
-        {
-            return targetIsArray && isIntegerKey(key) ? res : res.value;
-        }
-
-        // 如果是对象，则递归响应式化
-        if (isObject(res))
-        {
-            return reactive(res);
-        }
-
-        return res;
-    }
-}
-
-/**
- * 可变响应式处理器。
- */
-class MutableReactiveHandler extends BaseReactiveHandler
-{
-    /**
-     * 设置对象的属性值。
-     * @param target 被代理的对象。
-     * @param key 属性名。
-     * @param value 新值。
-     * @param receiver 代理对象。
-     * @returns 设置是否成功。
-     */
-    set(
-        target: Record<string | symbol, unknown>,
-        key: string | symbol,
-        value: unknown,
-        receiver: object,
-    ): boolean
-    {
-        let oldValue = target[key];
-
-        oldValue = toRaw(oldValue);
-        value = toRaw(value);
-
-        if (!isArray(target) && isRef(oldValue) && !isRef(value))
-        {
-            oldValue.value = value;
-
-            return true;
-        }
-
-        const hadKey
-            = isArray(target) && isIntegerKey(key)
-                ? Number(key) < target.length
-                : hasOwn(target, key);
-        const result = Reflect.set(
-            target,
-            key,
-            value,
-            isRef(target) ? target : receiver,
-        );
-        //
-        __DEV__ && console.assert(target === toRaw(receiver));
-
-        // 如果目标在原始原型链中，则不要触发
-        if (target === toRaw(receiver))
-        {
-            if (!hadKey)
-            {
-                PropertyReactivity.trigger(target, TriggerOpTypes.ADD, key, value);
-            }
-            else if (hasChanged(value, oldValue))
-            {
-                PropertyReactivity.trigger(target, TriggerOpTypes.SET, key, value, oldValue);
-            }
-        }
-
-        return result;
-    }
-
-    /**
-     * 删除对象的属性。
-     *
-     * @param target 被代理的对象。
-     * @param key 属性名。
-     * @returns 删除是否成功。
-     */
-    deleteProperty(
-        target: Record<string | symbol, unknown>,
-        key: string | symbol,
-    ): boolean
-    {
-        const hadKey = hasOwn(target, key);
-        const oldValue = target[key];
-        const result = Reflect.deleteProperty(target, key);
-        if (result && hadKey)
-        {
-            PropertyReactivity.trigger(target, TriggerOpTypes.DELETE, key, undefined, oldValue);
-        }
-
-        return result;
-    }
-
-    has(target: Record<string | symbol, unknown>, key: string | symbol): boolean
-    {
-        const result = Reflect.has(target, key);
-        if (!isSymbol(key) || !builtInSymbols.has(key))
-        {
-            PropertyReactivity.track(target, TrackOpTypes.HAS, key);
-        }
-
-        return result;
-    }
-
-    ownKeys(target: Record<string | symbol, unknown>): (string | symbol)[]
-    {
-        PropertyReactivity.track(
-            target,
-            TrackOpTypes.ITERATE,
-            isArray(target) ? 'length' : ITERATE_KEY,
-        );
-
-        return Reflect.ownKeys(target);
-    }
-}
-
-/**
- * 可变响应式处理器。
- */
-export const mutableHandlers: ProxyHandler<object> = new MutableReactiveHandler();
-
-function hasOwnProperty(this: object, key: unknown)
-{
-    // #10455 hasOwnProperty may be called with non-string values
-    if (!isSymbol(key)) key = String(key);
-    const obj = toRaw(this);
-    PropertyReactivity.track(obj, TrackOpTypes.HAS, key);
-
-    return obj.hasOwnProperty(key as string);
-}
-
-const builtInSymbols = new Set(
-    /* @__PURE__*/
-    Object.getOwnPropertyNames(Symbol)
-        // ios10.x Object.getOwnPropertyNames(Symbol) can enumerate 'arguments' and 'caller'
-        // but accessing them on Symbol leads to TypeError because Symbol is a strict mode
-        // function
-        .filter((key) => key !== 'arguments' && key !== 'caller')
-        .map((key) => Symbol[key as keyof SymbolConstructor])
-        .filter(isSymbol),
-);
-
-const isNonTrackableKeys = /* @__PURE__*/ makeMap(`__proto__,__v_isRef,__isVue`);
+import { arrayInstrumentations } from './arrayInstrumentations';
+import { reactive, reactiveMap } from './reactive';
+import { isRef } from './ref';
+import { ITERATE_KEY, ReactiveFlags, TrackOpTypes, TriggerOpTypes } from './shared/constants';
+import { hasChanged, hasOwn, isArray, isIntegerKey, isObject, isSymbol, makeMap, Target, toRaw } from './shared/general';
+import { PropertyReactivity } from './property';
+
+/**
+ * 基础响应式处理器。
+ */
+class BaseReactiveHandler implements ProxyHandler<Target>
+{
+    /**
+     * 获取对象的属性值。
+     *
+     * @param target 对象本身
+     * @param key 属性名
+     * @param receiver 代理对象
+     * @returns
+     */
+    get(target: Target, key: string | symbol, receiver: object): any
+    {
+        //
+        if (key === ReactiveFlags.IS_REACTIVE) // 判断是否为响应式对象
+        {
+            return true;
+        }
+        else if (key === ReactiveFlags.RAW) // 获取原始对象
+        {
+            if (
+                receiver
+                === reactiveMap.get(target)
+                // receiver is not the reactive proxy, but has the same prototype
+                // this means the receiver is a user proxy of the reactive proxy
+                || Object.getPrototypeOf(target) === Object.getPrototypeOf(receiver)
+            )
+            {
+                return target;
+            }
+            // early return undefined
+
+            return;
+        }
+
+        const targetIsArray = isArray(target);
+
+        let fn: Function | undefined;
+        if (targetIsArray && (fn = arrayInstrumentations[key]))
+        {
+            return fn;
+        }
+        if (key === 'hasOwnProperty')
+        {
+            return hasOwnProperty;
+        }
+
+        const res = Reflect.get(
+            target,
+            key,
+            isRef(target) ? target : receiver,
+        );
+
+        if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key))
+        {
+            return res;
+        }
+
+        //
+        PropertyReactivity.track(target, TrackOpTypes.GET, key as any);
+
+        // 如果是 ref，则返回 ref.value
+        if (isRef(res))
+        {
+            return targetIsArray && isIntegerKey(key) ? res : res.value;
+        }
+
+        // 如果是对象，则递归响应式化
+        if (isObject(res))
+        {
+            return reactive(res);
+        }
+
+        return res;
+    }
+}
+
+/**
+ * 可变响应式处理器。
+ */
+class MutableReactiveHandler extends BaseReactiveHandler
+{
+    /**
+     * 设置对象的属性值。
+     * @param target 被代理的对象。
+     * @param key 属性名。
+     * @param value 新值。
+     * @param receiver 代理对象。
+     * @returns 设置是否成功。
+     */
+    set(
+        target: Record<string | symbol, unknown>,
+        key: string | symbol,
+        value: unknown,
+        receiver: object,
+    ): boolean
+    {
+        let oldValue = target[key];
+
+        oldValue = toRaw(oldValue);
+        value = toRaw(value);
+
+        if (!isArray(target) && isRef(oldValue) && !isRef(value))
+        {
+            oldValue.value = value;
+
+            return true;
+        }
+
+        const hadKey
+            = isArray(target) && isIntegerKey(key)
+                ? Number(key) < target.length
+                : hasOwn(target, key);
+        const result = Reflect.set(
+            target,
+            key,
+            value,
+            isRef(target) ? target : receiver,
+        );
+        //
+        __DEV__ && console.assert(target === toRaw(receiver));
+
+        // 如果目标在原始原型链中，则不要触发
+        if (target === toRaw(receiver))
+        {
+            if (!hadKey)
+            {
+                PropertyReactivity.trigger(target, TriggerOpTypes.ADD, key, value);
+            }
+            else if (hasChanged(value, oldValue))
+            {
+                PropertyReactivity.trigger(target, TriggerOpTypes.SET, key, value, oldValue);
+            }
+        }
+
+        return result;
+    }
+
+    /**
+     * 删除对象的属性。
+     *
+     * @param target 被代理的对象。
+     * @param key 属性名。
+     * @returns 删除是否成功。
+     */
+    deleteProperty(
+        target: Record<string | symbol, unknown>,
+        key: string | symbol,
+    ): boolean
+    {
+        const hadKey = hasOwn(target, key);
+        const oldValue = target[key];
+        const result = Reflect.deleteProperty(target, key);
+        if (result && hadKey)
+        {
+            PropertyReactivity.trigger(target, TriggerOpTypes.DELETE, key, undefined, oldValue);
+        }
+
+        return result;
+    }
+
+    has(target: Record<string | symbol, unknown>, key: string | symbol): boolean
+    {
+        const result = Reflect.has(target, key);
+        if (!isSymbol(key) || !builtInSymbols.has(key))
+        {
+            PropertyReactivity.track(target, TrackOpTypes.HAS, key);
+        }
+
+        return result;
+    }
+
+    ownKeys(target: Record<string | symbol, unknown>): (string | symbol)[]
+    {
+        PropertyReactivity.track(
+            target,
+            TrackOpTypes.ITERATE,
+            isArray(target) ? 'length' : ITERATE_KEY,
+        );
+
+        return Reflect.ownKeys(target);
+    }
+}
+
+/**
+ * 可变响应式处理器。
+ */
+export const mutableHandlers: ProxyHandler<object> = new MutableReactiveHandler();
+
+function hasOwnProperty(this: object, key: unknown)
+{
+    // #10455 hasOwnProperty may be called with non-string values
+    if (!isSymbol(key)) key = String(key);
+    const obj = toRaw(this);
+    PropertyReactivity.track(obj, TrackOpTypes.HAS, key);
+
+    return obj.hasOwnProperty(key as string);
+}
+
+const builtInSymbols = new Set(
+    /* @__PURE__*/
+    Object.getOwnPropertyNames(Symbol)
+        // ios10.x Object.getOwnPropertyNames(Symbol) can enumerate 'arguments' and 'caller'
+        // but accessing them on Symbol leads to TypeError because Symbol is a strict mode
+        // function
+        .filter((key) => key !== 'arguments' && key !== 'caller')
+        .map((key) => Symbol[key as keyof SymbolConstructor])
+        .filter(isSymbol),
+);
+
+const isNonTrackableKeys = /* @__PURE__*/ makeMap(`__proto__,__v_isRef,__isVue`);

package/src/batch.ts

@@ -1,91 +1,91 @@
-import { ComputedReactivity } from './computed';
-import { Reactivity } from './Reactivity';
-
-/**
- * 合批处理。
- *
- * @param dep 要处理的依赖。
- * @param isRunning 添加时是否是正在运行。
- */
-export function batch(dep: ComputedReactivity, isRunning: boolean): void
-{
-    if (isRunning)
-    {
-        _isRunedDeps.push(dep);
-    }
-    else
-    {
-        _needEffectDeps.push(dep);
-    }
-}
-
-/**
- * 批次执行多次修改反应式对象，可以减少不必要的反应式触发。
- *
- * ```ts
- * batchRun(() => {
- *     // 修改反应式对象
- *     reactiveObj.a = 1;
- *     reactiveObj.b = 2;
- * })
- * ```
- *
- * @param fn 要执行的函数，在此函数中多次修改反应式对象。
- */
-export function batchRun<T>(fn: () => T): T
-{
-    _batchDepth++;
-
-    const result = fn();
-
-    if (--_batchDepth > 0)
-    {
-        return;
-    }
-
-    // 处理已经运行过的依赖，
-    if (_isRunedDeps.length > 0)
-    {
-        _isRunedDeps.forEach((dep) =>
-        {
-            // 此时依赖以及子依赖都已经运行过了，只需修复与子节点关系。
-            __DEV__ && console.assert(dep._isDirty === false, 'dep.dirty === false');
-
-            // 修复与子节点关系
-            dep._children.forEach((version, node) =>
-            {
-                node._parents.set(dep, dep._version);
-            });
-            dep._children.clear();
-        });
-        _isRunedDeps.length = 0;
-    }
-
-    // 批次处理
-    if (_needEffectDeps.length > 0)
-    {
-        _needEffectDeps.forEach((dep) =>
-        {
-            // 独立执行回调
-            const pre = Reactivity.activeReactivity;
-            Reactivity.activeReactivity = null;
-
-            dep.runIfDirty();
-
-            Reactivity.activeReactivity = pre;
-        });
-        _needEffectDeps.length = 0;
-    }
-
-    return result;
-}
-
-let _batchDepth = 0;
-/**
- * 正在运行的依赖。
- */
-const _needEffectDeps: ComputedReactivity[] = [];
-/**
- * 已经运行过的依赖，只需要修复与子节点关系。
- */
-const _isRunedDeps: ComputedReactivity[] = [];
+import { ComputedReactivity } from './computed';
+import { Reactivity } from './Reactivity';
+
+/**
+ * 合批处理。
+ *
+ * @param dep 要处理的依赖。
+ * @param isRunning 添加时是否是正在运行。
+ */
+export function batch(dep: ComputedReactivity, isRunning: boolean): void
+{
+    if (isRunning)
+    {
+        _isRunedDeps.push(dep);
+    }
+    else
+    {
+        _needEffectDeps.push(dep);
+    }
+}
+
+/**
+ * 批次执行多次修改反应式对象，可以减少不必要的反应式触发。
+ *
+ * ```ts
+ * batchRun(() => {
+ *     // 修改反应式对象
+ *     reactiveObj.a = 1;
+ *     reactiveObj.b = 2;
+ * })
+ * ```
+ *
+ * @param fn 要执行的函数，在此函数中多次修改反应式对象。
+ */
+export function batchRun<T>(fn: () => T): T
+{
+    _batchDepth++;
+
+    const result = fn();
+
+    if (--_batchDepth > 0)
+    {
+        return;
+    }
+
+    // 处理已经运行过的依赖，
+    if (_isRunedDeps.length > 0)
+    {
+        _isRunedDeps.forEach((dep) =>
+        {
+            // 此时依赖以及子依赖都已经运行过了，只需修复与子节点关系。
+            __DEV__ && console.assert(dep._isDirty === false, 'dep.dirty === false');
+
+            // 修复与子节点关系
+            dep._children.forEach((version, node) =>
+            {
+                node._parents.set(dep, dep._version);
+            });
+            dep._children.clear();
+        });
+        _isRunedDeps.length = 0;
+    }
+
+    // 批次处理
+    if (_needEffectDeps.length > 0)
+    {
+        _needEffectDeps.forEach((dep) =>
+        {
+            // 独立执行回调
+            const pre = Reactivity.activeReactivity;
+            Reactivity.activeReactivity = null;
+
+            dep.runIfDirty();
+
+            Reactivity.activeReactivity = pre;
+        });
+        _needEffectDeps.length = 0;
+    }
+
+    return result;
+}
+
+let _batchDepth = 0;
+/**
+ * 正在运行的依赖。
+ */
+const _needEffectDeps: ComputedReactivity[] = [];
+/**
+ * 已经运行过的依赖，只需要修复与子节点关系。
+ */
+const _isRunedDeps: ComputedReactivity[] = [];