@bquery/bquery 1.2.0 → 1.4.0

package/dist/reactive/signal.d.ts

@@ -1,318 +1,19 @@
 /**
  * Reactive primitives inspired by fine-grained reactivity.
  *
- * This module provides a minimal but powerful reactive system:
- * - Signal: A reactive value that notifies subscribers when changed
- * - Computed: A derived value that automatically updates when dependencies change
- * - Effect: A side effect that re-runs when its dependencies change
- * - Batch: Group multiple updates to prevent intermediate re-renders
- *
  * @module bquery/reactive
- *
- * @example
- * ```ts
- * const count = signal(0);
- * const doubled = computed(() => count.value * 2);
- *
- * effect(() => {
- *   console.log(`Count: ${count.value}, Doubled: ${doubled.value}`);
- * });
- *
- * batch(() => {
- *   count.value = 1;
- *   count.value = 2;
- * });
- * // Logs: "Count: 2, Doubled: 4" (only once due to batching)
- * ```
- */
-/**
- * Observer function type used internally for tracking reactivity.
- */
-export type Observer = () => void;
-/**
- * Cleanup function returned by effects for disposal.
- */
-export type CleanupFn = () => void;
-/**
- * A reactive value container that notifies subscribers on change.
- *
- * Signals are the foundational primitive of the reactive system.
- * Reading a signal's value inside an effect or computed automatically
- * establishes a reactive dependency.
- *
- * @template T - The type of the stored value
- *
- * @example
- * ```ts
- * const name = signal('World');
- * console.log(name.value); // 'World'
- *
- * name.value = 'bQuery';
- * console.log(name.value); // 'bQuery'
- * ```
- */
-export declare class Signal<T> {
-    private _value;
-    private subscribers;
-    /**
-     * Creates a new signal with an initial value.
-     * @param _value - The initial value
-     */
-    constructor(_value: T);
-    /**
-     * Gets the current value and tracks the read if inside an observer.
-     * Respects the global tracking state (disabled during untrack calls).
-     */
-    get value(): T;
-    /**
-     * Sets a new value and notifies all subscribers if the value changed.
-     * Uses Object.is for equality comparison.
-     */
-    set value(next: T);
-    /**
-     * Reads the current value without tracking.
-     * Useful when you need the value but don't want to create a dependency.
-     *
-     * @returns The current value
-     */
-    peek(): T;
-    /**
-     * Updates the value using a function.
-     * Useful for updates based on the current value.
-     *
-     * @param updater - Function that receives current value and returns new value
-     */
-    update(updater: (current: T) => T): void;
-}
-/**
- * A computed value that derives from other reactive sources.
- *
- * Computed values are lazily evaluated and cached. They only
- * recompute when their dependencies change.
- *
- * @template T - The type of the computed value
- *
- * @example
- * ```ts
- * const price = signal(100);
- * const quantity = signal(2);
- * const total = computed(() => price.value * quantity.value);
- *
- * console.log(total.value); // 200
- * price.value = 150;
- * console.log(total.value); // 300
- * ```
- */
-export declare class Computed<T> {
-    private readonly compute;
-    private cachedValue;
-    private dirty;
-    private subscribers;
-    private readonly markDirty;
-    /**
-     * Creates a new computed value.
-     * @param compute - Function that computes the value
-     */
-    constructor(compute: () => T);
-    /**
-     * Gets the computed value, recomputing if dependencies changed.
-     */
-    get value(): T;
-    /**
-     * Reads the current computed value without tracking.
-     * Useful when you need the value but don't want to create a dependency.
-     *
-     * @returns The current cached value (recomputes if dirty)
-     */
-    peek(): T;
-}
-/**
- * Creates a new reactive signal.
- *
- * @template T - The type of the signal value
- * @param value - The initial value
- * @returns A new Signal instance
- *
- * @example
- * ```ts
- * const count = signal(0);
- * count.value++; // Triggers subscribers
- * ```
- */
-export declare const signal: <T>(value: T) => Signal<T>;
-/**
- * Creates a new computed value.
- *
- * @template T - The type of the computed value
- * @param fn - Function that computes the value from reactive sources
- * @returns A new Computed instance
- *
- * @example
- * ```ts
- * const doubled = computed(() => count.value * 2);
- * ```
- */
-export declare const computed: <T>(fn: () => T) => Computed<T>;
-/**
- * Creates a side effect that automatically re-runs when dependencies change.
- *
- * The effect runs immediately upon creation and then re-runs whenever
- * any signal or computed value read inside it changes.
- *
- * @param fn - The effect function to run
- * @returns A cleanup function to stop the effect
- *
- * @example
- * ```ts
- * const count = signal(0);
- *
- * const cleanup = effect(() => {
- *   document.title = `Count: ${count.value}`;
- * });
- *
- * // Later, to stop the effect:
- * cleanup();
- * ```
- */
-export declare const effect: (fn: () => void | CleanupFn) => CleanupFn;
-/**
- * Batches multiple signal updates into a single notification cycle.
- *
- * Updates made inside the batch function are deferred until the batch
- * completes, preventing intermediate re-renders and improving performance.
- *
- * @param fn - Function containing multiple signal updates
- *
- * @example
- * ```ts
- * batch(() => {
- *   firstName.value = 'John';
- *   lastName.value = 'Doe';
- *   age.value = 30;
- * });
- * // Effects only run once with all three updates
- * ```
- */
-export declare const batch: (fn: () => void) => void;
-/**
- * Creates a signal that persists to localStorage.
- *
- * @template T - The type of the signal value
- * @param key - The localStorage key
- * @param initialValue - The initial value if not found in storage
- * @returns A Signal that syncs with localStorage
- *
- * @example
- * ```ts
- * const theme = persistedSignal('theme', 'light');
- * theme.value = 'dark'; // Automatically saved to localStorage
- * ```
- */
-export declare const persistedSignal: <T>(key: string, initialValue: T) => Signal<T>;
-/**
- * A readonly wrapper around a signal that prevents writes.
- * Provides read-only access to a signal's value while maintaining reactivity.
- *
- * @template T - The type of the wrapped value
- */
-export interface ReadonlySignal<T> {
-    /** Gets the current value with dependency tracking. */
-    readonly value: T;
-    /** Gets the current value without dependency tracking. */
-    peek(): T;
-}
-/**
- * Creates a read-only view of a signal.
- * Useful for exposing reactive state without allowing modifications.
- *
- * @template T - The type of the signal value
- * @param sig - The signal to wrap
- * @returns A readonly signal wrapper
- *
- * @example
- * ```ts
- * const _count = signal(0);
- * const count = readonly(_count); // Expose read-only version
- *
- * console.log(count.value); // 0
- * count.value = 1; // TypeScript error: Cannot assign to 'value'
- * ```
- */
-export declare const readonly: <T>(sig: Signal<T>) => ReadonlySignal<T>;
-/**
- * Watches a signal or computed value and calls a callback with old and new values.
- * Unlike effect, watch provides access to the previous value.
- *
- * @template T - The type of the watched value
- * @param source - The signal or computed to watch
- * @param callback - Function called with (newValue, oldValue) on changes
- * @param options - Watch options
- * @returns A cleanup function to stop watching
- *
- * @example
- * ```ts
- * const count = signal(0);
- *
- * const cleanup = watch(count, (newVal, oldVal) => {
- *   console.log(`Changed from ${oldVal} to ${newVal}`);
- * });
- *
- * count.value = 5; // Logs: "Changed from 0 to 5"
- * cleanup();
- * ```
- */
-export declare const watch: <T>(source: Signal<T> | Computed<T>, callback: (newValue: T, oldValue: T | undefined) => void, options?: {
-    immediate?: boolean;
-}) => CleanupFn;
-/**
- * Executes a function without tracking any signal dependencies.
- * Useful when reading a signal value without creating a reactive dependency.
- *
- * @template T - The return type of the function
- * @param fn - The function to execute without tracking
- * @returns The result of the function
- *
- * @example
- * ```ts
- * const count = signal(0);
- *
- * effect(() => {
- *   // This creates a dependency
- *   console.log('Tracked:', count.value);
- *
- *   // This does NOT create a dependency
- *   const untracked = untrack(() => otherSignal.value);
- * });
- * ```
- */
-export declare const untrack: <T>(fn: () => T) => T;
-/**
- * Type guard to check if a value is a Signal instance.
- *
- * @param value - The value to check
- * @returns True if the value is a Signal
- *
- * @example
- * ```ts
- * const count = signal(0);
- * const num = 42;
- *
- * isSignal(count); // true
- * isSignal(num);   // false
- * ```
- */
-export declare const isSignal: (value: unknown) => value is Signal<unknown>;
-/**
- * Type guard to check if a value is a Computed instance.
- *
- * @param value - The value to check
- * @returns True if the value is a Computed
- *
- * @example
- * ```ts
- * const doubled = computed(() => count.value * 2);
- * isComputed(doubled); // true
- * ```
  */
-export declare const isComputed: (value: unknown) => value is Computed<unknown>;
+export { batch } from './batch';
+export { Computed, computed } from './computed';
+export { Signal, signal } from './core';
+export { effect } from './effect';
+export { linkedSignal } from './linked';
+export { persistedSignal } from './persisted';
+export { readonly } from './readonly';
+export { isComputed, isSignal } from './type-guards';
+export { untrack } from './untrack';
+export { watch } from './watch';
+export type { CleanupFn, Observer } from './internals';
+export type { LinkedSignal } from './linked';
+export type { ReadonlySignal } from './readonly';
 //# sourceMappingURL=signal.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"signal.d.ts","sourceRoot":"","sources":["../../src/reactive/signal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC;AAElC;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC;AA+CnC;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,MAAM,CAAC,CAAC;IAOP,OAAO,CAAC,MAAM;IAN1B,OAAO,CAAC,WAAW,CAAuB;IAE1C;;;OAGG;gBACiB,MAAM,EAAE,CAAC;IAE7B;;;OAGG;IACH,IAAI,KAAK,IAAI,CAAC,CAQb;IAED;;;OAGG;IACH,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC,EAMhB;IAED;;;;;OAKG;IACH,IAAI,IAAI,CAAC;IAIT;;;;;OAKG;IACH,MAAM,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,GAAG,IAAI;CAGzC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,QAAQ,CAAC,CAAC;IAeT,OAAO,CAAC,QAAQ,CAAC,OAAO;IAdpC,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,WAAW,CAAuB;IAC1C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAKxB;IAEF;;;OAGG;gBAC0B,OAAO,EAAE,MAAM,CAAC;IAE7C;;OAEG;IACH,IAAI,KAAK,IAAI,CAAC,CAUb;IAED;;;;;OAKG;IACH,IAAI,IAAI,CAAC;CAOV;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,MAAM,GAAI,CAAC,EAAE,OAAO,CAAC,KAAG,MAAM,CAAC,CAAC,CAAsB,CAAC;AAEpE;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,EAAE,IAAI,MAAM,CAAC,KAAG,QAAQ,CAAC,CAAC,CAAqB,CAAC;AAE1E;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,MAAM,GAAI,IAAI,MAAM,IAAI,GAAG,SAAS,KAAG,SAwBnD,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,KAAK,GAAI,IAAI,MAAM,IAAI,KAAG,IAUtC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,EAAE,KAAK,MAAM,EAAE,cAAc,CAAC,KAAG,MAAM,CAAC,CAAC,CAwBzE,CAAC;AAMF;;;;;GAKG;AACH,MAAM,WAAW,cAAc,CAAC,CAAC;IAC/B,uDAAuD;IACvD,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;IAClB,0DAA0D;IAC1D,IAAI,IAAI,CAAC,CAAC;CACX;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,EAAE,KAAK,MAAM,CAAC,CAAC,CAAC,KAAG,cAAc,CAAC,CAAC,CAO3D,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,EACrB,QAAQ,MAAM,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,EAC/B,UAAU,CAAC,QAAQ,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,SAAS,KAAK,IAAI,EACxD,UAAS;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAO,KACpC,SAmBF,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,EAAE,IAAI,MAAM,CAAC,KAAG,CAQxC,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,QAAQ,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,MAAM,CAAC,OAAO,CAA4B,CAAC;AAE9F;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,QAAQ,CAAC,OAAO,CAA8B,CAAC"}
+{"version":3,"file":"signal.d.ts","sourceRoot":"","sources":["../../src/reactive/signal.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AACxC,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,YAAY,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvD,YAAY,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAC7C,YAAY,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC"}

package/dist/reactive/type-guards.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Type guards for reactive primitives.
+ */
+import { Computed } from './computed';
+import { Signal } from './core';
+/**
+ * Type guard to check if a value is a Signal instance.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a Signal
+ */
+export declare const isSignal: (value: unknown) => value is Signal<unknown>;
+/**
+ * Type guard to check if a value is a Computed instance.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a Computed
+ */
+export declare const isComputed: (value: unknown) => value is Computed<unknown>;
+//# sourceMappingURL=type-guards.d.ts.map

package/dist/reactive/type-guards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-guards.d.ts","sourceRoot":"","sources":["../../src/reactive/type-guards.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,MAAM,CAAC,OAAO,CAA4B,CAAC;AAE9F;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,QAAQ,CAAC,OAAO,CAA8B,CAAC"}

package/dist/reactive/untrack.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Dependency tracking control helpers.
+ */
+/**
+ * Executes a function without tracking any signal dependencies.
+ * Useful when reading a signal value without creating a reactive dependency.
+ *
+ * This implementation temporarily hides the current observer rather than
+ * disabling tracking globally. This ensures that nested reactive internals
+ * (e.g., computed recomputation triggered during untrack) can still properly
+ * track their own dependencies.
+ *
+ * @template T - The return type of the function
+ * @param fn - The function to execute without tracking
+ * @returns The result of the function
+ *
+ * @example
+ * ```ts
+ * const count = signal(0);
+ * effect(() => {
+ *   // This read creates a dependency
+ *   console.log(count.value);
+ *   // This read does not create a dependency
+ *   const snapshot = untrack(() => count.value);
+ * });
+ * ```
+ */
+export declare const untrack: <T>(fn: () => T) => T;
+//# sourceMappingURL=untrack.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"untrack.d.ts","sourceRoot":"","sources":["../../src/reactive/untrack.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,EAAE,IAAI,MAAM,CAAC,KAAG,CAA+B,CAAC"}

package/dist/reactive/watch.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Value watching helpers.
+ */
+import type { Computed } from './computed';
+import type { Signal } from './core';
+import type { CleanupFn } from './internals';
+/**
+ * Options for the watch function.
+ */
+export interface WatchOptions<T> {
+    /** If true, the callback is invoked immediately with the current value. */
+    immediate?: boolean;
+    /** Custom equality function. Defaults to Object.is. */
+    equals?: (a: T, b: T | undefined) => boolean;
+}
+/**
+ * Watches a signal or computed value and calls a callback with old and new values.
+ * Unlike effect, watch provides access to the previous value.
+ * The callback is only invoked when the value actually changes (compared via Object.is or custom equals).
+ *
+ * @template T - The type of the watched value
+ * @param source - The signal or computed to watch
+ * @param callback - Function called with (newValue, oldValue) on changes
+ * @param options - Watch options
+ * @returns A cleanup function to stop watching
+ *
+ * @example
+ * ```ts
+ * const count = signal(0);
+ * watch(count, (newVal, oldVal) => {
+ *   console.log(`Changed from ${oldVal} to ${newVal}`);
+ * });
+ *
+ * // With custom equality for objects
+ * const user = signal({ id: 1, name: 'Alice' });
+ * watch(user, (newVal, oldVal) => { ... }, {
+ *   equals: (a, b) => a?.id === b?.id
+ * });
+ * ```
+ */
+export declare const watch: <T>(source: Signal<T> | Computed<T>, callback: (newValue: T, oldValue: T | undefined) => void, options?: WatchOptions<T>) => CleanupFn;
+//# sourceMappingURL=watch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["../../src/reactive/watch.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AACrC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAI7C;;GAEG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,2EAA2E;IAC3E,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,uDAAuD;IACvD,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,SAAS,KAAK,OAAO,CAAC;CAC9C;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,EACrB,QAAQ,MAAM,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,EAC/B,UAAU,CAAC,QAAQ,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,SAAS,KAAK,IAAI,EACxD,UAAS,YAAY,CAAC,CAAC,CAAM,KAC5B,SAuBF,CAAC"}

package/dist/reactive.es.mjs

@@ -1,169 +1,36 @@
-const i = [];
-let a = 0;
-const l = /* @__PURE__ */ new Set();
-let u = !0;
-const o = (t, e) => {
-  i.push(t);
-  try {
-    return e();
-  } finally {
-    i.pop();
-  }
-}, h = (t) => {
-  if (a > 0) {
-    l.add(t);
-    return;
-  }
-  t();
-}, p = () => {
-  for (const t of Array.from(l))
-    l.delete(t), t();
-};
-class f {
-  /**
-   * Creates a new signal with an initial value.
-   * @param _value - The initial value
-   */
-  constructor(e) {
-    this._value = e, this.subscribers = /* @__PURE__ */ new Set();
-  }
-  /**
-   * Gets the current value and tracks the read if inside an observer.
-   * Respects the global tracking state (disabled during untrack calls).
-   */
-  get value() {
-    if (u) {
-      const e = i[i.length - 1];
-      e && this.subscribers.add(e);
-    }
-    return this._value;
-  }
-  /**
-   * Sets a new value and notifies all subscribers if the value changed.
-   * Uses Object.is for equality comparison.
-   */
-  set value(e) {
-    if (!Object.is(this._value, e)) {
-      this._value = e;
-      for (const s of this.subscribers)
-        h(s);
+import { c as s } from "./core-BhpuvPhy.js";
+import { C as u, S as l, s as m } from "./core-BhpuvPhy.js";
+import { b as d } from "./batch-x7b2eZST.js";
+import { e as g, i as x, a as S } from "./type-guards-BdKlYYlS.js";
+import { p as v, r as C, w as b } from "./watch-DXXv3iAI.js";
+import { u as w } from "./untrack-DNnnqdlR.js";
+const p = (a, r) => {
+  const e = s(a);
+  return {
+    get value() {
+      return e.value;
+    },
+    set value(t) {
+      r(t);
+    },
+    peek() {
+      return e.peek();
     }
-  }
-  /**
-   * Reads the current value without tracking.
-   * Useful when you need the value but don't want to create a dependency.
-   *
-   * @returns The current value
-   */
-  peek() {
-    return this._value;
-  }
-  /**
-   * Updates the value using a function.
-   * Useful for updates based on the current value.
-   *
-   * @param updater - Function that receives current value and returns new value
-   */
-  update(e) {
-    this.value = e(this._value);
-  }
-}
-class d {
-  /**
-   * Creates a new computed value.
-   * @param compute - Function that computes the value
-   */
-  constructor(e) {
-    this.compute = e, this.dirty = !0, this.subscribers = /* @__PURE__ */ new Set(), this.markDirty = () => {
-      this.dirty = !0;
-      for (const s of this.subscribers)
-        h(s);
-    };
-  }
-  /**
-   * Gets the computed value, recomputing if dependencies changed.
-   */
-  get value() {
-    const e = i[i.length - 1];
-    return e && this.subscribers.add(e), this.dirty && (this.dirty = !1, this.cachedValue = o(this.markDirty, this.compute)), this.cachedValue;
-  }
-  /**
-   * Reads the current computed value without tracking.
-   * Useful when you need the value but don't want to create a dependency.
-   *
-   * @returns The current cached value (recomputes if dirty)
-   */
-  peek() {
-    return this.dirty && (this.dirty = !1, this.cachedValue = o(this.markDirty, this.compute)), this.cachedValue;
-  }
-}
-const v = (t) => new f(t), y = (t) => new d(t), b = (t) => {
-  let e, s = !1;
-  const r = () => {
-    s || (e && e(), e = o(r, t));
-  };
-  return r(), () => {
-    s = !0, e && e();
   };
-}, g = (t) => {
-  a += 1;
-  try {
-    t();
-  } finally {
-    a -= 1, a === 0 && p();
-  }
-}, m = (t, e) => {
-  let s = e;
-  try {
-    const n = localStorage.getItem(t);
-    n !== null && (s = JSON.parse(n));
-  } catch {
-  }
-  const r = v(s);
-  return b(() => {
-    try {
-      localStorage.setItem(t, JSON.stringify(r.value));
-    } catch {
-    }
-  }), r;
-}, S = (t) => ({
-  get value() {
-    return t.value;
-  },
-  peek() {
-    return t.peek();
-  }
-}), k = (t, e, s = {}) => {
-  let r, n = !0;
-  return b(() => {
-    const c = t.value;
-    if (n) {
-      n = !1, r = c, s.immediate && e(c, void 0);
-      return;
-    }
-    e(c, r), r = c;
-  });
-}, w = (t) => {
-  const e = u;
-  u = !1;
-  try {
-    return t();
-  } finally {
-    u = e;
-  }
-}, O = (t) => t instanceof f, V = (t) => t instanceof d;
+};
 export {
-  d as Computed,
-  f as Signal,
-  g as batch,
-  y as computed,
-  b as effect,
-  V as isComputed,
-  O as isSignal,
-  m as persistedSignal,
-  S as readonly,
-  v as signal,
+  u as Computed,
+  l as Signal,
+  d as batch,
+  s as computed,
+  g as effect,
+  x as isComputed,
+  S as isSignal,
+  p as linkedSignal,
+  v as persistedSignal,
+  C as readonly,
+  m as signal,
   w as untrack,
-  k as watch
+  b as watch
 };
 //# sourceMappingURL=reactive.es.mjs.map