@lobehub/editor 1.0.0

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

@@ -0,0 +1,8 @@
+import { IEditorPluginConstructor } from "../../../types";
+export interface LinkPluginOptions {
+    linkRegex?: RegExp;
+    theme?: {
+        link?: string;
+    };
+}
+export declare const LinkPlugin: IEditorPluginConstructor<LinkPluginOptions>;

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

@@ -0,0 +1,94 @@
+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 { $createTextNode, COMMAND_PRIORITY_NORMAL, PASTE_COMMAND } from 'lexical';
+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";
+export var LinkPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
+  _inherits(LinkPlugin, _KernelPlugin);
+  var _super = _createSuper(LinkPlugin);
+  function LinkPlugin(kernel, config) {
+    var _kernel$requireServic, _kernel$requireServic2;
+    var _this;
+    _classCallCheck(this, LinkPlugin);
+    _this = _super.call(this);
+    // Register the link nodes
+    _defineProperty(_assertThisInitialized(_this), "linkRegex", /^https?:\/\/\S+$/);
+    _this.kernel = kernel;
+    kernel.registerNodes([LinkNode, AutoLinkNode]);
+    if (config !== null && config !== void 0 && config.theme) {
+      kernel.registerThemes(config.theme);
+    }
+    if (config !== null && config !== void 0 && config.linkRegex) {
+      _this.linkRegex = config.linkRegex;
+    }
+    (_kernel$requireServic = kernel.requireService(IMarkdownShortCutService)) === null || _kernel$requireServic === void 0 || _kernel$requireServic.registerMarkdownShortCut({
+      regExp: /\[([^[]+)]\(([^\s()]+)(?:\s"((?:[^"]*\\")*[^"]*)"\s*)?\)\s?$/,
+      replace: function replace(textNode, match) {
+        var _match = _slicedToArray(match, 4),
+          linkText = _match[1],
+          linkUrl = _match[2],
+          linkTitle = _match[3];
+        var linkNode = $createLinkNode(linkUrl, {
+          title: linkTitle
+        });
+        var linkTextNode = $createTextNode(linkText);
+        linkTextNode.setFormat(textNode.getFormat());
+        linkNode.append(linkTextNode);
+        textNode.replace(linkNode);
+        return linkTextNode;
+      },
+      trigger: ')',
+      type: 'text-match'
+    });
+    (_kernel$requireServic2 = kernel.requireService(IMarkdownShortCutService)) === null || _kernel$requireServic2 === void 0 || _kernel$requireServic2.registerMarkdownWriter(LinkNode.getType(), function (ctx, node) {
+      if ($isLinkNode(node)) {
+        ctx.wrap('[', "](".concat(node.getURL(), ")"));
+      }
+    });
+    return _this;
+  }
+  _createClass(LinkPlugin, [{
+    key: "onInit",
+    value: function onInit(editor) {
+      var _this2 = this;
+      this.register(registerLinkCommand(editor));
+      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();
+          if (_this2.linkRegex.test(data)) {
+            payload.stopImmediatePropagation();
+            payload.preventDefault();
+            editor.dispatchCommand(INSERT_LINK_COMMAND, {
+              url: data
+            });
+            return true;
+          }
+        }
+        return false;
+      }, COMMAND_PRIORITY_NORMAL));
+    }
+  }]);
+  return LinkPlugin;
+}(KernelPlugin), _defineProperty(_class, "pluginName", 'LinkPlugin'), _class);

package/es/plugins/link/react/ReactLinkPlugin.d.ts

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

package/es/plugins/link/react/ReactLinkPlugin.js

@@ -0,0 +1,168 @@
+'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); }
+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 { computePosition, flip, offset, shift } from '@floating-ui/dom';
+import { mergeRegister } from '@lexical/utils';
+import { $getSelection, $isRangeSelection, COMMAND_PRIORITY_EDITOR, COMMAND_PRIORITY_LOW, COMMAND_PRIORITY_NORMAL, KEY_DOWN_COMMAND, isModifierMatch } from 'lexical';
+import { useLayoutEffect, useRef, useState } from 'react';
+import { CONTROL_OR_META } from "../../../common/sys";
+import { useLexicalEditor } from "../../../editor-kernel/react";
+import { useLexicalComposerContext } from "../../../editor-kernel/react/react-context";
+import { MarkdownPlugin } from "../../markdown";
+import { $isLinkNode, $toggleLink, HOVER_LINK_COMMAND, HOVER_OUT_LINK_COMMAND, TOGGLE_LINK_COMMAND } from "../node/LinkNode";
+import { LinkPlugin } from "../plugin";
+import { getSelectedNode, sanitizeUrl } from "../utils";
+import { EDIT_LINK_COMMAND, LinkEdit } from "./components/LinkEdit";
+import { Toolbar } from "./components/Toolbar";
+import { useStyles } from "./style";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Fragment as _Fragment } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+export var ReactLinkPlugin = function ReactLinkPlugin(_ref) {
+  var theme = _ref.theme,
+    validateUrl = _ref.validateUrl,
+    attributes = _ref.attributes;
+  var _useLexicalComposerCo = useLexicalComposerContext(),
+    _useLexicalComposerCo2 = _slicedToArray(_useLexicalComposerCo, 1),
+    editor = _useLexicalComposerCo2[0];
+  var _useState = useState(null),
+    _useState2 = _slicedToArray(_useState, 2),
+    linkNode = _useState2[0],
+    setLinkNode = _useState2[1];
+  var state = useRef({
+    isLink: false
+  });
+  var divRef = useRef(null);
+  var LinkRef = useRef(null);
+  var clearTimerRef = useRef(-1);
+  var _useStyles = useStyles(),
+    styles = _useStyles.styles;
+  useLayoutEffect(function () {
+    editor.registerPlugin(MarkdownPlugin);
+    editor.registerPlugin(LinkPlugin, {
+      theme: theme || styles
+    });
+  }, []);
+  useLexicalEditor(function (editor) {
+    return mergeRegister(editor.registerUpdateListener(function () {
+      var selection = editor.read(function () {
+        return $getSelection();
+      });
+      if (!selection) return;
+      if ($isRangeSelection(selection)) {
+        // Update links
+        editor.read(function () {
+          var node = getSelectedNode(selection);
+          var parent = node.getParent();
+          var isLink = $isLinkNode(parent) || $isLinkNode(node);
+          state.current.isLink = isLink;
+          if (isLink) {
+            var _linkNode = $isLinkNode(parent) ? parent : node;
+            editor.dispatchCommand(EDIT_LINK_COMMAND, {
+              linkNode: _linkNode,
+              linkNodeDOM: editor.getElementByKey(_linkNode.getKey())
+            });
+          } else {
+            editor.dispatchCommand(EDIT_LINK_COMMAND, {
+              linkNode: null,
+              linkNodeDOM: null
+            });
+          }
+        });
+      } else {
+        state.current.isLink = false;
+      }
+      if (divRef.current) {
+        divRef.current.style.left = '-9999px';
+        divRef.current.style.top = '-9999px';
+      }
+    }), 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), editor.registerCommand(KEY_DOWN_COMMAND, function (e) {
+      // ctrl + k / cmd + k
+      if (isModifierMatch(e, CONTROL_OR_META) && 'KeyK' === e.code) {
+        var isLink = state.current.isLink;
+        e.preventDefault();
+        e.stopPropagation();
+        editor.dispatchCommand(TOGGLE_LINK_COMMAND, isLink ? null : sanitizeUrl('https://'));
+        return true;
+      }
+      return false;
+    }, COMMAND_PRIORITY_EDITOR), editor.registerCommand(HOVER_LINK_COMMAND, function (payload) {
+      if (!payload.event.target || divRef.current === null) {
+        return false;
+      }
+      setLinkNode(payload.linkNode);
+      computePosition(payload.event.target, divRef.current, {
+        middleware: [offset(5), flip(), shift()],
+        placement: 'top-start'
+      }).then(function (_ref2) {
+        var x = _ref2.x,
+          y = _ref2.y;
+        if (!payload.event.target || divRef.current === null) {
+          return false;
+        }
+        LinkRef.current = payload.event.target;
+        // const url = editor.read(() => payload.linkNode.getURL());
+        divRef.current.style.left = "".concat(x, "px");
+        divRef.current.style.top = "".concat(y, "px");
+      });
+      return false;
+    }, COMMAND_PRIORITY_NORMAL), editor.registerCommand(HOVER_OUT_LINK_COMMAND, function () {
+      clearTimeout(clearTimerRef.current);
+      clearTimerRef.current = setTimeout(function () {
+        if (divRef.current) {
+          divRef.current.style.left = '-9999px';
+          divRef.current.style.top = '-9999px';
+        }
+      }, 300);
+      return true;
+    }, COMMAND_PRIORITY_NORMAL));
+  }, []);
+  return /*#__PURE__*/_jsxs(_Fragment, {
+    children: [/*#__PURE__*/_jsx("div", {
+      className: styles.editor_linkPlugin,
+      onMouseEnter: function onMouseEnter() {
+        clearTimeout(clearTimerRef.current);
+      },
+      ref: divRef,
+      children: /*#__PURE__*/_jsx(Toolbar, {
+        editor: editor.getLexicalEditor(),
+        linkNode: linkNode
+      })
+    }), /*#__PURE__*/_jsx(LinkEdit, {})]
+  });
+};
+ReactLinkPlugin.displayName = 'ReactLinkPlugin';
+export default ReactLinkPlugin;

package/es/plugins/link/react/components/LinkEdit.d.ts

@@ -0,0 +1,7 @@
+import { type FC } from 'react';
+import { LinkNode } from '../../node/LinkNode';
+export declare const EDIT_LINK_COMMAND: import("lexical").LexicalCommand<{
+    linkNode: LinkNode | null;
+    linkNodeDOM: HTMLElement | null;
+}>;
+export declare const LinkEdit: FC;

package/es/plugins/link/react/components/LinkEdit.js

@@ -0,0 +1,138 @@
+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 { computePosition, flip, offset, shift } from '@floating-ui/dom';
+import { mergeRegister } from '@lexical/utils';
+import { Icon, Input } from '@lobehub/ui';
+import { COMMAND_PRIORITY_EDITOR, COMMAND_PRIORITY_NORMAL, KEY_ESCAPE_COMMAND, KEY_TAB_COMMAND, createCommand } from 'lexical';
+import { LinkIcon } from 'lucide-react';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { useLexicalComposerContext, useLexicalEditor } from "../../../../editor-kernel/react";
+import { useStyles } from "../style";
+import { jsx as _jsx } from "react/jsx-runtime";
+export var EDIT_LINK_COMMAND = createCommand();
+export var LinkEdit = function LinkEdit() {
+  var divRef = useRef(null);
+  var linkNodeRef = useRef(null);
+  var linkInputRef = useRef(null);
+  var _useState = useState(''),
+    _useState2 = _slicedToArray(_useState, 2),
+    linkUrl = _useState2[0],
+    setLinkUrl = _useState2[1];
+  var _useState3 = useState(null),
+    _useState4 = _slicedToArray(_useState3, 2),
+    linkDom = _useState4[0],
+    setLinkDom = _useState4[1];
+  var _useLexicalComposerCo = useLexicalComposerContext(),
+    _useLexicalComposerCo2 = _slicedToArray(_useLexicalComposerCo, 1),
+    editor = _useLexicalComposerCo2[0];
+  var _useStyles = useStyles(),
+    styles = _useStyles.styles,
+    theme = _useStyles.theme;
+  useEffect(function () {
+    if (!linkDom || !divRef.current) {
+      return;
+    }
+    computePosition(linkDom, divRef.current, {
+      middleware: [offset(8), flip(), shift()],
+      placement: 'bottom-start'
+    }).then(function (_ref) {
+      var x = _ref.x,
+        y = _ref.y;
+      if (divRef.current) {
+        divRef.current.style.left = "".concat(x, "px");
+        divRef.current.style.top = "".concat(y, "px");
+      }
+    });
+  }, [linkDom]);
+  var handleKeyDown = useCallback(function (event) {
+    var lexicalEditor = editor.getLexicalEditor();
+    if (!linkNodeRef.current || !linkInputRef.current || !lexicalEditor) {
+      return;
+    }
+    var linkNode = linkNodeRef.current;
+    var input = linkInputRef.current;
+    var inputDOM = input.input;
+    if (event.key === 'Enter') {
+      event.preventDefault();
+      var currentURL = lexicalEditor.read(function () {
+        return linkNode.getURL();
+      });
+      if (currentURL !== inputDOM.value) {
+        lexicalEditor.update(function () {
+          linkNode.setURL(inputDOM.value);
+          lexicalEditor.focus();
+        });
+      } else {
+        lexicalEditor.focus();
+      }
+      return;
+    } else if (event.key === 'Escape' || event.key === 'Tab') {
+      event.preventDefault();
+      lexicalEditor.focus();
+      return;
+    }
+  }, [linkNodeRef, linkInputRef]);
+  useLexicalEditor(function (editor) {
+    return mergeRegister(editor.registerCommand(EDIT_LINK_COMMAND, function (payload) {
+      if (!payload.linkNode || !payload.linkNodeDOM) {
+        setLinkDom(null);
+        setLinkUrl('');
+        if (divRef.current) {
+          divRef.current.style.left = '-9999px';
+          divRef.current.style.top = '-9999px';
+        }
+        return false;
+      }
+      linkNodeRef.current = payload.linkNode;
+      setLinkUrl(payload.linkNode.getURL());
+      setLinkDom(payload.linkNodeDOM);
+      return true;
+    }, COMMAND_PRIORITY_EDITOR), editor.registerCommand(KEY_ESCAPE_COMMAND, function () {
+      if (divRef.current) {
+        divRef.current.style.left = '-9999px';
+        divRef.current.style.top = '-9999px';
+      }
+      linkNodeRef.current = null;
+      setLinkUrl('');
+      setLinkDom(null);
+      return true;
+    }, COMMAND_PRIORITY_EDITOR), editor.registerCommand(KEY_TAB_COMMAND, function (payload) {
+      if (linkNodeRef.current && linkInputRef.current) {
+        payload.stopImmediatePropagation();
+        payload.preventDefault();
+        linkInputRef.current.focus();
+        return true;
+      }
+      return false;
+    }, COMMAND_PRIORITY_NORMAL));
+  }, []);
+  return /*#__PURE__*/_jsx("div", {
+    className: styles.editor_linkEdit,
+    ref: divRef,
+    children: /*#__PURE__*/_jsx(Input, {
+      onChange: function onChange(e) {
+        // Handle link URL change
+        setLinkUrl(e.target.value);
+      },
+      onKeyDown: handleKeyDown,
+      placeholder: "https://enter-link-url",
+      prefix: /*#__PURE__*/_jsx(Icon, {
+        color: theme.colorTextDescription,
+        icon: LinkIcon
+      }),
+      ref: linkInputRef,
+      shadow: true,
+      style: {
+        background: theme.colorBgElevated,
+        maxWidth: '100%',
+        minWidth: 240
+      },
+      value: linkUrl,
+      variant: 'outlined'
+    })
+  });
+};

package/es/plugins/link/react/components/Toolbar.d.ts

@@ -0,0 +1,7 @@
+import { LexicalEditor } from 'lexical';
+import type { FC } from 'react';
+import { LinkNode } from '../../node/LinkNode';
+export declare const Toolbar: FC<{
+    editor: LexicalEditor;
+    linkNode: LinkNode | null;
+}>;

package/es/plugins/link/react/components/Toolbar.js

@@ -0,0 +1,63 @@
+import { ActionIconGroup } from '@lobehub/ui';
+import { EditIcon, ExternalLinkIcon, UnlinkIcon } from 'lucide-react';
+import { useTranslation } from "../../../../editor-kernel/react/useTranslation";
+import { TOGGLE_LINK_COMMAND } from "../../node/LinkNode";
+import { useStyles } from "../style";
+import { EDIT_LINK_COMMAND } from "./LinkEdit";
+import { jsx as _jsx } from "react/jsx-runtime";
+export var Toolbar = function Toolbar(_ref) {
+  var linkNode = _ref.linkNode,
+    editor = _ref.editor;
+  var _useStyles = useStyles(),
+    theme = _useStyles.theme;
+  var t = useTranslation();
+  var handleEdit = function handleEdit() {
+    // Edit link
+    if (linkNode) {
+      editor.dispatchCommand(EDIT_LINK_COMMAND, {
+        linkNode: linkNode,
+        linkNodeDOM: editor.getElementByKey(linkNode.getKey())
+      });
+    }
+  };
+  var handleRemove = function handleRemove() {
+    // Remove link
+    editor.dispatchCommand(TOGGLE_LINK_COMMAND, null);
+  };
+  var handleOpenLink = function handleOpenLink() {
+    // Open link in new window
+    if (linkNode) {
+      var url = editor.read(function () {
+        return linkNode.getURL();
+      });
+      window.open(url, '_blank');
+    }
+  };
+  return /*#__PURE__*/_jsx(ActionIconGroup, {
+    items: [{
+      icon: EditIcon,
+      key: 'edit',
+      label: t('link.edit'),
+      onClick: handleEdit
+    }, {
+      icon: ExternalLinkIcon,
+      key: 'openLink',
+      label: t('link.open'),
+      onClick: handleOpenLink
+    }, {
+      icon: UnlinkIcon,
+      key: 'unlink',
+      label: t('link.unlink'),
+      onClick: handleRemove
+    }],
+    shadow: true,
+    size: {
+      blockSize: 32,
+      size: 16
+    },
+    style: {
+      background: theme.colorBgElevated
+    },
+    variant: 'outlined'
+  });
+};

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

@@ -0,0 +1,2 @@
+export { default as ReactLinkPlugin } from './ReactLinkPlugin';
+export type * from './type';

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

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

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

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

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

@@ -0,0 +1,12 @@
+var _templateObject, _templateObject2;
+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;
+  var position = css(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n    position: absolute;\n    z-index: 999;\n    inset-block-start: -9999px;\n    inset-inline-start: -9999px;\n  "])));
+  return {
+    editor_linkEdit: position,
+    editor_linkPlugin: position,
+    link: css(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n      cursor: pointer;\n\n      margin-block: 1em;\n      margin-inline: 0;\n      padding: 2px;\n      border: none;\n    "])))
+  };
+});

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

@@ -0,0 +1,9 @@
+import { LinkAttributes } from "../node/LinkNode";
+export interface ReactLinkPluginProps {
+    attributes?: LinkAttributes;
+    className?: string;
+    theme?: {
+        link?: string;
+    };
+    validateUrl?: (url: string) => boolean;
+}

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

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

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

@@ -0,0 +1,4 @@
+import { ElementNode, RangeSelection, TextNode } from 'lexical';
+export declare function sanitizeUrl(url: string): string;
+export declare function validateUrl(url: string): boolean;
+export declare function getSelectedNode(selection: RangeSelection): TextNode | ElementNode;

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

@@ -0,0 +1,37 @@
+import { $isAtNodeEnd } from '@lexical/selection';
+var SUPPORTED_URL_PROTOCOLS = new Set(['http:', 'https:', 'mailto:', 'sms:', 'tel:']);
+export function sanitizeUrl(url) {
+  try {
+    var parsedUrl = new URL(url);
+    // eslint-disable-next-line no-script-url
+    if (!SUPPORTED_URL_PROTOCOLS.has(parsedUrl.protocol)) {
+      return 'about:blank';
+    }
+  } catch (_unused) {
+    return url;
+  }
+  return url;
+}
+
+// Source: https://stackoverflow.com/a/8234912/2013580
+var urlRegExp = new RegExp(/((([A-Za-z]{3,9}:(?:\/\/)?)(?:[\w$&+,:;=-]+@)?[\d.A-Za-z-]+|(?:www.|[\w$&+,:;=-]+@)[\d.A-Za-z-]+)((?:\/[%+./~\w-_]*)?\??[\w%&+.;=@-]*#?\w*)?)/);
+export function validateUrl(url) {
+  // TODO Fix UI for link insertion; it should never default to an invalid URL such as https://.
+  // Maybe show a dialog where they user can type the URL before inserting it.
+  return url === 'https://' || urlRegExp.test(url);
+}
+export function getSelectedNode(selection) {
+  var anchor = selection.anchor;
+  var focus = selection.focus;
+  var anchorNode = selection.anchor.getNode();
+  var focusNode = selection.focus.getNode();
+  if (anchorNode === focusNode) {
+    return anchorNode;
+  }
+  var isBackward = selection.isBackward();
+  if (isBackward) {
+    return $isAtNodeEnd(focus) ? anchorNode : focusNode;
+  } else {
+    return $isAtNodeEnd(anchor) ? anchorNode : focusNode;
+  }
+}

package/es/plugins/list/command/index.d.ts

@@ -0,0 +1 @@
+export { INSERT_ORDERED_LIST_COMMAND, INSERT_UNORDERED_LIST_COMMAND, REMOVE_LIST_COMMAND, UPDATE_LIST_START_COMMAND, } from '@lexical/list';

package/es/plugins/list/command/index.js

@@ -0,0 +1 @@
+export { INSERT_ORDERED_LIST_COMMAND, INSERT_UNORDERED_LIST_COMMAND, REMOVE_LIST_COMMAND, UPDATE_LIST_START_COMMAND } from '@lexical/list';

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

@@ -0,0 +1,3 @@
+export * from './command';
+export * from './plugin';
+export * from './react';

package/es/plugins/list/index.js

@@ -0,0 +1,3 @@
+export * from "./command";
+export * from "./plugin";
+export * from "./react";

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

@@ -0,0 +1,5 @@
+import { IEditorPluginConstructor } from "../../../types";
+export interface ListPluginOptions {
+    theme?: string;
+}
+export declare const ListPlugin: IEditorPluginConstructor<ListPluginOptions>;