@odoo/o-spreadsheet 19.5.0-alpha.0 → 19.5.0-alpha.10

package/dist/types/components/side_panel/side_panel/side_panel_store.d.ts

@@ -30,7 +30,7 @@ export declare class SidePanelStore extends SpreadsheetStore {
     }) | undefined;
     secondaryPanel: PanelInfo | undefined;
     availableWidth: number;
-    screenWidthStore: import("../../../types/store_engine").CQS<Pick<ScreenWidthStore, "setSmallThreshhold"> & import("../../../types/store_engine").OmitFunctions<ScreenWidthStore>>;
+    screenWidthStore: import("../../../types/store_engine").Store<ScreenWidthStore>;
     get isMainPanelOpen(): boolean;
     get isSecondaryPanelOpen(): boolean;
     get mainPanelProps(): SidePanelComponentProps | undefined;

package/dist/types/components/side_panel/split_to_columns_panel/split_to_columns_panel.d.ts

@@ -1,17 +1,12 @@
-import { NEWLINE } from "../../../constants";
 import { Component } from "../../../owl3_compatibility_layer";
 import { ValueAndLabel } from "../../../types/misc";
 import { SpreadsheetChildEnv } from "../../../types/spreadsheet_env";
+import { Store } from "../../../types/store_engine";
 import { Select } from "../../select/select";
 import { ValidationMessages } from "../../validation_messages/validation_messages";
 import { Checkbox } from "../components/checkbox/checkbox";
 import { Section } from "../components/section/section";
-type SeparatorValue = "auto" | "custom" | " " | "," | ";" | typeof NEWLINE;
-interface State {
-    separatorValue: SeparatorValue;
-    customSeparator: string;
-    addNewColumns: boolean;
-}
+import { SplitToColumnsSeparatorValue, SplitToColumnsStore } from "./split_to_columns_store";
 export declare class SplitIntoColumnsPanel extends Component<SpreadsheetChildEnv> {
     static template: string;
     static components: {
@@ -23,16 +18,14 @@ export declare class SplitIntoColumnsPanel extends Component<SpreadsheetChildEnv
     protected props: import("@odoo/owl").Props<{
         onCloseSidePanel: () => void;
     }>;
-    state: State;
+    store: Store<SplitToColumnsStore>;
     setup(): void;
-    onSeparatorChange(value: SeparatorValue): void;
+    onSeparatorChange(value: SplitToColumnsSeparatorValue): void;
     updateCustomSeparator(ev: InputEvent): void;
     updateAddNewColumnsCheckbox(addNewColumns: boolean): void;
     confirm(): void;
     get errorMessages(): string[];
     get warningMessages(): string[];
-    get separatorValue(): string;
     get separators(): ValueAndLabel[];
     get isConfirmDisabled(): boolean;
 }
-export {};

package/dist/types/components/side_panel/split_to_columns_panel/split_to_columns_store.d.ts

@@ -0,0 +1,33 @@
+import { NEWLINE } from "../../../constants";
+import { SpreadsheetStore } from "../../../stores/spreadsheet_store";
+import { Command, DispatchResult } from "../../../types/commands";
+export type SplitToColumnsSeparatorValue = "auto" | "custom" | " " | "," | ";" | typeof NEWLINE;
+export declare class SplitToColumnsStore extends SpreadsheetStore {
+    mutators: readonly ["setSeparatorValue", "setCustomSeparator", "setShouldAddNewColumns"];
+    storeGetters: readonly ["canSplitIntoColumns"];
+    separatorValue: SplitToColumnsSeparatorValue;
+    customSeparator: string;
+    addNewColumns: boolean;
+    setSeparatorValue(separatorValue: SplitToColumnsSeparatorValue): void;
+    setCustomSeparator(customSeparator: string): void;
+    setShouldAddNewColumns(addNewColumns: boolean): void;
+    canSplitIntoColumns(args: {
+        force: boolean;
+    }): DispatchResult;
+    handle(cmd: Command): void;
+    get automaticSeparatorOfSelection(): string;
+    private getAutoSeparatorForString;
+    private splitIntoColumns;
+    private getSplittedCols;
+    private splitAndRemoveTrailingEmpty;
+    private willSplittedColsOverwriteContent;
+    private removeMergesInSplitZone;
+    private addColsToAvoidCollisions;
+    private getColsToAddToAvoidCollision;
+    private addColumnsToNotOverflowSheet;
+    private checkSingleColSelected;
+    private checkNonEmptySelector;
+    private checkNotOverwritingContent;
+    private checkSeparatorInSelection;
+    get separatorString(): string;
+}

package/dist/types/components/small_bottom_bar/small_bottom_bar.d.ts

@@ -20,6 +20,7 @@ export declare class SmallBottomBar extends Component<SpreadsheetChildEnv> {
     }>;
     private composerFocusStore;
     private composerStore;
+    private viewStore;
     private composerInterface;
     private composerRef;
     private menuState;

package/dist/types/components/spreadsheet/spreadsheet.d.ts

@@ -43,6 +43,8 @@ export declare class Spreadsheet extends Component<SpreadsheetChildEnv> {
     private isViewportTooSmall;
     private notificationStore;
     private composerFocusStore;
+    private viewStore;
+    private zoomStore;
     get model(): Model;
     getStyle(): string;
     setup(): void;

package/dist/types/components/standalone_grid_canvas/standalone_grid_canvas.d.ts

@@ -11,9 +11,10 @@ export declare class StandaloneGridCanvas extends Component<SpreadsheetChildEnv>
         renderingCtx: {
             sheetId: import("../..").UID;
             hideGridLines?: boolean | undefined;
-            selectedZones: import("../..").Zone[];
             viewports: import("../../helpers/viewport_collection").ViewportCollection;
+            selectedZones: import("../..").Zone[];
             dpr: number;
+            hideFrozenPaneBorder?: boolean | undefined;
             activeCols: Set<number>;
             activeRows: Set<number>;
             activePosition: import("../..").CellPosition | undefined;

package/dist/types/components/standalone_viewport/standalone_viewport.d.ts

@@ -0,0 +1,56 @@
+import { Component } from "../../owl3_compatibility_layer";
+import { RendererStore } from "../../stores/renderer_store";
+import { ViewportsStore } from "../../stores/viewports_store";
+import { ZoomStore } from "../../stores/zoom_store";
+import { HeaderIndex } from "../../types/misc";
+import { Rect } from "../../types/rendering";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+import { Store } from "../../types/store_engine";
+import { ClickableCellsOverlay } from "../clickable_cells_overlay/clickable_cells_overlay";
+import { GridOverlay } from "../grid_overlay/grid_overlay";
+import { GridPopover } from "../grid_popover/grid_popover";
+import { CellPopoverStore } from "../popover/cell_popover_store";
+import { VerticalScrollBar } from "../scrollbar/scrollbar_vertical";
+interface ColResizer {
+    col: HeaderIndex;
+    style: string;
+}
+interface DnDResizeState {
+    col: HeaderIndex | undefined;
+}
+export declare class StandaloneViewport extends Component<SpreadsheetChildEnv> {
+    static template: string;
+    static components: {
+        VerticalScrollBar: typeof VerticalScrollBar;
+        GridOverlay: typeof GridOverlay;
+        ClickableCellsOverlay: typeof ClickableCellsOverlay;
+        GridPopover: typeof GridPopover;
+    };
+    protected props: import("@odoo/owl").PropsWithDefaults<{
+        range: import("../..").Range;
+        canResizeColumns: boolean;
+        onResizeColumns?: ((columnWeights: number[] | undefined) => void) | undefined;
+        columnWeights?: number[] | undefined;
+    }, "canResizeColumns">;
+    private canvasRef;
+    private containerRef;
+    private store;
+    dndState: DnDResizeState;
+    onMouseWheel: (ev: WheelEvent) => void;
+    rendererStore: Store<RendererStore>;
+    viewStore: Store<ViewportsStore>;
+    zoomStore: Store<ZoomStore>;
+    cellPopoverStore: Store<CellPopoverStore>;
+    setup(): void;
+    get containerWidth(): number;
+    get containerHeight(): number;
+    get hasVerticalScrollBar(): boolean | 0;
+    get scrollBarContainerStyle(): string;
+    onCellDoubleClicked(col: HeaderIndex, row: HeaderIndex, ev: MouseEvent): void;
+    get gridOverlayDimensions(): string;
+    get colResizers(): ColResizer[];
+    onResizerPointerDown(ev: MouseEvent, resizer: ColResizer): void;
+    onResizerDoubleClick(): void;
+    getGridRect(): Rect;
+}
+export {};

package/dist/types/components/standalone_viewport/standalone_viewport_store.d.ts

@@ -0,0 +1,28 @@
+import { SpreadsheetStore } from "../../stores/spreadsheet_store";
+import { Command } from "../../types/commands";
+import { HeaderDimensions, HeaderIndex, UID } from "../../types/misc";
+import { Range } from "../../types/range";
+import { GridRenderingContext } from "../../types/rendering";
+import { Get } from "../../types/store_engine";
+export declare class StandaloneViewportStore extends SpreadsheetStore {
+    mutators: readonly ["setContainerSize", "setRange", "resizeColumn", "setCustomColWeights"];
+    cachedColDimensions: Record<HeaderIndex, HeaderDimensions> | undefined;
+    private containerWidth;
+    private containerHeight;
+    private range;
+    private customColWeights;
+    private viewStore;
+    constructor(get: Get, range: Range, customColWeights?: number[]);
+    handle(cmd: Command): void;
+    setContainerSize(width: number, height: number): "noStateChange" | undefined;
+    setRange(range: Range): "noStateChange" | undefined;
+    setCustomColWeights(weights: number[] | undefined): "noStateChange" | undefined;
+    resizeColumn(resizedCol: HeaderIndex, weightDelta: number, weightsAtStartOfDrag: number[]): void;
+    private changeColumnWeights;
+    get renderingContext(): Omit<GridRenderingContext, "ctx" | "thinLineWidth">;
+    get headerDimensionsCallback(): (sheetId: UID, dimension: "COL" | "ROW", index: number) => HeaderDimensions;
+    getHeaderDimensions(sheetId: UID, dimension: "COL" | "ROW", index: number): HeaderDimensions;
+    get columnWeights(): number[];
+    private computeColDimensions;
+    private normalizeWeights;
+}

package/dist/types/components/tables/hovered_table_store.d.ts

@@ -1,14 +1,11 @@
 import { PositionMap } from "../../helpers/cells/position_map";
 import { SpreadsheetStore } from "../../stores/spreadsheet_store";
-import { Command } from "../../types/commands";
-import { Color, Position } from "../../types/misc";
+import { CellPosition, Color } from "../../types/misc";
 export declare class HoveredTableStore extends SpreadsheetStore {
     mutators: readonly ["clear", "hover"];
-    col: number | undefined;
-    row: number | undefined;
+    position: CellPosition | undefined;
     overlayColors: PositionMap<Color>;
-    handle(cmd: Command): void;
-    hover(position: Partial<Position>): "noStateChange" | undefined;
+    hover(position: CellPosition | undefined): "noStateChange" | undefined;
     clear(): void;
     private computeOverlay;
 }

package/dist/types/components/tables/table_resizer/table_resizer.d.ts

@@ -16,6 +16,7 @@ export declare class TableResizer extends Component<SpreadsheetChildEnv> {
             clientY: number;
         }, onPointerMove: (col: HeaderIndex, row: HeaderIndex, ev: MouseEvent) => void, onPointerUp: () => void, startScrollDirection?: import("../../helpers/drag_and_drop_grid_hook").DnDDirection) => void;
     };
+    private viewStore;
     setup(): void;
     get containerStyle(): string;
     onMouseDown(ev: PointerEvent): void;

package/dist/types/components/top_bar/zoom_editor/zoom_editor.d.ts

@@ -1,7 +1,7 @@
+import { Component } from "../../../owl3_compatibility_layer";
 import { SpreadsheetChildEnv } from "../../../types/spreadsheet_env";
 import { ToolBarDropdownStore } from "../../helpers/top_bar_tool_hook";
 import { NumberEditor } from "../../number_editor/number_editor";
-import { Component } from "../../../owl3_compatibility_layer";
 export declare class ToolBarZoom extends Component<SpreadsheetChildEnv> {
     static template: string;
     static components: {
@@ -11,6 +11,7 @@ export declare class ToolBarZoom extends Component<SpreadsheetChildEnv> {
         class: string;
     }>;
     topBarToolStore: ToolBarDropdownStore;
+    private zoomStore;
     valueList: number[];
     setup(): void;
     get currentFontSize(): number;

package/dist/types/constants.d.ts

@@ -64,6 +64,9 @@ export declare const MENU_SEPARATOR_BORDER_WIDTH = 1;
 export declare const MENU_SEPARATOR_PADDING = 5;
 export declare const MENU_SEPARATOR_HEIGHT: number;
 export declare const ZOOM_VALUES: number[];
+export declare const MIN_ZOOM = 0.5;
+export declare const MAX_ZOOM = 2;
+export declare const DEFAULT_ZOOM = 1;
 export declare const DEFAULT_STYLE: {
     align: "default";
     verticalAlign: "bottom";
@@ -95,6 +98,7 @@ export declare const DEFAULT_NUMBER_STYLE: {
 };
 export declare const DEFAULT_VERTICAL_ALIGN: "bottom";
 export declare const DEFAULT_WRAPPING_MODE: "overflow";
+export declare const DEFAULT_TEXT_HIGHLIGHT_PERCENT = 0.25;
 export declare const DEFAULT_FONT_WEIGHT = "400";
 export declare const DEFAULT_FONT_SIZE: number;
 export declare const HEADER_FONT_SIZE = 11;

package/dist/types/formulas/code_builder.d.ts

@@ -3,6 +3,7 @@
  */
 export interface FunctionCode {
     readonly returnExpression: JsString;
+    readonly returnsMatrix: boolean;
     /**
      * Return the same function code but with the return expression assigned to a variable.
      */
@@ -26,7 +27,7 @@ export declare class FunctionCodeBuilder {
     private code;
     constructor(scope?: Scope);
     append(...lines: (JsString | FunctionCode)[]): void;
-    return(expression: JsString): FunctionCode;
+    return(expression: JsString, returnsMatrix?: boolean): FunctionCode;
     toString(): string;
 }
 export declare class Scope {

package/dist/types/formulas/compiler.d.ts

@@ -1,4 +1,5 @@
 import { CoreGetters } from "../types/core_getters";
+import { ComputeFunction } from "../types/functions";
 import { ApplyRangeChange, ApplyRenameNamedRange, FormulaToExecute, LiteralValues, NamedRange, UID } from "../types/misc";
 import { Range, RangeStringOptions } from "../types/range";
 import { AST } from "./parser";
@@ -25,6 +26,7 @@ export declare const UNARY_OPERATOR_MAP: {
 };
 interface ICompiledFormula {
     execute: FormulaToExecute;
+    computeFunctions: ComputeFunction[];
     tokens: Token[];
     dependencies: string[];
     isBadExpression: boolean;
@@ -35,6 +37,9 @@ interface ICompiledFormula {
 export declare const functionCache: {
     [key: string]: FormulaToExecute;
 };
+export declare const computeFunctionsCache: {
+    [key: string]: ComputeFunction[];
+};
 /**
  * A compiled formula is the result of the compilation of a formula string.
  * It contains all the information needed to execute the formula, as well as some metadata
@@ -49,6 +54,7 @@ export declare class CompiledFormula implements Omit<ICompiledFormula, "tokens"
     readonly isBadExpression: boolean;
     readonly normalizedFormula: string;
     readonly execute: FormulaToExecute;
+    readonly computeFunctions: ComputeFunction[];
     readonly rangeDependencies: Range[];
     hasDependencies: boolean;
     private constructor();
@@ -92,6 +98,7 @@ export declare class CompiledFormula implements Omit<ICompiledFormula, "tokens"
      * Make a new instance of CompiledFormula by compiling the formula string as input by the user.
      * */
     static Compile(formula: string, sheetId: UID, getters: CoreGetters): CompiledFormula;
+    areRangeShapesInLineWithNormalizedFormula(): boolean;
 }
 /**
  * A compiled formula serialized

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

@@ -1,4 +1,4 @@
-import { ComputeFunction, EvalContext, FunctionDescription } from "../types/functions";
+import { ArgDefinition, ComputeFunction, EvalContext, FunctionDescription } from "../types/functions";
 import { Arg, FunctionResultObject, Matrix } from "../types/misc";
 /**
  * Enables a formula function to accept matrix or vector inputs instead of simple value, computing results across multiple dimensions.
@@ -36,7 +36,8 @@ import { Arg, FunctionResultObject, Matrix } from "../types/misc";
  * - For special behaviors (e.g. the `IF` function), you may declare all arguments
  *   as ranges and invoke this helper directly within your `compute` implementation.
  */
-export declare function applyVectorization(context: EvalContext, descr: FunctionDescription, args: Arg[], acceptToVectorize?: boolean[] | undefined): FunctionResultObject | Matrix<FunctionResultObject>;
-export declare function createComputeFunction(descr: FunctionDescription): ComputeFunction<Matrix<FunctionResultObject> | FunctionResultObject>;
+export declare function applyVectorization(context: EvalContext, descr: FunctionDescription, args: Arg[], argDefinitions: ArgDefinition[], vectorizedArgsIndices: number[]): FunctionResultObject | Matrix<FunctionResultObject>;
+export declare function getFunctionArgDefinitions(descr: FunctionDescription, argCount: number): ArgDefinition[];
+export declare function createComputeFunction(descr: FunctionDescription, argCount: number, vectorizedArgsIndices?: number[]): ComputeFunction;
 export declare function handleError(e: unknown, functionName: string): FunctionResultObject;
 export declare const implementationErrorMessage: string;

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

@@ -1,10 +1,6 @@
 import { Registry } from "../registries/registry";
-import { AddFunctionDescription, ComputeFunction, FunctionDescription } from "../types/functions";
-import { FunctionResultObject, Matrix } from "../types/misc";
+import { AddFunctionDescription, FunctionDescription } from "../types/functions";
 export declare class FunctionRegistry extends Registry<FunctionDescription> {
-    mapping: {
-        [key: string]: ComputeFunction<Matrix<FunctionResultObject> | FunctionResultObject>;
-    };
     add(name: string, addDescr: AddFunctionDescription): this;
     replace(name: string, addDescr: AddFunctionDescription): this;
 }

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

@@ -22,3 +22,4 @@ export declare function multiplyMatrices(matrix1: Matrix<number>, matrix2: Matri
  */
 export declare function toScalar<T>(arg: Matrix<T> | T): T;
 export declare function isMultipleElementMatrix(arg: any): boolean;
+export declare function getMatrixArgIndices(args: unknown[]): number[];

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

@@ -19,3 +19,9 @@ export declare function expM(M: Matrix<number>): Matrix<number>;
 export declare function logM(M: Matrix<number>): Matrix<number>;
 export declare function predictLinearValues(Y: Matrix<number>, X: Matrix<number>, newX: Matrix<number>, computeIntercept: boolean): Matrix<number>;
 export declare function getMovingAverageValues(dataset: number[], labels: number[], windowSize?: number): Point[];
+export declare function lnGamma(z: number): number;
+export declare function regularizedGammaUpper(a: number, x: number): number;
+export declare function regularizedBeta(x: number, a: number, b: number): number;
+export declare function normInv(p: number): number;
+export declare function tDistTwoTail(t: number, df: number): number;
+export declare function tInv2T(alpha: number, df: number): number;

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

@@ -3,135 +3,151 @@ import { Arg, FunctionResultObject, Matrix, Maybe } from "../types/misc";
 export declare const ARRAY_CONSTRAIN: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, array: Arg, rows: Maybe<FunctionResultObject>, columns: Maybe<FunctionResultObject>) => EvaluationError | Matrix<FunctionResultObject>;
+    computeArray: (this: import("..").EvalContext, array: Arg, rows: Maybe<FunctionResultObject>, columns: Maybe<FunctionResultObject>) => EvaluationError | Matrix<FunctionResultObject>;
     isExported: false;
 };
 export declare const ARRAY_LITERAL: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (...ranges: Arg[]) => EvaluationError | Matrix<FunctionResultObject>;
+    computeArray: (...ranges: Arg[]) => EvaluationError | Matrix<FunctionResultObject>;
     isExported: false;
     hidden: true;
 };
 export declare const ARRAY_ROW: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (...ranges: Arg[]) => EvaluationError | Matrix<FunctionResultObject>;
+    computeArray: (...ranges: Arg[]) => EvaluationError | Matrix<FunctionResultObject>;
     isExported: false;
     hidden: true;
 };
 export declare const CHOOSECOLS: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, array: Arg, ...columns: Arg[]) => EvaluationError | Matrix<FunctionResultObject>;
+    computeArray: (this: import("..").EvalContext, array: Arg, ...columns: Arg[]) => EvaluationError | Matrix<FunctionResultObject>;
     isExported: true;
 };
 export declare const CHOOSEROWS: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, array: Arg, ...rows: Arg[]) => EvaluationError | Matrix<FunctionResultObject>;
+    computeArray: (this: import("..").EvalContext, array: Arg, ...rows: Arg[]) => EvaluationError | Matrix<FunctionResultObject>;
     isExported: true;
 };
 export declare const EXPAND: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, arg: Arg, rows: Maybe<FunctionResultObject>, columns?: Maybe<FunctionResultObject>, padWith?: Maybe<FunctionResultObject>) => EvaluationError | Matrix<FunctionResultObject>;
+    computeArray: (this: import("..").EvalContext, arg: Arg, rows: Maybe<FunctionResultObject>, columns?: Maybe<FunctionResultObject>, padWith?: Maybe<FunctionResultObject>) => EvaluationError | Matrix<FunctionResultObject>;
     isExported: true;
 };
 export declare const FLATTEN: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (...ranges: Arg[]) => Matrix<FunctionResultObject>;
+    computeArray: (...ranges: Arg[]) => Matrix<FunctionResultObject>;
     isExported: false;
 };
 export declare const FREQUENCY: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (data: Matrix<FunctionResultObject>, classes: Matrix<FunctionResultObject>) => Matrix<number>;
+    computeArray: (data: Matrix<FunctionResultObject>, classes: Matrix<FunctionResultObject>) => {
+        value: number;
+    }[][];
     isExported: true;
 };
 export declare const HSTACK: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (...ranges: Arg[]) => EvaluationError | Matrix<FunctionResultObject>;
+    computeArray: (...ranges: Arg[]) => EvaluationError | Matrix<FunctionResultObject>;
     isExported: true;
 };
 export declare const MDETERM: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (matrix: Arg) => number | EvaluationError;
+    compute: (matrix: Arg) => EvaluationError | {
+        value: number;
+    };
     isExported: true;
 };
 export declare const MINVERSE: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (matrix: Arg) => EvaluationError | Matrix<number>;
+    computeArray: (matrix: Arg) => EvaluationError | Matrix<{
+        value: number;
+    }>;
     isExported: true;
 };
 export declare const MMULT: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (matrix1: Arg, matrix2: Arg) => EvaluationError | Matrix<number>;
+    computeArray: (matrix1: Arg, matrix2: Arg) => EvaluationError | Matrix<{
+        value: number;
+    }>;
     isExported: true;
 };
 export declare const SUMPRODUCT: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, ...args: Arg[]) => number | EvaluationError;
+    compute: (this: import("..").EvalContext, ...args: Arg[]) => EvaluationError | {
+        value: number;
+    };
     isExported: true;
 };
 export declare const SUMX2MY2: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (arrayX: Arg, arrayY: Arg) => number | EvaluationError;
+    compute: (arrayX: Arg, arrayY: Arg) => EvaluationError | {
+        value: number;
+    };
     isExported: true;
 };
 export declare const SUMX2PY2: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (arrayX: Arg, arrayY: Arg) => number | EvaluationError;
+    compute: (arrayX: Arg, arrayY: Arg) => EvaluationError | {
+        value: number;
+    };
     isExported: true;
 };
 export declare const SUMXMY2: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (arrayX: Arg, arrayY: Arg) => number | EvaluationError;
+    compute: (arrayX: Arg, arrayY: Arg) => EvaluationError | {
+        value: number;
+    };
     isExported: true;
 };
 export declare const TOCOL: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, array: Arg, ignore?: Maybe<FunctionResultObject>, scanByColumn?: Maybe<FunctionResultObject>) => NotAvailableError | FunctionResultObject[][];
+    computeArray: (this: import("..").EvalContext, array: Arg, ignore?: Maybe<FunctionResultObject>, scanByColumn?: Maybe<FunctionResultObject>) => NotAvailableError | FunctionResultObject[][];
     isExported: true;
 };
 export declare const TOROW: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, array: Arg, ignore?: Maybe<FunctionResultObject>, scanByColumn?: Maybe<FunctionResultObject>) => NotAvailableError | FunctionResultObject[][];
+    computeArray: (this: import("..").EvalContext, array: Arg, ignore?: Maybe<FunctionResultObject>, scanByColumn?: Maybe<FunctionResultObject>) => NotAvailableError | FunctionResultObject[][];
     isExported: true;
 };
 export declare const TRANSPOSE: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (arg: Arg) => Matrix<FunctionResultObject>;
+    computeArray: (arg: Arg) => Matrix<FunctionResultObject>;
     isExported: true;
 };
 export declare const VSTACK: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (...ranges: Arg[]) => EvaluationError | Matrix<FunctionResultObject>;
+    computeArray: (...ranges: Arg[]) => EvaluationError | Matrix<FunctionResultObject>;
     isExported: true;
 };
 export declare const WRAPCOLS: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, range: Arg, wrapCount: Maybe<FunctionResultObject>, padWith?: Maybe<FunctionResultObject>) => EvaluationError | Matrix<FunctionResultObject>;
+    computeArray: (this: import("..").EvalContext, range: Arg, wrapCount: Maybe<FunctionResultObject>, padWith?: Maybe<FunctionResultObject>) => EvaluationError | Matrix<FunctionResultObject>;
     isExported: true;
 };
 export declare const WRAPROWS: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, range: Arg, wrapCount: Maybe<FunctionResultObject>, padWith?: Maybe<FunctionResultObject>) => EvaluationError | Matrix<FunctionResultObject>;
+    computeArray: (this: import("..").EvalContext, range: Arg, wrapCount: Maybe<FunctionResultObject>, padWith?: Maybe<FunctionResultObject>) => EvaluationError | Matrix<FunctionResultObject>;
     isExported: true;
 };
 export declare const ARRAYTOTEXT: {
@@ -139,6 +155,8 @@ export declare const ARRAYTOTEXT: {
     args: import("..").ArgDefinition[];
     compute: (this: import("..").EvalContext, array: Matrix<{
         value: string;
-    }>, format?: Maybe<FunctionResultObject>) => string | EvaluationError;
+    }>, format?: Maybe<FunctionResultObject>) => EvaluationError | {
+        value: string;
+    };
     isExported: true;
 };

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

@@ -8,13 +8,17 @@ export declare const DAVERAGE: {
 export declare const DCOUNT: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, database: Matrix<FunctionResultObject>, field: Maybe<FunctionResultObject>, criteria: Matrix<FunctionResultObject>) => number;
+    compute: (this: import("..").EvalContext, database: Matrix<FunctionResultObject>, field: Maybe<FunctionResultObject>, criteria: Matrix<FunctionResultObject>) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const DCOUNTA: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, database: Matrix<FunctionResultObject>, field: Maybe<FunctionResultObject>, criteria: Matrix<FunctionResultObject>) => number;
+    compute: (this: import("..").EvalContext, database: Matrix<FunctionResultObject>, field: Maybe<FunctionResultObject>, criteria: Matrix<FunctionResultObject>) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const DGET: {
@@ -44,13 +48,17 @@ export declare const DPRODUCT: {
 export declare const DSTDEV: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, database: Matrix<FunctionResultObject>, field: Maybe<FunctionResultObject>, criteria: Matrix<FunctionResultObject>) => number;
+    compute: (this: import("..").EvalContext, database: Matrix<FunctionResultObject>, field: Maybe<FunctionResultObject>, criteria: Matrix<FunctionResultObject>) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const DSTDEVP: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, database: Matrix<FunctionResultObject>, field: Maybe<FunctionResultObject>, criteria: Matrix<FunctionResultObject>) => number;
+    compute: (this: import("..").EvalContext, database: Matrix<FunctionResultObject>, field: Maybe<FunctionResultObject>, criteria: Matrix<FunctionResultObject>) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const DSUM: {
@@ -62,12 +70,16 @@ export declare const DSUM: {
 export declare const DVAR: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, database: Matrix<FunctionResultObject>, field: Maybe<FunctionResultObject>, criteria: Matrix<FunctionResultObject>) => number;
+    compute: (this: import("..").EvalContext, database: Matrix<FunctionResultObject>, field: Maybe<FunctionResultObject>, criteria: Matrix<FunctionResultObject>) => {
+        value: number;
+    };
     isExported: true;
 };
 export declare const DVARP: {
     description: string;
     args: import("..").ArgDefinition[];
-    compute: (this: import("..").EvalContext, database: Matrix<FunctionResultObject>, field: Maybe<FunctionResultObject>, criteria: Matrix<FunctionResultObject>) => number;
+    compute: (this: import("..").EvalContext, database: Matrix<FunctionResultObject>, field: Maybe<FunctionResultObject>, criteria: Matrix<FunctionResultObject>) => {
+        value: number;
+    };
     isExported: true;
 };