@odoo/o-spreadsheet 18.0.55 → 18.0.68

package/dist/types/model.d.ts

@@ -0,0 +1,193 @@
+import { EventBus } from "./helpers/event_bus";
+import { UuidGenerator } from "./helpers/index";
+import { SelectionStreamProcessor } from "./selection_stream/selection_stream_processor";
+import { StateUpdateMessage, TransportService } from "./types/collaborative/transport_service";
+import { FileStore } from "./types/files";
+import { Client, ClientPosition, Color, CommandDispatcher, Currency, Getters, GridRenderingContext, InformationNotification, LayerName, Locale } from "./types/index";
+import { WorkbookData } from "./types/workbook_data";
+import { XLSXExport } from "./types/xlsx";
+/**
+ * Model
+ *
+ * The Model class is the owner of the state of the Spreadsheet. However, it
+ * has more a coordination role: it defers the actual state manipulation work to
+ * plugins.
+ *
+ * At creation, the Model instantiates all necessary plugins. They each have
+ * a private state (for example, the Selection plugin has the current selection).
+ *
+ * State changes are then performed through commands.  Commands are dispatched
+ * to the model, which will then relay them to each plugins (and the history
+ * handler). Then, the model will trigger an 'update' event to notify whoever
+ * is concerned that the command was applied (if it was not cancelled).
+ *
+ * Also, the model has an unconventional responsibility: it actually renders the
+ * visible viewport on a canvas. This is because each plugins actually manage a
+ * specific concern about the content of the spreadsheet, and it is more natural
+ * if they are able to read data from their internal state to represent it on the
+ * screen.
+ *
+ * Note that the Model can be used in a standalone way to manipulate
+ * programmatically a spreadsheet.
+ */
+export type Mode = "normal" | "readonly" | "dashboard";
+export interface ModelConfig {
+    readonly mode: Mode;
+    /**
+     * Any external custom dependencies your custom plugins or functions might need.
+     * They are available in plugins config and functions
+     * evaluation context.
+     */
+    readonly custom: Readonly<{
+        [key: string]: any;
+    }>;
+    readonly defaultCurrency?: Partial<Currency>;
+    /**
+     * External dependencies required to enable some features
+     * such as uploading images.
+     */
+    readonly external: Readonly<ModelExternalConfig>;
+    readonly moveClient: (position: ClientPosition) => void;
+    readonly transportService: TransportService;
+    readonly client: Client;
+    readonly snapshotRequested: boolean;
+    readonly notifyUI: (payload: InformationNotification) => void;
+    readonly raiseBlockingErrorUI: (text: string) => void;
+    readonly customColors: Color[];
+}
+export interface ModelExternalConfig {
+    readonly fileStore?: FileStore;
+    readonly loadCurrencies?: () => Promise<Currency[]>;
+    readonly loadLocales?: () => Promise<Locale[]>;
+}
+export declare class Model extends EventBus<any> implements CommandDispatcher {
+    private corePlugins;
+    private featurePlugins;
+    private statefulUIPlugins;
+    private coreViewsPlugins;
+    private range;
+    private session;
+    /**
+     * In a collaborative context, some commands can be replayed, we have to ensure
+     * that these commands are not replayed on the UI plugins.
+     */
+    private isReplayingCommand;
+    /**
+     * A plugin can draw some contents on the canvas. But even better: it can do
+     * so multiple times.  The order of the render calls will determine a list of
+     * "layers" (i.e., earlier calls will be obviously drawn below later calls).
+     * This list simply keeps the renderers+layer information so the drawing code
+     * can just iterate on it
+     */
+    private renderers;
+    /**
+     * Internal status of the model. Important for command handling coordination
+     */
+    private status;
+    /**
+     * The config object contains some configuration flag and callbacks
+     */
+    readonly config: ModelConfig;
+    private corePluginConfig;
+    private uiPluginConfig;
+    private state;
+    readonly selection: SelectionStreamProcessor;
+    /**
+     * Getters are the main way the rest of the UI read data from the model. Also,
+     * it is shared between all plugins, so they can also communicate with each
+     * other.
+     */
+    getters: Getters;
+    /**
+     * Getters that are accessible from the core plugins. It's a subset of `getters`,
+     * without the UI getters
+     */
+    private coreGetters;
+    uuidGenerator: UuidGenerator;
+    private readonly handlers;
+    private readonly uiHandlers;
+    private readonly coreHandlers;
+    constructor(data?: any, config?: Partial<ModelConfig>, stateUpdateMessages?: StateUpdateMessage[], uuidGenerator?: UuidGenerator, verboseImport?: boolean);
+    joinSession(): void;
+    leaveSession(): Promise<void>;
+    private setupUiPlugin;
+    /**
+     * Initialize and properly configure a plugin.
+     *
+     * This method is private for now, but if the need arise, there is no deep
+     * reason why the model could not add dynamically a plugin while it is running.
+     */
+    private setupCorePlugin;
+    private onRemoteRevisionReceived;
+    private setupSession;
+    private setupSessionEvents;
+    private setupConfig;
+    private setupExternalConfig;
+    private setupCorePluginConfig;
+    private setupUiPluginConfig;
+    /**
+     * Check if the given command is allowed by all the plugins and the history.
+     */
+    private checkDispatchAllowed;
+    private checkDispatchAllowedCoreCommand;
+    private checkDispatchAllowedLocalCommand;
+    private finalize;
+    /**
+     * Check if a command can be dispatched, and returns a DispatchResult object with the possible
+     * reasons the dispatch failed.
+     */
+    canDispatch: CommandDispatcher["dispatch"];
+    /**
+     * The dispatch method is the only entry point to manipulate data in the model.
+     * This is through this method that commands are dispatched most of the time
+     * recursively until no plugin want to react anymore.
+     *
+     * CoreCommands dispatched from this function are saved in the history.
+     *
+     * Small technical detail: it is defined as an arrow function.  There are two
+     * reasons for this:
+     * 1. this means that the dispatch method can be "detached" from the model,
+     *    which is done when it is put in the environment (see the Spreadsheet
+     *    component)
+     * 2. This allows us to define its type by using the interface CommandDispatcher
+     */
+    dispatch: CommandDispatcher["dispatch"];
+    /**
+     * Dispatch a command from a Core Plugin (or the History).
+     * A command dispatched from this function is not added to the history.
+     */
+    private dispatchFromCorePlugin;
+    /**
+     * Dispatch the given command to the given handlers.
+     * It will call `beforeHandle` and `handle`
+     */
+    private dispatchToHandlers;
+    /**
+     * When the Grid component is ready (= mounted), it has a reference to its
+     * canvas and need to draw the grid on it.  This is then done by calling this
+     * method, which will dispatch the call to all registered plugins.
+     *
+     * Note that nothing prevent multiple grid components from calling this method
+     * each, or one grid component calling it multiple times with a different
+     * context. This is probably the way we should do if we want to be able to
+     * freeze a part of the grid (so, we would need to render different zones)
+     */
+    drawLayer(context: GridRenderingContext, layer: LayerName): void;
+    /**
+     * As the name of this method strongly implies, it is useful when we need to
+     * export date out of the model.
+     */
+    exportData(): WorkbookData;
+    updateMode(mode: Mode): void;
+    /**
+     * Exports the current model data into a list of serialized XML files
+     * to be zipped together as an *.xlsx file.
+     *
+     * We need to trigger a cell revaluation  on every sheet and ensure that even
+     * async functions are evaluated.
+     * This prove to be necessary if the client did not trigger that evaluation in the first place
+     * (e.g. open a document with several sheet and click on download before visiting each sheet)
+     */
+    exportXLSX(): XLSXExport;
+    garbageCollectExternalResources(): void;
+}

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

@@ -0,0 +1,64 @@
+import { StateObserver } from "../state_observer";
+import { CommandDispatcher, CommandHandler, CommandResult, ExcelWorkbookData, Validation, WorkbookHistory } from "../types/index";
+import { Validator } from "../types/validator";
+/**
+ * BasePlugin
+ *
+ * Since the spreadsheet internal state is quite complex, it is split into
+ * multiple parts, each managing a specific concern.
+ *
+ * This file introduce the BasePlugin, which is the common class that defines
+ * how each of these model sub parts should interact with each other.
+ * There are two kind of plugins: core plugins handling persistent data
+ * and UI plugins handling transient data.
+ */
+export declare class BasePlugin<State = any, C = any> implements CommandHandler<C>, Validator {
+    static getters: readonly string[];
+    protected history: WorkbookHistory<State>;
+    protected dispatch: CommandDispatcher["dispatch"];
+    protected canDispatch: CommandDispatcher["dispatch"];
+    constructor(stateObserver: StateObserver, dispatch: CommandDispatcher["dispatch"], canDispatch: CommandDispatcher["dispatch"]);
+    /**
+     * Export for excel should be available for all plugins, even for the UI.
+     * In some case, we need to export evaluated value, which is available from
+     * UI plugin only.
+     */
+    exportForExcel(data: ExcelWorkbookData): void;
+    /**
+     * Before a command is accepted, the model will ask each plugin if the command
+     * is allowed.  If all of then return true, then we can proceed. Otherwise,
+     * the command is cancelled.
+     *
+     * There should not be any side effects in this method.
+     */
+    allowDispatch(command: C): CommandResult | CommandResult[];
+    /**
+     * This method is useful when a plugin need to perform some action before a
+     * command is handled in another plugin. This should only be used if it is not
+     * possible to do the work in the handle method.
+     */
+    beforeHandle(command: C): void;
+    /**
+     * This is the standard place to handle any command. Most of the plugin
+     * command handling work should take place here.
+     */
+    handle(command: C): void;
+    /**
+     * Sometimes, it is useful to perform some work after a command (and all its
+     * subcommands) has been completely handled.  For example, when we paste
+     * multiple cells, we only want to reevaluate the cell values once at the end.
+     */
+    finalize(): void;
+    /**
+     * Combine multiple validation functions into a single function
+     * returning the list of result of every validation.
+     */
+    batchValidations<T>(...validations: Validation<T>[]): Validation<T>;
+    /**
+     * Combine multiple validation functions. Every validation is executed one after
+     * the other. As soon as one validation fails, it stops and the cancelled reason
+     * is returned.
+     */
+    chainValidations<T>(...validations: Validation<T>[]): Validation<T>;
+    checkValidations<T>(command: T, ...validations: Validation<T>[]): CommandResult | CommandResult[];
+}

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

@@ -0,0 +1,127 @@
+import { Border, BorderDescription, CellPosition, Color, CommandResult, CoreCommand, ExcelWorkbookData, UID, WorkbookData } from "../../types/index";
+import { CorePlugin } from "../core_plugin";
+interface BordersPluginState {
+    readonly borders: Record<UID, (BorderDescription[] | undefined)[] | undefined>;
+}
+/**
+ * Formatting plugin.
+ *
+ * This plugin manages all things related to a cell look:
+ * - borders
+ */
+export declare class BordersPlugin extends CorePlugin<BordersPluginState> implements BordersPluginState {
+    static getters: readonly ["getCellBorder", "getBordersColors"];
+    readonly borders: BordersPluginState["borders"];
+    allowDispatch(cmd: CoreCommand): CommandResult.Success | CommandResult.NoChanges;
+    handle(cmd: CoreCommand): void;
+    /**
+     * Move borders according to the inserted columns.
+     * Ensure borders continuity.
+     */
+    private handleAddColumns;
+    /**
+     * Move borders according to the inserted rows.
+     * Ensure borders continuity.
+     */
+    private handleAddRows;
+    getCellBorder({ sheetId, col, row }: CellPosition): Border | null;
+    getBordersColors(sheetId: UID): Color[];
+    /**
+     * Ensure border continuity between two columns.
+     * If the two columns have the same borders (at each row respectively),
+     * the same borders are applied to each cell in between.
+     */
+    private ensureColumnBorderContinuity;
+    /**
+     * Ensure border continuity between two rows.
+     * If the two rows have the same borders (at each column respectively),
+     * the same borders are applied to each cell in between.
+     */
+    private ensureRowBorderContinuity;
+    /**
+     * From two borders, return a new border with sides defined in both borders.
+     * i.e. the intersection of two borders.
+     */
+    private getCommonSides;
+    /**
+     * Get all the columns which contains at least a border
+     */
+    private getColumnsWithBorders;
+    /**
+     * Get all the rows which contains at least a border
+     */
+    private getRowsWithBorders;
+    /**
+     * Get the range of all the rows in the sheet
+     */
+    private getRowsRange;
+    /**
+     * Move borders of a sheet horizontally.
+     * @param sheetId
+     * @param start starting column (included)
+     * @param delta how much borders will be moved (negative if moved to the left)
+     */
+    private shiftBordersHorizontally;
+    /**
+     * Move borders of a sheet vertically.
+     * @param sheetId
+     * @param start starting row (included)
+     * @param delta how much borders will be moved (negative if moved to the above)
+     */
+    private shiftBordersVertically;
+    /**
+     * Moves the borders (left if `vertical` or top if `horizontal` depending on
+     * `borderDirection`) of all cells in an entire row `delta` rows to the right
+     * (`delta` > 0) or to the left (`delta` < 0).
+     * Note that as the left of a cell is the right of the cell-1, if the left is
+     * moved the right is also moved. However, if `horizontal`, the bottom border
+     * is not moved.
+     * It does it by replacing the target border by the moved border. If the
+     * argument `destructive` is given false, the target border is preserved if
+     * the moved border is empty
+     */
+    private moveBordersOfRow;
+    /**
+     * Moves the borders (left if `vertical` or top if `horizontal` depending on
+     * `borderDirection`) of all cells in an entire column `delta` columns below
+     * (`delta` > 0) or above (`delta` < 0).
+     * Note that as the top of a cell is the bottom of the cell-1, if the top is
+     * moved the bottom is also moved. However, if `vertical`, the right border
+     * is not moved.
+     * It does it by replacing the target border by the moved border. If the
+     * argument `destructive` is given false, the target border is preserved if
+     * the moved border is empty
+     */
+    private moveBordersOfColumn;
+    /**
+     * Set the borders of a cell.
+     * It overrides the current border if override === true.
+     */
+    private setBorder;
+    /**
+     * Remove the borders of a zone
+     */
+    private clearBorders;
+    /**
+     * Remove the borders inside of a zone
+     */
+    private clearInsideBorders;
+    /**
+     * Add a border to the existing one to a cell
+     */
+    private addBorder;
+    /**
+     * Set the borders of a zone by computing the borders to add from the given
+     * command
+     */
+    private setBorders;
+    /**
+     * Compute the borders to add to the given zone merged.
+     */
+    private addBordersToMerge;
+    private checkBordersUnchanged;
+    import(data: WorkbookData): void;
+    export(data: WorkbookData): void;
+    exportForExcel(data: ExcelWorkbookData): void;
+}
+export {};

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

@@ -0,0 +1,115 @@
+import { Token } from "../../formulas";
+import { ApplyRangeChange, Cell, CellPosition, CommandResult, CompiledFormula, CoreCommand, ExcelWorkbookData, Format, FormulaCell, Range, RangeCompiledFormula, RangePart, Style, UID, WorkbookData, Zone } from "../../types/index";
+import { CorePlugin } from "../core_plugin";
+interface CoreState {
+    cells: Record<UID, Record<UID, Cell | undefined> | undefined>;
+    nextId: number;
+}
+/**
+ * Core Plugin
+ *
+ * This is the most fundamental of all plugins. It defines how to interact with
+ * cell and sheet content.
+ */
+export declare class CellPlugin extends CorePlugin<CoreState> implements CoreState {
+    static getters: readonly ["zoneToXC", "getCells", "getTranslatedCellFormula", "getCellStyle", "getCellById", "getFormulaString", "getFormulaMovedInSheet"];
+    readonly nextId = 1;
+    readonly cells: {
+        [sheetId: string]: {
+            [id: string]: Cell;
+        };
+    };
+    adaptRanges(applyChange: ApplyRangeChange, sheetId?: UID): void;
+    allowDispatch(cmd: CoreCommand): CommandResult | CommandResult[];
+    handle(cmd: CoreCommand): void;
+    private clearZones;
+    /**
+     * Set a format to all the cells in a zone
+     */
+    private setFormatter;
+    /**
+     * Clear the styles and format of zones
+     */
+    private clearFormatting;
+    /**
+     * Clear the styles, the format and the content of zones
+     */
+    private clearCells;
+    /**
+     * Copy the style of the reference column/row to the new columns/rows.
+     */
+    private handleAddColumnsRows;
+    import(data: WorkbookData): void;
+    export(data: WorkbookData): void;
+    importCell(sheetId: UID, content?: string, style?: Style, format?: Format): Cell;
+    exportForExcel(data: ExcelWorkbookData): void;
+    private extractCustomStyle;
+    getCells(sheetId: UID): Record<UID, Cell>;
+    /**
+     * get a cell by ID. Used in evaluation when evaluating an async cell, we need to be able to find it back after
+     * starting an async evaluation even if it has been moved or re-allocated
+     */
+    getCellById(cellId: UID): Cell | undefined;
+    getFormulaString(sheetId: UID, tokens: Token[], dependencies: Range[], useBoundedReference?: boolean): string;
+    getTranslatedCellFormula(sheetId: UID, offsetX: number, offsetY: number, tokens: Token[]): string;
+    getFormulaMovedInSheet(originSheetId: UID, targetSheetId: UID, tokens: Token[]): string;
+    getCellStyle(position: CellPosition): Style;
+    /**
+     * Converts a zone to a XC coordinate system
+     *
+     * The conversion also treats merges as one single cell
+     *
+     * Examples:
+     * {top:0,left:0,right:0,bottom:0} ==> A1
+     * {top:0,left:0,right:1,bottom:1} ==> A1:B2
+     *
+     * if A1:B2 is a merge:
+     * {top:0,left:0,right:1,bottom:1} ==> A1
+     * {top:1,left:0,right:1,bottom:2} ==> A1:B3
+     *
+     * if A1:B2 and A4:B5 are merges:
+     * {top:1,left:0,right:1,bottom:3} ==> A1:A5
+     */
+    zoneToXC(sheetId: UID, zone: Zone, fixedParts?: RangePart[]): string;
+    private setStyle;
+    /**
+     * Copy the style of one column to other columns.
+     */
+    private copyColumnStyle;
+    /**
+     * Copy the style of one row to other rows.
+     */
+    private copyRowStyle;
+    /**
+     * gets the currently used style/border of a cell based on it's coordinates
+     */
+    private getFormat;
+    private getNextUid;
+    private updateCell;
+    private createCell;
+    private createLiteralCell;
+    private createFormulaCell;
+    /**
+     * Create a new formula cell with the content
+     * being a computed property to rebuild the dependencies XC.
+     */
+    private createFormulaCellWithDependencies;
+    private checkCellOutOfSheet;
+    private checkUselessClearCell;
+    private checkUselessUpdateCell;
+}
+export declare class FormulaCellWithDependencies implements FormulaCell {
+    readonly id: UID;
+    readonly format: Format | undefined;
+    readonly style: Style | undefined;
+    private readonly sheetId;
+    private readonly getRangeString;
+    readonly isFormula = true;
+    readonly compiledFormula: RangeCompiledFormula;
+    constructor(id: UID, compiledFormula: CompiledFormula, format: Format | undefined, style: Style | undefined, dependencies: Range[], sheetId: UID, getRangeString: (range: Range, sheetId: UID, option?: {
+        useBoundedReference: boolean;
+    }) => string);
+    get content(): string;
+    get contentWithFixedReferences(): string;
+}
+export {};

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

@@ -0,0 +1,41 @@
+import { AbstractChart } from "../../helpers/figures/charts/abstract_chart";
+import { ChartCreationContext, ChartDefinition, ChartType } from "../../types/chart/chart";
+import { ApplyRangeChange, Command, CommandResult, CoreCommand, UID, WorkbookData } from "../../types/index";
+import { CorePlugin } from "../core_plugin";
+/**
+ * Chart plugin
+ *
+ * This plugin manages charts
+ * */
+interface ChartState {
+    readonly charts: Record<UID, AbstractChart | undefined>;
+}
+export declare class ChartPlugin extends CorePlugin<ChartState> implements ChartState {
+    static getters: readonly ["isChartDefined", "getChartDefinition", "getChartType", "getChartIds", "getChart", "getContextCreationChart"];
+    readonly charts: Record<UID, AbstractChart | undefined>;
+    private createChart;
+    private validateChartDefinition;
+    adaptRanges(applyChange: ApplyRangeChange): void;
+    allowDispatch(cmd: Command): CommandResult | CommandResult[];
+    handle(cmd: CoreCommand): void;
+    getContextCreationChart(figureId: UID): ChartCreationContext | undefined;
+    getChart(figureId: UID): AbstractChart | undefined;
+    getChartType(figureId: UID): ChartType;
+    isChartDefined(figureId: UID): boolean;
+    getChartIds(sheetId: UID): string[];
+    getChartDefinition(figureId: UID): ChartDefinition;
+    import(data: WorkbookData): void;
+    export(data: WorkbookData): void;
+    /**
+     * Add a figure with tag chart with the given id at the given position
+     */
+    private addFigure;
+    /**
+     * Add a chart in the local state. If a chart already exists, this chart is
+     * replaced
+     */
+    private addChart;
+    private checkChartDuplicate;
+    private checkChartExists;
+}
+export {};

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

@@ -0,0 +1,53 @@
+import { ApplyRangeChange, Command, CommandResult, ConditionalFormat, ConditionalFormatInternal, CoreCommand, ExcelWorkbookData, RangeData, UID, WorkbookData, Zone } from "../../types";
+import { CorePlugin } from "../core_plugin";
+interface ConditionalFormatState {
+    readonly cfRules: {
+        [sheet: string]: ConditionalFormatInternal[];
+    };
+}
+export declare class ConditionalFormatPlugin extends CorePlugin<ConditionalFormatState> implements ConditionalFormatState {
+    static getters: readonly ["getConditionalFormats", "getRulesSelection", "getRulesByCell", "getAdaptedCfRanges"];
+    readonly cfRules: {
+        [sheet: string]: ConditionalFormatInternal[];
+    };
+    loopThroughRangesOfSheet(sheetId: UID, applyChange: ApplyRangeChange): void;
+    adaptRanges(applyChange: ApplyRangeChange, sheetId?: UID): void;
+    allowDispatch(cmd: Command): CommandResult | CommandResult[];
+    handle(cmd: CoreCommand): void;
+    import(data: WorkbookData): void;
+    export(data: Partial<WorkbookData>): void;
+    exportForExcel(data: ExcelWorkbookData): void;
+    /**
+     * Returns all the conditional format rules defined for the current sheet to display the user
+     */
+    getConditionalFormats(sheetId: UID): ConditionalFormat[];
+    getRulesSelection(sheetId: UID, selection: Zone[]): UID[];
+    getRulesByZone(sheetId: UID, zone: Zone): Set<UID>;
+    getRulesByCell(sheetId: UID, cellCol: number, cellRow: number): Set<ConditionalFormat>;
+    /**
+     * Add or remove cells to a given conditional formatting rule and return the adapted CF's XCs.
+     */
+    getAdaptedCfRanges(sheetId: UID, cf: ConditionalFormat, toAdd: Zone[], toRemove: Zone[]): RangeData[] | undefined;
+    private mapToConditionalFormat;
+    private mapToConditionalFormatInternal;
+    /**
+     * Add or replace a conditional format rule
+     */
+    private addConditionalFormatting;
+    private checkValidPriorityChange;
+    private checkEmptyRange;
+    private checkCFRule;
+    private checkOperatorArgsNumber;
+    private checkNaN;
+    private checkFormulaCompilation;
+    private checkThresholds;
+    private checkInflectionPoints;
+    private checkLowerBiggerThanUpper;
+    private checkMinBiggerThanMax;
+    private checkMidBiggerThanMax;
+    private checkMinBiggerThanMid;
+    private checkCFValues;
+    private removeConditionalFormatting;
+    private changeCFPriority;
+}
+export {};

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

@@ -0,0 +1,33 @@
+import { ApplyRangeChange, CellPosition, Command, CommandResult, CoreCommand, DataValidationRule, ExcelWorkbookData, UID, WorkbookData } from "../../types";
+import { CorePlugin } from "../core_plugin";
+interface DataValidationState {
+    readonly rules: {
+        [sheet: string]: DataValidationRule[];
+    };
+}
+export declare class DataValidationPlugin extends CorePlugin<DataValidationState> implements DataValidationState {
+    static getters: readonly ["cellHasListDataValidationIcon", "getDataValidationRule", "getDataValidationRules", "getValidationRuleForCell"];
+    readonly rules: {
+        [sheet: string]: DataValidationRule[];
+    };
+    adaptRanges(applyChange: ApplyRangeChange, sheetId?: UID): void;
+    private loopThroughRangesOfSheet;
+    allowDispatch(cmd: Command): CommandResult | CommandResult[];
+    handle(cmd: CoreCommand): void;
+    getDataValidationRules(sheetId: UID): DataValidationRule[];
+    getDataValidationRule(sheetId: UID, id: UID): DataValidationRule | undefined;
+    getValidationRuleForCell({ sheetId, col, row }: CellPosition): DataValidationRule | undefined;
+    cellHasListDataValidationIcon(cellPosition: CellPosition): boolean;
+    private addDataValidationRule;
+    private removeRangesFromRules;
+    private removeDataValidationRule;
+    private setCenterStyleToBooleanCells;
+    private checkEmptyRange;
+    import(data: WorkbookData): void;
+    export(data: Partial<WorkbookData>): void;
+    exportForExcel(data: ExcelWorkbookData): void;
+    private checkCriterionTypeIsValid;
+    private checkCriterionHasValidNumberOfValues;
+    private checkCriterionValuesAreValid;
+}
+export {};

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

@@ -0,0 +1,34 @@
+import { CommandResult, CoreCommand, ExcelWorkbookData, Figure, UID, WorkbookData } from "../../types/index";
+import { CorePlugin } from "../core_plugin";
+interface FigureState {
+    readonly figures: {
+        [sheet: string]: Record<UID, Figure | undefined> | undefined;
+    };
+    readonly insertionOrders: UID[];
+}
+export declare class FigurePlugin extends CorePlugin<FigureState> implements FigureState {
+    static getters: readonly ["getFigures", "getFigure", "getFigureSheetId"];
+    readonly figures: {
+        [sheet: string]: Record<UID, Figure | undefined> | undefined;
+    };
+    readonly insertionOrders: UID[];
+    allowDispatch(cmd: CoreCommand): CommandResult;
+    beforeHandle(cmd: CoreCommand): void;
+    handle(cmd: CoreCommand): void;
+    private onRowColDelete;
+    private onRowDeletion;
+    private onColDeletion;
+    private updateFigure;
+    private addFigure;
+    private deleteSheet;
+    private removeFigure;
+    private checkFigureExists;
+    private checkFigureDuplicate;
+    getFigures(sheetId: UID): Figure[];
+    getFigure(sheetId: string, figureId: string): Figure | undefined;
+    getFigureSheetId(figureId: string): UID | undefined;
+    import(data: WorkbookData): void;
+    export(data: WorkbookData): void;
+    exportForExcel(data: ExcelWorkbookData): void;
+}
+export {};