@ones-editor/editor 2.1.0-beta.5 → 2.1.0-beta.6

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

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

package/@ones-editor/{block-menu → ui}/src/block-menu/index.d.ts

@@ -1,11 +1,13 @@
-import { BlockElement, OnesEditor, CommandItem } from '../../../../@ones-editor/core';
+import { BlockElement, OnesEditor, CommandFilterId, CommandFilter, CommandItem } from '../../../../@ones-editor/core';
 import type { ManualShowCommandBarOptions } from '../../../../@ones-editor/ui-base';
 export default class BlockMenu {
     private editor;
     private menu;
     currentBlock: BlockElement | null;
     private commandBlock;
+    private blockCommandProviders;
     constructor(editor: OnesEditor);
+    addFilter(id: CommandFilterId, filter: CommandFilter): void;
     show(target: HTMLElement, options?: ManualShowCommandBarOptions): void;
     isInMenu(eventTarget: EventTarget | null): boolean;
     handleShow: () => void;

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

@@ -1,21 +1,33 @@
 import './style.scss';
 import OnesEditorToolbar from './toolbar/toolbar-handler';
-import OnesEditorQuickMenu, { getAllQuickMenuItems, getHeadingMenuOptions, QuickMenuCommandBetween, QuickMenuCommandInline, QuickMenuCommandProvider, BasicCommands, GetAllQuickMenuItemsOptions, QuickMenuCommandParams, AddMenuCommand, QuickMenuItemFilter } from './quick-menu';
+import { QuickMenuCommandBetween, QuickMenuCommandInline, QuickMenuCommandProvider, QuickMenuCommandParams, AddMenuCommand, QuickMenuItem, QuickMenuOptions } from './quick-menu/types';
+import OnesEditorQuickMenu from './quick-menu';
+import * as BasicCommands from './providers/utils/basic-commands';
 import OnesEditorTooltip from './tooltips';
 import TextStyleShortcuts from './shortcuts';
 import { editLink } from './link-popup';
 import { getToolbar } from './toolbar/helper';
-import { GroupOrder } from './quick-menu/order';
 import { getReferenceClientRect } from './toolbar/get-reference-client-rect';
 import { isSelectBoxOnly } from './toolbar/box-only';
-import { InlineBoxCommandProvider } from './quick-menu/inline-box-items';
 import './locale';
 import type { OnesEditorToolbarBase } from './toolbar/types';
-import type { QuickMenuItem } from './quick-menu';
-import { ReadonlyToolbar } from './readonly-toolbar';
-import { ReadonlyToolbarCommandProvider, ReadonlyCommandOptions } from './readonly-toolbar/types';
-import { AddCommentToOldDocCommandProvider } from './readonly-toolbar/add-comment-to-old-doc';
-export type { QuickMenuItemFilter, QuickMenuCommandParams, QuickMenuCommandProvider, QuickMenuCommandBetween, AddMenuCommand, QuickMenuCommandInline, GetAllQuickMenuItemsOptions, OnesEditorToolbarBase, ReadonlyToolbarCommandProvider, ReadonlyCommandOptions, };
-export { OnesEditorToolbar, OnesEditorQuickMenu, OnesEditorTooltip, getAllQuickMenuItems, QuickMenuItem, editLink, TextStyleShortcuts, getToolbar, getHeadingMenuOptions, BasicCommands, GroupOrder, isSelectBoxOnly, InlineBoxCommandProvider, getReferenceClientRect, ReadonlyToolbar, AddCommentToOldDocCommandProvider, };
+import { BlockCommandProviders } from './block-menu/block-command-providers';
+import BlockMenu from './block-menu';
+import InlineStyleProvider from './providers/inline-style-provider';
+import ColorStyleProvider from './providers/color-provider';
+import ScriptDropdownProvider from './providers/script-with-dropdown';
+import TextScriptProvider from './providers/text-script-provider';
+import { AbstractProvider } from './providers/abstract-providers';
+import HeadingProvider from './providers/heading';
+import { ProxyProvider } from './providers/proxy-provider';
+import ParagraphProvider from './providers/paragraph';
+import AlignProvider from './providers/align';
+import { InlineBoxCommandProvider } from './providers/insert-box-provider';
+import { LinkProvider } from './providers/link';
+import { injectBlockOptions } from './providers/utils/inject-block-options';
+import TextCommandProvider from './providers/text-command-provider';
+import InlineCodeProvider from './providers/inline-code-provider';
+export { TextCommandProvider, injectBlockOptions, LinkProvider, InlineBoxCommandProvider, AlignProvider, ParagraphProvider, ProxyProvider, InlineCodeProvider, InlineStyleProvider, ColorStyleProvider, ScriptDropdownProvider, TextScriptProvider, AbstractProvider, HeadingProvider, };
+export type { QuickMenuCommandParams, QuickMenuCommandProvider, QuickMenuCommandBetween, AddMenuCommand, QuickMenuCommandInline, OnesEditorToolbarBase, QuickMenuItem, QuickMenuOptions, };
+export { BlockMenu, BlockCommandProviders, OnesEditorToolbar, OnesEditorQuickMenu, OnesEditorTooltip, editLink, TextStyleShortcuts, getToolbar, BasicCommands, isSelectBoxOnly, getReferenceClientRect, };
 export { createTextButton } from './text-button';
-export { mergeCommands } from './toolbar/merge-commands';

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

@@ -0,0 +1,27 @@
+import { BlockElement, CommandFilter, CommandFilterId, CommandItemWithSource, CommandParams, CommandResult, DocBlockTextAttributes, OnesEditor, OnesEditorCommandProvider, OnesEditorCommandProviders, SelectionRange } from '../../../../@ones-editor/core';
+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);
+    getEmptyBlockTextAttributes(editor: OnesEditor, blockId: string): DocBlockTextAttributes | undefined;
+    addFilter(id: CommandFilterId, filter: CommandFilter): void;
+    registerCommandProvider: (provider: OnesEditorCommandProvider) => void;
+    getCommandProviders: () => OnesEditorCommandProvider[];
+    getCommandProvider: (id: string) => OnesEditorCommandProvider;
+    filterItems: (range: SelectionRange, items: CommandItemWithSource[]) => CommandItemWithSource[];
+    getRangeCommands: (range: SelectionRange, source: string) => 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/ui/src/providers/align-dropdown.d.ts

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

package/@ones-editor/ui/src/{toolbar/commands → providers}/align.d.ts

@@ -1,10 +1,10 @@
-import { BlockCommandItem, BlockElement, DocBlock, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../../@ones-editor/core';
+import { BlockElement, CommandItem, DocBlock, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../@ones-editor/core';
 export default class AlignProvider implements OnesEditorCommandProvider {
     private editor;
     id: string;
     constructor(editor: OnesEditor);
-    applyAlignStyle(editor: OnesEditor, block: BlockElement, align: string): void;
     isChecked(blockData: DocBlock, id: string): boolean;
-    getAvailableCommands(editor: OnesEditor, block: BlockElement, range: SelectionRange): BlockCommandItem[];
-    executeCommand(editor: OnesEditor, block: BlockElement, range: SelectionRange, command: BlockCommandItem): boolean;
+    getAvailableCommands(editor: OnesEditor, block: BlockElement): CommandItem[];
+    getInsertCommands: () => never[];
+    executeCommand(editor: OnesEditor, block: BlockElement, range: SelectionRange, command: CommandItem): boolean;
 }

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

@@ -0,0 +1,16 @@
+import { BlockElement, CommandItem, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../@ones-editor/core';
+interface CommandWithExecute {
+    command: CommandItem;
+    executeCommand: (editor: OnesEditor, block: BlockElement, item: CommandItem) => unknown;
+}
+export declare class BlockHookProvider implements OnesEditorCommandProvider {
+    private editor;
+    id: string;
+    constructor(editor: OnesEditor);
+    commands: CommandWithExecute[];
+    getAvailableCommands: (editor: OnesEditor, block: BlockElement) => CommandItem[];
+    getInsertCommands: () => CommandItem[];
+    executeCommand(editor: OnesEditor, block: BlockElement, range: SelectionRange, command: CommandItem): boolean;
+    executeInsertCommand: () => boolean;
+}
+export {};

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

@@ -0,0 +1,16 @@
+import { BlockElement, CommandItem, CommandParams, OnesEditor, OnesEditorCommandProvider, SelectionRange, CommandResult } from '../../../../@ones-editor/core';
+import { TextColorItem } from '../../../../@ones-editor/ui-base';
+export default class ColorStyleProvider implements OnesEditorCommandProvider {
+    private editor;
+    id: string;
+    colorItem: TextColorItem;
+    constructor(editor: OnesEditor);
+    private getEmptyTextBlockColor;
+    private setEmptyTextBlockColor;
+    private updateButtonColor;
+    private handleChangeColor;
+    getAvailableCommands(editor: OnesEditor, block: BlockElement, range: SelectionRange): CommandItem[];
+    getInsertCommands(): CommandItem[];
+    executeCommand(editor: OnesEditor, block: BlockElement, range: SelectionRange, item: CommandItem, params: CommandParams, result?: CommandResult): boolean;
+    executeInsertCommand: () => boolean;
+}

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

@@ -0,0 +1,13 @@
+import { BlockElement, CommandItem, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../@ones-editor/core';
+export default class HeadingProvider implements OnesEditorCommandProvider {
+    private editor;
+    private withPlainText;
+    id: string;
+    constructor(editor: OnesEditor, withPlainText?: boolean);
+    getHeadingIndex(): number;
+    createHeadingCommandItem(heading: number): CommandItem[];
+    getAvailableCommands(editor: OnesEditor, block: BlockElement): CommandItem[];
+    getInsertCommands(): CommandItem[];
+    executeInsertCommand: (editor: OnesEditor, containerId: string, blockIndex: number, command: CommandItem) => boolean;
+    executeCommand(editor: OnesEditor, block: BlockElement, range: SelectionRange, command: CommandItem): boolean;
+}

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

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

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

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

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

@@ -0,0 +1,9 @@
+import { BlockElement, CommandItem, 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;
+}

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

@@ -0,0 +1,9 @@
+import { BlockElement, CommandItem, 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;
+}

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

@@ -0,0 +1,12 @@
+import { BlockElement, CommandItem, CommandParams, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../@ones-editor/core';
+import { ProxyProvider } from './proxy-provider';
+export declare class InlineBoxCommandProvider extends ProxyProvider implements OnesEditorCommandProvider {
+    private editor;
+    id: string;
+    constructor(editor: OnesEditor);
+    create(commands: CommandItem[]): CommandItem[];
+    getAvailableCommands: (editor: OnesEditor, block: BlockElement, range: SelectionRange) => CommandItem[];
+    getInsertCommands: (editor: OnesEditor, containerId: string, blockIndex: number) => 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;
+}

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

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

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

@@ -0,0 +1,16 @@
+import { BlockElement, CommandItem, 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 {
+    private editor;
+    private withPlainText;
+    id: string;
+    providersMap: Map<string, OnesEditorCommandProvider>;
+    providers: OnesEditorCommandProvider[];
+    quickProviders: QuickMenuCommandProvider[];
+    constructor(editor: OnesEditor, withPlainText?: boolean);
+    getInsertCommands: (editor: OnesEditor, containerId: string, blockIndex: number) => 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;
+}

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

@@ -0,0 +1,17 @@
+import { BlockElement, CommandItem, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../@ones-editor/core';
+export declare class LinkProvider implements OnesEditorCommandProvider {
+    private editor;
+    id: string;
+    constructor(editor: OnesEditor);
+    create(): {
+        id: string;
+        name: string;
+        icon: string;
+        order: number;
+        subText: string;
+    }[];
+    getAvailableCommands: () => CommandItem[];
+    getInsertCommands: () => CommandItem[];
+    executeCommand: (editor: OnesEditor, block: BlockElement, range: SelectionRange, item: CommandItem) => boolean;
+    executeInsertCommand(editor: OnesEditor, containerId: string, blockIndex: number, item: CommandItem): boolean;
+}

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

@@ -0,0 +1,14 @@
+import { BlockElement, CommandItem, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../@ones-editor/core';
+import { CommandItemParams } from './types';
+export default class ListProvider implements OnesEditorCommandProvider {
+    private editor;
+    id: string;
+    constructor(editor: OnesEditor);
+    createListCommandItem(block?: BlockElement): CommandItem[];
+    getAvailableCommands(editor: OnesEditor, block: BlockElement, range: SelectionRange, params?: CommandItemParams): CommandItem[];
+    getInsertCommands(): CommandItem[];
+    convertToList(editor: OnesEditor, block: BlockElement, listType: 'unordered' | 'ordered' | 'unchecked'): void;
+    insertList(editor: OnesEditor, containerId: string, blockIndex: number, listType: 'unordered' | 'ordered' | 'unchecked'): void;
+    executeCommand(editor: OnesEditor, block: BlockElement, range: SelectionRange, command: CommandItem): boolean;
+    executeInsertCommand: (editor: OnesEditor, containerId: string, blockIndex: number, command: CommandItem) => boolean;
+}

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

@@ -0,0 +1,8 @@
+import { OnesEditor, OnesEditorCommandProvider } from '../../../../@ones-editor/core';
+import { ProxyProvider } from './proxy-provider';
+export default class ParagraphProvider extends ProxyProvider implements OnesEditorCommandProvider {
+    private editor;
+    id: string;
+    groupIndex: number;
+    constructor(editor: OnesEditor);
+}

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

@@ -0,0 +1,10 @@
+import { BlockElement, CommandItem, CommandParams, CommandResult, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../@ones-editor/core';
+import { CommandItemParams } from './types';
+export declare abstract class ProxyProvider implements OnesEditorCommandProvider {
+    abstract id: string;
+    providers: OnesEditorCommandProvider[];
+    getAvailableCommands: (editor: OnesEditor, block: BlockElement, range: SelectionRange, params?: CommandItemParams) => CommandItem[];
+    getInsertCommands: (editor: OnesEditor, containerId: string, blockIndex: number) => 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;
+}

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

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

package/@ones-editor/ui/src/providers/script-with-dropdown.d.ts

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

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

@@ -0,0 +1,18 @@
+import { BlockAttributesHandler, BlockElement, CommandItem, CommandParams, CommandResult, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../@ones-editor/core';
+export default class TextCommandProvider implements OnesEditorCommandProvider {
+    private editor;
+    id: string;
+    groupIndex: number;
+    private providers;
+    constructor(editor: OnesEditor);
+    getAvailableCommands(editor: OnesEditor, block: BlockElement, range: SelectionRange): CommandItem[];
+    executeCommand(editor: OnesEditor, block: BlockElement, range: SelectionRange, item: CommandItem, params: CommandParams, result?: CommandResult): boolean;
+    get blockAttributesHandler(): BlockAttributesHandler;
+    private executeCommandOnEmptyText;
+    private setCommandsStates;
+    private static toTextCommand;
+    private static fromTextCommandId;
+    private static fromTextCommand;
+    private static toTextCommands;
+    private static fromTextCommands;
+}

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

@@ -0,0 +1,16 @@
+import { BlockElement, CommandItem, OnesEditor, SelectionRange } from '../../../../@ones-editor/core';
+import { ProxyProvider } from './proxy-provider';
+export default class TextStylesFixedProvider extends ProxyProvider {
+    private editor;
+    private afterCommandCallback;
+    id: string;
+    constructor(editor: OnesEditor, afterCommandCallback: () => void);
+    commands: CommandItem[];
+    block: BlockElement | null;
+    range: SelectionRange | null;
+    handleClick: (editor: OnesEditor, event: Event) => void;
+    getAvailableCommands: (editor: OnesEditor, block: BlockElement, range: SelectionRange) => CommandItem[];
+    getInsertCommands: () => never[];
+    executeCommand: () => boolean;
+    executeInsertCommand: () => boolean;
+}

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

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

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

@@ -0,0 +1,9 @@
+import { OnesEditor, OnesEditorCommandProvider } from '../../../../@ones-editor/core';
+import { ProxyProvider } from './proxy-provider';
+export default class TextStylesProvider extends ProxyProvider {
+    private editor;
+    private withPlainText;
+    id: string;
+    providers: OnesEditorCommandProvider[];
+    constructor(editor: OnesEditor, withPlainText?: boolean);
+}

package/@ones-editor/ui/src/providers/turn-into.d.ts

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

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

@@ -0,0 +1,3 @@
+export interface CommandItemParams {
+    isFilter: boolean;
+}

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/inject-block-options.d.ts

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

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

@@ -0,0 +1,2 @@
+import { BlockElement, CommandItemWithSource, OnesEditor, OnesEditorCommandProviders, SelectionRange } from '../../../../../@ones-editor/core';
+export declare function getBlockCommands(commandProviders: OnesEditorCommandProviders, editor: OnesEditor, block: BlockElement, range: SelectionRange, source: string): CommandItemWithSource[];

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

@@ -0,0 +1,3 @@
+import { CommandItem, BlockElement, CommandParams, CommandResult, OnesEditor, SelectionRange } from '../../../../../@ones-editor/core';
+export declare function getAvailableStyleCommands(editor: OnesEditor, block: BlockElement, range: SelectionRange): CommandItem[];
+export declare function executeStyleCommand(editor: OnesEditor, block: BlockElement, range: SelectionRange, command: string, params: CommandParams, result: CommandResult): boolean;

package/@ones-editor/{text-commands/src → ui/src/providers/utils}/text-styles.d.ts

@@ -1,4 +1,6 @@
-import { BlockElement, DocBlockText, OnesEditor, SelectionRange, TextStyles } from '../../../@ones-editor/core';
+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(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;
+    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,10 @@
+import { CommandItemWithSource, OnesEditor, OnesEditorCommandProviders, SelectionRange } from '../../../../@ones-editor/core';
+import { AbstractProvider } from '../providers/abstract-providers';
+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) => {};
+    getEmptyBlockTextAttributes: () => undefined;
+}

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

@@ -27,10 +27,6 @@ export interface QuickMenuCommandProvider {
     getCommands: (editor: OnesEditor, params: QuickMenuCommandParams) => CommandItem[];
     executeCommand: (editor: OnesEditor, item: CommandItem, params: QuickMenuCommandInline | QuickMenuCommandBetween | AddMenuCommand) => Promise<BlockElement | null>;
 }
-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/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-base/src/color-button/text-color-item.d.ts

@@ -8,6 +8,7 @@ export declare class TextColorItem extends TypedEmitter<ColorPaletteEvents> impl
     name: string;
     dropdown: boolean;
     manualShowChildren: boolean;
+    childrenType: "mobile-bottom-menu" | undefined;
     children: CommandItem[];
     element: HTMLButtonElement;
     colorPaletteItem: ColorPaletteItem;

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

@@ -35,7 +35,7 @@ export default abstract class CommandBar extends TypedEmitter<CommandBarEvents>
     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/mobile-bottom-menu.d.ts

@@ -0,0 +1,18 @@
+import { Closeable, CloseReason, CommandItem } from '../../../../@ones-editor/core';
+import { Instance } from 'tippy.js';
+import { AbstractManualCommandBar, CommandBarContentElement, CommandBarOptions, CommandItemElement, ManualShowCommandBarOptions } from './types';
+import CommandBar from './command-bar';
+export default class MobileBottomMenu extends CommandBar implements AbstractManualCommandBar {
+    tippyInstance: Instance | null;
+    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;
+}
+declare function createMobileBottomMenu(parentItem: CommandItem, closeable: Closeable, options?: CommandBarOptions): MobileBottomMenu;
+export { createMobileBottomMenu, };

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

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

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/dist/comments/local-doc-comments-provider.d.ts

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