@lobehub/editor 1.31.1 → 1.32.0

package/es/const/hotkey.js

@@ -40,7 +40,7 @@ export var HOTKEYS_REGISTRATION = [{
   scopes: [HotkeyScopeEnum.Format, HotkeyScopeEnum.Plugin]
 }, {
   id: HotkeyEnum.Link,
-  keys: combineKeys([KeyEnum.Mod, 'k']),
+  keys: combineKeys([KeyEnum.Mod, KeyEnum.Shift, 'k']),
   priority: COMMAND_PRIORITY_EDITOR,
   scopes: [HotkeyScopeEnum.Format, HotkeyScopeEnum.Plugin]
 },

package/es/index.d.ts

@@ -7,6 +7,7 @@ export * from './plugins/common';
 export * from './plugins/file';
 export * from './plugins/hr';
 export * from './plugins/image';
+export * from './plugins/inode';
 export * from './plugins/link';
 export * from './plugins/link-highlight';
 export * from './plugins/list';

package/es/index.js

@@ -7,6 +7,7 @@ export * from "./plugins/common";
 export * from "./plugins/file";
 export * from "./plugins/hr";
 export * from "./plugins/image";
+export * from "./plugins/inode";
 export * from "./plugins/link";
 export * from "./plugins/link-highlight";
 export * from "./plugins/list";

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

@@ -3,9 +3,10 @@ function _regeneratorRuntime() { "use strict"; /*! regenerator-runtime -- Copyri
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
 function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
 import { $isCodeHighlightNode, $isCodeNode } from '@lexical/code';
-import { $isHeadingNode } from '@lexical/rich-text';
+import { $isHeadingNode, QuoteNode } 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, REDO_COMMAND, UNDO_COMMAND } from 'lexical';
+import { $createNodeSelection, $createParagraphNode, $getRoot, $getSelection, $isDecoratorNode, $isElementNode, $isLineBreakNode, $isNodeSelection, $isRangeSelection, $isRootOrShadowRoot, $isTextNode, $setSelection, COMMAND_PRIORITY_EDITOR, COMMAND_PRIORITY_LOW, 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 { $closest } from "../../../editor-kernel";
 import { HotkeyEnum } from "../../../types/hotkey";
 function resolveElement(element, isBackward, focusOffset) {
   var parent = element.getParent();
@@ -246,6 +247,40 @@ export function registerRichKeydown(editor, kernel, options) {
     }
     return false;
   }, COMMAND_PRIORITY_EDITOR), kernel.registerHighCommand(KEY_ARROW_DOWN_COMMAND, function (event) {
+    var selection = $getSelection();
+    if ($isRangeSelection(selection)) {
+      if (!selection.isCollapsed()) {
+        return false;
+      }
+      var focusNode = selection.focus.getNode();
+      var quotaNode = $closest(focusNode, function (node) {
+        return node.getType() === QuoteNode.getType();
+      });
+      if (!quotaNode) {
+        return false;
+      }
+      if (quotaNode.getNextSibling()) {
+        return false;
+      }
+      var lastChild = quotaNode.getLastChild();
+      if (!lastChild) {
+        return false;
+      }
+      if (!$closest(focusNode, function (node) {
+        return node === lastChild;
+      })) {
+        return false;
+      }
+      event.preventDefault();
+      editor.update(function () {
+        var paragraph = $createParagraphNode();
+        quotaNode.insertAfter(paragraph);
+        paragraph.select();
+      });
+      return true;
+    }
+    return false;
+  }, COMMAND_PRIORITY_LOW), kernel.registerHighCommand(KEY_ARROW_DOWN_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

@@ -54,7 +54,7 @@ var ReactPlainText = /*#__PURE__*/memo(function (_ref) {
   var _theme$fontSize = theme.fontSize,
     fontSize = _theme$fontSize === void 0 ? isChat ? 14 : 16 : _theme$fontSize,
     _theme$headerMultiple = theme.headerMultiple,
-    headerMultiple = _theme$headerMultiple === void 0 ? isChat ? 0.25 : 1 : _theme$headerMultiple,
+    headerMultiple = _theme$headerMultiple === void 0 ? isChat ? 0.25 : 0.6 : _theme$headerMultiple,
     _theme$lineHeight = theme.lineHeight,
     lineHeight = _theme$lineHeight === void 0 ? isChat ? 1.6 : 1.8 : _theme$lineHeight,
     _theme$marginMultiple = theme.marginMultiple,

package/es/plugins/image/node/block-image-node.js

@@ -174,7 +174,7 @@ export function $createBlockImageNode(_ref) {
   var altText = _ref.altText,
     height = _ref.height,
     _ref$maxWidth = _ref.maxWidth,
-    maxWidth = _ref$maxWidth === void 0 ? 500 : _ref$maxWidth,
+    maxWidth = _ref$maxWidth === void 0 ? 4200 : _ref$maxWidth,
     src = _ref.src,
     width = _ref.width,
     key = _ref.key;

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

@@ -18,6 +18,7 @@ function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol"
 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 { INodeHelper } from "../../../editor-kernel/inode/helper";
 import { KernelPlugin } from "../../../editor-kernel/plugin";
+import { INodeService } from "../../inode";
 import { ILitexmlService } from "../../litexml";
 import { IMarkdownShortCutService } from "../../markdown/service/shortcut";
 import { IUploadService, UPLOAD_PRIORITY_HIGH } from "../../upload";
@@ -45,9 +46,10 @@ export var ImagePlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
     key: "onInit",
     value: function onInit(editor) {
       var _this$config;
-      this.register(registerImageCommand(editor, this.config.handleUpload, (_this$config = this.config) === null || _this$config === void 0 ? void 0 : _this$config.defaultBlockImage));
+      this.register(registerImageCommand(editor, this.config.handleUpload, ((_this$config = this.config) === null || _this$config === void 0 ? void 0 : _this$config.defaultBlockImage) !== false));
       this.registerMarkdown();
       this.registerLiteXml();
+      this.registerINode();
       this.registerUpload(editor);
     }
   }, {
@@ -70,7 +72,7 @@ export var ImagePlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
               case 2:
                 imageWidth = _context.sent;
                 return _context.abrupt("return", editor.dispatchCommand(INSERT_IMAGE_COMMAND, {
-                  block: (_this2$config = _this2.config) === null || _this2$config === void 0 ? void 0 : _this2$config.defaultBlockImage,
+                  block: ((_this2$config = _this2.config) === null || _this2$config === void 0 ? void 0 : _this2$config.defaultBlockImage) !== false,
                   file: file,
                   maxWidth: imageWidth,
                   range: range
@@ -145,6 +147,8 @@ export var ImagePlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
   }, {
     key: "registerMarkdown",
     value: function registerMarkdown() {
+      var _this$config2;
+      var defaultBlockImage = ((_this$config2 = this.config) === null || _this$config2 === void 0 ? void 0 : _this$config2.defaultBlockImage) !== false;
       var markdownService = this.kernel.requireService(IMarkdownShortCutService);
       if (!markdownService) {
         return;
@@ -162,7 +166,7 @@ export var ImagePlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
       markdownService.registerMarkdownReader('image', function (node) {
         var altText = node.alt;
         var src = node.url;
-        return INodeHelper.createTypeNode(ImageNode.getType(), {
+        return INodeHelper.createTypeNode(defaultBlockImage ? BlockImageNode.getType() : ImageNode.getType(), {
           altText: altText,
           showCaption: false,
           src: src,
@@ -170,6 +174,32 @@ export var ImagePlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
         });
       });
     }
+  }, {
+    key: "registerINode",
+    value: function registerINode() {
+      var service = this.kernel.requireService(INodeService);
+      if (!service) {
+        return;
+      }
+      service.registerProcessNodeTree(function (_ref2) {
+        var root = _ref2.root;
+        // Process the root node
+        var loopNodes = function loopNodes(node) {
+          if ('children' in node && Array.isArray(node.children)) {
+            if (node.type === 'paragraph' && node.children.length === 1 && node.children[0].type === BlockImageNode.getType()) {
+              return node.children[0];
+            }
+            node.children = node.children.map(function (child) {
+              return loopNodes(child);
+            });
+          }
+          return node;
+        };
+        root.children = root.children.map(function (child) {
+          return loopNodes(child);
+        });
+      });
+    }
   }, {
     key: "getImageWidth",
     value: function getImageWidth(file) {

package/es/plugins/image/react/components/Image.js

@@ -212,7 +212,7 @@ var Image = /*#__PURE__*/memo(function (_ref) {
     children: [children, showScaleInfo && isSelected && scale !== 1 && /*#__PURE__*/_jsxs("div", {
       className: styles.scaleInfo,
       children: [Math.round(scale * 100), "%"]
-    }), isHovered && /*#__PURE__*/_jsxs(_Fragment, {
+    }), isHovered && node.status === 'uploaded' && /*#__PURE__*/_jsxs(_Fragment, {
       children: [/*#__PURE__*/_jsx(ResizeHandle, {
         imageRef: imageRef,
         isBlock: isBlock,

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

@@ -0,0 +1,3 @@
+export * from './plugin';
+export * from './react';
+export { INodeService } from './service';

package/es/plugins/inode/index.js

@@ -0,0 +1,3 @@
+export * from "./plugin";
+export * from "./react";
+export { INodeService } from "./service";

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

@@ -0,0 +1,16 @@
+import type { IEditorPluginConstructor } from "../../../types";
+/**
+ * NodePluginOptions - Configuration options for the Node plugin
+ */
+export interface INodePluginOptions {
+    /**
+     * Enable or disable the node data source
+     * @default true
+     */
+    enabled?: boolean;
+}
+/**
+ * LitexmlPlugin - A plugin that provides XML-based data source support
+ * Allows converting between Lexical editor state and XML format
+ */
+export declare const INodePlugin: IEditorPluginConstructor<INodePluginOptions>;

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

@@ -0,0 +1,49 @@
+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 _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 { KernelPlugin } from "../../../editor-kernel/plugin";
+import { INodeService, NodeService } from "../service";
+
+/**
+ * NodePluginOptions - Configuration options for the Node plugin
+ */
+
+/**
+ * LitexmlPlugin - A plugin that provides XML-based data source support
+ * Allows converting between Lexical editor state and XML format
+ */
+export var INodePlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
+  _inherits(INodePlugin, _KernelPlugin);
+  var _super = _createSuper(INodePlugin);
+  function INodePlugin(kernel, config) {
+    var _this;
+    _classCallCheck(this, INodePlugin);
+    _this = _super.call(this);
+
+    // Create and register the Node service
+    _this.kernel = kernel;
+    _this.config = config;
+    var nodeService = new NodeService();
+    kernel.registerService(INodeService, nodeService);
+    return _this;
+  }
+  _createClass(INodePlugin, [{
+    key: "onInit",
+    value: function onInit() {
+      // Plugin initialization logic can be added here if needed
+    }
+  }]);
+  return INodePlugin;
+}(KernelPlugin), _defineProperty(_class, "pluginName", 'INodePlugin'), _class);

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

@@ -0,0 +1,3 @@
+import { type FC } from 'react';
+export declare const ReactNodePlugin: FC<void>;
+export default ReactNodePlugin;

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

@@ -0,0 +1,22 @@
+'use client';
+
+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";
+import { INodePlugin } from "../plugin";
+export var ReactNodePlugin = function ReactNodePlugin() {
+  var _useLexicalComposerCo = useLexicalComposerContext(),
+    _useLexicalComposerCo2 = _slicedToArray(_useLexicalComposerCo, 1),
+    editor = _useLexicalComposerCo2[0];
+  useLayoutEffect(function () {
+    editor.registerPlugin(INodePlugin);
+  }, [editor]);
+  return null;
+};
+ReactNodePlugin.displayName = 'ReactNodePlugin';
+export default ReactNodePlugin;

package/es/plugins/inode/service/index.d.ts

@@ -0,0 +1,25 @@
+import { IRootNode } from "../../../editor-kernel/inode";
+export interface INodeService {
+    processNodeTree(inode: {
+        root: IRootNode;
+    }): void;
+    registerProcessNodeTree(process: (inode: {
+        root: IRootNode;
+    }) => void): void;
+}
+/**
+ * Service ID for Node service
+ */
+export declare const INodeService: import("../../../types").IServiceID<INodeService>;
+/**
+ * Default implementation of INodeService
+ */
+export declare class NodeService implements INodeService {
+    private processNodeTreeHandlers;
+    registerProcessNodeTree(process: (inode: {
+        root: IRootNode;
+    }) => void): void;
+    processNodeTree(inode: {
+        root: IRootNode;
+    }): void;
+}

package/es/plugins/inode/service/index.js

@@ -0,0 +1,49 @@
+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 _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; }
+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 _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 { genServiceId } from "../../../editor-kernel";
+/**
+ * Service ID for Node service
+ */
+// eslint-disable-next-line @typescript-eslint/no-redeclare, no-redeclare
+export var INodeService = genServiceId('INodeService');
+
+/**
+ * Default implementation of INodeService
+ */
+export var NodeService = /*#__PURE__*/function () {
+  function NodeService() {
+    _classCallCheck(this, NodeService);
+    _defineProperty(this, "processNodeTreeHandlers", []);
+  }
+  _createClass(NodeService, [{
+    key: "registerProcessNodeTree",
+    value: function registerProcessNodeTree(process) {
+      this.processNodeTreeHandlers.push(process);
+    }
+  }, {
+    key: "processNodeTree",
+    value: function processNodeTree(inode) {
+      var _iterator = _createForOfIteratorHelper(this.processNodeTreeHandlers),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var handler = _step.value;
+          handler(inode);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+  }]);
+  return NodeService;
+}();

package/es/plugins/litexml/data-source/litexml-data-source.d.ts

@@ -1,6 +1,7 @@
 import type { LexicalEditor } from 'lexical';
 import { DataSource } from "../../../editor-kernel";
 import type { IWriteOptions } from "../../../editor-kernel/data-source";
+import { IServiceID } from "../../../types";
 import type { ILitexmlService } from '../service/litexml-service';
 /**
  * LitexmlDataSource - Handles conversion between Lexical editor state and XML format
@@ -8,9 +9,10 @@ import type { ILitexmlService } from '../service/litexml-service';
  */
 export default class LitexmlDataSource extends DataSource {
     protected dataType: string;
+    protected getService?: (<T>(serviceId: IServiceID<T>) => T | null) | undefined;
     private litexmlService;
     private ctx;
-    constructor(dataType?: string, service?: ILitexmlService);
+    constructor(dataType?: string, getService?: (<T>(serviceId: IServiceID<T>) => T | null) | undefined, service?: ILitexmlService);
     readLiteXMLToInode(litexml: string): any;
     /**
      * Parse XML string and set it to the editor

package/es/plugins/litexml/data-source/litexml-data-source.js

@@ -30,8 +30,10 @@ import { DOMParser } from '@xmldom/xmldom';
 import { $getRoot, $getSelection, $isElementNode, $isRangeSelection } from 'lexical';
 import { DataSource } from "../../../editor-kernel";
 import { INodeHelper } from "../../../editor-kernel/inode/helper";
+import { INodeService } from "../../inode";
 import { createDebugLogger } from "../../../utils/debug";
 import { LitexmlService } from "../service/litexml-service";
+import { charToId, idToChar } from "../utils";
 var logger = createDebugLogger('plugin', 'litexml');
 var IXmlWriterContext = /*#__PURE__*/function () {
   function IXmlWriterContext() {
@@ -60,23 +62,27 @@ var LitexmlDataSource = /*#__PURE__*/function (_DataSource) {
   function LitexmlDataSource() {
     var _this;
     var dataType = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'litexml';
-    var service = arguments.length > 1 ? arguments[1] : undefined;
+    var getService = arguments.length > 1 ? arguments[1] : undefined;
+    var service = arguments.length > 2 ? arguments[2] : undefined;
     _classCallCheck(this, LitexmlDataSource);
     _this = _super.call(this, dataType);
     _defineProperty(_assertThisInitialized(_this), "litexmlService", void 0);
     _defineProperty(_assertThisInitialized(_this), "ctx", new IXmlWriterContext());
     _this.dataType = dataType;
+    _this.getService = getService;
     _this.litexmlService = service || new LitexmlService();
     return _this;
   }
   _createClass(LitexmlDataSource, [{
     key: "readLiteXMLToInode",
     value: function readLiteXMLToInode(litexml) {
+      var _this$getService;
       if (typeof litexml !== 'string') {
         throw new Error('Invalid data type. Expected string, got ' + _typeof(litexml));
       }
       var xml = this.parseXMLString(litexml);
       var inode = this.xmlToLexical(xml);
+      (_this$getService = this.getService) === null || _this$getService === void 0 || (_this$getService = _this$getService.call(this, INodeService)) === null || _this$getService === void 0 || _this$getService.processNodeTree(inode);
       logger.debug('Parsed XML to Lexical State:', inode);
       return inode;
     }
@@ -214,7 +220,8 @@ var LitexmlDataSource = /*#__PURE__*/function (_DataSource) {
               if (Array.isArray(result)) {
                 INodeHelper.appendChild.apply(INodeHelper, [parentNode].concat(_toConsumableArray(result)));
               } else if (result) {
-                result.id = xmlElement.getAttribute('id') || undefined;
+                var attrId = xmlElement.getAttribute('id');
+                result.id = attrId ? charToId(attrId) : undefined;
                 INodeHelper.appendChild(parentNode, result);
               }
               return; // Custom reader handled it
@@ -364,7 +371,7 @@ var LitexmlDataSource = /*#__PURE__*/function (_DataSource) {
             var handled = writer(node, this.ctx, indent);
             if (handled) {
               var attrs = this.buildXMLAttributes(_objectSpread({
-                id: node.getKey()
+                id: idToChar(node.getKey())
               }, handled.attributes));
               var openTag = "".concat(indentStr, "<").concat(handled.tagName).concat(attrs, ">");
               var closeTag = "</".concat(handled.tagName, ">");

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

@@ -40,7 +40,9 @@ export var LitexmlPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
     _this.config = config;
     var litexmlService = new LitexmlService();
     kernel.registerService(ILitexmlService, litexmlService);
-    _this.datasource = new LitexmlDataSource('litexml', litexmlService);
+    _this.datasource = new LitexmlDataSource('litexml', function (serviceId) {
+      return kernel.requireService(serviceId);
+    }, litexmlService);
 
     // Register the litexml data source
     if ((config === null || config === void 0 ? void 0 : config.enabled) !== false) {

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

@@ -8,12 +8,14 @@ function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" !=
 function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 import { useLayoutEffect } from 'react';
 import { useLexicalComposerContext } from "../../../editor-kernel/react";
+import { INodePlugin } from "../../inode";
 import { LitexmlPlugin } from "../plugin";
 export var ReactLiteXmlPlugin = function ReactLiteXmlPlugin() {
   var _useLexicalComposerCo = useLexicalComposerContext(),
     _useLexicalComposerCo2 = _slicedToArray(_useLexicalComposerCo, 1),
     editor = _useLexicalComposerCo2[0];
   useLayoutEffect(function () {
+    editor.registerPlugin(INodePlugin);
     editor.registerPlugin(LitexmlPlugin);
   }, [editor]);
   return null;

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

@@ -1,2 +1,4 @@
 import { LexicalEditor, LexicalNode } from 'lexical';
 export declare function $parseSerializedNodeImpl(serializedNode: any, editor: LexicalEditor): LexicalNode;
+export declare function idToChar(id: string | number): string;
+export declare function charToId(char: string): string;

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

@@ -30,4 +30,17 @@ export function $parseSerializedNodeImpl(serializedNode, editor) {
     }
   }
   return node;
+}
+var maxId = 1679616; // 36^4
+var startId = 1000000; // to avoid short ids
+var step = 7211; // a prime number to reduce collisions
+var modInverse = 1394051; // modular inverse of step mod maxId
+
+export function idToChar(id) {
+  var nId = (Number(id) * step + startId) % maxId;
+  return nId.toString(36).padStart(4, '0');
+}
+export function charToId(char) {
+  var nId = parseInt(char, 36);
+  return String((nId - startId + maxId) * modInverse % maxId);
 }

package/es/plugins/markdown/data-source/markdown-data-source.d.ts

@@ -1,11 +1,13 @@
 import type { LexicalEditor } from 'lexical';
 import { DataSource } from "../../../editor-kernel";
 import type { IWriteOptions } from "../../../editor-kernel/data-source";
+import type { IServiceID } from "../../../types";
 import type { MarkdownShortCutService } from '../service/shortcut';
 export default class MarkdownDataSource extends DataSource {
     protected dataType: string;
     protected markdownService: MarkdownShortCutService;
-    constructor(dataType: string, markdownService: MarkdownShortCutService);
+    protected getService?: (<T>(serviceId: IServiceID<T>) => T | null) | undefined;
+    constructor(dataType: string, markdownService: MarkdownShortCutService, getService?: (<T>(serviceId: IServiceID<T>) => T | null) | undefined);
     read(editor: LexicalEditor, data: string): void;
     write(editor: LexicalEditor, options?: IWriteOptions): any;
 }

package/es/plugins/markdown/data-source/markdown-data-source.js

@@ -29,26 +29,30 @@ import { $isTableSelection } from '@lexical/table';
 import { $getCharacterOffsets, $getNodeByKey, $getRoot, $getSelection, $isElementNode, $isRangeSelection, $isTextNode } from 'lexical';
 import { DataSource } from "../../../editor-kernel";
 import { INodeHelper } from "../../../editor-kernel/inode/helper";
+import { INodeService } from "../../inode";
 import { logger } from "../utils/logger";
 import { MarkdownWriterContext } from "./markdown-writer-context";
 import { parseMarkdownToLexical } from "./markdown/parse";
 var MarkdownDataSource = /*#__PURE__*/function (_DataSource) {
   _inherits(MarkdownDataSource, _DataSource);
   var _super = _createSuper(MarkdownDataSource);
-  function MarkdownDataSource(dataType, markdownService) {
+  function MarkdownDataSource(dataType, markdownService, getService) {
     var _this;
     _classCallCheck(this, MarkdownDataSource);
     _this = _super.call(this, dataType);
     _this.dataType = dataType;
     _this.markdownService = markdownService;
+    _this.getService = getService;
     return _this;
   }
   _createClass(MarkdownDataSource, [{
     key: "read",
     value: function read(editor, data) {
+      var _this$getService;
       var inode = {
         root: parseMarkdownToLexical(data, this.markdownService.markdownReaders)
       };
+      (_this$getService = this.getService) === null || _this$getService === void 0 || (_this$getService = _this$getService.call(this, INodeService)) === null || _this$getService === void 0 || _this$getService.processNodeTree(inode);
       logger.debug('Parsed Lexical State:', inode);
       editor.setEditorState(editor.parseEditorState(inode));
     }

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

@@ -35,8 +35,9 @@ export var MarkdownPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
     _this.config = config;
     _this.service = new MarkdownShortCutService(kernel);
     kernel.registerService(IMarkdownShortCutService, _this.service);
-    // @todo To be implemented
-    kernel.registerDataSource(new MarkdownDataSource('markdown', _this.service));
+    kernel.registerDataSource(new MarkdownDataSource('markdown', _this.service, function (serviceId) {
+      return kernel.requireService(serviceId);
+    }));
     return _this;
   }
   _createClass(MarkdownPlugin, [{

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

@@ -11,6 +11,7 @@ import { Space, notification } from 'antd';
 import { useLayoutEffect } from 'react';
 import { useLexicalComposerContext } from "../../../editor-kernel/react";
 import { useTranslation } from "../../../editor-kernel/react/useTranslation";
+import { INodePlugin } from "../../inode";
 import { INSERT_MARKDOWN_COMMAND } from "../command";
 import { MarkdownPlugin } from "../plugin";
 import { jsx as _jsx } from "react/jsx-runtime";
@@ -25,6 +26,7 @@ var ReactMarkdownPlugin = function ReactMarkdownPlugin() {
     contextHolder = _notification$useNoti2[1];
   var t = useTranslation();
   useLayoutEffect(function () {
+    editor.registerPlugin(INodePlugin);
     editor.registerPlugin(MarkdownPlugin);
     var handleEvent = function handleEvent(_ref) {
       var markdown = _ref.markdown,

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

@@ -7,7 +7,7 @@ export type EditorPlugin = FC<any> | [FC<any>, Record<string, any>];
 interface MentionOption extends Partial<ReactSlashOptionProps> {
     markdownWriter?: ReactMentionPluginProps['markdownWriter'];
 }
-export interface EditorProps extends Partial<ReactEditorContentProps>, Omit<ReactPlainTextProps, 'theme' | 'children'> {
+export interface EditorProps extends Partial<ReactEditorContentProps>, Omit<ReactPlainTextProps, 'children'> {
     autoFocus?: boolean;
     children?: ReactNode;
     className?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/editor",
-  "version": "1.31.1",
+  "version": "1.32.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",
@@ -13,7 +13,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/lobehub/lobe-editor.git"
+    "url": "git+https://github.com/lobehub/lobe-editor.git"
   },
   "license": "MIT",
   "author": "LobeHub <i@lobehub.com>",