@fileverse-dev/dsheet 4.1.23-stabilise-package-8 → 4.1.24

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

@@ -0,0 +1,81 @@
+/**
+ * Pure (DOM-free, ctx-free) logic that decides what an arrow key does while a
+ * formula is being edited.
+ *
+ * GRID             - not editing: arrows move the grid selection
+ * TEXT_EDIT        - arrows move the text caret
+ * REFERENCE_READY  - next arrow inserts a new cell reference at the caret
+ * REFERENCE_ACTIVE - arrows move/extend the reference that was just inserted
+ */
+export type FormulaArrowMode = 'GRID' | 'TEXT_EDIT' | 'REFERENCE_READY' | 'REFERENCE_ACTIVE';
+/** Sticky, user-controlled (F2). `null` = automatic behavior. */
+export type FormulaArrowOverride = null | 'TEXT_EDIT' | 'REFERENCE';
+export type TokenKind = 'EQ' | 'SPACE' | 'STRING' | 'REF' | 'NAME' | 'NUMBER' | 'FUNC_NAME' | 'LPAREN' | 'RPAREN' | 'COMMA' | 'OPERATOR' | 'POSTFIX' | 'UNKNOWN';
+export type Token = {
+    kind: TokenKind;
+    start: number;
+    end: number;
+    text: string;
+    /** STRING / quoted sheet name: closing quote present. */
+    terminated?: boolean;
+    /** REF that is not (yet) a complete reference, e.g. `A1:A`, `A1:`. */
+    partial?: boolean;
+};
+/** Never throws. Offsets index into `text` as given. */
+export declare function tokenizeFormula(text: string): Token[];
+export type CaretContext = {
+    inString: boolean;
+    /** Caret strictly inside a non-string token (e.g. `A|1`, `SU|M(`). */
+    insideToken: Token | null;
+    /** REF token the caret is inside or right after (start < caret <= end). */
+    touchingRef: Token | null;
+    prevSig: Token | null;
+    nextSig: Token | null;
+};
+export declare function getCaretContext(tokens: Token[], caret: number): CaretContext;
+/**
+ * True when a new operand (cell reference) can be entered at the caret:
+ * the previous significant token wants an operand, the caret is not inside a
+ * string or token, and no operand sits immediately to the right.
+ */
+export declare function isOperandSlot(ctx: CaretContext): boolean;
+export type ArrowModeInput = {
+    editing: boolean;
+    /** Full editor text (offsets of `caretOffset` index into it). */
+    text: string;
+    /** null when the caret is not inside the editor. */
+    caretOffset: number | null;
+    override: FormulaArrowOverride;
+    /** false for sessions opened on an existing formula (F2 / dblclick / bar). */
+    autoAllowed: boolean;
+    /**
+     * The engine is driving a reference right now (mouse drag, or a reference the
+     * keyboard just inserted and the caret is still on).
+     */
+    refActive: boolean;
+};
+/** Decision priority from the product spec, evaluated in this exact order. */
+export declare function resolveArrowMode(input: ArrowModeInput): FormulaArrowMode;
+/**
+ * F2 while editing a formula: flip between caret and reference selection.
+ *
+ * Toggles the stored override once one exists, so a second press always undoes
+ * the first, even at a caret where the derived mode cannot change (e.g. after
+ * `)`). With no stored override, flips from the mode the user is looking at.
+ */
+export declare function overrideAfterF2(mode: FormulaArrowMode, current?: FormulaArrowOverride): FormulaArrowOverride;
+/**
+ * Rule 4: keys typed while a reference is active end the arrow-driven
+ * reference. The next mode is then derived from the caret position
+ * (operator or `,` -> READY, `)` or anything else -> TEXT_EDIT).
+ * keyCode based because it is called from keyup/keydown handlers.
+ */
+export declare function isTextChangingKeyCode(kcode: number): boolean;
+/**
+ * Keys that edit characters *inside* a reference token (letters, digits incl.
+ * numpad digits, Backspace/Delete). Typing them over an arrow-inserted
+ * reference makes it a hand-edited token, so its highlight must be dropped.
+ * Operators, commas and spaces are not here: they end the reference but leave
+ * its highlight alone (see `isTextChangingKeyCode`).
+ */
+export declare function isReferenceDirtyingKeyCode(kcode: number): boolean;

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

@@ -37,11 +37,6 @@ export type FormulaAsyncEvalJob = {
     impactedByCircular: string[];
     cycleNodes: string[];
     workerSnapshotKey: string;
-    /**
-     * Set on a forced full pass: the dependency-graph epoch it started at. The
-     * last chunk marks the graph complete if the epoch is unchanged (C8).
-     */
-    fullPassEpoch?: number | null;
     nextIndex: number;
     total: number;
     debug?: FormulaEvalDebug;

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

@@ -20,8 +20,6 @@ export type SnapshotFormulaResult = {
     spe?: unknown;
     deps: string[];
     isError: boolean;
-    /** Read a sheet name that doesn't exist; the main thread keeps it on every commit's run list (C8). */
-    unresolvedSheetRef?: boolean;
 };
 export type SnapshotEvalInput = {
     sheets: SnapshotSheet[];

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

@@ -1,32 +1,7 @@
 /** 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 (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>, wide?: WideFormulaIndex): Set<string>;
+export declare function collectTransitiveFormulaDependents(originCellKey: string, revDepsByCell: Map<string, Set<string>>): Set<string>;

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

@@ -1,8 +1,8 @@
 import { Cell, CellMatrix, Rect, Selection } from '../types';
 import { Context } from '../context';
+import { FormulaArrowMode, FormulaArrowOverride } from './formula-arrow-mode';
 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. */
@@ -29,6 +29,9 @@ export declare class FormulaCache {
     rangedrag_row_start?: boolean;
     rangeSelectionActive?: boolean | null;
     keyboardRangeSelectionLock?: boolean;
+    arrowOverride?: FormulaArrowOverride;
+    arrowAutoAllowed?: boolean;
+    arrowSessionCell?: [number, number];
     /** True after arrow/Shift+arrow moved `func_selectedrange` without updating yellow selection. */
     formulaKeyboardRefSync?: boolean;
     formulaEditorOwner?: 'cell' | 'fx' | null;
@@ -52,32 +55,6 @@ 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
-     * cell (C8). While true, a commit to a cell with no dependents runs no
-     * formula pass. Cleared by `markDepGraphIncomplete`.
-     */
-    depGraphComplete: boolean;
-    /**
-     * Bumped each time the flag is cleared. A deferred full pass records it at
-     * start and sets the flag only if nothing cleared it while it ran.
-     */
-    depGraphEpoch: number;
-    /**
-     * Grid size (`rows x cols`) of each dense tab when the graph was completed.
-     * Whole-row and whole-column references were recorded at that size, so a
-     * commit to a tab that has grown since takes the full pass again.
-     */
-    depGraphSheetSizes: Map<string, string>;
     /**
      * Dependency collection state for the currently-parsed formula, set by `execfunction`.
      * When null, dependency recording is disabled.
@@ -86,10 +63,6 @@ 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>;
@@ -97,21 +70,6 @@ export declare class FormulaCache {
         hits: number;
         misses: number;
     };
-    /**
-     * Drop every recorded formula dependency, back to the state a fresh mount
-     * has. Used when a sheet's formula list is replaced from outside the
-     * engine (a collaborator's calcChain change, A4).
-     */
-    resetDependencyIndexes(): void;
-    /**
-     * The graph may miss edges: formulas moved, were rewritten or entered the
-     * chain without being evaluated. Commits take the full pass again until the
-     * next full pass completes.
-     */
-    markDepGraphIncomplete(): void;
-    /** Called after each `markDepGraphIncomplete` (the C8 warm-up re-runs). */
-    depGraphIncompleteListeners: Set<() => void>;
-    onDepGraphIncomplete(listener: () => void): () => void;
     constructor();
     materializeFullRangeFragment(context: Context, sheetId: string, flowdata: CellMatrix | null | undefined, startRow: number, endRow: number, startCol: number, endCol: number): {
         fragment: any[][];
@@ -123,46 +81,10 @@ 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
- * as calling delFunctionGroup for each cell.
- */
-export declare function delFunctionGroupBatch(ctx: Context, id: string, cells: {
-    r: number;
-    c: number;
-}[]): void;
 export declare function delFunctionGroup(ctx: Context, r: number, c: number, id?: string): void;
 export declare function insertUpdateFunctionGroup(ctx: Context, r: number, c: number, id?: string, calcChainSet?: Set<string>): void;
-/**
- * Drop every recorded formula dependency, back to a fresh mount's state, and
- * mark the graph incomplete (A4, C8).
- */
-export declare function resetFormulaDependencyIndexes(ctx: Context): void;
-/**
- * End of a full pass that started at `epoch` (C8): every formula in the chain
- * has recorded its dependencies, unless the graph was invalidated meanwhile.
- */
-export declare function finishFullFormulaPass(ctx: Context, epoch: number | null | undefined): void;
-/**
- * A tab that is loaded after the graph was completed keeps the flag on (K60,
- * PR 466): loading builds the grid from `celldata` and does not change the
- * tab's structure, and the text index already treated a whole-row or column
- * reference to a tab with no grid as wide. Without a recorded size the first
- * commit on the tab would take the full pass and clear the flag.
- */
-export declare function recordLoadedSheetSize(ctx: Context, sheetId: string | undefined, data: CellMatrix | 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. */
@@ -180,6 +102,14 @@ export declare function execFunctionGroup(ctx: Context, origin_r: number, origin
  * without resizing `luckysheet_select_save`.
  */
 export declare function seedFormulaFuncSelectedRangeFromLastSelection(ctx: Context): boolean;
+/**
+ * Explicit reference selection (F2) with the caret on an existing reference:
+ * seed the keyboard range from *that reference*, so the first arrow moves it
+ * from where it is (`=SUM(A1|)` + Right -> `=SUM(B1)`), not from the edited
+ * cell. Replaces any stale `func_selectedrange`. Returns false when the caret
+ * is not on a complete reference on the visible sheet.
+ */
+export declare function seedFormulaFuncSelectedRangeFromTouchedReference(ctx: Context): boolean;
 export declare function createFormulaRangeSelect(ctx: Context, select: {
     rangeIndex: number;
 } & Rect): void;
@@ -228,7 +158,7 @@ export declare function isBareCellOrRangeOnlyFormula(formulaText: string): boole
  * disable sheet-driven range selection until the caret reaches a fresh insertion slot
  * (comma, open paren, operator, etc.) or the user starts an active range drag.
  */
-export declare function suppressFormulaRangeSelectionForInitialEdit(ctx: Context): void;
+export declare function suppressFormulaRangeSelectionForInitialEdit(ctx: Context, cell?: [number, number]): void;
 export declare function isCaretAtValidFormulaRangeInsertionPoint(editor: HTMLElement | null): boolean;
 export declare function markRangeSelectionDirty(ctx: Context): void;
 /**
@@ -240,16 +170,31 @@ export declare function markRangeSelectionDirty(ctx: Context): void;
 export declare function getFormulaRangeIndexForKeyboardSync($editor: HTMLDivElement): number | null;
 export declare function handleFormulaInput(ctx: Context, $copyTo: HTMLDivElement | null | undefined, $editor: HTMLDivElement, kcode: number, preText?: string, refreshRangeSelect?: boolean): void;
 export declare function toggleFormulaAbsoluteReferenceAtCaret(ctx: Context, $copyTo: HTMLDivElement | null | undefined, $editor: HTMLDivElement | null | undefined): boolean;
-export type FormulaTabs = {
-    editedTab: string;
-    formulaTab: string;
-};
 /** True while picking a range for a formula (sheet selection drives references). */
 export declare function isLegacyFormulaRangeMode(ctx: Context): boolean;
 export declare function israngeseleciton(ctx: Context, istooltip?: boolean): boolean;
+/**
+ * Start (or end) an arrow-key session with the defaults: automatic reference
+ * selection on, no F2 override. Call when a session opens on a cell that does
+ * not hold a formula, and when one ends.
+ */
+export declare function resetFormulaArrowSession(ctx: Context): void;
+/** The F2 override / auto flag in effect for the cell being edited right now. */
+export declare function getFormulaArrowSession(ctx: Context): {
+    override: FormulaArrowOverride;
+    autoAllowed: boolean;
+};
+/** F2 pressed while editing: store the new override for this cell's session. */
+export declare function setFormulaArrowOverride(ctx: Context, override: FormulaArrowOverride): void;
+/**
+ * Single source of truth for what an arrow key does while editing.
+ * Thin ctx/DOM adapter over the pure `resolveArrowMode`.
+ */
+export declare function getFormulaArrowMode(ctx: Context): FormulaArrowMode;
+/** True while arrows should drive a cell reference (READY or ACTIVE). */
 export declare function isFormulaReferenceInputMode(ctx: Context): boolean;
 export declare function maybeRecoverDirtyRangeSelection(ctx: Context): boolean;
-export declare function functionStrChange(txt: string, type: string, rc: 'row' | 'col', orient: string | null, stindex: number, step: number, tabs: FormulaTabs): string;
+export declare function functionStrChange(txt: string, type: string, rc: 'row' | 'col', orient: string | null, stindex: number, step: number): string;
 export declare function rangeSetValue(ctx: Context, cellInput: HTMLDivElement, selected: any, fxInput?: HTMLDivElement | null): void;
 export declare function onFormulaRangeDragEnd(ctx: Context): void;
 export declare function rangeDrag(ctx: Context, e: MouseEvent, cellInput: HTMLDivElement, scrollLeft: number, scrollTop: number, container: HTMLDivElement, fxInput?: HTMLDivElement | null): void;

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

@@ -4,7 +4,7 @@ export { default as clipboard } from './clipboard';
 export { moveToEnd, getRangeRectsByCharacterOffset } from './cursor';
 export { getDateBaseLocale, getCanonicalDateDisplayFormat, getCanonicalDateEditFormat, getDateEditFormatForCell, isUsDateBaseLocale, normalizeDateBaseLocale, shouldPreserveDateFormatForEdit, setDateBaseLocale, } from './date-base-locale';
 export { update, is_date, valueShowEs, isTypedCurrencyDisplayFormat, isCurrencyLikeNumberFormat, buildFiatCurrencyFormat, quoteSsfLiteral, } from './format';
-export { FormulaCache, groupValuesRefresh, setCaretPosition, getrangeseleciton, getFormulaEditorOwner, rangeHightlightselected, handleFormulaInput, israngeseleciton, createRangeHightlight, createFormulaRangeSelect, maybeRecoverDirtyRangeSelection, delFunctionGroup, functionHTMLGenerate, onFormulaRangeDragEnd, rangeDrag, rangeSetValue, remapFormulaReferencesByMap, getFormulaRangeIndexAtCaret, isCaretAtValidFormulaRangeInsertionPoint, isLegacyFormulaRangeMode, markRangeSelectionDirty, getFormulaRangeIndexForKeyboardSync, isFormulaReferenceInputMode, seedFormulaFuncSelectedRangeFromLastSelection, functionStrChange, setFormulaEditorOwner, getAllFunctionGroup, suppressFormulaRangeSelectionForInitialEdit, ensureFormulaRangeToSheet, shouldPreserveFormulaEditOnSheetSwitch, activateSheetForNavigation, returnToFormulaOriginSheet, } from './formula';
+export { FormulaCache, groupValuesRefresh, setCaretPosition, getrangeseleciton, getFormulaEditorOwner, rangeHightlightselected, handleFormulaInput, israngeseleciton, createRangeHightlight, createFormulaRangeSelect, maybeRecoverDirtyRangeSelection, delFunctionGroup, functionHTMLGenerate, onFormulaRangeDragEnd, rangeDrag, rangeSetValue, remapFormulaReferencesByMap, getFormulaRangeIndexAtCaret, isCaretAtValidFormulaRangeInsertionPoint, isLegacyFormulaRangeMode, markRangeSelectionDirty, getFormulaRangeIndexForKeyboardSync, isFormulaReferenceInputMode, seedFormulaFuncSelectedRangeFromLastSelection, functionStrChange, setFormulaEditorOwner, getAllFunctionGroup, suppressFormulaRangeSelectionForInitialEdit, resetFormulaArrowSession, ensureFormulaRangeToSheet, shouldPreserveFormulaEditOnSheetSwitch, activateSheetForNavigation, returnToFormulaOriginSheet, } from './formula';
 export { FORMULA_ASYNC_CHUNK_SIZE, FORMULA_ASYNC_EVAL_THRESHOLD, FORMULA_WORKER_CHUNK_SIZE, FORMULA_WORKER_THRESHOLD, isFormulaEvalPending, } from './formula-async-eval';
 export type { FormulaAsyncEvalJob } from './formula-async-eval';
 export { initFreeze } from './freeze';
@@ -33,17 +33,16 @@ export { cfSplitRange } from './conditionalFormat';
 export { CFSplitRange } from './ConditionFormat';
 export { updateMoreCell, getRegStr, getDataArr } from './splitColumn';
 export { applyLocation, getOptionValue, getSelectRange, } from './locationCondition';
-export { getDropdownList, setDropdownValue, confirmMessage, cellFocus, validateCellData, splitDropdownOptions, getDropdownOptions, } from './dataVerification';
+export { getDropdownList, setDropdownValue, confirmMessage, cellFocus, validateCellData, } from './dataVerification';
 export { setConditionRules, CF_DATE_DEFAULT_FORMAT, parseCfDateConditionForUi, formatCfDatePresetSnapshot, parseDdMmYyyyToSerial, } from './ConditionFormat';
 export { handleOverlayTouchStart, handleOverlayTouchEnd } from './mobile';
 export { MAX_ZOOM_RATIO, MIN_ZOOM_RATIO } from './zoom';
 export { jfrefreshgrid } from './refresh';
-export { deleteCellsShift, insertCellsShift } from './cell-shift';
 export { sanitizeDuneUrl, insertDuneChart, onIframeMoveStart, onIframeResizeStart, onIframeMove, onIframeMoveEnd, onIframeResize, onIframeResizeEnd, } from './iframe';
 export { setCellError, clearCellError, overShowError, } from './error-state-helpers';
 export { checkCellIsLocked } from './protection';
 export { detectDateFormat, isdatatypemulti, diff, isdatetime, isRealNull, isRealNum, isNumericCellType, } from './validation';
-export { iscelldata, getcellrange, execfunction, execFunctionGroup, refreshFormulasUsingDefinedNames, runFormulaEvalChunk, applyWorkerFormulaChunkResults, finishFullFormulaPass, resetFormulaDependencyIndexes, insertUpdateFunctionGroup, functionCopy, } from './formula';
+export { iscelldata, getcellrange, execfunction, execFunctionGroup, refreshFormulasUsingDefinedNames, runFormulaEvalChunk, applyWorkerFormulaChunkResults, insertUpdateFunctionGroup, functionCopy, } from './formula';
 export { checkCF, getComputeMap } from './ConditionFormat';
 export { isValidDefinedNameIdentifier, getDefinedNameDisplayRange, findDefinedNameForSelection, findDefinedNameByName, resolveDefinedNameForFormula, addDefinedName, updateDefinedName, deleteDefinedName, selectDefinedName, openNamedRangesSidebar, scheduleDefinedNamesSync, shiftDefinedNamesOnInsert, shiftDefinedNamesOnDelete, removeDefinedNamesForSheet, } from './namedRanges';
 export { getdatabyselection, getQKBorder } from './cell';

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

@@ -1,13 +1,5 @@
 import { Context } from '../context';
-import { Sheet } from '../types';
 
-/**
- * True when the edit would change a cross-tab formula in the tab's celldata.
- * It is the test the rewrite below applies, so the tabs loaded before an edit
- * are the ones it would rewrite (PR 466 N1: `=C1-A!B5` names tab A, but the
- * sheet-name regex reads `C1-A`).
- */
-export declare const celldataFormulaWouldChange: (sheet: Sheet, mode: "add" | "del", rc: "row" | "col", orient: "lefttop" | "rightbottom" | null, stindex: number, step: number, editedTab: string) => boolean;
 /**
  * 增加行列
  * @param {string} type 行或列 ['row', 'column'] 之一

package/dist/sheet-engine/core/paste-helpers/calculate-range-cell-size.d.ts

@@ -1,18 +1,5 @@
 import { Context } from '../context';
 
-type Measure2d = {
-    measureText(t: string): {
-        width: number;
-    };
-    font: string;
-};
-/** Drop cached widths, e.g. after web fonts load and change the metrics. */
-export declare function clearSingleLineCache(): void;
-/**
- * Width of one line of text in `font`, from canvas measureText, cached by
- * (font, text). No DOM layout is involved.
- */
-export declare function measureSingleLine(font: string, text: string, ctx2d: Measure2d): number;
 export declare function calculateRangeCellSize(ctx: Context, sheetId: string, startRow: number, endRow: number, startCol: number, endCol: number, maxColumnWidth?: number): {
     rowMax: Record<number, number>;
     colMax: Record<number, number>;
@@ -22,4 +9,3 @@ export declare const updateSheetCellSizes: (ctx: Context, sheetIndex: number, me
     rowMax: Record<number, number>;
     colMax: Record<number, number>;
 }, maxColumnWidth?: number) => void;
-export {};

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

@@ -29,17 +29,7 @@ export type Hooks = {
     beforeUpdateCell?: (r: number, c: number, value: any) => boolean;
     /** Clears RTC remote-apply lock so local edits can run data-block formulas. */
     onLocalCellEdit?: () => void;
-    afterUpdateCell?: (row: number, column: number, oldValue: any, newValue: any, 
-    /** Sheet that held the cell when it was committed (updateCell only). */
-    sheetId?: string, 
-    /**
-     * `skipPersist`: the caller writes this cell to Yjs in its own batch (paste
-     * and fill), after the cell is final. Persisting here too wrote the
-     * pre-format value first, so every formula was written twice.
-     */
-    options?: {
-        skipPersist?: boolean;
-    }) => void;
+    afterUpdateCell?: (row: number, column: number, oldValue: any, newValue: any) => void;
     afterSelectionChange?: (sheetId: string, selection: Selection) => void;
     beforeRenderRowHeaderCell?: (rowNumber: string, rowIndex: number, top: number, width: number, height: number, ctx: CanvasRenderingContext2D) => boolean;
     afterRenderRowHeaderCell?: (rowNumber: string, rowIndex: number, top: number, width: number, height: number, ctx: CanvasRenderingContext2D) => void;

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

@@ -1,17 +1,6 @@
 import { Context } from '../context';
 import { Cell, CellWithRowAndCol } from '../types';
 
-/** Receives changes instead of the updateCellYdoc hook (see createYdocBatch). */
-export type YdocChangeSink = (changes: any[]) => void;
-/**
- * Collect the Yjs changes of one structural edit and send them in a single
- * updateCellYdoc call, so the edit is one transaction and one update for peers
- * (an insert used to send four and a delete five).
- */
-export declare function createYdocBatch(ctx: Context): {
-    sink: YdocChangeSink;
-    flush: () => void;
-};
 export type CelldataYdocChange = {
     sheetId: string;
     path: string[];
@@ -28,29 +17,13 @@ export declare function cellsEqualForYdocPersist(before: unknown, after: unknown
 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>, sink?: YdocChangeSink): void;
-/** Formula text per tab and cell key, taken before a structural edit rewrites it. */
-export type FormulaTextSnapshot = Map<string, Map<string, string>>;
-/**
- * Snapshot formula text on every hydrated tab. A row/column insert or delete
- * rewrites formulas on all tabs, but only the edited tab's shifted range is
- * diffed to Yjs, so the rest has to be found by comparing against this.
- */
-export declare function snapshotFormulaTexts(ctx: Context): FormulaTextSnapshot;
-/**
- * Emit cells whose formula text changed since `before`, so peers see the
- * rewrite. On the edited tab, cells at or past (`editedFromR`, `editedFromC`)
- * are skipped: the range diff already writes them. `before` keys are
- * pre-edit coordinates, which equal post-edit ones for every cell outside
- * that range.
- */
-export declare function emitRewrittenFormulasToYdoc(ctx: Context, before: FormulaTextSnapshot, editedSheetId: string, editedFromR: number, editedFromC: number, sink?: YdocChangeSink): void;
+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, sink?: YdocChangeSink): void;
+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;

package/dist/sheet-engine/react/components/ContextMenu/FilterMenu.d.ts

@@ -1,4 +1,4 @@
 import { default as React } from 'react';
 
-declare const _default: React.NamedExoticComponent<{}>;
-export default _default;
+declare const FilterMenu: React.FC;
+export default FilterMenu;

package/dist/sheet-engine/react/components/ContextMenu/SheetTab.d.ts

@@ -1,4 +1,4 @@
 import { default as React } from 'react';
 
-declare const _default: React.NamedExoticComponent<{}>;
-export default _default;
+declare const SheetTabContextMenu: React.FC;
+export default SheetTabContextMenu;

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

@@ -1,4 +1,4 @@
 import { default as React } from 'react';
 
-declare const _default: React.NamedExoticComponent<{}>;
-export default _default;
+declare const ContextMenu: React.FC;
+export default ContextMenu;

package/dist/sheet-engine/react/components/SVGDefines.d.ts

@@ -1,6 +1,6 @@
 import { default as React } from 'react';
 
-declare const _default: React.NamedExoticComponent<{
+declare const SVGDefines: React.FC<{
     currency: string;
 }>;
-export default _default;
+export default SVGDefines;

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

@@ -1,4 +1,4 @@
 import { default as React } from 'react';
 
-declare const _default: React.NamedExoticComponent<{}>;
-export default _default;
+declare const SheetTab: React.FC;
+export default SheetTab;

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

@@ -7,11 +7,11 @@ export declare const CurrencySelector: ({ cell, defaultTextFormat, toolTipText,
     defaultTextFormat: string;
     toolTipText: string;
 }) => import("react/jsx-runtime").JSX.Element;
-declare const _default: React.NamedExoticComponent<{
+declare const Toolbar: React.FC<{
     setMoreItems: React.Dispatch<React.SetStateAction<React.ReactNode>>;
     moreItemsOpen: boolean;
     onMoreToolbarItemsClose?: () => void;
     moreToolbarItems?: React.ReactNode;
     trailingContent?: React.ReactNode;
 }>;
-export default _default;
+export default Toolbar;

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

@@ -31,10 +31,6 @@ export declare function generateAPIs(context: Context, setContext: (recipe: (ctx
     applyRemoteCellValue: (row: number, column: number, value: any, options?: api.CommonOptions & {
         type?: keyof Cell;
     }) => void;
-    /** Remote formula-list change, applied in place (A4). */
-    setSheetCalcChain: (calcChain: Sheet["calcChain"], options?: api.CommonOptions) => void;
-    /** Remote cell batch: one quiet update, off the local undo stack (A5). */
-    applyRemoteCells: (cells: api.RemoteCellChange[], options?: api.CommonOptions, onSkip?: (cell: api.RemoteCellChange, error: unknown) => void) => void;
     setCellError: (row: number, column: number, errorMessage: {
         title: string;
         message: string;

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

@@ -33,8 +33,6 @@ declare const Workbook: React.ForwardRefExoticComponent<Settings & AdditionalPro
     applyRemoteCellValue: (row: number, column: number, value: any, options?: api.CommonOptions & {
         type?: keyof import('../../../core').Cell;
     }) => void;
-    setSheetCalcChain: (calcChain: SheetType["calcChain"], options?: api.CommonOptions) => void;
-    applyRemoteCells: (cells: api.RemoteCellChange[], options?: api.CommonOptions, onSkip?: (cell: api.RemoteCellChange, error: unknown) => void) => void;
     setCellError: (row: number, column: number, errorMessage: {
         title: string;
         message: string;

package/dist/sheet-engine/react/context/index.d.ts

@@ -1,6 +1,5 @@
 import { default as React } from 'react';
 import { Context, Settings, GlobalCache, PatchOptions } from '../../core';
-import { WorkbookStore } from './workbook-store';
 
 export type RefValues = {
     globalCache: GlobalCache;
@@ -24,18 +23,4 @@ declare const WorkbookContext: React.Context<{
     handleUndo: () => void;
     handleRedo: () => void;
 }>;
-/**
- * The parts of the workbook that rarely change (setters, settings, refs) plus
- * the store holding the latest context. Components that must not render on
- * every update read this instead of `WorkbookContext` (E2).
- */
-export type WorkbookStable = {
-    store: WorkbookStore<Context>;
-    setContext: (recipe: (ctx: Context) => void, options?: SetContextOptions) => void;
-    settings: Required<Settings>;
-    refs: RefValues;
-    handleUndo: () => void;
-    handleRedo: () => void;
-};
-export declare const WorkbookStableContext: React.Context<WorkbookStable>;
 export default WorkbookContext;