@fileverse-dev/dsheet 4.1.23-stabilise-package-8 → 4.1.24

package/README.md

@@ -86,7 +86,6 @@ function App() {
 | `isCollaborative` | `boolean` | `false` | Enable collaborative features |
 | `enableWebrtc` | `boolean` | `true` | Enable WebRTC for P2P collaboration |
 | `enableIndexeddbSync` | `boolean` | `true` | Enable local IndexedDB persistence |
-| `onIndexedDbError` | `(error: Error) => void` | - | Called when local persistence fails, or when the first read of the local store does not finish within 15 s. The editor continues with the in-memory document; call `rebuildLocalStore()` to recreate the store |
 | `isTemplateOpen` | `boolean` | - | Template sidebar state |
 | `selectedTemplate` | `string` | - | Selected template identifier |
 | `onboardingComplete` | `boolean` | - | Onboarding completion status |
@@ -116,15 +115,6 @@ function App() {
 | `setInputFetchURLDataBlock` | `Dispatch<SetStateAction<string>>` | URL input state setter |
 | `setForceSheetRender` | `Dispatch<SetStateAction<number>>` | Force re-render trigger |
 
-### Editor handle methods
-
-`sheetEditorRef` is a `DSheetEditorHandle`: the workbook instance plus these methods.
-
-| Method | Description |
-|--------|-------------|
-| `rebuildLocalStore()` | `Promise<void>`. Deletes this sheet's IndexedDB database and rewrites it from the live document, so local edits are kept. A no-op when read-only or when `enableIndexeddbSync` is off. Rejects if the rebuild fails, the new store does not sync within 15 s, or a refresh or unmount supersedes it. Concurrent calls share one rebuild. |
-| `getContentFingerprint()` | `string \| null`. Changes on every document change, deletes included; compare with `===` only. `null` until local persistence has synced. |
-
 ## Examples
 
 ### Read-Only Viewer

package/dist/editor/contexts/editor-context.d.ts

@@ -10,7 +10,6 @@ import { UseSmartContractReturn } from '../hooks/use-smart-contract';
 import { CollaborationProps, CollabState, CollabUser } from '../../sync-local/types';
 import { Awareness } from 'y-protocols/awareness';
 import { DSheetContentSnapshot } from '../../persistence';
-import { DSheetContentChange } from '../utils/content-change';
 
 import * as Y from 'yjs';
 export interface EditorContextType {
@@ -21,8 +20,6 @@ export interface EditorContextType {
     getDocumentTitle?: (dsheetId: string) => Promise<string>;
     updateDocumentTitle?: (title: string) => void;
     isAuthorized: boolean;
-    /** True once the sheet's meta.format is above what this client supports. */
-    formatLocked?: boolean;
     dataBlockCalcFunction: {
         [key: string]: {
             [key: string]: any;
@@ -34,19 +31,14 @@ export interface EditorContextType {
         };
     }>>;
     refreshIndexedDB: () => Promise<void>;
-    rebuildLocalStore: () => Promise<void>;
     sheetEditorRef: React.MutableRefObject<WorkbookInstance | null>;
     setSheetEditorRef: React.RefCallback<WorkbookInstance>;
-    /** Call when the active sheet changes or sheets appear; lets the keeper remember or restore it. */
-    notifyActiveSheetChange: () => void;
     ydocRef: React.MutableRefObject<Y.Doc | null>;
     persistenceRef: React.MutableRefObject<IndexeddbPersistence | null>;
     sheetData: Sheet[];
     setSheetData: React.Dispatch<React.SetStateAction<Sheet[]>>;
     currentDataRef: React.MutableRefObject<Sheet[]>;
     remoteUpdateRef: React.MutableRefObject<boolean>;
-    /** True while a peer's structural edit waits to remount the grid. */
-    structuralRemountPendingRef: React.MutableRefObject<boolean>;
     handleChange: (data: Sheet[]) => void;
     initialiseLiveQueryData: (data: Sheet[]) => void;
     loading: boolean;
@@ -88,7 +80,6 @@ interface EditorProviderProps {
     enableIndexeddbSync?: boolean;
     isReadOnly?: boolean;
     onContentUpdate?: () => void;
-    onContentChange?: (change: DSheetContentChange) => void;
     onChange?: (data: SheetUpdateData, encodedUpdate?: string) => void;
     collaboration?: CollaborationProps;
     externalEditorRef?: React.Ref<DSheetEditorHandle>;

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

@@ -1,12 +1,7 @@
 import { MutableRefObject, RefObject } from 'react';
 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;
+import type * as Y from 'yjs';
 type UseCelldataCompactionArgs = {
     dsheetId: string;
     ydocRef: RefObject<Y.Doc | null>;
@@ -17,48 +12,11 @@ type UseCelldataCompactionArgs = {
     isDataLoaded: boolean;
     isReadOnly: boolean;
     remoteUpdateRef: MutableRefObject<boolean>;
-    /** True while a structural remote change waits to remount the Workbook. */
-    structuralRemountPendingRef?: MutableRefObject<boolean>;
     collabSyncing: boolean;
 };
-/**
- * False while a remote apply is running, while a structural remount is pending
- * (the engine still has the old grid and the Yjs document has the new one) or
- * while collaboration is still syncing.
- */
-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
- * borderInfo write, would overwrite a newer value. So the run stops, leaving
- * the compaction unfinished (it is retried on a later open), as soon as the
- * document differs from what the previous chunk left. Returns true when every
- * chunk was applied.
- */
-export declare function applyCompactionChangesInChunks(ydoc: Y.Doc, dsheetId: string, changes: ReturnType<typeof planYdocCompaction>['changes'], handleOnChangePortalUpdate: () => void, isCancelled: () => boolean, sheetEditorRef: RefObject<WorkbookInstance | null>, chunkSize?: number): Promise<boolean>;
 /**
  * One-shot background compaction (celldata + borderInfo). Completion is stored
  * on the anchor sheet's config in Yjs so it syncs across devices.
  */
-export declare function useCelldataCompaction({ dsheetId, ydocRef, sheetEditorRef, currentDataRef, handleOnChangePortalUpdate, syncStatus, isDataLoaded, isReadOnly, remoteUpdateRef, structuralRemountPendingRef, collabSyncing, }: UseCelldataCompactionArgs): void;
+export declare function useCelldataCompaction({ dsheetId, ydocRef, sheetEditorRef, currentDataRef, handleOnChangePortalUpdate, syncStatus, isDataLoaded, isReadOnly, remoteUpdateRef, collabSyncing, }: UseCelldataCompactionArgs): void;
 export {};

package/dist/editor/hooks/use-editor-data.d.ts

@@ -21,7 +21,6 @@ export declare const useEditorData: (ydocRef: React.MutableRefObject<Y.Doc | nul
     setSheetData: import('react').Dispatch<import('react').SetStateAction<Sheet[]>>;
     currentDataRef: import('react').MutableRefObject<Sheet[]>;
     remoteUpdateRef: import('react').MutableRefObject<boolean>;
-    structuralRemountPendingRef: import('react').MutableRefObject<boolean>;
     isDataLoaded: boolean;
     setIsDataLoaded: import('react').Dispatch<import('react').SetStateAction<boolean>>;
     handleChange: (_data: Sheet[]) => void;

package/dist/editor/hooks/use-editor-sync.d.ts

@@ -1,17 +1,13 @@
 import { IndexeddbPersistence } from 'y-indexeddb';
 import { CollaborationProps } from '../../sync-local/types';
-import { DSheetContentChange } from '../utils/content-change';
 import * as Y from 'yjs';
-export declare const useEditorSync: (dsheetId: string, enableIndexeddbSync?: boolean, isReadOnly?: boolean, portalContent?: string, collaboration?: CollaborationProps, onRemoteApplied?: (update: Uint8Array) => void, onIndexedDbError?: (error: Error) => void) => {
+export declare const useEditorSync: (dsheetId: string, enableIndexeddbSync?: boolean, isReadOnly?: boolean, portalContent?: string, collaboration?: CollaborationProps, onCollabUpdate?: (fullState: string, updateChunk: string) => void, onIndexedDbError?: (error: Error) => void) => {
     ydocRef: import('react').MutableRefObject<Y.Doc | null>;
     persistenceRef: import('react').MutableRefObject<IndexeddbPersistence | null>;
     syncStatus: "error" | "syncing" | "initializing" | "synced";
     isContentBootstrapReady: boolean;
     refreshIndexedDB: () => Promise<void>;
-    rebuildLocalStore: () => Promise<void>;
     getContentSnapshot: () => import('../../persistence-utils').DSheetContentSnapshot;
-    getContentFingerprint: () => string | null;
-    getContentChange: () => DSheetContentChange;
     mergeContent: (encodedState: string) => import('../../persistence-utils').DSheetContentSnapshot;
     collabState: import('../..').CollabState;
     isCollabReady: boolean;

package/dist/editor/types.d.ts

@@ -5,13 +5,11 @@ import { CollaborationProps } from '../sync-local/types';
 import { CommentsConfig } from './types/comments';
 import { SmartContractConfig } from './types/smart-contract';
 import { ApiKeyStorage } from './utils/api-key-storage';
-import { DSheetContentChange } from './utils/content-change';
 import { ThemeKey } from '../sheet-engine/core/theme';
 import { DSheetContentSnapshot } from '../persistence';
 import { NavigateToSheetOptions } from './utils/navigate-to-sheet';
 
 import * as Y from 'yjs';
-export type { DSheetContentChange } from './utils/content-change';
 export type { ThemeKey } from '../sheet-engine/core/theme';
 export type DSheetPermissionMode = 'view' | 'comment' | 'edit';
 export type { CommentThread, CommentReply, CommentActionParams, CommentsConfig, CommentAnchorMove, } from './types/comments';
@@ -28,20 +26,6 @@ export interface EditorValues {
 }
 export type DSheetEditorHandle = WorkbookInstance & {
     refreshIndexedDB: () => Promise<void>;
-    /**
-     * Delete this sheet's IndexedDB database and rewrite it from the live
-     * document (same Y.Doc, never replaced), so local edits are kept. Resolves
-     * once the new store has synced. Resolves as a no-op when the editor is
-     * read-only, local persistence is disabled or there is no sheet id. Rejects
-     * if the rebuild fails, if the new store does not sync within 15 s, or if a
-     * refresh/unmount supersedes it. Concurrent calls share one rebuild.
-     *
-     * A bootstrap that is still waiting on an unreadable store (the case this
-     * heals) is abandoned after 3 s: the rebuild then finishes the bootstrap
-     * itself, merging the published content into the document, so the editor
-     * leaves "syncing" once the rebuild resolves.
-     */
-    rebuildLocalStore: () => Promise<void>;
     terminateSession: () => void;
     updateCollaboratorName: (name: string) => void;
     updateSessionTitle: (args: {
@@ -49,13 +33,6 @@ export type DSheetEditorHandle = WorkbookInstance & {
         documentTitle: string;
     }) => void;
     navigateToSheet: (sheetId: string, opts?: NavigateToSheetOptions) => Promise<boolean>;
-    /**
-     * Content fingerprint: base64 state vector + ":" + deleted count. Changes
-     * on every change, deletes included; compare with === only. null until
-     * y-indexeddb is attached and synced; use fingerprintFromUpdate of the
-     * IndexedDB body then.
-     */
-    getContentFingerprint: () => string | null;
 };
 export interface PanelConfig {
     id: string;
@@ -107,27 +84,10 @@ export interface DsheetProps {
      * Unlike `onChange`, this does not build a plain sheet or encode the Y.Doc.
      */
     onContentUpdate?: () => void;
-    /**
-     * Cheap change signal (Stabilize A1): `hasContent`, `userEdited` and the
-     * content `fingerprint`, computed without encoding the Y.Doc. At most one
-     * call per second (trailing), flushed on pagehide, beforeunload and unmount.
-     * Read full state on demand with `editorStateRef.getContentSnapshot()`.
-     */
-    onContentChange?: (change: DSheetContentChange) => void;
-    /**
-     * @deprecated Encodes the whole Y.Doc and rebuilds a plain workbook per
-     * call. Use `onContentChange` and read full state on demand. Called at most
-     * once per second (trailing), flushed only on unload and unmount. The latest
-     * `onChange` you pass is the one called, so an inline function is safe: a new
-     * identity does not cancel a pending call.
-     */
     onChange?: (updateData: SheetUpdateData, encodedUpdate?: string) => void;
     collaboration?: CollaborationProps;
     /** Called when local IndexedDB persistence fails. The editor and durable
-     * collaboration continue using the in-memory Y.Doc, matching dDoc. Also
-     * called when the first read of the local store does not finish within 15 s
-     * (the editor then continues without local persistence, and
-     * `rebuildLocalStore()` can recreate the store). */
+     * collaboration continue using the in-memory Y.Doc, matching dDoc. */
     onIndexedDbError?: (error: Error) => void;
     username?: string;
     portalContent?: string;

package/dist/editor/utils/after-update-cell.d.ts

@@ -50,13 +50,7 @@ interface AfterUpdateCellParams {
     collabEnabled?: boolean;
     collabIsOwner?: boolean;
     remoteUpdateRef?: React.MutableRefObject<boolean>;
-    /** True while a peer's structural edit waits to remount the grid. */
-    structuralRemountPendingRef?: React.MutableRefObject<boolean>;
     localUserEditRef?: React.MutableRefObject<boolean>;
-    /** Sheet that held the cell at commit time; falls back to the current sheet. */
-    sheetId?: string;
-    /** The caller writes the cell to Yjs itself (paste and fill batch writes). */
-    skipPersist?: boolean;
 }
 /** True when data-block formulas (API / smart contract) should run for this edit. */
 export declare const shouldExecuteDataBlocks: (params: {

package/dist/editor/utils/apply-comment-markers.d.ts

@@ -8,9 +8,7 @@ type CommentData = object | null | undefined;
  * `null`, so a tiny `{ ps }` object is created in the live view only so the
  * triangle can render. Row/column drag still owns real cell data.
  *
- * Updates the given arrays in place and returns them. Sparse celldata entries
- * are replaced with copies, never written into, because they may be Yjs
- * content (see ySheetArrayToPlain).
+ * Mutates in place and returns the same array.
  */
 export declare const applyCommentMarkers: <T>(sheets: T | null | undefined, commentData: CommentData, allowComments: boolean | undefined) => T | null | undefined;
 export {};

package/dist/editor/utils/editor-handle.d.ts

@@ -2,7 +2,7 @@ import { Ref } from 'react';
 import { WorkbookInstance } from '../../sheet-engine/react';
 import { DSheetEditorHandle } from '../types';
 
-export type DSheetEditorMethods = Pick<DSheetEditorHandle, "refreshIndexedDB" | "rebuildLocalStore" | "terminateSession" | "updateCollaboratorName" | "updateSessionTitle" | "navigateToSheet" | "getContentFingerprint">;
+export type DSheetEditorMethods = Pick<DSheetEditorHandle, "refreshIndexedDB" | "terminateSession" | "updateCollaboratorName" | "updateSessionTitle" | "navigateToSheet">;
 /**
  * Compose Fortune's regenerated imperative handle with dSheet lifecycle methods.
  * React callback refs invoke this again after every Workbook remount, so both

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

@@ -11,54 +11,9 @@ export type RemoteApplyGuardRefs = {
     remoteApplyDepthRef: MutableRefObject<number>;
     remoteUpdateRef: MutableRefObject<boolean>;
 };
-/**
- * True when an engine → Yjs echo hook (calcChain, conditional formats, ...)
- * must stay quiet: a remote apply is running, or a structural remount is
- * pending. While one is pending the engine still has the grid from before the
- * peer's insert or delete, so a diff of its metadata against Yjs would write
- * the old coordinates over the peer's (and delete the peer's calcChain
- * entries). Cell commits are not echo hooks and are not held back by this.
- */
-export declare function shouldSkipEchoWrite(refs: {
-    remoteUpdateRef: MutableRefObject<boolean>;
-    structuralRemountPendingRef?: MutableRefObject<boolean>;
-}): boolean;
 export declare function syncRemoteUpdateFlag(refs: RemoteApplyGuardRefs): void;
 export declare function beginRemoteApply(refs: RemoteApplyGuardRefs): void;
 export declare function endRemoteApply(refs: RemoteApplyGuardRefs): void;
 export declare function runUnderRemoteApply(refs: RemoteApplyGuardRefs, fn: () => void): void;
-export type StructuralRemountRefs = RemoteApplyGuardRefs & {
-    pendingRef: MutableRefObject<boolean>;
-    timerRef: MutableRefObject<number | null>;
-};
-/**
- * Debounced structural remount under the remote-apply guard.
- *
- * 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 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) and release the
- * guard begun for it.
- */
-export declare function cancelStructuralRemount(refs: StructuralRemountRefs): void;
-/**
- * Run `fn` under the guard and keep it until paint (a remount follows). If
- * `fn` throws, the guard is ended at once and the error is rethrown: a begin
- * with no matching end leaves the depth above zero, and `handleChange` then
- * drops every local write until reload.
- */
-export declare function runRemoteApplyUntilPaint<T>(refs: RemoteApplyGuardRefs, fn: () => T): T;
 /** End after Workbook remount hooks have flushed (2 rAF ≈ one paint). */
 export declare function endRemoteApplyAfterPaint(refs: RemoteApplyGuardRefs): void;

package/dist/editor/utils/sheet-ydoc-sync-utils.d.ts

@@ -2,29 +2,19 @@ import { WorkbookInstance } from '../../sheet-engine/react';
 import { SheetChangePath } from './update-ydoc';
 
 import * as Y from 'yjs';
-export { readYdocSheetField } from './update-ydoc';
-/** Sheet fields the per-feature Yjs hooks sync. */
-export declare const SYNCED_SHEET_FIELDS: readonly ["calcChain", "config", "dataVerification", "luckysheet_conditionformat_save", "hyperlink", "filter", "filter_select", "liveQueryList", "dataBlockCalcFunction"];
 type SyncContext = {
     currentSheetId: string;
-    /** Only `field` is populated: the value stored in Yjs. */
     oldSheet: Record<string, any>;
-    /** The engine's current value of `field` for the active sheet. */
-    newValue: any;
-    /** The engine's active sheet, for checks against its cells. */
-    engineSheet: Record<string, any> | undefined;
     ydoc: Y.Doc;
 };
 /**
- * Old (Yjs) and new (engine) value of one field of the active sheet (A3).
- * Reads only that field: no whole-workbook conversion, and no getSheet(),
- * which rebuilds celldata from the dense grid.
+ * Build a stable sync context from current editor sheet and Yjs snapshot.
+ * This keeps all field-level sync handlers aligned on the same baseline.
  */
-export declare const getSheetYdocSyncContext: ({ sheetEditorRef, ydocRef, dsheetId, field, }: {
+export declare const getSheetYdocSyncContext: ({ sheetEditorRef, ydocRef, dsheetId, }: {
     sheetEditorRef: React.RefObject<WorkbookInstance | null>;
     ydocRef: React.RefObject<Y.Doc | null>;
     dsheetId: string;
-    field: string;
 }) => SyncContext | null;
 export declare const buildMapFieldChanges: ({ sheetId, fieldPath, oldData, newData, }: {
     sheetId: string;
@@ -38,3 +28,4 @@ export declare const applyYdocSheetChanges: ({ ydoc, dsheetId, changes, handleCo
     changes: SheetChangePath[];
     handleContentPortal?: any;
 }) => void;
+export {};

package/dist/editor/utils/update-ydoc.d.ts

@@ -17,13 +17,5 @@ export type SheetChangePath = {
 export declare const updateYdocSheetData: (ydoc: Y.Doc | null, dsheetId: string, changes: SheetChangePath[], handleContentPortal: any, onCellFormatRangesCommitted?: (commits: Array<{
     sheetId: string;
     ranges: CellFormatRange[];
-}>) => void, 
-/** Transaction origin; omit for user edits. */
-origin?: unknown) => void;
+}>) => void) => void;
 export declare function ySheetArrayToPlain(sheetArray: Y.Array<Y.Map>): Sheet[];
-/**
- * One field of one sheet, with the same value ySheetArrayToPlain gives for
- * it, without converting the rest of the workbook (A3). Shared, read-only
- * semantics as ySheetArrayToPlain.
- */
-export declare function readYdocSheetField(ydoc: Y.Doc, dsheetId: string, sheetId: string, field: string): any;