@lobehub/editor 1.5.1 → 1.5.2

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

@@ -37,6 +37,15 @@ export declare class Kernel extends EventEmitter implements IEditorKernel {
     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;
+    /**
+     * Unregister a decorator
+     * @param name Decorator name
+     */
+    unregisterDecorator(name: string): boolean;
+    /**
+     * Get all registered decorator names
+     */
+    getRegisteredDecorators(): string[];
     /**
      * Support registering target data source
      * @param dataSource Data source

package/es/editor-kernel/kernel.js

@@ -25,6 +25,7 @@ import { get, merge, template, templateSettings } from 'lodash-es';
 import defaultLocale from "../locale";
 import { $isRootTextContentEmpty } from "../plugins/common/utils";
 import { registerEvent } from "./event";
+import { KernelPlugin } from "./plugin";
 import { createEmptyEditorState } from "./utils";
 templateSettings.interpolate = /{{([\S\s]+?)}}/g;
 export var Kernel = /*#__PURE__*/function (_EventEmitter) {
@@ -118,6 +119,9 @@ export var Kernel = /*#__PURE__*/function (_EventEmitter) {
       this.pluginsInstances = [];
       // Clear services to support hot reload
       this.serviceMap.clear();
+      // Clear decorators to prevent memory leaks
+      this.decorators = {};
+      console.debug('[Editor] Cleared all decorators during destroy');
     }
   }, {
     key: "getRootElement",
@@ -224,7 +228,28 @@ export var Kernel = /*#__PURE__*/function (_EventEmitter) {
   }, {
     key: "registerDecorator",
     value: function registerDecorator(name, decorator) {
+      if (this.decorators[name]) {
+        if (this.hotReloadMode) {
+          // In hot reload mode, allow decorator override with warning
+          console.warn("[Hot Reload] Overriding decorator \"".concat(name, "\""));
+          this.decorators[name] = decorator;
+          return this;
+        } else {
+          // Check if it's the same decorator function
+          var existingDecorator = this.decorators[name];
+          if (existingDecorator === decorator) {
+            // Same decorator function, no need to re-register
+            console.warn("[Editor] Decorator \"".concat(name, "\" is already registered with the same function"));
+            return this;
+          }
+
+          // Different decorator function in production mode
+          console.error("[Editor] Attempting to register duplicate decorator \"".concat(name, "\". Enable hot reload mode if this is intended."));
+          throw new Error("Decorator with name \"".concat(name, "\" is already registered."));
+        }
+      }
       this.decorators[name] = decorator;
+      console.debug("[Editor] Registered decorator: ".concat(name));
       return this;
     }
   }, {
@@ -233,6 +258,31 @@ export var Kernel = /*#__PURE__*/function (_EventEmitter) {
       return this.decorators[name];
     }
 
+    /**
+     * Unregister a decorator
+     * @param name Decorator name
+     */
+  }, {
+    key: "unregisterDecorator",
+    value: function unregisterDecorator(name) {
+      if (this.decorators[name]) {
+        delete this.decorators[name];
+        console.debug("[Editor] Unregistered decorator: ".concat(name));
+        return true;
+      }
+      console.warn("[Editor] Decorator \"".concat(name, "\" not found for unregistration"));
+      return false;
+    }
+
+    /**
+     * Get all registered decorator names
+     */
+  }, {
+    key: "getRegisteredDecorators",
+    value: function getRegisteredDecorators() {
+      return Object.keys(this.decorators);
+    }
+
     /**
      * Support registering target data source
      * @param dataSource Data source
@@ -270,6 +320,23 @@ export var Kernel = /*#__PURE__*/function (_EventEmitter) {
               });
               if (instanceIndex !== -1) {
                 var oldInstance = this.pluginsInstances[instanceIndex];
+                // Clean up decorators registered by the old plugin instance
+                if (oldInstance instanceof KernelPlugin) {
+                  var decoratorNames = oldInstance.getRegisteredDecorators();
+                  var _iterator2 = _createForOfIteratorHelper(decoratorNames),
+                    _step2;
+                  try {
+                    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                      var decoratorName = _step2.value;
+                      this.unregisterDecorator(decoratorName);
+                      console.debug("[Hot Reload] Cleaned up decorator \"".concat(decoratorName, "\" from old plugin instance"));
+                    }
+                  } catch (err) {
+                    _iterator2.e(err);
+                  } finally {
+                    _iterator2.f();
+                  }
+                }
                 if (oldInstance.destroy) {
                   oldInstance.destroy();
                 }
@@ -297,11 +364,11 @@ export var Kernel = /*#__PURE__*/function (_EventEmitter) {
   }, {
     key: "registerPlugins",
     value: function registerPlugins(plugins) {
-      var _iterator2 = _createForOfIteratorHelper(plugins),
-        _step2;
+      var _iterator3 = _createForOfIteratorHelper(plugins),
+        _step3;
       try {
-        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-          var plugin = _step2.value;
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var plugin = _step3.value;
           if (Array.isArray(plugin)) {
             this.registerPlugin(plugin[0], plugin[1]);
           } else {
@@ -309,9 +376,9 @@ export var Kernel = /*#__PURE__*/function (_EventEmitter) {
           }
         }
       } catch (err) {
-        _iterator2.e(err);
+        _iterator3.e(err);
       } finally {
-        _iterator2.f();
+        _iterator3.f();
       }
       return this;
     }
@@ -471,19 +538,19 @@ export var Kernel = /*#__PURE__*/function (_EventEmitter) {
             var listenerInPriorityOrder = _this4._commands.get(command);
             if (listenerInPriorityOrder !== undefined) {
               var listenersSet = listenerInPriorityOrder[i];
-              var _iterator3 = _createForOfIteratorHelper(listenersSet),
-                _step3;
+              var _iterator4 = _createForOfIteratorHelper(listenersSet),
+                _step4;
               try {
-                for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-                  var _listener = _step3.value;
+                for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+                  var _listener = _step4.value;
                   if (_listener(payload, lexicalEditor)) {
                     return true;
                   }
                 }
               } catch (err) {
-                _iterator3.e(err);
+                _iterator4.e(err);
               } finally {
-                _iterator3.f();
+                _iterator4.f();
               }
             }
           }

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

@@ -1,7 +1,21 @@
 import EventEmitter from 'eventemitter3';
+import type { IEditorKernel } from "../types/kernel";
 export declare abstract class KernelPlugin extends EventEmitter {
     protected clears: Array<() => void>;
+    protected registeredDecorators: Set<string>;
     protected register(clear: () => void): void;
     protected registerClears(...clears: Array<() => void>): void;
+    /**
+     * Register a decorator and track it for cleanup
+     */
+    protected registerDecorator(kernel: IEditorKernel, name: string, decorator: (node: any, editor: any) => any): void;
+    /**
+     * Unregister a specific decorator
+     */
+    protected unregisterDecorator(kernel: IEditorKernel, name: string): boolean;
+    /**
+     * Get all decorator names registered by this plugin
+     */
+    getRegisteredDecorators(): string[];
     destroy(): void;
 }

package/es/editor-kernel/plugin.js

@@ -24,6 +24,7 @@ export var KernelPlugin = /*#__PURE__*/function (_EventEmitter) {
     }
     _this = _super.call.apply(_super, [this].concat(args));
     _defineProperty(_assertThisInitialized(_this), "clears", []);
+    _defineProperty(_assertThisInitialized(_this), "registeredDecorators", new Set());
     return _this;
   }
   _createClass(KernelPlugin, [{
@@ -42,12 +43,47 @@ export var KernelPlugin = /*#__PURE__*/function (_EventEmitter) {
         return _this2.register(clear);
       });
     }
+
+    /**
+     * Register a decorator and track it for cleanup
+     */
+  }, {
+    key: "registerDecorator",
+    value: function registerDecorator(kernel, name, decorator) {
+      kernel.registerDecorator(name, decorator);
+      this.registeredDecorators.add(name);
+    }
+
+    /**
+     * Unregister a specific decorator
+     */
+  }, {
+    key: "unregisterDecorator",
+    value: function unregisterDecorator(kernel, name) {
+      var result = kernel.unregisterDecorator(name);
+      if (result) {
+        this.registeredDecorators.delete(name);
+      }
+      return result;
+    }
+
+    /**
+     * Get all decorator names registered by this plugin
+     */
+  }, {
+    key: "getRegisteredDecorators",
+    value: function getRegisteredDecorators() {
+      return Array.from(this.registeredDecorators);
+    }
   }, {
     key: "destroy",
     value: function destroy() {
       this.clears.forEach(function (clear) {
         return clear();
       });
+      // Note: Decorators will be cleaned up when kernel.destroy() is called
+      // Individual decorator cleanup should be handled by the kernel itself
+      this.registeredDecorators.clear();
     }
   }]);
   return KernelPlugin;

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

@@ -42,7 +42,7 @@ export var FilePlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
     if (config !== null && config !== void 0 && config.theme) {
       kernel.registerThemes(config === null || config === void 0 ? void 0 : config.theme);
     }
-    kernel.registerDecorator(FileNode.getType(), function (node, editor) {
+    _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) {

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

@@ -34,7 +34,7 @@ export var HRPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
     kernel.registerThemes({
       hr: (config === null || config === void 0 ? void 0 : config.theme) || ''
     });
-    kernel.registerDecorator('horizontalrule', function (node, editor) {
+    _this.registerDecorator(kernel, 'horizontalrule', 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.registerMarkdownShortCut({

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

@@ -41,10 +41,10 @@ export var MathPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
     if (config !== null && config !== void 0 && config.theme) {
       kernel.registerThemes(config === null || config === void 0 ? void 0 : config.theme);
     }
-    kernel.registerDecorator(MathInlineNode.getType(), function (node, editor) {
+    _this.registerDecorator(kernel, MathInlineNode.getType(), function (node, editor) {
       return config !== null && config !== void 0 && config.decorator ? config.decorator(node, editor) : null;
     });
-    kernel.registerDecorator(MathBlockNode.getType(), function (node, editor) {
+    _this.registerDecorator(kernel, MathBlockNode.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.registerMarkdownShortCut({

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

@@ -36,7 +36,7 @@ export var MentionPlugin = (_class = /*#__PURE__*/function (_KernelPlugin) {
     if (config !== null && config !== void 0 && config.theme) {
       kernel.registerThemes(config === null || config === void 0 ? void 0 : config.theme);
     }
-    kernel.registerDecorator(MentionNode.getType(), function (node, editor) {
+    _this.registerDecorator(kernel, MentionNode.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(MentionNode.getType(), function (ctx, node) {

package/es/types/kernel.d.ts

@@ -171,6 +171,10 @@ export interface IEditorKernel extends IEditor {
      * @param name
      */
     getDecorator(name: string): ((_node: DecoratorNode<any>, _editor: LexicalEditor) => any) | undefined;
+    /**
+     * Get all registered decorator names
+     */
+    getRegisteredDecorators(): string[];
     /**
      * Check if hot reload mode is enabled
      */
@@ -213,6 +217,11 @@ export interface IEditorKernel extends IEditor {
      * @param enabled Whether to enable hot reload mode
      */
     setHotReloadMode(enabled: boolean): void;
+    /**
+     * Unregister editor node decorator
+     * @param name Decorator name
+     */
+    unregisterDecorator(name: string): boolean;
 }
 /**
  * Plugin interface

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/editor",
-  "version": "1.5.1",
+  "version": "1.5.2",
   "description": "A powerful and extensible rich text editor built on Meta's Lexical framework, providing a modern editing experience with React integration.",
   "keywords": [
     "lobehub",