@bendyline/squisq-grid-react 2.11.12 → 2.11.13

package/dist/index.d.ts

@@ -202,10 +202,12 @@ declare function buildKernelSource(): string;
 interface KernelHost {
     post(message: KernelRequest, transfer?: Transferable[]): void;
     onResponse: (message: KernelResponse) => void;
+    onFailure: (error: Error) => void;
     terminate(): void;
 }
 /** In-process host: drives `tableKernel` directly (SSR/tests/parity). */
 declare class LocalKernelHost implements KernelHost {
+    onFailure: (error: Error) => void;
     onResponse: (message: KernelResponse) => void;
     private readonly scope;
     constructor();
@@ -215,6 +217,8 @@ declare class LocalKernelHost implements KernelHost {
 interface TableStoreClientOptions {
     /** Force the in-process host (tests, SSR probes). */
     forceLocal?: boolean;
+    /** Maximum wait for a worker response; default 30 seconds. */
+    requestTimeoutMs?: number;
 }
 declare class TableStoreClient implements TableQueryProvider {
     private readonly host;
@@ -222,8 +226,11 @@ declare class TableStoreClient implements TableQueryProvider {
     private seq;
     private viewRowCount;
     private readonly pending;
+    private failure;
+    private readonly requestTimeoutMs;
     private ready;
     constructor(table: IngestTable, options?: TableStoreClientOptions);
+    private fail;
     private request;
     describe(): Promise<TableSchema>;
     setView(view: TableViewState): Promise<TableViewResult>;
@@ -244,10 +251,9 @@ declare class TableStoreClient implements TableQueryProvider {
  * identity was never derived from values.
  *
  * Batches are the undo unit (one commit = one batch). The journal is
- * additionally cached module-level by `(cacheKey)` — conventionally
- * `${path}@${mediaRevision}` — so a widget unmount/remount (ProseMirror
- * re-decoration) does not lose unsaved edits; a revision bump (save or
- * re-upload) naturally misses the cache and starts clean.
+ * additionally cached by storage owner, path, and region so a widget
+ * unmount/remount does not lose unsaved edits. Scoped journals survive
+ * revision bumps; saving acknowledges only the persisted snapshot.
  */
 
 interface JournalEntry {
@@ -273,17 +279,25 @@ declare class EditJournal {
     redo(): TableCellEdit[];
     /** Net outstanding edits (what a Save must persist). */
     entries(): JournalEntry[];
+    /** Advance the save baseline without losing edits (or undo) made during I/O. */
+    acknowledge(saved: readonly JournalEntry[]): void;
     clear(): void;
     private applyLatest;
     private rebuildLatest;
 }
+interface JournalScope {
+    /** Container or provider that owns the bytes; never a relative file path. */
+    owner: object;
+    /** Worksheet, region anchor, and header interpretation. */
+    region: string;
+}
 /**
- * Get (or create) the journal for a cache key. Any entry for the same path
- * at a DIFFERENT revision is discarded — a revision bump means the bytes
- * changed underneath the edits.
+ * Get the journal for an owner/path/region. Scoped edits survive a revision
+ * change elsewhere in the container. Legacy unscoped callers start clean
+ * at each revision, preserving the original two-argument API.
  */
-declare function journalFor(path: string, revision: number): EditJournal;
-declare function discardJournal(path: string): void;
+declare function journalFor(path: string, revision: number, scope?: JournalScope): EditJournal;
+declare function discardJournal(path: string, scope?: JournalScope): void;
 
 /**
  * DataGrid — the virtualized grid over a `TableQueryProvider`.

package/dist/index.js

@@ -399,6 +399,8 @@ function buildKernelSource() {
 import { parseTableViewState, serializeTableViewState } from "@bendyline/squisq/table";
 var LocalKernelHost = class {
   constructor() {
+    this.onFailure = () => {
+    };
     this.onResponse = () => {
     };
     const scope = {
@@ -417,6 +419,8 @@ var LocalKernelHost = class {
 };
 var BlobWorkerHost = class {
   constructor() {
+    this.onFailure = () => {
+    };
     this.onResponse = () => {
     };
     const url = URL.createObjectURL(new Blob([buildKernelSource()], { type: "text/javascript" }));
@@ -428,6 +432,11 @@ var BlobWorkerHost = class {
     this.worker.onmessage = (event) => {
       this.onResponse(event.data);
     };
+    this.worker.onerror = (event) => {
+      event.preventDefault();
+      this.onFailure(new Error(event.message || "Table worker failed"));
+    };
+    this.worker.onmessageerror = () => this.onFailure(new Error("Table worker response could not be decoded"));
   }
   post(message, transfer) {
     this.worker.postMessage(message, transfer ?? []);
@@ -452,6 +461,8 @@ var TableStoreClient = class {
   constructor(table, options = {}) {
     this.seq = 0;
     this.pending = /* @__PURE__ */ new Map();
+    this.failure = null;
+    this.requestTimeoutMs = options.requestTimeoutMs ?? 3e4;
     const columnar = buildColumnarTable(table);
     this.schema = {
       columns: columnar.columns.map((column) => ({ name: column.name, kind: column.kind })),
@@ -460,12 +471,14 @@ var TableStoreClient = class {
     this.viewRowCount = columnar.rowCount;
     this.host = options.forceLocal || typeof Worker === "undefined" ? new LocalKernelHost() : new BlobWorkerHost();
     this.host.onResponse = (message) => {
-      const resolve = this.pending.get(message.seq);
-      if (resolve) {
+      const waiter = this.pending.get(message.seq);
+      if (waiter) {
         this.pending.delete(message.seq);
-        resolve(message);
+        clearTimeout(waiter.timer);
+        waiter.respond(message);
       }
     };
+    this.host.onFailure = (error) => this.fail(error);
     const payloads = columnar.columns.map(toPayload);
     this.ready = this.request(
       (seq) => ({
@@ -476,19 +489,43 @@ var TableStoreClient = class {
       }),
       payloads.flatMap((entry) => entry.transfer)
     ).then(() => void 0);
+    void this.ready.catch(() => void 0);
+  }
+  fail(error) {
+    if (this.failure) return;
+    this.failure = error;
+    for (const waiter of this.pending.values()) {
+      clearTimeout(waiter.timer);
+      waiter.reject(error);
+    }
+    this.pending.clear();
+    this.host.terminate();
   }
   request(build, transfer) {
+    if (this.failure) return Promise.reject(this.failure);
     const seq = ++this.seq;
     return new Promise((resolve, reject) => {
-      this.pending.set(seq, (message) => {
-        if (message.type === "error") reject(new Error(message.message));
-        else resolve(message);
+      this.pending.set(seq, {
+        respond: (message) => {
+          if (message.type === "error") reject(new Error(message.message));
+          else resolve(message);
+        },
+        reject,
+        timer: setTimeout(
+          () => this.fail(new Error("Table worker request timed out")),
+          this.requestTimeoutMs
+        )
       });
-      this.host.post(build(seq), transfer);
+      try {
+        this.host.post(build(seq), transfer);
+      } catch (error) {
+        this.fail(error instanceof Error ? error : new Error(String(error)));
+      }
     });
   }
   async describe() {
     await this.ready;
+    if (this.failure) throw this.failure;
     return this.schema;
   }
   async setView(view) {
@@ -546,9 +583,12 @@ var TableStoreClient = class {
     return this.viewRowCount;
   }
   dispose() {
-    this.host.post({ type: "dispose" });
-    this.host.terminate();
-    this.pending.clear();
+    if (this.failure) return;
+    try {
+      this.host.post({ type: "dispose" });
+    } finally {
+      this.fail(new Error("Table store disposed"));
+    }
   }
 };
 
@@ -602,7 +642,22 @@ var EditJournal = class {
   }
   /** Net outstanding edits (what a Save must persist). */
   entries() {
-    return [...this.latest.values()];
+    return [...this.latest.values()].map((entry) => ({ ...entry }));
+  }
+  /** Advance the save baseline without losing edits (or undo) made during I/O. */
+  acknowledge(saved) {
+    const remaining = new Map(
+      this.entries().map((entry) => [`${entry.rowId}:${entry.col}`, entry])
+    );
+    for (const entry of saved) {
+      const key = `${entry.rowId}:${entry.col}`;
+      const current = remaining.get(key);
+      const next = current ? current.next : entry.prev;
+      if (next === entry.next) remaining.delete(key);
+      else remaining.set(key, { ...entry, prev: entry.next, next });
+    }
+    this.clear();
+    this.commit([...remaining.values()]);
   }
   clear() {
     this.latest.clear();
@@ -624,21 +679,38 @@ var EditJournal = class {
   }
 };
 var journalCache = /* @__PURE__ */ new Map();
-function journalFor(path, revision) {
-  const key = `${revision} ${path}`;
-  let journal = journalCache.get(key);
+var scopedCaches = /* @__PURE__ */ new WeakMap();
+function cacheFor(scope) {
+  if (!scope) return journalCache;
+  let cache = scopedCaches.get(scope.owner);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    scopedCaches.set(scope.owner, cache);
+  }
+  return cache;
+}
+function journalFor(path, revision, scope) {
+  const cache = cacheFor(scope);
+  const identity = JSON.stringify([path, scope?.region ?? ""]);
+  const key = `${revision} ${identity}`;
+  let journal = cache.get(key);
   if (!journal) {
-    for (const existing of journalCache.keys()) {
-      if (existing.endsWith(` ${path}`) && existing !== key) journalCache.delete(existing);
+    for (const [existing, previous] of cache) {
+      if (existing.endsWith(` ${identity}`) && existing !== key) {
+        if (scope) journal = previous;
+        cache.delete(existing);
+      }
     }
-    journal = new EditJournal();
-    journalCache.set(key, journal);
+    journal ?? (journal = new EditJournal());
+    cache.set(key, journal);
   }
   return journal;
 }
-function discardJournal(path) {
-  for (const existing of [...journalCache.keys()]) {
-    if (existing.endsWith(` ${path}`)) journalCache.delete(existing);
+function discardJournal(path, scope) {
+  const cache = cacheFor(scope);
+  const identity = JSON.stringify([path, scope?.region ?? ""]);
+  for (const existing of [...cache.keys()]) {
+    if (existing.endsWith(` ${identity}`)) cache.delete(existing);
   }
 }
 
@@ -783,13 +855,32 @@ function DataGrid({
   const selectionCells = useRef(/* @__PURE__ */ new Map());
   const viewRef = useRef(view);
   viewRef.current = view;
-  const editable = Boolean(journal && provider.applyEdits && !readOnlyReason);
+  const editCallbacksRef = useRef({ formulaSupport, onCellEdited });
+  editCallbacksRef.current = { formulaSupport, onCellEdited };
+  const restoreRef = useRef(Promise.resolve());
+  const writable = Boolean(journal && provider.applyEdits && !readOnlyReason);
+  const editable = writable && !saving;
   const dirtyCount = journal?.dirtyCount ?? 0;
   void dirtyTick;
   void fetchTick;
   useEffect(() => {
     let cancelled = false;
-    provider.describe().then(
+    const restore = async () => {
+      const edits = journal?.entries().filter(
+        ({ rowId, col }) => !editCallbacksRef.current.formulaSupport?.getFormula(rowId, col)
+      ).map(({ rowId, col, next }) => ({ rowId, col, value: next })) ?? [];
+      if (edits.length && provider.applyEdits) {
+        await provider.applyEdits(edits);
+        for (const edit of edits) {
+          if (cancelled) break;
+          const updates = await editCallbacksRef.current.onCellEdited?.(edit);
+          if (updates?.length) await provider.applyEdits(updates);
+        }
+      }
+      return provider.describe();
+    };
+    restoreRef.current = restore();
+    restoreRef.current.then(
       (described) => {
         if (!cancelled) setSchema(described);
       },
@@ -798,9 +889,10 @@ function DataGrid({
     return () => {
       cancelled = true;
     };
-  }, [provider]);
+  }, [provider, journal]);
   const applyView = useCallback(
     async (next) => {
+      await restoreRef.current;
       const result = await provider.setView(next);
       cache.current = { version: cache.current.version + 1, pages: /* @__PURE__ */ new Map() };
       inFlight.current.clear();
@@ -814,7 +906,7 @@ function DataGrid({
     [provider]
   );
   useEffect(() => {
-    void applyView(view);
+    void applyView(view).catch(() => void 0);
   }, [applyView, JSON.stringify(serializeTableViewState2(view))]);
   const virtualizer = useVirtualizer({
     count: viewRowCount,
@@ -909,14 +1001,15 @@ function DataGrid({
     (pos, seed) => {
       if (!editable || !schema) return;
       const current = cellAt(pos.row);
-      if (current && isCellLocked?.(current.rowId, pos.col)) {
+      if (!current) return;
+      if (isCellLocked?.(current.rowId, pos.col)) {
         setAnnounce(lockedReason ?? "This cell is locked");
         return;
       }
-      const formula = current ? formulaSupport?.getFormula(current.rowId, pos.col) : void 0;
+      const formula = formulaSupport?.getFormula(current.rowId, pos.col);
       setEditing({
         ...pos,
-        draft: seed ?? (formula !== void 0 ? `=${formula}` : cellDisplay(current?.cells[pos.col] ?? null))
+        draft: seed ?? (formula !== void 0 ? `=${formula}` : cellDisplay(current.cells[pos.col] ?? null))
       });
     },
     [cellAt, editable, schema, isCellLocked, lockedReason, formulaSupport]
@@ -941,6 +1034,7 @@ function DataGrid({
     setFetchTick((t) => t + 1);
   }, []);
   const commitEdit = useCallback(async () => {
+    if (!editable) return false;
     if (!editing || !schema || !journal || !provider.applyEdits) return true;
     if (formulaSupport && editing.draft.trim().startsWith("=")) {
       const located2 = cellAt(editing.row);
@@ -999,10 +1093,20 @@ function DataGrid({
     }
     setDirtyTick((t) => t + 1);
     return true;
-  }, [applyCacheUpdates, cellAt, editing, formulaSupport, journal, onCellEdited, provider, schema]);
+  }, [
+    applyCacheUpdates,
+    cellAt,
+    editable,
+    editing,
+    formulaSupport,
+    journal,
+    onCellEdited,
+    provider,
+    schema
+  ]);
   const handlePaste = useCallback(
     (event) => {
-      if (!selection || !schema || !journal || !provider.applyEdits || editing) return;
+      if (!editable || !selection || !schema || !journal || !provider.applyEdits || editing) return;
       const target = event.target;
       if (target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement) return;
       const text = event.clipboardData.getData("text/plain");
@@ -1073,6 +1177,7 @@ function DataGrid({
     [
       applyCacheUpdates,
       cellAt,
+      editable,
       editing,
       isCellLocked,
       journal,
@@ -1085,16 +1190,23 @@ function DataGrid({
   );
   const runJournal = useCallback(
     async (direction) => {
-      if (!journal || !provider.applyEdits) return;
+      if (!editable || !journal || !provider.applyEdits) return;
       const edits = direction === "undo" ? journal.undo() : journal.redo();
       if (edits.length === 0) return;
       const result = await provider.applyEdits(edits);
       if (result.staleView) setStaleView(true);
+      for (const edit of edits) {
+        const dependents = await onCellEdited?.(edit);
+        if (dependents?.length) {
+          const applied = await provider.applyEdits(dependents);
+          if (applied.staleView) setStaleView(true);
+        }
+      }
       cache.current.pages.clear();
       setDirtyTick((t) => t + 1);
       setFetchTick((t) => t + 1);
     },
-    [journal, provider]
+    [editable, journal, provider, onCellEdited]
   );
   const cycleSort = useCallback(
     (columnName, additive) => {
@@ -1728,7 +1840,7 @@ function DataGrid({
             }
           ),
           readOnlyReason && /* @__PURE__ */ jsx("span", { className: "squisq-grid-readonly", children: readOnlyReason }),
-          editable && dirtyCount + extraDirtyCount > 0 && /* @__PURE__ */ jsxs("span", { className: "squisq-grid-dirtybar", children: [
+          writable && dirtyCount + extraDirtyCount > 0 && /* @__PURE__ */ jsxs("span", { className: "squisq-grid-dirtybar", children: [
             (dirtyCount + extraDirtyCount).toLocaleString(),
             " unsaved edit",
             dirtyCount + extraDirtyCount === 1 ? "" : "s",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bendyline/squisq-grid-react",
-  "version": "2.11.12",
+  "version": "2.11.13",
   "description": "Virtualized data grid for squisq data sidecars: columnar worker store, TableQueryProvider, and a TanStack-Virtual React renderer",
   "license": "MIT",
   "author": "Bendyline",
@@ -53,7 +53,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@bendyline/squisq": "2.11.11",
+    "@bendyline/squisq": "2.11.12",
     "@tanstack/react-virtual": "3.14.10"
   },
   "peerDependencies": {