@odoo/o-spreadsheet 18.0.55 → 18.0.68

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

@@ -0,0 +1,105 @@
+import { Component } from "@odoo/owl";
+import { Store } from "../../store_engine";
+import { Client, DOMCoordinates, DOMDimension, GridClickModifiers, HeaderIndex, Pixel, SpreadsheetChildEnv, Table } from "../../types/index";
+import { Autofill } from "../autofill/autofill";
+import { ClientTag } from "../collaborative_client_tag/collaborative_client_tag";
+import { ComposerSelection } from "../composer/composer/abstract_composer_store";
+import { GridComposer } from "../composer/grid_composer/grid_composer";
+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 { SidePanelStore } from "../side_panel/side_panel/side_panel_store";
+import { TableResizer } from "../tables/table_resizer/table_resizer";
+import { HoveredCellStore } from "./hovered_cell_store";
+/**
+ * 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 {
+    exposeFocus: (focus: () => void) => void;
+}
+export declare class Grid extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        exposeFocus: FunctionConstructor;
+    };
+    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;
+        TableResizer: typeof TableResizer;
+    };
+    readonly HEADER_HEIGHT = 26;
+    readonly HEADER_WIDTH = 48;
+    private menuState;
+    private gridRef;
+    private highlightStore;
+    private cellPopovers;
+    private composerFocusStore;
+    private DOMFocusableElementStore;
+    private paintFormatStore;
+    onMouseWheel: (ev: WheelEvent) => void;
+    canvasPosition: DOMCoordinates;
+    hoveredCell: Store<HoveredCellStore>;
+    sidePanel: Store<SidePanelStore>;
+    setup(): void;
+    onCellHovered({ col, row }: {
+        col: any;
+        row: any;
+    }): void;
+    get highlights(): import("../..").Highlight[];
+    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, modifiers: GridClickModifiers): void;
+    onCellDoubleClicked(col: HeaderIndex, row: HeaderIndex): 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): Promise<void>;
+    paste(ev: ClipboardEvent): Promise<void>;
+    private clearFormatting;
+    private setHorizontalAlign;
+    closeMenu(): void;
+    private processHeaderGroupingKey;
+    private processHeaderGroupingEventOnHeaders;
+    private processHeaderGroupingEventOnWholeSheet;
+    private processHeaderGroupingEventOnGrid;
+    onComposerCellFocused(content?: string, selection?: ComposerSelection): void;
+    onComposerContentFocused(): void;
+    get staticTables(): Table[];
+}
+export {};

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

@@ -0,0 +1,10 @@
+import { SpreadsheetStore } from "../../stores";
+import { Command, Position } from "../../types";
+export declare class HoveredCellStore extends SpreadsheetStore {
+    mutators: readonly ["clear", "hover"];
+    col: number | undefined;
+    row: number | undefined;
+    handle(cmd: Command): void;
+    hover(position: Position): "noStateChange" | undefined;
+    clear(): "noStateChange" | undefined;
+}

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

@@ -0,0 +1,29 @@
+import { Component } from "@odoo/owl";
+import { SpreadsheetChildEnv } from "../../types";
+import { ValidationMessages } from "../validation_messages/validation_messages";
+interface Props {
+}
+export declare class GridAddRowsFooter extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {};
+    static components: {
+        ValidationMessages: typeof ValidationMessages;
+    };
+    private DOMFocusableElementStore;
+    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;
+    private focusDefaultElement;
+}
+export {};

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

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

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

@@ -0,0 +1,68 @@
+import { Component } from "@odoo/owl";
+import { DOMCoordinates, GridClickModifiers, 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 { FilterIconsOverlay } from "../filters/filter_icons_overlay/filter_icons_overlay";
+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: GridClickModifiers) => void;
+    onCellRightClicked: (col: HeaderIndex, row: HeaderIndex, coordinates: DOMCoordinates) => void;
+    onGridResized: (dimension: Rect) => void;
+    onGridMoved: (deltaX: Pixel, deltaY: Pixel) => void;
+    gridOverlayDimensions: string;
+}
+export declare class GridOverlay extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        onCellHovered: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+        onCellDoubleClicked: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+        onCellClicked: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+        onCellRightClicked: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+        onGridResized: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+        onGridMoved: FunctionConstructor;
+        gridOverlayDimensions: StringConstructor;
+    };
+    static components: {
+        FiguresContainer: typeof FiguresContainer;
+        DataValidationOverlay: typeof DataValidationOverlay;
+        GridAddRowsFooter: typeof GridAddRowsFooter;
+        FilterIconsOverlay: typeof FilterIconsOverlay;
+    };
+    static defaultProps: {
+        onCellHovered: () => void;
+        onCellDoubleClicked: () => void;
+        onCellClicked: () => void;
+        onCellRightClicked: () => void;
+        onGridResized: () => void;
+    };
+    private gridOverlay;
+    private gridOverlayRect;
+    private cellPopovers;
+    private paintFormatStore;
+    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,28 @@
+import { Component } from "@odoo/owl";
+import { ComponentsImportance } from "../../constants";
+import { Store } from "../../store_engine/store";
+import { Rect, SpreadsheetChildEnv } from "../../types";
+import { ClosedCellPopover, PositionedCellPopoverComponent } from "../../types/cell_popovers";
+import { CellPopoverStore } from "../popover";
+import { Popover } from "../popover/popover";
+interface Props {
+    gridRect: Rect;
+    onClosePopover: () => void;
+    onMouseWheel: (ev: WheelEvent) => void;
+}
+export declare class GridPopover extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        onClosePopover: FunctionConstructor;
+        onMouseWheel: FunctionConstructor;
+        gridRect: ObjectConstructor;
+    };
+    static components: {
+        Popover: typeof Popover;
+    };
+    protected cellPopovers: Store<CellPopoverStore>;
+    zIndex: ComponentsImportance;
+    setup(): void;
+    get cellPopover(): PositionedCellPopoverComponent | ClosedCellPopover;
+}
+export {};

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

@@ -0,0 +1,46 @@
+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;
+    static props: {
+        group: ObjectConstructor;
+        layerOffset: NumberConstructor;
+        openContextMenu: FunctionConstructor;
+    };
+    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,33 @@
+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 props: {
+        dimension: StringConstructor;
+        layers: ArrayConstructor;
+    };
+    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 {};

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

@@ -0,0 +1,131 @@
+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> {
+    static props: {
+        onOpenContextMenu: FunctionConstructor;
+    };
+    private composerFocusStore;
+    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;
+    setup(): void;
+    _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 props: {
+        onOpenContextMenu: FunctionConstructor;
+    };
+    static template: string;
+    private colResizerRef;
+    setup(): void;
+    get sheetId(): import("../..").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;
+    getUnhideButtonStyle(hiddenIndex: HeaderIndex): string;
+}
+export declare class RowResizer extends AbstractResizer {
+    static props: {
+        onOpenContextMenu: FunctionConstructor;
+    };
+    static template: string;
+    setup(): void;
+    private rowResizerRef;
+    get sheetId(): import("../..").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;
+    getUnhideButtonStyle(hiddenIndex: HeaderIndex): string;
+}
+export declare class HeadersOverlay extends Component<any, SpreadsheetChildEnv> {
+    static props: {
+        onOpenContextMenu: FunctionConstructor;
+    };
+    static template: string;
+    static components: {
+        ColResizer: typeof ColResizer;
+        RowResizer: typeof RowResizer;
+    };
+    selectAll(): void;
+}
+export {};

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

@@ -0,0 +1,3 @@
+export declare function useAutofocus({ refName }: {
+    refName: string;
+}): void;

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 | null | undefined, 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 pointerdown event, this function allows to
+ * perform actions related to the pointermove and pointerup events and adjusts the viewport
+ * when the new position related to the pointermove event is outside of it.
+ * Among inputs are two callback functions. First intended for actions performed during
+ * the pointermove event, it receives as parameters the current position of the pointermove
+ * (occurrence of the current column and the current row). Second intended for actions
+ * performed during the pointerup 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[];
+    scrollableContainerEl: 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 "../../model";
+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/highlight_hook.d.ts

@@ -0,0 +1,4 @@
+import { HighlightProvider } from "../../stores/highlight_store";
+import { Ref } from "../../types";
+export declare function useHighlightsOnHover(ref: Ref<HTMLElement>, highlightProvider: HighlightProvider): void;
+export declare function useHighlights(highlightProvider: HighlightProvider): void;