@fileverse-dev/dsheet 3.0.0 → 3.0.1-formula-1

package/dist/{constants-yStXQJiK.js → constants-Cdz6oSCq.js}

@@ -1,13 +1,11 @@
-import { E as n, S as a } from "./crypto-constants-CqpCRs86.js";
-const E = n, d = a, f = [
+import { E as a, S as n } from "./crypto-constants-CqpCRs86.js";
+const E = a, d = n, f = [
   {
     id: "0",
     name: "Sheet1",
     celldata: [],
     config: {},
-    order: 0,
-    row: 500,
-    column: 26
+    order: 0
   }
 ], m = [
   "undo",
@@ -52,8 +50,8 @@ const E = n, d = a, f = [
   "copy",
   "paste",
   "|",
-  "insert-row",
   "insert-row-above",
+  "insert-row",
   "insert-column",
   "insert-column-right",
   "insert-cells",
@@ -89,8 +87,8 @@ const E = n, d = a, f = [
   "copy",
   "paste",
   "|",
-  "insert-row",
   "insert-row-above",
+  "insert-row",
   "insert-column",
   "insert-column-right",
   "|",

package/dist/constants.js

@@ -1,4 +1,4 @@
-import { a as R, c as _, E as C, S as a, p as s } from "./constants-yStXQJiK.js";
+import { a as R, c as _, E as C, S as a, p as s } from "./constants-Cdz6oSCq.js";
 export {
   R as COLLAB_PRESENCE_COLORS,
   _ as ENS_PRESENCE_COLOR,

package/dist/editor/components/editor-workbook-sync.d.ts

@@ -19,5 +19,5 @@ export declare const createAfterOrderChangesHandler: ({ sheetEditorRef, ydocRef,
 export declare const createAfterColorChangesHandler: ({ sheetEditorRef, ydocRef, dsheetId, handleOnChangePortalUpdate, }: SyncContext) => () => void;
 export declare const createAfterHideChangesHandler: ({ sheetEditorRef, ydocRef, dsheetId, handleOnChangePortalUpdate, }: SyncContext) => () => void;
 export declare const createAfterColRowChangesHandler: ({ sheetEditorRef, ydocRef, dsheetId, handleOnChangePortalUpdate, }: SyncContext) => () => void;
-export declare const updateAllCell: ({ sheetEditorRef, ydocRef, dsheetId, handleOnChangePortalUpdate, }: SyncContext, subSheetId: string) => void;
+export declare const updateAllCell: ({ sheetEditorRef, ydocRef, dsheetId, handleOnChangePortalUpdate, }: SyncContext, subSheetId: string, caller?: string) => void;
 export {};

package/dist/editor/components/sidebar/use-right-panels.d.ts

@@ -1,4 +1,4 @@
-export type BuiltInPanelType = 'templates' | 'comments' | 'functions' | 'data-verification' | 'conditional-format';
+export type BuiltInPanelType = 'templates' | 'comments' | 'functions' | 'data-verification' | 'conditional-format' | 'named-ranges';
 export type PanelId = BuiltInPanelType | string;
 interface UseRightPanelsReturn {
     activePanel: PanelId | null;

package/dist/editor/components/sidebars/named-ranges.d.ts

@@ -0,0 +1,2 @@
+declare const NamedRanges: () => import("react/jsx-runtime").JSX.Element;
+export { NamedRanges };

package/dist/editor/constants/shared-constants.d.ts

@@ -8,8 +8,6 @@ export declare const DEFAULT_SHEET_DATA: {
     celldata: never[];
     config: {};
     order: number;
-    row: number;
-    column: number;
 }[];
 export declare const TOOL_BAR_ITEMS: string[];
 export declare const CELL_CONTEXT_MENU_ITEMS: string[];

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

@@ -0,0 +1,23 @@
+import { MutableRefObject, RefObject } from 'react';
+import { WorkbookInstance, Sheet } from '../../sheet-engine/react';
+
+import type * as Y from 'yjs';
+type UseCelldataCompactionArgs = {
+    dsheetId: string;
+    ydocRef: RefObject<Y.Doc | null>;
+    sheetEditorRef: RefObject<WorkbookInstance | null>;
+    currentDataRef: MutableRefObject<Sheet[]>;
+    handleOnChangePortalUpdate: () => void;
+    syncStatus: 'initializing' | 'syncing' | 'synced' | 'error';
+    isDataLoaded: boolean;
+    isReadOnly: boolean;
+    remoteUpdateRef: MutableRefObject<boolean>;
+    collabSyncing: boolean;
+};
+/**
+ * One-shot background compaction: remove committed celldata entries that copy/paste
+ * would never write (`shouldPersistCelldataCell` === false). Runs once per dsheetId
+ * after the editor is synced and idle so it does not compete with load or edits.
+ */
+export declare function useCelldataCompaction({ dsheetId, ydocRef, sheetEditorRef, currentDataRef, handleOnChangePortalUpdate, syncStatus, isDataLoaded, isReadOnly, remoteUpdateRef, collabSyncing, }: UseCelldataCompactionArgs): void;
+export {};

package/dist/editor/hooks/use-xlsx-import-impl.d.ts

@@ -11,6 +11,7 @@ export type XlsxImportRuntimeDeps = {
     updateDocumentTitle?: (title: string) => void;
     filterToastShown: boolean;
     setFilterToastShown: React.Dispatch<React.SetStateAction<boolean>>;
+    handleContentPortal?: () => void;
 };
 export type XlsxImportOptions = {
     headless?: boolean;
@@ -19,4 +20,4 @@ export type XlsxImportOptions = {
     generateSheetId?: () => string;
 };
 /** Full XLSX import pipeline; loaded only when user imports a file. */
-export declare function runXlsxFileUpload({ sheetEditorRef, ydocRef, setForceSheetRender, dsheetId, currentDataRef, updateDocumentTitle, filterToastShown, setFilterToastShown, }: XlsxImportRuntimeDeps, event: React.ChangeEvent<HTMLInputElement> | undefined, fileArg: File, importType?: 'new-dsheet' | 'merge-current-dsheet' | 'new-current-dsheet', options?: XlsxImportOptions): Promise<void>;
+export declare function runXlsxFileUpload({ sheetEditorRef, ydocRef, setForceSheetRender, dsheetId, currentDataRef, updateDocumentTitle, filterToastShown, setFilterToastShown, handleContentPortal, }: XlsxImportRuntimeDeps, event: React.ChangeEvent<HTMLInputElement> | undefined, fileArg: File, importType?: 'new-dsheet' | 'merge-current-dsheet' | 'new-current-dsheet', options?: XlsxImportOptions): Promise<void>;

package/dist/editor/hooks/use-xlsx-import.d.ts

@@ -7,13 +7,14 @@ type ImportType = 'new-dsheet' | 'merge-current-dsheet' | 'new-current-dsheet';
  * XLSX import: keeps ~100k+ LOC (SSF, hyperlink helpers, exceljs/luckyexcel orchestration)
  * in a separate chunk until the user actually imports a file.
  */
-export declare const useXLSXImport: ({ sheetEditorRef, ydocRef, setForceSheetRender, dsheetId, currentDataRef, updateDocumentTitle, }: {
+export declare const useXLSXImport: ({ sheetEditorRef, ydocRef, setForceSheetRender, dsheetId, currentDataRef, updateDocumentTitle, handleContentPortal, }: {
     sheetEditorRef: RefObject<WorkbookInstance | null>;
     ydocRef: RefObject<Y.Doc | null>;
     setForceSheetRender: Dispatch<SetStateAction<number>>;
     dsheetId: string;
     currentDataRef: MutableRefObject<object | null>;
     updateDocumentTitle?: (title: string) => void;
+    handleContentPortal?: () => void;
 }) => {
     handleXLSXUpload: (event: ChangeEvent<HTMLInputElement> | undefined, fileArg: File, importType?: ImportType) => Promise<void>;
 };

package/dist/editor/utils/compact-committed-celldata.d.ts

@@ -0,0 +1,28 @@
+import { CellMatrix, CellWithRowAndCol, Sheet } from '../../sheet-engine/core/types';
+import { SheetChangePath } from './update-ydoc';
+import * as Y from 'yjs';
+export declare const CELLDATA_COMPACT_STORAGE_KEY_PREFIX = "dsheet-celldata-compact-v1:";
+export type CelldataCompactionResult = {
+    removedFromYdoc: number;
+    clearedInMemory: number;
+    changes: SheetChangePath[];
+};
+export declare function celldataCompactStorageKey(dsheetId: string): string;
+export declare function hasCelldataCompactionCompleted(dsheetId: string): boolean;
+export declare function markCelldataCompactionCompleted(dsheetId: string): void;
+/** Collect Yjs celldata keys that should not be persisted (format-only / empty ghosts). */
+export declare function collectStaleCelldataKeys(celldataMap: Y.Map<unknown> | Record<string, unknown> | null | undefined): string[];
+export declare function buildCelldataDeleteChanges(sheetId: string, keys: string[]): SheetChangePath[];
+/** Null out dense-grid cells that should not be persisted. */
+export declare function compactSheetDataMatrix(data: CellMatrix | null | undefined): number;
+/** Drop sparse celldata entries that should not be persisted. */
+export declare function compactSheetCelldataArray(celldata: CellWithRowAndCol[] | null | undefined): {
+    next: CellWithRowAndCol[];
+    removed: number;
+};
+export declare function compactInMemorySheets(sheets: Sheet[] | null | undefined): number;
+/**
+ * Scan Y.Doc for committed celldata ghosts. Does not mutate — caller applies
+ * `changes` via `updateYdocSheetData`.
+ */
+export declare function planYdocCelldataCompaction(ydoc: Y.Doc, dsheetId: string): CelldataCompactionResult;

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

@@ -0,0 +1,20 @@
+import { WorkbookInstance } from '../../sheet-engine/react';
+import { SheetChangePath } from './update-ydoc';
+
+import * as Y from 'yjs';
+/** Diff top-level config sub-keys and emit granular Yjs updates. */
+export declare function buildConfigSubKeyChanges({ sheetId, oldConfig, newConfig, }: {
+    sheetId: string;
+    oldConfig: Record<string, any>;
+    newConfig: Record<string, any>;
+}): SheetChangePath[];
+/**
+ * Sync active sheet config sub-keys to Yjs (borderInfo, merge, rowlen, …).
+ * Replaces whole-config writes so only changed sub-keys are broadcast.
+ */
+export declare const configYdocUpdate: ({ sheetEditorRef, ydocRef, dsheetId, handleContentPortal, }: {
+    sheetEditorRef: React.RefObject<WorkbookInstance | null>;
+    ydocRef: React.RefObject<Y.Doc | null>;
+    dsheetId: string;
+    handleContentPortal?: any;
+}) => void;

package/dist/editor/utils/defined-names-ydoc.d.ts

@@ -0,0 +1,31 @@
+import { WorkbookInstance } from '../../sheet-engine/react';
+import { DefinedName } from '../../sheet-engine/core/types';
+import { RefObject } from 'react';
+
+import * as Y from 'yjs';
+/** Sibling share key on the same Y.Doc as the sheet array. */
+export declare function getDefinedNamesMapKey(dsheetId: string): string;
+export declare function getDefinedNamesYMap(ydoc: Y.Doc, dsheetId: string): Y.Map<DefinedName>;
+/** Read workbook-level named ranges from Yjs (stable name order). */
+export declare function readDefinedNamesFromYdoc(ydoc: Y.Doc, dsheetId: string): DefinedName[];
+/**
+ * Prefer the sheet `Y.Array` share key when a doc has sibling maps
+ * (e.g. `${dsheetId}:definedNames`).
+ */
+export declare function resolveSheetArrayShareKey(doc: Y.Doc, preferredKey?: string): string | null;
+/**
+ * Diff Context definedNames against the Y.Map and apply set/delete by id.
+ */
+export declare function syncDefinedNamesToYdoc({ ydoc, dsheetId, definedNames, handleContentPortal, }: {
+    ydoc: Y.Doc;
+    dsheetId: string;
+    definedNames: DefinedName[];
+    handleContentPortal?: () => void;
+}): void;
+/** Push current workbook definedNames into Yjs (editor hook target). */
+export declare const definedNamesYdocUpdate: ({ sheetEditorRef, ydocRef, dsheetId, handleContentPortal, }: {
+    sheetEditorRef: RefObject<WorkbookInstance | null>;
+    ydocRef: RefObject<Y.Doc | null>;
+    dsheetId: string;
+    handleContentPortal?: () => void;
+}) => void;

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

@@ -1,11 +1,11 @@
 import { Sheet } from '../../sheet-engine/react';
-import * as Y from 'yjs';
+import * as Y from "yjs";
 export type SheetChangePath = {
     sheetId: string;
     path: string[];
     key?: string;
     value: any;
-    type?: 'update' | 'delete';
+    type?: "update" | "delete";
 };
 export declare const updateYdocSheetData: (ydoc: Y.Doc | null, dsheetId: string, changes: SheetChangePath[], handleContentPortal: any) => void;
 export declare function ySheetArrayToPlain(sheetArray: Y.Array<Y.Map>): Sheet[];

package/dist/editor/utils/xlsx-defined-names.d.ts

@@ -0,0 +1,41 @@
+import { DefinedName } from '../../sheet-engine/core/types';
+
+export type ExcelDefinedNameEntry = {
+    name: string;
+    ranges: string[];
+    localSheetId?: number;
+};
+export declare function isExcelSystemDefinedName(name: string): boolean;
+/** Build Excel loc string: `Sheet1!$A$1:$C$2` (or single cell). */
+export declare function encodeDefinedNameExcelRef(sheetName: string, range: DefinedName['range']): string;
+/**
+ * Parse `Sheet1!$A$1:$B$2` / `'My Sheet'!$A$1` into sheet name + 0-based range.
+ */
+export declare function parseExcelDefinedNameRef(ref: string): {
+    sheetName: string;
+    range: {
+        row: [number, number];
+        column: [number, number];
+    };
+} | null;
+/**
+ * Convert Excel defined-name entries into our DefinedName list.
+ * `sheets` must already have stable ids and names (Excel order).
+ */
+export declare function excelEntriesToDefinedNames(entries: ExcelDefinedNameEntry[], sheets: Array<{
+    id?: string;
+    name?: string;
+}>): DefinedName[];
+/** Write defined names onto an ExcelJS workbook (Pass 2). */
+export declare function applyDefinedNamesToExcelWorkbook(excelWorkbook: {
+    definedNames: {
+        add: (loc: string, name: string) => void;
+    };
+}, definedNames: DefinedName[] | undefined, sheets: Array<{
+    id?: string;
+    name?: string;
+}>): void;
+/**
+ * Parse `<definedNames>` from xl/workbook.xml (keeps localSheetId).
+ */
+export declare function parseDefinedNamesFromXlsxBuffer(arrayBuffer: ArrayBuffer): Promise<ExcelDefinedNameEntry[]>;