@lobehub/editor 1.31.2 → 1.33.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/editor-kernel/kernel.d.ts

@@ -1,8 +1,8 @@
 import { HistoryState } from '@lexical/history';
 import EventEmitter from 'eventemitter3';
-import { CommandListener, CommandListenerPriority, CommandPayloadType, DecoratorNode, LexicalCommand, LexicalEditor, LexicalNodeConfig } from 'lexical';
+import { CommandListener, CommandListenerPriority, CommandPayloadType, LexicalCommand, LexicalEditor, LexicalNodeConfig } from 'lexical';
 import { HotkeyId } from "../types/hotkey";
-import { IEditor, IEditorKernel, IEditorPluginConstructor, IPlugin, IServiceID } from "../types/kernel";
+import { IDecorator, IEditor, IEditorKernel, IEditorPluginConstructor, IPlugin, IServiceID } from "../types/kernel";
 import { ILocaleKeys } from "../types/locale";
 import { HotkeyOptions, HotkeysEvent } from "../utils/hotkey/registerHotkey";
 import DataSource from './data-source';
@@ -45,8 +45,8 @@ export declare class Kernel extends EventEmitter implements IEditorKernel {
     blur(): void;
     getDocument(type: string): DataSource | undefined;
     getSelectionDocument(type: string): unknown | null;
-    registerDecorator(name: string, decorator: (_node: DecoratorNode<any>, _editor: LexicalEditor) => any): this;
-    getDecorator(name: string): ((_node: DecoratorNode<any>, _editor: LexicalEditor) => any) | undefined;
+    registerDecorator(name: string, decorator: IDecorator): this;
+    getDecorator(name: string): IDecorator | undefined;
     /**
      * Unregister a decorator
      * @param name Decorator name

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, noop } from "./utils";
+import { EDITOR_THEME_KEY, createEmptyEditorState, generateEditorId, noop, registerEditorKernel, unregisterEditorKernel } from "./utils";
 templateSettings.interpolate = /{{([\S\s]+?)}}/g;
 export var Kernel = /*#__PURE__*/function (_EventEmitter) {
   _inherits(Kernel, _EventEmitter);
@@ -43,7 +43,7 @@ export var Kernel = /*#__PURE__*/function (_EventEmitter) {
     _defineProperty(_assertThisInitialized(_this), "pluginsConfig", new Map());
     _defineProperty(_assertThisInitialized(_this), "pluginsInstances", []);
     _defineProperty(_assertThisInitialized(_this), "nodes", []);
-    _defineProperty(_assertThisInitialized(_this), "themes", {});
+    _defineProperty(_assertThisInitialized(_this), "themes", _defineProperty({}, EDITOR_THEME_KEY, generateEditorId()));
     // Used to store theme configuration
     _defineProperty(_assertThisInitialized(_this), "decorators", {});
     _defineProperty(_assertThisInitialized(_this), "serviceMap", new Map());
@@ -127,6 +127,7 @@ export var Kernel = /*#__PURE__*/function (_EventEmitter) {
     key: "destroy",
     value: function destroy() {
       var _this$editor2;
+      unregisterEditorKernel(this.themes[EDITOR_THEME_KEY]);
       this.logger.info("\uD83D\uDDD1\uFE0F Destroying editor with ".concat(this.pluginsInstances.length, " plugins"));
       (_this$editor2 = this.editor) === null || _this$editor2 === void 0 || _this$editor2.setEditorState(createEmptyEditorState());
       this.dataTypeMap.clear();
@@ -140,6 +141,8 @@ export var Kernel = /*#__PURE__*/function (_EventEmitter) {
       this.serviceMap.clear();
       // Clear decorators to prevent memory leaks
       this.decorators = {};
+      // Clear themes
+      this.themes = {};
       this.logger.info('✅ Editor destroyed');
     }
   }, {
@@ -178,6 +181,7 @@ export var Kernel = /*#__PURE__*/function (_EventEmitter) {
         }
       }
       this.logger.info("\uD83D\uDCDD Creating editor with ".concat(this.nodes.length, " nodes"));
+      registerEditorKernel(this.themes[EDITOR_THEME_KEY], this);
       var editor = this.editor = createEditor({
         // @ts-expect-error Inject into lexical editor instance
         __kernel: this,

package/es/editor-kernel/react/PortalContainer.d.ts

@@ -0,0 +1,11 @@
+import { LexicalEditor, LexicalNode } from 'lexical';
+import React from 'react';
+export interface PortalContainerProps {
+    children: React.ReactNode;
+    className?: string;
+    editor: LexicalEditor;
+    node: LexicalNode;
+    style?: React.CSSProperties;
+}
+export declare const LexicalPortalContainer: React.ForwardRefExoticComponent<PortalContainerProps & React.RefAttributes<HTMLDivElement | null>>;
+export default LexicalPortalContainer;

package/es/editor-kernel/react/PortalContainer.js

@@ -0,0 +1,32 @@
+import React, { forwardRef, useEffect, useImperativeHandle, useRef } from 'react';
+import { jsx as _jsx } from "react/jsx-runtime";
+export var LexicalPortalContainer = /*#__PURE__*/forwardRef(function (_ref, ref) {
+  var editor = _ref.editor,
+    node = _ref.node,
+    children = _ref.children;
+  var divRef = useRef(null);
+  useImperativeHandle(ref, function () {
+    return divRef.current;
+  }, []);
+  useEffect(function () {
+    return function () {
+      if (divRef.current) {
+        // @ts-expect-error not error
+        delete divRef.current["__lexicalKey_".concat(editor._key)];
+      }
+    };
+  }, [editor, node]);
+  return /*#__PURE__*/_jsx("div", {
+    ref: function ref(dom) {
+      divRef.current = dom;
+      if (dom) {
+        var prop = "__lexicalKey_".concat(editor._key);
+        // @ts-expect-error not error
+        dom[prop] = node.getKey();
+      }
+    },
+    children: children
+  });
+});
+LexicalPortalContainer.displayName = 'LexicalPortalContainer';
+export default LexicalPortalContainer;

package/es/editor-kernel/react/index.d.ts

@@ -1,4 +1,5 @@
 export { LexicalErrorBoundary } from './LexicalErrorBoundary';
+export { LexicalPortalContainer } from './PortalContainer';
 export { useLexicalComposerContext } from './react-context';
 export { ReactEditor } from './react-editor';
 export { useLexicalEditor } from './useLexicalEditor';

package/es/editor-kernel/react/index.js

@@ -1,4 +1,5 @@
 export { LexicalErrorBoundary } from "./LexicalErrorBoundary";
+export { LexicalPortalContainer } from "./PortalContainer";
 export { useLexicalComposerContext } from "./react-context";
 export { ReactEditor } from "./react-editor";
 export { useLexicalEditor } from "./useLexicalEditor";

package/es/editor-kernel/react/useDecorators.js

@@ -59,6 +59,7 @@ export function useDecorators(editor, ErrorBoundary) {
     for (var _i = 0, _decoratorKeys = decoratorKeys; _i < _decoratorKeys.length; _i++) {
       var _editor$getLexicalEdi3;
       var nodeKey = _decoratorKeys[_i];
+      var decorator = decorators[nodeKey];
       var reactDecorator = /*#__PURE__*/_jsx(ErrorBoundary, {
         onError: function onError(e) {
           var _editor$getLexicalEdi2;
@@ -66,12 +67,12 @@ export function useDecorators(editor, ErrorBoundary) {
         },
         children: /*#__PURE__*/_jsx(Suspense, {
           fallback: null,
-          children: decorators[nodeKey]
+          children: 'render' in decorator ? decorator.render : decorator
         })
       });
       var element = (_editor$getLexicalEdi3 = editor.getLexicalEditor()) === null || _editor$getLexicalEdi3 === void 0 ? void 0 : _editor$getLexicalEdi3.getElementByKey(nodeKey);
       if (element !== null && element !== undefined) {
-        decoratedPortals.push( /*#__PURE__*/createPortal(reactDecorator, element, nodeKey));
+        decoratedPortals.push( /*#__PURE__*/createPortal(reactDecorator, 'queryDOM' in decorator ? decorator.queryDOM(element) : element, nodeKey));
       }
     }
     return decoratedPortals;

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

@@ -1,4 +1,4 @@
-import { ElementNode, LexicalEditor, LexicalNode, NodeKey } from 'lexical';
+import { EditorConfig, ElementNode, LexicalEditor, LexicalNode, NodeKey } from 'lexical';
 import type { IEditorKernel, IServiceID } from "../types";
 export declare const DOM_ELEMENT_TYPE = 1;
 export declare const DOM_TEXT_TYPE = 3;
@@ -23,6 +23,11 @@ export declare function isDocumentFragment(x: unknown): x is DocumentFragment;
 export declare function getParentElement(node: Node): HTMLElement | null;
 export declare function $getNearestNodeFromDOMNode(startingDOM: Node, editor: LexicalEditor, editorState?: ReturnType<LexicalEditor['getEditorState']>): LexicalNode | null;
 export declare function getKernelFromEditor(editor: LexicalEditor): IEditorKernel;
+export declare const EDITOR_THEME_KEY = "__editorId";
+export declare function generateEditorId(): string;
+export declare function registerEditorKernel(id: string, kernel: IEditorKernel): void;
+export declare function unregisterEditorKernel(id: string): void;
+export declare function getKernelFromEditorConfig(config: EditorConfig): IEditorKernel | null;
 /**
  *
  * @param nodeA
@@ -33,3 +38,4 @@ export declare function compareNodeOrder(nodeA: LexicalNode, nodeB: LexicalNode)
 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>;
+export declare function reconcileDecorator(activeEditor: LexicalEditor, key: NodeKey, decorator: unknown): void;

package/es/editor-kernel/utils.js

@@ -69,6 +69,23 @@ export function getKernelFromEditor(editor) {
   // @ts-expect-error __kernel is injected into the lexical editor instance
   return ((_editor$_createEditor = editor._createEditorArgs) === null || _editor$_createEditor === void 0 ? void 0 : _editor$_createEditor.__kernel) || editor._kernel;
 }
+var EditorId = 0;
+export var EDITOR_THEME_KEY = '__editorId';
+export function generateEditorId() {
+  EditorId += 1;
+  return "editor-".concat(EditorId);
+}
+var EditorMap = new Map();
+export function registerEditorKernel(id, kernel) {
+  EditorMap.set(id, kernel);
+}
+export function unregisterEditorKernel(id) {
+  EditorMap.delete(id);
+}
+export function getKernelFromEditorConfig(config) {
+  var id = config.theme[EDITOR_THEME_KEY];
+  return EditorMap.get(id) || null;
+}
 
 /**
  *
@@ -130,4 +147,21 @@ export function moment() {
       return resolve(true);
     });
   });
+}
+function cloneDecorators(editor) {
+  var currentDecorators = editor._decorators;
+  var pendingDecorators = Object.assign({}, currentDecorators);
+  editor._pendingDecorators = pendingDecorators;
+  return pendingDecorators;
+}
+export function reconcileDecorator(activeEditor, key, decorator) {
+  var pendingDecorators = activeEditor._pendingDecorators;
+  var currentDecorators = activeEditor._decorators;
+  if (pendingDecorators === null) {
+    if (currentDecorators[key] === decorator) {
+      return;
+    }
+    pendingDecorators = cloneDecorators(activeEditor);
+  }
+  pendingDecorators[key] = decorator;
 }

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/file/node/FileNode.js

@@ -123,8 +123,18 @@ export var FileNode = /*#__PURE__*/function (_DecoratorNode) {
   }, {
     key: "decorate",
     value: function decorate(editor) {
-      var _getKernelFromEditor, _getKernelFromEditor$;
-      return ((_getKernelFromEditor = getKernelFromEditor(editor)) === null || _getKernelFromEditor === void 0 || (_getKernelFromEditor$ = _getKernelFromEditor.getDecorator('file')) === null || _getKernelFromEditor$ === void 0 ? void 0 : _getKernelFromEditor$(this, editor)) || null;
+      var _getKernelFromEditor;
+      var decorator = (_getKernelFromEditor = getKernelFromEditor(editor)) === null || _getKernelFromEditor === void 0 ? void 0 : _getKernelFromEditor.getDecorator('file');
+      if (!decorator) {
+        return null;
+      }
+      if (typeof decorator === 'function') {
+        return decorator(this, editor);
+      }
+      return {
+        queryDOM: decorator.queryDOM,
+        render: decorator.render(this, editor)
+      };
     }
   }], [{
     key: "getType",

package/es/plugins/hr/node/HorizontalRuleNode.js

@@ -54,8 +54,18 @@ export var HorizontalRuleNode = /*#__PURE__*/function (_DecoratorNode) {
   }, {
     key: "decorate",
     value: function decorate(editor) {
-      var _getKernelFromEditor, _getKernelFromEditor$;
-      return ((_getKernelFromEditor = getKernelFromEditor(editor)) === null || _getKernelFromEditor === void 0 || (_getKernelFromEditor$ = _getKernelFromEditor.getDecorator('horizontalrule')) === null || _getKernelFromEditor$ === void 0 ? void 0 : _getKernelFromEditor$(this, editor)) || null;
+      var _getKernelFromEditor;
+      var decorator = (_getKernelFromEditor = getKernelFromEditor(editor)) === null || _getKernelFromEditor === void 0 ? void 0 : _getKernelFromEditor.getDecorator('horizontalrule');
+      if (!decorator) {
+        return null;
+      }
+      if (typeof decorator === 'function') {
+        return decorator(this, editor);
+      }
+      return {
+        queryDOM: decorator.queryDOM,
+        render: decorator.render(this, editor)
+      };
     }
   }], [{
     key: "getType",

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;
+}();