@ones-editor/editor 2.0.8-beta.1 → 2.1.0-beta.1

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

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

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

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

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

@@ -1,18 +1,18 @@
 import './style.scss';
 import OnesEditorToolbar from './toolbar/toolbar-handler';
-import OnesEditorQuickMenu, { getAllQuickMenuItems, getHeadingMenuOptions, QuickMenuCommandBetween, QuickMenuCommandInline, QuickMenuCommandProvider, BasicCommands, GetAllQuickMenuItemsOptions, QuickMenuCommandParams, AddMenuCommand } from './quick-menu';
+import { QuickMenuCommandBetween, QuickMenuCommandInline, QuickMenuCommandProvider, QuickMenuCommandParams, AddMenuCommand, QuickMenuItem, QuickMenuOptions } from './quick-menu/types';
+import OnesEditorQuickMenu from './quick-menu';
+import * as BasicCommands from './providers/utils/basic-commands';
 import OnesEditorTooltip from './tooltips';
 import TextStyleShortcuts from './shortcuts';
 import { editLink } from './link-popup';
 import { getToolbar } from './toolbar/helper';
-import { GroupOrder } from './quick-menu/order';
 import { getReferenceClientRect } from './toolbar/get-reference-client-rect';
 import { isSelectBoxOnly } from './toolbar/box-only';
-import { InlineBoxCommandProvider } from './quick-menu/inline-box-items';
 import './locale';
 import type { OnesEditorToolbarBase } from './toolbar/types';
-import type { QuickMenuItem } from './quick-menu';
-export type { QuickMenuCommandParams, QuickMenuCommandProvider, QuickMenuCommandBetween, AddMenuCommand, QuickMenuCommandInline, GetAllQuickMenuItemsOptions, OnesEditorToolbarBase };
-export { OnesEditorToolbar, OnesEditorQuickMenu, OnesEditorTooltip, getAllQuickMenuItems, QuickMenuItem, editLink, TextStyleShortcuts, getToolbar, getHeadingMenuOptions, BasicCommands, GroupOrder, isSelectBoxOnly, InlineBoxCommandProvider, getReferenceClientRect, };
+import { BlockCommandProviders } from './block-menu/block-command-providers';
+import BlockMenu from './block-menu';
+export type { QuickMenuCommandParams, QuickMenuCommandProvider, QuickMenuCommandBetween, AddMenuCommand, QuickMenuCommandInline, OnesEditorToolbarBase, QuickMenuItem, QuickMenuOptions, };
+export { BlockMenu, BlockCommandProviders, OnesEditorToolbar, OnesEditorQuickMenu, OnesEditorTooltip, editLink, TextStyleShortcuts, getToolbar, BasicCommands, isSelectBoxOnly, getReferenceClientRect, };
 export { createTextButton } from './text-button';
-export { mergeCommands } from './toolbar/merge-commands';

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

@@ -0,0 +1,19 @@
+import { CommandFilter, CommandFilterId, CommandItemWithSource, CommandParams, CommandResult, OnesEditor, OnesEditorCommandProvider, OnesEditorCommandProviders, SelectionRange } from '../../../../@ones-editor/core';
+import AttributeMap from 'quill-delta/dist/AttributeMap';
+export declare abstract class AbstractProvider implements OnesEditorCommandProviders {
+    protected editor: OnesEditor;
+    abstract id: string;
+    commandProviders: OnesEditorCommandProvider[];
+    commandFilters: Map<string | number | symbol, CommandFilter>;
+    constructor(editor: OnesEditor);
+    abstract getCommands(range: SelectionRange): CommandItemWithSource[];
+    abstract executeCommand(range: SelectionRange, item: CommandItemWithSource, params: CommandParams): {
+        [index: string]: CommandResult;
+    };
+    abstract getEmptyBlockTextAttributes(editor: OnesEditor, blockId: string): AttributeMap | undefined;
+    addFilter(id: CommandFilterId, filter: CommandFilter): void;
+    registerCommandProvider: (provider: OnesEditorCommandProvider) => void;
+    getCommandProviders: () => OnesEditorCommandProvider[];
+    getCommandProvider: (id: string) => OnesEditorCommandProvider;
+    filterItems: (range: SelectionRange, items: CommandItemWithSource[]) => CommandItemWithSource[];
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,13 @@
+import { BlockElement, CommandItem, 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): CommandItem[];
+    getInsertCommands(): CommandItem[];
+    convertToList(editor: OnesEditor, block: BlockElement, listType: 'unordered' | 'ordered' | 'unchecked'): void;
+    insertList(editor: OnesEditor, containerId: string, blockIndex: number, listType: 'unordered' | 'ordered' | 'unchecked'): void;
+    executeCommand(editor: OnesEditor, block: BlockElement, range: SelectionRange, command: CommandItem): boolean;
+    executeInsertCommand: (editor: OnesEditor, containerId: string, blockIndex: number, command: CommandItem) => boolean;
+}

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

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

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

@@ -0,0 +1,9 @@
+import { BlockElement, CommandItem, 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) => CommandItem[];
+    getInsertCommands: (editor: OnesEditor, containerId: string, blockIndex: number) => CommandItem[];
+    executeCommand(editor: OnesEditor, block: BlockElement, range: SelectionRange, command: CommandItem, params: CommandParams, result?: CommandResult): boolean;
+    executeInsertCommand: (editor: OnesEditor, containerId: string, blockIndex: number, item: CommandItem, params: CommandParams, result?: CommandResult) => boolean;
+}

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

@@ -0,0 +1,10 @@
+import { BlockElement, CommandItem, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../@ones-editor/core';
+export default class QuotedProvider implements OnesEditorCommandProvider {
+    private editor;
+    id: string;
+    constructor(editor: OnesEditor);
+    getAvailableCommands(editor: OnesEditor, block: BlockElement): 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/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-styles.d.ts

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

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

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

package/@ones-editor/ui/src/providers/utils/add-section.d.ts

@@ -0,0 +1,2 @@
+import { CommandItem } from '../../../../../@ones-editor/core';
+export declare const addSection: (items: CommandItem[]) => CommandItem[];

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

@@ -1,5 +1,4 @@
-import { BlockElement, OnesEditor } from '../../../../@ones-editor/core';
+import { BlockElement, OnesEditor } from '../../../../../@ones-editor/core';
 export declare function applyHeadingStyle(editor: OnesEditor, block: BlockElement, heading: number | null): void;
 export declare function applyAlignStyle(editor: OnesEditor, block: BlockElement, align: string): void;
 export declare function applyQuoteStyle(editor: OnesEditor, block: BlockElement): void;
-export declare function applyList(editor: OnesEditor, block: BlockElement, id: 'unordered-list' | 'ordered-list' | 'check-list'): void;

package/@ones-editor/ui/src/providers/utils/inject-block-options.d.ts

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

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

@@ -1,26 +1,21 @@
-import { OnesEditor, CommandItem } from '../../../../@ones-editor/core';
+import { OnesEditor, CommandItem, CommandFilterId, CommandFilter } from '../../../../@ones-editor/core';
 import { OnesEditorAutoSuggest } from '../../../../@ones-editor/ui-base';
-import { QuickMenuItem, QuickMenuOptions } from './types';
-import { getHeadingMenuOptions } from './basic-menu-items';
-import * as BasicCommands from './basic-commands';
-export * from './types';
-export * from './quick-menu-items';
-export { getHeadingMenuOptions, BasicCommands };
+import { QuickMenuOptions } from './types';
 export default class OnesEditorQuickMenu {
     protected editor: OnesEditor;
     private options;
     protected suggest: OnesEditorAutoSuggest;
     private items;
-    private maxHeading;
     private firstEmptyOffset;
+    private quickCommandProviders;
     constructor(editor: OnesEditor, options?: QuickMenuOptions);
     get menu(): import("@ones-editor/ui-base").ManualMenu;
+    addFilter(id: CommandFilterId, filter: CommandFilter): void;
     destroy(): void;
-    queryItems: (suggest: unknown, text: string) => Promise<QuickMenuItem[]>;
+    queryItems: (suggest: unknown, text: string) => Promise<CommandItem[]>;
     onClose: () => void;
     onShow: (suggest: OnesEditorAutoSuggest, containerId: string, blockIndex: number, offset: number) => boolean;
     onClickItem: (suggest: unknown, item: CommandItem) => void;
     private initMenuItems;
-    private refreshMenuItems;
     private handleEmptySearch;
 }

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

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

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

@@ -1,6 +1,7 @@
 import { CommandItem, BlockOptions, OnesEditor, BlockElement } from '../../../../@ones-editor/core';
 export interface QuickMenuItem extends CommandItem {
     itemType: 'insert-block';
+    blockType?: string;
     blockOptions?: BlockOptions;
     commandProvider?: QuickMenuCommandProvider;
 }

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

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

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

@@ -30,6 +30,8 @@ export default class OnesEditorToolbar implements OnesEditorHoveringBlockFilter,
     handleDocumentMouseUp: () => void;
     private handleHoveringBlockChildChange;
     handleSelectionChange: import("lodash").DebouncedFunc<(editor: OnesEditor) => void>;
+    updateItems(updater: (items: CommandItem[]) => CommandItem[]): void;
+    updateItemStates(id: CommandItem['id'], states: Required<CommandItem>['states']): void;
     update(reason: ShowToolbarReason): void;
     private showTextToolbar;
     private showObjectToolbar;

package/@ones-editor/ui-base/src/color-palette/color-palette.d.ts

@@ -3,8 +3,9 @@ import type { ColorPaletteOptions } from './create-palette';
 import './palette.scss';
 export { ColorPaletteOptions };
 export type ColorType = 'color' | 'backgroundColor';
+export type PaletteClickHandler = (type: ColorType | 'clearColor', value: number) => void;
 export interface ColorPaletteEvents {
-    onClick: (type: ColorType | 'clearColor', value: number) => void;
+    onClick: PaletteClickHandler;
     beforePopup: () => void;
 }
 export default class ColorPalette extends TypedEmitter<ColorPaletteEvents> {

package/@ones-editor/ui-base/src/color-palette/create-palette.d.ts

@@ -1,7 +1,15 @@
+type DefaultPaletteCreator<T> = (count: number, rows: number, fun: ColorButtonCreator, containerClass: T) => HTMLElement;
+type CustomPaletteCreator<T extends 'color' | 'background-color'> = (defaultPaletteCreator: DefaultPaletteCreator<T>) => HTMLElement;
 export interface ColorPaletteOptions {
     color?: boolean;
     backgroundColor?: boolean;
     clearColorButton?: boolean;
+    defaultColor?: number;
+    defaultBgColor?: number;
+    customColorPalette?: CustomPaletteCreator<'color'>;
+    customBgColorPalette?: CustomPaletteCreator<'background-color'>;
 }
+type ColorButtonCreator = (index: number) => HTMLElement;
 export declare function createPalette(options: ColorPaletteOptions): HTMLDivElement;
 export declare function selectPaletteColor(root: HTMLElement, type: 'color' | 'backgroundColor', value: number | null): void;
+export {};

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

@@ -1,4 +1,4 @@
-import type { ColorPaletteOptions } from './color-palette';
+import type { ColorPaletteOptions, PaletteClickHandler } from './color-palette';
 import ColorPalette from './color-palette';
 import ColorPaletteItem from './color-palette-item';
-export { ColorPalette, ColorPaletteOptions, ColorPaletteItem };
+export { ColorPalette, ColorPaletteOptions, ColorPaletteItem, PaletteClickHandler };

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

@@ -1,6 +1,6 @@
 import { TypedEmitter } from 'tiny-typed-emitter';
 import { CloseReason, CommandItem, Closeable } from '../../../../@ones-editor/core';
-import { AbstractManualCommandBar, AbstractCommandBar, CommandBarEvents, CommandBarOptions, CommandItemElement, CreateManualCommandBarFunction, ManualShowCommandBarOptions } from './types';
+import { AbstractManualCommandBar, AbstractCommandBar, CommandBarEvents, CommandBarOptions, CommandItemElement, CreateManualCommandBarFunction, ManualShowCommandBarOptions, SelectItemFrom } from './types';
 import 'tippy.js/dist/tippy.css';
 export default abstract class CommandBar extends TypedEmitter<CommandBarEvents> implements AbstractCommandBar {
     content: HTMLElement;
@@ -30,7 +30,7 @@ export default abstract class CommandBar extends TypedEmitter<CommandBarEvents>
     private getPrevItemIndex;
     private getNextItemIndex;
     protected clearSelectedItem(): void;
-    selectItem(id: string): void;
+    selectItem(id: string, from?: SelectItemFrom): void;
     private lastEnterPauseTime;
     private startPauseMouseEnter;
     private handleItemMouseEnter;

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

@@ -34,6 +34,7 @@ export interface ShowCommandBarOptions {
 }
 export interface AbstractManualCommandBar extends AbstractCommandBar {
     manualShow: (target: HTMLElement, options?: ShowCommandBarOptions) => void;
+    popper: Element | null;
 }
 export interface AbstractHoveringCommandBar extends AbstractCommandBar {
     setTarget: (target: HTMLElement, options: ShowCommandBarOptions) => void;
@@ -66,3 +67,4 @@ export type CreateManualCommandBarFunction = (parentItem: CommandItem, closeable
 export type PopoverOptions = {
     overflowBoundary?: Element;
 };
+export type SelectItemFrom = 'event' | 'manual';

package/@ones-editor/ui-base/src/emoji-item/emoji-item.d.ts

@@ -0,0 +1,19 @@
+import { Closeable, CommandItem, OnesEditor, OnesEditorCustom } from '../../../../@ones-editor/core';
+import { EmojiPalette } from '../emoji-palette';
+export declare class EmojiItem implements CommandItem, OnesEditorCustom {
+    id: string;
+    name: string;
+    element: HTMLButtonElement;
+    dropdown: boolean;
+    children: CommandItem[];
+    palette: EmojiPalette;
+    manualShowChildren: boolean;
+    childrenPlacement: "bottom-start";
+    childrenMenuId: string;
+    closeable: Closeable;
+    constructor();
+    beforePopup(): void;
+    setCloseable(closeable: Closeable): void;
+    destroy(): void;
+    static get(editor: OnesEditor): EmojiItem;
+}

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

@@ -0,0 +1,2 @@
+import './index.scss';
+export { EmojiItem } from './emoji-item';

package/@ones-editor/ui-base/src/emoji-palette/emoji-content.d.ts

@@ -0,0 +1,21 @@
+import { Emojis } from './emoji-data';
+interface EmojiContentOptions {
+    onSelectEmoji: (emoji: string) => void;
+    onCategoryReach: (category: string) => void;
+}
+export declare class EmojiContent {
+    private parent;
+    private options;
+    private root;
+    private observer;
+    constructor(parent: HTMLElement, options: EmojiContentOptions);
+    private handleIntersectionObserver;
+    private handleRootClick;
+    private updateCategoryGroupContent;
+    private createCategoryGroup;
+    updateFrequentlyUsedContent(emojis: Emojis): void;
+    updateContent: (emojis: Emojis) => void;
+    scrollToCategory(categoryId: string): void;
+    destroy(): void;
+}
+export {};

package/@ones-editor/ui-base/src/emoji-palette/emoji-data.d.ts

@@ -0,0 +1,60 @@
+export type Emoji = string;
+export type EmojiCategory = string;
+export type Emojis = EmojiMetaData['emojis'];
+interface EmojiMetaData {
+    emojis: Record<EmojiCategory, Emoji[]>;
+    keywords: Record<Emoji, string[]>;
+}
+type EmojiEntity = {
+    category: EmojiCategory;
+    emoji: Emoji;
+    keyword: string;
+};
+export declare function getCategoryInfo(category: string): {
+    icon: string;
+    label: string;
+} | {
+    icon: string;
+    label: string;
+} | {
+    icon: string;
+    label: string;
+} | {
+    icon: string;
+    label: string;
+} | {
+    icon: string;
+    label: string;
+} | {
+    icon: string;
+    label: string;
+} | {
+    icon: string;
+    label: string;
+} | {
+    icon: string;
+    label: string;
+};
+export declare class EmojiData {
+    static metaData: EmojiMetaData | null;
+    private emojiEntities;
+    private localMetaData;
+    constructor();
+    get recentlyUsedEmojis(): EmojiMetaData['emojis'];
+    get emojis(): {
+        [x: string]: string[];
+    };
+    get categories(): EmojiCategory[];
+    static get loaded(): boolean;
+    saveEmojiToRecentlyUsed(emoji: Emoji): void;
+    filterEmojis(v: string): {
+        emojis: {
+            [x: string]: string[];
+        };
+        categories: string[];
+    };
+    getEmojiEntity(emoji: string): EmojiEntity | null;
+    static loadData(): Promise<EmojiMetaData>;
+}
+export declare function isEmptyEmojiData(emojis: Emojis): boolean;
+export {};

package/@ones-editor/ui-base/src/emoji-palette/emoji-navigation.d.ts

@@ -0,0 +1,16 @@
+import { EmojiCategory } from './emoji-data';
+interface EmojiNavigationOptions {
+    onSelectCategory: (category: string) => void;
+}
+export declare class EmojiNavigation {
+    private parent;
+    private options;
+    private root;
+    constructor(parent: HTMLElement, options: EmojiNavigationOptions);
+    private handleRootClick;
+    private createCategoryItem;
+    updateFrequentlyUsedItem(): void;
+    updateContent(categories: EmojiCategory[]): void;
+    updateActiveCategory(category: string): void;
+}
+export {};

package/@ones-editor/ui-base/src/emoji-palette/emoji-search.d.ts

@@ -0,0 +1,11 @@
+import { createInput } from '../input/create-input';
+interface EmojiSearchOptions {
+    onSearch: (value: string) => void;
+}
+export declare class EmojiSearch {
+    private parent;
+    private options;
+    input: ReturnType<typeof createInput>;
+    constructor(parent: HTMLElement, options: EmojiSearchOptions);
+}
+export {};

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

@@ -0,0 +1,23 @@
+import { CommandItem } from '../../../../@ones-editor/core';
+import { TypedEmitter } from 'tiny-typed-emitter';
+import './index.scss';
+export interface EmojiPaletteEvents {
+    onSelectEmoji: (emoji: string) => void;
+}
+export declare class EmojiPalette extends TypedEmitter<EmojiPaletteEvents> implements CommandItem {
+    id: string;
+    name: string;
+    element: HTMLDivElement;
+    private emojiData;
+    private emojiSearch;
+    private emojiContent;
+    private emojiNavigation;
+    constructor();
+    private initEmojiData;
+    private handleSearch;
+    private handleEmojiSelect;
+    private handleSelectCategory;
+    private handleCategoryReach;
+    updateComponents(): void;
+    destroy(): void;
+}