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

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

@@ -0,0 +1,46 @@
+import { IRange } from '@sheetxl/primitives';
+import { CoordUtils } from '@sheetxl/utils';
+import { ICell } from '../cell';
+import { ISpatialMap } from '../collections';
+import { IWorksheet } from './IWorksheet';
+/**
+ * The checks a cell ignores, interned: equal sets are one object, in the schema's order, so a
+ * region's payload identity is its content and two fragments of one ignore regroup.
+ * @internal
+ */
+export type ErrorCheckSet = readonly ICell.ErrorCheck[];
+/** The interned set of `checks`; `null` for none (an unknown name is dropped). */
+export declare function internChecks(checks: Iterable<ICell.ErrorCheck>): ErrorCheckSet | null;
+/**
+ * The cells where Excel's error checks are ignored: one spatial map whose payload is the set of
+ * checks a cell ignores. Presence is the ignore; an entry goes when its set empties. Immutable;
+ * each change returns a new holder.
+ *
+ * @remarks
+ * Excel's rules (`openpy-parity/probe-ignored-errors.ps1`, 2026-10-18): the regions move with
+ * structural edits like cell content, an insert inside one splitting it; they are never copied
+ * (copy, paste, fill, the destination of a cut); and writing or clearing a cell, contents or
+ * formats, removes its ignores.
+ * @internal
+ */
+export declare class IgnoredErrors {
+    static readonly Empty: IgnoredErrors;
+    private readonly _map;
+    private constructor();
+    /** From {@link IWorksheet.JSON.ignoredErrors}; references that overlap ignore the union. */
+    static fromJSON(json: IWorksheet.JSON['ignoredErrors'], entireCoords: IRange.Coords): IgnoredErrors;
+    isEmpty(): boolean;
+    /** The map, for the sheet's range-state readers; `null` when nothing is ignored. */
+    getMap(): ISpatialMap<ErrorCheckSet> | null;
+    /** The checks `cell` ignores, or `null`. */
+    getAt(cell: IRange.CellCoords): ErrorCheckSet | null;
+    /** With `check` ignored, or no longer ignored, over `ranges`. */
+    set(ranges: readonly IRange.Coords[], check: ICell.ErrorCheck, ignored: boolean): IgnoredErrors;
+    /** Shifted by a structural edit of `ranges`, one range at a time, in order. */
+    shift(ranges: readonly IRange.Coords[], direction: IRange.Direction, coordValidator?: CoordUtils.CoordValidator): IgnoredErrors;
+    /** Without any ignore over `ranges`, for cells written or cleared. */
+    remove(...touched: (readonly IRange.Coords[])[]): IgnoredErrors;
+    /** As {@link IWorksheet.JSON.ignoredErrors}, in range order, or `null` when nothing is ignored. */
+    toJSON(entireCoords: IRange.Coords): IWorksheet.JSON['ignoredErrors'] | null;
+}
+//# sourceMappingURL=_IgnoredErrors.d.ts.map

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

@@ -1,14 +1,14 @@
 import { IRange, Scalar, IRangeStats } from '@sheetxl/primitives';
 import { IListener } from '../listener';
-import { IStyle } from '../style';
+import { ICellStyle } from '../style';
 import { ICell } from '../cell';
-import { ISheet } from './ISheet';
+import { IWorksheet } from './IWorksheet';
 import { ICellRange, ICellRegions, ICellRanges, ICellHeaderRanges } from '../cellRange';
 import { SheetRanges, SheetRangesOptions } from './SheetRanges';
 export declare function RETURN_FALSE(): boolean;
 export declare function RETURN_TRUE(): boolean;
 export declare function RETURN_NULL(): any;
-export declare function getInvalidCell(sheet: ISheet | null): ICell;
+export declare function getInvalidCell(sheet: IWorksheet | null): ICell;
 /**
  * This is for 0 size ranges.
  * @internal
@@ -17,7 +17,7 @@ export declare const InvalidSheetRange: ICellRange;
 export declare class InvalidSheetRanges extends SheetRanges {
     constructor(sheet: any, options?: SheetRangesOptions);
     getMerges(): IRange.Coords[];
-    getStyle(): IStyle;
+    getStyle(): ICellStyle;
     find(): Iterator<ICell>;
     [Symbol.iterator](): IterableIterator<Scalar>;
     entries(): IterableIterator<ICellRange.Entry>;
@@ -28,6 +28,7 @@ export declare class InvalidSheetRanges extends SheetRanges {
     insert(): this;
     delete(): this;
     insertFrom(): Promise<this | null>;
+    canInsertFrom(): boolean;
     getSnapshot(): ICellRange.ISnapshot;
     copyFrom(): Promise<this | null>;
     getEntireRows(): this;
@@ -41,10 +42,11 @@ export declare class InvalidSheetRanges extends SheetRanges {
     getStats(): IRangeStats;
     getCounts(): ICellRange.Counts;
     getRegions(): ICellRegions;
-    getDirectPrecedents(): ICellRanges | null;
-    getDirectDependents(): ICellRanges | null;
-    getPrecedents(): ICellRanges | null;
-    getDependents(): ICellRanges | null;
+    getAnomalies(): ICellRegions;
+    getDirectPrecedents(): Promise<ICellRanges | null>;
+    getDirectDependents(): Promise<ICellRanges | null>;
+    getPrecedents(): Promise<ICellRanges | null>;
+    getDependents(): Promise<ICellRanges | null>;
     isContentful(): boolean;
     getRowCount(): number;
     getColumnCount(): number;
@@ -58,7 +60,6 @@ export declare class InvalidSheetRanges extends SheetRanges {
     isSingleCell(): boolean;
     isEqual(): boolean;
     getFixed(): this;
-    getCount(): number;
     at(): ICellRange;
     doBatch<R>(): R | Promise<R>;
     getCoords(): readonly Readonly<IRange.FixableCoords>[];

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

@@ -0,0 +1,34 @@
+import { Scalar } from '@sheetxl/primitives';
+import { ISparseGrid, ISpatialMap, ISpatialQuery } from '../collections';
+/**
+ * What a cell holds (`ICellRange.Feature.Kind`). A formula cell is the kind of its result.
+ * @internal
+ */
+export declare const CellKind: {
+    readonly Number: "number";
+    /** A number under a date or time format. */
+    readonly Date: "date";
+    readonly Text: "text";
+    /** Text a typed entry would read as a number: Excel's number stored as text. */
+    readonly NumberText: "numberText";
+    readonly Boolean: "boolean";
+    readonly Error: "error";
+    readonly RichData: "richData";
+};
+/** @internal */
+export type CellKind = typeof CellKind[keyof typeof CellKind];
+/** What the kinds are read from. @internal */
+export interface KindSource {
+    readonly values: ISparseGrid<Scalar>;
+    /** The date-category number formats, by where they are applied. */
+    readonly dateFormats: ISpatialQuery<string>;
+    /** The number a text would enter as if typed, or `null`. */
+    parseNumber(text: string): number | null;
+}
+/**
+ * The kind partition of one sheet: one scan of the values, the same pass the reconciled error
+ * view makes, then the numbers under a date format become dates.
+ * @internal
+ */
+export declare function buildKinds(source: KindSource): ISpatialMap<CellKind>;
+//# sourceMappingURL=_Kinds.d.ts.map

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

@@ -0,0 +1,38 @@
+import { IRange } from '@sheetxl/primitives';
+import { IWorksheet } from './IWorksheet';
+/**
+ * A label and where it was read from.
+ * @internal
+ */
+export interface FoundLabel {
+    /** The label as the cell shows it. */
+    readonly text: string;
+    /** The label's cell, `B4`. */
+    readonly address: string;
+    readonly coords: IRange.CellCoords;
+}
+/**
+ * The text that labels a cell's row (`'row'`) or column (`'column'`).
+ *
+ * @remarks
+ * Deterministic, and the address is always returned so a reader can judge it:
+ *
+ * 1. The first cell of the line within the cell's current region (Ctrl+Shift+*), when it is text —
+ *    the row label at the left edge of the block, the header at its top.
+ * 2. Otherwise the first cell of each earlier run of filled cells on that line, nearest first —
+ *    leftward for a row, upward for a column — when it is text. Only a run's edge is read: a text
+ *    in the middle of a run of values (a scenario name, a unit) is part of the data, not the line's
+ *    label. The cost is the runs on the line, not its cells; there is no cap, because a cap is
+ *    only a different arbitrary answer.
+ *
+ * `null` when the cell is itself the first cell of the line or no run before it starts with text.
+ * @internal
+ */
+export declare function findLabel(sheet: IWorksheet, cell: IRange.CellCoords, axis: 'row' | 'column'): FoundLabel | null;
+/**
+ * A label reduced to what two labels are compared on: case, punctuation and runs of space
+ * dropped, so `Total Revenue:` and `total  revenue` agree.
+ * @internal
+ */
+export declare const normalizeLabel: (text: string) => string;
+//# sourceMappingURL=_Labels.d.ts.map

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

@@ -0,0 +1,104 @@
+import { IRange } from '@sheetxl/primitives';
+import { ISpatialMap } from '../collections';
+import { IListener } from '../listener';
+import { IAnchored } from '../anchored/IAnchored';
+import { Anchored } from '../anchored/Anchored';
+import { ICellRange, ICellRanges } from '../cellRange';
+/**
+ * The reference a range listener watches, as an entry in a versioned anchored map.
+ *
+ * @remarks
+ * This is the smallest thing that can be anchored. It deliberately does NOT extend
+ * `AbstractAnchored`: it has no store record of its own, no emitter, and no creation commit, so a
+ * UI layer can register one per scroll step. What it gets from living in the map is everything a
+ * conditional format's anchor gets - it shifts, splits and goes `#REF!` through `IAnchoredMap.shift`,
+ * and it comes back on undo because the map is in the snapshot.
+ *
+ * The callback is NOT here. It lives on the sheet instance keyed by {@link getNodeId}, because a
+ * callback is an observer, never document state.
+ *
+ * @internal
+ */
+export declare class ListenerAnchor implements IAnchored {
+    /** For runtime type checking. */
+    readonly isIAnchored: true;
+    protected _nodeId: number;
+    protected _options: ICellRange.ListenerOptions;
+    protected _resolveRanges: (coords: IRange.Coords[] | null) => ICellRanges;
+    protected _getContainerCoords: () => IRange.Coords[] | null;
+    protected _deleted: boolean;
+    protected _closed: boolean;
+    constructor(options: ListenerAnchor.ConstructorOptions);
+    /**
+     * Identifies this node. The sheet holds the callback under the same key.
+     */
+    getNodeId(): number;
+    /**
+     * The node's coords in the snapshot the sheet is currently at, or `null` when it holds no entry.
+     *
+     * @remarks
+     * `null` is not an error state to guard against - it IS the answer for a range that was deleted
+     * (`#REF!`) and for a snapshot from before the node was registered (`#N/A`).
+     */
+    getContainerCoords(): IRange.Coords[] | null;
+    /**
+     * What the listener asked for when it registered.
+     */
+    getListenerOptions(): ICellRange.ListenerOptions;
+    /** {@inheritDoc IAnchored.getRanges} */
+    getRanges(): ICellRanges;
+    /** {@inheritDoc IAnchored.isProtected} */
+    isProtected(): boolean;
+    /** {@inheritDoc IAnchored.addListeners} */
+    addListeners(_listeners: IAnchored.IListeners, _options?: IListener.Options): IListener.Remove;
+    /** {@inheritDoc IAnchored.delete} */
+    delete(): void;
+    /**
+     * The node's ranges are back, so it is no longer `#REF!`.
+     *
+     * @remarks
+     * Undo restores the map, and with it the entry a delete removed. The flag has to follow, or a
+     * reference that came back would keep reporting the error it had on the way out.
+     */
+    undelete(): void;
+    /** {@inheritDoc IAnchored.isDeleted} */
+    isDeleted(): boolean;
+    /** {@inheritDoc IAnchored.close} */
+    close(): void;
+    /** {@inheritDoc IAnchored.isClosed} */
+    isClosed(): boolean;
+}
+/** @internal */
+export declare namespace ListenerAnchor {
+    interface ConstructorOptions {
+        nodeId: number;
+        listenerOptions: ICellRange.ListenerOptions;
+        /** Builds the ranges for the node's coords; an INVALID ranges when it has none. */
+        resolveRanges: (coords: IRange.Coords[] | null) => ICellRanges;
+        /** The node's coords in the map the sheet is currently at, or `null` when it holds no entry. */
+        getContainerCoords: () => IRange.Coords[] | null;
+    }
+    /**
+     * Shift one of a node's ranges the way the calc graph shifts a formula precedent.
+     *
+     * @remarks
+     * The map the nodes live in is asked not to split on a shift, and to bring each entry here
+     * instead of using its own arithmetic. The answer is then, by construction, the answer
+     * `=SUM(A1:C3)` gets for the same operation: `shiftReferenceAxis` is the rule `shiftPrecedents`
+     * applies to every reference it rewrites. Inserting one cell at A1 shifting down leaves the
+     * reference `A2:C4`; deleting A1:A3 shifting up leaves it `#REF!`.
+     *
+     * A reference pushed past the edge of the sheet is `#REF!` as well, whole or in part. The graph
+     * applies that when it writes a reference out (`TokenUtils`: an endpoint outside the sheet's
+     * bounds is written as `#REF!`); the node applies it here, to the same effect.
+     *
+     * Handed to the map as {@link IAnchoredMap.ConstructorOptions.shiftEntry}.
+     *
+     * @param details The shift, as the map describes it.
+     * @param entire The bounds of the sheet the node is on.
+     */
+    function shiftReference(details: ISpatialMap.ShiftDetails, entire: IRange.Coords): IRange.Coords | null;
+    /** The container hooks a node registers; see {@link Anchored.ContainerCallbacks}. */
+    type Callbacks = Anchored.ContainerCallbacks;
+}
+//# sourceMappingURL=_ListenerAnchor.d.ts.map

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

@@ -0,0 +1,15 @@
+import { IRange } from '@sheetxl/primitives';
+import { RangeSweep, RunCoords, PieceStore } from '@sheetxl/utils';
+import { RangeState } from './_SheetStateTypes';
+import { SheetReadContext } from './_SheetStateReader';
+export { type PieceStore } from '@sheetxl/utils';
+export declare function collectPieces(ctx: SheetReadContext, bounds: IRange.Coords, searchTypes: RangeState.SearchTypes | null, injectReferences: IRange.JSONReference<any>[][] | undefined, containedBounds: IRange.Coords | undefined, hiddenRows: readonly RunCoords[] | null, hiddenColumns: readonly RunCoords[] | null): PieceStore | null;
+/**
+ * The range-state sweep: regions materialize as `RangeState.Intersection` (values merged by type
+ * key, overlapping same-key values as arrays in overlap order).
+ * @internal
+ */
+export declare class RangeStateSweep extends RangeSweep<RangeState.Intersection> {
+    protected _materialize(region: number): RangeState.Intersection;
+}
+//# sourceMappingURL=_RangeStateSweep.d.ts.map

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

@@ -0,0 +1,61 @@
+import { Scalar } from '@sheetxl/primitives';
+import { IStringCollection } from '../string';
+import { ICell } from '../cell';
+import { IListLike } from '../collections';
+import { MixedTypedArrayList } from '../collections/MixedTypedArrayList';
+/**
+ * Makes the list a run of cell values is stored as, over the sheet's string collection.
+ *
+ * The representation is chosen from what the writer saw ({@link Tuple.Hint}) and the run's length,
+ * never by looking at the values again:
+ * - shorter than {@link ScalarListFactory.TypedThreshold}: a plain array (a typed list costs
+ *   more than its values below that, measured at 64 on Node);
+ * - one value throughout: a `RepeatingList` of period 1, which the engine reads once;
+ * - holding rich data: a plain array (no pool for it yet);
+ * - otherwise a {@link MixedTypedArrayList}, strings and errors by id.
+ *
+ * @internal
+ */
+export declare class ScalarListFactory {
+    /** Below this length a run is a plain array. */
+    static readonly TypedThreshold = 64;
+    readonly codec: MixedTypedArrayList.Codec<Scalar>;
+    private readonly _strings;
+    private _codes;
+    private _nums;
+    constructor(strings: IStringCollection);
+    /**
+     * The list for a run a builder collected. Passed to `Tuple.Builder` as its `createList`.
+     *
+     * @param values The run's values, in an array that may be the writer's reused scratch: never
+     * retained, what the list keeps is copied out.
+     * @param length How many of `values` are the run's. Never 0.
+     * @param hint The {@link Tuple.Hint} bits the writer saw; computed here when a writer has none.
+     * @throws When a number is NaN or infinite: the entry points normalize those to `#NUM!`, so one
+     * arriving here is an internal path that skipped its boundary, and storing it would launder the
+     * defect into a plausible-looking cell.
+     */
+    readonly createList: (values: Scalar[], length?: number, hint?: number) => IListLike<Scalar>;
+    /**
+     * The list for a run as a file holds it (`IWorksheet.JSON` data): numbers and booleans as they are,
+     * strings as their id in this factory's collection, errors and rich data typed. One look at each
+     * value classifies it into a reused scratch; nothing is resolved for a typed run.
+     *
+     * @param values The run's JSON values. Never empty.
+     * @param onError Called with the offset of every error value, for the error index.
+     */
+    fromJSONRun(values: readonly ICell.JSON[], onError?: (offset: number) => void): IListLike<Scalar>;
+    /**
+     * The list for a run whose values are already codes and numbers, as a file holds them: string
+     * ids, error codes, ints and doubles. Nothing is resolved for a typed run; a short run is
+     * resolved into a plain array.
+     *
+     * @param codes The {@link MixedTypedArrayList.Type} per position; never `Rich`.
+     * @param values The number per position; ignored for a boolean or a blank.
+     */
+    fromEncoded(codes: Uint8Array, values: ArrayLike<number>): IListLike<Scalar>;
+    /** The representation for `length` classified values, from what the classification saw. */
+    private _fromCodes;
+    private _decode;
+}
+//# sourceMappingURL=_ScalarListFactory.d.ts.map

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

@@ -0,0 +1,74 @@
+import { IRange } from '@sheetxl/primitives';
+import { ICellRange } from '../cellRange';
+import { ICell } from '../cell';
+import { IAutoFill } from '../autoFill';
+import { IWorksheet } from './IWorksheet';
+import { SheetMutationContext } from './Worksheet';
+/**
+ * The default fill a range implies — which cells it reads, which it covers, which types can be
+ * offered, and the one to open on. See {@link ICellRange.getDefaultAutoFillCriteria}.
+ *
+ * @returns `null` when the range is one cell deep along the direction — there is nowhere to fill.
+ * @internal
+ */
+export declare function getDefaultAutoFillCriteria(sheet: IWorksheet, rangeCoords: IRange.Coords, direction?: IRange.Direction, destination?: IRange.Coords): IAutoFill.DefaultCriteria | null;
+/**
+ * Resolve a raw destination to the nearest destination {@link autoFill} accepts — what
+ * {@link ICellRange.AutoFillOptions.snap} runs before the fill.
+ * @internal
+ */
+export declare function autoFillRange(ctx: SheetMutationContext, template: IRange.Coords, destination: IRange.Coords): IRange.Coords;
+/**
+ * What an `autoFill` run with `preview` hands back instead of committing: the destination plus a
+ * cell-level projection of the fill that *would* happen. `SheetRange` wraps this in a read-only
+ * `ICellRange` — see {@link ICellRange.autoFill}.
+ * @internal
+ */
+export interface AutoFillProjection {
+    /** The destination the projection covers. */
+    coords: IRange.Coords;
+    /**
+     * The projected (uncommitted) cell at these coords. Cells the fill does not touch read straight from
+     * the sheet; filled cells are derived — value, style and, when the template tiles a merge across the
+     * fill, the merge itself (so `getRange`/`getSpans`/`getExtrusions` report the projected block, and a
+     * coord inside one resolves to that block's anchor, where the value lives).
+     */
+    getCellAt(rowIndex: number, colIndex: number): ICell;
+}
+/**
+ * The single-entry series memo behind `autoFill({ preview })` — the "last autofill".
+ *
+ * @remarks
+ * A drag previews the same template in the same direction over and over, changing only the destination;
+ * the series does not depend on the destination, so scanning it once serves the whole drag. Held on the
+ * sheet (one entry) and validated against `state` identity: the transaction store rebuilds the state
+ * object on every real change (reference-equal *is* its "nothing changed" signal), so any mutation,
+ * undo or redo drops the memo without anything having to invalidate it explicitly.
+ * @internal
+ */
+export interface AutoFillPreviewCache {
+    /** The sheet state the series was read from. */
+    state: unknown;
+    template: IRange.Coords;
+    isForward: boolean;
+    filler: IAutoFill.Filler;
+    /** The caller's `fillerOptions` **by reference** — a caller that rebuilds it simply misses the memo. */
+    fillerOptions: IAutoFill.Options | undefined;
+    /** Series per line of the opposite axis; `null` marks a line that produced nothing to fill. */
+    seriesByLine: Map<number, IAutoFill.FillAt | null>;
+}
+/**
+ * Fill the template's series/pattern into the destination (outward drag of the fill handle). Handles
+ * merges (tiles them, never splits), date series, previewing, table extension, and copies the
+ * per-feature style maps into the filled range. Delegates a negative (inward) fill to
+ * {@link autoFillShrink}. See SHEET-SPLIT-DESIGN §5.4.
+ * @internal
+ */
+export declare function autoFill(ctx: SheetMutationContext, template: IRange.Coords, destination: IRange.Coords, options?: ICellRange.AutoFillOptions): boolean | AutoFillProjection;
+/**
+ * An inward fill — Excel's drag of the fill handle back over the source range. The strip of the
+ * template beyond the destination edge is vacated: its cells are cleared, not filled.
+ * @internal
+ */
+export declare function autoFillShrink(ctx: SheetMutationContext, template: IRange.Coords, destination: IRange.Coords, direction: IRange.Direction, options?: ICellRange.AutoFillOptions): boolean;
+//# sourceMappingURL=_SheetAutoFillUtils.d.ts.map

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

@@ -1,7 +1,7 @@
 import { IRange } from '@sheetxl/primitives';
 import { Size } from '@sheetxl/utils';
 import { ICellRange } from '../cellRange';
-import { Sheet } from './Sheet';
+import { Worksheet } from './Worksheet';
 /**
  * Automatically adjusts row heights and column widths to fit cell content and styles.
  * - Merges and sorts input ranges for efficient processing.
@@ -15,7 +15,7 @@ import { Sheet } from './Sheet';
  * @param options AutoFit options (axis, expandOnly, skipCustomSize, etc).
  * @internal
  */
-export declare function doAutoFit(sheet: Sheet, ranges: readonly IRange.Coords[], options?: ICellRange.AutoFitOptions): void;
+export declare function doAutoFit(sheet: Worksheet, ranges: readonly IRange.Coords[], options?: ICellRange.AutoFitOptions): void;
 /**
  * The size `range`'s content needs — what {@link doAutoFit} would commit, reduced to a `Size`
  * instead of written.
@@ -24,8 +24,8 @@ export declare function doAutoFit(sheet: Sheet, ranges: readonly IRange.Coords[]
  * The same phases as `doAutoFit` ({@link measureRange}, then {@link reduceColumnWidths} /
  * {@link reduceRowHeights}) minus the commit. Everything that differs follows from not writing:
  *
- * - The clamps are IDENTITY. `expandOnly` reconciles a measurement with the size a header already
- *   has; a query has no such size to reconcile against.
+ * - No {@link ApplyPolicy}. `expandOnly` reconciles a measurement with the size a header already
+ *   has; a query has no such size to reconcile against, and measurement never reads the policy.
  * - `axes: Both` still lays the rows out against the widths the column pass produced — a wrapped
  *   cell's height is a function of its column width — but those widths reach
  *   {@link refreshSegmentWidths} as a lookup rather than being read back from headers that were
@@ -42,5 +42,5 @@ export declare function doAutoFit(sheet: Sheet, ranges: readonly IRange.Coords[]
  * @param options Measurement options (axes, minContent, formulaView).
  * @internal
  */
-export declare function doBestFit(sheet: Sheet, range: IRange.Coords, options?: ICellRange.BestFitOptions): Size;
+export declare function doBestFit(sheet: Worksheet, range: IRange.Coords, options?: ICellRange.BestFitOptions): Size;
 //# sourceMappingURL=_SheetAutoFitUtils.d.ts.map

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

@@ -0,0 +1,43 @@
+import { IRange } from '@sheetxl/primitives';
+/**
+ * The kinds of change a sheet announces from its commits, and the scope they are announced
+ * under.
+ *
+ * @remarks
+ * Every mutation appends the ranges it wrote under one of these, so a commit carries what to
+ * announce rather than what its last operation changed. The categories are recorded as the
+ * `sheet.events` intent (`_SheetIntents`), so they are unioned across the operations of a batch
+ * and travel on the commit, which is what lets an undo announce the same categories the forward
+ * commit did.
+ *
+ * The scope is {@link IWorksheet.getId}, so a commit that spans sheets announces each of them
+ * separately.
+ *
+ * @internal
+ */
+/**
+ * A category of change to announce, named after the mutation kind that produces it.
+ *
+ * @remarks
+ * * `data` - cell values written, cleared or pasted.
+ * * `style` - styles and number formats.
+ * * `comments` - comments and notes.
+ * * `hyperlinks` - hyperlinks.
+ * * `merges` - merge and unmerge.
+ * * `spills` - spill regions written or cleared.
+ * * `address` - a structural shift: an insert, a delete or a move of cells.
+ * * `layout` - sizes and hidden runs.
+ * * `anchored` - a model anchored over a range: a table, a conditional format, a validation, a
+ *   protected range.
+ * * `sheets` - the sheet itself, over the cells a reader of it may now read differently. A rename
+ *   is one: every cross-sheet formula naming it resolves again.
+ *
+ * `data`, `style`, `merges`, `spills`, `address` and `layout` each have an event of their own;
+ * the rest reach a consumer only through the union. A consumer that wants "did anything happen in
+ * my box" takes the union rather than naming categories, so a category added later cannot
+ * silently stop reaching it.
+ */
+export type EventCategory = 'data' | 'style' | 'comments' | 'hyperlinks' | 'merges' | 'spills' | 'address' | 'layout' | 'anchored' | 'sheets';
+/** What one sheet has to announce from a commit, by category. */
+export type SheetEvents = Readonly<Partial<Record<EventCategory, readonly IRange.Coords[]>>>;
+//# sourceMappingURL=_SheetEvents.d.ts.map