@ones-editor/editor 2.1.8-beta.6 → 2.1.8-beta.7

package/@ones-editor/ui/src/providers/utils/add-section.d.ts

@@ -0,0 +1,2 @@
+import { CommandItem } from '../../../../../@ones-editor/core';
+export declare const addSection: (items: CommandItem[]) => CommandItem[];

package/@ones-editor/ui/src/{quick-menu → providers/utils}/basic-commands.d.ts

@@ -1,5 +1,4 @@
-import { BlockElement, OnesEditor } from '../../../../@ones-editor/core';
+import { BlockElement, OnesEditor } from '../../../../../@ones-editor/core';
 export declare function applyHeadingStyle(editor: OnesEditor, block: BlockElement, heading: number | null): void;
 export declare function applyAlignStyle(editor: OnesEditor, block: BlockElement, align: string): void;
 export declare function applyQuoteStyle(editor: OnesEditor, block: BlockElement): void;
-export declare function applyList(editor: OnesEditor, block: BlockElement, id: 'unordered-list' | 'ordered-list' | 'check-list'): void;

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

@@ -0,0 +1,6 @@
+export declare function blobToString(blob: Blob): Promise<string>;
+export declare function isClipboardEmpty(): Promise<boolean>;
+export declare function saveAs(resourceUrl: string, resourceId: string): void;
+export declare function blob2String(blob: Blob): Promise<string>;
+export declare function getRandomFileName(mimeType: string, length?: number): string;
+export declare function getClipboardData(): Promise<DataTransfer>;

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

@@ -0,0 +1,2 @@
+import { OnesEditor } from '../../../../../@ones-editor/core';
+export declare const isSelectedTitleBlock: (editor: OnesEditor) => boolean;

package/@ones-editor/ui/src/providers/utils/inject-block-options.d.ts

@@ -0,0 +1,8 @@
+import { BlockOptions, CommandItem } from '../../../../../@ones-editor/core';
+import { QuickMenuCommandProvider } from '../../quick-menu/types';
+export interface QuickMenuItem extends CommandItem {
+    blockOptions?: BlockOptions;
+    commandProvider?: QuickMenuCommandProvider;
+}
+export declare const injectBlockOptions: (commands: QuickMenuItem[], blockOptions: BlockOptions) => void;
+export declare const injectCommandProvider: (commands: QuickMenuItem[], commandProvider: QuickMenuCommandProvider) => void;

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

@@ -0,0 +1,6 @@
+import { BlockElement, CommandItem, DocBlockText, OnesEditor, SelectionRange, TextStyles } from '../../../../../@ones-editor/core';
+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(editor: OnesEditor, textStyles: CommandItem[], text: DocBlockText): CommandItem[];
+export declare function getSubText(editor: OnesEditor, block: BlockElement, range: SelectionRange): DocBlockText;

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

@@ -1,33 +1,21 @@
-import { OnesEditor, CommandItem } from '../../../../@ones-editor/core';
+import { OnesEditor, CommandItem, CommandFilterId, CommandFilter } from '../../../../@ones-editor/core';
 import { OnesEditorAutoSuggest } from '../../../../@ones-editor/ui-base';
-import { QuickMenuItemFilter, QuickMenuItemFilterId, QuickMenuItem, QuickMenuOptions } from './types';
-import { getHeadingMenuOptions } from './basic-menu-items';
-import * as BasicCommands from './basic-commands';
-export * from './types';
-export * from './quick-menu-items';
-export { getHeadingMenuOptions, BasicCommands };
+import { QuickMenuOptions } from './types';
 export default class OnesEditorQuickMenu {
     protected editor: OnesEditor;
     private options;
     protected suggest: OnesEditorAutoSuggest;
-    private _items;
-    private maxHeading;
+    private items;
     private firstEmptyOffset;
-    private commandFilters;
-    private currentContainerId;
-    private currentBlockIndex;
-    private get selectedBlock();
-    private get items();
-    private set items(value);
+    private quickCommandProviders;
     constructor(editor: OnesEditor, options?: QuickMenuOptions);
-    get menu(): import("@ones-editor/ui-base").ManualMenu;
-    addFilter(id: QuickMenuItemFilterId, filter: QuickMenuItemFilter): void;
+    get menu(): import("@ones-editor/ui-base").ManualMenu | import("@ones-editor/ui-base/src/mobile-command-bar/mobile-bottom-menu").MobileBottomMenu;
+    addFilter(id: CommandFilterId, filter: CommandFilter): void;
     destroy(): void;
-    queryItems: (suggest: unknown, text: string) => Promise<QuickMenuItem[]>;
+    queryItems: (suggest: unknown, text: string) => Promise<CommandItem[]>;
     onClose: () => void;
     onShow: (suggest: OnesEditorAutoSuggest, containerId: string, blockIndex: number, offset: number) => boolean;
     onClickItem: (suggest: unknown, item: CommandItem) => void;
     private initMenuItems;
-    private refreshMenuItems;
     private handleEmptySearch;
 }

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

@@ -0,0 +1,8 @@
+import { AbstractProvider, CommandItemWithSource, OnesEditor, OnesEditorCommandProviders, SelectionRange } from '../../../../@ones-editor/core';
+export declare class QuickCommandProviders extends AbstractProvider implements OnesEditorCommandProviders {
+    protected editor: OnesEditor;
+    id: string;
+    constructor(editor: OnesEditor);
+    getCommands(range: SelectionRange): CommandItemWithSource[];
+    executeCommand: (range: SelectionRange, item: CommandItemWithSource) => {};
+}

package/@ones-editor/ui/src/quick-menu/types.d.ts

@@ -1,4 +1,4 @@
-import { CommandItem, BlockOptions, OnesEditor, BlockElement } from '../../../../@ones-editor/core';
+import { CommandItem, BlockOptions, OnesEditor, BlockElement, SelectionRange } from '../../../../@ones-editor/core';
 export interface QuickMenuItem extends CommandItem {
     itemType: 'insert-block';
     blockType?: string;
@@ -26,11 +26,8 @@ export interface QuickMenuCommandBetween extends QuickMenuCommandParams {
 export interface QuickMenuCommandProvider {
     getCommands: (editor: OnesEditor, params: QuickMenuCommandParams) => CommandItem[];
     executeCommand: (editor: OnesEditor, item: CommandItem, params: QuickMenuCommandInline | QuickMenuCommandBetween | AddMenuCommand) => Promise<BlockElement | null>;
+    filterCommands?: (editor: OnesEditor, items: CommandItem[], range: SelectionRange) => CommandItem[];
 }
-export interface QuickMenuItemFilter {
-    filter: (editor: OnesEditor, items: QuickMenuItem[], from: QuickMenuCommandParams['from']) => QuickMenuItem[];
-}
-export type QuickMenuItemFilterId = keyof any;
 export interface QuickMenuOptions {
     id?: string;
     trigger: string[];

package/@ones-editor/ui/src/readonly-toolbar/add-comment-to-old-doc.d.ts

@@ -0,0 +1,22 @@
+import { BlockElement, CommandItem, OnesEditor, OnesEditorBlockHook, SelectionRange, TextBlockContentChild } from '../../../../@ones-editor/core';
+import { ReadonlyCommandOptions, ReadonlyToolbarCommandProvider } from './types';
+export declare class AddCommentToOldDocCommandProvider implements ReadonlyToolbarCommandProvider, OnesEditorBlockHook {
+    private editor;
+    private version;
+    private localCreatedComments;
+    constructor(editor: OnesEditor, version: number);
+    onCreateComment(commentId: string, local: boolean): Promise<void>;
+    onDeleteComment(commentId: string, local: boolean): Promise<void>;
+    onUpdateComment(commentId: string, local: boolean): Promise<void>;
+    hideToolbar(editor: OnesEditor): void;
+    commands(editor: OnesEditor, blockElement: BlockElement, child: TextBlockContentChild | null): {
+        group: string;
+        commands: {
+            id: string;
+            name: string;
+        }[];
+        executeCommand: (editor: OnesEditor, block: BlockElement, item: CommandItem, child: TextBlockContentChild | null) => void;
+    } | undefined;
+    getTextCommands(editor: OnesEditor, range: SelectionRange): CommandItem[];
+    executeCommand(editor: OnesEditor, command: CommandItem, options: ReadonlyCommandOptions): void;
+}

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

@@ -0,0 +1,29 @@
+/// <reference types="lodash" />
+import { BlockElement, CommandItem, OnesEditor, OnesEditorCustom, SelectionRange, TextBlockContentChild } from '../../../../@ones-editor/core';
+import { AbstractCommandBar, ManualToolbar } from '../../../../@ones-editor/ui-base';
+import type { ReadonlyToolbarCommandProvider } from './types';
+export declare class ReadonlyToolbar implements OnesEditorCustom {
+    private editor;
+    toolbar: ManualToolbar;
+    toolbarType: 'text' | 'object';
+    mouseDown: boolean;
+    hoveringBlock: BlockElement | null;
+    hoveringTextChild: TextBlockContentChild | null;
+    oldRange: SelectionRange | null;
+    providers: ReadonlyToolbarCommandProvider[];
+    constructor(editor: OnesEditor);
+    destroy(): void;
+    addProvider(provider: ReadonlyToolbarCommandProvider): void;
+    isInBlock(block: BlockElement, event: MouseEvent): boolean;
+    handleButtonClick: (toolbar: AbstractCommandBar, item: CommandItem) => void;
+    handleClose: () => void;
+    handleClosing: (bar: unknown, event: MouseEvent | TouchEvent) => boolean;
+    bindEvents(): void;
+    unbindEvents(): void;
+    handleDocumentMouseDown: (event: MouseEvent) => void;
+    handleDocumentMouseUp: () => void;
+    handleSelectionChange: import("lodash").DebouncedFunc<(editor: OnesEditor) => void>;
+    private handleHoveringBlockChildChange;
+    groupCommands: (allCommands: CommandItem[]) => CommandItem[];
+    showTextToolbar(reason: string): void;
+}

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

@@ -0,0 +1,12 @@
+import { BlockElement, CommandItem, OnesEditor, SelectionRange, TextBlockContentChild } from '../../../../@ones-editor/core';
+import { CommandBar } from '../../../../@ones-editor/ui-base';
+export interface ReadonlyCommandOptions {
+    hoveringBlock: BlockElement | null;
+    hoveringTextChild: TextBlockContentChild | null;
+    bar: CommandBar;
+}
+export interface ReadonlyToolbarCommandProvider {
+    getTextCommands?: (editor: OnesEditor, range: SelectionRange) => CommandItem[];
+    destroy?: () => void;
+    executeCommand: (editor: OnesEditor, command: CommandItem, options: ReadonlyCommandOptions) => void;
+}

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

@@ -0,0 +1,11 @@
+import { BlockCommands, BlockElement, CommandItem, OnesEditor, OnesEditorBlockHook, TextBlockContentChild } from '../../../../@ones-editor/core';
+import { EditLinkProvider } from '../providers/edit-link-provider';
+import ClipboardProvider from '../providers/clipboard-provider';
+export declare class LinkCommands implements OnesEditorBlockHook {
+    private editor;
+    provider: EditLinkProvider;
+    clipboardProvider: ClipboardProvider;
+    constructor(editor: OnesEditor);
+    commands(editor: OnesEditor, block: BlockElement, child: TextBlockContentChild | null): BlockCommands | undefined;
+    executeCommand: (editor: OnesEditor, block: BlockElement, item: CommandItem, child: TextBlockContentChild | null) => void;
+}

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

@@ -1,2 +1,2 @@
-import { BlockCommandItem, CommandItem, OnesEditor } from '../../../../@ones-editor/core';
-export declare function getTextCommands(editor: OnesEditor, blockCommands: BlockCommandItem[]): CommandItem[];
+import { CommandItem, OnesEditor } from '../../../../@ones-editor/core';
+export declare function getTextCommands(editor: OnesEditor, blockCommands: CommandItem[]): CommandItem[];

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

@@ -23,11 +23,12 @@ 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;
     handleDocumentMouseUp: () => void;
+    isHoveringBlockContent(block: BlockElement): boolean;
     private handleHoveringBlockChildChange;
     handleSelectionChange: import("lodash").DebouncedFunc<(editor: OnesEditor) => void>;
     updateItems(updater: (items: CommandItem[]) => CommandItem[]): void;

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

@@ -0,0 +1,2 @@
+import { OnesEditor } from '../../../../@ones-editor/core';
+export declare const hideToolbar: (editor: OnesEditor) => void;

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

@@ -1,6 +1,7 @@
 /// <reference types="lodash" />
 import { CommandItem } from '../../../../@ones-editor/core';
 import { AbstractCommandBar, ManualMenu } from '../command-bar';
+import { MobileBottomMenu } from '../mobile-command-bar/mobile-bottom-menu';
 export interface AutoSuggestMenuOptions {
     id: string;
     showLoading?: boolean;
@@ -15,13 +16,14 @@ 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;
 }
 export default class AutoSuggestMenu {
     protected options: AutoSuggestMenuOptions;
-    menu: ManualMenu;
+    menu: ManualMenu | MobileBottomMenu;
     private currentText;
     handleSearchText: (text: string) => void;
     constructor(options: AutoSuggestMenuOptions);
@@ -39,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;
@@ -43,9 +44,10 @@ declare class OnesEditorAutoSuggest implements OnesEditorInputHandler {
     handleUpdateCompositionText(editor: OnesEditor, containerId: string, blockIndex: number, offset: number, end: boolean): boolean;
     handleSelectionChanged: (editor: OnesEditor) => void;
     private resetItems;
-    private deleteTrigger;
+    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

@@ -1,22 +1,29 @@
 import { CommandItem, OnesEditor } from '../../../../@ones-editor/core';
 import { TypedEmitter } from 'tiny-typed-emitter';
 import { ColorPaletteItem } from '../color-palette';
-import { ColorPaletteEvents } from '../color-palette/color-palette';
+import { ColorPaletteEvents, ColorAction } from '../color-palette/color-palette';
+import './text-color-item.scss';
 export declare class TextColorItem extends TypedEmitter<ColorPaletteEvents> implements CommandItem {
-    private editor;
+    editor: OnesEditor;
+    private storageName;
     id: string;
     name: string;
     dropdown: boolean;
+    dropSplit: boolean;
+    splitTooltip: string;
     manualShowChildren: boolean;
+    childrenType: "mobile-bottom-menu" | undefined;
     children: CommandItem[];
     element: HTMLButtonElement;
     colorPaletteItem: ColorPaletteItem;
     latestColors: [number | null, number | null];
-    constructor(editor: OnesEditor);
+    private currentTextColors;
+    constructor(editor: OnesEditor, storageName?: string);
     destroy(): void;
-    handlePaletteClick: (type: 'color' | 'backgroundColor' | 'clearColor', value: number) => void;
-    setLatestColors: (type: 'color' | 'backgroundColor' | 'clearColor', value: number) => void;
+    handlePaletteClick: (type: ColorAction, value: number) => void;
+    handleButtonClick: (event: MouseEvent) => void;
+    private setLatestColors;
     beforePopup: () => void;
-    updatePaletteColor(colors: [number | null, number | null]): void;
-    updateButtonColor(colors: [number | null, number | null]): void;
+    updatePaletteColor(): void;
+    setCurrentTextColors(colors: [number | null, number | null]): void;
 }

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

@@ -3,7 +3,13 @@ import type { ColorPaletteOptions } from './create-palette';
 import './palette.scss';
 export { ColorPaletteOptions };
 export type ColorType = 'color' | 'backgroundColor';
-export type PaletteClickHandler = (type: ColorType | 'clearColor', value: number) => void;
+export type ColorAction = ColorType | 'clearColor';
+export declare enum ColorClearActions {
+    clearAll = 0,
+    clearColor = 1,
+    clearBackground = 2
+}
+export type PaletteClickHandler = (type: ColorAction, value: number) => void;
 export interface ColorPaletteEvents {
     onClick: PaletteClickHandler;
     beforePopup: () => void;

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

@@ -1,4 +1,4 @@
-import type { ColorPaletteOptions, PaletteClickHandler } from './color-palette';
-import ColorPalette from './color-palette';
+import type { ColorPaletteOptions, PaletteClickHandler, ColorAction } from './color-palette';
+import ColorPalette, { ColorClearActions } from './color-palette';
 import ColorPaletteItem from './color-palette-item';
-export { ColorPalette, ColorPaletteOptions, ColorPaletteItem, PaletteClickHandler };
+export { ColorPalette, ColorPaletteOptions, ColorPaletteItem, PaletteClickHandler, ColorClearActions, ColorAction };

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

@@ -22,20 +22,22 @@ 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(): void;
+    private debounceClearSelectedItem;
     selectItem(id: string, from?: SelectItemFrom): void;
     private lastEnterPauseTime;
     private startPauseMouseEnter;
     private handleItemMouseEnter;
     private handleItemMouseLeave;
-    protected handleItemClick: (event: MouseEvent) => void;
+    protected handleItemClick: (event: MouseEvent | TouchEvent) => void;
     private showSubCommandBar;
     isInCommandBar(target: EventTarget | null): boolean;
     createCommandItem(item: CommandItem): CommandItemElement;

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

@@ -1,11 +1,12 @@
 import { CommandItem } from '../../../../@ones-editor/core';
 import CommandBar from './command-bar';
-import { CommandBarOptions, CommandItemElement } 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;
+    getSubBarOptions: (item: CommandItem) => ManualShowCommandBarOptions;
     destroy(): void;
     protected getCommandBarRoot(): HTMLElement | null;
     get isVisible(): boolean;

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

@@ -2,5 +2,6 @@ import { CommandItem } from '../../../../@ones-editor/core';
 import { CommandItemElement } from './types';
 export type InitToolbarItemOptions = {
     tooltipId?: string;
+    showName?: boolean;
 };
 export declare function initToolbarItem(item: CommandItem, elem: CommandItemElement, options: InitToolbarItemOptions): void;

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;
@@ -28,6 +30,8 @@ export interface AbstractCommandBar extends TypedEmitter<CommandBarEvents> {
     isInCommandBar: (target: EventTarget | null) => boolean;
     handleDocumentKeydown: (event: KeyboardEvent) => boolean;
     getSubBarOptions: (item: CommandItem) => ManualShowCommandBarOptions;
+    updateItems: (items: CommandItem[]) => void;
+    setProps?: (props: ManualShowCommandBarOptions) => void;
 }
 export interface ShowCommandBarOptions {
     placement?: Placement;
@@ -61,7 +65,8 @@ export interface CommandBarOptions {
     header?: HTMLElement | (() => HTMLElement | null);
     footer?: HTMLElement | (() => HTMLElement | null);
     padding?: number;
-    beforeClose?: (event?: MouseEvent) => boolean;
+    beforeClose?: (event?: MouseEvent | TouchEvent) => boolean;
+    showName?: boolean;
 }
 export type CreateManualCommandBarFunction = (parentItem: CommandItem, closeable: Closeable, options?: CommandBarOptions) => AbstractManualCommandBar;
 export type PopoverOptions = {

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/icons/index.d.ts

@@ -120,4 +120,8 @@ import SymbolIcon from './symbol.svg?raw';
 import TreeIcon from './tree.svg?raw';
 import TimeIcon from './time.svg?raw';
 import SearchIcon from './search.svg?raw';
-export { DownloadIcon, AddEmojiIcon, BallIcon, CardIcon, FoodIcon, LightIcon, SmileIcon, SymbolIcon, TreeIcon, TimeIcon, ClearIcon, CloseIcon, PrevIcon, NextIcon, MoreIcon, TextColorIcon, AddIcon, ArrowDownIcon, ArrowUpIcon, ArrowLeftIcon, ArrowRightIcon, DeleteRowIcon, DeleteColIcon, MergeCellIcon, SplitCellIcon, DeleteTableIcon, Heading1Icon, Heading2Icon, Heading3Icon, Heading4Icon, Heading5Icon, Heading6Icon, Heading7Icon, Heading8Icon, HeadingNIcon, OrderedListIcon, UnorderedListIcon, CheckListIcon, BlockquoteIcon, AlignCenterIcon, AlignLeftIcon, AlignRightIcon, ImageIcon, ImageMenuIcon, ImageErrorIcon, ImageEmptyIcon, LinkIcon, LinkOffIcon, WarningIcon, PasteSpecialIcon, LaunchIcon, CodeIcon, LayoutIcon, AudioIcon, GraphIcon, VideoIcon, FileIcon, MathIcon, MathMenuIcon, TableIcon, TableMenuIcon, BilibiliIcon, YoukuIcon, ModaoIcon, FigmaIcon, EditIcon, CommentIcon, RefreshIcon, HelpIcon, CheckMarkIcon, TextIcon, RightArrowIcon, TencentVideoIcon, WebPageIcon, UmlIcon, DividingLineIcon, HeadingH1Icon, HeadingH2Icon, HeadingH3Icon, HeadingH4Icon, HeadingH5Icon, HeadingH6Icon, HeadingH7Icon, HeadingH8Icon, CheckboxIcon, QuoteIcon, LinkHrefIcon, OrderedIcon, UnorderedIcon, CopyIcon, CutIcon, DeleteIcon, LockBlockIcon, UnLockBlockIcon, InsertBeforeIcon, InsertAfterIcon, MentionIcon, CircleAddIcon, LoadingIcon, DragIcon, UmlBrandIcon, OnesLoadingIcon, BoldIcon, ItalicIcon, UnderlineIcon, LineThroughIcon, SubscriptIcon, SuperscriptIcon, InlineCodeIcon, ToMindMapIcon, FitIcon, FullScreenIcon, ExitFullScreenIcon, CaretDownIcon, StatusIcon, AlertEmojiIcon, ForbiddenIcon, WarningFilledIcon, InformationFilledIcon, SearchIcon, CalloutIcon, LoadingCircleIcon, };
+import TextGroupIcon from './text-group.svg?raw';
+import TabIcon from './tab.svg?raw';
+import ShiftTabIcon from './shift-tab.svg?raw';
+import TableEditIcon from './table-edit.svg?raw';
+export { TableEditIcon, TabIcon, ShiftTabIcon, DownloadIcon, AddEmojiIcon, BallIcon, CardIcon, FoodIcon, LightIcon, SmileIcon, SymbolIcon, TreeIcon, TimeIcon, ClearIcon, CloseIcon, PrevIcon, NextIcon, MoreIcon, TextColorIcon, AddIcon, ArrowDownIcon, ArrowUpIcon, ArrowLeftIcon, ArrowRightIcon, DeleteRowIcon, DeleteColIcon, MergeCellIcon, SplitCellIcon, DeleteTableIcon, Heading1Icon, Heading2Icon, Heading3Icon, Heading4Icon, Heading5Icon, Heading6Icon, Heading7Icon, Heading8Icon, HeadingNIcon, OrderedListIcon, UnorderedListIcon, CheckListIcon, BlockquoteIcon, AlignCenterIcon, AlignLeftIcon, AlignRightIcon, ImageIcon, ImageMenuIcon, ImageErrorIcon, ImageEmptyIcon, LinkIcon, LinkOffIcon, WarningIcon, PasteSpecialIcon, LaunchIcon, CodeIcon, LayoutIcon, AudioIcon, GraphIcon, VideoIcon, FileIcon, MathIcon, MathMenuIcon, TableIcon, TableMenuIcon, BilibiliIcon, YoukuIcon, ModaoIcon, FigmaIcon, EditIcon, CommentIcon, RefreshIcon, HelpIcon, CheckMarkIcon, TextIcon, RightArrowIcon, TencentVideoIcon, WebPageIcon, UmlIcon, DividingLineIcon, HeadingH1Icon, HeadingH2Icon, HeadingH3Icon, HeadingH4Icon, HeadingH5Icon, HeadingH6Icon, HeadingH7Icon, HeadingH8Icon, CheckboxIcon, QuoteIcon, LinkHrefIcon, OrderedIcon, UnorderedIcon, CopyIcon, CutIcon, DeleteIcon, LockBlockIcon, UnLockBlockIcon, InsertBeforeIcon, InsertAfterIcon, MentionIcon, CircleAddIcon, LoadingIcon, DragIcon, UmlBrandIcon, OnesLoadingIcon, BoldIcon, ItalicIcon, UnderlineIcon, LineThroughIcon, SubscriptIcon, SuperscriptIcon, InlineCodeIcon, ToMindMapIcon, FitIcon, FullScreenIcon, ExitFullScreenIcon, CaretDownIcon, StatusIcon, AlertEmojiIcon, ForbiddenIcon, WarningFilledIcon, InformationFilledIcon, SearchIcon, CalloutIcon, LoadingCircleIcon, TextGroupIcon, };

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

@@ -15,4 +15,7 @@ export * from './input/create-input';
 export * from './auto-suggest';
 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

@@ -1,5 +1,5 @@
 import './input.scss';
-export declare function createInput(parent: HTMLElement, options: {
+export type EditorInputOptions = {
     label?: string;
     placeholder?: string;
     required?: boolean;
@@ -9,9 +9,30 @@ export declare function createInput(parent: HTMLElement, options: {
     onKeyDown?: (e: KeyboardEvent, composing: boolean) => void;
     maxLength?: number;
     prefix?: Element;
-}): {
+    suffixClose?: boolean;
+    mode?: 'textarea' | 'input';
+};
+export declare class EditorInput {
+    private parent;
+    private options;
+    private unbindKeyDownEvent;
+    constructor(parent: HTMLElement, options: EditorInputOptions);
+    private container;
+    private get errorContent();
+    private get input();
+    private get suffix();
+    private get prefix();
     getField: () => HTMLInputElement;
     getInputValue: () => string;
     setFieldError: (error: string) => void;
     focus: () => void;
-};
+    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;

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

@@ -4,6 +4,7 @@ declare const _default: {
         name: string;
         backgroundDesc: string;
         reset: string;
+        more: string;
     };
     emojiPalette: {
         name: string;

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

@@ -4,6 +4,7 @@ declare const _default: {
         name: string;
         backgroundDesc: string;
         reset: string;
+        more: string;
     };
     emojiPalette: {
         name: string;

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

@@ -4,6 +4,7 @@ declare const _default: {
         name: string;
         backgroundDesc: string;
         reset: string;
+        more: string;
     };
     emojiPalette: {
         name: string;

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

@@ -0,0 +1,3 @@
+import { CommandItem } from '../../../../@ones-editor/core';
+import { CommandItemElement } from '../command-bar';
+export declare function initMenuItem(item: CommandItem, elem: CommandItemElement): void;

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

@@ -0,0 +1,21 @@
+import { Closeable, CloseReason, CommandItem } from '../../../../@ones-editor/core';
+import { Instance } from 'tippy.js';
+import './mobile-bottom-menu.scss';
+import { AbstractManualCommandBar, CommandBar, CommandBarContentElement, CommandBarOptions, CommandItemElement, ManualShowCommandBarOptions } from '../command-bar';
+declare class MobileBottomMenu extends CommandBar implements AbstractManualCommandBar {
+    tippyInstance: Instance | null;
+    constructor(items: CommandItem[], closeable?: Closeable, options?: CommandBarOptions);
+    createContentWithHeader: () => HTMLDivElement;
+    handleClose: () => void;
+    oldActiveElement: HTMLElement | null;
+    manualShow: (target: HTMLElement, options?: ManualShowCommandBarOptions) => void;
+    close(reason: CloseReason): void;
+    destroy(): void;
+    get isVisible(): boolean;
+    get popper(): Element | null;
+    protected initCommandBarElement(elem: CommandBarContentElement): void;
+    protected getCommandBarRoot(): HTMLElement | null;
+    protected initItemElement(item: CommandItem, elem: CommandItemElement): void;
+}
+declare function createMobileBottomMenu(): void;
+export { createMobileBottomMenu, MobileBottomMenu, };

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/@ones-editor/ui-base/src/popup/popup.d.ts

@@ -3,7 +3,7 @@ import ManualCommandBar from '../command-bar/manual-command-bar';
 import { CommandBarContentElement, CommandItemElement } from '../command-bar/types';
 export type PopupOptions = {
     id?: string;
-    beforeClose?: (event?: MouseEvent) => boolean;
+    beforeClose?: (event?: MouseEvent | TouchEvent) => boolean;
 };
 export default class Popup extends ManualCommandBar {
     constructor(content: HTMLElement, options?: PopupOptions);

package/@ones-editor/{ui → ui-base}/src/text-button/index.d.ts

@@ -1,3 +1,3 @@
-import type { ButtonOptions } from '../../../../@ones-editor/ui-base';
+import { ButtonOptions } from '../components';
 import './index.scss';
 export declare function createTextButton(parent: HTMLElement, ...args: ButtonOptions): HTMLButtonElement;

package/dist/auto-new-line.d.ts

@@ -0,0 +1,7 @@
+import { OnesEditor, OnesEditorCustom } from '../@ones-editor/core';
+export default class AutoNewLine implements OnesEditorCustom {
+    private editor;
+    constructor(editor: OnesEditor);
+    destroy(): void;
+    handleClick: (e: MouseEvent) => void;
+}

package/dist/comments/local-doc-comments-provider.d.ts

@@ -3,7 +3,8 @@ import { DocObject, LocalDoc, OnesEditor, OnesEditorComment, OnesEditorDoc } fro
 export default class LocalDocCommentsProvider implements OnesEditorCommentsProvider {
     private editor;
     private localDoc;
-    private listeners;
+    private _listeners;
+    private _doc;
     constructor(editor: OnesEditor, localDoc: OnesEditorDoc);
     get doc(): DocObject;
     getComments(): OnesEditorComment[];