@lytjs/reactivity 6.0.0 → 6.4.0

package/dist/{types-CMYee6LB.d.cts → scope-BC3djHz7.d.cts}

@@ -50,13 +50,15 @@ declare class ReactiveEffect<T = unknown> {
     allowRecurse?: boolean;
     onStop?: () => void;
     onTrack?: (event: {
+        effect: ReactiveEffect;
         target: object;
-        key: string | symbol;
+        key?: string | symbol;
         type: string;
     }) => void;
     onTrigger?: (event: {
+        effect: ReactiveEffect;
         target: object;
-        key: string | symbol;
+        key?: string | symbol;
         type: string;
         newValue?: unknown;
         oldValue?: unknown;
@@ -89,13 +91,15 @@ declare function effect(fn: () => void, options?: {
     allowRecurse?: boolean;
     onStop?: () => void;
     onTrack?: (event: {
+        effect: ReactiveEffect;
         target: object;
-        key: string | symbol;
+        key?: string | symbol;
         type: string;
     }) => void;
     onTrigger?: (event: {
+        effect: ReactiveEffect;
         target: object;
-        key: string | symbol;
+        key?: string | symbol;
         type: string;
         newValue?: unknown;
         oldValue?: unknown;
@@ -107,13 +111,15 @@ declare function effect<T>(fn: () => T, options: {
     allowRecurse?: boolean;
     onStop?: () => void;
     onTrack?: (event: {
+        effect: ReactiveEffect;
         target: object;
-        key: string | symbol;
+        key?: string | symbol;
         type: string;
     }) => void;
     onTrigger?: (event: {
+        effect: ReactiveEffect;
         target: object;
-        key: string | symbol;
+        key?: string | symbol;
         type: string;
         newValue?: unknown;
         oldValue?: unknown;
@@ -212,7 +218,9 @@ interface DebuggerEvent {
     effect: ReactiveEffect;
     target: object;
     type: 'track' | 'trigger';
-    key: unknown;
+    key?: string | symbol;
+    newValue?: unknown;
+    oldValue?: unknown;
 }
 interface WatchOptions<Immediate = boolean> {
     immediate?: Immediate;
@@ -267,4 +275,71 @@ type ReactiveObject<T extends object = object> = {
     __v_isReactive: true;
 };
 
-export { type ComputedGetter as C, type DeepReadonly as D, type OnCleanup as O, type ReactiveEffectOptions as R, type ToRefs as T, type UnwrapNestedRefs as U, type WritableComputedOptions as W, type WritableComputedRef as a, type WatchSource as b, type WatchCallbackWithImmediate as c, type WatchOptions as d, type WatchHandle as e, type WatchEffectOptions as f, type ComputedSetter as g, type DebuggerEvent as h, type ReactiveEffectRunner as i, type ReactiveObject as j, type UnwrapRef as k, type WatchCallback as l, batch as m, batchAsync as n, effect as o, enableTracking as p, getSkippedTrackingCount as q, onEffectCleanup as r, pauseTracking as s, resetSkippedTrackingCount as t, resetTracking as u, shouldSkipTracking as v, stop as w, untrack as x, withFirstRenderOptimization as y, ReactiveEffect as z };
+/**
+ * effectScope 收集的条目类型
+ * - ReactiveEffect: 响应式副作用
+ * - EffectScope: 嵌套的子 scope
+ */
+type EffectScopeEntry = ReactiveEffect | EffectScope;
+
+interface EffectScope {
+    /** 当前 scope 是否活跃 */
+    active: boolean;
+    /** scope 收集的 effects */
+    effects: EffectScopeEntry[];
+    /** scope 注册的清理回调 */
+    cleanups: (() => void)[];
+    /** 父 scope（嵌套时自动关联） */
+    parent: EffectScope | undefined;
+    /** 是否脱离父 scope（detached scope 不会被父 scope stop） */
+    detached: boolean;
+    /** 在 scope 上下文中执行 fn，期间创建的 effect 会被自动收集 */
+    run<T>(fn: () => T): T | undefined;
+    /** 停止 scope，清理所有收集的 effects 和 cleanups */
+    stop(): void;
+}
+interface EffectScopeOptions {
+    detached?: boolean;
+}
+/**
+ * 创建一个 effect scope，用于批量管理响应式副作用。
+ *
+ * @param options - 配置选项。支持传入 boolean（兼容旧 API）或 EffectScopeOptions 对象。
+ * @returns EffectScope 实例
+ *
+ * @example
+ * ```ts
+ * const scope = effectScope()
+ * scope.run(() => {
+ *   const count = ref(0)
+ *   watch(count, () => console.log(count.value))
+ * })
+ * // 不再需要时一次性停止所有副作用
+ * scope.stop()
+ * ```
+ */
+declare function effectScope(options?: boolean | EffectScopeOptions): EffectScope;
+/**
+ * 获取当前活跃的 effectScope。
+ */
+declare function getCurrentScope(): EffectScope | undefined;
+/**
+ * 在当前活跃的 effectScope 中注册一个清理回调。
+ * 当 scope 被 stop 时，所有注册的回调会被执行。
+ *
+ * @param fn - 清理回调函数
+ *
+ * @example
+ * ```ts
+ * const scope = effectScope()
+ * scope.run(() => {
+ *   onScopeDispose(() => {
+ *     console.log('scope disposed')
+ *   })
+ * })
+ * scope.stop() // 输出: scope disposed
+ * ```
+ */
+declare function onScopeDispose(fn: () => void): void;
+
+export { stop as A, untrack as B, type ComputedGetter as C, type DebuggerEvent as D, type EffectScope as E, withFirstRenderOptimization as F, type OnCleanup as O, type ReactiveEffectOptions as R, type ToRefs as T, type UnwrapNestedRefs as U, type WatchCallback as W, type ComputedSetter as a, type DeepReadonly as b, type EffectScopeOptions as c, type ReactiveEffectRunner as d, type ReactiveObject as e, type UnwrapRef as f, type WatchCallbackWithImmediate as g, type WatchEffectOptions as h, type WatchHandle as i, type WatchOptions as j, type WatchSource as k, type WritableComputedOptions as l, type WritableComputedRef as m, batch as n, batchAsync as o, effect as p, effectScope as q, enableTracking as r, getCurrentScope as s, getSkippedTrackingCount as t, onEffectCleanup as u, onScopeDispose as v, pauseTracking as w, resetSkippedTrackingCount as x, resetTracking as y, shouldSkipTracking as z };

package/dist/{types-CXeWWYm6.d.ts → scope-CTxSo201.d.ts}

@@ -50,13 +50,15 @@ declare class ReactiveEffect<T = unknown> {
     allowRecurse?: boolean;
     onStop?: () => void;
     onTrack?: (event: {
+        effect: ReactiveEffect;
         target: object;
-        key: string | symbol;
+        key?: string | symbol;
         type: string;
     }) => void;
     onTrigger?: (event: {
+        effect: ReactiveEffect;
         target: object;
-        key: string | symbol;
+        key?: string | symbol;
         type: string;
         newValue?: unknown;
         oldValue?: unknown;
@@ -89,13 +91,15 @@ declare function effect(fn: () => void, options?: {
     allowRecurse?: boolean;
     onStop?: () => void;
     onTrack?: (event: {
+        effect: ReactiveEffect;
         target: object;
-        key: string | symbol;
+        key?: string | symbol;
         type: string;
     }) => void;
     onTrigger?: (event: {
+        effect: ReactiveEffect;
         target: object;
-        key: string | symbol;
+        key?: string | symbol;
         type: string;
         newValue?: unknown;
         oldValue?: unknown;
@@ -107,13 +111,15 @@ declare function effect<T>(fn: () => T, options: {
     allowRecurse?: boolean;
     onStop?: () => void;
     onTrack?: (event: {
+        effect: ReactiveEffect;
         target: object;
-        key: string | symbol;
+        key?: string | symbol;
         type: string;
     }) => void;
     onTrigger?: (event: {
+        effect: ReactiveEffect;
         target: object;
-        key: string | symbol;
+        key?: string | symbol;
         type: string;
         newValue?: unknown;
         oldValue?: unknown;
@@ -212,7 +218,9 @@ interface DebuggerEvent {
     effect: ReactiveEffect;
     target: object;
     type: 'track' | 'trigger';
-    key: unknown;
+    key?: string | symbol;
+    newValue?: unknown;
+    oldValue?: unknown;
 }
 interface WatchOptions<Immediate = boolean> {
     immediate?: Immediate;
@@ -267,4 +275,71 @@ type ReactiveObject<T extends object = object> = {
     __v_isReactive: true;
 };
 
-export { type ComputedGetter as C, type DeepReadonly as D, type OnCleanup as O, type ReactiveEffectOptions as R, type ToRefs as T, type UnwrapNestedRefs as U, type WritableComputedOptions as W, type WritableComputedRef as a, type WatchSource as b, type WatchCallbackWithImmediate as c, type WatchOptions as d, type WatchHandle as e, type WatchEffectOptions as f, type ComputedSetter as g, type DebuggerEvent as h, type ReactiveEffectRunner as i, type ReactiveObject as j, type UnwrapRef as k, type WatchCallback as l, batch as m, batchAsync as n, effect as o, enableTracking as p, getSkippedTrackingCount as q, onEffectCleanup as r, pauseTracking as s, resetSkippedTrackingCount as t, resetTracking as u, shouldSkipTracking as v, stop as w, untrack as x, withFirstRenderOptimization as y, ReactiveEffect as z };
+/**
+ * effectScope 收集的条目类型
+ * - ReactiveEffect: 响应式副作用
+ * - EffectScope: 嵌套的子 scope
+ */
+type EffectScopeEntry = ReactiveEffect | EffectScope;
+
+interface EffectScope {
+    /** 当前 scope 是否活跃 */
+    active: boolean;
+    /** scope 收集的 effects */
+    effects: EffectScopeEntry[];
+    /** scope 注册的清理回调 */
+    cleanups: (() => void)[];
+    /** 父 scope（嵌套时自动关联） */
+    parent: EffectScope | undefined;
+    /** 是否脱离父 scope（detached scope 不会被父 scope stop） */
+    detached: boolean;
+    /** 在 scope 上下文中执行 fn，期间创建的 effect 会被自动收集 */
+    run<T>(fn: () => T): T | undefined;
+    /** 停止 scope，清理所有收集的 effects 和 cleanups */
+    stop(): void;
+}
+interface EffectScopeOptions {
+    detached?: boolean;
+}
+/**
+ * 创建一个 effect scope，用于批量管理响应式副作用。
+ *
+ * @param options - 配置选项。支持传入 boolean（兼容旧 API）或 EffectScopeOptions 对象。
+ * @returns EffectScope 实例
+ *
+ * @example
+ * ```ts
+ * const scope = effectScope()
+ * scope.run(() => {
+ *   const count = ref(0)
+ *   watch(count, () => console.log(count.value))
+ * })
+ * // 不再需要时一次性停止所有副作用
+ * scope.stop()
+ * ```
+ */
+declare function effectScope(options?: boolean | EffectScopeOptions): EffectScope;
+/**
+ * 获取当前活跃的 effectScope。
+ */
+declare function getCurrentScope(): EffectScope | undefined;
+/**
+ * 在当前活跃的 effectScope 中注册一个清理回调。
+ * 当 scope 被 stop 时，所有注册的回调会被执行。
+ *
+ * @param fn - 清理回调函数
+ *
+ * @example
+ * ```ts
+ * const scope = effectScope()
+ * scope.run(() => {
+ *   onScopeDispose(() => {
+ *     console.log('scope disposed')
+ *   })
+ * })
+ * scope.stop() // 输出: scope disposed
+ * ```
+ */
+declare function onScopeDispose(fn: () => void): void;
+
+export { stop as A, untrack as B, type ComputedGetter as C, type DebuggerEvent as D, type EffectScope as E, withFirstRenderOptimization as F, type OnCleanup as O, type ReactiveEffectOptions as R, type ToRefs as T, type UnwrapNestedRefs as U, type WatchCallback as W, type ComputedSetter as a, type DeepReadonly as b, type EffectScopeOptions as c, type ReactiveEffectRunner as d, type ReactiveObject as e, type UnwrapRef as f, type WatchCallbackWithImmediate as g, type WatchEffectOptions as h, type WatchHandle as i, type WatchOptions as j, type WatchSource as k, type WritableComputedOptions as l, type WritableComputedRef as m, batch as n, batchAsync as o, effect as p, effectScope as q, enableTracking as r, getCurrentScope as s, getSkippedTrackingCount as t, onEffectCleanup as u, onScopeDispose as v, pauseTracking as w, resetSkippedTrackingCount as x, resetTracking as y, shouldSkipTracking as z };

package/dist/scope.d.cts

@@ -1,71 +1,2 @@
-import { z as ReactiveEffect } from './types-CMYee6LB.cjs';
+export { E as EffectScope, c as EffectScopeOptions, q as effectScope, s as getCurrentScope, v as onScopeDispose } from './scope-BC3djHz7.cjs';
 import './ref-CwOCKoy2.cjs';
-
-/**
- * effectScope 收集的条目类型
- * - ReactiveEffect: 响应式副作用
- * - EffectScope: 嵌套的子 scope
- */
-type EffectScopeEntry = ReactiveEffect | EffectScope;
-
-interface EffectScope {
-    /** 当前 scope 是否活跃 */
-    active: boolean;
-    /** scope 收集的 effects */
-    effects: EffectScopeEntry[];
-    /** scope 注册的清理回调 */
-    cleanups: (() => void)[];
-    /** 父 scope（嵌套时自动关联） */
-    parent: EffectScope | undefined;
-    /** 是否脱离父 scope（detached scope 不会被父 scope stop） */
-    detached: boolean;
-    /** 在 scope 上下文中执行 fn，期间创建的 effect 会被自动收集 */
-    run<T>(fn: () => T): T | undefined;
-    /** 停止 scope，清理所有收集的 effects 和 cleanups */
-    stop(): void;
-}
-interface EffectScopeOptions {
-    detached?: boolean;
-}
-/**
- * 创建一个 effect scope，用于批量管理响应式副作用。
- *
- * @param options - 配置选项。支持传入 boolean（兼容旧 API）或 EffectScopeOptions 对象。
- * @returns EffectScope 实例
- *
- * @example
- * ```ts
- * const scope = effectScope()
- * scope.run(() => {
- *   const count = ref(0)
- *   watch(count, () => console.log(count.value))
- * })
- * // 不再需要时一次性停止所有副作用
- * scope.stop()
- * ```
- */
-declare function effectScope(options?: boolean | EffectScopeOptions): EffectScope;
-/**
- * 获取当前活跃的 effectScope。
- */
-declare function getCurrentScope(): EffectScope | undefined;
-/**
- * 在当前活跃的 effectScope 中注册一个清理回调。
- * 当 scope 被 stop 时，所有注册的回调会被执行。
- *
- * @param fn - 清理回调函数
- *
- * @example
- * ```ts
- * const scope = effectScope()
- * scope.run(() => {
- *   onScopeDispose(() => {
- *     console.log('scope disposed')
- *   })
- * })
- * scope.stop() // 输出: scope disposed
- * ```
- */
-declare function onScopeDispose(fn: () => void): void;
-
-export { type EffectScope, type EffectScopeOptions, effectScope, getCurrentScope, onScopeDispose };

package/dist/scope.d.ts

@@ -1,71 +1,2 @@
-import { z as ReactiveEffect } from './types-CXeWWYm6.js';
+export { E as EffectScope, c as EffectScopeOptions, q as effectScope, s as getCurrentScope, v as onScopeDispose } from './scope-CTxSo201.js';
 import './ref-CwOCKoy2.js';
-
-/**
- * effectScope 收集的条目类型
- * - ReactiveEffect: 响应式副作用
- * - EffectScope: 嵌套的子 scope
- */
-type EffectScopeEntry = ReactiveEffect | EffectScope;
-
-interface EffectScope {
-    /** 当前 scope 是否活跃 */
-    active: boolean;
-    /** scope 收集的 effects */
-    effects: EffectScopeEntry[];
-    /** scope 注册的清理回调 */
-    cleanups: (() => void)[];
-    /** 父 scope（嵌套时自动关联） */
-    parent: EffectScope | undefined;
-    /** 是否脱离父 scope（detached scope 不会被父 scope stop） */
-    detached: boolean;
-    /** 在 scope 上下文中执行 fn，期间创建的 effect 会被自动收集 */
-    run<T>(fn: () => T): T | undefined;
-    /** 停止 scope，清理所有收集的 effects 和 cleanups */
-    stop(): void;
-}
-interface EffectScopeOptions {
-    detached?: boolean;
-}
-/**
- * 创建一个 effect scope，用于批量管理响应式副作用。
- *
- * @param options - 配置选项。支持传入 boolean（兼容旧 API）或 EffectScopeOptions 对象。
- * @returns EffectScope 实例
- *
- * @example
- * ```ts
- * const scope = effectScope()
- * scope.run(() => {
- *   const count = ref(0)
- *   watch(count, () => console.log(count.value))
- * })
- * // 不再需要时一次性停止所有副作用
- * scope.stop()
- * ```
- */
-declare function effectScope(options?: boolean | EffectScopeOptions): EffectScope;
-/**
- * 获取当前活跃的 effectScope。
- */
-declare function getCurrentScope(): EffectScope | undefined;
-/**
- * 在当前活跃的 effectScope 中注册一个清理回调。
- * 当 scope 被 stop 时，所有注册的回调会被执行。
- *
- * @param fn - 清理回调函数
- *
- * @example
- * ```ts
- * const scope = effectScope()
- * scope.run(() => {
- *   onScopeDispose(() => {
- *     console.log('scope disposed')
- *   })
- * })
- * scope.stop() // 输出: scope disposed
- * ```
- */
-declare function onScopeDispose(fn: () => void): void;
-
-export { type EffectScope, type EffectScopeOptions, effectScope, getCurrentScope, onScopeDispose };

package/dist/{signal-BOAyevht.d.cts → signal-DWrUYmvd.d.cts}

@@ -106,4 +106,4 @@ declare function _getPendingNotificationsCount(): number;
 /** @internal 重置全局状态（仅用于测试） */
 declare function _resetSignalGlobalState(): void;
 
-export { ComputedRefSymbol as C, ReactiveSymbol as R, ShallowRefSymbol as S, type WritableComputedSignal as W, _getActiveSubscriber as _, type ComputedSignal as a, type ReadonlySignal as b, ReadonlySymbol as c, RefSymbol as d, type Signal as e, type Subscriber as f, type WritableSignal as g, computedSignal as h, signal as i, signalBatch as j, computed as k, signalUntrack as l, _getBatchDepth as m, _getPendingNotificationsCount as n, _isSignalUntracked as o, _resetSignalGlobalState as p, readonlySignal as r, set as s, update as u, valueOf as v, writableComputedSignal as w };
+export { ComputedRefSymbol as C, ReactiveSymbol as R, ShallowRefSymbol as S, type WritableComputedSignal as W, _getActiveSubscriber as _, type ComputedSignal as a, type ReadonlySignal as b, ReadonlySymbol as c, RefSymbol as d, type Signal as e, type Subscriber as f, type WritableSignal as g, _getBatchDepth as h, _getPendingNotificationsCount as i, _isSignalUntracked as j, _resetSignalGlobalState as k, computed as l, computedSignal as m, signal as n, signalBatch as o, signalUntrack as p, readonlySignal as r, set as s, update as u, valueOf as v, writableComputedSignal as w };

package/dist/{signal-BOAyevht.d.ts → signal-DWrUYmvd.d.ts}

@@ -106,4 +106,4 @@ declare function _getPendingNotificationsCount(): number;
 /** @internal 重置全局状态（仅用于测试） */
 declare function _resetSignalGlobalState(): void;
 
-export { ComputedRefSymbol as C, ReactiveSymbol as R, ShallowRefSymbol as S, type WritableComputedSignal as W, _getActiveSubscriber as _, type ComputedSignal as a, type ReadonlySignal as b, ReadonlySymbol as c, RefSymbol as d, type Signal as e, type Subscriber as f, type WritableSignal as g, computedSignal as h, signal as i, signalBatch as j, computed as k, signalUntrack as l, _getBatchDepth as m, _getPendingNotificationsCount as n, _isSignalUntracked as o, _resetSignalGlobalState as p, readonlySignal as r, set as s, update as u, valueOf as v, writableComputedSignal as w };
+export { ComputedRefSymbol as C, ReactiveSymbol as R, ShallowRefSymbol as S, type WritableComputedSignal as W, _getActiveSubscriber as _, type ComputedSignal as a, type ReadonlySignal as b, ReadonlySymbol as c, RefSymbol as d, type Signal as e, type Subscriber as f, type WritableSignal as g, _getBatchDepth as h, _getPendingNotificationsCount as i, _isSignalUntracked as j, _resetSignalGlobalState as k, computed as l, computedSignal as m, signal as n, signalBatch as o, signalUntrack as p, readonlySignal as r, set as s, update as u, valueOf as v, writableComputedSignal as w };

package/dist/signal-component.d.cts

@@ -1,4 +1,4 @@
-import { e as Signal, a as ComputedSignal, g as WritableSignal } from './signal-BOAyevht.cjs';
+import { e as Signal, a as ComputedSignal, g as WritableSignal } from './signal-DWrUYmvd.cjs';
 
 interface SignalComponentOptions<T = Record<string, unknown>> {
     signals?: {

package/dist/signal-component.d.ts

@@ -1,4 +1,4 @@
-import { e as Signal, a as ComputedSignal, g as WritableSignal } from './signal-BOAyevht.js';
+import { e as Signal, a as ComputedSignal, g as WritableSignal } from './signal-DWrUYmvd.js';
 
 interface SignalComponentOptions<T = Record<string, unknown>> {
     signals?: {

package/dist/signal.cjs

@@ -15,7 +15,7 @@ var TriggerOpTypes = {
 var activeEffect;
 var targetMap = /* @__PURE__ */ new WeakMap();
 var triggerDepth = 0;
-function trigger(target, type, key, _newValue, _oldValue) {
+function trigger(target, type, key, newValue, oldValue) {
   const depsMap = targetMap.get(target);
   if (!depsMap) return;
   const deps = [];
@@ -37,9 +37,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 > commonConstants.REACTIVITY_MAX_TRIGGER_DEPTH) {
     return;
   }
@@ -47,19 +47,19 @@ function triggerEffects(effects) {
   try {
     for (const effect of effects) {
       if (effect.computed) {
-        triggerEffect(effect);
+        triggerEffect(effect, target, type, key, newValue, oldValue);
       }
     }
     for (const effect of effects) {
       if (!effect.computed) {
-        triggerEffect(effect);
+        triggerEffect(effect, target, type, key, newValue, oldValue);
       }
     }
   } finally {
     triggerDepth--;
   }
 }
-function triggerEffect(effect) {
+function triggerEffect(effect, target, type, key, newValue, oldValue) {
   if (effect !== activeEffect || effect.allowRecurse) {
     if (effect.scheduler) {
       effect.scheduler();
@@ -257,7 +257,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() {