@sheetxl/sdk 0.7.27 → 0.7.28-beta.1

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

@@ -0,0 +1,64 @@
+import { RangeCoords } from '@sheetxl/utils';
+import { ISpatialMap } from './ISpatialMap';
+import { ISpatialMap3D } from './ISpatialMap3D';
+/**
+ * Implementation of {@link ISpatialMap3D}.
+ *
+ * Deliberately NOT a {@link SpatialMap}; it routes every operation to a per-scope 2D map.
+ * Entries are stamped with their scope key on the way in so that every entry inside a
+ * 2D map carries `scope` equal to the map's key (consumers read `.scope` off search
+ * results, so the scope must be preserved — never stripped).
+ */
+export declare class SpatialMap3D<T = any> implements ISpatialMap3D<T> {
+    protected _mapScopeTo2Ds: Map<string, ISpatialMap<T>>;
+    protected _last2DKey: string | null | undefined;
+    protected _last2DMap: ISpatialMap<T> | undefined;
+    protected _options: SpatialMap3D.ConstructorOptions<T> | undefined;
+    protected _options2D: ISpatialMap.ConstructorOptions<T> | undefined;
+    constructor(options?: SpatialMap3D.ConstructorOptions<T>);
+    /** {@inheritDoc ISpatialMap3D.all3D} */
+    all3D(results?: ISpatialMap.Entry<T>[]): ISpatialMap.Entry<T>[];
+    /** {@inheritDoc ISpatialMap3D.getSpatialAt} */
+    getSpatialAt(scope?: string | null): ISpatialMap<T>;
+    /** {@inheritDoc ISpatialMap3D.getScopeEntries} */
+    getScopeEntries(): MapIterator<[string, ISpatialMap<T>]>;
+    /** {@inheritDoc ISpatialMap3D.getScopeKeys} */
+    getScopeKeys(): MapIterator<string>;
+    /** {@inheritDoc ISpatialMap3D.getScopeValues} */
+    getScopeValues(): MapIterator<ISpatialMap<T>>;
+    /** {@inheritDoc ISpatialQuery.getBoundingRange} */
+    getBoundingRange(): RangeCoords;
+    /** {@inheritDoc ISpatialQuery.isEmpty} */
+    isEmpty(): boolean;
+    /** {@inheritDoc ISpatialQuery.search} */
+    search(range: RangeCoords, fullyContained?: boolean, sort?: boolean, results?: ISpatialMap.Entry<T>[]): ISpatialMap.Entry<T>[];
+    /** {@inheritDoc ISpatialMap3D.has} */
+    has(range: RangeCoords): boolean;
+    /** {@inheritDoc ISpatialMap3D.shift} */
+    shift(options: ISpatialMap.ShiftOptions<T>): this;
+    /** {@inheritDoc ISpatialMap3D.insertNonOverlapping} */
+    insertNonOverlapping(entry: ISpatialMap.Entry<T>, options?: ISpatialMap.InsertNonOverlappingOptions<T>): this;
+    /** {@inheritDoc ISpatialMap3D.createCopiedEntries} */
+    createCopiedEntries(from: RangeCoords, to: RangeCoords, options?: ISpatialMap.CopyOptions, reuseInserts?: ISpatialMap.Entry<T>[], reuseRemoves?: ISpatialMap.Entry<T>[]): ISpatialMap.Updates;
+    /** {@inheritDoc ISpatialMap3D.remove} */
+    remove(entry: ISpatialMap.Entry<T>, equals?: (a: ISpatialMap.Entry<T>, b: ISpatialMap.Entry<T>) => boolean): this;
+    /** {@inheritDoc ISpatialMap3D.removeAll} */
+    removeAll(entries: ISpatialMap.Entry<T>[], equals?: (a: ISpatialMap.Entry<T>, b: ISpatialMap.Entry<T>) => boolean): this;
+    /** {@inheritDoc ISpatialMap3D.insert} */
+    insert(entry: ISpatialMap.Entry<T>): this;
+    /** {@inheritDoc ISpatialMap3D.load} */
+    load(entries: ReadonlyArray<ISpatialMap.Entry<T>>): this;
+    /** {@inheritDoc ISpatialMap3D.delete} */
+    delete(coords: RangeCoords | null): this;
+    /** {@inheritDoc ISpatialMap3D.clone} */
+    clone(cloneKey?: any): this;
+    protected _getOrCreate2D(scope: string | null | undefined): ISpatialMap<T>;
+    protected _cleanupEmpty2D(scope: string | null | undefined, map2D: ISpatialMap<T> | undefined): void;
+    protected _createClone(options: SpatialMap3D.ConstructorOptions<T> | undefined): this;
+}
+export declare namespace SpatialMap3D {
+    /** Options */
+    interface ConstructorOptions<T = any> extends ISpatialMap.ConstructorOptions<T> {
+    }
+}
+//# sourceMappingURL=SpatialMap3D.d.ts.map

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

@@ -0,0 +1,160 @@
+import { ChainedError } from '@sheetxl/utils';
+import { IList, IListLike } from './IList';
+/**
+ * Namespace for tuples.
+ */
+export declare namespace Tuple {
+    /**
+     * Represents a pair of values: a numeric index represents the starting offset and an array of elements.
+     *
+     * This provides a convenient shorthand for scenarios where you need to associate
+     * a contiguous span of values with a specific index or position.
+     * @remarks
+     * The MinorTuple is types as an Array with 2 elements for performance reasons but can be logically
+     * conceptualized as the following type.
+     * ```
+  type MinorTuple<T = any> = {
+    minor: number;
+    values: T[];
+  };
+     * ```
+     */
+    type MinorTuple<T = any> = [minor: number, runs: IListLike<T>];
+    /**
+     * Represents a tuple associated with a specific dimension (e.g., a row or a column in a grid).
+     *
+     * The first element is the major index, and the second element is a `MinorTuple` representing
+     * the minor indices and values associated with that location.
+     */
+    type MajorTuple<T = any> = [major: number, minors: MinorTuple<T>[]];
+    /**
+     * Represents a collection of `MajorTuple`s, used to store data for a 2d collection of tuples.
+     * **Validity Requirements:**
+     * - The `major` values within a collection of `MajorTuple`s must be sorted in ascending order.
+     * - The `minor` values within each `MinorTuple` of a `MajorTuple` must be sorted in ascending order.
+     * - The `minors` (array of `MinorTuple`s) within a `MajorTuple` must not overlap; their ranges
+     *   (defined by the `minor` values and the `length` of the `values` arrays) should be mutually exclusive.
+     */
+    type GridTuple<T = any> = MajorTuple<T>[];
+    /**
+     * Adds precomputed bounds for the `MajorTuple`s.
+     *
+     * @remarks
+     * In some scenarios the maximum bounds of the tuples is required (e.g., during rendering or calculations),
+     * providing precomputed bounds can improve performance by avoiding the need to scan the entire collection.
+     */
+    interface BoundedTuples<T = any> {
+        /**
+         * The bounded tuples.
+         */
+        tuples: Tuple.GridTuple<T>;
+        /**
+         * The precomputed bounds encompassing all the `MajorTuple`s.
+         */
+        bounds: Tuple.OrientatedCoords;
+    }
+    /**
+     * RangeCoords expressed in relative coordinates.
+     */
+    interface OrientatedCoords {
+        majorStart: number;
+        minorStart: number;
+        majorEnd: number;
+        minorEnd: number;
+    }
+    /**
+     * A builder for easily creating tuples that can be either contiguous or non-contiguous.
+     * A builder maintains an ordered structure where major and minor values must always
+     * increase, otherwise an error will be thrown.
+     *
+     * @template T The type of values stored within the tuples.
+     */
+    interface IBuilder<T = any> {
+        /**
+         * Adds a single value associated with a specific major and minor index.
+         *
+         * @param major The major index.
+         * @param minor The minor index.
+         * @param value The value to be added.
+         * @throws `Error` If the point is out of order compared to previously added points
+         * (within the same row).
+         *
+         * @remarks
+         * If the value is an Array, it will be treated as a discrete value. If you want to set
+         * multiple values along the minor axis, then use {@link pushMultipleAt}.
+         */
+        pushAt(major: number, minor: number, value: T): IBuilder<T>;
+        /**
+         * Adds multiple values associated with a specific major and minor index.
+         *
+         * @param major The major index.
+         * @param minor The minor index.
+         * @param value An array of values to be added.
+         * @throws `Error` If the point is out of order compared to previously added points
+         * (within the same row).
+         */
+        pushMultipleAt(major: number, minor: number, value: IListLike<T> | T[]): IBuilder<T>;
+        /**
+         * Constructs and returns the bounded tuples based on the added values.
+         * This method can be called multiple times.
+         *
+         * @returns The built bounded tuples.
+         */
+        build(): Tuple.BoundedTuples<T>;
+    }
+    /**
+     * Implementation of {@link IBuilder} that that adds in aligned order.
+     */
+    class Builder<T = any> implements IBuilder<T> {
+        private _tuples;
+        private _minors;
+        private _values;
+        private _minorMin;
+        private _minorMax;
+        private _majorIndex;
+        private _minorIndex;
+        private _createList;
+        private _offsetMajor;
+        private _offsetMinor;
+        constructor(createList?: (arr: Array<T>) => IList<T>, offsetMajor?: number, offsetMinor?: number);
+        /** {@inheritDoc IBuilder.pushMultipleAt} */
+        pushMultipleAt(major: number, minor: number, value: T[]): IBuilder<T>;
+        /** {@inheritDoc IBuilder.pushAt} */
+        pushAt(major: number, minor: number, value: T): IBuilder<T>;
+        /** {@inheritDoc IBuilder.build} */
+        build(): Tuple.BoundedTuples<T>;
+    }
+    /**
+     * Transposes cell coordinates within tuples to create `MajorTuple` representations
+     * in the opposite axis.
+     *
+     * This utility efficiently converts data organized by one axis into the opposite.
+     */
+    class TransposedBuilder<T> implements IBuilder<T> {
+        private _minors;
+        /** the currentNode the node.minorIndex >= _minorIndex */
+        private _current;
+        private _first;
+        private _majorMin;
+        private _majorMax;
+        private _majorIndex;
+        private _minorIndex;
+        private _createList;
+        private _offsetMajor;
+        private _offsetMinor;
+        constructor(createList?: <T>(arr: Array<T>) => IListLike<T>, offsetMajor?: number, offsetMinor?: number);
+        /** {@inheritDoc IBuilder.pushMultipleAt} */
+        pushMultipleAt(major: number, minor: number, value: T[]): IBuilder<T>;
+        /** {@inheritDoc IBuilder.pushAt} */
+        pushAt(major: number, minor: number, value: T): IBuilder<T>;
+        /** {@inheritDoc IBuilder.build} */
+        build(): Tuple.BoundedTuples<T>;
+    }
+    /**
+     * Thrown when a major minor is set out of order.
+     */
+    class OutOfOrderError extends ChainedError {
+        constructor(message?: string, cause?: Error | null);
+    }
+}
+//# sourceMappingURL=Tuple.d.ts.map

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

@@ -0,0 +1,25 @@
+import { Direction, RangeCoords, RunCoords } from '@sheetxl/utils';
+/**
+ * Sorts ranges in 2 directions but weighted to direction.
+ *
+ * @remarks
+ * * Mutates the ranges array.
+ * * Will also sort nulls to the end.
+ * * Only uses the colStart and rowStart. It does not account for colEnd and rowEnd.
+ *
+ * @param ranges The ranges to sort
+ * @param direction defaultValue Direction.Right
+ */
+export declare function sortRanges(ranges: RangeCoords[], direction?: Direction, additionalSort?: ((a: RangeCoords, b: RangeCoords) => number) | null): RangeCoords[];
+/**
+ * Specialize Comparator. We only create RunCoords with a -1 max for search operations.
+ * We look for a RunCoord that has a missing edge.
+ *
+ * We only have to check the second argument because all of our search operations guarantee the
+ * key will be the second argument.
+ *
+ * @param a The first RunCoords.
+ * @param b The second RunCoords or the search key in the case where max is `Number.MAX_SAFE_INTEGER`.
+ */
+export declare function runCoordsAndPivotComparator(a: RunCoords, b: RunCoords): number;
+//# sourceMappingURL=_CollectionUtils.d.ts.map

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

@@ -0,0 +1,268 @@
+import { RangeAxis, CellCoords, RangeCoords } from '@sheetxl/utils';
+import { IGrid } from './IGrid';
+import { ISpatialMap } from './ISpatialMap';
+import { Tuple } from './Tuple';
+/**
+ * Return a range as an in the correct major/minor axis.
+ *
+ * If maxRange is provided then this will also validate
+ * and throw an `OutOfBoundsError`.
+ *
+ * @remarks
+ * This reuses the same OrientationBounds.
+ */
+export declare function orientAndValidateReused(colStart: number | undefined, rowStart: number | undefined, colEnd: number | undefined, rowEnd: number | undefined, isColumn: boolean, maxRange?: RangeCoords, dataRange?: RangeCoords): Tuple.OrientatedCoords;
+export declare function unOrientCoords(oriented: Tuple.OrientatedCoords, isColumn: boolean, reuseCoords?: RangeCoords): RangeCoords;
+/**
+ * Creates an iterator results.
+ *
+ * @param majorIndex The index for major value.
+ * @param minorIndex The index for minor value.
+ * @param value -The Value.
+ * @param isColumn The results are in absolute axis so we need to convert back
+ * @param reuseResult If provided this will not create a new object.
+ * @returns an {@link IGrid.EntryIteratorResult} that can be provide to the client.
+ * @see
+ * {@link IGrid.IteratorOptions.reuseResult}
+ */
+export declare function createEntryIteratorResults<T>(majorIndex: number, minorIndex: number, value: T, isColumn: boolean, reuseResult?: IGrid.EntryIteratorResult<T>): IGrid.EntryIteratorResult<T>;
+/**
+ * Simple util that converts a boolean to a the global value or undefined.
+ * @param reuseResult The client provided input
+ */
+export declare function toReusableEntryResult<T>(reuseResult: boolean | IGrid.EntryIteratorResult<T> | undefined): IGrid.EntryIteratorResult<T>;
+/**
+ * Sort by first index.
+ */
+export declare function validateTupleOffsets<T>(tuples: [number, T][]): void;
+/**
+ * Sort by first index.
+ */
+export declare function sortTupleOffset<T>(a: [number, T], b: [number, T]): number;
+/**
+ * Iterator Options.
+ */
+export interface EmptyIteratorOptions extends Omit<IGrid.IteratorOptions, 'bounds'> {
+    /**
+     * Required for the iterator to work correctly.
+     */
+    bounds: RangeCoords;
+    /**
+     * Setting skipMajors to `true` will have the EmptyIterator only visit empty minors.
+     * @remarks
+     * We don't have a skipMinors then empty majors would have to be skipped as well and then
+     * the EmptyIterator should not be used.
+     */
+    skipMajors?: boolean;
+}
+/**
+ * Visits an iterator and creates additional iterations for any missing gaps.
+ * Accounts for hidden and reverse.
+ * @remarks
+ * It is VERY important that the delegate iterator increments in the same order (not reversed).
+ *
+ * Unlike IGridIterator options Bounds is required.
+ *
+ */
+export declare class EmptyIterator<T = any, TReturn = any> implements Iterator<T, TReturn, CellCoords> {
+    private _delegate;
+    private _isColumn;
+    private _isReverse;
+    private _skipMajors;
+    private _majorMin;
+    private _majorMax;
+    private _minorMin;
+    private _minorMax;
+    private _majorIndex;
+    private _minorIndex;
+    private _delegateResult;
+    private _delegateMajorIndex;
+    private _delegateMinorIndex;
+    private _processMajorSkip;
+    private _processMinorSkip;
+    constructor(delegate: Iterator<T, TReturn, CellCoords>, options: EmptyIteratorOptions);
+    private _initialize;
+    /**
+     * Returns the next iterator.
+     */
+    next(cell?: CellCoords): IteratorResult<T>;
+    return(_value?: TReturn): IteratorResult<T, TReturn>;
+    throw(_e?: any): IteratorResult<T, TReturn>;
+    [Symbol.iterator](): IterableIterator<T>;
+}
+/**
+ * Options for RepeatingIterator.
+ */
+export type RepeatIteratorOptions<T = any, TReturn = any> = {
+    /**
+     * The delegate.
+     */
+    delegate: Iterator<[CellCoords, T], TReturn, CellCoords>;
+    /**
+     * Required - This must match the bounds of the Delegate iterator.
+     */
+    bounds: RangeCoords;
+    /**
+     * Required - This much be larger than the bounds.
+     */
+    dims: {
+        major: number;
+        minor: number;
+    };
+    /**
+     * Optional
+     * @remarks
+     * This can be different than the delegate but then the bounds and dim need to be manually
+     * transposed by the caller.
+     */
+    axis?: RangeAxis;
+    /**
+     * @see
+     * {@link IGrid.IteratorOptions.reuseResult}
+     */
+    reuseResult?: boolean | IGrid.EntryIteratorResult<T>;
+};
+/**
+ * Visits an iterator and will creates additional iterations to fill the new bounding area.
+ * @remarks
+ * This iterator creates a temporary copy of the first values to repeat.
+ *
+ * * delegate iterator bounds must not be larger than dimension.
+ * * reverse is currently not implemented.
+ */
+export declare class RepeatingIterator<T = any, TReturn = any> implements Iterator<[CellCoords, T], TReturn, CellCoords> {
+    private _isColumn;
+    private _majorSize;
+    private _minorSize;
+    private _majorMin;
+    private _majorMax;
+    private _minorMin;
+    private _minorMax;
+    private _delegate;
+    private _nextDelegateResult;
+    private _nextResult;
+    private _majorIndex;
+    private _minorIndex;
+    private _minorSpan;
+    private _minorOffset;
+    private _minorRepeat;
+    private _majorOffset;
+    private _majorRepeat;
+    private _pattern;
+    constructor(options: RepeatIteratorOptions);
+    private _initialize;
+    /**
+     * Returns the next iterator.
+     */
+    next(cell?: CellCoords): IteratorResult<[CellCoords, T]>;
+    return(_value?: TReturn): IteratorResult<[CellCoords, T], TReturn>;
+    throw(_e?: any): IteratorResult<[CellCoords, T], TReturn>;
+    [Symbol.iterator](): IterableIterator<[CellCoords, T]>;
+}
+/**
+ * Takes 2 iterators and returns the first one. In the event there is a 'tie' the first value will be returned.
+ */
+export declare class RacingIterator<T = any, TReturn = any> implements Iterator<[CellCoords, T], TReturn, CellCoords> {
+    private _iterator1;
+    private _nextResult1;
+    private _iterator2;
+    private _nextResult2;
+    private _onEqual;
+    private _comparator;
+    constructor(options: IGrid.IteratorOptions, iterator1: IGrid.EntryIterator<T>, iterator2: IGrid.EntryIterator<T>, onEqual?: (a: [CellCoords, T], b: [CellCoords, T]) => number);
+    /**
+     * Returns the next iterator.
+     */
+    next(cell?: CellCoords): IteratorResult<[CellCoords, T]>;
+    return(_value?: TReturn): IteratorResult<[CellCoords, T], TReturn>;
+    throw(_e?: any): IteratorResult<[CellCoords, T], TReturn>;
+    [Symbol.iterator](): IterableIterator<[CellCoords, T]>;
+}
+/**
+ * Takes 2 iterators and returns the them both in order. In the event there is a 'tie' they will be be returned.
+ */
+export declare class RacingIterator2<T = any, TReturn = any> implements Iterator<[CellCoords, T, CellCoords, T], TReturn, CellCoords> {
+    private _iterator1;
+    private _nextResult1;
+    private _iterator2;
+    private _nextResult2;
+    private _comparator;
+    private _reuseResult;
+    constructor(options: RacingIterator2Options, iterator1: IGrid.EntryIterator<T>, iterator2: IGrid.EntryIterator<T>);
+    /**
+     * Returns the next iterator.
+     */
+    next(cell?: CellCoords): IteratorResult<[CellCoords, T, CellCoords, T]>;
+    return(_value?: TReturn): IteratorResult<[CellCoords, T, CellCoords, T], TReturn>;
+    throw(_e?: any): IteratorResult<[CellCoords, T, CellCoords, T], TReturn>;
+    [Symbol.iterator](): IterableIterator<[CellCoords, T, CellCoords, T]>;
+}
+export interface RacingIterator2Options extends IGrid.IteratorOptions {
+    /**
+     * A custom comparator.
+     */
+    comparator?: (a: CellCoords, b: CellCoords) => number;
+}
+export declare const MESSAGE_ERROR_REQUIRE_INT = "Tuple indices must be integers.";
+/**
+ * Creates a tuple 2D tuple from a single value.
+ *
+ * @internal
+ */
+export declare function valueToTuples<T>(value: T | ((row: number, column: number) => T | null), ranges: Tuple.OrientatedCoords, isColumn: boolean): Tuple.BoundedTuples<T>;
+/**
+ * Entry for a Range iterator or visiting.
+ */
+export interface Entry<T extends any> {
+    value: T;
+    coords: CellCoords;
+}
+/**
+ * Deep copies value from into a tuple.
+ *
+ * @remarks
+ * This should generally be avoid in preference for zero-copy approaches but exist as a fallback.
+ */
+export declare function iteratorToTuples<T>(iterator: IterableIterator<Entry<T>>, axis: RangeAxis, builder: Tuple.IBuilder<T>, topLeft?: CellCoords | null): Tuple.BoundedTuples<T>;
+/**
+ * Creates an array of Tuple.GridTuple from a 2D array using {@link ITuple.IBuilder}.
+ * This adds supports for max bounds and offsetting the indices.
+ *
+ * @remarks
+ * For performance reasons this will not visit ths minor axis but will remove empty major axises.
+ */
+export declare function array2DToTuples<T>(array2d: T[][], transpose?: boolean, ranges?: Partial<Tuple.OrientatedCoords> | null, removeEmpty?: boolean): Tuple.BoundedTuples<T>;
+/**
+ * This is for the edge case where were have a GridTuple but need a bounds.
+ * This will iterator through all majors comparing the first and last minor
+ * to determine the bounds.
+ *
+ * @remarks
+ * We do not use this.
+ */
+export declare function calcTupleBounds(gridTuples: Tuple.GridTuple): Tuple.OrientatedCoords | null;
+/**
+ * Returns a new `BoundedTuples` with all major and minor indices shifted by the given offsets.
+ *
+ * @param boundedTuples The source tuples to translate.
+ * @param translateMajor Delta added to every major index (and to `bounds.majorStart/End`).
+ * @param translateMinor Delta added to every minor index (and to `bounds.minorStart/End`).
+ *
+ * @example
+ * // Normalize to origin then re-anchor at (row, col):
+ * tuples = translateTupleBounds(tuples, -bounds.majorStart, -bounds.minorStart);
+ * tuples = translateTupleBounds(tuples, row, col);
+ *
+ * @remarks
+ * Run arrays inside each `MinorTuple` are shared by reference; they are immutable `IList`s so this is safe.
+ */
+export declare function translateTupleBounds<T = any>(boundedTuples: Tuple.BoundedTuples<T>, translateMajor: number, translateMinor: number): Tuple.BoundedTuples<T>;
+/**
+ * Returns api for incrementally building ranges against minor and optionally major.
+ *
+ * @remarks
+ * * Assumes ordered writes.
+ * * Allows for reusable ranges.
+ */
+export declare function createConflatingRangeValue<T = any>(isColumn?: boolean, canMerge?: (a: T, b: T, isColumn: boolean) => T | undefined): ISpatialMap.IConflatingEntries<T>;
+//# sourceMappingURL=_GridUtils.d.ts.map

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

@@ -0,0 +1,170 @@
+import { RunCoords, RangeCoords, RunCoordValue, RangeCoordValue } from '@sheetxl/utils';
+export interface ModifiedRuns<T> {
+    preceding: RunCoordValue<T>[];
+    modified: RunCoordValue<T>[];
+    trailing: RunCoordValue<T>[];
+}
+export declare function deepUpdate(prevValue: any | null, newValue: any | null): any | null;
+export declare function deepCull(value: any, _min: number, _max: number): boolean;
+export interface UpdateAndCompactOptions<T, U = T> {
+    /**
+     * Used when split two runs.
+     * @remarks
+     * Should always return an array with 2 values.
+     */
+    onSplit?: (value: RunCoordValue<T>, offset: number) => T[];
+    /**
+     * Returns an updated value. If not specified a deep merge is done.
+     *
+     * IMPORTANT -
+     * both prevValue and newValue should be treated as frozen object and not
+     * mutated.
+     * A new value should always be returned. If you want to augment a value
+     * The deepUpdateMethod is offered
+    */
+    onUpdate?: (prevValue: T | null, newValue: U | null | undefined, run: RunCoordValue<T>) => T | null | undefined;
+    /**
+     * Used when attempting to merge two runs.
+     * Returns undefined if the values can't be merged
+     */
+    onMerge?: (a: T, b: T, sizeA: number, sizeB: number) => T | undefined;
+    /**
+     * Used to determine if a entry should removed. If value is null or undefined it will also be removed.
+     * By default an empty object will not be.
+     */
+    isCull?: (value: T, min: number, max: number) => boolean;
+    /**
+     * By default merge will freeze object in place to prevent mutations.
+     * Setting this to true will allow for special cases where objects are not immutable.
+     *
+     * @defaultValue false
+     */
+    inPlace?: boolean;
+}
+export declare function shiftRuns<T>(runs: RunCoordValue<T>[], index: number, amount?: number): ModifiedRuns<T>;
+export declare function unshiftRuns<T>(runs: RunCoordValue<T>[], index: number, amount?: number): ModifiedRuns<T>;
+export declare function unshiftAndMergeRuns<T>(runs: RunCoordValue<T>[], index: number, amount?: number, options?: MergeRunOptions<T>): ModifiedRuns<T>;
+/**
+ * Will take a list of runs and return the minimum set required.
+ *
+ * @param runs
+ * @param update
+ * @param options @UpdateAndCompactOptions
+ */
+export declare function updateAndCompactRuns<T, U = T>(runs: RunCoordValue<T>[], update: RunCoordValue<U>, options?: UpdateAndCompactOptions<T, U>): ModifiedRuns<T>;
+export declare function concatModifiedRuns<T>(parts: ModifiedRuns<T>): RunCoordValue<T>[];
+/**
+ * Split/update algo used for formatted text.
+ * This will split and update runs
+
+ * All runs must be:
+ * ** ordered
+ * ** non-overlapping
+ * Runs do not need to be contiguous.
+ */
+export declare function splitAndUpdateRuns<T, U = T>(runs: RunCoordValue<T>[], update: RunCoordValue<U> | null, onSplit?: (run: RunCoordValue<T>, offset: number) => T[], onUpdate?: (prevValue: T | null, newValue: U | null | undefined, run: RunCoordValue<T>) => T | null | undefined, inPlace?: boolean): ModifiedRuns<T>;
+interface CullRunsOptions<T> {
+    startOffset?: number;
+    endOffset?: number;
+    /**
+     * Used to determine if a value should removed. If data is null or undefined it will also be removed.
+     * By default an empty object will not be.
+     */
+    cull?(value: T, min: number, max: number): boolean;
+}
+export declare function cullRuns<T>(runs: RunCoordValue<T>[], options?: CullRunsOptions<T>): ModifiedRuns<T>;
+export interface MergeRunOptions<T> {
+    startOffset?: number;
+    endOffset?: number;
+    onMerge?: (a: T, b: T, sizeA: number, sizeB: number) => T | undefined | null;
+}
+/**
+ * Merges runs. Runs must be sorted; {@link sortRuns}
+ */
+export declare function mergeRuns<T>(runs: RunCoordValue<T>[], options?: MergeRunOptions<T>): ModifiedRuns<T>;
+export declare function sortRuns<T>(a: RunCoordValue<T>[]): RunCoordValue<T>[];
+/**
+ * Sorts twos runs by their min values.
+ */
+export declare function sortTwoRuns<T>(a: RunCoordValue<T>, b: RunCoordValue<T>, forward?: boolean): RunCoordValue<T>[] | undefined;
+/**
+ * Looks for a run going in a certain direction. If there isn't a run for this it will look for the next
+ * run. If you only want the run if it is found then use {@link findRun}.
+ *
+ * @param runs An array of Run or RunCoords.
+ * @param index The index that will be >= min && <= max.
+ * @param findGreater - *`default`* `true` If true will search greater if false lesser.
+ * @returns The index for the next run or -1 if no run was found.
+ */
+export declare function findNextRunOffset<T = any>(runs: readonly RunCoordValue<T>[], index: number, findGreater?: boolean): number;
+export declare function findRun<T>(runs: readonly RunCoordValue<T>[], index: number): RunCoordValue<T> | null;
+/**
+ * Converts a list of indices into Runs (an array of RunCoords).
+ *
+ * @param indices A list of indices. (Mutates if !presorted)
+ * @param presorted If set to true will not sort. @defaultValue false
+ */
+export declare function indicesToRuns(indices: number[], presorted?: boolean): RunCoords[];
+/**
+ * Runs are an ordered list of RunCoords with no overlapping values.
+ *
+ * Examples:
+ *
+ * - Valid - [0, 3][4, 4][8,10] // valid runs of size 4, 1, 3
+ *
+ * - Invalid -  [0, 4][4, 6][8,10] // 4 overlaps
+ *
+ * - Invalid -  [0, 3][7, 6][8,10] // second run has incorrect min/max
+ *
+ * - Invalid -  [4, 6][0, 5][8,10] // second run is out of order
+ *
+ * - Valid  - [] // empty but valid
+ * @param runs A list of RunCoords.
+ */
+export declare function validateRuns(runs: readonly RunCoords[]): boolean;
+/**
+ * Finds the intersection of 2 runs.
+ * @returns `null` if no intersection
+ */
+export declare function intersectRuns(a: Readonly<RunCoords>, b: Readonly<RunCoords>): RunCoords;
+export interface RunVisitor<T> {
+    (run: RunCoordValue<T>): {
+        break: any;
+    } | void;
+}
+export interface CacheSearchRunData<T = any> {
+    runs: readonly RunCoordValue<T>[];
+    run: RunCoordValue<T | null>;
+    index: number;
+}
+export declare function createSearchRunCache<T = any>(runs: readonly RunCoordValue<T>[]): CacheSearchRunData<T>;
+/**
+ * To minimize lookups we assume that the items are generally read in order.
+ * This allows use to cache the last run and check adjacent before doing a binary search.
+ *
+ * If the runs are update the an new CacheSearchRunData is required. see {@link createSearchRunCache}
+ * * We always return a run if one is found.
+ * * If one isn't we return a run with a null value with min/max being the empty space boundaries.
+ * * the runIndex is always the current run or the next run (or -1 if no runs).
+ * * We reuse cache
+ * @param index
+ * @param cache
+ */
+export declare function searchRunsWithCache<T = any>(index: number, cache: CacheSearchRunData<T>): T;
+/**
+ * Scans all of the runs. It will scan each run exactly once.
+ * In additional if there are gaps it will create an empty run.
+ */
+export declare function scanRuns<V, B = any>(runs: readonly RunCoordValue<V>[], visitor: RunVisitor<V>, start?: number, end?: number): {
+    break: B;
+} | void;
+/**
+ * Converts a set of RunCoords into a set of RangeCoords.
+ */
+export declare function runCoordsToRangeCoords<T = any>(runs: readonly Readonly<Partial<RunCoordValue<T>>>[], entireRange: RangeCoords, isColumn: boolean): RangeCoordValue<T>[];
+/**
+ * Returns a list of merged and non-overlapping run coordinates.
+ */
+export declare function removeOverlappingRuns(runs: readonly Readonly<Partial<RunCoords>>[], merge?: boolean): RunCoords[];
+export {};
+//# sourceMappingURL=_RunUtils.d.ts.map