@lobehub/editor 1.5.2 → 1.5.3

package/es/utils/debug.js

@@ -0,0 +1,231 @@
+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 _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); }
+// @ts-ignore - debug package types
+import createDebug from 'debug';
+
+/**
+ * Base namespace for all LobeHub Editor debug messages
+ */
+var BASE_NAMESPACE = 'lobe-editor';
+
+/**
+ * Debug utility factory for LobeHub Editor
+ * Creates namespaced debug functions following the pattern: lobe-editor:category
+ */
+export var DebugLogger = /*#__PURE__*/function () {
+  function DebugLogger() {
+    _classCallCheck(this, DebugLogger);
+    _defineProperty(this, "debuggers", new Map());
+  }
+  _createClass(DebugLogger, [{
+    key: "getDebugger",
+    value:
+    /**
+     * Get or create a debug function for a specific namespace
+     * @param category - The debug category (e.g., 'kernel', 'plugin', 'upload')
+     * @param subcategory - Optional subcategory for more specific debugging
+     * @returns Debug function
+     */
+    function getDebugger(category, subcategory) {
+      var namespace = subcategory ? "".concat(BASE_NAMESPACE, ":").concat(category, ":").concat(subcategory) : "".concat(BASE_NAMESPACE, ":").concat(category);
+      if (!this.debuggers.has(namespace)) {
+        this.debuggers.set(namespace, createDebug(namespace));
+      }
+      return this.debuggers.get(namespace);
+    }
+
+    /**
+     * Create a scoped debug logger for a specific component/service
+     * @param category - Main category
+     * @param subcategory - Optional subcategory
+     * @returns Object with debug methods
+     */
+  }, {
+    key: "createLogger",
+    value: function createLogger(category, subcategory) {
+      var debug = this.getDebugger(category, subcategory);
+      var warnDebugger = this.getDebugger(category, subcategory ? "".concat(subcategory, ":warn") : 'warn');
+      var errorDebugger = this.getDebugger(category, subcategory ? "".concat(subcategory, ":error") : 'error');
+      var info = this.getDebugger(category, subcategory ? "".concat(subcategory, ":info") : 'info');
+
+      // Create wrapper functions that use native console methods for proper browser dev tool support
+      var warn = function warn() {
+        if (warnDebugger.enabled) {
+          var _console;
+          var prefix = warnDebugger.namespace;
+          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+            args[_key] = arguments[_key];
+          }
+          (_console = console).warn.apply(_console, ["".concat(prefix)].concat(args));
+        }
+      };
+      var error = function error() {
+        if (errorDebugger.enabled) {
+          var _console2;
+          var prefix = errorDebugger.namespace;
+          for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+            args[_key2] = arguments[_key2];
+          }
+          (_console2 = console).error.apply(_console2, ["".concat(prefix)].concat(args));
+        }
+      };
+      return {
+        /**
+         * General debug logging
+         */
+        debug: debug,
+        /**
+         * Error level logging - uses console.error for proper browser dev tool support
+         */
+        error: error,
+        /**
+         * Info level logging
+         */
+        info: info,
+        /**
+         * Log function - alias for debug for compatibility
+         */
+        log: debug,
+        /**
+         * Warning level logging - uses console.warn for proper browser dev tool support
+         */
+        warn: warn
+      };
+    }
+
+    /**
+     * Enable debug for specific namespaces
+     * @param namespaces - Comma-separated list of namespaces to enable
+     */
+  }, {
+    key: "enable",
+    value: function enable(namespaces) {
+      createDebug.enable(namespaces);
+    }
+
+    /**
+     * Disable all debug output
+     */
+  }, {
+    key: "disable",
+    value: function disable() {
+      createDebug.disable();
+    }
+
+    /**
+     * Check if a namespace is enabled
+     * @param namespace - The namespace to check
+     * @returns Whether the namespace is enabled
+     */
+  }, {
+    key: "enabled",
+    value: function enabled(namespace) {
+      return createDebug.enabled(namespace);
+    }
+  }]);
+  return DebugLogger;
+}();
+
+/**
+ * Global debug logger instance
+ */
+export var debugLogger = new DebugLogger();
+
+/**
+ * Convenience function to create a debug logger for a specific category
+ * @param category - Main category (e.g., 'kernel', 'plugin', 'upload')
+ * @param subcategory - Optional subcategory
+ * @returns Logger object with debug methods
+ */
+export function createDebugLogger(category, subcategory) {
+  return debugLogger.createLogger(category, subcategory);
+}
+
+/**
+ * Pre-configured debug loggers for common categories
+ */
+export var debugLoggers = {
+  demo: createDebugLogger('demo'),
+  file: createDebugLogger('file'),
+  image: createDebugLogger('image'),
+  kernel: createDebugLogger('kernel'),
+  markdown: createDebugLogger('markdown'),
+  math: createDebugLogger('math'),
+  mention: createDebugLogger('mention'),
+  plugin: createDebugLogger('plugin'),
+  react: createDebugLogger('react'),
+  service: createDebugLogger('service'),
+  slash: createDebugLogger('slash'),
+  upload: createDebugLogger('upload')
+};
+
+/**
+ * Development mode utilities
+ */
+export var isDev = process.env.NODE_ENV === 'development';
+
+/**
+ * Conditional console logging - only logs in development mode
+ * Use this for demo files and development-only logging
+ */
+export var devConsole = {
+  error: function error() {
+    if (isDev) {
+      var _console3;
+      (_console3 = console).error.apply(_console3, arguments);
+    }
+  },
+  info: function info() {
+    if (isDev) {
+      var _console4;
+      (_console4 = console).info.apply(_console4, arguments);
+    }
+  },
+  log: function log() {
+    if (isDev) {
+      var _console5;
+      (_console5 = console).log.apply(_console5, arguments);
+    }
+  },
+  warn: function warn() {
+    if (isDev) {
+      var _console6;
+      (_console6 = console).warn.apply(_console6, arguments);
+    }
+  }
+};
+
+/**
+ * Production-safe error logging
+ * Always logs errors and warnings regardless of environment using native console methods
+ * for proper browser dev tool support. Debug/info uses debug package.
+ */
+export var prodSafeLogger = {
+  /**
+   * Debug info - only shown when debug is enabled
+   */
+  debug: debugLoggers.kernel.debug,
+  /**
+   * Log critical errors that should always be visible (uses console.error)
+   */
+  error: function error() {
+    var _console7;
+    (_console7 = console).error.apply(_console7, arguments);
+  },
+  /**
+   * Info logging - only shown when debug is enabled
+   */
+  info: debugLoggers.kernel.info,
+  /**
+   * Log warnings that should always be visible (uses console.warn)
+   */
+  warn: function warn() {
+    var _console8;
+    (_console8 = console).warn.apply(_console8, arguments);
+  }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/editor",
-  "version": "1.5.2",
+  "version": "1.5.3",
   "description": "A powerful and extensible rich text editor built on Meta's Lexical framework, providing a modern editing experience with React integration.",
   "keywords": [
     "lobehub",
@@ -43,6 +43,7 @@
     "@shikijs/engine-javascript": "^3.9.2",
     "ahooks": "^3.9.3",
     "antd-style": "^3.7.1",
+    "debug": "^4.4.1",
     "eventemitter3": "^5.0.1",
     "framer-motion": "^12.23.12",
     "fuse.js": "^7.1.0",