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

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,6 +1,11 @@
-import { ChartDefinition } from "../types/chart/chart";
-import { CarouselItem } from "../types/figure";
+import { AnchorOffset, CarouselItem } from "../types/figure";
 import { Getters } from "../types/getters";
-export declare const CAROUSEL_DEFAULT_CHART_DEFINITION: ChartDefinition;
+import { UID } from "../types/misc";
+import { SpreadsheetChildEnv } from "../types/spreadsheet_env";
+/**
+ * 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.
+ */
+export declare function getPoppedOutChartAnchor(env: SpreadsheetChildEnv, sheetId: UID, carouselId: UID): AnchorOffset;
 export declare function getCarouselItemPreview(getters: Getters, item: CarouselItem): string;
 export declare function getCarouselItemTitle(getters: Getters, item: CarouselItem): string;

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/figures/charts/chart_common.d.ts

@@ -6,7 +6,6 @@ import { Getters } from "../../../types/getters";
 import { Locale } from "../../../types/locale";
 import { Color, RangeAdapterFunctions, UID } from "../../../types/misc";
 import { Range } from "../../../types/range";
-import { DOMCoordinates, DOMDimension } from "../../../types/rendering";
 import { ColorGenerator } from "../../color";
 export declare const TREND_LINE_XAXIS_ID = "x1";
 export declare const MOVING_AVERAGE_TREND_LINE_XAXIS_ID = "xMovingAverage";
@@ -47,7 +46,6 @@ export declare function chartMutedFontColor(backgroundColor: Color | undefined):
 export declare function checkDataset(dataSource: ChartRangeDataSource<string>): CommandResult;
 export declare function checkLabelRange(dataSource: ChartRangeDataSource<string>): CommandResult;
 export declare function shouldRemoveFirstLabel(numberOfLabels: number, numberOfDataPoints: number | undefined, dataSetsHaveTitle: boolean): boolean;
-export declare function getChartPositionAtCenterOfViewport(getters: Getters, chartSize: DOMDimension): DOMCoordinates;
 export declare function getDefinedAxis(definition: Partial<ChartDefinition<string | Range>>): {
     useLeftAxis: boolean;
     useRightAxis: boolean;

package/dist/types/helpers/figures/charts/scorecard_chart_config_builder.d.ts

@@ -8,6 +8,7 @@ type ScorecardChartElement = {
         color: Color;
         strikethrough?: boolean;
         underline?: boolean;
+        highlightText?: boolean;
     };
     position: PixelPosition;
 };
@@ -23,6 +24,7 @@ export type ScorecardChartConfig = {
         style: {
             size: Pixel;
             color: Color;
+            highlight?: boolean;
         };
         position: PixelPosition;
     };

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

@@ -1,8 +1,9 @@
 import { Position, UID } from "../../..";
 import { AnchorOffset, Figure, FigureSize } from "../../../types/figure";
 import { Getters } from "../../../types/getters";
-export declare function centerFigurePosition(getters: Getters, size: FigureSize): AnchorOffset;
-export declare function getMaxFigureSize(getters: Getters, figureSize: FigureSize): FigureSize;
+import { SpreadsheetChildEnv } from "../../../types/spreadsheet_env";
+export declare function centerFigurePosition(env: SpreadsheetChildEnv, size: FigureSize): AnchorOffset;
+export declare function getMaxFigureSize(figureSize: FigureSize): FigureSize;
 export declare function boundColRowOffsetInSheet(getters: Getters, sheetId: UID, position: Position, figure: Figure): {
     col: import("../../..").HeaderIndex;
     row: import("../../..").HeaderIndex;

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).
@@ -49,6 +57,7 @@ export declare class InternalViewport {
     willNewOffsetScrollViewport(offsetX: Pixel, offsetY: Pixel): boolean;
     setViewportOffset(offsetX: Pixel, offsetY: Pixel): void;
     adjustViewportZone(): void;
+    isZoneVisible(zone: Zone): boolean;
     /**
      *
      * Computes the visible coordinates & dimensions of a given zone inside the viewport
@@ -84,3 +93,4 @@ export declare class InternalViewport {
      * */
     private get snapCorrection();
 }
+export {};

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

@@ -233,3 +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/pivot/pivot_helpers.d.ts

@@ -2,7 +2,7 @@ import { Registry } from "../../registries/registry";
 import { CellValue } from "../../types/cells";
 import { Locale } from "../../types/locale";
 import { CellPosition, FunctionResultObject, Matrix, Maybe } from "../../types/misc";
-import { Granularity, PivotCoreDefinition, PivotCoreDimension, PivotCoreMeasure, PivotCustomGroupedField, PivotDimension, PivotDomain, PivotField, PivotFields, PivotSortedColumn, PivotStyle, PivotTableCell } from "../../types/pivot";
+import { PivotCoreDefinition, PivotCoreDimension, PivotCoreMeasure, PivotCustomGroupedField, PivotDimension, PivotDomain, PivotField, PivotFields, PivotSortedColumn, PivotStyle, PivotTableCell } from "../../types/pivot";
 import { Pivot } from "../../types/pivot_runtime";
 import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
 import { PivotRuntimeDefinition } from "./pivot_runtime_definition";
@@ -53,7 +53,7 @@ export declare function createPivotFormula(formulaId: string, cell: PivotTableCe
  */
 export declare function toNormalizedPivotValue(dimension: Pick<PivotDimension, "type" | "displayName" | "granularity">, groupValue: Maybe<CellValue | FunctionResultObject>): CellValue;
 export declare function toFunctionPivotValue(value: CellValue, dimension: Pick<PivotDimension, "type" | "granularity">): string;
-export declare const pivotNormalizationValueRegistry: Registry<(value: string, granularity?: Granularity | string) => CellValue>;
+export declare const pivotNormalizationValueRegistry: Registry<(value: string, dimension: Pick<PivotDimension, "type" | "displayName" | "granularity">) => CellValue>;
 export declare const pivotToFunctionValueRegistry: Registry<(value: CellValue, granularity?: string) => string>;
 export declare function getFieldDisplayName(field: PivotDimension): string;
 export declare function addAlignFormatToPivotHeader(domain: PivotDomain, functionResult: FunctionResultObject): FunctionResultObject;

package/dist/types/helpers/pivot/pivot_highlight.d.ts

@@ -1,3 +1,3 @@
-import { Getters } from "../../types/getters";
 import { Highlight, UID } from "../../types/misc";
-export declare function getPivotHighlights(getters: Getters, pivotId: UID): Highlight[];
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+export declare function getPivotHighlights(env: SpreadsheetChildEnv, pivotId: UID): Highlight[];

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

@@ -6,3 +6,7 @@ export declare function rectIntersection(rect1: Rect, rect2: Rect): Rect | undef
 /** Compute the union of the rectangles, ie. the smallest rectangle that contain them all */
 export declare function rectUnion(...rects: Rect[]): Rect;
 export declare function isPointInsideRect(x: number, y: number, rect: Rect): boolean;
+/**
+ * Return a Rect with position and size on the zoomed canvas
+ */
+export declare function getZoomedRect(zoom: number, rect: Rect): Rect;

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

@@ -19,6 +19,10 @@ export declare function computeTextDimension(context: Canvas2DContext, text: str
     width: number;
     height: number;
 };
+export declare function computeCachedTextDimension(context: Canvas2DContext, text: string, font: string): {
+    width: number;
+    height: number;
+};
 export declare function fontSizeInPixels(fontSize: number): number;
 export declare function computeTextFont(style: Style, fontUnit?: "px" | "pt"): string;
 export declare function computeTextFontSizeInPixels(style?: Style): number;
@@ -38,7 +42,8 @@ export declare function getFontSizeMatchingWidth(lineWidth: number, maxFontSize:
 export declare function toTrimmedLowerCase(str: string | undefined): string;
 export declare function getContextFontSize(font: string): Pixel;
 export declare function clipTextWithEllipsis(ctx: Canvas2DContext, text: string, maxWidth: number): string;
-export declare function drawDecoratedText(context: Canvas2DContext, text: string, position: PixelPosition, underline?: boolean | undefined, strikethrough?: boolean | undefined, strokeWidth?: number): void;
+export declare function drawDecoratedText(context: Canvas2DContext, text: string, position: PixelPosition, underline?: boolean | undefined, strikethrough?: boolean | undefined, strokeWidth?: number, //This value is defined to get a good looking stroke
+highlightText?: boolean | undefined): void;
 export declare function sliceTextToFitWidth(context: Canvas2DContext, width: number, text: string, style: Style, fontUnit?: "px" | "pt"): string;
 /**
  * Return the position to draw text on a rotated canvas to ensure that the rotated text alignment correspond

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,15 +1,28 @@
-import { CommandResult, ResizeViewportCommand, SetViewportOffsetCommand } from "../types/commands";
 import { AnchorOffset, Figure, FigureUI } from "../types/figure";
-import { RenderingGetters } from "../types/getters";
-import { CellPosition, Dimension, HeaderDimensions, HeaderIndex, PaneDivision, Pixel, PixelPosition, Position, UID, Zone } from "../types/misc";
+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;
+    getZoomLevel: () => number;
+    getFooterSize: () => number;
+    zoneToDisplay?: Zone;
+}
 /**
  *   EdgeScrollCases Schema
  *
@@ -46,15 +59,18 @@ type SheetViewports = {
  *                                   ↓           ↓
  */
 export declare class ViewportCollection {
-    private paneDivision;
-    private sheetViewWidth;
-    private sheetViewHeight;
-    private zoomLevel;
-    getters: RenderingGetters;
+    getters: ViewportsGetters;
     viewports: Record<UID, SheetViewports | undefined>;
     private gridOffsetX;
     private gridOffsetY;
-    constructor(getters: RenderingGetters, paneDivision: Record<UID, PaneDivision>, sheetViewWidth?: Pixel, sheetViewHeight?: Pixel, zoomLevel?: number);
+    private paneDivision;
+    private sheetViewWidth;
+    private sheetViewHeight;
+    getZoomLevel: () => 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.
@@ -94,7 +110,7 @@ export declare class ViewportCollection {
      * Check if a given position is visible in the viewport.
      */
     isVisibleInViewport({ sheetId, col, row }: CellPosition): boolean;
-    getScrollBarWidth(): Pixel;
+    isZoneVisibleInViewport(sheetId: UID, zone: Zone): boolean;
     getEdgeScrollCol(sheetId: UID, x: number, previousX: number, startingX: number): EdgeScrollInfo;
     getEdgeScrollRow(sheetId: UID, y: number, previousY: number, startingY: number): EdgeScrollInfo;
     /**
@@ -139,21 +155,28 @@ export declare class ViewportCollection {
         zone: Zone;
         rect: Rect;
     }[];
-    getViewportZoomLevel(): number;
     ensureMainViewportExist(sheetId: UID): void;
+    getPanesDimensions(sheetId: UID): {
+        paneWidth: number;
+        paneHeight: number;
+    };
+    getPositionedViewports(sheetId: UID): PositionedViewport[];
     getSubViewports(sheetId: UID): InternalViewport[];
-    checkPositiveDimension(cmd: ResizeViewportCommand): CommandResult.Success | CommandResult.InvalidViewportSize;
-    checkValuesAreDifferent(cmd: ResizeViewportCommand): CommandResult.Success | CommandResult.ValuesNotChanged;
+    checkPositiveDimension(dims: SheetViewDimensions): boolean;
+    checkValuesAreDifferent(dims: SheetViewDimensions): boolean;
     checkScrollingDirection(sheetId: UID, { offsetX, offsetY }: {
         offsetX: Pixel;
         offsetY: Pixel;
-    }): CommandResult;
-    checkIfViewportsWillChange(sheetId: UID, { offsetX, offsetY }: SetViewportOffsetCommand): CommandResult.Success | CommandResult.ViewportScrollLimitsReached;
+    }): boolean;
+    checkIfViewportsWillChange(sheetId: UID, { offsetX, offsetY }: {
+        offsetX: Pixel;
+        offsetY: Pixel;
+    }): boolean;
     getMainViewport(sheetId: UID): Viewport;
     getMainInternalViewport(sheetId: UID): InternalViewport;
     /** gets rid of deprecated sheetIds */
     cleanViewports(): void;
-    resizeSheetView(height: Pixel, width: Pixel, gridOffsetX?: Pixel, gridOffsetY?: Pixel): void;
+    resizeSheetView(dimensions: SheetViewDimensions): void;
     recomputeViewports(): void;
     setSheetViewOffset(sheetId: UID, offsetX: Pixel, offsetY: Pixel): void;
     getViewportOffset(sheetId: UID): {
@@ -161,6 +184,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
      */
@@ -188,8 +220,6 @@ export declare class ViewportCollection {
     private mapViewportsToRect;
     getGridOffsetX(): Pixel;
     getGridOffsetY(): Pixel;
-    getZoomLevel(): number;
-    setZoomLevel(zoomLevel: number): void;
     private getPaneDivisions;
     setPaneDivision(sheetId: UID, paneDivision: PaneDivision): void;
 }

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;