@odoo/o-spreadsheet 19.5.0-alpha.6 → 19.5.0-alpha.8

package/dist/types/functions/module_text.d.ts

@@ -3,31 +3,41 @@ import { Arg, FunctionResultNumber, FunctionResultObject, Maybe } from "../types
 export declare const CHAR: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, tableNumber: Maybe<FunctionResultObject>) => string | EvaluationError;
+    compute: (this: import("..").EvalContext, tableNumber: Maybe<FunctionResultObject>) => EvaluationError | {
+        value: string;
+    };
     isExported: true;
 };
 export declare const CLEAN: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (text: Maybe<FunctionResultObject>) => string;
+    compute: (text: Maybe<FunctionResultObject>) => {
+        value: string;
+    };
     isExported: true;
 };
 export declare const CONCATENATE: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (...datas: Arg[]) => string;
+    compute: (...datas: Arg[]) => {
+        value: string;
+    };
     isExported: true;
 };
 export declare const EXACT: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (string1: Maybe<FunctionResultObject>, string2: Maybe<FunctionResultObject>) => boolean;
+    compute: (string1: Maybe<FunctionResultObject>, string2: Maybe<FunctionResultObject>) => {
+        value: boolean;
+    };
     isExported: true;
 };
 export declare const FIND: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, searchFor: Maybe<FunctionResultObject>, textToSearch: Maybe<FunctionResultObject>, startingAt?: Maybe<FunctionResultObject>) => number | EvaluationError;
+    compute: (this: import("..").EvalContext, searchFor: Maybe<FunctionResultObject>, textToSearch: Maybe<FunctionResultObject>, startingAt?: Maybe<FunctionResultObject>) => EvaluationError | {
+        value: number;
+    };
     isExported: true;
 };
 export declare const FORMAT_LARGE_NUMBER: {
@@ -38,48 +48,64 @@ export declare const FORMAT_LARGE_NUMBER: {
 export declare const JOIN: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (delimiter: Maybe<FunctionResultObject>, ...valuesOrArrays: Arg[]) => string;
+    compute: (delimiter: Maybe<FunctionResultObject>, ...valuesOrArrays: Arg[]) => {
+        value: string;
+    };
 };
 export declare const LEFT: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>, ...args: Maybe<FunctionResultObject>[]) => string | EvaluationError;
+    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>, ...args: Maybe<FunctionResultObject>[]) => EvaluationError | {
+        value: string;
+    };
     isExported: true;
 };
 export declare const LEN: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (text: Maybe<FunctionResultObject>) => number;
+    compute: (text: Maybe<FunctionResultObject>) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const LOWER: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (text: Maybe<FunctionResultObject>) => string;
+    compute: (text: Maybe<FunctionResultObject>) => {
+        value: string;
+    };
     isExported: true;
 };
 export declare const MID: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>, starting_at: Maybe<FunctionResultObject>, extract_length: Maybe<FunctionResultObject>) => string | EvaluationError;
+    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>, starting_at: Maybe<FunctionResultObject>, extract_length: Maybe<FunctionResultObject>) => EvaluationError | {
+        value: string;
+    };
     isExported: true;
 };
 export declare const PROPER: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (text: Maybe<FunctionResultObject>) => string;
+    compute: (text: Maybe<FunctionResultObject>) => {
+        value: string;
+    };
     isExported: true;
 };
 export declare const REGEXTEST: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>, pattern: Maybe<FunctionResultObject>, newText?: Maybe<FunctionResultObject>) => boolean | EvaluationError;
+    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>, pattern: Maybe<FunctionResultObject>, newText?: Maybe<FunctionResultObject>) => EvaluationError | {
+        value: boolean;
+    };
     isExported: true;
 };
 export declare const REGEXEXTRACT: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>, pattern: Maybe<FunctionResultObject>, return_mode?: Maybe<FunctionResultObject>, newText?: Maybe<FunctionResultObject>) => string | string[][] | EvaluationError | {
+    computeArray: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>, pattern: Maybe<FunctionResultObject>, return_mode?: Maybe<FunctionResultObject>, newText?: Maybe<FunctionResultObject>) => EvaluationError | {
+        value: string;
+    }[][] | {
         value: string;
     };
     isExported: true;
@@ -87,19 +113,25 @@ export declare const REGEXEXTRACT: {
 export declare const REGEXREPLACE: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>, pattern: Maybe<FunctionResultObject>, replacement: Maybe<FunctionResultObject>, occurence?: Maybe<FunctionResultObject>, newText?: Maybe<FunctionResultObject>) => string | EvaluationError;
+    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>, pattern: Maybe<FunctionResultObject>, replacement: Maybe<FunctionResultObject>, occurence?: Maybe<FunctionResultObject>, newText?: Maybe<FunctionResultObject>) => EvaluationError | {
+        value: string;
+    };
     isExported: true;
 };
 export declare const REPLACE: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>, position: Maybe<FunctionResultObject>, length: Maybe<FunctionResultObject>, newText: Maybe<FunctionResultObject>) => string | EvaluationError;
+    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>, position: Maybe<FunctionResultObject>, length: Maybe<FunctionResultObject>, newText: Maybe<FunctionResultObject>) => EvaluationError | {
+        value: string;
+    };
     isExported: true;
 };
 export declare const RIGHT: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>, ...args: Maybe<FunctionResultObject>[]) => string | EvaluationError;
+    compute: (this: import("..").EvalContext, text: Maybe<FunctionResultObject>, ...args: Maybe<FunctionResultObject>[]) => EvaluationError | {
+        value: string;
+    };
     isExported: true;
 };
 export declare const SEARCH: {
@@ -117,49 +149,63 @@ export declare const SEARCH: {
 export declare const SPLIT: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (text: Maybe<FunctionResultObject>, delimiter: Maybe<FunctionResultObject>, splitByEach?: Maybe<FunctionResultObject>, removeEmptyText?: Maybe<FunctionResultObject>) => EvaluationError | import("..").Matrix<string>;
+    computeArray: (text: Maybe<FunctionResultObject>, delimiter: Maybe<FunctionResultObject>, splitByEach?: Maybe<FunctionResultObject>, removeEmptyText?: Maybe<FunctionResultObject>) => EvaluationError | import("..").Matrix<{
+        value: string;
+    }>;
     isExported: false;
 };
 export declare const SUBSTITUTE: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, textToSearch: Maybe<FunctionResultObject>, searchFor: Maybe<FunctionResultObject>, replaceWith: Maybe<FunctionResultObject>, occurrenceNumber: Maybe<FunctionResultObject>) => string | EvaluationError;
+    compute: (this: import("..").EvalContext, textToSearch: Maybe<FunctionResultObject>, searchFor: Maybe<FunctionResultObject>, replaceWith: Maybe<FunctionResultObject>, occurrenceNumber: Maybe<FunctionResultObject>) => EvaluationError | {
+        value: string;
+    };
     isExported: true;
 };
 export declare const TEXTJOIN: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (delimiter: Maybe<FunctionResultObject>, ignoreEmpty?: Maybe<FunctionResultObject>, ...textsOrArrays: Arg[]) => string;
+    compute: (delimiter: Maybe<FunctionResultObject>, ignoreEmpty?: Maybe<FunctionResultObject>, ...textsOrArrays: Arg[]) => {
+        value: string;
+    };
     isExported: true;
 };
 export declare const TEXTSPLIT: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, text: FunctionResultObject, colDelimiter: Arg, rowDelimiter: Arg, ignoreEmpty?: Maybe<FunctionResultObject>, matchMode?: Maybe<FunctionResultObject>, padWith?: Maybe<FunctionResultObject>) => EvaluationError | import("..").Matrix<FunctionResultObject>;
+    computeArray: (this: import("..").EvalContext, text: FunctionResultObject, colDelimiter: Arg, rowDelimiter: Arg, ignoreEmpty?: Maybe<FunctionResultObject>, matchMode?: Maybe<FunctionResultObject>, padWith?: Maybe<FunctionResultObject>) => EvaluationError | import("..").Matrix<FunctionResultObject>;
     isExported: true;
 };
 export declare const TRIM: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (text: Maybe<FunctionResultObject>) => string;
+    compute: (text: Maybe<FunctionResultObject>) => {
+        value: string;
+    };
     isExported: true;
 };
 export declare const UPPER: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (text: Maybe<FunctionResultObject>) => string;
+    compute: (text: Maybe<FunctionResultObject>) => {
+        value: string;
+    };
     isExported: true;
 };
 export declare const TEXT: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, number: Maybe<FunctionResultObject>, format: Maybe<FunctionResultObject>) => string;
+    compute: (this: import("..").EvalContext, number: Maybe<FunctionResultObject>, format: Maybe<FunctionResultObject>) => {
+        value: import("..").FormattedValue;
+    };
     isExported: true;
 };
 export declare const VALUE: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>) => number;
+    compute: (this: import("..").EvalContext, value: Maybe<FunctionResultObject>) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const TEXTAFTER: {

package/dist/types/functions/module_web.d.ts

@@ -2,6 +2,8 @@ import { FunctionResultObject, Maybe } from "../types/misc";
 export declare const HYPERLINK: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (url: Maybe<FunctionResultObject>, linkLabel: Maybe<FunctionResultObject>) => string;
+    compute: (url: Maybe<FunctionResultObject>, linkLabel: Maybe<FunctionResultObject>) => {
+        value: string;
+    };
     isExported: true;
 };

package/dist/types/helpers/carousel_helpers.d.ts

@@ -1,9 +1,7 @@
-import { ChartDefinition } from "../types/chart/chart";
 import { AnchorOffset, CarouselItem } from "../types/figure";
 import { Getters } from "../types/getters";
 import { UID } from "../types/misc";
 import { SpreadsheetChildEnv } from "../types/spreadsheet_env";
-export declare const CAROUSEL_DEFAULT_CHART_DEFINITION: ChartDefinition;
 /**
  * Compute the anchor of a chart popped out of a carousel: slightly offset from the
  * carousel figure so the new chart does not perfectly overlap it.

package/dist/types/helpers/figures/chart.d.ts

@@ -1,3 +1,4 @@
+import { CompiledFormula } from "../../formulas/compiler";
 import { ChartCreationContext, ChartData, ChartDefinition } from "../../types/chart/chart";
 import { CoreGetters } from "../../types/core_getters";
 import { Getters } from "../../types/getters";
@@ -24,6 +25,7 @@ export declare class SpreadsheetChart {
     getContextCreation(): ChartCreationContext;
     getDefinitionForExcel(getters: Getters): import("../..").ExcelChartDefinition | undefined;
     getData(getters: Getters, chartId: UID): ChartData;
+    getFormulas(getters: CoreGetters): CompiledFormula[];
     getRuntime(getters: Getters, chartId: UID): import("../..").ChartRuntime;
     static deleteInvalidKeys(definition: ChartDefinition<any>): ChartDefinition<any>;
 }

package/dist/types/helpers/internal_viewport.d.ts

@@ -1,10 +1,17 @@
-import { RenderingGetters } from "../types/getters";
+import { ViewportsGetters } from "../types/getters";
 import { Dimension, HeaderIndex, Pixel, Position, UID, Zone } from "../types/misc";
 import { DOMCoordinates, DOMDimension, Rect } from "../types/rendering";
+interface InternalViewportArgs {
+    getters: ViewportsGetters;
+    sheetId: UID;
+    boundaries: Zone;
+    sizeInGrid: DOMDimension;
+    canScrollVertically: boolean;
+    canScrollHorizontally: boolean;
+    offsets: DOMCoordinates;
+    getFooterSize: () => number;
+}
 export declare class InternalViewport {
-    private getters;
-    private sheetId;
-    private boundaries;
     top: HeaderIndex;
     bottom: HeaderIndex;
     left: HeaderIndex;
@@ -15,12 +22,13 @@ export declare class InternalViewport {
     canScrollHorizontally: boolean;
     viewportWidth: Pixel;
     viewportHeight: Pixel;
-    offsetCorrectionX: Pixel;
-    offsetCorrectionY: Pixel;
-    constructor(getters: RenderingGetters, sheetId: UID, boundaries: Zone, sizeInGrid: DOMDimension, options: {
-        canScrollVertically: boolean;
-        canScrollHorizontally: boolean;
-    }, offsets: DOMCoordinates);
+    boundaryLeftX: Pixel;
+    boundaryTopY: Pixel;
+    private getters;
+    private sheetId;
+    private boundaries;
+    private getFooterSize;
+    constructor(args: InternalViewportArgs);
     /** Returns the maximum size (in Pixels) of the viewport relative to its allocated client size
      * When the viewport grid size is smaller than its client width (resp. height), it will return
      * the client width (resp. height).
@@ -85,3 +93,4 @@ export declare class InternalViewport {
      * */
     private get snapCorrection();
 }
+export {};

package/dist/types/helpers/misc.d.ts

@@ -233,4 +233,5 @@ export declare function defaultDict<T>(def: T): {
     get: (key: string) => T;
     set: (key: string, value: T) => void;
 };
+export declare function sumArray(array: number[]): number;
 export declare function repeat<T>(array: T[], times: number): T[];

package/dist/types/helpers/ui/split_to_columns_interactive.d.ts

@@ -3,4 +3,4 @@ import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
 export declare const SplitToColumnsInteractiveContent: {
     SplitIsDestructive: string;
 };
-export declare function interactiveSplitToColumns(env: SpreadsheetChildEnv, separator: string, addNewColumns: boolean): DispatchResult;
+export declare function interactiveSplitToColumns(env: SpreadsheetChildEnv): DispatchResult;

package/dist/types/helpers/viewport_collection.d.ts

@@ -1,14 +1,28 @@
 import { AnchorOffset, Figure, FigureUI } from "../types/figure";
-import { RenderingGetters } from "../types/getters";
+import { ViewportsGetters } from "../types/getters";
 import { CellPosition, Dimension, HeaderDimensions, HeaderIndex, PaneDivision, Pixel, PixelPosition, Position, SheetViewDimensions, UID, Zone } from "../types/misc";
 import { DOMCoordinates, DOMDimension, EdgeScrollInfo, Rect, SheetDOMScrollInfo, Viewport } from "../types/rendering";
 import { InternalViewport } from "./internal_viewport";
 type SheetViewports = {
-    topLeft: InternalViewport | undefined;
-    bottomLeft: InternalViewport | undefined;
-    topRight: InternalViewport | undefined;
+    topLeft?: InternalViewport;
+    bottomLeft?: InternalViewport;
+    topRight?: InternalViewport;
     bottomRight: InternalViewport;
 };
+interface PositionedViewport {
+    viewport: InternalViewport;
+    viewportX: Pixel;
+    viewportY: Pixel;
+}
+interface ViewportCollectionArgs {
+    getters: ViewportsGetters;
+    paneDivision: Record<UID, PaneDivision>;
+    sheetViewWidth: Pixel;
+    sheetViewHeight: Pixel;
+    zoomLevel: number;
+    getFooterSize: () => number;
+    zoneToDisplay?: Zone;
+}
 /**
  *   EdgeScrollCases Schema
  *
@@ -45,15 +59,18 @@ type SheetViewports = {
  *                                   ↓           ↓
  */
 export declare class ViewportCollection {
+    getters: ViewportsGetters;
+    viewports: Record<UID, SheetViewports | undefined>;
+    private gridOffsetX;
+    private gridOffsetY;
     private paneDivision;
     private sheetViewWidth;
     private sheetViewHeight;
     private zoomLevel;
-    getters: RenderingGetters;
-    viewports: Record<UID, SheetViewports | undefined>;
-    private gridOffsetX;
-    private gridOffsetY;
-    constructor(getters: RenderingGetters, paneDivision: Record<UID, PaneDivision>, sheetViewWidth?: Pixel, sheetViewHeight?: Pixel, zoomLevel?: number);
+    private getFooterSize;
+    private zoneToDisplay?;
+    constructor(args: ViewportCollectionArgs);
+    changeViewportArgs(args: Partial<ViewportCollectionArgs>): void;
     /**
      * Return the index of a column given an offset x, based on the viewport left
      * visible cell.
@@ -141,6 +158,11 @@ export declare class ViewportCollection {
     }[];
     getViewportZoomLevel(): number;
     ensureMainViewportExist(sheetId: UID): void;
+    getPanesDimensions(sheetId: UID): {
+        paneWidth: number;
+        paneHeight: number;
+    };
+    getPositionedViewports(sheetId: UID): PositionedViewport[];
     getSubViewports(sheetId: UID): InternalViewport[];
     checkPositiveDimension(dims: SheetViewDimensions): boolean;
     checkValuesAreDifferent(dims: SheetViewDimensions): boolean;
@@ -164,6 +186,15 @@ export declare class ViewportCollection {
         y: number | Pixel;
     };
     resetViewports(sheetId: UID): void;
+    /**
+     * Depending on how `this.zoneToDisplay` intersects the viewports, we may need to reorganize the viewports to ensure that
+     * `viewports.bottomRight` is always defined.
+     *
+     * For example if `this.zoneToDisplay` is only intersecting the bottom-left viewport, we need to treat the bottom-left
+     * viewport as the bottom-right viewport.
+     */
+    private reorganizeViewportZones;
+    private getViewportZones;
     /**
      * Adjust the viewport such that the anchor position is visible
      */

package/dist/types/helpers/zones.d.ts

@@ -204,3 +204,4 @@ export declare function mergeContiguousZones(zones: Zone[]): Zone[];
  * ]
  */
 export declare function splitZone(z1: Zone, z2: Zone): Zone[];
+export declare function haveSameNumberOfCols(z1: Zone | UnboundedZone, z2: Zone | UnboundedZone): boolean;

package/dist/types/index.d.ts

@@ -219,6 +219,7 @@ export declare const registries: {
         getKeys(): string[];
         remove(key: string): void;
     };
+    unusedDataSourceRegistry: import(".").Registry<import("./registries/data_source_registry").DataSourceType>;
 };
 /** Registries Population */
 import "./clipboard_handlers/clipboard_handler_registrations";
@@ -232,10 +233,13 @@ import { AutofillStore } from "./components/autofill/autofill_store";
 import { TableAutofillStore } from "./components/autofill/table_autofill_store";
 import { Composer } from "./components/composer/composer/composer";
 import { StandaloneComposer } from "./components/composer/standalone_composer/standalone_composer";
+import { isMobileOS } from "./components/helpers/dom_helpers";
 import { Select } from "./components/select/select";
 import { ChartRangeDataSourceComponent } from "./components/side_panel/chart/building_blocks/range_data_source/range_data_source";
 import { CalendarButton } from "./components/side_panel/criterion_form/calendar_button/calendar_button";
+import { Spreadsheet } from "./components/spreadsheet/spreadsheet";
 import { TopBar } from "./components/top_bar/top_bar";
+import { createComputeFunction } from "./functions/create_compute_function";
 import { PositionMap } from "./helpers/cells/position_map";
 import { parseFormat } from "./helpers/format/format_parser";
 import { replaceSymbolInFormula } from "./helpers/formulas";
@@ -321,6 +325,8 @@ export declare const helpers: {
     replaceSymbolInFormula: typeof replaceSymbolInFormula;
     isSingleCellReference: typeof isSingleCellReference;
     computeCachedTextDimension: typeof computeCachedTextDimension;
+    createComputeFunction: typeof createComputeFunction;
+    isMobileOS: typeof isMobileOS;
 };
 export declare const links: {
     isMarkdownLink: typeof isMarkdownLink;
@@ -392,6 +398,7 @@ export declare const components: {
     TopBar: typeof TopBar;
     Composer: typeof Composer;
     CalendarButton: typeof CalendarButton;
+    Spreadsheet: typeof Spreadsheet;
 };
 export declare const hooks: {
     useDragAndDropListItems: typeof useDragAndDropListItems;

package/dist/types/model.d.ts

@@ -35,6 +35,7 @@ export declare class Model extends EventBus<any> implements CommandDispatcher {
     private corePlugins;
     private statefulUIPlugins;
     private range;
+    private formulasPlugin;
     private session;
     /**
      * In a collaborative context, some commands can be replayed, we have to ensure

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

@@ -1,19 +1,23 @@
 import { CommandResult, CoreCommand } from "../../types/commands";
-import { Carousel } from "../../types/figure";
-import { UID } from "../../types/misc";
+import { Carousel, CarouselData } from "../../types/figure";
+import { RangeAdapterFunctions, 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"];
+    static getters: readonly ["getCarousel", "doesCarouselExist", "carouselToCarouselData"];
     readonly carousels: Record<UID, Record<UID, Carousel | undefined> | undefined>;
-    allowDispatch(cmd: CoreCommand): CommandResult.Success | CommandResult.InvalidFigureId | CommandResult.DuplicatedFigureId;
+    adaptRanges(rangeAdapterFunctions: RangeAdapterFunctions): void;
+    allowDispatch(cmd: CoreCommand): CommandResult.Success | CommandResult.InvalidRange | CommandResult.InvalidFigureId | CommandResult.DuplicatedFigureId;
     handle(cmd: CoreCommand): void;
     doesCarouselExist(figureId: UID): boolean;
     getCarousel(figureId: UID): Carousel;
     private removeDeletedCharts;
+    private carouselDataToCarousel;
+    carouselToCarouselData(carousel: Carousel): CarouselData;
+    private areDataViewRangesValid;
     import(data: WorkbookData): void;
     export(data: WorkbookData): void;
 }

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

@@ -87,5 +87,6 @@ export declare class CellPlugin extends CorePlugin<CoreState> implements CoreSta
     private checkCellOutOfSheet;
     private checkUselessClearCell;
     private checkUselessUpdateCell;
+    getFormulas(): CompiledFormula[];
 }
 export {};

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

@@ -1,3 +1,4 @@
+import { CompiledFormula } from "../../formulas/compiler";
 import { SpreadsheetChart } from "../../helpers/figures/chart";
 import { ChartCreationContext, ChartDefinition, ChartType } from "../../types/chart/chart";
 import { Command, CommandResult, CoreCommand } from "../../types/commands";
@@ -41,5 +42,6 @@ export declare class ChartPlugin extends CorePlugin<ChartState> implements Chart
     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;
+    getFormulas(): CompiledFormula[];
 }
 export {};

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

@@ -1,3 +1,4 @@
+import { CompiledFormula } from "../../formulas/compiler";
 import { Command, CommandResult, CoreCommand } from "../../types/commands";
 import { ConditionalFormat, ConditionalFormatInternal } from "../../types/conditional_formatting";
 import { RangeAdapterFunctions, UID, Zone } from "../../types/misc";
@@ -55,5 +56,6 @@ export declare class ConditionalFormatPlugin extends CorePlugin<ConditionalForma
     private checkCFValues;
     private removeConditionalFormatting;
     private changeCFPriority;
+    getFormulas(): CompiledFormula[];
 }
 export {};

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

@@ -1,3 +1,4 @@
+import { CompiledFormula } from "../../formulas/compiler";
 import { Command, CommandResult, CoreCommand } from "../../types/commands";
 import { DataValidationRule } from "../../types/data_validation";
 import { CellPosition, RangeAdapterFunctions, UID } from "../../types/misc";
@@ -34,5 +35,6 @@ export declare class DataValidationPlugin extends CorePlugin<DataValidationState
     private checkCriterionHasValidNumberOfValues;
     private checkCriterionValuesAreValid;
     private checkValidRange;
+    getFormulas(): CompiledFormula[];
 }
 export {};

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

@@ -0,0 +1,8 @@
+import { CompiledFormula } from "../../formulas/compiler";
+import { FormulaProvider } from "../../types/misc";
+export declare class FormulaProviderAggregator {
+    private providers;
+    static getters: readonly ["getAllFormulas"];
+    addFormulaProvider(provider: FormulaProvider["getFormulas"]): void;
+    getAllFormulas(): CompiledFormula[];
+}

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

@@ -59,6 +59,7 @@ export declare class PivotCorePlugin extends CorePlugin<CoreState> implements Co
     private checkSortedColumnInMeasures;
     private checkDuplicatedMeasureIds;
     private checkCustomFieldsAreValid;
+    getFormulas(): CompiledFormula[];
     /**
      * Import the pivots
      */

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

@@ -1,15 +1,18 @@
+import { CompiledFormula } from "../formulas/compiler";
 import { StateObserver } from "../state_observer";
 import { CoreCommand, CoreCommandDispatcher } from "../types/commands";
 import { CoreGetters } from "../types/core_getters";
-import { RangeAdapterFunctions, RangeProvider } from "../types/misc";
+import { FormulaProvider, RangeAdapterFunctions, RangeProvider } from "../types/misc";
 import { ModelConfig } from "../types/model";
 import { WorkbookData } from "../types/workbook_data";
 import { BasePlugin } from "./base_plugin";
+import { FormulaProviderAggregator } from "./core/formulas_provider";
 import { RangeAdapterPlugin } from "./core/range";
 export interface CorePluginConfig {
     readonly getters: CoreGetters;
     readonly stateObserver: StateObserver;
     readonly range: RangeAdapterPlugin;
+    readonly formulasPlugin: FormulaProviderAggregator;
     readonly dispatch: CoreCommandDispatcher["dispatch"];
     readonly canDispatch: CoreCommandDispatcher["dispatch"];
     readonly custom: ModelConfig["custom"];
@@ -25,11 +28,11 @@ export interface CorePluginConstructor {
  * 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 {
+export declare class CorePlugin<State = any> extends BasePlugin<State, CoreCommand> implements RangeProvider, FormulaProvider {
     protected getters: CoreGetters;
     protected dispatch: CoreCommandDispatcher["dispatch"];
     protected canDispatch: CoreCommandDispatcher["dispatch"];
-    constructor({ getters, stateObserver, range, dispatch, canDispatch }: CorePluginConfig);
+    constructor({ getters, stateObserver, range, dispatch, canDispatch, formulasPlugin, }: CorePluginConfig);
     import(data: WorkbookData): void;
     export(data: WorkbookData, shouldSquish: boolean): void;
     /**
@@ -44,4 +47,5 @@ export declare class CorePlugin<State = any> extends BasePlugin<State, CoreComma
      * @param sheetName couple of old and new sheet names to adapt ranges pointing to that sheet
      */
     adaptRanges(rangeAdapterFunctions: RangeAdapterFunctions): void;
+    getFormulas(): CompiledFormula[];
 }

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

@@ -1,21 +1,28 @@
 import { CompiledFormula } from "../../../formulas/compiler";
 import { CellValue, EvaluatedCell, FormulaCell } from "../../../types/cells";
-import { Command, CoreViewCommand } from "../../../types/commands";
+import { Command, CommandResult } from "../../../types/commands";
 import { PerfProfile } from "../../../types/functions";
 import { CellPosition, FunctionResultObject, GetSymbolValue, Matrix, UID, Zone } from "../../../types/misc";
 import { Range } from "../../../types/range";
 import { ExcelWorkbookData } from "../../../types/workbook_data";
 import { CoreViewPlugin, CoreViewPluginConfig } from "../../core_view_plugin";
 export declare class EvaluationPlugin extends CoreViewPlugin {
-    static getters: readonly ["evaluateFormula", "evaluateFormulaResult", "evaluateCompiledFormula", "getCorrespondingFormulaCell", "getVisibleRangeValues", "getEvaluatedCell", "getEvaluatedCells", "getEvaluatedCellsInZone", "getEvaluatedCellsPositions", "getSpreadZone", "getArrayFormulaSpreadingOn", "isArrayFormulaSpillBlocked", "isEmpty", "getPerfProfile"];
+    static getters: readonly ["evaluateFormula", "evaluateFormulaResult", "evaluateCompiledFormula", "getCorrespondingFormulaCell", "getVisibleRangeValues", "getEvaluatedCell", "getEvaluatedCells", "getEvaluatedCellsInZone", "getEvaluatedCellsPositions", "getSpreadZone", "getArrayFormulaSpreadingOn", "isArrayFormulaSpillBlocked", "isEmpty", "getPerfProfile", "isAutomaticEvaluationEnabled"];
     private shouldRebuildDependenciesGraph;
     private forceEvaluation;
+    private automaticEvaluation;
     private evaluator;
     private positionsToUpdate;
     constructor(config: CoreViewPluginConfig);
+    allowDispatch(cmd: Command): CommandResult.Success | CommandResult.NoChangeInAutomaticEvaluation;
     beforeHandle(cmd: Command): void;
-    handle(cmd: CoreViewCommand): void;
+    handle(cmd: Command): void;
     finalize(): void;
+    /**
+     * Returns whether automatic evaluation is enabled.
+     * When disabled, cells are only re-evaluated on explicit EVALUATE_CELLS commands (F9).
+     */
+    isAutomaticEvaluationEnabled(): boolean;
     evaluateFormula(sheetId: UID, formulaString: string, cellPosition?: CellPosition): CellValue | Matrix<CellValue>;
     evaluateFormulaResult(sheetId: UID, formulaString: string, cellPosition?: CellPosition): Matrix<FunctionResultObject> | FunctionResultObject;
     evaluateCompiledFormula(sheetId: UID, compiledFormula: CompiledFormula, getSymbolValue?: GetSymbolValue): FunctionResultObject | Matrix<FunctionResultObject>;

package/dist/types/plugins/ui_feature/ui_options.d.ts

@@ -1,14 +1,8 @@
 import { Command } from "../../types/commands";
 import { UIPlugin } from "../ui_plugin";
 export declare class UIOptionsPlugin extends UIPlugin {
-    static getters: readonly ["shouldShowFormulas", "isAutomaticEvaluationEnabled"];
+    static getters: readonly ["shouldShowFormulas"];
     private showFormulas;
-    private automaticEvaluation;
     handle(cmd: Command): void;
     shouldShowFormulas(): boolean;
-    /**
-     * Returns whether automatic evaluation is enabled.
-     * When disabled, cells are only re-evaluated on explicit EVALUATE_CELLS commands (F9).
-     */
-    isAutomaticEvaluationEnabled(): boolean;
 }