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

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/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/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";
@@ -236,6 +237,7 @@ 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 { 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 +323,7 @@ export declare const helpers: {
     replaceSymbolInFormula: typeof replaceSymbolInFormula;
     isSingleCellReference: typeof isSingleCellReference;
     computeCachedTextDimension: typeof computeCachedTextDimension;
+    createComputeFunction: typeof createComputeFunction;
 };
 export declare const links: {
     isMarkdownLink: typeof isMarkdownLink;

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/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;
 }

package/dist/types/plugins/ui_stateful/filter_evaluation.d.ts

@@ -1,10 +1,10 @@
 import { Command, CommandResult, LocalCommand } from "../../types/commands";
 import { CellPosition, UID } from "../../types/misc";
-import { CriterionFilter, DataFilterValue, Table } from "../../types/table";
+import { CriterionFilter, DataFilterValue } from "../../types/table";
 import { ExcelWorkbookData } from "../../types/workbook_data";
 import { UIPlugin } from "../ui_plugin";
 export declare class FilterEvaluationPlugin extends UIPlugin {
-    static getters: readonly ["getFilterValue", "getFilterHiddenValues", "getFilterCriterionValue", "getFirstTableInSelection", "isRowFiltered", "isFilterActive"];
+    static getters: readonly ["getFilterValue", "getFilterHiddenValues", "getFilterCriterionValue", "isRowFiltered", "isFilterActive"];
     private filterValues;
     hiddenRows: Record<UID, Set<number> | undefined>;
     isEvaluationDirty: boolean;
@@ -16,7 +16,6 @@ export declare class FilterEvaluationPlugin extends UIPlugin {
     getFilterHiddenValues(position: CellPosition): string[];
     getFilterCriterionValue(position: CellPosition): CriterionFilter;
     isFilterActive(position: CellPosition): boolean;
-    getFirstTableInSelection(): Table | undefined;
     private updateFilter;
     private updateHiddenRows;
     exportForExcel(data: ExcelWorkbookData): void;

package/dist/types/registries/chart_registry.d.ts

@@ -1,4 +1,5 @@
 import { CoreChartOptions } from "chart.js";
+import { CompiledFormula } from "..";
 import { ChartCreationContext, ChartData, ChartRuntime, ChartType, ChartTypeDefinition, ExcelChartDefinition } from "../types/chart/chart";
 import { CommandResult } from "../types/commands";
 import { CoreGetters } from "../types/core_getters";
@@ -47,6 +48,8 @@ export interface ChartTypeBuilder<T extends ChartType> {
      */
     getDefinitionForExcel(getters: Getters, definition: ChartTypeDefinition<T, Range>, params: Pick<ExcelChartDefinition, "dataSets" | "labelRange">): ExcelChartDefinition | undefined;
     getRuntime(getters: Getters, definition: ChartTypeDefinition<T, Range>, chartDataExtractors: ChartDataExtractors, sheetId: UID, eventHandlers: ChartJsEventHandlers): ChartRuntime;
+    /** Get all the formulas used in the chart */
+    getFormulas(getters: CoreGetters, sheetId: UID, definition: ChartTypeDefinition<T, Range>): CompiledFormula[];
     allowedDefinitionKeys: readonly string[];
     sequence: number;
     dataSeriesLimit?: number;

package/dist/types/registries/data_source_registry.d.ts

@@ -0,0 +1,15 @@
+import { Model } from "../model";
+import { Getters } from "../types/getters";
+import { UID } from "../types/misc";
+import { Registry } from "./registry";
+export interface UnusedDataSource {
+    label: string;
+    id: UID;
+}
+export interface DataSourceType {
+    type: string;
+    unusedLabel: string;
+    getUnusedInstances: (getters: Getters) => UnusedDataSource[];
+    deleteDataSource: (dispatch: Model["dispatch"], id: UID) => void;
+}
+export declare const unusedDataSourceRegistry: Registry<DataSourceType>;

package/dist/types/stores/table_resize_store.d.ts

@@ -0,0 +1,6 @@
+import { Command, DispatchResult, ResizeTableCommand } from "../types/commands";
+import { SpreadsheetStore } from "./spreadsheet_store";
+export declare class TableResizeStore extends SpreadsheetStore {
+    canResizeTable(cmd: ResizeTableCommand): DispatchResult;
+    handle(cmd: Command): void;
+}