@lobehub/editor 3.3.2 → 3.4.0

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

@@ -3,6 +3,8 @@ function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o =
 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 { $isElementNode } from 'lexical';
 export function $parseSerializedNodeImpl(serializedNode, editor) {
+  var keepId = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var state = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
   var type = serializedNode.type;
   var registeredNode = editor._nodes.get(type);
   if (registeredNode === undefined) {
@@ -13,6 +15,10 @@ export function $parseSerializedNodeImpl(serializedNode, editor) {
     throw new Error("LexicalNode: Node ".concat(nodeClass.name, " does not implement .importJSON()."));
   }
   var node = nodeClass.importJSON(serializedNode);
+  if (keepId && serializedNode.id) {
+    node.__key = serializedNode.id;
+    state === null || state === void 0 || state._nodeMap.set(node.__key, node);
+  }
   var children = serializedNode.children;
   if ($isElementNode(node) && Array.isArray(children)) {
     var _iterator = _createForOfIteratorHelper(children),
@@ -20,7 +26,7 @@ export function $parseSerializedNodeImpl(serializedNode, editor) {
     try {
       for (_iterator.s(); !(_step = _iterator.n()).done;) {
         var serializedJSONChildNode = _step.value;
-        var childNode = $parseSerializedNodeImpl(serializedJSONChildNode, editor);
+        var childNode = $parseSerializedNodeImpl(serializedJSONChildNode, editor, keepId, state);
         node.append(childNode);
       }
     } catch (err) {

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

@@ -60,25 +60,6 @@ var MarkdownDataSource = /*#__PURE__*/function (_DataSource) {
     key: "write",
     value: function write(editor, options) {
       var _this2 = this;
-      var processChild = function processChild(parentCtx, child) {
-        var writer = _this2.markdownService.markdownWriters[child.getType()];
-        var currentCtx = parentCtx;
-        if ($isElementNode(child)) {
-          currentCtx = currentCtx.newChild();
-        }
-        var skipChildren = false;
-        if (writer) {
-          skipChildren = writer(currentCtx, child);
-        }
-        if (skipChildren) {
-          return;
-        }
-        if ($isElementNode(child)) {
-          child.getChildren().forEach(function (child) {
-            return processChild(currentCtx, child);
-          });
-        }
-      };
       if (options !== null && options !== void 0 && options.selection) {
         return editor.getEditorState().read(function () {
           var selection = $getSelection();
@@ -193,10 +174,10 @@ var MarkdownDataSource = /*#__PURE__*/function (_DataSource) {
               root: _rootNode
             });
             var _lexicalRootNode = _editorState._nodeMap.get('root');
-            var _rootCtx = new MarkdownWriterContext();
+            var _rootCtx = new MarkdownWriterContext(_this2.markdownService);
             return _editorState.read(function () {
               _lexicalRootNode.getChildren().forEach(function (child) {
-                return processChild(_rootCtx, child);
+                return _rootCtx.processChild(_rootCtx, child);
               });
               return _rootCtx.toString();
             });
@@ -221,10 +202,10 @@ var MarkdownDataSource = /*#__PURE__*/function (_DataSource) {
             root: rootNode
           });
           var lexicalRootNode = editorState._nodeMap.get('root');
-          var rootCtx = new MarkdownWriterContext();
+          var rootCtx = new MarkdownWriterContext(_this2.markdownService);
           return editorState.read(function () {
             lexicalRootNode.getChildren().forEach(function (child) {
-              return processChild(rootCtx, child);
+              return rootCtx.processChild(rootCtx, child);
             });
             return rootCtx.toString();
           });
@@ -232,9 +213,9 @@ var MarkdownDataSource = /*#__PURE__*/function (_DataSource) {
       }
       return editor.getEditorState().read(function () {
         var rootNode = $getRoot();
-        var rootCtx = new MarkdownWriterContext();
+        var rootCtx = new MarkdownWriterContext(_this2.markdownService);
         rootNode.getChildren().forEach(function (child) {
-          return processChild(rootCtx, child);
+          return rootCtx.processChild(rootCtx, child);
         });
         return rootCtx.toString();
       });

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

@@ -1,12 +1,16 @@
-import { IMarkdownWriterContext } from '../service/shortcut';
+import { LexicalNode } from 'lexical';
+import { IMarkdownWriterContext, MarkdownShortCutService } from '../service/shortcut';
 export declare class MarkdownWriterContext implements IMarkdownWriterContext {
     private before;
     private after;
     private children;
+    private markdownService;
     private processor?;
+    constructor(markdownService?: MarkdownShortCutService);
     appendLine(line: string): void;
     newChild(): MarkdownWriterContext;
     wrap(before: string, after: string): void;
     addProcessor(processor: (before: string, content: string, after: string) => string): void;
     toString(): string;
+    processChild(parentCtx: IMarkdownWriterContext, child: LexicalNode): void;
 }

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

@@ -5,13 +5,16 @@ function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _d
 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 { $isElementNode } from 'lexical';
 export var MarkdownWriterContext = /*#__PURE__*/function () {
-  function MarkdownWriterContext() {
+  function MarkdownWriterContext(markdownService) {
     _classCallCheck(this, MarkdownWriterContext);
     _defineProperty(this, "before", '');
     _defineProperty(this, "after", '');
     _defineProperty(this, "children", []);
+    _defineProperty(this, "markdownService", void 0);
     _defineProperty(this, "processor", void 0);
+    this.markdownService = markdownService;
   }
   _createClass(MarkdownWriterContext, [{
     key: "appendLine",
@@ -21,7 +24,7 @@ export var MarkdownWriterContext = /*#__PURE__*/function () {
   }, {
     key: "newChild",
     value: function newChild() {
-      var child = new MarkdownWriterContext();
+      var child = new MarkdownWriterContext(this.markdownService);
       this.children.push(child);
       return child;
     }
@@ -46,6 +49,28 @@ export var MarkdownWriterContext = /*#__PURE__*/function () {
         return child.toString();
       }).join(''), this.after) : content;
     }
+  }, {
+    key: "processChild",
+    value: function processChild(parentCtx, child) {
+      var _this = this;
+      var writer = this.markdownService.markdownWriters[child.getType()];
+      var currentCtx = parentCtx;
+      if ($isElementNode(child)) {
+        currentCtx = currentCtx.newChild();
+      }
+      var skipChildren = false;
+      if (writer) {
+        skipChildren = writer(currentCtx, child);
+      }
+      if (skipChildren) {
+        return;
+      }
+      if ($isElementNode(child)) {
+        child.getChildren().forEach(function (child) {
+          return _this.processChild(currentCtx, child);
+        });
+      }
+    }
   }]);
   return MarkdownWriterContext;
 }();

package/es/plugins/markdown/service/shortcut.d.ts

@@ -15,6 +15,13 @@ export interface IMarkdownWriterContext {
      * @returns
      */
     appendLine: (line: string) => void;
+    /**
+     * Control child node to markdown
+     * @param parentCtx
+     * @param child
+     * @returns
+     */
+    processChild: (parentCtx: IMarkdownWriterContext, child: LexicalNode) => void;
     /**
      * Wrap child elements
      * @param before

package/es/types/kernel.d.ts

@@ -19,6 +19,10 @@ export type IServiceID<Service> = {
     __serviceType?: Service;
 };
 export interface IKernelEventMap {
+    /**
+     * Document change event
+     */
+    documentChange: (type: string, content: any) => void;
     /**
      * Editor editable state change event
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/editor",
-  "version": "3.3.2",
+  "version": "3.4.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",
@@ -25,6 +25,7 @@
   "types": "es/index.d.ts",
   "files": [
     "es",
+    "scripts/patch-lexical.js",
     "react.d.ts",
     "react.js"
   ],
@@ -70,5 +71,10 @@
     "react": "^19.0.0",
     "react-dom": "^19.0.0"
   },
-  "packageManager": "pnpm@10.20.0"
+  "packageManager": "pnpm@10.20.0",
+  "pnpm": {
+    "overrides": {
+      "chalk": "^4.1.2"
+    }
+  }
 }

package/scripts/patch-lexical.js

@@ -0,0 +1,39 @@
+/* eslint-disable unicorn/no-process-exit */
+const fs = require('node:fs');
+const path = require('node:path');
+
+const sourceDir = path.resolve(__dirname, '../src/editor-kernel/lexical');
+const esSourceDir = path.resolve(__dirname, '../es/editor-kernel/lexical');
+const targetDir = path.resolve(__dirname, '../node_modules/lexical');
+
+if (!fs.existsSync(targetDir)) {
+  console.warn('node_modules/lexical not found, skipping patch.');
+  process.exit(0);
+}
+
+const realSourceDir = fs.existsSync(esSourceDir) ? esSourceDir : sourceDir;
+
+if (!fs.existsSync(realSourceDir)) {
+  console.warn('No source directory found for lexical patch.');
+  process.exit(0);
+}
+
+function copyToLexical(dir, target) {
+  const files = fs.readdirSync(dir);
+
+  files.forEach((file) => {
+    const sourceFile = path.join(dir, file);
+    const targetFile = path.join(target, file);
+    if (fs.statSync(sourceFile).isDirectory()) {
+      copyToLexical(sourceFile, targetFile);
+      return;
+    }
+
+    if (fs.existsSync(sourceFile)) {
+      fs.copyFileSync(sourceFile, targetFile);
+      console.log(`Overwrote ${file} in node_modules/lexical/`);
+    }
+  });
+}
+
+copyToLexical(realSourceDir, targetDir);