sibujs 4.5.0 → 4.7.0

package/dist/data.d.cts

@@ -1,3 +1,5 @@
+import { D as DisposableAccessor } from './signal-EotCj4hS.cjs';
+
 /**
  * Configurable retry strategies for async operations.
  * Used by `resource` and `query` for automatic error recovery.
@@ -55,6 +57,43 @@ declare function calculateDelay(attempt: number, strategy: "exponential" | "line
  */
 declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions, onRetry?: (error: unknown, attempt: number, delay: number) => void, signal?: AbortSignal): Promise<T>;
 
+/**
+ * Structural sharing for the data layer.
+ *
+ * A refetch almost always produces a brand-new object graph, even when the
+ * server sent back exactly what it sent last time. Committing that graph to a
+ * signal notifies every subscriber — signals compare with `Object.is` — so a
+ * background refresh that changed nothing still re-ran every binding reading
+ * the data, and a `when(() => q.data(), …)` or a `() => q.data() && Form()`
+ * child rebuilt its subtree and threw away whatever the user was typing.
+ *
+ * `replaceEqualDeep(prev, next)` reconciles the new graph against the old one:
+ *
+ * - deeply equal → returns `prev` itself, so the signal write is a no-op and
+ *   nothing is notified;
+ * - partially equal → returns a new container in which every unchanged
+ *   subtree is the OLD reference, so an `each()` keyed by reference, a
+ *   `derived` over one branch, or an `equals`-less signal holding a sub-object
+ *   stays stable while only the changed path gets fresh identities.
+ *
+ * Only plain objects (prototype `Object.prototype` or `null`) and arrays are
+ * reconciled. Everything else — Date, Map, Set, class instances — is opaque
+ * and compared by identity: its enumerable keys say nothing about its state,
+ * and rebuilding it as a plain object would change its type.
+ *
+ * Internal to the data layer; not re-exported from `data.ts`.
+ */
+/**
+ * The public knob shared by `query()` and `resource()`.
+ *
+ * - `true` (default) — reconcile with {@link replaceEqualDeep}.
+ * - `false` — commit every result as-is (a fresh reference notifies).
+ * - a function — custom reconciliation. It receives the previously committed
+ *   value and the new one and returns what to commit; returning `prev` means
+ *   "unchanged" and notifies nobody.
+ */
+type StructuralSharingOption<T> = boolean | ((prev: T, next: T) => T);
+
 /**
  * ## Callback semantics
  *
@@ -116,8 +155,52 @@ interface QueryOptions<T> {
     onError?: (error: Error) => void;
     /** Called on fetch settle (success or error) */
     onSettled?: () => void;
-    /** Transform fetched data before returning to consumers. Cache stores raw data. */
+    /**
+     * Transform fetched data before returning to consumers. Cache stores raw data.
+     *
+     * Runs in this observer's own reactive computation: it re-runs when the
+     * cached value changes, and when a signal it reads changes — without
+     * re-running the key effect, so such a signal never triggers a refetch. It
+     * runs once per fetch that changed the data, and its output is structurally
+     * shared against this observer's previous output for the same key, so an
+     * identical refetch notifies nobody.
+     */
     select?: (data: T) => T;
+    /**
+     * Keep data referentially stable across refetches. Default: `true`.
+     *
+     * Every refetch — `refetchInterval`, window focus, reconnect,
+     * `invalidateQueries` — produces a new object graph even when the server
+     * returned the same thing. With structural sharing on, the new result is
+     * reconciled against the previous value of the same key: if it is deeply
+     * equal the previous reference is kept and `data` subscribers are not
+     * notified at all; if only part of it changed, every unchanged nested object
+     * or array keeps its old reference, so `each()` rows and deriveds over
+     * untouched branches stay put. Only plain objects and arrays are compared —
+     * Date, Map, Set and class instances compare by identity. Cyclic data is
+     * safe: the containers on a cycle are taken as-is.
+     *
+     * Every observer of a key using the default holds the SAME reference.
+     *
+     * `setQueryData()` is an explicit write, not a fetch: when it hands over a
+     * new top-level reference, observers always receive a new top-level
+     * reference and are notified — even if every child is unchanged, as after
+     * `prev.items.push(x); return { ...prev }`. Unchanged nested subtrees are
+     * still reused beneath it.
+     *
+     * The option applies to this observer only; observers of one key may use
+     * different settings.
+     *
+     * - `false` commits every result as-is (each refetch notifies).
+     * - A function `(prev, next) => T` replaces the default reconciliation;
+     *   `prev` is this observer's previous value for the same key. Return `prev`
+     *   to report "unchanged" (ignored for an explicit write of a new
+     *   reference). It must not throw — if it does, the error is reported and
+     *   `next` is committed unshared.
+     *
+     * Also applied to this observer's `select` output.
+     */
+    structuralSharing?: StructuralSharingOption<T>;
 }
 interface QueryResult<T> {
     /** Reactive getter for the cached data */
@@ -141,9 +224,20 @@ declare function query<T>(key: string | (() => string), fetcher: (ctx: {
 }) => Promise<T>, options?: QueryOptions<T>): QueryResult<T>;
 /** Invalidate queries matching a key or predicate, triggering refetch for active subscribers */
 declare function invalidateQueries(keyOrPredicate: string | ((key: string) => boolean)): void;
-/** Get cached data for a query key */
+/**
+ * Get cached data for a query key — the same reference every observer using
+ * the default `structuralSharing` holds.
+ */
 declare function getQueryData<T>(key: string): T | undefined;
-/** Set cached data for a query key, notifying subscribers */
+/**
+ * Set cached data for a query key, notifying subscribers.
+ *
+ * An explicit write: a value (or updater result) that is a new top-level
+ * reference reaches every observer as a new top-level reference, even when it
+ * is deeply equal to the previous value — so `prev.items.push(x); return
+ * { ...prev }` is never dropped. Unchanged nested subtrees are still reused.
+ * Returning `prev` itself changes nothing.
+ */
 declare function setQueryData<T>(key: string, data: T | ((prev: T | undefined) => T)): void;
 /** Clear the entire query cache */
 declare function clearQueryCache(): void;
@@ -278,7 +372,8 @@ declare function infiniteQuery<TData, TPageParam = number>(key: string | (() =>
  * Returns `undefined` on first read (there is no previous value yet).
  *
  * @param getter A reactive getter to track
- * @returns A reactive getter for the previous value
+ * @returns A reactive getter for the previous value, with `dispose()` to stop
+ *   tracking the source
  *
  * @example
  * ```ts
@@ -291,7 +386,7 @@ declare function infiniteQuery<TData, TPageParam = number>(key: string | (() =>
  * prev(); // 5
  * ```
  */
-declare function previous<T>(getter: () => T): () => T | undefined;
+declare function previous<T>(getter: () => T): DisposableAccessor<T | undefined>;
 
 /**
  * Returns a debounced reactive getter that only updates after `delay` ms
@@ -299,7 +394,8 @@ declare function previous<T>(getter: () => T): () => T | undefined;
  *
  * @param getter A reactive getter to debounce
  * @param delay Debounce delay in milliseconds
- * @returns A reactive getter for the debounced value
+ * @returns A reactive getter for the debounced value, with `dispose()` to stop
+ *   tracking the source and cancel the pending timer
  *
  * @example
  * ```ts
@@ -308,7 +404,7 @@ declare function previous<T>(getter: () => T): () => T | undefined;
  * // debouncedSearch() only updates 300ms after the last setSearch call
  * ```
  */
-declare function debounce<T>(getter: () => T, delay: number): () => T;
+declare function debounce<T>(getter: () => T, delay: number): DisposableAccessor<T>;
 
 /**
  * Returns a throttled reactive getter that updates at most once per `interval` ms.
@@ -317,7 +413,8 @@ declare function debounce<T>(getter: () => T, delay: number): () => T;
  *
  * @param getter A reactive getter to throttle
  * @param interval Throttle interval in milliseconds
- * @returns A reactive getter for the throttled value
+ * @returns A reactive getter for the throttled value, with `dispose()` to stop
+ *   tracking the source and clear the cooldown timer
  *
  * @example
  * ```ts
@@ -326,7 +423,7 @@ declare function debounce<T>(getter: () => T, delay: number): () => T;
  * // throttled() updates at most once every 100ms
  * ```
  */
-declare function throttle<T>(getter: () => T, interval: number): () => T;
+declare function throttle<T>(getter: () => T, interval: number): DisposableAccessor<T>;
 
 /**
  * Lifecycle callbacks follow the shared data-layer contract: an exception
@@ -349,6 +446,30 @@ interface ResourceOptions<T> {
     onError?: (error: Error) => void;
     /** Called on fetch settle (success or error) */
     onSettled?: () => void;
+    /**
+     * Keep data referentially stable across refetches. Default: `true`.
+     *
+     * Each fetched result — from `refetch()` or a source change — is
+     * reconciled against the value already held: a deeply equal result keeps
+     * the previous reference and notifies nobody, and a partially changed one
+     * reuses every unchanged nested object or array. Only plain objects and
+     * arrays are compared; Date, Map, Set and class instances compare by
+     * identity. Cyclic data is safe: the containers on a cycle are taken as-is.
+     * Same contract as `QueryOptions.structuralSharing`.
+     *
+     * `mutate()` is an explicit write, not a fetch: when it hands over a new
+     * top-level reference, `data` always becomes a new top-level reference and
+     * notifies — even if every child is unchanged, as after
+     * `prev.items.push(x); return { ...prev }`. Unchanged nested subtrees are
+     * still reused beneath it.
+     *
+     * - `false` commits every result as-is.
+     * - A function `(prev, next) => T` replaces the default reconciliation;
+     *   return `prev` to report "unchanged" (ignored for a `mutate()` of a new
+     *   reference). If it throws, the error is reported and `next` is committed
+     *   unshared.
+     */
+    structuralSharing?: StructuralSharingOption<T>;
 }
 interface Resource<T> {
     /** Reactive getter for the fetched data */
@@ -527,14 +648,47 @@ interface LoaderRoute {
 }
 /**
  * Execute a route loader and wrap its result in a reactive Resource.
+ *
+ * Executing a loader does not make its data visible to `loaderData()`; render
+ * the route's component inside {@link renderWithLoader} (or use
+ * {@link withLoader}) so the component reads its own route's data.
  */
 declare function executeLoader<T>(loader: RouteLoaderFn<T>, context: {
     params: Record<string, string>;
     path: string;
 }, options?: ResourceOptions<T>): Resource<T>;
 /**
- * Access loader data from within a route component.
- * Must be called inside a component rendered by a route with a loader.
+ * Run `render` with `loader` as the loader data seen by `loaderData()`, then
+ * restore the previous scope — even if `render` throws. Scopes nest: an inner
+ * call shadows the outer one only for its own duration.
+ *
+ * `loaderData()` must be called synchronously while `render` runs (typically at
+ * the top of the component); the accessors it returns stay bound to `loader`
+ * afterwards.
+ *
+ * @example
+ * ```ts
+ * const data = executeLoader(route.loader, ctx);
+ * const view = renderWithLoader(data, () => route.component());
+ * ```
+ */
+declare function renderWithLoader<T, R>(loader: Resource<T>, render: () => R): R;
+/**
+ * Execute `loader` and render with its data in scope, in one step. Returns the
+ * rendered result together with the resource, which the caller disposes when
+ * the route unmounts.
+ */
+declare function withLoader<T, R>(loader: RouteLoaderFn<T>, context: {
+    params: Record<string, string>;
+    path: string;
+}, render: () => R, options?: ResourceOptions<T>): {
+    view: R;
+    resource: Resource<T>;
+};
+/**
+ * Access loader data from within a route component: the innermost
+ * {@link renderWithLoader} scope (per SSR request on the server). Throws when
+ * called outside such a scope, or when that scope's loader has been disposed.
  */
 declare function loaderData<T = unknown>(): {
     data: () => T | undefined;
@@ -596,4 +750,4 @@ declare function stream(url: string, options?: {
     dispose: () => void;
 };
 
-export { type ConflictStrategy, type InfiniteQueryOptions, type InfiniteQueryResult, type LoaderRoute, type MutationOptions, type MutationResult, type OfflineStore, type OfflineStoreOptions, type QueryOptions, type QueryResult, type Resource, type ResourceOptions, type RetryOptions, type RouteLoaderFn, type SyncAdapter, type SyncChange, type SyncConflict, type SyncResult, __resetQueryCache, calculateDelay, clearQueryCache, debounce, executeLoader, getQueryData, infiniteQuery, invalidateQueries, loaderData, mutation, offlineStore, preloadRoute, previous, query, resource, setQueryData, socket, stream, syncAdapter, throttle, withRetry };
+export { type ConflictStrategy, type InfiniteQueryOptions, type InfiniteQueryResult, type LoaderRoute, type MutationOptions, type MutationResult, type OfflineStore, type OfflineStoreOptions, type QueryOptions, type QueryResult, type Resource, type ResourceOptions, type RetryOptions, type RouteLoaderFn, type SyncAdapter, type SyncChange, type SyncConflict, type SyncResult, __resetQueryCache, calculateDelay, clearQueryCache, debounce, executeLoader, getQueryData, infiniteQuery, invalidateQueries, loaderData, mutation, offlineStore, preloadRoute, previous, query, renderWithLoader, resource, setQueryData, socket, stream, syncAdapter, throttle, withLoader, withRetry };

package/dist/data.d.ts

@@ -1,3 +1,5 @@
+import { D as DisposableAccessor } from './signal-EotCj4hS.js';
+
 /**
  * Configurable retry strategies for async operations.
  * Used by `resource` and `query` for automatic error recovery.
@@ -55,6 +57,43 @@ declare function calculateDelay(attempt: number, strategy: "exponential" | "line
  */
 declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions, onRetry?: (error: unknown, attempt: number, delay: number) => void, signal?: AbortSignal): Promise<T>;
 
+/**
+ * Structural sharing for the data layer.
+ *
+ * A refetch almost always produces a brand-new object graph, even when the
+ * server sent back exactly what it sent last time. Committing that graph to a
+ * signal notifies every subscriber — signals compare with `Object.is` — so a
+ * background refresh that changed nothing still re-ran every binding reading
+ * the data, and a `when(() => q.data(), …)` or a `() => q.data() && Form()`
+ * child rebuilt its subtree and threw away whatever the user was typing.
+ *
+ * `replaceEqualDeep(prev, next)` reconciles the new graph against the old one:
+ *
+ * - deeply equal → returns `prev` itself, so the signal write is a no-op and
+ *   nothing is notified;
+ * - partially equal → returns a new container in which every unchanged
+ *   subtree is the OLD reference, so an `each()` keyed by reference, a
+ *   `derived` over one branch, or an `equals`-less signal holding a sub-object
+ *   stays stable while only the changed path gets fresh identities.
+ *
+ * Only plain objects (prototype `Object.prototype` or `null`) and arrays are
+ * reconciled. Everything else — Date, Map, Set, class instances — is opaque
+ * and compared by identity: its enumerable keys say nothing about its state,
+ * and rebuilding it as a plain object would change its type.
+ *
+ * Internal to the data layer; not re-exported from `data.ts`.
+ */
+/**
+ * The public knob shared by `query()` and `resource()`.
+ *
+ * - `true` (default) — reconcile with {@link replaceEqualDeep}.
+ * - `false` — commit every result as-is (a fresh reference notifies).
+ * - a function — custom reconciliation. It receives the previously committed
+ *   value and the new one and returns what to commit; returning `prev` means
+ *   "unchanged" and notifies nobody.
+ */
+type StructuralSharingOption<T> = boolean | ((prev: T, next: T) => T);
+
 /**
  * ## Callback semantics
  *
@@ -116,8 +155,52 @@ interface QueryOptions<T> {
     onError?: (error: Error) => void;
     /** Called on fetch settle (success or error) */
     onSettled?: () => void;
-    /** Transform fetched data before returning to consumers. Cache stores raw data. */
+    /**
+     * Transform fetched data before returning to consumers. Cache stores raw data.
+     *
+     * Runs in this observer's own reactive computation: it re-runs when the
+     * cached value changes, and when a signal it reads changes — without
+     * re-running the key effect, so such a signal never triggers a refetch. It
+     * runs once per fetch that changed the data, and its output is structurally
+     * shared against this observer's previous output for the same key, so an
+     * identical refetch notifies nobody.
+     */
     select?: (data: T) => T;
+    /**
+     * Keep data referentially stable across refetches. Default: `true`.
+     *
+     * Every refetch — `refetchInterval`, window focus, reconnect,
+     * `invalidateQueries` — produces a new object graph even when the server
+     * returned the same thing. With structural sharing on, the new result is
+     * reconciled against the previous value of the same key: if it is deeply
+     * equal the previous reference is kept and `data` subscribers are not
+     * notified at all; if only part of it changed, every unchanged nested object
+     * or array keeps its old reference, so `each()` rows and deriveds over
+     * untouched branches stay put. Only plain objects and arrays are compared —
+     * Date, Map, Set and class instances compare by identity. Cyclic data is
+     * safe: the containers on a cycle are taken as-is.
+     *
+     * Every observer of a key using the default holds the SAME reference.
+     *
+     * `setQueryData()` is an explicit write, not a fetch: when it hands over a
+     * new top-level reference, observers always receive a new top-level
+     * reference and are notified — even if every child is unchanged, as after
+     * `prev.items.push(x); return { ...prev }`. Unchanged nested subtrees are
+     * still reused beneath it.
+     *
+     * The option applies to this observer only; observers of one key may use
+     * different settings.
+     *
+     * - `false` commits every result as-is (each refetch notifies).
+     * - A function `(prev, next) => T` replaces the default reconciliation;
+     *   `prev` is this observer's previous value for the same key. Return `prev`
+     *   to report "unchanged" (ignored for an explicit write of a new
+     *   reference). It must not throw — if it does, the error is reported and
+     *   `next` is committed unshared.
+     *
+     * Also applied to this observer's `select` output.
+     */
+    structuralSharing?: StructuralSharingOption<T>;
 }
 interface QueryResult<T> {
     /** Reactive getter for the cached data */
@@ -141,9 +224,20 @@ declare function query<T>(key: string | (() => string), fetcher: (ctx: {
 }) => Promise<T>, options?: QueryOptions<T>): QueryResult<T>;
 /** Invalidate queries matching a key or predicate, triggering refetch for active subscribers */
 declare function invalidateQueries(keyOrPredicate: string | ((key: string) => boolean)): void;
-/** Get cached data for a query key */
+/**
+ * Get cached data for a query key — the same reference every observer using
+ * the default `structuralSharing` holds.
+ */
 declare function getQueryData<T>(key: string): T | undefined;
-/** Set cached data for a query key, notifying subscribers */
+/**
+ * Set cached data for a query key, notifying subscribers.
+ *
+ * An explicit write: a value (or updater result) that is a new top-level
+ * reference reaches every observer as a new top-level reference, even when it
+ * is deeply equal to the previous value — so `prev.items.push(x); return
+ * { ...prev }` is never dropped. Unchanged nested subtrees are still reused.
+ * Returning `prev` itself changes nothing.
+ */
 declare function setQueryData<T>(key: string, data: T | ((prev: T | undefined) => T)): void;
 /** Clear the entire query cache */
 declare function clearQueryCache(): void;
@@ -278,7 +372,8 @@ declare function infiniteQuery<TData, TPageParam = number>(key: string | (() =>
  * Returns `undefined` on first read (there is no previous value yet).
  *
  * @param getter A reactive getter to track
- * @returns A reactive getter for the previous value
+ * @returns A reactive getter for the previous value, with `dispose()` to stop
+ *   tracking the source
  *
  * @example
  * ```ts
@@ -291,7 +386,7 @@ declare function infiniteQuery<TData, TPageParam = number>(key: string | (() =>
  * prev(); // 5
  * ```
  */
-declare function previous<T>(getter: () => T): () => T | undefined;
+declare function previous<T>(getter: () => T): DisposableAccessor<T | undefined>;
 
 /**
  * Returns a debounced reactive getter that only updates after `delay` ms
@@ -299,7 +394,8 @@ declare function previous<T>(getter: () => T): () => T | undefined;
  *
  * @param getter A reactive getter to debounce
  * @param delay Debounce delay in milliseconds
- * @returns A reactive getter for the debounced value
+ * @returns A reactive getter for the debounced value, with `dispose()` to stop
+ *   tracking the source and cancel the pending timer
  *
  * @example
  * ```ts
@@ -308,7 +404,7 @@ declare function previous<T>(getter: () => T): () => T | undefined;
  * // debouncedSearch() only updates 300ms after the last setSearch call
  * ```
  */
-declare function debounce<T>(getter: () => T, delay: number): () => T;
+declare function debounce<T>(getter: () => T, delay: number): DisposableAccessor<T>;
 
 /**
  * Returns a throttled reactive getter that updates at most once per `interval` ms.
@@ -317,7 +413,8 @@ declare function debounce<T>(getter: () => T, delay: number): () => T;
  *
  * @param getter A reactive getter to throttle
  * @param interval Throttle interval in milliseconds
- * @returns A reactive getter for the throttled value
+ * @returns A reactive getter for the throttled value, with `dispose()` to stop
+ *   tracking the source and clear the cooldown timer
  *
  * @example
  * ```ts
@@ -326,7 +423,7 @@ declare function debounce<T>(getter: () => T, delay: number): () => T;
  * // throttled() updates at most once every 100ms
  * ```
  */
-declare function throttle<T>(getter: () => T, interval: number): () => T;
+declare function throttle<T>(getter: () => T, interval: number): DisposableAccessor<T>;
 
 /**
  * Lifecycle callbacks follow the shared data-layer contract: an exception
@@ -349,6 +446,30 @@ interface ResourceOptions<T> {
     onError?: (error: Error) => void;
     /** Called on fetch settle (success or error) */
     onSettled?: () => void;
+    /**
+     * Keep data referentially stable across refetches. Default: `true`.
+     *
+     * Each fetched result — from `refetch()` or a source change — is
+     * reconciled against the value already held: a deeply equal result keeps
+     * the previous reference and notifies nobody, and a partially changed one
+     * reuses every unchanged nested object or array. Only plain objects and
+     * arrays are compared; Date, Map, Set and class instances compare by
+     * identity. Cyclic data is safe: the containers on a cycle are taken as-is.
+     * Same contract as `QueryOptions.structuralSharing`.
+     *
+     * `mutate()` is an explicit write, not a fetch: when it hands over a new
+     * top-level reference, `data` always becomes a new top-level reference and
+     * notifies — even if every child is unchanged, as after
+     * `prev.items.push(x); return { ...prev }`. Unchanged nested subtrees are
+     * still reused beneath it.
+     *
+     * - `false` commits every result as-is.
+     * - A function `(prev, next) => T` replaces the default reconciliation;
+     *   return `prev` to report "unchanged" (ignored for a `mutate()` of a new
+     *   reference). If it throws, the error is reported and `next` is committed
+     *   unshared.
+     */
+    structuralSharing?: StructuralSharingOption<T>;
 }
 interface Resource<T> {
     /** Reactive getter for the fetched data */
@@ -527,14 +648,47 @@ interface LoaderRoute {
 }
 /**
  * Execute a route loader and wrap its result in a reactive Resource.
+ *
+ * Executing a loader does not make its data visible to `loaderData()`; render
+ * the route's component inside {@link renderWithLoader} (or use
+ * {@link withLoader}) so the component reads its own route's data.
  */
 declare function executeLoader<T>(loader: RouteLoaderFn<T>, context: {
     params: Record<string, string>;
     path: string;
 }, options?: ResourceOptions<T>): Resource<T>;
 /**
- * Access loader data from within a route component.
- * Must be called inside a component rendered by a route with a loader.
+ * Run `render` with `loader` as the loader data seen by `loaderData()`, then
+ * restore the previous scope — even if `render` throws. Scopes nest: an inner
+ * call shadows the outer one only for its own duration.
+ *
+ * `loaderData()` must be called synchronously while `render` runs (typically at
+ * the top of the component); the accessors it returns stay bound to `loader`
+ * afterwards.
+ *
+ * @example
+ * ```ts
+ * const data = executeLoader(route.loader, ctx);
+ * const view = renderWithLoader(data, () => route.component());
+ * ```
+ */
+declare function renderWithLoader<T, R>(loader: Resource<T>, render: () => R): R;
+/**
+ * Execute `loader` and render with its data in scope, in one step. Returns the
+ * rendered result together with the resource, which the caller disposes when
+ * the route unmounts.
+ */
+declare function withLoader<T, R>(loader: RouteLoaderFn<T>, context: {
+    params: Record<string, string>;
+    path: string;
+}, render: () => R, options?: ResourceOptions<T>): {
+    view: R;
+    resource: Resource<T>;
+};
+/**
+ * Access loader data from within a route component: the innermost
+ * {@link renderWithLoader} scope (per SSR request on the server). Throws when
+ * called outside such a scope, or when that scope's loader has been disposed.
  */
 declare function loaderData<T = unknown>(): {
     data: () => T | undefined;
@@ -596,4 +750,4 @@ declare function stream(url: string, options?: {
     dispose: () => void;
 };
 
-export { type ConflictStrategy, type InfiniteQueryOptions, type InfiniteQueryResult, type LoaderRoute, type MutationOptions, type MutationResult, type OfflineStore, type OfflineStoreOptions, type QueryOptions, type QueryResult, type Resource, type ResourceOptions, type RetryOptions, type RouteLoaderFn, type SyncAdapter, type SyncChange, type SyncConflict, type SyncResult, __resetQueryCache, calculateDelay, clearQueryCache, debounce, executeLoader, getQueryData, infiniteQuery, invalidateQueries, loaderData, mutation, offlineStore, preloadRoute, previous, query, resource, setQueryData, socket, stream, syncAdapter, throttle, withRetry };
+export { type ConflictStrategy, type InfiniteQueryOptions, type InfiniteQueryResult, type LoaderRoute, type MutationOptions, type MutationResult, type OfflineStore, type OfflineStoreOptions, type QueryOptions, type QueryResult, type Resource, type ResourceOptions, type RetryOptions, type RouteLoaderFn, type SyncAdapter, type SyncChange, type SyncConflict, type SyncResult, __resetQueryCache, calculateDelay, clearQueryCache, debounce, executeLoader, getQueryData, infiniteQuery, invalidateQueries, loaderData, mutation, offlineStore, preloadRoute, previous, query, renderWithLoader, resource, setQueryData, socket, stream, syncAdapter, throttle, withLoader, withRetry };

package/dist/data.js

@@ -13,23 +13,24 @@ import {
   preloadRoute,
   previous,
   query,
+  renderWithLoader,
   resource,
   setQueryData,
   socket,
   stream,
   syncAdapter,
   throttle,
+  withLoader,
   withRetry
-} from "./chunk-3JZ4L5TJ.js";
-import "./chunk-VUF4ALSW.js";
-import "./chunk-RBTPLM32.js";
-import "./chunk-IXKSNWV5.js";
+} from "./chunk-WOLJZUFQ.js";
+import "./chunk-RUSSKG6G.js";
+import "./chunk-2INLLLMZ.js";
 import "./chunk-7ZHH77QA.js";
-import "./chunk-RIXRAYIU.js";
-import "./chunk-5DXA2J44.js";
-import "./chunk-XZZOBQAY.js";
-import "./chunk-UGRX3S57.js";
-import "./chunk-2WLZ6757.js";
+import "./chunk-WEQ3DMVL.js";
+import "./chunk-7XHATCIH.js";
+import "./chunk-FQRUXCEE.js";
+import "./chunk-JWKYU5GV.js";
+import "./chunk-NYNYSPK7.js";
 export {
   __resetQueryCache,
   calculateDelay,
@@ -45,11 +46,13 @@ export {
   preloadRoute,
   previous,
   query,
+  renderWithLoader,
   resource,
   setQueryData,
   socket,
   stream,
   syncAdapter,
   throttle,
+  withLoader,
   withRetry
 };