@ones-editor/editor 0.0.1

package/@ones-editor/ui/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "@ones-editor/ui",
+  "version": "1.0.0",
+  "main": "./src/index.ts",
+  "private": true,
+  "type": "module",
+  "types": "src/index.d.ts"
+}

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

@@ -0,0 +1,15 @@
+import SplitCellIcon from './split-cell.svg?raw';
+import MergeCellsIcon from './merge-cells.svg?raw';
+import headingH1Icon from './heading-h1.svg?raw';
+import headingH2Icon from './heading-h2.svg?raw';
+import headingH3Icon from './heading-h3.svg?raw';
+import headingH4Icon from './heading-h4.svg?raw';
+import headingH5Icon from './heading-h5.svg?raw';
+import headingH6Icon from './heading-h6.svg?raw';
+import headingH7Icon from './heading-h7.svg?raw';
+import headingH8Icon from './heading-h8.svg?raw';
+import unorderedIcon from './unordered-list.svg?raw';
+import orderedIcon from './ordered-list.svg?raw';
+import checkboxIcon from './checkbox.svg?raw';
+import quoteIcon from './quote.svg?raw';
+export { SplitCellIcon, MergeCellsIcon, headingH1Icon, headingH2Icon, headingH3Icon, headingH4Icon, headingH5Icon, headingH6Icon, headingH7Icon, headingH8Icon, unorderedIcon, orderedIcon, checkboxIcon, quoteIcon, };

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

@@ -0,0 +1,10 @@
+import './style.scss';
+import OnesEditorToolbar from './toolbar/toolbar-handler';
+import OnesEditorQuickMenu, { getAllQuickMenuItems } from './quick-menu';
+import OnesEditorTooltip from './tooltips';
+import TextStyleShortcuts from './shortcuts';
+import { editLink } from './link-popup';
+import './locale';
+import type { QuickMenuItem } from './quick-menu';
+export { OnesEditorToolbar, OnesEditorQuickMenu, OnesEditorTooltip, getAllQuickMenuItems, QuickMenuItem, editLink, TextStyleShortcuts };
+export { createTextButton } from './text-button';

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

@@ -0,0 +1,15 @@
+import { OnesEditor } from '../../../../@ones-editor/core';
+import { Placement } from '../../../../@ones-editor/ui-base';
+import './index.scss';
+type OnFinished = (linkText: string, linkUrl: string) => void;
+type OnClose = () => void;
+interface LinkEditorOptions {
+    target: HTMLElement;
+    linkText: string;
+    linkUrl: string;
+    onFinished: OnFinished;
+    onClose?: OnClose;
+    placement?: Placement;
+}
+export declare function editLink(editor: OnesEditor, optoins: LinkEditorOptions): void;
+export {};

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

@@ -0,0 +1,51 @@
+declare const _default: {
+    quickMenu: {
+        basic: {
+            heading: {
+                title: string;
+                space: string;
+            };
+            unordered: string;
+            ordered: string;
+            checkbox: string;
+            quote: string;
+        };
+        inlineBox: {
+            math: string;
+            link: string;
+        };
+        link: {
+            textLabel: string;
+            urlLabel: string;
+            textPlaceholder: string;
+            urlPlaceholder: string;
+            submitText: string;
+            cancelText: string;
+        };
+    };
+    commands: {
+        unordered: string;
+        ordered: string;
+        check: string;
+        link: string;
+        quote: string;
+        alignLeft: string;
+        alignRight: string;
+        alignCenter: string;
+        heading: string;
+        text: string;
+    };
+    commandDesc: {
+        mac: {
+            unordered: string;
+            ordered: string;
+            link: string;
+        };
+        window: {
+            unordered: string;
+            ordered: string;
+            link: string;
+        };
+    };
+};
+export default _default;

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,51 @@
+declare const _default: {
+    quickMenu: {
+        basic: {
+            heading: {
+                title: string;
+                space: string;
+            };
+            unordered: string;
+            ordered: string;
+            checkbox: string;
+            quote: string;
+        };
+        inlineBox: {
+            math: string;
+            link: string;
+        };
+    };
+    link: {
+        textLabel: string;
+        urlLabel: string;
+        textPlaceholder: string;
+        urlPlaceholder: string;
+        submitText: string;
+        cancelText: string;
+    };
+    commands: {
+        unordered: string;
+        ordered: string;
+        check: string;
+        link: string;
+        quote: string;
+        alignLeft: string;
+        alignRight: string;
+        alignCenter: string;
+        heading: string;
+        text: string;
+    };
+    commandDesc: {
+        mac: {
+            unordered: string;
+            ordered: string;
+            link: string;
+        };
+        window: {
+            unordered: string;
+            ordered: string;
+            link: string;
+        };
+    };
+};
+export default _default;

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

@@ -0,0 +1,15 @@
+import type { BlockOptions, CommandItem, OnesEditor, InsertEmptyBlockOptions } from '../../../../@ones-editor/core';
+export declare function addQuickMenuItemFields(item: CommandItem, options: BlockOptions): void;
+declare function handleInsertEmptyBlock(editor: OnesEditor, options: InsertEmptyBlockOptions): Promise<null>;
+export declare function getHeadingMenuOptions(start?: number): BlockOptions;
+export declare function getCompleteHeadingMenuOptions(): {
+    name: string;
+    insertBlockCommandItems: CommandItem[];
+    handleInsertEmptyBlock: typeof handleInsertEmptyBlock;
+};
+export declare function getBasicMenuItems(): {
+    name: string;
+    insertBlockCommandItems: CommandItem[];
+    handleInsertEmptyBlock: typeof handleInsertEmptyBlock;
+};
+export {};

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

@@ -0,0 +1,25 @@
+import { OnesEditor, CommandItem } from '../../../../@ones-editor/core';
+import { OnesEditorAutoSuggest } from '../../../../@ones-editor/ui-base';
+import { QuickMenuItem } from './types';
+export * from './types';
+export * from './quick-menu-items';
+export interface QuickMenuOptions {
+    id?: string;
+    trigger: string[];
+}
+export default class OnesEditorQuickMenu {
+    protected editor: OnesEditor;
+    private options;
+    protected suggest: OnesEditorAutoSuggest;
+    private items;
+    private maxHeading;
+    constructor(editor: OnesEditor, options?: QuickMenuOptions);
+    get menu(): import("@ones-editor/ui-base").ManualMenu;
+    destroy(): void;
+    queryItems: (suggest: unknown, text: string) => Promise<QuickMenuItem[]>;
+    onShow: (suggest: OnesEditorAutoSuggest, containerId: string, blockIndex: number, offset: number) => boolean;
+    onClickItem: (suggest: unknown, item: CommandItem) => void;
+    private renderMenuItem;
+    private initMenuItems;
+    private refreshMenuItems;
+}

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

@@ -0,0 +1,14 @@
+import { InsertEmptyBlockOptions, OnesEditor, BlockElement } from '../../../../@ones-editor/core';
+declare function handleInsertEmptyBlock(editor: OnesEditor, options: InsertEmptyBlockOptions): Promise<BlockElement | null>;
+export declare function getInlineBoxItems(): {
+    name: string;
+    insertBlockCommandItems: {
+        id: string;
+        name: string;
+        icon: string;
+        order: number;
+        group: string;
+    }[];
+    handleInsertEmptyBlock: typeof handleInsertEmptyBlock;
+};
+export {};

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

@@ -0,0 +1,2 @@
+import { OnesEditor, BlockOptions, CommandItem } from '../../../../@ones-editor/core';
+export declare function insertEmptyBlock(editor: OnesEditor, options: BlockOptions, item: CommandItem): void;

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

@@ -0,0 +1,3 @@
+import type { CommandItem } from '../../../../@ones-editor/core';
+export declare function getItemShortcut(item: CommandItem): string;
+export declare function getItemMarkdown(item: CommandItem): string;

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,3 @@
+import { OnesEditor } from '../../../../@ones-editor/core';
+import { QuickMenuItem } from './types';
+export declare function getAllQuickMenuItems(editor: OnesEditor): QuickMenuItem[];

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

@@ -0,0 +1,5 @@
+import { CommandItem, BlockOptions } from '../../../../@ones-editor/core';
+export interface QuickMenuItem extends CommandItem {
+    itemType: 'insert-block';
+    blockOptions?: BlockOptions;
+}

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

@@ -0,0 +1,2 @@
+import TextStyleShortcuts from './text-style-shortcuts';
+export default TextStyleShortcuts;

package/@ones-editor/ui/src/shortcuts/text-style-shortcuts.d.ts

@@ -0,0 +1,3 @@
+import { ShortcutRecords } from '../../../../@ones-editor/core';
+declare const TextStyleShortcuts: ShortcutRecords;
+export default TextStyleShortcuts;

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

@@ -0,0 +1,3 @@
+import type { ButtonOptions } from '../../../../@ones-editor/ui-base';
+import './index.scss';
+export declare function createTextButton(parent: HTMLElement, ...args: ButtonOptions): HTMLButtonElement;

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

@@ -0,0 +1,10 @@
+import { BlockCommandItem, BlockCommandItemWithSource, 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, range: SelectionRange): BlockCommandItem[];
+    executeRangeCommand(editor: OnesEditor, range: SelectionRange, command: BlockCommandItemWithSource): boolean;
+}

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

@@ -0,0 +1,10 @@
+import { BlockCommandItem, BlockCommandItemWithSource, BlockElement, DocBlock, OnesEditor, OnesEditorCommandProvider, SelectedBlock, 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, selectBlock: SelectedBlock): void;
+    executeRangeCommand(editor: OnesEditor, range: SelectionRange, command: BlockCommandItemWithSource): boolean;
+}

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

@@ -0,0 +1,10 @@
+import { BlockCommandItem, BlockCommandItemWithSource, BlockElement, CommandParams, CommandResult, 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;
+    executeRangeCommand(editor: OnesEditor, range: SelectionRange, command: BlockCommandItemWithSource, params: CommandParams, result: CommandResult): boolean;
+}

package/@ones-editor/ui/src/toolbar/get-reference-client-rect.d.ts

@@ -0,0 +1,2 @@
+import { OnesEditor, SelectedBlock } from '../../../../@ones-editor/core';
+export declare function getReferenceClientRect(editor: OnesEditor, selectedBlocks: SelectedBlock[]): DOMRect | undefined;

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

@@ -0,0 +1,3 @@
+import { OnesEditor } from '../../../../@ones-editor/core';
+import { OnesEditorToolbarBase } from './types';
+export declare function getToolbar(editor: OnesEditor): OnesEditorToolbarBase;

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/object-commands.d.ts

@@ -0,0 +1,3 @@
+import { BlockElement, CommandItem, OnesEditor, TextBlockContentChild } from '../../../../@ones-editor/core';
+export declare function getObjectCommands(editor: OnesEditor, block: BlockElement, child: TextBlockContentChild | null): CommandItem[];
+export declare function executeObjectCommand(editor: OnesEditor, block: BlockElement, child: TextBlockContentChild | null, item: CommandItem): void;

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

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

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

@@ -0,0 +1,33 @@
+/// <reference types="lodash" />
+import { BlockElement, CommandItem, OnesEditor, OnesEditorHoveringBlockFilter } from '../../../../@ones-editor/core';
+import { AbstractCommandBar } from '../../../../@ones-editor/ui-base';
+import { OnesEditorToolbarBase } from './types';
+export default class OnesEditorToolbar implements OnesEditorHoveringBlockFilter, OnesEditorToolbarBase {
+    private editor;
+    private toolbar;
+    private toolbarType;
+    private mouseDown;
+    private oldRange;
+    private hoveringBlock;
+    private hoveringTextChild;
+    private _disableTextToolbar;
+    constructor(editor: OnesEditor);
+    disableTextToolbar(): void;
+    enableTextToolbar(): void;
+    hide(): void;
+    destroy(): void;
+    isInBlock(block: BlockElement, event: MouseEvent): boolean;
+    handleButtonClick: (toolbar: AbstractCommandBar, item: CommandItem) => void;
+    handleClose: () => void;
+    bindEvents(): void;
+    unbindEvents(): void;
+    handleDocumentMouseDown: (event: MouseEvent) => void;
+    handleDocumentMouseUp: () => void;
+    private handleHoveringBlockChildChange;
+    handleSelectionChange: import("lodash").DebouncedFunc<(editor: OnesEditor) => void>;
+    update(): void;
+    private showTextToolbar;
+    private showObjectToolbar;
+    static register(editor: OnesEditor): OnesEditorToolbar;
+    static get(editor: OnesEditor): OnesEditorToolbar;
+}

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

@@ -0,0 +1,6 @@
+import { OnesEditorCustom } from '../../../../@ones-editor/core';
+export interface OnesEditorToolbarBase extends OnesEditorCustom {
+    disableTextToolbar: () => void;
+    enableTextToolbar: () => void;
+    hide: () => void;
+}

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

@@ -0,0 +1,25 @@
+import { OnesEditor } from '../../../../@ones-editor/core';
+import { Instance } from 'tippy.js';
+export default class OnesEditorTooltip {
+    private editor;
+    instance: Instance;
+    mousedown: boolean;
+    currentInstance: Instance | null;
+    attributeName: string;
+    attributeDesc: string;
+    constructor(editor: OnesEditor);
+    createContent: (reference: Element) => string | HTMLDivElement;
+    visible(): boolean | undefined;
+    hide(): void;
+    destroy(): void;
+    handleDocumentMouseDown: () => void;
+    handleDocumentMouseUp: () => void;
+    handleShown: (a: Instance) => void;
+    handleHidden: () => void;
+    handleShow: (instance: Instance) => boolean;
+}
+declare global {
+    interface Window {
+        isDragging?: boolean;
+    }
+}

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

@@ -0,0 +1 @@
+export default function maxHeadingContainDocument(): number;

package/@ones-editor/ui-base/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@ones-editor/ui-base",
+  "version": "1.0.0",
+  "private": true,
+  "main": "./src/index.ts",
+  "type": "module",
+  "devDependencies": {
+    "sass": "*"
+  },
+  "types": "src/index.d.ts"
+}

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

@@ -0,0 +1,33 @@
+import { CommandItem, OnesEditor } from '../../../../@ones-editor/core';
+import { AbstractCommandBar, ManualMenu } from '../command-bar';
+export interface AutoSuggestMenuOptions {
+    id: string;
+    showLoading?: boolean;
+    loadingElement?: HTMLElement;
+    placeholder?: HTMLElement | string;
+    noResultMessage?: HTMLElement | string;
+    highlight?: boolean;
+    onShow?: (menu: AutoSuggestMenu, containerId: string, blockIndex: number, offset: number) => boolean | undefined;
+    onClickItem: (menu: AutoSuggestMenu, item: CommandItem) => void;
+    queryItems: (menu: AutoSuggestMenu, text: string) => Promise<CommandItem[]>;
+    renderMenuItem?: (menu: AutoSuggestMenu, item: CommandItem) => HTMLElement | undefined;
+}
+export default class AutoSuggestMenu {
+    private editor;
+    private options;
+    menu: ManualMenu;
+    private currentText;
+    constructor(editor: OnesEditor, options: AutoSuggestMenuOptions);
+    private setItems;
+    popup(containerId: string, blockIndex: number, offset: number): Promise<void>;
+    private showLoading;
+    private showPlaceholder;
+    private showNoResultMessage;
+    close(): void;
+    get isVisible(): boolean;
+    destroy(): void;
+    handleSearchText(text: string): Promise<void>;
+    handleClick: (menu: AbstractCommandBar, item: CommandItem) => void;
+    handleKeydown: (event: KeyboardEvent) => void;
+    private highlightText;
+}

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

@@ -0,0 +1,44 @@
+import { OnesEditor, OnesEditorInputHandler, CommandItem, BlockElement } from '../../../../@ones-editor/core';
+import AutoSuggestMenu from './auto-suggest-menu';
+export { AutoSuggestMenu };
+export interface AutoSuggestAnchor {
+    blockId: string;
+    offset: number;
+    leftText: string;
+    trigger: string;
+}
+export interface AutoSuggestOptions {
+    id: string;
+    trigger: string[];
+    autoDeleteTrigger?: boolean;
+    needSpaceBeforeTrigger?: boolean;
+    showLoading?: boolean;
+    loadingElement?: HTMLElement;
+    placeholder?: HTMLElement | string;
+    noResultMessage?: HTMLElement | string;
+    highlight?: boolean;
+    onShow?: (menu: OnesEditorAutoSuggest, containerId: string, blockIndex: number, offset: number) => boolean | undefined;
+    onClickItem: (menu: OnesEditorAutoSuggest, item: CommandItem, anchor: AutoSuggestAnchor) => void;
+    queryItems: (menu: OnesEditorAutoSuggest, text: string) => Promise<CommandItem[]>;
+    renderMenuItem?: (menu: OnesEditorAutoSuggest, item: CommandItem) => HTMLElement | undefined;
+}
+declare class OnesEditorAutoSuggest implements OnesEditorInputHandler {
+    private editor;
+    private options;
+    menu: AutoSuggestMenu;
+    anchor: AutoSuggestAnchor | null;
+    constructor(editor: OnesEditor, options: AutoSuggestOptions);
+    handleBeforeKeyDown(editor: OnesEditor, event: KeyboardEvent): boolean;
+    popup(block: BlockElement, offset: number, leftText: string, trigger: string): void;
+    handleAfterInsertText(editor: OnesEditor, containerId: string, blockIndex: number, insertOffset: number, text: string): boolean;
+    handleUpdateCompositionText(editor: OnesEditor, containerId: string, blockIndex: number, offset: number, end: boolean): boolean;
+    handleSelectionChanged: (editor: OnesEditor) => void;
+    private resetItems;
+    private deleteTrigger;
+    private onShow;
+    private onClickItem;
+    private queryItems;
+    private renderMenuItem;
+    destroy(): void;
+}
+export default OnesEditorAutoSuggest;

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

@@ -0,0 +1,3 @@
+import OnesEditorAutoSuggest from './auto-suggest';
+import type { AutoSuggestAnchor, AutoSuggestOptions } from './auto-suggest';
+export { OnesEditorAutoSuggest, AutoSuggestAnchor, AutoSuggestOptions };

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

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

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

@@ -0,0 +1,2 @@
+import { TextColorItem } from './text-color-item';
+export { TextColorItem };

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

@@ -0,0 +1,23 @@
+import { CommandItem, OnesEditor } from '../../../../@ones-editor/core';
+import { TypedEmitter } from 'tiny-typed-emitter';
+import { ColorPaletteItem } from '../color-palette';
+import { ColorPaletteEvents } from '../color-palette/color-palette';
+export declare class TextColorItem extends TypedEmitter<ColorPaletteEvents> implements CommandItem {
+    private editor;
+    id: string;
+    name: string;
+    dropdown: boolean;
+    manualShowChildren: boolean;
+    children: CommandItem[];
+    element: HTMLButtonElement;
+    colorPaletteItem: ColorPaletteItem;
+    private latestColors;
+    constructor(editor: OnesEditor);
+    destroy(): void;
+    handlePaletteClick: (type: 'color' | 'backgroundColor' | 'clearColor', value: number) => void;
+    beforePopup: () => void;
+    updatePaletteColor(colors: [number | null, number | null]): void;
+    updateButtonColor(): void;
+    loadSettings(): Promise<void>;
+    saveSettings(): void;
+}

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

@@ -0,0 +1,12 @@
+import { Closeable, CommandItem } from '../../../../@ones-editor/core';
+import ColorPalette, { ColorPaletteOptions } from './color-palette';
+export default class ColorPaletteItem implements CommandItem {
+    id: string;
+    name: string;
+    element: HTMLElement;
+    palette: ColorPalette;
+    closeable: Closeable | null;
+    constructor(id: string, options?: ColorPaletteOptions);
+    setCloseable(closeable: Closeable): void;
+    destroy(): void;
+}

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

@@ -0,0 +1,17 @@
+import { TypedEmitter } from 'tiny-typed-emitter';
+import type { ColorPaletteOptions } from './create-palette';
+import './palette.scss';
+export { ColorPaletteOptions };
+export type ColorType = 'color' | 'backgroundColor';
+export interface ColorPaletteEvents {
+    onClick: (type: ColorType | 'clearColor', value: number) => void;
+    beforePopup: () => void;
+}
+export default class ColorPalette extends TypedEmitter<ColorPaletteEvents> {
+    private options;
+    root: HTMLElement;
+    constructor(options?: ColorPaletteOptions);
+    destroy(): void;
+    setColor(type: ColorType, value: number | null): void;
+    handleClick: (event: MouseEvent) => void;
+}

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

@@ -0,0 +1,2 @@
+export declare const FONT_COLOR_MAP: number[];
+export declare const BKG_COLOR_MAP: number[];

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

@@ -0,0 +1,7 @@
+export interface ColorPaletteOptions {
+    color?: boolean;
+    backgroundColor?: boolean;
+    clearColorButton?: boolean;
+}
+export declare function createPalette(options: ColorPaletteOptions): HTMLDivElement;
+export declare function selectPaletteColor(root: HTMLElement, type: 'color' | 'backgroundColor', value: number | null): void;

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

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

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

@@ -0,0 +1,51 @@
+import { TypedEmitter } from 'tiny-typed-emitter';
+import { CommandItem, Closeable } from '../../../../@ones-editor/core';
+import { AbstractManualCommandBar, AbstractCommandBar, CommandBarEvents, CommandBarOptions, CommandItemElement, CreateManualCommandBarFunction, ManualShowCommandBarOptions } from './types';
+import 'tippy.js/dist/tippy.css';
+export default abstract class CommandBar extends TypedEmitter<CommandBarEvents> implements AbstractCommandBar {
+    content: HTMLElement;
+    items: CommandItem[];
+    subBar: AbstractManualCommandBar | null;
+    parentItem: CommandItem | null;
+    closeable: Closeable | null;
+    options: CommandBarOptions;
+    id: string;
+    constructor(items: CommandItem[], closeable?: Closeable, options?: CommandBarOptions);
+    close(): void;
+    click(item: CommandItem, target: HTMLElement): void;
+    destroy(): void;
+    abstract readonly isVisible: boolean;
+    get isSubCommandBar(): boolean;
+    updateItems(items: CommandItem[]): void;
+    handleDocumentKeydown: (event: KeyboardEvent) => void;
+    protected handleDocumentMouseDown: (event: MouseEvent) => void;
+    protected handleHidden: () => void;
+    protected handleShow: () => void;
+    get popper(): Element | null;
+    private getSelectedItemIndex;
+    private getPrevItemIndex;
+    private getNextItemIndex;
+    protected clearSelectedItem(): void;
+    private selectItem;
+    private handleItemMouseEnter;
+    private handleItemMouseLeave;
+    protected handleItemClick: (event: MouseEvent) => void;
+    private showSubCommandBar;
+    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;
+    protected getParentCommandItemElement(target: EventTarget | null): CommandItemElement | null;
+    protected createCommandBarContent(items: CommandItem[]): HTMLElement;
+    handleWheel: (e: WheelEvent) => void;
+    getSubBarOptions(item: CommandItem): ManualShowCommandBarOptions;
+    protected abstract initCommandBarElement(elem: HTMLElement): void;
+    protected abstract initItemElement(item: CommandItem, elem: CommandItemElement): void;
+    protected abstract getCommandBarRoot(): HTMLElement | null;
+    static commandBarCreators: Map<string, CreateManualCommandBarFunction>;
+    static registerManualCommandBar(type: string, creator: CreateManualCommandBarFunction): void;
+    static createSubCommandBar(item: CommandItem, closeable: Closeable): AbstractManualCommandBar;
+    static hasExistsCommandBar(): boolean;
+}

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

@@ -0,0 +1,17 @@
+import { Instance, Placement } from 'tippy.js';
+import CommandBar from './command-bar';
+export default abstract class HoveringCommandBar extends CommandBar {
+    tippyInstance: Instance | null;
+    create(target: HTMLElement, options?: {
+        placement?: Placement;
+        point?: {
+            x: number;
+            y: number;
+        };
+        delay?: number | [number | null, number | null] | undefined;
+    }): void;
+    close(): void;
+    destroy(): void;
+    protected getCommandBarRoot(): HTMLElement | null;
+    get isVisible(): boolean;
+}