@cgboiler/biz-basic 1.0.53 → 1.0.55

package/lib/rich-text-editor/menu-system/components/text-align-button.js

@@ -0,0 +1,99 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+__export(stdin_exports, {
+  TextAlignButton: () => TextAlignButton
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_vue = require("vue");
+var import_atomic = require("./_atomic.css");
+var import_vue2 = require("vue");
+var import_use_text_align = require("../hooks/use-text-align");
+var import_button = require("../primitives/button");
+var import_tiptap_utils = require("../utils/tiptap-utils");
+const TextAlignButton = (0, import_vue2.defineComponent)({
+  name: "TextAlignButton",
+  props: {
+    editor: {
+      type: Object,
+      required: true
+    },
+    align: {
+      type: String,
+      required: true
+    },
+    text: {
+      type: String,
+      default: ""
+    },
+    hideWhenUnavailable: {
+      type: Boolean,
+      default: false
+    },
+    showShortcut: {
+      type: Boolean,
+      default: false
+    },
+    className: {
+      type: String,
+      default: ""
+    }
+  },
+  setup(props, {
+    slots,
+    attrs
+  }) {
+    const {
+      isVisible,
+      handleTextAlign,
+      label,
+      canAlign,
+      isActive,
+      Icon,
+      shortcutKeys
+    } = (0, import_use_text_align.useTextAlign)({
+      editor: props.editor,
+      align: props.align,
+      hideWhenUnavailable: props.hideWhenUnavailable
+    });
+    return () => {
+      if (!isVisible.value)
+        return null;
+      return (0, import_vue.createVNode)(import_button.Button, (0, import_vue.mergeProps)({
+        "type": "button",
+        "disabled": !canAlign.value,
+        "data-style": "ghost",
+        "data-active-state": isActive.value ? "on" : "off",
+        "data-disabled": !canAlign.value,
+        "role": "button",
+        "tabindex": -1,
+        "aria-label": label,
+        "aria-pressed": isActive.value,
+        "tooltip": label,
+        "onClick": handleTextAlign,
+        "class": (0, import_tiptap_utils.cn)(props.className)
+      }, attrs), {
+        default: () => [slots.default ? slots.default() : (0, import_vue.createVNode)(import_vue.Fragment, null, [(0, import_vue.createVNode)(Icon, {
+          "class": "tiptap-button-icon"
+        }, null), props.text && (0, import_vue.createVNode)("span", {
+          "class": "tiptap-button-text"
+        }, [props.text])])]
+      });
+    };
+  }
+});

package/lib/rich-text-editor/menu-system/components/undo-redo-button.d.ts

@@ -0,0 +1,58 @@
+import { type PropType } from 'vue';
+import { type UndoRedoAction } from '../hooks/use-undo-redo';
+export declare const UndoRedoButton: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    editor: {
+        type: PropType<any>;
+        required: true;
+    };
+    action: {
+        type: PropType<UndoRedoAction>;
+        required: true;
+    };
+    text: {
+        type: StringConstructor;
+        default: string;
+    };
+    hideWhenUnavailable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showShortcut: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    className: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    editor: {
+        type: PropType<any>;
+        required: true;
+    };
+    action: {
+        type: PropType<UndoRedoAction>;
+        required: true;
+    };
+    text: {
+        type: StringConstructor;
+        default: string;
+    };
+    hideWhenUnavailable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showShortcut: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    className: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    text: string;
+    className: string;
+    hideWhenUnavailable: boolean;
+    showShortcut: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/lib/rich-text-editor/menu-system/components/undo-redo-button.js

@@ -0,0 +1,96 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+__export(stdin_exports, {
+  UndoRedoButton: () => UndoRedoButton
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_vue = require("vue");
+var import_atomic = require("./_atomic.css");
+var import_vue2 = require("vue");
+var import_use_undo_redo = require("../hooks/use-undo-redo");
+var import_button = require("../primitives/button");
+var import_tiptap_utils = require("../utils/tiptap-utils");
+const UndoRedoButton = (0, import_vue2.defineComponent)({
+  name: "UndoRedoButton",
+  props: {
+    editor: {
+      type: Object,
+      required: true
+    },
+    action: {
+      type: String,
+      required: true
+    },
+    text: {
+      type: String,
+      default: ""
+    },
+    hideWhenUnavailable: {
+      type: Boolean,
+      default: false
+    },
+    showShortcut: {
+      type: Boolean,
+      default: false
+    },
+    className: {
+      type: String,
+      default: ""
+    }
+  },
+  setup(props, {
+    slots,
+    attrs
+  }) {
+    const {
+      isVisible,
+      handleAction,
+      label,
+      canExecute,
+      Icon,
+      shortcutKeys
+    } = (0, import_use_undo_redo.useUndoRedo)({
+      editor: props.editor,
+      action: props.action,
+      hideWhenUnavailable: props.hideWhenUnavailable
+    });
+    return () => {
+      if (!isVisible.value)
+        return null;
+      return (0, import_vue.createVNode)(import_button.Button, (0, import_vue.mergeProps)({
+        "type": "button",
+        "disabled": !canExecute.value,
+        "data-style": "ghost",
+        "data-disabled": !canExecute.value,
+        "role": "button",
+        "tabindex": -1,
+        "aria-label": label,
+        "tooltip": label,
+        "onClick": handleAction,
+        "class": (0, import_tiptap_utils.cn)(props.className)
+      }, attrs), {
+        default: () => [slots.default ? slots.default() : (0, import_vue.createVNode)(import_vue.Fragment, null, [(0, import_vue.createVNode)(Icon, {
+          "class": "tiptap-button-icon"
+        }, null), props.text && (0, import_vue.createVNode)("span", {
+          "class": "tiptap-button-text"
+        }, [props.text])])]
+      });
+    };
+  }
+});

package/lib/rich-text-editor/menu-system/hooks/use-blockquote.d.ts

@@ -0,0 +1,34 @@
+import type { Editor } from '@tiptap/vue-3';
+export declare const BLOCKQUOTE_SHORTCUT_KEY = "mod+shift+b";
+export interface UseBlockquoteConfig {
+    editor: any;
+    hideWhenUnavailable?: boolean;
+    onToggled?: () => void;
+}
+export declare function canToggleBlockquote(editor: Editor | null, turnInto?: boolean): boolean;
+export declare function toggleBlockquote(editor: Editor | null): boolean;
+export declare function shouldShowButton(props: {
+    editor: Editor | null;
+    hideWhenUnavailable: boolean;
+}): boolean;
+export declare function useBlockquote(config: UseBlockquoteConfig): {
+    isVisible: import("vue").Ref<boolean, boolean>;
+    isActive: import("vue").Ref<boolean, boolean>;
+    handleToggle: () => void;
+    canToggle: import("vue").Ref<boolean, boolean>;
+    label: string;
+    shortcutKeys: string;
+    Icon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        className: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        className: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>> & Readonly<{}>, {
+        className: string;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+};

package/lib/rich-text-editor/menu-system/hooks/use-blockquote.js

@@ -0,0 +1,154 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+__export(stdin_exports, {
+  BLOCKQUOTE_SHORTCUT_KEY: () => BLOCKQUOTE_SHORTCUT_KEY,
+  canToggleBlockquote: () => canToggleBlockquote,
+  shouldShowButton: () => shouldShowButton,
+  toggleBlockquote: () => toggleBlockquote,
+  useBlockquote: () => useBlockquote
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_vue = require("vue");
+var import_state = require("@tiptap/pm/state");
+var import_tiptap_utils = require("../utils/tiptap-utils");
+var import_icons = require("../icons");
+const BLOCKQUOTE_SHORTCUT_KEY = "mod+shift+b";
+function canToggleBlockquote(editor, turnInto = true) {
+  var _a;
+  if (!editor || !editor.isEditable)
+    return false;
+  if (!(0, import_tiptap_utils.isNodeInSchema)("blockquote", editor) || (0, import_tiptap_utils.isNodeTypeSelected)(editor, ["image"]))
+    return false;
+  if (!turnInto) {
+    return editor.can().toggleWrap("blockquote");
+  }
+  try {
+    const view = editor.view;
+    const state = view.state;
+    const selection = state.selection;
+    if (selection.empty || selection instanceof import_state.TextSelection) {
+      const pos = (_a = (0, import_tiptap_utils.findNodePosition)({
+        editor,
+        node: state.selection.$anchor.node(1)
+      })) == null ? void 0 : _a.pos;
+      if (!(0, import_tiptap_utils.isValidPosition)(pos))
+        return false;
+    }
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+function toggleBlockquote(editor) {
+  var _a;
+  if (!editor || !editor.isEditable)
+    return false;
+  if (!canToggleBlockquote(editor))
+    return false;
+  try {
+    const view = editor.view;
+    let state = view.state;
+    let tr = state.tr;
+    if (state.selection.empty || state.selection instanceof import_state.TextSelection) {
+      const pos = (_a = (0, import_tiptap_utils.findNodePosition)({
+        editor,
+        node: state.selection.$anchor.node(1)
+      })) == null ? void 0 : _a.pos;
+      if (!(0, import_tiptap_utils.isValidPosition)(pos))
+        return false;
+      tr = tr.setSelection(import_state.NodeSelection.create(state.doc, pos));
+      view.dispatch(tr);
+      state = view.state;
+    }
+    const selection = state.selection;
+    let chain = editor.chain().focus();
+    if (selection instanceof import_state.NodeSelection) {
+      chain = chain.clearNodes();
+    }
+    const toggle = editor.isActive("blockquote") ? chain.lift("blockquote") : chain.wrapIn("blockquote");
+    toggle.run();
+    editor.chain().focus().selectTextblockEnd().run();
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+function shouldShowButton(props) {
+  const { editor, hideWhenUnavailable } = props;
+  if (!editor || !editor.isEditable)
+    return false;
+  if (!(0, import_tiptap_utils.isNodeInSchema)("blockquote", editor))
+    return false;
+  if (hideWhenUnavailable && !editor.isActive("code")) {
+    return canToggleBlockquote(editor);
+  }
+  return true;
+}
+function useBlockquote(config) {
+  const { hideWhenUnavailable = false, onToggled } = config;
+  const isVisible = (0, import_vue.ref)(true);
+  const isActive = (0, import_vue.ref)(false);
+  const canToggle = (0, import_vue.ref)(false);
+  const getEditor = () => {
+    const editor = config.editor;
+    return editor && "value" in editor ? editor.value : editor;
+  };
+  const updateState = () => {
+    const editor = getEditor();
+    if (!editor || !editor.isEditable) {
+      isVisible.value = false;
+      isActive.value = false;
+      canToggle.value = false;
+      return;
+    }
+    isActive.value = editor.isActive("blockquote");
+    canToggle.value = canToggleBlockquote(editor);
+    isVisible.value = shouldShowButton({ editor, hideWhenUnavailable });
+  };
+  (0, import_vue.watch)(
+    () => getEditor(),
+    (editor) => {
+      if (!editor)
+        return;
+      updateState();
+      editor.on("selectionUpdate", updateState);
+      editor.on("transaction", updateState);
+      (0, import_vue.onBeforeUnmount)(() => {
+        editor.off("selectionUpdate", updateState);
+        editor.off("transaction", updateState);
+      });
+    },
+    { immediate: true }
+  );
+  const handleToggle = () => {
+    const editor = getEditor();
+    if (toggleBlockquote(editor)) {
+      onToggled == null ? void 0 : onToggled();
+    }
+  };
+  return {
+    isVisible,
+    isActive,
+    handleToggle,
+    canToggle,
+    label: "Blockquote",
+    shortcutKeys: BLOCKQUOTE_SHORTCUT_KEY,
+    Icon: import_icons.BlockquoteIcon
+  };
+}

package/lib/rich-text-editor/menu-system/hooks/use-code-block.d.ts

@@ -0,0 +1,34 @@
+import type { Editor } from '@tiptap/vue-3';
+export declare const CODE_BLOCK_SHORTCUT_KEY = "mod+alt+c";
+export interface UseCodeBlockConfig {
+    editor: any;
+    hideWhenUnavailable?: boolean;
+    onToggled?: () => void;
+}
+export declare function canToggle(editor: Editor | null, turnInto?: boolean): boolean;
+export declare function toggleCodeBlock(editor: Editor | null): boolean;
+export declare function shouldShowButton(props: {
+    editor: Editor | null;
+    hideWhenUnavailable: boolean;
+}): boolean;
+export declare function useCodeBlock(config: UseCodeBlockConfig): {
+    isVisible: import("vue").Ref<boolean, boolean>;
+    isActive: import("vue").Ref<boolean, boolean>;
+    handleToggle: () => void;
+    canToggle: import("vue").Ref<boolean, boolean>;
+    label: string;
+    shortcutKeys: string;
+    Icon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        className: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        className: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>> & Readonly<{}>, {
+        className: string;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+};

package/lib/rich-text-editor/menu-system/hooks/use-code-block.js

@@ -0,0 +1,154 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+__export(stdin_exports, {
+  CODE_BLOCK_SHORTCUT_KEY: () => CODE_BLOCK_SHORTCUT_KEY,
+  canToggle: () => canToggle,
+  shouldShowButton: () => shouldShowButton,
+  toggleCodeBlock: () => toggleCodeBlock,
+  useCodeBlock: () => useCodeBlock
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_vue = require("vue");
+var import_state = require("@tiptap/pm/state");
+var import_tiptap_utils = require("../utils/tiptap-utils");
+var import_icons = require("../icons");
+const CODE_BLOCK_SHORTCUT_KEY = "mod+alt+c";
+function canToggle(editor, turnInto = true) {
+  var _a;
+  if (!editor || !editor.isEditable)
+    return false;
+  if (!(0, import_tiptap_utils.isNodeInSchema)("codeBlock", editor) || (0, import_tiptap_utils.isNodeTypeSelected)(editor, ["image"]))
+    return false;
+  if (!turnInto) {
+    return editor.can().toggleNode("codeBlock", "paragraph");
+  }
+  try {
+    const view = editor.view;
+    const state = view.state;
+    const selection = state.selection;
+    if (selection.empty || selection instanceof import_state.TextSelection) {
+      const pos = (_a = (0, import_tiptap_utils.findNodePosition)({
+        editor,
+        node: state.selection.$anchor.node(1)
+      })) == null ? void 0 : _a.pos;
+      if (!(0, import_tiptap_utils.isValidPosition)(pos))
+        return false;
+    }
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+function toggleCodeBlock(editor) {
+  var _a;
+  if (!editor || !editor.isEditable)
+    return false;
+  if (!canToggle(editor))
+    return false;
+  try {
+    const view = editor.view;
+    let state = view.state;
+    let tr = state.tr;
+    if (state.selection.empty || state.selection instanceof import_state.TextSelection) {
+      const pos = (_a = (0, import_tiptap_utils.findNodePosition)({
+        editor,
+        node: state.selection.$anchor.node(1)
+      })) == null ? void 0 : _a.pos;
+      if (!(0, import_tiptap_utils.isValidPosition)(pos))
+        return false;
+      tr = tr.setSelection(import_state.NodeSelection.create(state.doc, pos));
+      view.dispatch(tr);
+      state = view.state;
+    }
+    const selection = state.selection;
+    let chain = editor.chain().focus();
+    if (selection instanceof import_state.NodeSelection) {
+      chain = chain.clearNodes();
+    }
+    const toggle = editor.isActive("codeBlock") ? chain.setNode("paragraph") : chain.toggleNode("codeBlock", "paragraph");
+    toggle.run();
+    editor.chain().focus().selectTextblockEnd().run();
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+function shouldShowButton(props) {
+  const { editor, hideWhenUnavailable } = props;
+  if (!editor || !editor.isEditable)
+    return false;
+  if (!(0, import_tiptap_utils.isNodeInSchema)("codeBlock", editor))
+    return false;
+  if (hideWhenUnavailable && !editor.isActive("code")) {
+    return canToggle(editor);
+  }
+  return true;
+}
+function useCodeBlock(config) {
+  const { hideWhenUnavailable = false, onToggled } = config;
+  const isVisible = (0, import_vue.ref)(true);
+  const isActive = (0, import_vue.ref)(false);
+  const canToggleState = (0, import_vue.ref)(false);
+  const getEditor = () => {
+    const editor = config.editor;
+    return editor && "value" in editor ? editor.value : editor;
+  };
+  const updateState = () => {
+    const editor = getEditor();
+    if (!editor || !editor.isEditable) {
+      isVisible.value = false;
+      isActive.value = false;
+      canToggleState.value = false;
+      return;
+    }
+    isActive.value = editor.isActive("codeBlock");
+    canToggleState.value = canToggle(editor);
+    isVisible.value = shouldShowButton({ editor, hideWhenUnavailable });
+  };
+  (0, import_vue.watch)(
+    () => getEditor(),
+    (editor) => {
+      if (!editor)
+        return;
+      updateState();
+      editor.on("selectionUpdate", updateState);
+      editor.on("transaction", updateState);
+      (0, import_vue.onBeforeUnmount)(() => {
+        editor.off("selectionUpdate", updateState);
+        editor.off("transaction", updateState);
+      });
+    },
+    { immediate: true }
+  );
+  const handleToggle = () => {
+    const editor = getEditor();
+    if (toggleCodeBlock(editor)) {
+      onToggled == null ? void 0 : onToggled();
+    }
+  };
+  return {
+    isVisible,
+    isActive,
+    handleToggle,
+    canToggle: canToggleState,
+    label: "Code Block",
+    shortcutKeys: CODE_BLOCK_SHORTCUT_KEY,
+    Icon: import_icons.CodeBlockIcon
+  };
+}

package/lib/rich-text-editor/menu-system/hooks/use-color-highlight.d.ts

@@ -0,0 +1,46 @@
+import type { Editor } from '@tiptap/vue-3';
+export declare const COLOR_HIGHLIGHT_SHORTCUT_KEY = "mod+shift+h";
+export declare const HIGHLIGHT_COLORS: {
+    label: string;
+    value: string;
+    border: string;
+}[];
+export type HighlightColor = (typeof HIGHLIGHT_COLORS)[number];
+export declare function canColorHighlight(editor: Editor | null): boolean;
+export declare function isColorHighlightActive(editor: Editor | null, highlightColor?: string): boolean;
+export declare function removeHighlight(editor: Editor | null): boolean;
+export declare function shouldShowButton(props: {
+    editor: Editor | null;
+    hideWhenUnavailable: boolean;
+}): boolean;
+export declare function useColorHighlight(config: {
+    editor: any;
+    label?: string;
+    highlightColor?: string;
+    hideWhenUnavailable?: boolean;
+    onApplied?: (params: {
+        color: string;
+        label: string;
+    }) => void;
+}): {
+    isVisible: import("vue").Ref<boolean, boolean>;
+    isActive: import("vue").Ref<boolean, boolean>;
+    handleColorHighlight: () => void;
+    handleRemoveHighlight: () => void;
+    canHighlight: import("vue").Ref<boolean, boolean>;
+    label: string;
+    shortcutKeys: string;
+    Icon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        className: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        className: {
+            type: StringConstructor;
+            default: string;
+        };
+    }>> & Readonly<{}>, {
+        className: string;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+};