@fileverse-dev/dsheet 4.1.23-stabilise-package-4 → 4.1.23-stabilise-package-6

package/dist/editor/hooks/use-celldata-compaction.d.ts

@@ -3,6 +3,10 @@ import { WorkbookInstance, Sheet } from '../../sheet-engine/react';
 import { planYdocCompaction } from '../utils/compact-committed-celldata';
 
 import * as Y from 'yjs';
+/** Wait before a refused or stopped run is tried again. */
+export declare const COMPACTION_RETRY_MS = 30000;
+/** Tries after the first run; the compaction is also retried on a later open. */
+export declare const COMPACTION_MAX_RETRIES = 10;
 type UseCelldataCompactionArgs = {
     dsheetId: string;
     ydocRef: RefObject<Y.Doc | null>;
@@ -26,6 +30,23 @@ export declare function canRunCompaction(refs: {
     remoteUpdateRef: MutableRefObject<boolean>;
     structuralRemountPendingRef?: MutableRefObject<boolean>;
 }, collabSyncing: boolean): boolean;
+/**
+ * Runs `attempt` and, when it asks for a retry (the gate was closed, or a run
+ * stopped because the document changed), calls `retry` after `delayMs`, up to
+ * `maxRetries` times. Without it a refused run waited for the next open, so
+ * compaction made one chunk of progress per open (PR 466 N10).
+ */
+export declare function createCompactionRetrier({ attempt, retry, delayMs, maxRetries, setTimer, clearTimer, }: {
+    attempt: () => Promise<'done' | 'retry'>;
+    retry: () => void;
+    delayMs?: number;
+    maxRetries?: number;
+    setTimer?: (cb: () => void, ms: number) => ReturnType<typeof setTimeout>;
+    clearTimer?: (handle: ReturnType<typeof setTimeout>) => void;
+}): {
+    run(): Promise<void>;
+    cancel(): void;
+};
 /**
  * Applies the plan chunk by chunk, yielding between chunks. The plan was made
  * from the document as it was, and one change in it, the whole-value

package/dist/editor/utils/remote-apply-guard.d.ts

@@ -34,26 +34,23 @@ export type StructuralRemountRefs = RemoteApplyGuardRefs & {
 /**
  * Debounced structural remount under the remote-apply guard.
  *
- * The guard is begun once, right before `run`, and ended after paint, so each
- * remount owns exactly one begin and one end. It is NOT held while the timer
- * is merely pending or deferred by a cell edit: `remoteUpdateRef` makes
- * handleChange and the data-block work in afterUpdateCell drop local work, so
- * holding it across an edit would drop the user's typed edit. (The cell write
- * in afterUpdateCell and the commit-time write do not check it.) What must not
- * run while a remount is pending is the engine → Yjs echo hooks, which diff
- * the old grid against Yjs: they check `shouldSkipEchoWrite`. Events that
- * land while one is pending only re-arm its timer.
+ * Each pending remount owns exactly one begin and one end (B1): the guard is
+ * begun when the remount becomes pending (no remount was pending before),
+ * held while the timer is pending or deferred by a cell edit (B3), and ended
+ * after paint once `run` has finished. Events that land while one is pending
+ * only re-arm its timer.
  *
  * While `isEditing()` is true at fire time the timer re-arms (250 ms) and the
- * pending flag is kept; the remount runs once the edit ends.
+ * pending flag and guard depth are kept; the remount runs once the edit ends.
+ * The typed cell itself is still written: the commit-time write and the cell
+ * write in afterUpdateCell do not check the guard.
  */
 export declare function scheduleStructuralRemount(refs: StructuralRemountRefs, run: () => void, delayMs?: number, isEditing?: () => boolean): void;
 /** Re-arm interval while a cell edit blocks the remount. */
 export declare const STRUCTURAL_REMOUNT_EDIT_RETRY_MS = 250;
 /**
- * Drop a pending structural remount (observer teardown). The guard is only
- * held while `run` executes and until paint afterwards, so there is nothing
- * to release here.
+ * Drop a pending structural remount (observer teardown) and release the
+ * guard begun for it.
  */
 export declare function cancelStructuralRemount(refs: StructuralRemountRefs): void;
 /**