@odoo/o-spreadsheet 19.2.0-alpha.4 → 19.3.2

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

@@ -0,0 +1,78 @@
+import { Component } from "@odoo/owl";
+import { Action, MenuItemOrSeparator } from "../../actions/action";
+import { Pixel, Rect } from "../../types";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+export type MenuItemRects = {
+    [menuItemId: string]: Rect;
+};
+export interface MenuProps {
+    menuItems: MenuItemOrSeparator[];
+    onClose: () => void;
+    onScroll?: (ev: CustomEvent) => void;
+    onClickMenu?: (menu: Action, ev: PointerEvent) => void;
+    onMouseEnter?: (menu: Action, ev: PointerEvent) => void;
+    onMouseLeave?: (menu: Action, ev: PointerEvent) => void;
+    hoveredMenuId?: string;
+    isHoveredMenuFocused?: boolean;
+    width?: number;
+    onKeyDown?: (ev: KeyboardEvent) => void;
+}
+export interface MenuState {
+    isOpen: boolean;
+    parentMenu?: Action;
+    scrollOffset?: Pixel;
+    menuItems: Action[];
+    isHoveringChild?: boolean;
+}
+export declare class Menu extends Component<MenuProps, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        menuItems: ArrayConstructor;
+        onClose: FunctionConstructor;
+        onClickMenu: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+        onMouseEnter: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+        onMouseLeave: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+        width: {
+            type: NumberConstructor;
+            optional: boolean;
+        };
+        hoveredMenuId: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        isHoveredMenuFocused: {
+            type: BooleanConstructor;
+            optional: boolean;
+        };
+        onScroll: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+        onKeyDown: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+    };
+    static components: {};
+    static defaultProps: {};
+    private menuRef;
+    setup(): void;
+    get childrenHaveIcon(): boolean;
+    getIconName(menu: Action): string;
+    getColor(menu: Action): string;
+    getIconColor(menu: Action): string;
+    getName(menu: Action): string;
+    isRoot(menu: Action): boolean;
+    isEnabled(menu: Action): boolean;
+    get menuStyle(): string;
+    onClickMenu(menu: Action, ev: PointerEvent): void;
+}

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

@@ -0,0 +1,127 @@
+import { Component } from "@odoo/owl";
+import { Action } from "../../actions/action";
+import { Pixel, Rect, UID } from "../../types";
+import { PopoverPropsPosition } from "../../types/cell_popovers";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+import { Menu, MenuProps } from "../menu/menu";
+import { Popover, PopoverProps } from "../popover/popover";
+interface Props {
+    anchorRect: Rect;
+    popoverPositioning: PopoverPropsPosition;
+    menuItems: Action[];
+    depth: number;
+    maxHeight?: Pixel;
+    onClose: () => void;
+    onMenuClicked?: (ev: CustomEvent) => void;
+    menuId?: UID;
+    onMouseOver?: () => void;
+    width?: number;
+    autoSelectFirstItem?: boolean;
+    disableKeyboardNavigation?: boolean;
+    onKeyboardNavigation?: (ev: KeyboardEvent) => void;
+}
+export interface MenuState {
+    isOpen: boolean;
+    parentMenu?: Action;
+    anchorRect: null | Rect;
+    scrollOffset?: Pixel;
+    menuItems: Action[];
+    isHoveringChild?: boolean;
+    autoSelectFirstItem?: boolean;
+}
+export declare class MenuPopover extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        anchorRect: ObjectConstructor;
+        popoverPositioning: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        menuItems: ArrayConstructor;
+        depth: {
+            type: NumberConstructor;
+            optional: boolean;
+        };
+        maxHeight: {
+            type: NumberConstructor;
+            optional: boolean;
+        };
+        onClose: FunctionConstructor;
+        onMenuClicked: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+        menuId: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        onMouseOver: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+        width: {
+            type: NumberConstructor;
+            optional: boolean;
+        };
+        autoSelectFirstItem: {
+            type: BooleanConstructor;
+            optional: boolean;
+        };
+        disableKeyboardNavigation: {
+            type: BooleanConstructor;
+            optional: boolean;
+        };
+        onKeyboardNavigation: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+    };
+    static components: {
+        MenuPopover: typeof MenuPopover;
+        Menu: typeof Menu;
+        Popover: typeof Popover;
+    };
+    static defaultProps: {
+        depth: number;
+        popoverPositioning: string;
+    };
+    private subMenu;
+    private state;
+    private menuRef;
+    private openingTimeOut;
+    setup(): void;
+    get menuProps(): MenuProps;
+    get subMenuAnchorRect(): Rect;
+    get popoverProps(): PopoverProps;
+    get childrenHaveIcon(): boolean;
+    getIconName(menu: Action): string;
+    getColor(menu: Action): string;
+    getIconColor(menu: Action): string;
+    activateMenu(menu: Action, isMiddleClick?: boolean): Promise<void>;
+    private close;
+    private onExternalClick;
+    get menuItems(): import("../../actions/action").MenuItemOrSeparator[];
+    getName(menu: Action): string;
+    isRoot(menu: Action): boolean;
+    isMenuHovered(menuItem: Action): boolean;
+    onScroll(ev: any): void;
+    /**
+     * If the given menu is not disabled, open it's submenu at the
+     * correct position according to available surrounding space.
+     */
+    private openSubMenu;
+    private isParentMenu;
+    private closeSubMenu;
+    onClickMenu(menu: Action, ev: PointerEvent): Promise<void>;
+    onMenuItemMouseEnter(menu: Action, ev: PointerEvent): void;
+    onMouseOverMainMenu(): void;
+    onMouseOverChildMenu(): void;
+    onMouseLeave(menu: Action): void;
+    get menuStyle(): string;
+    onKeydown(ev: KeyboardEvent): void;
+    private navigateMenu;
+    private getMenuItemRect;
+    getNextEnabledMenuItem(currentHoveredMenu?: Action): Action | undefined;
+    getPreviousEnabledMenuItem(currentHoveredMenu?: Action): Action | undefined;
+}
+export {};

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

@@ -0,0 +1,36 @@
+import { Component } from "@odoo/owl";
+import { Action } from "../../actions/action";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+import { ToolBarDropdownStore } from "../helpers/top_bar_tool_hook";
+import { MenuPopover, MenuState } from "../menu_popover/menu_popover";
+import { TextInput } from "../text_input/text_input";
+interface Props {
+}
+interface State extends Omit<MenuState, "isOpen"> {
+    searchedText?: string;
+}
+export declare class NamedRangeSelector extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {};
+    static components: {
+        TextInput: typeof TextInput;
+        MenuPopover: typeof MenuPopover;
+    };
+    private DOMFocusableElementStore;
+    topBarToolStore: ToolBarDropdownStore;
+    menuState: State;
+    private namedRangeSelectorRef;
+    setup(): void;
+    onInput(value: string): void;
+    changeInputValue(newValue: string): void;
+    get inputValue(): string;
+    get selectedZone(): import("../..").Zone;
+    openDropdown(): void;
+    getNamedRangeMenuItems(): Action[];
+    private stopEditingNamedRange;
+    private navigateToRange;
+    get selectionKey(): string;
+    onInputFocused(): void;
+    onInputBlur(): void;
+}
+export {};

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

@@ -0,0 +1,80 @@
+import { Component } from "@odoo/owl";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+import { Popover, PopoverProps } from "../popover";
+interface State {
+    isOpen: boolean;
+}
+interface Props {
+    currentValue: number;
+    class: string;
+    onValueChange: (fontSize: number) => void;
+    onToggle?: () => void;
+    onFocusInput?: () => void;
+    valueIcon?: String;
+    min: number;
+    max: number;
+    title: String;
+    valueList: number[];
+}
+export declare class NumberEditor extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        currentValue: NumberConstructor;
+        onValueChange: FunctionConstructor;
+        onToggle: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+        onFocusInput: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+        class: StringConstructor;
+        valueIcon: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        min: NumberConstructor;
+        max: NumberConstructor;
+        title: StringConstructor;
+        valueList: {
+            (arrayLength: number): Number[];
+            (...items: Number[]): Number[];
+            new (arrayLength: number): Number[];
+            new (...items: Number[]): Number[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+    };
+    static defaultProps: {
+        onFocusInput: () => void;
+    };
+    static components: {
+        Popover: typeof Popover;
+    };
+    dropdown: State;
+    private inputRef;
+    private rootEditorRef;
+    private valueListRef;
+    private DOMFocusableElementStore;
+    setup(): void;
+    get popoverProps(): PopoverProps;
+    onExternalClick(ev: MouseEvent): void;
+    toggleList(): void;
+    closeList(): void;
+    private setValue;
+    setValueFromInput(ev: InputEvent): void;
+    setValueFromList(valueStr: string): void;
+    get currentValue(): string;
+    onInputFocused(ev: InputEvent): void;
+    onInputKeydown(ev: KeyboardEvent): void;
+}
+export {};

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

@@ -0,0 +1,67 @@
+import { GenericInput, GenericInputProps } from "../generic_input/generic_input";
+interface Props extends GenericInputProps {
+    alwaysShowBorder?: boolean;
+    min?: number;
+    max?: number;
+    value: number;
+}
+export declare class NumberInput extends GenericInput<Props> {
+    static template: string;
+    static components: {};
+    static props: {
+        min: {
+            type: NumberConstructor;
+            optional: boolean;
+        };
+        max: {
+            type: NumberConstructor;
+            optional: boolean;
+        };
+        value: (StringConstructor | NumberConstructor)[];
+        onChange: FunctionConstructor;
+        onFocused: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+        onBlur: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+        onInput: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+        class: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        id: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        placeholder: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        autofocus: {
+            type: BooleanConstructor;
+            optional: boolean;
+        };
+        alwaysShowBorder: {
+            type: BooleanConstructor;
+            optional: boolean;
+        };
+        selectContentOnFocus: {
+            type: BooleanConstructor;
+            optional: boolean;
+        };
+        resetOnBlur: {
+            type: BooleanConstructor;
+            optional: boolean;
+        };
+    };
+    debouncedOnChange: import("../..").DebouncedFunction<(value: string) => void>;
+    save(): void;
+    get inputClass(): string;
+}
+export {};

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

@@ -0,0 +1,20 @@
+import { Component } from "@odoo/owl";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+interface Props {
+    class?: string;
+}
+export declare class PaintFormatButton extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        class: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+    };
+    private paintFormatStore;
+    setup(): void;
+    get isActive(): boolean;
+    onDblClick(): void;
+    togglePaintFormat(): void;
+}
+export {};

package/dist/types/components/paint_format_button/paint_format_store.d.ts

@@ -0,0 +1,22 @@
+import { Get } from "../../store_engine";
+import { SpreadsheetStore } from "../../stores";
+import { HighlightStore } from "../../stores/highlight_store";
+import { Command, Highlight, Zone } from "../../types";
+export declare class PaintFormatStore extends SpreadsheetStore {
+    mutators: readonly ["activate", "cancel", "pasteFormat"];
+    protected highlightStore: import("../../store_engine").CQS<Pick<HighlightStore, "register" | "unRegister"> & import("../../store_engine").OmitFunctions<HighlightStore>>;
+    private status;
+    private copiedData?;
+    constructor(get: Get);
+    protected handle(cmd: Command): void;
+    activate(args: {
+        persistent: boolean;
+    }): void;
+    cancel(): void;
+    pasteFormat(target: Zone[]): void;
+    get isActive(): boolean;
+    private get clipboardHandlers();
+    private copyFormats;
+    private paintFormat;
+    get highlights(): Highlight[];
+}

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

@@ -0,0 +1,88 @@
+import { Component } from "@odoo/owl";
+import { SpreadsheetPivotTable, UID } from "../..";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+import { Checkbox } from "../side_panel/components/checkbox/checkbox";
+interface PivotDialogColumn {
+    formula: string;
+    value: string;
+    isMissing: boolean;
+    style?: string;
+    span: number;
+}
+interface PivotDialogRow {
+    formula: string;
+    value: string;
+    isMissing: boolean;
+    style?: string;
+}
+interface PivotDialogValue {
+    formula: string;
+    value: string;
+    isMissing: boolean;
+}
+interface Props {
+    pivotId: UID;
+    onCellClicked: (formula: string) => void;
+}
+interface TableData {
+    columns: PivotDialogColumn[][];
+    rows: PivotDialogRow[];
+    values: PivotDialogValue[][];
+}
+export declare class PivotHTMLRenderer extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static components: {
+        Checkbox: typeof Checkbox;
+    };
+    static props: {
+        pivotId: StringConstructor;
+        onCellClicked: FunctionConstructor;
+    };
+    private pivot;
+    data: TableData;
+    private state;
+    setup(): void;
+    get tracker(): import("../../helpers/pivot/pivot_presence_tracker").PivotPresenceTracker | undefined;
+    /**
+     * Retrieve the data to display in the Pivot Table
+     * In the case when showMissingValuesOnly is false, the returned value
+     * is the complete data
+     * In the case when showMissingValuesOnly is true, the returned value is
+     * the data which contains only missing values in the rows and cols. In
+     * the rows, we also return the parent rows of rows which contains missing
+     * values, to give context to the user.
+     *
+     */
+    getTableData(): TableData;
+    /**
+     * Retrieve the parents of the given row
+     * ex:
+     *  Australia
+     *    January
+     *    February
+     * The parent of "January" is "Australia"
+     */
+    private addRecursiveRow;
+    /**
+     * Create the columns to be used, based on the indexes of the columns in
+     * which a missing value is present
+     *
+     */
+    private buildColumnsMissing;
+    /**
+     * Create the rows to be used, based on the indexes of the rows in
+     * which a missing value is present.
+     */
+    private buildRowsMissing;
+    /**
+     * Create the value to be used, based on the indexes of the columns and
+     * rows in which a missing value is present.
+     */
+    private buildValuesMissing;
+    private getColumnsIndexes;
+    private getRowsIndexes;
+    _buildColHeaders(id: UID, table: SpreadsheetPivotTable): PivotDialogColumn[][];
+    _buildRowHeaders(id: UID, table: SpreadsheetPivotTable): PivotDialogRow[];
+    _buildValues(id: UID, table: SpreadsheetPivotTable): PivotDialogValue[][];
+}
+export {};

package/dist/types/components/popover/cell_popover_store.d.ts

@@ -0,0 +1,16 @@
+import { SpreadsheetStore } from "../../stores";
+import { Command, Position } from "../../types";
+import { CellPopoverType, ClosedCellPopover, OpenCellPopover, PositionedCellPopoverComponent } from "../../types/cell_popovers";
+import { DelayedHoveredCellStore } from "../grid/delayed_hovered_cell_store";
+export declare class CellPopoverStore extends SpreadsheetStore {
+    mutators: readonly ["open", "close"];
+    private persistentPopover?;
+    protected hoveredCell: import("../../store_engine").CQS<Pick<DelayedHoveredCellStore, "clear" | "hover"> & import("../../store_engine").OmitFunctions<DelayedHoveredCellStore>>;
+    handle(cmd: Command): void;
+    open({ col, row }: Position, type: CellPopoverType): void;
+    close(): "noStateChange" | undefined;
+    get persistentCellPopover(): OpenCellPopover | ClosedCellPopover;
+    get isOpen(): boolean;
+    get cellPopover(): ClosedCellPopover | PositionedCellPopoverComponent;
+    private computePopoverAnchorRect;
+}

package/dist/types/components/popover/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./cell_popover_store";
+export * from "./popover";
+import "./popover_builders";

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

@@ -0,0 +1,83 @@
+import { Component } from "@odoo/owl";
+import { Pixel, Rect } from "../../types";
+import { PopoverPropsPosition } from "../../types/cell_popovers";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+export interface PopoverProps {
+    /**
+     * Rectangle around which the popover is displayed.
+     * Coordinates are expressed as absolute DOM position.
+     */
+    anchorRect: Rect;
+    /** The popover can be positioned below the anchor Rectangle, or to the right of the rectangle */
+    positioning: PopoverPropsPosition;
+    maxWidth?: Pixel;
+    maxHeight?: Pixel;
+    /** Offset to apply to the vertical position of the popover.*/
+    verticalOffset: number;
+    onMouseWheel?: () => void;
+    onPopoverMoved?: () => void;
+    onPopoverHidden?: () => void;
+    class?: string;
+}
+export declare class Popover extends Component<PopoverProps, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        anchorRect: ObjectConstructor;
+        containerRect: {
+            type: ObjectConstructor;
+            optional: boolean;
+        };
+        positioning: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        maxWidth: {
+            type: NumberConstructor;
+            optional: boolean;
+        };
+        maxHeight: {
+            type: NumberConstructor;
+            optional: boolean;
+        };
+        verticalOffset: {
+            type: NumberConstructor;
+            optional: boolean;
+        };
+        onMouseWheel: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+        onPopoverHidden: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+        onPopoverMoved: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+        zIndex: {
+            type: NumberConstructor;
+            optional: boolean;
+        };
+        class: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        slots: ObjectConstructor;
+    };
+    static defaultProps: {
+        positioning: string;
+        verticalOffset: number;
+        onMouseWheel: () => void;
+        onPopoverMoved: () => void;
+        onPopoverHidden: () => void;
+    };
+    private popoverRef;
+    private popoverContentRef;
+    private currentPosition;
+    private currentDisplayValue;
+    private spreadsheetRect;
+    private containerRect;
+    setup(): void;
+    private computePopoverPosition;
+}

package/dist/types/components/popover/popover_builders.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/components/scrollbar/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./scrollbar_horizontal";
+export * from "./scrollbar_vertical";

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

@@ -0,0 +1,39 @@
+import { Component } from "@odoo/owl";
+import { CSSProperties, Pixel } from "../../types";
+import { ScrollDirection } from "../../types/scroll_direction";
+interface Props {
+    width: Pixel;
+    height: Pixel;
+    direction: ScrollDirection;
+    position: CSSProperties;
+    offset: Pixel;
+    onScroll: (offset: Pixel) => void;
+}
+export declare class ScrollBar extends Component<Props> {
+    static props: {
+        width: {
+            type: NumberConstructor;
+            optional: boolean;
+        };
+        height: {
+            type: NumberConstructor;
+            optional: boolean;
+        };
+        direction: StringConstructor;
+        position: ObjectConstructor;
+        offset: NumberConstructor;
+        onScroll: FunctionConstructor;
+    };
+    static template: string;
+    static defaultProps: {
+        width: number;
+        height: number;
+    };
+    private scrollbarRef;
+    private scrollbar;
+    setup(): void;
+    get sizeCss(): string;
+    get positionCss(): string;
+    onScroll(ev: any): void;
+}
+export {};