@sheetxl/sdk 0.7.27 → 0.7.28-beta.2

package/types/src/collections/SortedMap.d.ts

@@ -0,0 +1,396 @@
+import { ISortedMap } from './ISortedMap';
+/**
+ * {@inheritDoc ISortedMap}
+ *
+ * B+ tree implementation. Nodes split at `maxNodeSize` (default 32). Cloning is O(1)
+ * via copy-on-write structural sharing — only the path to a mutated node is copied.
+ * Supports `freeze()` to make the map immutable at runtime.
+ *
+ * @remarks
+ * - TODO: Test performance of preallocating values array at max size
+ * - TODO: Add fast initialization when a sorted array is provided to constructor
+ *
+ * Adapted from {@link https://github.com/qwertie/btree-typescript | btree-typescript} (MIT).
+ */
+export declare class SortedMap<K = any, V = any> implements ISortedMap<K, V> {
+    protected _root: BNode<K, V>;
+    _size: number;
+    _maxNodeSize: number;
+    /**
+     * Provides a total order over keys (and a strict partial order over the type K)
+     * @returns A negative value if a < b, 0 if a === b and a positive value if a > b
+     */
+    _compare: (a: K, b: K) => number;
+    /**
+     * Initializes an SortedMap.
+     *
+     * @param compare Custom function to compare pairs of elements in the map.
+     *        If not specified, defaultComparator will be used which is valid as long as K extends DefaultComparable.
+     * @param entries A set of key-value pairs to initialize the map
+     * @param maxNodeSize Branching factor (maximum items or children per node)
+     *        Must be in range 4..256. If undefined or <4 then 32 is used; if >256 then 256.
+     */
+    constructor(entries?: [K, V][], compare?: (a: K, b: K) => number, maxNodeSize?: number);
+    /** {@inheritDoc ISortedMap.size} */
+    get size(): number;
+    /**
+     * Returns the number of key-value pairs in the map.
+     *
+     * @remarks
+     * This is the same as size.
+     */
+    get length(): number;
+    /**
+     * Returns true iff the map contains no key-value pairs.
+     */
+    isEmpty(): boolean;
+    /** {@inheritDoc ISortedMap.clear} */
+    clear(): void;
+    /**
+     * {@inheritDoc ISortedMap.forEach}
+     * @remarks
+     * For ES6 Map compatibility, argument order to the callback is `(value, key)` — the
+     * reverse of `forEachPair`. Use `forEachPair` if you want key first.
+     */
+    forEach<R = number>(callback: (v: V, k: K, map: ISortedMap<K, V>) => {
+        break?: R;
+    } | void, thisArg?: any): R | number;
+    /**
+     * Runs a function for each key-value pair, in order from smallest to
+     * largest key. The callback can return {break: R} (where R is any value
+     * except undefined) to stop immediately and return R from forEachPair.
+     *
+     * @param onFound A function that is called for each key-value pair. This
+     *        function can return {break: R} to stop early with result R.
+     *        The reason that you must return {break: R} instead of simply R
+     *        itself is for consistency with editRange(), which allows
+     *        multiple actions, not just breaking.
+     * @param initialCounter This is the value of the third argument of
+     *        `onFound` the first time it is called. The counter increases
+     *        by one each time `onFound` is called. Default value: 0
+     * @returns The number of pairs sent to the callback (plus initialCounter,
+     *        if you provided one). If the callback returned {break: R} then
+     *        the R value is returned instead.
+     */
+    forEachPair<R = number>(callback: (k: K, v: V, counter: number) => {
+        break?: R;
+    } | void, initialCounter?: number): R | number;
+    /**
+     * {@inheritDoc ISortedMap.get}
+     * @remarks
+     * Also accepts an optional `defaultValue` returned when the key is not found.
+     * Complexity: O(log size).
+     */
+    get(key: K, defaultValue?: V): V | undefined;
+    /**
+     * {@inheritDoc ISortedMap.set}
+     * @remarks
+     * When overwriting an existing key, the key itself is also updated — no visible
+     * effect unless the new key has data that does not affect sort order.
+     * Complexity: O(log size).
+     */
+    set(key: K, value: V, overwrite?: boolean | ISortedMap.SetPairCallback<K, V>): boolean;
+    /**
+     * {@inheritDoc ISortedMap.has}
+     * @remarks
+     * Use `get()` when you also need the value — it is faster. Use `has()` only when you
+     * need to distinguish "undefined value" from "key not present".
+     * Complexity: O(log size).
+     */
+    has(key: K): boolean;
+    /**
+     * {@inheritDoc ISortedMap.delete}
+     * @remarks
+     * Complexity: O(log size).
+     */
+    delete(key: K): boolean;
+    /** {@inheritDoc ISortedMap.filter} */
+    filter(callback: (k: K, v: V, counter: number) => boolean, returnThisIfUnchanged?: boolean): ISortedMap<K, V>;
+    /** {@inheritDoc ISortedMap.mapValues} */
+    mapValues<R>(callback: (v: V, k: K, counter: number) => R): ISortedMap<K, R>;
+    /**
+     * {@inheritDoc ISortedMap.reduce}
+     * @remarks
+     * The same `currentPair` array is reused on every callback invocation — do not
+     * hold a reference to it between iterations.
+     */
+    reduce<R>(callback: (previous: R, currentPair: [K, V], counter: number) => R, initialValue: R): R;
+    reduce<R>(callback: (previous: R | undefined, currentPair: [K, V], counter: number) => R): R | undefined;
+    /**
+     * {@inheritDoc ISortedMap.entries}
+     * @remarks
+     * If `firstKey` does not exist, iteration starts at the next higher key.
+     * Pass `reusedResults` to reuse the iterator result object on each step and avoid
+     * per-iteration allocations — do not hold a reference to the result between calls.
+     */
+    entries(lowestKey?: K, reusedResults?: IteratorResult<[K, V], any>): IterableIterator<[K, V]>;
+    /** {@inheritDoc ISortedMap.entriesReversed} */
+    entriesReversed(highestKey?: K, reusedResults?: IteratorResult<[K, V], any>, skipHighest?: boolean): IterableIterator<[K, V]>;
+    private findPath;
+    /**
+     * Computes the differences between `this` and `other`.
+     * For efficiency, the diff is returned via invocations of supplied handlers.
+     * The computation is optimized for the case in which the two trees have large amounts
+     * of shared data (obtained by calling the `clone` or `with` APIs) and will avoid
+     * any iteration of shared state.
+     * The handlers can cause computation to early exit by returning {break: R}.
+     * Neither of the collections should be changed during the comparison process (in your callbacks), as this method assumes they will not be mutated.
+     *
+     * @param other The map to compute a diff against.
+     * @param onlyThis Callback invoked for all keys only present in `this`.
+     * @param onlyOther Callback invoked for all keys only present in `other`.
+     * @param different Callback invoked for all keys with differing values.
+     */
+    diffAgainst<R>(other: SortedMap<K, V>, onlyThis?: (k: K, v: V) => {
+        break?: R;
+    } | void, onlyOther?: (k: K, v: V) => {
+        break?: R;
+    } | void, different?: (k: K, vThis: V, vOther: V) => {
+        break?: R;
+    } | void): R | undefined;
+    private static finishCursorWalk;
+    private static stepToEnd;
+    private static makeDiffCursor;
+    /**
+     * Advances the cursor to the next step in the walk of its map.
+     * Cursors are walked backwards in sort order, as this allows them to leverage maxKey() in order to be compared in O(1).
+     *
+     * @param cursor The cursor to step
+     * @param stepToNode If true, the cursor will be advanced to the next node (skipping values)
+     * @returns `true` if the step was completed and false if the step would have caused the cursor to move beyond the end of the map.
+     */
+    private static step;
+    /**
+     * Compares the two cursors. Returns a value indicating which cursor is ahead in a walk.
+     * Note that cursors are advanced in reverse sorting order.
+     */
+    private static compare;
+    /** {@inheritDoc ISortedMap.keys} */
+    keys(firstKey?: K, reusedResults?: IteratorResult<[K, V], any>): IterableIterator<K>;
+    /** {@inheritDoc ISortedMap.values} */
+    values(firstKey?: K, reusedResults?: IteratorResult<[K, V], any>): IterableIterator<V>;
+    /** Returns the maximum number of children/values before nodes will split. */
+    getMaxNodeSize(): number;
+    /** {@inheritDoc ISortedMap.minKey} */
+    minKey(): K | undefined;
+    /** {@inheritDoc ISortedMap.maxKey} */
+    maxKey(): K | undefined;
+    /**
+     * {@inheritDoc ISortedMap.clone}
+     * @remarks
+     * Marks the root node as shared (copy-on-write). Both copies remain editable;
+     * only the path to a mutated node is cloned when a write occurs.
+     */
+    clone(): SortedMap<K, V>;
+    /**
+     * Performs a greedy clone, immediately duplicating any nodes that are
+     * not currently marked as shared, in order to avoid marking any
+     * additional nodes as shared.
+     *
+     * @param force Clone all nodes, even shared ones.
+     */
+    greedyClone(force?: boolean): SortedMap<K, V>;
+    /**
+     * Gets an array filled with the contents of the map, sorted by key.
+     */
+    toArray(maxLength?: number): [K, V][];
+    /**
+     * Gets an array of all keys, sorted.
+     */
+    keysArray(): K[];
+    /**
+     * Gets an array of all values, sorted by key.
+     */
+    valuesArray(): V[];
+    /**
+     * Gets a string representing the map's data based on toArray().
+     */
+    toString(): string;
+    /**
+     * Stores a key-value pair only if the key doesn't already exist in the map.
+     *
+     * @returns `true` if a new key was added
+     */
+    setIfNotPresent(key: K, value: V): boolean;
+    /**
+     * {@inheritDoc ISortedMap.nextHigherPair}
+     * @remarks
+     * Pass `reusedPair` to reuse the result array across calls and avoid per-call allocations.
+     */
+    nextHigherPair(key: K | undefined, reusedPair?: [K, V]): [K, V] | undefined;
+    /** {@inheritDoc ISortedMap.nextHigherKey} */
+    nextHigherKey(key: K | undefined, reusedPair?: [K, V]): K | undefined;
+    /**
+     * {@inheritDoc ISortedMap.nextLowerPair}
+     * @remarks
+     * Pass `reusedPair` to reuse the result array across calls and avoid per-call allocations.
+     */
+    nextLowerPair(key: K | undefined, reusedPair?: [K, V]): [K, V] | undefined;
+    /** {@inheritDoc ISortedMap.nextLowerKey} */
+    nextLowerKey(key: K | undefined, reusedPair?: [K, V]): K | undefined;
+    /** {@inheritDoc ISortedMap.getPairOrNextLower} */
+    getPairOrNextLower(key: K, reusedPair?: [K, V]): [K, V] | undefined;
+    /** {@inheritDoc ISortedMap.getPairOrNextHigher} */
+    getPairOrNextHigher(key: K, reusedPair?: [K, V]): [K, V] | undefined;
+    /**
+     * Edits the value associated with a key in the map, if it already exists.
+     *
+     * @returns `true` if the key existed, false if not.
+     */
+    changeIfPresent(key: K, value: V): boolean;
+    /**
+     * {@inheritDoc ISortedMap.getRange}
+     * @remarks
+     * Complexity: O(result.length + log size).
+     */
+    getRange(low: K, high: K, includeHigh?: boolean, maxLength?: number): [K, V][];
+    /**
+     * {@inheritDoc ISortedMap.setPairs}
+     * @remarks
+     * Duplicate keys in `pairs`: later entries overwrite earlier ones.
+     * If `overwrite` is a `SetPairCallback`, it is called on both inserts and updates.
+     * Complexity: O(pairs.length × log(size + pairs.length)).
+     */
+    setPairs(pairs: [K, V][], overwrite?: boolean | ISortedMap.SetPairCallback<K, V>): number;
+    /**
+     * {@inheritDoc ISortedMap.forRange}
+     * @remarks
+     * The callback must not insert or remove items — doing so may cause incorrect results.
+     * Returns `R` if the callback returned `{break: R}` to stop early.
+     * Complexity: O(items scanned + log size).
+     */
+    forRange<R = number>(low: K, high: K, includeHigh: boolean, onFound?: ISortedMap.EditRangeCallback<K, V, R>, initialCounter?: number): R | number;
+    /**
+     * {@inheritDoc ISortedMap.editRange}
+     * @remarks
+     * Any shared nodes (from a prior `clone()`) are copied before the callback is called —
+     * O(n) extra work proportional to the shared data scanned.
+     */
+    editRange<R = V>(low: K, high: K, includeHigh: boolean, onFound: ISortedMap.EditRangeCallback<K, V, R>, initialCounter?: number): R | number;
+    /**
+     * Same as `editRange` except that the callback is called for all pairs.
+     */
+    editAll<R = V>(onFound: ISortedMap.EditRangeCallback<K, V, R>, initialCounter?: number): R | number;
+    /**
+     * {@inheritDoc ISortedMap.deleteRange}
+     * @remarks
+     * Complexity: O(log size + items deleted).
+     */
+    deleteRange(low: K, high: K, includeHigh: boolean): number;
+    /** {@inheritDoc ISortedMap.deleteKeys} */
+    deleteKeys(keys: K[]): number;
+    /**
+     * Gets the height of the tree: the number of internal nodes between the
+     * SortedMap object and its leaf nodes (zero if there are no internal nodes).
+    */
+    getHeight(): number;
+    /**
+     * Makes the object read-only to ensure it is not accidentally modified.
+     * Freezing does not have to be permanent; unfreeze() reverses the effect.
+     * This is accomplished by replacing mutator functions with a function
+     * that throws an Error. Compared to using a property (e.g. this.isFrozen)
+     * this implementation gives better performance in non-frozen SortedMaps.
+     */
+    freeze(): void;
+    /** Ensures mutations are allowed, reversing the effect of freeze(). */
+    unfreeze(): void;
+    /**
+     * Returns true if the map appears to be frozen.
+     */
+    isFrozen(): boolean;
+    /**
+     * Scans the tree for signs of serious bugs (e.g. this.size doesn't match
+     * number of elements, internal nodes not caching max element properly...)
+     * Computational complexity: O(number of nodes), i.e. O(size). This method
+     * skips the most expensive test - whether all keys are sorted - but it
+     * does check that maxKey() of the children of internal nodes are sorted.
+    */
+    checkValid(): void;
+}
+/** Leaf node / base class. **************************************************/
+declare class BNode<K, V> {
+    keys: K[];
+    values: V[];
+    isShared: true | undefined;
+    readonly isLeaf: boolean;
+    constructor(isLeaf: boolean, keys?: K[], values?: V[]);
+    maxKey(): K;
+    indexOf(key: K, failXor: number, cmp: (a: K, b: K) => number): index;
+    minKey(): K | undefined;
+    minPair(reusedPair?: [K, V]): [K, V] | undefined;
+    maxPair(reusedPair?: [K, V]): [K, V] | undefined;
+    clone(): BNode<K, V>;
+    greedyClone(force?: boolean): BNode<K, V>;
+    get(key: K, defaultValue: V | undefined, map: SortedMap<K, V>): V | undefined;
+    getPairOrNextLower(key: K, compare: (a: K, b: K) => number, inclusive: boolean, reusedPair?: [K, V]): [K, V] | undefined;
+    getPairOrNextHigher(key: K, compare: (a: K, b: K) => number, inclusive: boolean, reusedPair?: [K, V]): [K, V] | undefined;
+    checkValid(depth: number, map: SortedMap<K, V>, baseIndex: number): number;
+    set(key: K, value: V, overwrite: boolean | ISortedMap.SetPairCallback<K, V> | undefined, map: SortedMap<K, V>): boolean | BNode<K, V>;
+    reifyValues(): V[];
+    insertInLeaf(i: index, key: K, value: V, overwrite: boolean | ISortedMap.SetPairCallback<K, V> | undefined, map: SortedMap<K, V>): boolean;
+    takeFromRight(rhs: BNode<K, V>): void;
+    takeFromLeft(lhs: BNode<K, V>): void;
+    splitOffRightSide(): BNode<K, V>;
+    forRange<R>(low: K, high: K, includeHigh: boolean | undefined, editMode: boolean, map: SortedMap<K, V>, count: number, onFound?: ISortedMap.EditRangeCallback<K, V, R>): ISortedMap.EditRangeResult<V, R> | number;
+    /**
+     * Adds entire contents of right-hand sibling (rhs is left unchanged)
+     */
+    mergeSibling(rhs: BNode<K, V>, _: number): void;
+}
+type index = number;
+/**
+ * {@inheritDoc SortedMap}
+ * @see
+ * ### **Interface**
+ *
+ * {@link SortedMap}
+ */
+export declare namespace SortedMap {
+    const DeleteValue: Readonly<{
+        delete: true;
+    }>;
+    const Break: Readonly<{
+        break: true;
+    }>;
+    const DeleteRange: () => Readonly<{
+        delete: true;
+    }>;
+    /**
+     * Types that SortedMap supports by default
+     */
+    type DefaultComparable = number | string | Date | boolean | null | undefined | (number | string)[] | {
+        valueOf: () => number | string | Date | boolean | null | undefined | (number | string)[];
+    };
+    /** A SortedMap frozen in the empty state. */
+    const EmptySortedMap: SortedMap<any, any>;
+    /**
+     * Compares DefaultComparables to form a strict partial ordering.
+     *
+     * Handles +/-0 and NaN like Map: NaN is equal to NaN, and -0 is equal to +0.
+     *
+     * Arrays are compared using '<' and '>', which may cause unexpected equality:
+     * for example [1] will be considered equal to ['1'].
+     *
+     * Two objects with equal valueOf compare the same, but compare unequal to
+     * primitives that have the same value.
+     */
+    function defaultComparator(a: DefaultComparable, b: DefaultComparable): number;
+    /**
+     * Compares items using the < and > operators. This function is probably slightly
+     * faster than the defaultComparator for Dates and strings, but has not been benchmarked.
+     * Unlike defaultComparator, this comparator doesn't support mixed types correctly,
+     * i.e. use it with `SortedMap<string>` or `SortedMap<number>` but not `SortedMap<string|number>`.
+     *
+     * NaN is not supported.
+     *
+     * Note: null is treated like 0 when compared with numbers or Date, but in general
+     *   null is not ordered with respect to strings (neither greater nor less), and
+     *   undefined is not ordered with other types.
+     */
+    function simpleComparator(a: string, b: string): number;
+    function simpleComparator(a: number | null, b: number | null): number;
+    function simpleComparator(a: Date | null, b: Date | null): number;
+    function simpleComparator(a: (number | string)[], b: (number | string)[]): number;
+}
+export {};
+//# sourceMappingURL=SortedMap.d.ts.map

package/types/src/collections/SparseGrid.d.ts

@@ -0,0 +1,99 @@
+import { CellCoords, Direction, RangeAxis, RangeCoords } from '@sheetxl/utils';
+import { Tuple } from './Tuple';
+import { IReadableList } from './IReadableList';
+import { IGrid } from './IGrid';
+import { ISparseGrid } from './ISparseGrid';
+/**
+ * Implementation of {@link IGrid} that uses a ISparseList of ISparseList.
+ */
+export declare class SparseGrid<T = any> implements ISparseGrid<T> {
+    private _major;
+    private _dataCoords;
+    private _count;
+    private _isColumn;
+    private _lastMajor;
+    private _lastMinorSpan;
+    private _maxCoords;
+    private _options;
+    private _optionsMinor;
+    private _isShared;
+    private _createRun;
+    constructor(options?: SparseGrid.ConstructorOptions);
+    /**
+     * Returns an IterableIterator over all the runs in the sparse grid.
+     * Each run is a contiguous list of values in the grid.
+     *
+     * @returns An iterator that yields [majorIndex, minorIndex, IReadableList] entries
+     */
+    /** {@inheritDoc ISparseGrid.getMaxCoords} */
+    getRuns(options?: ISparseGrid.RunIteratorOptions): ISparseGrid.RunIterableIterator<T>;
+    /** {@inheritDoc IGrid.getAxis} */
+    getAxis(): RangeAxis;
+    /** {@inheritDoc IGrid.entries} */
+    entries(options?: IGrid.IteratorOptions): IGrid.EntryIterator<T>;
+    /** {@inheritDoc IGrid.values} */
+    values(options?: IGrid.IteratorOptions): IGrid.ValueIterator;
+    /** {@inheritDoc IGrid.keys} */
+    keys(options?: IGrid.IteratorOptions): IGrid.KeyIterator;
+    private _updateMajorSpan;
+    /** {@inheritDoc IGrid.setValues} */
+    setValues(values: Tuple.GridTuple<T>): this;
+    /** {@inheritDoc IGrid.getValues} */
+    getValues(coords?: RangeCoords): Tuple.BoundedTuples<T> | null;
+    private _updateCountAndCoords;
+    /** {@inheritDoc IGrid.clear} */
+    clear(): void;
+    /** {@inheritDoc IGrid.delete} */
+    delete(range: RangeCoords | null): boolean;
+    /** {@inheritDoc IGrid.shift} */
+    shift(range: RangeCoords, direction: Direction): boolean;
+    /** {@inheritDoc IGrid.getCount} */
+    getCount(): number;
+    /** {@inheritDoc IGrid.getValueAt} */
+    getValueAt(row: number, column: number): T;
+    /** {@inheritDoc IGrid.setValueAt} */
+    setValueAt(row: number, column: number, value: T): void;
+    /** {@inheritDoc IGrid.copyTo} */
+    copyTo(destination: IGrid, topLeft: CellCoords, from: RangeCoords): void;
+    /** {@inheritDoc IGrid.getCoords} */
+    getCoords(): RangeCoords | null;
+    /** {@inheritDoc IGrid.clone} */
+    clone(cloneKey?: string): this;
+    /** {@inheritDoc IGrid.cloneEmpty} */
+    cloneEmpty(cloneKey?: string): this;
+    /** {@inheritDoc IGrid.getMaxCoords} */
+    getMaxCoords(): RangeCoords | null;
+    get [Symbol.toStringTag](): string;
+}
+/**
+ * {@inheritDoc SparseGrid}
+ * @see
+ * ### **Interface**
+ *
+ * {@link SparseGrid}
+ */
+export declare namespace SparseGrid {
+    /**
+     * For constructing a SparseGrid.
+     */
+    interface ConstructorOptions<T = any> {
+        /**
+         * If not specified then unlimited bounds.
+         * @defaultValue undefined
+         */
+        maxCoords?: Partial<RangeCoords>;
+        /**
+         * Determines the axis that cells are visited.
+         *
+         * @defaultValue RangeAxis.Column
+         */
+        axis?: RangeAxis;
+        /**
+         * Hook to allow for custom storing of contiguous values.
+         *
+         * @param values The values to wrap in a List.
+         */
+        createRun?: (values: T[]) => IReadableList<T>;
+    }
+}
+//# sourceMappingURL=SparseGrid.d.ts.map

package/types/src/collections/SparseList.d.ts

@@ -0,0 +1,90 @@
+import { RunCoords } from '@sheetxl/utils';
+import { IListLike } from './IList';
+import { IReadableList } from './IReadableList';
+import { ISparseList } from './ISparseList';
+/**
+ * A SparseList implemented using a SortedMap of contiguous ReadableLists/WritableLists.
+ */
+export declare class SparseList<T = any> implements ISparseList<T> {
+    private _options;
+    private _runs;
+    private _dataCoords;
+    private _count;
+    private _length;
+    private _maxCoords;
+    private _reuseRunsIterator;
+    private _reuseRunsEntry;
+    private _lastRunsRead;
+    private _lastListRead;
+    constructor(options?: SparseList.ConstructorOptions);
+    private _validateBounds;
+    /** {@inheritDoc IReadableList.entries} */
+    entries(options?: IReadableList.IteratorOptions): IReadableList.EntryIterator<T>;
+    /** {@inheritDoc ISparseList.runs} */
+    runs(options?: ISparseList.RunIteratorOptions): ISparseList.RunIterator<T>;
+    /** {@inheritDoc IReadableList.slice} */
+    slice(start: number, end?: number): ISparseList<T>;
+    /** {@inheritDoc IReadableList.concat} */
+    concat(list: IListLike<T>): ISparseList<T>;
+    /** {@inheritDoc IReadableList.toArray} */
+    toArray(maxLength?: number, includeEmpty?: boolean): T[];
+    /** {@inheritDoc IReadableList.isIReadableList} */
+    get isIReadableList(): true;
+    /** {@inheritDoc IListLike.length} */
+    get length(): number;
+    /** {@inheritDoc ISparseList.clear} */
+    getCoords(): RunCoords | null;
+    /** {@inheritDoc ISparseList.clear} */
+    clear(): void;
+    /** {@inheritDoc ISparseList.isISparseList} */
+    get isISparseList(): true;
+    /** {@inheritDoc IList.isIList} */
+    get isIList(): true;
+    private _updateCount;
+    private _update;
+    /** {@inheritDoc IWritableList.setAt} */
+    setAt(index: number, value: T): boolean;
+    /** {@inheritDoc ISparseList.setRunAt} */
+    setRunAt(index: number, list: IReadableList<T>): boolean;
+    /** {@inheritDoc IWritableList.delete} */
+    delete(start: number, amount?: number): boolean;
+    /** {@inheritDoc IWritableList.shift} */
+    shift(index: number, amount: number): boolean;
+    /** {@inheritDoc IListLike.at} */
+    at(index: number): T | undefined;
+    [Symbol.iterator](): IterableIterator<T>;
+    /** {@inheritDoc IWritableList.clone} */
+    clone(): this;
+    /** {@inheritDoc ISparseList.getMaxCoords} */
+    getMaxCoords(): RunCoords | null;
+    /** {@inheritDoc ISparseList.getCount} */
+    getCount(): number;
+    /** {@inheritDoc ISparseList.getRunsCount} */
+    getRunsCount(): number;
+    get [Symbol.toStringTag](): string;
+}
+/**
+ * {@inheritDoc SparseList}
+ * @see
+ * ### **Interface**
+ *
+ * {@link SparseList}
+ */
+export declare namespace SparseList {
+    /**
+     * For constructing a SparseList.
+     */
+    interface ConstructorOptions {
+        /**
+         * If not specified then unlimited bounds.
+         *
+         * @defaultValue undefined
+         */
+        maxCoords?: RunCoords;
+        /**
+         * @defaultValue 4
+         */
+        nodeSize?: number;
+    }
+}
+//# sourceMappingURL=SparseList.d.ts.map

package/types/src/collections/SpatialMap.d.ts

@@ -0,0 +1,102 @@
+import { Direction, RangeCoords } from '@sheetxl/utils';
+import { RTree } from './RTree';
+import { ISpatialMap } from './ISpatialMap';
+/**
+ * The default implementation for {@link ISpatialMap}
+ */
+export declare class SpatialMap<T = any> implements ISpatialMap<T> {
+    protected _shared: SharedRecord<T> | null;
+    protected _rTree: FilterRTree<T>;
+    protected _cloneKey: any;
+    protected _options: ISpatialMap.ConstructorOptions<T> | undefined;
+    protected _lastMiss: RangeCoords;
+    protected _lastSingle: RangeCoords;
+    protected _lastSingleResult: ISpatialMap.Entry<T>[] | null;
+    constructor(options?: ISpatialMap.ConstructorOptions<T>);
+    /** {@inheritDoc ISpatialMap.visitRanges} */
+    visitRanges(range: RangeCoords, visitor: ISpatialMap.Visitor<T>, sort?: Direction | null): void;
+    /** {@inheritDoc ISpatialMap.getBoundingRange} */
+    getBoundingRange(): RangeCoords;
+    /** {@inheritDoc ISpatialMap.size} */
+    size(): number;
+    /** {@inheritDoc ISpatialMap.isEmpty} */
+    isEmpty(): boolean;
+    /** {@inheritDoc ISpatialMap.search} */
+    search(range: RangeCoords, fullyContained?: boolean, sort?: boolean, results?: ISpatialMap.Entry<T>[]): ISpatialMap.Entry<T>[];
+    /** {@inheritDoc ISpatialMap.has} */
+    has(range: RangeCoords): boolean;
+    /** {@inheritDoc ISpatialMap.all} */
+    all(results?: ISpatialMap.Entry<T>[]): ISpatialMap.Entry<T>[];
+    /** {@inheritDoc ISpatialMap.shift} */
+    shift(options: ISpatialMap.ShiftOptions<T>): this;
+    /** {@inheritDoc ISpatialMap.insertNonOverlapping} */
+    insertNonOverlapping(range: ISpatialMap.Entry<T>, options?: ISpatialMap.InsertNonOverlappingOptions<T>): this;
+    /** {@inheritDoc ISpatialMap.insertGroup} */
+    insertGroup(entries: ISpatialMap.Entry<T>[], groupId?: string): this;
+    /** {@inheritDoc ISpatialMap.createCopiedEntries} */
+    createCopiedEntries(from: RangeCoords, to: RangeCoords, options?: ISpatialMap.CopyOptions, reuseInserts?: ISpatialMap.Entry<T>[], reuseRemoves?: ISpatialMap.Entry<T>[]): ISpatialMap.Updates;
+    /** {@inheritDoc ISpatialMap.remove} */
+    remove(entry: ISpatialMap.Entry<T>, equals?: (a: ISpatialMap.Entry<T>, b: ISpatialMap.Entry<T>) => boolean): this;
+    /** {@inheritDoc ISpatialMap.removeAll} */
+    removeAll(entries: ISpatialMap.Entry<T>[], equals?: (a: ISpatialMap.Entry<T>, b: ISpatialMap.Entry<T>) => boolean): this;
+    /** {@inheritDoc ISpatialMap.insert} */
+    insert(entry: ISpatialMap.Entry<T>): this;
+    /** {@inheritDoc ISpatialMap.load} */
+    load(entries: ReadonlyArray<ISpatialMap.Entry<T>>): this;
+    /** {@inheritDoc ISpatialMap.clear} */
+    clear(): this;
+    /** {@inheritDoc ISpatialMap.delete} */
+    delete(coords: RangeCoords | null): this;
+    /** {@inheritDoc ISpatialMap.clone} */
+    clone(cloneKey?: any): this;
+    /**
+     * Insert and removes nodes that contained with a group.
+     *
+     * @param groupsByGroupId Groups by the id of the group
+     * @param entriesByEntryId Amendments by the original id
+     *
+     * @remarks
+     * * This logic visits all group entries and ensures all entries are update and removed so that all group entries entries are the same instance.
+     */
+    protected _updateGroupedEntries(groupsByGroupId: Map<string, Group>, entriesByEntryId: Map<string, (ISpatialMap.Entry<T> | null)[]>): void;
+    protected _copy(source: SharedRecord<T>, entries?: ReadonlyArray<ISpatialMap.Entry<T>>): SharedRecord<T>;
+    protected _updateNodes(nodesInsert: ISpatialMap.Entry<T>[], nodesRemove?: ISpatialMap.Entry<T>[], onUpdates?: (nodesInsert: ISpatialMap.Entry<T>[], nodesRemove: ISpatialMap.Entry<T>[], map: ISpatialMap<T>) => void): void;
+    protected _mergeNodes(range: RangeCoords, fullyContained?: boolean): ISpatialMap.Entry<T>[];
+    protected _getReadTree(): FilterRTree<T>;
+    protected _ensureWritable(entries?: ReadonlyArray<ISpatialMap.Entry<T>>): void;
+    /**
+     * entries is a special performance optimization to allow a single bulk load.
+     */
+    protected _getWritableTree(entries?: ReadonlyArray<ISpatialMap.Entry<T>>): FilterRTree<T>;
+    /**
+     * Callback for any modification
+     */
+    protected _onModified(): void;
+    /**
+     * Create the clone
+     */
+    protected _createClone(options: ISpatialMap.ConstructorOptions<T> | undefined): this;
+}
+interface SharedRecord<T> {
+    refCount: number;
+    rTree: FilterRTree<T>;
+}
+interface Group<T = any> {
+    entries: InternalEntry<T>[];
+    uuid: string;
+    offset: number;
+}
+interface InternalEntry<T = any> extends ISpatialMap.Entry<T> {
+    group?: Group<T>;
+    timeStamp?: number;
+}
+/**
+ * Internal class that extends RTree to support Filters.
+ * is needed — the default passthrough in RTree works directly.
+ */
+declare class FilterRTree<T = any> extends RTree<ISpatialMap.Entry<T>> {
+    isEmpty(): boolean;
+    searchRange(range: RangeCoords, fullyContained?: boolean, results?: ISpatialMap.Entry<T>[]): ISpatialMap.Entry<T>[];
+}
+export {};
+//# sourceMappingURL=SpatialMap.d.ts.map