@fileverse-dev/dsheet 4.1.23-stabilise-package-4 → 4.1.23-stabilise-package-6

package/dist/index.es.js

@@ -1,5 +1,5 @@
-import { C as s, f as o, g as t, S as r, h as l, j as n, k as d, T as S, l as c, n as i, o as h, p as m, q as p, t as C, u, v as E, w as F, x, z as g, A as R, B as f, D as A, E as I, F as L, G as w, H as T, I as v, J as y, K as D, L as M, M as O, N as b, O as k, P, Q as V } from "./index-YKT7Lz7Z.js";
-import { cG as B, cH as G, cI as H, cO as K, by as U, e as X, f as _, l as J, a as j, du as q, dv as N, bh as Q, dw as Y, dx as Z, dB as W, dC as $, dE as ee, J as ae, dS as se, eq as oe, ba as te } from "./executeStringFunction-BsVLVYUB.js";
+import { C as s, f as o, g as t, S as r, h as l, j as n, k as d, T as S, l as c, n as i, o as h, p as m, q as p, t as C, u, v as F, w as E, x, z as g, A as R, B as f, D as A, E as I, F as L, G as w, H as y, I as T, J as v, K as D, L as M, M as b, N as k, O as K, P as O, Q as P } from "./index-CYTfmipC.js";
+import { cI as z, cJ as J, cK as U, cQ as X, by as _, e as B, f as G, l as H, a as j, dv as q, dw as N, bh as Q, dx as Y, dy as Z, dC as W, dD as $, dF as ee, J as ae, dS as se, eq as oe, ba as te } from "./executeStringFunction-7PJajNOY.js";
 import { FLVURL as le } from "@fileverse-dev/formulajs";
 import { E as de, S as Se } from "./constants-8Ij49Lxv.js";
 export {
@@ -15,22 +15,22 @@ export {
   d as SupportedChain,
   S as TEMPLATES,
   c as api,
-  B as clearColumnsCellsFormat,
+  z as clearColumnsCellsFormat,
   i as clearFilter,
-  G as clearRowsCellsFormat,
-  H as clearSelectedCellFormat,
+  J as clearRowsCellsFormat,
+  U as clearSelectedCellFormat,
   h as createFilter,
   m as decryptForRoomKey,
-  K as deleteRowCol,
-  U as deleteSelectedCellText,
+  X as deleteRowCol,
+  _ as deleteSelectedCellText,
   p as describeMatchedShortcut,
   C as encryptForRoomKey,
-  X as executeStringFunction,
+  B as executeStringFunction,
   u as fetchSessionState,
-  _ as formulaResponseUiSync,
-  J as getFlowdata,
-  E as getRemoveDuplicatesErrorMessage,
-  F as getRemoveDuplicatesPreview,
+  G as formulaResponseUiSync,
+  H as getFlowdata,
+  F as getRemoveDuplicatesErrorMessage,
+  E as getRemoveDuplicatesPreview,
   j as getSheetIndex,
   x as handleCSVUpload,
   g as handleCopy,
@@ -48,18 +48,18 @@ export {
   $ as handleVerticalAlign,
   w as importSpreadsheetFile,
   ee as insertRowCol,
-  T as isBrowserZoomShortcut,
-  v as isFormulaListShortcut,
-  y as isOpenShortcutsModalShortcut,
+  y as isBrowserZoomShortcut,
+  T as isFormulaListShortcut,
+  v as isOpenShortcutsModalShortcut,
   ae as jfrefreshgrid,
   se as loadLocale,
   D as remapCommentAnchors,
   M as removeActiveImage,
-  O as removeDuplicates,
-  b as seedSession,
-  k as showImgChooser,
+  b as removeDuplicates,
+  k as seedSession,
+  K as showImgChooser,
   oe as toolbarItemClickHandler,
   te as updateFormat,
-  P as useEnsStatus,
-  V as useXLSXImport
+  O as useEnsStatus,
+  P as useXLSXImport
 };

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

@@ -8,10 +8,15 @@ export declare function getCellValue(ctx: Context, row: number, column: number,
 export declare function setCellValue(ctx: Context, row: number, column: number, value: any, cellInput: HTMLDivElement | null, options?: CommonOptions, callAfterUpdate?: boolean): void;
 export declare function applyRemoteCellValue(ctx: Context, row: number, column: number, value: any, options?: CommonOptions): void;
 /**
- * Replace a sheet's formula list with the collaborator's value from Yjs and
- * reset the formula dependency indexes to a fresh mount's state (A4). This
- * is what the grid rebuild it replaces produced, without the rebuild. The
+ * Replace a sheet's formula list with the collaborator's value from Yjs (A4).
+ * This is what the grid rebuild it replaces produced, without the rebuild. The
  * caller runs it with noHistory.
+ *
+ * The dependency edges follow the change (C8): an entry that left the chain
+ * loses its edges, one that joined gets the edges its cell's text names (or
+ * runs on every commit until its cell arrives), and the rest are left alone, so
+ * `depGraphComplete` stays on. When the two chains can't be compared the
+ * indexes reset to a fresh mount's state.
  */
 export declare function setSheetCalcChain(ctx: Context, calcChain: Sheet['calcChain'], options?: CommonOptions): void;
 export type RemoteCellChange = {

package/dist/sheet-engine/core/modules/formula-dep-text.d.ts

@@ -0,0 +1,23 @@
+import { Context } from '../context';
+import { WideRange } from './formula-transitive-deps';
+
+/** Same cap as `execfunction` (MAX_RANGE_DEPS in formula.ts). */
+export declare const MAX_TEXT_RANGE_DEPS = 10000;
+export type FormulaTextDeps = {
+    /** `${sheetId}:${r}:${c}` of every cell the formula reads. */
+    deps: Set<string>;
+    /** Too wide or unresolvable to list. */
+    wide: boolean;
+    /**
+     * The ranges that made it wide, as `execfunction` records them. `null` when
+     * the formula is wide but its ranges can't be read from its text (an
+     * unresolved tab, INDIRECT, OFFSET, a whole row or column of a tab with no
+     * grid): it joins every commit's walk. `[]` when it is not wide.
+     */
+    wideRanges: WideRange[] | null;
+};
+/**
+ * Collect the references of formula text `f` (with its leading `=`) written
+ * in cell (`r`, `c`) of tab `sheetId`.
+ */
+export declare function collectFormulaTextDeps(ctx: Context, f: string, sheetId: string, r: number, c: number): FormulaTextDeps;

package/dist/sheet-engine/core/modules/formula-dep-text.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sheet-engine/core/modules/formula-edge-update.d.ts

@@ -0,0 +1,13 @@
+import { Context } from '../context';
+
+/**
+ * Set the edges of the formula `f` written in (`r`, `c`) of tab `sheetId`, or
+ * drop them when `f` is null (the value is no longer a formula).
+ */
+export declare function setFormulaEdgesFromText(ctx: Context, r: number, c: number, sheetId: string, f: string | null): void;
+/**
+ * A chain entry whose cell isn't here yet (a peer's chain can arrive before
+ * its cells): it can't be read, so it runs on every commit until the cell
+ * arrives and replaces this.
+ */
+export declare function markFormulaEdgesUnknown(ctx: Context, r: number, c: number, sheetId: string): void;

package/dist/sheet-engine/core/modules/formula-transitive-deps.d.ts

@@ -1,11 +1,32 @@
 /** Cell / formula key format used in depsByCell and revDepsByCell. */
 export declare function toFormulaDepCellKey(sheetId: string, r: number, c: number): string;
+/** A range a wide formula reads (more cells than get individual edges). */
+export type WideRange = {
+    sheetId: string;
+    startRow: number;
+    endRow: number;
+    startCol: number;
+    endCol: number;
+};
+/**
+ * Wide formulas (ranges over MAX_RANGE_DEPS cells record no cell edges).
+ * `ranges` holds the ranges of those whose ranges could be read; a key in
+ * `keys` without an entry in `ranges` can't be bounded, so it joins every walk.
+ */
+export type WideFormulaIndex = {
+    keys: Iterable<string>;
+    ranges: Map<string, WideRange[]>;
+};
 /**
  * Walk revDepsByCell from a changed cell to collect every formula cell that
  * must recalculate (direct + transitive dependents).
  *
  * `extraFormulaSeeds` are formulas that run on every commit whatever the
- * graph says (very large ranges, named ranges covering the edited cell). They
- * join the same walk, so formulas that read their results are reached too.
+ * graph says (named ranges covering the edited cell). They join the same
+ * walk, so formulas that read their results are reached too.
+ *
+ * A wide formula joins the walk only when one of its ranges holds the edited
+ * cell or a formula cell the walk reaches; one whose ranges can't be read
+ * joins every walk. It then seeds the walk like any other formula.
  */
-export declare function collectTransitiveFormulaDependents(originCellKey: string, revDepsByCell: Map<string, Set<string>>, extraFormulaSeeds?: Iterable<string>): Set<string>;
+export declare function collectTransitiveFormulaDependents(originCellKey: string, revDepsByCell: Map<string, Set<string>>, extraFormulaSeeds?: Iterable<string>, wide?: WideFormulaIndex): Set<string>;

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

@@ -5,21 +5,17 @@ export declare const FORMULA_WARMUP_DEBOUNCE_MS = 2000;
 export declare const FORMULA_WARMUP_IDLE_TIMEOUT_MS = 1000;
 export type FormulaWarmupResult = 'complete' | 'aborted';
 export type FormulaWarmupOptions = {
-    /** Longest a slice keeps evaluating before it yields (default 8). */
+    /** Longest a slice keeps reading formulas before it yields (default 8). */
     budgetMs: number;
     /** Runs the next slice later (idle callback in the app). */
     schedule: (cb: () => void) => void;
     isCancelled?: () => boolean;
 };
 /**
- * Formula functions that are `async` (they fetch over the network, e.g.
- * ETHERSCAN, EOA). The warm-up records their arguments but never calls them.
- */
-export declare function isAsyncFormulaFunction(name: string): boolean;
-/**
- * Walk the calc chain in slices and record every formula's dependencies, then
+ * Walk the calc chain in slices and read every formula's references, then
  * mark the graph complete (C8). Resolves 'aborted' if the graph is cleared
- * while it runs, a tab holding formulas is sparse, or `isCancelled` says so.
+ * while it runs or `isCancelled` says so. A tab with no grid is read from its
+ * `celldata`.
  *
  * Pass a getter to read the latest context in each slice (the Workbook does);
  * a plain context is used as is.

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

@@ -2,6 +2,7 @@ import { Cell, CellMatrix, Rect, Selection } from '../types';
 import { Context } from '../context';
 import { FormulaAsyncEvalJob } from './formula-async-eval';
 import { RangePassCacheEntry } from './formula-range-cache';
+import { WideRange } from './formula-transitive-deps';
 import { SnapshotEvalOutput } from './formula-snapshot-eval';
 
 /** True when the formula is only numeric ops on TODAY()/NOW() (incl. unary +/−); used to display serials as dates. */
@@ -51,6 +52,14 @@ export declare class FormulaCache {
      * affect them even when no precise reverse edge exists.
      */
     formulasWithWideRangeDeps: Set<string>;
+    /**
+     * The ranges of the wide formulas whose ranges could be read, by formula
+     * key. A wide formula joins a commit's walk only when one of these holds the
+     * edited cell or a formula cell the walk reaches. A key in
+     * `formulasWithWideRangeDeps` with no entry here (an unresolved tab, an
+     * unreadable range) joins every walk.
+     */
+    wideRangesByFormula: Map<string, WideRange[]>;
     /**
      * True once a full pass has evaluated every formula in the chain since the
      * indexes were last reset, so `revDepsByCell` lists every dependent of every
@@ -77,6 +86,10 @@ export declare class FormulaCache {
         originKey: string;
         deps: Set<string>;
         hasWideRangeDep: boolean;
+        /** Ranges over the cap, in the order they were read. */
+        wideRanges: WideRange[];
+        /** A wide dependency whose range can't be bounded (unresolved tab). */
+        wideUnreadable: boolean;
     };
     /** Step 2: per execFunctionGroup pass cache for materialized range reads. */
     rangeValuePassCache?: Map<string, RangePassCacheEntry>;
@@ -110,6 +123,8 @@ export declare class FormulaCache {
 export declare function iscelldata(txt: string): boolean;
 export declare function getcellrange(ctx: Context, txt: string, formulaId?: string): any;
 export declare function getAllFunctionGroup(ctx: Context): any[];
+/** Remove the dependency edges recorded for a cell that is no longer a formula. */
+export declare function dropDependencyEdges(ctx: Context, r: number, c: number, id: string): void;
 /**
  * delFunctionGroup for many cells of one sheet: the chain and the dynamic
  * array list are filtered once, not scanned and copied per cell. Same result
@@ -131,8 +146,15 @@ export declare function resetFormulaDependencyIndexes(ctx: Context): void;
  * has recorded its dependencies, unless the graph was invalidated meanwhile.
  */
 export declare function finishFullFormulaPass(ctx: Context, epoch: number | null | undefined): void;
+/**
+ * INDIRECT and OFFSET would resolve references at run time, which the graph
+ * cannot see. Today both evaluate to an error (formulajs implements neither),
+ * but formulas using them are kept on every commit's run list regardless.
+ */
+export declare const RUNTIME_REFERENCE_RE: RegExp;
 export declare function execfunction(ctx: Context, txt: string, r: number, c: number, id?: string, calcChainSet?: Set<string>, isrefresh?: boolean, notInsertFunc?: boolean): any[];
 export declare function groupValuesRefresh(ctx: Context): void;
+export declare function mergeFormulaDeps(ctx: Context, originKey: string, deps: Iterable<string>): void;
 /** Apply worker chunk output onto the live context (main thread only). */
 export declare function applyWorkerFormulaChunkResults(ctx: Context, output: SnapshotEvalOutput, impactedByCircular: Set<string>, cycleNodes: Set<string>, calcChainKeys?: string[], data?: CellMatrix | null): void;
 /** Run up to `chunkSize` formulas from an async job. Returns true when job is complete. */

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

@@ -0,0 +1,25 @@
+/**
+ * A structural edit rewrites the cross-tab formulas of a tab that is not
+ * loaded in its `celldata`, as one replacement of the whole array (PR 466 N1).
+ * Undo and redo replay that replacement, so the engine is right; the Yjs write
+ * for it compares the two arrays here.
+ *
+ * Only formulas that name another tab (they contain `!`) are compared. Those
+ * are the cells a structural edit on another tab can rewrite; a cell a
+ * collaborator changed in between is not written back.
+ */
+type CelldataEntry = {
+    r: number;
+    c: number;
+    v?: any;
+};
+export type CelldataArrayChange = {
+    sheetId: string;
+    path: ['celldata'];
+    key: string;
+    value: CelldataEntry | null;
+    type: 'update' | 'delete';
+};
+/** The Yjs changes that turn `before` into `after` for the cross-tab formulas. */
+export declare function celldataArrayChanges(sheetId: string, before: CelldataEntry[] | undefined, after: CelldataEntry[] | undefined): CelldataArrayChange[];
+export {};

package/dist/sheet-engine/core/modules/rowcol-refused-edit.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sheet-engine/core/modules/rowcol-unloaded-history.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sheet-engine/react/components/NotationBoxes/shown-comments.d.ts

@@ -3,6 +3,8 @@ import { Cell } from '../../../core/types';
 export type ShownCommentCell = {
     r: number;
     c: number;
+    /** Position, size and text of the pinned box (see `shownCommentsKey`). */
+    sig: string;
 };
 /** Cells whose comment popup is pinned open (`ps.isShow`), in row-major order. */
 export declare function collectShownCommentCells(data: (Cell | null)[][]): ShownCommentCell[];
@@ -11,6 +13,8 @@ export declare function collectShownCommentCells(data: (Cell | null)[][]): Shown
  * when this changes, so an edit that leaves the set alone costs no second
  * context update. The sheet id is part of the key so that switching to a sheet
  * with an equal (for example empty) set still replaces the previous sheet's
- * boxes.
+ * boxes. Moving or resizing a pinned box, or a peer editing its text, writes
+ * `ps` but not `commentBoxes`, so each shown cell's `ps` position, size and
+ * text are part of the key too.
  */
 export declare function shownCommentsKey(sheetId: string | undefined, cells: ShownCommentCell[]): string;

package/dist/sheet-engine/react/components/SheetOverlay/hover-tracker.d.ts

@@ -34,7 +34,11 @@ export declare function createHoverTracker({ getRect, locate, isInteracting, req
 /**
  * True when `handleOverlayMouseMove` or `overShowLinkCard` do something that
  * depends on more than the hovered cell: a comment box, image, cell or dialog
- * drag, or a popup that must see the pointer leave it.
+ * drag, a popup that must see the pointer leave it, or one of the drag states
+ * after which `handleOverlayMouseMove` runs `mouseRender` on every move
+ * (`luckysheet_scroll_status` is set by every drag start). Outside the grid
+ * every position maps to "no cell", so auto-scroll and the resize guide need
+ * each move.
  */
 export declare function isHoverInteractionActive(ctx: Context, globalCache: GlobalCache): boolean;
 export {};

package/dist/{use-xlsx-import-impl-8Lojcck9.js → use-xlsx-import-impl-C1HeHhb9.js}

@@ -1,10 +1,10 @@
 import * as BZ from "yjs";
-import { i as Yl, a as hl, b as ul, s as eZ, r as Il, y as pl, d as Rl, m as sl } from "./index-YKT7Lz7Z.js";
-import { g as al } from "./executeStringFunction-BsVLVYUB.js";
+import { i as Yl, a as hl, b as ul, s as eZ, r as Il, y as pl, d as Rl, m as sl } from "./index-CYTfmipC.js";
+import { g as al } from "./executeStringFunction-7PJajNOY.js";
 import { Workbook as Kl } from "exceljs";
 import Jl from "luckyexcel";
-import { e as xl, b as Ml, n as Sl } from "./xlsx-hyperlink-inline-07QbQDEt.js";
-import { parseDefinedNamesFromXlsxBuffer as Nl, excelEntriesToDefinedNames as OZ } from "./xlsx-defined-names-D3F23p2Z.js";
+import { e as xl, b as Ml, n as Sl } from "./xlsx-hyperlink-inline-C88tUQTK.js";
+import { parseDefinedNamesFromXlsxBuffer as Nl, excelEntriesToDefinedNames as OZ } from "./xlsx-defined-names-k0uTgLHs.js";
 import { toast as fZ } from "@fileverse/ui";
 var Zl = { exports: {} };
 (function(m) {

package/dist/{xlsx-defined-names-D3F23p2Z.js → xlsx-defined-names-k0uTgLHs.js}

@@ -1,5 +1,5 @@
-import { i as w } from "./executeStringFunction-BsVLVYUB.js";
-import { J as x } from "./xlsx-hyperlink-inline-07QbQDEt.js";
+import { i as w } from "./executeStringFunction-7PJajNOY.js";
+import { J as x } from "./xlsx-hyperlink-inline-C88tUQTK.js";
 function g(o) {
   return o.startsWith("_xlnm.");
 }

package/dist/{xlsx-export-impl-DXWvjnk5.js → xlsx-export-impl-93M1pRiV.js}

@@ -1,9 +1,9 @@
 import { utils as S, write as nt } from "xlsx-js-style";
 import { Workbook as pt } from "exceljs";
 import { toast as rt } from "@fileverse/ui";
-import { J as dt, c as X, g as ht, a as mt } from "./xlsx-hyperlink-inline-07QbQDEt.js";
-import { b as gt } from "./executeStringFunction-BsVLVYUB.js";
-import { e as bt } from "./index-YKT7Lz7Z.js";
+import { J as dt, c as X, g as ht, a as mt } from "./xlsx-hyperlink-inline-C88tUQTK.js";
+import { b as gt } from "./executeStringFunction-7PJajNOY.js";
+import { e as bt } from "./index-CYTfmipC.js";
 const xt = {
   1: "thin",
   2: "hair",
@@ -854,7 +854,7 @@ const Z = (t) => {
           O
         );
       });
-      const { applyDefinedNamesToExcelWorkbook: ct } = await import("./xlsx-defined-names-D3F23p2Z.js");
+      const { applyDefinedNamesToExcelWorkbook: ct } = await import("./xlsx-defined-names-k0uTgLHs.js");
       ct(
         B,
         (k = (C = (s = t.current).getWorkbookContext) == null ? void 0 : C.call(s)) == null ? void 0 : k.definedNames,

package/dist/{xlsx-hyperlink-inline-07QbQDEt.js → xlsx-hyperlink-inline-C88tUQTK.js}

@@ -1,5 +1,5 @@
-import { g as Rt, c as yt } from "./executeStringFunction-BsVLVYUB.js";
-import { c as wt } from "./index-YKT7Lz7Z.js";
+import { g as Rt, c as yt } from "./executeStringFunction-7PJajNOY.js";
+import { c as wt } from "./index-CYTfmipC.js";
 function jt(J, nt) {
   const g = J.getImages();
   if (!g.length) return [];

package/package.json

@@ -2,7 +2,7 @@
   "name": "@fileverse-dev/dsheet",
   "private": false,
   "description": "DSheet",
-  "version": "4.1.23-stabilise-package-4",
+  "version": "4.1.23-stabilise-package-6",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/fileverse/fileverse-dsheets.git"