@sheetxl/sdk 0.8.0-beta.10 → 0.8.0-beta.11

package/types/src/sheet/_SheetChangeEvent.d.ts

@@ -0,0 +1,72 @@
+import { IRange } from '@sheetxl/primitives';
+import { ITransaction } from '../transaction';
+import { ICellRanges } from '../cellRange';
+import { IWorksheet } from './IWorksheet';
+import { Worksheet } from './Worksheet';
+import { ShiftIntent } from './_SheetIntents';
+/** What a {@link SheetChangeEvent} says beside its kind and coords. @internal */
+export interface SheetChangeDetails {
+    /** What wrote the change; `null` for one not written. */
+    commit: ITransaction.ICommit | null;
+    /** The commit the change moved from; `null` when there is none. */
+    previous?: ITransaction.ICommit | null;
+    /** The change is an undo. */
+    isUndo?: boolean;
+    /** The change moved cells, so its coords do not name the same cells before it. */
+    isStructural?: boolean;
+    /** The inserts and deletes that moved them, as the change reports them (an undo's inverted). */
+    shifts?: readonly ShiftIntent[];
+}
+/** A change not written and of no known extent: what a cache or a collection announces. @internal */
+export declare const UnknownChange: SheetChangeDetails;
+/**
+ * {@link IWorksheet.ChangeEvent} over the coords a change announced.
+ *
+ * @remarks
+ * The ranges are built on first read: most listeners only need to know that something changed,
+ * and building an {@link ICellRanges} for every announcement would tax every write for them. The
+ * previous ranges cost a snapshot sheet, so they are built only when asked for too.
+ *
+ * @internal
+ */
+export declare class SheetChangeEvent implements IWorksheet.ChangeEvent {
+    private readonly _sheet;
+    private _kind;
+    private _coords;
+    private readonly _details;
+    private _ranges;
+    private _previousRanges;
+    private _shifts;
+    constructor(_sheet: Worksheet, _kind: IWorksheet.ChangeEventKey, _coords: readonly IRange.Coords[] | null, _details: SheetChangeDetails);
+    /** {@inheritDoc IWorksheet.ChangeEvent.getSheet} */
+    getSheet(): IWorksheet;
+    /** {@inheritDoc IWorksheet.ChangeEvent.getKind} */
+    getKind(): IWorksheet.ChangeEventKey;
+    /** {@inheritDoc IWorksheet.ChangeEvent.getRanges} */
+    getRanges(): ICellRanges | null;
+    /** {@inheritDoc IWorksheet.ChangeEvent.getCommit} */
+    getCommit(): ITransaction.ICommit | null;
+    /** {@inheritDoc IWorksheet.ChangeEvent.isUndo} */
+    isUndo(): boolean;
+    /** {@inheritDoc IWorksheet.ChangeEvent.getPreviousCommit} */
+    getPreviousCommit(): ITransaction.ICommit | null;
+    /** {@inheritDoc IWorksheet.ChangeEvent.getPreviousRanges} */
+    getPreviousRanges(): ICellRanges | null;
+    /** {@inheritDoc IWorksheet.ChangeEvent.getShifts} */
+    getShifts(): readonly IWorksheet.Shift[];
+    /**
+     * One event for two deliveries conflated into one: the union of the ranges (unknown wins), the
+     * latest commit, and the earliest previous one, so the pair spans both.
+     *
+     * @remarks
+     * A callback can be shared across event keys. Two kinds conflated into one delivery say no
+     * extent, and either side may not be a change event at all.
+     *
+     * An operation announces each of its writes, so one delivery can merge many. The first merge
+     * makes an event of its own, and later merges into it append in place: nothing else holds it.
+     */
+    static merge(prev: IWorksheet.ChangeEvent | null | undefined, next: IWorksheet.ChangeEvent | null | undefined): IWorksheet.ChangeEvent | null | undefined;
+    private _merged;
+    private _toMerged;
+}
+//# sourceMappingURL=_SheetChangeEvent.d.ts.map

package/types/src/sheet/_SheetCoords.d.ts

@@ -1,8 +1,8 @@
 import { IRange } from '@sheetxl/primitives';
 import { ICell } from '../cell';
 import { ICellRange, ICellRanges } from '../cellRange';
-import { ISheetProtection } from '../sheetProtection';
-import { SheetCoordContext } from './Sheet';
+import { IWorksheetProtection } from '../sheetProtection';
+import { SheetCoordContext } from './Worksheet';
 /**
  * Coordinate/address resolution for a {@link Sheet}: parses addresses into coords, validates bounds,
  * runs protection checks, and constructs the `ICellRange`/`ICellRanges` handles. Functions take a
@@ -17,7 +17,7 @@ import { SheetCoordContext } from './Sheet';
  * @internal
  */
 export interface ProtectionCheck {
-    (coords?: IRange.Coords[]): ISheetProtection.PropertyKeys[];
+    (coords?: IRange.Coords[]): IWorksheetProtection.PropertyKeys[];
 }
 /** @internal */
 export declare function createRange(ctx: SheetCoordContext, coords: Readonly<IRange.FixableCoords> | string, getOptions?: ICellRange.GetRangeOptions, readOnly?: string | null): ICellRange;

package/types/src/sheet/_SheetEvents.d.ts

@@ -10,7 +10,7 @@ import { IRange } from '@sheetxl/primitives';
  * and travel on the commit, which is what lets an undo announce the same categories the forward
  * commit did.
  *
- * The scope is {@link ISheet.getId}, so a commit that spans sheets announces each of them
+ * The scope is {@link IWorksheet.getId}, so a commit that spans sheets announces each of them
  * separately.
  *
  * @internal

package/types/src/sheet/_SheetFilterUtils.d.ts

@@ -3,8 +3,8 @@ import { RunCoords } from '@sheetxl/utils';
 import { ITransaction } from '../transaction';
 import { ICondition } from '../condition';
 import { NumberFormatRef } from '../numFmt/BuiltInFormats';
-import { ISheet } from './ISheet';
-import { Sheet } from './Sheet';
+import { IWorksheet } from './IWorksheet';
+import { Worksheet } from './Worksheet';
 /** A run of one column's rows that show their values under the same number format. */
 export interface TextFormatRun {
     rowStart: number;
@@ -19,7 +19,7 @@ export interface TextFormatRun {
  * What a cell shows follows from its value and its number format. The formats lie in few runs
  * whatever the number of rows, so a reader of the column's text formats values and builds no cell.
  */
-export declare function getTextFormatRuns(sheet: ISheet, coords: Readonly<IRange.Coords>): TextFormatRun[];
+export declare function getTextFormatRuns(sheet: IWorksheet, coords: Readonly<IRange.Coords>): TextFormatRun[];
 /**
  * What a filter evaluation settles: on one axis, the runs that stay visible and the runs that hide.
  *
@@ -39,7 +39,7 @@ export interface FilterRuns {
 /**
  * Read-only: resolves every condition and settles the final visible and hidden runs.
  */
-export declare function evalFilter(sheet: Sheet, coords: Readonly<IRange.Coords>, condition: ICondition.Input | ICondition.RangeOptions | null | undefined): Promise<FilterRuns>;
+export declare function evalFilter(sheet: Worksheet, coords: Readonly<IRange.Coords>, condition: ICondition.Input | ICondition.RangeOptions | null | undefined): Promise<FilterRuns>;
 /**
  * Writes the hidden bits {@link evalFilter} settled. Inside the caller's open transaction.
  *
@@ -48,10 +48,10 @@ export declare function evalFilter(sheet: Sheet, coords: Readonly<IRange.Coords>
  * then hide every row/column that doesn't — including one the user hid manually, matching real
  * Excel AutoFilter (there's no persisted "hidden by filter" vs. "hidden by user" bit to preserve).
  */
-export declare function applyFilterRuns(sheet: Sheet, runs: FilterRuns, options?: ITransaction.OperationOptions): void;
+export declare function applyFilterRuns(sheet: Worksheet, runs: FilterRuns, options?: ITransaction.OperationOptions): void;
 /**
  * Sheet specific filter utils. Mirrors `_SheetSortUtils.doSort`: {@link evalFilter}, then one
  * transaction around {@link applyFilterRuns}.
  */
-export declare function doFilter(sheet: Sheet, coords: Readonly<IRange.Coords>, condition: ICondition.Input | ICondition.RangeOptions, options?: ITransaction.OperationOptions): Promise<IRange.Coords>;
+export declare function doFilter(sheet: Worksheet, coords: Readonly<IRange.Coords>, condition: ICondition.Input | ICondition.RangeOptions, options?: ITransaction.OperationOptions): Promise<IRange.Coords>;
 //# sourceMappingURL=_SheetFilterUtils.d.ts.map

package/types/src/sheet/_SheetIntents.d.ts

@@ -3,7 +3,7 @@ import { ICellRange } from '../cellRange';
 import { IMovable } from '../movable';
 import { IMovableSelection, IRangeSelection } from '../selection';
 import { ITransaction } from '../transaction';
-import { ISheet } from './ISheet';
+import { IWorksheet } from './IWorksheet';
 import { SheetEvents } from './_SheetEvents';
 /**
  * Directives a sheet operation records on its transaction: something to do once the operation
@@ -27,7 +27,7 @@ export declare const IntentBatchSelect = "sheet.batchSelect";
 /** Key for {@link AutoFitIntent}`[]`. */
 export declare const IntentAutoFit = "sheet.autoFit";
 /**
- * Key for the sheet ids ({@link ISheet.getId}) whose commit-time protection check stands down.
+ * Key for the sheet ids ({@link IWorksheet.getId}) whose commit-time protection check stands down.
  *
  * @remarks
  * The catch-all at `onBeforeCommitStart` refuses any write to a locked sheet. An operation that
@@ -38,10 +38,12 @@ export declare const IntentAutoFit = "sheet.autoFit";
 export declare const IntentSkipProtectionCheck = "sheet.skipProtectionCheck";
 /** Key for the {@link FreezePanesIntent}. */
 export declare const IntentFreezePanes = "sheet.freezePanes";
+/** Key for the {@link ShiftsIntent}. */
+export declare const IntentShifts = "sheet.shifts";
 /** Key for the {@link MovableSelectionIntent}`[]` the operations of a commit declared. */
 export declare const IntentMovableSelection = "sheet.movableSelection";
 /**
- * Key for the sheet ids ({@link ISheet.getId}) a load is populating in this commit.
+ * Key for the sheet ids ({@link IWorksheet.getId}) a load is populating in this commit.
  *
  * @remarks
  * A load is not an edit: nothing it writes is announced, and the calculation it would otherwise
@@ -52,7 +54,7 @@ export declare const IntentMovableSelection = "sheet.movableSelection";
  */
 export declare const IntentInitial = "sheet.initial";
 /**
- * Key for the sheet ids ({@link ISheet.getId}) whose entered formulas should take the number
+ * Key for the sheet ids ({@link IWorksheet.getId}) whose entered formulas should take the number
  * format of the first cell they read that has one, or failing that the format their results
  * carry, once the compile and the calculation have them.
  *
@@ -75,7 +77,7 @@ export declare const IntentAutoFormat = "sheet.autoFormat";
  */
 export declare const IntentCalcResolved = "sheet.calcResolved";
 /**
- * What to announce once the operation lands, by sheet ({@link ISheet.getId}) and by category.
+ * What to announce once the operation lands, by sheet ({@link IWorksheet.getId}) and by category.
  *
  * @remarks
  * The one intent every mutation writes. A union: each write appends the ranges it wrote, so a
@@ -90,7 +92,7 @@ export declare const IntentCalcResolved = "sheet.calcResolved";
  */
 export type EventsIntent = Readonly<Record<string, SheetEvents>>;
 /**
- * The ranges a formula was entered over, by sheet ({@link ISheet.getId}).
+ * The ranges a formula was entered over, by sheet ({@link IWorksheet.getId}).
  *
  * @remarks
  * A subset of the `data` category, found from what the write produced rather than named by the
@@ -130,10 +132,10 @@ export declare const _appendOwnedRanges: (list: readonly IRange.Coords[] | undef
  * its operations'.
  */
 export interface SelectionIntent {
-    /** {@link ISheet.getId} of the sheet the selection is on. */
+    /** {@link IWorksheet.getId} of the sheet the selection is on. */
     sheetId: string;
     /**
-     * {@link ISheetView.getId} of the view the operation was made against.
+     * {@link IWorksheetView.getId} of the view the operation was made against.
      *
      * @remarks
      * A sheet can be shown through more than one view - each user in a shared workbook has their
@@ -162,7 +164,7 @@ export interface SelectionIntent {
     nested: boolean;
 }
 /**
- * The `autoSelect` a batch was opened with, by sheet ({@link ISheet.getId}).
+ * The `autoSelect` a batch was opened with, by sheet ({@link IWorksheet.getId}).
  *
  * @remarks
  * A batch asks to select for the operations inside it that did not ask for themselves: a command
@@ -198,7 +200,7 @@ export declare const resolveSelection: (intents: Readonly<Record<string, any>> |
     options: boolean | ICellRange.SelectOptions;
 } | null;
 /**
- * Where the freeze panes sit before and after the operation, by sheet ({@link ISheet.getId}).
+ * Where the freeze panes sit before and after the operation, by sheet ({@link IWorksheet.getId}).
  *
  * @remarks
  * The one view fact an insert or delete changes: a frozen row above the insertion point moves
@@ -211,6 +213,22 @@ export type FreezePanesIntent = Readonly<Record<string, {
     before: IRange.CellCoords;
     after: IRange.CellCoords;
 }>>;
+/** One insert or delete of cells, as {@link ShiftsIntent} records it. */
+export interface ShiftIntent {
+    kind: IWorksheet.ShiftKind;
+    axis: IRange.Axis;
+    /** The cells inserted or deleted, in the coords of the sheet as this shift found it. */
+    ranges: readonly IRange.Coords[];
+}
+/**
+ * The inserts and deletes of cells, by sheet ({@link IWorksheet.getId}), in the order they ran.
+ *
+ * @remarks
+ * The `address` category says where the cells moved; this says how, so a reader can tell an
+ * insert from a delete and on which axis. A move is not one: it is recorded as the insert and the
+ * delete it is made of. Appended copy-on-write, as {@link EventsIntent} is.
+ */
+export type ShiftsIntent = Readonly<Record<string, readonly ShiftIntent[]>>;
 /**
  * What one operation declared about the movable selection: what it leaves selected, and what was
  * selected when it began.
@@ -227,10 +245,10 @@ export type FreezePanesIntent = Readonly<Record<string, {
  * survives a reload and a collaborator.
  */
 export interface MovableSelectionIntent {
-    /** {@link ISheet.getId} of the sheet the movables are on. */
+    /** {@link IWorksheet.getId} of the sheet the movables are on. */
     sheetId: string;
     /**
-     * {@link ISheetView.getId} of the view the operation was made against.
+     * {@link IWorksheetView.getId} of the view the operation was made against.
      *
      * @remarks
      * Only the view that made the change is moved by it - see {@link SelectionIntent}.
@@ -262,7 +280,7 @@ export declare const pickOrder: (selection: IMovableSelection) => readonly IMova
  * @param undo What was selected when the operation began, the active one last, when the view no
  * longer says: the operation has deleted what was selected.
  */
-export declare const recordMovableSelection: (trans: ITransaction, sheet: ISheet, selection: readonly IMovable[], options?: Pick<IMovable.OperationOptions, "autoSelect" | "autoSelectRestore"> | null, undo?: readonly IMovable[]) => void;
+export declare const recordMovableSelection: (trans: ITransaction, sheet: IWorksheet, selection: readonly IMovable[], options?: Pick<IMovable.OperationOptions, "autoSelect" | "autoSelectRestore"> | null, undo?: readonly IMovable[]) => void;
 /**
  * The movables a commit selects on a view, by id with the active one last, or `null` when it
  * leaves the selection alone.
@@ -288,7 +306,7 @@ export declare const resolveMovableSelection: (intents: Readonly<Record<string,
  * be measured as one.
  */
 export interface AutoFitIntent {
-    /** {@link ISheet.getId} of the sheet to fit on. */
+    /** {@link IWorksheet.getId} of the sheet to fit on. */
     sheetId: string;
     ranges: IRange.Coords[];
     options?: ICellRange.AutoFitOptions;

package/types/src/sheet/_SheetMessages.d.ts

@@ -6,6 +6,6 @@ export declare const ERROR_ITEM_OVERLAPPING: (type: string) => string;
 export declare const ERROR_PASTE: (message: string) => string;
 export declare const ERROR_AUTOFILL_INVALID_DESTINATION: (template: string, destination: string) => string;
 export declare const ERROR_AUTOFILL_MULTIPLE: (modulus: number) => string;
-export declare const ERROR_MAX_VALUES: (max: number) => string;
+export declare const ERROR_MAX_VALUES: (max: number, count: number | string, address: string) => string;
 export declare const ERROR_UNIQUE_NAME: (name: string) => string;
 //# sourceMappingURL=_SheetMessages.d.ts.map

package/types/src/sheet/_SheetMutations.d.ts

@@ -12,7 +12,7 @@ import { FormulaEntry } from '../calculation/grid';
 import { CellStateIteratorContext } from './_SheetUtils';
 import { SheetDirectStyle } from './style/SheetDirectStyle';
 import { RangeState, InternalTupleUpdate } from './_SheetStateTypes';
-import { SheetMutationContext } from './Sheet';
+import { SheetMutationContext } from './Worksheet';
 /**
  * The shared insert/delete engine (see SHEET-SPLIT-DESIGN §6e). Shifts every state map (values,
  * spills, styles, merges, hyperlinks, comments, movables, tables, listeners, calc, …) one range at
@@ -33,6 +33,12 @@ export declare function shiftCells(ctx: SheetMutationContext, ranges: readonly I
  */
 export declare function setComments(ctx: SheetMutationContext, ranges: readonly ISpatialMap.Entry<IComment.Update>[], comments?: IComment.Update, // `undefined` = each entry carries its own (updateTuples)
 options?: ITransaction.OperationOptions): void;
+/**
+ * Ignores, or stops ignoring, one of Excel's error checks over each range. Presence is the ignore:
+ * a cell's entry is the set of checks it ignores, and goes when the set empties.
+ * @internal
+ */
+export declare function setErrorIgnored(ctx: SheetMutationContext, ranges: readonly IRange.Coords[], check: ICell.ErrorCheck, ignored: boolean, options?: ITransaction.OperationOptions): void;
 /**
  * Set (or clear when the resolved update is `null`) the hyperlink over each range, applying the
  * built-in `Hyperlink` style and writing the display text into the cell. See SHEET-SPLIT-DESIGN §5.4.
@@ -45,13 +51,6 @@ options?: ITransaction.OperationOptions): void;
  */
 export declare function setHyperlinks(ctx: SheetMutationContext, ranges: readonly ISpatialMap.Entry<IHyperlink.Update>[], defaultUpdate?: IHyperlink.Update, // we do this because updateTuples may update each
 options?: ITransaction.OperationOptions): void;
-/**
- * The single style write choke point. Partitions each `ICellStyle.Update` by category (border / fill /
- * content) and writes each per-feature map directly (DISCRETE — no merged blob); the function-form
- * branch is the one surviving write-side compose. Re-derives the content-derived side maps
- * (continuousFill + dateFormat) over the touched region. See SHEET-STYLE-SPLIT step 4/5.
- * @internal
- */
 export declare function updateStyles(ctx: SheetMutationContext, ranges: readonly ISpatialMap.Entry<ICellStyle.Update>[], defaultUpdate?: ICellStyle.Update, // we do this because updateTuples may update each
 options?: ICellStyle.UpdateOptions, calcedNumberFormat?: boolean, // this is a bit of a hack. This is prevent number formats from functions to override user defined formats.
 isStep?: boolean): void;

package/types/src/sheet/_SheetSortUtils.d.ts

@@ -1,9 +1,9 @@
 import { IRange } from '@sheetxl/primitives';
 import { ITransaction } from '../transaction';
 import { ISort } from '../sort';
-import { Sheet } from './Sheet';
+import { Worksheet } from './Worksheet';
 /**
  * Sheet specific sort utils.
  */
-export declare function doSort(sheet: Sheet, coords: Readonly<IRange.Coords>, options?: boolean | ISort.Options[] | ISort.RangeOptions & ITransaction.OperationOptions): IRange.Coords;
+export declare function doSort(sheet: Worksheet, coords: Readonly<IRange.Coords>, options?: boolean | ISort.Options[] | ISort.RangeOptions & ITransaction.OperationOptions): IRange.Coords;
 //# sourceMappingURL=_SheetSortUtils.d.ts.map

package/types/src/sheet/_SheetStateReader.d.ts

@@ -11,6 +11,7 @@ import { ITransaction } from '../transaction';
 import { ICalcGrid } from '../calculation/grid';
 import { RangeState, CellState, State } from './_SheetStateTypes';
 import { SheetCellOptions } from './SheetCell';
+import { CellKind } from './_Kinds';
 /** @internal */
 export interface ViewEdgeEntry {
     rowIndex: number;
@@ -52,6 +53,23 @@ export interface SheetReadContext {
     readonly lists: ScalarListFactory;
     getEntireCoords(): IRange.Coords;
     getUsedCoords(options?: ICellRange.GetRangeOptions): IRange.Coords | null;
+    /**
+     * Where the error checks fire, by cell (`RangeState.Type.Anomalies`). Derived from the other
+     * features on first call and cached until the sheet or its values change; absent for a context
+     * with no sheet behind it.
+     */
+    getAnomalies?(): ISpatialMap<readonly ICell.Anomaly[]>;
+    /**
+     * What each cell holds, by kind (`RangeState.Type.Kind`). Derived from the values on first call
+     * and cached until the sheet or its values change; absent for a context with no sheet behind it.
+     */
+    getKinds?(): ISpatialMap<CellKind>;
+    /**
+     * Each cell's job, by role (`RangeState.Type.Role`). Derived from the kinds and the formulas on
+     * first call and cached until the sheet or its values change; absent for a context with no sheet
+     * behind it.
+     */
+    getRoles?(): ISpatialMap<ICell.Role>;
 }
 /**
  * The read engine for a {@link Sheet}'s versioned state.

package/types/src/sheet/_SheetStateTypes.d.ts

@@ -14,6 +14,10 @@ import { IConditionalFormat } from '../conditionalFormat';
 import { IDataValidation } from '../dataValidation';
 import { IProtectedRange } from '../protectedRange';
 import { IPivotTable } from '../pivot';
+import { IDataTable } from '../dataTable';
+import { ICell } from '../cell';
+import { IgnoredErrors } from './_IgnoredErrors';
+import { CellKind } from './_Kinds';
 import { IAnchoredMap } from '../anchored/IAnchoredMap';
 import { Anchored } from '../anchored/Anchored';
 import { IUsedRangeSpatialMap } from './style/UsedRangeSpatialMap';
@@ -164,6 +168,23 @@ export declare namespace RangeState {
          * The hyperlink.
          */
         hyperlink?: IHyperlink.Properties;
+        /**
+         * The error checks the cells ignore (`ICellRange.setErrorIgnored`). One interned set per
+         * distinct combination, so equal sets are one object.
+         */
+        ignoredErrors?: readonly ICell.ErrorCheck[];
+        /**
+         * The error checks that fire, with their evidence. One interned list per distinct set of
+         * findings, so equal findings are one object and a region's identity is its payload.
+         */
+        anomalies?: readonly ICell.Anomaly[];
+        /**
+         * What the cell holds (`ICellRange.Feature.Kind`): number, date, text, text that reads as a
+         * number, boolean, error or rich data; a formula by its result.
+         */
+        kind?: CellKind;
+        /** The cell's job (`ICellRange.Feature.Role`): label, input, link, reference, computed or output. */
+        role?: ICell.Role;
         /**
          * Directives for unlocking a range. (Only applies if the sheet is protected).
          *
@@ -257,6 +278,7 @@ export declare namespace RangeState {
         readonly DataValidations: "dataValidations";
         readonly Merge: "merge";
         readonly Hyperlink: "hyperlink";
+        readonly IgnoredErrors: "ignoredErrors";
         readonly Comments: "comments";
         readonly Unlock: "unlock";
         readonly Contentful: "contentful";
@@ -279,6 +301,22 @@ export declare namespace RangeState {
          * {@link AllRangeTypes} / the all-types sweep.
          */
         readonly Error: "error";
+        /**
+         * Where an error check fires (`ICell.getAnomalies`). Backed by a map derived from the other
+         * features on first read and cached per sheet state and value epoch, so like {@link Error}
+         * it is opt-in only: never part of {@link AllRangeTypes} / the all-types sweep.
+         */
+        readonly Anomalies: "anomalies";
+        /**
+         * What each cell holds, by kind. Backed by a map derived from the values on first read and
+         * cached per sheet state and value epoch, so like {@link Error} it is opt-in only.
+         */
+        readonly Kind: "kind";
+        /**
+         * Each cell's job, by role. Backed by a map derived from the kinds and the formulas on first
+         * read and cached per sheet state and value epoch, so like {@link Error} it is opt-in only.
+         */
+        readonly Role: "role";
         readonly Validation: "dataValidation";
     };
     type Type = typeof Type[keyof typeof Type];
@@ -294,7 +332,9 @@ export declare namespace RangeState {
  * - `null` = no backing index at all — nothing left in the public vocabulary hits this today.
  *   `String`/`Number`/`Boolean` used to (scalar kinds count from values, not state); they were
  *   retired from the vocabulary entirely rather than kept as a permanent `null` — a stats scan
- *   already answers the same question, richer.
+ *   already answers the same question, richer. The value kind came back as one feature, `Kind`,
+ *   backed by a derived map, because a check needs it as a partition (a typed row is a region),
+ *   not as a count.
  * - `DateFormat` and `Error` are both real, directly indexed state now — `DateFormat` off its own
  *   spatial map (`dateFormatSpatial`, no longer internal-only), `Error` off the reconciled error
  *   view. Neither needs the value-scan special-casing the old derived `Date` feature did.
@@ -352,6 +392,14 @@ export declare const NoMergeRangeTypes: RangeState.SearchTypes;
  * @internal
  */
 export declare const OverflowsRangeTypes: RangeState.SearchTypes;
+/**
+ * Which axes of the sheet's entire size end where its content does. See `IWorksheet.setEntireSize`.
+ * @internal
+ */
+export interface EntireFit {
+    width: boolean;
+    height: boolean;
+}
 /**
  * A movable's spatial entry (anchor + container callbacks + z-order).
  * @internal
@@ -386,6 +434,8 @@ export interface State {
     continuousFillSpatial: ISpatialMap<SheetDirectStyle>;
     dateFormatSpatial: ISpatialMap<string>;
     hyperlinkSpatial: ISpatialMap<IHyperlink.Properties>;
+    /** Where Excel's error checks are ignored, by check. */
+    ignoredErrors: IgnoredErrors;
     movableSpatial: ISpatialMap<MovableEntry>;
     movableMapModel: Map<IMovable, ISpatialMap.Entry<MovableEntry>>;
     /**
@@ -426,6 +476,8 @@ export interface State {
     listeners: IAnchoredMap<ListenerAnchor, never>;
     /** The pivot tables laid out on the sheet, anchored at their locations as tables are. */
     pivotTables: IAnchoredMap<IPivotTable, IPivotTable.JSON>;
+    /** The data tables on the sheet, anchored at their result cells. */
+    dataTables: IAnchoredMap<IDataTable, IDataTable.JSON>;
     /**
      * The grid's inputs this record pairs with, as the grid named them when the model last wrote
      * this sheet's cells (`ICalcGrid.Events.onInputsWritten`); `null` before any write.
@@ -438,6 +490,8 @@ export interface State {
      */
     inputsCommitId: string | null;
     entireCoords: IRange.Coords;
+    /** `null` when neither axis fits. */
+    entireFit: EntireFit | null;
     deleted: boolean;
 }
 /**
@@ -460,5 +514,10 @@ export interface InternalTupleUpdate {
      * formula at the top-left, every other cell cleared. The calc node is minted fixed to it.
      */
     arrayFixed?: IRange.Coords;
+    /**
+     * A table's calculated column, filled into body rows the table has just taken in. Those rows came
+     * from an operation that has ruled on the sheet's protection, so locked cells do not refuse it.
+     */
+    isCalculatedFill?: boolean;
 }
 //# sourceMappingURL=_SheetStateTypes.d.ts.map

package/types/src/sheet/_SheetUtils.d.ts

@@ -4,11 +4,11 @@ import { ITypes } from '../type';
 import { IStringCollection } from '../string';
 import { ISort } from '../sort';
 import { ICellStyle, IStyleCollection } from '../style';
-import { ICell, ICellHeader } from '../cell';
+import { ICell } from '../cell';
 import { ICellRange, ICellRanges } from '../cellRange';
 import { ISheetHeader } from '../sheetHeader';
-import { ISheet } from './ISheet';
-import { ISheetInternal } from './Sheet';
+import { IWorksheet } from './IWorksheet';
+import { IWorksheetInternal } from './Worksheet';
 import { ISpatialMap, ISpatialQuery } from '../collections';
 import { MergeEntry } from './spatial';
 import { RangeState, CellState } from './_SheetStateTypes';
@@ -42,15 +42,15 @@ export declare function getDefaultShiftAxis(range: IRange.Coords, entireRange: I
  */
 export declare function toAbsRangeCoords(rowIndex: number, colIndex: number, relative: IRange.Coords): IRange.Coords;
 /**
- * Bridge from the public {@link ISheet} to the internal capability object its ranges are built on.
+ * Bridge from the public {@link IWorksheet} to the internal capability object its ranges are built on.
  *
  * @remarks
- * `Sheet` is the only implementation of `ISheet`, so this is total in practice. It exists as a
- * helper (rather than a member of `ISheet`) to keep `_getInternal` off the published interface —
- * `Workbook` holds sheets as `ISheet` and is the only caller that needs to cross the boundary.
+ * `Sheet` is the only implementation of `IWorksheet`, so this is total in practice. It exists as a
+ * helper (rather than a member of `IWorksheet`) to keep `_getInternal` off the published interface —
+ * `Workbook` holds sheets as `IWorksheet` and is the only caller that needs to cross the boundary.
  * @internal
  */
-export declare function getInternal(sheet: ISheet): ISheetInternal;
+export declare function getInternal(sheet: IWorksheet): IWorksheetInternal;
 /**
  * The internals a scoped coord actually addresses — the sheet named by `scope`, not the anchor.
  *
@@ -69,7 +69,7 @@ export declare function getInternal(sheet: ISheet): ISheetInternal;
  * see `WorkbookRanges._createRange`.
  * @internal
  */
-export declare function resolveScopedInternal(internal: ISheetInternal, scope: string | null | undefined): ISheetInternal | null;
+export declare function resolveScopedInternal(internal: IWorksheetInternal, scope: string | null | undefined): IWorksheetInternal | null;
 /**
  * Drops a coord's `scope` when it merely restates the anchor.
  *
@@ -84,12 +84,18 @@ export declare function resolveScopedInternal(internal: ISheetInternal, scope: s
  * redundant with, and stay fully qualified.
  * @internal
  */
-export declare function normalizeScope<T extends IRange.Coords>(coords: T, anchor: ISheet): T;
+export declare function normalizeScope<T extends IRange.Coords>(coords: T, anchor: IWorksheet): T;
 /** {@link normalizeScope} over a set, allocating only when something is actually redundant. @internal */
-export declare function normalizeScopes<T>(coords: readonly T[], anchor: ISheet): readonly T[];
+export declare function normalizeScopes<T>(coords: readonly T[], anchor: IWorksheet): readonly T[];
 /** @internal */
-export declare function createInvalidRange(sheet: ISheet | null, maxRange?: IRange.Coords | null, range?: IRange.Coords | null, errorType?: string): ICellRange;
-export declare function createInvalidRanges(sheet: ISheet): ICellRanges;
+export declare function createInvalidRange(sheet: IWorksheet | null, maxRange?: IRange.Coords | null, range?: IRange.Coords | null, errorType?: string): ICellRange;
+export declare function createInvalidRanges(sheet: IWorksheet): ICellRanges;
+/**
+ * The number `strValue` would enter as if typed, or `null`: the entry parser's number half, so a
+ * date or a time is not a number here.
+ * @internal
+ */
+export declare function parseNumberInput(runtime: IRuntime, strValue: string): number | null;
 /**
  * Implementation of date/number/currency parsing
  *
@@ -189,7 +195,7 @@ export declare function rangeTopLeft(range: IRange.Coords): IRange.Coords;
  * Given a selection, find the 'natural' bounding area to sort.
  * When checking for header and default sort criteria this is the axis to use. @default IRange.Axis.Row
  */
-export declare function getDefaultSortCriteria(sheet: ISheet, rangeCoords: IRange.Coords, cellCoords?: IRange.CellCoords, axis?: IRange.Axis): ISort.DefaultSortCriteria;
+export declare function getDefaultSortCriteria(sheet: IWorksheet, rangeCoords: IRange.Coords, cellCoords?: IRange.CellCoords, axis?: IRange.Axis): ISort.DefaultSortCriteria;
 /**
  * Search all spatials expanding the range until no immediate bounding rectangles.
  */
@@ -210,11 +216,6 @@ export declare function closeOverMerges<T extends IRange.Coords>(range: T, getMe
  * Expands ranges to include merges. See {@link closeOverMerges}.
  */
 export declare function expandToIncludeMerges(ranges: readonly IRange.Coords[], mergeSpatial: ISpatialMap<MergeEntry>, entireCoords: IRange.Coords): IRange.Coords[];
-export type OrientedStyled = {
-    axes: IRange.AxisSelection;
-    index: number;
-};
-export declare function headerToRangedStyles(headers: IRange.JSONReference<ICellHeader.JSON>[], axis: IRange.Axis, entireCoords: IRange.Coords): ITypes.RangeCoordValue<OrientedStyled>[] | null;
 export declare function shiftFrozen(coords: IRange.CellCoords, range: IRange.Coords, isColumn: boolean, shiftAmount: number, // we could get from range but already have it in caller
 entireRange: IRange.Coords): IRange.CellCoords;
 export declare function flattenRanges(coords: readonly IRange.Coords[], axes?: IRange.AxisSelection): IRange.Coords[];

package/types/src/sheet/_WatchAnchor.d.ts

@@ -2,7 +2,6 @@ import { Scalar } from '@sheetxl/primitives';
 import { ISparseGrid } from '../collections';
 import { ICellRange } from '../cellRange';
 import { ICalcGrid, FormulaHost } from '../calculation/grid';
-import { FormulaSpatialValue } from '../calculation/spatial';
 import { ListenerAnchor } from './_ListenerAnchor';
 /**
  * A listener node that owns a formula: the location of a watch.
@@ -34,7 +33,7 @@ export declare class WatchAnchor extends ListenerAnchor {
     /** The grid's values as of the last delivery, so a pass that changed nothing is not re-delivered. */
     protected _lastValues: ISparseGrid<Scalar> | null;
     /** The body's blank region as of the last delivery - the part of the answer the grid does not hold. */
-    protected _lastBlank: FormulaSpatialValue.BlankRegion | null;
+    protected _lastBlank: ICalcGrid.BlankRegion | null;
     constructor(options: WatchAnchor.ConstructorOptions);
     /**
      * Hand the body's values to the watch after a pass, when something inside the location changed.
@@ -80,6 +79,15 @@ export declare namespace WatchAnchor {
     interface ConstructorOptions extends ListenerAnchor.ConstructorOptions {
         host: FormulaHost;
     }
+    /** {@link ICellRange.WatchOptions}, and what only an owner inside the sdk asks for. */
+    interface Options extends ICellRange.WatchOptions {
+        /**
+         * Evaluate the body's blank region a tile at a time, when its answer there depends on the
+         * position: see `CalcGridBackend.ConstructorOptions.paged`. The owner asks for what it reads
+         * through {@link FormulaHost.request}; a cell it has not asked for holds nothing.
+         */
+        paged?: boolean;
+    }
     /** What a watch is told. Held by the sheet, never by the node. */
     interface Handlers {
         /** The body's values after every pass that changed them. */
@@ -88,6 +96,11 @@ export declare namespace WatchAnchor {
         onChange?: () => void;
         /** The body's host, once registered — for an owner that reads the body back. */
         onRegistered?: (host: FormulaHost) => void;
+        /**
+         * The registration was undone by a rollback of the operation it was made in: the node and the
+         * body are gone, and nothing will deliver. An owner waiting on a delivery must stop waiting.
+         */
+        onRemoved?: () => void;
     }
 }
 //# sourceMappingURL=_WatchAnchor.d.ts.map