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

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

@@ -1,33 +1,21 @@
 import './style.scss';
 import OnesEditorToolbar from './toolbar/toolbar-handler';
-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 OnesEditorQuickMenu, { getAllQuickMenuItems, getHeadingMenuOptions, QuickMenuCommandBetween, QuickMenuCommandInline, QuickMenuCommandProvider, BasicCommands, GetAllQuickMenuItemsOptions, QuickMenuCommandParams, AddMenuCommand, QuickMenuItemFilter } from './quick-menu';
 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 { 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, };
+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, };
 export { createTextButton } from './text-button';
+export { mergeCommands } from './toolbar/merge-commands';

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

@@ -1,4 +1,5 @@
-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/quick-menu/basic-menu-items.d.ts

@@ -0,0 +1,16 @@
+import { BlockElement } from '../../../../@ones-editor/core';
+import type { BlockOptions, CommandItem, OnesEditor, InsertEmptyBlockOptions } from '../../../../@ones-editor/core';
+import type { AddMenuCommand, QuickMenuCommandBetween, QuickMenuCommandInline, QuickMenuCommandProvider } from './types';
+export declare function addQuickMenuItemFields(item: CommandItem, options: BlockOptions, blockType: string): void;
+export declare function getPlainTextMenuOptions(): BlockOptions;
+export declare function getHeadingMenuOptions(start?: number): BlockOptions;
+export declare function getCompleteHeadingMenuOptions(): CommandItem[];
+export declare class BasicCommandProvider implements QuickMenuCommandProvider {
+    private withPlainText?;
+    constructor(withPlainText?: boolean | undefined);
+    getCommands(): CommandItem[];
+    updateBlock(editor: OnesEditor, containerId: string, block: BlockElement, item: CommandItem): null;
+    handleUpdateBlockCore(editor: OnesEditor, options: InsertEmptyBlockOptions): Promise<null>;
+    handleInsertEmptyBlockCore(editor: OnesEditor, options: InsertEmptyBlockOptions): Promise<null>;
+    executeCommand(editor: OnesEditor, item: CommandItem, params: QuickMenuCommandInline | QuickMenuCommandBetween | AddMenuCommand): Promise<BlockElement | null>;
+}

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

@@ -1,21 +1,33 @@
-import { OnesEditor, CommandItem, CommandFilterId, CommandFilter } from '../../../../@ones-editor/core';
+import { OnesEditor, CommandItem } from '../../../../@ones-editor/core';
 import { OnesEditorAutoSuggest } from '../../../../@ones-editor/ui-base';
-import { QuickMenuOptions } from './types';
+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 };
 export default class OnesEditorQuickMenu {
     protected editor: OnesEditor;
     private options;
     protected suggest: OnesEditorAutoSuggest;
-    private items;
+    private _items;
+    private maxHeading;
     private firstEmptyOffset;
-    private quickCommandProviders;
+    private commandFilters;
+    private currentContainerId;
+    private currentBlockIndex;
+    private get selectedBlock();
+    private get items();
+    private set items(value);
     constructor(editor: OnesEditor, options?: QuickMenuOptions);
     get menu(): import("@ones-editor/ui-base").ManualMenu;
-    addFilter(id: CommandFilterId, filter: CommandFilter): void;
+    addFilter(id: QuickMenuItemFilterId, filter: QuickMenuItemFilter): void;
     destroy(): void;
-    queryItems: (suggest: unknown, text: string) => Promise<CommandItem[]>;
+    queryItems: (suggest: unknown, text: string) => Promise<QuickMenuItem[]>;
     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/inline-box-items.d.ts

@@ -0,0 +1,8 @@
+import { InsertEmptyBlockOptions, OnesEditor, BlockElement, CommandItem } from '../../../../@ones-editor/core';
+import { AddMenuCommand, QuickMenuCommandBetween, QuickMenuCommandInline, QuickMenuCommandProvider } from './types';
+export declare class InlineBoxCommandProvider implements QuickMenuCommandProvider {
+    getCommands(): CommandItem[];
+    handleUpdateBlockCore(editor: OnesEditor, options: InsertEmptyBlockOptions): Promise<void | BlockElement | null>;
+    handleInsertEmptyBlockCore(editor: OnesEditor, options: InsertEmptyBlockOptions): Promise<BlockElement | null>;
+    executeCommand(editor: OnesEditor, item: CommandItem, params: QuickMenuCommandInline | QuickMenuCommandBetween | AddMenuCommand): Promise<BlockElement | null>;
+}

package/@ones-editor/ui/src/quick-menu/insert-empty-block.d.ts

@@ -0,0 +1,4 @@
+import { OnesEditor } from '../../../../@ones-editor/core';
+import { AutoSuggestAnchor } from '../../../../@ones-editor/ui-base';
+import { QuickMenuItem } from './types';
+export declare function insertEmptyBlock(editor: OnesEditor, quickItem: QuickMenuItem, anchor: AutoSuggestAnchor): void;

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

@@ -0,0 +1 @@
+export declare const GroupOrder: Record<string, number>;

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

@@ -0,0 +1,9 @@
+import { BlockElement, CommandItemMenuType, OnesEditor } from '../../../../@ones-editor/core';
+import { QuickMenuCommandParams, QuickMenuItem } from './types';
+export interface GetAllQuickMenuItemsOptions {
+    withPlainText: boolean;
+    from: QuickMenuCommandParams['from'];
+    type: CommandItemMenuType;
+    ignoreFilter?: boolean;
+}
+export declare function getAllQuickMenuItems(editor: OnesEditor, block: BlockElement | undefined, options: GetAllQuickMenuItemsOptions): QuickMenuItem[];

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

@@ -27,6 +27,10 @@ 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/readonly-toolbar/add-comment-to-old-doc.d.ts

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

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

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

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

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

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

@@ -1,10 +1,10 @@
-import { BlockElement, CommandItem, DocBlock, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../@ones-editor/core';
+import { BlockCommandItem, BlockElement, 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): CommandItem[];
-    getInsertCommands: () => never[];
-    executeCommand(editor: OnesEditor, block: BlockElement, range: SelectionRange, command: CommandItem): boolean;
+    getAvailableCommands(editor: OnesEditor, block: BlockElement, range: SelectionRange): BlockCommandItem[];
+    executeCommand(editor: OnesEditor, block: BlockElement, range: SelectionRange, command: BlockCommandItem): boolean;
 }

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

@@ -0,0 +1,11 @@
+import { BlockCommandItem, BlockElement, DocBlock, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../../@ones-editor/core';
+export default class ParagraphProvider implements OnesEditorCommandProvider {
+    private editor;
+    id: string;
+    constructor(editor: OnesEditor);
+    isChecked(blockData: DocBlock, id: string): boolean;
+    getAvailableCommands(editor: OnesEditor, block: BlockElement): BlockCommandItem[];
+    convertLink(editor: OnesEditor, range: SelectionRange, block: BlockElement): void;
+    convertToList(editor: OnesEditor, block: BlockElement, listType: 'unordered' | 'ordered' | 'unchecked'): void;
+    executeCommand(editor: OnesEditor, block: BlockElement, range: SelectionRange, command: BlockCommandItem): boolean;
+}

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

@@ -0,0 +1,10 @@
+import { BlockCommandItem, BlockElement, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../../@ones-editor/core';
+export default class BlockTurnIntoCommandProvider implements OnesEditorCommandProvider {
+    private editor;
+    id: string;
+    constructor(editor: OnesEditor);
+    getHeadingIndex(): number;
+    getAvailableCommands(editor: OnesEditor, block: BlockElement, range: SelectionRange): BlockCommandItem[];
+    applyHeadingStyle(editor: OnesEditor, block: BlockElement, heading: number | null): void;
+    executeCommand(editor: OnesEditor, block: BlockElement, range: SelectionRange, command: BlockCommandItem): boolean;
+}

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

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

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

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

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

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

package/@ones-editor/ui-base/src/color-button/text-color-item.d.ts

@@ -8,7 +8,6 @@ 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 | TouchEvent) => void;
+    protected handleItemClick: (event: MouseEvent) => void;
     private showSubCommandBar;
     isInCommandBar(target: EventTarget | null): boolean;
     createCommandItem(item: CommandItem): CommandItemElement;

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

@@ -28,7 +28,6 @@ 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;
@@ -62,7 +61,7 @@ export interface CommandBarOptions {
     header?: HTMLElement | (() => HTMLElement | null);
     footer?: HTMLElement | (() => HTMLElement | null);
     padding?: number;
-    beforeClose?: (event?: MouseEvent | TouchEvent) => boolean;
+    beforeClose?: (event?: MouseEvent) => 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 | TouchEvent) => boolean;
+    beforeClose?: (event?: MouseEvent) => boolean;
 };
 export default class Popup extends ManualCommandBar {
     constructor(content: HTMLElement, options?: PopupOptions);

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

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