@bquery/bquery 1.8.2 → 1.10.0

package/src/reactive/watch.ts

@@ -6,7 +6,9 @@ import type { Computed } from './computed';
 import type { Signal } from './core';
 import type { CleanupFn } from './internals';
 
+import { debounce, throttle } from '../core/utils/function';
 import { effect } from './effect';
+import { getCurrentScope, onScopeDispose } from './scope';
 
 /**
  * Options for the watch function.
@@ -71,3 +73,139 @@ export const watch = <T>(
     }
   });
 };
+
+/**
+ * Watches a signal or computed value and debounces callback delivery.
+ * Rapid changes are collapsed into a single callback using the latest value
+ * and the first old value observed within the debounce window.
+ *
+ * @template T - The type of the watched value
+ * @param source - The signal or computed to watch
+ * @param callback - Function called with the debounced (newValue, oldValue)
+ * @param delayMs - Debounce delay in milliseconds
+ * @param options - Watch options
+ * @returns A cleanup function to stop watching and cancel pending callbacks
+ *
+ * @example
+ * ```ts
+ * const query = signal('');
+ * const stop = watchDebounce(query, (newQuery) => {
+ *   console.log('Search for', newQuery);
+ * }, 250);
+ *
+ * query.value = 'b';
+ * query.value = 'bq';
+ * query.value = 'bqu'; // Only this value is delivered after 250ms
+ *
+ * stop();
+ * ```
+ */
+export const watchDebounce = <T>(
+  source: Signal<T> | Computed<T>,
+  callback: (newValue: T, oldValue: T | undefined) => void,
+  delayMs: number,
+  options: WatchOptions<T> = {}
+): CleanupFn => {
+  const { immediate = false, equals = Object.is } = options;
+  const normalizedDelayMs = Number.isFinite(delayMs) ? Math.max(0, delayMs) : 0;
+  let hasPending = false;
+  let pendingNewValue!: T;
+  let pendingOldValue: T | undefined;
+  const cancelPending = (): void => {
+    notify.cancel();
+    hasPending = false;
+    pendingOldValue = undefined;
+  };
+
+  const notify = debounce(() => {
+    if (!hasPending) {
+      return;
+    }
+
+    try {
+      callback(pendingNewValue, pendingOldValue);
+    } catch (error) {
+      console.error('bQuery reactive: Error in watchDebounce callback', error);
+    }
+    hasPending = false;
+    pendingOldValue = undefined;
+  }, normalizedDelayMs);
+
+  if (immediate) {
+    callback(source.peek(), undefined);
+  }
+
+  const cleanup = watch(
+    source,
+    (newValue, oldValue) => {
+      if (!hasPending) {
+        pendingOldValue = oldValue;
+      }
+
+      pendingNewValue = newValue;
+      hasPending = true;
+      notify();
+    },
+    { equals }
+  );
+
+  if (getCurrentScope()) {
+    onScopeDispose(cancelPending);
+  }
+
+  return () => {
+    cleanup();
+    cancelPending();
+  };
+};
+
+/**
+ * Watches a signal or computed value and throttles callback delivery.
+ * Changes are delivered at most once per interval.
+ *
+ * @template T - The type of the watched value
+ * @param source - The signal or computed to watch
+ * @param callback - Function called with throttled (newValue, oldValue) updates
+ * @param intervalMs - Minimum interval between callback runs in milliseconds
+ * @param options - Watch options
+ * @returns A cleanup function to stop watching and reset the throttle window
+ *
+ * @example
+ * ```ts
+ * const scrollY = signal(0);
+ * const stop = watchThrottle(scrollY, (nextY) => {
+ *   console.log('Scroll position', nextY);
+ * }, 100);
+ *
+ * stop();
+ * ```
+ */
+export const watchThrottle = <T>(
+  source: Signal<T> | Computed<T>,
+  callback: (newValue: T, oldValue: T | undefined) => void,
+  intervalMs: number,
+  options: WatchOptions<T> = {}
+): CleanupFn => {
+  const { immediate = false, equals = Object.is } = options;
+  const normalizedIntervalMs = Number.isFinite(intervalMs) ? Math.max(0, intervalMs) : 0;
+  const notify = throttle((newValue: T, oldValue: T | undefined) => {
+    callback(newValue, oldValue);
+  }, normalizedIntervalMs);
+
+  if (immediate) {
+    notify(source.peek(), undefined);
+  }
+
+  const cleanup = watch(
+    source,
+    (newValue, oldValue) => {
+      notify(newValue, oldValue);
+    },
+    { equals }
+  );
+
+  return () => {
+    cleanup();
+    notify.cancel();
+  };
+};

package/src/reactive/websocket.ts

@@ -8,6 +8,9 @@
 import { computed } from './computed';
 import { Signal, signal } from './core';
 
+/** @internal */
+type WebSocketSendData = string | Blob | ArrayBufferLike | ArrayBufferView;
+
 // ---------------------------------------------------------------------------
 // Types
 // ---------------------------------------------------------------------------
@@ -40,7 +43,7 @@ export type EventSourceReconnectConfig = Pick<
 /** Configuration for keep-alive heartbeats. */
 export interface WebSocketHeartbeatConfig {
   /** Outgoing ping message (default: `'ping'`). */
-  message?: string | ArrayBufferLike | Blob | ArrayBufferView;
+  message?: WebSocketSendData;
   /** Interval in ms between heartbeat pings (default: 30 000). */
   interval?: number;
   /** Time in ms to wait for a pong before assuming the connection is dead (default: 10 000). */
@@ -52,7 +55,7 @@ export interface WebSocketHeartbeatConfig {
 /** Serializer/deserializer for typed messaging. */
 export interface WebSocketSerializer<TSend = unknown, TReceive = unknown> {
   /** Serialize a value before sending over the wire. Default: `JSON.stringify`. */
-  serialize?: (data: TSend) => string | ArrayBufferLike | Blob | ArrayBufferView;
+  serialize?: (data: TSend) => WebSocketSendData;
   /** Deserialize an incoming message. Default: `JSON.parse`. */
   deserialize?: (event: MessageEvent) => TReceive;
 }
@@ -115,7 +118,7 @@ export interface UseWebSocketReturn<TSend = unknown, TReceive = unknown> {
    * Uses the same queuing behavior as {@link send}: data is queued when the
    * socket is not `OPEN` and flushed once a connection is (re)established.
    */
-  sendRaw: (data: string | ArrayBufferLike | Blob | ArrayBufferView) => void;
+  sendRaw: (data: WebSocketSendData) => void;
   /** Manually open / reconnect the WebSocket. */
   open: () => void;
   /** Gracefully close the connection. */
@@ -162,6 +165,26 @@ const computeDelay = (attempt: number, config: WebSocketReconnectConfig): number
   return Math.min(base * factor ** attempt, max);
 };
 
+/** @internal */
+const sendSocketData = (socket: WebSocket, data: WebSocketSendData): void => {
+  if (typeof data === 'string' || data instanceof Blob || data instanceof ArrayBuffer) {
+    socket.send(data);
+    return;
+  }
+
+  if (ArrayBuffer.isView(data)) {
+    socket.send(data as BufferSource);
+    return;
+  }
+
+  if (typeof SharedArrayBuffer !== 'undefined' && data instanceof SharedArrayBuffer) {
+    socket.send(data as unknown as BufferSource);
+    return;
+  }
+
+  throw new TypeError('Unsupported WebSocket payload type.');
+};
+
 // ---------------------------------------------------------------------------
 // useWebSocket
 // ---------------------------------------------------------------------------
@@ -249,7 +272,7 @@ export const useWebSocket = <TSend = string, TReceive = string>(
   let internalReconnectCount = 0;
   let isAutoReconnecting = false;
   let pingSentAt = 0;
-  const sendQueue: Array<string | ArrayBufferLike | Blob | ArrayBufferView> = [];
+  const sendQueue: WebSocketSendData[] = [];
 
   const reconnectConfig = resolveReconnect(options.autoReconnect);
   const heartbeatConfig = resolveHeartbeat(options.heartbeat);
@@ -265,7 +288,7 @@ export const useWebSocket = <TSend = string, TReceive = string>(
     heartbeatTimer = setInterval(() => {
       if (ws?.readyState === WebSocket.OPEN) {
         pingSentAt = Date.now();
-        ws.send(pingMsg);
+        sendSocketData(ws, pingMsg);
         if (pongTimer !== undefined) {
           clearTimeout(pongTimer);
         }
@@ -341,7 +364,7 @@ export const useWebSocket = <TSend = string, TReceive = string>(
       if (ws.readyState !== WebSocket.OPEN) {
         break;
       }
-      ws.send(sendQueue[index]);
+      sendSocketData(ws, sendQueue[index]);
     }
 
     if (index > 0) {
@@ -460,10 +483,10 @@ export const useWebSocket = <TSend = string, TReceive = string>(
     sendRaw(serialized);
   };
 
-  const sendRaw = (raw: string | ArrayBufferLike | Blob | ArrayBufferView): void => {
+  const sendRaw = (raw: WebSocketSendData): void => {
     if (disposed) return;
     if (ws?.readyState === WebSocket.OPEN) {
-      ws.send(raw);
+      sendSocketData(ws, raw);
     } else {
       sendQueue.push(raw);
     }

package/src/view/directives/aria.ts

@@ -0,0 +1,72 @@
+import { effect } from '../../reactive/index';
+import { isPrototypePollutionKey } from '../../core/utils/object';
+import { evaluate, parseObjectExpression } from '../evaluate';
+import type { DirectiveHandler } from '../types';
+
+const toKebabCase = (value: string): string => value.replace(/([A-Z])/g, '-$1').toLowerCase();
+
+const normalizeAriaAttribute = (name: string): string => {
+  const trimmed = name.trim();
+  const lower = trimmed.toLowerCase();
+
+  if (lower.startsWith('aria-')) {
+    return lower;
+  }
+
+  const withoutPrefix = /^aria[A-Z]/.test(trimmed) ? trimmed.slice(4) : trimmed;
+  return `aria-${toKebabCase(withoutPrefix).replace(/^-/, '')}`;
+};
+
+const shouldRemoveAttribute = (value: unknown): boolean => value == null || value === '';
+
+/**
+ * Handles bq-aria directive - reactive ARIA attribute binding.
+ * @internal
+ */
+export const handleAria: DirectiveHandler = (el, expression, context, cleanups) => {
+  let appliedAttributes: Set<string> = new Set();
+
+  const cleanup = effect(() => {
+    const newAttributes = new Set<string>();
+    const ariaValues = Object.create(null) as Record<string, unknown>;
+
+    if (expression.trimStart().startsWith('{')) {
+      const ariaMap = parseObjectExpression(expression);
+      for (const [attrName, valueExpr] of Object.entries(ariaMap)) {
+        ariaValues[attrName] = evaluate(valueExpr, context);
+      }
+    } else {
+      const result = evaluate<Record<string, unknown>>(expression, context);
+      if (result && typeof result === 'object' && !Array.isArray(result)) {
+        for (const [attrName, value] of Object.entries(result)) {
+          if (isPrototypePollutionKey(attrName)) {
+            continue;
+          }
+
+          ariaValues[attrName] = value;
+        }
+      }
+    }
+
+    for (const [attrName, value] of Object.entries(ariaValues)) {
+      const normalizedName = normalizeAriaAttribute(attrName);
+      if (shouldRemoveAttribute(value)) {
+        el.removeAttribute(normalizedName);
+        continue;
+      }
+
+      el.setAttribute(normalizedName, value === true ? 'true' : String(value));
+      newAttributes.add(normalizedName);
+    }
+
+    for (const attrName of appliedAttributes) {
+      if (!newAttributes.has(attrName)) {
+        el.removeAttribute(attrName);
+      }
+    }
+
+    appliedAttributes = newAttributes;
+  });
+
+  cleanups.push(cleanup);
+};

package/src/view/directives/error.ts

@@ -0,0 +1,56 @@
+import { effect, isComputed, isSignal } from '../../reactive/index';
+import { evaluate } from '../evaluate';
+import type { DirectiveHandler } from '../types';
+
+type ErrorSource = unknown;
+
+const getErrorMessage = (source: ErrorSource): string => {
+  if (isSignal(source) || isComputed(source)) {
+    return String(source.value ?? '');
+  }
+
+  if (source && typeof source === 'object' && 'error' in source) {
+    const errorValue = source.error;
+    if (isSignal(errorValue) || isComputed(errorValue)) {
+      return String(errorValue.value ?? '');
+    }
+    return String(errorValue ?? '');
+  }
+
+  return String(source ?? '');
+};
+
+/**
+ * Handles bq-error directive - renders error messages and toggles visibility.
+ * @internal
+ */
+export const handleError: DirectiveHandler = (el, expression, context, cleanups) => {
+  const htmlEl = el as HTMLElement;
+  const shouldManageAriaHidden = !htmlEl.hasAttribute('aria-hidden');
+
+  if (!htmlEl.hasAttribute('role')) {
+    htmlEl.setAttribute('role', 'alert');
+  }
+
+  if (!htmlEl.hasAttribute('aria-live')) {
+    htmlEl.setAttribute('aria-live', 'assertive');
+  }
+
+  const cleanup = effect(() => {
+    const source = evaluate(expression, context);
+    const message = getErrorMessage(source).trim();
+    const hasMessage = message.length > 0;
+
+    htmlEl.textContent = message;
+    htmlEl.hidden = !hasMessage;
+    if (shouldManageAriaHidden) {
+      if (hasMessage) {
+        htmlEl.removeAttribute('aria-hidden');
+      } else {
+        htmlEl.setAttribute('aria-hidden', 'true');
+      }
+    }
+  });
+
+  cleanups.push(cleanup);
+};

package/src/view/directives/index.ts

@@ -1,5 +1,7 @@
+export { handleAria } from './aria';
 export { handleBind } from './bind';
 export { handleClass } from './class';
+export { handleError } from './error';
 export { createForHandler } from './for';
 export { handleHtml } from './html';
 export { handleIf } from './if';

package/src/view/mount.ts

@@ -1,8 +1,10 @@
 import type { CleanupFn } from '../reactive/index';
 import {
   createForHandler,
+  handleAria,
   handleBind,
   handleClass,
+  handleError,
   handleHtml,
   handleIf,
   handleModel,
@@ -80,6 +82,8 @@ export const mount = (
 
   const handlers: DirectiveHandlers = {
     text: handleText,
+    error: handleError,
+    aria: handleAria,
     html: handleHtml(sanitize),
     if: handleIf,
     show: handleShow,

package/src/view/process.ts

@@ -5,6 +5,8 @@ import type { BindingContext, DirectiveHandler } from './types';
 
 export type DirectiveHandlers = {
   text: DirectiveHandler;
+  error: DirectiveHandler;
+  aria: DirectiveHandler;
   html: DirectiveHandler;
   if: DirectiveHandler;
   show: DirectiveHandler;
@@ -46,6 +48,10 @@ export const processElement = (
     // Handle other directives
     if (directive === 'text') {
       handlers.text(el, value, context, cleanups);
+    } else if (directive === 'error') {
+      handlers.error(el, value, context, cleanups);
+    } else if (directive === 'aria') {
+      handlers.aria(el, value, context, cleanups);
     } else if (directive === 'html') {
       handlers.html(el, value, context, cleanups);
     } else if (directive === 'if') {

package/dist/core-DdtZHzsS.js

@@ -1,168 +0,0 @@
-var t = [], o = 0, p = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new WeakMap(), y = (e, r) => {
-  t.push(e);
-  try {
-    return r();
-  } finally {
-    t.pop();
-  }
-}, g = () => t[t.length - 1], A = (e) => {
-  t.push(void 0);
-  try {
-    return e();
-  } finally {
-    t.pop();
-  }
-}, S = (e) => {
-  if (o > 0) {
-    p.add(e);
-    return;
-  }
-  e();
-}, _ = () => {
-  for (const e of Array.from(p)) {
-    p.delete(e);
-    try {
-      e();
-    } catch (r) {
-      console.error("bQuery reactive: Error in observer during batch flush", r);
-    }
-  }
-}, O = () => {
-  o += 1;
-}, C = () => {
-  o <= 0 || (o -= 1, o === 0 && _());
-}, w = (e, r) => {
-  let s = n.get(e);
-  s || (s = /* @__PURE__ */ new Set(), n.set(e, s)), s.add(r);
-}, D = (e, r) => {
-  const s = n.get(e);
-  s && s.delete(r);
-}, d = (e) => {
-  const r = n.get(e);
-  if (r) {
-    for (const s of r) s.unsubscribe(e);
-    r.clear();
-  }
-}, c = [], f = (e) => typeof e == "object" && e !== null && "_addDisposer" in e, m = (e) => (typeof e == "object" || typeof e == "function") && e !== null && typeof e.then == "function", E = (e) => {
-  const r = typeof e.constructor == "function" ? e.constructor.name : void 0;
-  return typeof e == "function" && (Symbol.toStringTag in e && e[Symbol.toStringTag] === "AsyncFunction" || r === "AsyncFunction");
-}, a = () => {
-  for (let e = c.length - 1; e >= 0; e--) if (c[e].active) return c[e];
-}, k = class {
-  constructor() {
-    this.disposers = [], this._active = !0;
-  }
-  get active() {
-    return this._active;
-  }
-  _addDisposer(e) {
-    this._active && this.disposers.push(e);
-  }
-  run(e) {
-    if (!this._active) throw new Error("bQuery reactive: Cannot run in a stopped effectScope");
-    if (E(e)) throw new Error("bQuery reactive: effectScope.run() only supports synchronous callbacks");
-    c.push(this);
-    try {
-      const r = e();
-      if (m(r))
-        throw this.stop(), new Error("bQuery reactive: effectScope.run() only supports synchronous callbacks");
-      return r;
-    } finally {
-      c.pop();
-    }
-  }
-  stop() {
-    if (this._active) {
-      this._active = !1;
-      for (let e = this.disposers.length - 1; e >= 0; e--) try {
-        this.disposers[e]();
-      } catch (r) {
-        console.error("bQuery reactive: Error in scope cleanup", r);
-      }
-      this.disposers.length = 0;
-    }
-  }
-}, F = () => {
-  const e = new k(), r = a();
-  return f(r) && r._addDisposer(() => e.stop()), e;
-}, j = () => a(), B = (e) => {
-  const r = a();
-  if (!r || !r.active || !f(r)) throw new Error("bQuery reactive: onScopeDispose() must be called inside an active effectScope");
-  r._addDisposer(e);
-}, T = (e) => {
-  let r, s = !1;
-  const h = a(), l = () => {
-    if (r) {
-      try {
-        r();
-      } catch (u) {
-        console.error("bQuery reactive: Error in effect cleanup", u);
-      }
-      r = void 0;
-    }
-  }, v = () => {
-    l(), d(i);
-  }, b = () => {
-    s || (s = !0, v());
-  };
-  f(h) && h._addDisposer(b);
-  const i = () => {
-    if (!s) {
-      l(), d(i);
-      try {
-        r = y(i, e);
-      } catch (u) {
-        console.error("bQuery reactive: Error in effect", u);
-      }
-      s && v();
-    }
-  };
-  return i(), b;
-}, Q = class {
-  constructor(e) {
-    this._value = e, this.subscribers = /* @__PURE__ */ new Set();
-  }
-  get value() {
-    const e = g();
-    return e && (this.subscribers.add(e), w(e, this)), this._value;
-  }
-  set value(e) {
-    if (Object.is(this._value, e)) return;
-    this._value = e;
-    const r = Array.from(this.subscribers);
-    for (const s of r) S(s);
-  }
-  peek() {
-    return this._value;
-  }
-  update(e) {
-    this.value = e(this._value);
-  }
-  dispose() {
-    for (const e of this.subscribers) D(e, this);
-    this.subscribers.clear();
-  }
-  unsubscribe(e) {
-    this.subscribers.delete(e);
-  }
-}, I = (e) => new Q(e);
-export {
-  a,
-  B as c,
-  C as d,
-  g as f,
-  A as g,
-  y as h,
-  F as i,
-  O as l,
-  S as m,
-  I as n,
-  j as o,
-  w as p,
-  T as r,
-  f as s,
-  Q as t,
-  d as u
-};
-
-//# sourceMappingURL=core-DdtZHzsS.js.map

package/dist/core-DdtZHzsS.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"core-DdtZHzsS.js","names":[],"sources":["../src/reactive/internals.ts","../src/reactive/scope.ts","../src/reactive/effect.ts","../src/reactive/core.ts"],"sourcesContent":["/**\n * Internal reactive plumbing shared across primitives.\n * @internal\n */\n\nexport type Observer = () => void;\nexport type CleanupFn = () => void;\n\n/**\n * Interface for reactive sources (Signals, Computed) that can unsubscribe observers.\n * @internal\n */\nexport interface ReactiveSource {\n  unsubscribe(observer: Observer): void;\n}\n\nconst observerStack: Observer[] = [];\nlet batchDepth = 0;\nconst pendingObservers = new Set<Observer>();\n\n// Track dependencies for each observer to enable cleanup\nconst observerDependencies = new WeakMap<Observer, Set<ReactiveSource>>();\n\nexport const track = <T>(observer: Observer, fn: () => T): T => {\n  observerStack.push(observer);\n  try {\n    return fn();\n  } finally {\n    observerStack.pop();\n  }\n};\n\nexport const getCurrentObserver = (): Observer | undefined =>\n  observerStack[observerStack.length - 1];\n\n/**\n * Executes a function without exposing the current observer to dependencies.\n * Unlike disabling tracking globally, this still allows nested reactive internals\n * (e.g., computed recomputation) to track their own dependencies.\n * @internal\n */\nexport const withoutCurrentObserver = <T>(fn: () => T): T => {\n  // Push undefined to temporarily \"hide\" the current observer\n  // This way, Signal.value reads won't link to the previous observer,\n  // but nested track() calls (e.g., computed recompute) still work normally.\n  observerStack.push(undefined as unknown as Observer);\n  try {\n    return fn();\n  } finally {\n    observerStack.pop();\n  }\n};\n\nexport const scheduleObserver = (observer: Observer): void => {\n  if (batchDepth > 0) {\n    pendingObservers.add(observer);\n    return;\n  }\n  observer();\n};\n\nconst flushObservers = (): void => {\n  for (const observer of Array.from(pendingObservers)) {\n    pendingObservers.delete(observer);\n    try {\n      observer();\n    } catch (error) {\n      console.error('bQuery reactive: Error in observer during batch flush', error);\n    }\n  }\n};\n\nexport const beginBatch = (): void => {\n  batchDepth += 1;\n};\n\nexport const endBatch = (): void => {\n  if (batchDepth <= 0) return;\n  batchDepth -= 1;\n  if (batchDepth === 0) {\n    flushObservers();\n  }\n};\n\n/**\n * Registers a dependency between an observer and a reactive source.\n * @internal\n */\nexport const registerDependency = (observer: Observer, source: ReactiveSource): void => {\n  let deps = observerDependencies.get(observer);\n  if (!deps) {\n    deps = new Set();\n    observerDependencies.set(observer, deps);\n  }\n  deps.add(source);\n};\n\n/**\n * Removes a specific source from an observer's dependency set.\n * Used when a source (e.g. Signal) is disposed to prevent stale references.\n * @internal\n */\nexport const removeDependency = (observer: Observer, source: ReactiveSource): void => {\n  const deps = observerDependencies.get(observer);\n  if (deps) {\n    deps.delete(source);\n  }\n};\n\n/**\n * Clears all dependencies for an observer, unsubscribing from all sources.\n * @internal\n */\nexport const clearDependencies = (observer: Observer): void => {\n  const deps = observerDependencies.get(observer);\n  if (deps) {\n    for (const source of deps) {\n      source.unsubscribe(observer);\n    }\n    deps.clear();\n  }\n};\n","/**\n * Reactive effect scopes for grouped disposal.\n *\n * An `EffectScope` collects all effects, computed values, and watches created\n * inside its `run()` callback so they can be disposed together with a single\n * `stop()` call. Scopes nest — an inner scope is collected by its parent.\n *\n * @module bquery/reactive\n */\n\nimport type { CleanupFn } from './internals';\n\n// ---------------------------------------------------------------------------\n// Types\n// ---------------------------------------------------------------------------\n\n/**\n * A scope that collects reactive resources for grouped disposal.\n *\n * @example\n * ```ts\n * import { effectScope, signal, effect, computed } from '@bquery/bquery/reactive';\n *\n * const scope = effectScope();\n *\n * scope.run(() => {\n *   const count = signal(0);\n *   effect(() => console.log(count.value));\n *   const doubled = computed(() => count.value * 2);\n * });\n *\n * scope.stop(); // All effects and computed values disposed\n * ```\n */\nexport interface EffectScope {\n  /** Whether the scope has not yet been stopped. */\n  readonly active: boolean;\n\n  /**\n   * Executes `fn` inside this scope, collecting any reactive resources\n   * (effects, computed values, watches, nested scopes) created during the call.\n   *\n   * `run()` is synchronous-only. Do not pass an async function or a function\n   * that returns a Promise — resources created after an `await` cannot be\n   * collected reliably.\n   *\n   * @template T - Return type of the provided function\n   * @param fn - Function to run inside the scope\n   * @returns The return value of `fn`\n   * @throws {Error} If the scope has already been stopped\n   */\n  run<T>(fn: () => T): T;\n\n  /**\n   * Disposes all collected resources and marks the scope as inactive.\n   * Calling `stop()` on an already-stopped scope is a safe no-op.\n   */\n  stop(): void;\n}\n\n// ---------------------------------------------------------------------------\n// Internal scope stack\n// ---------------------------------------------------------------------------\n\n/** @internal */\ninterface ScopeInternal extends EffectScope {\n  /** @internal – Register a cleanup callback to run when the scope stops. */\n  _addDisposer(fn: CleanupFn): void;\n}\n\nconst scopeStack: ScopeInternal[] = [];\n\n/** @internal */\nexport const hasScopeDisposer = (\n  scope: EffectScope | undefined\n): scope is EffectScope & { _addDisposer(fn: CleanupFn): void } =>\n  typeof scope === 'object' && scope !== null && '_addDisposer' in scope;\n\nconst isPromiseLike = (value: unknown): value is PromiseLike<unknown> =>\n  (typeof value === 'object' || typeof value === 'function') &&\n  value !== null &&\n  typeof (value as { then?: unknown }).then === 'function';\n\n/**\n * Best-effort detection for native async functions so `run()` can reject them\n * before invocation. Transpiled async functions may not preserve this shape, so\n * promise-like return values are still checked after execution as a fallback.\n * @internal\n */\nconst isAsyncFunction = (value: unknown): value is (...args: never[]) => Promise<unknown> => {\n  const constructorName =\n    typeof (value as { constructor?: unknown }).constructor === 'function'\n      ? (value as { constructor: { name?: unknown } }).constructor.name\n      : undefined;\n\n  return (\n    typeof value === 'function' &&\n    ((Symbol.toStringTag in value &&\n      (value as { [Symbol.toStringTag]?: unknown })[Symbol.toStringTag] === 'AsyncFunction') ||\n      constructorName === 'AsyncFunction')\n  );\n};\n\n/**\n * Returns the currently active scope, or `undefined` if none.\n * @internal\n */\nexport const getActiveScope = (): EffectScope | undefined => {\n  for (let i = scopeStack.length - 1; i >= 0; i--) {\n    if (scopeStack[i].active) {\n      return scopeStack[i];\n    }\n  }\n\n  return undefined;\n};\n\n// ---------------------------------------------------------------------------\n// EffectScope implementation\n// ---------------------------------------------------------------------------\n\nclass EffectScopeImpl implements ScopeInternal {\n  private disposers: CleanupFn[] = [];\n  private _active = true;\n\n  get active(): boolean {\n    return this._active;\n  }\n\n  /** @internal */\n  _addDisposer(fn: CleanupFn): void {\n    if (this._active) {\n      this.disposers.push(fn);\n    }\n  }\n\n  run<T>(fn: () => T): T {\n    if (!this._active) {\n      throw new Error('bQuery reactive: Cannot run in a stopped effectScope');\n    }\n    if (isAsyncFunction(fn)) {\n      throw new Error('bQuery reactive: effectScope.run() only supports synchronous callbacks');\n    }\n\n    scopeStack.push(this);\n    try {\n      const result = fn();\n      if (isPromiseLike(result)) {\n        this.stop();\n        throw new Error('bQuery reactive: effectScope.run() only supports synchronous callbacks');\n      }\n      return result;\n    } finally {\n      scopeStack.pop();\n    }\n  }\n\n  stop(): void {\n    if (!this._active) return;\n    this._active = false;\n\n    // Dispose in reverse order (LIFO) to mirror creation order\n    for (let i = this.disposers.length - 1; i >= 0; i--) {\n      try {\n        this.disposers[i]();\n      } catch (error) {\n        console.error('bQuery reactive: Error in scope cleanup', error);\n      }\n    }\n    this.disposers.length = 0;\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Public API\n// ---------------------------------------------------------------------------\n\n/**\n * Creates a new effect scope for grouped disposal of reactive resources.\n *\n * All `effect()`, `computed()`, `watch()`, and nested `effectScope()` calls\n * made inside `scope.run(fn)` are automatically collected. Calling\n * `scope.stop()` disposes them all at once.\n *\n * `run()` is synchronous-only. Create the scope outside async flows when\n * needed, but keep the callback itself synchronous so cleanup registration\n * stays deterministic.\n *\n * @returns A new {@link EffectScope}\n *\n * @example\n * ```ts\n * import { effectScope, signal, effect, onScopeDispose } from '@bquery/bquery/reactive';\n *\n * const scope = effectScope();\n *\n * scope.run(() => {\n *   const count = signal(0);\n *\n *   effect(() => console.log(count.value));\n *\n *   onScopeDispose(() => {\n *     console.log('Custom cleanup');\n *   });\n * });\n *\n * scope.stop(); // logs \"Custom cleanup\", all effects stopped\n * ```\n */\nexport const effectScope = (): EffectScope => {\n  const scope = new EffectScopeImpl();\n\n  // If created inside another scope, auto-collect as a nested scope\n  const parent = getActiveScope();\n  if (hasScopeDisposer(parent)) {\n    parent._addDisposer(() => scope.stop());\n  }\n\n  return scope;\n};\n\n/**\n * Returns the currently active {@link EffectScope}, or `undefined` if\n * code is not running inside any scope's `run()` callback.\n *\n * @returns The active scope, or `undefined`\n *\n * @example\n * ```ts\n * import { effectScope, getCurrentScope } from '@bquery/bquery/reactive';\n *\n * const scope = effectScope();\n * scope.run(() => {\n *   console.log(getCurrentScope() !== undefined); // true\n * });\n *\n * console.log(getCurrentScope()); // undefined\n * ```\n */\nexport const getCurrentScope = (): EffectScope | undefined => getActiveScope();\n\n/**\n * Registers a cleanup callback on the currently active scope.\n *\n * The callback runs when the scope is stopped. This is useful for\n * registering arbitrary cleanup (e.g. event listeners, timers)\n * alongside effects and computed values.\n *\n * @param fn - Cleanup function to run when the scope stops\n * @throws {Error} If called outside an active scope\n *\n * @example\n * ```ts\n * import { effectScope, onScopeDispose } from '@bquery/bquery/reactive';\n *\n * const scope = effectScope();\n *\n * scope.run(() => {\n *   const controller = new AbortController();\n *   fetch('/api/data', { signal: controller.signal });\n *\n *   onScopeDispose(() => controller.abort());\n * });\n *\n * scope.stop(); // abort() is called\n * ```\n */\nexport const onScopeDispose = (fn: CleanupFn): void => {\n  const scope = getActiveScope();\n  if (!scope || !scope.active || !hasScopeDisposer(scope)) {\n    throw new Error(\n      'bQuery reactive: onScopeDispose() must be called inside an active effectScope'\n    );\n  }\n  scope._addDisposer(fn);\n};\n","/**\n * Reactive effects.\n */\n\nimport { CleanupFn, Observer, track, clearDependencies } from './internals';\nimport { getActiveScope, hasScopeDisposer } from './scope';\n\n/**\n * Creates a side effect that automatically re-runs when dependencies change.\n *\n * The effect runs immediately upon creation and then re-runs whenever\n * any signal or computed value read inside it changes.\n *\n * If created inside an {@link effectScope}, the effect is automatically\n * collected and will be disposed when the scope stops.\n *\n * @param fn - The effect function to run\n * @returns A cleanup function to stop the effect\n */\nexport const effect = (fn: () => void | CleanupFn): CleanupFn => {\n  let cleanupFn: CleanupFn | void;\n  let isDisposed = false;\n  const scope = getActiveScope();\n\n  const runCleanup = (): void => {\n    if (cleanupFn) {\n      try {\n        cleanupFn();\n      } catch (error) {\n        console.error('bQuery reactive: Error in effect cleanup', error);\n      }\n      cleanupFn = undefined;\n    }\n  };\n\n  const clearEffectState = (): void => {\n    runCleanup();\n    // Clean up all dependencies when effect is disposed\n    clearDependencies(observer);\n  };\n\n  const dispose: CleanupFn = () => {\n    if (isDisposed) {\n      return;\n    }\n\n    isDisposed = true;\n    clearEffectState();\n  };\n\n  if (hasScopeDisposer(scope)) {\n    scope._addDisposer(dispose);\n  }\n\n  const observer: Observer = () => {\n    if (isDisposed) return;\n\n    runCleanup();\n\n    // Clear old dependencies before running to avoid stale subscriptions\n    clearDependencies(observer);\n\n    try {\n      cleanupFn = track(observer, fn);\n    } catch (error) {\n      console.error('bQuery reactive: Error in effect', error);\n    }\n\n    if (isDisposed) {\n      clearEffectState();\n    }\n  };\n\n  observer();\n\n  return dispose;\n};\n","/**\n * Core reactive signals.\n */\n\nimport {\n  getCurrentObserver,\n  registerDependency,\n  removeDependency,\n  scheduleObserver,\n  type ReactiveSource,\n} from './internals';\n\n/**\n * A reactive value container that notifies subscribers on change.\n *\n * Signals are the foundational primitive of the reactive system.\n * Reading a signal's value inside an effect or computed automatically\n * establishes a reactive dependency.\n *\n * @template T - The type of the stored value\n */\nexport class Signal<T> implements ReactiveSource {\n  private subscribers = new Set<() => void>();\n\n  /**\n   * Creates a new signal with an initial value.\n   * @param _value - The initial value\n   */\n  constructor(private _value: T) {}\n\n  /**\n   * Gets the current value and tracks the read if inside an observer.\n   * During untrack calls, getCurrentObserver returns undefined, preventing dependency tracking.\n   */\n  get value(): T {\n    const current = getCurrentObserver();\n    if (current) {\n      this.subscribers.add(current);\n      registerDependency(current, this);\n    }\n    return this._value;\n  }\n\n  /**\n   * Sets a new value and notifies all subscribers if the value changed.\n   * Uses Object.is for equality comparison.\n   */\n  set value(next: T) {\n    if (Object.is(this._value, next)) return;\n    this._value = next;\n    // Create snapshot to avoid issues with subscribers modifying the set during iteration\n    const subscribersSnapshot = Array.from(this.subscribers);\n    for (const subscriber of subscribersSnapshot) {\n      scheduleObserver(subscriber);\n    }\n  }\n\n  /**\n   * Reads the current value without tracking.\n   * Useful when you need the value but don't want to create a dependency.\n   *\n   * @returns The current value\n   */\n  peek(): T {\n    return this._value;\n  }\n\n  /**\n   * Updates the value using a function.\n   * Useful for updates based on the current value.\n   *\n   * @param updater - Function that receives current value and returns new value\n   */\n  update(updater: (current: T) => T): void {\n    this.value = updater(this._value);\n  }\n\n  /**\n   * Removes all subscribers from this signal.\n   * Use this when a signal is no longer needed to prevent memory leaks.\n   *\n   * @example\n   * ```ts\n   * const count = signal(0);\n   * effect(() => console.log(count.value));\n   * count.dispose(); // All subscribers removed\n   * ```\n   */\n  dispose(): void {\n    // Remove this signal from each subscriber's dependency set\n    // so the observer no longer holds a strong reference to it\n    for (const subscriber of this.subscribers) {\n      removeDependency(subscriber, this);\n    }\n    this.subscribers.clear();\n  }\n\n  /**\n   * Removes an observer from this signal's subscriber set.\n   * @internal\n   */\n  unsubscribe(observer: () => void): void {\n    this.subscribers.delete(observer);\n  }\n}\n\n/**\n * Creates a new reactive signal.\n *\n * @template T - The type of the signal value\n * @param value - The initial value\n * @returns A new Signal instance\n */\nexport const signal = <T>(value: T): Signal<T> => new Signal(value);\n"],"mappings":"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"}