@ones-editor/editor 2.1.1-beta.10 → 2.1.1-beta.11

package/@ones-editor/block-menu/src/block-menu-button/menu-button/index.d.ts

@@ -1,6 +1,6 @@
 import { BlockElement, OnesEditor } from '../../../../../@ones-editor/core';
+import { BlockMenu } from '../../../../../@ones-editor/ui';
 import EmptyBlockMenu from '../../empty-block-menu';
-import BlockMenu from '../../block-menu';
 export default class OnesEditorBlockMenuButton {
     private editor;
     buttonElement: HTMLButtonElement;

package/@ones-editor/block-padding/src/index.d.ts

@@ -7,4 +7,4 @@ declare const BlockPaddingShortcuts: {
     Backspace: typeof handleBackspace;
 };
 export * from './utils';
-export { BlockPaddingRender, BlockPaddingShortcuts, };
+export { BlockPaddingRender, BlockPaddingShortcuts, handleShiftTab, handleTab, };

package/@ones-editor/callout-block/src/callout-block/callout-quick-menu-item-filter.d.ts

@@ -1,8 +1,7 @@
-import { OnesEditor, OnesEditorCustom } from '../../../../@ones-editor/core';
-import type { QuickMenuItem, QuickMenuItemFilter } from '../../../../@ones-editor/ui';
-export declare class CalloutQuickMenuItemFilter implements QuickMenuItemFilter, OnesEditorCustom {
+import { CommandFilter, CommandItemWithSource, OnesEditor, OnesEditorCustom, SelectionRange } from '../../../../@ones-editor/core';
+export declare class CalloutQuickMenuItemFilter implements CommandFilter, OnesEditorCustom {
     constructor(editor: OnesEditor);
-    filter(editor: OnesEditor, items: QuickMenuItem[], from: string): QuickMenuItem[];
+    filter(editor: OnesEditor, range: SelectionRange, items: CommandItemWithSource[], source: string[]): CommandItemWithSource[];
     destroy(): void;
     static init(editor: OnesEditor): CalloutQuickMenuItemFilter;
 }

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

@@ -1,12 +1,13 @@
-import { BlockCommandItem, BlockCommandItemWithSource, BlockElement, CommandParams, CommandResult, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../@ones-editor/core';
+import { BlockElement, CommandItem, CommandItemWithSource, CommandParams, CommandResult, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../@ones-editor/core';
 import { OnesEditorCommentsProvider } from '../types';
 import type { OnesEditorComments } from '../comments';
 export default class CommentsCommandProvider implements OnesEditorCommandProvider {
     private provider;
     private editorComments;
     id: string;
+    groupIndex: number;
     constructor(provider: OnesEditorCommentsProvider, editorComments: OnesEditorComments);
-    getAvailableCommands(editor: OnesEditor, block: BlockElement, range: SelectionRange): BlockCommandItem[];
+    getAvailableCommands(editor: OnesEditor, block: BlockElement, range: SelectionRange): CommandItem[];
     hideToolbar(editor: OnesEditor): void;
-    executeRangeCommand(editor: OnesEditor, range: SelectionRange, command: BlockCommandItemWithSource, params: CommandParams, result: CommandResult): boolean;
+    executeRangeCommand(editor: OnesEditor, range: SelectionRange, command: CommandItemWithSource, params: CommandParams, result?: CommandResult): boolean;
 }

package/@ones-editor/core/src/core/blocks/common/execute-block-command.d.ts

@@ -1,3 +1,3 @@
-import { BlockCommandItemWithSource, BlockElement, CommandItem, OnesEditor } from '../../types';
+import { BlockElement, CommandItem, CommandItemWithSource, OnesEditor } from '../../types';
 export declare function executeEmbedBlockCommand(editor: OnesEditor, block: BlockElement, commandGroup: string, item: CommandItem): unknown;
-export declare function executeBlockCommand(editor: OnesEditor, block: BlockElement, commandGroup: string, item: BlockCommandItemWithSource): unknown;
+export declare function executeBlockCommand(editor: OnesEditor, block: BlockElement, commandGroup: string, item: CommandItemWithSource): unknown;

package/@ones-editor/core/src/core/command-providers/abstract-providers.d.ts

@@ -0,0 +1,25 @@
+import { OnesEditor, OnesEditorCommandProviders, OnesEditorCommandProvider, SelectionRange, CommandParams, CommandItemWithSource, CommandFilterId, CommandFilter, CommandResult, BlockElement } from '../types';
+type RangeCommandResult = {
+    [index: string]: CommandResult;
+};
+export declare abstract class AbstractProvider implements OnesEditorCommandProviders {
+    protected editor: OnesEditor;
+    abstract id: string;
+    commandProviders: OnesEditorCommandProvider[];
+    commandFilters: Map<string | number | symbol, CommandFilter>;
+    constructor(editor: OnesEditor);
+    addFilter(id: CommandFilterId, filter: CommandFilter): void;
+    registerCommandProvider: (provider: OnesEditorCommandProvider) => void;
+    getCommandProviders: () => OnesEditorCommandProvider[];
+    getCommandProvider: (id: string) => OnesEditorCommandProvider;
+    filterItems: (range: SelectionRange, items: CommandItemWithSource[]) => CommandItemWithSource[];
+    getCommands(range: SelectionRange): CommandItemWithSource[];
+    executeBlockCommand: (editor: OnesEditor, block: BlockElement, range: SelectionRange, command: CommandItemWithSource, params: CommandParams, result: RangeCommandResult) => boolean;
+    executeRangeCommand: (range: SelectionRange, command: CommandItemWithSource, params: CommandParams) => {
+        [index: string]: CommandResult;
+    };
+    executeCommand(range: SelectionRange, command: CommandItemWithSource, params: CommandParams): {
+        [index: string]: CommandResult;
+    };
+}
+export {};

package/@ones-editor/core/src/core/command-providers/block-attributes.d.ts

@@ -0,0 +1,14 @@
+import { DocBlockTextAttributes } from '../doc';
+import { CommandParams, OnesEditor, OnesEditorCustom } from '../types';
+export default class BlockAttributesHandler implements OnesEditorCustom {
+    private editor;
+    private textBlockAttributes;
+    private activeBlockAttributes;
+    constructor(editor: OnesEditor);
+    clear: () => void;
+    destroy(): void;
+    getEmptyBlockTextAttributes(blockId: string): DocBlockTextAttributes | undefined;
+    setActiveBlockAttributes: (attributes: CommandParams) => void;
+    setEmptyBlockTextAttributes: (blockId: string, attributes: CommandParams) => void;
+    setActiveAttribute: (attribute: string, value: unknown) => void;
+}

package/@ones-editor/core/src/core/command-providers/commands/index.d.ts

@@ -1,2 +1,4 @@
 export * from './intersection-commands';
 export * from './range-commands';
+export * from './merge-commands';
+export * from './inject-source';

package/@ones-editor/core/src/core/command-providers/commands/inject-source.d.ts

@@ -0,0 +1,3 @@
+import { CommandItemWithSource } from '../../types';
+export declare const injectSource: (commands: CommandItemWithSource[], source?: string[]) => void;
+export declare const getSourceList: (source: string) => string[];

package/@ones-editor/core/src/core/command-providers/commands/merge-commands.d.ts

@@ -0,0 +1,3 @@
+import { CommandItem } from '../../types';
+export declare function mergeCommands(blockCommands: CommandItem[]): CommandItem[];
+export declare const flatCommands: (allCommands: Map<number, CommandItem[]>, sort?: boolean) => CommandItem[];

package/@ones-editor/core/src/core/command-providers/commands/range-commands.d.ts

@@ -1,5 +1,2 @@
-import { BlockCommandItemWithSource, CommandParams, CommandResult, SelectionRange } from '../../types';
-export declare function getRangeCommands(range: SelectionRange, source: string): BlockCommandItemWithSource[];
-export declare function executeRangeCommand(range: SelectionRange, command: BlockCommandItemWithSource, params: CommandParams): {
-    [index: string]: CommandResult;
-};
+import { CommandItemWithSource, BlockElement, OnesEditor, SelectionRange, OnesEditorCommandProvider } from '../../types';
+export declare function getBlockCommands(providers: OnesEditorCommandProvider[], editor: OnesEditor, block: BlockElement, range: SelectionRange, source: string): CommandItemWithSource[];

package/@ones-editor/core/src/core/command-providers/editor-command-providers.d.ts

@@ -1,15 +1,5 @@
-import { DocBlockTextAttributes } from '../doc';
-import { OnesEditor, OnesEditorCommandProviders, OnesEditorCommandProvider, SelectionRange, CommandParams, BlockCommandItemWithSource } from '../types';
-export default class EditorCommandProviders implements OnesEditorCommandProviders {
-    private editor;
-    private providers;
-    constructor(editor: OnesEditor);
-    registerCommandProvider(provider: OnesEditorCommandProvider): void;
-    getCommandProviders(): OnesEditorCommandProvider[];
-    getCommandProvider(id: string): OnesEditorCommandProvider;
-    getCommands(range: SelectionRange, source: string): BlockCommandItemWithSource[];
-    executeCommand(range: SelectionRange, command: BlockCommandItemWithSource, params: CommandParams): {
-        [index: string]: import("../types").CommandResult;
-    };
-    getEmptyBlockTextAttributes(editor: OnesEditor, blockId: string): DocBlockTextAttributes | undefined;
+import { OnesEditorCommandProviders } from '../types';
+import { AbstractProvider } from './abstract-providers';
+export default class EditorCommandProviders extends AbstractProvider implements OnesEditorCommandProviders {
+    id: string;
 }

package/@ones-editor/core/src/core/command-providers/index.d.ts

@@ -1,3 +1,5 @@
 import EditorCommandProviders from './editor-command-providers';
+import BlockAttributesHandler from './block-attributes';
+import { AbstractProvider } from './abstract-providers';
 export * from './commands';
-export { EditorCommandProviders };
+export { EditorCommandProviders, BlockAttributesHandler, AbstractProvider };

package/@ones-editor/core/src/core/composition/editor-input.d.ts

@@ -34,7 +34,7 @@ export declare class EditorInput implements OnesEditorInput {
     isInDisableScrollMask(target: Node): boolean;
     handleWindowBlur: () => void;
     handleWindowFocus: () => void;
-    handleDocumentClick: (event: MouseEvent) => void;
+    handleDocumentClick: (event: MouseEvent | TouchEvent) => void;
     handleDocumentSelectionChange: () => void;
     handleEditorSelectionChanged: () => void;
     handleReadonlyChanged: () => void;

package/@ones-editor/core/src/core/containers/root-container.d.ts

@@ -12,12 +12,12 @@ export declare class RootContainer {
     destroy(): void;
     handleContextMenu: (event: MouseEvent) => void;
     handleResize: () => void;
-    handleClick: (event: MouseEvent) => void;
-    handleBlockClick: (event: MouseEvent, block: BlockElement, elem: Element) => void;
+    handleClick: (event: MouseEvent | TouchEvent) => void;
+    handleBlockClick: (event: MouseEvent | TouchEvent, block: BlockElement, elem: Element) => void;
     handleDblClick: (event: MouseEvent) => void;
-    handleMouseDown: (event: MouseEvent) => void;
+    handleMouseDown: (event: TouchEvent | MouseEvent) => void;
     handleMouseMove: (event: MouseEvent) => void;
-    handleMouseUp: (event: MouseEvent) => void;
+    handleMouseUp: (event: MouseEvent | TouchEvent) => void;
     handleCaptureClick: (event: MouseEvent) => void;
     handleCaptureDbClick: (event: MouseEvent) => void;
     reload(): void;

package/@ones-editor/core/src/core/doc/rich-text/text-style.d.ts

@@ -14,6 +14,8 @@ export declare function rangeRemoveAttribute(offset: number, length: number, tex
 export declare function getAttributesAt(text: DocBlockText, offset: number): DocBlockTextAttributes | undefined;
 export type DocBlockTextProcessor = (op: DocBlockTextOp) => DocBlockTextOp;
 export declare function rangeTransformText(offset: number, length: number, text: DocBlockText, processor: DocBlockTextProcessor): DocBlockText;
+export declare function deleteColor(op: DocBlockTextOp, type: 'color' | 'backgroundColor'): void;
+export declare function addColor(op: DocBlockTextOp, type: 'color' | 'backgroundColor', value: number): void;
 export declare function rangeSetTextColor(offset: number, length: number, docText: DocBlockText, type: 'color' | 'backgroundColor', value: number | null): DocBlockText;
 export declare function getColorFromAttributes(attributes?: DocBlockTextAttributes): [number | null, number | null];
 export declare function setColorToAttributes(attributes: DocBlockTextAttributes, type: 'color' | 'backgroundColor', value: number | null): void;

package/@ones-editor/core/src/core/editor/actions/clear-selected-contents.d.ts

@@ -1,2 +1,2 @@
-import { OnesEditor } from '../../types';
-export declare function editorClearSelectedContents(editor: OnesEditor): void;
+import { OnesEditor, SelectionRange } from '../../types';
+export declare function editorClearSelectedContents(editor: OnesEditor, selectionRange?: SelectionRange): void;

package/@ones-editor/core/src/core/selection/actions/index.d.ts

@@ -23,4 +23,5 @@ import { editorMovePageDown } from './move-page-down';
 import { editorSelectPageUp } from './select-page-up';
 import { editorSelectPageDown } from './select-page-down';
 import { editorSelectAll, editorSelectContainer, isContainerSelectedAllChildBlocks } from './select-all';
-export { editorMoveLeft, editorMoveRight, editorMoveUp, editorMoveDown, editorSelectDown, editorSelectUp, editorSelectLeft, editorSelectRight, editorMoveWordLeft, editorMoveWordEnd, editorSelectWordLeft, editorSelectWordEnd, editorMoveHome, editorMoveEnd, editorSelectHome, editorSelectEnd, editorMovePageUp, editorMovePageDown, editorSelectPageUp, editorSelectPageDown, editorSelectLineHome, editorSelectLineEnd, editorMoveLineHome, editorMoveLineEnd, editorSelectAll, editorSelectContainer, isContainerSelectedAllChildBlocks, };
+import { editorSelectWord } from './select-word';
+export { editorMoveLeft, editorMoveRight, editorMoveUp, editorMoveDown, editorSelectDown, editorSelectUp, editorSelectLeft, editorSelectRight, editorSelectWord, editorMoveWordLeft, editorMoveWordEnd, editorSelectWordLeft, editorSelectWordEnd, editorMoveHome, editorMoveEnd, editorSelectHome, editorSelectEnd, editorMovePageUp, editorMovePageDown, editorSelectPageUp, editorSelectPageDown, editorSelectLineHome, editorSelectLineEnd, editorMoveLineHome, editorMoveLineEnd, editorSelectAll, editorSelectContainer, isContainerSelectedAllChildBlocks, };

package/@ones-editor/core/src/core/selection/index.d.ts

@@ -1,3 +1,4 @@
 export * from './editor-position';
 export * from './range';
 export * from './range-from-point';
+export * from './adjust-selection-pos';

package/@ones-editor/core/src/core/selection/select-handler.d.ts

@@ -4,16 +4,16 @@ export declare class EditorSelectionHandler implements OnesEditorSelectionHandle
     editor: OnesEditor;
     startPos: BlockPosition | null;
     lastCaretRect: DOMRect;
-    mouseDownEvent: MouseEvent | null;
+    mouseDownEvent: TouchEvent | MouseEvent | null;
     autoScroll: AutoScroll | null;
     constructor(editor: OnesEditor);
     isSelecting(): boolean;
     stopSelection(): void;
-    handleMouseDown: (event: MouseEvent, options: {
+    handleMouseDown: (event: MouseEvent | TouchEvent, options: {
         autoScroll: boolean;
     }) => void;
     handleMouseMove: (event: MouseEvent) => void;
-    handleMouseUp: (event: MouseEvent) => void;
+    handleMouseUp: (event: MouseEvent | TouchEvent) => void;
     handleDblClick(event: MouseEvent): void;
     handleTripleClick(event: MouseEvent): void;
 }

package/@ones-editor/core/src/core/types.d.ts

@@ -126,7 +126,6 @@ export interface Closeable {
     click: (item: CommandItem, target: HTMLElement) => void;
 }
 export type CommandItemChildrenPlacement = 'auto' | 'top' | 'left' | 'right' | 'bottom' | 'auto-start' | 'auto-end' | 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end' | 'right-start' | 'right-end' | 'left-start' | 'left-end';
-export type CommandItemMenuType = 'inline' | 'sibling';
 export interface CommandItem {
     id: string;
     name: string;
@@ -137,7 +136,7 @@ export interface CommandItem {
     type?: CommandItemType;
     element?: HTMLElement | ((item: CommandItem) => HTMLElement);
     icon?: string;
-    childrenType?: 'menu' | 'toolbar';
+    childrenType?: 'menu' | 'toolbar' | 'mobile-bottom-menu';
     children?: CommandItem[];
     childrenMenuId?: string;
     data?: unknown;
@@ -159,18 +158,8 @@ export interface CommandItem {
     /**
      * defaults to true
     */
-    shouldShown?: (currentBlock: BlockElement | undefined, menuType: CommandItemMenuType) => boolean;
-    /**
-     * defaults to true
-    */
     clickToClose?: boolean;
 }
-export interface BlockCommandItem extends CommandItem {
-    blockId: string;
-    blockType: string;
-    blockKind: BlockKind;
-    groupIndex: number;
-}
 export type StyleType = boolean | string | number;
 export type BlockStyles = {
     [index: string]: StyleType;
@@ -668,11 +657,11 @@ export interface OnesEditorInput {
 export interface OnesEditorSelectionHandler {
     isSelecting: () => boolean;
     stopSelection: () => void;
-    handleMouseDown: (event: MouseEvent, options: {
+    handleMouseDown: (event: MouseEvent | TouchEvent, options: {
         autoScroll: boolean;
     }) => void;
     handleMouseMove: (event: MouseEvent) => void;
-    handleMouseUp: (event: MouseEvent) => void;
+    handleMouseUp: (event: MouseEvent | TouchEvent) => void;
     handleDblClick: (event: MouseEvent) => void;
     handleTripleClick: (event: MouseEvent) => void;
 }
@@ -723,32 +712,42 @@ export interface OnesEditorInsertions {
 }
 export type CommandParams = {
     [index: string]: unknown;
+} & {
+    source?: string[];
 };
 export type CommandResult = {
     [index: string]: unknown;
 };
 export interface OnesEditorCommandProvider {
     id: string;
-    getAvailableCommands: (editor: OnesEditor, block: BlockElement, range: SelectionRange) => BlockCommandItem[];
-    executeCommand?: (editor: OnesEditor, block: BlockElement, range: SelectionRange, item: BlockCommandItem, params: CommandParams, result: CommandResult) => boolean;
-    filterCommands?: (editor: OnesEditor, block: BlockElement, range: SelectionRange, commands: BlockCommandItemWithSource[]) => BlockCommandItemWithSource[] | undefined;
-    beforeExecuteCommand?: (editor: OnesEditor, block: BlockElement, range: SelectionRange, item: BlockCommandItem, params: CommandParams) => boolean | undefined;
-    afterExecuteCommand?: (editor: OnesEditor, block: BlockElement, range: SelectionRange, item: BlockCommandItem, params: CommandParams, result: CommandResult) => void;
-    getEmptyBlockTextAttributes?: (editor: OnesEditor, blockId: string) => DocBlockTextAttributes | undefined;
-    executeRangeCommand?: (editor: OnesEditor, range: SelectionRange, command: BlockCommandItemWithSource, params: CommandParams, result: CommandResult) => boolean;
-}
-export interface BlockCommandItemWithSource extends BlockCommandItem {
+    groupIndex?: number;
+    getAvailableCommands: (editor: OnesEditor, block: BlockElement, range: SelectionRange, params?: CommandParams) => CommandItem[];
+    getInsertCommands?: (editor: OnesEditor, containerId: string) => CommandItem[];
+    executeInsertCommand?: (editor: OnesEditor, containerId: string, blockIndex: number, item: CommandItem, params: CommandParams, result?: CommandResult) => boolean;
+    executeRangeCommand?: (editor: OnesEditor, range: SelectionRange, command: CommandItemWithSource, params: CommandParams, result?: CommandResult) => boolean;
+    executeCommand?: (editor: OnesEditor, block: BlockElement, range: SelectionRange, item: CommandItem, params: CommandParams, result?: CommandResult) => boolean;
+    filterCommands?: (editor: OnesEditor, block: BlockElement, range: SelectionRange, commands: CommandItemWithSource[]) => CommandItemWithSource[] | undefined;
+    beforeExecuteCommand?: (editor: OnesEditor, block: BlockElement, range: SelectionRange, item: CommandItem, params: CommandParams) => boolean | undefined;
+    afterExecuteCommand?: (editor: OnesEditor, block: BlockElement, range: SelectionRange, item: CommandItem, params: CommandParams, result: CommandResult) => void;
+}
+export interface CommandItemWithSource extends CommandItem {
     source: string;
 }
+export interface CommandFilter {
+    filter: (editor: OnesEditor, range: SelectionRange, items: CommandItemWithSource[], source: string[]) => CommandItemWithSource[];
+}
+export type CommandFilterId = keyof any;
 export interface OnesEditorCommandProviders {
+    commandFilters?: Map<CommandFilterId, CommandFilter>;
+    addFilter?: (id: CommandFilterId, filter: CommandFilter) => void;
+    filterItems?: (range: SelectionRange, items: CommandItemWithSource[]) => CommandItemWithSource[];
     registerCommandProvider: (provider: OnesEditorCommandProvider) => void;
     getCommandProviders: () => OnesEditorCommandProvider[];
     getCommandProvider: (id: string) => OnesEditorCommandProvider;
-    getCommands: (range: SelectionRange, source: string) => BlockCommandItemWithSource[];
-    executeCommand: (range: SelectionRange, item: BlockCommandItemWithSource, params: CommandParams) => {
+    getCommands: (range: SelectionRange) => CommandItemWithSource[];
+    executeCommand: (range: SelectionRange, item: CommandItemWithSource, params: CommandParams) => {
         [index: string]: CommandResult;
     };
-    getEmptyBlockTextAttributes: (editor: OnesEditor, blockId: string) => DocBlockTextAttributes | undefined;
 }
 export interface EditorDocLocalActionCallbacks {
     onBeforeUpdateBlockText: (containerId: string, blockId: string, oldText: DocBlockText, newText: DocBlockText, newRange: OnesEditorDocRange) => void;

package/@ones-editor/core/src/utils/dom.d.ts

@@ -37,4 +37,7 @@ export declare function bindKeyDownEvent(input: HTMLInputElement | HTMLTextAreaE
 export declare function getElementFromPoint(x: number, y: number, options?: {
     noFilter: boolean;
 }): Element;
+export declare function ensureIsMobileEvent(events: MouseEvent | TouchEvent): events is TouchEvent;
+export declare function createMouseEventFromTouchEvent(event: TouchEvent, type: 'mousedown' | 'mousemove' | 'mouseup' | 'click'): MouseEvent;
+export declare function bindTouchEnd(elem: HTMLElement | Document, callback: (e: any) => void): void;
 export {};

package/@ones-editor/core/src/utils/drag-drop.d.ts

@@ -1,6 +1,6 @@
-export type DragStartHandler<T> = (drag: DragDrop<T>, event: MouseEvent, elem: HTMLElement) => void;
-export type DraggingHandler<T> = (drag: DragDrop<T>, event: MouseEvent, elem: HTMLElement, deltaX: number, deltaY: number) => void;
-export type DragEndHandler<T> = (drag: DragDrop<T>, event: MouseEvent, elem: HTMLElement, deltaX: number, deltaY: number) => void;
+export type DragStartHandler<T> = (drag: DragDrop<T>, event: MouseEvent | TouchEvent, elem: HTMLElement) => void;
+export type DraggingHandler<T> = (drag: DragDrop<T>, event: MouseEvent | TouchEvent, elem: HTMLElement, deltaX: number, deltaY: number) => void;
+export type DragEndHandler<T> = (drag: DragDrop<T>, event: MouseEvent | TouchEvent, elem: HTMLElement, deltaX: number, deltaY: number) => void;
 export interface DragDropOptions<T> {
     elem: HTMLElement;
     onDragStart: DragStartHandler<T>;
@@ -10,6 +10,7 @@ export interface DragDropOptions<T> {
     minThreshold?: number;
     cursor?: string;
     mouseDownEvent?: MouseEvent;
+    mobile?: boolean;
 }
 export declare const MIN_DISTANCE_THRESHOLD = 3;
 export declare class DragDrop<T> {
@@ -37,5 +38,9 @@ export declare class DragDrop<T> {
     private onDragging;
     private onDragEnd;
     destroy(): void;
+    static getEventPosition(event: MouseEvent | TouchEvent): {
+        x: number;
+        y: number;
+    };
 }
 export declare function registerDragDrop<T>(options: DragDropOptions<T>): DragDrop<T>;

package/@ones-editor/image-embed/src/splitter-resizer/index.d.ts

@@ -11,7 +11,7 @@ export declare class ImageSplitterResizer implements DragDropOptions<ImageSplitt
     cursor: string;
     initWidths: number[];
     constructor(editor: OnesEditor, elem: HTMLElement, data: ImageSplitterResizerData, mouseDownEvent: MouseEvent);
-    onDragStart(drag: DragDrop<ImageSplitterResizerData>, event: MouseEvent, elem: HTMLElement): void;
-    onDragging(drag: DragDrop<ImageSplitterResizerData>, event: MouseEvent, elem: HTMLElement, deltaX: number, deltaY: number): void;
-    onDragEnd(drag: DragDrop<ImageSplitterResizerData>, event: MouseEvent, elem: HTMLElement, deltaX: number, deltaY: number): void;
+    onDragStart(drag: DragDrop<ImageSplitterResizerData>, event: MouseEvent | TouchEvent, elem: HTMLElement): void;
+    onDragging(drag: DragDrop<ImageSplitterResizerData>, event: MouseEvent | TouchEvent, elem: HTMLElement, deltaX: number, deltaY: number): void;
+    onDragEnd(drag: DragDrop<ImageSplitterResizerData>, event: MouseEvent | TouchEvent, elem: HTMLElement, deltaX: number, deltaY: number): void;
 }

package/@ones-editor/layout-block/src/command-filter.d.ts

@@ -0,0 +1,7 @@
+import { CommandFilter, CommandItemWithSource, OnesEditor, OnesEditorCustom, SelectionRange } from '../../../@ones-editor/core';
+export declare class LayoutQuickMenuItemFilter implements CommandFilter, OnesEditorCustom {
+    constructor(editor: OnesEditor);
+    filter(editor: OnesEditor, range: SelectionRange, items: CommandItemWithSource[], source: string[]): CommandItemWithSource[];
+    destroy(): void;
+    static init(editor: OnesEditor): LayoutQuickMenuItemFilter;
+}

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

@@ -1,6 +1,7 @@
 declare const _default: {
     mention: {
         abstract: string;
+        placeholder: string;
     };
 };
 export default _default;

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

@@ -1,6 +1,7 @@
 declare const _default: {
     mention: {
         abstract: string;
+        placeholder: string;
     };
 };
 export default _default;

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

@@ -1,6 +1,7 @@
 declare const _default: {
     mention: {
         abstract: string;
+        placeholder: string;
     };
 };
 export default _default;

package/@ones-editor/mention/src/mention.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="lodash" />
 import { CommandItem, OnesEditor, OnesEditorCustom } from '../../../@ones-editor/core';
 import { AutoSuggestAnchor, OnesEditorAutoSuggest } from '../../../@ones-editor/ui-base';
 import { MentionOptions } from './types';
@@ -5,10 +6,23 @@ export default class OnesEditorMention implements OnesEditorCustom {
     private editor;
     private options;
     suggest: OnesEditorAutoSuggest;
+    private mobileWrap;
+    private items;
     constructor(editor: OnesEditor, options: MentionOptions);
     onClose: () => void;
     destroy(): void;
     onShow: (suggest: OnesEditorAutoSuggest, containerId: string, blockIndex: number, offset: number) => boolean;
+    handleClickItem: (item: CommandItem) => void;
+    handleMobileWrapClick: (e: Event) => void;
     onClickItem: (menu: OnesEditorAutoSuggest, item: CommandItem, anchor: AutoSuggestAnchor) => void;
+    createItemElement: (item: CommandItem, find: string) => HTMLElement;
+    createMobileItems: (content: HTMLElement, items: CommandItem[], find: string) => void;
+    onInputChanged: import("lodash").DebouncedFunc<(content: HTMLElement, e: Event) => void>;
+    createMobileCommandItem: (items: CommandItem[]) => {
+        id: string;
+        name: string;
+        element: HTMLElement;
+    }[];
+    _queryItems: (text: string) => Promise<CommandItem[]>;
     queryItems: (menu: OnesEditorAutoSuggest, text: string) => Promise<CommandItem[]>;
 }

package/@ones-editor/mobile-helper/src/fixed-toolbar/fixed-providers.d.ts

@@ -0,0 +1,6 @@
+import { AbstractProvider, OnesEditor, OnesEditorCommandProviders } from '../../../../@ones-editor/core';
+export declare class FixedProviders extends AbstractProvider implements OnesEditorCommandProviders {
+    protected editor: OnesEditor;
+    id: string;
+    constructor(editor: OnesEditor);
+}

package/@ones-editor/mobile-helper/src/fixed-toolbar/index.d.ts

@@ -0,0 +1,18 @@
+import { OnesEditor } from '../../../../@ones-editor/core';
+import './mobile.scss';
+export declare class MobileCommandHandler {
+    private editor;
+    private commandBar;
+    private showKeyboard;
+    private initViewportHeight;
+    constructor(editor: OnesEditor);
+    destroy(): void;
+    private get isKeyboardShow();
+    private get virtualViewportHeight();
+    private get virtualViewportOffsetTop();
+    private setDebugInfo;
+    toggle: () => void;
+    handleViewportScroll: () => void;
+    handleFocusIn: () => void;
+    handleFocusOut: (event: FocusEvent) => void;
+}

package/@ones-editor/mobile-helper/src/fixed-toolbar/providers/align-dropdown.d.ts

@@ -0,0 +1,9 @@
+import { BlockElement, CommandItem, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../../@ones-editor/core';
+import { ProxyProvider } from '../../../../../@ones-editor/ui';
+export default class AlignDropdownProvider extends ProxyProvider implements OnesEditorCommandProvider {
+    private editor;
+    id: string;
+    constructor(editor: OnesEditor);
+    getInsertCommands: () => never[];
+    getAvailableCommands: (editor: OnesEditor, block: BlockElement, range: SelectionRange) => CommandItem[];
+}

package/@ones-editor/mobile-helper/src/fixed-toolbar/providers/group.d.ts

@@ -0,0 +1,7 @@
+import { OnesEditor, OnesEditorCommandProvider } from '../../../../../@ones-editor/core';
+import { ProxyProvider } from '../../../../../@ones-editor/ui';
+export default class GroupProvider extends ProxyProvider implements OnesEditorCommandProvider {
+    private editor;
+    id: string;
+    constructor(editor: OnesEditor);
+}

package/@ones-editor/mobile-helper/src/fixed-toolbar/providers/insert-menu.d.ts

@@ -0,0 +1,15 @@
+import { BlockElement, CommandItem, CommandParams, ContainerElement, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../../@ones-editor/core';
+import { ProxyProvider } from '../../../../../@ones-editor/ui';
+export default class InsertMenuProvider extends ProxyProvider {
+    private editor;
+    id: string;
+    whiteList: string[];
+    providers: OnesEditorCommandProvider[];
+    constructor(editor: OnesEditor);
+    getNextBlock(container: ContainerElement, block: BlockElement): number;
+    getInsertCommands: () => CommandItem[];
+    getAvailableCommands: (editor: OnesEditor, block: BlockElement, range: SelectionRange) => CommandItem[];
+    executeInsertCommand: () => boolean;
+    getNextBlockIndex: (container: ContainerElement, block: BlockElement) => number;
+    executeCommand: (editor: OnesEditor, block: BlockElement, range: SelectionRange, item: CommandItem, params: CommandParams) => boolean;
+}

package/@ones-editor/mobile-helper/src/fixed-toolbar/providers/insert.d.ts

@@ -0,0 +1,8 @@
+import { BlockElement, CommandItem, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../../@ones-editor/core';
+import { ProxyProvider } from '../../../../../@ones-editor/ui';
+export default class InsertProvider extends ProxyProvider implements OnesEditorCommandProvider {
+    private editor;
+    id: string;
+    constructor(editor: OnesEditor);
+    getAvailableCommands: (editor: OnesEditor, block: BlockElement, range: SelectionRange) => CommandItem[];
+}

package/@ones-editor/mobile-helper/src/fixed-toolbar/providers/paragraph.d.ts

@@ -0,0 +1,9 @@
+import { BlockElement, CommandItem, CommandParams, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../../@ones-editor/core';
+import { ProxyProvider } from '../../../../../@ones-editor/ui';
+export default class ParagraphProvider extends ProxyProvider implements OnesEditorCommandProvider {
+    private editor;
+    id: string;
+    groupIndex: number;
+    constructor(editor: OnesEditor);
+    getAvailableCommands: (editor: OnesEditor, block: BlockElement, range: SelectionRange, params?: CommandParams) => CommandItem[];
+}

package/@ones-editor/mobile-helper/src/fixed-toolbar/providers/text-dropdown.d.ts

@@ -0,0 +1,9 @@
+import { BlockElement, CommandItem, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../../@ones-editor/core';
+import { ProxyProvider } from '../../../../../@ones-editor/ui';
+export default class TextDropdownProvider extends ProxyProvider implements OnesEditorCommandProvider {
+    private editor;
+    id: string;
+    constructor(editor: OnesEditor);
+    getInsertCommands: () => never[];
+    getAvailableCommands: (editor: OnesEditor, block: BlockElement, range: SelectionRange) => CommandItem[];
+}

package/@ones-editor/mobile-helper/src/fixed-toolbar/providers/turn-into.d.ts

@@ -0,0 +1,8 @@
+import { BlockElement, CommandItem, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../../@ones-editor/core';
+import { ProxyProvider } from '../../../../../@ones-editor/ui';
+export default class TurnIntoCommandProvider extends ProxyProvider implements OnesEditorCommandProvider {
+    private editor;
+    id: string;
+    constructor(editor: OnesEditor);
+    getAvailableCommands: (editor: OnesEditor, block: BlockElement, range: SelectionRange) => CommandItem[];
+}

package/@ones-editor/mobile-helper/src/fixed-toolbar/toolbar-handler.d.ts

@@ -0,0 +1,11 @@
+import type { CommandItem, OnesEditor } from '../../../../@ones-editor/core';
+export declare class MobileToolbarHandler {
+    private editor;
+    private mobileToolbar;
+    private fixedProviders;
+    bar: HTMLElement;
+    constructor(editor: OnesEditor, parent: HTMLElement);
+    private handleSelectionChange;
+    handleClick: (_: any, item: CommandItem) => void;
+    destroy(): void;
+}

package/@ones-editor/mobile-helper/src/index.d.ts

@@ -1,11 +1,17 @@
 import { OnesEditor, OnesEditorCustom } from '../../../@ones-editor/core';
+import { MobileCommandHandler } from './fixed-toolbar';
+import './mobile-helper-styles.scss';
+export { MobileCommandHandler };
 export declare class OnesEditorMobileHelper implements OnesEditorCustom {
     private editor;
     private longPressTimeout;
+    private gripper;
     constructor(editor: OnesEditor);
     destroy(): void;
     handleSelectionChange: () => void;
     handleLongPress: (event: TouchEvent) => void;
+    private isMoving;
+    handleTouchMove: (event: TouchEvent) => void;
     handleTouchStart: (event: TouchEvent) => void;
     handleTouchEnd: (event: TouchEvent) => void;
 }

package/@ones-editor/mobile-helper/src/selection-gripper/index.d.ts

@@ -0,0 +1,19 @@
+import { DragDrop, OnesEditor } from '../../../../@ones-editor/core';
+interface DragData {
+    type: 'start' | 'end';
+}
+export default class SelectionGripper {
+    private editor;
+    private startGripper;
+    private endGripper;
+    private dragDropStart;
+    private dragDropEnd;
+    constructor(editor: OnesEditor);
+    destroy(): void;
+    handleDragStart: (drag: DragDrop<DragData>, event: MouseEvent | TouchEvent, elem: HTMLElement) => void;
+    handleDragging: (drag: DragDrop<DragData>, event: MouseEvent | TouchEvent, elem: HTMLElement) => void;
+    handleDragEnd: (drag: DragDrop<DragData>, event: MouseEvent | TouchEvent, elem: HTMLElement) => void;
+    update(): void;
+    close(): void;
+}
+export {};

package/@ones-editor/mobile-helper/src/selection-gripper/select-handle.d.ts

@@ -0,0 +1,3 @@
+export declare const HANDLE_CIRCLE_SIZE = 12;
+export declare const HANDLE_WIDTH = 12;
+export declare function createSelectHandle(type: 'start' | 'end'): HTMLDivElement;