@fileverse-dev/dsheet 3.0.0 → 3.0.1-yjs

package/dist/index.es.js

@@ -1,59 +1,59 @@
-import { C as s, a as t, b as o, S as r, d as l, i as n, e as i, T as d, f as S, g as c, h, j as m, k as p, l as C, n as u, o as E, p as F, q as g, s as x, t as R, u as L, v as f, w as A, x as I, z as w, A as T, B as b, D as v, E as M, F as D, G as k, H as V, I as X, J as z, K as P, L as U, M as _, N as y } from "./index-CBzFxleP.js";
-import { bW as G, bX as H, bY as O, c0 as j, bi as J, e as K, f as N, h as Y, a as q, cm as W, as as Z, cu as Q } from "./executeStringFunction-C5hEkx9z.js";
+import { C as s, a as t, b as o, S as l, d as r, i as n, e as d, T as c, f as i, g as S, h, j as m, k as p, l as C, n as u, o as E, p as g, q as F, s as x, t as R, u as f, v as A, w as L, x as w, z as I, A as T, B as v, D, E as M } from "./index-Xk62PVvQ.js";
+import { ce as V, cf as X, cg as b, cl as z, bd as P, e as U, f as _, l as y, a as B, cW as O, cX as Y, aY as j, cY as G, cZ as H, d1 as J, d2 as Z, d4 as q, D as K, di as N, dJ as W, aR as Q } from "./executeStringFunction-CPkwRrkE.js";
 import { FLVURL as ee } from "@fileverse-dev/formulajs";
-import { E as se, S as te } from "./constants-yStXQJiK.js";
+import { E as se, S as te } from "./constants-Cdz6oSCq.js";
 export {
   s as CommentAction,
   t as CommentCellUI,
   o as CommentsContent,
-  r as DSheetEditor,
-  l as DSheetSkeleton,
+  l as DSheetEditor,
+  r as DSheetSkeleton,
   se as ERROR_MESSAGES_FLAG,
   ee as FLVURL,
   n as FortuneCore,
   te as SERVICES_API_KEY,
-  i as SupportedChain,
-  d as TEMPLATES,
-  S as api,
-  G as clearColumnsCellsFormat,
-  c as clearFilter,
-  H as clearRowsCellsFormat,
-  O as clearSelectedCellFormat,
+  d as SupportedChain,
+  c as TEMPLATES,
+  i as api,
+  V as clearColumnsCellsFormat,
+  S as clearFilter,
+  X as clearRowsCellsFormat,
+  b as clearSelectedCellFormat,
   h as createFilter,
-  j as deleteRowCol,
-  J as deleteSelectedCellText,
+  z as deleteRowCol,
+  P as deleteSelectedCellText,
   m as describeMatchedShortcut,
-  K as executeStringFunction,
-  N as formulaResponseUiSync,
-  Y as getFlowdata,
+  U as executeStringFunction,
+  _ as formulaResponseUiSync,
+  y as getFlowdata,
   p as getRemoveDuplicatesErrorMessage,
   C as getRemoveDuplicatesPreview,
-  q as getSheetIndex,
+  B as getSheetIndex,
   u as handleCSVUpload,
   E as handleCopy,
-  F as handleExportToCSV,
-  g as handleExportToJSON,
+  g as handleExportToCSV,
+  F as handleExportToJSON,
   x as handleExportToXLSX,
-  R as handleFreeze,
-  L as handleHorizontalAlign,
-  f as handleLink,
-  A as handleMerge,
-  I as handlePasteByClick,
-  w as handleSort,
-  T as handleTextSize,
-  b as handleVerticalAlign,
-  v as importSpreadsheetFile,
-  W as insertRowCol,
-  M as isBrowserZoomShortcut,
-  D as isFormulaListShortcut,
-  k as isOpenShortcutsModalShortcut,
-  Z as jfrefreshgrid,
-  Q as loadLocale,
-  V as removeActiveImage,
-  X as removeDuplicates,
-  z as showImgChooser,
-  P as toolbarItemClickHandler,
-  U as updateFormat,
-  _ as useEnsStatus,
-  y as useXLSXImport
+  O as handleFreeze,
+  Y as handleHorizontalAlign,
+  j as handleLink,
+  G as handleMerge,
+  R as handlePasteByClick,
+  H as handleSort,
+  J as handleTextSize,
+  Z as handleVerticalAlign,
+  f as importSpreadsheetFile,
+  q as insertRowCol,
+  A as isBrowserZoomShortcut,
+  L as isFormulaListShortcut,
+  w as isOpenShortcutsModalShortcut,
+  K as jfrefreshgrid,
+  N as loadLocale,
+  I as removeActiveImage,
+  T as removeDuplicates,
+  v as showImgChooser,
+  W as toolbarItemClickHandler,
+  Q as updateFormat,
+  D as useEnsStatus,
+  M as useXLSXImport
 };

package/dist/sheet-engine/core/api/cell.d.ts

@@ -6,26 +6,6 @@ export declare function getCellValue(ctx: Context, row: number, column: number,
     type?: keyof Cell;
 }): any;
 export declare function setCellValue(ctx: Context, row: number, column: number, value: any, cellInput: HTMLDivElement | null, options?: CommonOptions, callAfterUpdate?: boolean): void;
-/**
- * Apply a cell value coming from a remote RTC peer, verbatim.
- *
- * This differs from `setCellValue` in two important ways and must be used for
- * every Yjs-driven remote apply:
- *
- * 1. It NEVER runs the formula engine and NEVER fires the local-edit hooks
- *    (`onLocalCellEdit` / `afterUpdateCell`). The peer already computed the
- *    value, so we use the synced `v`/`m`/`f` as-is. This avoids both
- *    recomputation divergence and an update loop back into Yjs.
- *
- * 2. It PRESERVES the formula calc list. The regular `setCellValue` object
- *    branch calls `delFunctionGroup`, which removes the cell from `calcChain`
- *    and strips its dependency edges. Because `execFunctionGroup` walks
- *    `calcChain` to decide what to recompute, dropping a formula cell there
- *    permanently breaks its reactivity on that client (even after RTC stops).
- *    Here we instead keep formula cells registered via
- *    `insertUpdateFunctionGroup`, so they stay reactive to future local edits
- *    on both owner and peer.
- */
 export declare function applyRemoteCellValue(ctx: Context, row: number, column: number, value: any, options?: CommonOptions): void;
 export declare function clearCell(ctx: Context, row: number, column: number, options?: CommonOptions): void;
 export declare function setCellFormat(ctx: Context, row: number, column: number, attr: keyof Cell, value: any, options?: CommonOptions): void;

package/dist/sheet-engine/core/api/common.d.ts

@@ -1,12 +1,13 @@
 import { Context } from '../context';
 import { CellMatrix, CellWithRowAndCol, Sheet } from '../types';
+import { CellFormatRange } from '../utils/range-format';
 
 export type CommonOptions = {
     index?: number;
     id?: string;
 };
 export declare const dataToCelldata: (data: CellMatrix | undefined) => CellWithRowAndCol[];
-export declare const celldataToData: (celldata: CellWithRowAndCol[], rowCount?: number, colCount?: number) => CellMatrix | null;
+export declare const celldataToData: (celldata: CellWithRowAndCol[], rowCount?: number, colCount?: number, cellFormatRanges?: CellFormatRange[]) => CellMatrix | null;
 export declare function getSheet(ctx: Context, options?: CommonOptions): Sheet;
 export declare function getSheetWithLatestCelldata(ctx: Context, options?: CommonOptions): {
     celldata: CellWithRowAndCol[];

package/dist/sheet-engine/core/api/index.d.ts

@@ -7,5 +7,6 @@ export * from './rowcol';
 export * from './range';
 export * from './merge';
 export * from './sheet';
+export * from './sheet-flowdata-lifecycle';
 export * from './workbook';
 export * from '../modules/error-state-helpers';

package/dist/sheet-engine/core/api/sheet-flowdata-lifecycle.d.ts

@@ -0,0 +1,17 @@
+import { Context } from '../context';
+
+/** Drop cached dense-sheet set (e.g. after structural workbook changes). */
+export declare function invalidateSheetsRequiredDenseCache(): void;
+/**
+ * Sheets that must keep dense `data` while `activeSheetId` is active:
+ * the active tab plus any tab referenced by its formulas (deps graph + text scan).
+ */
+export declare function getSheetsRequiredDense(ctx: Context, activeSheetId: string): Set<string>;
+/** Sheets the formula worker needs dense — active refs plus any tab with formulas. */
+export declare function getSheetsNeededForWorkerSnapshot(ctx: Context): Set<string>;
+export declare function demoteSheetToCelldata(ctx: Context, sheetId: string): void;
+/**
+ * On tab switch: persist outgoing config, demote tabs not needed dense,
+ * hydrate active tab + cross-sheet references.
+ */
+export declare function syncAndDemoteInactiveFlowdata(ctx: Context, activeSheetId: string, previousSheetId: string | null): Set<string>;

package/dist/sheet-engine/core/api/sheet.d.ts

@@ -5,6 +5,11 @@ import { CellMatrix, Sheet } from '../types';
 export declare function getAllSheets(ctx: Context): Sheet[];
 export { getSheet };
 export declare function initSheetData(draftCtx: Context, index: number, newData: Sheet): CellMatrix | null;
+/** Build dense `data` from sparse `celldata` when a sheet is activated or referenced. */
+export declare function ensureSheetFlowdata(ctx: Context, options?: {
+    index?: number;
+    id?: string;
+}): CellMatrix | null;
 export declare function hideSheet(ctx: Context, sheetId: string): void;
 export declare function showSheet(ctx: Context, sheetId: string): void;
 export declare function copySheet(ctx: Context, sheetId: string): void;

package/dist/sheet-engine/core/modules/formula-worker-bridge.d.ts

@@ -2,6 +2,7 @@ import { Context } from '../context';
 import { SnapshotEvalInput, SnapshotEvalOutput, SnapshotFormulaCell, evalFormulasInSnapshot } from './formula-snapshot-eval';
 import { FORMULA_WORKER_CHUNK_SIZE } from './formula-async-eval';
 
+export declare function invalidateFormulaWorkerSnapshot(): void;
 export declare function buildSnapshotEvalInput(ctx: Context, formulas: SnapshotFormulaCell[]): SnapshotEvalInput;
 export declare function buildWorkerEvalInput(ctx: Context, formulas: SnapshotFormulaCell[]): Omit<SnapshotEvalInput, 'sheets'>;
 export declare function initFormulaWorkerSnapshot(ctx: Context, snapshotKey: string): boolean;

package/dist/sheet-engine/core/paste/paste-border-utils.d.ts

@@ -0,0 +1,23 @@
+export declare function isTransparentBorderColor(color: string): boolean;
+export declare function isMeaningfulBorderSide(side: {
+    style?: number;
+    color?: string;
+} | undefined): boolean;
+export declare function filterMeaningfulBorderSides(sides: {
+    l?: {
+        style?: number;
+        color?: string;
+    };
+    r?: {
+        style?: number;
+        color?: string;
+    };
+    t?: {
+        style?: number;
+        color?: string;
+    };
+    b?: {
+        style?: number;
+        color?: string;
+    };
+}): typeof sides;

package/dist/sheet-engine/core/settings.d.ts

@@ -23,7 +23,7 @@ export type Hooks = {
     cellDataChange?: () => void;
     hyperlinkChange?: () => void;
     updateCellYdoc?: (changes: SheetChangePath[]) => void;
-    updateAllCell?: (sheetId: string) => void;
+    updateAllCell?: (sheetId: string, caller?: string) => void;
     beforeUpdateCell?: (r: number, c: number, value: any) => boolean;
     /** Clears RTC remote-apply lock so local edits can run data-block formulas. */
     onLocalCellEdit?: () => void;

package/dist/sheet-engine/core/types.d.ts

@@ -1,5 +1,6 @@
 import { Patch as ImmerPatch } from 'immer';
 import { PatchOptions } from './utils';
+import { CellFormatRange } from './utils/range-format';
 
 export type Op = {
     op: 'replace' | 'remove' | 'add' | 'insertRowCol' | 'deleteRowCol' | 'addSheet' | 'deleteSheet';
@@ -140,6 +141,8 @@ export type SheetConfig = {
     customHeight?: Record<string, number>;
     customWidth?: Record<string, number>;
     borderInfo?: any[];
+    /** Range-level cell formatting for empty cells (toolbar bulk format). */
+    cellFormatRanges?: CellFormatRange[];
     authority?: any;
     rowReadOnly?: Record<number, number>;
     colReadOnly?: Record<number, number>;

package/dist/sheet-engine/core/utils/border-config-utils.d.ts

@@ -0,0 +1,10 @@
+import { Context } from '../context';
+
+export type BorderSelection = {
+    row: [number, number];
+    column: [number, number];
+};
+/** Remove border entries overlapping a single selection (cell + range types). */
+export declare function removeBorderInfoForSelection(borderInfo: any[], rowSt: number, rowEd: number, colSt: number, colEd: number): any[];
+export declare function removeBorderInfoInSelections(borderInfo: any[] | undefined, selections: BorderSelection[]): any[];
+export declare function syncBorderInfoToYdoc(ctx: Context, borderInfo: any[]): void;

package/dist/sheet-engine/core/utils/cell-persist-utils.d.ts

@@ -0,0 +1,8 @@
+import { Cell } from '../types';
+
+export declare const CELL_FORMAT_ATTRS: readonly ["tb", "ht", "vt", "tr", "fs", "ff", "fc", "bl", "it", "un", "cl", "bg", "ct"];
+export type CellFormatAttr = (typeof CELL_FORMAT_ATTRS)[number];
+export declare function hasCellMeaningfulContent(cell: Cell | string | number | boolean | null | undefined): boolean;
+export declare function isFormatOnlyEmptyCell(cell: Cell | string | number | boolean | null | undefined): boolean;
+export declare function shouldPersistCelldataCell(cell: Cell | string | number | boolean | null | undefined): boolean;
+export declare function celldataEntryEqual(existing: unknown, next: unknown): boolean;

package/dist/sheet-engine/core/utils/range-format.d.ts

@@ -0,0 +1,43 @@
+import { Cell, CellMatrix, CellWithRowAndCol, Sheet } from '../types';
+
+export type CellFormatRange = {
+    row: [number, number];
+    column: [number, number];
+    tb?: string;
+    ht?: number | string;
+    vt?: number | string;
+    tr?: string;
+    fs?: number;
+    ff?: number | string;
+    fc?: string;
+    bl?: number;
+    it?: number;
+    un?: number;
+    cl?: number;
+    bg?: string;
+    ct?: Cell['ct'];
+};
+declare function rangesEqual(a: CellFormatRange[] | undefined, b: CellFormatRange[] | undefined): boolean;
+/** Merge overlapping/adjacent ranges that carry identical format attrs. */
+export declare function normalizeCellFormatRanges(ranges: CellFormatRange[] | undefined): CellFormatRange[];
+export declare function getCellFormatRangeGridBounds(ranges: CellFormatRange[] | undefined): {
+    maxRow: number;
+    maxCol: number;
+} | null;
+export declare function upsertCellFormatRange(ranges: CellFormatRange[] | undefined, rowSt: number, rowEd: number, colSt: number, colEd: number, attrs: Partial<CellFormatRange>): {
+    ranges: CellFormatRange[];
+    changed: boolean;
+};
+export declare function punchHoleInCellFormatRanges(ranges: CellFormatRange[] | undefined, r: number, c: number): CellFormatRange[];
+export declare function punchRectHoleInCellFormatRanges(ranges: CellFormatRange[] | undefined, rowSt: number, rowEd: number, colSt: number, colEd: number): CellFormatRange[];
+export declare function shiftCellFormatRangesOnInsert(ranges: CellFormatRange[] | undefined, type: 'row' | 'column', index: number, count: number, direction: 'lefttop' | 'rightbottom'): CellFormatRange[];
+export declare function shiftCellFormatRangesOnDelete(ranges: CellFormatRange[] | undefined, type: 'row' | 'column', start: number, end: number): CellFormatRange[];
+export declare function applyCellFormatRangesToData(data: CellMatrix | null | undefined, ranges: CellFormatRange[] | undefined): void;
+export declare function buildSheetDataMatrixForExport(sheet: {
+    data?: CellMatrix | null;
+    celldata?: CellWithRowAndCol[];
+    row?: number;
+    column?: number;
+    config?: Sheet['config'];
+}): CellMatrix;
+export { rangesEqual };

package/dist/sheet-engine/core/utils/ydoc-celldata-changes.d.ts

@@ -0,0 +1,40 @@
+import { Context } from '../context';
+import { Cell, CellWithRowAndCol } from '../types';
+
+export type CelldataYdocChange = {
+    sheetId: string;
+    path: string[];
+    key?: string;
+    value: any;
+    type?: 'update' | 'delete';
+};
+/** Cheap equality before deep compare — hot path for structural diffs. */
+export declare function cellsEqualForYdocPersist(before: unknown, after: unknown): boolean;
+/**
+ * Snapshot persisted cells in a range.
+ * Prefer sparse `celldata` when provided — O(populated cells), not O(range area).
+ */
+export declare function snapshotPersistedCelldataInRange(data: unknown[][] | null | undefined, r1: number, r2: number, c1: number, c2: number, celldata?: CellWithRowAndCol[] | null): Map<string, Cell | string | number | boolean>;
+export declare function appendCelldataDiffChange(changes: CelldataYdocChange[], sheetId: string, r: number, c: number, cell: unknown, beforePersisted?: Map<string, Cell | string | number | boolean>): void;
+export declare function buildCelldataChangesForRange(sheetId: string, data: unknown[][], r1: number, r2: number, c1: number, c2: number, beforePersisted?: Map<string, Cell | string | number | boolean>): CelldataYdocChange[];
+export declare function emitCelldataRangeDiffToYdoc(ctx: Context, sheetId: string, data: unknown[][], r1: number, r2: number, c1: number, c2: number, beforePersisted?: Map<string, Cell | string | number | boolean>): void;
+export type MergeBounds = {
+    minR: number;
+    minC: number;
+    maxR: number;
+    maxC: number;
+};
+/** Disturbed range for insert row/col — snapshot only rows/cols that may shift. */
+export declare function getInsertRowColSnapshotBounds(type: 'row' | 'column', index: number, direction: 'lefttop' | 'rightbottom', rowCount: number, colCount: number, mergeBounds: MergeBounds | null): {
+    r1: number;
+    r2: number;
+    c1: number;
+    c2: number;
+};
+/** Disturbed range for delete row/col — from deletion point to sheet edge. */
+export declare function getDeleteRowColSnapshotBounds(type: 'row' | 'column', start: number, rowCount: number, colCount: number, mergeBounds: MergeBounds | null): {
+    r1: number;
+    r2: number;
+    c1: number;
+    c2: number;
+};

package/dist/sheet-engine/react/components/Workbook/api.d.ts

@@ -1,3 +1,4 @@
+import { CellFormatRange } from '../../../core/utils/range-format';
 import { api, Cell, Context, Op, Range, Selection, Presence, Settings, SingleRange, Sheet, CellMatrix, CellWithRowAndCol, GlobalCache, LiveQueryData } from '../../../core';
 import { getCryptoPrice } from '../../utils/cryptoApi';
 import { SetContextOptions } from '../../context';
@@ -148,6 +149,12 @@ export declare function generateAPIs(context: Context, setContext: (recipe: (ctx
         } | null;
     }, options?: api.CommonOptions) => void;
     setSheetMapField: (field: string, value: Record<string, any> | null | undefined, options?: api.CommonOptions) => void;
+    /** Merge keys into a map-backed sheet field without replacing the whole map. */
+    patchSheetMapField: (field: string, updates: Record<string, any>, deleteKeys?: string[], options?: api.CommonOptions) => void;
+    /** Merge sub-keys into sheet.config without replacing the whole config object. */
+    setSheetConfigFields: (partial: Record<string, any>, options?: api.CommonOptions & {
+        deleteKeys?: string[];
+    }) => void;
     setSheetConditionFormatRules: (rules: any[], options?: api.CommonOptions) => void;
     scroll: (options: {
         scrollLeft?: number;
@@ -166,7 +173,7 @@ export declare function generateAPIs(context: Context, setContext: (recipe: (ctx
     calculateSubSheetFormula: (id: string) => void;
     calculateCellReferencedSubSheetFormula: (id: string, refCell?: string[]) => void;
     dataToCelldata: (data: CellMatrix | undefined) => CellWithRowAndCol[];
-    celldataToData: (celldata: CellWithRowAndCol[], rowCount?: number, colCount?: number) => CellMatrix | null;
+    celldataToData: (celldata: CellWithRowAndCol[], rowCount?: number, colCount?: number, cellFormatRanges?: CellFormatRange[]) => CellMatrix | null;
     insertFunction: (selectedFuncIndex: number, filteredFunctionList: any[], callback?: () => void) => void;
     getLocaleContext: () => any;
     getWorkbookContext: () => Context;

package/dist/sheet-engine/react/components/Workbook/index.d.ts

@@ -150,6 +150,10 @@ declare const Workbook: React.ForwardRefExoticComponent<Settings & AdditionalPro
         } | null;
     }, options?: api.CommonOptions) => void;
     setSheetMapField: (field: string, value: Record<string, any> | null | undefined, options?: api.CommonOptions) => void;
+    patchSheetMapField: (field: string, updates: Record<string, any>, deleteKeys?: string[], options?: api.CommonOptions) => void;
+    setSheetConfigFields: (partial: Record<string, any>, options?: api.CommonOptions & {
+        deleteKeys?: string[];
+    }) => void;
     setSheetConditionFormatRules: (rules: any[], options?: api.CommonOptions) => void;
     scroll: (options: {
         scrollLeft?: number;
@@ -168,7 +172,7 @@ declare const Workbook: React.ForwardRefExoticComponent<Settings & AdditionalPro
     calculateSubSheetFormula: (id: string) => void;
     calculateCellReferencedSubSheetFormula: (id: string, refCell?: string[]) => void;
     dataToCelldata: (data: CellMatrix | undefined) => CellWithRowAndCol[];
-    celldataToData: (celldata: CellWithRowAndCol[], rowCount?: number, colCount?: number) => CellMatrix | null;
+    celldataToData: (celldata: CellWithRowAndCol[], rowCount?: number, colCount?: number, cellFormatRanges?: import('../../../core/utils/range-format').CellFormatRange[]) => CellMatrix | null;
     insertFunction: (selectedFuncIndex: number, filteredFunctionList: any[], callback?: () => void) => void;
     getLocaleContext: () => any;
     getWorkbookContext: () => Context;