@sheetxl/sdk 0.7.26 → 0.7.28-beta.1

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

@@ -0,0 +1,265 @@
+import { IRange, Scalar, InteropScalar, IRuntime } from '@sheetxl/primitives';
+import { RunCoords } from '@sheetxl/utils';
+import { ITypes } from '../type';
+import { IStringCollection } from '../string';
+import { ISort } from '../sort';
+import { IStyle, IStyleCollection } from '../style';
+import { ICell, ICellHeader } from '../cell';
+import { ICellRange, ICellRanges } from '../cellRange';
+import { ISheetHeader } from '../sheetHeader';
+import { ISheet } from './ISheet';
+import { ISheetInternal } from './Sheet';
+import { Tuple, ISpatialMap, IListLike, ISpatialQuery } from '../collections';
+import { MergeEntry } from './spatial';
+import { ContentfulSpatialValue } from '../calculation/spatial';
+import { RangeState, CellState } from './_SheetStateTypes';
+import { SheetDirectStyle } from './style/SheetDirectStyle';
+import { SheetCellOptions } from './SheetCell';
+/**
+ * Selects max coords in an axis.
+ */
+export declare function expandRanges<CT extends IRange.Coords = IRange.Coords>(ranges: readonly CT[], maxRange: IRange.Coords, axis: IRange.Axis, after?: boolean): CT[];
+export declare function isEntireRows(coords: readonly IRange.Coords[], maxCoords: IRange.Coords, all: boolean): boolean;
+export declare function isEntireCols(coords: readonly IRange.Coords[], maxCoords: IRange.Coords, all: boolean): boolean;
+export declare function countSpans(coords: readonly IRange.Coords[], axis?: IRange.Axis): number;
+/**
+ * Defaults to IRange.Axis.Row if the bounds are the same size.
+ */
+export declare function getDefaultAxis(range: IRange.Coords): IRange.Axis;
+/**
+ * Default insert/delete direction for a given range.
+ */
+export declare function getDefaultShiftAxis(range: IRange.Coords, entireRange: IRange.Coords): IRange.Axis;
+/**
+ * @internal
+ */
+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.
+ *
+ * @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.
+ * @internal
+ */
+export declare function getInternal(sheet: ISheet): ISheetInternal;
+/**
+ * The internals a scoped coord actually addresses — the sheet named by `scope`, not the anchor.
+ *
+ * @remarks
+ * Ranges are ANCHORED to a sheet but each coord may name another one, exactly as a formula's
+ * references do: `Sheet1!A1 = SUM(B2, Sheet2!B2)` carries one bare precedent (the anchor's) and
+ * one scoped. A bare coord therefore resolves to `internal` and costs nothing; only a scoped one
+ * is looked up.
+ *
+ * `scope` is a sheet NAME here. The calc engine speaks stableIds/gridIds, which are translated at
+ * the SDK boundary (`Sheet._dependencyRanges`) — a stableId arriving at this layer is a bug, and
+ * shows up as an unresolvable scope rather than silently reading the wrong sheet.
+ *
+ * Returns `null` when the scope names no sheet, which callers turn into a `#REF!` range. Falling
+ * back to the anchor is what produced `workbook.getRanges("Sheet2!B2").at(0)` reading Sheet1 —
+ * see `WorkbookRanges._createRange`.
+ * @internal
+ */
+export declare function resolveScopedInternal(internal: ISheetInternal, scope: string | null | undefined): ISheetInternal | null;
+/**
+ * Drops a coord's `scope` when it merely restates the anchor.
+ *
+ * @remarks
+ * "An anchored cell has no scope" — bare IS the anchor, exactly as in a formula, so
+ * `sheet1.getRanges('Sheet1!D5')` and `sheet1.getRanges('D5')` are the same coord and must read
+ * back the same way (`D5`). Normalizing here, at the one seam where the anchor is known, is what
+ * keeps every downstream renderer on the simple rule: a scope that survived is a scope worth
+ * printing.
+ *
+ * ANCHORLESS collections (`WorkbookRanges`) do not come through here — they have no anchor to be
+ * redundant with, and stay fully qualified.
+ * @internal
+ */
+export declare function normalizeScope<T extends IRange.Coords>(coords: T, anchor: ISheet): 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[];
+/** @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;
+/**
+ * Implementation of date/number/currency parsing
+ *
+ * @param reuseCellModifiers If this is provided it is expected to be pre-initialized with empty values.
+ -We could to move to a more robust solution but I believe we have all of the accounting rules that Excel has
+ -https://github.com/BrightspaceUI/intl - https://github.com/openexchangerates/accounting.js, https://github.com/dinerojs/dinero.js
+ -TODO  internationalization - https://github.com/BrightspaceUI/intl
+  * @internal
+ */
+export declare function createCellModifiersFromString(runtime: IRuntime, strValue: string, options?: ICell.ModifiersFromStringOptions, reuseCellModifiers?: ICell.Modifiers): ICell.Modifiers;
+/**
+ * Calculates the bottom inset based on accounting rules
+ * @internal
+ */
+export declare function calcAccountingBottomInset(style: IStyle): number;
+/** @internal */
+export declare function getHiddenRuns(header: ISheetHeader): RunCoords[];
+/**
+ * Merges an array of rangeStateIntersections into a single RangeStateIntersection.
+ *
+ * @internal
+ */
+export declare function mergeRangeStateIntersections(ranges: readonly ITypes.RangeCoordValue<RangeState.Intersection>[]): RangeState.Intersection;
+/**
+ * @internal
+ */
+export declare function cellStateIteratorTo2DArray(iteratorCallback: (options: CellState.IteratorOptions) => Iterator<ICellRange.Entry, ICellRange.Entry, IRange.CellCoords>, bounds: IRange.Coords, options?: ICellRange.GetValuesOptions, asCells?: boolean, asInteropValues?: boolean): (ICell | InteropScalar)[][];
+export declare function isEqualSheetRanges(a?: IRange.FixableCoords, b?: IRange.FixableCoords): boolean;
+/**
+ * Check if two ranges arrays are equal
+ * @param a First Range Array.
+ * @param b Second Range Array.
+ */
+export declare function isEqualSheetRangesArrays(a?: readonly IRange.FixableCoords[], b?: readonly IRange.FixableCoords[]): boolean;
+/**
+ * Check if two coords are equal.
+ * @param a First CellCoords
+ * @param b Second CellCoords
+ */
+export declare function isEqualSheetCells(a: IRange.FixableCellCoords | null, b: IRange.FixableCellCoords | null): boolean;
+export declare function sanitizeSheetCoords(rangeOrCoords: IRange.FixableCoords | IRange.FixableCellCoords): IRange.FixableCoords;
+/** Copies fixed values to dest values. */
+export declare function copyFixedRangeCoords(dest: IRange.FixableCoords, source: IRange.FixableCoords): void;
+/** adjust the FixedRangeCoords. */
+export declare function adjustFixedRangeCoords(source: Readonly<IRange.FixableCoords>, options: ICellRange.GetFixedOptions | boolean): Readonly<IRange.FixableCoords>;
+export declare class CellStateIteratorContext {
+    private _c;
+    private _v;
+    private _t;
+    private _r;
+    private _p;
+    private _n;
+    context: ICell.IteratorContext;
+    setState: (entry: CellState.Entry) => Scalar;
+    clear: () => void;
+    constructor(strings: IStringCollection, iteratorOptions: CellState.IteratorOptions, options: SheetCellOptions);
+}
+export interface FillAmounts {
+    direction: IRange.Direction;
+    amount: number;
+}
+/**
+ * Returns the direction and amount for fill.
+ *
+ * @remarks
+ * The destination must share 3 edges with the template and move exactly one edge:
+ * outward (extend, positive amount) or inward (shrink, negative amount). The returned
+ * direction is the edge that moved — a retracted bottom edge is `Down` with a negative amount.
+ */
+export declare function getFillDirectionAmount(template: IRange.Coords, destination: IRange.Coords): FillAmounts;
+/**
+ * Quick and dirty merge of two objects.
+ * @remarks optionsB has higher priority.
+ */
+export declare function mergeOptions(optionsA: any, optionsB: any): any;
+/**
+ * Returns a regEx. Either a regular regex or a Excel like wildcard regex.
+ */
+export declare function builtFindReg(findText: string, matchCase: boolean, useRegex: boolean): RegExp;
+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;
+/**
+ * Search all spatials expanding the range until no immediate bounding rectangles.
+ */
+export declare function findSurroundingRegion(range: IRange.Coords, spatials: ISpatialQuery[], maxIterations?: number): IRange.Coords | null;
+export declare function findExtendedRegion(direction: IRange.Direction, coords: IRange.CellCoords, asRange: IRange.Coords, // TODO - merge this into coords?
+searchSpatials: (range: IRange.Coords) => IRange.Coords[], entireCoords: IRange.Coords): IRange.Coords;
+/**
+ * Internal representation of a Scalar.
+ */
+export type TypeAndValue = [v: Scalar, t: string];
+/**
+ * Converts TypeAndValue to a value appropriate for storing in the grid.
+ *
+ * @param values an array of Scalar.
+ * @returns An `IListLike` of values
+ */
+export declare function toListLike(values: Scalar[], strings: IStringCollection, internal?: TypeAndValue[] | null): IListLike<Scalar>;
+/**
+ * Wraps each value in a ContentfulSpatialValue
+ */
+export declare function tuplesToContentfulEntries(gridTuple: Tuple.GridTuple<Scalar>, isColumn: boolean): ISpatialMap.Entry<ContentfulSpatialValue>[];
+/**
+ * Expands ranges to include merges.
+ */
+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[];
+export declare function createDirectStyleUpdater(styles: IStyleCollection): ((prev: SheetDirectStyle, update: IStyle.Update, keepNulls?: boolean) => SheetDirectStyle);
+export declare function clearAdjacentBorderEdge(asInsert: SheetDirectStyle, rangeStyle: IRange.Coords, directStylesByRangeWrite: ISpatialMap<SheetDirectStyle>, styleUpdater: (prev: SheetDirectStyle, update: IStyle.Update) => SheetDirectStyle, entireCoords: IRange.Coords): void;
+/**
+ * SHEET-STYLE-SPLIT: re-derive the border/fill/content maps over `region` from the authoritative
+ * merged `directStyleWrite` blob.
+ *
+ * Used by write paths that resolve a *whole* style and so can't partition the update up front
+ * (function-form style updates, hyperlink styling). Clears `region` in each feature map, then
+ * re-inserts the split of every blob entry covering it. Entries are re-inserted at their **full
+ * coords — never clipped** — so border range-relativity is preserved; the parts of an entry that
+ * straddle outside the cleared region overwrite equal values (the blob == the maps everywhere the
+ * op didn't touch) and coalesce.
+ *
+ * `region` should be grown by one cell on each side of the changed range when borders may be
+ * involved, so the adjacent border-edge clears the blob applies *outside* the change are captured.
+ * @internal
+ */
+export declare function rederiveFeatureMaps(directStyleWrite: ISpatialMap<SheetDirectStyle>, borderWrite: ISpatialMap<SheetDirectStyle>, fillWrite: ISpatialMap<SheetDirectStyle>, contentWrite: ISpatialMap<SheetDirectStyle>, region: IRange.Coords): void;
+/**
+ * Split text values in a single-column IRange into multiple columns.
+ * Uses sparseBuilder — never materializes a full 2D array.
+ * Non-string and empty cells produce no output row.
+ * Null tokens within a split are left empty (not pushed to the builder).
+ */
+export declare function textToColumns(range: IRange, options?: ICellRange.TextToColumnsOptions): IRange;
+/**
+ * The duplicate rows within a range. Rows are 0-based and range-relative.
+ */
+export interface DuplicateRows {
+    /** Runs of duplicate rows in ascending order. Never overlapping (they are deletable as-is). */
+    runs: RowRun[];
+    /** The total number of duplicate rows (the sum of the runs). */
+    count: number;
+    /** `true` when no row in the range had a value. */
+    isEmpty: boolean;
+}
+/**
+ * An inclusive run of rows.
+ */
+export interface RowRun {
+    rowStart: number;
+    rowEnd: number;
+}
+/**
+ * Finds the duplicate rows within an IRange in a single streaming pass.
+ * IRange coords are always 0-based, so rowIndex/colIndex are range-relative.
+ *
+ * Design: accumulate one row at a time; when rowIndex changes (or after the last entry), key the
+ * row — the first row with a given key is unique, every later one is a duplicate. The only
+ * persistent bookkeeping is `seenKeys`.
+ *
+ * A row with no values is still a row: Excel counts blanks, so the first blank row is unique and
+ * the rest are duplicates of it. The exception is the blank rows *after* the last row with a value
+ * — they are not data, they are just how far the selection was dragged — so the scan ends at the
+ * last row with a value rather than collapsing the empty tail of a selection.
+ *
+ * @param range             Source range (0-based coords from getValuesRange).
+ * @param hasHeader         When true, row 0 is never removed and is excluded from the comparison.
+ * @param compareColIndices 0-based column indices to key on (undefined = all columns).
+ */
+export declare function findDuplicateRows(range: IRange, hasHeader: boolean, compareColIndices: number[] | undefined): DuplicateRows;
+//# sourceMappingURL=_SheetUtils.d.ts.map

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

@@ -0,0 +1,92 @@
+import { IRange } from '@sheetxl/primitives';
+import { ICell, ICellHeader } from '../../cell';
+export declare namespace IHTMLParser {
+    type GetCSSStyles = (node: Element | null) => Record<string, string>;
+    interface TableParser {
+        /**
+         * This will be called after a valid table type has been found.
+         */
+        onStart?: (styles: Map<string, any>) => void;
+        onTableStart?: (getStyles: GetCSSStyles, element: HTMLTableElement) => void;
+        onColumn?: (colIndex: number, colSpan: number, getStyles: GetCSSStyles, element: HTMLTableColElement | null) => void;
+        onRowStart?: (rowIndex: number, rowSpan: number, getStyles: GetCSSStyles, element: HTMLTableRowElement | null) => void;
+        onCell: (coords: IRange.Coords, plainText: string, htmlText: string | null, getStyles: GetCSSStyles, element: Element | null) => void;
+        onRowDow?: (rowIndex: number, rowSpan: number, getStyles: GetCSSStyles, element: HTMLTableRowElement | null) => void;
+        onTableDone?: (getStyles: GetCSSStyles, element: HTMLTableElement) => void;
+        /**
+         * Called when a table isn't found.
+         */
+        onNoTable?: (strValue: string, getCSSStyles: GetCSSStyles, element: Element) => void;
+        onDone?: () => void;
+    }
+    interface Writer {
+        /**
+         * inline indicates if is it stored as a style attribute. By default it is stored in the style tag
+         */
+        addStyle: (name: string, value: string) => void;
+        /**
+         * inline indicates if is it stored as a style attribute. By default it is stored in the style tag
+         */
+        addAttribute: (name: string, value: any) => void;
+        /**
+         * Adds style to a global style.
+         * If the style is already declared this will add to the style.
+         * Note - Some implementations may not support this and instead force everything to be inlined.
+         */
+        addSharedStyle: (name: string, styles: Record<string, string>) => void;
+    }
+    /**
+     * Extends the write to support arbitrary values.
+     * Both setPlainText and setHTMLText will be call so that rich values
+     * and simple fallback values can be provided.
+     */
+    interface ValueWriter extends Writer {
+        /**
+         * Set the value as plain text.
+         */
+        setPlainText: (value: string) => void;
+        /**
+         * Set the value as HTML text.
+         *
+         * @remarks
+         * If this is not set the the plain text is used. Generally the HTML text will be formatted.
+         */
+        setHTMLText: (value: string) => void;
+    }
+    /**
+     * Used for writing tables.
+     */
+    interface TableWriter {
+        /**
+         * Called when the writer starts.
+         */
+        onStart?: () => void;
+        /**
+         * Called when a table is visited.
+         */
+        onTable?: (writer: Writer, coords: IRange.Coords) => void;
+        /**
+         * Called when a row is visited.
+         *
+         * @remarks
+         * HTML rows don't span.
+         */
+        onRow?: (header: ICellHeader, index: number, span: number, writer: Writer) => void;
+        /**
+         * If returns a number representing the colspan.
+         */
+        onColumn?: (header: ICellHeader, index: number, span: number, writer: Writer) => void;
+        /**
+         * If returns `false` this cell will not be added.
+         *
+         * @remarks
+         * Useful for spanning.
+         */
+        onCell: (cell: ICell, coords: ICell.Coords, writer: ValueWriter) => void | false;
+        /**
+         * Called when the write is finished to allow for any post processing.
+         */
+        onDone?: () => void;
+    }
+}
+//# sourceMappingURL=IHTMLParser.d.ts.map

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

@@ -0,0 +1,55 @@
+import { IRange, IRuntime } from '@sheetxl/primitives';
+import { ReferenceableClipboard, EditMode } from '@sheetxl/utils';
+import { ICellRange } from '../../cellRange';
+import { IStyleCollection } from '../../style';
+import { ISheet } from '../ISheet';
+/**
+ * Implements {@link ReferenceableClipboard.ReferenceItem} by delegating to {@link ICellRange.ISnapshot}.
+ */
+export declare class RangeClipboardItem implements ReferenceableClipboard.ReferenceItem<ICellRange.ISnapshot> {
+    protected _snapshot: ICellRange.ISnapshot;
+    constructor(snapshot: ICellRange.ISnapshot);
+    getItemType(): string;
+    getItem(): ICellRange.ISnapshot;
+    editMode(): EditMode;
+    isCut(): boolean;
+    getName(): string;
+    toText(): Promise<string> | string;
+    toHtml(): Promise<string> | string;
+    toImage(): Promise<Blob> | Blob;
+    get isClipboardItem(): true;
+}
+/**
+ * Implements {@link ReferenceableClipboard.ReferenceItem} by creating a {@link ICellRange.ISnapshot} from
+ * {@link ReferenceableClipboard.NativeItems}.
+ *
+ * @remarks
+ * **IMPORTANT** Before this api can be used the async {@link parse} methods needs to be called and resolved.
+ * @see
+ * {@link parse}
+ */
+export declare class ExternalRangeClipboardItem implements ReferenceableClipboard.ReferenceItem<ICellRange.ISnapshot> {
+    protected _runtime: IRuntime;
+    protected _native: ReferenceableClipboard.NativeItems;
+    protected _topLeft: IRange.CellCoords;
+    protected _markOptions: ICellRange.CopyOptions;
+    protected _styles: IStyleCollection | undefined;
+    protected _snapshot: ICellRange.ISnapshot<ISheet> | undefined;
+    /** undefined = not yet parsed; null = parsed but empty */
+    protected _parsed: Partial<ICellRange.ISnapshot<ISheet>> | 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>;
+    /**
+     * Required to be called before getItem().
+     * @remarks
+     * This is required because the ExternalClipboard lazy loads the parsing library.
+     */
+    parse(): Promise<boolean>;
+    get isClipboardItem(): true;
+}
+//# sourceMappingURL=RangeClipboardItems.d.ts.map

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

@@ -0,0 +1,29 @@
+import { IRange, IRuntime } from '@sheetxl/primitives';
+import { ICell } from '../../cell';
+import { IStyleCollection } from '../../style';
+import { ISheet } from '../ISheet';
+import { IHTMLParser } from './IHTMLParser';
+/**
+ * Reads html and writes to an ISheet.
+ */
+export declare class SheetHTMLTableParser implements IHTMLParser.TableParser {
+    private _sheet;
+    private _styles;
+    private _topLeft;
+    private _builder;
+    private _mergedReading;
+    private _colsReading;
+    private _rowsReading;
+    constructor(runtime: IRuntime, topLeft: IRange.CellCoords, styles: IStyleCollection, description?: string);
+    /**
+     * Requires both to be non-null
+     */
+    applyCSSStyle(modifiers: ICell.Modifiers, cssStylesOriginal: Record<string, string>): void;
+    onCell(coords: IRange.Coords, plainValue: string, htmlValue: string | null, getStyles: IHTMLParser.GetCSSStyles, element: Element | null): void;
+    onNoTable(strValue: string, getStyles: IHTMLParser.GetCSSStyles, element: Element): void;
+    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;
+}
+//# sourceMappingURL=SheetHTMLTableParser.d.ts.map

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

@@ -0,0 +1,46 @@
+import { IRange } from '@sheetxl/primitives';
+import { ICell, ICellHeader } from '../../cell';
+import { ISheet } from '../ISheet';
+import { IHTMLParser } from './IHTMLParser';
+/**
+ * Writes `ISheet` to html.
+ */
+export declare class SheetHTMLTableWriter implements IHTMLParser.TableWriter {
+    private _sheet;
+    private _visitedStyles;
+    private _lastStyleClassId;
+    private _wroteTD;
+    private _normalStyle;
+    /**
+     * The width/height can be embedded into each cell. We default this to value
+     */
+    private _includeSizeInCell;
+    /** Write what formula view shows — see {@link SheetHTMLTableWriter.Options.showFormulas}. */
+    private _textOptions;
+    constructor(sheet: ISheet, options?: SheetHTMLTableWriter.Options);
+    private _createCSSStyle;
+    private _createCSSNormalStyle;
+    onCell(cell: ICell, coords: IRange.CellCoords, valueWriter: IHTMLParser.ValueWriter): void | false;
+    onRow(header: ICellHeader, index: number, span: number, writer: IHTMLParser.Writer): void;
+    onColumn(header: ICellHeader, index: number, span: number, writer: IHTMLParser.Writer): void;
+}
+export declare namespace SheetHTMLTableWriter {
+    interface Options {
+        /**
+         * Embed each cell's column width / row height as attributes on the `td` itself.
+         *
+         * @defaultValue false
+         */
+        includeSizeInCell?: boolean;
+        /**
+         * Write what **formula view** shows — `=` + formula text for a formula cell, the raw
+         * (unformatted) value for everything else, and blank for a cell spilled INTO.
+         *
+         * @defaultValue false
+         *
+         * @see {@link ICell.GetTextOptions.showFormulas} for the exact rules.
+         */
+        showFormulas?: boolean;
+    }
+}
+//# sourceMappingURL=SheetHTMLTableWriter.d.ts.map

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

@@ -0,0 +1,10 @@
+import { ICellRange } from '../../cellRange';
+import { IHTMLParser } from './IHTMLParser';
+export declare function sheetToHTMLAndText(writer: IHTMLParser.TableWriter, range: ICellRange): [string, string];
+export declare function pasteTextOrCSV(value: any, delimiter?: string): Promise<string[][]>;
+/**
+ * Parses clipboard for a table. It tried to force regardless of html.
+ * An html table parser must be passed.
+ */
+export declare function parseAsTable(htmlDoc: Document | null | undefined, plainTextArray: string[][] | null, parser: IHTMLParser.TableParser): boolean;
+//# sourceMappingURL=_ClipboardUtils.d.ts.map

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

@@ -0,0 +1,2 @@
+export * from './RangeClipboardItems';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,6 @@
+export * from './clipboard';
+export * from './ICellContainerOptions';
+export * from './ISheet';
+export * from './ISheetCollection';
+export * from './Sheet';
+//# sourceMappingURL=index.d.ts.map

package/types/src/sheet/listener/RangesListener.d.ts

@@ -0,0 +1,32 @@
+import { ICellRanges, ICellRange } from '../../cellRange';
+import { IListener } from '../../listener';
+import { ISpatialMap } from '../../collections/ISpatialMap';
+import { RangesListenerEntry } from './RangesListenerEntry';
+import { ISheet } from '../../sheet';
+interface NotifierOptions {
+    getTransactionId: () => string;
+    timeStamp?: number;
+    trigger?: string;
+}
+export declare class RangesListener {
+    coords: ICellRanges.Coords | null;
+    isRanges: boolean;
+    spatialsIds: string[];
+    uuid: string;
+    sheet: ISheet;
+    generation: number;
+    handler: ICellRange.Listener;
+    handlerW: WeakRef<ICellRange.Listener>;
+    removeListener: IListener.Remove;
+    options: ICellRange.ListenerOptions;
+    constructor(uuid: string, spatialsIds: string[], coords: ICellRanges.Coords | null, isRanges: boolean, sheet: ISheet, generation: number, handler: ICellRange.Listener, handlerW: WeakRef<ICellRange.Listener>, removeListener: IListener.Remove, options: ICellRange.ListenerOptions);
+    delete(): void;
+    createRangeEvent(options: NotifierOptions, customError?: string): ICellRange.Event;
+    notify(options: NotifierOptions, customError?: string): void;
+    processRemove(entry: ISpatialMap.Entry<RangesListenerEntry>): RangesListener;
+    processShift(entry: ISpatialMap.Entry<RangesListenerEntry>): RangesListener;
+    processSplit(_entries: ISpatialMap.Entry<RangesListenerEntry>[]): RangesListener | undefined;
+    processMerge(_entries: ISpatialMap.Entry<RangesListenerEntry>[]): RangesListener | undefined;
+}
+export {};
+//# sourceMappingURL=RangesListener.d.ts.map

package/types/src/sheet/listener/RangesListenerEntry.d.ts

@@ -0,0 +1,19 @@
+import { IRange } from '@sheetxl/primitives';
+import { ISpatialMap } from '../../collections/ISpatialMap';
+export declare class RangesListenerEntry implements ISpatialMap.IUpdatableValue<RangesListenerEntry> {
+    uuid: string;
+    groupId: string;
+    noShift: boolean;
+    constructor(groupId: string, uuid: string, noShift: boolean);
+    /** {@inheritDoc ISpatialMap.IUpdatableValue.onRemove} */
+    onRemove(options: IRange.Coords): void;
+    /** {@inheritDoc ISpatialMap.IUpdatableValue.getShifted} */
+    getShifted(options: ISpatialMap.ShiftDetails<this>): ISpatialMap.Entry<this> | undefined;
+    /** {@inheritDoc ISpatialMap.IUpdatableValue.getSplit} */
+    getSplit(_coords: [IRange.Coords, IRange.Coords], _axis: IRange.Axis): [this, this] | undefined;
+    /** {@inheritDoc ISpatialMap.IUpdatableValue.copyTo} */
+    copyTo(_destination: IRange.Coords, _options?: ISpatialMap.CopyOptions): ISpatialMap.Entry<this> | undefined;
+    /** {@inheritDoc ISpatialMap.IUpdatableValue.canTile} */
+    canTile(_destination: IRange.Coords, _options?: ISpatialMap.CopyOptions): boolean;
+}
+//# sourceMappingURL=RangesListenerEntry.d.ts.map

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

@@ -0,0 +1,3 @@
+export * from './RangesListenerEntry';
+export * from './RangesListener';
+//# sourceMappingURL=index.d.ts.map

package/types/src/sheet/spatial/MergeEntry.d.ts

@@ -0,0 +1,17 @@
+import { Scalar, IRange } from '@sheetxl/primitives';
+/**
+ * MergeEntry
+ */
+export declare class MergeEntry {
+    private _c;
+    private _tvTl;
+    constructor(coords: IRange.Coords, tvTl?: (coords: IRange.Coords) => Scalar | null);
+    /**
+     * The cell value at the top left.
+     * We track this because we want a quick way to access
+     * the coords state during overflow scenarios.
+     */
+    tvTl(): Scalar | null;
+    getCoords(): IRange.Coords;
+}
+//# sourceMappingURL=MergeEntry.d.ts.map

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

@@ -0,0 +1,2 @@
+export * from './MergeEntry';
+//# sourceMappingURL=index.d.ts.map