@lobehub/editor 1.5.1 → 1.5.3

package/README.md

@@ -47,6 +47,7 @@ A modern, extensible rich text editor built on Meta's Lexical framework with dua
 - [🛠️ Development](#️-development)
   - [Setup](#setup)
   - [Available Scripts](#available-scripts)
+  - [Debug Environment Variables](#debug-environment-variables)
   - [Project Architecture](#project-architecture)
 - [🤝 Contributing](#-contributing)
 - [🔗 Links](#-links)
@@ -434,6 +435,77 @@ This will start the Dumi documentation server with live playground at `http://lo
 | `pnpm docs:build`    | Build documentation for production            |
 | `pnpm release`       | Publish new version with semantic-release     |
 
+### Debug Environment Variables
+
+LobeHub Editor includes comprehensive debug logging that can be controlled via environment variables:
+
+#### Basic Debug Configuration
+
+```bash
+# Enable all LobeHub Editor debug output
+DEBUG=lobe-editor:*
+
+# Enable only important logs (recommended for development)
+DEBUG=lobe-editor:*:info,lobe-editor:*:warn,lobe-editor:*:error
+
+# Enable specific components
+DEBUG=lobe-editor:kernel,lobe-editor:plugin:*
+```
+
+#### Available Debug Categories
+
+| Category           | Description               | Example                              |
+| ------------------ | ------------------------- | ------------------------------------ |
+| `kernel`           | Core editor functionality | `DEBUG=lobe-editor:kernel`           |
+| `plugin:*`         | All plugins               | `DEBUG=lobe-editor:plugin:*`         |
+| `plugin:slash`     | Slash commands            | `DEBUG=lobe-editor:plugin:slash`     |
+| `plugin:mention`   | Mention system            | `DEBUG=lobe-editor:plugin:mention`   |
+| `plugin:image`     | Image handling            | `DEBUG=lobe-editor:plugin:image`     |
+| `plugin:file`      | File operations           | `DEBUG=lobe-editor:plugin:file`      |
+| `service:*`        | All services              | `DEBUG=lobe-editor:service:*`        |
+| `service:upload`   | Upload service            | `DEBUG=lobe-editor:service:upload`   |
+| `service:markdown` | Markdown processing       | `DEBUG=lobe-editor:service:markdown` |
+
+#### Debug Levels
+
+| Level   | Browser Display       | Usage               | Environment Variable        |
+| ------- | --------------------- | ------------------- | --------------------------- |
+| `debug` | Console.log (gray)    | Detailed tracing    | `DEBUG=lobe-editor:*:debug` |
+| `info`  | Console.log (blue)    | General information | `DEBUG=lobe-editor:*:info`  |
+| `warn`  | Console.warn (yellow) | Warnings            | `DEBUG=lobe-editor:*:warn`  |
+| `error` | Console.error (red)   | Errors              | `DEBUG=lobe-editor:*:error` |
+
+#### Development Usage
+
+```bash
+# Full debug during development
+DEBUG=lobe-editor:* pnpm dev
+
+# Only critical logs
+DEBUG=lobe-editor:*:error,lobe-editor:*:warn pnpm dev
+
+# Plugin debugging
+DEBUG=lobe-editor:plugin:* pnpm dev
+
+# Service debugging
+DEBUG=lobe-editor:service:* pnpm dev
+```
+
+#### Browser Configuration
+
+In browser environment, you can also enable debug logging via localStorage:
+
+```javascript
+// Enable all debug output
+localStorage.debug = 'lobe-editor:*';
+
+// Enable specific categories
+localStorage.debug = 'lobe-editor:kernel,lobe-editor:plugin:*';
+
+// Disable debug output
+localStorage.removeItem('debug');
+```
+
 ### Project Architecture
 
 ```

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

@@ -14,6 +14,7 @@ export declare class Kernel extends EventEmitter implements IEditorKernel {
     private serviceMap;
     private localeMap;
     private hotReloadMode;
+    private logger;
     private editor?;
     constructor();
     private detectDevelopmentMode;
@@ -37,6 +38,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

@@ -1,8 +1,8 @@
-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 _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
 function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
 function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
 function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+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; }
@@ -24,7 +24,9 @@ import { $getSelection, $isRangeSelection, COMMAND_PRIORITY_CRITICAL, createEdit
 import { get, merge, template, templateSettings } from 'lodash-es';
 import defaultLocale from "../locale";
 import { $isRootTextContentEmpty } from "../plugins/common/utils";
+import { createDebugLogger } from "../utils/debug";
 import { registerEvent } from "./event";
+import { KernelPlugin } from "./plugin";
 import { createEmptyEditorState } from "./utils";
 templateSettings.interpolate = /{{([\S\s]+?)}}/g;
 export var Kernel = /*#__PURE__*/function (_EventEmitter) {
@@ -44,12 +46,14 @@ export var Kernel = /*#__PURE__*/function (_EventEmitter) {
     _defineProperty(_assertThisInitialized(_this), "serviceMap", new Map());
     _defineProperty(_assertThisInitialized(_this), "localeMap", defaultLocale);
     _defineProperty(_assertThisInitialized(_this), "hotReloadMode", false);
+    _defineProperty(_assertThisInitialized(_this), "logger", createDebugLogger('kernel'));
     _defineProperty(_assertThisInitialized(_this), "editor", void 0);
     _defineProperty(_assertThisInitialized(_this), "_commands", new Map());
     _defineProperty(_assertThisInitialized(_this), "_commandsClean", new Map());
     _this.dataTypeMap = new Map();
     // Enable hot reload mode in development
     _this.hotReloadMode = _this.detectDevelopmentMode();
+    _this.logger.info("\uD83D\uDE80 Kernel initialized (hot reload: ".concat(_this.hotReloadMode, ")"));
     return _this;
   }
   _createClass(Kernel, [{
@@ -108,6 +112,7 @@ export var Kernel = /*#__PURE__*/function (_EventEmitter) {
     key: "destroy",
     value: function destroy() {
       var _this$editor;
+      this.logger.info("\uD83D\uDDD1\uFE0F Destroying editor with ".concat(this.pluginsInstances.length, " plugins"));
       (_this$editor = this.editor) === null || _this$editor === void 0 || _this$editor.setEditorState(createEmptyEditorState());
       this.dataTypeMap.clear();
       this.pluginsInstances.forEach(function (plugin) {
@@ -118,6 +123,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 = {};
+      this.logger.info('✅ Editor destroyed');
     }
   }, {
     key: "getRootElement",
@@ -131,13 +139,14 @@ export var Kernel = /*#__PURE__*/function (_EventEmitter) {
       var _this2 = this;
       // Check if editor is already initialized to prevent re-initialization
       if (this.editor) {
-        console.warn('[Editor] Editor is already initialized, updating root element only');
+        this.logger.warn('[Editor] Editor is already initialized, updating root element only');
         this.editor.setRootElement(dom);
         return this.editor;
       }
 
       // Initialize plugins if not already done
       if (this.pluginsInstances.length === 0) {
+        this.logger.info("\uD83D\uDD0C Initializing ".concat(this.plugins.length, " plugins"));
         var _iterator = _createForOfIteratorHelper(this.plugins),
           _step;
         try {
@@ -152,12 +161,14 @@ export var Kernel = /*#__PURE__*/function (_EventEmitter) {
           _iterator.f();
         }
       }
+      this.logger.info("\uD83D\uDCDD Creating editor with ".concat(this.nodes.length, " nodes"));
       var editor = this.editor = createEditor({
         // @ts-expect-error Inject into lexical editor instance
         __kernel: this,
         namespace: 'lobehub',
         nodes: this.nodes,
         onError: function onError(error) {
+          _this2.logger.error('❌ Lexical editor error:', error);
           _this2.emit('error', error);
         },
         theme: this.themes
@@ -168,6 +179,7 @@ export var Kernel = /*#__PURE__*/function (_EventEmitter) {
         var _plugin$onInit;
         (_plugin$onInit = plugin.onInit) === null || _plugin$onInit === void 0 || _plugin$onInit.call(plugin, editor);
       });
+      this.logger.info("\u2705 Editor ready with ".concat(this.pluginsInstances.length, " plugins"));
       this.emit('initialized', editor);
       return this.editor;
     }
@@ -176,12 +188,15 @@ export var Kernel = /*#__PURE__*/function (_EventEmitter) {
     value: function setDocument(type, content) {
       var datasource = this.dataTypeMap.get(type);
       if (!datasource) {
+        this.logger.error("\u274C DataSource for type \"".concat(type, "\" not found"));
         throw new Error("DataSource for type \"".concat(type, "\" is not registered."));
       }
       if (!this.editor) {
+        this.logger.error('❌ Editor not initialized');
         throw new Error("Editor is not initialized.");
       }
       datasource.read(this.editor, content);
+      this.logger.debug("\uD83D\uDCE5 Set ".concat(type, " document"));
     }
   }, {
     key: "focus",
@@ -200,12 +215,15 @@ export var Kernel = /*#__PURE__*/function (_EventEmitter) {
     value: function getDocument(type) {
       var datasource = this.dataTypeMap.get(type);
       if (!datasource) {
+        this.logger.error("\u274C DataSource for type \"".concat(type, "\" not found"));
         throw new Error("DataSource for type \"".concat(type, "\" is not registered."));
       }
       if (!this.editor) {
+        this.logger.error('❌ Editor not initialized');
         throw new Error("Editor is not initialized.");
       }
-      return datasource.write(this.editor);
+      var result = datasource.write(this.editor);
+      return result;
     }
   }, {
     key: "getSelectionDocument",
@@ -224,7 +242,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
+          this.logger.warn("\uD83D\uDD04 Hot reload: 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
+            this.logger.warn("[Editor] Decorator \"".concat(name, "\" is already registered with the same function"));
+            return this;
+          }
+
+          // Different decorator function in production mode
+          this.logger.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;
+      this.logger.debug("\uD83C\uDFAD Decorator: ".concat(name));
       return this;
     }
   }, {
@@ -233,6 +272,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];
+        this.logger.debug("\uD83D\uDDD1\uFE0F Removed decorator: ".concat(name));
+        return true;
+      }
+      this.logger.warn("\u26A0\uFE0F Decorator \"".concat(name, "\" not found"));
+      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
@@ -241,6 +305,7 @@ export var Kernel = /*#__PURE__*/function (_EventEmitter) {
     key: "registerDataSource",
     value: function registerDataSource(dataSource) {
       this.dataTypeMap.set(dataSource.type, dataSource);
+      this.logger.debug("\uD83D\uDCC4 Data source: ".concat(dataSource.type));
     }
   }, {
     key: "registerThemes",
@@ -257,7 +322,7 @@ export var Kernel = /*#__PURE__*/function (_EventEmitter) {
         // Error if same name but different plugin
         if (findPlugin !== plugin) {
           if (this.hotReloadMode) {
-            console.warn("[Hot Reload] Replacing plugin \"".concat(plugin.pluginName, "\" with new implementation"));
+            this.logger.warn("\uD83D\uDD04 Hot reload: plugin \"".concat(plugin.pluginName, "\""));
             // Remove old plugin
             var index = this.plugins.findIndex(function (p) {
               return p.pluginName === plugin.pluginName;
@@ -270,6 +335,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);
+                      this.logger.debug("\uD83E\uDDE8 Cleanup: decorator \"".concat(decoratorName, "\""));
+                    }
+                  } catch (err) {
+                    _iterator2.e(err);
+                  } finally {
+                    _iterator2.f();
+                  }
+                }
                 if (oldInstance.destroy) {
                   oldInstance.destroy();
                 }
@@ -292,16 +374,17 @@ export var Kernel = /*#__PURE__*/function (_EventEmitter) {
       plugin.__config = config || {};
       // @ts-expect-error not error
       this.plugins.push(plugin);
+      this.logger.debug("\uD83D\uDD0C Plugin: ".concat(plugin.pluginName));
       return this;
     }
   }, {
     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,17 +392,34 @@ export var Kernel = /*#__PURE__*/function (_EventEmitter) {
           }
         }
       } catch (err) {
-        _iterator2.e(err);
+        _iterator3.e(err);
       } finally {
-        _iterator2.f();
+        _iterator3.f();
       }
+      this.logger.debug("\uD83D\uDD0C Registered ".concat(plugins.length, " plugins"));
       return this;
     }
   }, {
     key: "registerNodes",
     value: function registerNodes(nodes) {
       var _this$nodes;
+      var nodeTypes = nodes.map(function (node) {
+        // Handle both node classes and node replacements
+        if (typeof node === 'function' && node.getType) {
+          return node.getType();
+        } else if (_typeof(node) === 'object' && node.replace && typeof node.replace === 'function' && node.replace.getType) {
+          return node.replace.getType();
+        }
+        return 'unknown';
+      }).filter(function (type) {
+        return type !== 'unknown';
+      });
       (_this$nodes = this.nodes).push.apply(_this$nodes, _toConsumableArray(nodes));
+      if (nodeTypes.length > 3) {
+        this.logger.debug("\uD83E\uDDE9 Nodes: ".concat(nodeTypes.length, " types"));
+      } else {
+        this.logger.debug("\uD83E\uDDE9 Nodes: ".concat(nodeTypes.join(', ')));
+      }
     }
   }, {
     key: "registerService",
@@ -328,7 +428,7 @@ export var Kernel = /*#__PURE__*/function (_EventEmitter) {
       if (this.serviceMap.has(serviceIdString)) {
         if (this.hotReloadMode) {
           // In hot reload mode, allow service override with warning
-          console.warn("[Hot Reload] Overriding service with ID \"".concat(serviceIdString, "\""));
+          this.logger.warn("\uD83D\uDD04 Hot reload: service \"".concat(serviceIdString, "\""));
           this.serviceMap.set(serviceIdString, service);
           return;
         } else {
@@ -336,17 +436,17 @@ export var Kernel = /*#__PURE__*/function (_EventEmitter) {
           var existingService = this.serviceMap.get(serviceIdString);
           if (existingService === service) {
             // Same service instance, no need to re-register
-            console.warn("[Editor] Service \"".concat(serviceIdString, "\" is already registered with the same instance"));
+            this.logger.warn("[Editor] Service \"".concat(serviceIdString, "\" is already registered with the same instance"));
             return;
           }
 
           // Different service instance in production mode
-          console.error("[Editor] Attempting to register duplicate service \"".concat(serviceIdString, "\". Enable hot reload mode if this is intended."));
+          this.logger.error("[Editor] Attempting to register duplicate service \"".concat(serviceIdString, "\". Enable hot reload mode if this is intended."));
           throw new Error("Service with ID \"".concat(serviceIdString, "\" is already registered."));
         }
       }
       this.serviceMap.set(serviceIdString, service);
-      console.debug("[Editor] Registered service: ".concat(serviceIdString));
+      this.logger.debug("\uD83D\uDD27 Service: ".concat(serviceIdString));
     }
 
     /**
@@ -358,6 +458,7 @@ export var Kernel = /*#__PURE__*/function (_EventEmitter) {
     key: "registerServiceHotReload",
     value: function registerServiceHotReload(serviceId, service) {
       this.serviceMap.set(serviceId.__serviceId, service);
+      this.logger.debug("\uD83D\uDD04 Hot-reload service: ".concat(serviceId.__serviceId));
     }
 
     /**
@@ -413,7 +514,9 @@ export var Kernel = /*#__PURE__*/function (_EventEmitter) {
   }, {
     key: "registerLocale",
     value: function registerLocale(locale) {
+      var localeKeys = Object.keys(locale);
       this.localeMap = merge(this.localeMap, locale);
+      this.logger.debug("\uD83C\uDF10 Locale: ".concat(localeKeys.length, " keys"));
     }
   }, {
     key: "t",
@@ -465,30 +568,35 @@ export var Kernel = /*#__PURE__*/function (_EventEmitter) {
       }
       var commandsMap = this._commands;
       if (!commandsMap.has(command)) {
+        var _command$type;
         commandsMap.set(command, [new Set(), new Set(), new Set(), new Set(), new Set()]);
         this._commandsClean.set(command, lexicalEditor.registerCommand(command, function (payload) {
           for (var i = 4; i >= 0; i--) {
             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();
               }
             }
           }
           return false;
         }, COMMAND_PRIORITY_CRITICAL));
+        // Only log non-keyboard commands to reduce noise
+        if (!((_command$type = command.type) !== null && _command$type !== void 0 && _command$type.includes('KEY'))) {
+          this.logger.debug("\u26A1 Command: ".concat(command.type || 'unknown'));
+        }
       }
       var listenersInPriorityOrder = commandsMap.get(command);
       if (listenersInPriorityOrder === undefined) {

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/editor-kernel/react/useDecorators.js

@@ -25,16 +25,26 @@ export function useDecorators(editor, ErrorBoundary) {
   useLayoutEffectImpl(function () {
     var clears = [];
     var handleInit = function handleInit(editor) {
+      // Get initial decorators
+      var initialDecorators = editor.getDecorators();
+      setDecorators(initialDecorators);
       clears.push(editor.registerDecoratorListener(function (nextDecorators) {
         flushSync(function () {
           setDecorators(nextDecorators);
         });
       }));
     };
-    editor.on('initialized', handleInit);
-    clears.push(function () {
-      editor.off('initialized', handleInit);
-    });
+
+    // Check if editor is already initialized
+    var lexicalEditor = editor.getLexicalEditor();
+    if (lexicalEditor) {
+      handleInit(lexicalEditor);
+    } else {
+      editor.on('initialized', handleInit);
+      clears.push(function () {
+        editor.off('initialized', handleInit);
+      });
+    }
     return function () {
       clears.forEach(function (clear) {
         return clear();

package/es/index.d.ts

@@ -14,6 +14,7 @@ export * from './plugins/slash';
 export * from './plugins/table';
 export * from './plugins/upload';
 export type { IEditor } from './types';
+export { createDebugLogger, debugLogger, debugLoggers, devConsole, prodSafeLogger, } from './utils/debug';
 export { Kernel } from './editor-kernel/kernel';
 /**
  * Enable hot reload mode globally for all editor instances

package/es/index.js

@@ -13,6 +13,9 @@ export * from "./plugins/mention";
 export * from "./plugins/slash";
 export * from "./plugins/table";
 export * from "./plugins/upload";
+// Debug utilities
+export { createDebugLogger, debugLogger, debugLoggers, devConsole, prodSafeLogger } from "./utils/debug";
+
 // Hot reload utilities
 export { Kernel } from "./editor-kernel/kernel";
 
@@ -24,8 +27,10 @@ export function enableHotReload() {
   if (typeof window !== 'undefined') {
     var _require = require("./editor-kernel/kernel"),
       Kernel = _require.Kernel;
+    var _require2 = require("./utils/debug"),
+      debugLoggers = _require2.debugLoggers;
     Kernel.setGlobalHotReloadMode(true);
-    console.log('[LobeHub Editor] Hot reload mode enabled globally');
+    debugLoggers.kernel.info('[LobeHub Editor] Hot reload mode enabled globally');
   }
 }
 
@@ -34,9 +39,11 @@ export function enableHotReload() {
  */
 export function disableHotReload() {
   if (typeof window !== 'undefined') {
-    var _require2 = require("./editor-kernel/kernel"),
-      Kernel = _require2.Kernel;
+    var _require3 = require("./editor-kernel/kernel"),
+      Kernel = _require3.Kernel;
+    var _require4 = require("./utils/debug"),
+      debugLoggers = _require4.debugLoggers;
     Kernel.setGlobalHotReloadMode(false);
-    console.log('[LobeHub Editor] Hot reload mode disabled globally');
+    debugLoggers.kernel.info('[LobeHub Editor] Hot reload mode disabled globally');
   }
 }