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

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

@@ -0,0 +1,66 @@
+import { Component } from "@odoo/owl";
+import { MenuItemRegistry } from "../../../registries/menu_items_registry";
+import { Rect } from "../../../types";
+import { SpreadsheetChildEnv } from "../../../types/spreadsheet_env";
+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: PointerEvent) => 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 iconRef;
+    private sheetNameRef;
+    private editionState;
+    private DOMFocusableElementStore;
+    setup(): void;
+    private focusInputAndSelectContent;
+    private scrollToSheet;
+    onFocusOut(): void;
+    onClick(): void;
+    onMouseDown(ev: PointerEvent): 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;
+    get isSheetLocked(): boolean;
+}
+export {};

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

@@ -0,0 +1,13 @@
+import { StatisticFnResults } from "../../../helpers/selection_statistic_functions";
+import { Get } from "../../../store_engine";
+import { SpreadsheetStore } from "../../../stores";
+import { Command } from "../../../types";
+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/spreadsheet_env";
+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,22 @@
+import { Component } from "@odoo/owl";
+import { Color, HeaderIndex } from "../../types";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+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/spreadsheet_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;
+}

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

@@ -0,0 +1,53 @@
+import { Component } from "@odoo/owl";
+import { Pixel, Rect } from "../../types";
+import { SpreadsheetChildEnv } from "../../types/spreadsheet_env";
+import { ColorPicker } from "./color_picker";
+interface Props {
+    currentColor: string | undefined;
+    toggleColorPicker: () => void;
+    showColorPicker: boolean;
+    onColorPicked: (color: string) => void;
+    icon: string;
+    title?: string;
+    disabled?: boolean;
+    dropdownMaxHeight?: Pixel;
+    class?: string;
+}
+export declare class ColorPickerWidget extends Component<Props, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        currentColor: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        toggleColorPicker: FunctionConstructor;
+        showColorPicker: BooleanConstructor;
+        onColorPicked: FunctionConstructor;
+        icon: StringConstructor;
+        title: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            optional: boolean;
+        };
+        dropdownMaxHeight: {
+            type: NumberConstructor;
+            optional: boolean;
+        };
+        class: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+    };
+    static components: {
+        ColorPicker: typeof ColorPicker;
+    };
+    colorPickerButtonRef: {
+        el: HTMLElement | null;
+    };
+    get iconStyle(): string;
+    get colorPickerAnchorRect(): Rect;
+}
+export {};

package/dist/types/components/composer/autocomplete_dropdown/autocomplete_dropdown.d.ts

@@ -0,0 +1,25 @@
+import { Component } from "@odoo/owl";
+import { AutoCompleteProposal } from "../../../registries/auto_completes";
+import { HtmlContent } from "../composer/composer";
+interface Props {
+    proposals: AutoCompleteProposal[];
+    selectedIndex: number | undefined;
+    onValueSelected: (proposal: AutoCompleteProposal) => void;
+    onValueHovered: (index: string) => void;
+}
+export declare class TextValueProvider extends Component<Props> {
+    static template: string;
+    static props: {
+        proposals: ArrayConstructor;
+        selectedIndex: {
+            type: NumberConstructor;
+            optional: boolean;
+        };
+        onValueSelected: FunctionConstructor;
+        onValueHovered: FunctionConstructor;
+    };
+    private autoCompleteListRef;
+    setup(): void;
+    getCss(html: HtmlContent): string;
+}
+export {};

package/dist/types/components/composer/autocomplete_dropdown/autocomplete_dropdown_store.d.ts

@@ -0,0 +1,12 @@
+import { AutoCompleteProposal, AutoCompleteProvider } from "../../../registries/auto_completes";
+import { SpreadsheetStore } from "../../../stores";
+export declare class AutoCompleteStore extends SpreadsheetStore {
+    mutators: readonly ["useProvider", "moveSelection", "hide", "selectIndex"];
+    selectedIndex: number | undefined;
+    provider: AutoCompleteProvider | undefined;
+    get selectedProposal(): AutoCompleteProposal | undefined;
+    useProvider(provider: AutoCompleteProvider): void;
+    hide(): void;
+    selectIndex(index: number): void;
+    moveSelection(direction: "previous" | "next"): void;
+}

package/dist/types/components/composer/composer/abstract_composer_store.d.ts

@@ -0,0 +1,147 @@
+import { EnrichedToken } from "../../../formulas/composer_tokenizer";
+import { AutoCompleteProposal, AutoCompleteProviderDefinition } from "../../../registries/auto_completes/auto_complete_registry";
+import { Get } from "../../../store_engine";
+import { SpreadsheetStore } from "../../../stores";
+import { NotificationStore } from "../../../stores/notification_store";
+import { CellPosition, Command, Direction, EditionMode, HeaderIndex, Highlight, UID, UnboundedZone, Zone } from "../../../types";
+export interface ComposerSelection {
+    start: number;
+    end: number;
+}
+export declare abstract class AbstractComposerStore extends SpreadsheetStore {
+    mutators: readonly ["startEdition", "setCurrentContent", "stopEdition", "stopComposerRangeSelection", "cancelEdition", "cycleReferences", "hideHelp", "autoCompleteOrStop", "insertAutoCompleteValue", "moveAutoCompleteSelection", "selectAutoCompleteIndex", "toggleEditionMode", "changeComposerCursorSelection", "replaceComposerCursorSelection", "hoverToken"];
+    protected col: HeaderIndex;
+    protected row: HeaderIndex;
+    editionMode: EditionMode;
+    sheetId: UID;
+    protected _currentContent: string;
+    currentTokens: EnrichedToken[];
+    protected selectionStart: number;
+    protected selectionEnd: number;
+    protected initialContent: string | undefined;
+    private colorIndexByRange;
+    private autoComplete;
+    private hasSelectedAProposal;
+    hoveredTokens: EnrichedToken[];
+    hoveredContentEvaluation: string;
+    private autoCompleteKeepLast;
+    protected notificationStore: import("../../../store_engine").CQS<Pick<NotificationStore, "notifyUser" | "raiseError" | "askConfirmation" | "updateNotificationCallbacks"> & import("../../../store_engine").OmitFunctions<NotificationStore>>;
+    private highlightStore;
+    constructor(get: Get);
+    protected abstract confirmEdition(content: string): void;
+    protected abstract getComposerContent(position: CellPosition, selection?: ComposerSelection): {
+        text: string;
+        adjustedSelection?: ComposerSelection;
+    };
+    abstract stopEdition(direction?: Direction): void;
+    private handleEvent;
+    changeComposerCursorSelection(start: number, end: number): void;
+    stopComposerRangeSelection(): void;
+    startEdition(text?: string, selection?: ComposerSelection): void;
+    cancelEdition(): void;
+    setCurrentContent(content: string, selection?: ComposerSelection): void;
+    replaceComposerCursorSelection(text: string): void;
+    handle(cmd: Command): void;
+    get currentContent(): string;
+    get composerSelection(): ComposerSelection;
+    get isSelectingRange(): boolean;
+    get showSelectionIndicator(): boolean;
+    /**
+     * Return the (enriched) token just before the cursor.
+     */
+    get tokenAtCursor(): EnrichedToken | undefined;
+    get autoCompleteProposals(): AutoCompleteProposal[];
+    get autoCompleteSelectedIndex(): number | undefined;
+    get isAutoCompleteDisplayed(): boolean;
+    get canBeToggled(): boolean;
+    cycleReferences(): void;
+    toggleEditionMode(): void;
+    hoverToken(tokenIndex: number | undefined): void;
+    protected evaluateCanonicalFormula(canonicalFormula: string): import("../../..").FunctionResultObject | import("../../..").Matrix<import("../../..").FunctionResultObject>;
+    private getRelatedTokens;
+    private captureSelection;
+    private isSelectionValid;
+    /**
+     * Enable the selecting mode
+     */
+    private startComposerRangeSelection;
+    /**
+     * start the edition of a cell
+     * @param str the key that is used to start the edition if it is a "content" key like a letter or number
+     * @param selection
+     * @private
+     */
+    private _startEdition;
+    protected _stopEdition(): void;
+    protected getCurrentCanonicalContent(): string;
+    protected cancelEditionAndActivateSheet(): void;
+    protected _cancelEdition(): void;
+    /**
+     * Reset the current content to the active cell content
+     */
+    protected resetContent(): void;
+    protected setContent(text: string, selection?: ComposerSelection, raise?: boolean): void;
+    protected getAutoCompleteProviders(): AutoCompleteProviderDefinition[];
+    private insertSelectedRange;
+    /**
+     * Replace the current reference selected by the new one.
+     * */
+    private replaceSelectedRange;
+    /**
+     * Replace the reference of the old zone by the new one.
+     */
+    private updateComposerRange;
+    protected getZoneReference(zone: Zone | UnboundedZone): string;
+    private getRangeReference;
+    /**
+     * Replace the current selection by a new text.
+     * The cursor is then set at the end of the text.
+     */
+    private replaceSelection;
+    private replaceText;
+    /**
+     * Insert a text at the given position.
+     * The cursor is then set at the end of the text.
+     */
+    private insertText;
+    private updateTokenColor;
+    protected getTokenColor(token: EnrichedToken): string;
+    private rangeXCColor;
+    private rangeColor;
+    /**
+     * Compute for each token if it is part of the same
+     * formula as the current selector token.
+     * If no specific formula found for the current selected
+     * token, it assumes all tokens are part of the formula
+     * context.
+     */
+    private computeFormulaCursorContext;
+    private getParenthesesCodeAfterCursor;
+    private computeParenthesisRelatedToCursor;
+    private updateRangeColor;
+    /**
+     * Highlight all ranges that can be found in the composer content.
+     */
+    get highlights(): Highlight[];
+    /**
+     * Return ranges currently referenced in the composer
+     */
+    private getReferencedRanges;
+    private getFullySpreadRange;
+    private updateAutoCompleteProvider;
+    private findAutocompleteProvider;
+    hideHelp(): void;
+    autoCompleteOrStop(direction: Direction, assistantForcedClosed?: boolean): void;
+    insertAutoCompleteValue(proposal: AutoCompleteProposal): void;
+    selectAutoCompleteIndex(index: number): void;
+    moveAutoCompleteSelection(direction: "previous" | "next"): void;
+    /**
+     * Function used to determine when composer selection can start.
+     * Three conditions are necessary:
+     * - the previous token is among ["ARG_SEPARATOR", "LEFT_PAREN", "OPERATOR"], and is not a postfix unary operator
+     * - the next token is missing or is among ["ARG_SEPARATOR", "RIGHT_PAREN", "OPERATOR"]
+     * - Previous and next tokens can be separated by spaces
+     */
+    private canStartComposerRangeSelection;
+    private getMissingSymbols;
+}

package/dist/types/components/composer/composer/cell_composer_store.d.ts

@@ -0,0 +1,24 @@
+import { CellPosition, Command, Direction } from "../../../types";
+import { AbstractComposerStore, ComposerSelection } from "./abstract_composer_store";
+export declare class CellComposerStore extends AbstractComposerStore {
+    private canStopEdition;
+    stopEdition(direction?: Direction): void;
+    handle(cmd: Command): void;
+    get placeholder(): string | undefined;
+    get currentEditedCell(): CellPosition;
+    private onColumnsRemoved;
+    private onRowsRemoved;
+    private onAddElements;
+    protected confirmEdition(content: string): void;
+    protected getComposerContent(position: CellPosition, selection?: ComposerSelection): {
+        text: string;
+        adjustedSelection?: ComposerSelection;
+    };
+    private getPrettifiedFormula;
+    private numberComposerContent;
+    /** Add headers at the end of the sheet so the formula in the composer has enough space to spread */
+    private addHeadersForSpreadingFormula;
+    private checkDataValidation;
+    startEdition(text?: string, selection?: ComposerSelection): void | "NoStateChange";
+    protected evaluateCanonicalFormula(canonicalFormula: string): import("../../..").FunctionResultObject | import("../../..").Matrix<import("../../..").FunctionResultObject>;
+}

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

@@ -0,0 +1,194 @@
+import { Component } from "@odoo/owl";
+import { EnrichedToken } from "../../../formulas/composer_tokenizer";
+import { AutoCompleteProposal } from "../../../registries/auto_completes";
+import { Store } from "../../../store_engine";
+import { CSSProperties, Color, ComposerFocusType, DOMDimension, FunctionDescription, Rect } from "../../../types/index";
+import { SpreadsheetChildEnv } from "../../../types/spreadsheet_env";
+import { TextValueProvider } from "../autocomplete_dropdown/autocomplete_dropdown";
+import { ContentEditableHelper } from "../content_editable_helper";
+import { FunctionDescriptionProvider } from "../formula_assistant/formula_assistant";
+import { SpeechBubble } from "../speech_bubble/speech_bubble";
+import { AbstractComposerStore, ComposerSelection } from "./abstract_composer_store";
+export type HtmlContent = {
+    value: string;
+    onHover?: (rect: Rect) => void;
+    onStopHover?: () => void;
+    color?: Color;
+    backgroundColor?: Color;
+    classes?: string[];
+};
+export interface CellComposerProps {
+    focus: ComposerFocusType;
+    inputStyle?: string;
+    rect?: Rect;
+    delimitation?: DOMDimension;
+    onComposerContentFocused: (selection: ComposerSelection) => void;
+    onComposerCellFocused?: (content: string) => void;
+    onInputContextMenu?: (event: MouseEvent) => void;
+    isDefaultFocus?: boolean;
+    composerStore: Store<AbstractComposerStore>;
+    placeholder?: string;
+    inputMode?: ElementContentEditable["inputMode"];
+    showAssistant?: boolean;
+}
+interface ComposerState {
+    positionStart: number;
+    positionEnd: number;
+    hoveredRect: Rect | undefined;
+}
+interface FunctionDescriptionState {
+    showDescription: boolean;
+    functionDescription: FunctionDescription;
+    argsToFocus: number[];
+    repeatingArgGroupIndex: number | undefined;
+}
+export declare class Composer extends Component<CellComposerProps, SpreadsheetChildEnv> {
+    static template: string;
+    static props: {
+        focus: {
+            validate: (value: string) => boolean;
+        };
+        inputStyle: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        rect: {
+            type: ObjectConstructor;
+            optional: boolean;
+        };
+        delimitation: {
+            type: ObjectConstructor;
+            optional: boolean;
+        };
+        onComposerCellFocused: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+        onComposerContentFocused: FunctionConstructor;
+        isDefaultFocus: {
+            type: BooleanConstructor;
+            optional: boolean;
+        };
+        onInputContextMenu: {
+            type: FunctionConstructor;
+            optional: boolean;
+        };
+        composerStore: ObjectConstructor;
+        placeholder: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        inputMode: {
+            type: StringConstructor;
+            optional: boolean;
+        };
+        showAssistant: {
+            type: BooleanConstructor;
+            optional: boolean;
+        };
+    };
+    static components: {
+        TextValueProvider: typeof TextValueProvider;
+        FunctionDescriptionProvider: typeof FunctionDescriptionProvider;
+        SpeechBubble: typeof SpeechBubble;
+    };
+    static defaultProps: {
+        inputStyle: string;
+        isDefaultFocus: boolean;
+        inputMode: string;
+        showAssistant: boolean;
+    };
+    private DOMFocusableElementStore;
+    composerRef: {
+        el: HTMLElement | null;
+    };
+    containerRef: {
+        el: HTMLElement | null;
+    };
+    contentHelper: ContentEditableHelper;
+    composerState: ComposerState;
+    functionDescriptionState: FunctionDescriptionState;
+    assistant: {
+        forcedClosed: boolean;
+    };
+    private compositionActive;
+    private spreadsheetRect;
+    private lastHoveredTokenIndex;
+    private debouncedHover;
+    get assistantStyleProperties(): CSSProperties;
+    get assistantStyle(): string;
+    get assistantContainerStyle(): string;
+    shouldProcessInputEvents: boolean;
+    tokens: EnrichedToken[];
+    keyMapping: {
+        [key: string]: Function;
+    };
+    keyCodeMapping: {
+        [keyCode: string]: Function;
+    };
+    setup(): void;
+    private processArrowKeys;
+    private handleArrowKeysForAutocomplete;
+    private processTabKey;
+    private processEnterKey;
+    private processNewLineEvent;
+    private processEscapeKey;
+    private processF4Key;
+    private toggleEditionMode;
+    private processNumpadDecimal;
+    onCompositionStart(): void;
+    onCompositionEnd(): void;
+    onKeydown(ev: KeyboardEvent): void;
+    onPaste(ev: ClipboardEvent): void;
+    onInput(ev: InputEvent): void;
+    onKeyup(ev: KeyboardEvent): void;
+    onBlur(ev: FocusEvent): void;
+    /**
+     * This is required to ensure the content helper selection is
+     * properly updated on "onclick" events. Depending on the browser,
+     * the callback onClick from the composer will be executed before
+     * the selection was updated in the dom, which means we capture an
+     * wrong selection which is then forced upon the content helper on
+     * processContent.
+     */
+    onMousedown(ev: MouseEvent): void;
+    onMouseup(): void;
+    onClick(): void;
+    onDblClick(): void;
+    onContextMenu(ev: MouseEvent): void;
+    closeAssistant(): void;
+    openAssistant(): void;
+    onWheel(event: WheelEvent): void;
+    private processContent;
+    /**
+     * Get the HTML content corresponding to the current composer token, divided by lines.
+     */
+    private getContentLines;
+    private getHtmlContentFromTokens;
+    private onTokenHover;
+    /**
+     * Split an array of HTMLContents into lines. Each NEWLINE character encountered will create a new
+     * line. Contents can be split into multiple parts if they contain multiple NEWLINE characters.
+     */
+    private splitHtmlContentIntoLines;
+    private isContentEmpty;
+    /**
+     * Compute the state of the composer from the tokenAtCursor.
+     * If the token is a function or symbol (that isn't a cell/range reference) we have to initialize
+     * the autocomplete engine otherwise we initialize the formula assistant.
+     */
+    private processTokenAtCursor;
+    private getRepeatingArgGroupIndex;
+    /**
+     * Compute the arguments to focus depending on the current value position.
+     *
+     * Normally, 'argTargeting' is used to compute the argument to focus, but in the composer,
+     * we don't yet know how many arguments the user will supply.
+     *
+     * This function computes all the possible arguments to focus for different numbers of arguments supplied.
+     */
+    private getArgsToFocus;
+    autoComplete(proposal: AutoCompleteProposal): void;
+    get displaySpeechBubble(): boolean;
+}
+export {};

package/dist/types/components/composer/composer_focus_store.d.ts

@@ -0,0 +1,28 @@
+import { SpreadsheetStore } from "../../stores/spreadsheet_store";
+import { ComposerFocusType, EditionMode } from "../../types";
+import { ComposerSelection } from "./composer/abstract_composer_store";
+export interface ComposerInterface {
+    id: string;
+    editionMode: EditionMode;
+    startEdition(content?: string, selection?: ComposerSelection): void;
+    stopEdition(): void;
+    setCurrentContent(content: string, selection?: ComposerSelection): void;
+}
+interface Args {
+    focusMode?: ComposerFocusType;
+    content?: string;
+    selection?: ComposerSelection;
+}
+export declare class ComposerFocusStore extends SpreadsheetStore {
+    mutators: readonly ["focusComposer", "focusActiveComposer"];
+    activeComposer: ComposerInterface;
+    private _focusMode;
+    get focusMode(): ComposerFocusType;
+    focusComposer(listener: ComposerInterface, args: Args): "noStateChange" | undefined;
+    focusActiveComposer(args: Args): "noStateChange" | undefined;
+    /**
+     * Start the edition or update the content if it's already started.
+     */
+    private setComposerContent;
+}
+export {};