@fileverse-dev/dsheet 4.1.1-edit-mode-16 → 4.1.2-overhaul-1

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

@@ -8,7 +8,7 @@ import * as Y from 'yjs';
  * Hook for managing sheet data
  * Handles initialization, updates, and persistence of sheet data
  */
-export declare const useEditorData: (ydocRef: React.MutableRefObject<Y.Doc | null>, dsheetId: string, sheetEditorRef: React.MutableRefObject<WorkbookInstance | null>, setForceSheetRender?: React.Dispatch<React.SetStateAction<number>>, isReadOnly?: boolean, onChange?: (data: Sheet[]) => void, syncStatus?: "initializing" | "syncing" | "synced" | "error", isContentBootstrapReady?: boolean, commentData?: object, dataBlockCalcFunction?: {
+export declare const useEditorData: (ydocRef: React.MutableRefObject<Y.Doc | null>, dsheetId: string, sheetEditorRef: React.MutableRefObject<WorkbookInstance | null>, setForceSheetRender?: React.Dispatch<React.SetStateAction<number>>, portalContent?: string, isReadOnly?: boolean, onChange?: (data: Sheet[]) => void, syncStatus?: "initializing" | "syncing" | "synced" | "error", commentData?: object, dataBlockCalcFunction?: {
     [key: string]: {
         [key: string]: any;
     };
@@ -16,7 +16,7 @@ export declare const useEditorData: (ydocRef: React.MutableRefObject<Y.Doc | nul
     [key: string]: {
         [key: string]: any;
     };
-}>>, enableLiveQuery?: boolean, liveQueryRefreshRate?: number, apiKeyStorage?: ApiKeyStorage, openApiKeyModal?: OpenApiKeyModalFn, onDataBlockEvent?: (event: DataBlockEvent) => void, allowComments?: boolean, collabEnabled?: boolean) => {
+}>>, enableLiveQuery?: boolean, liveQueryRefreshRate?: number, apiKeyStorage?: ApiKeyStorage, openApiKeyModal?: OpenApiKeyModalFn, onDataBlockEvent?: (event: DataBlockEvent) => void, allowComments?: boolean, hasCollabContentInitialised?: boolean, collabEnabled?: boolean) => {
     sheetData: Sheet[];
     setSheetData: import('react').Dispatch<import('react').SetStateAction<Sheet[]>>;
     currentDataRef: import('react').MutableRefObject<Sheet[]>;

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

@@ -1,11 +1,11 @@
 import { IndexeddbPersistence } from 'y-indexeddb';
 import { CollaborationProps } from '../../sync-local/types';
 import * as Y from 'yjs';
-export declare const useEditorSync: (dsheetId: string, enableIndexeddbSync?: boolean, isReadOnly?: boolean, portalContent?: string, collaboration?: CollaborationProps, onCollabUpdate?: (fullState: string, updateChunk: string) => void, onIndexedDbError?: (error: Error) => void) => {
+export declare const useEditorSync: (dsheetId: string, enableIndexeddbSync?: boolean, isReadOnly?: boolean, collaboration?: CollaborationProps, onCollabUpdate?: (fullState: string, updateChunk: string) => void) => {
     ydocRef: import('react').MutableRefObject<Y.Doc | null>;
     persistenceRef: import('react').MutableRefObject<IndexeddbPersistence | null>;
     syncStatus: "error" | "syncing" | "initializing" | "synced";
-    isContentBootstrapReady: boolean;
+    isSyncedRef: import('react').MutableRefObject<boolean>;
     refreshIndexedDB: () => Promise<void>;
     getContentSnapshot: () => import('../../persistence-utils').DSheetContentSnapshot;
     mergeContent: (encodedState: string) => import('../../persistence-utils').DSheetContentSnapshot;
@@ -13,10 +13,6 @@ export declare const useEditorSync: (dsheetId: string, enableIndexeddbSync?: boo
     isCollabReady: boolean;
     isCollabSyncing: boolean;
     terminateSession: () => void;
-    updateTitle: (args: {
-        encryptedTitle: string;
-        documentTitle: string;
-    }) => void;
     awareness: import('y-protocols/awareness.js').Awareness | null;
     hasCollabContentInitialised: boolean;
 };

package/dist/editor/types/comments.d.ts

@@ -1,5 +1,7 @@
 import { default as React } from 'react';
+import { CommentAnchorMove } from '../../sheet-engine/core/settings';
 
+export type { CommentAnchorMove };
 export interface CommentThread {
     id: string;
     key: string;
@@ -12,6 +14,8 @@ export interface CommentThread {
     replies: CommentReply[];
     isResolved?: boolean;
     isDeleted?: boolean;
+    /** IPFS/indexer hash — stable across local `comment-*` ids and on-chain uuids. */
+    contentHash?: string;
 }
 export interface CommentReply {
     id: string;
@@ -41,6 +45,11 @@ export interface CommentsConfig {
     commentsData: Record<string, CommentThread>;
     onSendComment: (key: string, textareaId: string) => void;
     onCommentAction: (action: CommentActionParams) => void;
+    /**
+     * Called after row/column drag-drop or a cell-range move so the host can
+     * remap comment keys. Use `remapCommentAnchors` from the package.
+     */
+    onCellPositionsChanged?: (move: CommentAnchorMove) => void;
     userName?: string;
     ownerAddress?: string;
     currentUserAddress?: string;
@@ -118,6 +127,8 @@ export interface CommentCellUIProps {
     dragHandler: (e: React.MouseEvent<HTMLDivElement, MouseEvent>) => void;
     isHover?: boolean;
     disabled?: boolean;
+    isAuthenticated?: boolean;
+    unauthenticatedFallback?: React.ReactNode;
 }
 export interface CommentsContentProps {
     sheetEditorRef: React.RefObject<SheetEditorRef>;

package/dist/editor/types.d.ts

@@ -10,8 +10,7 @@ import { DSheetContentSnapshot } from '../persistence';
 
 import * as Y from 'yjs';
 export type { ThemeKey } from '../sheet-engine/core/theme';
-export type DSheetPermissionMode = 'view' | 'comment' | 'edit';
-export type { CommentThread, CommentReply, CommentActionParams, CommentsConfig, } from './types/comments';
+export type { CommentThread, CommentReply, CommentActionParams, CommentsConfig, CommentAnchorMove, } from './types/comments';
 export { CommentAction } from './types/comments';
 export interface SheetUpdateData {
     data: Sheet[];
@@ -23,15 +22,6 @@ export interface EditorValues {
     openPanel: (panelId: string) => void;
     closePanel: () => void;
 }
-export type DSheetEditorHandle = WorkbookInstance & {
-    refreshIndexedDB: () => Promise<void>;
-    terminateSession: () => void;
-    updateCollaboratorName: (name: string) => void;
-    updateSessionTitle: (args: {
-        encryptedTitle: string;
-        documentTitle: string;
-    }) => void;
-};
 export interface PanelConfig {
     id: string;
     header: {
@@ -77,23 +67,9 @@ export interface DsheetProps {
     onContentUpdate?: () => void;
     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. */
-    onIndexedDbError?: (error: Error) => void;
     username?: string;
     portalContent?: string;
     isReadOnly?: boolean;
-    /** Permission status displayed above the toolbar. When omitted, read-only
-     * sheets retain the existing View/View-and-comment behavior. */
-    permissionMode?: DSheetPermissionMode;
-    /** Called when a read-only consumer asks to elevate to edit mode. The host
-     * owns access proof, loading, errors, and the resulting mode transition. */
-    onEnterEdit?: () => void;
-    /** Called when an invited commenter needs to authenticate before the host can
-     * recover comment capability. */
-    onSignInToComment?: () => void;
-    /** Lets the host toggle a recovered commenter between comment and view mode. */
-    onViewerModeChange?: (mode: 'comment' | 'view') => void;
     allowSheetDownload?: boolean;
     isTemplateOpen?: boolean;
     selectedTemplate?: string;
@@ -104,8 +80,9 @@ export interface DsheetProps {
     setForceSheetRender?: React.Dispatch<React.SetStateAction<number>>;
     commentsConfig?: CommentsConfig;
     toggleTemplateSidebar?: () => void;
-    /** Legacy ref prop. Standard React refs are also supported. */
-    sheetEditorRef?: React.Ref<DSheetEditorHandle>;
+    sheetEditorRef?: RefObject<WorkbookInstance & {
+        refreshIndexedDB: () => Promise<void>;
+    }>;
     /** Override where datablock API keys are stored (default: localStorage). */
     apiKeyStorage?: ApiKeyStorage;
     /** Optional lifecycle events for analytics / side-effects. */
@@ -116,9 +93,6 @@ export interface DsheetProps {
      * collab start/resume on 'synced' — starting before local content is fully
      * synced is what let the RTC layer bind to a stale doc in the past. */
     onContentSyncStatusChange?: (status: 'initializing' | 'syncing' | 'synced' | 'error') => void;
-    /** Fires once the first collaboration sync has been reconciled with the
-     * workbook, or when that reconciliation fails. */
-    onCollaborationInitializationComplete?: (result: 'ready' | 'error') => void;
     editorStateRef?: React.MutableRefObject<{
         refreshIndexedDB: () => Promise<void>;
         getContentSnapshot: () => DSheetContentSnapshot;

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

@@ -4,17 +4,9 @@ type CommentData = object | null | undefined;
  * the consumer-provided `commentData`.
  *
  * `ps` is a per-client, permission-gated *view overlay* — it is NOT persisted in
- * ydoc. Every path that rebuilds sheet data from ydoc (portal load, collab sync
- * remount, remote cell edits) produces cells WITHOUT `ps`, so this must run on
- * each such snapshot or the red-triangle indicator vanishes. Because it is
- * gated on the local `allowComments` permission, it must never be written back
- * to shared ydoc state — doing so would let one viewer wipe markers for all.
- *
- * Handles both shapes:
- * - Dense `sheet.data` (the live active sheet in `luckysheetfile`).
- * - Sparse `sheet.celldata` (plain snapshots from `ySheetArrayToPlain`, and
- *   inactive sheets). `initSheetData()` converts celldata → data on activation,
- *   so `ps` set on celldata carries through.
+ * ydoc (`shouldPersistCelldataCell` ignores marker-only cells). Empty cells are
+ * `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.
  *
  * Mutates in place and returns the same array.
  */

package/dist/editor/utils/comment-anchors-ydoc.d.ts

@@ -0,0 +1,32 @@
+import * as Y from 'yjs';
+/** Sibling share key on the same Y.Doc as the sheet array. */
+export declare function getCommentAnchorsMapKey(dsheetId: string): string;
+export declare function getCommentAnchorsYMap(ydoc: Y.Doc, dsheetId: string): Y.Map<string>;
+export declare function readCommentAnchorsFromYdoc(ydoc: Y.Doc | null | undefined, dsheetId: string): Record<string, string>;
+type CommentAnchorRecord = {
+    id?: string;
+    key?: string;
+    contentHash?: string;
+};
+/**
+ * Re-key comments by identity first (id, then contentHash), then the comment's
+ * own current cell-key. Stale cell-key aliases that now belong to another
+ * thread must not steal or duplicate it.
+ */
+export declare function applyCommentAnchorMap<T extends CommentAnchorRecord>(commentsData: Record<string, T> | null | undefined, anchors: Record<string, string>): Record<string, T>;
+export declare function applyYdocCommentAnchors<T extends CommentAnchorRecord>(commentsData: Record<string, T> | object | null | undefined, ydoc: Y.Doc | null | undefined, dsheetId: string): Record<string, T>;
+/**
+ * Persist current commentId/contentHash → cell-key into ydoc so viewers/publish
+ * see the remapped positions. No-ops when the map already matches.
+ */
+export declare function writeCommentAnchorsToYdoc({ ydoc, dsheetId, commentsData, handleContentPortal, skipUnmapped, keyMoves, }: {
+    ydoc: Y.Doc | null | undefined;
+    dsheetId: string;
+    commentsData: Record<string, CommentAnchorRecord> | null | undefined;
+    handleContentPortal?: () => void;
+    /** When the map already has entries, skip comments that are not in it yet. */
+    skipUnmapped?: boolean;
+    /** old cell-key → new cell-key so indexer keys still resolve after remap. */
+    keyMoves?: Record<string, string>;
+}): void;
+export {};

package/dist/editor/utils/remap-comment-anchors.d.ts

@@ -0,0 +1,26 @@
+import { CommentAnchorMove } from '../../sheet-engine/core/settings';
+
+/**
+ * old cell-key → new cell-key, matched by comment id. Used when writing
+ * ydoc aliases so indexer keys still resolve after a remap.
+ */
+export declare function commentKeyMovesById<T extends {
+    id?: string;
+    key?: string;
+}>(before: Record<string, T>, after: Record<string, T>): Record<string, string>;
+/**
+ * Remap in-memory comment keys after a row/column drag, cell-range move,
+ * or insert/delete of rows/columns.
+ *
+ * - Row/column drag: apply the full permutation `indexMap` (no collisions).
+ * - Cells: comments in the source rectangle follow the offset; comments that
+ *   only lived in the destination are detached to `WITHOUT_CELL_<id>` so they
+ *   remain in the sidebar instead of colliding with the incoming thread.
+ * - Insert: comments at/after the insertion point shift by `count`.
+ * - Delete: comments on removed rows/cols are detached; later ones shift up/left.
+ */
+export declare function remapCommentAnchors<T extends {
+    key?: string;
+    id?: string;
+}>(commentsData: Record<string, T>, move: CommentAnchorMove): Record<string, T>;
+export type { CommentAnchorMove };