@lobehub/editor 1.29.0 → 1.31.0

package/es/editor-kernel/kernel.js

@@ -29,7 +29,7 @@ import { createDebugLogger } from "../utils/debug";
 import { getHotkeyById, registerHotkey as _registerHotkey } from "../utils/hotkey/registerHotkey";
 import { registerEvent } from "./event";
 import { KernelPlugin } from "./plugin";
-import { createEmptyEditorState } from "./utils";
+import { createEmptyEditorState, noop } from "./utils";
 templateSettings.interpolate = /{{([\S\s]+?)}}/g;
 export var Kernel = /*#__PURE__*/function (_EventEmitter) {
   _inherits(Kernel, _EventEmitter);
@@ -687,7 +687,7 @@ export var Kernel = /*#__PURE__*/function (_EventEmitter) {
       }
       var listenersInPriorityOrder = commandsMap.get(command);
       if (listenersInPriorityOrder === undefined) {
-        return function () {};
+        return noop;
       }
       var listeners = listenersInPriorityOrder[priority];
       listeners.add(listener);

package/es/editor-kernel/utils.d.ts

@@ -30,5 +30,6 @@ export declare function getKernelFromEditor(editor: LexicalEditor): IEditorKerne
  * @returns
  */
 export declare function compareNodeOrder(nodeA: LexicalNode, nodeB: LexicalNode): number;
-export declare function closest(node: LexicalNode | ElementNode | null, test: (node: LexicalNode) => boolean): LexicalNode | null;
+export declare function $closest(node: LexicalNode | ElementNode | null, test: (node: LexicalNode) => boolean): LexicalNode | null;
 export declare function $closestNodeType(node: LexicalNode | ElementNode | null, type: string | string[]): LexicalNode | null;
+export declare function moment(): Promise<unknown>;

package/es/editor-kernel/utils.js

@@ -109,7 +109,7 @@ export function compareNodeOrder(nodeA, nodeB) {
   // This case should not happen as we checked for equality at the start
   return 0;
 }
-export function closest(node, test) {
+export function $closest(node, test) {
   var current = node;
   while (current) {
     if (test(current)) {
@@ -120,7 +120,14 @@ export function closest(node, test) {
   return null;
 }
 export function $closestNodeType(node, type) {
-  return closest(node, function (n) {
+  return $closest(node, function (n) {
     return Array.isArray(type) ? type.includes(n.getType()) : n.getType() === type;
   });
+}
+export function moment() {
+  return new Promise(function (resolve) {
+    queueMicrotask(function () {
+      return resolve(true);
+    });
+  });
 }

package/es/index.d.ts

@@ -10,6 +10,7 @@ export * from './plugins/image';
 export * from './plugins/link';
 export * from './plugins/link-highlight';
 export * from './plugins/list';
+export * from './plugins/litexml';
 export * from './plugins/markdown';
 export * from './plugins/math';
 export * from './plugins/mention';

package/es/index.js

@@ -10,6 +10,7 @@ export * from "./plugins/image";
 export * from "./plugins/link";
 export * from "./plugins/link-highlight";
 export * from "./plugins/list";
+export * from "./plugins/litexml";
 export * from "./plugins/markdown";
 export * from "./plugins/math";
 export * from "./plugins/mention";

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

@@ -17,6 +17,7 @@ import { $setSelection, TextNode } from 'lexical';
 import { INodeHelper } from "../../../editor-kernel/inode/helper";
 import { KernelPlugin } from "../../../editor-kernel/plugin";
 import { $createCursorNode, cursorNodeSerialized } from "../../common";
+import { ILitexmlService } from "../../litexml";
 import { IMarkdownShortCutService } from "../../markdown/service/shortcut";
 import { registerCodeInlineCommand } from "../command";
 import { $createCodeNode, CodeNode } from "../node/code";
@@ -49,12 +50,34 @@ export var CodePlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
           node.replace($createCodeNode(node.getTextContent())).insertAfter($createCursorNode());
         }
       }));
+      this.registerMarkdown();
+      this.registerLiteXml();
+    }
+  }, {
+    key: "registerLiteXml",
+    value: function registerLiteXml() {
+      var litexmlService = this.kernel.requireService(ILitexmlService);
+      if (!litexmlService) {
+        return;
+      }
+      litexmlService.registerXMLWriter(CodeNode.getType(), function (node, ctx) {
+        return ctx.createXmlNode('codeInline', {});
+      });
+      litexmlService.registerXMLReader('codeInline', function (xmlElement, children) {
+        return INodeHelper.createElementNode(CodeNode.getType(), {
+          children: children
+        });
+      });
+    }
+  }, {
+    key: "registerMarkdown",
+    value: function registerMarkdown() {
       var markdownService = this.kernel.requireService(IMarkdownShortCutService);
       if (!markdownService) {
         return;
       }
       markdownService.registerMarkdownWriter(CodeNode.getType(), function (ctx, node) {
-        ctx.appendLine("`".concat(node.getTextContent(), "`"));
+        ctx.appendLine("`".concat(node.getTextContent().replaceAll("\uFEFF", ''), "`"));
         return true;
       });
       markdownService.registerMarkdownShortCuts([{

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

@@ -17,6 +17,7 @@ import { $createCodeNode, $isCodeHighlightNode, $isCodeNode, CodeHighlightNode,
 import { $getSelection, $isRangeSelection, COMMAND_PRIORITY_EDITOR, PASTE_COMMAND, TabNode } 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 { CustomShikiTokenizer, registerCodeCommand } from "../command";
 import { getCodeLanguageByInput } from "../utils/language";
@@ -121,11 +122,54 @@ export var CodeblockPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
         return false;
       }, COMMAND_PRIORITY_EDITOR));
       this.registerMarkdown();
+      this.registerLiteXml();
+    }
+  }, {
+    key: "registerLiteXml",
+    value: function registerLiteXml() {
+      var _this2 = this;
+      var litexmlService = this.kernel.requireService(ILitexmlService);
+      if (!litexmlService) {
+        return;
+      }
+      litexmlService.registerXMLWriter(CodeNode.getType(), function (node, ctx) {
+        var codeNode = node;
+        var xmlNode = ctx.createXmlNode('code', {
+          lang: codeNode.getLanguage() || 'plaintext'
+        }, codeNode.getTextContent());
+        return xmlNode;
+      });
+      litexmlService.registerXMLReader('code', function (xmlElment, children) {
+        var _this2$config;
+        var text = children.map(function (v) {
+          return v.text || '';
+        }).join('');
+        return INodeHelper.createElementNode(CodeNode.getType(), {
+          children: text.split('\n').flatMap(function (text, index, arr) {
+            var textNode = INodeHelper.createTextNode(text);
+            textNode.type = 'code-highlight';
+            if (index === arr.length - 1) {
+              return textNode;
+            }
+            return [textNode, {
+              type: 'linebreak',
+              version: 1
+            }];
+          }).flat(),
+          direction: 'ltr',
+          format: '',
+          indent: 0,
+          language: xmlElment.getAttribute('lang'),
+          textStyle: '--shiki-dark:var(--color-info);--shiki-light:var(--color-info)',
+          theme: "".concat(toMarkdownTheme((_this2$config = _this2.config) === null || _this2$config === void 0 ? void 0 : _this2$config.shikiTheme), " needUpdate"),
+          version: 1
+        });
+      });
     }
   }, {
     key: "registerMarkdown",
     value: function registerMarkdown() {
-      var _this2 = this;
+      var _this3 = this;
       var kernel = this.kernel;
       var markdownService = kernel.requireService(IMarkdownShortCutService);
       if (!markdownService) {
@@ -160,7 +204,7 @@ export var CodeblockPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
         }
       });
       markdownService.registerMarkdownReader('code', function (node) {
-        var _this2$config;
+        var _this3$config;
         var language = node.lang ? getCodeLanguageByInput(node.lang) : 'plaintext';
         return INodeHelper.createElementNode('code', {
           children: node.value.split('\n').flatMap(function (text, index, arr) {
@@ -179,7 +223,7 @@ export var CodeblockPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
           indent: 0,
           language: language,
           textStyle: '--shiki-dark:var(--color-info);--shiki-light:var(--color-info)',
-          theme: "".concat(toMarkdownTheme((_this2$config = _this2.config) === null || _this2$config === void 0 ? void 0 : _this2$config.shikiTheme), " needUpdate"),
+          theme: "".concat(toMarkdownTheme((_this3$config = _this3.config) === null || _this3$config === void 0 ? void 0 : _this3$config.shikiTheme), " needUpdate"),
           version: 1
         });
       });

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

@@ -25,8 +25,11 @@ import { registerDragonSupport } from '@lexical/dragon';
 import { registerHistory } from '@lexical/history';
 import { $createHeadingNode, $createQuoteNode, $isHeadingNode, $isQuoteNode, HeadingNode, QuoteNode, registerRichText } from '@lexical/rich-text';
 import { CAN_USE_DOM } from '@lexical/utils';
-import { $createLineBreakNode, $createParagraphNode, $getSelection, $isRangeSelection, $isTextNode, COMMAND_PRIORITY_HIGH, INSERT_LINE_BREAK_COMMAND, INSERT_PARAGRAPH_COMMAND } from 'lexical';
+import { $createLineBreakNode, $createParagraphNode, $getSelection, $isRangeSelection, $isTextNode, COMMAND_PRIORITY_HIGH, INSERT_LINE_BREAK_COMMAND, INSERT_PARAGRAPH_COMMAND, ParagraphNode, TEXT_TYPE_TO_FORMAT, TextNode } from 'lexical';
+import { noop } from "../../../editor-kernel";
+import { INodeHelper } from "../../../editor-kernel/inode/helper";
 import { KernelPlugin } from "../../../editor-kernel/plugin";
+import { ILitexmlService } from "../../litexml";
 import { IMarkdownShortCutService } from "../../markdown/service/shortcut";
 import { isPunctuationChar } from "../../markdown/utils";
 import { registerCommands } from "../command";
@@ -199,7 +202,7 @@ export var CommonPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
         markdownService.registerMarkdownShortCuts(textFormatShortcuts);
       }
       markdownService.registerMarkdownWriter('paragraph', function (ctx) {
-        ctx.wrap('', '\n');
+        ctx.wrap('', '\n\n');
       });
       markdownService.registerMarkdownWriter('quote', function (ctx, node) {
         if ($isQuoteNode(node)) {
@@ -323,7 +326,7 @@ export var CommonPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
     key: "onInit",
     value: function onInit(editor) {
       var _this$config2;
-      this.registerClears(registerRichText(editor), CAN_USE_DOM ? registerDragonSupport(editor) : function () {}, registerHistory(editor, this.kernel.getHistoryState(), 300), registerHeaderBackspace(editor), registerRichKeydown(editor, this.kernel, {
+      this.registerClears(registerRichText(editor), CAN_USE_DOM ? registerDragonSupport(editor) : noop, registerHistory(editor, this.kernel.getHistoryState(), 300), registerHeaderBackspace(editor), registerRichKeydown(editor, this.kernel, {
         enableHotkey: (_this$config2 = this.config) === null || _this$config2 === void 0 ? void 0 : _this$config2.enableHotkey
       }), registerCommands(editor), registerBreakLineClick(editor), registerCursorNode(editor), registerLastElement(editor),
       // Convert soft line breaks (Shift+Enter) to hard line breaks (paragraph breaks)
@@ -363,6 +366,108 @@ export var CommonPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
         return true; // Prevent default line break behavior
       }, COMMAND_PRIORITY_HIGH));
       this.registerMarkdown(this.kernel);
+      this.registerLiteXml();
+    }
+  }, {
+    key: "registerLiteXml",
+    value: function registerLiteXml() {
+      var litexmlService = this.kernel.requireService(ILitexmlService);
+      if (!litexmlService) {
+        return;
+      }
+      litexmlService.registerXMLWriter(TextNode.getType(), function (node, ctx) {
+        var attr = {};
+        if ($isTextNode(node)) {
+          if (node.hasFormat('bold')) {
+            attr['bold'] = 'true';
+          }
+          if (node.hasFormat('italic')) {
+            attr['italic'] = 'true';
+          }
+          if (node.hasFormat('underline')) {
+            attr['underline'] = 'true';
+          }
+          if (node.hasFormat('strikethrough')) {
+            attr['strikethrough'] = 'true';
+          }
+          if (node.hasFormat('subscript')) {
+            attr['subscript'] = 'true';
+          }
+          if (node.hasFormat('superscript')) {
+            attr['superscript'] = 'true';
+          }
+          return ctx.createXmlNode('span', attr, node.getTextContent());
+        }
+        return false;
+      });
+      litexmlService.registerXMLReader('span', function (xmlElement) {
+        var textContent = xmlElement.textContent || '';
+        var bold = xmlElement.getAttribute('bold');
+        var italic = xmlElement.getAttribute('italic');
+        var underline = xmlElement.getAttribute('underline');
+        var strikethrough = xmlElement.getAttribute('strikethrough');
+        var subscript = xmlElement.getAttribute('subscript');
+        var superscript = xmlElement.getAttribute('superscript');
+        var format = 0;
+        if (bold === 'true') {
+          format |= TEXT_TYPE_TO_FORMAT['bold'];
+        }
+        if (italic === 'true') {
+          format |= TEXT_TYPE_TO_FORMAT['italic'];
+        }
+        if (underline === 'true') {
+          format |= TEXT_TYPE_TO_FORMAT['underline'];
+        }
+        if (strikethrough === 'true') {
+          format |= TEXT_TYPE_TO_FORMAT['strikethrough'];
+        }
+        if (subscript === 'true') {
+          format |= TEXT_TYPE_TO_FORMAT['subscript'];
+        }
+        if (superscript === 'true') {
+          format |= TEXT_TYPE_TO_FORMAT['superscript'];
+        }
+        return INodeHelper.createTextNode(textContent, {
+          detail: 0,
+          format: format,
+          mode: 'normal',
+          style: ''
+        });
+      });
+      litexmlService.registerXMLWriter('quote', function (node, ctx) {
+        if ($isQuoteNode(node)) {
+          return ctx.createXmlNode('quote', {});
+        }
+        return false;
+      });
+      litexmlService.registerXMLWriter('heading', function (node, ctx) {
+        if ($isHeadingNode(node)) {
+          return ctx.createXmlNode(node.getTag(), {});
+        }
+        return false;
+      });
+      litexmlService.registerXMLWriter(ParagraphNode.getType(), function (node, ctx) {
+        return ctx.createXmlNode('p', {});
+      });
+      litexmlService.registerXMLReader('quote', function (xmlElement, children) {
+        return INodeHelper.createElementNode(QuoteNode.getType(), {
+          children: children
+        });
+      });
+      litexmlService.registerXMLReader('p', function (xmlElement, children) {
+        return INodeHelper.createElementNode(ParagraphNode.getType(), {
+          children: children
+        });
+      });
+      var headingTags = ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'];
+      headingTags.forEach(function (tag) {
+        litexmlService.registerXMLReader(tag, function (xmlElement, children) {
+          return INodeHelper.createElementNode(HeadingNode.getType(), {
+            children: children,
+            tag: tag
+          });
+        });
+      });
     }
   }, {
     key: "destroy",

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

@@ -18,7 +18,9 @@ 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 { $wrapNodeInElement } from '@lexical/utils';
 import { $createParagraphNode, $createRangeSelection, $insertNodes, $isRootOrShadowRoot, $setSelection } 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 { IUploadService } from "../../upload";
 import { createDebugLogger } from "../../../utils/debug";
@@ -32,7 +34,6 @@ export var FilePlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
   _inherits(FilePlugin, _KernelPlugin);
   var _super = _createSuper(FilePlugin);
   function FilePlugin(kernel, config) {
-    var _kernel$requireServic;
     var _this;
     _classCallCheck(this, FilePlugin);
     _this = _super.call(this);
@@ -47,21 +48,6 @@ export var FilePlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
     _this.registerDecorator(kernel, FileNode.getType(), function (node, editor) {
       return config !== null && config !== void 0 && config.decorator ? config.decorator(node, editor) : null;
     });
-    (_kernel$requireServic = kernel.requireService(IMarkdownShortCutService)) === null || _kernel$requireServic === void 0 || _kernel$requireServic.registerMarkdownWriter(FileNode.getType(), function (ctx, node) {
-      if ($isFileNode(node)) {
-        if (config !== null && config !== void 0 && config.markdownWriter) {
-          ctx.appendLine(config.markdownWriter(node));
-          return;
-        }
-        if (node.status === 'pending') {
-          ctx.appendLine("Uploading ".concat(node.name, "..."));
-        } else if (node.status === 'error') {
-          ctx.appendLine("Failed to upload ".concat(node.name, ": ").concat(node.message));
-        } else {
-          ctx.appendLine("[".concat(node.name, "](").concat(node.fileUrl, ")"));
-        }
-      }
-    });
     return _this;
   }
   _createClass(FilePlugin, [{
@@ -112,6 +98,66 @@ export var FilePlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
       }());
       this.register(registerFileCommand(editor, this.config.handleUpload));
       this.register(registerFileNodeSelectionObserver(editor));
+      this.registerLiteXml();
+      this.registerMarkdownWriter();
+    }
+  }, {
+    key: "registerLiteXml",
+    value: function registerLiteXml() {
+      var litexmlService = this.kernel.requireService(ILitexmlService);
+      if (!litexmlService) {
+        return;
+      }
+      litexmlService.registerXMLWriter(FileNode.getType(), function (node, ctx) {
+        if ($isFileNode(node)) {
+          var _node$size;
+          return ctx.createXmlNode('file', {
+            fileUrl: node.fileUrl || '',
+            message: node.message || '',
+            name: node.name,
+            size: ((_node$size = node.size) === null || _node$size === void 0 ? void 0 : _node$size.toString()) || '0',
+            status: node.status
+          });
+        }
+        return false;
+      });
+      litexmlService.registerXMLReader('file', function (xmlElement) {
+        var name = xmlElement.getAttribute('name') || 'unknown';
+        var fileUrl = xmlElement.getAttribute('fileUrl') || '';
+        var status = xmlElement.getAttribute('status');
+        return INodeHelper.createTypeNode(FileNode.getType(), {
+          fileUrl: fileUrl,
+          message: xmlElement.getAttribute('message') || '',
+          name: name,
+          size: parseInt(xmlElement.getAttribute('size') || '0', 10),
+          status: status
+        });
+      });
+    }
+  }, {
+    key: "registerMarkdownWriter",
+    value: function registerMarkdownWriter() {
+      var _this3 = this;
+      var markdownService = this.kernel.requireService(IMarkdownShortCutService);
+      if (!markdownService) {
+        return;
+      }
+      markdownService.registerMarkdownWriter(FileNode.getType(), function (ctx, node) {
+        if ($isFileNode(node)) {
+          var _this3$config;
+          if ((_this3$config = _this3.config) !== null && _this3$config !== void 0 && _this3$config.markdownWriter) {
+            ctx.appendLine(_this3.config.markdownWriter(node));
+            return;
+          }
+          if (node.status === 'pending') {
+            ctx.appendLine("Uploading ".concat(node.name, "..."));
+          } else if (node.status === 'error') {
+            ctx.appendLine("Failed to upload ".concat(node.name, ": ").concat(node.message));
+          } else {
+            ctx.appendLine("[".concat(node.name, "](").concat(node.fileUrl, ")"));
+          }
+        }
+      });
     }
   }]);
   return FilePlugin;

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

@@ -15,6 +15,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 { ILitexmlService } from "../../litexml";
 import { IMarkdownShortCutService } from "../../markdown/service/shortcut";
 import { registerHorizontalRuleCommand } from "../command";
 import { $createHorizontalRuleNode, $isHorizontalRuleNode, HorizontalRuleNode } from "../node/HorizontalRuleNode";
@@ -42,8 +43,31 @@ export var HRPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
   _createClass(HRPlugin, [{
     key: "onInit",
     value: function onInit(editor) {
-      var _this$kernel$requireS, _this$kernel$requireS2, _this$kernel$requireS3;
       this.register(registerHorizontalRuleCommand(editor));
+      this.registerMarkdown();
+      this.registerLiteXml();
+    }
+  }, {
+    key: "registerLiteXml",
+    value: function registerLiteXml() {
+      var litexmlService = this.kernel.requireService(ILitexmlService);
+      if (!litexmlService) {
+        return;
+      }
+      litexmlService.registerXMLWriter(HorizontalRuleNode.getType(), function (node, ctx) {
+        if ($isHorizontalRuleNode(node)) {
+          return ctx.createXmlNode('hr', {});
+        }
+        return false;
+      });
+      litexmlService.registerXMLReader('hr', function () {
+        return INodeHelper.createElementNode(HorizontalRuleNode.getType(), {});
+      });
+    }
+  }, {
+    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: /^(---|\*\*\*|___)$/,
         replace: function replace(parentNode, _1, _2, isImport) {

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

@@ -1,21 +1,17 @@
-import { DOMExportOutput, DecoratorNode, EditorConfig, LexicalEditor, LexicalUpdateJSON, NodeKey, SerializedEditor, SerializedLexicalNode, Spread } from 'lexical';
+import { DOMExportOutput, DecoratorNode, EditorConfig, LexicalEditor, LexicalUpdateJSON, NodeKey, SerializedLexicalNode, Spread } from 'lexical';
 export interface ImagePayload {
     altText: string;
     caption?: LexicalEditor;
-    captionsEnabled?: boolean;
     height?: number;
     key?: NodeKey;
     maxWidth?: number;
-    showCaption?: boolean;
     src: string;
     width?: number;
 }
 export type SerializedImageNode = Spread<{
     altText: string;
-    caption: SerializedEditor;
     height?: number;
     maxWidth: number;
-    showCaption: boolean;
     src: string;
     width?: number;
 }, SerializedLexicalNode>;
@@ -25,18 +21,14 @@ export declare class BaseImageNode extends DecoratorNode<any> {
     __width: 'inherit' | number;
     __height: 'inherit' | number;
     __maxWidth: number;
-    __showCaption: boolean;
-    __caption: LexicalEditor;
-    __captionsEnabled: boolean;
     static clone(node: BaseImageNode): BaseImageNode;
     static importJSON(serializedNode: SerializedImageNode): BaseImageNode;
     static getType(): string;
     updateFromJSON(serializedNode: LexicalUpdateJSON<SerializedImageNode>): this;
     exportDOM(): DOMExportOutput;
-    constructor(src: string, altText: string, maxWidth: number, width?: 'inherit' | number, height?: 'inherit' | number, showCaption?: boolean, caption?: LexicalEditor, captionsEnabled?: boolean, key?: NodeKey);
+    constructor(src: string, altText: string, maxWidth: number, width?: 'inherit' | number, height?: 'inherit' | number, key?: NodeKey);
     exportJSON(): SerializedImageNode;
     setWidthAndHeight(width: 'inherit' | number, height: 'inherit' | number): void;
-    setShowCaption(showCaption: boolean): void;
     isInline(): boolean;
     createDOM(config: EditorConfig): HTMLElement;
     updateDOM(): false;

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

@@ -16,11 +16,11 @@ 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 { DecoratorNode, ParagraphNode, RootNode, TextNode, createEditor } from 'lexical';
+import { DecoratorNode } from 'lexical';
 export var BaseImageNode = /*#__PURE__*/function (_DecoratorNode) {
   _inherits(BaseImageNode, _DecoratorNode);
   var _super = _createSuper(BaseImageNode);
-  function BaseImageNode(src, altText, maxWidth, width, height, showCaption, caption, captionsEnabled, key) {
+  function BaseImageNode(src, altText, maxWidth, width, height, key) {
     var _this;
     _classCallCheck(this, BaseImageNode);
     _this = _super.call(this, key);
@@ -29,33 +29,17 @@ export var BaseImageNode = /*#__PURE__*/function (_DecoratorNode) {
     _defineProperty(_assertThisInitialized(_this), "__width", void 0);
     _defineProperty(_assertThisInitialized(_this), "__height", void 0);
     _defineProperty(_assertThisInitialized(_this), "__maxWidth", void 0);
-    _defineProperty(_assertThisInitialized(_this), "__showCaption", void 0);
-    _defineProperty(_assertThisInitialized(_this), "__caption", void 0);
-    // Captions cannot yet be used within editor cells
-    _defineProperty(_assertThisInitialized(_this), "__captionsEnabled", void 0);
     _this.__src = src;
     _this.__altText = altText;
     _this.__maxWidth = maxWidth;
     _this.__width = width || 'inherit';
     _this.__height = height || 'inherit';
-    _this.__showCaption = showCaption || false;
-    _this.__caption = caption || createEditor({
-      namespace: 'Playground/ImageNodeCaption',
-      nodes: [RootNode, TextNode, ParagraphNode]
-    });
-    _this.__captionsEnabled = captionsEnabled || captionsEnabled === undefined;
     return _this;
   }
   _createClass(BaseImageNode, [{
     key: "updateFromJSON",
     value: function updateFromJSON(serializedNode) {
       var node = _get(_getPrototypeOf(BaseImageNode.prototype), "updateFromJSON", this).call(this, serializedNode);
-      var caption = serializedNode.caption;
-      var nestedEditor = node.__caption;
-      var editorState = nestedEditor.parseEditorState(caption.editorState);
-      if (!editorState.isEmpty()) {
-        nestedEditor.setEditorState(editorState);
-      }
       return node;
     }
   }, {
@@ -75,10 +59,8 @@ export var BaseImageNode = /*#__PURE__*/function (_DecoratorNode) {
     value: function exportJSON() {
       return _objectSpread(_objectSpread({}, _get(_getPrototypeOf(BaseImageNode.prototype), "exportJSON", this).call(this)), {}, {
         altText: this.getAltText(),
-        caption: this.__caption.toJSON(),
         height: this.__height === 'inherit' ? 0 : this.__height,
         maxWidth: this.__maxWidth,
-        showCaption: this.__showCaption,
         src: this.getSrc(),
         width: this.__width === 'inherit' ? 0 : this.__width
       });
@@ -90,12 +72,6 @@ export var BaseImageNode = /*#__PURE__*/function (_DecoratorNode) {
       writable.__width = width;
       writable.__height = height;
     }
-  }, {
-    key: "setShowCaption",
-    value: function setShowCaption(showCaption) {
-      var writable = this.getWritable();
-      writable.__showCaption = showCaption;
-    }
   }, {
     key: "isInline",
     value: function isInline() {
@@ -132,7 +108,7 @@ export var BaseImageNode = /*#__PURE__*/function (_DecoratorNode) {
   }], [{
     key: "clone",
     value: function clone(node) {
-      return new BaseImageNode(node.__src, node.__altText, node.__maxWidth, node.__width, node.__height, node.__showCaption, node.__caption, node.__captionsEnabled, node.__key);
+      return new BaseImageNode(node.__src, node.__altText, node.__maxWidth, node.__width, node.__height, node.__key);
     }
   }, {
     key: "importJSON",
@@ -141,10 +117,9 @@ export var BaseImageNode = /*#__PURE__*/function (_DecoratorNode) {
         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 new BaseImageNode(src, altText, maxWidth, width, height, showCaption);
+      return new BaseImageNode(src, altText, maxWidth, width, height);
     }
   }, {
     key: "getType",

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

@@ -27,5 +27,5 @@ export declare class BlockImageNode extends BaseImageNode {
     decorate(): any;
     createDOM(config: EditorConfig): HTMLElement;
 }
-export declare function $createBlockImageNode({ altText, height, maxWidth, captionsEnabled, src, width, showCaption, caption, key, }: ImagePayload): BlockImageNode;
+export declare function $createBlockImageNode({ altText, height, maxWidth, src, width, key, }: ImagePayload): BlockImageNode;
 export declare function $isBlockImageNode(node: LexicalNode): node is BlockImageNode;