@bquery/bquery 1.4.0 → 1.6.0

package/src/reactive/core.ts

@@ -1,114 +1,114 @@
-/**
- * Core reactive signals.
- */
-
-import {
-  getCurrentObserver,
-  registerDependency,
-  removeDependency,
-  scheduleObserver,
-  type ReactiveSource,
-} from './internals';
-
-/**
- * A reactive value container that notifies subscribers on change.
- *
- * Signals are the foundational primitive of the reactive system.
- * Reading a signal's value inside an effect or computed automatically
- * establishes a reactive dependency.
- *
- * @template T - The type of the stored value
- */
-export class Signal<T> implements ReactiveSource {
-  private subscribers = new Set<() => void>();
-
-  /**
-   * Creates a new signal with an initial value.
-   * @param _value - The initial value
-   */
-  constructor(private _value: T) {}
-
-  /**
-   * Gets the current value and tracks the read if inside an observer.
-   * During untrack calls, getCurrentObserver returns undefined, preventing dependency tracking.
-   */
-  get value(): T {
-    const current = getCurrentObserver();
-    if (current) {
-      this.subscribers.add(current);
-      registerDependency(current, this);
-    }
-    return this._value;
-  }
-
-  /**
-   * Sets a new value and notifies all subscribers if the value changed.
-   * Uses Object.is for equality comparison.
-   */
-  set value(next: T) {
-    if (Object.is(this._value, next)) return;
-    this._value = next;
-    // Create snapshot to avoid issues with subscribers modifying the set during iteration
-    const subscribersSnapshot = Array.from(this.subscribers);
-    for (const subscriber of subscribersSnapshot) {
-      scheduleObserver(subscriber);
-    }
-  }
-
-  /**
-   * Reads the current value without tracking.
-   * Useful when you need the value but don't want to create a dependency.
-   *
-   * @returns The current value
-   */
-  peek(): T {
-    return this._value;
-  }
-
-  /**
-   * Updates the value using a function.
-   * Useful for updates based on the current value.
-   *
-   * @param updater - Function that receives current value and returns new value
-   */
-  update(updater: (current: T) => T): void {
-    this.value = updater(this._value);
-  }
-
-  /**
-   * Removes all subscribers from this signal.
-   * Use this when a signal is no longer needed to prevent memory leaks.
-   *
-   * @example
-   * ```ts
-   * const count = signal(0);
-   * effect(() => console.log(count.value));
-   * count.dispose(); // All subscribers removed
-   * ```
-   */
-  dispose(): void {
-    // Remove this signal from each subscriber's dependency set
-    // so the observer no longer holds a strong reference to it
-    for (const subscriber of this.subscribers) {
-      removeDependency(subscriber, this);
-    }
-    this.subscribers.clear();
-  }
-
-  /**
-   * Removes an observer from this signal's subscriber set.
-   * @internal
-   */
-  unsubscribe(observer: () => void): void {
-    this.subscribers.delete(observer);
-  }
-}
-
-/**
- * Creates a new reactive signal.
- *
- * @template T - The type of the signal value
- * @param value - The initial value
- * @returns A new Signal instance
- */
-export const signal = <T>(value: T): Signal<T> => new Signal(value);
+/**
+ * Core reactive signals.
+ */
+
+import {
+  getCurrentObserver,
+  registerDependency,
+  removeDependency,
+  scheduleObserver,
+  type ReactiveSource,
+} from './internals';
+
+/**
+ * A reactive value container that notifies subscribers on change.
+ *
+ * Signals are the foundational primitive of the reactive system.
+ * Reading a signal's value inside an effect or computed automatically
+ * establishes a reactive dependency.
+ *
+ * @template T - The type of the stored value
+ */
+export class Signal<T> implements ReactiveSource {
+  private subscribers = new Set<() => void>();
+
+  /**
+   * Creates a new signal with an initial value.
+   * @param _value - The initial value
+   */
+  constructor(private _value: T) {}
+
+  /**
+   * Gets the current value and tracks the read if inside an observer.
+   * During untrack calls, getCurrentObserver returns undefined, preventing dependency tracking.
+   */
+  get value(): T {
+    const current = getCurrentObserver();
+    if (current) {
+      this.subscribers.add(current);
+      registerDependency(current, this);
+    }
+    return this._value;
+  }
+
+  /**
+   * Sets a new value and notifies all subscribers if the value changed.
+   * Uses Object.is for equality comparison.
+   */
+  set value(next: T) {
+    if (Object.is(this._value, next)) return;
+    this._value = next;
+    // Create snapshot to avoid issues with subscribers modifying the set during iteration
+    const subscribersSnapshot = Array.from(this.subscribers);
+    for (const subscriber of subscribersSnapshot) {
+      scheduleObserver(subscriber);
+    }
+  }
+
+  /**
+   * Reads the current value without tracking.
+   * Useful when you need the value but don't want to create a dependency.
+   *
+   * @returns The current value
+   */
+  peek(): T {
+    return this._value;
+  }
+
+  /**
+   * Updates the value using a function.
+   * Useful for updates based on the current value.
+   *
+   * @param updater - Function that receives current value and returns new value
+   */
+  update(updater: (current: T) => T): void {
+    this.value = updater(this._value);
+  }
+
+  /**
+   * Removes all subscribers from this signal.
+   * Use this when a signal is no longer needed to prevent memory leaks.
+   *
+   * @example
+   * ```ts
+   * const count = signal(0);
+   * effect(() => console.log(count.value));
+   * count.dispose(); // All subscribers removed
+   * ```
+   */
+  dispose(): void {
+    // Remove this signal from each subscriber's dependency set
+    // so the observer no longer holds a strong reference to it
+    for (const subscriber of this.subscribers) {
+      removeDependency(subscriber, this);
+    }
+    this.subscribers.clear();
+  }
+
+  /**
+   * Removes an observer from this signal's subscriber set.
+   * @internal
+   */
+  unsubscribe(observer: () => void): void {
+    this.subscribers.delete(observer);
+  }
+}
+
+/**
+ * Creates a new reactive signal.
+ *
+ * @template T - The type of the signal value
+ * @param value - The initial value
+ * @returns A new Signal instance
+ */
+export const signal = <T>(value: T): Signal<T> => new Signal(value);

package/src/reactive/effect.ts

@@ -1,54 +1,54 @@
-/**
- * Reactive effects.
- */
-
-import { CleanupFn, Observer, track, clearDependencies } from './internals';
-
-/**
- * Creates a side effect that automatically re-runs when dependencies change.
- *
- * The effect runs immediately upon creation and then re-runs whenever
- * any signal or computed value read inside it changes.
- *
- * @param fn - The effect function to run
- * @returns A cleanup function to stop the effect
- */
-export const effect = (fn: () => void | CleanupFn): CleanupFn => {
-  let cleanupFn: CleanupFn | void;
-  let isDisposed = false;
-
-  const runCleanup = (): void => {
-    if (cleanupFn) {
-      try {
-        cleanupFn();
-      } catch (error) {
-        console.error('bQuery reactive: Error in effect cleanup', error);
-      }
-      cleanupFn = undefined;
-    }
-  };
-
-  const observer: Observer = () => {
-    if (isDisposed) return;
-
-    runCleanup();
-
-    // Clear old dependencies before running to avoid stale subscriptions
-    clearDependencies(observer);
-
-    try {
-      cleanupFn = track(observer, fn);
-    } catch (error) {
-      console.error('bQuery reactive: Error in effect', error);
-    }
-  };
-
-  observer();
-
-  return () => {
-    isDisposed = true;
-    runCleanup();
-    // Clean up all dependencies when effect is disposed
-    clearDependencies(observer);
-  };
-};
+/**
+ * Reactive effects.
+ */
+
+import { CleanupFn, Observer, track, clearDependencies } from './internals';
+
+/**
+ * Creates a side effect that automatically re-runs when dependencies change.
+ *
+ * The effect runs immediately upon creation and then re-runs whenever
+ * any signal or computed value read inside it changes.
+ *
+ * @param fn - The effect function to run
+ * @returns A cleanup function to stop the effect
+ */
+export const effect = (fn: () => void | CleanupFn): CleanupFn => {
+  let cleanupFn: CleanupFn | void;
+  let isDisposed = false;
+
+  const runCleanup = (): void => {
+    if (cleanupFn) {
+      try {
+        cleanupFn();
+      } catch (error) {
+        console.error('bQuery reactive: Error in effect cleanup', error);
+      }
+      cleanupFn = undefined;
+    }
+  };
+
+  const observer: Observer = () => {
+    if (isDisposed) return;
+
+    runCleanup();
+
+    // Clear old dependencies before running to avoid stale subscriptions
+    clearDependencies(observer);
+
+    try {
+      cleanupFn = track(observer, fn);
+    } catch (error) {
+      console.error('bQuery reactive: Error in effect', error);
+    }
+  };
+
+  observer();
+
+  return () => {
+    isDisposed = true;
+    runCleanup();
+    // Clean up all dependencies when effect is disposed
+    clearDependencies(observer);
+  };
+};

package/src/reactive/index.ts

@@ -9,6 +9,7 @@ export {
   Signal,
   batch,
   computed,
+  createUseFetch,
   effect,
   isComputed,
   isSignal,
@@ -16,8 +17,21 @@ export {
   persistedSignal,
   readonly,
   signal,
+  useAsyncData,
+  useFetch,
   untrack,
   watch,
 } from './signal';
 
-export type { CleanupFn, LinkedSignal, Observer, ReadonlySignal } from './signal';
+export type {
+  AsyncDataState,
+  AsyncDataStatus,
+  AsyncWatchSource,
+  CleanupFn,
+  FetchInput,
+  LinkedSignal,
+  Observer,
+  ReadonlySignal,
+  UseAsyncDataOptions,
+  UseFetchOptions,
+} from './signal';

package/src/reactive/internals.ts

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

package/src/reactive/signal.ts

@@ -5,6 +5,7 @@
  */
 
 export { batch } from './batch';
+export { createUseFetch, useAsyncData, useFetch } from './async-data';
 export { Computed, computed } from './computed';
 export { Signal, signal } from './core';
 export { effect } from './effect';
@@ -16,5 +17,13 @@ export { untrack } from './untrack';
 export { watch } from './watch';
 
 export type { CleanupFn, Observer } from './internals';
+export type {
+  AsyncDataState,
+  AsyncDataStatus,
+  AsyncWatchSource,
+  FetchInput,
+  UseAsyncDataOptions,
+  UseFetchOptions,
+} from './async-data';
 export type { LinkedSignal } from './linked';
 export type { ReadonlySignal } from './readonly';

package/src/security/constants.ts

@@ -116,7 +116,9 @@ export const DANGEROUS_TAGS = new Set([
   'style',
   'base',
   'template',
-  'slot',
+  // 'slot' is intentionally excluded here so component shadow markup can opt in
+  // via sanitizeHtml(..., { allowTags: ['slot'] }). It remains disallowed by default
+  // for general HTML writes, because DEFAULT_ALLOWED_TAGS does not include it.
   'math',
   'svg',
   'foreignobject',

package/src/security/index.ts

@@ -1,10 +1,17 @@
-/**
- * Security module providing sanitization, CSP compatibility, and Trusted Types.
- *
- * @module bquery/security
- */
-
-export { generateNonce, hasCSPDirective } from './csp';
-export { escapeHtml, sanitizeHtml as sanitize, sanitizeHtml, stripTags } from './sanitize';
-export { createTrustedHtml, getTrustedTypesPolicy, isTrustedTypesSupported } from './trusted-types';
-export type { SanitizeOptions } from './types';
+/**
+ * Security module providing sanitization, CSP compatibility, and Trusted Types.
+ *
+ * @module bquery/security
+ */
+
+export { generateNonce, hasCSPDirective } from './csp';
+export {
+  escapeHtml,
+  sanitizeHtml as sanitize,
+  sanitizeHtml,
+  stripTags,
+} from './sanitize';
+export { trusted } from './trusted-html';
+export { createTrustedHtml, getTrustedTypesPolicy, isTrustedTypesSupported } from './trusted-types';
+export type { SanitizedHtml, TrustedHtml } from './trusted-html';
+export type { SanitizeOptions } from './sanitize';