@fileverse-dev/dsheet 3.0.2-patch.7 → 3.0.2-patch.9

package/dist/index.es.js

@@ -1,7 +1,7 @@
-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-BqJw4oqU.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 r, d as l, i as d, e as n, T as i, f as c, g as S, 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 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-T7U1EYEU.js";
+import { cm as k, cn as V, co as X, ct as z, bj as P, e as U, f as _, l as j, a as y, d2 as B, d3 as O, b2 as G, d4 as H, d5 as q, d9 as J, da as K, dc as N, D as Y, dr as Z, dR as Q, aX as W } from "./executeStringFunction-DVN2p-9G.js";
 import { FLVURL as ee } from "@fileverse-dev/formulajs";
-import { E as se, S as te } from "./constants-Q8nzbvQO.js";
+import { E as se, S as te } from "./constants-Cdz6oSCq.js";
 export {
   s as CommentAction,
   t as CommentCellUI,
@@ -10,50 +10,50 @@ export {
   l as DSheetSkeleton,
   se as ERROR_MESSAGES_FLAG,
   ee as FLVURL,
-  n as FortuneCore,
+  d 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,
+  n as SupportedChain,
+  i as TEMPLATES,
+  c as api,
+  k as clearColumnsCellsFormat,
+  S as clearFilter,
+  V as clearRowsCellsFormat,
+  X 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,
+  j as getFlowdata,
   p as getRemoveDuplicatesErrorMessage,
   C as getRemoveDuplicatesPreview,
-  q as getSheetIndex,
+  y as getSheetIndex,
   u as handleCSVUpload,
   E as handleCopy,
   F as handleExportToCSV,
   g 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
+  B as handleFreeze,
+  O as handleHorizontalAlign,
+  G as handleLink,
+  H as handleMerge,
+  R as handlePasteByClick,
+  q as handleSort,
+  J as handleTextSize,
+  K as handleVerticalAlign,
+  f as importSpreadsheetFile,
+  N as insertRowCol,
+  A as isBrowserZoomShortcut,
+  L as isFormulaListShortcut,
+  w as isOpenShortcutsModalShortcut,
+  Y as jfrefreshgrid,
+  Z as loadLocale,
+  I as removeActiveImage,
+  T as removeDuplicates,
+  v as showImgChooser,
+  Q as toolbarItemClickHandler,
+  W 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[], merge?: Record<string, any> | null) => 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, tabs its formulas read, and tabs with formulas that read it.
+ */
+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/modules/sheet-metadata-hooks.d.ts

@@ -3,5 +3,9 @@ import { Context } from '../context';
 /**
  * Defer sheet-level metadata hooks until after React applies Immer updates, so
  * getSheet() / Yjs diff see dataVerification, CF rules, and hyperlinks from paste/cut.
+ *
+ * Capture the hook fns themselves (not `ctx.hooks`): paste runs inside produce,
+ * and reading a draft `hooks` proxy after it is revoked throws
+ * "Cannot perform 'get' on a proxy that has been revoked".
  */
 export declare function scheduleSheetMetadataSyncHooks(ctx: Context): void;

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

@@ -1,7 +1,23 @@
 import { Context } from '../context';
 import { Settings } from '../settings';
-import { CellMatrix, Sheet } from '../types';
+import { CellMatrix, Sheet, SheetConfig } from '../types';
+import { CellFormatRange } from '../utils/range-format';
 
+/**
+ * Persist active ctx.config onto ONE sheet file only.
+ * If Immer wrote keys (e.g. cellFormatRanges) on file.config but not ctx.config,
+ * keep those instead of wiping them with a blind replace.
+ * Never touches other sheets.
+ */
+export declare function assignActiveConfigToSheetFile(file: Sheet, activeConfig: SheetConfig | undefined): void;
+/**
+ * Promote format-only cells in a rectangle into cellFormatRanges.
+ * Scans only [r1..r2]×[c1..c2]. Returns new ranges if anything changed.
+ *
+ * Writes through luckysheetfile[i].config (same as toolbar) so Immer undo
+ * history tracks the change and peers get the reverse via afterConfigChanges.
+ */
+export declare function syncFormatOnlyRectIntoRanges(ctx: Context, cfg: SheetConfig | undefined, data: CellMatrix | null | undefined, r1: number, r2: number, c1: number, c2: number): CellFormatRange[] | null;
 export declare function storeSheetParamALL(ctx: Context): void;
 export declare function changeSheet(ctx: Context, id: string, isPivotInitial?: boolean, isNewSheet?: boolean, isCopySheet?: boolean): void;
 export declare function addSheet(ctx: Context, settings?: Required<Settings>, newSheetID?: string | undefined, // if action is from websocket, there will be a new sheetID

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/active-draft-context.d.ts

@@ -0,0 +1,4 @@
+import { Context } from '../context';
+
+export declare function setActiveDraftContext(ctx: Context | null): void;
+export declare function getActiveDraftContext(): Context | null;

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

@@ -0,0 +1,16 @@
+import { Context } from '../context';
+
+export type BorderSelection = {
+    row: [number, number];
+    column: [number, number];
+};
+/**
+ * Remap borderInfo after a row/column reorder (header drag).
+ * Uses the same old→new index map as remapCellFormatRanges.
+ * O(border entries × span) — only runs on drag drop, not per-frame.
+ */
+export declare function remapBorderInfo(borderInfo: any[] | undefined, axis: 'row' | 'column', indexMap: Record<number, number>): any[];
+/** 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,10 @@
+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;
+/** Pull only present format attrs from a format-only empty cell (cheap, no clone). */
+export declare function extractCellFormatAttrs(cell: Cell | string | number | boolean | null | undefined): Partial<Record<CellFormatAttr, unknown>> | null;
+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/merge-hydrate.d.ts

@@ -0,0 +1,15 @@
+import { CellMatrix } from '../types';
+
+type MergeEntry = {
+    r?: number;
+    c?: number;
+    rs?: number;
+    cs?: number;
+};
+/**
+ * Rebuild merge anchor + shadow `mc` refs on dense data from config.merge.
+ * Cheap: O(merge area), not O(grid). Safe to call on every hydrate — idempotent.
+ * Covers docs whose shadow cells were dropped by earlier compaction.
+ */
+export declare function applyMergeConfigToData(data: CellMatrix | null | undefined, merge: Record<string, MergeEntry> | null | undefined): void;
+export {};

package/dist/sheet-engine/core/utils/mirror-cell-format-ranges.d.ts

@@ -0,0 +1,17 @@
+import { Context } from '../context';
+import { CellFormatRange } from './range-format';
+
+/**
+ * Keep workbook config.cellFormatRanges aligned with a ydoc commit.
+ * Cheap no-op when already equal. Mutates ctx in place (immer draft or produce).
+ */
+export declare function mirrorCellFormatRangesIntoContext(ctx: Context, sheetId: string, ranges: CellFormatRange[]): boolean;
+export type CellFormatRangesCommit = {
+    sheetId: string;
+    ranges: CellFormatRange[];
+};
+/**
+ * Apply ydoc-committed ranges into the live workbook.
+ * Prefers the in-flight immer draft (same edit); falls back to a produce() update.
+ */
+export declare function applyCellFormatRangesCommits(commits: CellFormatRangesCommit[], setContext?: ((updater: (prev: Context) => Context) => void) | null): void;

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

@@ -0,0 +1,76 @@
+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[];
+/**
+ * Remap format ranges after a row or column permutation, such as header
+ * drag-and-drop. A contiguous source range can become multiple rectangles
+ * when the moved indices are no longer contiguous.
+ */
+export declare function remapCellFormatRanges(ranges: CellFormatRange[] | undefined, axis: "row" | "column", indexMap: Record<number, number>): CellFormatRange[];
+/**
+ * Move format ranges with a cut-and-paste cell block move. Formatting in both
+ * the old source and the overwritten destination is cleared; only the source
+ * intersection is translated to the target rectangle.
+ */
+export declare function moveCellFormatRanges(ranges: CellFormatRange[] | undefined, source: Pick<CellFormatRange, "row" | "column">, target: Pick<CellFormatRange, "row" | "column">): 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;
+};
+/**
+ * When a cell loses meaningful content but keeps style, put that style back
+ * into cellFormatRanges as a 1x1 (normalize merges with neighbours).
+ */
+export declare function migrateFormatOnlyCellIntoRanges(ranges: CellFormatRange[] | undefined, r: number, c: number, cell: Cell | string | number | boolean | null | undefined): {
+    ranges: CellFormatRange[];
+    changed: boolean;
+};
+/**
+ * Scan a dense-data rectangle and move any format-only cells into
+ * cellFormatRanges. Adjacent identical styles merge via normalize.
+ */
+export declare function migrateFormatOnlyCellsFromData(ranges: CellFormatRange[] | undefined, data: CellMatrix | null | undefined, r1: number, r2: number, c1: number, c2: number): {
+    ranges: CellFormatRange[];
+    changed: boolean;
+};
+export declare function punchHoleInCellFormatRanges(ranges: CellFormatRange[] | undefined, r: number, c: number): CellFormatRange[];
+/**
+ * Remove format coverage for a whole rectangle in O(ranges), not O(area × ranges).
+ * Prefer this over punching cell-by-cell (select-all clear must stay cheap).
+ */
+export declare function removeCellFormatRangesInRect(ranges: CellFormatRange[] | undefined, row: [number, number], column: [number, 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,46 @@
+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;
+/**
+ * After delete row/col, emit deletes for persisted keys that now sit past the
+ * shrunken grid. Range diffs only visit coordinates still inside `data`, so
+ * tail keys would otherwise resurrect on peers/reload.
+ */
+export declare function emitCelldataDeletesBeyondGrid(ctx: Context, sheetId: string, beforePersisted: Map<string, Cell | string | number | boolean> | undefined, rowCount: number, colCount: number): 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[], merge?: Record<string, any> | null) => 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[], merge?: Record<string, any> | null) => CellMatrix | null;
     insertFunction: (selectedFuncIndex: number, filteredFunctionList: any[], callback?: () => void) => void;
     getLocaleContext: () => any;
     getWorkbookContext: () => Context;