@ai-matrx/records 0.76.4 → 0.76.6

package/dist/react/index.js

@@ -43083,11 +43083,12 @@ function createTableDataPort({ client, aliases }) {
 }
 
 // src/data/react.tsx
-import { createContext as createContext3, createElement as createElement3, useContext as useContext3, useEffect as useEffect5, useMemo as useMemo3 } from "react";
+import { createContext as createContext3, createElement as createElement3, useContext as useContext3, useEffect as useEffect5, useMemo as useMemo3, useRef as useRef4 } from "react";
 import {
   QueryClient as QueryClientClass,
   QueryClientContext,
   QueryClientProvider,
+  hashKey,
   useInfiniteQuery,
   useQuery
 } from "@tanstack/react-query";
@@ -43158,7 +43159,64 @@ function forEachRowsEntry(qc, portKey, alias, fn) {
     if (next && next !== data) qc.setQueryData(key, next);
   }
 }
+var LANDED_MS = 3e4;
+var LANDED_KEY = /* @__PURE__ */ Symbol.for("@ai-matrx/records/data-landed");
+function landedHome(qc) {
+  const holder = qc;
+  let home = holder[LANDED_KEY];
+  if (!home) {
+    const made = { byAlias: /* @__PURE__ */ new Map(), unsubscribe: () => {
+    } };
+    made.unsubscribe = qc.getQueryCache().subscribe((event) => {
+      if (event.type !== "updated" || event.action.type !== "success") return;
+      const key = event.query.queryKey;
+      if (key[0] !== RECORDS_QUERY_ROOT || key[1] !== "data" || key[3] !== "alias" || key[5] !== "rows") return;
+      const portKey = String(key[2]);
+      const alias = String(key[4]);
+      const landed = made.byAlias.get(`${portKey}
${alias}`);
+      if (!landed || landed.size === 0) return;
+      reapplyLanded(qc, event.query.queryKey, landed);
+    });
+    holder[LANDED_KEY] = made;
+    home = made;
+  }
+  return home;
+}
+function remember(qc, portKey, alias, id, row) {
+  const home = landedHome(qc);
+  const key = `${portKey}
${alias}`;
+  let landed = home.byAlias.get(key);
+  if (!landed) home.byAlias.set(key, landed = /* @__PURE__ */ new Map());
+  const now = Date.now();
+  for (const [oldId, entry] of landed) if (now - entry.at > LANDED_MS) landed.delete(oldId);
+  landed.set(id, { row, at: now });
+}
+function reapplyLanded(qc, key, landed) {
+  const data = qc.getQueryData(key);
+  if (!data) return;
+  const now = Date.now();
+  let changed = false;
+  const pages = data.pages.map((page2) => {
+    let rows = null;
+    page2.rows.forEach((r, i) => {
+      const entry = landed.get(r._id);
+      if (!entry || now - entry.at > LANDED_MS) return;
+      if (entry.row === null) {
+        rows ??= page2.rows.slice();
+        rows[i] = null;
+      } else if (entry.row._version > r._version) {
+        rows ??= page2.rows.slice();
+        rows[i] = entry.row;
+      }
+    });
+    if (!rows) return page2;
+    changed = true;
+    return { ...page2, rows: rows.filter((r) => r !== null) };
+  });
+  if (changed) qc.setQueryData(key, { ...data, pages });
+}
 function patchRow(qc, portKey, alias, row, options = {}) {
+  if (options.fromStore) remember(qc, portKey, alias, row._id, row);
   let held = false;
   forEachRowsEntry(qc, portKey, alias, (_key, data) => {
     let changed = false;
@@ -43179,7 +43237,8 @@ function patchRow(qc, portKey, alias, row, options = {}) {
   if (options.force || !current || current._version <= row._version) qc.setQueryData(rowKey, row);
   return held;
 }
-function dropRow(qc, portKey, alias, id) {
+function dropRow(qc, portKey, alias, id, options = {}) {
+  if (options.fromStore) remember(qc, portKey, alias, id, null);
   forEachRowsEntry(qc, portKey, alias, (_key, data) => {
     let changed = false;
     const pages = data.pages.map((page2) => {
@@ -43229,8 +43288,52 @@ async function sourceKind(qc, port, portKey, alias) {
     return null;
   }
 }
+var DEFERRED_KEY = /* @__PURE__ */ Symbol.for("@ai-matrx/records/data-deferred-rereads");
+var OWED_KEY = /* @__PURE__ */ Symbol.for("@ai-matrx/records/data-owed-pages");
+function owedPages(qc) {
+  const holder = qc;
+  return holder[OWED_KEY] ??= /* @__PURE__ */ new Map();
+}
+function owedPage(qc, hash) {
+  const owed = owedPages(qc).get(hash);
+  if (!owed) return null;
+  const query = qc.getQueryCache().get(hash);
+  const data = query?.state.data;
+  const last = data?.pages[data.pages.length - 1];
+  if (!query || query.state.status === "error" || !data || data.pages.length >= owed.pages || !last?.cursor) {
+    owedPages(qc).delete(hash);
+    return null;
+  }
+  return owed;
+}
+function rereadList(qc, key) {
+  const query = qc.getQueryCache().find({ queryKey: key, exact: true });
+  if (!query || query.state.fetchStatus !== "fetching" && !owedPage(qc, query.queryHash)) {
+    void qc.invalidateQueries({ queryKey: key, exact: true });
+    return;
+  }
+  const holder = qc;
+  const waiting = holder[DEFERRED_KEY] ??= /* @__PURE__ */ new Set();
+  if (waiting.has(query.queryHash)) return;
+  waiting.add(query.queryHash);
+  const settle = () => {
+    if (query.state.fetchStatus === "fetching") return;
+    const owed = owedPage(qc, query.queryHash);
+    if (owed) {
+      owed.fetchNext();
+      return;
+    }
+    stop();
+    waiting.delete(query.queryHash);
+    void qc.invalidateQueries({ queryKey: key, exact: true });
+  };
+  const stop = qc.getQueryCache().subscribe((event) => {
+    if (event.query === query) settle();
+  });
+  settle();
+}
 function rereadOrCount(qc, key, data, count) {
-  if (data.pages.length <= REREAD_PAGES_MAX) void qc.invalidateQueries({ queryKey: key, exact: true });
+  if (data.pages.length <= REREAD_PAGES_MAX) rereadList(qc, key);
   else qc.setQueryData(key, { ...data, newer: (data.newer ?? 0) + count });
 }
 function placeUnseen(qc, portKey, alias, rows, kind) {
@@ -43255,8 +43358,8 @@ async function rereadIds(qc, port, portKey, alias, ids) {
   for (const [id, answer] of answers) {
     if (!answer.ok) continue;
     if (answer.data === null) {
-      dropRow(qc, portKey, alias, id);
-    } else if (!patchRow(qc, portKey, alias, answer.data)) {
+      dropRow(qc, portKey, alias, id, { fromStore: true });
+    } else if (!patchRow(qc, portKey, alias, answer.data, { fromStore: true })) {
       unseen.push(answer.data);
     }
   }
@@ -43265,10 +43368,10 @@ async function rereadIds(qc, port, portKey, alias, ids) {
 function rereadUnknown(qc, portKey, alias) {
   for (const [key, data] of qc.getQueriesData({ queryKey: dataKeys.rowsPrefix(portKey, alias) })) {
     if (!data || data.pages.length === 0) {
-      void qc.invalidateQueries({ queryKey: key, exact: true });
+      rereadList(qc, key);
       continue;
     }
-    if (data.pages.length <= REREAD_PAGES_MAX) void qc.invalidateQueries({ queryKey: key, exact: true });
+    if (data.pages.length <= REREAD_PAGES_MAX) rereadList(qc, key);
     else qc.setQueryData(key, { ...data, newer: Math.max(data.newer ?? 0, 1) });
   }
   void qc.invalidateQueries({ queryKey: [...dataKeys.alias(portKey, alias), "row"] });
@@ -43348,9 +43451,10 @@ function useDataRows(alias, query = {}, scope) {
   const { port, portKey } = useDataPort(scope);
   const qc = useRecordsQueryClient();
   useLive(alias, scope);
+  const rowsKey = dataKeys.rows(portKey, alias, query);
   const q = useInfiniteQuery(
     {
-      queryKey: dataKeys.rows(portKey, alias, query),
+      queryKey: rowsKey,
       queryFn: async ({ pageParam }) => unwrap(await port.list(alias, query, pageParam ?? void 0)),
       initialPageParam: null,
       getNextPageParam: (last) => last.cursor ?? void 0,
@@ -43370,6 +43474,20 @@ function useDataRows(alias, query = {}, scope) {
     }
     return out;
   }, [q.data]);
+  const want = useRef4({ key: "", pages: 0 });
+  const keyHash = hashKey(rowsKey);
+  const loaded = q.data?.pages.length ?? 0;
+  const { isFetching, hasNextPage, isFetchNextPageError, fetchNextPage } = q;
+  useEffect5(() => {
+    const w = want.current;
+    if (w.key !== keyHash || isFetching || loaded >= w.pages) return;
+    if (!hasNextPage || isFetchNextPageError) {
+      want.current = { key: keyHash, pages: 0 };
+      owedPages(qc).delete(keyHash);
+      return;
+    }
+    void fetchNextPage({ cancelRefetch: false });
+  }, [qc, keyHash, isFetching, loaded, hasNextPage, isFetchNextPageError, fetchNextPage]);
   return {
     rows,
     total: q.data?.pages[0]?.total ?? null,
@@ -43378,7 +43496,10 @@ function useDataRows(alias, query = {}, scope) {
     hasMore: Boolean(q.hasNextPage),
     error: asRecordsError(q.error),
     loadMore: () => {
-      if (q.hasNextPage && !q.isFetchingNextPage) void q.fetchNextPage();
+      if (!q.hasNextPage || q.isFetchingNextPage) return;
+      want.current = { key: keyHash, pages: loaded + 1 };
+      owedPages(qc).set(keyHash, { pages: loaded + 1, fetchNext: () => void q.fetchNextPage({ cancelRefetch: false }) });
+      if (!q.isFetching) void q.fetchNextPage({ cancelRefetch: false });
     },
     newer: q.data?.newer ?? 0,
     refresh: () => void q.refetch()
@@ -43436,7 +43557,7 @@ function useDataMutations(alias, scope) {
         if (before) patchRow(qc, portKey, alias, drawPatch(before, patch), { force: true });
         const answer = await port.update(alias, id, patch, baseVersion);
         if (answer.ok) {
-          patchRow(qc, portKey, alias, answer.data, { force: true });
+          patchRow(qc, portKey, alias, answer.data, { force: true, fromStore: true });
           return answer;
         }
         if (before) patchRow(qc, portKey, alias, before, { force: true });