@odoo/o-spreadsheet 19.2.12 → 19.3.3

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

@@ -0,0 +1,77 @@
+import { SquishedFormula } from "../plugins/core/squisher";
+import { CoreCommand } from "../types/commands";
+import { CoreGetters } from "../types/core_getters";
+import { UpdateCellData } from "../types/misc";
+/**
+When squishing, commands go through 3 stages:
+
+  STEP1 (content is a string, position is defined by row and column)
+
+        { sheetId: "Sheet1", col: 0, row: 0, content: "1", type: "UPDATE_CELL" },
+        { sheetId: "Sheet1", col: 0, row: 1, content: "2", type: "UPDATE_CELL" },
+        { sheetId: "Sheet1", col: 0, row: 2, content: "3", type: "UPDATE_CELL" },
+
+  STEP2 (content can be a string or a SquishedFormula, position is still defined by row and column)
+
+        { sheetId: "Sheet1", col: 0, row: 0, content: "1", type: "UPDATE_CELL" },
+        { sheetId: "Sheet1", col: 0, row: 1, content: { N: "+1" }, type: "UPDATE_CELL" },
+        { sheetId: "Sheet1", col: 0, row: 2, content: { N: "+1" }, type: "UPDATE_CELL" },
+
+  STEP3 (position can be defined by a range like "A1:A5")
+
+        { sheetId: "Sheet1", col: 0, row: 0, content: "1", type: "UPDATE_CELL" },
+        { sheetId: "Sheet1", targetRange: "A2:A3", content: { N: "+1" }, type: "SQUISHED_UPDATE_CELL" },
+*/
+interface SquishedCellData extends Omit<UpdateCellData, "content"> {
+    content?: string | SquishedFormula;
+}
+interface UpdateCellSquishCommand extends SquishedCellData {
+    type: "SQUISHED_UPDATE_CELL";
+    sheetId: string;
+    targetRange: string;
+}
+export type SquishedCoreCommand = UpdateCellSquishCommand;
+/**
+ * The CommandSquisher is responsible for squishing consecutive UPDATE_CELL commands into a single
+ * SQUISHED_UPDATE_CELL command to optimize the size of messages sent over the network in collaborative mode.
+ * It also unsquishes SQUISHED_UPDATE_CELL commands back into individual UPDATE_CELL commands when receiving messages from the network.
+ *
+ * The interface is useful to extract the dependency to the getters and be able to test the squishing and unsquishing logic in isolation.
+ */
+export interface ICommandSquisher {
+    squish: (commands: readonly CoreCommand[]) => (CoreCommand | SquishedCoreCommand)[];
+    unsquish: (commands: (CoreCommand | SquishedCoreCommand)[] | readonly CoreCommand[]) => CoreCommand[];
+}
+export declare class CommandSquisher implements ICommandSquisher {
+    private getters;
+    constructor(getters: CoreGetters);
+    /**
+     * Takes a list of commands and squish them, meaning that it transforms
+     * consecutive UPDATE_CELL commands with the same value or similar change to value into a single SQUISHED_UPDATE_CELL command.
+     * The logic to find similar value is the same as the one used in the export of the cells, in squisher.ts.
+     *
+     * We do not squish UPDATE_CELL commands if there are duplicates (same cell updated multiple times),
+     * and we stop squishing if a series of consecutive UPDATE_CELL commands is interrupted by another command type.
+     *
+     * We reorder the command within the same consecutive UPDATE_CELL uninterrupted block by sheet,
+     * to maximize the chances to squish commands together, but we do not reorder commands
+     * from different sheets or blocks, to avoid creating conflicts with commands that are not commutative.
+     *
+     * @param revisionCommands all the commands of a given revision
+     * @returns all the commands of the revision, with consecutive UPDATE_CELL commands squished together when possible
+     */
+    squish(revisionCommands: readonly CoreCommand[]): (CoreCommand | SquishedCoreCommand)[];
+    /**
+     * Takes a list of commands and unsquish them, meaning that it transforms
+     * SQUISHED_UPDATE_CELL commands into multiple UPDATE_CELL commands.
+     */
+    unsquish(commands: (CoreCommand | SquishedCoreCommand)[] | readonly CoreCommand[]): CoreCommand[];
+    /**
+     * Create a block of consecutive UPDATE_CELL commands, meaning a block of
+     * commands where all UPDATE_CELL commands are consecutive and uninterrupted by other command types.
+     */
+    private collectConsecutiveUpdateCellCommands;
+    private sortAndSquishUpdateCellsBySheet;
+    private compareUpdateCell;
+}
+export {};

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

@@ -0,0 +1,8 @@
+import { CollaborationMessage, NewMessageCallback, TransportService } from "../types/collaborative/transport_service";
+import { UID } from "../types/misc";
+export declare class LocalTransportService implements TransportService<CollaborationMessage> {
+    private listeners;
+    sendMessage(message: CollaborationMessage): Promise<void>;
+    onNewMessage(id: UID, callback: NewMessageCallback<CollaborationMessage>): void;
+    leave(id: UID): void;
+}

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

@@ -0,0 +1,23 @@
+import { CoreCommand } from "../../types/commands";
+import "./ot_specific";
+import "./srt_specific";
+/**
+ * Get the result of applying the operation transformations on the given command
+ * to transform based on the executed command.
+ * Let's see a small example:
+ * Given
+ *  - command A: set the content of C1 to "Hello"
+ *  - command B: add a column after A
+ *
+ * If command B has been executed locally and not transmitted (yet) to
+ * other clients, and command A arrives from an other client to be executed locally.
+ * Command A is no longer valid and no longer reflects the user intention.
+ * It needs to be transformed knowing that command B is already executed.
+ * transform(A, B) => set the content of D1 to "Hello"
+ */
+export declare function transform(toTransform: CoreCommand, executed: CoreCommand): CoreCommand | undefined;
+/**
+ * Get the result of applying the operation transformations on all the given
+ * commands to transform for each executed commands.
+ */
+export declare function transformAll(toTransform: readonly CoreCommand[], executed: readonly CoreCommand[]): CoreCommand[];

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

@@ -0,0 +1,5 @@
+import { CoreCommand } from "../../types/commands";
+import { UnboundedZone, Zone } from "../../types/misc";
+import { RangeData } from "../../types/range";
+export declare function transformZone<Z extends Zone | UnboundedZone>(zone: Z, executed: CoreCommand): Z | undefined;
+export declare function transformRangeData(range: RangeData, executed: CoreCommand): RangeData | undefined;

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

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

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

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

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

@@ -0,0 +1,9 @@
+import { CollaborationMessage, NewMessageCallback, TransportService } from "../types/collaborative/transport_service";
+import { UID } from "../types/misc";
+export declare class ReadonlyTransportFilter implements TransportService<CollaborationMessage> {
+    private transportService;
+    constructor(transportService: TransportService<CollaborationMessage>);
+    sendMessage(message: CollaborationMessage): Promise<void>;
+    onNewMessage(id: UID, callback: NewMessageCallback<CollaborationMessage>): void;
+    leave(id: UID): void;
+}

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

@@ -0,0 +1,26 @@
+import { RevisionData } from "../types/collaborative/revisions";
+import { ClientId } from "../types/collaborative/session";
+import { Command, CoreCommand } from "../types/commands";
+import { HistoryChange } from "../types/history";
+import { UID } from "../types/misc";
+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,107 @@
+import { EventBus } from "../helpers/event_bus";
+import { SelectiveHistory as RevisionLog } from "../history/selective_history";
+import { Client, ClientId, ClientPosition, CollaborativeEvent } from "../types/collaborative/session";
+import { CollaborationMessage, StateUpdateMessage, TransportService } from "../types/collaborative/transport_service";
+import { Command, CoreCommand } from "../types/commands";
+import { HistoryChange } from "../types/history";
+import { Lazy, UID } from "../types/misc";
+import { WorkbookData } from "../types/workbook_data";
+import { ICommandSquisher } from "./command_squisher";
+import { Revision } from "./revisions";
+export declare class ClientDisconnectedError extends Error {
+}
+export declare class Session extends EventBus<CollaborativeEvent> {
+    private revisions;
+    private transportService;
+    private serverRevisionId;
+    private commandSquisher;
+    /**
+     * Positions of the others client.
+     */
+    private clients;
+    private clientId;
+    private pendingMessages;
+    /**
+     * Stored position of the client, if session.move is called while the client is not in a session.
+     * Will be used to send the position to the server when the client joins.
+     */
+    private awaitingClientPosition;
+    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 client 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 serverRevisionId
+     * @param commandSquisher used to squish and unsquish commands to reduce the size of messages sent to the server
+     */
+    constructor(revisions: RevisionLog<Revision>, transportService: TransportService<CollaborationMessage>, serverRevisionId: UID | undefined, commandSquisher: ICommandSquisher);
+    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;
+    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>;
+    getCurrentClient(): Client;
+    getClient(clientId: ClientId): Client;
+    getConnectedClients(): Set<Client>;
+    getRevisionId(): UID;
+    isFullySynchronized(): boolean;
+    /**
+     * Get the last local revision
+     * */
+    getLastLocalNonEmptyRevision(): Revision | undefined;
+    /**
+     * Notify that the position of the client has changed
+     */
+    move(position: ClientPosition): void;
+    /**
+     * 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;
+    private sendToTransport;
+    /**
+     * 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/spreadsheet_env";
+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/spreadsheet_env";
+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,32 @@
+import { Component } from "@odoo/owl";
+import { DOMCoordinates, HeaderIndex } from "../../types";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+interface Props {
+    isVisible: boolean;
+    position: DOMCoordinates;
+}
+interface State {
+    position: DOMCoordinates;
+    handler: boolean;
+}
+export declare class Autofill extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        position: ObjectConstructor;
+        isVisible: BooleanConstructor;
+    };
+    state: State;
+    dragNDropGrid: {
+        start: (initialPointerCoordinates: {
+            clientX: number;
+            clientY: number;
+        }, onPointerMove: (col: HeaderIndex, row: HeaderIndex, ev: MouseEvent) => void, onPointerUp: () => void, startScrollDirection?: import("../helpers/drag_and_drop_grid_hook").DnDDirection) => void;
+    };
+    get style(): string;
+    get handlerStyle(): string;
+    get styleNextValue(): string;
+    getTooltip(): import("../..").Tooltip | undefined;
+    onMouseDown(ev: PointerEvent): void;
+    onDblClick(): void;
+}
+export {};

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

@@ -0,0 +1,68 @@
+import { Component } from "@odoo/owl";
+import { BorderPosition, BorderStyle, Color, Pixel, Rect } from "../../types/index";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+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,50 @@
+import { Component } from "@odoo/owl";
+import { BorderPosition, BorderStyle, Color, Pixel, Rect } from "../../types";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+import { ToolBarDropdownStore } from "../helpers/top_bar_tool_hook";
+import { BorderEditor } from "./border_editor";
+interface Props {
+    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: {
+        disabled: {
+            type: BooleanConstructor;
+            optional: boolean;
+        };
+        dropdownMaxHeight: {
+            type: NumberConstructor;
+            optional: boolean;
+        };
+        class: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+    };
+    static components: {
+        BorderEditor: typeof BorderEditor;
+    };
+    topBarToolStore: ToolBarDropdownStore;
+    borderEditorButtonRef: {
+        el: HTMLElement | null;
+    };
+    state: State;
+    setup(): void;
+    get dropdownMaxHeight(): Pixel;
+    get borderEditorAnchorRect(): Rect;
+    onBorderPositionPicked(position: BorderPosition): void;
+    onBorderColorPicked(color: Color): void;
+    onBorderStylePicked(style: BorderStyle): void;
+    get isActive(): boolean;
+    toggleBorderEditor(): void;
+    private updateBorder;
+}
+export {};

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

@@ -0,0 +1,60 @@
+import { Component } from "@odoo/owl";
+import { MenuItemRegistry } from "../../registries/menu_items_registry";
+import { MenuMouseEvent, Pixel, UID } from "../../types";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+import { Ripple } from "../animation/ripple";
+import { MenuPopover, MenuState } from "../menu_popover/menu_popover";
+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: {
+        MenuPopover: typeof MenuPopover;
+        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 {};