@odoo/o-spreadsheet 18.0.55 → 18.0.67

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

@@ -0,0 +1,50 @@
+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 canDispatch: 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, canDispatch, 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/binary_grid.d.ts

@@ -0,0 +1,36 @@
+import { CellPosition } from "../../../types";
+type Bit = 0 | 1;
+/**
+ * Implements a fixed-sized grid or 2D matrix of bits.
+ * based on https://github.com/zandaqo/structurae
+ *
+ * The grid is implemented as a 1D array of 32-bit integers, where each bit represents a cell in the grid.
+ * It follows row-major order, with each row stored consecutively in 32-bit blocks.
+ * Pads the number of columns to the next power of 2 to allow quick lookups with bitwise operations.
+ *
+ * Key terminology:
+ * - bucket: Index of an item in the Uint32Array, a 32-bit integer.
+ * - bitPosition: The position of a bit within the bucket 32-bit integer.
+ */
+export declare class BinaryGrid extends Uint32Array {
+    private columnOffset;
+    cols: number;
+    rows: number;
+    /**
+     * Creates a binary grid of specified dimensions.
+     */
+    static create(rows: number, columns: number): BinaryGrid;
+    /**
+     * Returns the bit at given coordinates.
+     */
+    getValue(position: CellPosition): Bit;
+    /**
+     * Sets the bit at given coordinates.
+     */
+    setValue(position: CellPosition, value: Bit): boolean;
+    isEmpty(): boolean;
+    fillAllPositions(): void;
+    clear(): void;
+    private getCoordinates;
+}
+export {};

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

@@ -0,0 +1,14 @@
+import { ModelConfig } from "../../../model";
+import { CellPosition, EnsureRange, EvalContext, EvaluatedCell, Getters, ReferenceDenormalizer } from "../../../types";
+export type CompilationParameters = {
+    referenceDenormalizer: ReferenceDenormalizer;
+    ensureRange: EnsureRange;
+    evalContext: 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,58 @@
+import { CellPosition, CellValue, Command, EvaluatedCell, ExcelWorkbookData, Format, FormattedValue, FormulaCell, FunctionResultObject, GetSymbolValue, Matrix, Range, RangeCompiledFormula, UID, 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", "evaluateCompiledFormula", "getCorrespondingFormulaCell", "getRangeFormattedValues", "getRangeValues", "getRangeFormats", "getEvaluatedCell", "getEvaluatedCells", "getEvaluatedCellsInZone", "getEvaluatedCellsPositions", "getSpreadZone", "getArrayFormulaSpreadingOn", "isArrayFormulaSpillBlocked", "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, originCellPosition?: CellPosition): CellValue | Matrix<CellValue>;
+    evaluateFormulaResult(sheetId: UID, formulaString: string, originCellPosition?: CellPosition): Matrix<FunctionResultObject> | FunctionResultObject;
+    evaluateCompiledFormula(sheetId: UID, compiledFormula: RangeCompiledFormula, getSymbolValue: GetSymbolValue): FunctionResultObject | Matrix<FunctionResultObject>;
+    /**
+     * 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): EvaluatedCell[];
+    getEvaluatedCellsPositions(sheetId: UID): CellPosition[];
+    getEvaluatedCellsInZone(sheetId: UID, zone: Zone): EvaluatedCell[];
+    /**
+     * Return the spread zone the position is part of, if any
+     */
+    getSpreadZone(position: CellPosition, options?: {
+        ignoreSpillError: boolean;
+    }): Zone | undefined;
+    getArrayFormulaSpreadingOn(position: CellPosition): CellPosition | undefined;
+    isArrayFormulaSpillBlocked(position: CellPosition): boolean;
+    /**
+     * Check if a zone only contains empty cells
+     */
+    isEmpty(sheetId: UID, zone: Zone): boolean;
+    /**
+     * Maps the visible positions of a range  according to a provided callback
+     * @param range - the range we filter out
+     * @param evaluationCallback - the callback applied to the filtered positions
+     * @returns the values filtered (ie we keep only the not hidden values)
+     */
+    private mapVisiblePositions;
+    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;
+}

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

@@ -0,0 +1,59 @@
+import { ModelConfig } from "../../../model";
+import { CellPosition, EvaluatedCell, FunctionResultObject, GetSymbolValue, Getters, Matrix, RangeCompiledFormula, UID, Zone } from "../../../types";
+import { CompilationParameters } from "./compilation_parameters";
+export declare class Evaluator {
+    private readonly context;
+    private readonly getters;
+    private compilationParams;
+    private evaluatedCells;
+    private formulaDependencies;
+    private blockedArrayFormulas;
+    private spreadingRelations;
+    constructor(context: ModelConfig["custom"], getters: Getters);
+    getEvaluatedCell(position: CellPosition): EvaluatedCell;
+    getSpreadZone(position: CellPosition, options?: {
+        ignoreSpillError: boolean;
+    }): Zone | undefined;
+    getEvaluatedPositions(): CellPosition[];
+    getEvaluatedPositionsInSheet(sheetId: UID): CellPosition[];
+    getArrayFormulaSpreadingOn(position: CellPosition): CellPosition | undefined;
+    isArrayFormulaSpillBlocked(position: CellPosition): boolean;
+    updateDependencies(position: CellPosition): void;
+    private addDependencies;
+    private updateCompilationParameters;
+    private updateCompilationParametersForGridEvaluation;
+    private createEmptyPositionSet;
+    evaluateCells(positions: CellPosition[]): void;
+    private getArrayFormulasImpactedByChangesOf;
+    buildDependencyGraph(): void;
+    evaluateAllCells(): void;
+    evaluateFormulaResult(sheetId: UID, formulaString: string, originCellPosition?: CellPosition): FunctionResultObject | Matrix<FunctionResultObject>;
+    evaluateCompiledFormula(sheetId: UID, compiledFormula: RangeCompiledFormula, getContextualSymbolValue?: GetSymbolValue): FunctionResultObject | Matrix<FunctionResultObject>;
+    private getAllCells;
+    /**
+     * Return the position of formulas blocked by the given positions
+     * as well as all their dependencies.
+     */
+    private getArrayFormulasBlockedBy;
+    private nextPositionsToUpdate;
+    private cellsBeingComputed;
+    private symbolsBeingComputed;
+    private evaluate;
+    private computeCell;
+    private computeAndSave;
+    private computeFormulaCell;
+    private invalidatePositionsDependingOnSpread;
+    private assertSheetHasEnoughSpaceToSpreadFormulaResult;
+    private assertNoMergedCellsInSpreadZone;
+    private checkCollision;
+    private spreadValues;
+    private invalidateSpreading;
+    /**
+     * Wraps a GetSymbolValue function to add cycle detection
+     * and error handling.
+     */
+    private buildSafeGetSymbolValue;
+    private getDirectDependencies;
+    private getCellsDependingOn;
+}
+export declare function updateEvalContextAndExecute(compiledFormula: RangeCompiledFormula, compilationParams: CompilationParameters, sheetId: UID, getSymbolValue: GetSymbolValue, originCellPosition: CellPosition | undefined): FunctionResultObject | Matrix<FunctionResultObject>;

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

@@ -0,0 +1,24 @@
+import { CellPosition } from "../../../types";
+import { PositionSet } from "./position_set";
+import { RTreeBoundingBox, RTreeItem } from "./r_tree";
+/**
+ * Implementation of a dependency Graph.
+ * The graph is used to evaluate the cells in the correct
+ * order, and should be updated each time a cell's content is modified
+ *
+ * It uses an R-Tree data structure to efficiently find dependent cells.
+ */
+export declare class FormulaDependencyGraph {
+    private readonly createEmptyPositionSet;
+    private readonly dependencies;
+    private readonly rTree;
+    constructor(createEmptyPositionSet: () => PositionSet, data?: RTreeItem<CellPosition>[]);
+    removeAllDependencies(formulaPosition: CellPosition): void;
+    addDependencies(formulaPosition: CellPosition, dependencies: RTreeBoundingBox[]): void;
+    /**
+     * Return all the cells that depend on the provided ranges,
+     * in the correct order they should be evaluated.
+     * This is called a topological ordering (excluding cycles)
+     */
+    getCellsDependingOn(ranges: RTreeBoundingBox[], ignore: PositionSet): PositionSet;
+}

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

@@ -0,0 +1 @@
+export * from "./evaluation_plugin";

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

@@ -0,0 +1,11 @@
+import { CellPosition, UID } from "../../../types";
+export declare class PositionMap<T> {
+    private map;
+    set({ sheetId, col, row }: CellPosition, value: T): void;
+    get({ sheetId, col, row }: CellPosition): T | undefined;
+    getSheet(sheetId: UID): Record<number, Record<number, T>> | undefined;
+    has({ sheetId, col, row }: CellPosition): boolean;
+    delete({ sheetId, col, row }: CellPosition): void;
+    keys(): CellPosition[];
+    keysForSheet(sheetId: UID): CellPosition[];
+}

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

@@ -0,0 +1,28 @@
+import { CellPosition, UID } from "../../../types";
+export type SheetSizes = Record<UID, {
+    rows: number;
+    cols: number;
+}>;
+export declare class PositionSet {
+    private sheets;
+    /**
+     * List of positions in the order they were inserted.
+     */
+    private insertions;
+    private maxSize;
+    constructor(sheetSizes: SheetSizes);
+    add(position: CellPosition): void;
+    addMany(positions: Iterable<CellPosition>): void;
+    delete(position: CellPosition): void;
+    deleteMany(positions: Iterable<CellPosition>): void;
+    has(position: CellPosition): boolean;
+    clear(): CellPosition[];
+    isEmpty(): boolean;
+    fillAllPositions(): void;
+    /**
+     * Iterate over the positions in the order of insertion.
+     * Note that the same position may be yielded multiple times if the value was added
+     * to the set then removed and then added again.
+     */
+    [Symbol.iterator](): Generator<CellPosition>;
+}

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

@@ -0,0 +1,108 @@
+import { UID, Zone } from "../../../types";
+/**
+ * R-Tree Data Structure
+ *
+ * R-Tree is a spatial data structure used for efficient indexing and querying
+ * of multi-dimensional objects, particularly in geometric and spatial applications.
+ *
+ * It organizes objects into a tree hierarchy, grouping nearby objects together
+ * in bounding boxes. Each node in the tree represents a bounding box that
+ * contains its child nodes or leaf objects. This hierarchical structure allows
+ * for faster spatial queries.
+ *
+ * @see https://en.wikipedia.org/wiki/R-tree
+ *
+ * Consider a 2D Space with four zones: A, B, C, D
+ * +--------------------------+
+ * |                          |
+ * |   +---+     +-------+    |
+ * |   | A |     |   B   |    |
+ * |   +---+     +-------+    |
+ * |                          |
+ * |                          |
+ * |          +---+           |
+ * |          | C |           |
+ * |          +---+           |
+ * |      +-----------+       |
+ * |      |     D     |       |
+ * |      +-----------+       |
+ * |                          |
+ * +--------------------------+
+ *
+ * It groups together zones that are spatially close into a minimum bounding box.
+ * For example, A and B are grouped together in rectangle R1, and C and D are grouped
+ * in R2.
+ *
+ * R0
+ * +--------------------------+
+ * |   R1                     |
+ * |   +-----------------+    |
+ * |   | A |     |   B   |    |
+ * |   +-----------------+    |
+ * |                          |
+ * |      R2                  |
+ * |      +---+---+---+       |
+ * |      |   | C |   |       |
+ * |      |   +---+   |       |
+ * |      +-----------+       |
+ * |      |     D     |       |
+ * |      +-----------+       |
+ * |                          |
+ * +--------------------------+
+ *
+ * The tree would look like this:
+ *          R0
+ *         /  \
+ *        /    \
+ *       R1     R2
+ *       |      |
+ *      A,B    C,D
+
+ * Choosing how to group the zones is crucial for the performance of the tree.
+ * Key considerations include avoiding excessive empty space coverage and minimizing overlap
+ * to reduce the number of subtrees processed during searches.
+ *
+ * Various heuristics exist for determining the optimal grouping strategy, such as "least enlargement"
+ * which prioritizes grouping nodes resulting in the smallest increase in bounding box size. In cases where
+ * the choice cannot be made based on this criterion due to the same enlargement for different groupings,
+ * we then evaluate "least area," aiming to minimize the overall area of bounding boxes.
+ *
+ * This implementation is tailored for spreadsheet use, indexing objects associated
+ * with a zone and a sheet.
+ *
+ * It uses the RBush library under the hood. One 2D RBush R-tree per sheet.
+ * @see https://github.com/mourner/rbush
+ */
+export declare class SpreadsheetRTree<T> {
+    /**
+     * One 2D R-tree per sheet
+     */
+    private rTrees;
+    /**
+     * Bulk-inserts the given items into the tree. Bulk insertion is usually ~2-3 times
+     * faster than inserting items one by one. After bulk loading (bulk insertion into
+     * an empty tree), subsequent query performance is also ~20-30% better.
+     */
+    constructor(items?: RTreeItem[]);
+    insert(item: RTreeItem<T>): void;
+    search({ zone, sheetId }: RTreeBoundingBox): RTreeItem<T>[];
+    remove(item: RTreeItem<T>): void;
+    rtreeItemComparer(left: RTreeItem<T>, right: RTreeItem<T>): boolean;
+}
+/**
+ * Data associated with a range to be indexed in a R-tree
+ */
+export interface RTreeItem<T = unknown> {
+    /**
+     * A bounding box to locate the item in the space
+     */
+    boundingBox: RTreeBoundingBox;
+    /**
+     * Any arbitrary data associated with the bounding box
+     */
+    data: T;
+}
+export interface RTreeBoundingBox {
+    sheetId: UID;
+    zone: Zone;
+}

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

@@ -0,0 +1,63 @@
+import { CellPosition, UID, Zone } from "../../../types";
+/**
+ * Contains, for each cell, the array
+ * formulas that could potentially spread on it
+ * This is essentially a two way mapping between array formulas
+ * and their results.
+ *
+ * As we don't allow two array formulas to spread on the same cell, this structure
+ * is used to force the reevaluation of the potential spreaders of a cell when the
+ * content of this cell is modified. This structure should be updated each time
+ * an array formula is evaluated and try to spread on another cell.
+ *
+ */
+export declare class SpreadingRelation {
+    /**
+     * Internal structure:
+     * For something like
+     * - A2:'=SPLIT("KAYAK", "A")'
+     * - B1:'=TRANSPOSE(SPLIT("COYOTE", "O"))'
+     *
+     * Resulting in:
+     * ```
+     * -----------------
+     * |   | A | B | C |
+     * |---+---+---+---|
+     * | 1 |   | C |   |
+     * | 2 | K | Y | K |
+     * | 3 |   | T |   |
+     * | 4 |   | E |   |
+     * -----------------
+     * ```
+     * We have `resultsToArrayFormulas` is an R-tree looking like:
+     * - (A2:C2) --> A2     meaning values in A2:C2 are the result of A2
+     * - (B1:B4) --> B1     meaning values in B1:B4 are the result of B1
+     *
+     * Note that B2 is part of both zones because it can be the result of
+     * A2 or B1.
+     * Using an R-tree allows for fast insertions while still having
+     * a relatively fast lookup.
+     *
+     * We have `arrayFormulasToResults` looking like:
+     * - (A2) --> A2:C2     meaning A2 spreads on the zone A2:C2
+     * - (B1) --> B1:B4     meaning B1 spreads on the zone B1:B4
+     *
+     */
+    private readonly resultsToArrayFormulas;
+    private readonly arrayFormulasToResults;
+    searchFormulaPositionsSpreadingOn(sheetId: UID, zone: Zone): Iterable<CellPosition>;
+    getArrayResultZone(formulasPosition: CellPosition): Zone | undefined;
+    /**
+     * Remove a spreading relation for a given array formula position
+     * and its result zone
+     */
+    removeNode(position: CellPosition): void;
+    /**
+     * Create a spreading relation between two cells
+     */
+    addRelation({ arrayFormulaPosition, resultZone: resultPosition, }: {
+        arrayFormulaPosition: CellPosition;
+        resultZone: Zone;
+    }): void;
+    isArrayFormula(position: CellPosition): boolean;
+}

package/dist/types/plugins/ui_core_views/custom_colors.d.ts

@@ -0,0 +1,28 @@
+import { Color, Command, Immutable } from "../../types";
+import { UIPlugin, UIPluginConfig } from "../ui_plugin";
+interface CustomColorState {
+    readonly customColors: Immutable<Record<Color, true>>;
+    readonly shouldUpdateColors: boolean;
+}
+/**
+ * CustomColors plugin
+ * This plugins aims to compute and keep to custom colors used in the
+ * current spreadsheet
+ */
+export declare class CustomColorsPlugin extends UIPlugin<CustomColorState> {
+    private readonly customColors;
+    private readonly shouldUpdateColors;
+    static getters: readonly ["getCustomColors"];
+    constructor(config: UIPluginConfig);
+    handle(cmd: Command): void;
+    finalize(): void;
+    getCustomColors(): Color[];
+    private computeCustomColors;
+    private getColorsFromCells;
+    private getFormattingColors;
+    private getChartColors;
+    private getTableColors;
+    private getTableStyleElementColors;
+    private tryToAddColors;
+}
+export {};

package/dist/types/plugins/ui_core_views/dynamic_tables.d.ts

@@ -0,0 +1,32 @@
+import { CellPosition, Command, ExcelWorkbookData, Filter, FilterId, Table, UID, Zone } from "../../types/index";
+import { UIPlugin } from "../ui_plugin";
+export declare class DynamicTablesPlugin extends UIPlugin {
+    static getters: readonly ["canCreateDynamicTableOnZones", "doesZonesContainFilter", "getFilter", "getFilters", "getTable", "getTables", "getTablesOverlappingZones", "getFilterId", "getFilterHeaders", "isFilterHeader"];
+    tables: Record<UID, Table[]>;
+    handle(cmd: Command): void;
+    finalize(): void;
+    private computeTables;
+    getFilters(sheetId: UID): Filter[];
+    getTables(sheetId: UID): Table[];
+    getFilter(position: CellPosition): Filter | undefined;
+    getFilterId(position: CellPosition): FilterId | undefined;
+    getTable({ sheetId, col, row }: CellPosition): Table | undefined;
+    getTablesOverlappingZones(sheetId: UID, zones: Zone[]): Table[];
+    doesZonesContainFilter(sheetId: UID, zones: Zone[]): boolean;
+    getFilterHeaders(sheetId: UID): CellPosition[];
+    isFilterHeader({ sheetId, col, row }: CellPosition): boolean;
+    /**
+     * Check if we can create a dynamic table on the given zones.
+     * - The zones must be continuous
+     * - The union of the zones must be either:
+     *    - A single cell that contains an array formula
+     *    - All the spread cells of a single array formula
+     */
+    canCreateDynamicTableOnZones(sheetId: UID, zones: Zone[]): boolean;
+    private coreTableToTable;
+    private getDynamicTableFilters;
+    private getDynamicTableFilterId;
+    /** Check if a table contains array formula, as we cannot have them in a table in Excel */
+    private isTableExcelExportable;
+    exportForExcel(data: ExcelWorkbookData): void;
+}

package/dist/types/plugins/ui_core_views/evaluation_chart.d.ts

@@ -0,0 +1,24 @@
+import { Color, ExcelWorkbookData, Range, UID } from "../../types";
+import { ChartRuntime } from "../../types/chart/chart";
+import { CoreViewCommand } from "../../types/commands";
+import { UIPlugin } from "../ui_plugin";
+interface EvaluationChartStyle {
+    background: Color;
+    fontColor: Color;
+}
+interface EvaluationChartState {
+    charts: Record<UID, ChartRuntime | undefined>;
+}
+export declare class EvaluationChartPlugin extends UIPlugin<EvaluationChartState> {
+    static getters: readonly ["getChartRuntime", "getStyleOfSingleCellChart"];
+    charts: Record<UID, ChartRuntime | undefined>;
+    private createRuntimeChart;
+    handle(cmd: CoreViewCommand): void;
+    getChartRuntime(figureId: UID): ChartRuntime;
+    /**
+     * Get the background and textColor of a chart based on the color of the first cell of the main range of the chart.
+     */
+    getStyleOfSingleCellChart(chartBackground: Color | undefined, mainRange: Range | undefined): EvaluationChartStyle;
+    exportForExcel(data: ExcelWorkbookData): void;
+}
+export {};

package/dist/types/plugins/ui_core_views/evaluation_conditional_format.d.ts

@@ -0,0 +1,41 @@
+import { CellPosition, DataBarFill, Style } from "../../types/index";
+import { UIPlugin } from "../ui_plugin";
+import { CoreViewCommand } from "./../../types/commands";
+export declare class EvaluationConditionalFormatPlugin extends UIPlugin {
+    static getters: readonly ["getConditionalIcon", "getCellConditionalFormatStyle", "getConditionalDataBar"];
+    private isStale;
+    private computedStyles;
+    private computedIcons;
+    private computedDataBars;
+    handle(cmd: CoreViewCommand): void;
+    finalize(): void;
+    getCellConditionalFormatStyle(position: CellPosition): Style | undefined;
+    getConditionalIcon({ sheetId, col, row }: CellPosition): string | undefined;
+    getConditionalDataBar({ sheetId, col, row }: CellPosition): DataBarFill | undefined;
+    /**
+     * Compute the styles according to the conditional formatting.
+     * This computation must happen after the cell values are computed if they change
+     *
+     * This result of the computation will be in the state.cell[XC].conditionalStyle and will be the union of all the style
+     * properties of the rules applied (in order).
+     * So if a cell has multiple conditional formatting applied to it, and each affect a different value of the style,
+     * the resulting style will have the combination of all those values.
+     * If multiple conditional formatting use the same style value, they will be applied in order so that the last applied wins
+     */
+    private getComputedStyles;
+    private getComputedIcons;
+    private getComputedDataBars;
+    private parsePoint;
+    /** Compute the CF icons for the given range and CF rule, and apply in in the given computedIcons object */
+    private applyIcon;
+    private computeIcon;
+    private applyDataBar;
+    /** Compute the color scale for the given range and CF rule, and apply in in the given computedStyle object */
+    private applyColorScale;
+    private computeColorDiffUnits;
+    private colorCell;
+    /**
+     * Execute the predicate to know if a conditional formatting rule should be applied to a cell
+     */
+    private rulePredicate;
+}

package/dist/types/plugins/ui_core_views/evaluation_data_validation.d.ts

@@ -0,0 +1,38 @@
+import { CellPosition, CellValue, DataValidationCriterionType, DataValidationRule, HeaderIndex, Lazy, UID } from "../../types";
+import { CoreViewCommand } from "../../types/commands";
+import { UIPlugin } from "../ui_plugin";
+interface InvalidValidationResult {
+    readonly isValid: false;
+    readonly rule: DataValidationRule;
+    readonly error: string;
+}
+interface ValidValidationResult {
+    readonly isValid: true;
+}
+type ValidationResult = ValidValidationResult | InvalidValidationResult;
+type SheetValidationResult = {
+    [col: HeaderIndex]: Array<Lazy<ValidationResult>>;
+};
+export declare class EvaluationDataValidationPlugin extends UIPlugin {
+    static getters: readonly ["getDataValidationInvalidCriterionValueMessage", "getInvalidDataValidationMessage", "getValidationResultForCellValue", "isCellValidCheckbox", "isDataValidationInvalid"];
+    validationResults: Record<UID, SheetValidationResult>;
+    handle(cmd: CoreViewCommand): void;
+    isDataValidationInvalid(cellPosition: CellPosition): boolean;
+    getInvalidDataValidationMessage(cellPosition: CellPosition): string | undefined;
+    /**
+     * Check if the value is valid for the given criterion, and return an error message if not.
+     *
+     * The value must be canonicalized.
+     */
+    getDataValidationInvalidCriterionValueMessage(criterionType: DataValidationCriterionType, value: string): string | undefined;
+    isCellValidCheckbox(cellPosition: CellPosition): boolean;
+    /** Get the validation result if the cell on the given position had the given value */
+    getValidationResultForCellValue(cellValue: CellValue, cellPosition: CellPosition): ValidationResult;
+    private getValidationResultForCell;
+    private computeSheetValidationResults;
+    private getRuleErrorForCellValue;
+    /** Get the offset of the cell inside the ranges of the rule. Throws an error if the cell isn't inside the rule. */
+    private getCellOffsetInRule;
+    private getEvaluatedCriterionValues;
+}
+export {};