@odoo/o-spreadsheet 18.0.54 → 18.0.67

package/dist/types/collaborative/ot/ot_specific.d.ts

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

package/dist/types/collaborative/revisions.d.ts

@@ -0,0 +1,22 @@
+import { ClientId, Command, CoreCommand, HistoryChange, RevisionData, UID } from "../types";
+export declare class Revision implements RevisionData {
+    readonly rootCommand?: Command | undefined;
+    readonly timestamp?: number | undefined;
+    readonly id: UID;
+    readonly clientId: ClientId;
+    private _commands;
+    private _changes;
+    /**
+     * A revision represents a whole client action (Create a sheet, merge a Zone, Undo, ...).
+     * A revision contains the following information:
+     *  - id: ID of the revision
+     *  - commands: CoreCommands that are linked to the action, and should be
+     *              dispatched in other clients
+     *  - clientId: Client who initiated the action
+     *  - changes: List of changes applied on the state.
+     */
+    constructor(id: UID, clientId: ClientId, commands: readonly CoreCommand[], rootCommand?: Command | undefined, changes?: readonly HistoryChange[], timestamp?: number | undefined);
+    setChanges(changes: readonly HistoryChange[]): void;
+    get commands(): readonly CoreCommand[];
+    get changes(): readonly HistoryChange[];
+}

package/dist/types/collaborative/session.d.ts

@@ -0,0 +1,101 @@
+import { EventBus } from "../helpers/event_bus";
+import { SelectiveHistory as RevisionLog } from "../history/selective_history";
+import { CoreCommand, HistoryChange, Lazy, UID, WorkbookData } from "../types";
+import { Client, ClientPosition, CollaborativeEvent } from "../types/collaborative/session";
+import { CollaborationMessage, StateUpdateMessage, TransportService } from "../types/collaborative/transport_service";
+import { Command } from "./../types/commands";
+import { Revision } from "./revisions";
+export declare class ClientDisconnectedError extends Error {
+}
+export declare class Session extends EventBus<CollaborativeEvent> {
+    private revisions;
+    private transportService;
+    private serverRevisionId;
+    /**
+     * Positions of the others client.
+     */
+    private clients;
+    private clientId;
+    /**
+     * Id of the server revision
+     */
+    private debouncedMove;
+    private pendingMessages;
+    private waitingAck;
+    /**
+     * Flag used to block all commands when an undo or redo is triggered, until
+     * it is accepted on the server
+     */
+    private waitingUndoRedoAck;
+    private isReplayingInitialRevisions;
+    private processedRevisions;
+    private lastRevisionMessage;
+    private uuidGenerator;
+    private lastLocalOperation;
+    /**
+     * Manages the collaboration between multiple users on the same spreadsheet.
+     * It can forward local state changes to other users to ensure they all eventually
+     * reach the same state.
+     * It also manages the positions of each clients in the spreadsheet to provide
+     * a visual indication of what other users are doing in the spreadsheet.
+     *
+     * @param revisions
+     * @param transportService communication channel used to send and receive messages
+     * between all connected clients
+     * @param client the client connected locally
+     * @param serverRevisionId
+     */
+    constructor(revisions: RevisionLog<Revision>, transportService: TransportService<CollaborationMessage>, serverRevisionId?: UID);
+    canApplyOptimisticUpdate(): boolean;
+    /**
+     * Add a new revision to the collaborative session.
+     * It will be transmitted to all other connected clients.
+     */
+    save(rootCommand: Command, commands: CoreCommand[], changes: HistoryChange[]): void;
+    undo(revisionId: UID): void;
+    redo(revisionId: UID): void;
+    /**
+     * Notify that the position of the client has changed
+     */
+    move(position: ClientPosition): void;
+    join(client?: Client): void;
+    loadInitialMessages(messages: StateUpdateMessage[]): void;
+    /**
+     * Notify the server that the user client left the collaborative session
+     */
+    leave(data?: Lazy<WorkbookData>): Promise<void>;
+    /**
+     * Send a snapshot of the spreadsheet to the collaboration server
+     */
+    snapshot(data: WorkbookData): Promise<void>;
+    getClient(): Client;
+    getConnectedClients(): Set<Client>;
+    getRevisionId(): UID;
+    isFullySynchronized(): boolean;
+    /**
+     * Get the last local revision
+     * */
+    getLastLocalNonEmptyRevision(): Revision | undefined;
+    private _move;
+    /**
+     * Handles messages received from other clients in the collaborative
+     * session.
+     */
+    private onMessageReceived;
+    private onClientMoved;
+    /**
+     * Register the new client and send your
+     * own position back.
+     */
+    private onClientJoined;
+    private onClientLeft;
+    private sendUpdateMessage;
+    /**
+     * Send the next pending message
+     */
+    private sendPendingMessage;
+    private acknowledge;
+    private isAlreadyProcessed;
+    isWrongServerRevisionId(message: CollaborationMessage): boolean;
+    private dropPendingHistoryMessages;
+}

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

@@ -0,0 +1,42 @@
+import { Component } from "@odoo/owl";
+import { ActionSpec } from "../../actions/action";
+import { SpreadsheetChildEnv } from "../../types";
+interface Props {
+    action: ActionSpec;
+    hasTriangleDownIcon?: boolean;
+    selectedColor?: string;
+    class?: string;
+    onClick?: (ev: MouseEvent) => void;
+}
+export declare class ActionButton extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        action: ObjectConstructor;
+        hasTriangleDownIcon: {
+            type: BooleanConstructor;
+            optional: boolean;
+        };
+        selectedColor: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        class: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        onClick: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+    };
+    private actionButton;
+    setup(): void;
+    get isVisible(): boolean;
+    get isEnabled(): boolean;
+    get isActive(): boolean | undefined;
+    get title(): string;
+    get iconTitle(): string;
+    onClick(ev: MouseEvent): void;
+    get buttonStyle(): string;
+}
+export {};

package/dist/types/components/animation/ripple.d.ts

@@ -0,0 +1,118 @@
+import { Component } from "@odoo/owl";
+import { SpreadsheetChildEnv } from "../../types";
+interface RippleProps {
+    color: string;
+    opacity: number;
+    duration: number;
+    /** If true, the ripple will play from the element center instead of the position of the click */
+    ignoreClickPosition?: boolean;
+    /** Width of the ripple. Defaults to the width of the element the ripple is on (without margins). */
+    width?: number;
+    /** Height of the ripple. Defaults to the height of the element the ripple is on (without margins). */
+    height?: number;
+    offsetY?: number;
+    offsetX?: number;
+    allowOverflow?: boolean;
+    enabled: boolean;
+    onAnimationEnd: () => void;
+    class: string;
+}
+interface RippleEffectProps extends Omit<Required<RippleProps>, "ignoreClickPosition" | "enabled" | "class"> {
+    x: string;
+    y: string;
+    style: string;
+}
+declare class RippleEffect extends Component<RippleEffectProps, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        x: StringConstructor;
+        y: StringConstructor;
+        color: StringConstructor;
+        opacity: NumberConstructor;
+        duration: NumberConstructor;
+        width: NumberConstructor;
+        height: NumberConstructor;
+        offsetY: NumberConstructor;
+        offsetX: NumberConstructor;
+        allowOverflow: BooleanConstructor;
+        onAnimationEnd: FunctionConstructor;
+        style: StringConstructor;
+    };
+    private rippleRef;
+    setup(): void;
+    get rippleStyle(): string;
+}
+export declare class Ripple extends Component<RippleProps, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        color: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        opacity: {
+            type: NumberConstructor;
+            optional: boolean;
+        };
+        duration: {
+            type: NumberConstructor;
+            optional: boolean;
+        };
+        ignoreClickPosition: {
+            type: BooleanConstructor;
+            optional: boolean;
+        };
+        width: {
+            type: NumberConstructor;
+            optional: boolean;
+        };
+        height: {
+            type: NumberConstructor;
+            optional: boolean;
+        };
+        offsetY: {
+            type: NumberConstructor;
+            optional: boolean;
+        };
+        offsetX: {
+            type: NumberConstructor;
+            optional: boolean;
+        };
+        allowOverflow: {
+            type: BooleanConstructor;
+            optional: boolean;
+        };
+        enabled: {
+            type: BooleanConstructor;
+            optional: boolean;
+        };
+        onAnimationEnd: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+        slots: ObjectConstructor;
+        class: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+    };
+    static components: {
+        RippleEffect: typeof RippleEffect;
+    };
+    static defaultProps: {
+        color: string;
+        opacity: number;
+        duration: number;
+        enabled: boolean;
+        onAnimationEnd: () => void;
+        class: string;
+    };
+    private childContainer;
+    private state;
+    private currentId;
+    onClick(ev: MouseEvent): void;
+    private getRippleStyle;
+    private getRippleChildRectInfo;
+    private removeRipple;
+    getRippleEffectProps(id: number): RippleEffectProps;
+}
+export {};

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

@@ -0,0 +1,29 @@
+import { Component } from "@odoo/owl";
+import { HeaderIndex, SpreadsheetChildEnv } from "../../types";
+interface Props {
+    isVisible: boolean;
+    position: Position;
+}
+interface Position {
+    top: HeaderIndex;
+    left: HeaderIndex;
+}
+interface State {
+    position: Position;
+    handler: boolean;
+}
+export declare class Autofill extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        position: ObjectConstructor;
+        isVisible: BooleanConstructor;
+    };
+    state: State;
+    get style(): string;
+    get handlerStyle(): string;
+    get styleNextValue(): string;
+    getTooltip(): import("../..").Tooltip | undefined;
+    onMouseDown(ev: MouseEvent): void;
+    onDblClick(): void;
+}
+export {};

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

@@ -0,0 +1,67 @@
+import { Component } from "@odoo/owl";
+import { BorderPosition, BorderStyle, Color, Pixel, Rect, SpreadsheetChildEnv } from "../../types/index";
+import { ColorPickerWidget } from "../color_picker/color_picker_widget";
+import { Popover, PopoverProps } from "../popover/popover";
+type Tool = "borderColorTool" | "borderTypeTool";
+interface State {
+    activeTool: Tool | undefined;
+}
+export interface BorderEditorProps {
+    class?: string;
+    currentBorderColor: Color;
+    currentBorderStyle: BorderStyle;
+    currentBorderPosition: BorderPosition | undefined;
+    onBorderColorPicked: (color: Color) => void;
+    onBorderStylePicked: (style: BorderStyle) => void;
+    onBorderPositionPicked: (position: BorderPosition) => void;
+    maxHeight?: Pixel;
+    anchorRect: Rect;
+}
+export declare class BorderEditor extends Component<BorderEditorProps, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        class: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        currentBorderColor: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        currentBorderStyle: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        currentBorderPosition: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        onBorderColorPicked: FunctionConstructor;
+        onBorderStylePicked: FunctionConstructor;
+        onBorderPositionPicked: FunctionConstructor;
+        maxHeight: {
+            type: NumberConstructor;
+            optional: boolean;
+        };
+        anchorRect: ObjectConstructor;
+    };
+    static components: {
+        ColorPickerWidget: typeof ColorPickerWidget;
+        Popover: typeof Popover;
+    };
+    BORDER_POSITIONS: [BorderPosition, string][][];
+    lineStyleButtonRef: {
+        el: HTMLElement | null;
+    };
+    borderStyles: readonly ["thin", "medium", "thick", "dashed", "dotted"];
+    state: State;
+    toggleDropdownTool(tool: Tool): void;
+    closeDropdown(): void;
+    setBorderPosition(position: BorderPosition): void;
+    setBorderColor(color: Color): void;
+    setBorderStyle(style: BorderStyle): void;
+    get lineStylePickerPopoverProps(): PopoverProps;
+    get popoverProps(): PopoverProps;
+    get lineStylePickerAnchorRect(): Rect;
+}
+export {};

package/dist/types/components/border_editor/border_editor_widget.d.ts

@@ -0,0 +1,47 @@
+import { Component } from "@odoo/owl";
+import { BorderPosition, BorderStyle, Color, Pixel, Rect, SpreadsheetChildEnv } from "../../types";
+import { BorderEditor } from "./border_editor";
+interface Props {
+    toggleBorderEditor: () => void;
+    showBorderEditor: boolean;
+    disabled?: boolean;
+    dropdownMaxHeight?: Pixel;
+    class?: string;
+}
+interface State {
+    currentColor: Color;
+    currentStyle: BorderStyle;
+    currentPosition: BorderPosition | undefined;
+}
+export declare class BorderEditorWidget extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        toggleBorderEditor: FunctionConstructor;
+        showBorderEditor: BooleanConstructor;
+        disabled: {
+            type: BooleanConstructor;
+            optional: boolean;
+        };
+        dropdownMaxHeight: {
+            type: NumberConstructor;
+            optional: boolean;
+        };
+        class: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+    };
+    static components: {
+        BorderEditor: typeof BorderEditor;
+    };
+    borderEditorButtonRef: {
+        el: HTMLElement | null;
+    };
+    state: State;
+    get borderEditorAnchorRect(): Rect;
+    onBorderPositionPicked(position: BorderPosition): void;
+    onBorderColorPicked(color: Color): void;
+    onBorderStylePicked(style: BorderStyle): void;
+    private updateBorder;
+}
+export {};

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

@@ -0,0 +1,59 @@
+import { Component } from "@odoo/owl";
+import { MenuItemRegistry } from "../../registries/menu_items_registry";
+import { MenuMouseEvent, Pixel, SpreadsheetChildEnv, UID } from "../../types";
+import { Ripple } from "../animation/ripple";
+import { Menu, MenuState } from "../menu/menu";
+import { BottomBarSheet } from "./bottom_bar_sheet/bottom_bar_sheet";
+import { BottomBarStatistic } from "./bottom_bar_statistic/bottom_bar_statistic";
+interface BottomBarSheetItem {
+    id: UID;
+    name: string;
+}
+interface Props {
+    onClick: () => void;
+}
+interface BottomBarMenuState extends MenuState {
+    menuId: UID | undefined;
+}
+export declare class BottomBar extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        onClick: FunctionConstructor;
+    };
+    static components: {
+        Menu: typeof Menu;
+        Ripple: typeof Ripple;
+        BottomBarSheet: typeof BottomBarSheet;
+        BottomBarStatistic: typeof BottomBarStatistic;
+    };
+    private bottomBarRef;
+    private sheetListRef;
+    private dragAndDrop;
+    private targetScroll;
+    private state;
+    menuMaxHeight: number;
+    menuState: BottomBarMenuState;
+    sheetList: BottomBarSheetItem[];
+    setup(): void;
+    clickAddSheet(ev: MouseEvent): void;
+    getVisibleSheets(): BottomBarSheetItem[];
+    clickListSheets(ev: MouseEvent): void;
+    openContextMenu(x: Pixel, y: Pixel, menuId: UID, registry: MenuItemRegistry): void;
+    onSheetContextMenu(sheetId: UID, registry: MenuItemRegistry, ev: MenuMouseEvent): void;
+    closeMenu(): void;
+    closeContextMenuWithId(menuId: UID): void;
+    onWheel(ev: WheelEvent): void;
+    onScroll(): void;
+    onArrowLeft(ev: MouseEvent): void;
+    onArrowRight(ev: MouseEvent): void;
+    private updateScrollState;
+    private scrollSheetListTo;
+    onSheetMouseDown(sheetId: UID, event: MouseEvent): void;
+    private onDragEnd;
+    getSheetStyle(sheetId: UID): string;
+    private getSheetItemRects;
+    get sheetListCurrentScroll(): number;
+    get sheetListWidth(): number;
+    get sheetListMaxScroll(): number;
+}
+export {};

package/dist/types/components/bottom_bar/bottom_bar_sheet/bottom_bar_sheet.d.ts

@@ -0,0 +1,62 @@
+import { Component } from "@odoo/owl";
+import { MenuItemRegistry } from "../../../registries/menu_items_registry";
+import { Rect, SpreadsheetChildEnv } from "../../../types";
+import { Ripple } from "../../animation/ripple";
+import { ColorPicker } from "../../color_picker/color_picker";
+interface Props {
+    sheetId: string;
+    openContextMenu: (registry: MenuItemRegistry, ev: MouseEvent) => void;
+    style?: string;
+    onMouseDown: (ev: MouseEvent) => void;
+}
+export declare class BottomBarSheet extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        sheetId: StringConstructor;
+        openContextMenu: FunctionConstructor;
+        style: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        onMouseDown: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+    };
+    static components: {
+        Ripple: typeof Ripple;
+        ColorPicker: typeof ColorPicker;
+    };
+    static defaultProps: {
+        onMouseDown: () => void;
+        style: string;
+    };
+    private state;
+    private sheetDivRef;
+    private sheetNameRef;
+    private editionState;
+    private DOMFocusableElementStore;
+    setup(): void;
+    private focusInputAndSelectContent;
+    private scrollToSheet;
+    onFocusOut(): void;
+    onMouseDown(ev: any): void;
+    private activateSheet;
+    onDblClick(): void;
+    onKeyDown(ev: KeyboardEvent): void;
+    onMouseEventSheetName(ev: MouseEvent): void;
+    private startEdition;
+    private stopEdition;
+    private cancelEdition;
+    onIconClick(ev: MouseEvent): void;
+    onContextMenu(ev: MouseEvent): void;
+    private getInputContent;
+    private setInputContent;
+    onColorPicked(color: string): void;
+    get colorPickerAnchorRect(): Rect;
+    get contextMenuRegistry(): MenuItemRegistry;
+    get isSheetActive(): boolean;
+    get sheetName(): string;
+    get sheetColorStyle(): string;
+}
+export {};

package/dist/types/components/bottom_bar/bottom_bar_statistic/aggregate_statistics_store.d.ts

@@ -0,0 +1,15 @@
+import { Get } from "../../../store_engine";
+import { SpreadsheetStore } from "../../../stores";
+import { Command, Lazy } from "../../../types";
+export interface StatisticFnResults {
+    [name: string]: Lazy<number> | undefined;
+}
+export declare class AggregateStatisticsStore extends SpreadsheetStore {
+    statisticFnResults: StatisticFnResults;
+    private isDirty;
+    constructor(get: Get);
+    handle(cmd: Command): void;
+    finalize(): void;
+    handleEvent(): void;
+    private _computeStatisticFnResults;
+}

package/dist/types/components/bottom_bar/bottom_bar_statistic/bottom_bar_statistic.d.ts

@@ -0,0 +1,25 @@
+import { Component } from "@odoo/owl";
+import { MenuItemRegistry } from "../../../registries/menu_items_registry";
+import { SpreadsheetChildEnv } from "../../../types";
+import { Ripple } from "../../animation/ripple";
+interface Props {
+    openContextMenu: (x: number, y: number, registry: MenuItemRegistry) => void;
+    closeContextMenu: () => void;
+}
+export declare class BottomBarStatistic extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        openContextMenu: FunctionConstructor;
+        closeContextMenu: FunctionConstructor;
+    };
+    static components: {
+        Ripple: typeof Ripple;
+    };
+    selectedStatisticFn: string;
+    private store;
+    setup(): void;
+    getSelectedStatistic(): string | undefined;
+    listSelectionStatistics(ev: MouseEvent): void;
+    private getComposedFnName;
+}
+export {};

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

@@ -0,0 +1,21 @@
+import { Component } from "@odoo/owl";
+import { Color, HeaderIndex, SpreadsheetChildEnv } from "../../types";
+interface ClientTagProps {
+    active: boolean;
+    name: string;
+    color: Color;
+    col: HeaderIndex;
+    row: HeaderIndex;
+}
+export declare class ClientTag extends Component<ClientTagProps, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        active: BooleanConstructor;
+        name: StringConstructor;
+        color: StringConstructor;
+        col: NumberConstructor;
+        row: NumberConstructor;
+    };
+    get tagStyle(): string;
+}
+export {};

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

@@ -0,0 +1,57 @@
+import { Component } from "@odoo/owl";
+import { Color, Pixel, Rect } from "../../types";
+import { SpreadsheetChildEnv } from "../../types/env";
+import { Popover, PopoverProps } from "../popover/popover";
+export interface ColorPickerProps {
+    anchorRect: Rect;
+    maxHeight?: Pixel;
+    onColorPicked: (color: Color) => void;
+    currentColor: Color;
+    disableNoColor?: boolean;
+}
+export declare class ColorPicker extends Component<ColorPickerProps, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        onColorPicked: FunctionConstructor;
+        currentColor: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        maxHeight: {
+            type: NumberConstructor;
+            optional: boolean;
+        };
+        anchorRect: ObjectConstructor;
+        disableNoColor: {
+            type: BooleanConstructor;
+            optional: boolean;
+        };
+    };
+    static defaultProps: {
+        currentColor: string;
+    };
+    static components: {
+        Popover: typeof Popover;
+    };
+    COLORS: Color[];
+    private state;
+    get colorPickerStyle(): string;
+    get popoverProps(): PopoverProps;
+    get gradientHueStyle(): string;
+    get sliderStyle(): string;
+    get pointerStyle(): string;
+    get colorPreviewStyle(): string;
+    get checkmarkColor(): Color;
+    get isHexColorInputValid(): boolean;
+    private setCustomGradient;
+    private setCustomHue;
+    private updateColor;
+    onColorClick(color: Color): void;
+    resetColor(): void;
+    toggleColorPicker(): void;
+    dragGradientPointer(ev: MouseEvent): void;
+    dragHuePointer(ev: MouseEvent): void;
+    setHexColor(ev: InputEvent): void;
+    addCustomColor(ev: Event): void;
+    isSameColor(color1: Color, color2: Color): boolean;
+}