@ones-editor/editor 2.1.8-beta.1 → 2.1.8-beta.10

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

@@ -0,0 +1,8 @@
+import { AbstractProvider, CommandItemWithSource, OnesEditor, OnesEditorCommandProviders, SelectionRange } from '../../../../@ones-editor/core';
+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) => {};
+}

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/box-helper/standard-box-commands.d.ts

@@ -0,0 +1,10 @@
+import { BlockElement, BoxCommands, BoxElement, CommandItem, OnesEditor, OnesEditorCommandProvider } from '../../../../@ones-editor/core';
+export declare class StandardBoxCommands implements BoxCommands {
+    private editor;
+    group: string;
+    providers: OnesEditorCommandProvider[];
+    constructor(editor: OnesEditor);
+    get commands(): CommandItem[];
+    executeCommand(editor: OnesEditor, block: BlockElement, box: BoxElement, item: CommandItem): void;
+    static create(editor: OnesEditor): StandardBoxCommands;
+}

package/@ones-editor/ui/src/box-helper/standard-box-provider.d.ts

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

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

@@ -1,18 +1,43 @@
 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 OnesEditorTooltip, { OnesEditorTooltipCallbacks, EditorTooltipTippyInstance, OnesEditorTooltipProps } from './tooltips';
+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 type { OnesEditorTooltipCallbacks, EditorTooltipTippyInstance, OnesEditorTooltipProps } 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';
-export type { QuickMenuItemFilter, QuickMenuCommandParams, QuickMenuCommandProvider, QuickMenuCommandBetween, AddMenuCommand, QuickMenuCommandInline, GetAllQuickMenuItemsOptions, OnesEditorToolbarBase, OnesEditorTooltipCallbacks, EditorTooltipTippyInstance, OnesEditorTooltipProps, };
-export { OnesEditorToolbar, OnesEditorQuickMenu, OnesEditorTooltip, getAllQuickMenuItems, QuickMenuItem, editLink, TextStyleShortcuts, getToolbar, getHeadingMenuOptions, BasicCommands, GroupOrder, isSelectBoxOnly, InlineBoxCommandProvider, getReferenceClientRect, };
-export { createTextButton } from './text-button';
-export { mergeCommands } from './toolbar/merge-commands';
+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 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 InsertMenuProvider from './providers/insert-menu';
+import { injectBlockOptions } from './providers/utils/inject-block-options';
+import TextCommandProvider from './providers/text-command-provider';
+import InlineCodeProvider from './providers/inline-code-provider';
+import { MobileLinkProvider } from './providers/mobile-link-provider';
+import ListProvider from './providers/list';
+import QuotedProvider from './providers/quoted';
+import { ReadonlyToolbar } from './readonly-toolbar';
+import { ReadonlyToolbarCommandProvider, ReadonlyCommandOptions } from './readonly-toolbar/types';
+import { AddCommentToOldDocCommandProvider } from './readonly-toolbar/add-comment-to-old-doc';
+import ClipboardProvider from './providers/clipboard-provider';
+export * from './providers/utils/clipboard';
+export * from './providers/utils';
+export { ClipboardProvider, ListProvider, QuotedProvider, TextCommandProvider, injectBlockOptions, LinkProvider, InlineBoxCommandProvider, AlignProvider, ParagraphProvider, ProxyProvider, InlineCodeProvider, InlineStyleProvider, ColorStyleProvider, ScriptDropdownProvider, TextScriptProvider, HeadingProvider, MobileLinkProvider, InsertMenuProvider, };
+export type { QuickMenuCommandParams, QuickMenuCommandProvider, QuickMenuCommandBetween, AddMenuCommand, QuickMenuCommandInline, OnesEditorToolbarBase, OnesEditorTooltipCallbacks, EditorTooltipTippyInstance, OnesEditorTooltipProps, QuickMenuItem, QuickMenuOptions, ReadonlyToolbarCommandProvider, ReadonlyCommandOptions, };
+export { BlockMenu, BlockCommandProviders, OnesEditorToolbar, OnesEditorQuickMenu, OnesEditorTooltip, editLink, TextStyleShortcuts, getToolbar, BasicCommands, isSelectBoxOnly, getReferenceClientRect, ReadonlyToolbar, AddCommentToOldDocCommandProvider, };
+export * from './utils/hide-toolbar';

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

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

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

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

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

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

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

@@ -24,6 +24,8 @@ declare const _default: {
         cancelText: string;
         edit: string;
         remove: string;
+        title: string;
+        openLink: string;
     };
     commands: {
         unordered: string;
@@ -38,6 +40,18 @@ declare const _default: {
         heading: string;
         headingGroup: string;
         text: string;
+        paste: string;
+        tab: string;
+        shiftTab: string;
+        bold: string;
+        italic: string;
+        underline: string;
+        strikethrough: string;
+        code: string;
+        subscript: string;
+        superscript: string;
+        more: string;
+        selectBlock: string;
     };
 };
 export default _default;

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

@@ -24,6 +24,8 @@ declare const _default: {
         cancelText: string;
         edit: string;
         remove: string;
+        title: string;
+        openLink: string;
     };
     commands: {
         unordered: string;
@@ -38,6 +40,18 @@ declare const _default: {
         heading: string;
         headingGroup: string;
         text: string;
+        paste: string;
+        tab: string;
+        shiftTab: string;
+        bold: string;
+        italic: string;
+        underline: string;
+        strikethrough: string;
+        code: string;
+        subscript: string;
+        superscript: string;
+        more: string;
+        selectBlock: string;
     };
 };
 export default _default;

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

@@ -24,6 +24,8 @@ declare const _default: {
         cancelText: string;
         edit: string;
         remove: string;
+        title: string;
+        openLink: string;
     };
     commands: {
         unordered: string;
@@ -38,6 +40,18 @@ declare const _default: {
         heading: string;
         headingGroup: string;
         text: string;
+        paste: string;
+        tab: string;
+        shiftTab: string;
+        bold: string;
+        italic: string;
+        underline: string;
+        strikethrough: string;
+        code: string;
+        subscript: string;
+        superscript: string;
+        more: string;
+        selectBlock: string;
     };
 };
 export default _default;

package/@ones-editor/ui/src/providers/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/providers/align.d.ts

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

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

@@ -0,0 +1,16 @@
+import { BlockCommands, BlockElement, CommandItem, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../@ones-editor/core';
+interface CommandWithExecute {
+    command: CommandItem;
+    executeCommand: BlockCommands['executeCommand'];
+}
+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/clipboard-provider.d.ts

@@ -0,0 +1,20 @@
+import { BlockElement, CommandItem, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../@ones-editor/core';
+export default class ClipboardProvider implements OnesEditorCommandProvider {
+    private editor;
+    private options;
+    id: string;
+    constructor(editor: OnesEditor, options: {
+        withPaste: boolean;
+    });
+    private clipboardPermission;
+    private isSecureContext;
+    get hasClipboardReadPermission(): boolean;
+    get hasClipboardWritePermission(): boolean;
+    clipboardSupport(): void;
+    canPaste(): Promise<boolean>;
+    createPasteElement(editor: OnesEditor): HTMLDivElement;
+    getAvailableCommands: (editor: OnesEditor, blockElement: BlockElement) => CommandItem[];
+    getInsertCommands: () => never[];
+    copyRange(editor: OnesEditor, range: SelectionRange): void;
+    executeRangeCommand(editor: OnesEditor, range: SelectionRange, command: CommandItem): boolean;
+}

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

@@ -0,0 +1,18 @@
+import { BlockElement, CommandItem, CommandParams, OnesEditor, OnesEditorCommandProvider, SelectionRange, CommandResult, BlockAttributesHandler } 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);
+    get blockAttributesHandler(): BlockAttributesHandler;
+    private getEmptyTextBlockColor;
+    private setEmptyTextBlockColor;
+    private updateButtonColor;
+    private setActiveAttribute;
+    private handleChangeColor;
+    getAvailableCommands(editor: OnesEditor, block: BlockElement, range: SelectionRange, params?: CommandParams): 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/edit-link-provider.d.ts

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

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

@@ -0,0 +1,13 @@
+import { BlockElement, CommandItem, CommandParams, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../@ones-editor/core';
+export default class HeadingProvider implements OnesEditorCommandProvider {
+    private editor;
+    private options?;
+    id: string;
+    constructor(editor: OnesEditor, options?: CommandParams | undefined);
+    getHeadingIndex(): number;
+    createHeadingCommandItem(heading: number): CommandItem[];
+    getAvailableCommands(editor: OnesEditor, block: BlockElement, range: SelectionRange, params?: CommandParams): 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,10 @@
+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?: CommandParams): 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, params?: CommandParams): 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, CommandItemWithSource, CommandParams, OnesEditor, SelectionRange } from '../../../../@ones-editor/core';
+import { ProxyProvider } from './proxy-provider';
+export default class InsertAboveProvider extends ProxyProvider {
+    private editor;
+    id: string;
+    constructor(editor: OnesEditor);
+    getAvailableCommands: (editor: OnesEditor, block: BlockElement) => CommandItem[];
+    executeCommand: (editor: OnesEditor, block: BlockElement, range: SelectionRange, command: CommandItemWithSource, params: CommandParams) => boolean;
+}

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

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

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

@@ -0,0 +1,12 @@
+import { BlockElement, CommandItem, CommandItemWithSource, CommandParams, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../@ones-editor/core';
+import { ProxyProvider } from './proxy-provider';
+export declare class InlineBoxCommandProvider extends ProxyProvider implements OnesEditorCommandProvider {
+    private editor;
+    id: string;
+    constructor(editor: OnesEditor);
+    create(commands: CommandItem[]): CommandItem[];
+    getAvailableCommands: (editor: OnesEditor, block: BlockElement, range: SelectionRange) => CommandItem[];
+    getInsertCommands: (editor: OnesEditor, containerId: string) => CommandItem[];
+    executeCommand: (editor: OnesEditor, block: BlockElement, range: SelectionRange, item: CommandItemWithSource, params: CommandParams) => boolean;
+    executeInsertCommand: (editor: OnesEditor, containerId: string, blockIndex: number, item: CommandItemWithSource, 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, CommandItemWithSource, CommandParams, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../@ones-editor/core';
+import { ProxyProvider } from './proxy-provider';
+import { QuickMenuCommandProvider } from '../quick-menu/types';
+export default class InsertMenuProvider extends ProxyProvider {
+    private editor;
+    private options?;
+    id: string;
+    providersMap: Map<string, OnesEditorCommandProvider>;
+    providers: OnesEditorCommandProvider[];
+    quickProviders: QuickMenuCommandProvider[];
+    constructor(editor: OnesEditor, options?: CommandParams | undefined);
+    getInsertCommands: (editor: OnesEditor, containerId: string) => CommandItem[];
+    getAvailableCommands: (editor: OnesEditor, block: BlockElement, range: SelectionRange) => CommandItem[];
+    executeInsertCommand: (editor: OnesEditor, containerId: string, blockIndex: number, item: CommandItemWithSource, params: CommandParams) => boolean;
+    executeCommand: (editor: OnesEditor, block: BlockElement, range: SelectionRange, item: CommandItemWithSource, params: CommandParams) => boolean;
+}

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

@@ -0,0 +1,12 @@
+import { BlockElement, CommandItem, CommandParams, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../@ones-editor/core';
+export declare class LinkProvider implements OnesEditorCommandProvider {
+    private editor;
+    id: string;
+    constructor(editor: OnesEditor);
+    create(): CommandItem[];
+    isDisabled: (editor: OnesEditor, block: BlockElement, range: SelectionRange) => boolean;
+    getAvailableCommands: (editor: OnesEditor, block: BlockElement, range: SelectionRange, params?: CommandParams) => 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,13 @@
+import { BlockElement, CommandItem, CommandParams, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../@ones-editor/core';
+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?: CommandParams): 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/mobile-link-provider.d.ts

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

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

@@ -0,0 +1,9 @@
+import { BlockElement, CommandItem, CommandParams, OnesEditor, OnesEditorCommandProvider, SelectionRange } 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);
+    getAvailableCommands: (editor: OnesEditor, block: BlockElement, range: SelectionRange, params?: CommandParams) => CommandItem[];
+}

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

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

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

@@ -0,0 +1,10 @@
+import { BlockElement, CommandItem, CommandParams, 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?: CommandParams): 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, CommandParams, 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, params?: CommandParams) => CommandItem[];
+}

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

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

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

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

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, params?: CommandParams): 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[];
+}