@odoo/o-spreadsheet 17.0.84 → 17.0.96

package/dist/types/history/repeat_commands/repeat_commands_specific.d.ts

@@ -0,0 +1,13 @@
+import { Getters } from "../../types";
+import { AddColumnsRowsCommand, AutoresizeColumnsCommand, AutoresizeRowsCommand, CreateChartCommand, CreateFigureCommand, CreateImageOverCommand, CreateSheetCommand, DeleteCellCommand, GroupHeadersCommand, HideColumnsRowsCommand, InsertCellCommand, PasteCommand, RemoveColumnsRowsCommand, RepeatPasteCommand, ResizeColumnsRowsCommand, SortCommand, UnGroupHeadersCommand } from "./../../types/commands";
+export declare function repeatCreateChartCommand(getters: Getters, cmd: CreateChartCommand): CreateChartCommand;
+export declare function repeatCreateImageCommand(getters: Getters, cmd: CreateImageOverCommand): CreateImageOverCommand;
+export declare function repeatCreateFigureCommand(getters: Getters, cmd: CreateFigureCommand): CreateFigureCommand;
+export declare function repeatCreateSheetCommand(getters: Getters, cmd: CreateSheetCommand): CreateSheetCommand;
+export declare function repeatAddColumnsRowsCommand(getters: Getters, cmd: AddColumnsRowsCommand): AddColumnsRowsCommand;
+export declare function repeatHeaderElementCommand<T extends RemoveColumnsRowsCommand | HideColumnsRowsCommand | ResizeColumnsRowsCommand>(getters: Getters, cmd: T): T;
+export declare function repeatInsertOrDeleteCellCommand<T extends InsertCellCommand | DeleteCellCommand>(getters: Getters, cmd: T): T;
+export declare function repeatAutoResizeCommand<T extends AutoresizeColumnsCommand | AutoresizeRowsCommand>(getters: Getters, cmd: T): T;
+export declare function repeatSortCellsCommand(getters: Getters, cmd: SortCommand): SortCommand;
+export declare function repeatPasteCommand(getters: Getters, cmd: PasteCommand): RepeatPasteCommand;
+export declare function repeatGroupHeadersCommand<T extends GroupHeadersCommand | UnGroupHeadersCommand>(getters: Getters, cmd: T): T;

package/dist/types/history/repeat_commands/repeat_revision.d.ts

@@ -0,0 +1,5 @@
+import { Revision } from "../../collaborative/revisions";
+import { CoreCommand, Getters } from "../../types";
+import { Command } from "../../types/commands";
+export declare function canRepeatRevision(revision: Revision | undefined): boolean;
+export declare function repeatRevision(revision: Revision, getters: Getters): CoreCommand[] | Command | undefined;

package/dist/types/history/selective_history.d.ts

@@ -0,0 +1,81 @@
+import { TransformationFactory, UID } from "../types";
+export declare class SelectiveHistory<T = unknown> {
+    private HEAD_BRANCH;
+    private HEAD_OPERATION;
+    private tree;
+    private readonly applyOperation;
+    private readonly revertOperation;
+    private readonly buildEmpty;
+    private readonly buildTransformation;
+    /**
+     * The selective history is a data structure used to register changes/updates of a state.
+     * Each change/update is called an "operation".
+     * The data structure allows to easily cancel (and redo) any operation individually.
+     * An operation can be represented by any data structure. It can be a "command", a "diff", etc.
+     * However it must have the following properties:
+     * - it can be applied to modify the state
+     * - it can be reverted on the state such that it was never executed.
+     * - it can be transformed given other operation (Operational Transformation)
+     *
+     * Since this data structure doesn't know anything about the state nor the structure of
+     * operations, the actual work must be performed by external functions given as parameters.
+     * @param initialOperationId
+     * @param applyOperation a function which can apply an operation to the state
+     * @param revertOperation  a function which can revert an operation from the state
+     * @param buildEmpty  a function returning an "empty" operation.
+     *                    i.e an operation that leaves the state unmodified once applied or reverted
+     *                    (used for internal implementation)
+     * @param buildTransformation Factory used to build transformations
+     */
+    constructor(args: {
+        initialOperationId: UID;
+        applyOperation: (data: T) => void;
+        revertOperation: (data: T) => void;
+        buildEmpty: (id: UID) => T;
+        buildTransformation: TransformationFactory<T>;
+    });
+    /**
+     * Return the operation identified by its id.
+     */
+    get(operationId: UID): T;
+    /**
+     * Append a new operation as the last one
+     */
+    append(operationId: UID, data: T): void;
+    /**
+     * Insert a new operation after a specific operation (may not be the last operation).
+     * Following operations will be transformed according
+     * to the new operation.
+     */
+    insert(operationId: UID, data: T, insertAfter: UID): void;
+    /**
+     * @param operationId operation to undo
+     * @param undoId the id of the "undo operation"
+     * @param insertAfter the id of the operation after which to insert the undo
+     */
+    undo(operationId: UID, undoId: UID, insertAfter: UID): void;
+    /**
+     * @param operationId operation to redo
+     * @param redoId the if of the "redo operation"
+     * @param insertAfter the id of the operation after which to insert the redo
+     */
+    redo(operationId: UID, redoId: UID, insertAfter: UID): void;
+    rebase(operationId: UID): void;
+    getRevertedExecution(): T[];
+    /**
+     * Revert the state as it was *before* the given operation was executed.
+     */
+    private revertBefore;
+    /**
+     * Revert the state as it was *after* the given operation was executed.
+     */
+    private revertTo;
+    /**
+     * Revert an execution
+     */
+    private revert;
+    /**
+     * Replay the operations between the current HEAD_BRANCH and the end of the tree
+     */
+    private fastForward;
+}

package/dist/types/history/tree.d.ts

@@ -0,0 +1,175 @@
+import { OperationSequenceNode, TransformationFactory, UID } from "../types";
+import { Branch } from "./branch";
+import { Operation } from "./operation";
+import { OperationSequence } from "./operation_sequence";
+/**
+ * The tree is a data structure used to maintain the different branches of the
+ * SelectiveHistory.
+ *
+ * Branches can be "stacked" on each other and an execution path can be derived
+ * from any stack of branches. The rules to derive this path is explained below.
+ *
+ * An operation can be cancelled/undone by inserting a new branch below
+ * this operation.
+ * e.g
+ *    Given the branch A    B   C
+ *    To undo B, a new branching branch is inserted at operation B.
+ *    ```txt
+ *    A   B   C   D
+ *        >   C'  D'
+ *    ```
+ *    A new execution path can now be derived. At each operation:
+ *    - if there is a lower branch, don't execute it and go to the operation below
+ *    - if not, execute it and go to the operation on the right.
+ *    The execution path is   A   C'    D'
+ *    Operation C and D have been adapted (transformed) in the lower branch
+ *    since operation B is not executed in this branch.
+ *
+ */
+export declare class Tree<T = unknown> {
+    private readonly buildTransformation;
+    private readonly branches;
+    private branchingOperationIds;
+    constructor(buildTransformation: TransformationFactory<T>, initialBranch: Branch<T>);
+    /**
+     * Return the last branch of the entire stack of branches.
+     */
+    getLastBranch(): Branch<T>;
+    /**
+     * Return the sequence of operations from this branch
+     * until the very last branch.
+     */
+    execution(branch: Branch<T>): OperationSequence<T>;
+    /**
+     * Return the sequence of operations from this branch
+     * to the very first branch.
+     */
+    revertedExecution(branch: Branch<T>): OperationSequence<T>;
+    /**
+     * Append an operation to the end of the tree.
+     * Also insert the (transformed) operation in all previous branches.
+     *
+     * Adding operation `D` to the last branch
+     * ```txt
+     *  A1   B1   C1
+     *  >    B2   C2
+     * ```
+     * will give
+     * ```txt
+     *  A1   B1   C1   D'   with D' = D transformed with A1
+     *  >    B2   C2   D
+     * ```
+     */
+    insertOperationLast(branch: Branch<T>, operation: Operation<T>): void;
+    /**
+     * Insert a new operation after an other operation.
+     * The operation will be inserted in this branch, in next branches (transformed)
+     * and in previous branches (also transformed).
+     *
+     * Given
+     * ```txt
+     *  1: A1   B1   C1
+     *  2: >    B2   C2
+     *  3:      >    C3
+     * ```
+     * Inserting D to branch 2 gives
+     * ```txt
+     *  1: A1   B1   C1   D1          D1 = D transformed with A1
+     *  2: >    B2   C2   D     with  D  = D
+     *  3:      >    C3   D2          D2 = D transformed without B2 (B2⁻¹)
+     * ```
+     */
+    insertOperationAfter(branch: Branch<T>, operation: Operation<T>, predecessorOpId: UID): void;
+    /**
+     * Create a new branching branch at the given operation.
+     * This cancels the operation from the execution path.
+     */
+    undo(branch: Branch<T>, operation: Operation<T>): void;
+    /**
+     * Remove the branch just after this one. This un-cancels (redo) the branching
+     * operation. Lower branches will be transformed accordingly.
+     *
+     * Given
+     * ```txt
+     *  1: A1   B1   C1
+     *  2: >    B2   C2
+     *  3:      >    C3
+     * ```
+     * removing the next branch of 1 gives
+     *
+     * ```txt
+     *  1: A1   B1   C1
+     *  2:      >    C3'   with  C3' = C1 transformed without B1 (B1⁻¹)
+     * ```
+     */
+    redo(branch: Branch<T>): void;
+    /**
+     * Drop the operation and all following operations in every
+     * branches
+     */
+    drop(operationId: UID): void;
+    /**
+     * Find the operation in the execution path.
+     */
+    findOperation(branch: Branch<T>, operationId: UID): OperationSequenceNode<T>;
+    /**
+     * Rebuild transformed operations of this branch based on the upper branch.
+     *
+     * Given the following structure:
+     * ```txt
+     *  1: A1   B1    C1
+     *  2: >    B2    C2
+     *  3:      >     C3
+     * ```
+     * Rebasing branch "2" gives
+     * ```txt
+     *  1: A1   B1    C1
+     *  2: >    B2'   C2'  With  B2' = B1 transformed without A1 and C2' = C1 transformed without A1
+     *  3:      >     C3'        C3' = C2' transformed without B2'
+     * ```
+     */
+    private rebaseUp;
+    private removeBranchFromTree;
+    private insertBranchAfter;
+    /**
+     * Update the branching branch of this branch, either by (1) inserting the new
+     * operation in it or (2) by transforming it.
+     * (1) If the operation is positioned before the branching branch, the branching
+     *     branch should be transformed with this operation.
+     * (2) If it's positioned after, the operation should be inserted in the
+     *     branching branch.
+     */
+    private updateNextWith;
+    private addToNextBranch;
+    private getTransformedOperation;
+    /**
+     * Check if this branch should execute the given operation.
+     * i.e. If the operation is not cancelled by a branching branch.
+     */
+    private shouldExecute;
+    private transform;
+    /**
+     * Insert a new operation in previous branches. The operations which are
+     * positioned after the inserted operations are transformed with the newly
+     * inserted operations. This one is also transformed, with the branching
+     * operation.
+     */
+    private insertPrevious;
+    private findPreviousBranchingOperation;
+    /**
+     * Retrieve the next branch of the given branch
+     */
+    private nextBranch;
+    /**
+     * Retrieve the previous branch of the given branch
+     */
+    private previousBranch;
+    /**
+     * Yields the sequence of operations to execute, in reverse order.
+     */
+    private _revertedExecution;
+    /**
+     * Yields the sequence of operations to execute
+     */
+    private _execution;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,189 @@
+import { createAction, createActions } from "./actions/action";
+import { transformRangeData } from "./collaborative/ot/ot_helpers";
+import { ChartJsComponent } from "./components/figures/chart/chartJs/chartjs";
+import { ScorecardChart } from "./components/figures/chart/scorecard/chart_scorecard";
+import { FigureComponent } from "./components/figures/figure/figure";
+import { ChartFigure } from "./components/figures/figure_chart/figure_chart";
+import { Grid } from "./components/grid/grid";
+import { GridOverlay } from "./components/grid_overlay/grid_overlay";
+import { useDragAndDropListItems } from "./components/helpers/drag_and_drop_hook";
+import { Menu } from "./components/menu/menu";
+import { SelectionInput } from "./components/selection_input/selection_input";
+import { BarConfigPanel, GaugeChartConfigPanel, GaugeChartDesignPanel, LineBarPieConfigPanel, LineBarPieDesignPanel, LineConfigPanel, ScorecardChartConfigPanel, ScorecardChartDesignPanel } from "./components/side_panel/chart";
+import { ChartPanel } from "./components/side_panel/chart/main_chart_panel/main_chart_panel";
+import { toBoolean, toJsDate, toNumber, toString } from "./functions/helpers";
+import { arg } from "./functions/index";
+import { ChartColors, chartFontColor, getDefaultChartJsRuntime, getFillingMode } from "./helpers/figures/charts";
+import { UuidGenerator, colorToRGBA, computeTextWidth, createCurrencyFormat, deepEquals, formatValue, isDateTime, isDefined, isMarkdownLink, isNumber, lazy, lettersToNumber, markdownLink, numberToLetters, parseMarkdownLink, positionToZone, rgbaToHex, toCartesian, toUnboundedZone, toXC, toZone } from "./helpers/index";
+import { openLink, urlRepresentation } from "./helpers/links";
+import { createEmptyExcelSheet, createEmptySheet, createEmptyWorkbookData } from "./migrations/data";
+import { genericRepeat } from "./registries/repeat_commands_registry";
+import { AddFunctionDescription, isMatrix } from "./types";
+import { CellErrorLevel, EvaluationError } from "./types/errors";
+/**
+ * We export here all entities that needs to be accessed publicly by Odoo.
+ *
+ * Note that the __info__ key is actually completed by the build process (see
+ * the rollup.config.js file)
+ */
+export declare const __info__: {};
+export { Revision } from "./collaborative/revisions";
+export { Spreadsheet } from "./components/index";
+export { setDefaultSheetViewSize } from "./constants";
+export { compile, compileTokens, functionCache } from "./formulas/compiler";
+export { astToFormula, convertAstNodes, iterateAstNodes, parse, parseTokens, } from "./formulas/parser";
+export { tokenize } from "./formulas/tokenizer";
+export { AbstractChart } from "./helpers/figures/charts";
+export { findCellInNewZone } from "./helpers/zones";
+export { load } from "./migrations/data";
+export { Model } from "./model";
+export { CorePlugin } from "./plugins/core_plugin";
+export { UIPlugin } from "./plugins/ui_plugin";
+export { Registry } from "./registries/registry";
+export { setTranslationMethod } from "./translation";
+export { CommandResult, DispatchResult } from "./types";
+export type { CancelledReason } from "./types";
+export type { Client } from "./types/collaborative/session";
+export type { ClientJoinedMessage, ClientLeftMessage, ClientMovedMessage, CollaborationMessage, RemoteRevisionMessage, RevisionRedoneMessage, RevisionUndoneMessage, TransportService, } from "./types/collaborative/transport_service";
+export { coreTypes, invalidateCFEvaluationCommands, invalidateDependenciesCommands, invalidateEvaluationCommands, readonlyAllowedCommands, } from "./types/commands";
+export { EvaluationError } from "./types/errors";
+export declare const SPREADSHEET_DIMENSIONS: {
+    MIN_ROW_HEIGHT: number;
+    MIN_COL_WIDTH: number;
+    HEADER_HEIGHT: number;
+    HEADER_WIDTH: number;
+    TOPBAR_HEIGHT: number;
+    BOTTOMBAR_HEIGHT: number;
+    DEFAULT_CELL_WIDTH: number;
+    DEFAULT_CELL_HEIGHT: number;
+    SCROLLBAR_WIDTH: number;
+};
+export declare const registries: {
+    autofillModifiersRegistry: import(".").Registry<import("./types").AutofillModifierImplementation>;
+    autofillRulesRegistry: import(".").Registry<import("./registries/autofill_rules").AutofillRule>;
+    cellMenuRegistry: import("./registries/menu_items_registry").MenuItemRegistry;
+    colMenuRegistry: import("./registries/menu_items_registry").MenuItemRegistry;
+    linkMenuRegistry: import("./registries/menu_items_registry").MenuItemRegistry;
+    functionRegistry: {
+        mapping: {
+            [key: string]: import("./types").ComputeFunction<import("./types").Arg, import("./types").Matrix<import("./types").ValueAndFormat> | import("./types").ValueAndFormat>;
+        };
+        add(name: string, addDescr: AddFunctionDescription): /*elided*/ any;
+        content: {
+            [key: string]: import("./types").FunctionDescription;
+        };
+        get(key: string): import("./types").FunctionDescription;
+        contains(key: string): boolean;
+        getAll(): import("./types").FunctionDescription[];
+        getKeys(): string[];
+        remove(key: string): void;
+    };
+    featurePluginRegistry: import(".").Registry<import("./plugins/ui_plugin").UIPluginConstructor>;
+    statefulUIPluginRegistry: import(".").Registry<import("./plugins/ui_plugin").UIPluginConstructor>;
+    coreViewsPluginRegistry: import(".").Registry<import("./plugins/ui_plugin").UIPluginConstructor>;
+    corePluginRegistry: import(".").Registry<import("./plugins/core_plugin").CorePluginConstructor>;
+    rowMenuRegistry: import("./registries/menu_items_registry").MenuItemRegistry;
+    sidePanelRegistry: import(".").Registry<import("./registries/side_panel_registry").SidePanelContent>;
+    figureRegistry: import(".").Registry<import("./registries/figure_registry").FigureContent>;
+    chartSidePanelComponentRegistry: import(".").Registry<import("./components/side_panel/chart").ChartSidePanel>;
+    chartComponentRegistry: import(".").Registry<new (...args: any) => import("@odoo/owl").Component>;
+    chartRegistry: import(".").Registry<import("./registries/chart_types").ChartBuilder>;
+    topbarMenuRegistry: import("./registries/menu_items_registry").MenuItemRegistry;
+    topbarComponentRegistry: {
+        mapping: {
+            [key: string]: Function;
+        };
+        uuidGenerator: UuidGenerator;
+        add(name: string, value: Omit<import("./registries/topbar_component_registry").TopbarComponent, "id">): import(".").Registry<import("./registries/topbar_component_registry").TopbarComponent>;
+        content: {
+            [key: string]: import("./registries/topbar_component_registry").TopbarComponent;
+        };
+        get(key: string): import("./registries/topbar_component_registry").TopbarComponent;
+        contains(key: string): boolean;
+        getAll(): import("./registries/topbar_component_registry").TopbarComponent[];
+        getKeys(): string[];
+        remove(key: string): void;
+    };
+    clickableCellRegistry: import(".").Registry<import("./registries/cell_clickable_registry").CellClickableItem>;
+    otRegistry: import("./registries/ot_registry").OTRegistry;
+    inverseCommandRegistry: import(".").Registry<(cmd: import("./types").CoreCommand) => import("./types").CoreCommand[]>;
+    urlRegistry: import(".").Registry<import("./helpers/links").LinkSpec>;
+    cellPopoverRegistry: import(".").Registry<import("./types/cell_popovers").PopoverBuilders>;
+    numberFormatMenuRegistry: import("./registries/menu_items_registry").MenuItemRegistry;
+    repeatLocalCommandTransformRegistry: import(".").Registry<(getters: import("./types").Getters, cmd: import("./types").LocalCommand, childCommands: readonly import("./types").CoreCommand[]) => import("./types").CoreCommand[] | import("./types").LocalCommand | undefined>;
+    repeatCommandTransformRegistry: import(".").Registry<(getters: import("./types").Getters, cmd: import("./types").CoreCommand) => import("./types").CoreCommand | undefined>;
+};
+export declare const helpers: {
+    arg: typeof arg;
+    toBoolean: typeof toBoolean;
+    toJsDate: typeof toJsDate;
+    toNumber: typeof toNumber;
+    toString: typeof toString;
+    toXC: typeof toXC;
+    toZone: typeof toZone;
+    toUnboundedZone: typeof toUnboundedZone;
+    toCartesian: typeof toCartesian;
+    numberToLetters: typeof numberToLetters;
+    lettersToNumber: typeof lettersToNumber;
+    UuidGenerator: typeof UuidGenerator;
+    formatValue: typeof formatValue;
+    createCurrencyFormat: typeof createCurrencyFormat;
+    computeTextWidth: typeof computeTextWidth;
+    createEmptyWorkbookData: typeof createEmptyWorkbookData;
+    createEmptySheet: typeof createEmptySheet;
+    createEmptyExcelSheet: typeof createEmptyExcelSheet;
+    getDefaultChartJsRuntime: typeof getDefaultChartJsRuntime;
+    chartFontColor: typeof chartFontColor;
+    ChartColors: typeof ChartColors;
+    EvaluationError: typeof EvaluationError;
+    CellErrorLevel: typeof CellErrorLevel;
+    getFillingMode: typeof getFillingMode;
+    rgbaToHex: typeof rgbaToHex;
+    colorToRGBA: typeof colorToRGBA;
+    positionToZone: typeof positionToZone;
+    isDefined: typeof isDefined;
+    isMatrix: typeof isMatrix;
+    lazy: typeof lazy;
+    genericRepeat: typeof genericRepeat;
+    createAction: typeof createAction;
+    createActions: typeof createActions;
+    transformRangeData: typeof transformRangeData;
+    deepEquals: typeof deepEquals;
+    isNumber: typeof isNumber;
+    isDateTime: typeof isDateTime;
+};
+export declare const links: {
+    isMarkdownLink: typeof isMarkdownLink;
+    parseMarkdownLink: typeof parseMarkdownLink;
+    markdownLink: typeof markdownLink;
+    openLink: typeof openLink;
+    urlRepresentation: typeof urlRepresentation;
+};
+export declare const components: {
+    ChartPanel: typeof ChartPanel;
+    ChartFigure: typeof ChartFigure;
+    ChartJsComponent: typeof ChartJsComponent;
+    Grid: typeof Grid;
+    GridOverlay: typeof GridOverlay;
+    ScorecardChart: typeof ScorecardChart;
+    LineConfigPanel: typeof LineConfigPanel;
+    LineBarPieDesignPanel: typeof LineBarPieDesignPanel;
+    BarConfigPanel: typeof BarConfigPanel;
+    LineBarPieConfigPanel: typeof LineBarPieConfigPanel;
+    GaugeChartConfigPanel: typeof GaugeChartConfigPanel;
+    GaugeChartDesignPanel: typeof GaugeChartDesignPanel;
+    ScorecardChartConfigPanel: typeof ScorecardChartConfigPanel;
+    ScorecardChartDesignPanel: typeof ScorecardChartDesignPanel;
+    FigureComponent: typeof FigureComponent;
+    Menu: typeof Menu;
+    SelectionInput: typeof SelectionInput;
+};
+export declare const hooks: {
+    useDragAndDropListItems: typeof useDragAndDropListItems;
+};
+export declare function addFunction(functionName: string, functionDescription: AddFunctionDescription): {
+    addFunction: (fName: string, fDescription: AddFunctionDescription) => /*elided*/ any;
+};
+export declare const constants: {
+    DEFAULT_LOCALE: import("./types").Locale;
+};

package/dist/types/migrations/data.d.ts

@@ -0,0 +1,30 @@
+import { StateUpdateMessage } from "../types/collaborative/transport_service";
+import { ExcelSheetData, ExcelWorkbookData, SheetData, UID, WorkbookData } from "../types/index";
+/**
+ * This is the current state version number. It should be incremented each time
+ * a breaking change is made in the way the state is handled, and an upgrade
+ * function should be defined
+ */
+export declare const CURRENT_VERSION = 14.5;
+/**
+ * This function tries to load anything that could look like a valid
+ * workbookData object. It applies any migrations, if needed, and return a
+ * current, complete workbookData object.
+ *
+ * It also ensures that there is at least one sheet.
+ */
+export declare function load(data?: any, verboseImport?: boolean): WorkbookData;
+/**
+ * This function is used to repair faulty data independently of the migration.
+ */
+export declare function repairData(data: Partial<WorkbookData>): Partial<WorkbookData>;
+/**
+ * The goal of this function is to repair corrupted/wrong initial messages caused by
+ * a bug.
+ * The bug should obviously be fixed, but it's too late for existing spreadsheet.
+ */
+export declare function repairInitialMessages(data: Partial<WorkbookData>, initialMessages: StateUpdateMessage[]): StateUpdateMessage[];
+export declare function createEmptySheet(sheetId: UID, name: string): SheetData;
+export declare function createEmptyWorkbookData(sheetName?: string): WorkbookData;
+export declare function createEmptyExcelSheet(sheetId: UID, name: string): ExcelSheetData;
+export declare function createEmptyExcelWorkbookData(): ExcelWorkbookData;

package/dist/types/migrations/legacy_tools.d.ts

@@ -0,0 +1,15 @@
+type LegacyNormalizedFormula = {
+    text: string;
+    dependencies: string[];
+    value?: any;
+};
+/**
+ * parses a formula (as a string) into the same formula,
+ * but with the references to other cells extracted
+ *
+ * =sum(a3:b1) + c3 --> =sum(|0|) + |1|
+ *
+ * @param formula
+ */
+export declare function normalizeV9(formula: string): LegacyNormalizedFormula;
+export {};