@odoo/o-spreadsheet 17.0.84 → 17.0.96

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

@@ -0,0 +1,41 @@
+import { Component } from "@odoo/owl";
+import { Figure, ResizeDirection, SpreadsheetChildEnv } from "../../../types/index";
+import { Menu } from "../../menu/menu";
+type ResizeAnchor = "top left" | "top" | "top right" | "right" | "bottom right" | "bottom" | "bottom left" | "left";
+interface Props {
+    figure: Figure;
+    style: string;
+    onFigureDeleted: () => void;
+    onMouseDown: (ev: MouseEvent) => void;
+    onClickAnchor(dirX: ResizeDirection, dirY: ResizeDirection, ev: MouseEvent): void;
+}
+export declare class FigureComponent extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static components: {
+        Menu: typeof Menu;
+    };
+    static defaultProps: {
+        onFigureDeleted: () => void;
+        onMouseDown: () => void;
+        onClickAnchor: () => void;
+    };
+    private menuState;
+    private figureRef;
+    private menuButtonRef;
+    private menuButtonRect;
+    private borderWidth;
+    get isSelected(): boolean;
+    get figureRegistry(): import("../../..").Registry<import("../../../registries/figure_registry").FigureContent>;
+    private getBorderWidth;
+    get borderStyle(): string;
+    get wrapperStyle(): string;
+    getResizerPosition(resizer: ResizeAnchor): string;
+    setup(): void;
+    clickAnchor(dirX: ResizeDirection, dirY: ResizeDirection, ev: MouseEvent): void;
+    onMouseDown(ev: MouseEvent): void;
+    onKeyDown(ev: KeyboardEvent): void;
+    onContextMenu(ev: MouseEvent): void;
+    showMenu(): void;
+    private openContextMenu;
+}
+export {};

package/dist/types/components/figures/figure_chart/figure_chart.d.ts

@@ -0,0 +1,14 @@
+import { Component } from "@odoo/owl";
+import { ChartType, Figure, SpreadsheetChildEnv } from "../../../types";
+interface Props {
+    figure: Figure;
+    onFigureDeleted: () => void;
+}
+export declare class ChartFigure extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static components: {};
+    onDoubleClick(): void;
+    get chartType(): ChartType;
+    get chartComponent(): new (...args: any) => Component;
+}
+export {};

package/dist/types/components/figures/figure_container/figure_container.d.ts

@@ -0,0 +1,117 @@
+import { Component } from "@odoo/owl";
+import { Figure, ResizeDirection, SpreadsheetChildEnv } from "../../../types/index";
+import { HFigureAxisType, SnapLine, VFigureAxisType } from "../../helpers/figure_snap_helper";
+import { FigureComponent } from "../figure/figure";
+type ContainerType = "topLeft" | "topRight" | "bottomLeft" | "bottomRight" | "dnd";
+interface Props {
+    onFigureDeleted: () => void;
+}
+interface Container {
+    type: ContainerType;
+    figures: Figure[];
+    style: string;
+    inverseViewportStyle: string;
+}
+interface Snap<T extends HFigureAxisType | VFigureAxisType> {
+    line: SnapLine<T>;
+    lineStyle: string;
+    containerStyle: string;
+}
+interface DndState {
+    draggedFigure?: Figure;
+    horizontalSnap?: Snap<HFigureAxisType>;
+    verticalSnap?: Snap<VFigureAxisType>;
+    cancelDnd: (() => void) | undefined;
+}
+/**
+ * Each figure ⭐ is positioned inside a container `div` placed and sized
+ * according to the split pane the figure is part of, or a separate container for the figure
+ * currently drag & dropped. Any part of the figure outside of the container is hidden
+ * thanks to its `overflow: hidden` property.
+ *
+ * Additionally, the figure is placed inside a "inverse viewport" `div` 🟥.
+ * Its position represents the viewport position in the grid: its top/left
+ * corner represents the top/left corner of the grid.
+ *
+ * It allows to position the figure inside this div regardless of the
+ * (possibly freezed) viewports and the scrolling position.
+ *
+ * --: container limits
+ * 🟥: inverse viewport
+ * ⭐: figure top/left position
+ *
+ *                     container
+ *                         ↓
+ * |🟥--------------------------------------------
+ * |  \                                          |
+ * |   \                                         |
+ * |    \                                        |
+ * |     \          visible area                 |  no scroll
+ * |      ⭐                                     |
+ * |                                             |
+ * |                                             |
+ * -----------------------------------------------
+ *
+ * the scrolling of the pane is applied as an inverse offset
+ * to the div which will in turn move the figure up and down
+ * inside the container.
+ * Hence, once the figure position is (resp. partly) out of
+ * the container dimensions, it will be (resp. partly) hidden.
+ *
+ * The same reasoning applies to the horizontal axis.
+ *
+ *  🟥 ························
+ *    \                       ↑
+ *     \                      |
+ *      \                     | inverse viewport = -1 * scroll of pane
+ *       \                    |
+ *        ⭐ <- not visible   |
+ *                            ↓
+ * -----------------------------------------------
+ * |                                             |
+ * |                                             |
+ * |                                             |
+ * |               visible area                  |
+ * |                                             |
+ * |                                             |
+ * |                                             |
+ * -----------------------------------------------
+ *
+ * In the case the d&d figure container, the container is the same as the "topLeft" container for
+ * frozen pane (unaffected by scroll and always visible). The figure coordinates are transformed
+ * for this container at the start of the d&d, and transformed back at the end to adapt to the scroll
+ * that occurred during the drag & drop, and to position the figure on the correct pane.
+ *
+ */
+export declare class FiguresContainer extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static components: {
+        FigureComponent: typeof FigureComponent;
+    };
+    dnd: DndState;
+    setup(): void;
+    private getVisibleFigures;
+    get containers(): Container[];
+    private getContainerStyle;
+    private rectToCss;
+    private getContainerRect;
+    private getInverseViewportPositionStyle;
+    private getFigureContainer;
+    startDraggingFigure(figure: Figure, ev: MouseEvent): void;
+    /**
+     * Initialize the resize of a figure with mouse movements
+     *
+     * @param dirX X direction of the resize. -1 : resize from the left border of the figure, 0 : no resize in X, 1 :
+     * resize from the right border of the figure
+     * @param dirY Y direction of the resize. -1 : resize from the top border of the figure, 0 : no resize in Y, 1 :
+     * resize from the bottom border of the figure
+     * @param ev Mouse Event
+     */
+    startResize(figure: Figure, dirX: ResizeDirection, dirY: ResizeDirection, ev: MouseEvent): void;
+    private getOtherFigures;
+    private getDndFigure;
+    getFigureStyle(figure: Figure): string;
+    private getSnap;
+    private getSnapLineStyle;
+}
+export {};

package/dist/types/components/figures/figure_image/figure_image.d.ts

@@ -0,0 +1,13 @@
+import { Component } from "@odoo/owl";
+import { Figure, SpreadsheetChildEnv, UID } from "../../../types";
+interface Props {
+    figure: Figure;
+    onFigureDeleted: () => void;
+}
+export declare class ImageFigure extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static components: {};
+    get figureId(): UID;
+    get getImagePath(): string;
+}
+export {};

package/dist/types/components/filters/filter_icon/filter_icon.d.ts

@@ -0,0 +1,12 @@
+import { Component } from "@odoo/owl";
+import { CellPosition, SpreadsheetChildEnv } from "../../../types";
+interface Props {
+    cellPosition: CellPosition;
+}
+export declare class FilterIcon extends Component<Props, SpreadsheetChildEnv> {
+    static style: string;
+    static template: string;
+    onClick(): void;
+    get isFilterActive(): boolean;
+}
+export {};

package/dist/types/components/filters/filter_icons_overlay/filter_icons_overlay.d.ts

@@ -0,0 +1,22 @@
+import { Component } from "@odoo/owl";
+import { CellPosition, DOMCoordinates, SpreadsheetChildEnv } from "../../../types";
+import { GridCellIcon } from "../../grid_cell_icon/grid_cell_icon";
+import { FilterIcon } from "../filter_icon/filter_icon";
+interface Props {
+    gridPosition: DOMCoordinates;
+}
+export declare class FilterIconsOverlay extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static components: {
+        GridCellIcon: typeof GridCellIcon;
+        FilterIcon: typeof FilterIcon;
+    };
+    static defaultProps: {
+        gridPosition: {
+            x: number;
+            y: number;
+        };
+    };
+    getFilterHeadersPositions(): CellPosition[];
+}
+export {};

package/dist/types/components/filters/filter_menu/filter_menu.d.ts

@@ -0,0 +1,43 @@
+import { Component } from "@odoo/owl";
+import { Position, SortDirection, SpreadsheetChildEnv } from "../../../types";
+import { PopoverBuilders } from "../../../types/cell_popovers";
+import { FilterMenuValueItem } from "../filter_menu_item/filter_menu_value_item";
+interface Props {
+    filterPosition: Position;
+    onClosed?: () => void;
+}
+interface Value {
+    checked: boolean;
+    string: string;
+    scrolledTo?: "top" | "bottom" | undefined;
+}
+export declare class FilterMenu extends Component<Props, SpreadsheetChildEnv> {
+    static size: {
+        width: number;
+        height: number;
+    };
+    static template: string;
+    static style: string;
+    static components: {
+        FilterMenuValueItem: typeof FilterMenuValueItem;
+    };
+    private state;
+    private searchBar;
+    setup(): void;
+    get isReadonly(): boolean;
+    private getFilterValues;
+    checkValue(value: Value): void;
+    onMouseMove(value: Value): void;
+    selectAll(): void;
+    clearAll(): void;
+    get filterTable(): import("../../../helpers/filters").FilterTable | undefined;
+    get displayedValues(): Value[];
+    confirm(): void;
+    cancel(): void;
+    onKeyDown(ev: KeyboardEvent): void;
+    clearScrolledToValue(): void;
+    private scrollListToSelectedValue;
+    sortFilterZone(sortDirection: SortDirection): void;
+}
+export declare const FilterMenuPopoverBuilder: PopoverBuilders;
+export {};

package/dist/types/components/filters/filter_menu_item/filter_menu_value_item.d.ts

@@ -0,0 +1,17 @@
+import { Component } from "@odoo/owl";
+import { SpreadsheetChildEnv } from "../../../types";
+interface Props {
+    value: string;
+    isChecked: boolean;
+    isSelected: boolean;
+    onClick: () => void;
+    onMouseMove: () => void;
+    scrolledTo: "top" | "bottom" | undefined;
+}
+export declare class FilterMenuValueItem extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    private itemRef;
+    setup(): void;
+    private scrollListToSelectedValue;
+}
+export {};

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

@@ -0,0 +1,29 @@
+import { Component } from "@odoo/owl";
+import { SpreadsheetChildEnv } from "../../types/index";
+interface State {
+    isOpen: boolean;
+}
+interface Props {
+    onToggle: () => void;
+    dropdownStyle: string;
+    class: string;
+}
+export declare class FontSizeEditor extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static components: {};
+    fontSizes: number[];
+    dropdown: State;
+    private inputRef;
+    private rootEditorRef;
+    setup(): void;
+    onExternalClick(ev: MouseEvent): void;
+    get currentFontSize(): number;
+    toggleFontList(): void;
+    closeFontList(): void;
+    private setSize;
+    setSizeFromInput(ev: InputEvent): void;
+    setSizeFromList(fontSizeStr: string): void;
+    onInputFocused(ev: InputEvent): void;
+    onInputKeydown(ev: KeyboardEvent): void;
+}
+export {};

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

@@ -0,0 +1,99 @@
+import { Component } from "@odoo/owl";
+import { ComposerSelection } from "../../plugins/ui_stateful";
+import { Client, DOMCoordinates, DOMDimension, HeaderIndex, Pixel, Position, SpreadsheetChildEnv } from "../../types/index";
+import { Autofill } from "../autofill/autofill";
+import { ClientTag } from "../collaborative_client_tag/collaborative_client_tag";
+import { GridComposer } from "../composer/grid_composer/grid_composer";
+import { FilterIconsOverlay } from "../filters/filter_icons_overlay/filter_icons_overlay";
+import { GridOverlay } from "../grid_overlay/grid_overlay";
+import { GridPopover } from "../grid_popover/grid_popover";
+import { HeadersOverlay } from "../headers_overlay/headers_overlay";
+import { Highlight } from "../highlight/highlight/highlight";
+import { Menu } from "../menu/menu";
+import { Popover } from "../popover/popover";
+import { HorizontalScrollBar, VerticalScrollBar } from "../scrollbar/";
+import { ComposerFocusType } from "../spreadsheet/spreadsheet";
+/**
+ * The Grid component is the main part of the spreadsheet UI. It is responsible
+ * for displaying the actual grid, rendering it, managing events, ...
+ *
+ * The grid is rendered on a canvas. 3 sub components are (sometimes) displayed
+ * on top of the canvas:
+ * - a composer (to edit the cell content)
+ * - a horizontal resizer (to resize columns)
+ * - a vertical resizer (same, for rows)
+ */
+export type ContextMenuType = "ROW" | "COL" | "CELL" | "FILTER" | "GROUP_HEADERS" | "UNGROUP_HEADERS";
+interface Props {
+    sidePanelIsOpen: boolean;
+    exposeFocus: (focus: () => void) => void;
+    focusComposer: ComposerFocusType;
+    onComposerContentFocused: () => void;
+    onGridComposerCellFocused: (content?: string, selection?: ComposerSelection) => void;
+}
+export declare class Grid extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static components: {
+        GridComposer: typeof GridComposer;
+        GridOverlay: typeof GridOverlay;
+        GridPopover: typeof GridPopover;
+        HeadersOverlay: typeof HeadersOverlay;
+        Menu: typeof Menu;
+        Autofill: typeof Autofill;
+        ClientTag: typeof ClientTag;
+        Highlight: typeof Highlight;
+        Popover: typeof Popover;
+        VerticalScrollBar: typeof VerticalScrollBar;
+        HorizontalScrollBar: typeof HorizontalScrollBar;
+        FilterIconsOverlay: typeof FilterIconsOverlay;
+    };
+    readonly HEADER_HEIGHT = 26;
+    readonly HEADER_WIDTH = 48;
+    private menuState;
+    private gridRef;
+    onMouseWheel: (ev: WheelEvent) => void;
+    canvasPosition: DOMCoordinates;
+    hoveredCell: Partial<Position>;
+    setup(): void;
+    onCellHovered({ col, row }: {
+        col: any;
+        row: any;
+    }): void;
+    get gridOverlayDimensions(): string;
+    onClosePopover(): void;
+    private keyDownMapping;
+    focusDefaultElement(): void;
+    get gridEl(): HTMLElement;
+    getAutofillPosition(): {
+        left: number;
+        top: number;
+    };
+    get isAutofillVisible(): boolean;
+    onGridResized({ height, width }: DOMDimension): void;
+    private moveCanvas;
+    getClientPositionKey(client: Client): string;
+    isCellHovered(col: HeaderIndex, row: HeaderIndex): boolean;
+    private getGridRect;
+    onCellClicked(col: HeaderIndex, row: HeaderIndex, { addZone, expandZone }: {
+        addZone: boolean;
+        expandZone: boolean;
+    }): void;
+    onCellDoubleClicked(col: HeaderIndex, row: HeaderIndex): void;
+    closeOpenedPopover(): void;
+    processArrows(ev: KeyboardEvent): void;
+    onKeydown(ev: KeyboardEvent): void;
+    onInputContextMenu(ev: MouseEvent): void;
+    onCellRightClicked(col: HeaderIndex, row: HeaderIndex, { x, y }: DOMCoordinates): void;
+    toggleContextMenu(type: ContextMenuType, x: Pixel, y: Pixel): void;
+    copy(cut: boolean, ev: ClipboardEvent): void;
+    paste(ev: ClipboardEvent): Promise<void>;
+    private displayWarningCopyPasteNotSupported;
+    private clearFormatting;
+    private setHorizontalAlign;
+    closeMenu(): void;
+    private processHeaderGroupingKey;
+    private processHeaderGroupingEventOnHeaders;
+    private processHeaderGroupingEventOnWholeSheet;
+    private processHeaderGroupingEventOnGrid;
+}
+export {};

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

@@ -0,0 +1,27 @@
+import { Component } from "@odoo/owl";
+import { SpreadsheetChildEnv } from "../../types";
+import { ValidationMessages } from "../validation_messages/validation_messages";
+interface Props {
+    focusGrid: () => void;
+}
+export declare class GridAddRowsFooter extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static components: {
+        ValidationMessages: typeof ValidationMessages;
+    };
+    inputRef: {
+        el: HTMLInputElement | null;
+    };
+    state: {
+        inputValue: string;
+        errorFlag: boolean;
+    };
+    setup(): void;
+    get addRowsPosition(): string;
+    get errorMessages(): string[];
+    onKeydown(ev: KeyboardEvent): void;
+    onInput(ev: InputEvent): void;
+    onConfirm(): void;
+    private onExternalClick;
+}
+export {};

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

@@ -0,0 +1,16 @@
+import { Component } from "@odoo/owl";
+import { Align, CellPosition, DOMCoordinates, SpreadsheetChildEnv, VerticalAlign } from "../../types";
+export interface GridCellIconProps {
+    cellPosition: CellPosition;
+    horizontalAlign?: Align;
+    verticalAlign?: VerticalAlign;
+    offset?: DOMCoordinates;
+}
+export declare class GridCellIcon extends Component<GridCellIconProps, SpreadsheetChildEnv> {
+    static style: string;
+    static template: string;
+    get iconStyle(): string;
+    private getIconVerticalPosition;
+    private getIconHorizontalPosition;
+    isPositionVisible(position: CellPosition): boolean;
+}

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

@@ -0,0 +1,45 @@
+import { Component } from "@odoo/owl";
+import { DOMCoordinates, HeaderIndex, Pixel, Position, Rect, SpreadsheetChildEnv } from "../../types";
+import { DataValidationOverlay } from "../data_validation_overlay/data_validation_overlay";
+import { FiguresContainer } from "../figures/figure_container/figure_container";
+import { GridAddRowsFooter } from "../grid_add_rows_footer/grid_add_rows_footer";
+interface Props {
+    onCellHovered: (position: Partial<Position>) => void;
+    onCellDoubleClicked: (col: HeaderIndex, row: HeaderIndex) => void;
+    onCellClicked: (col: HeaderIndex, row: HeaderIndex, modifiers: {
+        addZone: boolean;
+        expandZone: boolean;
+    }) => void;
+    onCellRightClicked: (col: HeaderIndex, row: HeaderIndex, coordinates: DOMCoordinates) => void;
+    onGridResized: (dimension: Rect) => void;
+    onGridMoved: (deltaX: Pixel, deltaY: Pixel) => void;
+    gridOverlayDimensions: string;
+    onFigureDeleted: () => void;
+}
+export declare class GridOverlay extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static components: {
+        FiguresContainer: typeof FiguresContainer;
+        DataValidationOverlay: typeof DataValidationOverlay;
+        GridAddRowsFooter: typeof GridAddRowsFooter;
+    };
+    static defaultProps: {
+        onCellHovered: () => void;
+        onCellDoubleClicked: () => void;
+        onCellClicked: () => void;
+        onCellRightClicked: () => void;
+        onGridResized: () => void;
+        onFigureDeleted: () => void;
+    };
+    private gridOverlay;
+    private gridOverlayRect;
+    setup(): void;
+    get gridOverlayEl(): HTMLElement;
+    get style(): string;
+    get isPaintingFormat(): boolean;
+    onMouseDown(ev: MouseEvent): void;
+    onDoubleClick(ev: MouseEvent): void;
+    onContextMenu(ev: MouseEvent): void;
+    private getCartesianCoordinates;
+}
+export {};

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

@@ -0,0 +1,20 @@
+import { Component } from "@odoo/owl";
+import { ComponentsImportance } from "../../constants";
+import { Position, Rect, SpreadsheetChildEnv } from "../../types";
+import { ClosedCellPopover, PositionedCellPopover } from "../../types/cell_popovers";
+import { Popover } from "../popover/popover";
+interface Props {
+    hoveredCell: Partial<Position>;
+    gridRect: Rect;
+    onClosePopover: () => void;
+    onMouseWheel: (ev: WheelEvent) => void;
+}
+export declare class GridPopover extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static components: {
+        Popover: typeof Popover;
+    };
+    zIndex: ComponentsImportance;
+    get cellPopover(): PositionedCellPopover | ClosedCellPopover;
+}
+export {};

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

@@ -0,0 +1,41 @@
+import { Component } from "@odoo/owl";
+import { Action } from "../../actions/action";
+import { DOMCoordinates, Dimension, HeaderGroup, Rect } from "../../types";
+import { SpreadsheetChildEnv } from "../../types/env";
+interface Props {
+    group: HeaderGroup;
+    layerOffset: number;
+    openContextMenu(position: DOMCoordinates, menuItems: Action[]): void;
+}
+interface GroupBox {
+    groupRect: Rect;
+    headerRect: Rect;
+    isEndHidden: boolean;
+}
+declare abstract class AbstractHeaderGroup extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    abstract dimension: Dimension;
+    toggleGroup(): void;
+    get groupBoxStyle(): string;
+    abstract get groupBorderStyle(): string;
+    abstract get groupHeaderStyle(): string;
+    get groupButtonStyle(): string;
+    get groupButtonIcon(): string;
+    get isGroupFolded(): boolean;
+    /** The box that will be used to draw the header group. */
+    abstract get groupBox(): GroupBox;
+    onContextMenu(ev: MouseEvent): void;
+}
+export declare class RowGroup extends AbstractHeaderGroup {
+    dimension: Dimension;
+    get groupBorderStyle(): string;
+    get groupHeaderStyle(): string;
+    get groupBox(): GroupBox;
+}
+export declare class ColGroup extends AbstractHeaderGroup {
+    dimension: Dimension;
+    get groupBorderStyle(): string;
+    get groupHeaderStyle(): string;
+    get groupBox(): GroupBox;
+}
+export {};

package/dist/types/components/header_group/header_group_container.d.ts

@@ -0,0 +1,29 @@
+import { Component } from "@odoo/owl";
+import { Action } from "../../actions/action";
+import { DOMCoordinates, SpreadsheetChildEnv } from "../../types";
+import { Dimension, HeaderGroup, Pixel } from "../../types/misc";
+import { Menu, MenuState } from "./../menu/menu";
+import { ColGroup, RowGroup } from "./header_group";
+interface Props {
+    dimension: Dimension;
+    layers: HeaderGroup[][];
+}
+export declare class HeaderGroupContainer extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static components: {
+        RowGroup: typeof RowGroup;
+        ColGroup: typeof ColGroup;
+        Menu: typeof Menu;
+    };
+    menu: MenuState;
+    getLayerOffset(layerIndex: number): number;
+    onContextMenu(event: MouseEvent): void;
+    openContextMenu(position: DOMCoordinates, menuItems: Action[]): void;
+    closeMenu(): void;
+    get groupComponent(): typeof RowGroup;
+    get hasFrozenPane(): boolean;
+    get scrollContainerStyle(): string;
+    get frozenPaneContainerStyle(): string;
+    get frozenPaneContainerSize(): Pixel;
+}
+export {};