@ones-editor/editor 2.1.7-beta.14 → 2.1.7-beta.16

package/@ones-editor/ui/src/link-popup/mobile-link-popup.d.ts

@@ -0,0 +1,22 @@
+import './index.scss';
+import { TypedEmitter } from 'tiny-typed-emitter';
+import { OnesEditor } from '../../../../@ones-editor/core';
+import { LinkEditorEvents, LinkEditorOptions, LinkPopupType } from './types';
+export declare class MobileLinkPopup extends TypedEmitter<LinkEditorEvents> implements LinkPopupType {
+    private editor;
+    private content;
+    private options;
+    private linkPopup;
+    private onShow;
+    constructor(editor: OnesEditor, content: HTMLElement, options: LinkEditorOptions);
+    close: () => void;
+    private createItems;
+    private createHeader;
+    handleOk: () => void;
+    handleClose: () => void;
+    handleShown: () => void;
+    disabledSubmit: () => void;
+    enableSubmit: () => void;
+    manualShow: () => void;
+    destroy(): void;
+}

package/@ones-editor/ui/src/link-popup/types.d.ts

@@ -0,0 +1,34 @@
+import { Placement } from '../../../../@ones-editor/ui-base';
+import { TypedEmitter } from 'tiny-typed-emitter';
+export interface FormField {
+    getInputValue: () => string;
+    setFieldError: (error: string) => void;
+    getField: () => HTMLElement;
+}
+export interface Form {
+    [key: string]: FormField;
+}
+export type OnFinished = (linkText: string, linkUrl: string) => void;
+export type OnClose = () => void;
+export type OnBeforeFormatUrl = (linkUrl: string) => string | false;
+export interface LinkEditorOptions {
+    target: HTMLElement;
+    linkText: string;
+    linkUrl: string;
+    onFinished: OnFinished;
+    onClose?: OnClose;
+    onBeforeFormatUrl?: OnBeforeFormatUrl;
+    placement?: Placement;
+}
+export interface LinkEditorEvents {
+    show: () => void;
+    finished: () => void;
+    close: () => void;
+}
+export interface LinkPopupType extends TypedEmitter<LinkEditorEvents> {
+    disabledSubmit: () => void;
+    enableSubmit: () => void;
+    destroy: () => void;
+    close: () => void;
+    manualShow: () => void;
+}

package/@ones-editor/ui/src/link-popup/web-link-popup.d.ts

@@ -0,0 +1,19 @@
+import { TypedEmitter } from 'tiny-typed-emitter';
+import { LinkEditorEvents, LinkEditorOptions, LinkPopupType } from './types';
+import './index.scss';
+export declare class LinkPopup extends TypedEmitter<LinkEditorEvents> implements LinkPopupType {
+    private content;
+    private options;
+    private linkPopup;
+    private onShow;
+    constructor(content: HTMLElement, options: LinkEditorOptions);
+    private createPopupContent;
+    handleOk: () => void;
+    handleClose: () => void;
+    close: () => void;
+    disabledSubmit: () => void;
+    enableSubmit: () => void;
+    manualShow: () => void;
+    static showPopup: (content: HTMLElement, options: LinkEditorOptions) => LinkPopup;
+    destroy(): void;
+}

package/@ones-editor/ui/src/locale/en-us.d.ts

@@ -43,6 +43,15 @@ declare const _default: {
         paste: string;
         tab: string;
         shiftTab: string;
+        bold: string;
+        italic: string;
+        underline: string;
+        strikethrough: string;
+        code: string;
+        subscript: string;
+        superscript: string;
+        more: string;
+        selectBlock: string;
     };
 };
 export default _default;

package/@ones-editor/ui/src/locale/ja-jp.d.ts

@@ -43,6 +43,15 @@ declare const _default: {
         paste: string;
         tab: string;
         shiftTab: string;
+        bold: string;
+        italic: string;
+        underline: string;
+        strikethrough: string;
+        code: string;
+        subscript: string;
+        superscript: string;
+        more: string;
+        selectBlock: string;
     };
 };
 export default _default;

package/@ones-editor/ui/src/locale/zh-cn.d.ts

@@ -43,6 +43,15 @@ declare const _default: {
         paste: string;
         tab: string;
         shiftTab: string;
+        bold: string;
+        italic: string;
+        underline: string;
+        strikethrough: string;
+        code: string;
+        subscript: string;
+        superscript: string;
+        more: string;
+        selectBlock: string;
     };
 };
 export default _default;

package/@ones-editor/ui/src/providers/insert-above.d.ts

@@ -1,9 +1,9 @@
-import { BlockElement, CommandItem, CommandParams, OnesEditor, SelectionRange } from '../../../../@ones-editor/core';
+import { BlockElement, CommandItem, CommandItemWithSource, CommandParams, OnesEditor, SelectionRange } from '../../../../@ones-editor/core';
 import { ProxyProvider } from './proxy-provider';
 export default class InsertAboveProvider extends ProxyProvider {
     private editor;
     id: string;
     constructor(editor: OnesEditor);
     getAvailableCommands: (editor: OnesEditor, block: BlockElement) => CommandItem[];
-    executeCommand: (editor: OnesEditor, block: BlockElement, range: SelectionRange, command: CommandItem, params: CommandParams) => boolean;
+    executeCommand: (editor: OnesEditor, block: BlockElement, range: SelectionRange, command: CommandItemWithSource, params: CommandParams) => boolean;
 }

package/@ones-editor/ui/src/providers/insert-after.d.ts

@@ -1,9 +1,9 @@
-import { BlockElement, CommandItem, CommandParams, OnesEditor, SelectionRange } from '../../../../@ones-editor/core';
+import { BlockElement, CommandItem, CommandItemWithSource, CommandParams, OnesEditor, SelectionRange } from '../../../../@ones-editor/core';
 import { ProxyProvider } from './proxy-provider';
 export default class InsertAfterProvider extends ProxyProvider {
     private editor;
     id: string;
     constructor(editor: OnesEditor);
     getAvailableCommands: (editor: OnesEditor, block: BlockElement) => CommandItem[];
-    executeCommand: (editor: OnesEditor, block: BlockElement, range: SelectionRange, command: CommandItem, params: CommandParams) => boolean;
+    executeCommand: (editor: OnesEditor, block: BlockElement, range: SelectionRange, command: CommandItemWithSource, params: CommandParams) => boolean;
 }

package/@ones-editor/ui/src/providers/insert-box-provider.d.ts

@@ -1,4 +1,4 @@
-import { BlockElement, CommandItem, CommandParams, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../@ones-editor/core';
+import { BlockElement, CommandItem, CommandItemWithSource, CommandParams, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../@ones-editor/core';
 import { ProxyProvider } from './proxy-provider';
 export declare class InlineBoxCommandProvider extends ProxyProvider implements OnesEditorCommandProvider {
     private editor;
@@ -7,6 +7,6 @@ export declare class InlineBoxCommandProvider extends ProxyProvider implements O
     create(commands: CommandItem[]): CommandItem[];
     getAvailableCommands: (editor: OnesEditor, block: BlockElement, range: SelectionRange) => CommandItem[];
     getInsertCommands: (editor: OnesEditor, containerId: string) => CommandItem[];
-    executeCommand: (editor: OnesEditor, block: BlockElement, range: SelectionRange, item: CommandItem, params: CommandParams) => boolean;
-    executeInsertCommand: (editor: OnesEditor, containerId: string, blockIndex: number, item: CommandItem, params: CommandParams) => boolean;
+    executeCommand: (editor: OnesEditor, block: BlockElement, range: SelectionRange, item: CommandItemWithSource, params: CommandParams) => boolean;
+    executeInsertCommand: (editor: OnesEditor, containerId: string, blockIndex: number, item: CommandItemWithSource, params: CommandParams) => boolean;
 }

package/@ones-editor/ui/src/providers/insert-menu.d.ts

@@ -1,4 +1,4 @@
-import { BlockElement, CommandItem, CommandParams, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../@ones-editor/core';
+import { BlockElement, CommandItem, CommandItemWithSource, CommandParams, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../@ones-editor/core';
 import { ProxyProvider } from './proxy-provider';
 import { QuickMenuCommandProvider } from '../quick-menu/types';
 export default class InsertMenuProvider extends ProxyProvider {
@@ -11,6 +11,6 @@ export default class InsertMenuProvider extends ProxyProvider {
     constructor(editor: OnesEditor, options?: CommandParams | undefined);
     getInsertCommands: (editor: OnesEditor, containerId: string) => CommandItem[];
     getAvailableCommands: (editor: OnesEditor, block: BlockElement, range: SelectionRange) => CommandItem[];
-    executeInsertCommand: (editor: OnesEditor, containerId: string, blockIndex: number, item: CommandItem, params: CommandParams) => boolean;
-    executeCommand: (editor: OnesEditor, block: BlockElement, range: SelectionRange, item: CommandItem, params: CommandParams) => boolean;
+    executeInsertCommand: (editor: OnesEditor, containerId: string, blockIndex: number, item: CommandItemWithSource, params: CommandParams) => boolean;
+    executeCommand: (editor: OnesEditor, block: BlockElement, range: SelectionRange, item: CommandItemWithSource, params: CommandParams) => boolean;
 }

package/@ones-editor/ui/src/providers/mobile-link-provider.d.ts

@@ -1,10 +1,13 @@
-import { BlockElement, CommandItem, CommandParams, CommandResult, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../@ones-editor/core';
+import { BlockElement, CommandItem, CommandItemWithSource, CommandParams, CommandResult, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../@ones-editor/core';
 export declare class MobileLinkProvider implements OnesEditorCommandProvider {
+    private options?;
     id: string;
     insertProvider: OnesEditorCommandProvider;
     editProvider: OnesEditorCommandProvider;
-    constructor(editor: OnesEditor);
+    constructor(editor: OnesEditor, options?: {
+        linkMode: 'insert' | 'edit';
+    } | undefined);
     getSelectedLinkChild: (editor: OnesEditor, range: SelectionRange) => import("@ones-editor/core").TextBlockContentChild | null;
     getAvailableCommands: (editor: OnesEditor, block: BlockElement, range: SelectionRange, params?: CommandParams) => CommandItem[];
-    executeCommand: (editor: OnesEditor, block: BlockElement, range: SelectionRange, item: CommandItem, params: CommandParams, result?: CommandResult) => boolean;
+    executeCommand: (editor: OnesEditor, block: BlockElement, range: SelectionRange, item: CommandItemWithSource, params: CommandParams, result?: CommandResult) => boolean;
 }

package/@ones-editor/ui/src/providers/proxy-provider.d.ts

@@ -1,9 +1,9 @@
-import { BlockElement, CommandItem, CommandParams, CommandResult, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../@ones-editor/core';
+import { BlockElement, CommandItem, CommandItemWithSource, CommandParams, CommandResult, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../@ones-editor/core';
 export declare abstract class ProxyProvider implements OnesEditorCommandProvider {
     abstract id: string;
     providers: OnesEditorCommandProvider[];
     getAvailableCommands: (editor: OnesEditor, block: BlockElement, range: SelectionRange, params?: CommandParams) => CommandItem[];
     getInsertCommands: (editor: OnesEditor, containerId: string) => CommandItem[];
-    executeCommand(editor: OnesEditor, block: BlockElement, range: SelectionRange, command: CommandItem, params: CommandParams, result?: CommandResult): boolean;
-    executeInsertCommand: (editor: OnesEditor, containerId: string, blockIndex: number, item: CommandItem, params: CommandParams, result?: CommandResult) => boolean;
+    executeCommand(editor: OnesEditor, block: BlockElement, range: SelectionRange, command: CommandItemWithSource, params: CommandParams, result?: CommandResult): boolean;
+    executeInsertCommand: (editor: OnesEditor, containerId: string, blockIndex: number, item: CommandItemWithSource, params: CommandParams, result?: CommandResult) => boolean;
 }

package/@ones-editor/ui/src/providers/selection-provider.d.ts

@@ -0,0 +1,9 @@
+import { BlockElement, CommandItem, CommandParams, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../@ones-editor/core';
+export default class SelectionProvider implements OnesEditorCommandProvider {
+    private editor;
+    id: string;
+    constructor(editor: OnesEditor);
+    getAvailableCommands(editor: OnesEditor, block: BlockElement, range: SelectionRange, params?: CommandParams): CommandItem[];
+    getInsertCommands: () => never[];
+    executeCommand(editor: OnesEditor, block: BlockElement, range: SelectionRange, command: CommandItem): boolean;
+}

package/@ones-editor/ui/src/providers/text-command-provider.d.ts

@@ -1,4 +1,4 @@
-import { BlockAttributesHandler, BlockElement, CommandItem, CommandParams, CommandResult, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../@ones-editor/core';
+import { BlockAttributesHandler, BlockElement, CommandItem, CommandItemWithSource, CommandParams, CommandResult, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../@ones-editor/core';
 export default class TextCommandProvider implements OnesEditorCommandProvider {
     private editor;
     private options?;
@@ -7,7 +7,7 @@ export default class TextCommandProvider implements OnesEditorCommandProvider {
     private providers;
     constructor(editor: OnesEditor, options?: CommandParams | undefined);
     getAvailableCommands(editor: OnesEditor, block: BlockElement, range: SelectionRange): CommandItem[];
-    executeCommand(editor: OnesEditor, block: BlockElement, range: SelectionRange, item: CommandItem, params: CommandParams, result?: CommandResult): boolean;
+    executeCommand(editor: OnesEditor, block: BlockElement, range: SelectionRange, item: CommandItemWithSource, params: CommandParams, result?: CommandResult): boolean;
     get blockAttributesHandler(): BlockAttributesHandler;
     private executeCommandOnEmptyText;
     private setCommandsStates;

package/@ones-editor/ui/src/providers/utils/text-styles.d.ts

@@ -2,5 +2,5 @@ import { BlockElement, CommandItem, DocBlockText, OnesEditor, SelectionRange, Te
 export declare function getIntersectionStyles(text: DocBlockText): Map<any, any>;
 export declare function getTextStyles(editor: OnesEditor, block: BlockElement, range: SelectionRange): TextStyles;
 export declare function applyTextStyle(editor: OnesEditor, block: BlockElement, range: SelectionRange, style: string, value?: boolean | string | number): DocBlockText;
-export declare function getStandardTextStyles(textStyles: CommandItem[], text: DocBlockText): CommandItem[];
+export declare function getStandardTextStyles(editor: OnesEditor, textStyles: CommandItem[], text: DocBlockText): CommandItem[];
 export declare function getSubText(editor: OnesEditor, block: BlockElement, range: SelectionRange): DocBlockText;

package/@ones-editor/ui/src/readonly-toolbar/index.d.ts

@@ -17,7 +17,7 @@ export declare class ReadonlyToolbar implements OnesEditorCustom {
     isInBlock(block: BlockElement, event: MouseEvent): boolean;
     handleButtonClick: (toolbar: AbstractCommandBar, item: CommandItem) => void;
     handleClose: () => void;
-    handleClosing: (bar: unknown, event: MouseEvent) => boolean;
+    handleClosing: (bar: unknown, event: MouseEvent | TouchEvent) => boolean;
     bindEvents(): void;
     unbindEvents(): void;
     handleDocumentMouseDown: (event: MouseEvent) => void;

package/@ones-editor/ui/src/toolbar/toolbar-handler.d.ts

@@ -24,7 +24,7 @@ export default class OnesEditorToolbar implements OnesEditorHoveringBlockFilter,
     isInBlock(block: BlockElement, event: MouseEvent): boolean;
     handleButtonClick: (toolbar: AbstractCommandBar, item: CommandItem) => void;
     handleClose: () => void;
-    handleClosing: (bar: unknown, event: MouseEvent) => boolean;
+    handleClosing: (bar: unknown, event: MouseEvent | TouchEvent) => boolean;
     bindEvents(): void;
     unbindEvents(): void;
     handleDocumentMouseDown: (event: MouseEvent) => void;

package/@ones-editor/ui-base/src/auto-suggest/auto-suggest-menu.d.ts

@@ -16,6 +16,7 @@ export interface AutoSuggestMenuOptions {
     disableSelectedScroll?: boolean;
     onClose?: () => void;
     onShow?: (menu: AutoSuggestMenu) => boolean | undefined;
+    onShown?: (menu: AutoSuggestMenu) => void;
     onClickItem: (menu: AutoSuggestMenu, item: CommandItem) => void;
     queryItems: (menu: AutoSuggestMenu, text: string) => Promise<CommandItem[]>;
     renderMenuItem?: (menu: AutoSuggestMenu, item: CommandItem) => HTMLElement | undefined;
@@ -40,6 +41,7 @@ export default class AutoSuggestMenu {
     handleSearchTextPure(text: string): Promise<void>;
     handleClick: import("lodash").DebouncedFuncLeading<(menu: AbstractCommandBar, item: CommandItem) => void>;
     handleShow: (menu: AbstractCommandBar) => void;
+    handleShown: () => void;
     handleClose: () => void;
     handleKeydown: (event: KeyboardEvent) => boolean;
     protected highlightText(search: string, items?: CommandItem[]): void;

package/@ones-editor/ui-base/src/auto-suggest/auto-suggest.d.ts

@@ -26,6 +26,7 @@ export interface AutoSuggestOptions {
     onClickItem: (menu: OnesEditorAutoSuggest, item: CommandItem, anchor: AutoSuggestAnchor) => void;
     queryItems: (menu: OnesEditorAutoSuggest, text: string) => Promise<CommandItem[]>;
     renderMenuItem?: (menu: OnesEditorAutoSuggest, item: CommandItem) => HTMLElement | undefined;
+    onShown?: (menu: OnesEditorAutoSuggest) => void;
 }
 declare class OnesEditorAutoSuggest implements OnesEditorInputHandler {
     private editor;
@@ -46,6 +47,7 @@ declare class OnesEditorAutoSuggest implements OnesEditorInputHandler {
     deleteTrigger: () => boolean;
     private onClose;
     private onShow;
+    private onShown;
     private onClickItem;
     private queryItems;
     private renderMenuItem;

package/@ones-editor/ui-base/src/color-button/text-color-item.d.ts

@@ -17,13 +17,14 @@ export declare class TextColorItem extends TypedEmitter<ColorPaletteEvents> impl
     element: HTMLButtonElement;
     colorPaletteItem: ColorPaletteItem;
     latestColors: [number | null, number | null];
+    private currentTextColors;
     constructor(editor: OnesEditor, storageName?: string);
     destroy(): void;
     handlePaletteClick: (type: 'color' | 'backgroundColor' | 'clearColor', value: number) => void;
     handleButtonClick: (event: MouseEvent) => void;
-    setLatestColors: (type: 'color' | 'backgroundColor' | 'clearColor', value: number) => void;
+    private setLatestColors;
     beforePopup: () => void;
     updatePaletteColor(colors: [number | null, number | null]): void;
-    updateButtonColor(colors: [number | null, number | null]): void;
+    setCurrentTextColors(colors: [number | null, number | null]): void;
     getButtonColor: () => (number | null)[];
 }

package/@ones-editor/ui-base/src/color-palette/color-palette.d.ts

@@ -14,5 +14,5 @@ export default class ColorPalette extends TypedEmitter<ColorPaletteEvents> {
     constructor(options?: ColorPaletteOptions);
     destroy(): void;
     setColor(type: ColorType, value: number | null): void;
-    handleClick: (event: MouseEvent | PointerEvent) => void;
+    handleClick: (event: MouseEvent) => void;
 }

package/@ones-editor/ui-base/src/command-bar/command-bar.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="lodash" />
 import { TypedEmitter } from 'tiny-typed-emitter';
 import { CloseReason, CommandItem, Closeable } from '../../../../@ones-editor/core';
 import { AbstractManualCommandBar, AbstractCommandBar, CommandBarEvents, CommandBarOptions, CommandItemElement, CreateManualCommandBarFunction, ManualShowCommandBarOptions, SelectItemFrom } from './types';
@@ -23,14 +22,16 @@ export default abstract class CommandBar extends TypedEmitter<CommandBarEvents>
     get isSubCommandBar(): boolean;
     updateItems(items: CommandItem[]): void;
     handleDocumentKeydown: (event: KeyboardEvent) => boolean;
-    protected handleDocumentMouseDown: (event: MouseEvent) => void;
+    protected handleDocumentMouseDown: (event: MouseEvent | TouchEvent) => void;
     protected handleHidden: () => void;
+    protected handleShown: () => void;
     protected handleShow: () => void;
     get popper(): Element | null;
     private getSelectedItemIndex;
     private getPrevItemIndex;
     private getNextItemIndex;
-    protected clearSelectedItem: import("lodash").DebouncedFunc<() => void>;
+    protected clearSelectedItem(): void;
+    private debounceClearSelectedItem;
     selectItem(id: string, from?: SelectItemFrom): void;
     private lastEnterPauseTime;
     private startPauseMouseEnter;

package/@ones-editor/ui-base/src/command-bar/fixed-toolbar.d.ts

@@ -1,12 +1,11 @@
 import { CommandItem } from '../../../../@ones-editor/core';
 import CommandBar from './command-bar';
-import { AbstractManualCommandBar, CommandBarOptions, CommandItemElement, ManualShowCommandBarOptions } from './types';
+import { CommandBarOptions, CommandItemElement, ManualShowCommandBarOptions } from './types';
 export default class FixedToolbar extends CommandBar {
     constructor(parent: HTMLElement, items: CommandItem[], options?: CommandBarOptions);
     protected initCommandBarElement(elem: HTMLElement): void;
     protected initItemElement(item: CommandItem, elem: CommandItemElement): void;
     close(): void;
-    onShown: (instance: AbstractManualCommandBar) => void;
     getSubBarOptions: (item: CommandItem) => ManualShowCommandBarOptions;
     destroy(): void;
     protected getCommandBarRoot(): HTMLElement | null;

package/@ones-editor/ui-base/src/command-bar/manual-command-bar.d.ts

@@ -4,6 +4,7 @@ import CommandBar from './command-bar';
 import { AbstractManualCommandBar, ManualShowCommandBarOptions } from './types';
 export default abstract class ManualCommandBar extends CommandBar implements AbstractManualCommandBar {
     tippyInstance: Instance | null;
+    setProps: (props: ManualShowCommandBarOptions) => void;
     manualShow(target: HTMLElement, options?: ManualShowCommandBarOptions): void;
     close(reason: CloseReason): void;
     destroy(): void;

package/@ones-editor/ui-base/src/command-bar/types.d.ts

@@ -4,10 +4,12 @@ import type { GetReferenceClientRect, Placement } from 'tippy.js';
 export { Placement };
 export interface CommandBarEvents {
     'show': (bar: AbstractCommandBar) => void;
+    'shown': (bar: AbstractCommandBar) => void;
     'click': (bar: AbstractCommandBar, item: CommandItem, elem: HTMLElement) => void;
     'close': (bar: AbstractCommandBar) => void;
     'selectionChange': (bar: AbstractCommandBar, id: string) => void;
-    'closing': (bar: AbstractCommandBar, event: MouseEvent) => boolean | undefined;
+    'closing': (bar: AbstractCommandBar, event: MouseEvent | TouchEvent) => boolean | undefined;
+    'subBarShown': (bar: AbstractCommandBar, subBar: AbstractCommandBar) => void;
 }
 export interface ManualShowCommandBarOptions {
     placement?: Placement;
@@ -19,7 +21,6 @@ export interface ManualShowCommandBarOptions {
     getReferenceClientRect?: GetReferenceClientRect | null | undefined;
     offset?: [number, number];
     arrow?: boolean;
-    onShown?(instance: AbstractManualCommandBar): void;
 }
 export interface AbstractCommandBar extends TypedEmitter<CommandBarEvents> {
     readonly isVisible: boolean;
@@ -30,6 +31,7 @@ export interface AbstractCommandBar extends TypedEmitter<CommandBarEvents> {
     handleDocumentKeydown: (event: KeyboardEvent) => boolean;
     getSubBarOptions: (item: CommandItem) => ManualShowCommandBarOptions;
     updateItems: (items: CommandItem[]) => void;
+    setProps?: (props: ManualShowCommandBarOptions) => void;
 }
 export interface ShowCommandBarOptions {
     placement?: Placement;

package/@ones-editor/ui-base/src/dialog/manual-close-dialog.d.ts

@@ -20,6 +20,6 @@ export default class ManualCloseDialog extends ManualCommandBar {
         getReferenceClientRect?: GetReferenceClientRect | null | undefined;
     }): void;
     get dialogContent(): HTMLElement | ((item: CommandItem) => HTMLElement);
-    handleDocumentMouseDown: (event: MouseEvent) => void;
+    handleDocumentMouseDown: () => void;
     static getCommandItems(content: HTMLElement, options?: ManualCloseDialogOptions): CommandItem[];
 }

package/@ones-editor/ui-base/src/index.d.ts

@@ -17,4 +17,5 @@ export * from './item-shortcuts';
 export * from './emoji-item';
 export * from './mobile-command-bar/mobile-bottom-menu';
 export * from './text-button';
+export { scrollBarIntoView } from './mobile-command-bar/scroll-into-view';
 export { tippy, };

package/@ones-editor/ui-base/src/input/create-input.d.ts

@@ -11,7 +11,7 @@ export type EditorInputOptions = {
     prefix?: Element;
     suffixClose?: boolean;
 };
-declare class EditorInput {
+export declare class EditorInput {
     private parent;
     private options;
     private unbindKeyDownEvent;
@@ -28,10 +28,10 @@ declare class EditorInput {
     handleKeyDown: (e: KeyboardEvent, composing: boolean) => void;
     showSuffix: () => void;
     hideSuffix: () => void;
+    reset: () => void;
     handleInput: (e: Event) => void;
     handleClose: (e: Event | TouchEvent) => void;
     init(): HTMLDivElement;
     destroy(): void;
 }
 export declare function createInput(parent: HTMLElement, options: EditorInputOptions): EditorInput;
-export {};

package/@ones-editor/ui-base/src/mobile-command-bar/mobile-bottom-menu.d.ts

@@ -8,13 +8,11 @@ declare class MobileBottomMenu extends CommandBar implements AbstractManualComma
     createContentWithHeader: () => HTMLDivElement;
     handleClose: () => void;
     oldActiveElement: HTMLElement | null;
-    handleShown: () => void;
     manualShow: (target: HTMLElement, options?: ManualShowCommandBarOptions) => void;
     close(reason: CloseReason): void;
     destroy(): void;
     get isVisible(): boolean;
     get popper(): Element | null;
-    getSubBarOptions: (item: CommandItem) => ManualShowCommandBarOptions;
     protected initCommandBarElement(elem: CommandBarContentElement): void;
     protected getCommandBarRoot(): HTMLElement | null;
     protected initItemElement(item: CommandItem, elem: CommandItemElement): void;

package/@ones-editor/ui-base/src/mobile-command-bar/scroll-into-view.d.ts

@@ -0,0 +1,3 @@
+import { OnesEditor } from '../../../../@ones-editor/core';
+import { AbstractCommandBar } from '../command-bar';
+export declare const scrollBarIntoView: (editor: OnesEditor, bar: AbstractCommandBar) => void;

package/dist/index.d.ts

@@ -12,6 +12,7 @@ import ShareDBDocVersionsProvider from './versions/versions-provider';
 import { CreateLocalEditorOptions, CreateOnesEditorOptions } from './types';
 import './lang';
 import './style.scss';
+export * from '../@ones-editor/scroll-container';
 export * from '../@ones-editor/to-docx';
 export * from '../@ones-editor/core';
 export * from '../@ones-editor/sharedb-doc';
@@ -79,6 +80,7 @@ export declare function getDefaultOnesEditorOptions(options: CreateOnesEditorOpt
             mathjax?: import("@ones-editor/mathjax").MathjaxOptions | undefined;
             link?: import("@ones-editor/ui/src/link-popup").LinkOptions | undefined;
             columns?: import("@ones-editor/layout-block/src/types").EditorConfigLayoutOptions | undefined;
+            mobile?: import("@ones-editor/core").MobileClient | undefined;
         };
     };
     shortcuts: import("@ones-editor/core").ShortcutRecords[];