@bquery/bquery 1.1.1 → 1.2.0

package/dist/index.d.ts

@@ -13,4 +13,7 @@ export * from './component/index';
 export * from './motion/index';
 export * from './security/index';
 export * from './platform/index';
+export * from './router/index';
+export * from './store/index';
+export * from './view/index';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,cAAc,cAAc,CAAC;AAG7B,cAAc,kBAAkB,CAAC;AAGjC,cAAc,mBAAmB,CAAC;AAGlC,cAAc,gBAAgB,CAAC;AAG/B,cAAc,kBAAkB,CAAC;AAGjC,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,cAAc,cAAc,CAAC;AAG7B,cAAc,kBAAkB,CAAC;AAGjC,cAAc,mBAAmB,CAAC;AAGlC,cAAc,gBAAgB,CAAC;AAG/B,cAAc,kBAAkB,CAAC;AAGjC,cAAc,kBAAkB,CAAC;AAGjC,cAAc,gBAAgB,CAAC;AAG/B,cAAc,eAAe,CAAC;AAG9B,cAAc,cAAc,CAAC"}

package/dist/index.es.mjs

@@ -1,48 +1,71 @@
-import { $ as i, $$ as r, BQueryCollection as s, BQueryElement as o, utils as a } from "./core.es.mjs";
-import { Computed as p, Signal as c, batch as l, computed as m, effect as u, isComputed as f, isSignal as g, persistedSignal as d, readonly as x, signal as y, untrack as T, watch as h } from "./reactive.es.mjs";
-import { component as C, html as H, safeHtml as P } from "./component.es.mjs";
-import { capturePosition as $, flip as b, flipList as k, spring as B, springPresets as Q, transition as v } from "./motion.es.mjs";
-import { createTrustedHtml as D, escapeHtml as E, generateNonce as L, getTrustedTypesPolicy as N, hasCSPDirective as j, isTrustedTypesSupported as q, sanitize as A, sanitize as F, stripTags as G } from "./security.es.mjs";
-import { buckets as J, cache as K, notifications as M, storage as O } from "./platform.es.mjs";
+import { $ as r, $$ as o, BQueryCollection as i, BQueryElement as s, utils as a } from "./core.es.mjs";
+import { Computed as p, Signal as c, batch as l, computed as m, effect as u, isComputed as f, isSignal as g, persistedSignal as d, readonly as S, signal as x, untrack as y, watch as T } from "./reactive.es.mjs";
+import { component as h, html as k, safeHtml as v } from "./component.es.mjs";
+import { capturePosition as H, flip as b, flipList as z, spring as A, springPresets as $, transition as w } from "./motion.es.mjs";
+import { createTrustedHtml as L, escapeHtml as Q, generateNonce as R, getTrustedTypesPolicy as D, hasCSPDirective as E, isTrustedTypesSupported as N, sanitize as j, sanitize as q, stripTags as F } from "./security.es.mjs";
+import { buckets as I, cache as J, notifications as K, storage as M } from "./platform.es.mjs";
+import { back as U, createRouter as V, currentRoute as W, forward as X, interceptLinks as Y, isActive as Z, isActiveSignal as _, link as ee, navigate as te, resolve as re } from "./router.es.mjs";
+import { createPersistedStore as ie, createStore as se, destroyStore as ae, getStore as ne, listStores as pe, mapActions as ce, mapState as le, registerPlugin as me } from "./store.es.mjs";
+import { createTemplate as fe, mount as ge } from "./view.es.mjs";
 export {
-  i as $,
-  r as $$,
-  s as BQueryCollection,
-  o as BQueryElement,
+  r as $,
+  o as $$,
+  i as BQueryCollection,
+  s as BQueryElement,
   p as Computed,
   c as Signal,
+  U as back,
   l as batch,
-  J as buckets,
-  K as cache,
-  $ as capturePosition,
-  C as component,
+  I as buckets,
+  J as cache,
+  H as capturePosition,
+  h as component,
   m as computed,
-  D as createTrustedHtml,
+  ie as createPersistedStore,
+  V as createRouter,
+  se as createStore,
+  fe as createTemplate,
+  L as createTrustedHtml,
+  W as currentRoute,
+  ae as destroyStore,
   u as effect,
-  E as escapeHtml,
+  Q as escapeHtml,
   b as flip,
-  k as flipList,
-  L as generateNonce,
-  N as getTrustedTypesPolicy,
-  j as hasCSPDirective,
-  H as html,
+  z as flipList,
+  X as forward,
+  R as generateNonce,
+  ne as getStore,
+  D as getTrustedTypesPolicy,
+  E as hasCSPDirective,
+  k as html,
+  Y as interceptLinks,
+  Z as isActive,
+  _ as isActiveSignal,
   f as isComputed,
   g as isSignal,
-  q as isTrustedTypesSupported,
-  M as notifications,
+  N as isTrustedTypesSupported,
+  ee as link,
+  pe as listStores,
+  ce as mapActions,
+  le as mapState,
+  ge as mount,
+  te as navigate,
+  K as notifications,
   d as persistedSignal,
-  x as readonly,
-  P as safeHtml,
-  A as sanitize,
-  F as sanitizeHtml,
-  y as signal,
-  B as spring,
-  Q as springPresets,
-  O as storage,
-  G as stripTags,
-  v as transition,
-  T as untrack,
+  S as readonly,
+  me as registerPlugin,
+  re as resolve,
+  v as safeHtml,
+  j as sanitize,
+  q as sanitizeHtml,
+  x as signal,
+  A as spring,
+  $ as springPresets,
+  M as storage,
+  F as stripTags,
+  w as transition,
+  y as untrack,
   a as utils,
-  h as watch
+  T as watch
 };
 //# sourceMappingURL=index.es.mjs.map

package/dist/index.es.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.es.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;"}
+{"version":3,"file":"index.es.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;"}

package/dist/reactive/signal.d.ts

@@ -118,6 +118,13 @@ export declare class Computed<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.

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

@@ -1 +1 @@
-{"version":3,"file":"signal.d.ts","sourceRoot":"","sources":["../../src/reactive/signal.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"signal.d.ts","sourceRoot":"","sources":["../../src/reactive/signal.ts"],"names":[],"mappings":"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"}

package/dist/reactive.es.mjs

@@ -1,8 +1,8 @@
 const i = [];
-let u = 0;
-const o = /* @__PURE__ */ new Set();
-let a = !0;
-const l = (t, e) => {
+let a = 0;
+const l = /* @__PURE__ */ new Set();
+let u = !0;
+const o = (t, e) => {
   i.push(t);
   try {
     return e();
@@ -10,14 +10,14 @@ const l = (t, e) => {
     i.pop();
   }
 }, h = (t) => {
-  if (u > 0) {
-    o.add(t);
+  if (a > 0) {
+    l.add(t);
     return;
   }
   t();
-}, v = () => {
-  for (const t of Array.from(o))
-    o.delete(t), t();
+}, p = () => {
+  for (const t of Array.from(l))
+    l.delete(t), t();
 };
 class f {
   /**
@@ -32,7 +32,7 @@ class f {
    * Respects the global tracking state (disabled during untrack calls).
    */
   get value() {
-    if (a) {
+    if (u) {
       const e = i[i.length - 1];
       e && this.subscribers.add(e);
     }
@@ -85,23 +85,32 @@ class d {
    */
   get value() {
     const e = i[i.length - 1];
-    return e && this.subscribers.add(e), this.dirty && (this.dirty = !1, this.cachedValue = l(this.markDirty, this.compute)), this.cachedValue;
+    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 p = (t) => new f(t), g = (t) => new d(t), b = (t) => {
+const v = (t) => new f(t), y = (t) => new d(t), b = (t) => {
   let e, s = !1;
   const r = () => {
-    s || (e && e(), e = l(r, t));
+    s || (e && e(), e = o(r, t));
   };
   return r(), () => {
     s = !0, e && e();
   };
-}, y = (t) => {
-  u += 1;
+}, g = (t) => {
+  a += 1;
   try {
     t();
   } finally {
-    u -= 1, u === 0 && v();
+    a -= 1, a === 0 && p();
   }
 }, m = (t, e) => {
   let s = e;
@@ -110,7 +119,7 @@ const p = (t) => new f(t), g = (t) => new d(t), b = (t) => {
     n !== null && (s = JSON.parse(n));
   } catch {
   }
-  const r = p(s);
+  const r = v(s);
   return b(() => {
     try {
       localStorage.setItem(t, JSON.stringify(r.value));
@@ -135,25 +144,25 @@ const p = (t) => new f(t), g = (t) => new d(t), b = (t) => {
     e(c, r), r = c;
   });
 }, w = (t) => {
-  const e = a;
-  a = !1;
+  const e = u;
+  u = !1;
   try {
     return t();
   } finally {
-    a = e;
+    u = e;
   }
-}, O = (t) => t instanceof f, _ = (t) => t instanceof d;
+}, O = (t) => t instanceof f, V = (t) => t instanceof d;
 export {
   d as Computed,
   f as Signal,
-  y as batch,
-  g as computed,
+  g as batch,
+  y as computed,
   b as effect,
-  _ as isComputed,
+  V as isComputed,
   O as isSignal,
   m as persistedSignal,
   S as readonly,
-  p as signal,
+  v as signal,
   w as untrack,
   k as watch
 };

package/dist/reactive.es.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"reactive.es.mjs","sources":["../src/reactive/signal.ts"],"sourcesContent":["/**\r\n * Reactive primitives inspired by fine-grained reactivity.\r\n *\r\n * This module provides a minimal but powerful reactive system:\r\n * - Signal: A reactive value that notifies subscribers when changed\r\n * - Computed: A derived value that automatically updates when dependencies change\r\n * - Effect: A side effect that re-runs when its dependencies change\r\n * - Batch: Group multiple updates to prevent intermediate re-renders\r\n *\r\n * @module bquery/reactive\r\n *\r\n * @example\r\n * ```ts\r\n * const count = signal(0);\r\n * const doubled = computed(() => count.value * 2);\r\n *\r\n * effect(() => {\r\n *   console.log(`Count: ${count.value}, Doubled: ${doubled.value}`);\r\n * });\r\n *\r\n * batch(() => {\r\n *   count.value = 1;\r\n *   count.value = 2;\r\n * });\r\n * // Logs: \"Count: 2, Doubled: 4\" (only once due to batching)\r\n * ```\r\n */\r\n\r\n/**\r\n * Observer function type used internally for tracking reactivity.\r\n */\r\nexport type Observer = () => void;\r\n\r\n/**\r\n * Cleanup function returned by effects for disposal.\r\n */\r\nexport type CleanupFn = () => void;\r\n\r\n// Internal state for tracking the current observer context\r\nconst observerStack: Observer[] = [];\r\nlet batchDepth = 0;\r\nconst pendingObservers = new Set<Observer>();\r\n\r\n// Flag to disable tracking temporarily (for untrack)\r\nlet trackingEnabled = true;\r\n\r\n/**\r\n * Tracks dependencies during a function execution.\r\n * Uses direct push/pop for O(1) operations instead of array copying.\r\n * @internal\r\n */\r\nconst track = <T>(observer: Observer, fn: () => T): T => {\r\n  observerStack.push(observer);\r\n  try {\r\n    return fn();\r\n  } finally {\r\n    observerStack.pop();\r\n  }\r\n};\r\n\r\n/**\r\n * Schedules an observer to run, respecting batch mode.\r\n * @internal\r\n */\r\nconst scheduleObserver = (observer: Observer) => {\r\n  if (batchDepth > 0) {\r\n    pendingObservers.add(observer);\r\n    return;\r\n  }\r\n  observer();\r\n};\r\n\r\n/**\r\n * Flushes all pending observers after a batch completes.\r\n * @internal\r\n */\r\nconst flushObservers = () => {\r\n  for (const observer of Array.from(pendingObservers)) {\r\n    pendingObservers.delete(observer);\r\n    observer();\r\n  }\r\n};\r\n\r\n/**\r\n * A reactive value container that notifies subscribers on change.\r\n *\r\n * Signals are the foundational primitive of the reactive system.\r\n * Reading a signal's value inside an effect or computed automatically\r\n * establishes a reactive dependency.\r\n *\r\n * @template T - The type of the stored value\r\n *\r\n * @example\r\n * ```ts\r\n * const name = signal('World');\r\n * console.log(name.value); // 'World'\r\n *\r\n * name.value = 'bQuery';\r\n * console.log(name.value); // 'bQuery'\r\n * ```\r\n */\r\nexport class Signal<T> {\r\n  private subscribers = new Set<Observer>();\r\n\r\n  /**\r\n   * Creates a new signal with an initial value.\r\n   * @param _value - The initial value\r\n   */\r\n  constructor(private _value: T) {}\r\n\r\n  /**\r\n   * Gets the current value and tracks the read if inside an observer.\r\n   * Respects the global tracking state (disabled during untrack calls).\r\n   */\r\n  get value(): T {\r\n    if (trackingEnabled) {\r\n      const current = observerStack[observerStack.length - 1];\r\n      if (current) {\r\n        this.subscribers.add(current);\r\n      }\r\n    }\r\n    return this._value;\r\n  }\r\n\r\n  /**\r\n   * Sets a new value and notifies all subscribers if the value changed.\r\n   * Uses Object.is for equality comparison.\r\n   */\r\n  set value(next: T) {\r\n    if (Object.is(this._value, next)) return;\r\n    this._value = next;\r\n    for (const subscriber of this.subscribers) {\r\n      scheduleObserver(subscriber);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Reads the current value without tracking.\r\n   * Useful when you need the value but don't want to create a dependency.\r\n   *\r\n   * @returns The current value\r\n   */\r\n  peek(): T {\r\n    return this._value;\r\n  }\r\n\r\n  /**\r\n   * Updates the value using a function.\r\n   * Useful for updates based on the current value.\r\n   *\r\n   * @param updater - Function that receives current value and returns new value\r\n   */\r\n  update(updater: (current: T) => T): void {\r\n    this.value = updater(this._value);\r\n  }\r\n}\r\n\r\n/**\r\n * A computed value that derives from other reactive sources.\r\n *\r\n * Computed values are lazily evaluated and cached. They only\r\n * recompute when their dependencies change.\r\n *\r\n * @template T - The type of the computed value\r\n *\r\n * @example\r\n * ```ts\r\n * const price = signal(100);\r\n * const quantity = signal(2);\r\n * const total = computed(() => price.value * quantity.value);\r\n *\r\n * console.log(total.value); // 200\r\n * price.value = 150;\r\n * console.log(total.value); // 300\r\n * ```\r\n */\r\nexport class Computed<T> {\r\n  private cachedValue!: T;\r\n  private dirty = true;\r\n  private subscribers = new Set<Observer>();\r\n  private readonly markDirty = () => {\r\n    this.dirty = true;\r\n    for (const subscriber of this.subscribers) {\r\n      scheduleObserver(subscriber);\r\n    }\r\n  };\r\n\r\n  /**\r\n   * Creates a new computed value.\r\n   * @param compute - Function that computes the value\r\n   */\r\n  constructor(private readonly compute: () => T) {}\r\n\r\n  /**\r\n   * Gets the computed value, recomputing if dependencies changed.\r\n   */\r\n  get value(): T {\r\n    const current = observerStack[observerStack.length - 1];\r\n    if (current) {\r\n      this.subscribers.add(current);\r\n    }\r\n    if (this.dirty) {\r\n      this.dirty = false;\r\n      this.cachedValue = track(this.markDirty, this.compute);\r\n    }\r\n    return this.cachedValue;\r\n  }\r\n}\r\n\r\n/**\r\n * Creates a new reactive signal.\r\n *\r\n * @template T - The type of the signal value\r\n * @param value - The initial value\r\n * @returns A new Signal instance\r\n *\r\n * @example\r\n * ```ts\r\n * const count = signal(0);\r\n * count.value++; // Triggers subscribers\r\n * ```\r\n */\r\nexport const signal = <T>(value: T): Signal<T> => new Signal(value);\r\n\r\n/**\r\n * Creates a new computed value.\r\n *\r\n * @template T - The type of the computed value\r\n * @param fn - Function that computes the value from reactive sources\r\n * @returns A new Computed instance\r\n *\r\n * @example\r\n * ```ts\r\n * const doubled = computed(() => count.value * 2);\r\n * ```\r\n */\r\nexport const computed = <T>(fn: () => T): Computed<T> => new Computed(fn);\r\n\r\n/**\r\n * Creates a side effect that automatically re-runs when dependencies change.\r\n *\r\n * The effect runs immediately upon creation and then re-runs whenever\r\n * any signal or computed value read inside it changes.\r\n *\r\n * @param fn - The effect function to run\r\n * @returns A cleanup function to stop the effect\r\n *\r\n * @example\r\n * ```ts\r\n * const count = signal(0);\r\n *\r\n * const cleanup = effect(() => {\r\n *   document.title = `Count: ${count.value}`;\r\n * });\r\n *\r\n * // Later, to stop the effect:\r\n * cleanup();\r\n * ```\r\n */\r\nexport const effect = (fn: () => void | CleanupFn): CleanupFn => {\r\n  let cleanupFn: CleanupFn | void;\r\n  let isDisposed = false;\r\n\r\n  const observer: Observer = () => {\r\n    if (isDisposed) return;\r\n\r\n    // Run previous cleanup if exists\r\n    if (cleanupFn) {\r\n      cleanupFn();\r\n    }\r\n\r\n    // Run effect and capture cleanup\r\n    cleanupFn = track(observer, fn);\r\n  };\r\n\r\n  observer();\r\n\r\n  return () => {\r\n    isDisposed = true;\r\n    if (cleanupFn) {\r\n      cleanupFn();\r\n    }\r\n  };\r\n};\r\n\r\n/**\r\n * Batches multiple signal updates into a single notification cycle.\r\n *\r\n * Updates made inside the batch function are deferred until the batch\r\n * completes, preventing intermediate re-renders and improving performance.\r\n *\r\n * @param fn - Function containing multiple signal updates\r\n *\r\n * @example\r\n * ```ts\r\n * batch(() => {\r\n *   firstName.value = 'John';\r\n *   lastName.value = 'Doe';\r\n *   age.value = 30;\r\n * });\r\n * // Effects only run once with all three updates\r\n * ```\r\n */\r\nexport const batch = (fn: () => void): void => {\r\n  batchDepth += 1;\r\n  try {\r\n    fn();\r\n  } finally {\r\n    batchDepth -= 1;\r\n    if (batchDepth === 0) {\r\n      flushObservers();\r\n    }\r\n  }\r\n};\r\n\r\n/**\r\n * Creates a signal that persists to localStorage.\r\n *\r\n * @template T - The type of the signal value\r\n * @param key - The localStorage key\r\n * @param initialValue - The initial value if not found in storage\r\n * @returns A Signal that syncs with localStorage\r\n *\r\n * @example\r\n * ```ts\r\n * const theme = persistedSignal('theme', 'light');\r\n * theme.value = 'dark'; // Automatically saved to localStorage\r\n * ```\r\n */\r\nexport const persistedSignal = <T>(key: string, initialValue: T): Signal<T> => {\r\n  let stored: T = initialValue;\r\n\r\n  try {\r\n    const raw = localStorage.getItem(key);\r\n    if (raw !== null) {\r\n      stored = JSON.parse(raw) as T;\r\n    }\r\n  } catch {\r\n    // Use initial value on parse error\r\n  }\r\n\r\n  const sig = signal(stored);\r\n\r\n  // Create an effect to persist changes\r\n  effect(() => {\r\n    try {\r\n      localStorage.setItem(key, JSON.stringify(sig.value));\r\n    } catch {\r\n      // Ignore storage errors\r\n    }\r\n  });\r\n\r\n  return sig;\r\n};\r\n\r\n// ============================================================================\r\n// Extended Reactive Utilities\r\n// ============================================================================\r\n\r\n/**\r\n * A readonly wrapper around a signal that prevents writes.\r\n * Provides read-only access to a signal's value while maintaining reactivity.\r\n *\r\n * @template T - The type of the wrapped value\r\n */\r\nexport interface ReadonlySignal<T> {\r\n  /** Gets the current value with dependency tracking. */\r\n  readonly value: T;\r\n  /** Gets the current value without dependency tracking. */\r\n  peek(): T;\r\n}\r\n\r\n/**\r\n * Creates a read-only view of a signal.\r\n * Useful for exposing reactive state without allowing modifications.\r\n *\r\n * @template T - The type of the signal value\r\n * @param sig - The signal to wrap\r\n * @returns A readonly signal wrapper\r\n *\r\n * @example\r\n * ```ts\r\n * const _count = signal(0);\r\n * const count = readonly(_count); // Expose read-only version\r\n *\r\n * console.log(count.value); // 0\r\n * count.value = 1; // TypeScript error: Cannot assign to 'value'\r\n * ```\r\n */\r\nexport const readonly = <T>(sig: Signal<T>): ReadonlySignal<T> => ({\r\n  get value(): T {\r\n    return sig.value;\r\n  },\r\n  peek(): T {\r\n    return sig.peek();\r\n  },\r\n});\r\n\r\n/**\r\n * Watches a signal or computed value and calls a callback with old and new values.\r\n * Unlike effect, watch provides access to the previous value.\r\n *\r\n * @template T - The type of the watched value\r\n * @param source - The signal or computed to watch\r\n * @param callback - Function called with (newValue, oldValue) on changes\r\n * @param options - Watch options\r\n * @returns A cleanup function to stop watching\r\n *\r\n * @example\r\n * ```ts\r\n * const count = signal(0);\r\n *\r\n * const cleanup = watch(count, (newVal, oldVal) => {\r\n *   console.log(`Changed from ${oldVal} to ${newVal}`);\r\n * });\r\n *\r\n * count.value = 5; // Logs: \"Changed from 0 to 5\"\r\n * cleanup();\r\n * ```\r\n */\r\nexport const watch = <T>(\r\n  source: Signal<T> | Computed<T>,\r\n  callback: (newValue: T, oldValue: T | undefined) => void,\r\n  options: { immediate?: boolean } = {}\r\n): CleanupFn => {\r\n  let oldValue: T | undefined;\r\n  let isFirst = true;\r\n\r\n  return effect(() => {\r\n    const newValue = source.value;\r\n\r\n    if (isFirst) {\r\n      isFirst = false;\r\n      oldValue = newValue;\r\n      if (options.immediate) {\r\n        callback(newValue, undefined);\r\n      }\r\n      return;\r\n    }\r\n\r\n    callback(newValue, oldValue);\r\n    oldValue = newValue;\r\n  });\r\n};\r\n\r\n/**\r\n * Executes a function without tracking any signal dependencies.\r\n * Useful when reading a signal value without creating a reactive dependency.\r\n *\r\n * @template T - The return type of the function\r\n * @param fn - The function to execute without tracking\r\n * @returns The result of the function\r\n *\r\n * @example\r\n * ```ts\r\n * const count = signal(0);\r\n *\r\n * effect(() => {\r\n *   // This creates a dependency\r\n *   console.log('Tracked:', count.value);\r\n *\r\n *   // This does NOT create a dependency\r\n *   const untracked = untrack(() => otherSignal.value);\r\n * });\r\n * ```\r\n */\r\nexport const untrack = <T>(fn: () => T): T => {\r\n  const prevTracking = trackingEnabled;\r\n  trackingEnabled = false;\r\n  try {\r\n    return fn();\r\n  } finally {\r\n    trackingEnabled = prevTracking;\r\n  }\r\n};\r\n\r\n/**\r\n * Type guard to check if a value is a Signal instance.\r\n *\r\n * @param value - The value to check\r\n * @returns True if the value is a Signal\r\n *\r\n * @example\r\n * ```ts\r\n * const count = signal(0);\r\n * const num = 42;\r\n *\r\n * isSignal(count); // true\r\n * isSignal(num);   // false\r\n * ```\r\n */\r\nexport const isSignal = (value: unknown): value is Signal<unknown> => value instanceof Signal;\r\n\r\n/**\r\n * Type guard to check if a value is a Computed instance.\r\n *\r\n * @param value - The value to check\r\n * @returns True if the value is a Computed\r\n *\r\n * @example\r\n * ```ts\r\n * const doubled = computed(() => count.value * 2);\r\n * isComputed(doubled); // true\r\n * ```\r\n */\r\nexport const isComputed = (value: unknown): value is Computed<unknown> => value instanceof Computed;\r\n"],"names":["observerStack","batchDepth","pendingObservers","trackingEnabled","track","observer","fn","scheduleObserver","flushObservers","Signal","_value","current","next","subscriber","updater","Computed","compute","signal","value","computed","effect","cleanupFn","isDisposed","batch","persistedSignal","key","initialValue","stored","raw","sig","readonly","watch","source","callback","options","oldValue","isFirst","newValue","untrack","prevTracking","isSignal","isComputed"],"mappings":"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"}
+{"version":3,"file":"reactive.es.mjs","sources":["../src/reactive/signal.ts"],"sourcesContent":["/**\r\n * Reactive primitives inspired by fine-grained reactivity.\r\n *\r\n * This module provides a minimal but powerful reactive system:\r\n * - Signal: A reactive value that notifies subscribers when changed\r\n * - Computed: A derived value that automatically updates when dependencies change\r\n * - Effect: A side effect that re-runs when its dependencies change\r\n * - Batch: Group multiple updates to prevent intermediate re-renders\r\n *\r\n * @module bquery/reactive\r\n *\r\n * @example\r\n * ```ts\r\n * const count = signal(0);\r\n * const doubled = computed(() => count.value * 2);\r\n *\r\n * effect(() => {\r\n *   console.log(`Count: ${count.value}, Doubled: ${doubled.value}`);\r\n * });\r\n *\r\n * batch(() => {\r\n *   count.value = 1;\r\n *   count.value = 2;\r\n * });\r\n * // Logs: \"Count: 2, Doubled: 4\" (only once due to batching)\r\n * ```\r\n */\r\n\r\n/**\r\n * Observer function type used internally for tracking reactivity.\r\n */\r\nexport type Observer = () => void;\r\n\r\n/**\r\n * Cleanup function returned by effects for disposal.\r\n */\r\nexport type CleanupFn = () => void;\r\n\r\n// Internal state for tracking the current observer context\r\nconst observerStack: Observer[] = [];\r\nlet batchDepth = 0;\r\nconst pendingObservers = new Set<Observer>();\r\n\r\n// Flag to disable tracking temporarily (for untrack)\r\nlet trackingEnabled = true;\r\n\r\n/**\r\n * Tracks dependencies during a function execution.\r\n * Uses direct push/pop for O(1) operations instead of array copying.\r\n * @internal\r\n */\r\nconst track = <T>(observer: Observer, fn: () => T): T => {\r\n  observerStack.push(observer);\r\n  try {\r\n    return fn();\r\n  } finally {\r\n    observerStack.pop();\r\n  }\r\n};\r\n\r\n/**\r\n * Schedules an observer to run, respecting batch mode.\r\n * @internal\r\n */\r\nconst scheduleObserver = (observer: Observer) => {\r\n  if (batchDepth > 0) {\r\n    pendingObservers.add(observer);\r\n    return;\r\n  }\r\n  observer();\r\n};\r\n\r\n/**\r\n * Flushes all pending observers after a batch completes.\r\n * @internal\r\n */\r\nconst flushObservers = () => {\r\n  for (const observer of Array.from(pendingObservers)) {\r\n    pendingObservers.delete(observer);\r\n    observer();\r\n  }\r\n};\r\n\r\n/**\r\n * A reactive value container that notifies subscribers on change.\r\n *\r\n * Signals are the foundational primitive of the reactive system.\r\n * Reading a signal's value inside an effect or computed automatically\r\n * establishes a reactive dependency.\r\n *\r\n * @template T - The type of the stored value\r\n *\r\n * @example\r\n * ```ts\r\n * const name = signal('World');\r\n * console.log(name.value); // 'World'\r\n *\r\n * name.value = 'bQuery';\r\n * console.log(name.value); // 'bQuery'\r\n * ```\r\n */\r\nexport class Signal<T> {\r\n  private subscribers = new Set<Observer>();\r\n\r\n  /**\r\n   * Creates a new signal with an initial value.\r\n   * @param _value - The initial value\r\n   */\r\n  constructor(private _value: T) {}\r\n\r\n  /**\r\n   * Gets the current value and tracks the read if inside an observer.\r\n   * Respects the global tracking state (disabled during untrack calls).\r\n   */\r\n  get value(): T {\r\n    if (trackingEnabled) {\r\n      const current = observerStack[observerStack.length - 1];\r\n      if (current) {\r\n        this.subscribers.add(current);\r\n      }\r\n    }\r\n    return this._value;\r\n  }\r\n\r\n  /**\r\n   * Sets a new value and notifies all subscribers if the value changed.\r\n   * Uses Object.is for equality comparison.\r\n   */\r\n  set value(next: T) {\r\n    if (Object.is(this._value, next)) return;\r\n    this._value = next;\r\n    for (const subscriber of this.subscribers) {\r\n      scheduleObserver(subscriber);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Reads the current value without tracking.\r\n   * Useful when you need the value but don't want to create a dependency.\r\n   *\r\n   * @returns The current value\r\n   */\r\n  peek(): T {\r\n    return this._value;\r\n  }\r\n\r\n  /**\r\n   * Updates the value using a function.\r\n   * Useful for updates based on the current value.\r\n   *\r\n   * @param updater - Function that receives current value and returns new value\r\n   */\r\n  update(updater: (current: T) => T): void {\r\n    this.value = updater(this._value);\r\n  }\r\n}\r\n\r\n/**\r\n * A computed value that derives from other reactive sources.\r\n *\r\n * Computed values are lazily evaluated and cached. They only\r\n * recompute when their dependencies change.\r\n *\r\n * @template T - The type of the computed value\r\n *\r\n * @example\r\n * ```ts\r\n * const price = signal(100);\r\n * const quantity = signal(2);\r\n * const total = computed(() => price.value * quantity.value);\r\n *\r\n * console.log(total.value); // 200\r\n * price.value = 150;\r\n * console.log(total.value); // 300\r\n * ```\r\n */\r\nexport class Computed<T> {\r\n  private cachedValue!: T;\r\n  private dirty = true;\r\n  private subscribers = new Set<Observer>();\r\n  private readonly markDirty = () => {\r\n    this.dirty = true;\r\n    for (const subscriber of this.subscribers) {\r\n      scheduleObserver(subscriber);\r\n    }\r\n  };\r\n\r\n  /**\r\n   * Creates a new computed value.\r\n   * @param compute - Function that computes the value\r\n   */\r\n  constructor(private readonly compute: () => T) {}\r\n\r\n  /**\r\n   * Gets the computed value, recomputing if dependencies changed.\r\n   */\r\n  get value(): T {\r\n    const current = observerStack[observerStack.length - 1];\r\n    if (current) {\r\n      this.subscribers.add(current);\r\n    }\r\n    if (this.dirty) {\r\n      this.dirty = false;\r\n      this.cachedValue = track(this.markDirty, this.compute);\r\n    }\r\n    return this.cachedValue;\r\n  }\r\n\r\n  /**\r\n   * Reads the current computed value without tracking.\r\n   * Useful when you need the value but don't want to create a dependency.\r\n   *\r\n   * @returns The current cached value (recomputes if dirty)\r\n   */\r\n  peek(): T {\r\n    if (this.dirty) {\r\n      this.dirty = false;\r\n      this.cachedValue = track(this.markDirty, this.compute);\r\n    }\r\n    return this.cachedValue;\r\n  }\r\n}\r\n\r\n/**\r\n * Creates a new reactive signal.\r\n *\r\n * @template T - The type of the signal value\r\n * @param value - The initial value\r\n * @returns A new Signal instance\r\n *\r\n * @example\r\n * ```ts\r\n * const count = signal(0);\r\n * count.value++; // Triggers subscribers\r\n * ```\r\n */\r\nexport const signal = <T>(value: T): Signal<T> => new Signal(value);\r\n\r\n/**\r\n * Creates a new computed value.\r\n *\r\n * @template T - The type of the computed value\r\n * @param fn - Function that computes the value from reactive sources\r\n * @returns A new Computed instance\r\n *\r\n * @example\r\n * ```ts\r\n * const doubled = computed(() => count.value * 2);\r\n * ```\r\n */\r\nexport const computed = <T>(fn: () => T): Computed<T> => new Computed(fn);\r\n\r\n/**\r\n * Creates a side effect that automatically re-runs when dependencies change.\r\n *\r\n * The effect runs immediately upon creation and then re-runs whenever\r\n * any signal or computed value read inside it changes.\r\n *\r\n * @param fn - The effect function to run\r\n * @returns A cleanup function to stop the effect\r\n *\r\n * @example\r\n * ```ts\r\n * const count = signal(0);\r\n *\r\n * const cleanup = effect(() => {\r\n *   document.title = `Count: ${count.value}`;\r\n * });\r\n *\r\n * // Later, to stop the effect:\r\n * cleanup();\r\n * ```\r\n */\r\nexport const effect = (fn: () => void | CleanupFn): CleanupFn => {\r\n  let cleanupFn: CleanupFn | void;\r\n  let isDisposed = false;\r\n\r\n  const observer: Observer = () => {\r\n    if (isDisposed) return;\r\n\r\n    // Run previous cleanup if exists\r\n    if (cleanupFn) {\r\n      cleanupFn();\r\n    }\r\n\r\n    // Run effect and capture cleanup\r\n    cleanupFn = track(observer, fn);\r\n  };\r\n\r\n  observer();\r\n\r\n  return () => {\r\n    isDisposed = true;\r\n    if (cleanupFn) {\r\n      cleanupFn();\r\n    }\r\n  };\r\n};\r\n\r\n/**\r\n * Batches multiple signal updates into a single notification cycle.\r\n *\r\n * Updates made inside the batch function are deferred until the batch\r\n * completes, preventing intermediate re-renders and improving performance.\r\n *\r\n * @param fn - Function containing multiple signal updates\r\n *\r\n * @example\r\n * ```ts\r\n * batch(() => {\r\n *   firstName.value = 'John';\r\n *   lastName.value = 'Doe';\r\n *   age.value = 30;\r\n * });\r\n * // Effects only run once with all three updates\r\n * ```\r\n */\r\nexport const batch = (fn: () => void): void => {\r\n  batchDepth += 1;\r\n  try {\r\n    fn();\r\n  } finally {\r\n    batchDepth -= 1;\r\n    if (batchDepth === 0) {\r\n      flushObservers();\r\n    }\r\n  }\r\n};\r\n\r\n/**\r\n * Creates a signal that persists to localStorage.\r\n *\r\n * @template T - The type of the signal value\r\n * @param key - The localStorage key\r\n * @param initialValue - The initial value if not found in storage\r\n * @returns A Signal that syncs with localStorage\r\n *\r\n * @example\r\n * ```ts\r\n * const theme = persistedSignal('theme', 'light');\r\n * theme.value = 'dark'; // Automatically saved to localStorage\r\n * ```\r\n */\r\nexport const persistedSignal = <T>(key: string, initialValue: T): Signal<T> => {\r\n  let stored: T = initialValue;\r\n\r\n  try {\r\n    const raw = localStorage.getItem(key);\r\n    if (raw !== null) {\r\n      stored = JSON.parse(raw) as T;\r\n    }\r\n  } catch {\r\n    // Use initial value on parse error\r\n  }\r\n\r\n  const sig = signal(stored);\r\n\r\n  // Create an effect to persist changes\r\n  effect(() => {\r\n    try {\r\n      localStorage.setItem(key, JSON.stringify(sig.value));\r\n    } catch {\r\n      // Ignore storage errors\r\n    }\r\n  });\r\n\r\n  return sig;\r\n};\r\n\r\n// ============================================================================\r\n// Extended Reactive Utilities\r\n// ============================================================================\r\n\r\n/**\r\n * A readonly wrapper around a signal that prevents writes.\r\n * Provides read-only access to a signal's value while maintaining reactivity.\r\n *\r\n * @template T - The type of the wrapped value\r\n */\r\nexport interface ReadonlySignal<T> {\r\n  /** Gets the current value with dependency tracking. */\r\n  readonly value: T;\r\n  /** Gets the current value without dependency tracking. */\r\n  peek(): T;\r\n}\r\n\r\n/**\r\n * Creates a read-only view of a signal.\r\n * Useful for exposing reactive state without allowing modifications.\r\n *\r\n * @template T - The type of the signal value\r\n * @param sig - The signal to wrap\r\n * @returns A readonly signal wrapper\r\n *\r\n * @example\r\n * ```ts\r\n * const _count = signal(0);\r\n * const count = readonly(_count); // Expose read-only version\r\n *\r\n * console.log(count.value); // 0\r\n * count.value = 1; // TypeScript error: Cannot assign to 'value'\r\n * ```\r\n */\r\nexport const readonly = <T>(sig: Signal<T>): ReadonlySignal<T> => ({\r\n  get value(): T {\r\n    return sig.value;\r\n  },\r\n  peek(): T {\r\n    return sig.peek();\r\n  },\r\n});\r\n\r\n/**\r\n * Watches a signal or computed value and calls a callback with old and new values.\r\n * Unlike effect, watch provides access to the previous value.\r\n *\r\n * @template T - The type of the watched value\r\n * @param source - The signal or computed to watch\r\n * @param callback - Function called with (newValue, oldValue) on changes\r\n * @param options - Watch options\r\n * @returns A cleanup function to stop watching\r\n *\r\n * @example\r\n * ```ts\r\n * const count = signal(0);\r\n *\r\n * const cleanup = watch(count, (newVal, oldVal) => {\r\n *   console.log(`Changed from ${oldVal} to ${newVal}`);\r\n * });\r\n *\r\n * count.value = 5; // Logs: \"Changed from 0 to 5\"\r\n * cleanup();\r\n * ```\r\n */\r\nexport const watch = <T>(\r\n  source: Signal<T> | Computed<T>,\r\n  callback: (newValue: T, oldValue: T | undefined) => void,\r\n  options: { immediate?: boolean } = {}\r\n): CleanupFn => {\r\n  let oldValue: T | undefined;\r\n  let isFirst = true;\r\n\r\n  return effect(() => {\r\n    const newValue = source.value;\r\n\r\n    if (isFirst) {\r\n      isFirst = false;\r\n      oldValue = newValue;\r\n      if (options.immediate) {\r\n        callback(newValue, undefined);\r\n      }\r\n      return;\r\n    }\r\n\r\n    callback(newValue, oldValue);\r\n    oldValue = newValue;\r\n  });\r\n};\r\n\r\n/**\r\n * Executes a function without tracking any signal dependencies.\r\n * Useful when reading a signal value without creating a reactive dependency.\r\n *\r\n * @template T - The return type of the function\r\n * @param fn - The function to execute without tracking\r\n * @returns The result of the function\r\n *\r\n * @example\r\n * ```ts\r\n * const count = signal(0);\r\n *\r\n * effect(() => {\r\n *   // This creates a dependency\r\n *   console.log('Tracked:', count.value);\r\n *\r\n *   // This does NOT create a dependency\r\n *   const untracked = untrack(() => otherSignal.value);\r\n * });\r\n * ```\r\n */\r\nexport const untrack = <T>(fn: () => T): T => {\r\n  const prevTracking = trackingEnabled;\r\n  trackingEnabled = false;\r\n  try {\r\n    return fn();\r\n  } finally {\r\n    trackingEnabled = prevTracking;\r\n  }\r\n};\r\n\r\n/**\r\n * Type guard to check if a value is a Signal instance.\r\n *\r\n * @param value - The value to check\r\n * @returns True if the value is a Signal\r\n *\r\n * @example\r\n * ```ts\r\n * const count = signal(0);\r\n * const num = 42;\r\n *\r\n * isSignal(count); // true\r\n * isSignal(num);   // false\r\n * ```\r\n */\r\nexport const isSignal = (value: unknown): value is Signal<unknown> => value instanceof Signal;\r\n\r\n/**\r\n * Type guard to check if a value is a Computed instance.\r\n *\r\n * @param value - The value to check\r\n * @returns True if the value is a Computed\r\n *\r\n * @example\r\n * ```ts\r\n * const doubled = computed(() => count.value * 2);\r\n * isComputed(doubled); // true\r\n * ```\r\n */\r\nexport const isComputed = (value: unknown): value is Computed<unknown> => value instanceof Computed;\r\n"],"names":["observerStack","batchDepth","pendingObservers","trackingEnabled","track","observer","fn","scheduleObserver","flushObservers","Signal","_value","current","next","subscriber","updater","Computed","compute","signal","value","computed","effect","cleanupFn","isDisposed","batch","persistedSignal","key","initialValue","stored","raw","sig","readonly","watch","source","callback","options","oldValue","isFirst","newValue","untrack","prevTracking","isSignal","isComputed"],"mappings":"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"}

package/dist/router/index.d.ts

@@ -0,0 +1,287 @@
+/**
+ * Minimal SPA router with History API integration.
+ *
+ * This module provides a lightweight, signal-based router for single-page
+ * applications. Features include:
+ * - History API navigation
+ * - Route matching with params and wildcards
+ * - Lazy route loading
+ * - Navigation guards (beforeEach, afterEach)
+ * - Reactive current route via signals
+ * - Multi-value query params (e.g., `?tag=a&tag=b` → `{ tag: ['a', 'b'] }`)
+ *
+ * @module bquery/router
+ *
+ * @example
+ * ```ts
+ * import { createRouter, navigate, currentRoute } from 'bquery/router';
+ * import { effect } from 'bquery/reactive';
+ *
+ * const router = createRouter({
+ *   routes: [
+ *     { path: '/', component: () => import('./Home') },
+ *     { path: '/user/:id', component: () => import('./User') },
+ *     { path: '*', component: () => import('./NotFound') },
+ *   ],
+ * });
+ *
+ * effect(() => {
+ *   console.log('Route changed:', currentRoute.value);
+ * });
+ *
+ * navigate('/user/42');
+ * ```
+ */
+import { type ReadonlySignal } from '../reactive/index';
+/**
+ * Represents a parsed route with matched params.
+ */
+export type Route = {
+    /** The current path (e.g., '/user/42') */
+    path: string;
+    /** Extracted route params (e.g., { id: '42' }) */
+    params: Record<string, string>;
+    /**
+     * Query string params.
+     * Each key maps to a single string value by default.
+     * Only keys that appear multiple times in the query string become arrays.
+     * @example
+     * // ?foo=1 → { foo: '1' }
+     * // ?tag=a&tag=b → { tag: ['a', 'b'] }
+     * // ?x=1&y=2&x=3 → { x: ['1', '3'], y: '2' }
+     */
+    query: Record<string, string | string[]>;
+    /** The matched route definition */
+    matched: RouteDefinition | null;
+    /** Hash fragment without # */
+    hash: string;
+};
+/**
+ * Route definition for configuration.
+ */
+export type RouteDefinition = {
+    /** Path pattern (e.g., '/user/:id', '/posts/*') */
+    path: string;
+    /** Component loader (sync or async) */
+    component: () => unknown | Promise<unknown>;
+    /** Optional route name for programmatic navigation */
+    name?: string;
+    /** Optional metadata */
+    meta?: Record<string, unknown>;
+    /** Nested child routes */
+    children?: RouteDefinition[];
+};
+/**
+ * Router configuration options.
+ */
+export type RouterOptions = {
+    /** Array of route definitions */
+    routes: RouteDefinition[];
+    /** Base path for all routes (default: '') */
+    base?: string;
+    /** Use hash-based routing instead of history (default: false) */
+    hash?: boolean;
+};
+/**
+ * Navigation guard function type.
+ */
+export type NavigationGuard = (to: Route, from: Route) => boolean | void | Promise<boolean | void>;
+/**
+ * Router instance returned by createRouter.
+ */
+export type Router = {
+    /** Navigate to a path */
+    push: (path: string) => Promise<void>;
+    /** Replace current history entry */
+    replace: (path: string) => Promise<void>;
+    /** Go back in history */
+    back: () => void;
+    /** Go forward in history */
+    forward: () => void;
+    /** Go to a specific history entry */
+    go: (delta: number) => void;
+    /** Add a beforeEach guard */
+    beforeEach: (guard: NavigationGuard) => () => void;
+    /** Add an afterEach hook */
+    afterEach: (hook: (to: Route, from: Route) => void) => () => void;
+    /** Current route (reactive) */
+    currentRoute: ReadonlySignal<Route>;
+    /** All route definitions */
+    routes: RouteDefinition[];
+    /** Destroy the router and cleanup listeners */
+    destroy: () => void;
+};
+/**
+ * Reactive signal containing the current route.
+ *
+ * @example
+ * ```ts
+ * import { currentRoute } from 'bquery/router';
+ * import { effect } from 'bquery/reactive';
+ *
+ * effect(() => {
+ *   document.title = `Page: ${currentRoute.value.path}`;
+ * });
+ * ```
+ */
+export declare const currentRoute: ReadonlySignal<Route>;
+/**
+ * Navigates to a new path.
+ *
+ * @param path - The path to navigate to
+ * @param options - Navigation options
+ *
+ * @example
+ * ```ts
+ * import { navigate } from 'bquery/router';
+ *
+ * // Push to history
+ * await navigate('/dashboard');
+ *
+ * // Replace current entry
+ * await navigate('/login', { replace: true });
+ * ```
+ */
+export declare const navigate: (path: string, options?: {
+    replace?: boolean;
+}) => Promise<void>;
+/**
+ * Programmatically go back in history.
+ *
+ * @example
+ * ```ts
+ * import { back } from 'bquery/router';
+ * back();
+ * ```
+ */
+export declare const back: () => void;
+/**
+ * Programmatically go forward in history.
+ *
+ * @example
+ * ```ts
+ * import { forward } from 'bquery/router';
+ * forward();
+ * ```
+ */
+export declare const forward: () => void;
+/**
+ * Creates and initializes a router instance.
+ *
+ * @param options - Router configuration
+ * @returns The router instance
+ *
+ * @example
+ * ```ts
+ * import { createRouter } from 'bquery/router';
+ *
+ * const router = createRouter({
+ *   routes: [
+ *     { path: '/', component: () => import('./pages/Home') },
+ *     { path: '/about', component: () => import('./pages/About') },
+ *     { path: '/user/:id', component: () => import('./pages/User') },
+ *     { path: '*', component: () => import('./pages/NotFound') },
+ *   ],
+ *   base: '/app',
+ * });
+ *
+ * router.beforeEach((to, from) => {
+ *   if (to.path === '/admin' && !isAuthenticated()) {
+ *     return false; // Cancel navigation
+ *   }
+ * });
+ * ```
+ */
+export declare const createRouter: (options: RouterOptions) => Router;
+/**
+ * Resolves a route by name and params.
+ *
+ * @param name - The route name
+ * @param params - Route params to interpolate
+ * @returns The resolved path
+ *
+ * @example
+ * ```ts
+ * import { resolve } from 'bquery/router';
+ *
+ * const path = resolve('user', { id: '42' });
+ * // Returns '/user/42' if route is defined as { name: 'user', path: '/user/:id' }
+ * ```
+ */
+export declare const resolve: (name: string, params?: Record<string, string>) => string;
+/**
+ * Checks if a path matches the current route.
+ *
+ * @param path - Path to check
+ * @param exact - Whether to match exactly (default: false)
+ * @returns True if the path matches
+ *
+ * @example
+ * ```ts
+ * import { isActive } from 'bquery/router';
+ *
+ * if (isActive('/dashboard')) {
+ *   // Highlight nav item
+ * }
+ * ```
+ */
+export declare const isActive: (path: string, exact?: boolean) => boolean;
+/**
+ * Creates a computed signal that checks if a path is active.
+ *
+ * @param path - Path to check
+ * @param exact - Whether to match exactly
+ * @returns A reactive signal
+ *
+ * @example
+ * ```ts
+ * import { isActiveSignal } from 'bquery/router';
+ * import { effect } from 'bquery/reactive';
+ *
+ * const dashboardActive = isActiveSignal('/dashboard');
+ * effect(() => {
+ *   navItem.classList.toggle('active', dashboardActive.value);
+ * });
+ * ```
+ */
+export declare const isActiveSignal: (path: string, exact?: boolean) => ReadonlySignal<boolean>;
+/**
+ * Creates click handler for router links.
+ * Attach to anchor elements to enable client-side navigation.
+ *
+ * @param path - Target path
+ * @param options - Navigation options
+ * @returns Click event handler
+ *
+ * @example
+ * ```ts
+ * import { link } from 'bquery/router';
+ * import { $ } from 'bquery/core';
+ *
+ * $('#nav-home').on('click', link('/'));
+ * $('#nav-about').on('click', link('/about'));
+ * ```
+ */
+export declare const link: (path: string, options?: {
+    replace?: boolean;
+}) => ((e: Event) => void);
+/**
+ * Intercepts all link clicks within a container for client-side routing.
+ * Only intercepts links with matching origins and no target attribute.
+ *
+ * @param container - The container element to intercept links in
+ * @returns Cleanup function to remove the listener
+ *
+ * @example
+ * ```ts
+ * import { interceptLinks } from 'bquery/router';
+ *
+ * // Intercept all links in the app
+ * const cleanup = interceptLinks(document.body);
+ *
+ * // Later, remove the interceptor
+ * cleanup();
+ * ```
+ */
+export declare const interceptLinks: (container?: Element) => (() => void);
+//# sourceMappingURL=index.d.ts.map

package/dist/router/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/router/index.ts"],"names":[],"mappings":"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"}