@bquery/bquery 1.3.0 → 1.4.0

package/src/reactive/effect.ts

@@ -1,43 +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 observer: Observer = () => {
-    if (isDisposed) return;
-
-    if (cleanupFn) {
-      cleanupFn();
-    }
-
-    // Clear old dependencies before running to avoid stale subscriptions
-    clearDependencies(observer);
-
-    cleanupFn = track(observer, fn);
-  };
-
-  observer();
-
-  return () => {
-    isDisposed = true;
-    if (cleanupFn) {
-      cleanupFn();
-    }
-    // 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/internals.ts

@@ -1,105 +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);
-    observer();
-  }
-};
-
-export const beginBatch = (): void => {
-  batchDepth += 1;
-};
-
-export const endBatch = (): void => {
-  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);
-};
-
-/**
- * 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();
+  }
+};