@odoo/o-spreadsheet 17.0.84 → 17.0.96

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

@@ -0,0 +1,117 @@
+import { Component } from "@odoo/owl";
+import { EdgeScrollInfo, HeaderDimensions, HeaderIndex, Pixel, SpreadsheetChildEnv } from "../../types/index";
+import { ContextMenuType } from "../grid/grid";
+interface ResizerState {
+    resizerIsActive: boolean;
+    isResizing: boolean;
+    isMoving: boolean;
+    isSelecting: boolean;
+    waitingForMove: boolean;
+    activeElement: Pixel;
+    draggerLinePosition: Pixel;
+    draggerShadowPosition: Pixel;
+    draggerShadowThickness: number;
+    delta: number;
+    base: number;
+    position: "before" | "after";
+}
+interface ResizerProps {
+    onOpenContextMenu: (type: ContextMenuType, x: Pixel, y: Pixel) => void;
+}
+declare abstract class AbstractResizer extends Component<ResizerProps, SpreadsheetChildEnv> {
+    PADDING: number;
+    MAX_SIZE_MARGIN: number;
+    MIN_ELEMENT_SIZE: number;
+    lastSelectedElementIndex: HeaderIndex | null;
+    state: ResizerState;
+    abstract _getEvOffset(ev: MouseEvent): Pixel;
+    abstract _getViewportOffset(): Pixel;
+    abstract _getClientPosition(ev: MouseEvent): Pixel;
+    abstract _getElementIndex(position: Pixel): HeaderIndex;
+    abstract _getSelectedZoneStart(): HeaderIndex;
+    abstract _getSelectedZoneEnd(): HeaderIndex;
+    abstract _getEdgeScroll(position: Pixel): EdgeScrollInfo;
+    abstract _getDimensionsInViewport(index: HeaderIndex): HeaderDimensions;
+    abstract _getElementSize(index: HeaderIndex): Pixel;
+    abstract _getMaxSize(): Pixel;
+    abstract _updateSize(): void;
+    abstract _moveElements(): void;
+    abstract _selectElement(index: HeaderIndex, addDistinctHeader: boolean): void;
+    abstract _increaseSelection(index: HeaderIndex): void;
+    abstract _fitElementSize(index: HeaderIndex): void;
+    abstract _getType(): ContextMenuType;
+    abstract _getActiveElements(): Set<HeaderIndex>;
+    abstract _getPreviousVisibleElement(index: HeaderIndex): HeaderIndex;
+    _computeHandleDisplay(ev: MouseEvent): void;
+    _computeGrabDisplay(ev: MouseEvent): void;
+    onMouseMove(ev: MouseEvent): void;
+    onMouseLeave(): void;
+    onDblClick(ev: MouseEvent): void;
+    onMouseDown(ev: MouseEvent): void;
+    select(ev: MouseEvent): void;
+    private startMovement;
+    private startSelection;
+    onMouseUp(ev: MouseEvent): void;
+    onContextMenu(ev: MouseEvent): void;
+}
+export declare class ColResizer extends AbstractResizer {
+    static template: string;
+    private colResizerRef;
+    setup(): void;
+    get sheetId(): import("../../types/misc").UID;
+    _getEvOffset(ev: MouseEvent): Pixel;
+    _getViewportOffset(): Pixel;
+    _getClientPosition(ev: MouseEvent): Pixel;
+    _getElementIndex(position: Pixel): HeaderIndex;
+    _getSelectedZoneStart(): HeaderIndex;
+    _getSelectedZoneEnd(): HeaderIndex;
+    _getEdgeScroll(position: Pixel): EdgeScrollInfo;
+    _getDimensionsInViewport(index: HeaderIndex): HeaderDimensions;
+    _getElementSize(index: HeaderIndex): Pixel;
+    _getMaxSize(): Pixel;
+    _updateSize(): void;
+    _moveElements(): void;
+    _selectElement(index: HeaderIndex, addDistinctHeader: boolean): void;
+    _increaseSelection(index: HeaderIndex): void;
+    _fitElementSize(index: HeaderIndex): void;
+    _getType(): ContextMenuType;
+    _getActiveElements(): Set<HeaderIndex>;
+    _getPreviousVisibleElement(index: HeaderIndex): HeaderIndex;
+    unhide(hiddenElements: HeaderIndex[]): void;
+    unhideStyleValue(hiddenIndex: HeaderIndex): Pixel;
+}
+export declare class RowResizer extends AbstractResizer {
+    static template: string;
+    setup(): void;
+    private rowResizerRef;
+    get sheetId(): import("../../types/misc").UID;
+    _getEvOffset(ev: MouseEvent): Pixel;
+    _getViewportOffset(): Pixel;
+    _getClientPosition(ev: MouseEvent): Pixel;
+    _getElementIndex(position: Pixel): HeaderIndex;
+    _getSelectedZoneStart(): HeaderIndex;
+    _getSelectedZoneEnd(): HeaderIndex;
+    _getEdgeScroll(position: Pixel): EdgeScrollInfo;
+    _getDimensionsInViewport(index: HeaderIndex): HeaderDimensions;
+    _getElementSize(index: HeaderIndex): Pixel;
+    _getMaxSize(): Pixel;
+    _updateSize(): void;
+    _moveElements(): void;
+    _selectElement(index: HeaderIndex, addDistinctHeader: boolean): void;
+    _increaseSelection(index: HeaderIndex): void;
+    _fitElementSize(index: HeaderIndex): void;
+    _getType(): ContextMenuType;
+    _getActiveElements(): Set<HeaderIndex>;
+    _getPreviousVisibleElement(index: HeaderIndex): HeaderIndex;
+    unhide(hiddenElements: HeaderIndex[]): void;
+    unhideStyleValue(hiddenIndex: HeaderIndex): Pixel;
+}
+export declare class HeadersOverlay extends Component<any, SpreadsheetChildEnv> {
+    static template: string;
+    static components: {
+        ColResizer: typeof ColResizer;
+        RowResizer: typeof RowResizer;
+    };
+    selectAll(): void;
+}
+export {};

package/dist/types/components/helpers/css.d.ts

@@ -0,0 +1,40 @@
+/**
+ * This file is largely inspired by owl 1.
+ * `css` tag has been removed from owl 2 without workaround to manage css.
+ * So, the solution was to import the behavior of owl 1 directly in our
+ * codebase, with one difference: the css is added to the sheet as soon as the
+ * css tag is executed. In owl 1, the css was added as soon as a Component was
+ * created for the first time.
+ */
+import { CSSProperties, Style } from "../../types";
+/**
+ * CSS tag helper for defining inline stylesheets.  With this, one can simply define
+ * an inline stylesheet with just the following code:
+ * ```js
+ *     css`.component-a { color: red; }`;
+ * ```
+ */
+export declare function css(strings: any, ...args: any[]): string;
+export declare function processSheet(str: string): string;
+export declare function getTextDecoration({ strikethrough, underline, }: {
+    strikethrough?: boolean;
+    underline?: boolean;
+}): string;
+/**
+ * Convert the cell style to CSS properties.
+ */
+export declare function cellStyleToCss(style: Style | undefined): CSSProperties;
+/**
+ * Convert the cell text style to CSS properties.
+ */
+export declare function cellTextStyleToCss(style: Style | undefined): CSSProperties;
+/**
+ * Transform CSS properties into a CSS string.
+ */
+export declare function cssPropertiesToCss(attributes: CSSProperties): string;
+export declare function getElementMargins(el: Element): {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+};

package/dist/types/components/helpers/dom_helpers.d.ts

@@ -0,0 +1,34 @@
+import { Rect } from "./../../types/rendering";
+/**
+ * Return true if the event was triggered from
+ * a child element.
+ */
+export declare function isChildEvent(parent: HTMLElement, ev: Event): boolean;
+export declare function gridOverlayPosition(): {
+    top: number;
+    left: number;
+};
+export declare function getBoundingRectAsPOJO(el: Element): Rect;
+/**
+ * Iterate over all the children of `el` in the dom tree starting at `el`, depth first.
+ */
+export declare function iterateChildren(el: Node): Generator<Node>;
+export declare function getOpenedMenus(): HTMLElement[];
+/**
+ * Transform a keyboard event into a shortcut string that represent this event. The letters keys will be uppercased.
+ *
+ * @argument ev - The keyboard event to transform
+ * @argument mode - Use either ev.key of ev.code to get the string shortcut
+ *
+ * @example
+ * event : { ctrlKey: true, key: "a" } => "Ctrl+A"
+ * event : { shift: true, alt: true, key: "Home" } => "Alt+Shift+Home"
+ */
+export declare function keyboardEventToShortcutString(ev: KeyboardEvent, mode?: "key" | "code"): string;
+export declare function isMacOS(): boolean;
+/**
+ * @param {KeyboardEvent | MouseEvent} ev
+ * @returns Returns true if the event was triggered with the "ctrl" modifier pressed.
+ * On Mac, this is the "meta" or "command" key.
+ */
+export declare function isCtrlKey(ev: KeyboardEvent | MouseEvent): boolean;

package/dist/types/components/helpers/drag_and_drop.d.ts

@@ -0,0 +1,20 @@
+import { SpreadsheetChildEnv } from "../../types/env";
+import { HeaderIndex } from "../../types/misc";
+type EventFn = (ev: MouseEvent) => void;
+/**
+ * Start listening to pointer events and apply the given callbacks.
+ *
+ * @returns A function to remove the listeners.
+ */
+export declare function startDnd(onMouseMove: EventFn, onMouseUp: EventFn, onMouseDown?: EventFn): () => void;
+/**
+ * Function to be used during a mousedown event, this function allows to
+ * perform actions related to the mousemove and mouseup events and adjusts the viewport
+ * when the new position related to the mousemove event is outside of it.
+ * Among inputs are two callback functions. First intended for actions performed during
+ * the mousemove event, it receives as parameters the current position of the mousemove
+ * (occurrence of the current column and the current row). Second intended for actions
+ * performed during the mouseup event.
+ */
+export declare function dragAndDropBeyondTheViewport(env: SpreadsheetChildEnv, cbMouseMove: (col: HeaderIndex, row: HeaderIndex, ev: MouseEvent) => void, cbMouseUp: () => void, only?: "horizontal" | "vertical" | false): void;
+export {};

package/dist/types/components/helpers/drag_and_drop_hook.d.ts

@@ -0,0 +1,24 @@
+import { Pixel, UID } from "../../types";
+type Direction = "horizontal" | "vertical";
+interface DragAndDropItemsPartial {
+    id: UID;
+    size: Pixel;
+    position: Pixel;
+}
+interface DndPartialArgs {
+    draggedItemId: UID;
+    initialMousePosition: Pixel;
+    items: DragAndDropItemsPartial[];
+    containerEl: HTMLElement;
+    onChange?: () => void;
+    onCancel?: () => void;
+    onDragEnd?: (itemId: UID, indexAtEnd: Pixel) => void;
+}
+interface State {
+    itemsStyle: Record<UID, string>;
+    draggedItemId: UID | undefined;
+    start: (direction: Direction, args: DndPartialArgs) => void;
+    cancel: () => void;
+}
+export declare function useDragAndDropListItems(): State;
+export {};

package/dist/types/components/helpers/draw_grid_hook.d.ts

@@ -0,0 +1,3 @@
+import { Model } from "../..";
+import { DOMDimension } from "../../types";
+export declare function useGridDrawing(refName: string, model: Model, canvasSize: () => DOMDimension): void;

package/dist/types/components/helpers/figure_container_helper.d.ts

@@ -0,0 +1,14 @@
+import { Figure, Getters } from "../../types";
+/**
+ * Transform a figure with coordinates from the model, to coordinates as they are shown on the screen,
+ * taking into account the scroll position of the active sheet and the frozen panes.
+ */
+export declare function internalFigureToScreen(getters: Getters, fig: Figure): Figure;
+/**
+ * Transform a figure with coordinates as they are shown on the screen, to coordinates as they are in the model,
+ * taking into account the scroll position of the active sheet and the frozen panes.
+ *
+ * Note that this isn't  exactly the reverse operation as internalFigureToScreen, because the figure will always be on top
+ * of the frozen panes.
+ */
+export declare function screenFigureToInternal(getters: Getters, fig: Figure): Figure;

package/dist/types/components/helpers/figure_drag_helper.d.ts

@@ -0,0 +1,6 @@
+import { Figure, PixelPosition, SheetScrollInfo } from "../../types";
+export declare function dragFigureForMove({ x: mouseX, y: mouseY }: PixelPosition, { x: mouseInitialX, y: mouseInitialY }: PixelPosition, initialFigure: Figure, { x: viewportX, y: viewportY }: PixelPosition, { maxX, maxY }: {
+    maxX: number;
+    maxY: number;
+}, { scrollX, scrollY }: SheetScrollInfo): Figure;
+export declare function dragFigureForResize(initialFigure: Figure, dirX: -1 | 0 | 1, dirY: -1 | 0 | 1, { x: mouseX, y: mouseY }: PixelPosition, { x: mouseInitialX, y: mouseInitialY }: PixelPosition, keepRatio: boolean, minFigSize: number, { scrollX, scrollY }: SheetScrollInfo): Figure;

package/dist/types/components/helpers/figure_snap_helper.d.ts

@@ -0,0 +1,25 @@
+import { Figure, Getters, Pixel, UID } from "../../types";
+export type HFigureAxisType = "top" | "bottom" | "vCenter";
+export type VFigureAxisType = "right" | "left" | "hCenter";
+export interface SnapLine<T extends HFigureAxisType | VFigureAxisType> {
+    matchedFigIds: UID[];
+    snapOffset: number;
+    snappedAxisType: T;
+    position: Pixel;
+}
+interface SnapReturn {
+    snappedFigure: Figure;
+    verticalSnapLine?: SnapLine<VFigureAxisType>;
+    horizontalSnapLine?: SnapLine<HFigureAxisType>;
+}
+/**
+ * Try to snap the given figure to other figures when moving the figure, and return the snapped
+ * figure and the possible snap lines, if any were found
+ */
+export declare function snapForMove(getters: Getters, figureToSnap: Figure, otherFigures: Figure[]): SnapReturn;
+/**
+ * Try to snap the given figure to the other figures when resizing the figure, and return the snapped
+ * figure and the possible snap lines, if any were found
+ */
+export declare function snapForResize(getters: Getters, resizeDirX: -1 | 0 | 1, resizeDirY: -1 | 0 | 1, figureToSnap: Figure, otherFigures: Figure[]): SnapReturn;
+export {};

package/dist/types/components/helpers/html_content_helpers.d.ts

@@ -0,0 +1,2 @@
+import { HtmlContent } from "../composer/composer/composer";
+export declare function getHtmlContentFromPattern(pattern: string, value: string, highlightColor: string, className: string): HtmlContent[];

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

@@ -0,0 +1 @@
+export * from "./css";

package/dist/types/components/helpers/listener_hook.d.ts

@@ -0,0 +1,10 @@
+import { Ref } from "../../types";
+/**
+ * Manages an event listener on a ref. Useful for hooks that want to manage
+ * event listeners, especially more than one. Prefer using t-on directly in
+ * components. If your hook only needs a single event listener, consider simply
+ * returning it from the hook and letting the user attach it with t-on.
+ *
+ * Adapted from Odoo Community - See https://github.com/odoo/odoo/blob/saas-16.2/addons/web/static/src/core/utils/hooks.js
+ */
+export declare function useRefListener(ref: Ref<HTMLElement>, ...listener: Parameters<typeof addEventListener>): void;

package/dist/types/components/helpers/position_hook.d.ts

@@ -0,0 +1,25 @@
+import { useRef } from "@odoo/owl";
+import { Rect } from "../../types";
+type Ref = ReturnType<typeof useRef>;
+/**
+ * Return the o-spreadsheet element position relative
+ * to the browser viewport.
+ */
+export declare function useSpreadsheetRect(): Rect;
+/**
+ * Return the component (or ref's component) BoundingRect, relative
+ * to the upper left corner of the screen (<body> element).
+ *
+ * Note: when used with a <Portal/> component, it will
+ * return the portal position, not the teleported position.
+ */
+export declare function useAbsoluteBoundingRect(ref: Ref): Rect;
+/**
+ * Get the rectangle inside which a popover should stay when being displayed.
+ * It's the value defined in `env.getPopoverContainerRect`, or the Rect of the "o-spreadsheet"
+ * element by default.
+ *
+ * Coordinates are expressed expressed as absolute DOM position.
+ */
+export declare function usePopoverContainer(): Rect;
+export {};

package/dist/types/components/helpers/selection_helpers.d.ts

@@ -0,0 +1,2 @@
+import { SelectionStreamProcessor } from "../../selection_stream/selection_stream_processor";
+export declare function updateSelectionWithArrowKeys(ev: KeyboardEvent, selection: SelectionStreamProcessor): void;

package/dist/types/components/helpers/time_hooks.d.ts

@@ -0,0 +1,9 @@
+interface IntervalTimer {
+    pause: () => void;
+    resume: () => void;
+}
+/**
+ * Repeatedly calls a callback function with a time delay between calls.
+ */
+export declare function useInterval(callback: () => void, delay: number): IntervalTimer;
+export {};

package/dist/types/components/helpers/wheel_hook.d.ts

@@ -0,0 +1 @@
+export declare function useWheelHandler(handler: (deltaX: number, deltaY: number) => void): (ev: WheelEvent) => void;

package/dist/types/components/highlight/border/border.d.ts

@@ -0,0 +1,15 @@
+import { Component } from "@odoo/owl";
+import { Pixel, SpreadsheetChildEnv, Zone } from "../../../types";
+type Orientation = "n" | "s" | "w" | "e";
+interface Props {
+    zone: Zone;
+    orientation: Orientation;
+    isMoving: boolean;
+    onMoveHighlight: (x: Pixel, y: Pixel) => void;
+}
+export declare class Border extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    get style(): string;
+    onMouseDown(ev: MouseEvent): void;
+}
+export {};

package/dist/types/components/highlight/corner/corner.d.ts

@@ -0,0 +1,18 @@
+import { Component } from "@odoo/owl";
+import { Color, SpreadsheetChildEnv, Zone } from "../../../types";
+type Orientation = "nw" | "ne" | "sw" | "se";
+interface Props {
+    zone: Zone;
+    color: Color;
+    orientation: Orientation;
+    isResizing: boolean;
+    onResizeHighlight: (isLeft: boolean, isRight: boolean) => void;
+}
+export declare class Corner extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    private isTop;
+    private isLeft;
+    get style(): string;
+    onMouseDown(ev: MouseEvent): void;
+}
+export {};

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

@@ -0,0 +1,22 @@
+import { Component } from "@odoo/owl";
+import { Color, Pixel, SpreadsheetChildEnv, Zone } from "../../../types";
+import { Border } from "../border/border";
+import { Corner } from "../corner/corner";
+interface Props {
+    zone: Zone;
+    color: Color;
+}
+interface HighlightState {
+    shiftingMode: "isMoving" | "isResizing" | "none";
+}
+export declare class Highlight extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static components: {
+        Corner: typeof Corner;
+        Border: typeof Border;
+    };
+    highlightState: HighlightState;
+    onResizeHighlight(isLeft: boolean, isTop: boolean): void;
+    onMoveHighlight(clientX: Pixel, clientY: Pixel): void;
+}
+export {};

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

@@ -0,0 +1,65 @@
+import { Component } from "@odoo/owl";
+import { SpreadsheetChildEnv } from "../../types/env";
+interface Props {
+    onIconPicked: (icon: string) => void;
+}
+export declare class IconPicker extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    icons: {
+        arrowGood: {
+            template: string;
+            img: HTMLImageElement;
+        };
+        arrowNeutral: {
+            template: string;
+            img: HTMLImageElement;
+        };
+        arrowBad: {
+            template: string;
+            img: HTMLImageElement;
+        };
+        smileyGood: {
+            template: string;
+            img: HTMLImageElement;
+        };
+        smileyNeutral: {
+            template: string;
+            img: HTMLImageElement;
+        };
+        smileyBad: {
+            template: string;
+            img: HTMLImageElement;
+        };
+        dotGood: {
+            template: string;
+            img: HTMLImageElement;
+        };
+        dotNeutral: {
+            template: string;
+            img: HTMLImageElement;
+        };
+        dotBad: {
+            template: string;
+            img: HTMLImageElement;
+        };
+    };
+    iconSets: {
+        arrows: {
+            good: string;
+            neutral: string;
+            bad: string;
+        };
+        smiley: {
+            good: string;
+            neutral: string;
+            bad: string;
+        };
+        dots: {
+            good: string;
+            neutral: string;
+            bad: string;
+        };
+    };
+    onIconClick(icon: string): void;
+}
+export {};

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

@@ -0,0 +1,56 @@
+export type IconSetType = keyof typeof ICON_SETS;
+export declare const ICONS: {
+    arrowGood: {
+        template: string;
+        img: HTMLImageElement;
+    };
+    arrowNeutral: {
+        template: string;
+        img: HTMLImageElement;
+    };
+    arrowBad: {
+        template: string;
+        img: HTMLImageElement;
+    };
+    smileyGood: {
+        template: string;
+        img: HTMLImageElement;
+    };
+    smileyNeutral: {
+        template: string;
+        img: HTMLImageElement;
+    };
+    smileyBad: {
+        template: string;
+        img: HTMLImageElement;
+    };
+    dotGood: {
+        template: string;
+        img: HTMLImageElement;
+    };
+    dotNeutral: {
+        template: string;
+        img: HTMLImageElement;
+    };
+    dotBad: {
+        template: string;
+        img: HTMLImageElement;
+    };
+};
+export declare const ICON_SETS: {
+    arrows: {
+        good: string;
+        neutral: string;
+        bad: string;
+    };
+    smiley: {
+        good: string;
+        neutral: string;
+        bad: string;
+    };
+    dots: {
+        good: string;
+        neutral: string;
+        bad: string;
+    };
+};

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

@@ -0,0 +1 @@
+export { Spreadsheet } from "./spreadsheet/spreadsheet";

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

@@ -0,0 +1,2 @@
+export * from "./link_display/link_display";
+export * from "./link_editor/link_editor";

package/dist/types/components/link/link_display/link_display.d.ts

@@ -0,0 +1,21 @@
+import { Component } from "@odoo/owl";
+import { EvaluatedCell, Link, Position, SpreadsheetChildEnv } from "../../../types";
+import { PopoverBuilders } from "../../../types/cell_popovers";
+import { Menu } from "../../menu/menu";
+interface LinkDisplayProps {
+    cellPosition: Position;
+}
+export declare class LinkDisplay extends Component<LinkDisplayProps, SpreadsheetChildEnv> {
+    static components: {
+        Menu: typeof Menu;
+    };
+    static template: string;
+    get cell(): EvaluatedCell;
+    get link(): Link;
+    getUrlRepresentation(link: Link): string;
+    openLink(): void;
+    edit(): void;
+    unlink(): void;
+}
+export declare const LinkCellPopoverBuilder: PopoverBuilders;
+export {};

package/dist/types/components/link/link_editor/link_editor.d.ts

@@ -0,0 +1,39 @@
+import { Component } from "@odoo/owl";
+import { DOMCoordinates, Link, Position, SpreadsheetChildEnv } from "../../../types";
+import { PopoverBuilders } from "../../../types/cell_popovers";
+import { Menu } from "../../menu/menu";
+interface LinkEditorProps {
+    cellPosition: Position;
+    onClosed?: () => void;
+}
+interface State {
+    label: string;
+    url: string;
+    isUrlEditable: boolean;
+}
+export declare class LinkEditor extends Component<LinkEditorProps, SpreadsheetChildEnv> {
+    static template: string;
+    static components: {
+        Menu: typeof Menu;
+    };
+    menuItems: import("../../../actions/action").Action[];
+    private link;
+    private menu;
+    private linkEditorRef;
+    private position;
+    urlInput: {
+        el: HTMLElement | null;
+    };
+    setup(): void;
+    get defaultState(): State;
+    get menuPosition(): DOMCoordinates;
+    onSpecialLink(ev: CustomEvent<string>): void;
+    getUrlRepresentation(link: Link): string;
+    openMenu(): void;
+    removeLink(): void;
+    save(): void;
+    cancel(): void;
+    onKeyDown(ev: KeyboardEvent): void;
+}
+export declare const LinkEditorPopoverBuilder: PopoverBuilders;
+export {};

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

@@ -0,0 +1,58 @@
+import { Component } from "@odoo/owl";
+import { Action } from "../../actions/action";
+import { DOMCoordinates, Pixel, SpreadsheetChildEnv, UID } from "../../types";
+import { Popover, PopoverProps } from "../popover/popover";
+type MenuItemOrSeparator = Action | "separator";
+interface Props {
+    position: DOMCoordinates;
+    menuItems: Action[];
+    depth: number;
+    maxHeight?: Pixel;
+    onClose: () => void;
+    onMenuClicked?: (ev: CustomEvent) => void;
+    menuId?: UID;
+}
+export interface MenuState {
+    isOpen: boolean;
+    parentMenu?: Action;
+    position: null | DOMCoordinates;
+    scrollOffset?: Pixel;
+    menuItems: Action[];
+}
+export declare class Menu extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static components: {
+        Menu: typeof Menu;
+        Popover: typeof Popover;
+    };
+    static defaultProps: {
+        depth: number;
+    };
+    private subMenu;
+    private menuRef;
+    private position;
+    setup(): void;
+    get menuItemsAndSeparators(): MenuItemOrSeparator[];
+    get subMenuPosition(): DOMCoordinates;
+    get popoverProps(): PopoverProps;
+    get childrenHaveIcon(): boolean;
+    getIconName(menu: Action): string;
+    getColor(menu: Action): string | undefined;
+    activateMenu(menu: Action): Promise<void>;
+    private close;
+    private onExternalClick;
+    getName(menu: Action): string;
+    isRoot(menu: Action): boolean;
+    isEnabled(menu: 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.
+     */
+    openSubMenu(menu: Action, menuIndex: number, ev: MouseEvent): void;
+    isParentMenu(subMenu: MenuState, menuItem: Action): boolean;
+    closeSubMenu(): void;
+    onClickMenu(menu: Action, menuIndex: number, ev: MouseEvent): void;
+    onMouseOver(menu: Action, position: Pixel, ev: MouseEvent): void;
+}
+export {};