@lytjs/reactivity 5.0.1 → 6.0.0

package/dist/types/computed.d.ts

@@ -1,70 +0,0 @@
-/**
- * Lyt.js 响应式系统 — 计算属性（Computed）
- *
- * 计算属性是基于响应式依赖进行缓存的派生值。
- * 只有当依赖发生变化时才会重新计算，否则返回缓存值。
- *
- * 核心机制：
- * 1. dirty 标记：标记计算值是否过期
- * 2. 惰性求值：只有在访问 .value 时才计算
- * 3. 缓存：dirty 为 false 时直接返回缓存值
- * 4. 依赖传播：当计算属性的值变化时，通知依赖它的副作用
- *
- * 实现原理：
- * - 内部维护一个 ReactiveEffect，getter 作为副作用函数
- * - 当 getter 中的响应式数据变化时，将 dirty 设为 true
- * - 当访问 .value 且 dirty 为 true 时，重新执行 getter
- */
-import { Ref } from './ref';
-/** 计算属性的 getter 函数 */
-export type ComputedGetter<T = any> = () => T;
-/** 计算属性的 setter 函数 */
-export type ComputedSetter<T = any> = (value: T) => void;
-/** computed 选项（支持 getter 或 getter+setter） */
-export interface WritableComputedOptions<T = any> {
-    get: ComputedGetter<T>;
-    set: ComputedSetter<T>;
-}
-/** ComputedRef 接口（只读） */
-export interface ComputedRef<T = any> extends Ref<T> {
-    /** 只读标记 */
-    readonly value: T;
-}
-/** WritableComputedRef 接口（可写） */
-export interface WritableComputedRef<T = any> extends Ref<T> {
-    value: T;
-}
-/**
- * 创建一个计算属性
- *
- * 支持两种用法：
- * 1. 传入 getter 函数：创建只读计算属性
- * 2. 传入 { get, set } 对象：创建可写计算属性
- *
- * @param getterOrOptions - getter 函数或 { get, set } 选项对象
- * @returns 计算属性 Ref
- *
- * @example
- * ```ts
- * const count = ref(1)
- * const double = computed(() => count.value * 2)
- * console.log(double.value)  // 2
- * count.value = 5
- * console.log(double.value)  // 10（自动重新计算）
- *
- * // 可写计算属性
- * const firstName = ref('Lyt')
- * const lastName = ref('JS')
- * const fullName = computed({
- *   get: () => firstName.value + ' ' + lastName.value,
- *   set: (val) => {
- *     const [first, last] = val.split(' ')
- *     firstName.value = first
- *     lastName.value = last
- *   }
- * })
- * fullName.value = 'Hello World'  // firstName = 'Hello', lastName = 'World'
- * ```
- */
-export declare function computed<T = any>(getterOrOptions: ComputedGetter<T> | WritableComputedOptions<T>): ComputedRef<T> | WritableComputedRef<T>;
-//# sourceMappingURL=computed.d.ts.map

package/dist/types/computed.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"computed.d.ts","sourceRoot":"","sources":["../../src/computed.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AASH,OAAO,EAAE,GAAG,EAAoB,MAAM,OAAO,CAAC;AAI9C,sBAAsB;AACtB,MAAM,MAAM,cAAc,CAAC,CAAC,GAAG,GAAG,IAAI,MAAM,CAAC,CAAC;AAE9C,sBAAsB;AACtB,MAAM,MAAM,cAAc,CAAC,CAAC,GAAG,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;AAEzD,6CAA6C;AAC7C,MAAM,WAAW,uBAAuB,CAAC,CAAC,GAAG,GAAG;IAC9C,GAAG,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC;IACvB,GAAG,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC;CACxB;AAED,yBAAyB;AACzB,MAAM,WAAW,WAAW,CAAC,CAAC,GAAG,GAAG,CAAE,SAAQ,GAAG,CAAC,CAAC,CAAC;IAClD,WAAW;IACX,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;CACnB;AAED,iCAAiC;AACjC,MAAM,WAAW,mBAAmB,CAAC,CAAC,GAAG,GAAG,CAAE,SAAQ,GAAG,CAAC,CAAC,CAAC;IAC1D,KAAK,EAAE,CAAC,CAAC;CACV;AA4GD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,QAAQ,CAAC,CAAC,GAAG,GAAG,EAC9B,eAAe,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,uBAAuB,CAAC,CAAC,CAAC,GAC9D,WAAW,CAAC,CAAC,CAAC,GAAG,mBAAmB,CAAC,CAAC,CAAC,CAmBzC"}

package/dist/types/effect.d.ts

@@ -1,157 +0,0 @@
-/**
- * Lyt.js 响应式系统 — 副作用系统（Effect）
- *
- * 核心机制：
- * 1. 依赖收集（track）：当读取响应式属性时，记录当前正在执行的副作用
- * 2. 触发更新（trigger）：当修改响应式属性时，通知所有依赖该属性的副作用重新执行
- *
- * 数据结构：
- *   targetMap: WeakMap<target, Map<key, Set<ReactiveEffect>>>
- *   - 第一层 WeakMap：以目标对象为 key，value 是该对象所有属性的依赖映射
- *   - 第二层 Map：以属性名为 key，value 是依赖该属性的所有副作用集合
- *   - 第三层 Set：存储具体的 ReactiveEffect 实例（自动去重）
- */
-/** 副作用函数类型 */
-export type EffectFn = () => any;
-/** trigger 触发类型 */
-export type TriggerOpTypes = 'add' | 'delete' | 'set';
-/** effect 选项 */
-export interface ReactiveEffectOptions {
-    /** 调度器函数：自定义副作用的执行时机 */
-    scheduler?: (effect: ReactiveEffect) => void;
-    /** 副作用执行前的回调 */
-    beforeRun?: () => void;
-    /** 副作用执行后的回调 */
-    afterRun?: () => void;
-    /** 是否在首次运行时就停止（用于 computed） */
-    lazy?: boolean;
-    /** 是否允许在 stop 后重新激活 */
-    allowRecurse?: boolean;
-    /** 副作用唯一标识（用于调试和排序） */
-    id?: number;
-}
-/**
- * 当前正在运行的副作用
- * 在依赖收集时使用，用于将副作用与响应式属性关联
- */
-export declare let activeEffect: ReactiveEffect | null;
-/** 依赖映射表类型：属性名 → 依赖该属性的副作用集合 */
-export type DepsMap = Map<unknown, Set<ReactiveEffect>>;
-/**
- * 响应式副作用类
- * 封装一个副作用函数，管理其依赖关系和执行生命周期
- */
-export declare class ReactiveEffect {
-    /** 副作用函数 */
-    fn: EffectFn;
-    /** 调度器（可选） */
-    scheduler?: (effect: ReactiveEffect) => void;
-    /** 副作用执行前的回调 */
-    beforeRun?: () => void;
-    /** 副作用执行后的回调 */
-    afterRun?: () => void;
-    /** 是否惰性执行（首次不自动执行） */
-    lazy?: boolean;
-    /** 是否允许递归 */
-    allowRecurse?: boolean;
-    /** 副作用唯一 ID */
-    id: number;
-    /** 是否处于活跃状态 */
-    active: boolean;
-    /**
-     * 该副作用依赖的所有 dep 集合
-     * 用于在 stop 时从所有 dep 中移除自身
-     * 每个 dep 是一个 Set<ReactiveEffect>
-     */
-    deps: Set<Set<ReactiveEffect>>;
-    constructor(fn: EffectFn, options?: ReactiveEffectOptions);
-    /**
-     * 执行副作用函数
-     * - 将自身压入 effectStack 并设为 activeEffect
-     * - 执行前清理旧依赖（每次执行重新收集依赖）
-     * - 执行完毕后弹出栈
-     *
-     * @returns 副作用函数的返回值
-     */
-    run(): any;
-    /**
-     * 停止该副作用
-     * - 从所有依赖集合中移除自身
-     * - 标记为非活跃状态
-     */
-    stop(): void;
-    /** 停止时的回调（可由外部设置） */
-    onStop?: () => void;
-}
-/**
- * 暂停依赖收集
- * 将当前 shouldTrack 状态压入栈中，并设置为 false
- */
-export declare function pauseTracking(): void;
-/**
- * 恢复依赖收集
- * 从栈中弹出上一次的 shouldTrack 状态
- */
-export declare function resetTracking(): void;
-/**
- * 依赖收集
- * 当响应式对象的属性被读取时调用
- * 将当前活跃的副作用（activeEffect）添加到对应属性的依赖集合中
- *
- * @param target - 被读取的目标对象
- * @param key - 被读取的属性名
- */
-export declare function track(target: object, key: unknown): void;
-/**
- * 触发依赖更新
- * 当响应式对象的属性被修改时调用
- * 通知所有依赖该属性的副作用重新执行
- *
- * @param target - 被修改的目标对象
- * @param key - 被修改的属性名
- * @param type - 操作类型：'set'（修改）、'add'（新增）、'delete'（删除）
- * @param newValue - 新值（可选，用于某些特殊场景）
- */
-export declare function trigger(target: object, key: unknown, type: TriggerOpTypes, newValue?: any): void;
-/**
- * 迭代器依赖的 key
- * 当对象新增或删除属性时，需要触发依赖 ITERATE_KEY 的副作用
- * （例如 for...in 循环、Object.keys() 等）
- */
-export declare const ITERATE_KEY: unique symbol;
-/**
- * 创建响应式副作用
- *
- * @param fn - 副作用函数
- * @param options - 配置选项
- * @returns 副作用对象（ReactiveEffect 实例）
- *
- * @example
- * ```ts
- * const obj = reactive({ count: 0 })
- * const runner = effect(() => {
- *   console.log(obj.count)
- * })
- * obj.count++ // 自动触发副作用重新执行
- * runner.effect.stop() // 停止副作用
- * ```
- */
-/** effect() 返回的 runner 类型 */
-export interface EffectRunner {
-    (): unknown;
-    effect: ReactiveEffect;
-    stop(): void;
-}
-export declare function effect(fn: EffectFn, options?: ReactiveEffectOptions): EffectRunner;
-/**
- * 停止一个副作用
- *
- * @param runner - effect() 返回的 runner 对象
- */
-export declare function stop(runner: EffectRunner): void;
-/**
- * 获取当前 targetMap 的引用（用于调试）
- * @internal
- */
-export declare function getTargetMap(): WeakMap<object, DepsMap>;
-//# sourceMappingURL=effect.d.ts.map

package/dist/types/effect.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"effect.d.ts","sourceRoot":"","sources":["../../src/effect.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAMH,cAAc;AACd,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,CAAC;AAEjC,mBAAmB;AACnB,MAAM,MAAM,cAAc,GAAG,KAAK,GAAG,QAAQ,GAAG,KAAK,CAAC;AAEtD,gBAAgB;AAChB,MAAM,WAAW,qBAAqB;IACpC,wBAAwB;IACxB,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,cAAc,KAAK,IAAI,CAAC;IAC7C,gBAAgB;IAChB,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;IACvB,gBAAgB;IAChB,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IACtB,+BAA+B;IAC/B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,uBAAuB;IACvB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,uBAAuB;IACvB,EAAE,CAAC,EAAE,MAAM,CAAC;CACb;AAID;;;GAGG;AACH,eAAO,IAAI,YAAY,EAAE,cAAc,GAAG,IAAW,CAAC;AAgBtD,gCAAgC;AAChC,MAAM,MAAM,OAAO,GAAG,GAAG,CAAC,OAAO,EAAE,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC;AAUxD;;;GAGG;AACH,qBAAa,cAAc;IACzB,YAAY;IACZ,EAAE,EAAE,QAAQ,CAAC;IAEb,cAAc;IACd,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,cAAc,KAAK,IAAI,CAAC;IAE7C,gBAAgB;IAChB,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;IAEvB,gBAAgB;IAChB,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IAEtB,sBAAsB;IACtB,IAAI,CAAC,EAAE,OAAO,CAAC;IAEf,aAAa;IACb,YAAY,CAAC,EAAE,OAAO,CAAC;IAEvB,eAAe;IACf,EAAE,EAAE,MAAM,CAAC;IAEX,eAAe;IACf,MAAM,EAAE,OAAO,CAAQ;IAEvB;;;;OAIG;IACH,IAAI,EAAE,GAAG,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,CAAa;gBAE/B,EAAE,EAAE,QAAQ,EAAE,OAAO,GAAE,qBAA0B;IAS7D;;;;;;;OAOG;IACH,GAAG,IAAI,GAAG;IAkCV;;;;OAIG;IACH,IAAI,IAAI,IAAI;IAYZ,qBAAqB;IACrB,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;CACrB;AAgBD;;;GAGG;AACH,wBAAgB,aAAa,IAAI,IAAI,CAGpC;AAED;;;GAGG;AACH,wBAAgB,aAAa,IAAI,IAAI,CAGpC;AAqBD;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,GAAG,IAAI,CA2BxD;AAID;;;;;;;;;GASG;AACH,wBAAgB,OAAO,CACrB,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,OAAO,EACZ,IAAI,EAAE,cAAc,EACpB,QAAQ,CAAC,EAAE,GAAG,GACb,IAAI,CAiDN;AAED;;;;GAIG;AACH,eAAO,MAAM,WAAW,eAAoB,CAAC;AAI7C;;;;;;;;;;;;;;;;GAgBG;AACH,6BAA6B;AAC7B,MAAM,WAAW,YAAY;IAC3B,IAAI,OAAO,CAAC;IACZ,MAAM,EAAE,cAAc,CAAC;IACvB,IAAI,IAAI,IAAI,CAAC;CACd;AAED,wBAAgB,MAAM,CACpB,EAAE,EAAE,QAAQ,EACZ,OAAO,GAAE,qBAA0B,GAClC,YAAY,CAed;AAED;;;;GAIG;AACH,wBAAgB,IAAI,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,CAE/C;AAED;;;GAGG;AACH,wBAAgB,YAAY,IAAI,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,CAEvD"}

package/dist/types/index.d.ts

@@ -1,21 +0,0 @@
-/**
- * Lyt.js 响应式系统 — 统一导出入口
- *
- * 导出所有公共 API，供外部使用。
- * 纯原生零依赖实现。
- */
-export { effect, stop, ReactiveEffect, track, trigger, ITERATE_KEY, activeEffect, pauseTracking, resetTracking, } from './effect';
-export type { EffectFn, ReactiveEffectOptions, TriggerOpTypes, } from './effect';
-export { reactive, readonly, shallowReactive, toRaw, isReactive, isReadonly, markReadOnly, markSkip, reactiveFlag, readonlyFlag, rawSymbol, } from './reactive';
-export type { ReactiveOptions } from './reactive';
-export { ref, shallowRef, isRef, unref, toRef, toRefs, triggerRef, refSymbol, shallowRefSymbol, } from './ref';
-export type { Ref, UnwrapRef } from './ref';
-export { computed } from './computed';
-export type { ComputedRef, WritableComputedRef, ComputedGetter, ComputedSetter, WritableComputedOptions, } from './computed';
-export { watch, watchEffect, nextTick } from './watch';
-export type { WatchCallback, WatchSource, WatchOptions, WatchEffectOptions, WatchStopHandle, } from './watch';
-export { queueJob, queuePostFlushCb, hasPendingJob, clearQueue, type SchedulerJob, } from '@lytjs/common';
-export { signal, computed as computedSignal, effect as signalEffect, batch, untrack, } from './signal';
-export type { Signal, WritableSignal, ComputedSignal, EffectCleanup, } from './signal';
-export { useSignal, useSignalState, enterSignalComponentContext, onSignalCleanup, } from './signal-component';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EACL,MAAM,EACN,IAAI,EACJ,cAAc,EACd,KAAK,EACL,OAAO,EACP,WAAW,EACX,YAAY,EACZ,aAAa,EACb,aAAa,GACd,MAAM,UAAU,CAAC;AAElB,YAAY,EACV,QAAQ,EACR,qBAAqB,EACrB,cAAc,GACf,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,QAAQ,EACR,QAAQ,EACR,eAAe,EACf,KAAK,EACL,UAAU,EACV,UAAU,EACV,YAAY,EACZ,QAAQ,EACR,YAAY,EACZ,YAAY,EACZ,SAAS,GACV,MAAM,YAAY,CAAC;AAEpB,YAAY,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAGlD,OAAO,EACL,GAAG,EACH,UAAU,EACV,KAAK,EACL,KAAK,EACL,KAAK,EACL,MAAM,EACN,UAAU,EACV,SAAS,EACT,gBAAgB,GACjB,MAAM,OAAO,CAAC;AAEf,YAAY,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAG5C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC,YAAY,EACV,WAAW,EACX,mBAAmB,EACnB,cAAc,EACd,cAAc,EACd,uBAAuB,GACxB,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEvD,YAAY,EACV,aAAa,EACb,WAAW,EACX,YAAY,EACZ,kBAAkB,EAClB,eAAe,GAChB,MAAM,SAAS,CAAC;AAIjB,OAAO,EACL,QAAQ,EACR,gBAAgB,EAChB,aAAa,EACb,UAAU,EACV,KAAK,YAAY,GAClB,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,MAAM,EACN,QAAQ,IAAI,cAAc,EAC1B,MAAM,IAAI,YAAY,EACtB,KAAK,EACL,OAAO,GACR,MAAM,UAAU,CAAC;AAElB,YAAY,EACV,MAAM,EACN,cAAc,EACd,cAAc,EACd,aAAa,GACd,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,SAAS,EACT,cAAc,EACd,2BAA2B,EAC3B,eAAe,GAChB,MAAM,oBAAoB,CAAC"}

package/dist/types/reactive.d.ts

@@ -1,98 +0,0 @@
-/**
- * Lyt.js 响应式系统 — 响应式代理（Reactive）
- *
- * 基于 ES6 Proxy 实现的深层响应式代理。
- * - 拦截 get 进行依赖收集，并对嵌套对象递归代理
- * - 拦截 set 进行值比较后触发更新
- * - 拦截 deleteProperty 处理属性删除
- * - 支持 readonly 和 shallow 模式
- */
-/** reactive 配置选项 */
-export interface ReactiveOptions {
-    /** 是否深层响应式（默认 true） */
-    deep?: boolean;
-    /** 是否只读（默认 false） */
-    readonly?: boolean;
-}
-/** 只读标记 Symbol */
-export declare const readonlyFlag: unique symbol;
-/** 原始对象标记 Symbol（存储在代理对象上，指向原始对象） */
-export declare const rawSymbol: unique symbol;
-/** 响应式标记 Symbol（存储在原始对象上，标记已被代理） */
-export declare const reactiveFlag: unique symbol;
-/** 跳过代理标记 Symbol */
-export declare const skipFlag: unique symbol;
-/**
- * 判断值是否为对象（非 null）
- */
-export declare function isObject(val: unknown): val is object;
-/**
- * 创建深层响应式代理
- *
- * @param target - 要代理的目标对象（必须是对象类型）
- * @param options - 配置选项
- * @returns 响应式代理对象
- *
- * @example
- * ```ts
- * const state = reactive({ count: 0, nested: { foo: 'bar' } })
- * effect(() => console.log(state.count))  // 0
- * state.count++  // 触发 effect，输出 1
- * ```
- */
-export declare function reactive<T extends object>(target: T, options?: ReactiveOptions): T;
-/**
- * 创建只读响应式代理
- * 所有修改操作都会被阻止并发出警告
- *
- * @param target - 要代理的目标对象
- * @returns 只读代理对象
- */
-export declare function readonly<T extends object>(target: T): T;
-/**
- * 创建浅层响应式代理
- * 只有第一层属性是响应式的，嵌套对象不会被代理
- *
- * @param target - 要代理的目标对象
- * @returns 浅层响应式代理对象
- */
-export declare function shallowReactive<T extends object>(target: T): T;
-/**
- * 获取代理对象对应的原始对象
- * 如果传入的不是代理对象，则原样返回
- *
- * @param observed - 代理对象或普通对象
- * @returns 原始对象
- */
-export declare function toRaw<T>(observed: T): T;
-/**
- * 判断一个值是否是响应式代理对象
- *
- * @param value - 要检查的值
- * @returns 是否是响应式代理
- */
-export declare function isReactive(value: unknown): boolean;
-/**
- * 判断一个值是否是只读代理对象
- *
- * @param value - 要检查的值
- * @returns 是否是只读代理
- */
-export declare function isReadonly(value: unknown): boolean;
-/**
- * 标记一个对象为只读
- * 用于在 reactive 内部标记嵌套对象
- *
- * @param obj - 要标记的对象
- * @returns 标记后的对象
- */
-export declare function markReadOnly(obj: object): object;
-/**
- * 标记一个对象跳过代理
- * 当 reactive 遇到标记了 skip 的对象时，不会对其子属性进行代理
- *
- * @param obj - 要标记的对象
- * @returns 标记后的对象
- */
-export declare function markSkip(obj: object): object;
-//# sourceMappingURL=reactive.d.ts.map

package/dist/types/reactive.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"reactive.d.ts","sourceRoot":"","sources":["../../src/reactive.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,oBAAoB;AACpB,MAAM,WAAW,eAAe;IAC9B,uBAAuB;IACvB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,qBAAqB;IACrB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,kBAAkB;AAClB,eAAO,MAAM,YAAY,eAAqB,CAAC;AAE/C,qCAAqC;AACrC,eAAO,MAAM,SAAS,eAAgB,CAAC;AAEvC,oCAAoC;AACpC,eAAO,MAAM,YAAY,eAAqB,CAAC;AAE/C,oBAAoB;AACpB,eAAO,MAAM,QAAQ,eAAiB,CAAC;AAwBvC;;GAEG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,MAAM,CAEpD;AAgVD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,MAAM,EACvC,MAAM,EAAE,CAAC,EACT,OAAO,GAAE,eAAoB,GAC5B,CAAC,CA2BH;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,CAmBvD;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,CAgB9D;AAED;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,CAAC,CAIvC;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAMlD;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAElD;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAGhD;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAG5C"}

package/dist/types/ref.d.ts

@@ -1,128 +0,0 @@
-/**
- * Lyt.js 响应式系统 — Ref（引用类型响应式）
- *
- * Ref 用于将基本类型值（string/number/boolean）变为响应式。
- * 也可以包装对象，此时行为类似 reactive。
- *
- * 实现方式：
- * - 使用一个普通对象 { _value, __v_isRef } 存储值
- * - 通过 Proxy 拦截 get/set 来实现依赖收集和触发更新
- * - 当值是对象时，自动用 reactive 进行深层代理
- */
-/** Ref 标记 Symbol */
-export declare const refSymbol: unique symbol;
-/** ShallowRef 标记 Symbol */
-export declare const shallowRefSymbol: unique symbol;
-/** Ref 接口 */
-export interface Ref<T = any> {
-    /** 存储的值 */
-    value: T;
-    /** Ref 标记 */
-    [refSymbol]: true;
-}
-/** Ref 类型守卫 */
-export type UnwrapRef<T> = T extends Ref<infer V> ? V : T;
-/**
- * 创建一个 Ref
- *
- * - 如果传入的值已经是 Ref，直接返回
- * - 如果传入的是对象，内部用 reactive 包装
- * - 返回一个 Proxy，拦截 .value 的读写
- *
- * @param value - 初始值
- * @returns Ref 对象
- *
- * @example
- * ```ts
- * const count = ref(0)
- * effect(() => console.log(count.value))  // 0
- * count.value++  // 触发 effect，输出 1
- *
- * const obj = ref({ name: 'lyt' })
- * effect(() => console.log(obj.value.name))  // 'lyt'
- * obj.value.name = 'new'  // 触发 effect（深层响应式）
- * ```
- */
-export declare function ref<T = any>(value: T): Ref<T>;
-/**
- * 创建一个浅层 Ref
- * 与 ref 的区别：当值是对象时，不会用 reactive 包装
- * 只有 .value 本身的替换会触发更新，对象内部的变化不会触发
- *
- * @param value - 初始值
- * @returns ShallowRef 对象
- *
- * @example
- * ```ts
- * const state = shallowRef({ count: 0 })
- * effect(() => console.log(state.value.count))  // 0
- * state.value.count++  // 不会触发 effect（浅层）
- * state.value = { count: 1 }  // 触发 effect（替换了 .value）
- * ```
- */
-export declare function shallowRef<T = any>(value: T): Ref<T>;
-/**
- * 判断一个值是否是 Ref
- *
- * @param value - 要检查的值
- * @returns 是否是 Ref
- */
-export declare function isRef(value: unknown): value is Ref;
-/**
- * 如果值是 Ref，返回 .value；否则返回值本身
- * 用于在模板或函数中自动解包 Ref
- *
- * @param value - Ref 或普通值
- * @returns 解包后的值
- *
- * @example
- * ```ts
- * const count = ref(5)
- * unref(count)  // 5
- * unref(10)     // 10
- * ```
- */
-export declare function unref<T>(value: T | Ref<T>): T;
-/**
- * 为响应式对象的某个属性创建一个 Ref
- * 创建的 Ref 与原始对象的属性保持双向同步
- *
- * @param object - 响应式对象
- * @param key - 属性名
- * @returns 与属性关联的 Ref
- *
- * @example
- * ```ts
- * const state = reactive({ count: 0 })
- * const countRef = toRef(state, 'count')
- * countRef.value++  // state.count 也变为 1
- * state.count++     // countRef.value 也变为 2
- * ```
- */
-export declare function toRef<T extends object, K extends keyof T>(object: T, key: K): Ref<T[K]>;
-/**
- * 将响应式对象的所有属性转换为 Ref
- * 返回一个与原始对象结构相同的普通对象，每个属性都是 Ref
- *
- * @param object - 响应式对象
- * @returns 属性全部为 Ref 的普通对象
- *
- * @example
- * ```ts
- * const state = reactive({ count: 0, name: 'lyt' })
- * const refs = toRefs(state)
- * refs.count.value++  // state.count 也变为 1
- * refs.name.value = 'new'  // state.name 也变为 'new'
- * ```
- */
-export declare function toRefs<T extends object>(object: T): {
-    [K in keyof T]: Ref<T[K]>;
-};
-/**
- * 触发 Ref 的更新（手动触发）
- * 主要用于 shallowRef 中修改对象内部属性后手动触发更新
- *
- * @param ref - 要触发的 Ref
- */
-export declare function triggerRef(ref: Ref): void;
-//# sourceMappingURL=ref.d.ts.map

package/dist/types/ref.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ref.d.ts","sourceRoot":"","sources":["../../src/ref.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAQH,oBAAoB;AACpB,eAAO,MAAM,SAAS,eAAgB,CAAC;AAEvC,2BAA2B;AAC3B,eAAO,MAAM,gBAAgB,eAAuB,CAAC;AAErD,aAAa;AACb,MAAM,WAAW,GAAG,CAAC,CAAC,GAAG,GAAG;IAC1B,WAAW;IACX,KAAK,EAAE,CAAC,CAAC;IACT,aAAa;IACb,CAAC,SAAS,CAAC,EAAE,IAAI,CAAC;CACnB;AAED,eAAe;AACf,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CAAC,SAAS,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAqB1D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,GAAG,CAAC,CAAC,GAAG,GAAG,EAAE,KAAK,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAkB7C;AAsED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CAAC,CAAC,GAAG,GAAG,EAAE,KAAK,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAkBpD;AAuDD;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,GAAG,CAElD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAE7C;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,CAAC,EACvD,MAAM,EAAE,CAAC,EACT,GAAG,EAAE,CAAC,GACL,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAyBX;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG;KAClD,CAAC,IAAI,MAAM,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAC1B,CAUA;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI,CAIzC"}

package/dist/types/scheduler.d.ts

@@ -1,44 +0,0 @@
-/**
- * Lyt.js 响应式系统 — 调度器（Scheduler）
- *
- * 基于 Promise 微任务实现异步批量更新队列。
- * 当响应式数据变化时，副作用函数不会立即执行，
- * 而是被推入队列，在下一个微任务中统一批量执行，
- * 避免同一个 tick 内重复执行相同的副作用。
- */
-/** 调度任务（副作用函数）类型 */
-export type SchedulerJob = (...args: any[]) => void;
-/**
- * 将一个 job 加入调度队列
- * - 使用 Set 自动去重，同一个 job 只会被执行一次
- * - 如果队列尚未安排刷新，则通过 Promise.resolve 安排微任务
- *
- * @param job - 要调度的副作用函数
- */
-export declare function queueJob(job: SchedulerJob): void;
-/**
- * 将回调加入 post-flush 队列
- * 这些回调会在主队列刷新完毕后执行
- *
- * @param cb - 要在队列刷新后执行的回调
- */
-export declare function queuePostFlushCb(cb: SchedulerJob): void;
-/**
- * 获取当前刷新 Promise
- * 可用于等待当前队列刷新完毕
- *
- * @returns 当前微任务的 Promise，如果没有则返回已 resolved 的 Promise
- */
-export declare function nextTick(): Promise<void>;
-/**
- * 查询队列中是否包含指定的 job
- *
- * @param job - 要查询的 job
- * @returns 是否在队列中
- */
-export declare function hasPendingJob(job: SchedulerJob): boolean;
-/**
- * 清空队列中的所有待执行 job（主要用于测试）
- */
-export declare function clearQueue(): void;
-//# sourceMappingURL=scheduler.d.ts.map

package/dist/types/scheduler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"scheduler.d.ts","sourceRoot":"","sources":["../../src/scheduler.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,oBAAoB;AACpB,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAC;AA2BpD;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,YAAY,GAAG,IAAI,CAgBhD;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,YAAY,GAAG,IAAI,CAWvD;AA4DD;;;;;GAKG;AACH,wBAAgB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAGxC;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAExD;AAED;;GAEG;AACH,wBAAgB,UAAU,IAAI,IAAI,CAQjC"}

package/dist/types/signal-component.d.ts

@@ -1,45 +0,0 @@
-/**
- * Lyt.js Signal 组件集成辅助模块
- *
- * 提供 Signal 与组件渲染函数之间的桥接工具。
- * 纯原生零依赖实现，无 DOM / 浏览器 API 依赖。
- */
-import { type Signal, type WritableSignal } from './signal';
-/**
- * 在组件渲染函数中追踪 Signal 依赖
- *
- * 读取 Signal 的值并自动建立依赖追踪。
- * 当 Signal 变化时，会触发关联的 effect 重新执行。
- *
- * @param sig 要追踪的 Signal
- * @returns Signal 的当前值
- */
-export declare function useSignal<T>(sig: Signal<T>): T;
-/**
- * 创建一个与组件生命周期绑定的 Signal 状态
- *
- * 返回一个元组 [signal, setter]：
- *   - signal: WritableSignal 实例
- *   - setter: 便捷的值设置函数
- *
- * 当组件卸载时，关联的 effect 会自动清理。
- *
- * @param initialValue 初始值
- * @returns [WritableSignal, setter] 元组
- */
-export declare function useSignalState<T>(initialValue: T): [WritableSignal<T>, (value: T) => void];
-/**
- * 进入组件 Signal 上下文
- *
- * 在组件渲染/挂载时调用，用于追踪组件级别的 Signal effect。
- *
- * @returns 退出上下文的函数
- */
-export declare function enterSignalComponentContext(): () => void;
-/**
- * 在当前组件上下文中注册清理函数
- *
- * @param cleanup 清理函数
- */
-export declare function onSignalCleanup(cleanup: () => void): void;
-//# sourceMappingURL=signal-component.d.ts.map

package/dist/types/signal-component.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"signal-component.d.ts","sourceRoot":"","sources":["../../src/signal-component.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAkB,KAAK,MAAM,EAAE,KAAK,cAAc,EAAE,MAAM,UAAU,CAAA;AA4B3E;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,CAG9C;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAC9B,YAAY,EAAE,CAAC,GACd,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC,CAYzC;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,IAAI,MAAM,IAAI,CAmBxD;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,IAAI,GAAG,IAAI,CAKzD"}