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

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

@@ -1,140 +1,200 @@
-import { IListLike } from './IList';
+import { IList, IListLike } from './IList';
 /**
- * Stores mixed value types in an ArrayBuffer or a SharedArrayBuffer.
+ * An immutable run of mixed scalar values in ONE `ArrayBuffer` or `SharedArrayBuffer`.
  *
- * Enable more efficient storage of mixed types in a single array.
- * Supports fully shared between threads without copy.
+ * Numbers, booleans and blanks are stored natively; strings and errors as `int32` ids that a
+ * {@link MixedTypedArrayList.Codec} resolves. The buffer is the whole list: another thread that
+ * receives its {@link MixedTypedArrayList.Handle} (and has the same codec) reads it without a copy.
  *
  * @remarks
- * * Implements {@link IListLike} — expects all values to be immutable.
- * * Supports numbers (int32, float32, float64, bigint), booleans, null, and undefined natively.
- * * Strings and errors are stored as ordinal references; provide `getCoercedValue` to resolve them.
- * * Custom types (128–255) are supported via `getCoercedKey` / `getCoercedValue` callbacks.
+ * Layout, for `length` values at `width` 4 or 8 bytes:
+ * - the value slots, `length * width` bytes, absent when no value needs one (booleans and blanks);
+ * - then one type byte per value, absent when every value is of one type.
+ *
+ * The width is 4 when no value is a non-int32 number, else 8. At width 8 an `int32` (int, string
+ * id, error code) lives in the low word of its slot and a double in the whole slot.
+ *
+ * Implements {@link IListLike}: `at` answers `undefined` past the end and `null` for a blank.
+ * Slicing and concatenation are `ImmutableList`'s, logically, over any list.
+ *
+ * Create with {@link MixedTypedArrayList.fromArray}; rebuild from a handle with the constructor.
  */
-export declare class MixedTypedArrayList<T = any> implements IListLike<T> {
-    private _l;
-    private _at;
-    private _dt;
-    private _a32;
-    private _a64;
-    private _cv;
-    private _vt;
-    private _vi32;
-    private _vi64;
-    private _vf32;
-    private _vf64;
-    constructor(options: MixTypedArrayListConstructorOptions);
+export declare class MixedTypedArrayList<T = any> implements IList<T> {
+    private readonly _l;
+    private readonly _w;
+    /** `0` at width 4, `1` at width 8: the int32 index is `(i << _sh) + _lo`. */
+    private readonly _sh;
+    /** The word an int32 occupies at width 8: `0` little-endian, `1` big-endian. */
+    private readonly _lo;
+    private readonly _dt;
+    private readonly _m;
+    private readonly _buf;
+    private readonly _vi;
+    private readonly _vf;
+    private readonly _t;
+    private readonly _c;
+    private _v;
     /**
-     * Returns constructor options that can used to recreate the MixedTypedArrayList.
+     * Rebuilds a list over a handle's buffer, without copying it.
+     *
+     * @param handle The handle, from {@link getHandle} or from another thread.
+     * @param codec Required when the run holds strings or errors.
      */
-    getConstructorOptions(): MixTypedArrayListConstructorOptions;
+    constructor(handle: MixedTypedArrayList.Handle, codec?: MixedTypedArrayList.Codec<T> | null);
     /** {@inheritDoc IListLike.at} */
     at(index: number): T | undefined;
-    /** {@inheritDoc IListLike.toArray} */
-    toArray(maxLength: number): T[];
+    /**
+     * The type code of the value at `index` (see {@link MixedTypedArrayList.Type}), or `-1` past
+     * the end.
+     */
+    typeAt(index: number): number;
+    /**
+     * The types the list may hold, as a bitmask of `1 << Type`. It never omits a type a value
+     * holds, so a missing bit answers "none here" without a scan; a set bit may name a type no
+     * value holds.
+     */
+    get typeMask(): number;
+    /**
+     * The typed arrays under the list, for a loop over a stretch of it without `at`: the type of
+     * index `i` is `types[i]` (or `defaultType` when `types` is `null`), an int32, string id or
+     * error code is `ints[(i << intShift) + intOffset]`, and a double is `doubles[i]`.
+     */
+    getViews(): MixedTypedArrayList.Views;
     /** {@inheritDoc IListLike.length} */
     get length(): number;
-    get [Symbol.toStringTag](): string;
-    toString(): string;
-    protected static _createArrayBuffer(length: number): ArrayBufferLike;
+    /** {@inheritDoc IList.isIList} */
+    get isIList(): true;
     /**
-     * Creates a MixedTypedArrayList from an array.
-     *
-     * @param array The array to convert.
-     * @param getCoercedKey A function that returns a key for a complex value.
-     * @param getCoercedValue A function that returns a coerced value for a given key.
-     * @param getCoerceType A function that returns a type for a given value.
-     * @returns A MixedTypedArrayList.
-     *
+     * {@inheritDoc IListLike.fromArray}
      * @remarks
-     * - `getCoercedKey` will generally be a map id.
+     * A plain list: this is asked for small merges (`ImmutableList.concat`), below the length a
+     * typed list is worth.
      */
-    static fromArray<T = any>(array: T[], getCoercedKey?: (type: number, value: T) => number, getCoercedValue?: (type: number, key: number) => T, getCoerceType?: (value: T) => number, threshold64?: number): MixedTypedArrayList;
-}
-export interface MixTypedArrayListConstructorOptions<T = any> {
+    fromArray(arr: T[]): IListLike<T>;
+    /** The bytes a value occupies: `4` or `8`. */
+    get width(): number;
+    /** Whether the buffer is a `SharedArrayBuffer`. */
+    get isShared(): boolean;
     /**
-     * The length of the array.
+     * The values as an `Array`.
+     * @param maxLength At most this many, from the start.
      */
-    length: number;
+    toArray(maxLength?: number): T[];
     /**
-      * The array used for storing types.
-      *
-      * @remarks
-      * This is the default type if types is not provided.
-      */
-    type: number;
-    /**
-     * The array used for storing types.
-     *
-     * @remarks
-     * This must be a Uint8Array. This or type must be provided.
+     * What rebuilds this list: the buffer and its shape. Post it to another thread (a shared
+     * buffer is shared; an `ArrayBuffer` is copied, or transferred and then unusable here).
      */
-    types?: ArrayBufferLike | null;
+    getHandle(): MixedTypedArrayList.Handle;
+    get [Symbol.toStringTag](): string;
+    toString(): string;
     /**
-     * Stores 32bit values.
-     *
-     * @remarks
-     * If this is not provided then all values stored in values64.
-     * * Must be 32bit aligned
+     * Whether `SharedArrayBuffer` can be allocated here: it exists, and the page is cross-origin
+     * isolated where that applies.
      */
-    values32?: ArrayBufferLike | null;
+    static get isSharedSupported(): boolean;
     /**
-     * Stores 64 bit overflow values or all 64 bit values if is64Bit is `true`.
+     * Encodes an array of values.
      *
-     * @remarks
-     * * This behave different depending on if the values32 is provided.
-     * * * values32 is provided - This stores 32 bit values and 32 bit references to 64 bit values.
-     * * * values32 is NOT provided - Then this is used for all values and values32 is not used.
-     * * Must be 64bit aligned
+     * @param values The values, or a scratch holding them first (`options.length`). `undefined` is
+     * stored as a blank. Never retained.
+     * @param codec Resolves strings and errors. Without one a run holding either cannot be encoded.
+     * @param options Allocation and the hints a writer that saw the values already has.
+     * @returns The list, or `null` when a value cannot be encoded: a rich value, or a string or
+     * error with no codec. Nothing is allocated in that case.
      */
-    values64?: ArrayBufferLike | null;
+    static fromArray<T = any>(values: readonly T[], codec?: MixedTypedArrayList.Codec<T> | null, options?: MixedTypedArrayList.FromArrayOptions): MixedTypedArrayList<T> | null;
     /**
+     * Encodes values that are already codes and numbers: a load path that has string ids and
+     * error codes in hand writes them without resolving a single string.
      *
-     * Returns a value for a given type The default implementation auto coerces ints/floats/boolean and 'null'.
-     *
-     * @param type An 8bit number. Will always be between 0 and 255.
-     * @param key The key as either a 32bit or 64bit integer.
-     * @returns Returns a coerced value.
-     *
-     * @remarks
-     * This is used for returning string lookup, error lookup, or custom.
+     * @param codes The {@link MixedTypedArrayList.Type} of each value. Never `Rich`.
+     * @param values Per position: the int, double, string id or error code; ignored for a boolean
+     * or a blank.
+     * @param codec For reads; the run is written as given.
      */
-    getCoercedValue?: ((type: number, key: number) => T) | null;
+    static fromEncoded<T = any>(codes: Uint8Array, values: ArrayLike<number>, codec?: MixedTypedArrayList.Codec<T> | null, options?: MixedTypedArrayList.FromArrayOptions): MixedTypedArrayList<T>;
 }
 /**
- * Defines the list of Known valid type codes for a MixedTypedArrayList.
- *
- * @remarks
- * MixedTypedArray stores a type using an Uint8Array. The first
- * 127 bits are reserved for known types. The last 128-255 are
- * reserved for custom types.
- *
+ * {@inheritDoc MixedTypedArrayList}
  * @see
- * {@link MixTypedArrayListConstructorOptions.coerceType}
- */
-export declare const KnownType: {
-    readonly Null: 0;
-    readonly Boolean: 1;
-    readonly Integer: 2;
-    readonly Float: 3;
-    readonly Integer64: 4;
-    readonly Float64: 5;
-    readonly String: 6;
-    readonly Error: 7;
-    readonly PosInfinity: 16;
-    readonly NegInfinity: 17;
-    readonly NaN: 18;
-    readonly MaxSafeInteger: 19;
-    readonly MinSafeInteger: 20;
-    readonly Undefined: 15;
-    readonly Unknown: 127;
-};
-/**
- * Return a 8 bit int that represents the type to using in the type array.
+ * ### **Class**
  *
- * @param value The value of the type. Only the type is used
- * @param custom If provided this will be called if the type is not well known. Must return a value between '128' and '255'.
- * @returns a number representing a type between '0' and '255'.
+ * {@link MixedTypedArrayList}
  */
-export declare function getBuiltinCoerceType<T = any>(value: T, custom?: (T: any) => number): number;
+export declare namespace MixedTypedArrayList {
+    /**
+     * The type codes, one byte each. A boolean or a blank is its code alone and has no value slot.
+     */
+    const Type: {
+        readonly Blank: 0;
+        readonly False: 1;
+        readonly True: 2;
+        readonly Int32: 3;
+        readonly Float64: 4;
+        readonly String: 5;
+        readonly Error: 6;
+        /** Reserved. A run holding a rich value is not encoded. */
+        readonly Rich: 7;
+    };
+    /**
+     * Resolves what the buffer stores as an id: strings and errors, both ways.
+     */
+    interface Codec<T = any> {
+        /** Whether an object value is an error (anything else is rich, and not encoded). */
+        isError(value: object): boolean;
+        /** The id a string is stored as; the same string must give the same id. */
+        encodeString(value: string): number;
+        /** The string for an id. */
+        decodeString(id: number): T;
+        /** The code an error is stored as. */
+        encodeError(value: T): number;
+        /** The error for a code. */
+        decodeError(code: number): T;
+    }
+    /**
+     * What rebuilds a list over its buffer. Passes through `structuredClone` and `postMessage`.
+     */
+    interface Handle {
+        buffer: ArrayBufferLike;
+        length: number;
+        width: 4 | 8;
+        /** The one type, when `hasTypes` is `false`. */
+        defaultType: number;
+        /** {@inheritDoc MixedTypedArrayList.typeMask} */
+        typeMask: number;
+        /** Whether a type byte per value follows the slots. */
+        hasTypes: boolean;
+        /** Whether any value has a slot; `false` for a run of booleans and blanks. */
+        hasSlots: boolean;
+    }
+    /** {@inheritDoc MixedTypedArrayList.getViews} */
+    interface Views {
+        readonly types: Uint8Array | null;
+        readonly defaultType: number;
+        readonly ints: Int32Array;
+        readonly doubles: Float64Array | null;
+        readonly intShift: 0 | 1;
+        readonly intOffset: 0 | 1;
+    }
+    interface FromArrayOptions {
+        /**
+         * Allocate a `SharedArrayBuffer` when supported.
+         * @defaultValue false
+         */
+        shared?: boolean;
+        /**
+         * Encode only the first `length` values: the input is a writer's reused scratch, longer than
+         * the run.
+         * @defaultValue the input's length
+         */
+        length?: number;
+        /**
+         * The types the values hold, as a bitmask of `1 << Type`, from a writer that saw them. Not
+         * validated: a wrong mask encodes wrong values, and it is kept as
+         * {@link MixedTypedArrayList.typeMask}. A single-type mask skips the type bytes and the
+         * classification; any mask sets the width before allocating.
+         */
+        seen?: number;
+    }
+}
 //# sourceMappingURL=MixedTypedArrayList.d.ts.map

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

@@ -4,26 +4,43 @@ import { RangeCoordValue, RangeCoords } from '@sheetxl/utils';
  *
  * Use this to answer "which items overlap this region?" without a linear scan.
  *
- * @typeParam T must extend `RangeCoordValue` (carries `colStart/rowStart/colEnd/rowEnd`)
+ * {@link clone} is O(1): the copies share every node, and a change to either copies only the
+ * nodes on its path from the root, so each keeps the version it had.
+ *
+ * Items are returned by identity: {@link search} and {@link all} return the objects that were
+ * inserted. An item's coordinates must not change while it is in the tree.
  *
- * @TODO See RTree-REDESIGN.md for planned structural changes.
+ * @typeParam T must extend `RangeCoordValue` (carries `colStart/rowStart/colEnd/rowEnd`)
  */
 export declare class RTree<T extends RangeCoordValue> {
     protected _maxEntries: number;
     protected _minEntries: number;
-    protected _data: Node<T>;
+    /** The nodes and items, shared with every clone of this tree. */
+    protected _arena: Arena<T>;
+    /** The id carried by the arena nodes this tree may write in place. */
+    protected _owner: number;
+    protected _root: number;
+    protected _size: number;
+    /** The nodes reachable from the root; the arena holding many more is what triggers a compaction. */
+    protected _nodes: number;
+    protected _colStart: number;
+    protected _rowStart: number;
+    protected _colEnd: number;
+    protected _rowEnd: number;
     /**
      * Constructs an `RTree`, a high-performance 2D spatial index for points and
      * rectangles. Based on an optimized __R-tree__ data structure with
      * __bulk-insertion__ support.
      *
      * @param maxEntries An optional argument to RTree defines the maximum
-     *                   number of entries in a tree node. `9` (used by default)
-     *                   is a reasonable choice for most applications. Higher
-     *                   value means faster insertion and slower search, and
-     *                   vice versa.
+     *                   number of entries in a tree node, from `4` to `12`. `9`
+     *                   (used by default) is a reasonable choice for most
+     *                   applications. Higher value means faster insertion and
+     *                   slower search, and vice versa.
      */
     constructor(maxEntries?: number);
+    /** Returns the number of items in the tree. */
+    size(): number;
     /** Returns all items contained in the tree. */
     all(result?: T[]): T[];
     /**
@@ -64,6 +81,10 @@ export declare class RTree<T extends RangeCoordValue> {
      * Removes all items.
      */
     clear(): RTree<T>;
+    /**
+     * Returns a copy that shares this tree's nodes; changing either leaves the other as it was.
+     */
+    clone(): this;
     /**
      * Inserts an item. To insert many items at once, use `load()`.
      */
@@ -73,39 +94,98 @@ export declare class RTree<T extends RangeCoordValue> {
      * Pass `equals` to compare by value instead.
      */
     remove(item: T, equals?: (a: T, b: T) => boolean): RTree<T>;
-    protected _all(node: Node<T>, result: T[]): T[];
-    protected _build(items: T[], left: number, right: number, height: number): Node<T>;
-    protected _chooseSubtree(coords: RangeCoordValue, node: Node<T>, level: number, path: Node<T>[]): Node<T>;
-    protected _insert(node: Node<T>, level: number): void;
-    protected _split(insertPath: Node<T>[], level: number): void;
-    protected _splitRoot(node: Node<T>, newNode: Node<T>): void;
-    protected _chooseSplitIndex(node: Node<T>, min: number, length: number): number;
-    protected _chooseSplitAxis(node: Node<T>, min: number, length: number): void;
-    protected _allDistMargin(node: Node<T>, min: number, length: number, compare: (a: Node<T>, b: Node<T>) => number): number;
+    protected _rootIntersects(coords: RangeCoords): boolean;
+    protected _setRootBox(): void;
+    /** The arena, created on the first write: an empty tree holds none. */
+    protected _writableArena(): Arena<T>;
+    /** `node` if this tree owns it, otherwise an owned copy of it that nothing points at yet. */
+    protected _ownDetached(node: number): number;
+    /**
+     * `node` if this tree owns it, otherwise an owned copy put in its place: in slot `slot` of
+     * `parent` (which this tree must own), or as the root when `parent` is `NONE`.
+     */
+    protected _own(node: number, parent: number, slot: number): number;
+    protected _all(node: number, result: T[]): T[];
+    /**
+     * Builds a subtree over `order[left..right]` (indices into `itemBoxes`, four numbers an item,
+     * and into the payload from `first`) and returns its node, leaving its box in `_bx0`..`_bx3` and
+     * its height in `_BuiltHeight`. The same overlap-minimizing tiling as rbush's bulk load.
+     */
+    protected _build(order: Int32Array, itemBoxes: Float64Array, first: number, left: number, right: number, height: number): number;
+    /**
+     * Adds `child` (an item's payload index when `height` is `0`, otherwise a node of height
+     * `height - 1`) to a node of height `height`, copying the shared nodes on the way down and
+     * splitting full ones on the way up.
+     */
+    protected _insertEntry(child: number, colStart: number, rowStart: number, colEnd: number, rowEnd: number, height: number): void;
+    /**
+     * Adds an entry to an owned node; when the node is full, splits it and returns the new sibling
+     * (for the caller to add to the parent), otherwise `NONE`.
+     */
+    protected _addEntry(node: number, child: number, colStart: number, rowStart: number, colEnd: number, rowEnd: number): number;
+    /** Grows the tree by a level: a new root over the old root and `sibling`, of the same height. */
+    protected _splitRoot(sibling: number): void;
+    /**
+     * Finds `item` under `node` as `remove` does: a leaf's items are compared, a node whose children
+     * are leaves has every leaf searched, a deeper node only the children that contain the item. On
+     * a match, records the path in `_RemovePath`/`_RemoveSlots` and the item's slot in `_RemoveSlot`.
+     *
+     * The path is written only on the way back up, after the last call to `equals`, so an `equals`
+     * that uses another tree cannot disturb it.
+     */
+    protected _findItem(node: number, depth: number, item: T, equals: ((a: T, b: T) => boolean) | undefined): boolean;
+    /**
+     * Removes every item under `node` that `isRemove` matches, visiting only children that intersect
+     * the given box. A node is written only when something under it is removed, and copied first
+     * when it is shared, so a subtree with nothing to remove is never copied.
+     *
+     * @returns `UNCHANGED`, `EMPTY` (the node should be removed from its parent), or the node to keep
+     * in its place (a copy when it was shared).
+     */
+    protected _removeWithin(node: number, isRemove: (item: T) => boolean, colStart: number, rowStart: number, colEnd: number, rowEnd: number): number;
+    /**
+     * Compacts when the arena holds much more than this tree reaches: the nodes and items other
+     * versions still use, and the ones no version does. A compaction copies the tree's nodes and
+     * items, so it waits until the unreached nodes outnumber both, which keeps its cost per write
+     * constant.
+     */
+    protected _maybeCompact(): void;
+    /**
+     * Moves this tree into an arena of its own, copying what it reaches depth first so a parent is
+     * next to its first child. Other versions keep the old arena, which is freed with the last of them.
+     */
+    protected _detach(): void;
+    /**
+     * Throws if the tree is inconsistent: heights, boxes, counts, the size and the node count. For
+     * tests.
+     */
+    protected _validate(): void;
 }
 /**
- * Internal R-tree node.
+ * The storage of a tree and every clone of it.
  *
- * - Leaf nodes: `children === null`, `range` is a cast of the user item (`T`), `height === 0`.
- * - Internal nodes: `children` is an array of child nodes, `range` is the mutable aggregate
- *   bounding box of all descendants, `height >= 1`.
+ * Nodes are appended and never freed or rewritten once another version can reach them: a tree
+ * writes a node in place only when the node carries the tree's owner id, and {@link RTree.clone}
+ * gives both trees new ids, so no existing node carries either. That is what makes a clone free
+ * and an old version immutable. The garbage collects as a whole: a tree that reaches much less
+ * than its arena holds moves to a new one ({@link RTree._detach}), and the old one goes when the
+ * last version using it does.
  */
-interface Node<T> {
-    range: RangeCoordValue<T>;
-    children: Node<T>[] | null;
-    height: number;
+declare class Arena<T> {
+    boxes: Float64Array;
+    meta: Int32Array;
+    /** The number of nodes allocated. */
+    top: number;
+    /** Item by payload index. */
+    payload: T[];
+    /** The last owner id handed out. */
+    owners: number;
+    constructor(capacity: number);
+    /** A new node carrying `owner`; may replace `boxes` and `meta`, so neither is held across it. */
+    alloc(owner: number): number;
+    /** Grows the arrays to hold at least `capacity` nodes; replaces `boxes` and `meta` when it does. */
+    reserve(capacity: number): void;
+    nextOwner(): number;
 }
-/**
- * Rearranges items so that all items in the [left, k] are the smallest.
- * The k-th element will have the (k - left + 1)-th smallest value in [left, right].
- *
- * @template T
- * @param arr the array to partially sort (in place)
- * @param k middle index for partial sorting (as defined above)
- * @param left left index of the range to sort
- * @param right right index
- * @param compare compare function
- */
-export declare function quickSelect<T>(arr: T[], k: number, left?: number | undefined, right?: number | undefined, compare?: ((a: T, b: T) => number) | undefined): void;
 export {};
 //# sourceMappingURL=RTree.d.ts.map

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

@@ -13,8 +13,15 @@ export declare class RepeatingList<T> implements IList<T> {
     toArray(maxLength?: number): T[];
     /** {@inheritDoc IListLike.length} */
     get length(): number;
+    /**
+     * The length of the repeated list — the period. A period of `1` is one value however long, so a
+     * consumer that would otherwise scan every position can read `at(0)` once.
+     */
+    getPeriod(): number;
     get [Symbol.toStringTag](): string;
     /** {@inheritDoc IList.isIList} */
     get isIList(): true;
+    /** For runtime type checking. */
+    get isIRepeatingList(): true;
 }
 //# sourceMappingURL=RepeatingList.d.ts.map

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

@@ -0,0 +1,50 @@
+import { Direction, RangeAxis, CellCoords, RangeCoords } from '@sheetxl/utils';
+import { Tuple } from './Tuple';
+import { IGrid } from './IGrid';
+import { ISparseGrid } from './ISparseGrid';
+/**
+ * A grid holding one value at (0,0) — the backing of a direct-scalar box.
+ *
+ * @remarks
+ * Every scalar handed to a range-typed parameter (`IF`'s branches, `AND`/`OR`/`MIN`/`MAX`
+ * arguments) is boxed into a 1x1 range, and most boxes are only ever read back out again by the
+ * consumer (`getValueAt(0, 0)`), so building a full {@link SparseGrid} — a major list, a minor
+ * list, a run — for each was the single largest allocation in a recalculation: ~100K per pass on
+ * a 28K-formula template. This answers the reads a box gets natively and holds no structure at
+ * all; the first call that needs one (iteration, a write, a copy) materializes a real
+ * `SparseGrid` and delegates to it from then on, so every other behavior is exactly the grid's.
+ */
+export declare class ScalarGrid<T = any> implements ISparseGrid<T> {
+    private _value;
+    private _axis;
+    private _maxCoords;
+    /** The real grid, once anything beyond a point read was asked for. */
+    private _grid;
+    constructor(value: T, options?: ScalarGrid.ConstructorOptions);
+    private _materialize;
+    getValueAt(row: number, column: number): T;
+    getCount(): number;
+    getCoords(): RangeCoords | null;
+    getAxis(): RangeAxis;
+    getMaxCoords(): RangeCoords | null;
+    clone(cloneKey?: any): this;
+    cloneEmpty(cloneKey?: any): this;
+    setValues(values: Tuple.GridTuple<T>): this;
+    setValueAt(row: number, column: number, value: T): void;
+    getValues(coords?: RangeCoords): Tuple.Region<T> | null;
+    entries(options?: IGrid.IteratorOptions): IGrid.EntryIterator<T>;
+    keys(options?: IGrid.IteratorOptions): IGrid.KeyIterator;
+    values(options?: IGrid.IteratorOptions): IGrid.ValueIterator;
+    getRuns(options?: ISparseGrid.RunIteratorOptions): ISparseGrid.RunIterableIterator<T>;
+    delete(coords: RangeCoords | null): boolean;
+    clear(): void;
+    shift(coords: RangeCoords, direction: Direction): boolean;
+    copyTo(destination: IGrid, topLeft: CellCoords, from: RangeCoords): void;
+}
+export declare namespace ScalarGrid {
+    interface ConstructorOptions {
+        axis?: RangeAxis;
+        maxCoords?: RangeCoords;
+    }
+}
+//# sourceMappingURL=ScalarGrid.d.ts.map

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

@@ -3,6 +3,7 @@ import { Tuple } from './Tuple';
 import { IReadableList } from './IReadableList';
 import { IGrid } from './IGrid';
 import { ISparseGrid } from './ISparseGrid';
+import { IListLike } from './IList';
 /**
  * Implementation of {@link IGrid} that uses a ISparseList of ISparseList.
  */
@@ -39,7 +40,7 @@ export declare class SparseGrid<T = any> implements ISparseGrid<T> {
     /** {@inheritDoc IGrid.setValues} */
     setValues(values: Tuple.GridTuple<T>): this;
     /** {@inheritDoc IGrid.getValues} */
-    getValues(coords?: RangeCoords): Tuple.BoundedTuples<T> | null;
+    getValues(coords?: RangeCoords): Tuple.Region<T> | null;
     private _updateCountAndCoords;
     /** {@inheritDoc IGrid.clear} */
     clear(): void;
@@ -89,11 +90,13 @@ export declare namespace SparseGrid {
          */
         axis?: RangeAxis;
         /**
-         * Hook to allow for custom storing of contiguous values.
+         * Makes the list a run of contiguous values is stored as: the one place a value enters this
+         * grid, so a grid with a policy about what it holds applies it here, once per run.
          *
-         * @param values The values to wrap in a List.
+         * @param values The run's values: a writer's array, or a list another grid already held.
+         * @defaultValue wraps the values as they are
          */
-        createRun?: (values: T[]) => IReadableList<T>;
+        createRun?: (values: IListLike<T> | T[]) => IReadableList<T>;
     }
 }
 //# sourceMappingURL=SparseGrid.d.ts.map