@lobehub/editor 1.19.1 → 1.20.0

package/es/index.d.ts

@@ -7,6 +7,7 @@ export * from './plugins/file';
 export * from './plugins/hr';
 export * from './plugins/image';
 export * from './plugins/link';
+export * from './plugins/link-highlight';
 export * from './plugins/list';
 export * from './plugins/markdown';
 export * from './plugins/math';
@@ -17,6 +18,7 @@ export * from './plugins/upload';
 export type { IEditor } from './types';
 export * from './types/hotkey';
 export { getHotkeyById } from './utils/hotkey/registerHotkey';
+export { isPureUrl, isValidUrl } from './utils/url';
 export { browserDebug, createDebugLogger, debugLogger, debugLoggers, devConsole, prodSafeLogger, } from './utils/debug';
 export { Kernel } from './editor-kernel/kernel';
 /**

package/es/index.js

@@ -7,6 +7,7 @@ export * from "./plugins/file";
 export * from "./plugins/hr";
 export * from "./plugins/image";
 export * from "./plugins/link";
+export * from "./plugins/link-highlight";
 export * from "./plugins/list";
 export * from "./plugins/markdown";
 export * from "./plugins/math";
@@ -18,6 +19,9 @@ export * from "./plugins/upload";
 export * from "./types/hotkey";
 export { getHotkeyById } from "./utils/hotkey/registerHotkey";
 
+// URL utilities
+export { isPureUrl, isValidUrl } from "./utils/url";
+
 // Debug utilities
 export { browserDebug, createDebugLogger, debugLogger, debugLoggers, devConsole, prodSafeLogger } from "./utils/debug";
 

package/es/plugins/link-highlight/command/index.d.ts

@@ -0,0 +1,3 @@
+import { LexicalEditor } from 'lexical';
+export declare const INSERT_LINK_HIGHLIGHT_COMMAND: import("lexical").LexicalCommand<undefined>;
+export declare function registerLinkHighlightCommand(editor: LexicalEditor): () => void;

package/es/plugins/link-highlight/command/index.js

@@ -0,0 +1,46 @@
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+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 { $getSelection, $insertNodes, $isRangeSelection, COMMAND_PRIORITY_EDITOR, createCommand } from 'lexical';
+import { $createCursorNode } from "../../common/node/cursor";
+import { $createLinkHighlightNode, $isLinkHighlightNode, getLinkHighlightNode } from "../node/link-highlight";
+export var INSERT_LINK_HIGHLIGHT_COMMAND = createCommand('INSERT_LINK_HIGHLIGHT_COMMAND');
+export function registerLinkHighlightCommand(editor) {
+  return editor.registerCommand(INSERT_LINK_HIGHLIGHT_COMMAND, function () {
+    editor.update(function () {
+      var selection = $getSelection();
+      if (!selection || !$isRangeSelection(selection)) {
+        return false;
+      }
+      var focusNode = selection.focus.getNode();
+      var anchorNode = selection.anchor.getNode();
+      var linkHighlight = getLinkHighlightNode(focusNode);
+      if (linkHighlight !== getLinkHighlightNode(anchorNode)) {
+        return false;
+      }
+      if ($isLinkHighlightNode(linkHighlight)) {
+        // Remove link highlight formatting
+        var _iterator = _createForOfIteratorHelper(linkHighlight.getChildren().slice(0)),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var node = _step.value;
+            linkHighlight.insertBefore(node);
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+        linkHighlight.remove();
+        return true;
+      }
+
+      // Create link highlight with selected text
+      var linkHighlightNode = $createLinkHighlightNode(selection.getTextContent());
+      $insertNodes([linkHighlightNode, $createCursorNode()]);
+      linkHighlightNode.select();
+    });
+    return true;
+  }, COMMAND_PRIORITY_EDITOR);
+}

package/es/plugins/link-highlight/index.d.ts

@@ -0,0 +1,4 @@
+export * from './command';
+export * from './node/link-highlight';
+export * from './plugin';
+export * from './react';

package/es/plugins/link-highlight/index.js

@@ -0,0 +1,5 @@
+export * from "./command";
+export * from "./node/link-highlight";
+export * from "./plugin";
+export * from "./react";
+// Note: utils are internal only and not exported to avoid conflicts with other plugins

package/es/plugins/link-highlight/node/link-highlight.d.ts

@@ -0,0 +1,29 @@
+import { EditorConfig, LexicalEditor, LexicalNode, SerializedElementNode } from 'lexical';
+import { CardLikeElementNode } from "../../common/node/cursor";
+export type SerializedLinkHighlightNode = SerializedElementNode;
+export declare class LinkHighlightNode extends CardLikeElementNode {
+    static getType(): string;
+    static clone(node: LinkHighlightNode): LinkHighlightNode;
+    static importJSON(serializedNode: SerializedLinkHighlightNode): LinkHighlightNode;
+    createDOM(config: EditorConfig, editor: LexicalEditor): HTMLElement;
+    /**
+     * Format URL to ensure it has proper protocol
+     */
+    private formatUrl;
+    getDOMSlot(element: HTMLElement): import("lexical").ElementDOMSlot<HTMLElement>;
+    canBeEmpty(): boolean;
+    isCardLike(): boolean;
+    isInline(): boolean;
+    canIndent(): boolean;
+    canInsertTextBefore(): boolean;
+    canInsertTextAfter(): boolean;
+    updateDOM(prevNode: LinkHighlightNode, dom: HTMLElement, config: EditorConfig): boolean;
+    /**
+     * Get the URL from the text content
+     */
+    getURL(): string;
+}
+export declare function $createLinkHighlightNode(textContent?: string): LinkHighlightNode;
+export declare function $isLinkHighlightNode(node: unknown): node is LinkHighlightNode;
+export declare function getLinkHighlightNode(node: LexicalNode): LexicalNode | null;
+export declare function $isSelectionInLinkHighlight(editor: LexicalEditor): boolean;

package/es/plugins/link-highlight/node/link-highlight.js

@@ -0,0 +1,223 @@
+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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+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 _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get.bind(); } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
+function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+/* eslint-disable @typescript-eslint/no-use-before-define */
+import { addClassNamesToElement } from '@lexical/utils';
+import { $applyNodeReplacement, $createTextNode, $getSelection, $isNodeSelection, $isRangeSelection } from 'lexical';
+import { $createCursorNode, $isCursorNode, CardLikeElementNode } from "../../common/node/cursor";
+export var LinkHighlightNode = /*#__PURE__*/function (_CardLikeElementNode) {
+  _inherits(LinkHighlightNode, _CardLikeElementNode);
+  var _super = _createSuper(LinkHighlightNode);
+  function LinkHighlightNode() {
+    _classCallCheck(this, LinkHighlightNode);
+    return _super.apply(this, arguments);
+  }
+  _createClass(LinkHighlightNode, [{
+    key: "createDOM",
+    value: function createDOM(config, editor) {
+      var _this = this;
+      var element = document.createElement('span');
+      // eslint-disable-next-line unicorn/prefer-dom-node-dataset
+      element.setAttribute('data-lexical-key', this.getKey());
+      var childContainer = document.createElement('ne-content');
+      element.append(childContainer);
+      addClassNamesToElement(element, config.theme.linkHighlight);
+
+      // Add click handler to open link in new window
+      element.addEventListener('click', function (event) {
+        // Only handle left click without modifier keys
+        if (event.button === 0 && !event.metaKey && !event.ctrlKey && !event.shiftKey) {
+          event.preventDefault();
+          event.stopPropagation();
+
+          // Read URL in editor context
+          editor.read(function () {
+            var url = _this.getURL();
+            if (url) {
+              // Format URL to ensure it has proper protocol
+              var formattedUrl = _this.formatUrl(url);
+              window.open(formattedUrl, '_blank', 'noopener,noreferrer');
+            }
+          });
+        }
+      });
+      return element;
+    }
+
+    /**
+     * Format URL to ensure it has proper protocol
+     */
+  }, {
+    key: "formatUrl",
+    value: function formatUrl(url) {
+      // Check if URL already has a protocol
+      if (/^[a-z][\d+.a-z-]*:/i.test(url)) {
+        return url;
+      }
+      // Check if it's a relative path
+      if (/^[#./]/.test(url)) {
+        return url;
+      }
+      // Check for email address
+      if (url.includes('@') && !url.startsWith('mailto:')) {
+        return "mailto:".concat(url);
+      }
+      // Check for phone number
+      if (/^\+?[\d\s()-]{5,}$/.test(url)) {
+        return "tel:".concat(url);
+      }
+      // Default to https
+      if (url.startsWith('www.')) {
+        return "https://".concat(url);
+      }
+      // If no protocol, assume https
+      if (!url.includes('://')) {
+        return "https://".concat(url);
+      }
+      return url;
+    }
+  }, {
+    key: "getDOMSlot",
+    value: function getDOMSlot(element) {
+      var neContent = element.querySelector('ne-content');
+      if (!neContent) {
+        throw new Error('LinkHighlightNode: ne-content not found');
+      }
+      return _get(_getPrototypeOf(LinkHighlightNode.prototype), "getDOMSlot", this).call(this, element).withElement(neContent);
+    }
+  }, {
+    key: "canBeEmpty",
+    value: function canBeEmpty() {
+      return false;
+    }
+  }, {
+    key: "isCardLike",
+    value: function isCardLike() {
+      return true;
+    }
+  }, {
+    key: "isInline",
+    value: function isInline() {
+      return true;
+    }
+  }, {
+    key: "canIndent",
+    value: function canIndent() {
+      return false;
+    }
+  }, {
+    key: "canInsertTextBefore",
+    value: function canInsertTextBefore() {
+      return true;
+    }
+  }, {
+    key: "canInsertTextAfter",
+    value: function canInsertTextAfter() {
+      return true;
+    }
+  }, {
+    key: "updateDOM",
+    value: function updateDOM(prevNode, dom, config) {
+      // Update the class names if theme has changed
+      var prevTheme = prevNode ? prevNode : null;
+      if (prevTheme !== this) {
+        addClassNamesToElement(dom, config.theme.linkHighlight);
+      }
+      return false;
+    }
+
+    /**
+     * Get the URL from the text content
+     */
+  }, {
+    key: "getURL",
+    value: function getURL() {
+      return this.getTextContent().trim();
+    }
+  }], [{
+    key: "getType",
+    value: function getType() {
+      return 'linkHighlight';
+    }
+  }, {
+    key: "clone",
+    value: function clone(node) {
+      return new LinkHighlightNode(node.__key);
+    }
+  }, {
+    key: "importJSON",
+    value: function importJSON(serializedNode) {
+      return $createLinkHighlightNode().updateFromJSON(serializedNode);
+    }
+  }]);
+  return LinkHighlightNode;
+}(CardLikeElementNode);
+export function $createLinkHighlightNode(textContent) {
+  var linkHighlightNode = $applyNodeReplacement(new LinkHighlightNode());
+  var cursorNode = $createCursorNode();
+  linkHighlightNode.append(cursorNode);
+  if (textContent) {
+    linkHighlightNode.append($createTextNode(textContent));
+  }
+  return linkHighlightNode;
+}
+export function $isLinkHighlightNode(node) {
+  return node instanceof LinkHighlightNode;
+}
+export function getLinkHighlightNode(node) {
+  if ($isCursorNode(node)) {
+    var parent = node.getParent();
+    if ($isLinkHighlightNode(parent)) {
+      return parent;
+    }
+    if ($isLinkHighlightNode(node.getNextSibling())) {
+      return node.getNextSibling();
+    }
+    if ($isLinkHighlightNode(node.getPreviousSibling())) {
+      return node.getPreviousSibling();
+    }
+    return null;
+  }
+  if ($isLinkHighlightNode(node.getParent())) {
+    return node.getParent();
+  }
+  return null;
+}
+export function $isSelectionInLinkHighlight(editor) {
+  return editor.read(function () {
+    var selection = $getSelection();
+    if (!selection) {
+      return false;
+    }
+    if ($isRangeSelection(selection)) {
+      var focusNode = selection.focus.getNode();
+      var anchorNode = selection.anchor.getNode();
+      var linkHighlight = getLinkHighlightNode(focusNode);
+      if (linkHighlight !== getLinkHighlightNode(anchorNode)) {
+        return false;
+      }
+      if ($isLinkHighlightNode(linkHighlight)) {
+        return true;
+      }
+      return false;
+    } else if ($isNodeSelection(selection)) {
+      var nodes = selection.getNodes();
+      if (nodes.length === 1 && $isLinkHighlightNode(nodes[0])) {
+        return true;
+      }
+    }
+    return false;
+  });
+}

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

@@ -0,0 +1,15 @@
+import type { IEditorPluginConstructor } from "../../../types";
+export interface LinkHighlightPluginOptions {
+    enableHotkey?: boolean;
+    /**
+     * Enable auto-highlight when pasting URLs
+     * @default true
+     */
+    enablePasteAutoHighlight?: boolean;
+    theme?: string;
+    /**
+     * Custom URL validation regex
+     */
+    urlRegex?: RegExp;
+}
+export declare const LinkHighlightPlugin: IEditorPluginConstructor<LinkHighlightPluginOptions>;

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

@@ -0,0 +1,187 @@
+var _class;
+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 _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+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; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+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 { $getSelection, $isRangeSelection, COMMAND_PRIORITY_NORMAL, PASTE_COMMAND } from 'lexical';
+import { INodeHelper } from "../../../editor-kernel/inode/helper";
+import { KernelPlugin } from "../../../editor-kernel/plugin";
+import { $createCursorNode, cursorNodeSerialized } from "../../common/node/cursor";
+import { IMarkdownShortCutService, MARKDOWN_READER_LEVEL_HIGH } from "../../markdown/service/shortcut";
+import { createDebugLogger } from "../../../utils/debug";
+import { registerLinkHighlightCommand } from "../command";
+import { $createLinkHighlightNode, LinkHighlightNode } from "../node/link-highlight";
+import { isValidUrl } from "../utils";
+import { registerLinkHighlight } from "./registry";
+export var LinkHighlightPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
+  _inherits(LinkHighlightPlugin, _KernelPlugin);
+  var _super = _createSuper(LinkHighlightPlugin);
+  function LinkHighlightPlugin(kernel, config) {
+    var _this;
+    _classCallCheck(this, LinkHighlightPlugin);
+    _this = _super.call(this);
+    _defineProperty(_assertThisInitialized(_this), "logger", createDebugLogger('plugin', 'link-highlight'));
+    _defineProperty(_assertThisInitialized(_this), "urlRegex", void 0);
+    _this.kernel = kernel;
+    _this.config = config;
+    kernel.registerNodes([LinkHighlightNode]);
+    kernel.registerThemes({
+      linkHighlight: (config === null || config === void 0 ? void 0 : config.theme) || 'editor-link-highlight'
+    });
+
+    // Default URL regex that matches http(s), mailto, tel, etc.
+    _this.urlRegex = (config === null || config === void 0 ? void 0 : config.urlRegex) || /^(?:https?:\/\/|mailto:|tel:)[^\s"<>[\\\]^`{|}]+|^www\.[^\s"<>[\\\]^`{|}]+/i;
+    _this.logger.debug('LinkHighlightPlugin initialized');
+    return _this;
+  }
+  _createClass(LinkHighlightPlugin, [{
+    key: "onInit",
+    value: function onInit(editor) {
+      var _this$config,
+        _this$config2,
+        _this2 = this;
+      this.register(registerLinkHighlightCommand(editor));
+      this.register(registerLinkHighlight(editor, this.kernel, {
+        enableHotkey: (_this$config = this.config) === null || _this$config === void 0 ? void 0 : _this$config.enableHotkey
+      }));
+
+      // Register paste handler for auto-highlighting URLs
+      if (((_this$config2 = this.config) === null || _this$config2 === void 0 ? void 0 : _this$config2.enablePasteAutoHighlight) !== false) {
+        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') {
+            var data = clipboardData.getData('text/plain').trim();
+            // Check if the pasted content is a valid URL
+            if (_this2.urlRegex.test(data) && isValidUrl(data)) {
+              payload.stopImmediatePropagation();
+              payload.preventDefault();
+              _this2.logger.debug('Auto-highlighting pasted URL:', data);
+
+              // Insert LinkHighlightNode directly
+              editor.update(function () {
+                var selection = $getSelection();
+                if ($isRangeSelection(selection)) {
+                  var linkHighlightNode = $createLinkHighlightNode(data);
+                  var cursorNode = $createCursorNode();
+                  selection.insertNodes([linkHighlightNode, cursorNode]);
+                }
+              });
+              return true;
+            }
+          }
+          return false;
+        }, COMMAND_PRIORITY_NORMAL));
+      }
+      var markdownService = this.kernel.requireService(IMarkdownShortCutService);
+      if (!markdownService) {
+        return;
+      }
+
+      // Register markdown writer for <link> format
+      markdownService.registerMarkdownWriter(LinkHighlightNode.getType(), function (ctx, node) {
+        ctx.appendLine("<".concat(node.getTextContent(), ">"));
+        return true;
+      });
+
+      // Register markdown shortcut for auto-link syntax: <url>
+      // Matches URLs wrapped in angle brackets like <https://example.com>
+      markdownService.registerMarkdownShortCut({
+        regExp: /<((?:https?:\/\/|mailto:|tel:|www\.)[^\s"<>[\\\]^`{|}]+)>\s?$/,
+        replace: function replace(textNode, match) {
+          var _match = _slicedToArray(match, 2),
+            url = _match[1];
+          if (!url || !isValidUrl(url)) {
+            return;
+          }
+          _this2.logger.debug('Converting markdown auto-link to LinkHighlightNode:', url);
+          var linkHighlightNode = $createLinkHighlightNode(url);
+          var cursorNode = $createCursorNode();
+          textNode.replace(linkHighlightNode);
+          linkHighlightNode.insertAfter(cursorNode);
+          return undefined;
+        },
+        trigger: '>',
+        type: 'text-match'
+      });
+
+      // Register HTML reader to handle <url> syntax that might be parsed as HTML
+      markdownService.registerMarkdownReader('html', function (node) {
+        var htmlValue = node.value || '';
+
+        // Check if this looks like an auto-link: <url>
+        var match = htmlValue.match(/^<((?:https?:\/\/|mailto:|tel:|www\.)[^\s"<>[\\\]^`{|}]+)>$/);
+        if (match) {
+          var url = match[1].replaceAll(/[\u200B-\u200D\u2060\uFEFF]/g, '');
+          _this2.logger.debug('Converting HTML auto-link to LinkHighlightNode:', url);
+          return [INodeHelper.createElementNode('linkHighlight', {
+            children: [cursorNodeSerialized, INodeHelper.createTextNode(url, {})],
+            direction: 'ltr',
+            format: '',
+            indent: 0,
+            type: 'linkHighlight',
+            version: 1
+          }), cursorNodeSerialized];
+        }
+
+        // Not an auto-link, let other handlers process it
+        return false;
+      }, MARKDOWN_READER_LEVEL_HIGH);
+
+      // Register markdown reader for 'link' type (auto-links like <url>)
+      // Use HIGH priority to handle auto-links before standard Link plugin
+      markdownService.registerMarkdownReader('link', function (node, children) {
+        // Check if this is an auto-link (URL and text are the same)
+        var url = node.url || '';
+
+        // Check if we have text children
+        if (!children || children.length === 0) {
+          return false;
+        }
+
+        // Get text content from children
+        var textContent = children.filter(function (child) {
+          return child.type === 'text';
+        }).map(function (child) {
+          return child.text || '';
+        }).join('');
+
+        // If text matches URL exactly (auto-link syntax), convert to LinkHighlightNode
+        if (textContent === url) {
+          _this2.logger.debug('Converting markdown auto-link to LinkHighlightNode:', url);
+          // Return array with LinkHighlightNode and trailing cursor
+          // Structure matches CodeNode: [node with internal cursor + text, external cursor]
+          return [INodeHelper.createElementNode('linkHighlight', {
+            children: [cursorNodeSerialized, INodeHelper.createTextNode(url, {})],
+            direction: 'ltr',
+            format: '',
+            indent: 0,
+            type: 'linkHighlight',
+            version: 1
+          }), cursorNodeSerialized];
+        }
+
+        // Otherwise, let standard Link plugin handle it
+        return false;
+      }, MARKDOWN_READER_LEVEL_HIGH // High priority to intercept auto-links
+      );
+      this.logger.debug('LinkHighlightPlugin initialized with markdown support');
+    }
+  }]);
+  return LinkHighlightPlugin;
+}(KernelPlugin), _defineProperty(_class, "pluginName", 'LinkHighlightPlugin'), _class);

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

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

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

@@ -0,0 +1,61 @@
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+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 } from 'lexical';
+import { $createCursorNode } from "../../common/node/cursor";
+import { HotkeyEnum } from "../../../types/hotkey";
+import { INSERT_LINK_HIGHLIGHT_COMMAND } from "../command";
+import { LinkHighlightNode } from "../node/link-highlight";
+export function registerLinkHighlight(editor, kernel, options) {
+  var _ref = options || {},
+    _ref$enableHotkey = _ref.enableHotkey,
+    enableHotkey = _ref$enableHotkey === void 0 ? true : _ref$enableHotkey;
+  return mergeRegister(
+  // Update listener to ensure cursor node before first LinkHighlightNode
+  editor.registerUpdateListener(function (_ref2) {
+    var mutatedNodes = _ref2.mutatedNodes;
+    var linkHighlightChanged = mutatedNodes === null || mutatedNodes === void 0 ? void 0 : mutatedNodes.get(LinkHighlightNode);
+    var keys = (linkHighlightChanged === null || linkHighlightChanged === void 0 ? void 0 : linkHighlightChanged.keys()) || [];
+    var needAddBefore = new Set();
+    editor.read(function () {
+      var _iterator = _createForOfIteratorHelper(keys),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var key = _step.value;
+          var node = $getNodeByKey(key);
+          if (!node) {
+            return;
+          }
+          var parent = node.getParent();
+          if ((parent === null || parent === void 0 ? void 0 : parent.getFirstChild()) === node) {
+            needAddBefore.add(node);
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    });
+    if (needAddBefore.size > 0) {
+      editor.update(function () {
+        needAddBefore.forEach(function (node) {
+          var prev = node.getPreviousSibling();
+          if (!prev) {
+            node.insertBefore($createCursorNode());
+          }
+        });
+      });
+    }
+  }),
+  // Hotkey for toggling link highlight (Ctrl+K or Cmd+K)
+  kernel.registerHotkey(HotkeyEnum.Link, function () {
+    return editor.dispatchCommand(INSERT_LINK_HIGHLIGHT_COMMAND, undefined);
+  }, {
+    enabled: enableHotkey,
+    preventDefault: true,
+    stopPropagation: true
+  }));
+}

package/es/plugins/link-highlight/react/ReactLinkHighlightPlugin.d.ts

@@ -0,0 +1,4 @@
+import { type FC } from 'react';
+import { ReactLinkHighlightPluginProps } from './type';
+declare const ReactLinkHighlightPlugin: FC<ReactLinkHighlightPluginProps>;
+export default ReactLinkHighlightPlugin;

package/es/plugins/link-highlight/react/ReactLinkHighlightPlugin.js

@@ -0,0 +1,35 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+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; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import { useLayoutEffect } from 'react';
+import { useLexicalComposerContext } from "../../../editor-kernel/react/react-context";
+import { MarkdownPlugin } from "../../markdown/plugin";
+import { LinkHighlightPlugin } from "../plugin";
+import { useStyles } from "./style";
+var ReactLinkHighlightPlugin = function ReactLinkHighlightPlugin(_ref) {
+  var className = _ref.className,
+    _ref$enableHotkey = _ref.enableHotkey,
+    enableHotkey = _ref$enableHotkey === void 0 ? true : _ref$enableHotkey,
+    _ref$enablePasteAutoH = _ref.enablePasteAutoHighlight,
+    enablePasteAutoHighlight = _ref$enablePasteAutoH === void 0 ? true : _ref$enablePasteAutoH;
+  var _useLexicalComposerCo = useLexicalComposerContext(),
+    _useLexicalComposerCo2 = _slicedToArray(_useLexicalComposerCo, 1),
+    editor = _useLexicalComposerCo2[0];
+  var _useStyles = useStyles(),
+    cx = _useStyles.cx,
+    styles = _useStyles.styles;
+  useLayoutEffect(function () {
+    editor.registerPlugin(MarkdownPlugin);
+    editor.registerPlugin(LinkHighlightPlugin, {
+      enableHotkey: enableHotkey,
+      enablePasteAutoHighlight: enablePasteAutoHighlight,
+      theme: cx(styles.linkHighlight, className)
+    });
+  }, [className, cx, enableHotkey, enablePasteAutoHighlight, editor, styles.linkHighlight]);
+  return null;
+};
+ReactLinkHighlightPlugin.displayName = 'ReactLinkHighlightPlugin';
+export default ReactLinkHighlightPlugin;

package/es/plugins/link-highlight/react/index.d.ts

@@ -0,0 +1 @@
+export { default as ReactLinkHighlightPlugin } from './ReactLinkHighlightPlugin';

package/es/plugins/link-highlight/react/index.js

@@ -0,0 +1 @@
+export { default as ReactLinkHighlightPlugin } from "./ReactLinkHighlightPlugin";

package/es/plugins/link-highlight/react/style.d.ts

@@ -0,0 +1,3 @@
+export declare const useStyles: (props?: unknown) => import("antd-style").ReturnStyles<{
+    linkHighlight: import("antd-style").SerializedStyles;
+}>;

package/es/plugins/link-highlight/react/style.js

@@ -0,0 +1,10 @@
+var _templateObject;
+function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
+import { createStyles } from 'antd-style';
+export var useStyles = createStyles(function (_ref) {
+  var css = _ref.css,
+    token = _ref.token;
+  return {
+    linkHighlight: css(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n      cursor: pointer;\n\n      display: inline;\n\n      padding: 2px;\n\n      color: ", ";\n      text-decoration: none;\n\n      transition: all 0.2s ease;\n\n      &:hover {\n        color: ", ";\n        text-decoration: underline;\n      }\n\n      ne-content {\n        display: inline;\n      }\n    "])), token.colorLink, token.colorLinkHover)
+  };
+});

package/es/plugins/link-highlight/react/type.d.ts

@@ -0,0 +1,13 @@
+export interface ReactLinkHighlightPluginProps {
+    className?: string;
+    /**
+     * Enable keyboard shortcut (Ctrl+K / Cmd+K)
+     * @default true
+     */
+    enableHotkey?: boolean;
+    /**
+     * Enable auto-highlight when pasting URLs
+     * @default true
+     */
+    enablePasteAutoHighlight?: boolean;
+}

package/es/plugins/link-highlight/react/type.js

@@ -0,0 +1 @@
+export {};

package/es/plugins/link-highlight/utils/index.d.ts

@@ -0,0 +1,17 @@
+export { isValidUrl } from "../../../utils/url";
+/**
+ * Sanitizes a URL to ensure it's safe to use
+ * @param url - The URL to sanitize
+ * @returns The sanitized URL
+ */
+export declare function sanitizeUrl(url: string): string;
+/**
+ * Extracts URL from text
+ * @param text - The text to extract URL from
+ * @returns The extracted URL information or null
+ */
+export declare function extractUrlFromText(text: string): {
+    index: number;
+    length: number;
+    url: string;
+} | null;

package/es/plugins/link-highlight/utils/index.js

@@ -0,0 +1,43 @@
+// Re-export shared URL validation from utils
+export { isValidUrl } from "../../../utils/url";
+
+// URL validation regex that matches common URL patterns for extraction
+var urlRegExp = new RegExp(/((([A-Za-z]{3,9}:(?:\/\/)?)(?:[\w$&+,:;=-]+@)?[\d.A-Za-z-]+|(?:www.|[\w$&+,:;=-]+@)[\d.A-Za-z-]+)((?:\/[%+./~\w-_]*)?\??[\w%&+.;=@-]*#?\w*)?)/);
+
+/**
+ * Sanitizes a URL to ensure it's safe to use
+ * @param url - The URL to sanitize
+ * @returns The sanitized URL
+ */
+export function sanitizeUrl(url) {
+  var SUPPORTED_URL_PROTOCOLS = new Set(['http:', 'https:', 'mailto:', 'sms:', 'tel:']);
+  try {
+    var parsedUrl = new URL(url);
+    if (!SUPPORTED_URL_PROTOCOLS.has(parsedUrl.protocol)) {
+      return 'about:blank';
+    }
+  } catch (_unused) {
+    return url;
+  }
+  return url;
+}
+
+/**
+ * Extracts URL from text
+ * @param text - The text to extract URL from
+ * @returns The extracted URL information or null
+ */
+export function extractUrlFromText(text) {
+  var _index;
+  var match = urlRegExp.exec(text);
+  if (!match) return null;
+  var raw = match[0];
+  var start = (_index = match.index) !== null && _index !== void 0 ? _index : text.indexOf(raw);
+  // Trim trailing punctuation that often follows inline links
+  var trimmed = raw.replace(/[\),\.:;\]]+$/, '');
+  return {
+    index: start,
+    length: trimmed.length,
+    url: trimmed
+  };
+}

package/es/plugins/markdown/index.d.ts

@@ -5,3 +5,4 @@ export type { MARKDOWN_READER_LEVEL } from './service/shortcut';
 export { IMarkdownShortCutService, MARKDOWN_READER_LEVEL_HIGH, MARKDOWN_READER_LEVEL_NORMAL, MARKDOWN_WRITER_LEVEL_MAX, } from './service/shortcut';
 export { isPunctuationChar } from './utils';
 export { detectCodeLanguage, detectLanguage } from './utils/detectLanguage';
+export { isPureUrl, isValidUrl } from './utils/url-validator';

package/es/plugins/markdown/index.js

@@ -3,4 +3,5 @@ export { MarkdownPlugin } from "./plugin";
 export { default as ReactMarkdownPlugin } from "./react";
 export { IMarkdownShortCutService, MARKDOWN_READER_LEVEL_HIGH, MARKDOWN_READER_LEVEL_NORMAL, MARKDOWN_WRITER_LEVEL_MAX } from "./service/shortcut";
 export { isPunctuationChar } from "./utils";
-export { detectCodeLanguage, detectLanguage } from "./utils/detectLanguage";
+export { detectCodeLanguage, detectLanguage } from "./utils/detectLanguage";
+export { isPureUrl, isValidUrl } from "./utils/url-validator";

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

@@ -23,6 +23,7 @@ import MarkdownDataSource from "../data-source/markdown-data-source";
 import { IMarkdownShortCutService, MarkdownShortCutService } from "../service/shortcut";
 import { canContainTransformableMarkdown } from "../utils";
 import { detectCodeLanguage, detectLanguage } from "../utils/detectLanguage";
+import { isValidUrl as isValidLinkUrl } from "../utils/url-validator";
 export var MarkdownPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
   _inherits(MarkdownPlugin, _KernelPlugin);
   var _super = _createSuper(MarkdownPlugin);
@@ -126,8 +127,10 @@ export var MarkdownPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
         var clipboardData = event.clipboardData;
         if (!clipboardData) return false;
 
-        // Get clipboard content
-        var text = clipboardData.getData('text/plain').trimEnd();
+        // Get clipboard content and clean BOM/zero-width characters
+        var rawText = clipboardData.getData('text/plain').trimEnd();
+        // Remove BOM, zero-width spaces, and other invisible characters
+        var text = rawText.replaceAll(/[\u200B-\u200D\u2060\uFEFF]/g, '');
         var html = clipboardData.getData('text/html').trimEnd();
 
         // If there's no text content, let Lexical handle it
@@ -206,6 +209,7 @@ export var MarkdownPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
         }
 
         // Check if markdown paste formatting is enabled (default: true)
+        // Note: URL pasting is handled by Link/LinkHighlight plugins themselves
 
         // Check if content is code (JSON, SQL, etc.) and should be inserted as code block
         var codeInfo = _this2.detectCodeContent(text);
@@ -270,6 +274,13 @@ export var MarkdownPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
           return true; // Command handled
         }
 
+        // Check if the pasted content is a pure URL
+        // If so, let Link/LinkHighlight plugins handle it
+        if (clipboardData.types.length === 1 && clipboardData.types[0] === 'text/plain' && isValidLinkUrl(text)) {
+          _this2.logger.debug('pure URL detected, letting Link/LinkHighlight plugins handle');
+          return false; // Let other plugins handle URL paste
+        }
+
         // Force plain text paste for external content
         event.preventDefault();
         event.stopPropagation();

package/es/plugins/markdown/utils/url-validator.d.ts

@@ -0,0 +1,4 @@
+/**
+ * URL validation utilities for detecting and validating URLs in pasted content
+ */
+export { isPureUrl, isValidUrl } from "../../../utils/url";

package/es/plugins/markdown/utils/url-validator.js

@@ -0,0 +1,6 @@
+/**
+ * URL validation utilities for detecting and validating URLs in pasted content
+ */
+
+// Re-export shared URL utilities from common utils
+export { isPureUrl, isValidUrl } from "../../../utils/url";

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

@@ -15,6 +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 { INSERT_LINK_HIGHLIGHT_COMMAND } from "../../../plugins/link-highlight/command";
+import { $isLinkHighlightNode } from "../../../plugins/link-highlight/node/link-highlight";
 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";
@@ -124,7 +126,8 @@ export function useEditorState(editor) {
       var elementDOM = editor === null || editor === void 0 || (_editor$getLexicalEdi = editor.getLexicalEditor()) === null || _editor$getLexicalEdi === void 0 ? void 0 : _editor$getLexicalEdi.getElementByKey(elementKey);
       var node = getSelectedNode(selection);
       var parent = node.getParent();
-      setIsLink($isLinkNode(parent) || $isLinkNode(node));
+      // Check for both Link and LinkHighlight nodes
+      setIsLink($isLinkNode(parent) || $isLinkNode(node) || $isLinkHighlightNode(parent) || $isLinkHighlightNode(node));
       var isCodeBlock = $isCodeNode(element) && $isCodeNode(focusElement) && elementKey === focusElement.getKey();
       setIsInCodeblok(isCodeBlock);
       setCodeblockLang(isCodeBlock ? element.getLanguage() : '');
@@ -258,7 +261,49 @@ export function useEditorState(editor) {
   var insertLink = useCallback(function () {
     var lexical = editor === null || editor === void 0 ? void 0 : editor.getLexicalEditor();
     if (!lexical) return;
+
+    // Detect which link type we're currently in
+    var inLinkNode = false;
+    var inLinkHighlightNode = false;
+    lexical.getEditorState().read(function () {
+      var selection = $getSelection();
+      if ($isRangeSelection(selection)) {
+        var node = getSelectedNode(selection);
+        var parent = node.getParent();
+        if ($isLinkNode(parent) || $isLinkNode(node)) {
+          inLinkNode = true;
+        }
+        if ($isLinkHighlightNode(parent) || $isLinkHighlightNode(node)) {
+          inLinkHighlightNode = true;
+        }
+      }
+    });
+
+    // If inside LinkHighlightNode, toggle it
+    if (inLinkHighlightNode) {
+      lexical.dispatchCommand(INSERT_LINK_HIGHLIGHT_COMMAND, undefined);
+      setIsLink(false);
+      return;
+    }
+
+    // If inside LinkNode, toggle it with standard Link plugin
+    if (inLinkNode) {
+      setIsLink(false);
+      lexical.dispatchCommand(TOGGLE_LINK_COMMAND, null);
+      return;
+    }
+
+    // Not in any link - try to insert new link
+    // Try LinkHighlight first, then fall back to standard Link if not handled
     if (!isLink) {
+      // First try INSERT_LINK_HIGHLIGHT_COMMAND
+      var linkHighlightHandled = lexical.dispatchCommand(INSERT_LINK_HIGHLIGHT_COMMAND, undefined);
+      if (linkHighlightHandled) {
+        setIsLink(true);
+        return;
+      }
+
+      // Fall back to standard Link plugin
       var nextUrl = sanitizeUrl('https://');
       var expandTo = null;
       lexical.getEditorState().read(function () {
@@ -283,7 +328,6 @@ export function useEditorState(editor) {
         }
       });
       setIsLink(true);
-      console.log(nextUrl);
       lexical.update(function () {
         if (expandTo) {
           var selection = $getSelection();
@@ -294,12 +338,8 @@ export function useEditorState(editor) {
             selection.focus.set(anchorNode.getKey(), expandTo.index + expandTo.length, 'text');
           }
         }
-        console.log(nextUrl);
         lexical.dispatchCommand(TOGGLE_LINK_COMMAND, validateUrl(nextUrl) ? nextUrl : sanitizeUrl('https://'));
       });
-    } else {
-      setIsLink(false);
-      lexical.dispatchCommand(TOGGLE_LINK_COMMAND, null);
     }
   }, [editor, isLink]);
   var insertMath = useCallback(function () {

package/es/utils/url.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Shared URL validation utilities
+ */
+/**
+ * Validates if a string is a valid URL
+ * @param url - The URL to validate
+ * @returns true if the URL is valid, false otherwise
+ */
+export declare function isValidUrl(url: string): boolean;
+/**
+ * Checks if text is a pure URL (single URL without other text)
+ * @param text - The text to check
+ * @returns true if text is a pure URL, false otherwise
+ */
+export declare function isPureUrl(text: string): boolean;

package/es/utils/url.js

@@ -0,0 +1,51 @@
+/**
+ * Shared URL validation utilities
+ */
+
+// URL validation regex that matches common URL patterns
+var URL_REGEX = new RegExp(/^(?:(?:https?|ftp):\/\/)?(?:www\.)?[\dA-Za-z][\w#%+./:=?@~-]*[\w#%+/=@~-]$/);
+
+/**
+ * Validates if a string is a valid URL
+ * @param url - The URL to validate
+ * @returns true if the URL is valid, false otherwise
+ */
+export function isValidUrl(url) {
+  if (!url || typeof url !== 'string') return false;
+  var trimmed = url.trim();
+
+  // Check if it matches URL pattern
+  if (URL_REGEX.test(trimmed)) {
+    return true;
+  }
+
+  // Check if it's a valid URL with protocol
+  try {
+    var urlObj = new URL(trimmed);
+    return !!urlObj.protocol && !!urlObj.hostname;
+  } catch (_unused) {
+    // Not a valid URL
+  }
+
+  // Check if it looks like a domain (e.g., "google.com")
+  if (/^[\da-z][\w#%+./:=?@~-]*\.[\w#%+/:=?@~-]+$/i.test(trimmed)) {
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Checks if text is a pure URL (single URL without other text)
+ * @param text - The text to check
+ * @returns true if text is a pure URL, false otherwise
+ */
+export function isPureUrl(text) {
+  if (!text || typeof text !== 'string') return false;
+  var trimmed = text.trim();
+
+  // Check if it's a single line
+  if (trimmed.includes('\n')) return false;
+
+  // Check if it's a valid URL
+  return isValidUrl(trimmed);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/editor",
-  "version": "1.19.1",
+  "version": "1.20.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",