logisheets 1.15.0 → 1.16.0

package/README.md

@@ -27,7 +27,8 @@ import {Workbook, isErrorMessage} from 'logisheets'
 // Load a workbook from an .xlsx file on disk.
 const wb = new Workbook()
 const buf = readFileSync('book.xlsx')
-const code = wb.load(new Uint8Array(buf), 'book.xlsx') // 0 === success
+const loaded = wb.load(new Uint8Array(buf), 'book.xlsx')
+if (isErrorMessage(loaded)) throw new Error(loaded.msg)
 
 // Read a cell.
 const ws = wb.getWorksheet(0)
@@ -49,7 +50,7 @@ wb.execTransaction({
 })
 
 // Save back to .xlsx.
-const saved = wb.save('') // { data: Uint8Array, code }
+const saved = wb.save('') // { data: Uint8Array }, or an ErrorMessage
 writeFileSync('out.xlsx', saved.data)
 ```
 

package/dist/index.js

@@ -1,4 +1,21 @@
 "use strict";
+// logisheets — the LogiSheets engine for Node.
+//
+// Same API as logisheets-web (`Workbook`, `Worksheet`, the generated bindings,
+// `isErrorMessage`, ...), from the same source: `./src` is NOT tracked here.
+// `yarn link` (run by `prepare` / `prepublishOnly`) copies packages/web/src
+// over it, so edit and document the code in packages/web, never here.
+//
+// Differences from logisheets-web:
+//   - built against the nodejs-target WASM, which loads the .wasm from disk
+//     and initializes itself on require. There is no `initWasm` to await; a
+//     `new Workbook()` works straight after import.
+//   - the web package's root-only extras (`initWasm`, `formatNumber`,
+//     `formatText`) are not exported.
+//   - CommonJS output.
+//
+// For a managed multi-workbook host with RPC, crafts and file watching on top
+// of this engine, use logisheets-runtime.
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);

package/dist/src/api/block_manager.d.ts

@@ -1,3 +1,5 @@
+/** Hands out block ids for `Workbook.createBlockForNewCraft` and checks that a
+ *  created block can be bound. Internal to `Workbook`. */
 export declare class BlockManager {
     constructor(checkBindBlock: (sheetIdx: number, blockId: number, rowCount: number, colCount: number) => boolean, getAvailableBlockId: (sheetIdx: number) => number);
     /**

package/dist/src/api/block_manager.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BlockManager = void 0;
+/** Hands out block ids for `Workbook.createBlockForNewCraft` and checks that a
+ *  created block can be bound. Internal to `Workbook`. */
 class BlockManager {
     constructor(checkBindBlock, getAvailableBlockId) {
         this._checkBindBlock = checkBindBlock;

package/dist/src/api/calculator.d.ts

@@ -1,16 +1,28 @@
 import { AsyncFuncResult, Task } from '../bindings';
+/** Why a custom function failed. Each becomes an error string in the cell:
+ *  `#ARGERR!`, `#TIMEOUT!`, `#NOTFOUND!`, anything else `#UNKNOWN!`. */
 export declare const enum CalcException {
     Unspecified = 0,
     ArgErr = 1,
     TimeOut = 2,
     NotFound = 3
 }
+/** Implements a custom function: receives its arguments as strings and
+ *  resolves the cell's result as a string, or a {@link CalcException}. */
 export type Executor = (args: readonly string[]) => Promise<string | CalcException>;
+/** A formula function implemented in JS. Register it with
+ *  `Workbook.registryCustomFunc`; `funcName` is what formulas call. */
 export declare class CustomFunc {
     readonly funcName: string;
     executor: Executor;
     constructor(funcName: string, executor: Executor);
 }
+/**
+ * Runs the async tasks an `ActionEffect` hands back for custom functions.
+ * All tasks run concurrently; the result keeps the task order, which is what
+ * the engine uses to match values to cells. An unregistered function yields
+ * `#NOTFOUND!` rather than rejecting.
+ */
 export declare class Calculator {
     calc(tasks: readonly Task[]): Promise<AsyncFuncResult>;
     registry(f: CustomFunc): void;

package/dist/src/api/calculator.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Calculator = exports.CustomFunc = void 0;
+/** A formula function implemented in JS. Register it with
+ *  `Workbook.registryCustomFunc`; `funcName` is what formulas call. */
 class CustomFunc {
     funcName;
     executor;
@@ -10,6 +12,12 @@ class CustomFunc {
     }
 }
 exports.CustomFunc = CustomFunc;
+/**
+ * Runs the async tasks an `ActionEffect` hands back for custom functions.
+ * All tasks run concurrently; the result keeps the task order, which is what
+ * the engine uses to match values to cells. An unregistered function yields
+ * `#NOTFOUND!` rather than rejecting.
+ */
 class Calculator {
     async calc(tasks) {
         const promises = tasks.map((t) => this._exec(t.asyncFunc, t.args));

package/dist/src/api/cell.d.ts

@@ -1,6 +1,10 @@
 import { CellInfo, Value, Style } from '../bindings';
+/** Convenience wrapper over one {@link CellInfo} snapshot; it does not track
+ *  later edits. */
 export declare class Cell {
     constructor(cellInfo: CellInfo);
+    /** The value as a plain string (`''` when empty, `true`/`false` for
+     *  booleans, the error text for errors). Not number-formatted. */
     getText(): string;
     getStyle(): Style;
     getFormula(): string;

package/dist/src/api/cell.js

@@ -1,11 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CellValue = exports.Cell = void 0;
+/** Convenience wrapper over one {@link CellInfo} snapshot; it does not track
+ *  later edits. */
 class Cell {
     constructor(cellInfo) {
         this._value = CellValue.from(cellInfo.value);
         this._info = cellInfo;
     }
+    /** The value as a plain string (`''` when empty, `true`/`false` for
+     *  booleans, the error text for errors). Not number-formatted. */
     getText() {
         return this._value.valueStr ?? '';
     }

package/dist/src/api/craft-calc.d.ts

@@ -18,6 +18,13 @@ import type { Client } from '../client';
  * Slot 0 inside each craft range is reserved for `calcOnce`; user
  * `localId`s are transparently offset by 1 so they cannot collide.
  *
+ * Failure: every method throws an `Error` when an engine call resolves an
+ * `ErrorMessage`. A write the engine REJECTS resolves an `ActionEffect` with
+ * `status.type === 'err'` instead, which these methods do not inspect, so a
+ * rejected formula surfaces only as whatever the slot then reads back.
+ *
+ * All slots live on sheet index 0, which must exist.
+ *
  * Lifetime notes:
  *  - Ephemeral cells are wiped on file save/load (that's what "ephemeral"
  *    means). No reload-survival design is needed.
@@ -55,7 +62,8 @@ export declare class CraftCalc {
      * for normal cells), so repeated `getCalc` calls reflect the latest
      * state without re-issuing the formula.
      *
-     * Throws if `localId` was never `setCalc`-ed (or has been dropped).
+     * A slot that was never `setCalc`-ed (or has been dropped) reads as
+     * `'empty'`; the engine does not distinguish it from an empty result.
      */
     getCalc(localId: number): Promise<Value>;
     /**
@@ -78,6 +86,7 @@ export declare class CraftCalc {
 }
 /**
  * Allocate a fresh ephemeral-id range and return a {@link CraftCalc}
- * handle scoped to it. Call once per craft (or per host-UI context).
+ * handle scoped to it. Call once per craft (or per host-UI context): every
+ * call burns a new range for the rest of the JS session.
  */
 export declare function acquireCraftCalc(workbook: Client): CraftCalc;

package/dist/src/api/craft-calc.js

@@ -15,6 +15,11 @@ const utils_1 = require("./utils");
 // keep both base and offset in plain Number. With 2^32 reserved for the
 // engine and 2^20 per craft, we can hand out ~2^21 craft ranges before
 // running into precision concerns — plenty.
+//
+// NOTE: the engine does not honour this split. Its shadow-cell allocator
+// (crates/controller/src/sid_assigner) starts at u32::MAX and counts UP, into
+// the first craft range, and `WorkbookOps.evalFormula` (logisheets-core) uses
+// ids from 1, so ids from different owners can collide.
 const ENGINE_RESERVED_END = 0x1_0000_0000; // 2^32
 const CRAFT_RANGE_SIZE = 1 << 20; // 2^20 ids per craft
 // Bumped on every acquire. Lives for the JS session only; on reload
@@ -40,6 +45,13 @@ let nextCraftBase = ENGINE_RESERVED_END;
  * Slot 0 inside each craft range is reserved for `calcOnce`; user
  * `localId`s are transparently offset by 1 so they cannot collide.
  *
+ * Failure: every method throws an `Error` when an engine call resolves an
+ * `ErrorMessage`. A write the engine REJECTS resolves an `ActionEffect` with
+ * `status.type === 'err'` instead, which these methods do not inspect, so a
+ * rejected formula surfaces only as whatever the slot then reads back.
+ *
+ * All slots live on sheet index 0, which must exist.
+ *
  * Lifetime notes:
  *  - Ephemeral cells are wiped on file save/load (that's what "ephemeral"
  *    means). No reload-survival design is needed.
@@ -91,7 +103,8 @@ class CraftCalc {
      * for normal cells), so repeated `getCalc` calls reflect the latest
      * state without re-issuing the formula.
      *
-     * Throws if `localId` was never `setCalc`-ed (or has been dropped).
+     * A slot that was never `setCalc`-ed (or has been dropped) reads as
+     * `'empty'`; the engine does not distinguish it from an empty result.
      */
     async getCalc(localId) {
         const sheetId = await this._resolveSheetId();
@@ -219,7 +232,8 @@ class CraftCalc {
 exports.CraftCalc = CraftCalc;
 /**
  * Allocate a fresh ephemeral-id range and return a {@link CraftCalc}
- * handle scoped to it. Call once per craft (or per host-UI context).
+ * handle scoped to it. Call once per craft (or per host-UI context): every
+ * call burns a new range for the rest of the JS session.
  */
 function acquireCraftCalc(workbook) {
     const base = nextCraftBase;

package/dist/src/api/utils.d.ts

@@ -1,5 +1,13 @@
 import { Fill, PatternFill } from '../bindings';
 import { ErrorMessage } from '../bindings/error_message';
+/**
+ * Whether an engine reply is an {@link ErrorMessage}. Structural: any object
+ * carrying both `msg` and `ty` matches. Use it on every `Result<T>` before
+ * reading the value; an engine refusal to APPLY a transaction is not an
+ * `ErrorMessage` but an `ActionEffect` with `status.type === 'err'`.
+ */
 export declare function isErrorMessage(v: any): v is ErrorMessage;
+/** A synchronous engine reply: the value, or an {@link ErrorMessage}. */
 export type Result<V> = V | ErrorMessage;
+/** The pattern fill of a cell `Fill`, or null for a gradient fill. */
 export declare function getPatternFill(v: Fill): PatternFill | null;

package/dist/src/api/utils.js

@@ -2,12 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isErrorMessage = isErrorMessage;
 exports.getPatternFill = getPatternFill;
+/**
+ * Whether an engine reply is an {@link ErrorMessage}. Structural: any object
+ * carrying both `msg` and `ty` matches. Use it on every `Result<T>` before
+ * reading the value; an engine refusal to APPLY a transaction is not an
+ * `ErrorMessage` but an `ActionEffect` with `status.type === 'err'`.
+ */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function isErrorMessage(v) {
     if (typeof v !== 'object' || v === null)
         return false;
     return 'msg' in v && 'ty' in v;
 }
+/** The pattern fill of a cell `Fill`, or null for a gradient fill. */
 function getPatternFill(v) {
     if (v.type === 'patternFill')
         return v.value;

package/dist/src/api/workbook.d.ts

@@ -1,21 +1,49 @@
-import { ActionEffect, BlockField, BlockInfo, BlockSortOrder, GetBlockSortOrderParams, PivotPlan, PivotPlanParams, PivotExcelNote, PivotPlanForParams, MayModifyBlockParams, CheckFieldValidationParams, FieldValidationVerdict, DuplicateBlockKey, EnumSetInfo, BlockOpForPayload, BlockOpPolicy, GetBlockModifyInfoParams, BlockModifyInfo, FormulaDisplayInfo, ShadowCellInfo, SheetCellId, SheetInfo, SaveFileResult, AppData, CellInfo, CellCoordinateWithSheet, Transaction, GetBlockValuesParams, GetCellIdParams, GetShadowCellIdParams, GetShadowCellIdsParams, GetAvailableBlockIdParams, TempStatusDiff, BlockDataRow, CommentMention } from '../bindings';
+import { ActionEffect, BlockField, BlockInfo, BlockSortOrder, GetBlockSortOrderParams, PivotPlan, PivotPlanParams, PivotExcelNote, PivotPlanForParams, MayModifyBlockParams, CheckFieldValidationParams, FieldValidationVerdict, DuplicateBlockKey, EnumSetInfo, DefinedNameInfo, BlockOpForPayload, BlockOpPolicy, GetBlockModifyInfoParams, BlockModifyInfo, FormulaDisplayInfo, ShadowCellInfo, SheetCellId, SheetInfo, SaveFileResult, AppData, CellInfo, CellCoordinateWithSheet, Transaction, GetBlockValuesParams, GetCellIdParams, GetShadowCellIdParams, GetShadowCellIdsParams, GetAvailableBlockIdParams, TempStatusDiff, BlockDataRow, CommentMention } from '../bindings';
 import { ColId, RowId } from '../types';
 import { Worksheet } from './worksheet';
 import { CustomFunc } from './calculator';
 import { Result } from './utils';
 import { Author } from './author';
-export type ReturnCode = number;
 export type Callback = () => void;
 export type CellIdCallback = (cellId: SheetCellId) => void;
+/**
+ * A synchronous handle on one engine workbook, living in the calling thread.
+ *
+ * In the browser, `initWasm()` must have resolved before the constructor runs;
+ * the Node build needs no init. The app does not use this directly on the main
+ * thread: logisheets-engine runs one inside its web worker and exposes it as
+ * the async {@link Client}. Shared code should target `Client`.
+ *
+ * Conventions for every method:
+ *  - Sheet, row and column indexes are 0-based. `sheetIdx` is the tab
+ *    position (changes when sheets move); `sheetId` is stable. Convert with
+ *    {@link getSheetId} / {@link getSheetIdx}.
+ *  - Reads return `Result<T>`: an `ErrorMessage` on failure, never a throw.
+ *  - Writes go through {@link execTransaction}, which reports a rejection in
+ *    the returned `ActionEffect` rather than throwing.
+ *
+ * Call {@link release} when done; the engine keeps the workbook alive until
+ * then.
+ */
 export declare class Workbook {
+    /** Allocates a new, empty workbook in the engine. */
     constructor();
+    /** Current tab position of the sheet with stable id `sheetId`. */
     getSheetIdx(sheetId: number): Result<number>;
     getBlockValues(params: GetBlockValuesParams): Result<readonly string[]>;
+    /**
+     * An unused block id on the sheet, asked of the engine every call and not
+     * reserved: two calls before a `createBlock` return the same id.
+     * {@link createBlockForNewCraft} instead hands out ids from a local
+     * counter.
+     */
     getAvailableBlockId(params: GetAvailableBlockIdParams): Result<number>;
     /**
-     * @returns the block id if success, otherwise the error message
+     * Create a `rowCnt` x `colCnt` block whose master (top-left) cell is at
+     * (`masterRow`, `masterCol`), as a non-undoable transaction.
      *
-     * It is caller's responsibility to store the block id.
+     * @returns the new block id, or an `ErrorMessage` if the engine rejected
+     * the block. The caller must store the id; nothing else records it.
      */
     createBlockForNewCraft(sheetIdx: number, masterRow: number, masterCol: number, rowCnt: number, colCnt: number): Result<number>;
     /**
@@ -68,9 +96,16 @@ export declare class Workbook {
      * {@link AuthorService.searchUsers} result.
      */
     upsertPerson(author: Author): ActionEffect;
+    /** Undo the last undoable transaction. `false` when there was nothing to
+     *  undo; on `true` the cell and sheet update callbacks fire. */
     undo(): boolean;
+    /** Redo the last undone transaction. Same contract as {@link undo}. */
     redo(): boolean;
+    /** Called after a transaction reporting cell changes, after undo/redo,
+     *  and when async custom-function results land. No unsubscribe. */
     registerCellUpdatedCallback(callback: Callback): void;
+    /** Called after a transaction reporting sheet-level changes, and after
+     *  undo/redo. No unsubscribe. */
     registerSheetInfoUpdateCallback(callback: Callback): void;
     /**
      * Fires after a transaction with sheet indices whose row/column headers
@@ -79,6 +114,7 @@ export declare class Workbook {
      */
     registerHeaderUpdatedCallback(callback: (sheetIdxes: readonly number[]) => void): void;
     getSheetNameByIdx(idx: number): Result<string>;
+    /** Every sheet, in tab order. */
     getAllSheetInfo(): Array<SheetInfo>;
     /**
      * Every distinct formula function name used across the workbook (cell
@@ -86,7 +122,15 @@ export declare class Workbook {
      * stored at parse time, sorted + deduped.
      */
     getFormulaFunctionNames(): Result<string[]>;
+    /** Whether `f` looks like a formula: it must start with `=` and the rest
+     *  must lex. A cheap syntax screen, not a full parse; nothing is evaluated. */
     checkFormula(f: string): boolean;
+    /**
+     * Evaluate a boolean formula on sheet `sheetIdx`. `f` is written as cell
+     * content into one engine-owned scratch ephemeral cell, so a formula needs
+     * its leading `=`. An `ErrorMessage` when the result is an error value or
+     * the write is rejected.
+     */
     calcCondition(sheetIdx: number, f: string): Result<boolean>;
     /**
      * Resolve a (refName, key, field) triple to a concrete cell, the same
@@ -117,23 +161,57 @@ export declare class Workbook {
      * rather than assume the slot is free.
      */
     isInTempMode(): Result<boolean>;
+    /** Stable id of the sheet at tab position `sheetIdx`. */
     getSheetId(sheetIdx: number): Result<number>;
     getBlockRowId(sheetId: number, blockId: number, rowIdx: number): Result<RowId>;
     getBlockColId(sheetId: number, blockId: number, colIdx: number): Result<ColId>;
     getDisplayUnitsOfFormula(f: string): Result<FormulaDisplayInfo>;
+    /**
+     * Subscribe to value changes of the cell now at (sheetIdx, rowIdx,
+     * colIdx). The coordinate is resolved to a cell id once, up front.
+     * Returns an `ErrorMessage` if it cannot be resolved.
+     */
     onCellValueChanged(sheetIdx: number, rowIdx: number, colIdx: number, callback: Callback): Result<void>;
     onCellRemoved(sheetIdx: number, rowIdx: number, colIdx: number, callback: Callback): Result<void>;
     onShadowCellValueChanged(sheetIdx: number, rowIdx: number, colIdx: number, callback: Callback): Result<void>;
     private _registerCellRemovedCallback;
     private _registerCellValueChangedCallback;
     registerCellValueChangedByCellId(cellId: SheetCellId, callback: Callback): void;
-    commitTempStatus(): void;
-    cleanupTempStatus(): void;
-    toggleStatus(useTemp: boolean): void;
+    /**
+     * Temp branch (speculative edits). Transactions sent with `temp: true`
+     * land on ONE workbook-wide branch; {@link commitTempStatus} folds it into
+     * the real state, {@link cleanupTempStatus} discards all of it, and
+     * {@link toggleStatus} picks which state reads are served from. Any
+     * non-temp write discards the branch. Check {@link isInTempMode} before
+     * assuming the slot is free.
+     */
+    commitTempStatus(): Result<void>;
+    cleanupTempStatus(): Result<void>;
+    /** Serve reads from the temp branch (`true`) or the committed state. */
+    toggleStatus(useTemp: boolean): Result<void>;
+    /** Cell infos for stable cell ids, in input order. Works for ephemeral and
+     *  shadow cells, which have no coordinate. */
     batchGetCellInfoById(ids: readonly SheetCellId[]): Result<readonly CellInfo[]>;
     batchGetCellCoordinateWithSheetById(ids: readonly SheetCellId[]): Result<readonly CellCoordinateWithSheet[]>;
+    /**
+     * Apply a transaction: all payloads, in order, as one unit and (when
+     * `tx.undoable`) one undo step.
+     *
+     * Never throws for an engine refusal. A rejected transaction applies
+     * nothing and returns an `ActionEffect` with `status.type === 'err'` and
+     * the reason (naming the offending payload) in `errorMessage`; check it
+     * whenever the write must land. Callbacks fire only on success.
+     *
+     * Custom-function calls in the new formulas come back as `asyncTasks`;
+     * they are run here through the registered {@link CustomFunc}s and their
+     * results fed back later, so those cells update after this returns.
+     */
     execTransaction(tx: Transaction): ActionEffect;
-    load(buf: Uint8Array, bookName: string): ReturnCode;
+    /**
+     * Replace this workbook's contents with a parsed .xlsx. An unreadable file
+     * comes back as an {@link ErrorMessage} and leaves this workbook as it was.
+     */
+    load(buf: Uint8Array, bookName: string): Result<void>;
     /**
      * Serialize to .xlsx bytes.
      *
@@ -143,14 +221,24 @@ export declare class Workbook {
      * so a file Excel must recalculate needs the coordinates. One-way — a
      * resolved `BLOCKREFS` becomes a plain range, which LogiSheets does not
      * parse back when it straddles a block.
+     *
+     * `data` is the opaque AppData string stored in the file (craft state and
+     * friends); read it back with {@link getAppData} after a load. Despite the
+     * return type, a failed save returns an `ErrorMessage`: check with
+     * `isErrorMessage`.
      */
     save(data: string, resolveBlockRefs?: boolean): SaveFileResult;
+    /** The AppData entries carried by the loaded file (see {@link save}). */
     getAppData(): readonly AppData[];
     /** Monotonic counter bumped on every committed write — snapshot it to
      *  detect concurrent modification (optimistic concurrency). */
     getVersion(): number;
+    /** Free the engine workbook. Every later call on this handle, or on a
+     *  `Worksheet` taken from it, is invalid. */
     release(): void;
     getSheetCount(): number;
+    /** The sheet at tab position `idx`. THROWS when `idx` is out of range,
+     *  unlike the `Result`-returning reads. */
     getWorksheet(idx: number): Worksheet;
     /**
      * Fill-handle drag: predict the contents for `dst` from the source
@@ -252,13 +340,24 @@ export declare class Workbook {
      * this just dispatches the resulting `reorderBlockLines` payload.
      */
     sortBlock(sheetIdx: number, blockId: number, field: string, asc: boolean): Result<ActionEffect>;
+    /** The sheet with stable id `id`. Not validated: an unknown id yields a
+     *  `Worksheet` whose calls fail. */
     getWorksheetById(id: number): Worksheet;
+    /** Make `customFunc.funcName` callable from formulas. The engine hands
+     *  such calls back as async tasks, see {@link execTransaction}. */
     registryCustomFunc(customFunc: CustomFunc): void;
+    /**
+     * The id of a cell's shadow: an ephemeral companion cell the engine keeps
+     * per (cell, kind) for validation-style formulas. Allocated on first ask
+     * and stable afterwards.
+     */
     getShadowCellId(params: GetShadowCellIdParams): Result<number>;
     getShadowCellIds(params: GetShadowCellIdsParams): Result<readonly number[]>;
     getShadowInfoById(params: {
         shadowId: number;
     }): Result<ShadowCellInfo>;
+    /** The stable id of the cell at a coordinate. It survives row/column
+     *  insertion and deletion, unlike the coordinate. */
     getCellId(params: GetCellIdParams): Result<SheetCellId>;
     getAllBlockFields(): Result<readonly BlockField[]>;
     /**
@@ -298,6 +397,13 @@ export declare class Workbook {
      * host, keyed by variant id.
      */
     getEnumSets(): Result<readonly EnumSetInfo[]>;
+    /**
+     * The workbook's defined names, ordered by name. Each definition is
+     * sheet-qualified (`Sheet1!$B$2:$B$9`) so it reads the same from any sheet.
+     * Define, rename and remove them with the `defineName` / `renameName` /
+     * `removeName` payloads.
+     */
+    getDefinedNames(): Result<readonly DefinedNameInfo[]>;
     /**
      * Every duplicated block row key in the workbook.
      *