@odoo/o-spreadsheet 17.0.84 → 17.0.96

package/dist/types/helpers/recompute_zones.d.ts

@@ -0,0 +1,136 @@
+import { UnboundedZone, Zone } from "../types";
+/**
+ * ####################################################
+ * # INTRODUCTION
+ * ####################################################
+ *
+ * This file contain the function recomputeZones.
+ * This function try to recompute in a performant way
+ * an ensemble of zones possibly overlapping to avoid
+ * overlapping and to reduce the number of zones.
+ *
+ * It also allows to remove some zones from the ensemble.
+ *
+ * In the following example, 2 zones are overlapping.
+ * Applying recomputeZones will return zones without
+ * overlapping:
+ *
+ * ["B3:D4", "D2:E3"]         ["B3:C4", "D2:D4", "E2:E3"]
+ *
+ *      A B C D E                    A B C D E
+ *    1       ___                  1       ___
+ *    2   ___|_  |                 2   ___| | |
+ *    3  |   |_|_|      --->       3  |   | |_|
+ *    4  |_____|                   4  |___|_|
+ *    6                            6
+ *    7                            7
+ *
+ *
+ * In the following example, 2 zones are contiguous.
+ * Applying recomputeZones will return only one zone:
+ *
+ *  ["B2:B3", "C2:D3"]               ["B2:D3"]
+ *
+ *       A B C D E                   A B C D E
+ *     1   _ ___                   1   _____
+ *     2  | |   |        --->      2  |     |
+ *     3  |_|___|                  3  |_____|
+ *     4                           4
+ *
+ *
+ * In the following example, we want to remove a zone
+ * from the ensemble. Applying recomputeZones will
+ * return the ensemble without the zone to remove:
+ *
+ *    remove ["C3:D3"]           ["B2:B4", "C2:D2",
+ *                                "C4:D4", "E2:E4"]
+ *
+ *       A B C D E F                 A B C D E F
+ *     1   _______                 1   _______
+ *     2  |       |       --->     2  | |___| |
+ *     3  |  xxx  |                3  | |___| |
+ *     4  |_______|                4  |_|___|_|
+ *     5                           5
+ *
+ *
+ * The exercise seems simple when we have only 2 zones.
+ * But with n zones and in a performant way, we want to
+ * avoid comparing each zone with all the others.
+ *
+ *
+ * ####################################################
+ * # Methodological approach
+ * ####################################################
+ *
+ * The methodological approach to avoid comparing each
+ * zone with all the others is to use a data structure
+ * that allow to quickly find which zones are
+ * overlapping with any other given zone.
+ *
+ * Here the idea is to profile the zones at the columns level.
+ *
+ * To do that, we propose to use a data structure
+ * composed of 2 parts:
+ * - profilesStartingPosition: a sorted number array
+ * indicating on which columns a new profile begins.
+ * - profiles: a map where the key is a column
+ * position (from profilesStartingPosition) and the
+ * value is a sorted number array representing a
+ * profile.
+ *
+ *
+ * See the following example:    here profileStartingPosition
+ *                               corresponds to [A,C,E,G,K]
+ *    A B C D E F G H I J K      so with number [0,2,4,6,10]
+ *  1    '   '   '       '
+ *  2    '   '   '_______'       here profile correspond
+ *  3    '___'   |_______|       for A to []
+ *  4    |   |                   for C to [3, 5]
+ *  5    |___|                   for E to []
+ *  6                            for G to [2, 3]
+ *  7                            for K to []
+ *
+ *
+ * Now we can easily find which zones are overlapping
+ * with a given zone. Suppose we want to add a new zone
+ * D5:H6 to the ensemble:
+ *
+ *                              With a binary search of left and right
+ *    A B C D E F G H I J K     on profilesStartingPosition, we can
+ *  1    '   '   '       '      find the indexes of the profiles on which
+ *  2    '   '   '_______'      to apply a modification.
+ *  3    '___'   |_______|
+ *  4    |  _|_______           Here we will:
+ *  5    |_|_|       |          - add a new profile in D   --> become [3, 6]
+ *  6      |_________|          - modify the profile in E  --> become [4, 6]
+ *  7                           - modify the profile in G  --> become [2, 3, 4, 6]
+ *                              - add a new profile in I   --> become [8, 10]
+ *
+ *  See below the result:
+ *
+ *                              Note the particularity of the profile
+ *    A B C D E F G H I J K     for G: it will correspond to [2, 3, 4, 6]
+ *  1    ' ' '   '   '   '
+ *  2    ' ' '   '___'___'      To know how to modify the profile (add a
+ *  3    '_'_'   |___|___|      zone or remove it) we do a binary
+ *  4    | | |___ ___           search of the top and bottom value on the
+ *  5    |_| |   |   |          profile array. Depending on the result index
+ *  6      |_|___|___|          parity (odd or even), because zone boundaries
+ *  7                           go by pairs, we know if we are in a zone or
+ *                              not and how operate.
+ */
+/**
+ * Recompute the zone without the cells in toRemoveZones and avoid overlapping.
+ * This compute is particularly useful because after this function:
+ * - you will find coordinate of a cell only once among all the zones
+ * - the number of zones will be reduced to the minimum
+ */
+export declare function futureRecomputeZones<Z extends Zone | UnboundedZone>(zones: Z[], zonesToRemove?: Z[]): Z[];
+export declare function modifyProfiles(// export for testing only
+profilesStartingPosition: number[], profiles: Map<number, number[]>, zones: UnboundedZone[], toRemove?: boolean): void;
+/**
+ * Compares two arrays.
+ * For performance reasons, this function is to be preferred
+ * to 'deepEquals' in the case we know that the inputs are arrays.
+ */
+export declare function deepEqualsArray(arr1: unknown[], arr2: unknown[]): boolean;

package/dist/types/helpers/rectangle.d.ts

@@ -0,0 +1,7 @@
+import { Rect } from "../types";
+/**
+ * Compute the intersection of two rectangles. Returns nothing if the two rectangles don't overlap
+ */
+export declare function rectIntersection(rect1: Rect, rect2: Rect): Rect | undefined;
+/** Compute the union of the rectangles, ie. the smallest rectangle that contain them all */
+export declare function rectUnion(...rects: Rect[]): Rect;

package/dist/types/helpers/reference_type.d.ts

@@ -0,0 +1,9 @@
+import { Token } from "../formulas";
+/**
+ * Change the reference types inside the given token, if the token represent a range or a cell
+ *
+ * Eg. :
+ *   A1 => $A$1 => A$1 => $A1 => A1
+ *   A1:$B$1 => $A$1:B$1 => A$1:$B1 => $A1:B1 => A1:$B$1
+ */
+export declare function loopThroughReferenceType(token: Readonly<Token>): Token;

package/dist/types/helpers/references.d.ts

@@ -0,0 +1,23 @@
+/** Reference of a cell (eg. A1, $B$5) */
+export declare const cellReference: RegExp;
+/** Reference of a cell or a range, it can be a bounded range, a full row or a full column */
+export declare const rangeReference: RegExp;
+/**
+ * Return true if the given xc is the reference of a column (e.g. A or AC or Sheet1!A)
+ */
+export declare function isColReference(xc: string): boolean;
+/**
+ * Return true if the given xc is the reference of a column (e.g. 1 or Sheet1!1)
+ */
+export declare function isRowReference(xc: string): boolean;
+export declare function isColHeader(str: string): boolean;
+export declare function isRowHeader(str: string): boolean;
+/**
+ * Return true if the given xc is the reference of a single cell,
+ * without any specified sheet (e.g. A1)
+ */
+export declare function isSingleCellReference(xc: string): boolean;
+export declare function splitReference(ref: string): {
+    sheetName?: string;
+    xc: string;
+};

package/dist/types/helpers/search.d.ts

@@ -0,0 +1,19 @@
+/** Methods from Odoo Web Utils  */
+/**
+ * This function computes a score that represent the fact that the
+ * string contains the pattern, or not
+ *
+ * - If the score is 0, the string does not contain the letters of the pattern in
+ *   the correct order.
+ * - if the score is > 0, it actually contains the letters.
+ *
+ * Better matches will get a higher score: consecutive letters are better,
+ * and a match closer to the beginning of the string is also scored higher.
+ */
+export declare function fuzzyMatch(pattern: string, str: string): number;
+/**
+ * Return a list of things that matches a pattern, ordered by their 'score' (
+ * higher score first). An higher score means that the match is better. For
+ * example, consecutive letters are considered a better match.
+ */
+export declare function fuzzyLookup<T>(pattern: string, list: T[], fn: (t: T) => string): T[];

package/dist/types/helpers/sheet.d.ts

@@ -0,0 +1,7 @@
+import { HeaderIndex, Row } from "../types";
+export declare function createDefaultRows(rowNumber: number): Row[];
+export declare function moveHeaderIndexesOnHeaderAddition(indexHeaderAdded: HeaderIndex, numberAdded: number, headers: HeaderIndex[]): HeaderIndex[];
+export declare function moveHeaderIndexesOnHeaderDeletion(deletedHeaders: HeaderIndex[], headers: HeaderIndex[]): HeaderIndex[];
+export declare function getNextSheetName(existingNames: string[], baseName?: string): string;
+export declare function getDuplicateSheetName(nameToDuplicate: string, existingNames: string[]): string;
+export declare function isSheetNameEqual(name1: string | undefined, name2: string | undefined): boolean;

package/dist/types/helpers/sort.d.ts

@@ -0,0 +1,16 @@
+import { CellValue, CellValueType, EvaluatedCell, Position, SortDirection, SpreadsheetChildEnv, UID, Zone } from "../types";
+type CellWithIndex = {
+    index: number;
+    type: CellValueType;
+    value: any;
+};
+export declare function cellsSortingCriterion(sortingOrder: string): (left: {
+    type: CellValueType;
+    value: CellValue;
+}, right: {
+    type: CellValueType;
+    value: CellValue;
+}) => number;
+export declare function sortCells(cells: EvaluatedCell[], sortDirection: SortDirection, emptyCellAsZero: boolean): CellWithIndex[];
+export declare function interactiveSortSelection(env: SpreadsheetChildEnv, sheetId: UID, anchor: Position, zone: Zone, sortDirection: SortDirection): void;
+export {};

package/dist/types/helpers/state_manager_helpers.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Create an empty structure according to the type of the node key:
+ * string: object
+ * number: array
+ */
+export declare function createEmptyStructure(node: string | number | any): {};

package/dist/types/helpers/text_helper.d.ts

@@ -0,0 +1,28 @@
+import { Cell, Locale, Pixel, PixelPosition, Style } from "../types";
+export declare function computeTextLinesHeight(textLineHeight: number, numberOfLines?: number): number;
+/**
+ * Get the default height of the cell given its style.
+ */
+export declare function getDefaultCellHeight(ctx: CanvasRenderingContext2D, cell: Cell | undefined, locale: Locale, colSize: number): number;
+export declare function getCellContentHeight(ctx: CanvasRenderingContext2D, content: string, style: Style | undefined, colSize: number): number;
+export declare function computeTextWidth(context: CanvasRenderingContext2D, text: string, style: Style): number;
+export declare function fontSizeInPixels(fontSize: number): number;
+export declare function computeTextFont(style: Style): string;
+export declare function computeTextFontSizeInPixels(style?: Style): number;
+/**
+ * Return the given text, split in multiple lines if needed. The text will be split in multiple
+ * line if it contains NEWLINE characters, or if it's longer than the given width.
+ */
+export declare function splitTextToWidth(ctx: CanvasRenderingContext2D, text: string, style: Style | undefined, width: number | undefined): string[];
+/**
+ * Return the font size that makes the width of a text match the given line width.
+ * Minimum font size is 1.
+ *
+ * @param getTextWidth function that takes a fontSize as argument, and return the width of the text with this font size.
+ */
+export declare function getFontSizeMatchingWidth(lineWidth: number, maxFontSize: number, getTextWidth: (fontSize: number) => number, precision?: number): number;
+export declare function computeIconWidth(style: Style): number;
+/** Transform a string to lower case. If the string is undefined, return an empty string */
+export declare function toLowerCase(str: string | undefined): string;
+export declare function getContextFontSize(font: string): Pixel;
+export declare function drawDecoratedText(context: CanvasRenderingContext2D, text: string, position: PixelPosition, underline?: boolean | undefined, strikethrough?: boolean | undefined, strokeWidth?: number): void;

package/dist/types/helpers/ui/cut_interactive.d.ts

@@ -0,0 +1,2 @@
+import { SpreadsheetChildEnv } from "../../types";
+export declare function interactiveCut(env: SpreadsheetChildEnv): void;

package/dist/types/helpers/ui/filter_interactive.d.ts

@@ -0,0 +1,7 @@
+import { SpreadsheetChildEnv, UID, Zone } from "../../types";
+export declare const AddFilterInteractiveContent: {
+    filterOverlap: string;
+    nonContinuousTargets: string;
+    mergeInFilter: string;
+};
+export declare function interactiveAddFilter(env: SpreadsheetChildEnv, sheetId: UID, target: Zone[]): void;

package/dist/types/helpers/ui/freeze_interactive.d.ts

@@ -0,0 +1,2 @@
+import { Dimension, HeaderIndex, SpreadsheetChildEnv } from "../../types";
+export declare function interactiveFreezeColumnsRows(env: SpreadsheetChildEnv, dimension: Dimension, base: HeaderIndex): void;

package/dist/types/helpers/ui/merge_interactive.d.ts

@@ -0,0 +1,6 @@
+import { SpreadsheetChildEnv, UID, Zone } from "../../types";
+export declare const AddMergeInteractiveContent: {
+    MergeIsDestructive: string;
+    MergeInFilter: string;
+};
+export declare function interactiveAddMerge(env: SpreadsheetChildEnv, sheetId: UID, target: Zone[]): void;

package/dist/types/helpers/ui/paste_interactive.d.ts

@@ -0,0 +1,10 @@
+import { ClipboardPasteOptions, DispatchResult, SpreadsheetChildEnv, Zone } from "../../types";
+export declare const PasteInteractiveContent: {
+    wrongPasteSelection: string;
+    willRemoveExistingMerge: string;
+    wrongFigurePasteOption: string;
+    frozenPaneOverlap: string;
+};
+export declare function handlePasteResult(env: SpreadsheetChildEnv, result: DispatchResult): void;
+export declare function interactivePaste(env: SpreadsheetChildEnv, target: Zone[], pasteOption?: ClipboardPasteOptions): void;
+export declare function interactivePasteFromOS(env: SpreadsheetChildEnv, target: Zone[], text: string, pasteOption?: ClipboardPasteOptions): void;

package/dist/types/helpers/ui/sheet_interactive.d.ts

@@ -0,0 +1,2 @@
+import { SpreadsheetChildEnv, UID } from "../../types";
+export declare function interactiveRenameSheet(env: SpreadsheetChildEnv, sheetId: UID, name: string, errorCallback: () => void): void;

package/dist/types/helpers/ui/split_to_columns_interactive.d.ts

@@ -0,0 +1,6 @@
+import { SpreadsheetChildEnv } from "../../types";
+import { DispatchResult } from "./../../types/commands";
+export declare const SplitToColumnsInteractiveContent: {
+    SplitIsDestructive: string;
+};
+export declare function interactiveSplitToColumns(env: SpreadsheetChildEnv, separator: string, addNewColumns: boolean): DispatchResult;

package/dist/types/helpers/ui/stop_edition_interactive.d.ts

@@ -0,0 +1,2 @@
+import { SpreadsheetChildEnv } from "../../types";
+export declare function interactiveStopEdition(env: SpreadsheetChildEnv): void;

package/dist/types/helpers/ui/toggle_group_interactive.d.ts

@@ -0,0 +1,6 @@
+import { Dimension, HeaderIndex, SpreadsheetChildEnv, UID } from "../../types";
+export declare const ToggleGroupInteractiveContent: {
+    CannotHideAllRows: string;
+    CannotHideAllColumns: string;
+};
+export declare function interactiveToggleGroup(env: SpreadsheetChildEnv, sheetId: UID, dimension: Dimension, start: HeaderIndex, end: HeaderIndex): void;

package/dist/types/helpers/uuid.d.ts

@@ -0,0 +1,20 @@
+export declare class UuidGenerator {
+    private isFastIdStrategy;
+    private fastIdStart;
+    setIsFastStrategy(isFast: boolean): void;
+    /**
+     * Generates a custom UUID using a simple 26^8 method (8-character alphanumeric string with lowercase letters)
+     * This has a higher chance of collision than a UUIDv4, but not only faster to generate than an UUIDV4,
+     * it also has a smaller size, which is preferable to alleviate the overall data size.
+     *
+     * This method is preferable when generating uuids for the core data (sheetId, figureId, etc)
+     * as they will appear several times in the revisions and local history.
+     *
+     */
+    smallUuid(): string;
+    /**
+     * Generates an UUIDV4, has astronomically low chance of collision, but is larger in size than the smallUuid.
+     * This method should be used when you need to avoid collisions at all costs, like the id of a revision.
+     */
+    uuidv4(): string;
+}

package/dist/types/helpers/zones.d.ts

@@ -0,0 +1,173 @@
+import { Position, UnboundedZone, Zone, ZoneDimension } from "../types";
+/**
+ * Convert from a cartesian reference to a Zone
+ * The range boundaries will be kept in the same order as the
+ * ones in the text.
+ * Examples:
+ *    "A1" ==> Top 0, Bottom 0, Left: 0, Right: 0
+ *    "B1:B3" ==> Top 0, Bottom 3, Left: 1, Right: 1
+ *    "Sheet1!A1" ==> Top 0, Bottom 0, Left: 0, Right: 0
+ *    "Sheet1!B1:B3" ==> Top 0, Bottom 3, Left: 1, Right: 1
+ *    "C3:A1" ==> Top 2, Bottom 0, Left 2, Right 0
+ *    "A:A" ==> Top 0, Bottom undefined, Left 0, Right 0
+ *    "A:B3" or "B3:A" ==> Top 2, Bottom undefined, Left 0, Right 1
+ *
+ * @param xc the string reference to convert
+ *
+ */
+export declare function toZoneWithoutBoundaryChanges(xc: string): UnboundedZone;
+/**
+ * Convert from a cartesian reference to a (possibly unbounded) Zone
+ *
+ * Examples:
+ *    "A1" ==> Top 0, Bottom 0, Left: 0, Right: 0
+ *    "B1:B3" ==> Top 0, Bottom 3, Left: 1, Right: 1
+ *    "B:B" ==> Top 0, Bottom undefined, Left: 1, Right: 1
+ *    "B2:B" ==> Top 1, Bottom undefined, Left: 1, Right: 1, hasHeader: 1
+ *    "Sheet1!A1" ==> Top 0, Bottom 0, Left: 0, Right: 0
+ *    "Sheet1!B1:B3" ==> Top 0, Bottom 3, Left: 1, Right: 1
+ *
+ * @param xc the string reference to convert
+ *
+ */
+export declare function toUnboundedZone(xc: string): UnboundedZone;
+export declare function reorderZone<Z extends UnboundedZone | Zone>(zone: Z): void;
+/**
+ * Convert from a cartesian reference to a Zone.
+ * Will return throw an error if given a unbounded zone (eg : A:A).
+ *
+ * Examples:
+ *    "A1" ==> Top 0, Bottom 0, Left: 0, Right: 0
+ *    "B1:B3" ==> Top 0, Bottom 3, Left: 1, Right: 1
+ *    "Sheet1!A1" ==> Top 0, Bottom 0, Left: 0, Right: 0
+ *    "Sheet1!B1:B3" ==> Top 0, Bottom 3, Left: 1, Right: 1
+ *
+ * @param xc the string reference to convert
+ *
+ */
+export declare function toZone(xc: string): Zone;
+export declare function isXcValid(xc: string): boolean;
+/**
+ * Check that the zone has valid coordinates and in
+ * the correct order.
+ */
+export declare function isZoneValid(zone: Zone | UnboundedZone): boolean;
+/**
+ * Check that the zone properties are in the correct order.
+ */
+export declare function isZoneOrdered(zone: Zone | UnboundedZone): boolean;
+/**
+ * Convert from zone to a cartesian reference
+ *
+ */
+export declare function zoneToXc(zone: Zone | UnboundedZone): string;
+/**
+ * Expand a zone after inserting columns or rows.
+ *
+ * Don't resize the zone if a col/row was added right before/after the row but only move the zone.
+ */
+export declare function expandZoneOnInsertion<Z extends UnboundedZone | Zone>(zone: Z, start: "left" | "top", base: number, position: "after" | "before", quantity: number): Z;
+/**
+ * Update the selection after column/row addition
+ */
+export declare function updateSelectionOnInsertion(selection: Zone, start: "left" | "top", base: number, position: "after" | "before", quantity: number): Zone;
+/**
+ * Update the selection after column/row deletion
+ */
+export declare function updateSelectionOnDeletion(zone: Zone, start: "left" | "top", elements: number[]): Zone;
+/**
+ * Reduce a zone after deletion of elements
+ */
+export declare function reduceZoneOnDeletion<Z extends UnboundedZone | Zone>(zone: Z, start: "left" | "top", elements: number[]): Z | undefined;
+/**
+ * Compute the union of multiple zones.
+ */
+export declare function union(...zones: Zone[]): Zone;
+/**
+ * Compute the intersection of two zones. Returns nothing if the two zones don't overlap
+ */
+export declare function intersection(z1: Zone, z2: Zone): Zone | undefined;
+/**
+ * Two zones are equal if they represent the same area, so we clearly cannot use
+ * reference equality.
+ */
+export declare function isEqual(z1: Zone, z2: Zone): boolean;
+/**
+ * Return true if two zones overlap, false otherwise.
+ */
+export declare function overlap(z1: Zone, z2: Zone): boolean;
+export declare function isInside(col: number, row: number, zone: Zone): boolean;
+/**
+ * Check if a zone is inside another
+ */
+export declare function isZoneInside(smallZone: Zone, biggerZone: Zone): boolean;
+/**
+ * Recompute the ranges of the zone to contain all the cells in zones, without the cells in toRemoveZones
+ * Also regroup zones together to shorten the string
+ */
+export declare function recomputeZones(zonesXc: string[], toRemoveZonesXc: string[]): string[];
+/**
+ * Merge aligned adjacent columns into single zones
+ * e.g. A1:A5 and B1:B5 are merged into A1:B5
+ */
+export declare function mergeAlignedColumns(columns: readonly Zone[]): Zone[];
+/**
+ * Merge adjacent positions into vertical zones (columns)
+ */
+export declare function mergePositionsIntoColumns(positions: readonly Position[]): Zone[];
+export declare function zoneToDimension(zone: Zone): ZoneDimension;
+export declare function isOneDimensional(zone: Zone): boolean;
+/**
+ * Array of all positions in the zone.
+ */
+export declare function positions(zone: Zone): Position[];
+export declare function forEachPositionsInZone(zone: Zone, callback: (col: number, row: number) => void): void;
+/**
+ * This function returns a zone with coordinates modified according to the change
+ * applied to the zone. It may be possible to change the zone by resizing or moving
+ * it according to different dimensions.
+ *
+ * @param zone the zone to modify
+ * @param dimension the direction to change the zone among "columns", "rows" and
+ * "both"
+ * @param operation how to change the zone, modify its size "RESIZE" or modify
+ * its location "MOVE"
+ * @param by a number of how many units the change should be made. This parameter
+ * takes the form of a two-number array when the dimension is "both"
+ */
+export declare function createAdaptedZone<Dimension extends "columns" | "rows" | "both", Z extends UnboundedZone | Zone>(zone: Z, dimension: Dimension, operation: "MOVE" | "RESIZE", by: Dimension extends "both" ? [number, number] : number): Z;
+/**
+ * Returns a Zone array with unique occurrence of each zone.
+ * For each multiple occurrence, the occurrence with the largest index is kept.
+ * This allows to always have the last selection made in the last position.
+ * */
+export declare function uniqueZones(zones: Zone[]): Zone[];
+/**
+ * This function will find all overlapping zones in an array and transform them
+ * into an union of each one.
+ * */
+export declare function mergeOverlappingZones(zones: Zone[]): Zone[];
+/**
+ * This function will compare the modifications of selection to determine
+ * a cell that is part of the new zone and not the previous one.
+ */
+export declare function findCellInNewZone(oldZone: Zone, currentZone: Zone): Position;
+export declare function organizeZone(zone: Zone): Zone;
+export declare function positionToZone(position: Position): {
+    left: import("../types").HeaderIndex;
+    right: import("../types").HeaderIndex;
+    top: import("../types").HeaderIndex;
+    bottom: import("../types").HeaderIndex;
+};
+export declare function isFullRow(zone: UnboundedZone): boolean;
+/** Returns the area of a zone */
+export declare function getZoneArea(zone: Zone): number;
+/**
+ * Check if the zones are continuous, ie. if they can be merged into a single zone without
+ * including cells outside the zones
+ * */
+export declare function areZonesContinuous(...zones: Zone[]): boolean;
+/** Return all the columns in the given list of zones */
+export declare function getZonesCols(zones: Zone[]): Set<number>;
+/** Return all the rows in the given list of zones */
+export declare function getZonesRows(zones: Zone[]): Set<number>;

package/dist/types/history/branch.d.ts

@@ -0,0 +1,62 @@
+import { Transformation, TransformationFactory, UID } from "../types";
+import { Operation } from "./operation";
+/**
+ * A branch holds a sequence of operations.
+ * It can be represented as "A - B - C - D" if A, B, C and D are executed one
+ * after the other.
+ *
+ * @param buildTransformation Factory to build transformations
+ * @param operations initial operations
+ */
+export declare class Branch<T> {
+    private readonly buildTransformation;
+    private operations;
+    constructor(buildTransformation: TransformationFactory<T>, operations?: Operation<T>[]);
+    getOperations(): readonly Operation<T>[];
+    getOperation(operationId: UID): Operation<T>;
+    getLastOperationId(): UID | undefined;
+    /**
+     * Get the id of the operation appears first in the list of operations
+     */
+    getFirstOperationAmong(op1: UID, op2: UID): UID;
+    contains(operationId: UID): boolean;
+    /**
+     * Add the given operation as the first operation
+     */
+    prepend(operation: Operation<T>): void;
+    /**
+     * add the given operation after the given predecessorOpId
+     */
+    insert(newOperation: Operation<T>, predecessorOpId: UID): void;
+    /**
+     * Add the given operation as the last operation
+     */
+    append(operation: Operation<T>): void;
+    /**
+     * Append operations in the given branch to this branch.
+     */
+    appendBranch(branch: Branch<T>): void;
+    /**
+     * Create and return a copy of this branch, starting after the given operationId
+     */
+    fork(operationId: UID): Branch<T>;
+    /**
+     * Transform all the operations in this branch with the given transformation
+     */
+    transform(transformation: Transformation<T>): void;
+    /**
+     * Cut the branch before the operation, meaning the operation
+     * and all following operations are dropped.
+     */
+    cutBefore(operationId: UID): void;
+    /**
+     * Cut the branch after the operation, meaning all following operations are dropped.
+     */
+    cutAfter(operationId: UID): void;
+    /**
+     * Find an operation in this branch based on its id.
+     * This returns the operation itself, operations which comes before it
+     * and operation which comes after it.
+     */
+    private locateOperation;
+}

package/dist/types/history/factory.d.ts

@@ -0,0 +1,9 @@
+import { Revision } from "../collaborative/revisions";
+import { StateObserver } from "../state_observer";
+import { CoreCommand, UID } from "../types";
+import { SelectiveHistory } from "./selective_history";
+export declare function buildRevisionLog(args: {
+    initialRevisionId: UID;
+    recordChanges: StateObserver["recordChanges"];
+    dispatch: (command: CoreCommand) => void;
+}): SelectiveHistory<Revision>;

package/dist/types/history/operation.d.ts

@@ -0,0 +1,17 @@
+import { Transformation, UID } from "../types";
+/**
+ * An Operation can be executed to change a data structure from state A
+ * to state B.
+ * It should hold the necessary data used to perform this transition.
+ * It should be possible to revert the changes made by this operation.
+ *
+ * In the context of o-spreadsheet, the data from an operation would
+ * be a revision (the commands are used to execute it, the `changes` are used
+ * to revert it).
+ */
+export declare class Operation<T> {
+    readonly id: UID;
+    readonly data: T;
+    constructor(id: UID, data: T);
+    transformed(transformation: Transformation<T>): Operation<T>;
+}

package/dist/types/history/operation_sequence.d.ts

@@ -0,0 +1,31 @@
+import { OperationSequenceNode, UID } from "../types";
+/**
+ * An execution object is a sequence of executionSteps (each execution step is an operation in a branch).
+ *
+ * You can iterate over the steps of an execution
+ * ```js
+ * for (const operation of execution) {
+ *   // ... do something
+ * }
+ * ```
+ */
+export declare class OperationSequence<T> implements Iterable<OperationSequenceNode<T>> {
+    private readonly operations;
+    constructor(operations: Iterable<OperationSequenceNode<T>>);
+    [Symbol.iterator](): Iterator<OperationSequenceNode<T>, void>;
+    /**
+     * Stop the operation sequence at a given operation
+     * @param operationId included
+     */
+    stopWith(operationId: UID): OperationSequence<T>;
+    /**
+     * Stop the operation sequence before a given operation
+     * @param operationId excluded
+     */
+    stopBefore(operationId: UID): OperationSequence<T>;
+    /**
+     * Start the operation sequence at a given operation
+     * @param operationId excluded
+     */
+    startAfter(operationId: UID): OperationSequence<T>;
+}

package/dist/types/history/repeat_commands/repeat_commands_generic.d.ts

@@ -0,0 +1,6 @@
+import { Command, Getters } from "../../types";
+export declare const genericRepeatsTransforms: (typeof repeatSheetDependantCommand)[];
+export declare function repeatSheetDependantCommand<T extends Command>(getters: Getters, command: T): T;
+export declare function repeatTargetDependantCommand<T extends Command>(getters: Getters, command: T): T;
+export declare function repeatZoneDependantCommand<T extends Command>(getters: Getters, command: T): T;
+export declare function repeatPositionDependantCommand<T extends Command>(getters: Getters, command: T): T;