@lytjs/reactivity 5.0.1 → 6.0.0

package/dist/scope.d.cts

@@ -0,0 +1,71 @@
+import { z as ReactiveEffect } from './types-CMYee6LB.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

@@ -0,0 +1,71 @@
+import { z as ReactiveEffect } from './types-CXeWWYm6.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/scope.mjs

@@ -0,0 +1,70 @@
+import { error } from '@lytjs/common-error';
+import { unsafeCast } from '@lytjs/common-assertions';
+
+// src/effect-scope.ts
+var 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 effect of this.effects) {
+        try {
+          effect.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);
+  }
+}
+
+export { effectScope, getCurrentScope, onScopeDispose };
+//# sourceMappingURL=scope.mjs.map
+//# sourceMappingURL=scope.mjs.map

package/dist/scope.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/effect-scope.ts"],"names":[],"mappings":";;;;AA8BA,IAAI,iBAAA;AA6BG,SAAS,YAAY,OAAA,EAAqD;AAC/E,EAAA,MAAM,QAAA,GAAW,OAAO,OAAA,KAAY,SAAA,GAAY,UAAU,OAAA,EAAS,QAAA;AACnE,EAAA,MAAM,KAAA,GAAqB;AAAA,IACzB,MAAA,EAAQ,IAAA;AAAA,IACR,SAAS,EAAC;AAAA,IACV,UAAU,EAAC;AAAA,IACX,MAAA,EAAQ,iBAAA;AAAA,IACR,QAAA,EAAU,CAAC,CAAC,QAAA;AAAA,IAEZ,IAAI,EAAA,EAAI;AACN,MAAA,IAAI,CAAC,KAAK,MAAA,EAAQ;AAIhB,QAAA;AAAA,MACF;AACA,MAAA,MAAM,SAAA,GAAY,iBAAA;AAElB,MAAA,iBAAA,GAAoB,IAAA;AACpB,MAAA,IAAI;AACF,QAAA,OAAO,EAAA,EAAG;AAAA,MACZ,CAAA,SAAE;AACA,QAAA,iBAAA,GAAoB,SAAA;AAAA,MACtB;AAAA,IACF,CAAA;AAAA,IAEA,IAAA,GAAO;AACL,MAAA,IAAI,CAAC,KAAK,MAAA,EAAQ;AAClB,MAAA,IAAA,CAAK,MAAA,GAAS,KAAA;AACd,MAAA,KAAA,MAAW,MAAA,IAAU,KAAK,OAAA,EAAS;AACjC,QAAA,IAAI;AACF,UAAA,MAAA,CAAO,IAAA,EAAK;AAAA,QACd,SAAS,CAAA,EAAG;AACV,UAAA,KAAA,CAAM,CAAA,gCAAA,EAAmC,MAAA,CAAO,CAAC,CAAC,CAAA,CAAE,CAAA;AAAA,QACtD;AAAA,MACF;AACA,MAAA,KAAA,MAAW,OAAA,IAAW,KAAK,QAAA,EAAU;AACnC,QAAA,IAAI;AACF,UAAA,OAAA,EAAQ;AAAA,QACV,SAAS,CAAA,EAAG;AACV,UAAA,KAAA,CAAM,CAAA,gCAAA,EAAmC,MAAA,CAAO,CAAC,CAAC,CAAA,CAAE,CAAA;AAAA,QACtD;AAAA,MACF;AACA,MAAA,IAAI,KAAK,MAAA,EAAQ;AACf,QAAA,MAAM,MAAM,IAAA,CAAK,MAAA,CAAO,QAAQ,OAAA,CAAQ,UAAA,CAA6B,IAAI,CAAC,CAAA;AAC1E,QAAA,IAAI,QAAQ,EAAA,EAAI;AACd,UAAA,IAAA,CAAK,MAAA,CAAO,OAAA,CAAQ,MAAA,CAAO,GAAA,EAAK,CAAC,CAAA;AAAA,QACnC;AAAA,MACF;AACA,MAAA,IAAA,CAAK,QAAQ,MAAA,GAAS,CAAA;AACtB,MAAA,IAAA,CAAK,SAAS,MAAA,GAAS,CAAA;AACvB,MAAA,IAAA,CAAK,MAAA,GAAS,MAAA;AAAA,IAChB;AAAA,GACF;AAEA,EAAA,IAAI,CAAC,KAAA,CAAM,QAAA,IAAY,iBAAA,EAAmB;AAIxC,IAAA,iBAAA,CAAkB,OAAA,CAAQ,IAAA,CAAK,UAAA,CAA6B,KAAK,CAAC,CAAA;AAAA,EACpE;AAEA,EAAA,OAAO,KAAA;AACT;AAKO,SAAS,eAAA,GAA2C;AACzD,EAAA,OAAO,iBAAA;AACT;AAmBO,SAAS,eAAe,EAAA,EAAsB;AACnD,EAAA,IAAI,iBAAA,EAAmB;AACrB,IAAA,iBAAA,CAAkB,QAAA,CAAS,KAAK,EAAE,CAAA;AAAA,EACpC;AAKF","file":"scope.mjs","sourcesContent":["// src/effect-scope.ts\r\n// Vue 3 风格的 effectScope API\r\n// 用于批量管理响应式副作用的创建和销毁\r\n\r\nimport type { EffectScopeEntry } from './effect-scope-registrar';\r\nimport { warn, error } from '@lytjs/common-error';\r\nimport { unsafeCast } from '@lytjs/common-assertions';\r\n\r\nexport interface EffectScope {\r\n  /** 当前 scope 是否活跃 */\r\n  active: boolean;\r\n  /** scope 收集的 effects */\r\n  effects: EffectScopeEntry[];\r\n  /** scope 注册的清理回调 */\r\n  cleanups: (() => void)[];\r\n  /** 父 scope（嵌套时自动关联） */\r\n  parent: EffectScope | undefined;\r\n  /** 是否脱离父 scope（detached scope 不会被父 scope stop） */\r\n  detached: boolean;\r\n  /** 在 scope 上下文中执行 fn，期间创建的 effect 会被自动收集 */\r\n  run<T>(fn: () => T): T | undefined;\r\n  /** 停止 scope，清理所有收集的 effects 和 cleanups */\r\n  stop(): void;\r\n}\r\n\r\nexport interface EffectScopeOptions {\r\n  detached?: boolean;\r\n}\r\n\r\n/** 当前活跃的 effectScope（唯一来源） */\r\nlet activeEffectScope: EffectScope | undefined;\r\n\r\n/** 获取当前活跃的 effectScope */\r\nexport function getActiveEffectScope(): EffectScope | undefined {\r\n  return activeEffectScope;\r\n}\r\n\r\n/** 设置当前活跃的 effectScope */\r\nexport function setActiveEffectScope(scope: EffectScope | undefined): void {\r\n  activeEffectScope = scope;\r\n}\r\n\r\n/**\r\n * 创建一个 effect scope，用于批量管理响应式副作用。\r\n *\r\n * @param options - 配置选项。支持传入 boolean（兼容旧 API）或 EffectScopeOptions 对象。\r\n * @returns EffectScope 实例\r\n *\r\n * @example\r\n * ```ts\r\n * const scope = effectScope()\r\n * scope.run(() => {\r\n *   const count = ref(0)\r\n *   watch(count, () => console.log(count.value))\r\n * })\r\n * // 不再需要时一次性停止所有副作用\r\n * scope.stop()\r\n * ```\r\n */\r\nexport function effectScope(options?: boolean | EffectScopeOptions): EffectScope {\r\n  const detached = typeof options === 'boolean' ? options : options?.detached;\r\n  const scope: EffectScope = {\r\n    active: true,\r\n    effects: [],\r\n    cleanups: [],\r\n    parent: activeEffectScope,\r\n    detached: !!detached,\r\n\r\n    run(fn) {\r\n      if (!this.active) {\r\n        if (__DEV__) {\r\n          warn(`EffectScope is not active. Cannot run fn.`);\r\n        }\r\n        return;\r\n      }\r\n      const prevScope = activeEffectScope;\r\n      // eslint-disable-next-line @typescript-eslint/no-this-alias\r\n      activeEffectScope = this;\r\n      try {\r\n        return fn();\r\n      } finally {\r\n        activeEffectScope = prevScope;\r\n      }\r\n    },\r\n\r\n    stop() {\r\n      if (!this.active) return;\r\n      this.active = false;\r\n      for (const effect of this.effects) {\r\n        try {\r\n          effect.stop();\r\n        } catch (e) {\r\n          error(`Error stopping effect in scope: ${String(e)}`);\r\n        }\r\n      }\r\n      for (const cleanup of this.cleanups) {\r\n        try {\r\n          cleanup();\r\n        } catch (e) {\r\n          error(`Error running cleanup in scope: ${String(e)}`);\r\n        }\r\n      }\r\n      if (this.parent) {\r\n        const idx = this.parent.effects.indexOf(unsafeCast<EffectScopeEntry>(this));\r\n        if (idx !== -1) {\r\n          this.parent.effects.splice(idx, 1);\r\n        }\r\n      }\r\n      this.effects.length = 0;\r\n      this.cleanups.length = 0;\r\n      this.parent = undefined;\r\n    },\r\n  } as EffectScope;\r\n\r\n  if (!scope.detached && activeEffectScope) {\r\n    // 双重断言是必要的：EffectScope 对象字面量实现了 EffectScopeEntry 所需的\r\n    // stop() 方法，但 TypeScript 无法自动推断对象字面量满足联合类型。\r\n    // EffectScopeEntry = ReactiveEffect | EffectScope，此处 scope 是 EffectScope 实例。\r\n    activeEffectScope.effects.push(unsafeCast<EffectScopeEntry>(scope));\r\n  }\r\n\r\n  return scope;\r\n}\r\n\r\n/**\r\n * 获取当前活跃的 effectScope。\r\n */\r\nexport function getCurrentScope(): EffectScope | undefined {\r\n  return activeEffectScope;\r\n}\r\n\r\n/**\r\n * 在当前活跃的 effectScope 中注册一个清理回调。\r\n * 当 scope 被 stop 时，所有注册的回调会被执行。\r\n *\r\n * @param fn - 清理回调函数\r\n *\r\n * @example\r\n * ```ts\r\n * const scope = effectScope()\r\n * scope.run(() => {\r\n *   onScopeDispose(() => {\r\n *     console.log('scope disposed')\r\n *   })\r\n * })\r\n * scope.stop() // 输出: scope disposed\r\n * ```\r\n */\r\nexport function onScopeDispose(fn: () => void): void {\r\n  if (activeEffectScope) {\r\n    activeEffectScope.cleanups.push(fn);\r\n  } else if (__DEV__) {\r\n    warn(\r\n      'onScopeDispose() was called when there was no active effect scope to be associated with.',\r\n    );\r\n  }\r\n}\r\n"]}

package/dist/signal-BOAyevht.d.cts

@@ -0,0 +1,109 @@
+declare const RefSymbol: unique symbol;
+declare const ShallowRefSymbol: unique symbol;
+declare const ComputedRefSymbol: unique symbol;
+declare const ReactiveSymbol: unique symbol;
+declare const ReadonlySymbol: unique symbol;
+declare const SignalSymbol: unique symbol;
+declare const ComputedSignalSymbol: unique symbol;
+
+/**
+ * @lytjs/reactivity - Shared Types
+ * 响应式系统公共类型定义。
+ */
+/** 订阅者回调函数 */
+type Subscriber = () => void;
+
+/**
+ * @lytjs/reactivity - Signal
+ * 独立自包含的 Signal 响应式原语。
+ * 拥有独立的订阅/通知机制，同时桥接 effect 系统保持互操作性。
+ */
+
+/** Signal 只读接口 */
+interface Signal<T = unknown> {
+    /** 读取当前值 */
+    (): T;
+    readonly [SignalSymbol]: true;
+}
+/** WritableSignal 可写接口 */
+interface WritableSignal<T = unknown> extends Signal<T> {
+    /** 设置新值 */
+    set(newValue: T): void;
+    /** 通过 updater 函数更新值 */
+    update(updater: (prev: T) => T): void;
+    /** 停止所有订阅通知，释放资源 */
+    dispose(): void;
+    /** @internal 订阅变更通知 */
+    _subscribe(subscriber: Subscriber): () => void;
+    /** FIX: P1-5 REACTIVITY-NEW-03 - 手动清理依赖，防止内存泄漏 */
+    cleanup(): void;
+}
+/** ComputedSignal 计算信号接口 */
+interface ComputedSignal<T = unknown> extends Signal<T> {
+    /** 停止计算信号的依赖追踪和更新 */
+    dispose(): void;
+    /** @deprecated 使用 dispose() */
+    stop?: () => void;
+    readonly [ComputedSignalSymbol]: true;
+}
+/** WritableComputedSignal 可写计算信号接口 */
+interface WritableComputedSignal<T = unknown> extends ComputedSignal<T> {
+    /** 设置新值（通过 setter 函数） */
+    set(newValue: T): void;
+}
+/** ReadonlySignal 只读信号接口 */
+interface ReadonlySignal<T = unknown> {
+    /** 读取当前值 */
+    (): T;
+    readonly [SignalSymbol]: true;
+}
+/**
+ * 创建一个可写 Signal。
+ * 使用闭包变量存储值，Set 管理订阅者。
+ */
+declare function signal<T>(initialValue: T): WritableSignal<T>;
+/**
+ * 创建一个计算信号。
+ * 惰性求值、自动依赖追踪与清理、循环依赖检测。
+ */
+declare function computed<T>(fn: () => T): ComputedSignal<T>;
+/**
+ * 创建一个可写计算信号。
+ * 通过 getter 读取计算值，通过 setter 写入值。
+ * setter 通常会间接更新 getter 依赖的底层 signal。
+ */
+declare function writableComputedSignal<T>(getter: () => T, setter: (value: T) => void): WritableComputedSignal<T>;
+/**
+ * 在批处理中执行函数。
+ * batch 内多次 signal.set 只在函数结束后统一触发一次通知。
+ */
+declare function signalBatch(fn: () => void): void;
+/**
+ * 在取消追踪模式中执行函数。
+ * 函数内读取 signal 不会建立依赖关系。
+ */
+declare function signalUntrack<T>(fn: () => T): T;
+/** @internal 检查当前是否处于 untrack 模式（供 effect 系统桥接使用） */
+declare function _isSignalUntracked(): boolean;
+/**
+ * @deprecated 使用 computed() 代替
+ */
+declare function computedSignal<T>(fn: () => T): ComputedSignal<T>;
+/** 读取 signal 值 */
+declare function valueOf<T>(sig: Signal<T>): T;
+/** 设置 signal 值（适配器） */
+declare function set<T>(sig: WritableSignal<T> | ReadonlySignal<T>, newValue: T): void;
+/** 通过 updater 更新 signal 值（适配器） */
+declare function update<T>(sig: WritableSignal<T>, updater: (prev: T) => T): void;
+/** 创建只读 signal（适配器） */
+declare function readonlySignal<T>(sig: Signal<T>): ReadonlySignal<T>;
+/** @internal 获取当前活跃订阅者（仅用于测试） */
+declare function _getActiveSubscriber(): Subscriber | null;
+/** @internal 获取 batch 深度（仅用于测试） */
+declare function _getBatchDepth(): number;
+/** @internal 获取待通知订阅者数量（仅用于测试） */
+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 };

package/dist/signal-BOAyevht.d.ts

@@ -0,0 +1,109 @@
+declare const RefSymbol: unique symbol;
+declare const ShallowRefSymbol: unique symbol;
+declare const ComputedRefSymbol: unique symbol;
+declare const ReactiveSymbol: unique symbol;
+declare const ReadonlySymbol: unique symbol;
+declare const SignalSymbol: unique symbol;
+declare const ComputedSignalSymbol: unique symbol;
+
+/**
+ * @lytjs/reactivity - Shared Types
+ * 响应式系统公共类型定义。
+ */
+/** 订阅者回调函数 */
+type Subscriber = () => void;
+
+/**
+ * @lytjs/reactivity - Signal
+ * 独立自包含的 Signal 响应式原语。
+ * 拥有独立的订阅/通知机制，同时桥接 effect 系统保持互操作性。
+ */
+
+/** Signal 只读接口 */
+interface Signal<T = unknown> {
+    /** 读取当前值 */
+    (): T;
+    readonly [SignalSymbol]: true;
+}
+/** WritableSignal 可写接口 */
+interface WritableSignal<T = unknown> extends Signal<T> {
+    /** 设置新值 */
+    set(newValue: T): void;
+    /** 通过 updater 函数更新值 */
+    update(updater: (prev: T) => T): void;
+    /** 停止所有订阅通知，释放资源 */
+    dispose(): void;
+    /** @internal 订阅变更通知 */
+    _subscribe(subscriber: Subscriber): () => void;
+    /** FIX: P1-5 REACTIVITY-NEW-03 - 手动清理依赖，防止内存泄漏 */
+    cleanup(): void;
+}
+/** ComputedSignal 计算信号接口 */
+interface ComputedSignal<T = unknown> extends Signal<T> {
+    /** 停止计算信号的依赖追踪和更新 */
+    dispose(): void;
+    /** @deprecated 使用 dispose() */
+    stop?: () => void;
+    readonly [ComputedSignalSymbol]: true;
+}
+/** WritableComputedSignal 可写计算信号接口 */
+interface WritableComputedSignal<T = unknown> extends ComputedSignal<T> {
+    /** 设置新值（通过 setter 函数） */
+    set(newValue: T): void;
+}
+/** ReadonlySignal 只读信号接口 */
+interface ReadonlySignal<T = unknown> {
+    /** 读取当前值 */
+    (): T;
+    readonly [SignalSymbol]: true;
+}
+/**
+ * 创建一个可写 Signal。
+ * 使用闭包变量存储值，Set 管理订阅者。
+ */
+declare function signal<T>(initialValue: T): WritableSignal<T>;
+/**
+ * 创建一个计算信号。
+ * 惰性求值、自动依赖追踪与清理、循环依赖检测。
+ */
+declare function computed<T>(fn: () => T): ComputedSignal<T>;
+/**
+ * 创建一个可写计算信号。
+ * 通过 getter 读取计算值，通过 setter 写入值。
+ * setter 通常会间接更新 getter 依赖的底层 signal。
+ */
+declare function writableComputedSignal<T>(getter: () => T, setter: (value: T) => void): WritableComputedSignal<T>;
+/**
+ * 在批处理中执行函数。
+ * batch 内多次 signal.set 只在函数结束后统一触发一次通知。
+ */
+declare function signalBatch(fn: () => void): void;
+/**
+ * 在取消追踪模式中执行函数。
+ * 函数内读取 signal 不会建立依赖关系。
+ */
+declare function signalUntrack<T>(fn: () => T): T;
+/** @internal 检查当前是否处于 untrack 模式（供 effect 系统桥接使用） */
+declare function _isSignalUntracked(): boolean;
+/**
+ * @deprecated 使用 computed() 代替
+ */
+declare function computedSignal<T>(fn: () => T): ComputedSignal<T>;
+/** 读取 signal 值 */
+declare function valueOf<T>(sig: Signal<T>): T;
+/** 设置 signal 值（适配器） */
+declare function set<T>(sig: WritableSignal<T> | ReadonlySignal<T>, newValue: T): void;
+/** 通过 updater 更新 signal 值（适配器） */
+declare function update<T>(sig: WritableSignal<T>, updater: (prev: T) => T): void;
+/** 创建只读 signal（适配器） */
+declare function readonlySignal<T>(sig: Signal<T>): ReadonlySignal<T>;
+/** @internal 获取当前活跃订阅者（仅用于测试） */
+declare function _getActiveSubscriber(): Subscriber | null;
+/** @internal 获取 batch 深度（仅用于测试） */
+declare function _getBatchDepth(): number;
+/** @internal 获取待通知订阅者数量（仅用于测试） */
+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 };

package/dist/signal-component.cjs

@@ -0,0 +1,39 @@
+'use strict';
+
+// src/signal-component.ts
+function extractSignals(options) {
+  const signals = [];
+  if (options.signals) {
+    signals.push(...Object.values(options.signals));
+  }
+  if (options.computed) {
+    signals.push(...Object.values(options.computed));
+  }
+  return signals;
+}
+function createSignalBinding(sig, onChange) {
+  return {
+    get: () => sig(),
+    set: (value) => {
+      sig.set(value);
+      onChange?.(value);
+    }
+  };
+}
+function signalToProps(signals) {
+  const props = {};
+  for (const [key, sig] of Object.entries(signals)) {
+    Object.defineProperty(props, key, {
+      get: () => sig(),
+      enumerable: true,
+      configurable: true
+    });
+  }
+  return props;
+}
+
+exports.createSignalBinding = createSignalBinding;
+exports.extractSignals = extractSignals;
+exports.signalToProps = signalToProps;
+//# sourceMappingURL=signal-component.cjs.map
+//# sourceMappingURL=signal-component.cjs.map

package/dist/signal-component.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/signal-component.ts"],"names":[],"mappings":";;;AAaO,SAAS,eACd,OAAA,EAC+C;AAC/C,EAAA,MAAM,UAAyD,EAAC;AAChE,EAAA,IAAI,QAAQ,OAAA,EAAS;AACnB,IAAA,OAAA,CAAQ,KAAK,GAAI,MAAA,CAAO,MAAA,CAAO,OAAA,CAAQ,OAAO,CAAuB,CAAA;AAAA,EACvE;AACA,EAAA,IAAI,QAAQ,QAAA,EAAU;AACpB,IAAA,OAAA,CAAQ,KAAK,GAAI,MAAA,CAAO,MAAA,CAAO,OAAA,CAAQ,QAAQ,CAA+B,CAAA;AAAA,EAChF;AACA,EAAA,OAAO,OAAA;AACT;AAKO,SAAS,mBAAA,CACd,KACA,QAAA,EAC2C;AAC3C,EAAA,OAAO;AAAA,IACL,GAAA,EAAK,MAAM,GAAA,EAAI;AAAA,IACf,GAAA,EAAK,CAAC,KAAA,KAAa;AACjB,MAAA,GAAA,CAAI,IAAI,KAAK,CAAA;AACb,MAAA,QAAA,GAAW,KAAK,CAAA;AAAA,IAClB;AAAA,GACF;AACF;AASO,SAAS,cAAc,OAAA,EAAmE;AAC/F,EAAA,MAAM,QAAiC,EAAC;AACxC,EAAA,KAAA,MAAW,CAAC,GAAA,EAAK,GAAG,KAAK,MAAA,CAAO,OAAA,CAAQ,OAAO,CAAA,EAAG;AAChD,IAAA,MAAA,CAAO,cAAA,CAAe,OAAO,GAAA,EAAK;AAAA,MAChC,GAAA,EAAK,MAAM,GAAA,EAAI;AAAA,MACf,UAAA,EAAY,IAAA;AAAA,MACZ,YAAA,EAAc;AAAA,KACf,CAAA;AAAA,EACH;AACA,EAAA,OAAO,KAAA;AACT","file":"signal-component.cjs","sourcesContent":["// src/signal-component.ts\r\n// Signal 组件集成工具\r\n\r\nimport type { Signal, WritableSignal, ComputedSignal } from './signal';\r\n\r\nexport interface SignalComponentOptions<T = Record<string, unknown>> {\r\n  signals?: { [K in keyof T]?: Signal<T[K]> };\r\n  computed?: { [K in keyof T]?: ComputedSignal<T[K]> };\r\n}\r\n\r\n/**\r\n * 从组件选项中提取所有 signal 依赖\r\n */\r\nexport function extractSignals(\r\n  options: SignalComponentOptions,\r\n): (Signal<unknown> | ComputedSignal<unknown>)[] {\r\n  const signals: (Signal<unknown> | ComputedSignal<unknown>)[] = [];\r\n  if (options.signals) {\r\n    signals.push(...(Object.values(options.signals) as Signal<unknown>[]));\r\n  }\r\n  if (options.computed) {\r\n    signals.push(...(Object.values(options.computed) as ComputedSignal<unknown>[]));\r\n  }\r\n  return signals;\r\n}\r\n\r\n/**\r\n * 创建 signal 绑定辅助\r\n */\r\nexport function createSignalBinding<T>(\r\n  sig: WritableSignal<T>,\r\n  onChange?: (value: T) => void,\r\n): { get: () => T; set: (value: T) => void } {\r\n  return {\r\n    get: () => sig(),\r\n    set: (value: T) => {\r\n      sig.set(value);\r\n      onChange?.(value);\r\n    },\r\n  };\r\n}\r\n\r\n/**\r\n * 将 signal 值转换为响应式 props\r\n *\r\n * 注意：通过 Object.defineProperty 定义的 getter 会在每次属性访问时调用 signal()，\r\n * 这会触发 signal 的依赖追踪机制。如果此 props 对象在响应式上下文（如 effect 或\r\n * computed）中被读取，访问的 signal 会自动注册为该上下文的依赖。\r\n */\r\nexport function signalToProps(signals: Record<string, Signal<unknown>>): Record<string, unknown> {\r\n  const props: Record<string, unknown> = {};\r\n  for (const [key, sig] of Object.entries(signals)) {\r\n    Object.defineProperty(props, key, {\r\n      get: () => sig(),\r\n      enumerable: true,\r\n      configurable: true,\r\n    });\r\n  }\r\n  return props;\r\n}\r\n"]}

package/dist/signal-component.d.cts

@@ -0,0 +1,31 @@
+import { e as Signal, a as ComputedSignal, g as WritableSignal } from './signal-BOAyevht.cjs';
+
+interface SignalComponentOptions<T = Record<string, unknown>> {
+    signals?: {
+        [K in keyof T]?: Signal<T[K]>;
+    };
+    computed?: {
+        [K in keyof T]?: ComputedSignal<T[K]>;
+    };
+}
+/**
+ * 从组件选项中提取所有 signal 依赖
+ */
+declare function extractSignals(options: SignalComponentOptions): (Signal<unknown> | ComputedSignal<unknown>)[];
+/**
+ * 创建 signal 绑定辅助
+ */
+declare function createSignalBinding<T>(sig: WritableSignal<T>, onChange?: (value: T) => void): {
+    get: () => T;
+    set: (value: T) => void;
+};
+/**
+ * 将 signal 值转换为响应式 props
+ *
+ * 注意：通过 Object.defineProperty 定义的 getter 会在每次属性访问时调用 signal()，
+ * 这会触发 signal 的依赖追踪机制。如果此 props 对象在响应式上下文（如 effect 或
+ * computed）中被读取，访问的 signal 会自动注册为该上下文的依赖。
+ */
+declare function signalToProps(signals: Record<string, Signal<unknown>>): Record<string, unknown>;
+
+export { type SignalComponentOptions, createSignalBinding, extractSignals, signalToProps };

package/dist/signal-component.d.ts

@@ -0,0 +1,31 @@
+import { e as Signal, a as ComputedSignal, g as WritableSignal } from './signal-BOAyevht.js';
+
+interface SignalComponentOptions<T = Record<string, unknown>> {
+    signals?: {
+        [K in keyof T]?: Signal<T[K]>;
+    };
+    computed?: {
+        [K in keyof T]?: ComputedSignal<T[K]>;
+    };
+}
+/**
+ * 从组件选项中提取所有 signal 依赖
+ */
+declare function extractSignals(options: SignalComponentOptions): (Signal<unknown> | ComputedSignal<unknown>)[];
+/**
+ * 创建 signal 绑定辅助
+ */
+declare function createSignalBinding<T>(sig: WritableSignal<T>, onChange?: (value: T) => void): {
+    get: () => T;
+    set: (value: T) => void;
+};
+/**
+ * 将 signal 值转换为响应式 props
+ *
+ * 注意：通过 Object.defineProperty 定义的 getter 会在每次属性访问时调用 signal()，
+ * 这会触发 signal 的依赖追踪机制。如果此 props 对象在响应式上下文（如 effect 或
+ * computed）中被读取，访问的 signal 会自动注册为该上下文的依赖。
+ */
+declare function signalToProps(signals: Record<string, Signal<unknown>>): Record<string, unknown>;
+
+export { type SignalComponentOptions, createSignalBinding, extractSignals, signalToProps };

package/dist/signal-component.mjs

@@ -0,0 +1,35 @@
+// src/signal-component.ts
+function extractSignals(options) {
+  const signals = [];
+  if (options.signals) {
+    signals.push(...Object.values(options.signals));
+  }
+  if (options.computed) {
+    signals.push(...Object.values(options.computed));
+  }
+  return signals;
+}
+function createSignalBinding(sig, onChange) {
+  return {
+    get: () => sig(),
+    set: (value) => {
+      sig.set(value);
+      onChange?.(value);
+    }
+  };
+}
+function signalToProps(signals) {
+  const props = {};
+  for (const [key, sig] of Object.entries(signals)) {
+    Object.defineProperty(props, key, {
+      get: () => sig(),
+      enumerable: true,
+      configurable: true
+    });
+  }
+  return props;
+}
+
+export { createSignalBinding, extractSignals, signalToProps };
+//# sourceMappingURL=signal-component.mjs.map
+//# sourceMappingURL=signal-component.mjs.map

package/dist/signal-component.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/signal-component.ts"],"names":[],"mappings":";AAaO,SAAS,eACd,OAAA,EAC+C;AAC/C,EAAA,MAAM,UAAyD,EAAC;AAChE,EAAA,IAAI,QAAQ,OAAA,EAAS;AACnB,IAAA,OAAA,CAAQ,KAAK,GAAI,MAAA,CAAO,MAAA,CAAO,OAAA,CAAQ,OAAO,CAAuB,CAAA;AAAA,EACvE;AACA,EAAA,IAAI,QAAQ,QAAA,EAAU;AACpB,IAAA,OAAA,CAAQ,KAAK,GAAI,MAAA,CAAO,MAAA,CAAO,OAAA,CAAQ,QAAQ,CAA+B,CAAA;AAAA,EAChF;AACA,EAAA,OAAO,OAAA;AACT;AAKO,SAAS,mBAAA,CACd,KACA,QAAA,EAC2C;AAC3C,EAAA,OAAO;AAAA,IACL,GAAA,EAAK,MAAM,GAAA,EAAI;AAAA,IACf,GAAA,EAAK,CAAC,KAAA,KAAa;AACjB,MAAA,GAAA,CAAI,IAAI,KAAK,CAAA;AACb,MAAA,QAAA,GAAW,KAAK,CAAA;AAAA,IAClB;AAAA,GACF;AACF;AASO,SAAS,cAAc,OAAA,EAAmE;AAC/F,EAAA,MAAM,QAAiC,EAAC;AACxC,EAAA,KAAA,MAAW,CAAC,GAAA,EAAK,GAAG,KAAK,MAAA,CAAO,OAAA,CAAQ,OAAO,CAAA,EAAG;AAChD,IAAA,MAAA,CAAO,cAAA,CAAe,OAAO,GAAA,EAAK;AAAA,MAChC,GAAA,EAAK,MAAM,GAAA,EAAI;AAAA,MACf,UAAA,EAAY,IAAA;AAAA,MACZ,YAAA,EAAc;AAAA,KACf,CAAA;AAAA,EACH;AACA,EAAA,OAAO,KAAA;AACT","file":"signal-component.mjs","sourcesContent":["// src/signal-component.ts\r\n// Signal 组件集成工具\r\n\r\nimport type { Signal, WritableSignal, ComputedSignal } from './signal';\r\n\r\nexport interface SignalComponentOptions<T = Record<string, unknown>> {\r\n  signals?: { [K in keyof T]?: Signal<T[K]> };\r\n  computed?: { [K in keyof T]?: ComputedSignal<T[K]> };\r\n}\r\n\r\n/**\r\n * 从组件选项中提取所有 signal 依赖\r\n */\r\nexport function extractSignals(\r\n  options: SignalComponentOptions,\r\n): (Signal<unknown> | ComputedSignal<unknown>)[] {\r\n  const signals: (Signal<unknown> | ComputedSignal<unknown>)[] = [];\r\n  if (options.signals) {\r\n    signals.push(...(Object.values(options.signals) as Signal<unknown>[]));\r\n  }\r\n  if (options.computed) {\r\n    signals.push(...(Object.values(options.computed) as ComputedSignal<unknown>[]));\r\n  }\r\n  return signals;\r\n}\r\n\r\n/**\r\n * 创建 signal 绑定辅助\r\n */\r\nexport function createSignalBinding<T>(\r\n  sig: WritableSignal<T>,\r\n  onChange?: (value: T) => void,\r\n): { get: () => T; set: (value: T) => void } {\r\n  return {\r\n    get: () => sig(),\r\n    set: (value: T) => {\r\n      sig.set(value);\r\n      onChange?.(value);\r\n    },\r\n  };\r\n}\r\n\r\n/**\r\n * 将 signal 值转换为响应式 props\r\n *\r\n * 注意：通过 Object.defineProperty 定义的 getter 会在每次属性访问时调用 signal()，\r\n * 这会触发 signal 的依赖追踪机制。如果此 props 对象在响应式上下文（如 effect 或\r\n * computed）中被读取，访问的 signal 会自动注册为该上下文的依赖。\r\n */\r\nexport function signalToProps(signals: Record<string, Signal<unknown>>): Record<string, unknown> {\r\n  const props: Record<string, unknown> = {};\r\n  for (const [key, sig] of Object.entries(signals)) {\r\n    Object.defineProperty(props, key, {\r\n      get: () => sig(),\r\n      enumerable: true,\r\n      configurable: true,\r\n    });\r\n  }\r\n  return props;\r\n}\r\n"]}