@bquery/bquery 1.7.0 → 1.8.1

package/dist/core/shared.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../src/core/shared.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,OAAO,EAAE,CAAC;AAEpC,eAAO,MAAM,aAAa,GAAI,OAAO,OAAO,GAAG,WAAW,KAAG,WACrB,CAAC;AAEzC,eAAO,MAAM,QAAQ,GAAI,UAAU,WAAW,EAAE,QAAQ,CAAC,EAAE,EAAE,OAAO,KAAK,IAAI,SAI5E,CAAC;AAEF,gBAAgB;AAChB,eAAO,MAAM,aAAa,GAAI,SAAS,OAAO,GAAG,IAAI,GAAG,SAAS,KAAG,OAAO,IAAI,WAQ9E,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,YAAY,GACvB,SAAS,OAAO,GAAG,IAAI,GAAG,SAAS,EACnC,WAAW,OAAO,GAAG,QAAQ,EAC7B,eAAe,OAAO,KACrB,MA2BF,CAAC"}
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../src/core/shared.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,OAAO,EAAE,CAAC;AAEpC,eAAO,MAAM,aAAa,GAAI,OAAO,OAAO,GAAG,WAAW,KAAG,WACrB,CAAC;AAEzC,eAAO,MAAM,QAAQ,GAAI,UAAU,WAAW,EAAE,QAAQ,CAAC,EAAE,EAAE,OAAO,KAAK,IAAI,SAI5E,CAAC;AAEF,gBAAgB;AAChB,eAAO,MAAM,aAAa,GAAI,SAAS,OAAO,GAAG,IAAI,GAAG,SAAS,KAAG,OAAO,IAAI,WAQ9E,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,YAAY,GACvB,SAAS,OAAO,GAAG,IAAI,GAAG,SAAS,EACnC,WAAW,OAAO,GAAG,QAAQ,KAC5B,MAKF,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,YAAY,GACvB,SAAS,OAAO,GAAG,IAAI,GAAG,SAAS,EACnC,WAAW,OAAO,GAAG,QAAQ,EAC7B,eAAe,OAAO,KACrB,MA2BF,CAAC"}

package/dist/core-DdtZHzsS.js

@@ -0,0 +1,168 @@
+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

@@ -0,0 +1 @@
+{"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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"}