@lytjs/reactivity 5.0.1 → 6.0.0

package/dist/types-CMYee6LB.d.cts

@@ -0,0 +1,270 @@
+import { R as Ref, S as ShallowRef, C as ComputedRef } from './ref-CwOCKoy2.cjs';
+
+/**
+ * 包裹首次渲染过程，期间禁用响应式依赖收集。
+ * 支持嵌套调用：如果外层已经处于首次渲染优化期间，
+ * 内层调用不会提前重置标志位。
+ */
+declare function withFirstRenderOptimization<T>(fn: () => T): T;
+/**
+ * 检查当前是否应跳过响应式依赖收集。
+ * 在 withFirstRenderOptimization 执行期间返回 true。
+ */
+declare function shouldSkipTracking(): boolean;
+/**
+ * 获取被跳过的追踪次数（用于调试和测试）。
+ */
+declare function getSkippedTrackingCount(): number;
+/**
+ * 重置被跳过的追踪计数（用于测试）。
+ */
+declare function resetSkippedTrackingCount(): void;
+/**
+ * 依赖集合类型，存储订阅某个响应式属性的所有 ReactiveEffect。
+ */
+type Dep = Set<ReactiveEffect>;
+/**
+ * 响应式副作用类。
+ * 封装一个副作用函数，支持依赖自动收集、调度执行和手动停止。
+ *
+ * 创建时会自动注册到当前活跃的 effectScope 中。
+ *
+ * @typeParam T - 副作用函数的返回值类型
+ *
+ * @example
+ * ```ts
+ * const eff = new ReactiveEffect(() => {
+ *   console.log(state.count);
+ * });
+ * eff.run(); // 执行副作用，同时收集依赖
+ * eff.stop(); // 停止副作用，清理所有依赖
+ * ```
+ */
+declare class ReactiveEffect<T = unknown> {
+    fn: () => T;
+    scheduler?: ((...args: unknown[]) => unknown) | undefined;
+    active: boolean;
+    deps: Dep[];
+    parent: ReactiveEffect | undefined;
+    computed?: boolean;
+    allowRecurse?: boolean;
+    onStop?: () => void;
+    onTrack?: (event: {
+        target: object;
+        key: string | symbol;
+        type: string;
+    }) => void;
+    onTrigger?: (event: {
+        target: object;
+        key: string | symbol;
+        type: string;
+        newValue?: unknown;
+        oldValue?: unknown;
+    }) => void;
+    onError?: (error: Error) => void;
+    _cleanups: Array<() => void>;
+    constructor(fn: () => T, scheduler?: ((...args: unknown[]) => unknown) | undefined);
+    run(): T | undefined;
+    stop(): void;
+}
+/**
+ * 创建一个响应式副作用并立即执行。
+ *
+ * 副作用函数会在执行期间自动追踪所使用的响应式属性，
+ * 当这些属性发生变化时，副作用会重新执行。
+ *
+ * @param fn - 副作用函数，返回 void
+ * @param options - 配置选项
+ * @param options.lazy - 是否延迟执行（false 时立即执行）
+ * @param options.scheduler - 自定义调度器，替代默认的立即执行行为
+ * @param options.allowRecurse - 是否允许副作用递归触发自身
+ * @param options.onStop - 副作用停止时的回调
+ * @param options.onTrack - 依赖被追踪时的调试回调
+ * @param options.onTrigger - 依赖被触发时的调试回调
+ * @returns 副作用运行器，可调用 run() 手动执行或 stop() 停止
+ */
+declare function effect(fn: () => void, options?: {
+    lazy?: false;
+    scheduler?: (...args: unknown[]) => unknown;
+    allowRecurse?: boolean;
+    onStop?: () => void;
+    onTrack?: (event: {
+        target: object;
+        key: string | symbol;
+        type: string;
+    }) => void;
+    onTrigger?: (event: {
+        target: object;
+        key: string | symbol;
+        type: string;
+        newValue?: unknown;
+        oldValue?: unknown;
+    }) => void;
+}): ReactiveEffectRunner<void>;
+declare function effect<T>(fn: () => T, options: {
+    lazy: true;
+    scheduler?: (...args: unknown[]) => unknown;
+    allowRecurse?: boolean;
+    onStop?: () => void;
+    onTrack?: (event: {
+        target: object;
+        key: string | symbol;
+        type: string;
+    }) => void;
+    onTrigger?: (event: {
+        target: object;
+        key: string | symbol;
+        type: string;
+        newValue?: unknown;
+        oldValue?: unknown;
+    }) => void;
+}): ReactiveEffectRunner<T>;
+/**
+ * 停止一个响应式副作用。
+ * 清理所有依赖关系，并调用 onStop 回调。
+ *
+ * @param runner - 由 effect() 返回的副作用运行器
+ */
+declare function stop(runner: ReactiveEffectRunner): void;
+/**
+ * 暂停依赖追踪。
+ * 调用后，响应式属性的读取不会建立依赖关系。
+ * 可通过 resetTracking() 恢复。
+ */
+declare function pauseTracking(): void;
+/**
+ * 启用依赖追踪。
+ * 将当前追踪状态压入栈中并设为 true。
+ * 可通过 resetTracking() 恢复到之前的状态。
+ */
+declare function enableTracking(): void;
+/**
+ * 重置依赖追踪状态到上一次暂停/启用之前的状态。
+ * 从追踪栈中弹出最近的状态并恢复。
+ */
+declare function resetTracking(): void;
+/**
+ * 批量执行函数，期间暂停依赖追踪。
+ * 与 signalBatch 不同，batch 侧重于暂停追踪而非延迟通知。
+ * 支持嵌套调用，内层 batch 不会提前恢复追踪状态。
+ *
+ * @param fn - 需要批量执行的函数
+ *
+ * @example
+ * ```ts
+ * batch(() => {
+ *   state.a = 1; // 不会触发依赖更新
+ *   state.b = 2; // 不会触发依赖更新
+ * }); // 函数结束后恢复追踪
+ * ```
+ */
+declare function batch(fn: () => void): void;
+/**
+ * batchAsync - like batch but supports async functions.
+ * Pauses tracking during fn execution (including after await),
+ * and restores tracking state when fn completes (or throws).
+ * Returns a Promise.
+ */
+declare function batchAsync(fn: () => void | Promise<void>): Promise<void>;
+/**
+ * untrack - execute fn without tracking dependencies.
+ * Semantically different from batch: untrack means "run but don't track".
+ * Returns the return value of fn.
+ */
+declare function untrack<T>(fn: () => T): T;
+/**
+ * 在当前活跃的 effect 上注册一个清理回调。
+ * 该回调会在 effect 重新执行前或停止时被调用，用于清理副作用资源。
+ *
+ * @param fn - 清理回调函数
+ * @param failSilently - 当没有活跃 effect 时是否静默失败（默认 false，开发模式下会发出警告）
+ *
+ * @example
+ * ```ts
+ * effect(() => {
+ *   const timer = setInterval(() => console.log('tick'), 1000);
+ *   onEffectCleanup(() => clearInterval(timer));
+ * });
+ * ```
+ */
+declare function onEffectCleanup(fn: () => void, failSilently?: boolean): void;
+
+type ReactiveEffectRunner<T = unknown> = {
+    (): T;
+    effect: ReactiveEffect;
+};
+type EffectScheduler = (...args: unknown[]) => unknown;
+interface ReactiveEffectOptions {
+    lazy?: boolean;
+    scheduler?: EffectScheduler;
+    allowRecurse?: boolean;
+    onStop?: () => void;
+    onTrack?: (event: DebuggerEvent) => void;
+    onTrigger?: (event: DebuggerEvent) => void;
+}
+/**
+ * 调试事件
+ * 注意：此版本使用具体的 ReactiveEffect 类引用（生产者视角），
+ * 与 @lytjs/shared-types 中使用脱敏 ReactiveEffectRef 的版本不同。
+ * 保持此定义以避免类型不兼容（type: string vs 'track' | 'trigger'）。
+ */
+interface DebuggerEvent {
+    effect: ReactiveEffect;
+    target: object;
+    type: 'track' | 'trigger';
+    key: unknown;
+}
+interface WatchOptions<Immediate = boolean> {
+    immediate?: Immediate;
+    deep?: boolean;
+    flush?: 'pre' | 'post' | 'sync';
+    once?: boolean;
+    onTrack?: (event: DebuggerEvent) => void;
+    onTrigger?: (event: DebuggerEvent) => void;
+    scheduler?: WatchScheduler;
+    allowRecurse?: boolean;
+}
+interface WatchEffectOptions {
+    flush?: 'pre' | 'post' | 'sync';
+    once?: boolean;
+    onTrack?: (event: DebuggerEvent) => void;
+    onTrigger?: (event: DebuggerEvent) => void;
+    scheduler?: WatchScheduler;
+    allowRecurse?: boolean;
+}
+type WatchSource<T = unknown> = Ref<T> | (() => T) | object;
+type WatchCallback<T = unknown, S = T> = (newValue: T, oldValue: S, onCleanup: OnCleanup) => void;
+/**
+ * immediate 模式下 oldValue 为 undefined，否则为 T | undefined。
+ * 用于 watch 函数的回调类型推断。
+ */
+type WatchCallbackWithImmediate<T, Immediate extends boolean> = WatchCallback<T, Immediate extends true ? undefined : T | undefined>;
+type OnCleanup = (cleanupFn: () => void) => void;
+type WatchHandle = () => void;
+type WatchScheduler = (...args: unknown[]) => unknown;
+type ComputedGetter<T> = () => T;
+type ComputedSetter<T> = (newValue: T) => void;
+interface WritableComputedOptions<T> {
+    get: ComputedGetter<T>;
+    set: ComputedSetter<T>;
+}
+type WritableComputedRef<T = unknown> = ComputedRef<T> & {
+    value: T;
+};
+type UnwrapRef<T> = T extends ShallowRef<infer V> ? V : T extends Ref<infer V> ? UnwrapRef<V> : T;
+type UnwrapNestedRefs<T> = T extends Ref<infer V> ? UnwrapRef<V> : T extends object | ((...args: unknown[]) => unknown) ? {
+    [K in keyof T]: UnwrapNestedRefs<T[K]>;
+} : T;
+type DeepReadonly<T> = {
+    readonly [K in keyof T]: DeepReadonly<T[K]>;
+};
+type ToRefs<T = unknown> = {
+    [K in keyof T]: Ref<T[K]>;
+};
+type ReactiveObject<T extends object = object> = {
+    [K in keyof T]: T[K];
+} & {
+    __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 };

package/dist/types-CXeWWYm6.d.ts

@@ -0,0 +1,270 @@
+import { R as Ref, S as ShallowRef, C as ComputedRef } from './ref-CwOCKoy2.js';
+
+/**
+ * 包裹首次渲染过程，期间禁用响应式依赖收集。
+ * 支持嵌套调用：如果外层已经处于首次渲染优化期间，
+ * 内层调用不会提前重置标志位。
+ */
+declare function withFirstRenderOptimization<T>(fn: () => T): T;
+/**
+ * 检查当前是否应跳过响应式依赖收集。
+ * 在 withFirstRenderOptimization 执行期间返回 true。
+ */
+declare function shouldSkipTracking(): boolean;
+/**
+ * 获取被跳过的追踪次数（用于调试和测试）。
+ */
+declare function getSkippedTrackingCount(): number;
+/**
+ * 重置被跳过的追踪计数（用于测试）。
+ */
+declare function resetSkippedTrackingCount(): void;
+/**
+ * 依赖集合类型，存储订阅某个响应式属性的所有 ReactiveEffect。
+ */
+type Dep = Set<ReactiveEffect>;
+/**
+ * 响应式副作用类。
+ * 封装一个副作用函数，支持依赖自动收集、调度执行和手动停止。
+ *
+ * 创建时会自动注册到当前活跃的 effectScope 中。
+ *
+ * @typeParam T - 副作用函数的返回值类型
+ *
+ * @example
+ * ```ts
+ * const eff = new ReactiveEffect(() => {
+ *   console.log(state.count);
+ * });
+ * eff.run(); // 执行副作用，同时收集依赖
+ * eff.stop(); // 停止副作用，清理所有依赖
+ * ```
+ */
+declare class ReactiveEffect<T = unknown> {
+    fn: () => T;
+    scheduler?: ((...args: unknown[]) => unknown) | undefined;
+    active: boolean;
+    deps: Dep[];
+    parent: ReactiveEffect | undefined;
+    computed?: boolean;
+    allowRecurse?: boolean;
+    onStop?: () => void;
+    onTrack?: (event: {
+        target: object;
+        key: string | symbol;
+        type: string;
+    }) => void;
+    onTrigger?: (event: {
+        target: object;
+        key: string | symbol;
+        type: string;
+        newValue?: unknown;
+        oldValue?: unknown;
+    }) => void;
+    onError?: (error: Error) => void;
+    _cleanups: Array<() => void>;
+    constructor(fn: () => T, scheduler?: ((...args: unknown[]) => unknown) | undefined);
+    run(): T | undefined;
+    stop(): void;
+}
+/**
+ * 创建一个响应式副作用并立即执行。
+ *
+ * 副作用函数会在执行期间自动追踪所使用的响应式属性，
+ * 当这些属性发生变化时，副作用会重新执行。
+ *
+ * @param fn - 副作用函数，返回 void
+ * @param options - 配置选项
+ * @param options.lazy - 是否延迟执行（false 时立即执行）
+ * @param options.scheduler - 自定义调度器，替代默认的立即执行行为
+ * @param options.allowRecurse - 是否允许副作用递归触发自身
+ * @param options.onStop - 副作用停止时的回调
+ * @param options.onTrack - 依赖被追踪时的调试回调
+ * @param options.onTrigger - 依赖被触发时的调试回调
+ * @returns 副作用运行器，可调用 run() 手动执行或 stop() 停止
+ */
+declare function effect(fn: () => void, options?: {
+    lazy?: false;
+    scheduler?: (...args: unknown[]) => unknown;
+    allowRecurse?: boolean;
+    onStop?: () => void;
+    onTrack?: (event: {
+        target: object;
+        key: string | symbol;
+        type: string;
+    }) => void;
+    onTrigger?: (event: {
+        target: object;
+        key: string | symbol;
+        type: string;
+        newValue?: unknown;
+        oldValue?: unknown;
+    }) => void;
+}): ReactiveEffectRunner<void>;
+declare function effect<T>(fn: () => T, options: {
+    lazy: true;
+    scheduler?: (...args: unknown[]) => unknown;
+    allowRecurse?: boolean;
+    onStop?: () => void;
+    onTrack?: (event: {
+        target: object;
+        key: string | symbol;
+        type: string;
+    }) => void;
+    onTrigger?: (event: {
+        target: object;
+        key: string | symbol;
+        type: string;
+        newValue?: unknown;
+        oldValue?: unknown;
+    }) => void;
+}): ReactiveEffectRunner<T>;
+/**
+ * 停止一个响应式副作用。
+ * 清理所有依赖关系，并调用 onStop 回调。
+ *
+ * @param runner - 由 effect() 返回的副作用运行器
+ */
+declare function stop(runner: ReactiveEffectRunner): void;
+/**
+ * 暂停依赖追踪。
+ * 调用后，响应式属性的读取不会建立依赖关系。
+ * 可通过 resetTracking() 恢复。
+ */
+declare function pauseTracking(): void;
+/**
+ * 启用依赖追踪。
+ * 将当前追踪状态压入栈中并设为 true。
+ * 可通过 resetTracking() 恢复到之前的状态。
+ */
+declare function enableTracking(): void;
+/**
+ * 重置依赖追踪状态到上一次暂停/启用之前的状态。
+ * 从追踪栈中弹出最近的状态并恢复。
+ */
+declare function resetTracking(): void;
+/**
+ * 批量执行函数，期间暂停依赖追踪。
+ * 与 signalBatch 不同，batch 侧重于暂停追踪而非延迟通知。
+ * 支持嵌套调用，内层 batch 不会提前恢复追踪状态。
+ *
+ * @param fn - 需要批量执行的函数
+ *
+ * @example
+ * ```ts
+ * batch(() => {
+ *   state.a = 1; // 不会触发依赖更新
+ *   state.b = 2; // 不会触发依赖更新
+ * }); // 函数结束后恢复追踪
+ * ```
+ */
+declare function batch(fn: () => void): void;
+/**
+ * batchAsync - like batch but supports async functions.
+ * Pauses tracking during fn execution (including after await),
+ * and restores tracking state when fn completes (or throws).
+ * Returns a Promise.
+ */
+declare function batchAsync(fn: () => void | Promise<void>): Promise<void>;
+/**
+ * untrack - execute fn without tracking dependencies.
+ * Semantically different from batch: untrack means "run but don't track".
+ * Returns the return value of fn.
+ */
+declare function untrack<T>(fn: () => T): T;
+/**
+ * 在当前活跃的 effect 上注册一个清理回调。
+ * 该回调会在 effect 重新执行前或停止时被调用，用于清理副作用资源。
+ *
+ * @param fn - 清理回调函数
+ * @param failSilently - 当没有活跃 effect 时是否静默失败（默认 false，开发模式下会发出警告）
+ *
+ * @example
+ * ```ts
+ * effect(() => {
+ *   const timer = setInterval(() => console.log('tick'), 1000);
+ *   onEffectCleanup(() => clearInterval(timer));
+ * });
+ * ```
+ */
+declare function onEffectCleanup(fn: () => void, failSilently?: boolean): void;
+
+type ReactiveEffectRunner<T = unknown> = {
+    (): T;
+    effect: ReactiveEffect;
+};
+type EffectScheduler = (...args: unknown[]) => unknown;
+interface ReactiveEffectOptions {
+    lazy?: boolean;
+    scheduler?: EffectScheduler;
+    allowRecurse?: boolean;
+    onStop?: () => void;
+    onTrack?: (event: DebuggerEvent) => void;
+    onTrigger?: (event: DebuggerEvent) => void;
+}
+/**
+ * 调试事件
+ * 注意：此版本使用具体的 ReactiveEffect 类引用（生产者视角），
+ * 与 @lytjs/shared-types 中使用脱敏 ReactiveEffectRef 的版本不同。
+ * 保持此定义以避免类型不兼容（type: string vs 'track' | 'trigger'）。
+ */
+interface DebuggerEvent {
+    effect: ReactiveEffect;
+    target: object;
+    type: 'track' | 'trigger';
+    key: unknown;
+}
+interface WatchOptions<Immediate = boolean> {
+    immediate?: Immediate;
+    deep?: boolean;
+    flush?: 'pre' | 'post' | 'sync';
+    once?: boolean;
+    onTrack?: (event: DebuggerEvent) => void;
+    onTrigger?: (event: DebuggerEvent) => void;
+    scheduler?: WatchScheduler;
+    allowRecurse?: boolean;
+}
+interface WatchEffectOptions {
+    flush?: 'pre' | 'post' | 'sync';
+    once?: boolean;
+    onTrack?: (event: DebuggerEvent) => void;
+    onTrigger?: (event: DebuggerEvent) => void;
+    scheduler?: WatchScheduler;
+    allowRecurse?: boolean;
+}
+type WatchSource<T = unknown> = Ref<T> | (() => T) | object;
+type WatchCallback<T = unknown, S = T> = (newValue: T, oldValue: S, onCleanup: OnCleanup) => void;
+/**
+ * immediate 模式下 oldValue 为 undefined，否则为 T | undefined。
+ * 用于 watch 函数的回调类型推断。
+ */
+type WatchCallbackWithImmediate<T, Immediate extends boolean> = WatchCallback<T, Immediate extends true ? undefined : T | undefined>;
+type OnCleanup = (cleanupFn: () => void) => void;
+type WatchHandle = () => void;
+type WatchScheduler = (...args: unknown[]) => unknown;
+type ComputedGetter<T> = () => T;
+type ComputedSetter<T> = (newValue: T) => void;
+interface WritableComputedOptions<T> {
+    get: ComputedGetter<T>;
+    set: ComputedSetter<T>;
+}
+type WritableComputedRef<T = unknown> = ComputedRef<T> & {
+    value: T;
+};
+type UnwrapRef<T> = T extends ShallowRef<infer V> ? V : T extends Ref<infer V> ? UnwrapRef<V> : T;
+type UnwrapNestedRefs<T> = T extends Ref<infer V> ? UnwrapRef<V> : T extends object | ((...args: unknown[]) => unknown) ? {
+    [K in keyof T]: UnwrapNestedRefs<T[K]>;
+} : T;
+type DeepReadonly<T> = {
+    readonly [K in keyof T]: DeepReadonly<T[K]>;
+};
+type ToRefs<T = unknown> = {
+    [K in keyof T]: Ref<T[K]>;
+};
+type ReactiveObject<T extends object = object> = {
+    [K in keyof T]: T[K];
+} & {
+    __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 };

package/package.json

@@ -1,56 +1,79 @@
 {
   "name": "@lytjs/reactivity",
-  "version": "5.0.1",
-  "description": "Lyt.js 响应式系统 - 提供响应式数据、计算属性、侦听器等核心响应式能力",
+  "version": "6.0.0",
+  "description": "LytJS reactive system - signals, refs, computed, watch, and effects",
+  "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
-  "types": "./dist/types/index.d.ts",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/types/index.d.ts",
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs",
-      "require": "./dist/index.cjs",
-      "default": "./dist/index.mjs"
+      "require": "./dist/index.cjs"
     },
     "./signal": {
-      "types": "./dist/types/signal.d.ts",
+      "types": "./dist/signal.d.ts",
       "import": "./dist/signal.mjs",
-      "require": "./dist/signal.cjs",
-      "default": "./dist/signal.mjs"
+      "require": "./dist/signal.cjs"
+    },
+    "./signal-component": {
+      "types": "./dist/signal-component.d.ts",
+      "import": "./dist/signal-component.mjs",
+      "require": "./dist/signal-component.cjs"
+    },
+    "./scope": {
+      "types": "./dist/scope.d.ts",
+      "import": "./dist/scope.mjs",
+      "require": "./dist/scope.cjs"
+    },
+    "./async": {
+      "types": "./dist/async.d.ts",
+      "import": "./dist/async.mjs",
+      "require": "./dist/async.cjs"
     }
   },
-  "sideEffects": false,
   "files": [
     "dist"
   ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "type-check": "tsc --noEmit",
+    "lint": "eslint \"src/**/*.ts\" \"tests/**/*.ts\"",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@lytjs/shared-types": "^6.0.0",
+    "@lytjs/common-is": "^6.0.0",
+    "@lytjs/common-scheduler": "^6.0.0",
+    "@lytjs/common-error": "^6.0.0",
+    "@lytjs/common-constants": "^6.0.0",
+    "@lytjs/common-assertions": "^6.0.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0",
+    "vitest": "^1.6.0"
+  },
+  "peerDependencies": {},
   "license": "MIT",
-  "author": "lytjs",
   "repository": {
     "type": "git",
-    "url": "https://gitee.com/lytjs/lytjs"
+    "url": "https://gitee.com/lytjs/lytjs.git",
+    "directory": "packages/reactivity"
   },
-  "homepage": "https://gitee.com/lytjs/lytjs",
   "keywords": [
-    "lyt",
     "lytjs",
-    "javascript",
-    "framework",
-    "frontend",
-    "vue-like",
-    "lightweight",
-    "zero-dependency",
     "reactivity",
+    "signal",
+    "vue",
     "reactive",
-    "ref",
     "computed",
-    "watch",
-    "effect",
-    "响应式"
-  ],
-  "publishConfig": {
-    "access": "public"
-  },
-  "dependencies": {
-    "@lytjs/common": "^5.0.1"
-  }
+    "watch"
+  ]
 }