@odoo/o-spreadsheet 17.0.85 → 17.0.96

package/dist/types/plugins/core/filters.d.ts

@@ -0,0 +1,43 @@
+import { Filter, FilterTable } from "../../helpers/filters";
+import { CellPosition, CommandResult, CoreCommand, ExcelWorkbookData, FilterId, FilterTableId, Position, UID, WorkbookData, Zone } from "../../types/index";
+import { CorePlugin } from "../core_plugin";
+interface FiltersState {
+    tables: Record<UID, Record<FilterTableId, FilterTable | undefined>>;
+}
+export declare class FiltersPlugin extends CorePlugin<FiltersState> implements FiltersState {
+    static getters: readonly ["doesZonesContainFilter", "getFilter", "getFilters", "getFilterTable", "getFilterTables", "getFilterTablesInZone", "getFilterId", "getFilterHeaders", "isFilterHeader"];
+    readonly tables: Record<UID, Record<FilterTableId, FilterTable | undefined>>;
+    allowDispatch(cmd: CoreCommand): CommandResult | CommandResult[];
+    handle(cmd: CoreCommand): void;
+    getFilters(sheetId: UID): Filter[];
+    getFilterTables(sheetId: UID): FilterTable[];
+    getFilter(position: CellPosition): Filter | undefined;
+    getFilterId(position: CellPosition): FilterId | undefined;
+    getFilterTable({ sheetId, col, row }: CellPosition): FilterTable | undefined;
+    /** Get the filter tables that are fully inside the given zone */
+    getFilterTablesInZone(sheetId: UID, zone: Zone): FilterTable[];
+    doesZonesContainFilter(sheetId: UID, zones: Zone[]): boolean;
+    getFilterHeaders(sheetId: UID): Position[];
+    isFilterHeader({ sheetId, col, row }: CellPosition): boolean;
+    private onAddColumnsRows;
+    private onDeleteColumnsRows;
+    private createFilterTable;
+    /** Extend a table down one row */
+    private extendTableDown;
+    /**
+     * Check if an UpdateCell command should cause the given table to be extended by one row.
+     *
+     * The table should be extended if all of these conditions are true:
+     * 1) The updated cell is right below the table
+     * 2) The command adds a content to the cell
+     * 3) No cell right below the table had any content before the command
+     * 4) Extending the table down would not overlap with another filter
+     * 5) Extending the table down would not overlap with a merge
+     *
+     */
+    private canUpdateCellCmdExtendTable;
+    import(data: WorkbookData): void;
+    export(data: WorkbookData): void;
+    exportForExcel(data: ExcelWorkbookData): void;
+}
+export {};

package/dist/types/plugins/core/header_grouping.d.ts

@@ -0,0 +1,82 @@
+import { CommandResult, CoreCommand, UID, WorkbookData } from "../../types";
+import { Dimension, HeaderGroup, HeaderIndex, Zone } from "./../../types/misc";
+import { CorePlugin } from "./../core_plugin";
+interface State {
+    groups: Record<UID, Record<Dimension, HeaderGroup[]>>;
+}
+export declare class HeaderGroupingPlugin extends CorePlugin<State> {
+    static getters: readonly ["getHeaderGroups", "getGroupsLayers", "getVisibleGroupLayers", "getHeaderGroup", "getHeaderGroupsInZone", "isGroupFolded", "isRowFolded", "isColFolded"];
+    private readonly groups;
+    allowDispatch(cmd: CoreCommand): CommandResult;
+    handle(cmd: CoreCommand): void;
+    getHeaderGroups(sheetId: UID, dim: Dimension): HeaderGroup[];
+    getHeaderGroup(sheetId: UID, dim: Dimension, start: number, end: number): HeaderGroup | undefined;
+    getHeaderGroupsInZone(sheetId: UID, dim: Dimension, zone: Zone): HeaderGroup[];
+    /**
+     * Get all the groups of a sheet in a dimension, and return an array of layers of those groups.
+     *
+     * The layering rules are:
+     * 1) A group containing another group should be on a layer above the group it contains
+     * 2) The widest/highest groups should be on the left/top layer compared to the groups it contains
+     * 3) The group should be on the left/top-most layer possible, barring intersections with other groups (see rules 1 and 2)
+     */
+    getGroupsLayers(sheetId: UID, dimension: Dimension): HeaderGroup[][];
+    /**
+     * Get all the groups of a sheet in a dimension, and return an array of layers of those groups,
+     * excluding the groups that are totally hidden.
+     */
+    getVisibleGroupLayers(sheetId: UID, dimension: Dimension): HeaderGroup[][];
+    isGroupFolded(sheetId: UID, dimension: Dimension, start: number, end: number): boolean;
+    isRowFolded(sheetId: UID, row: HeaderIndex): boolean;
+    isColFolded(sheetId: UID, col: HeaderIndex): boolean;
+    private getGroupId;
+    /**
+     * To get layers of groups, and to add/remove headers from groups, we can see each header of a group as a brick. Each
+     * brick falls down in the pile corresponding to its header, until it hits another brick, or the ground.
+     *
+     * With this abstraction, we can very simply group/ungroup headers from groups, and get the layers of groups.
+     * - grouping headers is done by adding a brick to each header pile
+     * - un-grouping headers is done by removing a brick from each header pile
+     * - getting the layers of groups is done by simply letting the brick fall and checking the result
+     *
+     * Example:
+     * We have 2 groups ([A=>E] and [C=>D]), and we want to group headers [C=>F]
+     *
+     * Headers :                 A B C D E F G          A B C D E F G            A B C D E F G
+     * Headers to group: [C=>D]:     _ _         [C=>F]:    _ _ _ _
+     *                               | |           ==>      | | | |       ==>                    ==> Result: 3 groups
+     *                               | |                    ˅ ˅ | |                  _ _                - [C=>D]
+     * Groups:                       ˅ ˅                    _ _ ˅ |                  _ _ _              - [C=>E]
+     * Groups:                   _ _ _ _ _              _ _ _ _ _ ˅              _ _ _ _ _ _            - [A=>F]
+  
+     * @param groups
+     * @param start start of the range where to add/remove headers
+     * @param end end of the range where to add/remove headers
+     * @param delta -1: remove headers, 1: add headers, 0: get layers (don't add/remove anything)
+     */
+    private bricksFallingAlgorithm;
+    private groupHeaders;
+    /**
+     * Ungroup the given headers. The headers will be taken out of the group they are in. This might split a group into two
+     * if the headers were in the middle of a group. If multiple groups contains a header, it will only be taken out of the
+     * lowest group in the layering of the groups.
+     */
+    private unGroupHeaders;
+    private moveGroupsOnHeaderInsertion;
+    private moveGroupsOnHeaderDeletion;
+    private doGroupOverlap;
+    private removeDuplicateGroups;
+    private findGroupWithStartEnd;
+    /**
+     * Fold the given group, and all the groups starting at the same index that are contained inside the given group.
+     */
+    private foldHeaderGroup;
+    /**
+     * Unfold the given group, and all the groups starting at the same index that contain the given group.
+     */
+    private unfoldHeaderGroup;
+    private getGroupIndex;
+    import(data: WorkbookData): void;
+    export(data: WorkbookData): void;
+}
+export {};

package/dist/types/plugins/core/header_size.d.ts

@@ -0,0 +1,23 @@
+import { Command, ExcelWorkbookData, WorkbookData } from "../../types";
+import { Dimension, HeaderIndex, Pixel, UID } from "../../types/misc";
+import { CorePlugin } from "../core_plugin";
+interface HeaderSizeState {
+    sizes: Record<UID, Record<Dimension, Array<Pixel | undefined>>>;
+}
+export declare class HeaderSizePlugin extends CorePlugin<HeaderSizeState> implements HeaderSizeState {
+    static getters: readonly ["getUserRowSize", "getColSize"];
+    readonly sizes: Record<UID, Record<Dimension, Array<Pixel | undefined>>>;
+    handle(cmd: Command): void;
+    getColSize(sheetId: UID, index: HeaderIndex): Pixel;
+    getUserRowSize(sheetId: UID, index: HeaderIndex): Pixel | undefined;
+    import(data: WorkbookData): void;
+    exportForExcel(data: ExcelWorkbookData): void;
+    export(data: WorkbookData): void;
+    /**
+     * Export the header sizes
+     *
+     * @param exportDefaults : if true, export column/row sizes even if they have the default size
+     */
+    exportData(data: WorkbookData, exportDefaults?: boolean): void;
+}
+export {};

package/dist/types/plugins/core/header_visibility.d.ts

@@ -0,0 +1,20 @@
+import { Command, CommandResult, ExcelWorkbookData, WorkbookData } from "../../types";
+import { ConsecutiveIndexes, Dimension, HeaderIndex, UID } from "../../types/misc";
+import { CorePlugin } from "../core_plugin";
+export declare class HeaderVisibilityPlugin extends CorePlugin {
+    static getters: readonly ["checkElementsIncludeAllVisibleHeaders", "getHiddenColsGroups", "getHiddenRowsGroups", "isHeaderHiddenByUser", "isRowHiddenByUser", "isColHiddenByUser"];
+    private readonly hiddenHeaders;
+    allowDispatch(cmd: Command): CommandResult.Success | CommandResult.NotEnoughElements | CommandResult.InvalidSheetId | CommandResult.TooManyHiddenElements | CommandResult.InvalidHeaderIndex;
+    handle(cmd: Command): void;
+    checkElementsIncludeAllVisibleHeaders(sheetId: UID, dimension: Dimension, elements: HeaderIndex[]): boolean;
+    isHeaderHiddenByUser(sheetId: UID, dimension: Dimension, index: HeaderIndex): boolean;
+    isRowHiddenByUser(sheetId: UID, index: HeaderIndex): boolean;
+    isColHiddenByUser(sheetId: UID, index: HeaderIndex): boolean;
+    getHiddenColsGroups(sheetId: UID): ConsecutiveIndexes[];
+    getHiddenRowsGroups(sheetId: UID): ConsecutiveIndexes[];
+    private getAllVisibleHeaders;
+    import(data: WorkbookData): void;
+    exportForExcel(data: ExcelWorkbookData): void;
+    export(data: WorkbookData): void;
+    exportData(data: WorkbookData, exportDefaults?: boolean): void;
+}

package/dist/types/plugins/core/image.d.ts

@@ -0,0 +1,32 @@
+import { FileStore } from "../../types/files";
+import { Image } from "../../types/image";
+import { CommandResult, CoreCommand, ExcelWorkbookData, FigureSize, UID, WorkbookData } from "../../types/index";
+import { CorePlugin, CorePluginConfig } from "../core_plugin";
+interface ImageState {
+    readonly images: Record<UID, Record<UID, Image | undefined> | undefined>;
+}
+export declare class ImagePlugin extends CorePlugin<ImageState> implements ImageState {
+    static getters: readonly ["getImage", "getImagePath", "getImageSize"];
+    readonly fileStore?: FileStore;
+    readonly images: Record<UID, Record<UID, Image | undefined> | undefined>;
+    /**
+     * paths of images synced with the file store server.
+     */
+    readonly syncedImages: Set<Image["path"]>;
+    constructor(config: CorePluginConfig);
+    allowDispatch(cmd: CoreCommand): CommandResult.Success | CommandResult.InvalidFigureId;
+    handle(cmd: CoreCommand): void;
+    /**
+     * Delete unused images from the file store
+     */
+    garbageCollectExternalResources(): void;
+    getImage(figureId: UID): Image;
+    getImagePath(figureId: UID): string;
+    getImageSize(figureId: UID): FigureSize;
+    private addImage;
+    import(data: WorkbookData): void;
+    export(data: WorkbookData): void;
+    exportForExcel(data: ExcelWorkbookData): void;
+    private getAllImages;
+}
+export {};

package/dist/types/plugins/core/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./borders";
+export * from "./cell";
+export * from "./chart";
+export * from "./conditional_format";
+export * from "./data_validation";
+export * from "./figures";
+export * from "./filters";
+export * from "./header_size";
+export * from "./header_visibility";
+export * from "./image";
+export * from "./merge";
+export * from "./range";
+export * from "./sheet";

package/dist/types/plugins/core/merge.d.ts

@@ -0,0 +1,83 @@
+import { ApplyRangeChange, CellPosition, CommandResult, CoreCommand, ExcelWorkbookData, HeaderIndex, Merge, Range, UID, WorkbookData, Zone } from "../../types/index";
+import { CorePlugin } from "../core_plugin";
+type SheetMergeCellMap = Record<number, Record<number, number | undefined> | undefined>;
+interface MergeState {
+    readonly merges: Record<UID, Record<number, Range | undefined> | undefined>;
+    readonly mergeCellMap: Record<UID, SheetMergeCellMap | undefined>;
+}
+export declare class MergePlugin extends CorePlugin<MergeState> implements MergeState {
+    static getters: readonly ["isInMerge", "isInSameMerge", "isMergeHidden", "getMainCellPosition", "getBottomLeftCell", "expandZone", "doesIntersectMerge", "doesColumnsHaveCommonMerges", "doesRowsHaveCommonMerges", "getMerges", "getMerge", "getMergesInZone", "isSingleCellOrMerge", "getSelectionRangeString", "isMainCellPosition"];
+    private nextId;
+    readonly merges: Record<UID, Record<number, Range | undefined> | undefined>;
+    readonly mergeCellMap: Record<UID, SheetMergeCellMap | undefined>;
+    allowDispatch(cmd: CoreCommand): CommandResult | CommandResult[];
+    handle(cmd: CoreCommand): void;
+    adaptRanges(applyChange: ApplyRangeChange, sheetId?: UID): void;
+    getMerges(sheetId: UID): Merge[];
+    getMerge({ sheetId, col, row }: CellPosition): Merge | undefined;
+    getMergesInZone(sheetId: UID, zone: Zone): Merge[];
+    /**
+     * Same as `getRangeString` but add all necessary merge to the range to make it a valid selection
+     */
+    getSelectionRangeString(range: Range, forSheetId: UID): string;
+    /**
+     * Return true if the zone intersects an existing merge:
+     * if they have at least a common cell
+     */
+    doesIntersectMerge(sheetId: UID, zone: Zone): boolean;
+    /**
+     * Returns true if two columns have at least one merge in common
+     */
+    doesColumnsHaveCommonMerges(sheetId: string, colA: HeaderIndex, colB: HeaderIndex): boolean;
+    /**
+     * Returns true if two rows have at least one merge in common
+     */
+    doesRowsHaveCommonMerges(sheetId: string, rowA: HeaderIndex, rowB: HeaderIndex): boolean;
+    /**
+     * Add all necessary merge to the current selection to make it valid
+     */
+    expandZone(sheetId: UID, zone: Zone): Zone;
+    isInSameMerge(sheetId: UID, colA: HeaderIndex, rowA: HeaderIndex, colB: HeaderIndex, rowB: HeaderIndex): boolean;
+    isInMerge({ sheetId, col, row }: CellPosition): boolean;
+    getMainCellPosition(position: CellPosition): CellPosition;
+    getBottomLeftCell(position: CellPosition): CellPosition;
+    isMergeHidden(sheetId: UID, merge: Merge): boolean;
+    /**
+     * Check if the zone represents a single cell or a single merge.
+     */
+    isSingleCellOrMerge(sheetId: UID, zone: Zone): boolean;
+    isMainCellPosition(position: CellPosition): boolean;
+    /**
+     * Return true if the current selection requires losing state if it is merged.
+     * This happens when there is some textual content in other cells than the
+     * top left.
+     */
+    private isMergeDestructive;
+    private getMergeById;
+    private checkDestructiveMerge;
+    private checkOverlap;
+    private checkFrozenPanes;
+    /**
+     * The content of a merged cell should always be empty.
+     * Except for the top-left cell.
+     */
+    private checkMergedContentUpdate;
+    private checkMergeExists;
+    /**
+     * Merge the current selection. Note that:
+     * - it assumes that we have a valid selection (no intersection with other
+     *   merges)
+     * - it does nothing if the merge is trivial: A1:A1
+     */
+    private addMerge;
+    private removeMerge;
+    /**
+     * Apply a range change on merges of a particular sheet.
+     */
+    private applyRangeChangeOnSheet;
+    import(data: WorkbookData): void;
+    private importMerges;
+    export(data: WorkbookData): void;
+    exportForExcel(data: ExcelWorkbookData): void;
+}
+export {};

package/dist/types/plugins/core/range.d.ts

@@ -0,0 +1,59 @@
+import { RangeImpl } from "../../helpers/index";
+import { Command, CommandHandler, CommandResult, CoreCommand, CoreGetters, Range, RangeData, RangeProvider, UID, UnboundedZone, Zone } from "../../types/index";
+export declare class RangeAdapter implements CommandHandler<CoreCommand> {
+    private getters;
+    private providers;
+    constructor(getters: CoreGetters);
+    static getters: readonly ["getRangeString", "getRangeFromSheetXC", "createAdaptedRanges", "getRangeDataFromXc", "getRangeDataFromZone", "getRangeFromRangeData", "getRangeFromZone"];
+    allowDispatch(cmd: Command): CommandResult;
+    beforeHandle(command: Command): void;
+    handle(cmd: Command): void;
+    finalize(): void;
+    /**
+     * Return a modified adapting function that verifies that after adapting a range, the range is still valid.
+     * Any range that gets adapted by the function adaptRange in parameter does so
+     * without caring if the start and end of the range in both row and column
+     * direction can be incorrect. This function ensure that an incorrect range gets removed.
+     */
+    private verifyRangeRemoved;
+    private createAdaptedRange;
+    private executeOnAllRanges;
+    /**
+     * Stores the functions bound to each plugin to be able to iterate over all ranges of the application,
+     * without knowing any details of the internal data structure of the plugins and without storing ranges
+     * in the range adapter.
+     *
+     * @param provider a function bound to a plugin that will loop over its internal data structure to find
+     * all ranges
+     */
+    addRangeProvider(provider: RangeProvider["adaptRanges"]): void;
+    createAdaptedRanges(ranges: Range[], offsetX: number, offsetY: number, sheetId: UID): Range[];
+    /**
+     * Creates a range from a XC reference that can contain a sheet reference
+     * @param defaultSheetId the sheet to default to if the sheetXC parameter does not contain a sheet reference (usually the active sheet Id)
+     * @param sheetXC the string description of a range, in the form SheetName!XC:XC
+     */
+    getRangeFromSheetXC(defaultSheetId: UID, sheetXC: string): RangeImpl;
+    /**
+     * Gets the string that represents the range as it is at the moment of the call.
+     * The string will be prefixed with the sheet name if the call specified a sheet id in `forSheetId`
+     * different than the sheet on which the range has been created.
+     *
+     * @param range the range (received from getRangeFromXC or getRangeFromZone)
+     * @param forSheetId the id of the sheet where the range string is supposed to be used.
+     * @param options
+     * @param options.useFixedReference if true, the range will be returned with fixed row and column
+     */
+    getRangeString(range: Range, forSheetId: UID, options?: {
+        useFixedReference: boolean;
+    }): string;
+    getRangeDataFromXc(sheetId: UID, xc: string): RangeData;
+    getRangeDataFromZone(sheetId: UID, zone: Zone | UnboundedZone): RangeData;
+    getRangeFromZone(sheetId: UID, zone: Zone | UnboundedZone): Range;
+    getRangeFromRangeData(data: RangeData): Range;
+    /**
+     * Get a Xc string that represent a part of a range
+     */
+    private getRangePartString;
+    private getInvalidRange;
+}

package/dist/types/plugins/core/settings.d.ts

@@ -0,0 +1,12 @@
+import { CommandResult, CoreCommand, Locale, WorkbookData } from "../../types";
+import { CorePlugin } from "./../core_plugin";
+export declare class SettingsPlugin extends CorePlugin {
+    static getters: readonly ["getLocale"];
+    private locale;
+    allowDispatch(cmd: CoreCommand): CommandResult.Success | CommandResult.InvalidLocale;
+    handle(cmd: CoreCommand): void;
+    getLocale(): Locale;
+    private changeCellsDateFormatWithLocale;
+    import(data: WorkbookData): void;
+    export(data: WorkbookData): void;
+}

package/dist/types/plugins/core/sheet.d.ts

@@ -0,0 +1,151 @@
+import { Cell, CellPosition, Command, CommandResult, CoreCommand, Dimension, ExcelWorkbookData, HeaderIndex, PaneDivision, Row, Sheet, UID, UnboundedZone, WorkbookData, Zone, ZoneDimension } from "../../types/index";
+import { CorePlugin } from "../core_plugin";
+interface SheetState {
+    readonly sheets: Record<UID, Sheet | undefined>;
+    readonly orderedSheetIds: UID[];
+    readonly sheetIdsMapName: Record<string, UID | undefined>;
+    readonly cellPosition: Record<UID, CellPosition | undefined>;
+}
+export declare class SheetPlugin extends CorePlugin<SheetState> implements SheetState {
+    static getters: readonly ["getSheetName", "tryGetSheetName", "getSheet", "tryGetSheet", "getSheetIdByName", "getSheetIds", "getVisibleSheetIds", "isSheetVisible", "getEvaluationSheets", "doesHeaderExist", "doesHeadersExist", "getCell", "getCellPosition", "getColsZone", "getRowCells", "getRowsZone", "getNumberCols", "getNumberRows", "getNumberHeaders", "getGridLinesVisibility", "getNextSheetName", "getSheetSize", "getSheetZone", "getPaneDivisions", "checkZonesExistInSheet", "getCommandZones", "getUnboundedZone", "checkElementsIncludeAllNonFrozenHeaders", "getDuplicateSheetName"];
+    readonly sheetIdsMapName: Record<string, UID | undefined>;
+    readonly orderedSheetIds: UID[];
+    readonly sheets: Record<UID, Sheet | undefined>;
+    readonly cellPosition: Record<UID, CellPosition | undefined>;
+    allowDispatch(cmd: CoreCommand): CommandResult | CommandResult[];
+    handle(cmd: CoreCommand): void;
+    import(data: WorkbookData): void;
+    private exportSheets;
+    export(data: WorkbookData): void;
+    exportForExcel(data: ExcelWorkbookData): void;
+    getGridLinesVisibility(sheetId: UID): boolean;
+    tryGetSheet(sheetId: UID): Sheet | undefined;
+    getSheet(sheetId: UID): Sheet;
+    isSheetVisible(sheetId: UID): boolean;
+    /**
+     * Return the sheet name. Throw if the sheet is not found.
+     */
+    getSheetName(sheetId: UID): string;
+    /**
+     * Return the sheet name or undefined if the sheet doesn't exist.
+     */
+    tryGetSheetName(sheetId: UID): string | undefined;
+    getSheetIdByName(name: string | undefined): UID | undefined;
+    getSheetIds(): UID[];
+    getVisibleSheetIds(): UID[];
+    getEvaluationSheets(): Record<UID, Sheet | undefined>;
+    doesHeaderExist(sheetId: UID, dimension: Dimension, index: number): boolean;
+    doesHeadersExist(sheetId: UID, dimension: Dimension, headerIndexes: HeaderIndex[]): boolean;
+    getRow(sheetId: UID, index: HeaderIndex): Row;
+    getCell({ sheetId, col, row }: CellPosition): Cell | undefined;
+    getColsZone(sheetId: UID, start: HeaderIndex, end: HeaderIndex): Zone;
+    getRowCells(sheetId: UID, row: HeaderIndex): UID[];
+    getRowsZone(sheetId: UID, start: HeaderIndex, end: HeaderIndex): Zone;
+    getCellPosition(cellId: UID): CellPosition;
+    getNumberCols(sheetId: UID): number;
+    getNumberRows(sheetId: UID): number;
+    getNumberHeaders(sheetId: UID, dimension: Dimension): number;
+    getNextSheetName(baseName?: string): string;
+    getSheetSize(sheetId: UID): ZoneDimension;
+    getSheetZone(sheetId: UID): Zone;
+    getUnboundedZone(sheetId: UID, zone: Zone): UnboundedZone;
+    getPaneDivisions(sheetId: UID): Readonly<PaneDivision>;
+    private setPaneDivisions;
+    /**
+     * Checks if all non-frozen header indices are present in the provided elements of selected rows/columns.
+     * This validation ensures that all rows or columns cannot be deleted when frozen panes exist.
+     */
+    checkElementsIncludeAllNonFrozenHeaders(sheetId: UID, dimension: Dimension, elements: HeaderIndex[]): boolean;
+    getCommandZones(cmd: Command): Zone[];
+    /**
+     * Check if zones in the command are well formed and
+     * not outside the sheet.
+     */
+    checkZonesExistInSheet(sheetId: UID, zones: Zone[]): CommandResult;
+    private updateCellPosition;
+    /**
+     * Set the cell at a new position and clear its previous position.
+     */
+    private setNewPosition;
+    /**
+     * Remove the cell at the given position (if there's one)
+     */
+    private clearPosition;
+    private setGridLinesVisibility;
+    private clearZones;
+    private createSheet;
+    private moveSheet;
+    private findIndexOfTargetSheet;
+    private checkSheetName;
+    private checkSheetPosition;
+    private checkRowFreezeQuantity;
+    private checkColFreezeQuantity;
+    private checkRowFreezeOverlapMerge;
+    private checkColFreezeOverlapMerge;
+    private isRenameAllowed;
+    private renameSheet;
+    private hideSheet;
+    private showSheet;
+    private duplicateSheet;
+    getDuplicateSheetName(sheetName: string): string;
+    private deleteSheet;
+    /**
+     * Delete column. This requires a lot of handling:
+     * - Update all the formulas in all sheets
+     * - Move the cells
+     * - Update the cols/rows (size, number, (cells), ...)
+     * - Reevaluate the cells
+     *
+     * @param sheet ID of the sheet on which deletion should be applied
+     * @param columns Columns to delete
+     */
+    private removeColumns;
+    /**
+     * Delete row. This requires a lot of handling:
+     * - Update the merges
+     * - Update all the formulas in all sheets
+     * - Move the cells
+     * - Update the cols/rows (size, number, (cells), ...)
+     * - Reevaluate the cells
+     *
+     * @param sheet ID of the sheet on which deletion should be applied
+     * @param rows Rows to delete
+     */
+    private removeRows;
+    private addColumns;
+    private addRows;
+    private moveCellOnColumnsDeletion;
+    /**
+     * Move the cells after a column or rows insertion
+     */
+    private moveCellsOnAddition;
+    /**
+     * Move all the cells that are from the row under `deleteToRow` up to `deleteFromRow`
+     *
+     * b.e.
+     * move vertically with delete from 3 and delete to 5 will first clear all the cells from lines 3 to 5,
+     * then take all the row starting at index 6 and add them back at index 3
+     *
+     */
+    private moveCellOnRowsDeletion;
+    private updateRowsStructureOnDeletion;
+    /**
+     * Add empty rows at the end of the rows
+     *
+     * @param sheet Sheet
+     * @param quantity Number of rows to add
+     */
+    private addEmptyRows;
+    private getImportedSheetSize;
+    /**
+     * Check that any "sheetId" in the command matches an existing
+     * sheet.
+     */
+    private checkSheetExists;
+    /**
+     * Check if zones in the command are well formed and
+     * not outside the sheet.
+     */
+    private checkZonesAreInSheet;
+}
+export {};

package/dist/types/plugins/core_plugin.d.ts

@@ -0,0 +1,49 @@
+import { UuidGenerator } from "../helpers";
+import { ModelConfig } from "../model";
+import { StateObserver } from "../state_observer";
+import { ApplyRangeChange, CoreCommand, CoreCommandDispatcher, RangeProvider, UID, WorkbookData } from "../types";
+import { CoreGetters } from "../types/getters";
+import { BasePlugin } from "./base_plugin";
+import { RangeAdapter } from "./core/range";
+export interface CorePluginConfig {
+    readonly getters: CoreGetters;
+    readonly stateObserver: StateObserver;
+    readonly range: RangeAdapter;
+    readonly dispatch: CoreCommandDispatcher["dispatch"];
+    readonly uuidGenerator: UuidGenerator;
+    readonly custom: ModelConfig["custom"];
+    readonly external: ModelConfig["external"];
+}
+export interface CorePluginConstructor {
+    new (config: CorePluginConfig): CorePlugin;
+    getters: readonly string[];
+}
+/**
+ * Core plugins handle spreadsheet data.
+ * They are responsible to import, export and maintain the spreadsheet
+ * persisted state.
+ * They should not be concerned about UI parts or transient state.
+ */
+export declare class CorePlugin<State = any> extends BasePlugin<State, CoreCommand> implements RangeProvider {
+    protected getters: CoreGetters;
+    protected uuidGenerator: UuidGenerator;
+    constructor({ getters, stateObserver, range, dispatch, uuidGenerator }: CorePluginConfig);
+    import(data: WorkbookData): void;
+    export(data: WorkbookData): void;
+    /**
+     * This method can be implemented in any plugin, to loop over the plugin's data structure and adapt the plugin's ranges.
+     * To adapt them, the implementation of the function must have a perfect knowledge of the data structure, thus
+     * implementing the loops over it makes sense in the plugin itself.
+     * When calling the method applyChange, the range will be adapted if necessary, then a copy will be returned along with
+     * the type of change that occurred.
+     *
+     * @param applyChange a function that, when called, will adapt the range according to the change on the grid
+     * @param sheetId an optional sheetId to adapt either range of that sheet specifically, or ranges pointing to that sheet
+     */
+    adaptRanges(applyChange: ApplyRangeChange, sheetId?: UID): void;
+    /**
+     * Implement this method to clean unused external resources, such as images
+     * stored on a server which have been deleted.
+     */
+    garbageCollectExternalResources(): void;
+}

package/dist/types/plugins/index.d.ts

@@ -0,0 +1,7 @@
+import { Registry } from "../registries/registry";
+import { CorePluginConstructor } from "./core_plugin";
+import { UIPluginConstructor } from "./ui_plugin";
+export declare const corePluginRegistry: Registry<CorePluginConstructor>;
+export declare const featurePluginRegistry: Registry<UIPluginConstructor>;
+export declare const statefulUIPluginRegistry: Registry<UIPluginConstructor>;
+export declare const coreViewsPluginRegistry: Registry<UIPluginConstructor>;

package/dist/types/plugins/ui_core_views/cell_evaluation/compilation_parameters.d.ts

@@ -0,0 +1,10 @@
+import { ModelConfig } from "../../../model";
+import { CellPosition, EnsureRange, EvalContext, EvaluatedCell, Getters, ReferenceDenormalizer } from "../../../types";
+export type CompilationParameters = [ReferenceDenormalizer, EnsureRange, EvalContext];
+/**
+ * Return all functions necessary to properly evaluate a formula:
+ * - a refFn function to read any reference, cell or range of a normalized formula
+ * - a range function to convert any reference to a proper value array
+ * - an evaluation context
+ */
+export declare function buildCompilationParameters(context: ModelConfig["custom"], getters: Getters, computeCell: (position: CellPosition) => EvaluatedCell): CompilationParameters;

package/dist/types/plugins/ui_core_views/cell_evaluation/evaluation_plugin.d.ts

@@ -0,0 +1,43 @@
+import { CellPosition, CellValue, Command, EvaluatedCell, ExcelWorkbookData, Format, FormattedValue, FormulaCell, Matrix, Range, UID, ValueAndFormat, Zone } from "../../../types/index";
+import { UIPlugin, UIPluginConfig } from "../../ui_plugin";
+import { CoreViewCommand } from "./../../../types/commands";
+export declare class EvaluationPlugin extends UIPlugin {
+    static getters: readonly ["evaluateFormula", "evaluateFormulaResult", "getCorrespondingFormulaCell", "getRangeFormattedValues", "getRangeValues", "getRangeFormats", "getEvaluatedCell", "getEvaluatedCells", "getEvaluatedCellsInZone", "getSpreadPositionsOf", "getArrayFormulaSpreadingOn", "isEmpty"];
+    private shouldRebuildDependenciesGraph;
+    private evaluator;
+    private positionsToUpdate;
+    constructor(config: UIPluginConfig);
+    beforeHandle(cmd: Command): void;
+    handle(cmd: CoreViewCommand): void;
+    finalize(): void;
+    evaluateFormula(sheetId: UID, formulaString: string): CellValue | Matrix<CellValue>;
+    evaluateFormulaResult(sheetId: UID, formulaString: string): ValueAndFormat | Matrix<ValueAndFormat>;
+    /**
+     * Return the value of each cell in the range as they are displayed in the grid.
+     */
+    getRangeFormattedValues(range: Range): FormattedValue[];
+    /**
+     * Return the value of each cell in the range.
+     */
+    getRangeValues(range: Range): CellValue[];
+    /**
+     * Return the format of each cell in the range.
+     */
+    getRangeFormats(range: Range): (Format | undefined)[];
+    getEvaluatedCell(position: CellPosition): EvaluatedCell;
+    getEvaluatedCells(sheetId: UID): Record<UID, EvaluatedCell>;
+    getEvaluatedCellsInZone(sheetId: UID, zone: Zone): EvaluatedCell[];
+    getSpreadPositionsOf(position: CellPosition): CellPosition[];
+    getArrayFormulaSpreadingOn(position: CellPosition): CellPosition | undefined;
+    /**
+     * Check if a zone only contains empty cells
+     */
+    isEmpty(sheetId: UID, zone: Zone): boolean;
+    exportForExcel(data: ExcelWorkbookData): void;
+    /**
+     * Returns the corresponding formula cell of a given cell
+     * It could be the formula present in the cell itself or the
+     * formula of the array formula that spreads to the cell
+     */
+    getCorrespondingFormulaCell(position: CellPosition): FormulaCell | undefined;
+}