@ones-editor/editor 2.3.4 → 2.4.1

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

@@ -0,0 +1,21 @@
+import { OnesEditor, OnesEditorCustom } from '../../../../@ones-editor/core';
+import { EmojiPalette } from '../../../../@ones-editor/ui-base';
+export interface EmojiPopupCallbacks {
+    onSelectEmoji: (emoji: string, closePopup: VoidFunction) => void;
+    onClose: VoidFunction;
+}
+export declare class EmojiPopup implements OnesEditorCustom {
+    private editor;
+    private popup;
+    private popupContent;
+    emojiPalette: EmojiPalette;
+    private latestPopupCallbacks;
+    constructor(editor: OnesEditor);
+    private closePopup;
+    private handleEmojiSelect;
+    private handlePopupClose;
+    private populateEmojiPopupContent;
+    setCallbacks(callbacks: EmojiPopupCallbacks): void;
+    show(rect: DOMRect): void;
+    destroy(): void;
+}

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

@@ -0,0 +1,8 @@
+import { OnesEditor } from '../../../../@ones-editor/core';
+import { EmojiPopupCallbacks } from './emoji-popup';
+export interface ShowEmojiPopupOptions extends EmojiPopupCallbacks {
+    currentEmoji?: string;
+    anchor: HTMLElement;
+}
+declare function showEmojiPopup(editor: OnesEditor, options: ShowEmojiPopupOptions): void;
+export { showEmojiPopup, };

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

@@ -36,6 +36,7 @@ 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 { showEmojiPopup } from './emoji-popup';
 export * from './providers/utils/clipboard';
 export * from './providers/utils';
 export * from './box-helper/standard-box-commands';

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

@@ -13,6 +13,7 @@ declare const _default: {
         inlineBox: {
             math: string;
             link: string;
+            emoji: string;
         };
     };
     link: {

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

@@ -13,6 +13,7 @@ declare const _default: {
         inlineBox: {
             math: string;
             link: string;
+            emoji: string;
         };
     };
     link: {

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

@@ -13,6 +13,7 @@ declare const _default: {
         inlineBox: {
             math: string;
             link: string;
+            emoji: string;
         };
     };
     link: {

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

@@ -0,0 +1,12 @@
+import { BlockElement, CommandItem, CommandParams, OnesEditor, OnesEditorCommandProvider, SelectionRange } from '../../../../@ones-editor/core';
+export declare class EmojiProvider 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/insert-menu.d.ts

@@ -9,8 +9,8 @@ export default class InsertMenuProvider extends ProxyProvider {
     providers: OnesEditorCommandProvider[];
     quickProviders: QuickMenuCommandProvider[];
     constructor(editor: OnesEditor, options?: CommandParams | undefined);
-    getInsertCommands: (editor: OnesEditor, containerId: string) => CommandItem[];
-    getAvailableCommands: (editor: OnesEditor, block: BlockElement, range: SelectionRange) => CommandItem[];
+    getInsertCommands: (editor: OnesEditor, containerId: string, params?: CommandParams) => CommandItem[];
+    getAvailableCommands: (editor: OnesEditor, block: BlockElement, range: SelectionRange, params?: CommandParams) => 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/utils/add-section.d.ts

@@ -1,2 +1,11 @@
 import { CommandItem } from '../../../../../@ones-editor/core';
+declare const GroupOrder: {
+    basics: number;
+    system: number;
+    common: number;
+    thirdParty: number;
+};
+type GroupType = keyof typeof GroupOrder;
 export declare const addSection: (items: CommandItem[]) => CommandItem[];
+export declare const createSectionByGroup: (item: CommandItem, before: GroupType) => CommandItem;
+export {};

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

@@ -1,2 +1,4 @@
 import { OnesEditor } from '../../../../../@ones-editor/core';
+import { createSectionByGroup } from './add-section';
 export declare const isSelectedTitleBlock: (editor: OnesEditor) => boolean;
+export { createSectionByGroup };

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

@@ -1,4 +1,4 @@
-import { OnesEditor, CommandItem, CommandFilterId, CommandFilter } from '../../../../@ones-editor/core';
+import { OnesEditor, CommandItem, CommandItemWithSource, CommandFilterId, CommandFilter } from '../../../../@ones-editor/core';
 import { OnesEditorAutoSuggest } from '../../../../@ones-editor/ui-base';
 import { QuickMenuOptions } from './types';
 export default class OnesEditorQuickMenu {
@@ -12,6 +12,7 @@ export default class OnesEditorQuickMenu {
     get menu(): import("@ones-editor/ui-base").ManualMenu | import("@ones-editor/ui-base/src/mobile-command-bar/mobile-bottom-menu").MobileBottomMenu;
     addFilter(id: CommandFilterId, filter: CommandFilter): void;
     destroy(): void;
+    filterItems: (items: CommandItemWithSource[], search: string) => CommandItemWithSource[];
     queryItems: (suggest: unknown, text: string) => Promise<CommandItem[]>;
     onClose: () => void;
     onShow: (suggest: OnesEditorAutoSuggest, containerId: string, blockIndex: number, offset: number) => boolean;

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

@@ -1,8 +1,8 @@
-import { AbstractProvider, CommandItemWithSource, OnesEditor, OnesEditorCommandProviders, SelectionRange } from '../../../../@ones-editor/core';
+import { AbstractProvider, CommandItemWithSource, CommandParams, OnesEditor, OnesEditorCommandProviders, SelectionRange } from '../../../../@ones-editor/core';
 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) => {};
+    getCommands(range: SelectionRange, params?: CommandParams): CommandItemWithSource[];
+    executeCommand: (range: SelectionRange, item: CommandItemWithSource, params: CommandParams) => {};
 }

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

@@ -1,11 +1,11 @@
-import { CommandItem, BlockOptions, OnesEditor, BlockElement, SelectionRange } from '../../../../@ones-editor/core';
+import { CommandItem, BlockOptions, OnesEditor, BlockElement, SelectionRange, CommandParams } from '../../../../@ones-editor/core';
 export interface QuickMenuItem extends CommandItem {
     itemType: 'insert-block';
     blockType?: string;
     blockOptions?: BlockOptions;
     commandProvider?: QuickMenuCommandProvider;
 }
-export interface QuickMenuCommandParams {
+export interface QuickMenuCommandParams extends CommandParams {
     from: 'block-menu' | 'quick-menu' | 'add-block-menu';
 }
 export interface QuickMenuCommandInline extends QuickMenuCommandParams {

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

@@ -14,6 +14,7 @@ export default class OnesEditorToolbar implements OnesEditorHoveringBlockFilter,
     private hoveringTextChild;
     private _disableTextToolbar;
     private _lastClickTime;
+    private _disabled;
     constructor(editor: OnesEditor);
     disableTextToolbar(): void;
     enableTextToolbar(): void;
@@ -33,6 +34,7 @@ export default class OnesEditorToolbar implements OnesEditorHoveringBlockFilter,
     handleSelectionChange: import("lodash").DebouncedFunc<(editor: OnesEditor) => void>;
     updateItems(updater: (items: CommandItem[]) => CommandItem[]): void;
     updateItemStates(id: CommandItem['id'], states: Required<CommandItem>['states']): void;
+    disable(value: boolean): void;
     update(reason: ShowToolbarReason): void;
     private showTextToolbar;
     private showObjectToolbar;

package/@ones-editor/ui-base/src/auto-suggest/auto-suggest-menu.d.ts

@@ -17,6 +17,7 @@ export interface AutoSuggestMenuOptions {
     onClose?: () => void;
     onShow?: (menu: AutoSuggestMenu) => boolean | undefined;
     onShown?: (menu: AutoSuggestMenu) => void;
+    onSubBarShown?: (menu: AutoSuggestMenu) => void;
     onClickItem: (menu: AutoSuggestMenu, item: CommandItem) => void;
     queryItems: (menu: AutoSuggestMenu, text: string) => Promise<CommandItem[]>;
     renderMenuItem?: (menu: AutoSuggestMenu, item: CommandItem) => HTMLElement | undefined;
@@ -26,6 +27,7 @@ export default class AutoSuggestMenu {
     menu: ManualMenu | MobileBottomMenu;
     private currentText;
     handleSearchText: (text: string) => void;
+    get searchText(): string;
     constructor(options: AutoSuggestMenuOptions);
     private setItems;
     popup(anchor: HTMLElement, options?: {
@@ -45,4 +47,5 @@ export default class AutoSuggestMenu {
     handleClose: () => void;
     handleKeydown: (event: KeyboardEvent) => boolean;
     protected highlightText(search: string, items?: CommandItem[]): void;
+    handleSubBarShown: () => void;
 }

package/@ones-editor/ui-base/src/auto-suggest/auto-suggest.d.ts

@@ -27,6 +27,7 @@ export interface AutoSuggestOptions {
     queryItems: (menu: OnesEditorAutoSuggest, text: string) => Promise<CommandItem[]>;
     renderMenuItem?: (menu: OnesEditorAutoSuggest, item: CommandItem) => HTMLElement | undefined;
     onShown?: (menu: OnesEditorAutoSuggest) => void;
+    onSubBarShown?: (menu: OnesEditorAutoSuggest) => void;
 }
 declare class OnesEditorAutoSuggest implements OnesEditorInputHandler {
     private editor;
@@ -48,6 +49,7 @@ declare class OnesEditorAutoSuggest implements OnesEditorInputHandler {
     private onClose;
     private onShow;
     private onShown;
+    private onSubBarShown;
     private onClickItem;
     private queryItems;
     private renderMenuItem;

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

@@ -1,2 +1,3 @@
 export declare function createColorButton(): HTMLButtonElement;
 export declare function setColorButtonColor(button: HTMLElement, colors: [number | null, number | null]): void;
+export declare function getButtonColor(button: HTMLElement): (number | null)[];

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

@@ -39,12 +39,13 @@ export default abstract class CommandBar extends TypedEmitter<CommandBarEvents>
     private handleItemMouseLeave;
     protected handleItemClick: (event: MouseEvent | TouchEvent) => void;
     private showSubCommandBar;
+    getSubBarCreateOptions(item: CommandItem): CommandBarOptions;
     isInCommandBar(target: EventTarget | null): boolean;
     createCommandItem(item: CommandItem): CommandItemElement;
     getItemById(id: string): CommandItem;
     getSelectedItem(): CommandItem | null;
     protected getItemElementId(elem: CommandItemElement): string;
-    protected getItemElementById(id: string): CommandItemElement;
+    getItemElementById(id: string): CommandItemElement;
     protected getParentCommandItemElement(target: EventTarget | null): CommandItemElement | null;
     protected createCommandBarContent(items: CommandItem[]): HTMLElement;
     handleWheel: (e: WheelEvent) => void;

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

@@ -7,6 +7,7 @@ export default class FixedToolbar extends CommandBar {
     protected initCommandBarElement(elem: HTMLElement): void;
     protected initItemElement(item: CommandItem, elem: CommandItemElement): void;
     close(): void;
+    getSubBarCreateOptions: (item: CommandItem) => CommandBarOptions;
     getSubBarOptions: (item: CommandItem) => ManualShowCommandBarOptions;
     destroy(): void;
     protected getCommandBarRoot(): HTMLElement | null;

package/@ones-editor/ui-base/src/dialog/alert-dialog.d.ts

@@ -0,0 +1,19 @@
+import StandardDialog from './standard-dialog';
+import { ButtonType } from './types';
+import './alert-dialog.scss';
+export interface AlertDialogOptions {
+    id?: string;
+    title?: string;
+    content: string | HTMLElement;
+    icon?: string;
+    buttons?: ButtonType[] | HTMLElement[];
+    okButtonTitle?: string;
+    onOk?: (dialog: AlertDialog) => Promise<void> | void;
+    onClose?: () => void;
+    type?: 'warning' | 'info' | 'danger';
+}
+export default class AlertDialog extends StandardDialog {
+    private alertOptions;
+    constructor(alertOptions: AlertDialogOptions);
+    static showAlert(options: AlertDialogOptions): AlertDialog | null;
+}

package/@ones-editor/ui-base/src/dialog/confirm-dialog.d.ts

@@ -0,0 +1,20 @@
+import StandardDialog from './standard-dialog';
+import './confirm-dialog.scss';
+import { ButtonType } from './types';
+export interface ConfirmDialogOptions {
+    id?: string;
+    buttons?: ButtonType[] | HTMLElement[];
+    title?: string;
+    content: string | HTMLElement;
+    icon?: string;
+    hideClose?: boolean;
+    bodyClasses?: string[];
+    okButtonTitle?: string;
+    onClickButton?: (dialog: StandardDialog, button: HTMLElement) => Promise<boolean> | undefined;
+    onOk?: (dialog: ConfirmDialog) => Promise<boolean>;
+    onCancel?: (dialog: ConfirmDialog) => Promise<boolean>;
+}
+export default class ConfirmDialog extends StandardDialog {
+    private askOptions;
+    constructor(askOptions: ConfirmDialogOptions);
+}

package/@ones-editor/ui-base/src/dialog/dialog-button.d.ts

@@ -0,0 +1,10 @@
+import './dialog-buttons.scss';
+export interface StandardButtonOptions {
+    icon?: string;
+    title?: string;
+    id?: string;
+    primary?: boolean;
+    noBackground?: boolean;
+    noBorder?: boolean;
+}
+export declare function createStandardButton(parent: HTMLElement, options: StandardButtonOptions): HTMLButtonElement;

package/@ones-editor/ui-base/src/dialog/dialog-check.d.ts

@@ -0,0 +1,15 @@
+import './dialog-check.scss';
+export interface StandardCheckOptions {
+    label: string;
+    classes?: string[];
+    id?: string;
+    name?: string;
+    labelId?: string;
+    extra?: string;
+}
+export declare function createStandardCheck(parent: HTMLElement, options: StandardCheckOptions): {
+    root: HTMLLabelElement;
+    check: HTMLInputElement;
+    label: HTMLSpanElement;
+};
+export declare function updateStandardCheckExtra(check: HTMLInputElement, extra: string): void;

package/@ones-editor/ui-base/src/dialog/dialog-input.d.ts

@@ -0,0 +1,9 @@
+export declare function setInputError(input: HTMLInputElement, message: string): void;
+export declare function clearInputError(input: HTMLInputElement): void;
+export interface StandardInputOptions {
+    classes?: string[];
+    inputClasses?: string[];
+    placeholder?: string;
+}
+export declare function createStandardInput(parent: HTMLElement, options?: StandardInputOptions): HTMLInputElement;
+export declare function updateInputPlaceholder(input: HTMLInputElement, placeholder: string): void;

package/@ones-editor/ui-base/src/dialog/dialog-radio.d.ts

@@ -0,0 +1,12 @@
+import './dialog-radio.scss';
+export interface StandardRadioOptions {
+    label: string;
+    classes?: string[];
+    id: string;
+    name: string;
+}
+export declare function createStandardRadio(parent: HTMLElement, options: StandardRadioOptions): {
+    root: HTMLLabelElement;
+    radio: HTMLInputElement;
+    label: HTMLSpanElement;
+};

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

@@ -1,4 +1,19 @@
 import ManualCloseDialog from './manual-close-dialog';
 import type { ManualCloseDialogOptions } from './manual-close-dialog';
+import AlertDialog from './alert-dialog';
+import type { AlertDialogOptions } from './alert-dialog';
+import ConfirmDialog from './confirm-dialog';
+import type { ConfirmDialogOptions } from './confirm-dialog';
+import StandardDialog from './standard-dialog';
+import type { StandardDialogOptions } from './standard-dialog';
+import StandardModalDialog from './standard-modal-dialog';
+import type { StandardModalDialogOptions } from './standard-modal-dialog';
+import StandardPopupDialog from './standard-popup-dialog';
+import type { StandardPopupDialogOptions } from './standard-popup-dialog';
 export * from './types';
 export { ManualCloseDialog, ManualCloseDialogOptions };
+export { AlertDialog, AlertDialogOptions };
+export { ConfirmDialog, ConfirmDialogOptions };
+export { StandardDialog, StandardDialogOptions };
+export { StandardModalDialog, StandardModalDialogOptions };
+export { StandardPopupDialog, StandardPopupDialogOptions };

package/@ones-editor/ui-base/src/dialog/modal-dialog.d.ts

@@ -0,0 +1,21 @@
+import './modal-dialog.scss';
+import './dialog-buttons.scss';
+import './dialog-input.scss';
+export type ManualCloseDialogOptions = {
+    id?: string;
+    bodyClasses?: string[];
+    dialogClasses?: string[];
+    disableBackdropClose?: boolean;
+    onClose?: (dialog: ModalDialog) => void;
+};
+export default class ModalDialog {
+    protected content: HTMLElement;
+    protected options?: ManualCloseDialogOptions | undefined;
+    protected root: HTMLElement | null;
+    protected static zIndex: number;
+    constructor(content: HTMLElement, options?: ManualCloseDialogOptions | undefined);
+    show(): void;
+    close(): void;
+    destroy(): void;
+    protected handleWindowMouseDown: (event: MouseEvent) => void;
+}

package/@ones-editor/ui-base/src/dialog/popup-dialog.d.ts

@@ -0,0 +1,31 @@
+import './popup-dialog.scss';
+import { GetReferenceClientRect } from 'tippy.js';
+import { Placement } from '../command-bar/types';
+export interface PopupDialogOptions {
+    id?: string;
+    content: HTMLElement;
+    target?: HTMLElement;
+    placement?: Placement;
+    point?: {
+        x: number;
+        y: number;
+    };
+    theme?: string;
+    getReferenceClientRect?: GetReferenceClientRect | null | undefined;
+    offset?: [number, number];
+    arrow?: boolean;
+    disablePageScroll?: boolean;
+    onClose?: (dialog: PopupDialog) => void;
+    onShow?: (dialog: PopupDialog) => void;
+}
+export default class PopupDialog {
+    private options;
+    private popup;
+    constructor(options: PopupDialogOptions);
+    destroy(): void;
+    show(target?: HTMLElement): void;
+    close(): void;
+    handlePopupClose: () => void;
+    handlePopupShow: () => void;
+    popupContent(): HTMLElement;
+}

package/@ones-editor/ui-base/src/dialog/standard-dialog.d.ts

@@ -0,0 +1,25 @@
+import ModalDialog from './modal-dialog';
+import { ButtonType } from './types';
+import './standard-dialog.scss';
+export interface StandardDialogOptions {
+    id?: string;
+    buttons: ButtonType[] | HTMLElement[];
+    title?: string;
+    content: string | HTMLElement;
+    icon?: string;
+    hideClose?: boolean;
+    bodyClasses?: string[];
+    okButtonTitle?: string;
+    dialogClasses?: string[];
+    onClose?: (dialog: ModalDialog) => void;
+    onClickButton?: (dialog: StandardDialog, button: HTMLElement) => Promise<boolean> | undefined;
+    onClickClose?: (dialog: StandardDialog) => Promise<boolean>;
+}
+export default class StandardDialog extends ModalDialog {
+    protected dialogOptions: StandardDialogOptions;
+    constructor(dialogOptions: StandardDialogOptions);
+    destroy(): void;
+    private handleContentClick;
+    show(): void;
+    static createDialogContent(options: StandardDialogOptions): HTMLElement;
+}

package/@ones-editor/ui-base/src/dialog/standard-modal-dialog.d.ts

@@ -0,0 +1,7 @@
+import StandardDialog, { StandardDialogOptions } from './standard-dialog';
+import './standard-modal-dialog.scss';
+export type StandardModalDialogOptions = StandardDialogOptions;
+export default class StandardModalDialog extends StandardDialog {
+    constructor(dialogOptions: StandardModalDialogOptions);
+    destroy(): void;
+}

package/@ones-editor/ui-base/src/dialog/standard-popup-dialog.d.ts

@@ -0,0 +1,17 @@
+import { ButtonType } from './types';
+import PopupDialog, { PopupDialogOptions } from './popup-dialog';
+import './standard-popup-dialog.scss';
+export interface StandardPopupDialogOptions extends PopupDialogOptions {
+    buttons: ButtonType[] | HTMLElement[];
+    bodyClasses?: string[];
+    onClickButton?: (dialog: StandardPopupDialog, button: HTMLElement) => Promise<boolean> | undefined;
+}
+export default class StandardPopupDialog extends PopupDialog {
+    protected dialogOptions: StandardPopupDialogOptions;
+    private dialogContent;
+    constructor(dialogOptions: StandardPopupDialogOptions);
+    destroy(): void;
+    private handleContentClick;
+    show(): void;
+    static createDialogContent(options: StandardPopupDialogOptions): HTMLElement;
+}

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

@@ -2,3 +2,4 @@ export interface FindDialogOptions {
     popoverTarget?: HTMLElement;
     getReferenceClientRect?: (popoverTarget: HTMLElement, dialog: HTMLElement) => DOMRect;
 }
+export type ButtonType = 'ok' | 'cancel' | 'yes' | 'no' | 'close';

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

@@ -28,6 +28,7 @@ export declare class Dropdown {
     close(): void;
     destroy(): void;
     updateItems(items: CommandItem[]): void;
+    getItems(): CommandItem[];
     setText(text: string): void;
     clear(): void;
     setLabels(labels: string[]): void;

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

@@ -11,9 +11,8 @@ export declare class EmojiItem implements CommandItem, OnesEditorCustom {
     childrenPlacement: "bottom-start";
     childrenMenuId: string;
     closeable: Closeable;
-    constructor();
+    constructor(editor: OnesEditor);
     beforePopup(): void;
     setCloseable(closeable: Closeable): void;
     destroy(): void;
-    static get(editor: OnesEditor): EmojiItem;
 }

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

@@ -0,0 +1,3 @@
+import './index.scss';
+import { EmojiPaletteOptions } from './types';
+export declare function defaultPaletteRenderer(parent: HTMLDivElement, options: EmojiPaletteOptions): () => void;

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

@@ -1,23 +1,20 @@
-import { CommandItem } from '../../../../@ones-editor/core';
+import { CommandItem, OnesEditor } from '../../../../@ones-editor/core';
 import { TypedEmitter } from 'tiny-typed-emitter';
 import './index.scss';
-export interface EmojiPaletteEvents {
+export type { OnesEditorEmojiPaletteOptions, EmojiSelectedHandler } from './types';
+interface EmojiPaletteEvents {
     onSelectEmoji: (emoji: string) => void;
 }
 export declare class EmojiPalette extends TypedEmitter<EmojiPaletteEvents> implements CommandItem {
+    private editor;
     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;
+    private currentEmoji;
+    private unmountPalette;
+    constructor(editor: OnesEditor);
+    private renderPalette;
+    render(): Promise<void>;
+    setCurrentEmoji(emoji: string): void;
     destroy(): void;
 }

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

@@ -0,0 +1,10 @@
+export type EmojiSelectedHandler = (emoji: string) => void;
+export type EmojiPaletteOptions = {
+    emoji: string;
+    onSelectEmoji: EmojiSelectedHandler;
+};
+export type UnmountPalette = () => void;
+export type EmojiPaletteRenderer = (parent: HTMLDivElement, options: EmojiPaletteOptions) => UnmountPalette;
+export type OnesEditorEmojiPaletteOptions = {
+    emojiPaletteRenderer: EmojiPaletteRenderer;
+};

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

@@ -18,4 +18,6 @@ export * from './emoji-item';
 export * from './mobile-command-bar/mobile-bottom-menu';
 export * from './text-button';
 export { scrollBarIntoView } from './mobile-command-bar/scroll-into-view';
+export { EmojiPalette } from './emoji-palette';
+export type { OnesEditorEmojiPaletteOptions, EmojiSelectedHandler } from './emoji-palette';
 export { tippy, };

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

@@ -1,4 +1,9 @@
 declare const _default: {
+    button: {
+        ok: string;
+        cancel: string;
+        confirm: string;
+    };
     colorPalette: {
         colorDesc: string;
         name: string;

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

@@ -1,4 +1,9 @@
 declare const _default: {
+    button: {
+        ok: string;
+        cancel: string;
+        confirm: string;
+    };
     colorPalette: {
         colorDesc: string;
         name: string;

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

@@ -1,4 +1,9 @@
 declare const _default: {
+    button: {
+        ok: string;
+        cancel: string;
+        confirm: string;
+    };
     colorPalette: {
         colorDesc: string;
         name: string;

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

@@ -6,6 +6,7 @@ export interface VersionDialogOptions {
     useCreatedBy?: boolean;
     enableEdit?: boolean;
     textRenders?: OnesEditorBlockRenderer[];
+    autoCompareWithLastVersion?: boolean;
     getDisabledTip?: () => string | undefined;
     onMemoChanged?: (version: DocVersion) => void;
     onBeforeEditMemo?: () => Promise<boolean>;

package/@ones-editor/versions/src/version-dialog/versions-dropdown.d.ts

@@ -18,8 +18,10 @@ export default class VersionsDropdown {
     createFilterMemoedFilterItem: (hasLastVersion: boolean) => HTMLDivElement;
     setVersions(versions: DocVersion[]): void;
     setCurrentVersion(ver: DocVersion, compareWithVersion?: DocVersion): void;
+    setCompareWithVersion(compareWithVersion: DocVersion | null): void;
     resetItems(): void;
     filterItems: (item: CommandItem, keywords: string) => boolean;
+    getLastVersion(): DocVersion | null;
     handleClose: () => void;
     handleClear: () => void;
     handleClickItem: (item: CommandItem) => void;

package/dist/custom/image-preview-handler.d.ts

@@ -0,0 +1,11 @@
+import { OnesEditor, OnesEditorCustom } from '../../@ones-editor/core';
+export declare class ImagePreviewHandler implements OnesEditorCustom {
+    private editor;
+    private onPreview;
+    private lastClickPosition;
+    constructor(editor: OnesEditor, onPreview: (editor: OnesEditor, img: HTMLImageElement) => void);
+    handleImagePreview: (e: MouseEvent) => void;
+    handleMouseUp: (e: MouseEvent) => void;
+    handleMouseDown: (e: MouseEvent) => void;
+    destroy: () => void;
+}