@lobehub/editor 1.5.10 → 1.6.0

package/es/common/sys.d.ts

@@ -4,10 +4,12 @@ export declare const isNode: boolean;
 export declare const isBrowser: boolean;
 export declare const macOSDetect: () => boolean;
 export declare const isMac: boolean;
+/** @deprecated 请使用 @/const/hotkey 中的 PLATFORM_MODIFIER.MOD */
 export declare const CONTROL_OR_META: {
     ctrlKey: boolean;
     metaKey: boolean;
 };
+/** @deprecated 请使用 @/const/hotkey 中的 PLATFORM_MODIFIER.MOD_SHIFT */
 export declare const CONTROL_OR_META_AND_SHIFT: {
     ctrlKey: boolean;
     metaKey: boolean;

package/es/common/sys.js

@@ -17,10 +17,15 @@ export var macOSDetect = function macOSDetect() {
   return false;
 };
 export var isMac = macOSDetect();
+
+// TODO: 这些常量已经迁移到 @/const/hotkey，建议使用新的统一定义
+// 为了向后兼容性保留，但应该逐步迁移到新的 PLATFORM_MODIFIER
+/** @deprecated 请使用 @/const/hotkey 中的 PLATFORM_MODIFIER.MOD */
 export var CONTROL_OR_META = {
   ctrlKey: !IS_APPLE,
   metaKey: IS_APPLE
 };
+/** @deprecated 请使用 @/const/hotkey 中的 PLATFORM_MODIFIER.MOD_SHIFT */
 export var CONTROL_OR_META_AND_SHIFT = {
   ctrlKey: !IS_APPLE,
   metaKey: IS_APPLE,

package/es/const/hotkey.d.ts

@@ -0,0 +1,3 @@
+import { HotkeyItem } from "../types/hotkey";
+export type HotkeyRegistration = HotkeyItem[];
+export declare const HOTKEYS_REGISTRATION: HotkeyRegistration;

package/es/const/hotkey.js

@@ -0,0 +1,58 @@
+import { COMMAND_PRIORITY_EDITOR } from 'lexical';
+import { HotkeyEnum, HotkeyScopeEnum, KeyEnum } from "../types/hotkey";
+var combineKeys = function combineKeys(keys) {
+  return keys.join('+');
+};
+export var HOTKEYS_REGISTRATION = [{
+  id: HotkeyEnum.Undo,
+  keys: combineKeys([KeyEnum.Mod, 'z']),
+  priority: COMMAND_PRIORITY_EDITOR,
+  scopes: [HotkeyScopeEnum.Format]
+}, {
+  id: HotkeyEnum.Redo,
+  keys: combineKeys([KeyEnum.Mod, 'y']),
+  priority: COMMAND_PRIORITY_EDITOR,
+  scopes: [HotkeyScopeEnum.Format]
+}, {
+  id: HotkeyEnum.Bold,
+  keys: combineKeys([KeyEnum.Mod, 'b']),
+  priority: COMMAND_PRIORITY_EDITOR,
+  scopes: [HotkeyScopeEnum.Format]
+}, {
+  id: HotkeyEnum.Italic,
+  keys: combineKeys([KeyEnum.Mod, 'i']),
+  priority: COMMAND_PRIORITY_EDITOR,
+  scopes: [HotkeyScopeEnum.Format]
+}, {
+  id: HotkeyEnum.Underline,
+  keys: combineKeys([KeyEnum.Mod, 'u']),
+  priority: COMMAND_PRIORITY_EDITOR,
+  scopes: [HotkeyScopeEnum.Format]
+}, {
+  id: HotkeyEnum.Strikethrough,
+  keys: combineKeys([KeyEnum.Mod, KeyEnum.Shift, 'x']),
+  priority: COMMAND_PRIORITY_EDITOR,
+  scopes: [HotkeyScopeEnum.Format]
+}, {
+  id: HotkeyEnum.CodeInline,
+  keys: combineKeys([KeyEnum.Mod, 'e']),
+  priority: COMMAND_PRIORITY_EDITOR,
+  scopes: [HotkeyScopeEnum.Format, HotkeyScopeEnum.Plugin]
+}, {
+  id: HotkeyEnum.Link,
+  keys: combineKeys([KeyEnum.Mod, 'k']),
+  priority: COMMAND_PRIORITY_EDITOR,
+  scopes: [HotkeyScopeEnum.Format, HotkeyScopeEnum.Plugin]
+},
+// List hotkeys
+{
+  id: HotkeyEnum.NumberList,
+  keys: combineKeys([KeyEnum.Mod, KeyEnum.Shift, '7']),
+  priority: COMMAND_PRIORITY_EDITOR,
+  scopes: [HotkeyScopeEnum.Insert, HotkeyScopeEnum.Plugin]
+}, {
+  id: HotkeyEnum.BulletList,
+  keys: combineKeys([KeyEnum.Mod, KeyEnum.Shift, '8']),
+  priority: COMMAND_PRIORITY_EDITOR,
+  scopes: [HotkeyScopeEnum.Insert, HotkeyScopeEnum.Plugin]
+}];

package/es/editor-kernel/kernel.d.ts

@@ -1,7 +1,9 @@
 import EventEmitter from 'eventemitter3';
 import { CommandListener, CommandListenerPriority, CommandPayloadType, DecoratorNode, LexicalCommand, LexicalEditor, LexicalNodeConfig } from 'lexical';
+import { HotkeyId } from "../types/hotkey";
 import { IEditor, IEditorKernel, IEditorPluginConstructor, IPlugin, IServiceID } from "../types/kernel";
 import { ILocaleKeys } from "../types/locale";
+import { HotkeyOptions, HotkeysEvent } from "../utils/hotkey/registerHotkey";
 import DataSource from './data-source';
 export declare class Kernel extends EventEmitter implements IEditorKernel {
     private static globalHotReloadMode;
@@ -87,5 +89,6 @@ export declare class Kernel extends EventEmitter implements IEditorKernel {
     cleanDocument(): void;
     private _commands;
     private _commandsClean;
+    registerHotkey(hotkeyId: HotkeyId, callback: (event: KeyboardEvent, handler: HotkeysEvent) => void, options?: HotkeyOptions): () => void;
     registerHighCommand<P>(command: LexicalCommand<P>, listener: CommandListener<P>, priority: CommandListenerPriority): () => void;
 }

package/es/editor-kernel/kernel.js

@@ -20,11 +20,12 @@ function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key i
 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 EventEmitter from 'eventemitter3';
-import { $getSelection, $isRangeSelection, COMMAND_PRIORITY_CRITICAL, createEditor } from 'lexical';
+import { $getSelection, $isRangeSelection, COMMAND_PRIORITY_CRITICAL, KEY_DOWN_COMMAND, createEditor } from 'lexical';
 import { get, merge, template, templateSettings } from 'lodash-es';
 import defaultLocale from "../locale";
 import { $isRootTextContentEmpty } from "../plugins/common/utils";
 import { createDebugLogger } from "../utils/debug";
+import { getHotkeyById, registerHotkey as _registerHotkey } from "../utils/hotkey/registerHotkey";
 import { registerEvent } from "./event";
 import { KernelPlugin } from "./plugin";
 import { createEmptyEditorState } from "./utils";
@@ -558,6 +559,24 @@ export var Kernel = /*#__PURE__*/function (_EventEmitter) {
     value: function cleanDocument() {
       this.setDocument('text', '');
     }
+  }, {
+    key: "registerHotkey",
+    value: function registerHotkey(hotkeyId, callback) {
+      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      var lexicalEditor = this.editor;
+      if (!lexicalEditor) {
+        throw new Error('Editor is not initialized.');
+      }
+      var hotkey = getHotkeyById(hotkeyId);
+      if (!hotkey) return function () {
+        return false;
+      };
+      if (options.enabled === false) return function () {
+        return false;
+      };
+      this.logger.debug("\u2328\uFE0F Hotkey: ".concat(hotkey.id));
+      return lexicalEditor.registerCommand(KEY_DOWN_COMMAND, _registerHotkey(hotkey, callback, options), hotkey.priority);
+    }
   }, {
     key: "registerHighCommand",
     value: function registerHighCommand(command, listener, priority) {

package/es/index.d.ts

@@ -14,6 +14,8 @@ export * from './plugins/slash';
 export * from './plugins/table';
 export * from './plugins/upload';
 export type { IEditor } from './types';
+export * from './types/hotkey';
+export { getHotkeyById } from './utils/hotkey/registerHotkey';
 export { browserDebug, createDebugLogger, debugLogger, debugLoggers, devConsole, prodSafeLogger, } from './utils/debug';
 export { Kernel } from './editor-kernel/kernel';
 /**

package/es/index.js

@@ -13,6 +13,10 @@ export * from "./plugins/mention";
 export * from "./plugins/slash";
 export * from "./plugins/table";
 export * from "./plugins/upload";
+// Hotkey utilities
+export * from "./types/hotkey";
+export { getHotkeyById } from "./utils/hotkey/registerHotkey";
+
 // Debug utilities
 export { browserDebug, createDebugLogger, debugLogger, debugLoggers, devConsole, prodSafeLogger } from "./utils/debug";
 

package/es/plugins/code/plugin/index.d.ts

@@ -1,5 +1,6 @@
 import { IEditorPluginConstructor } from "../../../types";
 export interface CodePluginOptions {
+    enableHotkey?: boolean;
     theme?: string;
 }
 export declare const CodePlugin: IEditorPluginConstructor<CodePluginOptions>;

package/es/plugins/code/plugin/index.js

@@ -18,28 +18,29 @@ import { IMarkdownShortCutService } from "../../markdown/service/shortcut";
 import { registerCodeInlineCommand } from "../command";
 import { CodeNode } from "../node/code";
 import { registerCodeInline } from "./registry";
-
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
-
 export var CodePlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
   _inherits(CodePlugin, _KernelPlugin);
   var _super = _createSuper(CodePlugin);
-  function CodePlugin(kernel, options) {
+  function CodePlugin(kernel, config) {
     var _this;
     _classCallCheck(this, CodePlugin);
     _this = _super.call(this);
     _this.kernel = kernel;
+    _this.config = config;
     kernel.registerNodes([CodeNode]);
     kernel.registerThemes({
-      codeInline: (options === null || options === void 0 ? void 0 : options.theme) || 'editor-code'
+      codeInline: (config === null || config === void 0 ? void 0 : config.theme) || 'editor-code'
     });
     return _this;
   }
   _createClass(CodePlugin, [{
     key: "onInit",
     value: function onInit(editor) {
+      var _this$config;
       this.register(registerCodeInlineCommand(editor));
-      this.register(registerCodeInline(editor, this.kernel));
+      this.register(registerCodeInline(editor, this.kernel, {
+        enableHotkey: (_this$config = this.config) === null || _this$config === void 0 ? void 0 : _this$config.enableHotkey
+      }));
       var markdownService = this.kernel.requireService(IMarkdownShortCutService);
       if (!markdownService) {
         return;

package/es/plugins/code/plugin/registry.d.ts

@@ -1,3 +1,6 @@
 import { LexicalEditor } from 'lexical';
 import { IEditorKernel } from "../../../types";
-export declare function registerCodeInline(editor: LexicalEditor, kernel: IEditorKernel): () => void;
+export interface CodeRegistryOptions {
+    enableHotkey?: boolean;
+}
+export declare function registerCodeInline(editor: LexicalEditor, kernel: IEditorKernel, options?: CodeRegistryOptions): () => void;

package/es/plugins/code/plugin/registry.js

@@ -2,13 +2,16 @@ function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
 import { mergeRegister } from '@lexical/utils';
-import { $getNodeByKey, COMMAND_PRIORITY_EDITOR, KEY_DOWN_COMMAND, isModifierMatch } from 'lexical';
-import { CONTROL_OR_META } from "../../../common/sys";
+import { $getNodeByKey } from 'lexical';
+import { HotkeyEnum } from "../../../types/hotkey";
 import { INSERT_CODEINLINE_COMMAND } from "../command";
 import { CodeNode } from "../node/code";
-export function registerCodeInline(editor, kernel) {
-  return mergeRegister(editor.registerUpdateListener(function (_ref) {
-    var mutatedNodes = _ref.mutatedNodes;
+export function registerCodeInline(editor, kernel, options) {
+  var _ref = options || {},
+    _ref$enableHotkey = _ref.enableHotkey,
+    enableHotkey = _ref$enableHotkey === void 0 ? true : _ref$enableHotkey;
+  return mergeRegister(editor.registerUpdateListener(function (_ref2) {
+    var mutatedNodes = _ref2.mutatedNodes;
     var codeChanged = mutatedNodes === null || mutatedNodes === void 0 ? void 0 : mutatedNodes.get(CodeNode);
     var keys = (codeChanged === null || codeChanged === void 0 ? void 0 : codeChanged.keys()) || [];
     editor.read(function () {
@@ -37,12 +40,11 @@ export function registerCodeInline(editor, kernel) {
         _iterator.f();
       }
     });
-  }), kernel.registerHighCommand(KEY_DOWN_COMMAND, function (payload) {
-    // ctrl + e
-    if (isModifierMatch(payload, CONTROL_OR_META) && payload.code === 'KeyE') {
-      payload.preventDefault();
-      return editor.dispatchCommand(INSERT_CODEINLINE_COMMAND, undefined);
-    }
-    return false;
-  }, COMMAND_PRIORITY_EDITOR));
+  }), kernel.registerHotkey(HotkeyEnum.CodeInline, function () {
+    return editor.dispatchCommand(INSERT_CODEINLINE_COMMAND, undefined);
+  }, {
+    enabled: enableHotkey,
+    preventDefault: true,
+    stopImmediatePropagation: true
+  }));
 }

package/es/plugins/code/react/CodeReactPlugin.js

@@ -12,7 +12,9 @@ import { MarkdownPlugin } from "../../markdown";
 import { CodePlugin } from "../plugin";
 import { useStyles } from "./style";
 var ReactCodePlugin = function ReactCodePlugin(_ref) {
-  var className = _ref.className;
+  var className = _ref.className,
+    _ref$enableHotkey = _ref.enableHotkey,
+    enableHotkey = _ref$enableHotkey === void 0 ? true : _ref$enableHotkey;
   var _useLexicalComposerCo = useLexicalComposerContext(),
     _useLexicalComposerCo2 = _slicedToArray(_useLexicalComposerCo, 1),
     editor = _useLexicalComposerCo2[0];
@@ -22,9 +24,10 @@ var ReactCodePlugin = function ReactCodePlugin(_ref) {
   useLayoutEffect(function () {
     editor.registerPlugin(MarkdownPlugin);
     editor.registerPlugin(CodePlugin, {
+      enableHotkey: enableHotkey,
       theme: cx(styles.codeInline, className)
     });
-  }, []);
+  }, [className, cx, enableHotkey, styles.codeInline]);
   return null;
 };
 ReactCodePlugin.displayName = 'ReactCodePlugin';

package/es/plugins/code/react/type.d.ts

@@ -1,3 +1,4 @@
 export interface ReactCodePluginProps {
     className?: string;
+    enableHotkey?: boolean;
 }

package/es/plugins/common/plugin/index.d.ts

@@ -1,5 +1,6 @@
 import { IEditorPluginConstructor } from "../../../types";
 export interface CommonPluginOptions {
+    enableHotkey?: boolean;
     theme?: {
         quote?: string;
         textBold?: string;

package/es/plugins/common/plugin/index.js

@@ -241,7 +241,10 @@ export var CommonPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
   }, {
     key: "onInit",
     value: function onInit(editor) {
-      this.registerClears(registerRichText(editor), registerDragonSupport(editor), registerHistory(editor, createEmptyHistoryState(), 300), registerHeaderBackspace(editor), registerRichKeydown(editor, this.kernel), registerCommands(editor), registerBreakLineClick(editor), registerCursorNode(editor));
+      var _this$config;
+      this.registerClears(registerRichText(editor), registerDragonSupport(editor), registerHistory(editor, createEmptyHistoryState(), 300), registerHeaderBackspace(editor), registerRichKeydown(editor, this.kernel, {
+        enableHotkey: (_this$config = this.config) === null || _this$config === void 0 ? void 0 : _this$config.enableHotkey
+      }), registerCommands(editor), registerBreakLineClick(editor), registerCursorNode(editor));
     }
   }, {
     key: "destroy",

package/es/plugins/common/plugin/register.d.ts

@@ -3,4 +3,7 @@ import { IEditor } from "../../../types";
 export declare function $getAdjacentNode(focus: PointType, isBackward: boolean): null | LexicalNode;
 export declare function $getDownUpNode(focus: PointType, isUp: boolean): null | LexicalNode;
 export declare function registerHeaderBackspace(editor: LexicalEditor): () => void;
-export declare function registerRichKeydown(editor: LexicalEditor, kernel: IEditor): () => void;
+export interface RichKeydownOptions {
+    enableHotkey?: boolean;
+}
+export declare function registerRichKeydown(editor: LexicalEditor, kernel: IEditor, options?: RichKeydownOptions): () => void;

package/es/plugins/common/plugin/register.js

@@ -1,8 +1,8 @@
 import { $isCodeHighlightNode, $isCodeNode } from '@lexical/code';
 import { $isHeadingNode } from '@lexical/rich-text';
 import { mergeRegister } from '@lexical/utils';
-import { $createNodeSelection, $createParagraphNode, $getRoot, $getSelection, $isDecoratorNode, $isElementNode, $isLineBreakNode, $isNodeSelection, $isRangeSelection, $isRootOrShadowRoot, $isTextNode, $setSelection, COMMAND_PRIORITY_EDITOR, COMMAND_PRIORITY_NORMAL, FORMAT_TEXT_COMMAND, KEY_ARROW_DOWN_COMMAND, KEY_ARROW_RIGHT_COMMAND, KEY_ARROW_UP_COMMAND, KEY_BACKSPACE_COMMAND, KEY_DOWN_COMMAND, isModifierMatch } from 'lexical';
-import { CONTROL_OR_META_AND_SHIFT } from "../../../common/sys";
+import { $createNodeSelection, $createParagraphNode, $getRoot, $getSelection, $isDecoratorNode, $isElementNode, $isLineBreakNode, $isNodeSelection, $isRangeSelection, $isRootOrShadowRoot, $isTextNode, $setSelection, COMMAND_PRIORITY_EDITOR, COMMAND_PRIORITY_NORMAL, FORMAT_TEXT_COMMAND, KEY_ARROW_DOWN_COMMAND, KEY_ARROW_RIGHT_COMMAND, KEY_ARROW_UP_COMMAND, KEY_BACKSPACE_COMMAND, REDO_COMMAND, UNDO_COMMAND } from 'lexical';
+import { HotkeyEnum } from "../../../types/hotkey";
 function resolveElement(element, isBackward, focusOffset) {
   var parent = element.getParent();
   var offset = focusOffset;
@@ -132,18 +132,47 @@ export function registerHeaderBackspace(editor) {
     return false;
   }, COMMAND_PRIORITY_NORMAL);
 }
-export function registerRichKeydown(editor, kernel) {
-  return mergeRegister(kernel.registerHighCommand(KEY_DOWN_COMMAND, function (payload) {
-    // ctrl + shift + x
-    if (isModifierMatch(payload, CONTROL_OR_META_AND_SHIFT) && payload.code === 'KeyX') {
-      // Handle the custom key combination
-      payload.stopImmediatePropagation();
-      payload.preventDefault();
-      editor.dispatchCommand(FORMAT_TEXT_COMMAND, 'strikethrough');
-      return true;
-    }
-    return false;
-  }, COMMAND_PRIORITY_EDITOR), kernel.registerHighCommand(KEY_ARROW_UP_COMMAND, function (event) {
+export function registerRichKeydown(editor, kernel, options) {
+  var _ref = options || {},
+    _ref$enableHotkey = _ref.enableHotkey,
+    enableHotkey = _ref$enableHotkey === void 0 ? true : _ref$enableHotkey;
+  return mergeRegister(kernel.registerHotkey(HotkeyEnum.Bold, function () {
+    return editor.dispatchCommand(FORMAT_TEXT_COMMAND, 'bold');
+  }, {
+    enabled: enableHotkey,
+    preventDefault: true,
+    stopImmediatePropagation: true
+  }), kernel.registerHotkey(HotkeyEnum.Italic, function () {
+    return editor.dispatchCommand(FORMAT_TEXT_COMMAND, 'italic');
+  }, {
+    enabled: enableHotkey,
+    preventDefault: true,
+    stopImmediatePropagation: true
+  }), kernel.registerHotkey(HotkeyEnum.Underline, function () {
+    return editor.dispatchCommand(FORMAT_TEXT_COMMAND, 'underline');
+  }, {
+    enabled: enableHotkey,
+    preventDefault: true,
+    stopImmediatePropagation: true
+  }), kernel.registerHotkey(HotkeyEnum.Strikethrough, function () {
+    return editor.dispatchCommand(FORMAT_TEXT_COMMAND, 'strikethrough');
+  }, {
+    enabled: enableHotkey,
+    preventDefault: true,
+    stopImmediatePropagation: true
+  }), kernel.registerHotkey(HotkeyEnum.Undo, function () {
+    return editor.dispatchCommand(UNDO_COMMAND, undefined);
+  }, {
+    enabled: enableHotkey,
+    preventDefault: true,
+    stopImmediatePropagation: true
+  }), kernel.registerHotkey(HotkeyEnum.Redo, function () {
+    return editor.dispatchCommand(REDO_COMMAND, undefined);
+  }, {
+    enabled: enableHotkey,
+    preventDefault: true,
+    stopImmediatePropagation: true
+  }), kernel.registerHighCommand(KEY_ARROW_UP_COMMAND, function (event) {
     var selection = $getSelection();
     if ($isNodeSelection(selection)) {
       // If selection is on a node, let's try and move selection

package/es/plugins/common/react/ReactPlainText.js

@@ -34,6 +34,8 @@ var ReactPlainText = /*#__PURE__*/memo(function (_ref) {
     onChange = _ref.onChange,
     className = _ref.className,
     variant = _ref.variant,
+    _ref$enableHotkey = _ref.enableHotkey,
+    enableHotkey = _ref$enableHotkey === void 0 ? true : _ref$enableHotkey,
     onKeyDown = _ref.onKeyDown,
     onFocus = _ref.onFocus,
     onBlur = _ref.onBlur,
@@ -79,9 +81,10 @@ var ReactPlainText = /*#__PURE__*/memo(function (_ref) {
   useLayoutEffect(function () {
     editor.registerPlugin(MarkdownPlugin);
     editor.registerPlugin(CommonPlugin, {
+      enableHotkey: enableHotkey,
       theme: restTheme ? _objectSpread(_objectSpread({}, themeStyles), restTheme) : themeStyles
     });
-  }, [editor, restTheme, themeStyles]);
+  }, [editor, enableHotkey, restTheme, themeStyles]);
   useEffect(function () {
     var _editor$getLexicalEdi;
     var container = editorContainerRef.current;

package/es/plugins/common/react/type.d.ts

@@ -10,6 +10,7 @@ export interface ReactPlainTextProps {
     autoFocus?: boolean;
     children: ReactElement<ReactEditorContentProps>;
     className?: string;
+    enableHotkey?: boolean;
     onBlur?: (props: {
         editor: IEditor;
         event: FocusEvent<HTMLDivElement>;

package/es/plugins/link/node/LinkNode.js

@@ -715,7 +715,5 @@ export function formatUrl(url) {
   else if (PHONE_NUMBER_REGEX.test(url)) {
     return "tel:".concat(url);
   }
-
-  // For everything else, return with https:// prefix
-  return "https://".concat(url);
+  return url;
 }

package/es/plugins/link/plugin/index.d.ts

@@ -1,8 +1,12 @@
 import { IEditorPluginConstructor } from "../../../types";
+import { LinkAttributes } from '../node/LinkNode';
 export interface LinkPluginOptions {
+    attributes?: LinkAttributes;
+    enableHotkey?: boolean;
     linkRegex?: RegExp;
     theme?: {
         link?: string;
     };
+    validateUrl?: (url: string) => boolean;
 }
 export declare const LinkPlugin: IEditorPluginConstructor<LinkPluginOptions>;

package/es/plugins/link/plugin/index.js

@@ -24,6 +24,7 @@ import { KernelPlugin } from "../../../editor-kernel/plugin";
 import { IMarkdownShortCutService } from "../../markdown";
 import { INSERT_LINK_COMMAND, registerLinkCommand } from "../command";
 import { $createLinkNode, $isLinkNode, AutoLinkNode, LinkNode } from "../node/LinkNode";
+import { registerLinkCommands } from "./registry";
 export var LinkPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
   _inherits(LinkPlugin, _KernelPlugin);
   var _super = _createSuper(LinkPlugin);
@@ -35,6 +36,7 @@ export var LinkPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
     // Register the link nodes
     _defineProperty(_assertThisInitialized(_this), "linkRegex", /^https?:\/\/\S+$/);
     _this.kernel = kernel;
+    _this.config = config;
     kernel.registerNodes([LinkNode, AutoLinkNode]);
     if (config !== null && config !== void 0 && config.theme) {
       kernel.registerThemes(config.theme);
@@ -71,8 +73,16 @@ export var LinkPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
   _createClass(LinkPlugin, [{
     key: "onInit",
     value: function onInit(editor) {
-      var _this2 = this;
+      var _this$config,
+        _this$config2,
+        _this$config3,
+        _this2 = this;
       this.register(registerLinkCommand(editor));
+      this.register(registerLinkCommands(editor, this.kernel, {
+        attributes: (_this$config = this.config) === null || _this$config === void 0 ? void 0 : _this$config.attributes,
+        enableHotkey: (_this$config2 = this.config) === null || _this$config2 === void 0 ? void 0 : _this$config2.enableHotkey,
+        validateUrl: (_this$config3 = this.config) === null || _this$config3 === void 0 ? void 0 : _this$config3.validateUrl
+      }));
       this.register(editor.registerCommand(PASTE_COMMAND, function (payload) {
         var clipboardData = payload.clipboardData;
         if (clipboardData && clipboardData.types && clipboardData.types.length === 1 && clipboardData.types[0] === 'text/plain') {

package/es/plugins/link/plugin/registry.d.ts

@@ -0,0 +1,9 @@
+import { LexicalEditor } from 'lexical';
+import { IEditorKernel } from "../../../types";
+import { LinkAttributes } from '../node/LinkNode';
+export interface LinkRegistryOptions {
+    attributes?: LinkAttributes;
+    enableHotkey?: boolean;
+    validateUrl?: (url: string) => boolean;
+}
+export declare function registerLinkCommands(editor: LexicalEditor, kernel: IEditorKernel, options?: LinkRegistryOptions): () => void;

package/es/plugins/link/plugin/registry.js

@@ -0,0 +1,108 @@
+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 { mergeRegister } from '@lexical/utils';
+import { $getSelection, $isRangeSelection, COMMAND_PRIORITY_LOW } from 'lexical';
+import { HotkeyEnum } from "../../../types/hotkey";
+import { $isLinkNode, $toggleLink, TOGGLE_LINK_COMMAND, formatUrl } from "../node/LinkNode";
+import { extractUrlFromText, getSelectedNode, sanitizeUrl } from "../utils";
+export function registerLinkCommands(editor, kernel, options) {
+  var _ref = options || {},
+    validateUrl = _ref.validateUrl,
+    attributes = _ref.attributes,
+    _ref$enableHotkey = _ref.enableHotkey,
+    enableHotkey = _ref$enableHotkey === void 0 ? true : _ref$enableHotkey;
+  var state = {
+    isLink: false
+  };
+  var registrations = [editor.registerUpdateListener(function () {
+    var selection = editor.read(function () {
+      return $getSelection();
+    });
+    if (!selection) return;
+    if ($isRangeSelection(selection)) {
+      editor.read(function () {
+        var node = getSelectedNode(selection);
+        var parent = node.getParent();
+        var isLink = $isLinkNode(parent) || $isLinkNode(node);
+        state.isLink = isLink;
+      });
+    } else {
+      state.isLink = false;
+    }
+  }), editor.registerCommand(TOGGLE_LINK_COMMAND, function (payload) {
+    if (payload === null) {
+      $toggleLink(payload);
+      return true;
+    } else if (typeof payload === 'string') {
+      if (validateUrl === undefined || validateUrl(payload)) {
+        $toggleLink(payload, attributes);
+        return true;
+      }
+      return false;
+    } else {
+      var _url = payload.url,
+        target = payload.target,
+        rel = payload.rel,
+        title = payload.title;
+      $toggleLink(_url, _objectSpread(_objectSpread({}, attributes), {}, {
+        rel: rel,
+        target: target,
+        title: title
+      }));
+      return true;
+    }
+  }, COMMAND_PRIORITY_LOW)];
+
+  // 注册热键，通过 enabled 选项控制
+  registrations.push(kernel.registerHotkey(HotkeyEnum.Link, function () {
+    var isLink = state.isLink;
+    if (isLink) {
+      editor.dispatchCommand(TOGGLE_LINK_COMMAND, null);
+      return;
+    }
+    var nextUrl = sanitizeUrl('https://');
+    var expandTo = null;
+    editor.getEditorState().read(function () {
+      var selection = $getSelection();
+      if ($isRangeSelection(selection)) {
+        if (!selection.isCollapsed()) {
+          var text = selection.getTextContent().trim();
+          var maybeUrl = formatUrl(text);
+          if (validateUrl !== null && validateUrl !== void 0 && validateUrl(maybeUrl)) {
+            nextUrl = maybeUrl;
+          }
+        } else {
+          var lineText = selection.anchor.getNode().getTextContent();
+          var found = extractUrlFromText(lineText);
+          if (found && validateUrl !== null && validateUrl !== void 0 && validateUrl(formatUrl(found.url))) {
+            nextUrl = formatUrl(found.url);
+            expandTo = {
+              index: found.index,
+              length: found.length
+            };
+          }
+        }
+      }
+    });
+    editor.update(function () {
+      if (expandTo) {
+        var selection = $getSelection();
+        if ($isRangeSelection(selection)) {
+          var anchorNode = selection.anchor.getNode();
+          selection.anchor.set(anchorNode.getKey(), expandTo.index, 'text');
+          selection.focus.set(anchorNode.getKey(), expandTo.index + expandTo.length, 'text');
+        }
+      }
+      editor.dispatchCommand(TOGGLE_LINK_COMMAND, nextUrl);
+    });
+  }, {
+    enabled: enableHotkey,
+    preventDefault: true,
+    stopPropagation: true
+  }));
+  return mergeRegister.apply(void 0, registrations);
+}