@odoo/o-spreadsheet 19.2.11 → 19.4.0-alpha.4

package/dist/types/model.d.ts

@@ -0,0 +1,168 @@
+import { EventBus } from "./helpers/event_bus";
+import { StateUpdateMessage } from "./types/collaborative/transport_service";
+import { CommandDispatcher } from "./types/commands";
+import { Getters } from "./types/getters";
+import { Mode, ModelConfig } from "./types/model";
+import { GridRenderingContext, LayerName } from "./types/rendering";
+import { SelectionStreamProcessor } from "./types/selection_stream_processor";
+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 canceled).
+ *
+ * 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 declare class Model extends EventBus<any> implements CommandDispatcher {
+    private corePlugins;
+    private statefulUIPlugins;
+    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 coreViewPluginConfig;
+    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;
+    private readonly handlers;
+    private readonly uiHandlers;
+    private readonly coreHandlers;
+    constructor(data?: any, config?: Partial<ModelConfig>, stateUpdateMessages?: StateUpdateMessage[], verboseImport?: boolean);
+    joinSession(): void;
+    leaveSession({ shouldSnapshot }?: {
+        shouldSnapshot?: boolean;
+    }): Promise<void>;
+    private setupUiPlugin;
+    private setupCoreViewPlugin;
+    /**
+     * 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 setupCoreViewPluginConfig;
+    private setupUiPluginConfig;
+    /**
+     * Check if the given command is allowed by all the plugins and the history.
+     */
+    private checkDispatchAllowed;
+    private processCommandResults;
+    private checkDispatchAllowedRemoteCommand;
+    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 data out of the model.
+     */
+    exportData(): WorkbookData;
+    _exportData(shouldSquish: boolean): 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(): Promise<XLSXExport>;
+}

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

@@ -0,0 +1,65 @@
+import { StateObserver } from "../state_observer";
+import { CommandHandler, CommandResult } from "../types/commands";
+import type { WorkbookHistory } from "../types/history";
+import { Validation } from "../types/misc";
+import type { Validator } from "../types/validator";
+import { ExcelWorkbookData } from "../types/workbook_data";
+/**
+ * BasePlugin
+ *
+ * Since the spreadsheet internal state is quite complex, it is split into
+ * multiple parts, each managing a specific concern.
+ *
+ * This file introduces the BasePlugin, which is the common class that defines
+ * how each of these model sub parts should interact with each other.
+ * There are two kinds 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>;
+    constructor(stateObserver: StateObserver);
+    /**
+     * Export for excel should be available for all plugins, even for the UI.
+     * In some cases, we need to export evaluated value, which is available from
+     * UI plugin only.
+     */
+    exportForExcel(data: ExcelWorkbookData): void | Promise<void>;
+    /**
+     * Before a command is accepted, the model will ask each plugin if the command
+     * is allowed. If all of them 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 needs 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 results 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<NoInfer<T>>[]): CommandResult | CommandResult[];
+}

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

@@ -0,0 +1,129 @@
+import { CommandResult, CoreCommand } from "../../types/commands";
+import { Border, CellPosition, Color, UID } from "../../types/misc";
+import { ExcelWorkbookData, WorkbookData } from "../../types/workbook_data";
+import { CorePlugin } from "../core_plugin";
+interface BordersPluginState {
+    readonly borders: Record<UID, ((Border | undefined)[] | 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/carousel.d.ts

@@ -0,0 +1,20 @@
+import { CommandResult, CoreCommand } from "../../types/commands";
+import { Carousel } from "../../types/figure";
+import { UID } from "../../types/misc";
+import { WorkbookData } from "../../types/workbook_data";
+import { CorePlugin } from "../core_plugin";
+interface CarouselState {
+    readonly carousels: Record<UID, Record<UID, Carousel | undefined> | undefined>;
+}
+export declare class CarouselPlugin extends CorePlugin<CarouselState> implements CarouselState {
+    static getters: readonly ["getCarousel", "doesCarouselExist"];
+    readonly carousels: Record<UID, Record<UID, Carousel | undefined> | undefined>;
+    allowDispatch(cmd: CoreCommand): CommandResult.Success | CommandResult.InvalidFigureId | CommandResult.DuplicatedFigureId;
+    handle(cmd: CoreCommand): void;
+    doesCarouselExist(figureId: UID): boolean;
+    getCarousel(figureId: UID): Carousel;
+    private removeDeletedCharts;
+    import(data: WorkbookData): void;
+    export(data: WorkbookData): void;
+}
+export {};

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

@@ -0,0 +1,99 @@
+import { CorePlugin } from "../core_plugin";
+import { Cell } from "../../types/cells";
+import { CommandResult, CoreCommand } from "../../types/commands";
+import { CellPosition, RangeAdapterFunctions, UID } from "../../types/misc";
+import { CompiledFormula, SerializedCompiledFormula } from "../../formulas/compiler";
+import { Format } from "../../types/format";
+import { Style, Zone } from "../../types/misc";
+import { Range, RangePart } from "../../types/range";
+import { ExcelWorkbookData, WorkbookData } from "../../types/workbook_data";
+interface CoreState {
+    cells: Record<UID, Record<number, 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(adapters: RangeAdapterFunctions): void;
+    allowDispatch(cmd: CoreCommand): CommandResult | CommandResult[];
+    handle(cmd: CoreCommand): void;
+    private clearZones;
+    /**
+     * 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, shouldSquish: boolean): void;
+    importCell(sheetId: UID, content?: string, style?: Style, format?: Format, compiledFormula?: CompiledFormula | undefined): Cell;
+    exportForExcel(data: ExcelWorkbookData): void;
+    private extractCustomStyle;
+    getCells(sheetId: 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: number): Cell | undefined;
+    getFormulaString(sheetId: UID, compiledFormula: CompiledFormula, dependencies: Range[], useBoundedReference?: boolean): string;
+    /**
+     * Constructs a formula string based on an initial formula and a translation vector
+     */
+    getTranslatedCellFormula(sheetId: UID, offsetX: number, offsetY: number, compiledFormula: CompiledFormula | SerializedCompiledFormula): string;
+    getFormulaMovedInSheet(targetSheetId: UID, compiledFormula: CompiledFormula): 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 setStyleFormat;
+    /**
+     * 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 getNextCellId;
+    private updateCell;
+    private checkCellOutOfSheet;
+    private checkUselessClearCell;
+    private checkUselessUpdateCell;
+    private checkUselessSetFormatting;
+}
+export {};

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

@@ -0,0 +1,45 @@
+import { SpreadsheetChart } from "../../helpers/figures/chart";
+import { ChartCreationContext, ChartDefinition, ChartType } from "../../types/chart/chart";
+import { Command, CommandResult, CoreCommand } from "../../types/commands";
+import { RangeAdapterFunctions, UID } from "../../types/misc";
+import { WorkbookData } from "../../types/workbook_data";
+import { CorePlugin } from "../core_plugin";
+interface FigureChart {
+    figureId: UID;
+    chart: SpreadsheetChart;
+}
+interface ChartState {
+    readonly charts: Record<UID, FigureChart | undefined>;
+}
+export declare class ChartPlugin extends CorePlugin<ChartState> implements ChartState {
+    static getters: readonly ["isChartDefined", "getChartDefinition", "getChartType", "getChartIds", "getChart", "getFigureIdFromChartId", "getContextCreationChart"];
+    readonly charts: Record<UID, FigureChart | undefined>;
+    adaptRanges(rangeAdapters: RangeAdapterFunctions): void;
+    allowDispatch(cmd: Command): CommandResult | CommandResult[];
+    handle(cmd: CoreCommand): void;
+    getContextCreationChart(chartId: UID): ChartCreationContext | undefined;
+    getChart(chartId: UID): SpreadsheetChart | undefined;
+    getFigureIdFromChartId(chartId: UID): UID;
+    getChartType(chartId: UID): ChartType;
+    isChartDefined(chartId: UID): boolean;
+    getChartIds(sheetId: UID): string[];
+    getChartDefinition(chartId: UID): ChartDefinition<string>;
+    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 checkChartDefinition;
+    private checkChartExists;
+    private checkChartChanged;
+    /** If the command is meant to create a new figure, the position & offset argument need to be defined in the command */
+    private checkFigureArguments;
+}
+export {};

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

@@ -0,0 +1,59 @@
+import { Command, CommandResult, CoreCommand } from "../../types/commands";
+import { ConditionalFormat, ConditionalFormatInternal } from "../../types/conditional_formatting";
+import { RangeAdapterFunctions, UID, Zone } from "../../types/misc";
+import { RangeData } from "../../types/range";
+import { ExcelWorkbookData, WorkbookData } from "../../types/workbook_data";
+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[];
+    };
+    adaptCFFormulas({ applyChange, adaptFormulaString }: RangeAdapterFunctions): void;
+    adaptCFRanges(sheetId: UID, { applyChange }: RangeAdapterFunctions): void;
+    adaptRanges(rangeAdapters: RangeAdapterFunctions): 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 checkCFHasChanged;
+    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,38 @@
+import { Command, CommandResult, CoreCommand } from "../../types/commands";
+import { DataValidationRule } from "../../types/data_validation";
+import { CellPosition, RangeAdapterFunctions, UID } from "../../types/misc";
+import { ExcelWorkbookData, WorkbookData } from "../../types/workbook_data";
+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(rangeAdapters: RangeAdapterFunctions): void;
+    private adaptDVFormulas;
+    private adaptDVRanges;
+    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;
+    private checkValidRange;
+}
+export {};

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

@@ -0,0 +1,40 @@
+import { CommandResult, CoreCommand } from "../../types/commands";
+import { Figure } from "../../types/figure";
+import { RangeAdapterFunctions, UID } from "../../types/misc";
+import { ExcelWorkbookData, WorkbookData } from "../../types/workbook_data";
+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[];
+    adaptRanges(rangeAdapterFunctions: RangeAdapterFunctions): void;
+    adaptRangesOnSheet({ applyChange }: RangeAdapterFunctions, sheetId: UID): void;
+    allowDispatch(cmd: CoreCommand): CommandResult | CommandResult[];
+    beforeHandle(cmd: CoreCommand): void;
+    handle(cmd: CoreCommand): void;
+    private onColRemove;
+    private onRowRemove;
+    private getPositionInSheet;
+    private updateFigure;
+    private addFigure;
+    private deleteSheet;
+    private removeFigure;
+    private checkFigureExists;
+    private checkFigureDuplicate;
+    private checkFigureAnchorOffset;
+    getFigures(sheetId: UID): Figure[];
+    getFigure(sheetId: UID, figureId: string): Figure | undefined;
+    getFigureSheetId(figureId: string): UID | undefined;
+    import(data: WorkbookData): void;
+    export(data: WorkbookData): void;
+    exportForExcel(data: ExcelWorkbookData): void;
+}
+export {};