@tanstack/react-db 0.5.12 → 1.0.0-rc.1

package/dist/cjs/live-query-internals.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"live-query-internals.cjs","sources":["../../src/live-query-internals.ts"],"sourcesContent":["import type {\n  DbClient,\n  LiveQueryObserver,\n  UnhashableQueryIRError,\n} from '@tanstack/db'\n\nconst liveQueryResultInfo = Symbol(`liveQueryResultInfo`)\n\nexport type LiveQueryResultInfo = {\n  client: DbClient | undefined\n  queryHash: string | undefined\n  identityError: UnhashableQueryIRError | undefined\n  observer: LiveQueryObserver<object, string | number>\n}\n\ntype ResultWithInfo = {\n  [liveQueryResultInfo]?: LiveQueryResultInfo\n}\n\nexport function setLiveQueryResultInfo(\n  result: object,\n  info: LiveQueryResultInfo,\n): void {\n  Object.defineProperty(result, liveQueryResultInfo, {\n    configurable: true,\n    value: info,\n  })\n}\n\nexport function getLiveQueryResultInfo(result: object): LiveQueryResultInfo {\n  const info = (result as ResultWithInfo)[liveQueryResultInfo]\n  if (!info) {\n    throw new Error(`Missing internal live query result information.`)\n  }\n  return info\n}\n"],"names":[],"mappings":";;AAMA,MAAM,6CAA6B,qBAAqB;AAajD,SAAS,uBACd,QACA,MACM;AACN,SAAO,eAAe,QAAQ,qBAAqB;AAAA,IACjD,cAAc;AAAA,IACd,OAAO;AAAA,EAAA,CACR;AACH;AAEO,SAAS,uBAAuB,QAAqC;AAC1E,QAAM,OAAQ,OAA0B,mBAAmB;AAC3D,MAAI,CAAC,MAAM;AACT,UAAM,IAAI,MAAM,iDAAiD;AAAA,EACnE;AACA,SAAO;AACT;;;"}
+{"version":3,"file":"live-query-internals.cjs","sources":["../../src/live-query-internals.ts"],"sourcesContent":["import type {\n  DbClient,\n  DeferredLiveQueryCollections,\n  LiveQueryObserver,\n  UnhashableQueryIRError,\n} from '@tanstack/db'\n\nconst liveQueryResultInfo = Symbol(`liveQueryResultInfo`)\n\nexport type LiveQueryResultInfo = {\n  client: DbClient | undefined\n  queryHash: string | undefined\n  identityError: UnhashableQueryIRError | undefined\n  observer: LiveQueryObserver<object, string | number>\n  /** Sync starts this render deferred, released if the render throws. */\n  deferredCollections: DeferredLiveQueryCollections\n}\n\ntype ResultWithInfo = {\n  [liveQueryResultInfo]?: LiveQueryResultInfo\n}\n\nexport function setLiveQueryResultInfo(\n  result: object,\n  info: LiveQueryResultInfo,\n): void {\n  Object.defineProperty(result, liveQueryResultInfo, {\n    configurable: true,\n    value: info,\n  })\n}\n\nexport function getLiveQueryResultInfo(result: object): LiveQueryResultInfo {\n  const info = (result as ResultWithInfo)[liveQueryResultInfo]\n  if (!info) {\n    throw new Error(`Missing internal live query result information.`)\n  }\n  return info\n}\n"],"names":[],"mappings":";;AAOA,MAAM,6CAA6B,qBAAqB;AAejD,SAAS,uBACd,QACA,MACM;AACN,SAAO,eAAe,QAAQ,qBAAqB;AAAA,IACjD,cAAc;AAAA,IACd,OAAO;AAAA,EAAA,CACR;AACH;AAEO,SAAS,uBAAuB,QAAqC;AAC1E,QAAM,OAAQ,OAA0B,mBAAmB;AAC3D,MAAI,CAAC,MAAM;AACT,UAAM,IAAI,MAAM,iDAAiD;AAAA,EACnE;AACA,SAAO;AACT;;;"}

package/dist/cjs/live-query-internals.d.cts

@@ -1,9 +1,11 @@
-import { DbClient, LiveQueryObserver, UnhashableQueryIRError } from '@tanstack/db';
+import { DbClient, DeferredLiveQueryCollections, LiveQueryObserver, UnhashableQueryIRError } from '@tanstack/db';
 export type LiveQueryResultInfo = {
     client: DbClient | undefined;
     queryHash: string | undefined;
     identityError: UnhashableQueryIRError | undefined;
     observer: LiveQueryObserver<object, string | number>;
+    /** Sync starts this render deferred, released if the render throws. */
+    deferredCollections: DeferredLiveQueryCollections;
 };
 export declare function setLiveQueryResultInfo(result: object, info: LiveQueryResultInfo): void;
 export declare function getLiveQueryResultInfo(result: object): LiveQueryResultInfo;

package/dist/cjs/source-id-bindings.cjs

@@ -1,53 +1,20 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const db = require("@tanstack/db");
-const sourceObjectTokens = /* @__PURE__ */ new WeakMap();
-let nextSourceObjectToken = 0;
-function getSourceObjectToken(source) {
-  let id = sourceObjectTokens.get(source);
-  if (id === void 0) {
-    id = ++nextSourceObjectToken;
-    sourceObjectTokens.set(source, id);
-  }
-  return id;
+function getUnboundDescriptorReporter(client, hookName) {
+  if (client) return void 0;
+  return (alias) => {
+    throw new Error(
+      `[${hookName}] Collection descriptor "${alias}" requires a DbClient when the query is consumed. Wrap this component in <DbProvider client={client}> or use a concrete Collection.`
+    );
+  };
 }
 function getPreparedSources(preparedValue, client, hookName) {
   return db.getPreparedLiveQuerySources(
     preparedValue,
-    !client && hookName ? (alias) => {
-      throw new Error(
-        `[${hookName}] Collection descriptor "${alias}" requires a DbClient when the query is consumed. Wrap this component in <DbProvider client={client}> or use a concrete Collection.`
-      );
-    } : void 0
+    getUnboundDescriptorReporter(client, hookName)
   );
 }
-function createSourceIdBindings() {
-  return { unscoped: /* @__PURE__ */ new Map(), byClient: /* @__PURE__ */ new WeakMap() };
-}
-function claimSourceIds(bindings, preparedValue, client, hookName, release) {
-  const prior = client ? bindings.byClient.get(client) : bindings.unscoped;
-  const seen = /* @__PURE__ */ new Map();
-  for (const source of getPreparedSources(preparedValue, client, hookName)) {
-    const token = getSourceObjectToken(source);
-    const previous = seen.get(source.id) ?? prior?.get(source.id);
-    if (previous !== void 0 && previous !== token) {
-      release();
-      throw new Error(
-        `[${hookName}] Source Collection "${source.id}" was replaced by a different Collection with the same ID while this hook is mounted. Unmount the hook and clean up its previous source and client scope before reusing the ID.`
-      );
-    }
-    seen.set(source.id, token);
-  }
-  const claimed = prior ?? /* @__PURE__ */ new Map();
-  for (const [id, token] of seen) claimed.set(id, token);
-  if (client) bindings.byClient.set(client, claimed);
-}
-Object.defineProperty(exports, "resumeSyncStarts", {
-  enumerable: true,
-  get: () => db.resumeDeferredLiveQueryCollections
-});
-exports.claimSourceIds = claimSourceIds;
-exports.createSourceIdBindings = createSourceIdBindings;
 exports.getPreparedSources = getPreparedSources;
-exports.getSourceObjectToken = getSourceObjectToken;
+exports.getUnboundDescriptorReporter = getUnboundDescriptorReporter;
 //# sourceMappingURL=source-id-bindings.cjs.map

package/dist/cjs/source-id-bindings.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"source-id-bindings.cjs","sources":["../../src/source-id-bindings.ts"],"sourcesContent":["import { getPreparedLiveQuerySources } from '@tanstack/db'\nimport type { DbClient } from '@tanstack/db'\n\nexport { resumeDeferredLiveQueryCollections as resumeSyncStarts } from '@tanstack/db'\n\nconst sourceObjectTokens = new WeakMap<object, number>()\nlet nextSourceObjectToken = 0\n\nexport function getSourceObjectToken(source: object): number {\n  let id = sourceObjectTokens.get(source)\n  if (id === undefined) {\n    id = ++nextSourceObjectToken\n    sourceObjectTokens.set(source, id)\n  }\n  return id\n}\n\nexport function getPreparedSources(\n  preparedValue: unknown,\n  client?: DbClient,\n  hookName?: string,\n): Array<{ id: string }> {\n  return getPreparedLiveQuerySources(\n    preparedValue,\n    !client && hookName\n      ? (alias) => {\n          throw new Error(\n            `[${hookName}] Collection descriptor \"${alias}\" requires a DbClient when the query is consumed. Wrap this component in <DbProvider client={client}> or use a concrete Collection.`,\n          )\n        }\n      : undefined,\n  )\n}\n\n/** The source object each Collection ID named while one hook is mounted. */\nexport type SourceIdBindings = {\n  unscoped: Map<string, number>\n  byClient: WeakMap<DbClient, Map<string, number>>\n}\n\nexport function createSourceIdBindings(): SourceIdBindings {\n  return { unscoped: new Map(), byClient: new WeakMap() }\n}\n\n/**\n * Derived query identity names each source by its Collection ID. While a hook\n * is mounted, an ID must keep naming one source object in each client scope,\n * or the hook could reuse a live query that reads the old source. Claims the\n * prepared value's sources, or calls `release` and throws on a collision so a\n * rejected render keeps no sync-start deferral.\n */\nexport function claimSourceIds(\n  bindings: SourceIdBindings,\n  preparedValue: unknown,\n  client: DbClient | undefined,\n  hookName: string,\n  release: () => void,\n): void {\n  const prior = client ? bindings.byClient.get(client) : bindings.unscoped\n  const seen = new Map<string, number>()\n  for (const source of getPreparedSources(preparedValue, client, hookName)) {\n    const token = getSourceObjectToken(source)\n    const previous = seen.get(source.id) ?? prior?.get(source.id)\n    if (previous !== undefined && previous !== token) {\n      release()\n      throw new Error(\n        `[${hookName}] Source Collection \"${source.id}\" was replaced by a different Collection with the same ID while this hook is mounted. Unmount the hook and clean up its previous source and client scope before reusing the ID.`,\n      )\n    }\n    seen.set(source.id, token)\n  }\n  const claimed = prior ?? new Map<string, number>()\n  for (const [id, token] of seen) claimed.set(id, token)\n  if (client) bindings.byClient.set(client, claimed)\n}\n"],"names":["getPreparedLiveQuerySources"],"mappings":";;;AAKA,MAAM,yCAAyB,QAAA;AAC/B,IAAI,wBAAwB;AAErB,SAAS,qBAAqB,QAAwB;AAC3D,MAAI,KAAK,mBAAmB,IAAI,MAAM;AACtC,MAAI,OAAO,QAAW;AACpB,SAAK,EAAE;AACP,uBAAmB,IAAI,QAAQ,EAAE;AAAA,EACnC;AACA,SAAO;AACT;AAEO,SAAS,mBACd,eACA,QACA,UACuB;AACvB,SAAOA,GAAAA;AAAAA,IACL;AAAA,IACA,CAAC,UAAU,WACP,CAAC,UAAU;AACT,YAAM,IAAI;AAAA,QACR,IAAI,QAAQ,4BAA4B,KAAK;AAAA,MAAA;AAAA,IAEjD,IACA;AAAA,EAAA;AAER;AAQO,SAAS,yBAA2C;AACzD,SAAO,EAAE,UAAU,oBAAI,IAAA,GAAO,UAAU,oBAAI,UAAQ;AACtD;AASO,SAAS,eACd,UACA,eACA,QACA,UACA,SACM;AACN,QAAM,QAAQ,SAAS,SAAS,SAAS,IAAI,MAAM,IAAI,SAAS;AAChE,QAAM,2BAAW,IAAA;AACjB,aAAW,UAAU,mBAAmB,eAAe,QAAQ,QAAQ,GAAG;AACxE,UAAM,QAAQ,qBAAqB,MAAM;AACzC,UAAM,WAAW,KAAK,IAAI,OAAO,EAAE,KAAK,OAAO,IAAI,OAAO,EAAE;AAC5D,QAAI,aAAa,UAAa,aAAa,OAAO;AAChD,cAAA;AACA,YAAM,IAAI;AAAA,QACR,IAAI,QAAQ,wBAAwB,OAAO,EAAE;AAAA,MAAA;AAAA,IAEjD;AACA,SAAK,IAAI,OAAO,IAAI,KAAK;AAAA,EAC3B;AACA,QAAM,UAAU,SAAS,oBAAI,IAAA;AAC7B,aAAW,CAAC,IAAI,KAAK,KAAK,KAAM,SAAQ,IAAI,IAAI,KAAK;AACrD,MAAI,OAAQ,UAAS,SAAS,IAAI,QAAQ,OAAO;AACnD;;;;;;;;;"}
+{"version":3,"file":"source-id-bindings.cjs","sources":["../../src/source-id-bindings.ts"],"sourcesContent":["import { getPreparedLiveQuerySources } from '@tanstack/db'\nimport type { DbClient } from '@tanstack/db'\n\n/**\n * Reports a descriptor source that no DbClient bound, naming the provider a\n * React tree needs. Returns `undefined` when a client can bind descriptors.\n */\nexport function getUnboundDescriptorReporter(\n  client: DbClient | undefined,\n  hookName: string,\n): ((alias: string) => never) | undefined {\n  if (client) return undefined\n  return (alias) => {\n    throw new Error(\n      `[${hookName}] Collection descriptor \"${alias}\" requires a DbClient when the query is consumed. Wrap this component in <DbProvider client={client}> or use a concrete Collection.`,\n    )\n  }\n}\n\nexport function getPreparedSources(\n  preparedValue: unknown,\n  client: DbClient | undefined,\n  hookName: string,\n): Array<{ id: string }> {\n  return getPreparedLiveQuerySources(\n    preparedValue,\n    getUnboundDescriptorReporter(client, hookName),\n  )\n}\n"],"names":["getPreparedLiveQuerySources"],"mappings":";;;AAOO,SAAS,6BACd,QACA,UACwC;AACxC,MAAI,OAAQ,QAAO;AACnB,SAAO,CAAC,UAAU;AAChB,UAAM,IAAI;AAAA,MACR,IAAI,QAAQ,4BAA4B,KAAK;AAAA,IAAA;AAAA,EAEjD;AACF;AAEO,SAAS,mBACd,eACA,QACA,UACuB;AACvB,SAAOA,GAAAA;AAAAA,IACL;AAAA,IACA,6BAA6B,QAAQ,QAAQ;AAAA,EAAA;AAEjD;;;"}

package/dist/cjs/source-id-bindings.d.cts

@@ -1,20 +1,9 @@
 import { DbClient } from '@tanstack/db';
-export { resumeDeferredLiveQueryCollections as resumeSyncStarts } from '@tanstack/db';
-export declare function getSourceObjectToken(source: object): number;
-export declare function getPreparedSources(preparedValue: unknown, client?: DbClient, hookName?: string): Array<{
-    id: string;
-}>;
-/** The source object each Collection ID named while one hook is mounted. */
-export type SourceIdBindings = {
-    unscoped: Map<string, number>;
-    byClient: WeakMap<DbClient, Map<string, number>>;
-};
-export declare function createSourceIdBindings(): SourceIdBindings;
 /**
- * Derived query identity names each source by its Collection ID. While a hook
- * is mounted, an ID must keep naming one source object in each client scope,
- * or the hook could reuse a live query that reads the old source. Claims the
- * prepared value's sources, or calls `release` and throws on a collision so a
- * rejected render keeps no sync-start deferral.
+ * Reports a descriptor source that no DbClient bound, naming the provider a
+ * React tree needs. Returns `undefined` when a client can bind descriptors.
  */
-export declare function claimSourceIds(bindings: SourceIdBindings, preparedValue: unknown, client: DbClient | undefined, hookName: string, release: () => void): void;
+export declare function getUnboundDescriptorReporter(client: DbClient | undefined, hookName: string): ((alias: string) => never) | undefined;
+export declare function getPreparedSources(preparedValue: unknown, client: DbClient | undefined, hookName: string): Array<{
+    id: string;
+}>;

package/dist/cjs/useLiveInfiniteQuery.cjs

@@ -4,205 +4,126 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const react = require("react");
 const db = require("@tanstack/db");
 const DbProvider = require("./DbProvider.cjs");
-const sourceIdBindings = require("./source-id-bindings.cjs");
 const useLiveQuery = require("./useLiveQuery.cjs");
-const DEFAULT_GC_TIME_MS = 1;
 const unpreparedQueryValue = /* @__PURE__ */ Symbol(`unpreparedQueryValue`);
-function queryIdentityMatches(comparison, sameClient, usesLegacyDeps) {
-  return sameClient && (usesLegacyDeps ? !comparison.changed : comparison.structurallyEqual);
-}
-function useLiveInfiniteQuery(queryFnOrCollection, config, deps) {
-  if (`getNextPageParam` in config) {
-    throw new Error(
-      `getNextPageParam is not supported by useLiveInfiniteQuery. Use an on-demand collection and fulfill meta.loadSubsetOptions in queryFn for server pagination.`
-    );
-  }
-  const pageSize = db.normalizeLiveQueryWindowPageSize(config.pageSize);
-  const initialPageParam = config.initialPageParam ?? 0;
+function useLiveInfiniteQuery(queryFnOrCollection, config) {
+  const pageShape = db.readLiveQueryWindowPageShape(config);
   const contextDbClient = DbProvider.useOptionalDbClient();
   const dbClient = config.client ?? contextDbClient;
-  const inputIsCollection = db.getLiveQueryWindowInputKind(queryFnOrCollection) === `collection`;
+  const inputIsCollection = db.isCollection(queryFnOrCollection);
   const committedRef = react.useRef(null);
   const committed = committedRef.current;
-  const renderedCollectionRef = react.useRef(null);
+  const renderedRef = react.useRef(null);
   const sourceIdsRef = react.useRef(null);
-  const inputKind = inputIsCollection ? `collection` : `query`;
   const derivedIdentityProfilerRef = react.useRef({
     renderCount: 0,
     totalMs: 0,
     maxMs: 0,
     warned: false
   });
-  const legacyUnhashableIdentityRef = react.useRef([
-    `legacy-unhashable`
-  ]);
   const deferredCollections = /* @__PURE__ */ new Set();
+  const identityScope = () => useLiveQuery.getIdentityScope(
+    sourceIdsRef.current ??= db.createLiveQuerySourceIdClaims(),
+    dbClient,
+    `useLiveInfiniteQuery`
+  );
+  const queryKey = db.getLiveQueryKey(config);
   let preparedQueryValue = unpreparedQueryValue;
-  let identityDeps = [];
-  let identityMode = `collection`;
-  if (!inputIsCollection) {
-    if (config.queryKey !== void 0) {
-      identityMode = `queryKey`;
-      identityDeps = config.queryKey;
-    } else if (deps !== void 0) {
-      identityMode = `legacyDeps`;
-      identityDeps = deps;
-      useLiveQuery.warnDeprecatedDepsArray(`useLiveInfiniteQuery`);
-    } else if (committed?.identityMode === `derived` && committed.inputQuery === queryFnOrCollection && committed.client === dbClient) {
-      identityMode = `derived`;
-      identityDeps = committed.dependencies ?? [];
-    } else {
-      identityMode = `derived`;
-      const preparation = useLiveQuery.prepareDerivedQuery(
-        queryFnOrCollection,
-        dbClient,
-        derivedIdentityProfilerRef.current,
-        deferredCollections
-      );
-      preparedQueryValue = preparation.value;
-      sourceIdBindings.claimSourceIds(
-        sourceIdsRef.current ??= sourceIdBindings.createSourceIdBindings(),
-        preparation.value,
-        dbClient,
-        `useLiveInfiniteQuery`,
-        () => db.resumeDeferredLiveQueryCollections(deferredCollections)
-      );
-      if (preparation.status === `hashable`) {
-        identityDeps = preparation.identityDeps;
+  let dependencies;
+  let derivedQuery = void 0;
+  const rendered = renderedRef.current;
+  let binding;
+  try {
+    if (!inputIsCollection) {
+      if (queryKey !== void 0) {
+        dependencies = queryKey;
+      } else if (committed !== null && committed.derivedQuery === queryFnOrCollection && committed.binding.scope === dbClient) {
+        derivedQuery = queryFnOrCollection;
+        dependencies = committed.binding.dependencies;
       } else {
-        useLiveQuery.warnUnhashableDerivedIdentity(preparation.error);
-        identityDeps = legacyUnhashableIdentityRef.current;
+        const preparation = useLiveQuery.prepareDerivedQuery(
+          queryFnOrCollection,
+          derivedIdentityProfilerRef.current,
+          identityScope(),
+          deferredCollections
+        );
+        preparedQueryValue = preparation.value;
+        derivedQuery = queryFnOrCollection;
+        dependencies = preparation.identityDeps;
       }
     }
-  }
-  const usesLegacyDeps = !inputIsCollection && config.queryKey === void 0 && deps !== void 0;
-  const dependencyComparison = db.compareLiveQueryWindowDependencies(
-    committed?.dependencies,
-    identityDeps
-  );
-  const sameClient = committed?.client === dbClient;
-  const dependenciesChanged = !inputIsCollection && !queryIdentityMatches(dependencyComparison, sameClient, usesLegacyDeps);
-  const dependenciesStructurallyEqual = usesLegacyDeps && sameClient && dependencyComparison.structurallyEqual;
-  const needsNewCollection = committed === null || committed.inputKind !== inputKind || inputIsCollection && committed.inputCollection !== queryFnOrCollection || dependenciesChanged;
-  const pageShapeChanged = committed === null || committed.pageSize !== pageSize || committed.initialPageParam !== initialPageParam;
-  const needsNewController = committed === null || needsNewCollection || pageShapeChanged;
-  let renderState = committed;
-  if (needsNewController) {
-    let collection = committed?.collection;
-    let warning = null;
-    let startInRender = false;
-    let suppliedCollection = false;
-    let createdCollection = false;
-    const canPreservePageCount = db.shouldPreserveLiveQueryWindowPageCount({
-      hasPreviousController: committed !== null,
-      previousInputKind: committed?.inputKind,
-      inputKind,
-      sameCollection: inputIsCollection && committed?.inputCollection === queryFnOrCollection,
-      dependenciesChanged,
-      dependenciesStructurallyEqual,
-      pageShapeChanged
-    });
-    const previousPageCount = committed ? Math.max(1, committed.controller.getSnapshot().pages.length) : 1;
-    const initialPageCount = canPreservePageCount ? previousPageCount : 1;
-    const requiredLimit = initialPageCount * pageSize + 1;
-    if (needsNewCollection) {
-      let inputValue = queryFnOrCollection;
-      if (!inputIsCollection) {
-        if (preparedQueryValue === unpreparedQueryValue) {
-          preparedQueryValue = useLiveQuery.prepareQueryValue(
-            queryFnOrCollection,
-            dbClient,
-            deferredCollections
-          );
-        }
-        inputValue = () => preparedQueryValue;
-      }
-      const rendered = renderedCollectionRef.current;
-      if (!inputIsCollection && rendered !== null && queryIdentityMatches(
-        db.compareLiveQueryWindowDependencies(
-          rendered.dependencies,
-          identityDeps
-        ),
-        rendered.client === dbClient,
-        usesLegacyDeps
-      ) && rendered.collection.status !== `cleaned-up` && rendered.collection.status !== `error` && db.liveQueryWindowMatches(rendered.collection, requiredLimit)) {
-        collection = rendered.collection;
-        for (const deferred of rendered.deferredCollections) {
-          deferredCollections.add(deferred);
-        }
-      } else {
-        const input = db.resolveLiveQueryWindowInput(inputValue);
-        if (input.kind === `collection`) {
-          collection = input.collection;
-          suppliedCollection = true;
-          renderedCollectionRef.current = null;
-        } else {
-          collection = db.createLiveQueryCollection({
-            query: input.query.limit(requiredLimit).offset(0),
-            gcTime: DEFAULT_GC_TIME_MS
-          });
-          startInRender = true;
-          createdCollection = true;
-        }
+    const compileQuery = () => {
+      if (preparedQueryValue === unpreparedQueryValue) {
+        preparedQueryValue = useLiveQuery.prepareQueryValue(
+          queryFnOrCollection,
+          dbClient,
+          deferredCollections
+        );
       }
-    }
-    if (!collection) {
-      throw new Error(`useLiveInfiniteQuery: Failed to create a collection.`);
-    }
-    if (inputIsCollection) {
-      warning = db.getLiveQueryWindowCollectionWarning(collection, pageSize + 1) ?? null;
-    } else {
-      db.assertLiveQueryWindowManyResult(collection);
-    }
-    if (suppliedCollection) {
-      startInRender = db.liveQueryWindowMatches(collection, requiredLimit);
-    }
-    if (startInRender) collection.startSyncImmediate();
-    if (createdCollection) {
-      renderedCollectionRef.current = {
+      return preparedQueryValue;
+    };
+    binding = db.bindLiveQueryWindow(
+      committed?.binding ?? null,
+      {
+        ...pageShape,
+        input: typeof queryFnOrCollection === `function` ? compileQuery : queryFnOrCollection,
+        dependencies,
+        scope: dbClient,
         client: dbClient,
-        dependencies: [...identityDeps],
-        collection,
-        deferredCollections
-      };
+        queryKey,
+        recompile: `identity`
+      },
+      rendered?.binding
+    );
+  } catch (error) {
+    db.rejectLiveQueryInput(deferredCollections, error);
+  }
+  let currentRenderState = committed;
+  if (binding !== committed?.binding) {
+    const newCollection = binding.collection !== committed?.binding.collection;
+    if (newCollection && binding.collection === rendered?.binding.collection) {
+      for (const deferred of rendered.deferredCollections) {
+        deferredCollections.add(deferred);
+      }
     }
-    renderState = {
-      inputKind,
-      inputCollection: inputIsCollection ? collection : null,
-      inputQuery: inputIsCollection ? null : queryFnOrCollection,
-      client: dbClient,
-      identityMode,
-      dependencies: inputIsCollection ? null : [...identityDeps],
-      pageSize,
-      initialPageParam,
-      collection,
-      controller: db.createLiveQueryWindowController(collection, {
-        pageSize,
-        initialPageParam,
-        initialPageCount
-      }),
-      warning,
-      warned: false,
-      deferredCollections
+    const reusesRendered = newCollection && binding.collection === rendered?.binding.collection;
+    currentRenderState = {
+      binding,
+      derivedQuery,
+      deferredCollections,
+      // A render that never commits releases its deferred sync starts when
+      // garbage collection reclaims the window collection it built. A reused
+      // collection keeps the release its first render registered.
+      cancelReclaimRelease: reusesRendered ? rendered.cancelReclaimRelease : newCollection && binding.ownsCollection ? db.releaseDeferredOnReclaim(binding.collection, deferredCollections) : void 0,
+      warned: false
     };
+    if (binding.supplied) renderedRef.current = null;
+    else if (newCollection && binding.ownsCollection) {
+      renderedRef.current = currentRenderState;
+    }
   }
-  const currentRenderState = renderState;
-  const controller = currentRenderState.controller;
+  const renderState = currentRenderState;
+  const controller = renderState.binding.controller;
   const subscribe = react.useCallback(
     (onStoreChange) => {
       const unsubscribe = controller.subscribe(onStoreChange);
-      committedRef.current = currentRenderState;
-      if (currentRenderState.warning && !currentRenderState.warned) {
-        currentRenderState.warned = true;
-        console.warn(currentRenderState.warning);
+      committedRef.current = renderState;
+      if (renderState.binding.warning && !renderState.warned) {
+        renderState.warned = true;
+        console.warn(renderState.binding.warning);
       }
-      db.resumeDeferredLiveQueryCollections(currentRenderState.deferredCollections);
+      renderState.cancelReclaimRelease?.();
+      db.resumeDeferredLiveQueryCollections(renderState.deferredCollections);
       return unsubscribe;
     },
-    [controller, currentRenderState]
+    [controller, renderState]
   );
   const getSnapshot = react.useCallback(() => controller.getSnapshot(), [controller]);
-  const snapshot = react.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  const snapshot = react.useSyncExternalStore(
+    subscribe,
+    getSnapshot,
+    () => controller.getServerSnapshot()
+  );
   const fetchNextPage = react.useCallback(
     () => db.fetchNextLiveQueryWindowPage(controller),
     [controller]
@@ -215,12 +136,11 @@ function useLiveInfiniteQuery(queryFnOrCollection, config, deps) {
     status: snapshot.status,
     isLoading: snapshot.isLoading,
     isReady: snapshot.isReady,
-    persistedStatus: snapshot.persistedStatus,
-    isPersistedReady: snapshot.isPersistedReady,
-    persistedError: snapshot.persistedError,
     isIdle: snapshot.isIdle,
-    isError: snapshot.isError,
+    isLoadingError: snapshot.isLoadingError,
+    isCrashed: snapshot.isCrashed,
     isCleanedUp: snapshot.isCleanedUp,
+    isSyncError: snapshot.isSyncError,
     collection: snapshot.collection,
     isEnabled: snapshot.isEnabled,
     pages: snapshot.pages,
@@ -228,7 +148,7 @@ function useLiveInfiniteQuery(queryFnOrCollection, config, deps) {
     fetchNextPage,
     hasNextPage: snapshot.hasNextPage,
     isFetchingNextPage: snapshot.isFetchingNextPage,
-    error: snapshot.error
+    health: snapshot.health
   };
 }
 exports.useLiveInfiniteQuery = useLiveInfiniteQuery;

package/dist/cjs/useLiveInfiniteQuery.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"useLiveInfiniteQuery.cjs","sources":["../../src/useLiveInfiniteQuery.ts"],"sourcesContent":["'use client'\n\nimport { useCallback, useRef, useSyncExternalStore } from 'react'\nimport {\n  assertLiveQueryWindowManyResult,\n  compareLiveQueryWindowDependencies,\n  createLiveQueryCollection,\n  createLiveQueryWindowController,\n  fetchNextLiveQueryWindowPage,\n  getLiveQueryWindowCollectionWarning,\n  getLiveQueryWindowInputKind,\n  liveQueryWindowMatches,\n  normalizeLiveQueryWindowPageSize,\n  resolveLiveQueryWindowInput,\n  shouldPreserveLiveQueryWindowPageCount,\n} from '@tanstack/db'\nimport { useOptionalDbClient } from './DbProvider'\nimport {\n  claimSourceIds,\n  createSourceIdBindings,\n  resumeSyncStarts,\n} from './source-id-bindings'\nimport {\n  prepareDerivedQuery,\n  prepareQueryValue,\n  warnDeprecatedDepsArray,\n  warnUnhashableDerivedIdentity,\n} from './useLiveQuery'\nimport type { SourceIdBindings } from './source-id-bindings'\nimport type {\n  DerivedIdentityProfiler,\n  LiveQueryKey,\n  useLiveQuery,\n} from './useLiveQuery'\nimport type {\n  Collection,\n  CollectionImpl as CollectionImplType,\n  CollectionStatus,\n  Context,\n  DbClient,\n  InferResultType,\n  InitialQueryBuilder,\n  LiveQueryPersistedStatus,\n  LiveQueryWindowController,\n  NonSingleResult,\n  QueryBuilder,\n} from '@tanstack/db'\n\n// Live queries created here are cleaned up immediately (0 disables GC).\nconst DEFAULT_GC_TIME_MS = 1\nconst unpreparedQueryValue = Symbol(`unpreparedQueryValue`)\n\n// Keep the generic parameter for existing typed config wrappers.\nexport type UseLiveInfiniteQueryConfig<_TContext extends Context> = {\n  /**\n   * Explicit identity for queries that contain opaque functional variants or\n   * are hot enough that deriving identity from structured IR is too expensive.\n   * Structured queries should omit this so DB can derive identity directly.\n   */\n  queryKey?: LiveQueryKey\n  /** Override the nearest DbProvider for this query. */\n  client?: DbClient\n  pageSize?: number\n  /** First result-page label, not a server cursor or remote offset. */\n  initialPageParam?: number\n}\n\nexport type UseLiveInfiniteQueryReturn<TContext extends Context> = Omit<\n  ReturnType<typeof useLiveQuery<TContext>>,\n  `data`\n> & {\n  data: InferResultType<TContext>\n  pages: Array<Array<InferResultType<TContext>[number]>>\n  pageParams: Array<number>\n  fetchNextPage: () => Promise<void>\n  hasNextPage: boolean\n  isFetchingNextPage: boolean\n  error: unknown\n}\n\nexport type UseLiveInfiniteQueryReturnWithCollection<\n  TResult extends object,\n  TKey extends string | number,\n  TUtils extends Record<string, any>,\n> = {\n  data: Array<TResult>\n  state: Map<TKey, TResult>\n  collection: Collection<TResult, TKey, TUtils> & NonSingleResult\n  status: CollectionStatus\n  isLoading: boolean\n  isReady: boolean\n  persistedStatus: LiveQueryPersistedStatus\n  isPersistedReady: boolean\n  persistedError: unknown | undefined\n  isIdle: boolean\n  isError: boolean\n  isCleanedUp: boolean\n  isEnabled: true\n  pages: Array<Array<TResult>>\n  pageParams: Array<number>\n  fetchNextPage: () => Promise<void>\n  hasNextPage: boolean\n  isFetchingNextPage: boolean\n  error: unknown\n}\n\ntype EnabledLiveQueryReturn<TContext extends Context> = ReturnType<\n  typeof useLiveQuery<TContext>\n>\n\ntype InfiniteQueryRenderState = {\n  inputKind: `collection` | `query`\n  inputCollection: Collection<any, any, any> | null\n  inputQuery: unknown\n  client: DbClient | undefined\n  identityMode: `collection` | `queryKey` | `legacyDeps` | `derived`\n  dependencies: Array<unknown> | null\n  pageSize: number\n  initialPageParam: number\n  collection: Collection<any, any, any>\n  controller: LiveQueryWindowController<any, any>\n  warning: string | null\n  warned: boolean\n  deferredCollections: Set<\n    CollectionImplType<any, string | number, any, any, any>\n  >\n}\n\ntype RenderedWindowCollection = {\n  client: DbClient | undefined\n  dependencies: Array<unknown>\n  collection: Collection<any, any, any>\n  deferredCollections: Set<\n    CollectionImplType<any, string | number, any, any, any>\n  >\n}\n\n/**\n * Whether a recorded query identity matches the current one. Legacy deps\n * compare by reference. Derived identities and query keys compare by structure.\n */\nfunction queryIdentityMatches(\n  comparison: { changed: boolean; structurallyEqual: boolean },\n  sameClient: boolean,\n  usesLegacyDeps: boolean,\n): boolean {\n  return (\n    sameClient &&\n    (usesLegacyDeps ? !comparison.changed : comparison.structurallyEqual)\n  )\n}\n\n/**\n * Create an infinite query using a query function with live updates.\n *\n * Uses `utils.setWindow()` to dynamically adjust the limit/offset window\n * without recreating the live query collection on each page change.\n *\n * @param queryFn - Query function that defines what data to fetch. Must include `.orderBy()` for setWindow to work.\n * @param config - Configuration including pageSize and an optional initial page label\n * @param deps - Deprecated array of dependencies that trigger query re-execution when changed\n * @returns Object with pages, data, and pagination controls\n */\n\n// Overload for pre-created collection (non-single result)\nexport function useLiveInfiniteQuery<\n  TResult extends object,\n  TKey extends string | number,\n  TUtils extends Record<string, any>,\n>(\n  liveQueryCollection: Collection<TResult, TKey, TUtils> & NonSingleResult,\n  config: UseLiveInfiniteQueryConfig<any>,\n): UseLiveInfiniteQueryReturnWithCollection<TResult, TKey, TUtils>\n\n// Overload for query function\nexport function useLiveInfiniteQuery<TContext extends Context>(\n  queryFn: (q: InitialQueryBuilder) => QueryBuilder<TContext>,\n  config: UseLiveInfiniteQueryConfig<TContext>,\n  deps?: Array<unknown>,\n): UseLiveInfiniteQueryReturn<TContext>\n\n// Implementation\nexport function useLiveInfiniteQuery<TContext extends Context>(\n  queryFnOrCollection: any,\n  config: UseLiveInfiniteQueryConfig<TContext>,\n  deps?: Array<unknown>,\n): UseLiveInfiniteQueryReturn<TContext> {\n  if (`getNextPageParam` in config) {\n    throw new Error(\n      `getNextPageParam is not supported by useLiveInfiniteQuery. Use an on-demand collection and fulfill meta.loadSubsetOptions in queryFn for server pagination.`,\n    )\n  }\n  const pageSize = normalizeLiveQueryWindowPageSize(config.pageSize)\n  const initialPageParam = config.initialPageParam ?? 0\n  const contextDbClient = useOptionalDbClient()\n  const dbClient = config.client ?? contextDbClient\n\n  const inputIsCollection =\n    getLiveQueryWindowInputKind(queryFnOrCollection) === `collection`\n\n  const committedRef = useRef<InfiniteQueryRenderState | null>(null)\n  const committed = committedRef.current\n  // Like useLiveQuery's instance memo, keep the window collection built by the\n  // latest render. A second render before commit, such as a StrictMode double\n  // render, reuses it instead of starting another one. Only the collection is\n  // kept. Each render still builds its own controller and page count from the\n  // committed state, which an uncommitted render never changes.\n  const renderedCollectionRef = useRef<RenderedWindowCollection | null>(null)\n  const sourceIdsRef = useRef<SourceIdBindings | null>(null)\n  const inputKind = inputIsCollection ? `collection` : `query`\n  const derivedIdentityProfilerRef = useRef<DerivedIdentityProfiler>({\n    renderCount: 0,\n    totalMs: 0,\n    maxMs: 0,\n    warned: false,\n  })\n  const legacyUnhashableIdentityRef = useRef<Array<unknown>>([\n    `legacy-unhashable`,\n  ])\n  const deferredCollections = new Set<\n    CollectionImplType<any, string | number, any, any, any>\n  >()\n\n  let preparedQueryValue: unknown | typeof unpreparedQueryValue =\n    unpreparedQueryValue\n  let identityDeps: ReadonlyArray<unknown> = []\n  let identityMode: InfiniteQueryRenderState[`identityMode`] = `collection`\n\n  if (!inputIsCollection) {\n    if (config.queryKey !== undefined) {\n      identityMode = `queryKey`\n      identityDeps = config.queryKey\n    } else if (deps !== undefined) {\n      identityMode = `legacyDeps`\n      identityDeps = deps\n      warnDeprecatedDepsArray(`useLiveInfiniteQuery`)\n    } else if (\n      committed?.identityMode === `derived` &&\n      committed.inputQuery === queryFnOrCollection &&\n      committed.client === dbClient\n    ) {\n      identityMode = `derived`\n      identityDeps = committed.dependencies ?? []\n    } else {\n      identityMode = `derived`\n      const preparation = prepareDerivedQuery(\n        queryFnOrCollection,\n        dbClient,\n        derivedIdentityProfilerRef.current,\n        deferredCollections,\n      )\n      preparedQueryValue = preparation.value\n      claimSourceIds(\n        (sourceIdsRef.current ??= createSourceIdBindings()),\n        preparation.value,\n        dbClient,\n        `useLiveInfiniteQuery`,\n        () => resumeSyncStarts(deferredCollections),\n      )\n      if (preparation.status === `hashable`) {\n        identityDeps = preparation.identityDeps\n      } else {\n        warnUnhashableDerivedIdentity(preparation.error)\n        identityDeps = legacyUnhashableIdentityRef.current\n      }\n    }\n  }\n\n  const usesLegacyDeps =\n    !inputIsCollection && config.queryKey === undefined && deps !== undefined\n  const dependencyComparison = compareLiveQueryWindowDependencies(\n    committed?.dependencies,\n    identityDeps,\n  )\n  const sameClient = committed?.client === dbClient\n  const dependenciesChanged =\n    !inputIsCollection &&\n    !queryIdentityMatches(dependencyComparison, sameClient, usesLegacyDeps)\n  const dependenciesStructurallyEqual =\n    usesLegacyDeps && sameClient && dependencyComparison.structurallyEqual\n  const needsNewCollection =\n    committed === null ||\n    committed.inputKind !== inputKind ||\n    (inputIsCollection && committed.inputCollection !== queryFnOrCollection) ||\n    dependenciesChanged\n  const pageShapeChanged =\n    committed === null ||\n    committed.pageSize !== pageSize ||\n    committed.initialPageParam !== initialPageParam\n  const needsNewController =\n    committed === null || needsNewCollection || pageShapeChanged\n\n  let renderState = committed\n  if (needsNewController) {\n    let collection = committed?.collection\n    let warning: string | null = null\n    let startInRender = false\n    let suppliedCollection = false\n    let createdCollection = false\n\n    const canPreservePageCount = shouldPreserveLiveQueryWindowPageCount({\n      hasPreviousController: committed !== null,\n      previousInputKind: committed?.inputKind,\n      inputKind,\n      sameCollection:\n        inputIsCollection && committed?.inputCollection === queryFnOrCollection,\n      dependenciesChanged,\n      dependenciesStructurallyEqual,\n      pageShapeChanged,\n    })\n    const previousPageCount = committed\n      ? Math.max(1, committed.controller.getSnapshot().pages.length)\n      : 1\n    const initialPageCount = canPreservePageCount ? previousPageCount : 1\n    // The peek-ahead window for every retained page.\n    const requiredLimit = initialPageCount * pageSize + 1\n\n    if (needsNewCollection) {\n      let inputValue = queryFnOrCollection\n      if (!inputIsCollection) {\n        if (preparedQueryValue === unpreparedQueryValue) {\n          preparedQueryValue = prepareQueryValue(\n            queryFnOrCollection,\n            dbClient,\n            deferredCollections,\n          )\n        }\n        inputValue = () => preparedQueryValue\n      }\n      const rendered = renderedCollectionRef.current\n      if (\n        !inputIsCollection &&\n        rendered !== null &&\n        queryIdentityMatches(\n          compareLiveQueryWindowDependencies(\n            rendered.dependencies,\n            identityDeps,\n          ),\n          rendered.client === dbClient,\n          usesLegacyDeps,\n        ) &&\n        rendered.collection.status !== `cleaned-up` &&\n        rendered.collection.status !== `error` &&\n        liveQueryWindowMatches(rendered.collection, requiredLimit)\n      ) {\n        // An earlier render built this collection and nothing has committed\n        // since. Its window is exactly the retained pages, so its first\n        // rows are correct. Sources it deferred still resume at commit. A\n        // collection in terminal error, such as after its source restarted,\n        // cannot serve the query again, so a new one replaces it.\n        collection = rendered.collection\n        for (const deferred of rendered.deferredCollections) {\n          deferredCollections.add(deferred)\n        }\n      } else {\n        const input = resolveLiveQueryWindowInput<TContext>(inputValue)\n        if (input.kind === `collection`) {\n          collection = input.collection\n          suppliedCollection = true\n          // A supplied collection is never reused, so release the last one.\n          renderedCollectionRef.current = null\n        } else {\n          // Wrap the query with the peek-ahead window for every retained page,\n          // so a collection that starts syncing now never publishes fewer rows\n          // than the controller's pages. The controller grows the limit via\n          // setWindow.\n          collection = createLiveQueryCollection({\n            query: input.query.limit(requiredLimit).offset(0),\n            gcTime: DEFAULT_GC_TIME_MS,\n          })\n          startInRender = true\n          createdCollection = true\n        }\n      }\n    }\n\n    if (!collection) {\n      throw new Error(`useLiveInfiniteQuery: Failed to create a collection.`)\n    }\n\n    if (inputIsCollection) {\n      warning =\n        getLiveQueryWindowCollectionWarning(collection, pageSize + 1) ?? null\n    } else {\n      assertLiveQueryWindowManyResult(collection)\n    }\n    // Like useLiveQuery, start sync during render once the input is valid. A\n    // render reads only rows the sources already hold, such as a preloaded\n    // collection's, and sends no request until the subscription commits. GC\n    // reclaims a render that never commits. A supplied window that the\n    // controller must still adjust waits for the subscription.\n    if (suppliedCollection) {\n      startInRender = liveQueryWindowMatches(collection, requiredLimit)\n    }\n    if (startInRender) collection.startSyncImmediate()\n    // Keep a created collection for the next render only once it validated and\n    // started, so a retry after a startup error builds a new one and throws.\n    if (createdCollection) {\n      renderedCollectionRef.current = {\n        client: dbClient,\n        dependencies: [...identityDeps],\n        collection,\n        deferredCollections,\n      }\n    }\n\n    renderState = {\n      inputKind,\n      inputCollection: inputIsCollection ? collection : null,\n      inputQuery: inputIsCollection ? null : queryFnOrCollection,\n      client: dbClient,\n      identityMode,\n      dependencies: inputIsCollection ? null : [...identityDeps],\n      pageSize,\n      initialPageParam,\n      collection,\n      controller: createLiveQueryWindowController(collection, {\n        pageSize,\n        initialPageParam,\n        initialPageCount,\n      }),\n      warning,\n      warned: false,\n      deferredCollections,\n    }\n  }\n  const currentRenderState = renderState!\n  const controller = currentRenderState.controller\n\n  const subscribe = useCallback(\n    (onStoreChange: () => void) => {\n      const unsubscribe = controller.subscribe(onStoreChange)\n      committedRef.current = currentRenderState\n      if (currentRenderState.warning && !currentRenderState.warned) {\n        currentRenderState.warned = true\n        console.warn(currentRenderState.warning)\n      }\n      resumeSyncStarts(currentRenderState.deferredCollections)\n      return unsubscribe\n    },\n    [controller, currentRenderState],\n  )\n  const getSnapshot = useCallback(() => controller.getSnapshot(), [controller])\n  const snapshot = useSyncExternalStore(subscribe, getSnapshot, getSnapshot)\n\n  const fetchNextPage = useCallback(\n    () => fetchNextLiveQueryWindowPage(controller),\n    [controller],\n  )\n\n  return {\n    data: snapshot.data as InferResultType<TContext>,\n    get state() {\n      return snapshot.state as EnabledLiveQueryReturn<TContext>[`state`]\n    },\n    status: snapshot.status as EnabledLiveQueryReturn<TContext>[`status`],\n    isLoading: snapshot.isLoading,\n    isReady: snapshot.isReady,\n    persistedStatus: snapshot.persistedStatus,\n    isPersistedReady: snapshot.isPersistedReady,\n    persistedError: snapshot.persistedError,\n    isIdle: snapshot.isIdle,\n    isError: snapshot.isError,\n    isCleanedUp: snapshot.isCleanedUp,\n    collection:\n      snapshot.collection as EnabledLiveQueryReturn<TContext>[`collection`],\n    isEnabled: snapshot.isEnabled,\n    pages: snapshot.pages as Array<Array<InferResultType<TContext>[number]>>,\n    pageParams: snapshot.pageParams as Array<number>,\n    fetchNextPage,\n    hasNextPage: snapshot.hasNextPage,\n    isFetchingNextPage: snapshot.isFetchingNextPage,\n    error: snapshot.error,\n  }\n}\n"],"names":["warnDeprecatedDepsArray","prepareDerivedQuery","claimSourceIds","warnUnhashableDerivedIdentity","compareLiveQueryWindowDependencies","prepareQueryValue","assertLiveQueryWindowManyResult","useCallback","resumeSyncStarts"],"mappings":";;;;;;;;AAiDA;AACA;AA2FA;AAKE;AAIF;AAgCO;AAKL;AACE;AAAU;AACR;AAAA;AAGJ;AACA;AACA;AACA;AAEA;AAGA;AACA;AAMA;AACA;AACA;AACA;AAAmE;AACpD;AACJ;AACF;AACC;AAEV;AAA2D;AACzD;AAEF;AAIA;AAEA;AACA;AAEA;AACE;AACE;AACA;AAAsB;AAEtB;AACA;AACAA;AAA8C;AAM9C;AACA;AAAyC;AAEzC;AACA;AAAoBC;AAClB;AACA;AAC2B;AAC3B;AAEF;AACAC;AAAAA;AAC4B;AACd;AACZ;AACA;AAC0C;AAE5C;AACE;AAA2B;AAE3BC;AACA;AAA2C;AAC7C;AACF;AAGF;AAEA;AAA6BC;AAChB;AACX;AAEF;AACA;AAGA;AAEA;AAKA;AAIA;AAGA;AACA;AACE;AACA;AACA;AACA;AACA;AAEA;AAAoE;AAC7B;AACP;AAC9B;AAEsD;AACtD;AACA;AACA;AAEF;AAGA;AAEA;AAEA;AACE;AACA;AACE;AACE;AAAqBC;AACnB;AACA;AACA;AAAA;AAGJ;AAAmB;AAErB;AACA;AAGE;AACED;AACW;AACT;AAAA;AAEkB;AACpB;AAWF;AACA;AACE;AAAgC;AAClC;AAEA;AACA;AACE;AACA;AAEA;AAAgC;AAMhC;AAAuC;AACW;AACxC;AAEV;AACA;AAAoB;AACtB;AACF;AAGF;AACE;AAAsE;AAGxE;AACE;AACmE;AAEnEE;AAA0C;AAO5C;AACE;AAAgE;AAElE;AAGA;AACE;AAAgC;AACtB;AACsB;AAC9B;AACA;AAAA;AAIJ;AAAc;AACZ;AACkD;AACX;AAC/B;AACR;AACyD;AACzD;AACA;AACA;AACwD;AACtD;AACA;AACA;AACD;AACD;AACQ;AACR;AAAA;AAGJ;AACA;AAEA;AAAkBC;AAEd;AACA;AACA;AACE;AACA;AAAuC;AAEzCC;AACA;AAAO;AACT;AAC+B;AAEjC;AACA;AAEA;AAAsBD;AACyB;AAClC;AAGb;AAAO;AACU;AAEb;AAAgB;AAClB;AACiB;AACG;AACF;AACQ;AACC;AACF;AACR;AACC;AACI;AAEX;AACS;AACJ;AACK;AACrB;AACsB;AACO;AACb;AAEpB;;"}
+{"version":3,"file":"useLiveInfiniteQuery.cjs","sources":["../../src/useLiveInfiniteQuery.ts"],"sourcesContent":["'use client'\n\nimport { useCallback, useRef, useSyncExternalStore } from 'react'\nimport {\n  bindLiveQueryWindow,\n  createLiveQuerySourceIdClaims,\n  fetchNextLiveQueryWindowPage,\n  getLiveQueryKey,\n  isCollection,\n  readLiveQueryWindowPageShape,\n  rejectLiveQueryInput,\n  releaseDeferredOnReclaim,\n  resumeDeferredLiveQueryCollections,\n} from '@tanstack/db'\nimport { useOptionalDbClient } from './DbProvider'\nimport {\n  getIdentityScope,\n  prepareDerivedQuery,\n  prepareQueryValue,\n} from './useLiveQuery'\nimport type {\n  DerivedIdentityProfiler,\n  LiveQueryKey,\n  useLiveQuery,\n} from './useLiveQuery'\nimport type {\n  Collection,\n  CollectionImpl as CollectionImplType,\n  CollectionStatus,\n  Context,\n  DbClient,\n  InferResultType,\n  InitialQueryBuilder,\n  LiveQuerySourceIdClaims,\n  LiveQueryStatusFlags,\n  LiveQueryWindowBinding,\n  NonSingleResult,\n  QueryBuilder,\n} from '@tanstack/db'\n\nconst unpreparedQueryValue = Symbol(`unpreparedQueryValue`)\n\n// Keep the generic parameter for existing typed config wrappers.\nexport type UseLiveInfiniteQueryConfig<_TContext extends Context> = {\n  /**\n   * Explicit identity for queries that contain opaque functional variants or\n   * are hot enough that deriving identity from structured IR is too expensive.\n   * Structured queries should omit this so DB can derive identity directly.\n   */\n  queryKey?: LiveQueryKey\n  /** Override the nearest DbProvider for this query. */\n  client?: DbClient\n  pageSize?: number\n  /** First result-page label, not a server cursor or remote offset. */\n  initialPageParam?: number\n}\n\nexport type UseLiveInfiniteQueryReturn<TContext extends Context> = Omit<\n  ReturnType<typeof useLiveQuery<TContext>>,\n  `data`\n> & {\n  data: InferResultType<TContext>\n  pages: Array<Array<InferResultType<TContext>[number]>>\n  pageParams: Array<number>\n  fetchNextPage: () => Promise<void>\n  hasNextPage: boolean\n  isFetchingNextPage: boolean\n}\n\nexport type UseLiveInfiniteQueryReturnWithCollection<\n  TResult extends object,\n  TKey extends string | number,\n  TUtils extends Record<string, any>,\n> = LiveQueryStatusFlags & {\n  data: Array<TResult>\n  state: Map<TKey, TResult>\n  collection: Collection<TResult, TKey, TUtils> & NonSingleResult\n  status: CollectionStatus\n  isEnabled: true\n  pages: Array<Array<TResult>>\n  pageParams: Array<number>\n  fetchNextPage: () => Promise<void>\n  hasNextPage: boolean\n  isFetchingNextPage: boolean\n}\n\ntype EnabledLiveQueryReturn<TContext extends Context> = ReturnType<\n  typeof useLiveQuery<TContext>\n>\n\n/** One render's window binding and what its commit still owes. */\ntype InfiniteQueryRender = {\n  binding: LiveQueryWindowBinding\n  /** The query callback whose identity this render derived, if any. */\n  derivedQuery: unknown\n  deferredCollections: Set<\n    CollectionImplType<any, string | number, any, any, any>\n  >\n  /** Drops the reclaim release when this render commits. */\n  cancelReclaimRelease: (() => void) | undefined\n  warned: boolean\n}\n\n/**\n * Create an infinite query using a query function with live updates.\n *\n * Uses `utils.setWindow()` to dynamically adjust the limit/offset window\n * without recreating the live query collection on each page change.\n *\n * @param queryFn - Query function that defines what data to fetch. Must include `.orderBy()` for setWindow to work.\n * @param config - Configuration including pageSize and an optional initial page label\n * @returns Object with pages, data, and pagination controls\n */\n\n// Overload for pre-created collection (non-single result)\nexport function useLiveInfiniteQuery<\n  TResult extends object,\n  TKey extends string | number,\n  TUtils extends Record<string, any>,\n>(\n  liveQueryCollection: Collection<TResult, TKey, TUtils> & NonSingleResult,\n  config: UseLiveInfiniteQueryConfig<any>,\n): UseLiveInfiniteQueryReturnWithCollection<TResult, TKey, TUtils>\n\n// Overload for query function\nexport function useLiveInfiniteQuery<TContext extends Context>(\n  queryFn: (q: InitialQueryBuilder) => QueryBuilder<TContext>,\n  config: UseLiveInfiniteQueryConfig<TContext>,\n): UseLiveInfiniteQueryReturn<TContext>\n\n// Implementation\nexport function useLiveInfiniteQuery<TContext extends Context>(\n  queryFnOrCollection: any,\n  config: UseLiveInfiniteQueryConfig<TContext>,\n): UseLiveInfiniteQueryReturn<TContext> {\n  const pageShape = readLiveQueryWindowPageShape(config)\n  const contextDbClient = useOptionalDbClient()\n  const dbClient = config.client ?? contextDbClient\n  const inputIsCollection = isCollection(queryFnOrCollection)\n\n  const committedRef = useRef<InfiniteQueryRender | null>(null)\n  const committed = committedRef.current\n  // Like useLiveQuery's instance memo, keep the latest render whose binding\n  // built a window collection. A second render before commit, such as a\n  // StrictMode double render, reuses that collection instead of starting\n  // another. Each render still builds its own controller and page count from\n  // the committed binding, which an uncommitted render never changes.\n  const renderedRef = useRef<InfiniteQueryRender | null>(null)\n  const sourceIdsRef = useRef<LiveQuerySourceIdClaims | null>(null)\n  const derivedIdentityProfilerRef = useRef<DerivedIdentityProfiler>({\n    renderCount: 0,\n    totalMs: 0,\n    maxMs: 0,\n    warned: false,\n  })\n  const deferredCollections = new Set<\n    CollectionImplType<any, string | number, any, any, any>\n  >()\n  const identityScope = () =>\n    getIdentityScope(\n      (sourceIdsRef.current ??= createLiveQuerySourceIdClaims()),\n      dbClient,\n      `useLiveInfiniteQuery`,\n    )\n\n  const queryKey = getLiveQueryKey(config)\n  let preparedQueryValue: unknown | typeof unpreparedQueryValue =\n    unpreparedQueryValue\n  let dependencies: ReadonlyArray<unknown> | undefined\n  let derivedQuery: unknown = undefined\n\n  const rendered = renderedRef.current\n  let binding: LiveQueryWindowBinding\n  // The render boundary: a render that throws anywhere after preparation,\n  // such as an unhashable, single-result, or uncompilable query, never\n  // commits, so it releases the sync starts it deferred here.\n  try {\n    if (!inputIsCollection) {\n      if (queryKey !== undefined) {\n        dependencies = queryKey\n      } else if (\n        committed !== null &&\n        committed.derivedQuery === queryFnOrCollection &&\n        committed.binding.scope === dbClient\n      ) {\n        // The same callback in the same client scope keeps its identity.\n        derivedQuery = queryFnOrCollection\n        dependencies = committed.binding.dependencies\n      } else {\n        const preparation = prepareDerivedQuery(\n          queryFnOrCollection,\n          derivedIdentityProfilerRef.current,\n          identityScope(),\n          deferredCollections,\n        )\n        preparedQueryValue = preparation.value\n        derivedQuery = queryFnOrCollection\n        dependencies = preparation.identityDeps\n      }\n    }\n\n    // The binding calls this only when it compiles a new window collection.\n    const compileQuery = () => {\n      if (preparedQueryValue === unpreparedQueryValue) {\n        preparedQueryValue = prepareQueryValue(\n          queryFnOrCollection,\n          dbClient,\n          deferredCollections,\n        )\n      }\n      return preparedQueryValue\n    }\n\n    binding = bindLiveQueryWindow(\n      committed?.binding ?? null,\n      {\n        ...pageShape,\n        input:\n          typeof queryFnOrCollection === `function`\n            ? compileQuery\n            : queryFnOrCollection,\n        dependencies,\n        scope: dbClient,\n        client: dbClient,\n        queryKey,\n        recompile: `identity`,\n      },\n      rendered?.binding,\n    )\n  } catch (error) {\n    rejectLiveQueryInput(deferredCollections, error)\n  }\n\n  let currentRenderState = committed\n  if (binding !== committed?.binding) {\n    const newCollection = binding.collection !== committed?.binding.collection\n    if (newCollection && binding.collection === rendered?.binding.collection) {\n      // Sources the earlier render deferred still resume at this commit.\n      for (const deferred of rendered.deferredCollections) {\n        deferredCollections.add(deferred)\n      }\n    }\n    const reusesRendered =\n      newCollection && binding.collection === rendered?.binding.collection\n    currentRenderState = {\n      binding,\n      derivedQuery,\n      deferredCollections,\n      // A render that never commits releases its deferred sync starts when\n      // garbage collection reclaims the window collection it built. A reused\n      // collection keeps the release its first render registered.\n      cancelReclaimRelease: reusesRendered\n        ? rendered.cancelReclaimRelease\n        : newCollection && binding.ownsCollection\n          ? releaseDeferredOnReclaim(binding.collection, deferredCollections)\n          : undefined,\n      warned: false,\n    }\n    // Keep a created collection for the next render only once it validated\n    // and started, so a retry after a startup error builds a new one.\n    if (binding.supplied) renderedRef.current = null\n    else if (newCollection && binding.ownsCollection) {\n      renderedRef.current = currentRenderState\n    }\n  }\n  const renderState = currentRenderState!\n  const controller = renderState.binding.controller\n\n  const subscribe = useCallback(\n    (onStoreChange: () => void) => {\n      const unsubscribe = controller.subscribe(onStoreChange)\n      committedRef.current = renderState\n      if (renderState.binding.warning && !renderState.warned) {\n        renderState.warned = true\n        console.warn(renderState.binding.warning)\n      }\n      // A commit releases the starts itself, so it drops the reclaim release.\n      renderState.cancelReclaimRelease?.()\n      resumeDeferredLiveQueryCollections(renderState.deferredCollections)\n      return unsubscribe\n    },\n    [controller, renderState],\n  )\n  const getSnapshot = useCallback(() => controller.getSnapshot(), [controller])\n  const snapshot = useSyncExternalStore(subscribe, getSnapshot, () =>\n    controller.getServerSnapshot(),\n  )\n\n  const fetchNextPage = useCallback(\n    () => fetchNextLiveQueryWindowPage(controller),\n    [controller],\n  )\n\n  return {\n    data: snapshot.data as InferResultType<TContext>,\n    get state() {\n      return snapshot.state as EnabledLiveQueryReturn<TContext>[`state`]\n    },\n    status: snapshot.status as EnabledLiveQueryReturn<TContext>[`status`],\n    isLoading: snapshot.isLoading,\n    isReady: snapshot.isReady,\n    isIdle: snapshot.isIdle,\n    isLoadingError: snapshot.isLoadingError,\n    isCrashed: snapshot.isCrashed,\n    isCleanedUp: snapshot.isCleanedUp,\n    isSyncError: snapshot.isSyncError,\n    collection:\n      snapshot.collection as EnabledLiveQueryReturn<TContext>[`collection`],\n    isEnabled: snapshot.isEnabled,\n    pages: snapshot.pages as Array<Array<InferResultType<TContext>[number]>>,\n    pageParams: snapshot.pageParams as Array<number>,\n    fetchNextPage,\n    hasNextPage: snapshot.hasNextPage,\n    isFetchingNextPage: snapshot.isFetchingNextPage,\n    health: snapshot.health,\n  }\n}\n"],"names":["getIdentityScope","prepareDerivedQuery","prepareQueryValue","bindLiveQueryWindow","rejectLiveQueryInput","useCallback","resumeDeferredLiveQueryCollections","useSyncExternalStore"],"mappings":";;;;;;;AAwCA;AA2FO;AAIL;AACA;AACA;AACA;AAEA;AACA;AAMA;AACA;AACA;AAAmE;AACpD;AACJ;AACF;AACC;AAEV;AAGA;AACEA;AAC4B;AAC1B;AACA;AAGJ;AACA;AAEA;AACA;AAEA;AACA;AAIA;AACE;AACE;AACE;AAAe;AAOf;AACA;AAAiC;AAEjC;AAAoBC;AAClB;AAC2B;AAC3B;AACA;AAEF;AACA;AACA;AAA2B;AAC7B;AAIF;AACE;AACE;AAAqBC;AACnB;AACA;AACA;AAAA;AAGJ;AAAO;AAGT;AAAUC;AACc;AACtB;AACK;AAIG;AACN;AACO;AACC;AACR;AACW;AAAA;AAEH;AAAA;AAGZC;AAA+C;AAGjD;AACA;AACE;AACA;AAEE;AACE;AAAgC;AAClC;AAEF;AAEA;AAAqB;AACnB;AACA;AACA;AAAA;AAAA;AAAA;AAQM;AACE;AAIV;AAA4C;AAE1C;AAAsB;AACxB;AAEF;AACA;AAEA;AAAkBC;AAEd;AACA;AACA;AACE;AACA;AAAwC;AAG1C;AACAC;AACA;AAAO;AACT;AACwB;AAE1B;AACA;AAAiBC;AAAqB;AAAW;AACpC;AAGb;AAAsBF;AACyB;AAClC;AAGb;AAAO;AACU;AAEb;AAAgB;AAClB;AACiB;AACG;AACF;AACD;AACQ;AACL;AACE;AACA;AAEX;AACS;AACJ;AACK;AACrB;AACsB;AACO;AACZ;AAErB;;"}

package/dist/cjs/useLiveInfiniteQuery.d.cts

@@ -1,5 +1,5 @@
 import { LiveQueryKey, useLiveQuery } from './useLiveQuery.cjs';
-import { Collection, CollectionStatus, Context, DbClient, InferResultType, InitialQueryBuilder, LiveQueryPersistedStatus, NonSingleResult, QueryBuilder } from '@tanstack/db';
+import { Collection, CollectionStatus, Context, DbClient, InferResultType, InitialQueryBuilder, LiveQueryStatusFlags, NonSingleResult, QueryBuilder } from '@tanstack/db';
 export type UseLiveInfiniteQueryConfig<_TContext extends Context> = {
     /**
      * Explicit identity for queries that contain opaque functional variants or
@@ -20,28 +20,18 @@ export type UseLiveInfiniteQueryReturn<TContext extends Context> = Omit<ReturnTy
     fetchNextPage: () => Promise<void>;
     hasNextPage: boolean;
     isFetchingNextPage: boolean;
-    error: unknown;
 };
-export type UseLiveInfiniteQueryReturnWithCollection<TResult extends object, TKey extends string | number, TUtils extends Record<string, any>> = {
+export type UseLiveInfiniteQueryReturnWithCollection<TResult extends object, TKey extends string | number, TUtils extends Record<string, any>> = LiveQueryStatusFlags & {
     data: Array<TResult>;
     state: Map<TKey, TResult>;
     collection: Collection<TResult, TKey, TUtils> & NonSingleResult;
     status: CollectionStatus;
-    isLoading: boolean;
-    isReady: boolean;
-    persistedStatus: LiveQueryPersistedStatus;
-    isPersistedReady: boolean;
-    persistedError: unknown | undefined;
-    isIdle: boolean;
-    isError: boolean;
-    isCleanedUp: boolean;
     isEnabled: true;
     pages: Array<Array<TResult>>;
     pageParams: Array<number>;
     fetchNextPage: () => Promise<void>;
     hasNextPage: boolean;
     isFetchingNextPage: boolean;
-    error: unknown;
 };
 /**
  * Create an infinite query using a query function with live updates.
@@ -51,8 +41,7 @@ export type UseLiveInfiniteQueryReturnWithCollection<TResult extends object, TKe
  *
  * @param queryFn - Query function that defines what data to fetch. Must include `.orderBy()` for setWindow to work.
  * @param config - Configuration including pageSize and an optional initial page label
- * @param deps - Deprecated array of dependencies that trigger query re-execution when changed
  * @returns Object with pages, data, and pagination controls
  */
 export declare function useLiveInfiniteQuery<TResult extends object, TKey extends string | number, TUtils extends Record<string, any>>(liveQueryCollection: Collection<TResult, TKey, TUtils> & NonSingleResult, config: UseLiveInfiniteQueryConfig<any>): UseLiveInfiniteQueryReturnWithCollection<TResult, TKey, TUtils>;
-export declare function useLiveInfiniteQuery<TContext extends Context>(queryFn: (q: InitialQueryBuilder) => QueryBuilder<TContext>, config: UseLiveInfiniteQueryConfig<TContext>, deps?: Array<unknown>): UseLiveInfiniteQueryReturn<TContext>;
+export declare function useLiveInfiniteQuery<TContext extends Context>(queryFn: (q: InitialQueryBuilder) => QueryBuilder<TContext>, config: UseLiveInfiniteQueryConfig<TContext>): UseLiveInfiniteQueryReturn<TContext>;