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

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

@@ -1,13 +1,11 @@
-import { BlockElement, OnesEditor, CommandFilterId, CommandFilter, CommandItem } from '../../../../@ones-editor/core';
+import { BlockElement, OnesEditor, 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/block-menu/src/block-menu/items/block-command-items.d.ts

@@ -0,0 +1,3 @@
+import { BlockElement, OnesEditor } from '../../../../../@ones-editor/core';
+import { BlockMenuItem } from './types';
+export declare function getBlockCommandItems(editor: OnesEditor, block: BlockElement, excludes?: Set<string>): BlockMenuItem[];

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

@@ -0,0 +1,5 @@
+import { BlockElement, OnesEditor } from '../../../../../@ones-editor/core';
+import { TextStyleItemOptions } from './text-styles/text-style-item';
+import { BlockMenuItem } from './types';
+export declare function getBlockMenuItems(editor: OnesEditor, block: BlockElement, options: TextStyleItemOptions): BlockMenuItem[];
+export declare function handleBlockMenuItemClick(editor: OnesEditor, block: BlockElement, item: BlockMenuItem): void;

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

@@ -0,0 +1,5 @@
+import { BlockElement, OnesEditor } from '../../../../../../@ones-editor/core';
+import type { GetAllQuickMenuItemsOptions } from '../../../../../../@ones-editor/ui';
+import type { BlockMenuItem } from '../types';
+export declare function getAllInsertBlockItems(editor: OnesEditor, block: BlockElement, source: 'insert-block' | 'insert-block-before', options: GetAllQuickMenuItemsOptions): BlockMenuItem[];
+export declare function executeInsertBlockCommand(editor: OnesEditor, block: BlockElement, item: BlockMenuItem, insertAbove?: boolean): Promise<BlockElement | null> | undefined;

package/@ones-editor/block-menu/src/block-menu/items/text-styles/text-style-item.d.ts

@@ -0,0 +1,30 @@
+import { BlockElement, OnesEditor, DocBlock } from '../../../../../../@ones-editor/core';
+import { BlockMenuItem } from '../types';
+export interface ParagraphBlockAttribute extends DocBlock {
+    'heading'?: number;
+    quoted?: boolean;
+    align?: 'left' | 'center' | 'right';
+    checkbox?: 'checked' | 'unchecked';
+    ordered?: boolean;
+}
+export type TextStyleItemOptions = {
+    fromEmbed?: boolean;
+    onAfterStyleItemClick?: () => void;
+};
+export default class TextStyleItem implements BlockMenuItem {
+    private editor;
+    private block;
+    private options;
+    source: string;
+    id: string;
+    name: string;
+    element: HTMLElement;
+    private textStylesTooltips;
+    constructor(editor: OnesEditor, block: BlockElement, options: TextStyleItemOptions);
+    createItemElement(editor: OnesEditor, block: BlockElement): HTMLDivElement;
+    private createHeadingItemElement;
+    private createListItemElement;
+    createItem(id: string, icon: string, parent: HTMLElement, active?: boolean): void;
+    handleClick: (editor: OnesEditor, event: Event) => void;
+    private calcTextStyleItemTooltipsEnum;
+}

package/@ones-editor/block-menu/src/block-menu/items/types.d.ts

@@ -0,0 +1,5 @@
+import { CommandItem } from '../../../../../@ones-editor/core';
+export interface BlockMenuItem extends CommandItem {
+    source: string;
+    blockMenuItemCustomData?: unknown;
+}

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/callout-block/src/callout-block/callout-quick-menu-item-filter.d.ts

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

package/@ones-editor/comments/src/comments-helper/old-version-comment.d.ts

@@ -0,0 +1,16 @@
+import { DocObject, OnesEditor, OnesEditorComment, OnesEditorDocRange, SelectionRange } from '../../../../@ones-editor/core';
+export interface AddCommentToOldVersionBody {
+    avatarUrl: string;
+    containerId: string;
+    rangeType: 'simple' | 'complex';
+    range: OnesEditorDocRange;
+    selectedContainers: string[];
+    commentId?: string;
+    commentGroupId?: string;
+    comment: DocObject;
+    abstract?: string;
+}
+export declare function addCommentToOldVersion(editor: OnesEditor, version: number, range: SelectionRange, comment: OnesEditorComment, commentDoc: DocObject): Promise<void>;
+export declare function replyCommentToOldVersion(editor: OnesEditor, version: number, comment: OnesEditorComment, commentDoc: DocObject): Promise<unknown>;
+export declare function updateCommentToOldDoc(editor: OnesEditor, version: number, commentId: string, commentDoc: DocObject): Promise<unknown>;
+export declare function deleteCommentFromOldDoc(editor: OnesEditor, version: number, commentId: string): Promise<unknown>;

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

@@ -8,4 +8,7 @@ export { OnesEditorComments };
 export type { CommentItem } from './comment-item';
 export type { CommentGroupItem } from './comments-list/group-item';
 export { removeCommentFromBlock } from './actions/remove-comment-from-block';
+export { addCommentToTextBlocks } from './actions/add-comment-to-text-block';
+export { addCommentToBlock } from './actions/add-comment-to-block';
 export { editorAddComment } from './actions/editor-add-comment';
+export * from './comments-helper/old-version-comment';

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

@@ -1,13 +1,12 @@
-import { BlockElement, CommandItem, CommandItemWithSource, CommandParams, CommandResult, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../@ones-editor/core';
+import { BlockCommandItem, BlockCommandItemWithSource, BlockElement, 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): CommandItem[];
+    getAvailableCommands(editor: OnesEditor, block: BlockElement, range: SelectionRange): BlockCommandItem[];
     hideToolbar(editor: OnesEditor): void;
-    executeRangeCommand(editor: OnesEditor, range: SelectionRange, command: CommandItemWithSource, params: CommandParams, result?: CommandResult): boolean;
+    executeRangeCommand(editor: OnesEditor, range: SelectionRange, command: BlockCommandItemWithSource, params: CommandParams, result: CommandResult): boolean;
 }

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

@@ -1,10 +1,10 @@
-import { BlockCommands, BlockElement, OnesEditor } from '../../types';
+import { BlockCommands, BlockElement, BoxCommands, OnesEditor, TextBlockContentChild } from '../../types';
 export declare function getBlockProperties(editor: OnesEditor, block: BlockElement): import("../../types").BlockProperties | undefined;
-export declare function getBlockCommandsWithHook(editor: OnesEditor, block: BlockElement): Record<string, BlockCommands>;
-export declare function getSpecialBlockCommands(editor: OnesEditor, blockElement: BlockElement, group: string): {
-    element: import("../../types").BlockContentElement;
-    commands: import("../../types").CommandItem[];
-} | {
-    element: null;
-    commands: never[];
-};
+export declare function getBlockCommandsWithHook(editor: OnesEditor, block: BlockElement, child: TextBlockContentChild | null): Record<string, BlockCommands>;
+interface SpecialBlockCommands {
+    element: HTMLElement | null;
+    blockCommands: BlockCommands[];
+    boxCommands: BoxCommands[];
+}
+export declare function getSpecialBlockCommands(editor: OnesEditor, blockElement: BlockElement, child: TextBlockContentChild | null, group: string): SpecialBlockCommands;
+export {};

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

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

package/@ones-editor/core/src/core/blocks/complex-blocks/child-blocks.d.ts

@@ -1,7 +1,8 @@
-import { BlockElement, OnesEditor, SelectedBlock } from '../../types';
+import { BlockElement, OnesEditor, SelectedBlock, SelectionRange } from '../../types';
 export type GetAllChildBlocksOptions = {
     simpleBlockOnly?: boolean;
     visibleOnly?: boolean;
+    range?: SelectionRange;
 };
 export declare function getAllChildBlocks(editor: OnesEditor, options?: GetAllChildBlocksOptions): BlockElement[];
 export declare function getAllSelectedBlocks(editor: OnesEditor, options?: GetAllChildBlocksOptions): SelectedBlock[];

package/@ones-editor/core/src/core/blocks/complex-blocks/complex-block-helper.d.ts

@@ -1,4 +1,4 @@
-import { OnesEditor, BlockElement, BlockPosition, ContainerElement, ComplexBlockPosition, GetChildContainerOptions } from '../../types';
+import { OnesEditor, BlockElement, BlockPosition, ContainerElement, ComplexBlockPosition, GetChildContainerOptions, ComplexSelectionRange } from '../../types';
 export declare function complexBlockGetAllChildContainers(editor: OnesEditor, block: BlockElement, options?: GetChildContainerOptions): ContainerElement[];
 export declare function complexBlockGetSelectedContainers(editor: OnesEditor, block: BlockElement, start: BlockPosition, end: BlockPosition): ContainerElement[];
 export declare function isFirstChildBlockInComplexBlock(editor: OnesEditor, childBlock: BlockElement): boolean;
@@ -13,3 +13,4 @@ export declare function complexBlockAdjustSelectionPos(editor: OnesEditor, compl
     anchor: ComplexBlockPosition;
     focus: ComplexBlockPosition;
 };
+export declare function isFullSelectedOneComplexBlock(editor: OnesEditor, complexRange?: ComplexSelectionRange): boolean;

package/@ones-editor/core/src/core/blocks/text-blocks/base/child.d.ts

@@ -1,10 +1,5 @@
-import { BlockElement, BoxElement, InsertionElement } from '../../../types';
-export type TextBlockContentTextChild = HTMLSpanElement & {
-    __neverUse: 'TextBlockContentTextChild';
-};
-export type TextBlockContentInsertionChild = InsertionElement;
-export type TextBlockContentBoxChild = BoxElement;
-export type TextBlockContentChild = TextBlockContentTextChild | TextBlockContentBoxChild | TextBlockContentInsertionChild;
+import { BlockElement, TextBlockContentTextChild, TextBlockContentBoxChild, TextBlockContentInsertionChild, TextBlockContentChild } from '../../../types';
+export type { TextBlockContentTextChild, TextBlockContentBoxChild, TextBlockContentInsertionChild, TextBlockContentChild };
 export type TextBlockContentChildren = TextBlockContentChild[];
 export type TextBlockContentChildType = 'text' | 'box' | 'insertion';
 export declare function isTextBlockContentChild(elem: Element): boolean;

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

@@ -1,4 +1,2 @@
 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/range-commands.d.ts

@@ -1,5 +1,5 @@
-import { CommandItemWithSource, CommandParams, CommandResult, SelectionRange } from '../../types';
-export declare function getRangeCommands(range: SelectionRange, source: string): CommandItemWithSource[];
-export declare function executeRangeCommand(range: SelectionRange, command: CommandItemWithSource, params: CommandParams): {
+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;
 };

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

@@ -1,15 +1,14 @@
 import { DocBlockTextAttributes } from '../doc';
-import { OnesEditor, OnesEditorCommandProviders, OnesEditorCommandProvider, SelectionRange, CommandParams, CommandItemWithSource } from '../types';
+import { OnesEditor, OnesEditorCommandProviders, OnesEditorCommandProvider, SelectionRange, CommandParams, BlockCommandItemWithSource } from '../types';
 export default class EditorCommandProviders implements OnesEditorCommandProviders {
     private editor;
-    id: string;
     private providers;
     constructor(editor: OnesEditor);
     registerCommandProvider(provider: OnesEditorCommandProvider): void;
     getCommandProviders(): OnesEditorCommandProvider[];
     getCommandProvider(id: string): OnesEditorCommandProvider;
-    getCommands(range: SelectionRange): CommandItemWithSource[];
-    executeCommand(range: SelectionRange, command: CommandItemWithSource, params: CommandParams): {
+    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;

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

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

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 | TouchEvent) => void;
+    handleDocumentClick: (event: MouseEvent) => 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 | TouchEvent) => void;
-    handleBlockClick: (event: MouseEvent | TouchEvent, block: BlockElement, elem: Element) => void;
+    handleClick: (event: MouseEvent) => void;
+    handleBlockClick: (event: MouseEvent, block: BlockElement, elem: Element) => void;
     handleDblClick: (event: MouseEvent) => void;
-    handleMouseDown: (event: TouchEvent | MouseEvent) => void;
+    handleMouseDown: (event: MouseEvent) => void;
     handleMouseMove: (event: MouseEvent) => void;
-    handleMouseUp: (event: MouseEvent | TouchEvent) => void;
+    handleMouseUp: (event: MouseEvent) => void;
     handleCaptureClick: (event: MouseEvent) => void;
     handleCaptureDbClick: (event: MouseEvent) => void;
     reload(): void;

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

@@ -110,10 +110,12 @@ export interface OnesEditorDocComplexBlockPos {
 }
 export type OnesEditorDocBlockPos = OnesEditorDocSimpleBlockPos | OnesEditorDocComplexBlockPos;
 export interface OnesEditorDocSimpleRange {
+    reverse?: boolean;
     anchor: OnesEditorDocSimpleBlockPos;
     focus: OnesEditorDocSimpleBlockPos;
 }
 export interface OnesEditorDocComplexRange {
+    reverse?: boolean;
     anchor: OnesEditorDocComplexBlockPos;
     focus: OnesEditorDocComplexBlockPos;
 }
@@ -202,6 +204,7 @@ export interface OnesEditorDocServerMeta {
     serverId?: string;
     docId?: string;
     appId?: string;
+    apiServer?: string;
 }
 export interface RecognizeLinkResult {
     type?: 'iframe' | 'video' | 'audio' | 'image';

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

@@ -23,5 +23,4 @@ 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';
-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, };
+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, };

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

@@ -1,4 +1,3 @@
 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: TouchEvent | MouseEvent | null;
+    mouseDownEvent: MouseEvent | null;
     autoScroll: AutoScroll | null;
     constructor(editor: OnesEditor);
     isSelecting(): boolean;
     stopSelection(): void;
-    handleMouseDown: (event: MouseEvent | TouchEvent, options: {
+    handleMouseDown: (event: MouseEvent, options: {
         autoScroll: boolean;
     }) => void;
     handleMouseMove: (event: MouseEvent) => void;
-    handleMouseUp: (event: MouseEvent | TouchEvent) => void;
+    handleMouseUp: (event: MouseEvent) => void;
     handleDblClick(event: MouseEvent): void;
     handleTripleClick(event: MouseEvent): void;
 }

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

@@ -1,5 +1,11 @@
 import { TypedEmitter } from 'tiny-typed-emitter';
 import { DocBlock, DocBlockAttributes, DocBlockDelta, DocBlocks, DocBlockText, DocBlockTextAttributes, DocBox, DocEmbedBlock, DocEmbedData, DocInsertion, DocObject, InsertBlockOptions, OnesEditorDoc, OnesEditorDocRange, UpdateBlockOptions } from './doc';
+export type TextBlockContentTextChild = HTMLSpanElement & {
+    __neverUse: 'TextBlockContentTextChild';
+};
+export type TextBlockContentInsertionChild = InsertionElement;
+export type TextBlockContentBoxChild = BoxElement;
+export type TextBlockContentChild = TextBlockContentTextChild | TextBlockContentBoxChild | TextBlockContentInsertionChild;
 export type ContainerElement = HTMLDivElement & {
     __neverUse: 'ContainerElement';
 };
@@ -52,6 +58,7 @@ export type BlockPosition = SimpleBlockPosition | ComplexBlockPosition;
 export interface BoxCommands {
     group: string;
     commands: CommandItem[];
+    startGroup?: boolean;
     executeCommand: (editor: OnesEditor, block: BlockElement, box: BoxElement, item: CommandItem) => unknown;
 }
 export interface BoxProperties {
@@ -119,6 +126,7 @@ 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;
@@ -129,7 +137,7 @@ export interface CommandItem {
     type?: CommandItemType;
     element?: HTMLElement | ((item: CommandItem) => HTMLElement);
     icon?: string;
-    childrenType?: 'menu' | 'toolbar' | 'mobile-bottom-menu';
+    childrenType?: 'menu' | 'toolbar';
     children?: CommandItem[];
     childrenMenuId?: string;
     data?: unknown;
@@ -151,8 +159,18 @@ 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;
@@ -163,9 +181,11 @@ export type BlockPathComponent = {
 };
 export type BlockPath = BlockPathComponent[];
 export interface BlockCommands {
+    element?: HTMLElement;
     group: string;
     commands: CommandItem[];
-    executeCommand: (editor: OnesEditor, block: BlockElement, item: CommandItem) => unknown;
+    startGroup?: boolean;
+    executeCommand: (editor: OnesEditor, block: BlockElement, item: CommandItem, child: TextBlockContentChild | null) => unknown;
 }
 export interface BlockProperties {
     blockCommands?: Record<string, BlockCommands>;
@@ -648,11 +668,11 @@ export interface OnesEditorInput {
 export interface OnesEditorSelectionHandler {
     isSelecting: () => boolean;
     stopSelection: () => void;
-    handleMouseDown: (event: MouseEvent | TouchEvent, options: {
+    handleMouseDown: (event: MouseEvent, options: {
         autoScroll: boolean;
     }) => void;
     handleMouseMove: (event: MouseEvent) => void;
-    handleMouseUp: (event: MouseEvent | TouchEvent) => void;
+    handleMouseUp: (event: MouseEvent) => void;
     handleDblClick: (event: MouseEvent) => void;
     handleTripleClick: (event: MouseEvent) => void;
 }
@@ -703,46 +723,32 @@ export interface OnesEditorInsertions {
 }
 export type CommandParams = {
     [index: string]: unknown;
-} & {
-    source?: string[];
 };
 export type CommandResult = {
     [index: string]: unknown;
 };
 export interface OnesEditorCommandProvider {
     id: string;
-    groupIndex?: number;
-    getAvailableCommands: (editor: OnesEditor, block: BlockElement, range: SelectionRange, params?: {
-        isFilter: boolean;
-    }) => CommandItem[];
-    getInsertCommands?: (editor: OnesEditor, containerId: string, blockIndex: number) => 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;
+    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 CommandItemWithSource extends CommandItem {
+export interface BlockCommandItemWithSource extends BlockCommandItem {
     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) => CommandItemWithSource[];
-    executeCommand: (range: SelectionRange, item: CommandItemWithSource, params: CommandParams) => {
+    getCommands: (range: SelectionRange, source: string) => BlockCommandItemWithSource[];
+    executeCommand: (range: SelectionRange, item: BlockCommandItemWithSource, params: CommandParams) => {
         [index: string]: CommandResult;
     };
-    getEmptyBlockTextAttributes?: (editor: OnesEditor, blockId: string) => DocBlockTextAttributes | undefined;
+    getEmptyBlockTextAttributes: (editor: OnesEditor, blockId: string) => DocBlockTextAttributes | undefined;
 }
 export interface EditorDocLocalActionCallbacks {
     onBeforeUpdateBlockText: (containerId: string, blockId: string, oldText: DocBlockText, newText: DocBlockText, newRange: OnesEditorDocRange) => void;
@@ -756,5 +762,5 @@ export interface OnesEditorBlockHook {
     create?: (editor: OnesEditor, path: BlockPath, container: ContainerElement, blockElement: BlockElement, blockData: DocBlock) => void;
     update?: (editor: OnesEditor, path: BlockPath, container: ContainerElement, blockElement: BlockElement, blockData: DocBlock) => void;
     writable?: (editor: OnesEditor, blockElement: BlockElement | BlockElement[]) => boolean | undefined;
-    commands?: (editor: OnesEditor, blockElement: BlockElement) => BlockCommands;
+    commands?: (editor: OnesEditor, blockElement: BlockElement, child: TextBlockContentChild | null) => BlockCommands | undefined;
 }

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

@@ -37,7 +37,4 @@ 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 | 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 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 interface DragDropOptions<T> {
     elem: HTMLElement;
     onDragStart: DragStartHandler<T>;
@@ -10,7 +10,6 @@ export interface DragDropOptions<T> {
     minThreshold?: number;
     cursor?: string;
     mouseDownEvent?: MouseEvent;
-    mobile?: boolean;
 }
 export declare const MIN_DISTANCE_THRESHOLD = 3;
 export declare class DragDrop<T> {
@@ -38,9 +37,5 @@ 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 | 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;
+    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;
 }

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

@@ -1,17 +1,11 @@
 import { OnesEditor, OnesEditorCustom } from '../../../@ones-editor/core';
-import { CommandHandler } from './fixed-toolbar';
-import './mobile-helper-styles.scss';
-export { CommandHandler };
 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/sharedb-doc/src/index.d.ts

@@ -1,6 +1,9 @@
+import axios from 'axios';
 import ShareDBDoc from './doc/sharedb-doc';
 import { RemoteCarets, RemoteCaretsDecorator } from './remote-carets';
 export { ShareDBDoc, RemoteCarets, RemoteCaretsDecorator };
 export * from './doc/comments';
 export * from './types';
 export * from './versions';
+export * from './utils/converter';
+export { axios };

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

@@ -9,6 +9,4 @@ export * from './split-cell';
 export * from './merge-cells';
 export * from './change-cell-color';
 export * from './chart';
-export * from './insert-column';
-export * from './insert-row';
 export { TableBlockCommandProvider };

package/@ones-editor/table-block/src/commands/table-block-commands.d.ts

@@ -1,10 +1,9 @@
-import { CommandItem, BlockElement, CommandParams, CommandResult, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../@ones-editor/core';
+import { BlockCommandItem, BlockElement, CommandParams, CommandResult, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../@ones-editor/core';
 declare const TableCommands: readonly ["table/merge-cells", "table/split-cell", "table/insert-column", "table/insert-row", "table/delete-rows", "table/delete-columns", "table/delete"];
 export type TableCommand = typeof TableCommands[number];
 export default class TableBlockCommandProvider implements OnesEditorCommandProvider {
     id: string;
-    groupIndex: number;
-    getAvailableCommands(editor: OnesEditor, block: BlockElement, range: SelectionRange): CommandItem[];
-    executeCommand(editor: OnesEditor, block: BlockElement, range: SelectionRange, command: CommandItem, params: CommandParams, result?: CommandResult): boolean;
+    getAvailableCommands(editor: OnesEditor, block: BlockElement, range: SelectionRange): BlockCommandItem[];
+    executeCommand(editor: OnesEditor, block: BlockElement, range: SelectionRange, command: BlockCommandItem, params: CommandParams, result: CommandResult): boolean;
 }
 export {};

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

@@ -1,11 +1,8 @@
 import TableBlock, { includeBigTable } from './table-block';
-import { TableBlockCommandProvider, deleteColumns, deleteRows, setStripeStyle, setColTitle, setRowTitle, insertColumn, insertRow } from './commands';
+import { TableBlockCommandProvider } from './commands';
 import './locale';
 import './table-style.scss';
 import TableShortcuts from './table-block/table-shortcuts';
-import { createEntireRowAndColumnRange, getAbstractTableSelectionRange } from './table-block/cell-menu/table-cell-dom';
 export * from './types';
 export { TableBlock, TableBlockCommandProvider, TableShortcuts, includeBigTable };
-export { deleteColumns, deleteRows, setStripeStyle, setColTitle, setRowTitle, insertColumn, insertRow, };
-export { createEntireRowAndColumnRange, getAbstractTableSelectionRange };
 export type { CreateTableData } from './table-block/table-creator';

package/@ones-editor/table-block/src/table-block/cell-menu/table-cell-dom.d.ts

@@ -1,12 +1,6 @@
 import { BlockElement, ComplexBlockPosition, OnesEditor, SimpleBlockPosition } from '../../../../../@ones-editor/core';
 export declare function getCellElementByChildBlockId(editor: OnesEditor, tableBlock: BlockElement, blockId: string): HTMLTableCellElement;
 export declare function createComplexPosFromBlockPos(editor: OnesEditor, tableBlock: BlockElement, blockPosition: ComplexBlockPosition | SimpleBlockPosition): ComplexBlockPosition;
-export declare function getAbstractTableSelectionRange(editor: OnesEditor, tableBlock: BlockElement): {
-    fromRow: number;
-    toRow: number;
-    fromCol: number;
-    toCol: number;
-};
 export declare function updateBarsDangerStatus(editor: OnesEditor, tableBlock: BlockElement, selectedRows: number[], selectedColumns: number[]): void;
 export declare function updateCellsDangerStatus(editor: OnesEditor, tableBlock: BlockElement, isDanger?: boolean, isCol?: boolean): void;
 export declare function updateCellBarsDangerStatus(editor: OnesEditor, tableBlock: BlockElement, isDanger?: boolean, isCol?: boolean): void;