@odoo/o-spreadsheet 18.0.55 → 18.0.68

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

@@ -0,0 +1,83 @@
+import { CommandResult, CoreCommand, ExcelWorkbookData, 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;
+    exportForExcel(data: ExcelWorkbookData): 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 "./header_size";
+export * from "./header_visibility";
+export * from "./image";
+export * from "./merge";
+export * from "./range";
+export * from "./sheet";
+export * from "./tables";

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

@@ -0,0 +1,82 @@
+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", "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;
+    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/pivot.d.ts

@@ -0,0 +1,66 @@
+import { ApplyRangeChange, CommandResult, CoreCommand, Range, RangeCompiledFormula, UID, WorkbookData } from "../../types";
+import { PivotCoreDefinition, PivotCoreMeasure } from "../../types/pivot";
+import { CorePlugin } from "../core_plugin";
+interface Pivot {
+    definition: PivotCoreDefinition;
+    formulaId: string;
+}
+interface MeasureState {
+    formula: RangeCompiledFormula;
+    dependencies: Range[];
+}
+interface CoreState {
+    nextFormulaId: number;
+    pivots: Record<UID, Pivot | undefined>;
+    formulaIds: Record<UID, string | undefined>;
+    compiledMeasureFormulas: Record<UID, Record<string, MeasureState | undefined>>;
+}
+export declare class PivotCorePlugin extends CorePlugin<CoreState> implements CoreState {
+    static getters: readonly ["getPivotCoreDefinition", "getPivotDisplayName", "getPivotId", "getPivotFormulaId", "getPivotIds", "getMeasureCompiledFormula", "getPivotName", "isExistingPivot", "getMeasureFullDependencies"];
+    readonly nextFormulaId: number;
+    readonly pivots: {
+        [pivotId: UID]: Pivot | undefined;
+    };
+    readonly formulaIds: {
+        [formulaId: UID]: UID | undefined;
+    };
+    readonly compiledMeasureFormulas: Record<UID, Record<string, MeasureState>>;
+    allowDispatch(cmd: CoreCommand): CommandResult.Success | CommandResult.NoChanges | CommandResult.PivotIdNotFound | CommandResult.EmptyName | CommandResult.InvalidDefinition;
+    handle(cmd: CoreCommand): void;
+    adaptRanges(applyChange: ApplyRangeChange): void;
+    getPivotDisplayName(pivotId: UID): string;
+    getPivotName(pivotId: UID): string;
+    /**
+     * Returns the pivot core definition of the pivot with the given id.
+     * Be careful, this is the core definition, this should be used only in a
+     * context where the pivot is not loaded yet.
+     */
+    getPivotCoreDefinition(pivotId: UID): PivotCoreDefinition;
+    /**
+     * Get the pivot ID (UID) from the formula ID (the one used in the formula)
+     */
+    getPivotId(formulaId: string): UID | undefined;
+    getPivotFormulaId(pivotId: UID): string;
+    getPivotIds(): UID[];
+    isExistingPivot(pivotId: UID): boolean;
+    getMeasureCompiledFormula(pivotId: UID, measure: PivotCoreMeasure): RangeCompiledFormula;
+    getMeasureFullDependencies(pivotId: UID, measure: PivotCoreMeasure): Range[];
+    private addPivot;
+    private compileCalculatedMeasures;
+    private computeMeasureFullDependencies;
+    private insertPivot;
+    private resizeSheet;
+    private getPivotCore;
+    private compileMeasureFormula;
+    private replaceMeasureFormula;
+    private checkDuplicatedMeasureIds;
+    /**
+     * Import the pivots
+     */
+    import(data: WorkbookData): void;
+    /**
+     * Export the pivots
+     */
+    export(data: WorkbookData): void;
+}
+export {};

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

@@ -0,0 +1,75 @@
+import { RangeImpl } from "../../helpers/index";
+import { Command, CommandHandler, CommandResult, CoreCommand, CoreGetters, Dimension, Range, RangeData, RangeProvider, UID, UnboundedZone, Zone } from "../../types/index";
+interface RangeStringOptions {
+    useBoundedReference?: boolean;
+    useFixedReference?: boolean;
+}
+export declare class RangeAdapter implements CommandHandler<CoreCommand> {
+    private getters;
+    private providers;
+    private isAdaptingRanges;
+    constructor(getters: CoreGetters);
+    static getters: readonly ["extendRange", "getRangeString", "getRangeFromSheetXC", "createAdaptedRanges", "getRangeDataFromXc", "getRangeDataFromZone", "getRangeFromRangeData", "getRangeFromZone", "getRangesUnion", "recomputeRanges", "isRangeValid", "removeRangesSheetPrefix"];
+    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[];
+    /**
+     * Remove the sheet name prefix if a range is part of the given sheet.
+     */
+    removeRangesSheetPrefix(sheetId: UID, ranges: Range[]): Range[];
+    extendRange(range: Range, dimension: Dimension, quantity: number): 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.useBoundedReference if true, the range will be returned with bounded row and column
+     * @param options.useFixedReference if true, the range will be returned with fixed row and column
+     */
+    getRangeString(range: Range, forSheetId: UID, options?: RangeStringOptions): string;
+    getRangeDataFromXc(sheetId: UID, xc: string): RangeData;
+    getRangeDataFromZone(sheetId: UID, zone: Zone | UnboundedZone): RangeData;
+    getRangeFromZone(sheetId: UID, zone: Zone | UnboundedZone): Range;
+    /**
+     * Allows you to recompute ranges from the same sheet
+     */
+    recomputeRanges(ranges: Range[], rangesToRemove: Range[]): Range[];
+    getRangeFromRangeData(data: RangeData): Range;
+    isRangeValid(rangeStr: string): boolean;
+    getRangesUnion(ranges: Range[]): Range;
+    /**
+     * Get a Xc string that represent a part of a range
+     */
+    private getRangePartString;
+    private getInvalidRange;
+}
+export {};

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,148 @@
+import { Cell, CellPosition, Command, CommandResult, CoreCommand, Dimension, ExcelWorkbookData, HeaderIndex, PaneDivision, 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", "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[];
+    doesHeaderExist(sheetId: UID, dimension: Dimension, index: number): boolean;
+    doesHeadersExist(sheetId: UID, dimension: Dimension, headerIndexes: HeaderIndex[]): boolean;
+    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): 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 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/spreadsheet_pivot.d.ts

@@ -0,0 +1,6 @@
+import { CommandResult, CoreCommand } from "../../types";
+import { CorePlugin } from "../core_plugin";
+export declare class SpreadsheetPivotCorePlugin extends CorePlugin {
+    allowDispatch(cmd: CoreCommand): CommandResult;
+    private checkDataSetValidity;
+}

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

@@ -0,0 +1,22 @@
+import { CommandResult, CoreCommand, TableStyle, WorkbookData } from "../../types/index";
+import { CorePlugin } from "../core_plugin";
+interface TableStylesState {
+    readonly styles: {
+        [styleId: string]: TableStyle;
+    };
+}
+export declare class TableStylePlugin extends CorePlugin<TableStylesState> implements TableStylesState {
+    static getters: readonly ["getNewCustomTableStyleName", "getTableStyle", "getTableStyles", "isTableStyleEditable"];
+    readonly styles: {
+        [styleId: string]: TableStyle;
+    };
+    allowDispatch(cmd: CoreCommand): CommandResult | CommandResult[];
+    handle(cmd: CoreCommand): void;
+    getTableStyle(styleId: string): TableStyle;
+    getTableStyles(): Record<string, TableStyle>;
+    getNewCustomTableStyleName(): string;
+    isTableStyleEditable(styleId: string): boolean;
+    import(data: WorkbookData): void;
+    export(data: WorkbookData): void;
+}
+export {};

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

@@ -0,0 +1,56 @@
+import { ApplyRangeChange, CellPosition, CommandResult, CoreCommand, CoreTable, ExcelWorkbookData, TableId, UID, WorkbookData, Zone } from "../../types/index";
+import { CorePlugin } from "../core_plugin";
+interface TableState {
+    tables: Record<UID, Record<TableId, CoreTable | undefined>>;
+    insertionOrders: Record<UID, TableId[] | undefined>;
+}
+export declare class TablePlugin extends CorePlugin<TableState> implements TableState {
+    static getters: readonly ["getCoreTable", "getCoreTables", "getCoreTableMatchingTopLeft"];
+    readonly tables: Record<UID, Record<TableId, CoreTable | undefined>>;
+    readonly insertionOrders: Record<UID, TableId[] | undefined>;
+    adaptRanges(applyChange: ApplyRangeChange, sheetId?: UID): void;
+    allowDispatch(cmd: CoreCommand): CommandResult | CommandResult[];
+    handle(cmd: CoreCommand): void;
+    getCoreTables(sheetId: UID): CoreTable[];
+    getCoreTable({ sheetId, col, row }: CellPosition): CoreTable | undefined;
+    private getTablesOverlappingZones;
+    /** Extend a table down one row */
+    private extendTableDown;
+    /** Extend a table right one col */
+    private extendTableRight;
+    /**
+     * Check if an UpdateCell command should cause the given table to be extended by one row or col.
+     *
+     * The table should be extended if all of these conditions are true:
+     * 1) The updated cell is right below/right of the table
+     * 2) The command adds a content to the cell
+     * 3) No cell right below/right next to the table had any content before the command
+     * 4) Extending the table down/right would not overlap with another table
+     * 5) Extending the table down/right would not overlap with a merge
+     *
+     */
+    private canUpdateCellCmdExtendTable;
+    getCoreTableMatchingTopLeft(sheetId: UID, zone: Zone): CoreTable | undefined;
+    private checkUpdatedTableZoneIsValid;
+    private checkTableConfigUpdateIsValid;
+    private createStaticTable;
+    private createDynamicTable;
+    private updateTable;
+    private updateStaticTable;
+    private updateDynamicTable;
+    /**
+     * Update the old config of a table with the new partial config from an UpdateTable command.
+     *
+     * Make sure the new config make sense (e.g. if the table has no header, it should not have
+     * filters and number of headers should be 0)
+     */
+    private updateTableConfig;
+    private createFilterFromZone;
+    private copyStaticTableForSheet;
+    private copyDynamicTableForSheet;
+    private applyRangeChangeOnTable;
+    import(data: WorkbookData): void;
+    export(data: WorkbookData): void;
+    exportForExcel(data: ExcelWorkbookData): void;
+}
+export {};