@kaitify/vue 0.0.1-beta.1

package/lib/editor/menu/built-in/table/props.d.ts

@@ -0,0 +1,97 @@
+import { TableCellsMergeDirectionType } from '@kaitify/core';
+import { MenuPropsType } from '../../props';
+export type TableGridType = {
+    x: number;
+    y: number;
+    inside: boolean;
+};
+export type TableMenuPropsType = {
+    /**
+     * 是否禁用
+     */
+    disabled?: boolean;
+    /**
+     * 表格最大行数
+     */
+    maxRows?: number;
+    /**
+     * 表格最大列数
+     */
+    maxColumns?: number;
+    /**
+     * 浮层属性
+     */
+    popoverProps?: MenuPropsType['popoverProps'];
+};
+export type TableUnsetMenuPropsType = {
+    /**
+     * 是否禁用
+     */
+    disabled?: boolean;
+    /**
+     * 快捷键设置
+     */
+    shortcut?: (e: KeyboardEvent) => boolean;
+};
+export type TableDeleteRowMenuPropsType = {
+    /**
+     * 是否禁用
+     */
+    disabled?: boolean;
+    /**
+     * 快捷键设置
+     */
+    shortcut?: (e: KeyboardEvent) => boolean;
+};
+export type TableDeleteColumnMenuPropsType = {
+    /**
+     * 是否禁用
+     */
+    disabled?: boolean;
+    /**
+     * 快捷键设置
+     */
+    shortcut?: (e: KeyboardEvent) => boolean;
+};
+export type TableAddRowMenuPropsType = {
+    /**
+     * 是否禁用
+     */
+    disabled?: boolean;
+    /**
+     * 插入类型
+     */
+    type?: 'top' | 'bottom';
+    /**
+     * 快捷键设置
+     */
+    shortcut?: (e: KeyboardEvent) => boolean;
+};
+export type TableAddColumnMenuPropsType = {
+    /**
+     * 是否禁用
+     */
+    disabled?: boolean;
+    /**
+     * 插入类型
+     */
+    type?: 'left' | 'right';
+    /**
+     * 快捷键设置
+     */
+    shortcut?: (e: KeyboardEvent) => boolean;
+};
+export type TableMergeCellMenuPropsType = {
+    /**
+     * 是否禁用
+     */
+    disabled?: boolean;
+    /**
+     * 合并方向
+     */
+    direction: TableCellsMergeDirectionType;
+    /**
+     * 快捷键设置
+     */
+    shortcut?: (e: KeyboardEvent) => boolean;
+};

package/lib/editor/menu/built-in/table/table-add-column.vue.d.ts

@@ -0,0 +1,5 @@
+import { TableAddColumnMenuPropsType } from './props';
+declare const _default: import('vue').DefineComponent<TableAddColumnMenuPropsType, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<TableAddColumnMenuPropsType> & Readonly<{}>, {
+    disabled: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/lib/editor/menu/built-in/table/table-add-row.vue.d.ts

@@ -0,0 +1,5 @@
+import { TableAddRowMenuPropsType } from './props';
+declare const _default: import('vue').DefineComponent<TableAddRowMenuPropsType, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<TableAddRowMenuPropsType> & Readonly<{}>, {
+    disabled: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/lib/editor/menu/built-in/table/table-delete-column.vue.d.ts

@@ -0,0 +1,5 @@
+import { TableDeleteColumnMenuPropsType } from './props';
+declare const _default: import('vue').DefineComponent<TableDeleteColumnMenuPropsType, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<TableDeleteColumnMenuPropsType> & Readonly<{}>, {
+    disabled: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/lib/editor/menu/built-in/table/table-delete-row.vue.d.ts

@@ -0,0 +1,5 @@
+import { TableDeleteRowMenuPropsType } from './props';
+declare const _default: import('vue').DefineComponent<TableDeleteRowMenuPropsType, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<TableDeleteRowMenuPropsType> & Readonly<{}>, {
+    disabled: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/lib/editor/menu/built-in/table/table-merge-cell.vue.d.ts

@@ -0,0 +1,5 @@
+import { TableMergeCellMenuPropsType } from './props';
+declare const _default: import('vue').DefineComponent<TableMergeCellMenuPropsType, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<TableMergeCellMenuPropsType> & Readonly<{}>, {
+    disabled: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/lib/editor/menu/built-in/table/table-unset.vue.d.ts

@@ -0,0 +1,5 @@
+import { TableUnsetMenuPropsType } from './props';
+declare const _default: import('vue').DefineComponent<TableUnsetMenuPropsType, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<TableUnsetMenuPropsType> & Readonly<{}>, {
+    disabled: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/lib/editor/menu/built-in/table/table.vue.d.ts

@@ -0,0 +1,7 @@
+import { TableMenuPropsType } from './props';
+declare const _default: import('vue').DefineComponent<TableMenuPropsType, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<TableMenuPropsType> & Readonly<{}>, {
+    disabled: boolean;
+    maxRows: number;
+    maxColumns: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/lib/editor/menu/built-in/task/index.d.ts

@@ -0,0 +1,3 @@
+import { default as TaskMenu } from './task.vue';
+export * from './props';
+export { TaskMenu };

package/lib/editor/menu/built-in/task/props.d.ts

@@ -0,0 +1,10 @@
+export type TaskMenuPropsType = {
+    /**
+     * 是否禁用
+     */
+    disabled?: boolean;
+    /**
+     * 快捷键设置
+     */
+    shortcut?: (e: KeyboardEvent) => boolean;
+};

package/lib/editor/menu/built-in/task/task.vue.d.ts

@@ -0,0 +1,5 @@
+import { TaskMenuPropsType } from './props';
+declare const _default: import('vue').DefineComponent<TaskMenuPropsType, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<TaskMenuPropsType> & Readonly<{}>, {
+    disabled: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/lib/editor/menu/built-in/underline/index.d.ts

@@ -0,0 +1,3 @@
+import { default as UnderlineMenu } from './underline.vue';
+export * from './props';
+export { UnderlineMenu };

package/lib/editor/menu/built-in/underline/props.d.ts

@@ -0,0 +1,10 @@
+export type UnderlineMenuPropsType = {
+    /**
+     * 是否禁用
+     */
+    disabled?: boolean;
+    /**
+     * 快捷键设置
+     */
+    shortcut?: (e: KeyboardEvent) => boolean;
+};

package/lib/editor/menu/built-in/underline/underline.vue.d.ts

@@ -0,0 +1,5 @@
+import { UnderlineMenuPropsType } from './props';
+declare const _default: import('vue').DefineComponent<UnderlineMenuPropsType, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<UnderlineMenuPropsType> & Readonly<{}>, {
+    disabled: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/lib/editor/menu/built-in/undo/index.d.ts

@@ -0,0 +1,3 @@
+import { default as UndoMenu } from './undo.vue';
+export * from './props';
+export { UndoMenu };

package/lib/editor/menu/built-in/undo/props.d.ts

@@ -0,0 +1,6 @@
+export type UndoMenuPropsType = {
+    /**
+     * 是否禁用
+     */
+    disabled?: boolean;
+};

package/lib/editor/menu/built-in/undo/undo.vue.d.ts

@@ -0,0 +1,5 @@
+import { UndoMenuPropsType } from './props';
+declare const _default: import('vue').DefineComponent<UndoMenuPropsType, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<UndoMenuPropsType> & Readonly<{}>, {
+    disabled: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/lib/editor/menu/built-in/unordered-list/index.d.ts

@@ -0,0 +1,3 @@
+import { default as UnorderedListMenu } from './unordered-list.vue';
+export * from './props';
+export { UnorderedListMenu };

package/lib/editor/menu/built-in/unordered-list/props.d.ts

@@ -0,0 +1,11 @@
+import { MenuPropsType } from '../../props';
+export type UnorderedListMenuPropsType = {
+    /**
+     * 是否禁用
+     */
+    disabled?: boolean;
+    /**
+     * 浮层属性
+     */
+    popoverProps?: MenuPropsType['popoverProps'];
+};

package/lib/editor/menu/built-in/unordered-list/unordered-list.vue.d.ts

@@ -0,0 +1,5 @@
+import { UnorderedListMenuPropsType } from './props';
+declare const _default: import('vue').DefineComponent<UnorderedListMenuPropsType, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<UnorderedListMenuPropsType> & Readonly<{}>, {
+    disabled: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/lib/editor/menu/built-in/video/index.d.ts

@@ -0,0 +1,6 @@
+import { default as VideoMenu } from './video.vue';
+import { default as VideoControlsMenu } from './video-controls.vue';
+import { default as VideoMutedMenu } from './video-muted.vue';
+import { default as VideoLoopMenu } from './video-loop.vue';
+export * from './props';
+export { VideoMenu, VideoControlsMenu, VideoMutedMenu, VideoLoopMenu };

package/lib/editor/menu/built-in/video/props.d.ts

@@ -0,0 +1,49 @@
+import { MenuPropsType } from '../../props';
+export type VideoMenuPropsType = {
+    /**
+     * 是否禁用
+     */
+    disabled?: boolean;
+    /**
+     * 初始视频宽度
+     */
+    width?: string | number;
+    /**
+     * 自定义上传方法
+     */
+    customUpload?: (file: File) => string | Promise<string>;
+    /**
+     * 浮层属性
+     */
+    popoverProps?: MenuPropsType['popoverProps'];
+};
+export type VideoControlsMenuPropsType = {
+    /**
+     * 是否禁用
+     */
+    disabled?: boolean;
+    /**
+     * 快捷键设置
+     */
+    shortcut?: (e: KeyboardEvent) => boolean;
+};
+export type VideoMutedMenuPropsType = {
+    /**
+     * 是否禁用
+     */
+    disabled?: boolean;
+    /**
+     * 快捷键设置
+     */
+    shortcut?: (e: KeyboardEvent) => boolean;
+};
+export type VideoLoopMenuPropsType = {
+    /**
+     * 是否禁用
+     */
+    disabled?: boolean;
+    /**
+     * 快捷键设置
+     */
+    shortcut?: (e: KeyboardEvent) => boolean;
+};

package/lib/editor/menu/built-in/video/video-controls.vue.d.ts

@@ -0,0 +1,5 @@
+import { VideoControlsMenuPropsType } from './props';
+declare const _default: import('vue').DefineComponent<VideoControlsMenuPropsType, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<VideoControlsMenuPropsType> & Readonly<{}>, {
+    disabled: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/lib/editor/menu/built-in/video/video-loop.vue.d.ts

@@ -0,0 +1,5 @@
+import { VideoLoopMenuPropsType } from './props';
+declare const _default: import('vue').DefineComponent<VideoLoopMenuPropsType, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<VideoLoopMenuPropsType> & Readonly<{}>, {
+    disabled: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/lib/editor/menu/built-in/video/video-muted.vue.d.ts

@@ -0,0 +1,5 @@
+import { VideoMutedMenuPropsType } from './props';
+declare const _default: import('vue').DefineComponent<VideoMutedMenuPropsType, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<VideoMutedMenuPropsType> & Readonly<{}>, {
+    disabled: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/lib/editor/menu/built-in/video/video.vue.d.ts

@@ -0,0 +1,5 @@
+import { VideoMenuPropsType } from './props';
+declare const _default: import('vue').DefineComponent<VideoMenuPropsType, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<VideoMenuPropsType> & Readonly<{}>, {
+    disabled: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/lib/editor/menu/built-in/wrap-down/index.d.ts

@@ -0,0 +1,3 @@
+import { default as WrapDownMenu } from './wrap-down.vue';
+export * from './props';
+export { WrapDownMenu };

package/lib/editor/menu/built-in/wrap-down/props.d.ts

@@ -0,0 +1,15 @@
+import { KNodeMatchOptionType } from '../../../../index';
+export type WrapDownMenuPropsType = {
+    /**
+     * 是否禁用
+     */
+    disabled?: boolean;
+    /**
+     * 指定换行的块节点条件
+     */
+    match: KNodeMatchOptionType;
+    /**
+     * 快捷键设置
+     */
+    shortcut?: (e: KeyboardEvent) => boolean;
+};

package/lib/editor/menu/built-in/wrap-down/wrap-down.vue.d.ts

@@ -0,0 +1,5 @@
+import { WrapDownMenuPropsType } from './props';
+declare const _default: import('vue').DefineComponent<WrapDownMenuPropsType, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<WrapDownMenuPropsType> & Readonly<{}>, {
+    disabled: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/lib/editor/menu/built-in/wrap-up/index.d.ts

@@ -0,0 +1,3 @@
+import { default as WrapUpMenu } from './wrap-up.vue';
+export * from './props';
+export { WrapUpMenu };

package/lib/editor/menu/built-in/wrap-up/props.d.ts

@@ -0,0 +1,15 @@
+import { KNodeMatchOptionType } from '../../../../index';
+export type WrapUpMenuPropsType = {
+    /**
+     * 是否禁用
+     */
+    disabled?: boolean;
+    /**
+     * 指定换行的块节点条件
+     */
+    match: KNodeMatchOptionType;
+    /**
+     * 快捷键设置
+     */
+    shortcut?: (e: KeyboardEvent) => boolean;
+};

package/lib/editor/menu/built-in/wrap-up/wrap-up.vue.d.ts

@@ -0,0 +1,5 @@
+import { WrapUpMenuPropsType } from './props';
+declare const _default: import('vue').DefineComponent<WrapUpMenuPropsType, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<WrapUpMenuPropsType> & Readonly<{}>, {
+    disabled: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/lib/editor/menu/index.d.ts

@@ -0,0 +1,4 @@
+import { default as Menu } from './menu.vue';
+export * from './props';
+export * from './built-in';
+export { Menu };

package/lib/editor/menu/menu.vue.d.ts

@@ -0,0 +1,164 @@
+import { MenuDataType, MenuPropsType } from './props';
+declare function __VLS_template(): {
+    slots: {
+        default?(_: {}): any;
+        popover?(_: {}): any;
+        icon?(_: {
+            option: MenuDataType;
+        }): any;
+        label?(_: {
+            option: MenuDataType;
+        }): any;
+    };
+    refs: {
+        popoverRef: ({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly width?: (string | number) | undefined;
+                readonly minWidth?: (string | number) | undefined;
+                readonly maxHeight?: (string | number) | undefined;
+                readonly placement?: import('../../core/popover').PopoverPlacementType | undefined;
+                readonly arrow?: boolean | undefined;
+                readonly trigger?: ("hover" | "click" | "custom") | undefined;
+                readonly animation?: ("fade" | "translate" | (string & {})) | undefined;
+                readonly zIndex?: number | undefined;
+                readonly delay?: number | undefined;
+                readonly disabled?: boolean | undefined;
+                readonly onShow?: ((...args: any[]) => any) | undefined;
+                readonly onShowing?: ((...args: any[]) => any) | undefined;
+                readonly onShown?: ((...args: any[]) => any) | undefined;
+                readonly onHide?: ((...args: any[]) => any) | undefined;
+                readonly onHiding?: ((...args: any[]) => any) | undefined;
+                readonly onHidden?: ((...args: any[]) => any) | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any> | undefined;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "show", ...args: any[]) => void) & ((event: "showing", ...args: any[]) => void) & ((event: "shown", ...args: any[]) => void) & ((event: "hide", ...args: any[]) => void) & ((event: "hiding", ...args: any[]) => void) & ((event: "hidden", ...args: any[]) => void);
+            $el: any;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('../../core/popover').PopoverPropsType> & Readonly<{
+                onShow?: ((...args: any[]) => any) | undefined;
+                onShowing?: ((...args: any[]) => any) | undefined;
+                onShown?: ((...args: any[]) => any) | undefined;
+                onHide?: ((...args: any[]) => any) | undefined;
+                onHiding?: ((...args: any[]) => any) | undefined;
+                onHidden?: ((...args: any[]) => any) | undefined;
+            }>, {
+                visible: import('vue').Ref<boolean, boolean>;
+                showPopover: () => void;
+                hidePopover: () => void;
+                popperInstance: import('vue').Ref<import('@popperjs/core').Instance | undefined, import('@popperjs/core').Instance | undefined>;
+                update: () => Promise<void>;
+                realPlacement: import('vue').Ref<import('../../core/popover').PopoverPlacementType, import('../../core/popover').PopoverPlacementType>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                show: (...args: any[]) => void;
+                showing: (...args: any[]) => void;
+                shown: (...args: any[]) => void;
+                hide: (...args: any[]) => void;
+                hiding: (...args: any[]) => void;
+                hidden: (...args: any[]) => void;
+            }, string, {
+                zIndex: number;
+                disabled: boolean;
+                animation: "fade" | "translate" | (string & {});
+                placement: import('../../core/popover').PopoverPlacementType;
+                arrow: boolean;
+                trigger: "hover" | "click" | "custom";
+                delay: number;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import('vue').nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+        } & Readonly<{
+            zIndex: number;
+            disabled: boolean;
+            animation: "fade" | "translate" | (string & {});
+            placement: import('../../core/popover').PopoverPlacementType;
+            arrow: boolean;
+            trigger: "hover" | "click" | "custom";
+            delay: number;
+        }> & Omit<Readonly<import('../../core/popover').PopoverPropsType> & Readonly<{
+            onShow?: ((...args: any[]) => any) | undefined;
+            onShowing?: ((...args: any[]) => any) | undefined;
+            onShown?: ((...args: any[]) => any) | undefined;
+            onHide?: ((...args: any[]) => any) | undefined;
+            onHiding?: ((...args: any[]) => any) | undefined;
+            onHidden?: ((...args: any[]) => any) | undefined;
+        }>, "visible" | "popperInstance" | "showPopover" | "hidePopover" | "update" | "realPlacement" | ("zIndex" | "disabled" | "animation" | "placement" | "arrow" | "trigger" | "delay")> & import('vue').ShallowUnwrapRef<{
+            visible: import('vue').Ref<boolean, boolean>;
+            showPopover: () => void;
+            hidePopover: () => void;
+            popperInstance: import('vue').Ref<import('@popperjs/core').Instance | undefined, import('@popperjs/core').Instance | undefined>;
+            update: () => Promise<void>;
+            realPlacement: import('vue').Ref<import('../../core/popover').PopoverPlacementType, import('../../core/popover').PopoverPlacementType>;
+        }> & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: {
+                refer?(_: {}): any;
+                default?(_: {}): any;
+            };
+        }) | null;
+    };
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<MenuPropsType, {
+    showPopover: () => void;
+    hidePopover: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (...args: any[]) => void;
+    operate: (...args: any[]) => void;
+    popoverShow: (...args: any[]) => void;
+    popoverShowing: (...args: any[]) => void;
+    popoverShown: (...args: any[]) => void;
+    popoverHide: (...args: any[]) => void;
+    popoverHiding: (...args: any[]) => void;
+    popoverHidden: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<MenuPropsType> & Readonly<{
+    onSelect?: ((...args: any[]) => any) | undefined;
+    onOperate?: ((...args: any[]) => any) | undefined;
+    onPopoverShow?: ((...args: any[]) => any) | undefined;
+    onPopoverShowing?: ((...args: any[]) => any) | undefined;
+    onPopoverShown?: ((...args: any[]) => any) | undefined;
+    onPopoverHide?: ((...args: any[]) => any) | undefined;
+    onPopoverHiding?: ((...args: any[]) => any) | undefined;
+    onPopoverHidden?: ((...args: any[]) => any) | undefined;
+}>, {
+    data: MenuDataType[];
+    disabled: boolean;
+    active: boolean;
+    popover: boolean;
+    popoverProps: Omit<import('../../core/popover').PopoverPropsType, "disabled" | "delay">;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/editor/menu/props.d.ts

@@ -0,0 +1,57 @@
+import { PopoverPropsType } from '../../core/popover';
+/**
+ * 菜单可选数据的类型
+ */
+export type MenuDataType = {
+    /**
+     * 显示的文字
+     */
+    label: string;
+    /**
+     * 表示的值
+     */
+    value: string | number;
+    /**
+     * 左侧显示的图标
+     */
+    icon?: string;
+};
+/**
+ * 菜单组件的属性类型
+ */
+export type MenuPropsType = {
+    /**
+     * 是否禁用
+     */
+    disabled?: boolean;
+    /**
+     * 是否激活
+     */
+    active?: boolean;
+    /**
+     * 选项禁用
+     */
+    itemDisabled?: (item: MenuDataType) => boolean;
+    /**
+     * 选项是否激活
+     */
+    itemActive?: (item: MenuDataType) => boolean;
+    /**
+     * 是否有浮层
+     */
+    popover?: boolean;
+    /**
+     * 浮层属性
+     */
+    popoverProps?: Omit<PopoverPropsType, 'disabled' | 'delay'>;
+    /**
+     * 可选数据
+     */
+    data?: MenuDataType[];
+    /**
+     * 快捷键设置
+     */
+    shortcut?: ((e: KeyboardEvent) => boolean) | {
+        [key: MenuDataType['value']]: (e: KeyboardEvent) => boolean;
+    };
+};

package/lib/editor/wrapper/index.d.ts

@@ -0,0 +1,3 @@
+import { default as Wrapper } from './wrapper.vue';
+export * from './props';
+export { Wrapper };