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

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.
@@ -44,14 +50,9 @@ options?: ITransaction.OperationOptions): void;
  * @internal
  */
 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
- */
+options?: ITransaction.OperationOptions, 
+/** The caller has ruled on protection for these ranges (a content clear on a locked sheet). */
+isRuled?: boolean): void;
 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;
@@ -163,6 +164,7 @@ export interface TupleScan {
     readonly allowFormatCells: boolean;
     readonly hasUnlockRanges: boolean;
     readonly runtime: SheetMutationContext['runtime'];
+    readonly richData: SheetMutationContext['richData'];
     /**
      * A scan that stays open holds only cells whose write cannot fail once scanned, and whose held
      * style changes that cell alone: a cell that carries a hyperlink or comments, or a style that

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

@@ -13,7 +13,11 @@ import { SpillEntry, ContentfulSpatialValue, CircularEntry } from '../calculatio
 import { IConditionalFormat } from '../conditionalFormat';
 import { IDataValidation } from '../dataValidation';
 import { IProtectedRange } from '../protectedRange';
+import { ICellControl } from '../cellControl';
 import { IPivotTable } from '../pivot';
+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';
@@ -149,6 +153,14 @@ export declare namespace RangeState {
          * Overlaps are allowed
          */
         conditionals?: IConditionalFormat | IConditionalFormat[];
+        /**
+         * The cell's control, such as a checkbox.
+         *
+         * @remarks
+         * A cell has at most one; an array arises only from a file whose controls overlap, and the
+         * first wins (`ICell.getControl`).
+         */
+        cellControls?: ICellControl | ICellControl[];
         /**
          * The per-feature direct styles for a collection of cells (SHEET-STYLE-SPLIT). These are the
          * user-authored style, kept DISCRETE — `borderStyle` carries `borders`, `fillStyle` carries `fill`,
@@ -164,6 +176,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).
          *
@@ -213,10 +242,8 @@ export declare namespace RangeState {
          * The date format as a string
          */
         dateFormat?: string;
-        /**
-         * Pending calcs.
-         */
-        pending?: boolean;
+        /** Why the cell is waiting on a calculation: its own function's result, or a precedent's. */
+        calcStatus?: ICalcGrid.CalcStatus;
         /**
          * Errors during calculation.
          */
@@ -257,16 +284,18 @@ 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";
         readonly Conditionals: "conditionals";
+        readonly CellControls: "cellControls";
         /**
          * Has a formula
          */
         readonly Formula: "formula";
         readonly Spills: "spills";
-        readonly Pending: "pending";
+        readonly CalcStatus: "calcStatus";
         readonly CalcError: "calcError";
         /**
          * In a reference cycle, or downstream of one — evaluates to `0` (DESIGN-CIRCULAR-CALC.md §7).
@@ -279,6 +308,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,13 +339,15 @@ 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.
  *
- * Internal-only members of `RangeState.Type` (`Pending`, `Continuous`, the legacy `Validation`
- * alias) deliberately have no public feature.
+ * Internal-only members of `RangeState.Type` (`Continuous`, the legacy `Validation` alias)
+ * deliberately have no public feature.
  */
 export declare const FeatureToRangeState: Readonly<Record<ICellRange.Feature, RangeState.Type | null>>;
 /**
@@ -318,7 +365,7 @@ export declare function featuresToSearchTypes(features?: ICellRange.Feature | re
  *   would put an intersection on every valued cell (the null-check optimization dies).
  * - `Continuous` rides along with any content-style projection (it is the continuous-alignment
  *   fast path — internal, so no public feature can name it).
- * - `Pending` rides along with `Formula`/`CalcError` (calc status accompanies calc state).
+ * - `CalcStatus` rides along with `Formula`/`CalcError` (calc status accompanies calc state).
  */
 export declare function cellFeaturesToSearchTypes(features?: ICellRange.Feature | readonly ICellRange.Feature[]): boolean | RangeState.SearchTypes;
 /**
@@ -352,6 +399,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 +441,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>>;
     /**
@@ -413,6 +470,13 @@ export interface State {
      * Read through `RangeState.Type.Comments` — see {@link RangeState.Intersection.comments}.
      */
     comments: IAnchoredMap<IComment, IComment.JSON>;
+    /**
+     * The cell controls, such as checkboxes.
+     *
+     * @remarks
+     * Read through `RangeState.Type.CellControls` — see {@link RangeState.Intersection.cellControls}.
+     */
+    cellControls: IAnchoredMap<ICellControl, ICellControl.JSON>;
     /**
      * The reference each range listener watches.
      *
@@ -438,6 +502,8 @@ export interface State {
      */
     inputsCommitId: string | null;
     entireCoords: IRange.Coords;
+    /** `null` when neither axis fits. */
+    entireFit: EntireFit | null;
     deleted: boolean;
 }
 /**
@@ -460,5 +526,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

package/types/src/sheet/clipboard/RangeClipboardItems.d.ts

@@ -2,7 +2,7 @@ import { IRange, IRuntime } from '@sheetxl/primitives';
 import { ReferenceableClipboard, EditMode } from '@sheetxl/utils';
 import { ICellRange } from '../../cellRange';
 import { IStyleCollection } from '../../style';
-import { ISheet } from '../ISheet';
+import { IWorksheet } from '../IWorksheet';
 /**
  * Implements {@link ReferenceableClipboard.ReferenceItem} by delegating to {@link ICellRange.ISnapshot}.
  */
@@ -34,16 +34,16 @@ export declare class ExternalRangeClipboardItem implements ReferenceableClipboar
     protected _topLeft: IRange.CellCoords;
     protected _markOptions: ICellRange.CopyOptions;
     protected _styles: IStyleCollection | undefined;
-    protected _snapshot: ICellRange.ISnapshot<ISheet> | undefined;
+    protected _snapshot: ICellRange.ISnapshot<IWorksheet> | undefined;
     /** undefined = not yet parsed; null = parsed but empty */
-    protected _parsed: Partial<ICellRange.ISnapshot<ISheet>> | null | undefined;
+    protected _parsed: Partial<ICellRange.ISnapshot<IWorksheet>> | null | undefined;
     constructor(runtime: IRuntime, native: ReferenceableClipboard.NativeItems, topLeft: IRange.CellCoords, markOptions?: ICellRange.CopyOptions, styles?: IStyleCollection);
     getItemType(): string;
     isCut(): boolean;
     toText(): string;
     toHtml(): string;
     toImage(): Blob;
-    getItem(): ICellRange.ISnapshot<ISheet>;
+    getItem(): ICellRange.ISnapshot<IWorksheet>;
     /**
      * Required to be called before getItem().
      * @remarks

package/types/src/sheet/clipboard/SheetHTMLTableParser.d.ts

@@ -1,10 +1,10 @@
 import { IRange, IRuntime } from '@sheetxl/primitives';
 import { ICell } from '../../cell';
 import { IStyleCollection } from '../../style';
-import { ISheet } from '../ISheet';
+import { IWorksheet } from '../IWorksheet';
 import { IHTMLParser } from './IHTMLParser';
 /**
- * Reads html and writes to an ISheet.
+ * Reads html and writes to an IWorksheet.
  */
 export declare class SheetHTMLTableParser implements IHTMLParser.TableParser {
     private _sheet;
@@ -24,6 +24,6 @@ export declare class SheetHTMLTableParser implements IHTMLParser.TableParser {
     onRowStart(rowIndex: number, rowSpan: number, getStyles: IHTMLParser.GetCSSStyles, element: HTMLTableRowElement | null): void;
     onColumn(colIndex: number, colSpan: number, getStyles: IHTMLParser.GetCSSStyles, element: HTMLTableColElement | null): void;
     onDone(): void;
-    sheet(): ISheet;
+    sheet(): IWorksheet;
 }
 //# sourceMappingURL=SheetHTMLTableParser.d.ts.map

package/types/src/sheet/clipboard/SheetHTMLTableWriter.d.ts

@@ -1,9 +1,9 @@
 import { IRange } from '@sheetxl/primitives';
 import { ICell, ICellHeader } from '../../cell';
-import { ISheet } from '../ISheet';
+import { IWorksheet } from '../IWorksheet';
 import { IHTMLParser } from './IHTMLParser';
 /**
- * Writes `ISheet` to html.
+ * Writes `IWorksheet` to html.
  */
 export declare class SheetHTMLTableWriter implements IHTMLParser.TableWriter {
     private _sheet;
@@ -17,7 +17,7 @@ export declare class SheetHTMLTableWriter implements IHTMLParser.TableWriter {
     private _includeSizeInCell;
     /** Write what formula view shows — see {@link SheetHTMLTableWriter.Options.showFormulas}. */
     private _textOptions;
-    constructor(sheet: ISheet, options?: SheetHTMLTableWriter.Options);
+    constructor(sheet: IWorksheet, options?: SheetHTMLTableWriter.Options);
     private _createCSSStyle;
     private _createCSSNormalStyle;
     onCell(cell: ICell, coords: IRange.CellCoords, valueWriter: IHTMLParser.ValueWriter): void | false;

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

@@ -1,6 +1,9 @@
 export * from './clipboard';
 export * from './ICellContainerOptions';
 export * from './ISheet';
-export * from './ISheetCollection';
-export * from './Sheet';
+export * from './IOpaqueSheet';
+export * from './IWorksheet';
+export * from './IWorksheetCollection';
+export * from './Worksheet';
+export { findLabel, normalizeLabel, type FoundLabel } from './_Labels';
 //# sourceMappingURL=index.d.ts.map