@lobehub/editor 1.5.10 → 1.6.0

package/es/plugins/math/react/component/MathEditor.js

@@ -26,6 +26,9 @@ var MathEdit = /*#__PURE__*/memo(function (_ref) {
     _useState4 = _slicedToArray(_useState3, 2),
     value = _useState4[0],
     setValue = _useState4[1];
+  // 最近一次成功渲染（校验通过）的 LaTeX
+  var lastValidRef = useRef('');
+  var isInputValidRef = useRef(true);
   var _useState5 = useState(null),
     _useState6 = _slicedToArray(_useState5, 2),
     mathDOM = _useState6[0],
@@ -46,7 +49,7 @@ var MathEdit = /*#__PURE__*/memo(function (_ref) {
     _useLexicalComposerCo2 = _slicedToArray(_useLexicalComposerCo, 1),
     editor = _useLexicalComposerCo2[0];
 
-  // 实时更新节点内容
+  // 实时更新节点内容（仅当输入可渲染时才同步到 document）
   useEffect(function () {
     if (!mathNode) return;
 
@@ -55,6 +58,10 @@ var MathEdit = /*#__PURE__*/memo(function (_ref) {
       // 直接更新节点内容
       var lexicalEditor = editor.getLexicalEditor();
       if (lexicalEditor && !isUpdatingRef.current) {
+        // 仅在校验通过时更新文档；失败时不更新，保持最后一次成功渲染
+        if (!isInputValidRef.current) {
+          return;
+        }
         // 检查当前值是否与节点中的值不同，避免不必要的更新
         var currentCode = mathNode.code;
         if (currentCode === value) {
@@ -73,9 +80,9 @@ var MathEdit = /*#__PURE__*/memo(function (_ref) {
         // 延迟重置更新标志，确保更新监听器不会立即触发
         setTimeout(function () {
           isUpdatingRef.current = false;
-        }, 100);
+        }, 50);
       }
-    }, 100); // 增加防抖延迟
+    }, 50); // 增加防抖延迟
 
     return function () {
       return clearTimeout(timeoutId);
@@ -87,9 +94,10 @@ var MathEdit = /*#__PURE__*/memo(function (_ref) {
     if (!mathNode) return;
     var lexicalEditor = editor.getLexicalEditor();
     if (lexicalEditor) {
-      // 提交时总是使用原始的 value，不包含错误标记
+      // 提交时若当前不可渲染，则使用最近一次成功渲染的内容
+      var codeToCommit = isInputValidRef.current ? value : lastValidRef.current;
       lexicalEditor.dispatchCommand(UPDATE_MATH_COMMAND, {
-        code: value,
+        code: codeToCommit,
         key: mathNode.getKey()
       });
     }
@@ -180,6 +188,8 @@ var MathEdit = /*#__PURE__*/memo(function (_ref) {
         // 只有在不是同一个节点或值真正改变时才更新 value
         if (!isSameNode && node.code !== value) {
           setValue(node.code);
+          lastValidRef.current = node.code; // 切换节点时以节点里的内容作为最近一次有效值
+          isInputValidRef.current = true; // 重置有效状态
         }
         setMathDOM(editor.getElementByKey(node.getKey()));
         setIsBlockMode(node instanceof MathBlockNode);
@@ -211,6 +221,8 @@ var MathEdit = /*#__PURE__*/memo(function (_ref) {
         setMathNode(null);
         setMathDOM(null);
         setValue('');
+        lastValidRef.current = '';
+        isInputValidRef.current = true;
         setIsBlockMode(false);
         setIsOpen(false);
       }
@@ -226,11 +238,35 @@ var MathEdit = /*#__PURE__*/memo(function (_ref) {
     onCancel: handleCancel,
     onDelete: handleDelete,
     onSubmit: handleSubmit,
+    onValidationChange: function onValidationChange(isValid) {
+      isInputValidRef.current = isValid;
+      if (isValid) {
+        lastValidRef.current = value;
+      }
+    },
     onValueChange: setValue,
     prev: prev,
     value: value
   });
 
+  // 点击编辑器外部时关闭面板
+  useEffect(function () {
+    if (!isOpen) return;
+    var handlePointerDown = function handlePointerDown(event) {
+      var target = event.target;
+      if (!target) return;
+      var container = document.querySelector('[data-math-editor-container]');
+      if (container && container.contains(target)) return;
+      handleCancel();
+    };
+    document.addEventListener('mousedown', handlePointerDown);
+    document.addEventListener('touchstart', handlePointerDown);
+    return function () {
+      document.removeEventListener('mousedown', handlePointerDown);
+      document.removeEventListener('touchstart', handlePointerDown);
+    };
+  }, [isOpen, handleCancel]);
+
   // 如果有自定义渲染组件，使用它来包装 MathEditorContent
   if (renderComp) {
     return /*#__PURE__*/_jsx(_Fragment, {

package/es/plugins/math/react/component/MathEditorContainer.js

@@ -51,6 +51,7 @@ export var MathEditorContainer = /*#__PURE__*/memo(function (_ref) {
   }, [mathDOM]);
   return /*#__PURE__*/_jsx(Block, {
     className: styles.mathEditor,
+    "data-math-editor-container": true,
     ref: divRef,
     shadow: true,
     variant: 'outlined',

package/es/plugins/math/react/component/MathEditorContent.d.ts

@@ -16,6 +16,8 @@ export interface MathEditorContentProps {
     onDelete: () => void;
     /** 提交回调 */
     onSubmit: () => void;
+    /** 验证状态变化回调 */
+    onValidationChange?: (isValid: boolean) => void;
     /** 值变化回调 */
     onValueChange: (value: string) => void;
     /** 是否从前一个位置进入 */

package/es/plugins/math/react/component/MathEditorContent.js

@@ -23,6 +23,7 @@ export var MathEditorContent = /*#__PURE__*/memo(function (_ref) {
     onCancel = _ref.onCancel,
     onDelete = _ref.onDelete,
     onSubmit = _ref.onSubmit,
+    onValidationChange = _ref.onValidationChange,
     onValueChange = _ref.onValueChange,
     prev = _ref.prev,
     value = _ref.value;
@@ -57,6 +58,7 @@ export var MathEditorContent = /*#__PURE__*/memo(function (_ref) {
     var isEmpty = !value.trim();
     if (isEmpty) {
       setLatexError('');
+      onValidationChange === null || onValidationChange === void 0 || onValidationChange(true); // 空值视为有效
       return;
     }
 
@@ -67,18 +69,20 @@ export var MathEditorContent = /*#__PURE__*/memo(function (_ref) {
           displayMode: true,
           throwOnError: true
         });
-        // 验证成功：清除错误
+        // 验证成功：清除错误，通知父组件验证通过
         setLatexError('');
+        onValidationChange === null || onValidationChange === void 0 || onValidationChange(true);
       } catch (error) {
-        // 验证失败：设置错误信息
+        // 验证失败：设置错误信息，通知父组件验证失败
         var errorMessage = error instanceof Error ? error.message : 'LaTeX Parse Error';
         setLatexError(errorMessage);
+        onValidationChange === null || onValidationChange === void 0 || onValidationChange(false);
       }
     }, 50);
     return function () {
       return clearTimeout(timeoutId);
     };
-  }, [value, mathNode]);
+  }, [value, mathNode, onValidationChange]);
   var handleKeyDown = useCallback(function (e) {
     if (!mathNode) return;
     if (isModifierMatch(e, CONTROL_OR_META) && e.key === 'Enter') {

package/es/react/ChatInputActions/components/ActionItem.js

@@ -1,5 +1,11 @@
 'use client';
 
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 import { ActionIcon, Dropdown } from '@lobehub/ui';
 import { memo } from 'react';
 import ActionRender from "./ActionRender";
@@ -44,9 +50,9 @@ var ActionItem = /*#__PURE__*/memo(function (_ref) {
           size: 20
         },
         title: item.label,
-        tooltipProps: {
+        tooltipProps: _objectSpread({
           placement: 'top'
-        }
+        }, item.tooltipProps)
       })
     }, item.key);
   }

package/es/react/ChatInputActions/components/ActionRender.js

@@ -1,4 +1,10 @@
-var _excluded = ["wrapper", "icon", "key", "label", "onClick", "danger", "loading", "active"];
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+var _excluded = ["wrapper", "icon", "key", "label", "onClick", "danger", "loading", "active", "tooltipProps"];
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
 function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
 import { ActionIcon } from '@lobehub/ui';
@@ -30,6 +36,7 @@ var ActionRender = /*#__PURE__*/memo(function (_ref) {
     danger = _ref2.danger,
     loading = _ref2.loading,
     active = _ref2.active,
+    tooltipProps = _ref2.tooltipProps,
     itemRest = _objectWithoutProperties(_ref2, _excluded);
   if (item.children && /*#__PURE__*/isValidElement(item.children)) {
     if (!wrapper) return item.children;
@@ -54,9 +61,9 @@ var ActionRender = /*#__PURE__*/memo(function (_ref) {
       size: 20
     },
     title: label,
-    tooltipProps: {
+    tooltipProps: _objectSpread({
       placement: 'top'
-    }
+    }, tooltipProps)
   });
   if (!wrapper) return action;
   return wrapper(action);

package/es/react/ChatInputActions/type.d.ts

@@ -1,4 +1,4 @@
-import type { MenuInfo, MenuItemType } from '@lobehub/ui';
+import type { MenuInfo, MenuItemType, TooltipProps } from '@lobehub/ui';
 import type { ReactNode } from 'react';
 import type { FlexboxProps } from 'react-layout-kit';
 export type ChatInputActionEvent = Pick<MenuInfo, 'key' | 'keyPath' | 'domEvent'>;
@@ -6,6 +6,7 @@ export interface ActionItem extends MenuItemType {
     active?: boolean;
     alwaysDisplay?: boolean;
     children?: ReactNode;
+    tooltipProps?: TooltipProps;
     wrapper?: (dom: ReactNode) => ReactNode;
 }
 export type DividerItem = {

package/es/react/hooks/useEditorState/index.js

@@ -15,8 +15,8 @@ import { INSERT_CODEINLINE_COMMAND } from "../../../plugins/code";
 import { $isSelectionInCodeInline } from "../../../plugins/code/node/code";
 import { UPDATE_CODEBLOCK_LANG } from "../../../plugins/codeblock";
 import { $isRootTextContentEmpty } from "../../../plugins/common/utils";
-import { $isLinkNode, TOGGLE_LINK_COMMAND } from "../../../plugins/link/node/LinkNode";
-import { sanitizeUrl } from "../../../plugins/link/utils";
+import { $isLinkNode, TOGGLE_LINK_COMMAND, formatUrl } from "../../../plugins/link/node/LinkNode";
+import { extractUrlFromText, sanitizeUrl, validateUrl } from "../../../plugins/link/utils";
 import { INSERT_CHECK_LIST_COMMAND } from "../../../plugins/list";
 import { $createMathBlockNode, $createMathInlineNode } from "../../../plugins/math/node";
 import { $findTopLevelElement, formatParagraph, getSelectedNode } from "./utils";
@@ -238,19 +238,55 @@ export function useEditorState(editor) {
     });
   }, [editor, isCodeblock]);
   var insertLink = useCallback(function () {
+    var lexical = editor === null || editor === void 0 ? void 0 : editor.getLexicalEditor();
+    if (!lexical) return;
     if (!isLink) {
-      var _editor$getLexicalEdi4;
+      var nextUrl = sanitizeUrl('https://');
+      var expandTo = null;
+      lexical.getEditorState().read(function () {
+        var selection = $getSelection();
+        if ($isRangeSelection(selection)) {
+          var text = selection.getTextContent();
+          if (!selection.isCollapsed()) {
+            var maybeUrl = formatUrl(text.trim());
+            if (validateUrl(maybeUrl)) {
+              nextUrl = maybeUrl;
+            }
+          } else {
+            var lineText = selection.anchor.getNode().getTextContent();
+            var found = extractUrlFromText(lineText);
+            if (found && validateUrl(formatUrl(found.url))) {
+              expandTo = {
+                index: found.index,
+                length: found.length
+              };
+            }
+          }
+        }
+      });
       setIsLink(true);
-      editor === null || editor === void 0 || (_editor$getLexicalEdi4 = editor.getLexicalEditor()) === null || _editor$getLexicalEdi4 === void 0 || _editor$getLexicalEdi4.dispatchCommand(TOGGLE_LINK_COMMAND, sanitizeUrl('https://'));
+      console.log(nextUrl);
+      lexical.update(function () {
+        if (expandTo) {
+          var selection = $getSelection();
+          if ($isRangeSelection(selection)) {
+            var anchorNode = selection.anchor.getNode();
+            // Move selection to the URL range within the current text node
+            selection.anchor.set(anchorNode.getKey(), expandTo.index, 'text');
+            selection.focus.set(anchorNode.getKey(), expandTo.index + expandTo.length, 'text');
+          }
+        }
+        console.log(nextUrl);
+        lexical.dispatchCommand(TOGGLE_LINK_COMMAND, validateUrl(nextUrl) ? nextUrl : sanitizeUrl('https://'));
+      });
     } else {
-      var _editor$getLexicalEdi5;
       setIsLink(false);
-      editor === null || editor === void 0 || (_editor$getLexicalEdi5 = editor.getLexicalEditor()) === null || _editor$getLexicalEdi5 === void 0 || _editor$getLexicalEdi5.dispatchCommand(TOGGLE_LINK_COMMAND, null);
+      lexical.dispatchCommand(TOGGLE_LINK_COMMAND, null);
     }
   }, [editor, isLink]);
   var insertMath = useCallback(function () {
-    var _editor$getLexicalEdi6;
-    editor === null || editor === void 0 || (_editor$getLexicalEdi6 = editor.getLexicalEditor()) === null || _editor$getLexicalEdi6 === void 0 || _editor$getLexicalEdi6.update(function () {
+    var _editor$getLexicalEdi4;
+    editor === null || editor === void 0 || (_editor$getLexicalEdi4 = editor.getLexicalEditor()) === null || _editor$getLexicalEdi4 === void 0 || _editor$getLexicalEdi4.update(function () {
       var selection = $getSelection();
       if ($isRangeSelection(selection)) {
         // 检查当前上下文来决定插入行内还是块级数学公式

package/es/types/hotkey.d.ts

@@ -0,0 +1,71 @@
+import { CommandListenerPriority } from 'lexical';
+export declare const KeyEnum: {
+    readonly Alt: "alt";
+    readonly Backquote: "backquote";
+    readonly Backslash: "backslash";
+    readonly Backspace: "backspace";
+    readonly BracketLeft: "bracketleft";
+    readonly BracketRight: "bracketright";
+    readonly Comma: "comma";
+    readonly Ctrl: "ctrl";
+    readonly Down: "down";
+    readonly Enter: "enter";
+    readonly Equal: "equal";
+    readonly Esc: "esc";
+    readonly Left: "left";
+    readonly LeftClick: "left-click";
+    readonly LeftDoubleClick: "left-double-click";
+    readonly Meta: "meta";
+    readonly MiddleClick: "middle-click";
+    readonly Minus: "minus";
+    readonly Mod: "mod";
+    readonly Number: "1-9";
+    readonly Period: "period";
+    readonly Plus: "equal";
+    readonly QuestionMark: "slash";
+    readonly Quote: "quote";
+    readonly Right: "right";
+    readonly RightClick: "right-click";
+    readonly RightDoubleClick: "right-double-click";
+    readonly Semicolon: "semicolon";
+    readonly Shift: "shift";
+    readonly Slash: "slash";
+    readonly Space: "space";
+    readonly Tab: "tab";
+    readonly Up: "up";
+    readonly Zero: "0";
+};
+export declare const HotkeyEnum: {
+    readonly Bold: "bold";
+    readonly BulletList: "bulletList";
+    readonly CodeInline: "codeInline";
+    readonly Italic: "italic";
+    readonly Link: "link";
+    readonly Mention: "mention";
+    readonly NumberList: "numberList";
+    readonly Redo: "redo";
+    readonly Slash: "slash";
+    readonly Strikethrough: "strikethrough";
+    readonly Underline: "underline";
+    readonly Undo: "undo";
+};
+export declare const HotkeyScopeEnum: {
+    readonly Format: "format";
+    readonly Insert: "insert";
+    readonly Plugin: "plugin";
+    readonly Slash: "slash";
+};
+export type HotkeyId = (typeof HotkeyEnum)[keyof typeof HotkeyEnum];
+export type HotkeyScopeId = (typeof HotkeyScopeEnum)[keyof typeof HotkeyScopeEnum];
+export interface HotkeyItem {
+    id: HotkeyId;
+    keys: string;
+    priority: CommandListenerPriority;
+    scopes?: HotkeyScopeId[];
+}
+export type ModifierCombination = {
+    altKey?: boolean;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    shiftKey?: boolean;
+} | Record<string, never>;

package/es/types/hotkey.js

@@ -0,0 +1,71 @@
+export var KeyEnum = {
+  Alt: 'alt',
+  Backquote: 'backquote',
+  // `
+  Backslash: 'backslash',
+  // \
+  Backspace: 'backspace',
+  BracketLeft: 'bracketleft',
+  // [
+  BracketRight: 'bracketright',
+  // ]
+  Comma: 'comma',
+  // ,
+  Ctrl: 'ctrl',
+  Down: 'down',
+  Enter: 'enter',
+  Equal: 'equal',
+  // =
+  Esc: 'esc',
+  Left: 'left',
+  LeftClick: 'left-click',
+  LeftDoubleClick: 'left-double-click',
+  Meta: 'meta',
+  // Command on Mac, Win on Win
+  MiddleClick: 'middle-click',
+  Minus: 'minus',
+  // -
+  Mod: 'mod',
+  Number: '1-9',
+  // Command on Mac, Ctrl on Win
+  Period: 'period',
+  // .
+  Plus: 'equal',
+  // +
+  QuestionMark: 'slash',
+  // ?
+  Quote: 'quote',
+  // '
+  Right: 'right',
+  RightClick: 'right-click',
+  RightDoubleClick: 'right-double-click',
+  Semicolon: 'semicolon',
+  // ;
+  Shift: 'shift',
+  Slash: 'slash',
+  // /
+  Space: 'space',
+  Tab: 'tab',
+  Up: 'up',
+  Zero: '0'
+};
+export var HotkeyEnum = {
+  Bold: 'bold',
+  BulletList: 'bulletList',
+  CodeInline: 'codeInline',
+  Italic: 'italic',
+  Link: 'link',
+  Mention: 'mention',
+  NumberList: 'numberList',
+  Redo: 'redo',
+  Slash: 'slash',
+  Strikethrough: 'strikethrough',
+  Underline: 'underline',
+  Undo: 'undo'
+};
+export var HotkeyScopeEnum = {
+  Format: 'format',
+  Insert: 'insert',
+  Plugin: 'plugin',
+  Slash: 'slash'
+};

package/es/types/kernel.d.ts

@@ -1,5 +1,7 @@
 import type { CommandListener, CommandListenerPriority, CommandPayloadType, DecoratorNode, LexicalCommand, LexicalEditor, LexicalNodeConfig } from 'lexical';
 import type DataSource from "../editor-kernel/data-source";
+import { HotkeyId } from "./hotkey";
+import { HotkeyOptions, HotkeysEvent } from "../utils/hotkey/registerHotkey";
 import { ILocaleKeys } from './locale';
 export type Commands = Map<LexicalCommand<unknown>, Array<Set<CommandListener<unknown>>>>;
 export type CommandsClean = Map<LexicalCommand<unknown>, () => void>;
@@ -120,6 +122,13 @@ export interface IEditor {
      * @returns A teardown function to clean up the listener.
      */
     registerHighCommand<P>(command: LexicalCommand<P>, listener: CommandListener<P>, priority: CommandListenerPriority): () => void;
+    /**
+     * Register keyboard shortcut
+     * @param hotkey
+     * @param callback
+     * @param options
+     */
+    registerHotkey(hotkey: HotkeyId, callback: (event: KeyboardEvent, handler: HotkeysEvent) => void, options?: HotkeyOptions): () => void;
     /**
      * Register internationalization text
      * @param locale Internationalization text object

package/es/utils/hotkey/isHotkeyMatch.d.ts

@@ -0,0 +1 @@
+export declare const isHotkeyMatch: (event: KeyboardEvent, hotkey: string) => boolean;

package/es/utils/hotkey/isHotkeyMatch.js

@@ -0,0 +1,9 @@
+import { isModifierMatch } from 'lexical';
+import { mapCode, parseHotkey } from "./parseHotkeys";
+export var isHotkeyMatch = function isHotkeyMatch(event, hotkey) {
+  var keys = parseHotkey(hotkey);
+  var modifierMatch = isModifierMatch(event, keys.modifiers);
+  if (!modifierMatch) return false;
+  if (mapCode(event.code) !== keys.key) return false;
+  return true;
+};

package/es/utils/hotkey/parseHotkeys.d.ts

@@ -0,0 +1,6 @@
+import type { ModifierCombination } from "../../types/hotkey";
+export declare function mapCode(key: string): string;
+export declare function parseHotkey(hotkey: string): {
+    key?: string;
+    modifiers: ModifierCombination;
+};

package/es/utils/hotkey/parseHotkeys.js

@@ -0,0 +1,42 @@
+import { isApple } from "../../common/sys";
+var reservedModifierKeywords = new Set(['shift', 'alt', 'meta', 'mod', 'ctrl', 'control']);
+var mappedKeys = {
+  AltLeft: 'alt',
+  AltRight: 'alt',
+  ControlLeft: 'ctrl',
+  ControlRight: 'ctrl',
+  MetaLeft: 'meta',
+  MetaRight: 'meta',
+  OSLeft: 'meta',
+  OSRight: 'meta',
+  ShiftLeft: 'shift',
+  ShiftRight: 'shift',
+  down: 'arrowdown',
+  esc: 'escape',
+  left: 'arrowleft',
+  return: 'enter',
+  right: 'arrowright',
+  up: 'arrowup'
+};
+export function mapCode(key) {
+  return (mappedKeys[key.trim()] || key.trim()).toLowerCase().replace(/key|digit|numpad/, '');
+}
+export function parseHotkey(hotkey) {
+  var keys = [];
+  keys = hotkey.toLocaleLowerCase().split('+').map(function (k) {
+    return mapCode(k);
+  });
+  var modifiers = {
+    altKey: keys.includes('alt'),
+    ctrlKey: keys.includes('ctrl') || keys.includes('control') || (!isApple ? keys.includes('mod') : false),
+    metaKey: keys.includes('meta') || (isApple ? keys.includes('mod') : false),
+    shiftKey: keys.includes('shift')
+  };
+  var singleCharKeys = keys.find(function (k) {
+    return !reservedModifierKeywords.has(k);
+  });
+  return {
+    key: singleCharKeys,
+    modifiers: modifiers
+  };
+}

package/es/utils/hotkey/registerHotkey.d.ts

@@ -0,0 +1,15 @@
+import { HotkeyId, HotkeyItem, ModifierCombination } from "../../types/hotkey";
+export type HotkeysEvent = {
+    key?: string;
+    keys: string;
+    modifiers: ModifierCombination;
+    scopes?: string[];
+};
+export type HotkeyOptions = {
+    enabled?: boolean;
+    preventDefault?: boolean;
+    stopImmediatePropagation?: boolean;
+    stopPropagation?: boolean;
+};
+export declare const registerHotkey: (hotkey: HotkeyItem, callback: (event: KeyboardEvent, handler: HotkeysEvent) => void, options?: HotkeyOptions) => (e: KeyboardEvent) => boolean;
+export declare const getHotkeyById: (id: HotkeyId) => HotkeyItem;

package/es/utils/hotkey/registerHotkey.js

@@ -0,0 +1,32 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { HOTKEYS_REGISTRATION } from "../../const/hotkey";
+import { createDebugLogger } from "../debug";
+import { parseHotkey } from "./parseHotkeys";
+import { isHotkeyMatch } from "./isHotkeyMatch";
+var logger = createDebugLogger('hotkey');
+export var registerHotkey = function registerHotkey(hotkey, callback) {
+  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  return function (e) {
+    if (!isHotkeyMatch(e, hotkey.keys)) return false;
+    var keys = parseHotkey(hotkey.keys);
+    if (options.preventDefault) e.preventDefault();
+    if (options.stopPropagation) e.stopPropagation();
+    callback(e, _objectSpread(_objectSpread({
+      keys: hotkey.keys
+    }, keys), {}, {
+      scopes: hotkey.scopes
+    }));
+    logger.debug("\u2328\uFE0F Hotkey matched: ".concat(hotkey.id, " [").concat(hotkey.keys, "]"), hotkey);
+    return true;
+  };
+};
+export var getHotkeyById = function getHotkeyById(id) {
+  return HOTKEYS_REGISTRATION.find(function (hotkey) {
+    return hotkey.id === id;
+  });
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/editor",
-  "version": "1.5.10",
+  "version": "1.6.0",
   "description": "A powerful and extensible rich text editor built on Meta's Lexical framework, providing a modern editing experience with React integration.",
   "keywords": [
     "lobehub",
@@ -56,6 +56,7 @@
     "react-layout-kit": "^2.0.0",
     "react-merge-refs": "^3.0.2",
     "shiki": "^3.9.2",
+    "ts-key-enum": "^3.0.13",
     "use-merge-value": "^1.2.0"
   },
   "peerDependencies": {