@sheetxl/sdk 0.7.21 → 0.7.23-beta.2

package/types/src/chart/Chart.d.ts

@@ -0,0 +1,53 @@
+import { IResource, IResourceCollection } from '../resource';
+import { IModel, AbstractModel } from '../model';
+import { IChart } from './IChart';
+interface State extends AbstractModel.State {
+    data?: any;
+}
+/**
+ * Implementation for {@link IChart}.
+ */
+export declare class Chart extends AbstractModel<State, IChart.JSON> implements IChart {
+    constructor(options: Chart.ConstructorOptions);
+    /** {@inheritDoc IModel.getType} */
+    getType(): string;
+    /** {@inheritDoc IChart.getChartTitle} */
+    getChartTitle(): string | null;
+    /** {@inheritDoc IChart.getChartTye} */
+    getChartType(): string;
+    /** {@inheritDoc Movable.Content.getDescription} */
+    getDescription(): string;
+    /** {@inheritDoc Movable.Content.toJSON} */
+    toJSON(_toResourceId?: (resource: IResource) => number | null): IChart.JSON | null;
+    /** {@inheritDoc Movable.Content.getTypeDescription} */
+    getTypeDescription(): string;
+}
+/**
+ * Interfaces for creating `Chart` items.
+ *
+ * @see
+ * ### **Interface**
+ *
+ * {@link Chart}
+ */
+export declare namespace Chart {
+    /**
+     * Options for creating a Chart.
+     */
+    interface ConstructorOptions extends IModel.ConstructorOptions<IChart.JSON> {
+        /**
+         * Returns an IResource from the resourceId or null if not found.
+         */
+        fromResourceId?: (resourceId: number) => IResource;
+        /**
+         * Useful for load/save/copying.
+         */
+        beginPersistResource: () => IResourceCollection.IPersistScope<IResource.JSON>;
+        /**
+         * Allow for the default lock aspect ratio to be overwritten.
+         */
+        defaultLockAspectRatio?: boolean;
+    }
+}
+export {};
+//# sourceMappingURL=Chart.d.ts.map

package/types/src/chart/Chart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Chart.d.ts","sourceRoot":"","sources":["../../../../src/chart/Chart.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAEvE,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,UAAU,CAAC;AACvC,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,UAAU,CAAA;AAEtC,UAAU,KAAM,SAAQ,aAAa,CAAC,KAAK;IACzC,IAAI,CAAC,EAAE,GAAG,CAAC;CACZ;AACD;;GAEG;AACH,qBAAa,KAAM,SAAQ,aAAa,CAAC,KAAK,EAAE,MAAM,CAAC,IAAI,CAAE,YAAW,MAAM;gBAIhE,OAAO,EAAE,KAAK,CAAC,kBAAkB;IAS7C,mCAAmC;IACnC,OAAO,IAAI,MAAM;IAIjB,yCAAyC;IACzC,aAAa,IAAI,MAAM,GAAG,IAAI;IAS9B,uCAAuC;IACvC,YAAY,IAAI,MAAM;IAMtB,mDAAmD;IACnD,cAAc,IAAI,MAAM;IAIxB,2CAA2C;IAC3C,MAAM,CAAC,aAAa,CAAC,EAAE,CAAC,QAAQ,EAAE,SAAS,KAAK,MAAM,GAAG,IAAI,GAAG,MAAM,CAAC,IAAI,GAAG,IAAI;IAYlF,uDAAuD;IACvD,kBAAkB,IAAI,MAAM;CAI7B;AAGD;;;;;;;GAOG;AACH,yBAAiB,KAAK,CAAC;IACrB;;OAEG;IACH,UAAiB,kBAAmB,SAAQ,MAAM,CAAC,kBAAkB,CAAC,MAAM,CAAC,IAAI,CAAC;QAChF;;WAEG;QACH,cAAc,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,SAAS,CAAC;QACnD;;WAEG;QACH,oBAAoB,EAAE,MAAM,mBAAmB,CAAC,aAAa,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QAC9E;;WAEG;QAEH,sBAAsB,CAAC,EAAE,OAAO,CAAC;KAClC;CACF"}

package/types/src/chart/IChart.d.ts

@@ -0,0 +1,42 @@
+import { IListener } from '../listener';
+import { IResource } from '../resource';
+import { IModel } from '../model';
+/**
+ * Interface for working with Charts.
+ *
+ * **PLACEHOLDER** - This is under development and not made public yet.
+ */
+export interface IChart extends IModel {
+    toJSON(toResourceId?: (resource: IResource) => number | null): IChart.JSON | null;
+    getChartTitle(): string | null;
+    getChartType(): string;
+    getDescription(): string;
+}
+/**
+ * {@inheritDoc IChart}
+ * @see
+ * ### **Interface**
+ *
+ * {@link IChart}
+ */
+export declare namespace IChart {
+    interface JSON {
+        /** Opaque source XML fragment, captured verbatim from the source file and replayed as-is on
+         * save, for whatever this chart doesn't (yet) model structurally. */
+        xml?: string;
+        /** Original `cNvPr` id from the captured source fragment, if any; used to avoid id collisions
+         * with freshly-generated ids on write. */
+        sourceId?: number;
+        /** The literal `r:id` referencing the chart part inside `xml`, rewritten to match on write —
+         * `DrawingEmitter` regenerates the drawing part's own rels, so the id `xml` was captured with
+         * is not guaranteed to still be free. */
+        chartRelId?: string;
+        /** The chart part's absolute OPC path (e.g. "xl/charts/chart1.xml"), used to re-link `chartRelId`. */
+        chartTargetPath?: string;
+    }
+    interface Events extends IModel.Events {
+    }
+    interface IListeners extends IListener.Callbacks<IChart, IChart.Events> {
+    }
+}
+//# sourceMappingURL=IChart.d.ts.map

package/types/src/chart/IChart.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IChart.d.ts","sourceRoot":"","sources":["../../../../src/chart/IChart.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,UAAU,CAAC;AAEvC;;;;GAIG;AACH,MAAM,WAAW,MAAO,SAAQ,MAAM;IAEpC,MAAM,CAAC,YAAY,CAAC,EAAE,CAAC,QAAQ,EAAE,SAAS,KAAK,MAAM,GAAG,IAAI,GAAG,MAAM,CAAC,IAAI,GAAG,IAAI,CAAC;IAElF,aAAa,IAAI,MAAM,GAAG,IAAI,CAAC;IAE/B,YAAY,IAAI,MAAM,CAAC;IAEvB,cAAc,IAAI,MAAM,CAAC;CAC1B;AAED;;;;;;GAMG;AACH,yBAAiB,MAAM,CAAC;IAEtB,UAAiB,IAAI;QACnB;6EACqE;QACrE,GAAG,CAAC,EAAE,MAAM,CAAC;QACb;kDAC0C;QAC1C,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB;;iDAEyC;QACzC,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,sGAAsG;QACtG,eAAe,CAAC,EAAE,MAAM,CAAC;KAC1B;IAGD,UAAiB,MAAO,SAAQ,MAAM,CAAC,MAAM;KAE5C;IAED,UAAiB,UAAW,SAAQ,SAAS,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC;KAAG;CAElF"}

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

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

package/types/src/chart/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/chart/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,UAAU,CAAC"}

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

@@ -0,0 +1,72 @@
+import { Direction, RangeAxis, CellCoords, RangeCoords } from '@sheetxl/utils';
+import { Tuple } from './Tuple';
+import { IGrid } from './IGrid';
+/**
+ * PLACEHOLDER
+ *
+ * Uses 2d arrays to implement an IGrid.
+ *
+ * @remarks
+ * This is not finished or even tested. We may remove it. The original goal was to allow this
+ * in leu of SparseGrid for a reference implementation but SparseGrid ended up being more performant
+ * than expected and the use-case for this in no longer clear.
+ */
+export declare class ArraysGrid<T = any> implements IGrid<T> {
+    private _options;
+    private _isColumn;
+    private _maxCoords;
+    private _values;
+    constructor(options?: ArraysGrid.ConstructorOptions);
+    /** {@inheritDoc IGrid.entries} */
+    entries(options?: IGrid.IteratorOptions): IterableIterator<IGrid.Entry<T>, IGrid.Entry<T>, CellCoords>;
+    /** {@inheritDoc IGrid.getCoords} */
+    getCoords(): RangeCoords | null;
+    /** {@inheritDoc IGrid.setValues} */
+    setValues(_values: Tuple.GridTuple): this;
+    getValues(coords?: RangeCoords): Tuple.BoundedTuples<T> | null;
+    /** {@inheritDoc IGrid.getAxis} */
+    getAxis(): RangeAxis;
+    /** {@inheritDoc IGrid.delete} */
+    delete(_range: RangeCoords): boolean;
+    /** {@inheritDoc IGrid.copyTo} */
+    copyTo(destination: IGrid, topLeft: CellCoords, from: RangeCoords): void;
+    /** {@inheritDoc IGrid.shift} */
+    shift(_range: RangeCoords, _direction: Direction): boolean;
+    /** {@inheritDoc IGrid.getValueAt} */
+    getValueAt(row: number, column: number): T;
+    /** {@inheritDoc IGrid.setValueAt} */
+    setValueAt(row: number, column: number, value: T): void;
+    /** {@inheritDoc IGrid.clone} */
+    clone(cloneKey?: any): this;
+    /** {@inheritDoc IGrid.getMaxCoords} */
+    getMaxCoords(): RangeCoords | null;
+    /** {@inheritDoc IGrid.clear} */
+    clear(): void;
+    /** {@inheritDoc IGrid.getCount} */
+    getCount(): number;
+}
+/**
+ * {@inheritDoc ArraysGrid}
+ * @see
+ * ### **Interface**
+ *
+ * {@link ArraysGrid}
+ */
+export declare namespace ArraysGrid {
+    /**
+     * For constructing an ArraysGrid.
+     */
+    interface ConstructorOptions {
+        /**
+         * If not specified then unlimited bounds.
+         * @defaultValue undefined
+         */
+        maxCoords?: RangeCoords;
+        /**
+         * Determines the axis that cells are visited.
+         * @defaultValue RangeAxis.Column
+         */
+        axis?: RangeAxis;
+    }
+}
+//# sourceMappingURL=ArraysGrid.d.ts.map

package/types/src/collections/ArraysGrid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArraysGrid.d.ts","sourceRoot":"","sources":["../../../../src/collections/ArraysGrid.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,SAAS,EAAE,SAAS,EAAE,KAAK,UAAU,EAAE,KAAK,WAAW,EAC7D,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,SAAS,CAAC;AAKrC;;;;;;;;;GASG;AACH,qBAAa,UAAU,CAAC,CAAC,GAAC,GAAG,CAAE,YAAW,KAAK,CAAC,CAAC,CAAC;IAChD,OAAO,CAAC,QAAQ,CAA4C;IAC5D,OAAO,CAAC,SAAS,CAAU;IAC3B,OAAO,CAAC,UAAU,CAA0B;IAE5C,OAAO,CAAC,OAAO,CAAQ;gBACX,OAAO,CAAC,EAAE,UAAU,CAAC,kBAAkB;IASnD,kCAAkC;IAClC,OAAO,CAAC,OAAO,CAAC,EAAE,KAAK,CAAC,eAAe,GAAG,gBAAgB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC;IAsHtG,oCAAoC;IACpC,SAAS,IAAI,WAAW,GAAG,IAAI;IAI/B,oCAAoC;IACpC,SAAS,CAAC,OAAO,EAAE,KAAK,CAAC,SAAS,GAAG,IAAI;IAKzC,SAAS,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,GAAG,IAAI;IAK9D,kCAAkC;IAClC,OAAO,IAAI,SAAS;IAIpB,iCAAiC;IACjC,MAAM,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO;IAIpC,iCAAiC;IACjC,MAAM,CAAC,WAAW,EAAE,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI;IAIxE,gCAAgC;IAChC,KAAK,CAAC,MAAM,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,GAAG,OAAO;IAK1D,qCAAqC;IACrC,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,CAAC;IAI1C,qCAAqC;IACrC,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAIvD,gCAAgC;IAChC,KAAK,CAAC,QAAQ,CAAC,EAAE,GAAG,GAAG,IAAI;IAU3B,uCAAuC;IACvC,YAAY,IAAI,WAAW,GAAG,IAAI;IAIlC,gCAAgC;IAChC,KAAK,IAAI,IAAI;IAIb,mCAAmC;IACnC,QAAQ,IAAI,MAAM;CAInB;AAED;;;;;;GAMG;AACH,yBAAiB,UAAU,CAAC;IAC1B;;OAEG;IACH,UAAiB,kBAAkB;QACjC;;;WAGG;QACH,SAAS,CAAC,EAAE,WAAW,CAAC;QACxB;;;WAGG;QACH,IAAI,CAAC,EAAE,SAAS,CAAC;KAClB;CACF"}

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

@@ -0,0 +1,67 @@
+import { IListLike } from './IList';
+/**
+ * Compact, immutable, list for storing boolean flags.
+ *
+ * @remarks
+ * `BooleanList` stores `length` boolean values using a `Uint8Array`
+ * with 8 flags per byte. It implements {@link IListLike} so it can be
+ * used anywhere a simple array-like list is expected, without exposing
+ * the full {@link IReadableList} surface.
+ *
+ * This type is intended for metadata overlays such as:
+ *
+ * - Data validation masks (valid / invalid flags per row)
+ * - Per-row or per-cell boolean annotations
+ *
+ * The list is logically immutable:
+ *
+ * - Construction packs bits once (either from a length or from a boolean array).
+ * - Methods like {@link slice} and {@link concat} always return new instances.
+ */
+export declare class BooleanList implements IListLike<boolean> {
+    /**
+     * Backing storage, 8 bits per byte.
+     */
+    private _bytes;
+    /**
+     * Number of logical bits (not number of bytes).
+     */
+    protected _length: number;
+    /**
+     * Create an empty BooleanList of the given length (all bits false).
+     *
+     * Public, but logically immutable: callers can't mutate bits directly.
+     * Construction + factories are the only "write" sites.
+     */
+    constructor(arr: readonly boolean[]);
+    /** {@inheritDoc IListLike.length} */
+    get length(): number;
+    /**
+     * IListLike.fromArray implementation.
+     * Allows this type to participate in your generic IListLike machinery.
+     */
+    fromArray(arr: boolean[]): IListLike<boolean>;
+    /** {@inheritDoc IListLike.at} */
+    at(index: number): boolean | undefined;
+    /** {@inheritDoc IListLike.toArray} */
+    toArray(): boolean[];
+    /**
+     * Create a new BooleanList representing [start, end) in bit-space.
+     *
+     * Semantics match Array.prototype.slice:
+     *  - negative indices are relative to the end,
+     *  - end is exclusive,
+     *  - result is always a new instance (no shared view).
+     *
+     * Implementation is simple bit-by-bit copy.
+     */
+    slice(start: number, end?: number): BooleanList;
+    /**
+     * Concatenate this BooleanList with another, returning a new instance.
+     * Bits from `other` are appended after this list.
+     *
+     * Implementation is bit-by-bit copy for simplicity.
+     */
+    concat(other: BooleanList): BooleanList;
+}
+//# sourceMappingURL=BooleanList.d.ts.map

package/types/src/collections/BooleanList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BooleanList.d.ts","sourceRoot":"","sources":["../../../../src/collections/BooleanList.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzC;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,WAAY,YAAW,SAAS,CAAC,OAAO,CAAC;IACpD;;OAEG;IACH,OAAO,CAAC,MAAM,CAAa;IAE3B;;OAEG;IACH,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;IAE1B;;;;;OAKG;gBACS,GAAG,EAAE,SAAS,OAAO,EAAE;IAenC,qCAAqC;IACrC,IAAI,MAAM,IAAI,MAAM,CAEnB;IACD;;;OAGG;IACH,SAAS,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,SAAS,CAAC,OAAO,CAAC;IAI/C,iCAAiC;IAC/B,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS;IAQtC,sCAAsC;IACtC,OAAO,IAAI,OAAO,EAAE;IASpB;;;;;;;;;OASG;IACH,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,WAAW;IAkC/C;;;;;OAKG;IACH,MAAM,CAAC,KAAK,EAAE,WAAW,GAAG,WAAW;CAkCxC"}

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

@@ -0,0 +1,47 @@
+import { CellCoords } from '@sheetxl/utils';
+import { IGrid } from './IGrid';
+/**
+ * Wraps an {@link IGrid} as a standard Map.
+ */
+export declare class GridMap<V> implements Map<CellCoords, V> {
+    private _grid;
+    private _options;
+    private _isColumn;
+    private _optionsValues;
+    constructor(grid: IGrid, options?: IGrid.IteratorOptions);
+    clear(): void;
+    /**
+     * Returns true if an element in the Map existed and has been removed, or false if the element does not exist.
+     */
+    delete(key: CellCoords): boolean;
+    /**
+     * Executes a provided function once per each key/value pair in the Map, in insertion order.
+     */
+    forEach(callback: (value: V, key: CellCoords, map: Map<CellCoords, V>) => void, _thisArg?: any): void;
+    /**
+     * Returns a specified element from the Map object. If the value that is associated to the provided key is an object, then you will get a reference to that object and any change made to that object will effectively modify it inside the Map.
+     * @returns Returns the element associated with the specified key. If no element is associated with the specified key, undefined is returned.
+     */
+    get(key: CellCoords): V | undefined;
+    /**
+     * Returns boolean indicating whether an element with the specified key exists or not.
+     */
+    has(key: CellCoords): boolean;
+    /**
+     * Adds a new element with a specified key and value to the Map. If an element with the same key already exists, the element will be updated.
+     */
+    set(key: CellCoords, value: V): this;
+    /**
+     * Returns the number of elements in the Map.
+     */
+    get size(): number;
+    entries(): MapIterator<IGrid.Entry<V>>;
+    /** Returns an iterable of entries in the map. */
+    [Symbol.iterator](): MapIterator<IGrid.Entry<V>>;
+    test(): MapIterator<[CellCoords, V]>;
+    [Symbol.dispose](): void;
+    keys(): MapIterator<CellCoords>;
+    values(): MapIterator<V>;
+    get [Symbol.toStringTag](): string;
+}
+//# sourceMappingURL=GridMap.d.ts.map

package/types/src/collections/GridMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GridMap.d.ts","sourceRoot":"","sources":["../../../../src/collections/GridMap.ts"],"names":[],"mappings":"AAAA,OAAO,EAC4D,KAAK,UAAU,EACjF,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,SAAS,CAAC;AAKrC;;GAEG;AACH,qBAAa,OAAO,CAAC,CAAC,CAAE,YAAW,GAAG,CAAC,UAAU,EAAE,CAAC,CAAC;IACnD,OAAO,CAAC,KAAK,CAAW;IACxB,OAAO,CAAC,QAAQ,CAAoC;IAEpD,OAAO,CAAC,SAAS,CAAkB;IAEnC,OAAO,CAAC,cAAc,CAAwB;gBAClC,IAAI,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,KAAK,CAAC,eAAe;IAiBxD,KAAK,IAAI,IAAI;IAYb;;OAEG;IACH,MAAM,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO;IAShC;;OAEG;IACH,OAAO,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,UAAU,EAAE,GAAG,EAAE,GAAG,CAAC,UAAU,EAAE,CAAC,CAAC,KAAK,IAAI,EAAE,QAAQ,CAAC,EAAE,GAAG,GAAG,IAAI;IAIrG;;;OAGG;IACH,GAAG,CAAC,GAAG,EAAE,UAAU,GAAG,CAAC,GAAG,SAAS;IAQnC;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO;IAK7B;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAepC;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CASjB;IAED,OAAO,IAAI,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAMtC,iDAAiD;IACjD,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAIhD,IAAI,IAAI,WAAW,CAAC,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC;IAGpC,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI;IAIxB,IAAI,IAAI,WAAW,CAAC,UAAU,CAAC;IAuB/B,MAAM,IAAI,WAAW,CAAC,CAAC,CAAC;IAuBxB,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,MAAM,CAEjC;CAEF"}

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

@@ -0,0 +1,15 @@
+import { IMap } from './IMap';
+/**
+ * A basic implementation of IMap using JavaScript's native Map.
+ */
+export declare class HashMap<K, V> implements IMap<K, V> {
+    private _map;
+    private _isDirty;
+    constructor(source?: Map<K, V>);
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+    delete(key: K): this;
+    has(key: K): boolean;
+    clone(): IMap<K, V>;
+}
+//# sourceMappingURL=HashMap.d.ts.map

package/types/src/collections/HashMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HashMap.d.ts","sourceRoot":"","sources":["../../../../src/collections/HashMap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC;;GAEG;AACH,qBAAa,OAAO,CAAC,CAAC,EAAE,CAAC,CAAE,YAAW,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC;IAC9C,OAAO,CAAC,IAAI,CAAY;IACxB,OAAO,CAAC,QAAQ,CAAS;gBAEb,MAAM,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC;IAI9B,GAAG,CAAC,GAAG,EAAE,CAAC;IAEV,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC;IAKpB,MAAM,CAAC,GAAG,EAAE,CAAC;IAKb,GAAG,CAAC,GAAG,EAAE,CAAC;IAEV,KAAK,IAAI,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC;CAGpB"}

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

@@ -0,0 +1,278 @@
+import { Direction, RangeAxis, CellCoords, RangeCoords } from '@sheetxl/utils';
+import { Tuple } from './Tuple';
+/**
+ * Primary interface for retrieving and setting values in a 2D space.
+ *
+ * To support infinite values IGrid uses an iterator to retrieve values.
+ *
+ * For read-only the minimum implementation required are:
+ *
+ * {@link entries} - Iterator of key/value.
+ *
+ * {@link getCoords} - The size and location of the data.
+ *
+ * For read-write the minimum addition is
+ *
+ * {@link setValues} - Set an IGrid.Tuple2D.
+ *
+ * @see `ArraysGrid` - Implementation using a 2D array. ({@link https://www.sheetxl.com | source}).
+ * @see `GridMap` - Provides a `Map<CellCoords, T>` interface for an IGrid.
+ */
+export interface IGrid<T = any> {
+    /**
+     * Sets values at specific coordinates within the grid using an array of `Tuple2D`.
+     *
+     * @param values GridTuples to update.
+     * @throws `Error` If the Tuple.GridTuple are invalid see {@link Tuple.GridTuple} or if any the provided
+     * tuples extend beyond the 'maxCoords'.
+     *
+     * @remarks
+     * * Clear values - Setting values to `undefined` or `null` are not treated special and will become
+     *   managed values. To clear use delete.
+     * * Immutability - For performance reasons all arrays and values passed in are
+     *   accessed directly (zero-copy) so these should be treated as immutable.
+     */
+    setValues(values: Tuple.GridTuple<T>): this;
+    /**
+     * Returns bounded tuples for a given range of coordinates.
+     *
+     * @param coords The range of coordinates to retrieve values from.
+     *
+     * @remarks
+     * * Results `null` if there are no values
+     * * If `coords` is not provided then all values will be retrieved.
+     */
+    getValues(coords?: RangeCoords): Tuple.BoundedTuples<T> | null;
+    /**
+     * Returns an iterator for traversing entries in the IGrid.
+     *
+     * The entries must support all IteratorOptions.
+     *
+     * @remarks
+     * Unlike map this is does not need to be an IterableIterator.
+     */
+    entries(options?: IGrid.IteratorOptions): IGrid.EntryIterator<T>;
+    /**
+     * Delete all values within a range.
+     *
+     * @param coords The range to delete.
+     *
+     * @remarks
+     * If not implemented and setRange is then setRange will called with null values.
+     */
+    delete?(coords: RangeCoords | null): boolean;
+    /**
+     * Clears all values.
+     */
+    clear?(): void;
+    /**
+     * Shift values in a given direction.
+     *
+     * @param coords The range that will shift.
+     * @param direction The direction to shift.
+     * @returns `true` if data was shifted.
+     *
+     * @remarks
+     * If this is not implemented shifting ranges will be attempted using
+     * delete and setAt (if implemented).
+     */
+    shift?(coords: RangeCoords, direction: Direction): boolean;
+    /**
+     * Copy values from another grid.
+     *
+     * @param destination The grid to copy to.
+     * @param topLeft The coordinates of the destination grid.
+     * @param from The bounds coordinates to copy from.
+     */
+    copyTo(destination: IGrid, topLeft: CellCoords, from: RangeCoords): void;
+    /**
+     * Creates a logical copy of the current values.
+     *
+     * Undo and branching works by creating 'copies' and then rolling back or commit these later.
+     *
+     * @remarks
+     * If this is not available then undo does not work for values.
+     */
+    clone?(cloneKey?: any): this;
+    /**
+     * Create a new grid but with no data.
+     *
+     * @remarks
+     * * Returns an empty grid with the same configuration as the original grid.
+     * * This is the same as clone(); clear() but more efficient.
+     */
+    cloneEmpty?(cloneKey?: any): this;
+    /**
+     * Iterate keys.
+     *
+     * @remarks
+     * This is not required unless retrieving keys is significantly less expensive than
+     * entries. There are few internal use cases that use only keys.
+     *
+     * @see
+     * {@link IGrid.entries}
+     */
+    keys?(options?: IGrid.IteratorOptions): IGrid.KeyIterator;
+    /**
+     * Iterate values.
+     *
+     * @remarks
+     * This is not required unless retrieving values is significantly less expensive than
+     * entries. there are few internal uses cases that use only values.
+     *
+     * @see
+     * {@link IGrid.entries}
+     * @param options {@link IGrid.IteratorOptions}
+     */
+    values?(options?: IGrid.IteratorOptions): IGrid.ValueIterator;
+    /**
+     * Returns the value at a specific row and column or `undefined` if not found.
+     *
+     * @param row
+     * @param column
+     *
+     * @remarks
+     * This ignores hiddens rows and columns.
+     */
+    getValueAt(row: number, column: number): T;
+    /**
+     * Sets a single value on the grid.
+     *
+     * @param row
+     * @param column
+     *
+     * @remarks
+     * Consider using a TupleBuilder. This is always less efficient than setValues.
+     */
+    setValueAt(row: number, column: number, value: T): void;
+    /**
+     * Determine major axis for storing values.
+     *
+     * This is used to indicate which axis the 2D array for values will be
+     * interpreted as well as the default axis for getValues.
+     *
+     * @remarks
+     * This value is only read once and should never change.
+     *
+     * If not implemented the client should default to `RangeAxis.Row`.
+     */
+    getAxis?(): RangeAxis;
+    /**
+     * Returns the number of values.
+     *
+     * @remarks
+     * If this is not implemented an approximation using getCoords will be assumed.
+     */
+    getCount?(): number;
+    /**
+     * Returns the bounds for all of the entries or empty if null.
+     */
+    getCoords(): RangeCoords | null;
+    /**
+     * Represents a max range or a max number.
+     *
+     * If this is `null` or `undefined` then it is assume to be unlimited in size.
+     *
+     * @remarks
+     * Coords must always be positive even if no bounds are set
+     */
+    getMaxCoords?(): RangeCoords | null;
+}
+/**
+ * {@inheritDoc IGrid}
+ * @see
+ * ### **Interface**
+ *
+ * {@link IGrid}
+ */
+export declare namespace IGrid {
+    /**
+     * Allow for iterating over a subset of values in a given direction.
+     */
+    interface IteratorOptions<T = any> {
+        /**
+         * If `null' or `undefined` then all cells will be visited.
+         *
+         * @defaultValue undefined
+         */
+        bounds?: Partial<RangeCoords>;
+        /**
+         * Determines the axis that cells are visited.
+         *
+         * @defaultValue The ICoordsMap axis.
+         */
+        axis?: RangeAxis;
+        /**
+         * Iterate in reverse order.
+         * @defaultValue false
+         */
+        reverse?: boolean;
+        /**
+         * A callback function that allows customization of the iteration process by skipping specific rows.
+         * This is a row orientated implementation of {@link IReadableList.IteratorOptions.processSkip}.
+         *
+         * @see
+         * {@link IReadableList.IteratorOptions.processSkip}
+         * {@link IGrid.IteratorOptions.processColumnSkip}
+         */
+        processRowSkip?: (index: number, reverse?: boolean) => number;
+        /**
+         * A callback function that allows customization of the iteration process by skipping specific columns.
+         * This is a row orientated implementation of {@link IReadableList.IteratorOptions.processSkip}.
+         *
+         * @see
+         * {@link IReadableList.IteratorOptions.processSkip}
+         * {@link IGrid.IteratorOptions.processRowSkip}
+         */
+        processColumnSkip?: (index: number, reverse?: boolean) => number;
+        /**
+         * This is a performance optimization.
+         * To avoid a large amount of object creation a reusable Iterator result can be provided.
+         * If set to true a global instance will be used.
+         * If multiple iterators are being used simultaneously then the client can provide
+         * their own reusable result.
+         *
+         * Additionally if the reuseResults has a CellCoords defined this will also get reused.
+         * The `globalReuseResults` is as follows
+         *
+         * `-1` is use as placeholder to ensure monomorphic types.
+         * If a simple javascript type is used for the value a typed placeholder value should be
+         * used for it as well.
+         * ```ts
+    {
+      done: false,
+      value: [
+        {
+          colIndex: -1,
+          rowIndex: -1
+        },
+        null
+      ]
+    }
+         * ```
+         * @defaultValue false
+         */
+        reuseResult?: boolean | IteratorResult<T>;
+    }
+    /**
+     * Entries iterators are arrays of fixed length 2.
+     */
+    type Entry<T = any> = [CellCoords, T];
+    /**
+     * Shorthand type.
+     */
+    type EntryIteratorResult<T = any> = IteratorResult<IGrid.Entry<T>>;
+    /**
+     * Shorthand type.
+     */
+    type EntryIterator<T = any> = IterableIterator<IGrid.Entry<T>, IGrid.Entry<T>, CellCoords>;
+    /**
+     * Shorthand type.
+     */
+    type ValueIterator<T = any> = IterableIterator<T, T, CellCoords>;
+    /**
+     * Shorthand type.
+     */
+    type KeyIterator = IterableIterator<CellCoords, CellCoords, CellCoords>;
+}
+//# sourceMappingURL=IGrid.d.ts.map

package/types/src/collections/IGrid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IGrid.d.ts","sourceRoot":"","sources":["../../../../src/collections/IGrid.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,SAAS,EAAE,KAAK,UAAU,EAAE,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAEnG,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,SAAS,CAAC;AAKrC;;;;;;;;;;;;;;;;;GAiBG;AAMH,MAAM,WAAW,KAAK,CAAC,CAAC,GAAC,GAAG;IAC1B;;;;;;;;;;;;OAYG;IACH,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAC5C;;;;;;;;OAQG;IACH,SAAS,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAC/D;;;;;;;OAOG;IACH,OAAO,CAAC,OAAO,CAAC,EAAE,KAAK,CAAC,eAAe,GAAG,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;IACjE;;;;;;;OAOG;IACH,MAAM,CAAC,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,GAAG,OAAO,CAAC;IAC7C;;OAEG;IACH,KAAK,CAAC,IAAI,IAAI,CAAC;IACf;;;;;;;;;;OAUG;IACH,KAAK,CAAC,CAAC,MAAM,EAAE,WAAW,EAAE,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC;IAC3D;;;;;;OAMG;IAEH,MAAM,CAAC,WAAW,EAAE,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CAAC;IACzE;;;;;;;OAOG;IACH,KAAK,CAAC,CAAC,QAAQ,CAAC,EAAE,GAAG,GAAG,IAAI,CAAC;IAC7B;;;;;;OAMG;IACH,UAAU,CAAC,CAAC,QAAQ,CAAC,EAAE,GAAG,GAAG,IAAI,CAAC;IAClC;;;;;;;;;OASG;IACH,IAAI,CAAC,CAAC,OAAO,CAAC,EAAE,KAAK,CAAC,eAAe,GAAG,KAAK,CAAC,WAAW,CAAC;IAC1D;;;;;;;;;;OAUG;IACH,MAAM,CAAC,CAAC,OAAO,CAAC,EAAE,KAAK,CAAC,eAAe,GAAG,KAAK,CAAC,aAAa,CAAC;IAC9D;;;;;;;;OAQG;IACH,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,CAAC,CAAC;IAC3C;;;;;;;;OAQG;IACH,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;IACxD;;;;;;;;;;OAUG;IACH,OAAO,CAAC,IAAI,SAAS,CAAC;IACtB;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,MAAM,CAAC;IACpB;;OAEG;IACH,SAAS,IAAI,WAAW,GAAG,IAAI,CAAC;IAChC;;;;;;;OAOG;IACH,YAAY,CAAC,IAAI,WAAW,GAAG,IAAI,CAAC;CACrC;AAED;;;;;;GAMG;AACH,yBAAiB,KAAK,CAAC;IACrB;;OAEG;IACH,UAAiB,eAAe,CAAC,CAAC,GAAC,GAAG;QACpC;;;;WAIG;QACH,MAAM,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;QAC9B;;;;WAIG;QACH,IAAI,CAAC,EAAE,SAAS,CAAC;QACjB;;;WAGG;QACH,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB;;;;;;;WAOG;QACH,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,KAAK,MAAM,CAAC;QAC9D;;;;;;;WAOG;QACH,iBAAiB,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,KAAK,MAAM,CAAC;QACjE;;;;;;;;;;;;;;;;;;;;;;;;;;WA0BG;QACH,WAAW,CAAC,EAAE,OAAO,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC;KAC3C;IAED;;OAEG;IACH,KAAY,KAAK,CAAC,CAAC,GAAC,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC;IAC3C;;OAEG;IACH,KAAY,mBAAmB,CAAC,CAAC,GAAC,GAAG,IAAI,cAAc,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IACxE;;OAEG;IACH,KAAY,aAAa,CAAC,CAAC,GAAC,GAAG,IAAI,gBAAgB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC;IAChG;;OAEG;IACH,KAAY,aAAa,CAAC,CAAC,GAAC,GAAG,IAAI,gBAAgB,CAAC,CAAC,EAAE,CAAC,EAAE,UAAU,CAAC,CAAC;IACtE;;OAEG;IACH,KAAY,WAAW,GAAG,gBAAgB,CAAC,UAAU,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC;CAChF"}