@bquery/bquery 1.4.0 → 1.5.0

package/src/reactive/core.ts

@@ -1,114 +1,114 @@
-/**
- * Core reactive signals.
- */
-
-import {
-  getCurrentObserver,
-  registerDependency,
-  removeDependency,
-  scheduleObserver,
-  type ReactiveSource,
-} from './internals';
-
-/**
- * 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
- */
-export class Signal<T> implements ReactiveSource {
-  private subscribers = new Set<() => void>();
-
-  /**
-   * Creates a new signal with an initial value.
-   * @param _value - The initial value
-   */
-  constructor(private _value: T) {}
-
-  /**
-   * Gets the current value and tracks the read if inside an observer.
-   * During untrack calls, getCurrentObserver returns undefined, preventing dependency tracking.
-   */
-  get value(): T {
-    const current = getCurrentObserver();
-    if (current) {
-      this.subscribers.add(current);
-      registerDependency(current, this);
-    }
-    return this._value;
-  }
-
-  /**
-   * Sets a new value and notifies all subscribers if the value changed.
-   * Uses Object.is for equality comparison.
-   */
-  set value(next: T) {
-    if (Object.is(this._value, next)) return;
-    this._value = next;
-    // Create snapshot to avoid issues with subscribers modifying the set during iteration
-    const subscribersSnapshot = Array.from(this.subscribers);
-    for (const subscriber of subscribersSnapshot) {
-      scheduleObserver(subscriber);
-    }
-  }
-
-  /**
-   * 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 {
-    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(updater: (current: T) => T): void {
-    this.value = updater(this._value);
-  }
-
-  /**
-   * Removes all subscribers from this signal.
-   * Use this when a signal is no longer needed to prevent memory leaks.
-   *
-   * @example
-   * ```ts
-   * const count = signal(0);
-   * effect(() => console.log(count.value));
-   * count.dispose(); // All subscribers removed
-   * ```
-   */
-  dispose(): void {
-    // Remove this signal from each subscriber's dependency set
-    // so the observer no longer holds a strong reference to it
-    for (const subscriber of this.subscribers) {
-      removeDependency(subscriber, this);
-    }
-    this.subscribers.clear();
-  }
-
-  /**
-   * Removes an observer from this signal's subscriber set.
-   * @internal
-   */
-  unsubscribe(observer: () => void): void {
-    this.subscribers.delete(observer);
-  }
-}
-
-/**
- * Creates a new reactive signal.
- *
- * @template T - The type of the signal value
- * @param value - The initial value
- * @returns A new Signal instance
- */
-export const signal = <T>(value: T): Signal<T> => new Signal(value);
+/**
+ * Core reactive signals.
+ */
+
+import {
+  getCurrentObserver,
+  registerDependency,
+  removeDependency,
+  scheduleObserver,
+  type ReactiveSource,
+} from './internals';
+
+/**
+ * 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
+ */
+export class Signal<T> implements ReactiveSource {
+  private subscribers = new Set<() => void>();
+
+  /**
+   * Creates a new signal with an initial value.
+   * @param _value - The initial value
+   */
+  constructor(private _value: T) {}
+
+  /**
+   * Gets the current value and tracks the read if inside an observer.
+   * During untrack calls, getCurrentObserver returns undefined, preventing dependency tracking.
+   */
+  get value(): T {
+    const current = getCurrentObserver();
+    if (current) {
+      this.subscribers.add(current);
+      registerDependency(current, this);
+    }
+    return this._value;
+  }
+
+  /**
+   * Sets a new value and notifies all subscribers if the value changed.
+   * Uses Object.is for equality comparison.
+   */
+  set value(next: T) {
+    if (Object.is(this._value, next)) return;
+    this._value = next;
+    // Create snapshot to avoid issues with subscribers modifying the set during iteration
+    const subscribersSnapshot = Array.from(this.subscribers);
+    for (const subscriber of subscribersSnapshot) {
+      scheduleObserver(subscriber);
+    }
+  }
+
+  /**
+   * 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 {
+    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(updater: (current: T) => T): void {
+    this.value = updater(this._value);
+  }
+
+  /**
+   * Removes all subscribers from this signal.
+   * Use this when a signal is no longer needed to prevent memory leaks.
+   *
+   * @example
+   * ```ts
+   * const count = signal(0);
+   * effect(() => console.log(count.value));
+   * count.dispose(); // All subscribers removed
+   * ```
+   */
+  dispose(): void {
+    // Remove this signal from each subscriber's dependency set
+    // so the observer no longer holds a strong reference to it
+    for (const subscriber of this.subscribers) {
+      removeDependency(subscriber, this);
+    }
+    this.subscribers.clear();
+  }
+
+  /**
+   * Removes an observer from this signal's subscriber set.
+   * @internal
+   */
+  unsubscribe(observer: () => void): void {
+    this.subscribers.delete(observer);
+  }
+}
+
+/**
+ * Creates a new reactive signal.
+ *
+ * @template T - The type of the signal value
+ * @param value - The initial value
+ * @returns A new Signal instance
+ */
+export const signal = <T>(value: T): Signal<T> => new Signal(value);

package/src/reactive/effect.ts

@@ -1,54 +1,54 @@
-/**
- * Reactive effects.
- */
-
-import { CleanupFn, Observer, track, clearDependencies } from './internals';
-
-/**
- * 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
- */
-export const effect = (fn: () => void | CleanupFn): CleanupFn => {
-  let cleanupFn: CleanupFn | void;
-  let isDisposed = false;
-
-  const runCleanup = (): void => {
-    if (cleanupFn) {
-      try {
-        cleanupFn();
-      } catch (error) {
-        console.error('bQuery reactive: Error in effect cleanup', error);
-      }
-      cleanupFn = undefined;
-    }
-  };
-
-  const observer: Observer = () => {
-    if (isDisposed) return;
-
-    runCleanup();
-
-    // Clear old dependencies before running to avoid stale subscriptions
-    clearDependencies(observer);
-
-    try {
-      cleanupFn = track(observer, fn);
-    } catch (error) {
-      console.error('bQuery reactive: Error in effect', error);
-    }
-  };
-
-  observer();
-
-  return () => {
-    isDisposed = true;
-    runCleanup();
-    // Clean up all dependencies when effect is disposed
-    clearDependencies(observer);
-  };
-};
+/**
+ * Reactive effects.
+ */
+
+import { CleanupFn, Observer, track, clearDependencies } from './internals';
+
+/**
+ * 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
+ */
+export const effect = (fn: () => void | CleanupFn): CleanupFn => {
+  let cleanupFn: CleanupFn | void;
+  let isDisposed = false;
+
+  const runCleanup = (): void => {
+    if (cleanupFn) {
+      try {
+        cleanupFn();
+      } catch (error) {
+        console.error('bQuery reactive: Error in effect cleanup', error);
+      }
+      cleanupFn = undefined;
+    }
+  };
+
+  const observer: Observer = () => {
+    if (isDisposed) return;
+
+    runCleanup();
+
+    // Clear old dependencies before running to avoid stale subscriptions
+    clearDependencies(observer);
+
+    try {
+      cleanupFn = track(observer, fn);
+    } catch (error) {
+      console.error('bQuery reactive: Error in effect', error);
+    }
+  };
+
+  observer();
+
+  return () => {
+    isDisposed = true;
+    runCleanup();
+    // Clean up all dependencies when effect is disposed
+    clearDependencies(observer);
+  };
+};

package/src/reactive/index.ts

@@ -1,23 +1,37 @@
-/**
- * Reactive module providing fine-grained reactivity primitives.
- *
- * @module bquery/reactive
- */
-
-export {
-  Computed,
-  Signal,
-  batch,
-  computed,
-  effect,
-  isComputed,
-  isSignal,
-  linkedSignal,
-  persistedSignal,
-  readonly,
-  signal,
-  untrack,
-  watch,
-} from './signal';
-
-export type { CleanupFn, LinkedSignal, Observer, ReadonlySignal } from './signal';
+/**
+ * Reactive module providing fine-grained reactivity primitives.
+ *
+ * @module bquery/reactive
+ */
+
+export {
+  Computed,
+  Signal,
+  batch,
+  computed,
+  createUseFetch,
+  effect,
+  isComputed,
+  isSignal,
+  linkedSignal,
+  persistedSignal,
+  readonly,
+  signal,
+  useAsyncData,
+  useFetch,
+  untrack,
+  watch,
+} from './signal';
+
+export type {
+  AsyncDataState,
+  AsyncDataStatus,
+  AsyncWatchSource,
+  CleanupFn,
+  FetchInput,
+  LinkedSignal,
+  Observer,
+  ReadonlySignal,
+  UseAsyncDataOptions,
+  UseFetchOptions,
+} from './signal';

package/src/reactive/internals.ts

@@ -1,122 +1,122 @@
-/**
- * Internal reactive plumbing shared across primitives.
- * @internal
- */
-
-export type Observer = () => void;
-export type CleanupFn = () => void;
-
-/**
- * Interface for reactive sources (Signals, Computed) that can unsubscribe observers.
- * @internal
- */
-export interface ReactiveSource {
-  unsubscribe(observer: Observer): void;
-}
-
-const observerStack: Observer[] = [];
-let batchDepth = 0;
-const pendingObservers = new Set<Observer>();
-
-// Track dependencies for each observer to enable cleanup
-const observerDependencies = new WeakMap<Observer, Set<ReactiveSource>>();
-
-export const track = <T>(observer: Observer, fn: () => T): T => {
-  observerStack.push(observer);
-  try {
-    return fn();
-  } finally {
-    observerStack.pop();
-  }
-};
-
-export const getCurrentObserver = (): Observer | undefined =>
-  observerStack[observerStack.length - 1];
-
-/**
- * Executes a function without exposing the current observer to dependencies.
- * Unlike disabling tracking globally, this still allows nested reactive internals
- * (e.g., computed recomputation) to track their own dependencies.
- * @internal
- */
-export const withoutCurrentObserver = <T>(fn: () => T): T => {
-  // Push undefined to temporarily "hide" the current observer
-  // This way, Signal.value reads won't link to the previous observer,
-  // but nested track() calls (e.g., computed recompute) still work normally.
-  observerStack.push(undefined as unknown as Observer);
-  try {
-    return fn();
-  } finally {
-    observerStack.pop();
-  }
-};
-
-export const scheduleObserver = (observer: Observer): void => {
-  if (batchDepth > 0) {
-    pendingObservers.add(observer);
-    return;
-  }
-  observer();
-};
-
-const flushObservers = (): void => {
-  for (const observer of Array.from(pendingObservers)) {
-    pendingObservers.delete(observer);
-    try {
-      observer();
-    } catch (error) {
-      console.error('bQuery reactive: Error in observer during batch flush', error);
-    }
-  }
-};
-
-export const beginBatch = (): void => {
-  batchDepth += 1;
-};
-
-export const endBatch = (): void => {
-  if (batchDepth <= 0) return;
-  batchDepth -= 1;
-  if (batchDepth === 0) {
-    flushObservers();
-  }
-};
-
-/**
- * Registers a dependency between an observer and a reactive source.
- * @internal
- */
-export const registerDependency = (observer: Observer, source: ReactiveSource): void => {
-  let deps = observerDependencies.get(observer);
-  if (!deps) {
-    deps = new Set();
-    observerDependencies.set(observer, deps);
-  }
-  deps.add(source);
-};
-
-/**
- * Removes a specific source from an observer's dependency set.
- * Used when a source (e.g. Signal) is disposed to prevent stale references.
- * @internal
- */
-export const removeDependency = (observer: Observer, source: ReactiveSource): void => {
-  const deps = observerDependencies.get(observer);
-  if (deps) {
-    deps.delete(source);
-  }
-};
-
-/**
- * Clears all dependencies for an observer, unsubscribing from all sources.
- * @internal
- */
-export const clearDependencies = (observer: Observer): void => {
-  const deps = observerDependencies.get(observer);
-  if (deps) {
-    for (const source of deps) {
-      source.unsubscribe(observer);
-    }
-    deps.clear();
-  }
-};
+/**
+ * Internal reactive plumbing shared across primitives.
+ * @internal
+ */
+
+export type Observer = () => void;
+export type CleanupFn = () => void;
+
+/**
+ * Interface for reactive sources (Signals, Computed) that can unsubscribe observers.
+ * @internal
+ */
+export interface ReactiveSource {
+  unsubscribe(observer: Observer): void;
+}
+
+const observerStack: Observer[] = [];
+let batchDepth = 0;
+const pendingObservers = new Set<Observer>();
+
+// Track dependencies for each observer to enable cleanup
+const observerDependencies = new WeakMap<Observer, Set<ReactiveSource>>();
+
+export const track = <T>(observer: Observer, fn: () => T): T => {
+  observerStack.push(observer);
+  try {
+    return fn();
+  } finally {
+    observerStack.pop();
+  }
+};
+
+export const getCurrentObserver = (): Observer | undefined =>
+  observerStack[observerStack.length - 1];
+
+/**
+ * Executes a function without exposing the current observer to dependencies.
+ * Unlike disabling tracking globally, this still allows nested reactive internals
+ * (e.g., computed recomputation) to track their own dependencies.
+ * @internal
+ */
+export const withoutCurrentObserver = <T>(fn: () => T): T => {
+  // Push undefined to temporarily "hide" the current observer
+  // This way, Signal.value reads won't link to the previous observer,
+  // but nested track() calls (e.g., computed recompute) still work normally.
+  observerStack.push(undefined as unknown as Observer);
+  try {
+    return fn();
+  } finally {
+    observerStack.pop();
+  }
+};
+
+export const scheduleObserver = (observer: Observer): void => {
+  if (batchDepth > 0) {
+    pendingObservers.add(observer);
+    return;
+  }
+  observer();
+};
+
+const flushObservers = (): void => {
+  for (const observer of Array.from(pendingObservers)) {
+    pendingObservers.delete(observer);
+    try {
+      observer();
+    } catch (error) {
+      console.error('bQuery reactive: Error in observer during batch flush', error);
+    }
+  }
+};
+
+export const beginBatch = (): void => {
+  batchDepth += 1;
+};
+
+export const endBatch = (): void => {
+  if (batchDepth <= 0) return;
+  batchDepth -= 1;
+  if (batchDepth === 0) {
+    flushObservers();
+  }
+};
+
+/**
+ * Registers a dependency between an observer and a reactive source.
+ * @internal
+ */
+export const registerDependency = (observer: Observer, source: ReactiveSource): void => {
+  let deps = observerDependencies.get(observer);
+  if (!deps) {
+    deps = new Set();
+    observerDependencies.set(observer, deps);
+  }
+  deps.add(source);
+};
+
+/**
+ * Removes a specific source from an observer's dependency set.
+ * Used when a source (e.g. Signal) is disposed to prevent stale references.
+ * @internal
+ */
+export const removeDependency = (observer: Observer, source: ReactiveSource): void => {
+  const deps = observerDependencies.get(observer);
+  if (deps) {
+    deps.delete(source);
+  }
+};
+
+/**
+ * Clears all dependencies for an observer, unsubscribing from all sources.
+ * @internal
+ */
+export const clearDependencies = (observer: Observer): void => {
+  const deps = observerDependencies.get(observer);
+  if (deps) {
+    for (const source of deps) {
+      source.unsubscribe(observer);
+    }
+    deps.clear();
+  }
+};