@fileverse-dev/dsheet 3.0.2 → 3.0.3

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-Dql-IRPC.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/persistence-utils-DsM_MOB1.js

@@ -0,0 +1,89 @@
+import * as c from "yjs";
+const u = typeof Buffer == "function";
+typeof TextDecoder == "function" && new TextDecoder();
+typeof TextEncoder == "function" && new TextEncoder();
+const b = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=", s = Array.prototype.slice.call(b), l = ((t) => {
+  let e = {};
+  return t.forEach((r, o) => e[r] = o), e;
+})(s), g = /^(?:[A-Za-z\d+\/]{4})*?(?:[A-Za-z\d+\/]{2}(?:==)?|[A-Za-z\d+\/]{3}=?)?$/, f = String.fromCharCode.bind(String), h = typeof Uint8Array.from == "function" ? Uint8Array.from.bind(Uint8Array) : (t) => new Uint8Array(Array.prototype.slice.call(t, 0)), S = (t) => t.replace(/=/g, "").replace(/[+\/]/g, (e) => e == "+" ? "-" : "_"), A = (t) => t.replace(/[^A-Za-z0-9\+\/]/g, ""), E = (t) => {
+  let e, r, o, n, a = "";
+  const p = t.length % 3;
+  for (let i = 0; i < t.length; ) {
+    if ((r = t.charCodeAt(i++)) > 255 || (o = t.charCodeAt(i++)) > 255 || (n = t.charCodeAt(i++)) > 255)
+      throw new TypeError("invalid character found");
+    e = r << 16 | o << 8 | n, a += s[e >> 18 & 63] + s[e >> 12 & 63] + s[e >> 6 & 63] + s[e & 63];
+  }
+  return p ? a.slice(0, p - 3) + "===".substring(p) : a;
+}, U = typeof btoa == "function" ? (t) => btoa(t) : u ? (t) => Buffer.from(t, "binary").toString("base64") : E, d = u ? (t) => Buffer.from(t).toString("base64") : (t) => {
+  let r = [];
+  for (let o = 0, n = t.length; o < n; o += 4096)
+    r.push(f.apply(null, t.subarray(o, o + 4096)));
+  return U(r.join(""));
+}, m = (t, e = !1) => e ? S(d(t)) : d(t), _ = (t) => {
+  if (t = t.replace(/\s+/g, ""), !g.test(t))
+    throw new TypeError("malformed base64.");
+  t += "==".slice(2 - (t.length & 3));
+  let e, r, o, n = [];
+  for (let a = 0; a < t.length; )
+    e = l[t.charAt(a++)] << 18 | l[t.charAt(a++)] << 12 | (r = l[t.charAt(a++)]) << 6 | (o = l[t.charAt(a++)]), r === 64 ? n.push(f(e >> 16 & 255)) : o === 64 ? n.push(f(e >> 16 & 255, e >> 8 & 255)) : n.push(f(e >> 16 & 255, e >> 8 & 255, e & 255));
+  return n.join("");
+}, w = typeof atob == "function" ? (t) => atob(A(t)) : u ? (t) => Buffer.from(t, "base64").toString("binary") : _, D = u ? (t) => h(Buffer.from(t, "base64")) : (t) => h(w(t).split("").map((e) => e.charCodeAt(0))), T = (t) => D(C(t)), C = (t) => A(t.replace(/[-_]/g, (e) => e == "-" ? "+" : "/")), P = 8e3, x = (t) => t instanceof Error ? t : new Error(String(t)), v = async (t, e) => {
+  let r;
+  try {
+    return await Promise.race([
+      t,
+      new Promise((o, n) => {
+        r = setTimeout(
+          () => n(new Error("dSheet IndexedDB operation timed out")),
+          e
+        );
+      })
+    ]);
+  } finally {
+    r && clearTimeout(r);
+  }
+}, y = (t, e, r) => ({
+  dsheetId: t,
+  status: e,
+  encodedState: null,
+  stateVector: null,
+  ...r ? { error: x(r) } : {}
+}), B = (t, e) => {
+  const r = c.encodeStateAsUpdate(e);
+  return {
+    dsheetId: t,
+    status: r.length <= 2 ? "empty" : "available",
+    encodedState: m(r),
+    stateVector: m(c.encodeStateVector(e))
+  };
+}, z = (t, e, r) => {
+  if (!r)
+    return y(
+      t,
+      "unavailable",
+      new Error("dSheet document is not ready")
+    );
+  let o;
+  const n = new c.Doc();
+  try {
+    o = T(e), c.applyUpdate(n, o);
+  } catch (a) {
+    return y(t, "corrupt", a);
+  } finally {
+    n.destroy();
+  }
+  try {
+    return c.applyUpdate(r, o, "dsheet-package-ingress"), B(t, r);
+  } catch (a) {
+    return y(t, "corrupt", a);
+  }
+};
+export {
+  P as D,
+  m as f,
+  z as m,
+  B as s,
+  T as t,
+  y as u,
+  v as w
+};

package/dist/persistence-utils.d.ts

@@ -0,0 +1,17 @@
+import * as Y from 'yjs';
+export declare const DEFAULT_DSHEET_PERSISTENCE_TIMEOUT_MS = 8000;
+export type DSheetContentStatus = 'available' | 'empty' | 'missing' | 'corrupt' | 'timed-out' | 'unavailable';
+export type DSheetContentSnapshot = {
+    dsheetId: string;
+    status: DSheetContentStatus;
+    encodedState: string | null;
+    stateVector: string | null;
+    error?: Error;
+};
+export type DSheetContentReadOptions = {
+    timeoutMs?: number;
+};
+export declare const withDsheetPersistenceTimeout: <T>(promise: Promise<T>, timeoutMs: number) => Promise<T>;
+export declare const unavailableDsheetContentSnapshot: (dsheetId: string, status: Exclude<DSheetContentStatus, "available" | "empty">, error?: unknown) => DSheetContentSnapshot;
+export declare const snapshotDsheetDocument: (dsheetId: string, doc: Y.Doc) => DSheetContentSnapshot;
+export declare const mergeDsheetContentIntoDocument: (dsheetId: string, encodedState: string, doc: Y.Doc | null) => DSheetContentSnapshot;

package/dist/persistence.d.ts

@@ -0,0 +1,12 @@
+import { DSheetContentReadOptions, DSheetContentSnapshot } from './persistence-utils';
+
+export type { DSheetContentReadOptions, DSheetContentSnapshot, DSheetContentStatus, } from './persistence-utils';
+export declare const getDsheetStateVector: (encodedState: string | Uint8Array) => string;
+/**
+ * Read the package-owned Y-IndexedDB database without attaching another
+ * persistence writer. Completed reads are never cached.
+ */
+export declare const readDsheetContent: (dsheetId: string, options?: DSheetContentReadOptions) => Promise<DSheetContentSnapshot>;
+/** Merge content into the package-owned Y-IndexedDB document. */
+export declare const mergeDsheetContent: (dsheetId: string, encodedState: string, options?: DSheetContentReadOptions) => Promise<DSheetContentSnapshot>;
+export declare const deleteDsheetContent: (dsheetId: string) => Promise<void>;

package/dist/persistence.js

@@ -0,0 +1,118 @@
+import { t as D, f as h, D as b, u as p, w as S, s as w } from "./persistence-utils-DsM_MOB1.js";
+import * as u from "yjs";
+import { clearDocument as v, IndexeddbPersistence as E } from "y-indexeddb";
+const f = /* @__PURE__ */ new Map(), M = (e) => {
+  const o = new u.Doc();
+  try {
+    return u.applyUpdate(
+      o,
+      typeof e == "string" ? D(e) : e
+    ), h(u.encodeStateVector(o));
+  } finally {
+    o.destroy();
+  }
+}, x = (e, o) => new Promise((s) => {
+  const a = new u.Doc();
+  let r = null, t = null, i = !1, m = !1;
+  const y = (n) => {
+    i || (i = !0, clearTimeout(g), r == null || r.close(), a.destroy(), s(n));
+  }, c = (n, d) => y(p(e, n, d)), g = setTimeout(() => {
+    try {
+      t == null || t.abort();
+    } catch {
+    }
+    c("timed-out", new Error("dSheet IndexedDB read timed out"));
+  }, o);
+  let l;
+  try {
+    l = indexedDB.open(e);
+  } catch (n) {
+    c("unavailable", n);
+    return;
+  }
+  l.onupgradeneeded = () => {
+    var n;
+    m = !0, (n = l.transaction) == null || n.abort();
+  }, l.onerror = () => {
+    m ? y(p(e, "missing")) : c("unavailable", l.error);
+  }, l.onsuccess = () => {
+    if (r = l.result, !r.objectStoreNames.contains("updates") || !r.objectStoreNames.contains("custom")) {
+      c("corrupt", new Error("dSheet IndexedDB schema is invalid"));
+      return;
+    }
+    try {
+      t = r.transaction("updates", "readonly");
+      const n = t.objectStore("updates").getAll();
+      n.onerror = () => c("unavailable", n.error), n.onsuccess = () => {
+        try {
+          for (const d of n.result ?? []) {
+            if (!(d instanceof Uint8Array))
+              throw new Error("dSheet IndexedDB contains a non-Yjs update");
+            u.applyUpdate(a, d);
+          }
+        } catch (d) {
+          c("corrupt", d);
+        }
+      }, t.oncomplete = () => y(w(e, a)), t.onabort = () => {
+        i || c("unavailable", t == null ? void 0 : t.error);
+      }, t.onerror = () => {
+        i || c("unavailable", t == null ? void 0 : t.error);
+      };
+    } catch (n) {
+      c("unavailable", n);
+    }
+  };
+}), B = async (e, o) => {
+  if (typeof indexedDB > "u")
+    return p(
+      e,
+      "unavailable",
+      new Error("IndexedDB is unavailable")
+    );
+  const s = indexedDB;
+  if (s.databases)
+    try {
+      if (!(await s.databases()).some((r) => r.name === e))
+        return p(e, "missing");
+    } catch {
+    }
+  return x(e, o);
+}, A = (e, o = {}) => {
+  const s = f.get(e);
+  if (s) return s;
+  const a = B(
+    e,
+    o.timeoutMs ?? b
+  ).finally(() => {
+    f.get(e) === a && f.delete(e);
+  });
+  return f.set(e, a), a;
+}, C = async (e, o, s = {}) => {
+  const a = s.timeoutMs ?? b, r = new u.Doc();
+  try {
+    u.applyUpdate(r, D(o), "dsheet-package-ingress");
+  } catch (i) {
+    return r.destroy(), p(e, "corrupt", i);
+  }
+  let t = null;
+  try {
+    return t = new E(e, r), await S(t.whenSynced, a), w(e, r);
+  } catch (i) {
+    return p(
+      e,
+      /timed out/i.test(String(i)) ? "timed-out" : "unavailable",
+      i
+    );
+  } finally {
+    await (t == null ? void 0 : t.destroy().catch(() => {
+    })), r.destroy();
+  }
+}, j = async (e) => {
+  f.delete(e), typeof indexedDB < "u" && await v(e);
+};
+export {
+  j as deleteDsheetContent,
+  M as getDsheetStateVector,
+  C as mergeDsheetContent,
+  A as readDsheetContent
+};

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;