@lytjs/reactivity 6.0.0 → 6.4.0

package/dist/index.d.cts

@@ -1,8 +1,8 @@
-import { U as UnwrapNestedRefs, D as DeepReadonly, C as ComputedGetter, W as WritableComputedOptions, a as WritableComputedRef, b as WatchSource, c as WatchCallbackWithImmediate, d as WatchOptions, e as WatchHandle, O as OnCleanup, f as WatchEffectOptions } from './types-CMYee6LB.cjs';
-export { g as ComputedSetter, h as DebuggerEvent, R as ReactiveEffectOptions, i as ReactiveEffectRunner, j as ReactiveObject, T as ToRefs, k as UnwrapRef, l as WatchCallback, m as batch, n as batchAsync, o as effect, p as enableTracking, q as getSkippedTrackingCount, r as onEffectCleanup, s as pauseTracking, t as resetSkippedTrackingCount, u as resetTracking, v as shouldSkipTracking, w as stop, x as untrack, y as withFirstRenderOptimization } from './types-CMYee6LB.cjs';
+import { U as UnwrapNestedRefs, b as DeepReadonly, C as ComputedGetter, l as WritableComputedOptions, m as WritableComputedRef, k as WatchSource, g as WatchCallbackWithImmediate, j as WatchOptions, i as WatchHandle, O as OnCleanup, h as WatchEffectOptions } from './scope-BC3djHz7.cjs';
+export { a as ComputedSetter, D as DebuggerEvent, E as EffectScope, c as EffectScopeOptions, R as ReactiveEffectOptions, d as ReactiveEffectRunner, e as ReactiveObject, T as ToRefs, f as UnwrapRef, W as WatchCallback, n as batch, o as batchAsync, p as effect, q as effectScope, r as enableTracking, s as getCurrentScope, t as getSkippedTrackingCount, u as onEffectCleanup, v as onScopeDispose, w as pauseTracking, x as resetSkippedTrackingCount, y as resetTracking, z as shouldSkipTracking, A as stop, B as untrack, F as withFirstRenderOptimization } from './scope-BC3djHz7.cjs';
 import { C as ComputedRef } from './ref-CwOCKoy2.cjs';
 export { R as Ref, S as ShallowRef, c as customRef, i as isComputedRef, a as isShallowRef, r as ref, s as shallowRef, t as toRef, b as toRefs, d as toValue, e as triggerRef, u as unref } from './ref-CwOCKoy2.cjs';
-export { C as ComputedRefSymbol, a as ComputedSignal, R as ReactiveSymbol, b as ReadonlySignal, c as ReadonlySymbol, d as RefSymbol, S as ShallowRefSymbol, e as Signal, f as Subscriber, W as WritableComputedSignal, g as WritableSignal, h as computedSignal, r as readonlySignal, s as set, i as signal, j as signalBatch, k as signalComputed, l as signalUntrack, u as update, v as valueOf, w as writableComputedSignal } from './signal-BOAyevht.cjs';
+export { C as ComputedRefSymbol, a as ComputedSignal, R as ReactiveSymbol, b as ReadonlySignal, c as ReadonlySymbol, d as RefSymbol, S as ShallowRefSymbol, e as Signal, f as Subscriber, W as WritableComputedSignal, g as WritableSignal, m as computedSignal, r as readonlySignal, s as set, n as signal, o as signalBatch, l as signalComputed, p as signalUntrack, u as update, v as valueOf, w as writableComputedSignal } from './signal-DWrUYmvd.cjs';
 import { RefLike } from '@lytjs/shared-types';
 
 /**

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-import { U as UnwrapNestedRefs, D as DeepReadonly, C as ComputedGetter, W as WritableComputedOptions, a as WritableComputedRef, b as WatchSource, c as WatchCallbackWithImmediate, d as WatchOptions, e as WatchHandle, O as OnCleanup, f as WatchEffectOptions } from './types-CXeWWYm6.js';
-export { g as ComputedSetter, h as DebuggerEvent, R as ReactiveEffectOptions, i as ReactiveEffectRunner, j as ReactiveObject, T as ToRefs, k as UnwrapRef, l as WatchCallback, m as batch, n as batchAsync, o as effect, p as enableTracking, q as getSkippedTrackingCount, r as onEffectCleanup, s as pauseTracking, t as resetSkippedTrackingCount, u as resetTracking, v as shouldSkipTracking, w as stop, x as untrack, y as withFirstRenderOptimization } from './types-CXeWWYm6.js';
+import { U as UnwrapNestedRefs, b as DeepReadonly, C as ComputedGetter, l as WritableComputedOptions, m as WritableComputedRef, k as WatchSource, g as WatchCallbackWithImmediate, j as WatchOptions, i as WatchHandle, O as OnCleanup, h as WatchEffectOptions } from './scope-CTxSo201.js';
+export { a as ComputedSetter, D as DebuggerEvent, E as EffectScope, c as EffectScopeOptions, R as ReactiveEffectOptions, d as ReactiveEffectRunner, e as ReactiveObject, T as ToRefs, f as UnwrapRef, W as WatchCallback, n as batch, o as batchAsync, p as effect, q as effectScope, r as enableTracking, s as getCurrentScope, t as getSkippedTrackingCount, u as onEffectCleanup, v as onScopeDispose, w as pauseTracking, x as resetSkippedTrackingCount, y as resetTracking, z as shouldSkipTracking, A as stop, B as untrack, F as withFirstRenderOptimization } from './scope-CTxSo201.js';
 import { C as ComputedRef } from './ref-CwOCKoy2.js';
 export { R as Ref, S as ShallowRef, c as customRef, i as isComputedRef, a as isShallowRef, r as ref, s as shallowRef, t as toRef, b as toRefs, d as toValue, e as triggerRef, u as unref } from './ref-CwOCKoy2.js';
-export { C as ComputedRefSymbol, a as ComputedSignal, R as ReactiveSymbol, b as ReadonlySignal, c as ReadonlySymbol, d as RefSymbol, S as ShallowRefSymbol, e as Signal, f as Subscriber, W as WritableComputedSignal, g as WritableSignal, h as computedSignal, r as readonlySignal, s as set, i as signal, j as signalBatch, k as signalComputed, l as signalUntrack, u as update, v as valueOf, w as writableComputedSignal } from './signal-BOAyevht.js';
+export { C as ComputedRefSymbol, a as ComputedSignal, R as ReactiveSymbol, b as ReadonlySignal, c as ReadonlySymbol, d as RefSymbol, S as ShallowRefSymbol, e as Signal, f as Subscriber, W as WritableComputedSignal, g as WritableSignal, m as computedSignal, r as readonlySignal, s as set, n as signal, o as signalBatch, l as signalComputed, p as signalUntrack, u as update, v as valueOf, w as writableComputedSignal } from './signal-DWrUYmvd.js';
 import { RefLike } from '@lytjs/shared-types';
 
 /**

package/dist/index.mjs

@@ -222,7 +222,7 @@ function notifySubscribers(subscribers, store, signalKey, newValue) {
     next = it.next();
   }
   if (store && signalKey !== void 0) {
-    trigger(store, TriggerOpTypes.SET, signalKey);
+    trigger(store, TriggerOpTypes.SET, signalKey, newValue);
   }
 }
 function flushPendingNotifications() {
@@ -278,6 +278,71 @@ function readonlySignal(sig) {
   Object.defineProperty(readonlyFn, SignalSymbol, { value: true });
   return readonlyFn;
 }
+var activeEffectScope;
+function getActiveEffectScope() {
+  return activeEffectScope;
+}
+function effectScope(options) {
+  const detached = typeof options === "boolean" ? options : options?.detached;
+  const scope = {
+    active: true,
+    effects: [],
+    cleanups: [],
+    parent: activeEffectScope,
+    detached: !!detached,
+    run(fn) {
+      if (!this.active) {
+        return;
+      }
+      const prevScope = activeEffectScope;
+      activeEffectScope = this;
+      try {
+        return fn();
+      } finally {
+        activeEffectScope = prevScope;
+      }
+    },
+    stop() {
+      if (!this.active) return;
+      this.active = false;
+      for (const effect2 of this.effects) {
+        try {
+          effect2.stop();
+        } catch (e) {
+          error(`Error stopping effect in scope: ${String(e)}`);
+        }
+      }
+      for (const cleanup of this.cleanups) {
+        try {
+          cleanup();
+        } catch (e) {
+          error(`Error running cleanup in scope: ${String(e)}`);
+        }
+      }
+      if (this.parent) {
+        const idx = this.parent.effects.indexOf(unsafeCast(this));
+        if (idx !== -1) {
+          this.parent.effects.splice(idx, 1);
+        }
+      }
+      this.effects.length = 0;
+      this.cleanups.length = 0;
+      this.parent = void 0;
+    }
+  };
+  if (!scope.detached && activeEffectScope) {
+    activeEffectScope.effects.push(unsafeCast(scope));
+  }
+  return scope;
+}
+function getCurrentScope() {
+  return activeEffectScope;
+}
+function onScopeDispose(fn) {
+  if (activeEffectScope) {
+    activeEffectScope.cleanups.push(fn);
+  }
+}
 var activeEffect;
 var _trackDepth = 0;
 var targetMap = /* @__PURE__ */ new WeakMap();
@@ -338,7 +403,7 @@ function trackEffect(dep) {
     activeEffect.deps.push(dep);
   }
 }
-function trigger(target, type, key, _newValue, _oldValue) {
+function trigger(target, type, key, newValue, oldValue) {
   const depsMap = targetMap.get(target);
   if (!depsMap) return;
   const deps = [];
@@ -372,9 +437,9 @@ function trigger(target, type, key, _newValue, _oldValue) {
       }
     }
   }
-  triggerEffects([...new Set(effects)]);
+  triggerEffects([...new Set(effects)], target, type, key, newValue, oldValue);
 }
-function triggerEffects(effects) {
+function triggerEffects(effects, target, type, key, newValue, oldValue) {
   if (triggerDepth > REACTIVITY_MAX_TRIGGER_DEPTH) {
     return;
   }
@@ -382,19 +447,19 @@ function triggerEffects(effects) {
   try {
     for (const effect2 of effects) {
       if (effect2.computed) {
-        triggerEffect(effect2);
+        triggerEffect(effect2, target, type, key, newValue, oldValue);
       }
     }
     for (const effect2 of effects) {
       if (!effect2.computed) {
-        triggerEffect(effect2);
+        triggerEffect(effect2, target, type, key, newValue, oldValue);
       }
     }
   } finally {
     triggerDepth--;
   }
 }
-function triggerEffect(effect2) {
+function triggerEffect(effect2, target, type, key, newValue, oldValue) {
   if (effect2 !== activeEffect || effect2.allowRecurse) {
     if (effect2.scheduler) {
       effect2.scheduler();
@@ -412,6 +477,10 @@ var ReactiveEffect = class {
     this.parent = void 0;
     // 运行前清理（onEffectCleanup 注册的）
     this._cleanups = [];
+    const scope = getActiveEffectScope();
+    if (scope && scope.active) {
+      scope.effects.push(this);
+    }
   }
   run() {
     if (!this.active) {
@@ -707,9 +776,9 @@ function createMutableHandler(isReadonly2, isShallow) {
       const result = Reflect.set(target, key, value, receiver);
       if (target === toRaw(receiver)) {
         if (!hadKey) {
-          trigger(target, TriggerOpTypes.ADD, key);
+          trigger(target, TriggerOpTypes.ADD, key, value);
         } else if (hasChanged(value, oldValue)) {
-          trigger(target, TriggerOpTypes.SET, key);
+          trigger(target, TriggerOpTypes.SET, key, value, oldValue);
         }
       }
       return result;
@@ -719,10 +788,10 @@ function createMutableHandler(isReadonly2, isShallow) {
         return true;
       }
       const hadKey = hasOwn(target, key);
-      Reflect.get(target, key);
+      const oldValue = Reflect.get(target, key);
       const result = Reflect.deleteProperty(target, key);
       if (result && hadKey) {
-        trigger(target, TriggerOpTypes.DELETE, key);
+        trigger(target, TriggerOpTypes.DELETE, key, void 0, oldValue);
       }
       return result;
     },
@@ -784,7 +853,7 @@ function createCollectionHandler(isReadonly2, isShallow) {
                 if (!hadKey || !Object.is(toRaw(oldValue), toRaw(args[1]))) {
                   const triggerKey = toTriggerKey(args[0]);
                   if (triggerKey !== void 0) {
-                    trigger(target, TriggerOpTypes.SET, triggerKey, args[1]);
+                    trigger(target, TriggerOpTypes.SET, triggerKey, args[1], oldValue);
                   }
                 }
                 return result2;
@@ -805,7 +874,7 @@ function createCollectionHandler(isReadonly2, isShallow) {
                 if (hadKey) {
                   const triggerKey = toTriggerKey(args[0]);
                   if (triggerKey !== void 0) {
-                    trigger(target, TriggerOpTypes.DELETE, triggerKey);
+                    trigger(target, TriggerOpTypes.DELETE, triggerKey, void 0, void 0);
                   }
                   trigger(target, TriggerOpTypes.DELETE, ITERATE_KEY);
                 }
@@ -814,7 +883,7 @@ function createCollectionHandler(isReadonly2, isShallow) {
                 const hadItems = rawTarget.size > 0;
                 const result2 = res.apply(target, args);
                 if (hadItems) {
-                  trigger(target, TriggerOpTypes.CLEAR, void 0);
+                  trigger(target, TriggerOpTypes.CLEAR, void 0, void 0, void 0);
                 }
                 return result2;
               }
@@ -932,10 +1001,10 @@ var RefImpl = class {
     const useDirectValue = this.__v_isShallow;
     newVal = useDirectValue ? newVal : toRaw(newVal);
     if (hasChanged(newVal, this._rawValue)) {
-      this._rawValue;
+      const oldVal = this._rawValue;
       this._rawValue = newVal;
       this._value = useDirectValue ? newVal : toReactive(newVal);
-      triggerRefValue(this);
+      triggerRefValue(this, newVal, oldVal);
     }
   }
 };
@@ -954,10 +1023,10 @@ var ShallowRefImpl = class {
   }
   set value(newVal) {
     if (hasChanged(newVal, this._rawValue)) {
-      this._rawValue;
+      const oldVal = this._rawValue;
       this._rawValue = newVal;
       this._value = newVal;
-      triggerRefValue(this);
+      triggerRefValue(this, newVal, oldVal);
     }
   }
 };
@@ -967,7 +1036,7 @@ function trackRefValue(ref2) {
   }
 }
 function triggerRefValue(ref2, newVal, oldVal) {
-  trigger(ref2, TriggerOpTypes.SET, "value");
+  trigger(ref2, TriggerOpTypes.SET, "value", newVal, oldVal);
 }
 function ref(value) {
   if (isRef(value)) {
@@ -1538,6 +1607,6 @@ function _notifyDevToolsEffectRun(effectId) {
   return;
 }
 
-export { ComputedRefSymbol, ReactiveSymbol, ReadonlySymbol, RefSymbol, ShallowRefSymbol, _notifyDevToolsEffectRun, _notifyDevToolsSignalChange, batch, batchAsync, batchScope, batchScopeAsync, batchScopeUntrack, computed2 as computed, computedSignal, customRef, effect, enableTracking, flushBatchScopes, getBatchScopeDepth, getCurrentBatchScopeStack, getSkippedTrackingCount, isComputedRef, isInBatchScope, isProxy, isReactive, isReadonly, isRef, isShallowRef, markRaw, onEffectCleanup, pauseTracking, reactive, readonly, readonlySignal, ref, resetSkippedTrackingCount, resetTracking, set, setSSRMode, shallowReactive, shallowReadonly, shallowRef, shouldSkipTracking, signal, signalBatch, computed as signalComputed, signalUntrack, stop, toRaw, toRef, toRefs, toValue, triggerRef, unref, untrack, update, valueOf, watch, watchEffect, watchPostEffect, watchSyncEffect, withFirstRenderOptimization, writableComputedSignal };
+export { ComputedRefSymbol, ReactiveSymbol, ReadonlySymbol, RefSymbol, ShallowRefSymbol, _notifyDevToolsEffectRun, _notifyDevToolsSignalChange, batch, batchAsync, batchScope, batchScopeAsync, batchScopeUntrack, computed2 as computed, computedSignal, customRef, effect, effectScope, enableTracking, flushBatchScopes, getBatchScopeDepth, getCurrentBatchScopeStack, getCurrentScope, getSkippedTrackingCount, isComputedRef, isInBatchScope, isProxy, isReactive, isReadonly, isRef, isShallowRef, markRaw, onEffectCleanup, onScopeDispose, pauseTracking, reactive, readonly, readonlySignal, ref, resetSkippedTrackingCount, resetTracking, set, setSSRMode, shallowReactive, shallowReadonly, shallowRef, shouldSkipTracking, signal, signalBatch, computed as signalComputed, signalUntrack, stop, toRaw, toRef, toRefs, toValue, triggerRef, unref, untrack, update, valueOf, watch, watchEffect, watchPostEffect, watchSyncEffect, withFirstRenderOptimization, writableComputedSignal };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map