@lobehub/editor 1.29.0 → 1.31.0

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

@@ -132,7 +132,7 @@ export var BlockImageNode = /*#__PURE__*/function (_BaseImageNode) {
   }, {
     key: "clone",
     value: function clone(node) {
-      return new BlockImageNode(node.__src, node.__altText, node.__maxWidth, node.__width, node.__height, node.__showCaption, node.__caption, node.__captionsEnabled, node.__key);
+      return new BlockImageNode(node.__src, node.__altText, node.__maxWidth, node.__width, node.__height, node.__key);
     }
   }, {
     key: "importJSON",
@@ -141,14 +141,12 @@ export var BlockImageNode = /*#__PURE__*/function (_BaseImageNode) {
         height = serializedNode.height,
         width = serializedNode.width,
         maxWidth = serializedNode.maxWidth,
-        src = serializedNode.src,
-        showCaption = serializedNode.showCaption;
+        src = serializedNode.src;
       // eslint-disable-next-line @typescript-eslint/no-use-before-define
       return $createBlockImageNode({
         altText: altText,
         height: height,
         maxWidth: maxWidth,
-        showCaption: showCaption,
         src: src,
         width: width
       }).updateFromJSON(serializedNode);
@@ -177,13 +175,10 @@ export function $createBlockImageNode(_ref) {
     height = _ref.height,
     _ref$maxWidth = _ref.maxWidth,
     maxWidth = _ref$maxWidth === void 0 ? 500 : _ref$maxWidth,
-    captionsEnabled = _ref.captionsEnabled,
     src = _ref.src,
     width = _ref.width,
-    showCaption = _ref.showCaption,
-    caption = _ref.caption,
     key = _ref.key;
-  return $applyNodeReplacement(new BlockImageNode(src, altText, maxWidth, width, height, showCaption, caption, captionsEnabled, key));
+  return $applyNodeReplacement(new BlockImageNode(src, altText, maxWidth, width, height, key));
 }
 function $convertImageElement(domNode) {
   var img = domNode;

package/es/plugins/image/node/image-node.d.ts

@@ -25,5 +25,5 @@ export declare class ImageNode extends BaseImageNode {
     static importDOM(): DOMConversionMap | null;
     decorate(): any;
 }
-export declare function $createImageNode({ altText, height, maxWidth, captionsEnabled, src, width, showCaption, caption, key, }: ImagePayload): ImageNode;
+export declare function $createImageNode({ altText, height, maxWidth, src, width, key, }: ImagePayload): ImageNode;
 export declare function $isImageNode(node: LexicalNode): node is ImageNode;

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

@@ -116,7 +116,7 @@ export var ImageNode = /*#__PURE__*/function (_BaseImageNode) {
   }, {
     key: "clone",
     value: function clone(node) {
-      return new ImageNode(node.__src, node.__altText, node.__maxWidth, node.__width, node.__height, node.__showCaption, node.__caption, node.__captionsEnabled, node.__key);
+      return new ImageNode(node.__src, node.__altText, node.__maxWidth, node.__width, node.__height, node.__key);
     }
   }, {
     key: "importJSON",
@@ -125,14 +125,12 @@ export var ImageNode = /*#__PURE__*/function (_BaseImageNode) {
         height = serializedNode.height,
         width = serializedNode.width,
         maxWidth = serializedNode.maxWidth,
-        src = serializedNode.src,
-        showCaption = serializedNode.showCaption;
+        src = serializedNode.src;
       // eslint-disable-next-line @typescript-eslint/no-use-before-define
       return $createImageNode({
         altText: altText,
         height: height,
         maxWidth: maxWidth,
-        showCaption: showCaption,
         src: src,
         width: width
       }).updateFromJSON(serializedNode);
@@ -161,13 +159,10 @@ export function $createImageNode(_ref) {
     height = _ref.height,
     _ref$maxWidth = _ref.maxWidth,
     maxWidth = _ref$maxWidth === void 0 ? 500 : _ref$maxWidth,
-    captionsEnabled = _ref.captionsEnabled,
     src = _ref.src,
     width = _ref.width,
-    showCaption = _ref.showCaption,
-    caption = _ref.caption,
     key = _ref.key;
-  return $applyNodeReplacement(new ImageNode(src, altText, maxWidth, width, height, showCaption, caption, captionsEnabled, key));
+  return $applyNodeReplacement(new ImageNode(src, altText, maxWidth, width, height, key));
 }
 function $convertImageElement(domNode) {
   var img = domNode;

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

@@ -16,7 +16,9 @@ function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.g
 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 { INodeHelper } from "../../../editor-kernel/inode/helper";
 import { KernelPlugin } from "../../../editor-kernel/plugin";
+import { ILitexmlService } from "../../litexml";
 import { IMarkdownShortCutService } from "../../markdown/service/shortcut";
 import { IUploadService, UPLOAD_PRIORITY_HIGH } from "../../upload";
 import { INSERT_IMAGE_COMMAND, registerImageCommand } from "../command";
@@ -42,22 +44,21 @@ export var ImagePlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
   _createClass(ImagePlugin, [{
     key: "onInit",
     value: function onInit(editor) {
-      var _this$kernel$requireS,
-        _this$kernel$requireS2,
-        _this$kernel$requireS3,
-        _this2 = this,
-        _this$config;
-      (_this$kernel$requireS = this.kernel.requireService(IMarkdownShortCutService)) === null || _this$kernel$requireS === void 0 || _this$kernel$requireS.registerMarkdownWriter(ImageNode.getType(), function (ctx, node) {
-        if ($isImageNode(node)) {
-          ctx.appendLine("![".concat(node.altText, "](").concat(node.src, ")"));
-        }
-      });
-      (_this$kernel$requireS2 = this.kernel.requireService(IMarkdownShortCutService)) === null || _this$kernel$requireS2 === void 0 || _this$kernel$requireS2.registerMarkdownWriter(BlockImageNode.getType(), function (ctx, node) {
-        if ($isBlockImageNode(node)) {
-          ctx.appendLine("![".concat(node.altText, "](").concat(node.src, ")\n\n"));
-        }
-      });
-      (_this$kernel$requireS3 = this.kernel.requireService(IUploadService)) === null || _this$kernel$requireS3 === void 0 || _this$kernel$requireS3.registerUpload( /*#__PURE__*/function () {
+      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.registerMarkdown();
+      this.registerLiteXml();
+      this.registerUpload(editor);
+    }
+  }, {
+    key: "registerUpload",
+    value: function registerUpload(editor) {
+      var _this2 = this;
+      var uploadService = this.kernel.requireService(IUploadService);
+      if (!uploadService) {
+        return;
+      }
+      uploadService.registerUpload( /*#__PURE__*/function () {
         var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(file, from, range) {
           var _this2$config;
           var imageWidth;
@@ -84,7 +85,90 @@ export var ImagePlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
           return _ref.apply(this, arguments);
         };
       }(), UPLOAD_PRIORITY_HIGH);
-      this.register(registerImageCommand(editor, this.config.handleUpload, (_this$config = this.config) === null || _this$config === void 0 ? void 0 : _this$config.defaultBlockImage));
+    }
+  }, {
+    key: "registerLiteXml",
+    value: function registerLiteXml() {
+      var litexmlService = this.kernel.requireService(ILitexmlService);
+      if (!litexmlService) {
+        return;
+      }
+      litexmlService.registerXMLWriter(ImageNode.getType(), function (node, ctx) {
+        if ($isImageNode(node)) {
+          var attributes = {
+            src: node.src
+          };
+          if (node.altText) {
+            attributes.alt = node.altText;
+          }
+          return ctx.createXmlNode('img', attributes);
+        }
+        return false;
+      });
+      litexmlService.registerXMLWriter(BlockImageNode.getType(), function (node, ctx) {
+        if ($isBlockImageNode(node)) {
+          var attributes = {
+            block: 'true',
+            src: node.src
+          };
+          if (node.altText) {
+            attributes.alt = node.altText;
+          }
+          if (node.width) {
+            attributes.width = String(node.width);
+          }
+          if (node.maxWidth) {
+            attributes['max-width'] = String(node.maxWidth);
+          }
+          return ctx.createXmlNode('img', attributes);
+        }
+        return false;
+      });
+      litexmlService.registerXMLReader('img', function (xmlNode) {
+        if (xmlNode.getAttribute('block') === 'true') {
+          return INodeHelper.createElementNode(BlockImageNode.getType(), {
+            altText: xmlNode.getAttribute('alt') || '',
+            maxWidth: xmlNode.getAttribute('max-width') ? parseInt(xmlNode.getAttribute('max-width'), 10) : undefined,
+            src: xmlNode.getAttribute('src') || '',
+            width: xmlNode.getAttribute('width') ? parseInt(xmlNode.getAttribute('width'), 10) : undefined
+          });
+        } else {
+          return INodeHelper.createElementNode(ImageNode.getType(), {
+            altText: xmlNode.getAttribute('alt') || '',
+            maxWidth: xmlNode.getAttribute('max-width') ? parseInt(xmlNode.getAttribute('max-width'), 10) : undefined,
+            src: xmlNode.getAttribute('src') || '',
+            width: xmlNode.getAttribute('width') ? parseInt(xmlNode.getAttribute('width'), 10) : undefined
+          });
+        }
+      });
+    }
+  }, {
+    key: "registerMarkdown",
+    value: function registerMarkdown() {
+      var markdownService = this.kernel.requireService(IMarkdownShortCutService);
+      if (!markdownService) {
+        return;
+      }
+      markdownService.registerMarkdownWriter(ImageNode.getType(), function (ctx, node) {
+        if ($isImageNode(node)) {
+          ctx.appendLine("![".concat(node.altText, "](").concat(node.src, ")"));
+        }
+      });
+      markdownService.registerMarkdownWriter(BlockImageNode.getType(), function (ctx, node) {
+        if ($isBlockImageNode(node)) {
+          ctx.appendLine("![".concat(node.altText, "](").concat(node.src, ")\n\n"));
+        }
+      });
+      markdownService.registerMarkdownReader('image', function (node) {
+        var altText = node.alt;
+        var src = node.url;
+        return INodeHelper.createTypeNode(ImageNode.getType(), {
+          altText: altText,
+          showCaption: false,
+          src: src,
+          version: 1
+        });
+      });
     }
   }, {
     key: "getImageWidth",

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

@@ -22,6 +22,7 @@ function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e
 import { $createTextNode, COMMAND_PRIORITY_NORMAL, PASTE_COMMAND } from 'lexical';
 import { INodeHelper } from "../../../editor-kernel/inode/helper";
 import { KernelPlugin } from "../../../editor-kernel/plugin";
+import { ILitexmlService } from "../../litexml";
 import { IMarkdownShortCutService } from "../../markdown/service/shortcut";
 import { INSERT_LINK_COMMAND, registerLinkCommand } from "../command";
 import { $createLinkNode, $isLinkNode, AutoLinkNode, LinkNode } from "../node/LinkNode";
@@ -55,10 +56,7 @@ export var LinkPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
       var _this$config,
         _this$config2,
         _this$config3,
-        _this2 = this,
-        _this$kernel$requireS,
-        _this$kernel$requireS2,
-        _this$kernel$requireS3;
+        _this2 = this;
       this.register(registerLinkCommand(editor));
       this.register(registerLinkCommands(editor, this.kernel, {
         attributes: (_this$config = this.config) === null || _this$config === void 0 ? void 0 : _this$config.attributes,
@@ -80,6 +78,42 @@ export var LinkPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
         }
         return false;
       }, COMMAND_PRIORITY_NORMAL));
+      this.registerMarkdown();
+      this.registerLiteXml();
+    }
+  }, {
+    key: "registerLiteXml",
+    value: function registerLiteXml() {
+      var litexmlService = this.kernel.requireService(ILitexmlService);
+      if (!litexmlService) {
+        return;
+      }
+      litexmlService.registerXMLWriter(LinkNode.getType(), function (node, ctx) {
+        if ($isLinkNode(node)) {
+          var attributes = {
+            href: node.getURL()
+          };
+          return ctx.createXmlNode('a', attributes);
+        }
+        return false;
+      });
+      litexmlService.registerXMLReader('a', function (xmlNode, children) {
+        var linkNode = INodeHelper.createElementNode('link', {
+          children: children,
+          direction: 'ltr',
+          format: '',
+          indent: 0,
+          type: 'link',
+          url: xmlNode.getAttribute('href') || '',
+          version: 1
+        });
+        return [linkNode];
+      });
+    }
+  }, {
+    key: "registerMarkdown",
+    value: function registerMarkdown() {
+      var _this$kernel$requireS, _this$kernel$requireS2, _this$kernel$requireS3;
       (_this$kernel$requireS = this.kernel.requireService(IMarkdownShortCutService)) === null || _this$kernel$requireS === void 0 || _this$kernel$requireS.registerMarkdownShortCut({
         regExp: /\[([^[]+)]\(([^\s()]+)(?:\s"((?:[^"]*\\")*[^"]*)"\s*)?\)\s?$/,
         replace: function replace(textNode, match) {

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

@@ -19,6 +19,7 @@ import { cx } from 'antd-style';
 import { $isRootNode } from 'lexical';
 import { INodeHelper } from "../../../editor-kernel/inode/helper";
 import { KernelPlugin } from "../../../editor-kernel/plugin";
+import { ILitexmlService } from "../../litexml";
 import { IMarkdownShortCutService } from "../../markdown/service/shortcut";
 import { listReplace } from "../utils";
 import { registerCheckList } from "./checkList";
@@ -66,6 +67,66 @@ export var ListPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
         enableHotkey: (_this$config = this.config) === null || _this$config === void 0 ? void 0 : _this$config.enableHotkey
       }));
       this.registerMarkdown();
+      this.registerLiteXml();
+    }
+  }, {
+    key: "registerLiteXml",
+    value: function registerLiteXml() {
+      var litexmlService = this.kernel.requireService(ILitexmlService);
+      if (!litexmlService) {
+        return;
+      }
+      litexmlService.registerXMLWriter(ListNode.getType(), function (node, ctx) {
+        if ($isListNode(node)) {
+          var tagName = node.getListType() === 'number' ? 'ol' : 'ul';
+          var attributes = {};
+          if (node.getListType() === 'number' && node.getStart() !== 1) {
+            attributes.start = node.getStart().toString();
+          }
+          return ctx.createXmlNode(tagName, attributes);
+        }
+        return false;
+      });
+      litexmlService.registerXMLWriter(ListItemNode.getType(), function (node, ctx) {
+        if ($isListItemNode(node)) {
+          return ctx.createXmlNode('li');
+        }
+        return false;
+      });
+      litexmlService.registerXMLReader('ol', function (xmlNode, children) {
+        return INodeHelper.createElementNode('list', {
+          children: children,
+          direction: 'ltr',
+          format: '',
+          indent: 0,
+          listType: 'number',
+          start: xmlNode.getAttribute('start') ? parseInt(xmlNode.getAttribute('start'), 10) : 1,
+          tag: 'ol',
+          version: 1
+        });
+      });
+      litexmlService.registerXMLReader('ul', function (xmlNode, children) {
+        return INodeHelper.createElementNode('list', {
+          children: children,
+          direction: 'ltr',
+          format: '',
+          indent: 0,
+          listType: 'bullet',
+          start: 1,
+          tag: 'ul',
+          version: 1
+        });
+      });
+      litexmlService.registerXMLReader('li', function (xmlNode, children) {
+        return INodeHelper.createElementNode('listitem', {
+          children: children,
+          direction: 'ltr',
+          format: '',
+          indent: 0,
+          type: 'listitem',
+          version: 1
+        });
+      });
     }
   }, {
     key: "registerMarkdown",

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

@@ -0,0 +1,16 @@
+import { LexicalEditor } from 'lexical';
+import type LitexmlDataSource from '../data-source/litexml-data-source';
+export declare const LITEXML_APPLY_COMMAND: import("lexical").LexicalCommand<{
+    litexml: string | string[];
+}>;
+export declare const LITEXML_REMOVE_COMMAND: import("lexical").LexicalCommand<{
+    id: string;
+}>;
+export declare const LITEXML_INSERT_COMMAND: import("lexical").LexicalCommand<{
+    beforeId: string;
+    litexml: string;
+} | {
+    afterId: string;
+    litexml: string;
+}>;
+export declare function registerLiteXMLCommand(editor: LexicalEditor, dataSource: LitexmlDataSource): () => void;

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

@@ -0,0 +1,94 @@
+import { mergeRegister } from '@lexical/utils';
+import { $getNodeByKey, $insertNodes, $isElementNode, COMMAND_PRIORITY_EDITOR, createCommand } from 'lexical';
+import { $closest } from "../../../editor-kernel";
+import { $parseSerializedNodeImpl } from "../utils";
+export var LITEXML_APPLY_COMMAND = createCommand('LITEXML_APPLY_COMMAND');
+export var LITEXML_REMOVE_COMMAND = createCommand('LITEXML_REMOVE_COMMAND');
+export var LITEXML_INSERT_COMMAND = createCommand('LITEXML_INSERT_COMMAND');
+export function registerLiteXMLCommand(editor, dataSource) {
+  return mergeRegister(editor.registerCommand(LITEXML_APPLY_COMMAND, function (payload) {
+    var litexml = payload.litexml;
+    var arrayXml = Array.isArray(litexml) ? litexml : [litexml];
+    editor.update(function () {
+      arrayXml.forEach(function (xml) {
+        var inode = dataSource.readLiteXMLToInode(xml);
+        var prevNode = null;
+        inode.root.children.forEach(function (child) {
+          try {
+            var oldNode = $getNodeByKey(child.id);
+            var newNode = $parseSerializedNodeImpl(child, editor);
+            if (oldNode) {
+              prevNode = oldNode.replace(newNode, $isElementNode(newNode));
+            } else {
+              if (prevNode) {
+                if (!newNode.isInline()) {
+                  var prevBlock = $closest(prevNode, function (node) {
+                    return node.isInline() === false;
+                  });
+                  if (prevBlock) {
+                    prevNode = prevBlock.insertAfter(newNode);
+                  } else {
+                    $insertNodes([newNode]);
+                    prevNode = newNode;
+                  }
+                } else {
+                  prevNode = prevNode.insertAfter(newNode);
+                }
+              } else {
+                $insertNodes([newNode]);
+                prevNode = newNode;
+              }
+            }
+          } catch (error) {
+            console.error('Error replacing node:', error);
+          }
+        });
+      });
+    });
+    return false;
+  }, COMMAND_PRIORITY_EDITOR // Priority
+  ), editor.registerCommand(LITEXML_REMOVE_COMMAND, function (payload) {
+    var id = payload.id;
+    editor.update(function () {
+      var node = $getNodeByKey(id);
+      if (node) {
+        node.remove();
+      }
+    });
+    return false;
+  }, COMMAND_PRIORITY_EDITOR // Priority
+  ), editor.registerCommand(LITEXML_INSERT_COMMAND, function (payload) {
+    var litexml = payload.litexml;
+    var isBefore = ('beforeId' in payload);
+    var inode = dataSource.readLiteXMLToInode(litexml);
+    editor.update(function () {
+      try {
+        var referenceNode = null;
+        if (isBefore) {
+          referenceNode = $getNodeByKey(payload.beforeId);
+        } else {
+          referenceNode = $getNodeByKey(payload.afterId);
+        }
+        if (!referenceNode) {
+          throw new Error('Reference node not found for insertion.');
+        }
+        var newNodes = inode.root.children.map(function (child) {
+          return $parseSerializedNodeImpl(child, editor);
+        });
+        if (isBefore) {
+          referenceNode = referenceNode.insertBefore(newNodes);
+        } else {
+          newNodes.forEach(function (node) {
+            if (referenceNode) {
+              referenceNode = referenceNode.insertAfter(node);
+            }
+          });
+        }
+      } catch (error) {
+        console.error('Error inserting node:', error);
+      }
+    });
+    return false;
+  }, COMMAND_PRIORITY_EDITOR // Priority
+  ));
+}

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

@@ -0,0 +1,60 @@
+import type { LexicalEditor } from 'lexical';
+import { DataSource } from "../../../editor-kernel";
+import type { IWriteOptions } from "../../../editor-kernel/data-source";
+import type { ILitexmlService } from '../service/litexml-service';
+/**
+ * LitexmlDataSource - Handles conversion between Lexical editor state and XML format
+ * Provides read (parse XML to Lexical) and write (export Lexical to XML) capabilities
+ */
+export default class LitexmlDataSource extends DataSource {
+    protected dataType: string;
+    private litexmlService;
+    private ctx;
+    constructor(dataType?: string, service?: ILitexmlService);
+    readLiteXMLToInode(litexml: string): any;
+    /**
+     * Parse XML string and set it to the editor
+     * @param editor - The Lexical editor instance
+     * @param data - XML string to parse
+     */
+    read(editor: LexicalEditor, data: string): void;
+    /**
+     * Export editor content to XML format
+     * @param editor - The Lexical editor instance
+     * @param options - Write options (e.g., selection flag)
+     * @returns XML string representation of the editor content
+     */
+    write(editor: LexicalEditor, options?: IWriteOptions): any;
+    /**
+     * Parse XML string using browser's built-in parser
+     */
+    private parseXMLString;
+    /**
+     * Convert XML document to Lexical node structure
+     */
+    private xmlToLexical;
+    /**
+     * Recursively process XML elements and convert to Lexical nodes
+     */
+    private processXMLElement;
+    /**
+     * Process XML element's children
+     */
+    private processXMLChildren;
+    /**
+     * Convert Lexical node structure to XML string
+     */
+    private lexicalToXML;
+    /**
+     * Recursively convert Lexical nodes to XML elements
+     */
+    private nodesToXML;
+    /**
+     * Build XML attribute string from attributes object
+     */
+    private buildXMLAttributes;
+    /**
+     * Escape XML special characters
+     */
+    private escapeXML;
+}