@lobehub/editor 1.5.10 → 1.6.1

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,9 +58,20 @@ var MathEdit = /*#__PURE__*/memo(function (_ref) {
       // 直接更新节点内容
       var lexicalEditor = editor.getLexicalEditor();
       if (lexicalEditor && !isUpdatingRef.current) {
+        if (!isInputValidRef.current) {
+          var currentNode = lexicalEditor.getEditorState().read(function () {
+            return lexicalEditor.getElementByKey(mathNode.getKey());
+          });
+          if (currentNode) {
+            var writableNode = mathNode.getWritable();
+            writableNode.__code = value;
+          }
+          return;
+        }
+
         // 检查当前值是否与节点中的值不同，避免不必要的更新
         var currentCode = mathNode.code;
-        if (currentCode === value) {
+        if (value && currentCode && currentCode === value) {
           return; // 值相同，无需更新
         }
         isUpdatingRef.current = true;
@@ -66,16 +80,16 @@ var MathEdit = /*#__PURE__*/memo(function (_ref) {
             return lexicalEditor.getElementByKey(mathNode.getKey());
           });
           if (currentNode) {
-            var writableNode = mathNode.getWritable();
-            writableNode.__code = value;
+            var _writableNode = mathNode.getWritable();
+            _writableNode.__code = value;
           }
         });
         // 延迟重置更新标志，确保更新监听器不会立即触发
         setTimeout(function () {
           isUpdatingRef.current = false;
-        }, 100);
+        }, 50);
       }
-    }, 100); // 增加防抖延迟
+    }, 50); // 增加防抖延迟
 
     return function () {
       return clearTimeout(timeoutId);
@@ -87,9 +101,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 +195,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 +228,8 @@ var MathEdit = /*#__PURE__*/memo(function (_ref) {
         setMathNode(null);
         setMathDOM(null);
         setValue('');
+        lastValidRef.current = '';
+        isInputValidRef.current = true;
         setIsBlockMode(false);
         setIsOpen(false);
       }
@@ -226,16 +245,49 @@ 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;
+
+      // 支持多个容器（例如使用 renderComp 渲染到外部节点时，会有额外容器）
+      var containers = Array.from(document.querySelectorAll('[data-math-editor-container]'));
+      if (containers.some(function (el) {
+        return el && el.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) {
+    // 为自定义渲染的内容增加容器标记，便于外部点击检测
+    var wrapped = /*#__PURE__*/_jsx("div", {
+      "data-math-editor-container": true,
+      children: mathEditorContent
+    });
     return /*#__PURE__*/_jsx(_Fragment, {
       children: renderComp({
-        children: mathEditorContent,
+        children: wrapped,
         open: isOpen
       })
     });

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

@@ -13,33 +13,48 @@ export var MathEditorContainer = /*#__PURE__*/memo(function (_ref) {
   var _useStyles = useStyles(),
     styles = _useStyles.styles;
   useEffect(function () {
-    if (!mathDOM || !divRef.current) {
-      return;
-    }
-
-    // Inline 模式下使用默认的 floating-ui 定位
-    computePosition(mathDOM, divRef.current, {
-      middleware: [offset(8), flip(), shift()],
-      placement: 'bottom-start'
-    }).then(function (_ref2) {
-      var x = _ref2.x,
-        y = _ref2.y;
-      if (divRef.current) {
-        divRef.current.style.left = "".concat(x, "px");
-        divRef.current.style.top = "".concat(y, "px");
-        divRef.current.style.width = ''; // 重置宽度
-        onFocus === null || onFocus === void 0 || onFocus();
-      }
-      if (isBlockMode && divRef.current) {
-        // Block 模式下，获取主编辑器容器的位置和宽度
-        var editorContainer = mathDOM.closest('[contenteditable="true"]');
-        if (editorContainer) {
-          var containerRect = editorContainer.getBoundingClientRect();
-          divRef.current.style.width = "".concat(containerRect.width, "px");
-          onFocus === null || onFocus === void 0 || onFocus();
+    if (!mathDOM || !divRef.current) return;
+    var floating = divRef.current;
+    var updatePosition = function updatePosition() {
+      if (!mathDOM || !floating) return;
+      computePosition(mathDOM, floating, {
+        middleware: [offset(8), flip(), shift()],
+        placement: 'bottom-start'
+      }).then(function (_ref2) {
+        var x = _ref2.x,
+          y = _ref2.y;
+        if (!floating) return;
+        floating.style.left = "".concat(x, "px");
+        floating.style.top = "".concat(y, "px");
+        floating.style.width = '';
+        if (isBlockMode) {
+          var _editorContainer = mathDOM.closest('[contenteditable="true"]');
+          if (_editorContainer) {
+            var containerRect = _editorContainer.getBoundingClientRect();
+            floating.style.width = "".concat(containerRect.width, "px");
+          }
         }
-      }
+      });
+    };
+
+    // 监听尺寸变化，随内容变化重新定位
+    var resizeObserver = new ResizeObserver(function () {
+      return updatePosition();
     });
+    resizeObserver.observe(mathDOM);
+    resizeObserver.observe(floating);
+    var editorContainer = null;
+    if (isBlockMode) {
+      editorContainer = mathDOM.closest('[contenteditable="true"]');
+      if (editorContainer) resizeObserver.observe(editorContainer);
+    }
+
+    // 窗口尺寸变化时也重新定位
+    window.addEventListener('resize', updatePosition);
+    return function () {
+      resizeObserver.disconnect();
+      window.removeEventListener('resize', updatePosition);
+    };
   }, [mathDOM, prev, isBlockMode, onFocus]);
 
   // 当没有 mathDOM 时，隐藏容器
@@ -51,6 +66,10 @@ export var MathEditorContainer = /*#__PURE__*/memo(function (_ref) {
   }, [mathDOM]);
   return /*#__PURE__*/_jsx(Block, {
     className: styles.mathEditor,
+    "data-math-editor-container": true,
+    onClick: function onClick(e) {
+      e.preventDefault();
+    },
     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/plugins/math/react/component/MathInline.js

@@ -28,9 +28,12 @@ var MathInline = /*#__PURE__*/memo(function (_ref) {
     _useState2 = _slicedToArray(_useState, 2),
     isEditing = _useState2[0],
     setIsEditing = _useState2[1];
+  var isMathBlock = node instanceof MathBlockNode;
   useEffect(function () {
     if (ref.current && node.code) {
       Katex.render(node.code, ref.current, {
+        // 使用 displayMode 渲染块级公式
+        displayMode: node instanceof MathBlockNode,
         throwOnError: false
       });
     }
@@ -101,7 +104,9 @@ var MathInline = /*#__PURE__*/memo(function (_ref) {
   return /*#__PURE__*/_jsx("span", {
     className: className,
     ref: ref,
-    children: node.code ? node.code : /*#__PURE__*/_jsx(Placeholder, {})
+    children: node.code ? node.code : /*#__PURE__*/_jsx(Placeholder, {
+      mathBlock: isMathBlock
+    })
   });
 });
 export default MathInline;

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

@@ -1,3 +1,5 @@
 /// <reference types="react" />
-declare const Placeholder: import("react").MemoExoticComponent<() => import("react/jsx-runtime").JSX.Element>;
+declare const Placeholder: import("react").NamedExoticComponent<{
+    mathBlock?: boolean | undefined;
+}>;
 export default Placeholder;

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

@@ -1,13 +1,15 @@
 import { Text } from '@lobehub/ui';
 import { memo } from 'react';
+import { Center } from 'react-layout-kit';
 import { useTranslation } from "../../../../editor-kernel/react/useTranslation";
 import { jsx as _jsx } from "react/jsx-runtime";
-var Placeholder = /*#__PURE__*/memo(function () {
+var Placeholder = /*#__PURE__*/memo(function (_ref) {
+  var mathBlock = _ref.mathBlock;
   var t = useTranslation();
-  return /*#__PURE__*/_jsx(Text, {
+  var node = /*#__PURE__*/_jsx(Text, {
     as: 'span',
     className: 'katex',
-    fontSize: '1em',
+    fontSize: mathBlock ? '1.2em' : '1em',
     style: {
       fontStyle: 'italic',
       paddingInline: '0.2em'
@@ -15,5 +17,11 @@ var Placeholder = /*#__PURE__*/memo(function () {
     type: 'secondary',
     children: t('math.placeholder')
   });
+  if (!mathBlock) return node;
+  return /*#__PURE__*/_jsx(Center, {
+    padding: 18,
+    width: '100%',
+    children: node
+  });
 });
 export default Placeholder;

package/es/plugins/math/react/style.js

@@ -8,8 +8,8 @@ export var useStyles = createStyles(function (_ref) {
     token = _ref.token;
   var latex = css(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n    cursor: pointer;\n    user-select: none;\n    font-size: 1em;\n\n    .katex-error {\n      color: ", " !important;\n    }\n\n    .katex-html {\n      overflow: auto hidden;\n      padding: 3px;\n\n      .base {\n        margin-block: 0;\n        margin-inline: auto;\n      }\n\n      .tag {\n        position: relative !important;\n        display: inline-block;\n        padding-inline-start: 0.5rem;\n      }\n    }\n\n    &.selected {\n      color: #000;\n      background: ", ";\n    }\n\n    &:hover {\n      background: ", ";\n    }\n\n    &.editing {\n      background: ", ";\n    }\n\n    &:has(.katex-error) {\n      background: ", ";\n    }\n  "])), token.colorError, token.yellow, token.colorFillTertiary, token.colorFillTertiary, token.colorErrorBg);
   return {
-    mathInline: cx(latex, css(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n        display: inline-block;\n      "])))),
-    mathBlock: cx(latex, css(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n        overflow: auto hidden;\n        display: block;\n        white-space: nowrap;\n      "])))),
+    mathInline: cx(latex, css(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n        display: inline-block;\n        border-radius: calc(var(--lobe-markdown-border-radius) * 0.5px);\n      "])))),
+    mathBlock: cx(latex, css(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n        overflow: auto hidden;\n        display: block;\n        border-radius: calc(var(--lobe-markdown-border-radius) * 1px);\n        white-space: nowrap;\n      "])))),
     mathEditor: css(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["\n      position: absolute;\n      z-index: 999;\n      inset-block-start: -9999px;\n      inset-inline-start: -9999px;\n\n      width: 320px;\n\n      background: ", ";\n\n      textarea {\n        width: 100%;\n\n        font-family: ", ";\n        font-size: 13px;\n\n        background: transparent !important;\n\n        transition: none !important;\n      }\n    "])), token.colorBgElevated, token.fontFamilyCode),
     mathEditorFooter: css(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral(["\n      border-block-start: 1px solid ", ";\n      background: ", ";\n    "])), token.colorBorderSecondary, token.colorFillQuaternary)
   };

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'
+};