@lobehub/editor 1.5.2 → 1.5.4

package/es/utils/debug.js

@@ -0,0 +1,348 @@
+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';
+
+/**
+ * Development mode check
+ */
+var isDev = process.env.NODE_ENV === 'development';
+
+/**
+ * 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();
+
+/**
+ * Browser environment debug initialization - Zero configuration approach
+ * Automatically enables debug based on environment variables or development mode
+ */
+if (typeof window !== 'undefined') {
+  // Check for server-side DEBUG environment variable (passed through build process)
+  var envDebug = process.env.DEBUG;
+
+  // Simple logic: Environment variable takes precedence, then development mode
+  var debugConfig = null;
+  if (envDebug) {
+    // Environment variable exists - use it directly
+    debugConfig = envDebug;
+    localStorage.debug = envDebug;
+  } else if (isDev) {
+    // Development mode - auto-enable all lobe-editor debug
+    debugConfig = 'lobe-editor:*';
+    localStorage.debug = debugConfig;
+  }
+
+  // Apply debug configuration
+  if (debugConfig) {
+    createDebug.enable(debugConfig);
+  }
+}
+
+/**
+ * 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 { isDev };
+
+/**
+ * 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);
+  }
+};
+
+/**
+ * Browser debug utilities for Next.js and other client-side frameworks
+ */
+export var browserDebug = {
+  /**
+   * Disable debug logging in browser environment
+   */
+  disable: function disable() {
+    if (typeof window !== 'undefined') {
+      localStorage.removeItem('debug');
+      createDebug.disable();
+      console.info('Debug disabled.');
+    }
+  },
+  /**
+   * Enable debug logging in browser environment
+   * @param namespaces - Debug namespaces to enable (e.g., 'lobe-editor:*')
+   */
+  enable: function enable() {
+    var namespaces = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'lobe-editor:*';
+    if (typeof window !== 'undefined') {
+      localStorage.debug = namespaces;
+      createDebug.enable(namespaces);
+      console.info("Debug enabled: ".concat(namespaces));
+      console.info('Refresh the page to see debug logs from initialization.');
+    }
+  },
+  /**
+   * Get current debug configuration
+   */
+  getConfig: function getConfig() {
+    if (typeof window !== 'undefined') {
+      var _envDebug = process.env.DEBUG;
+      var currentDebug = localStorage.getItem('debug');
+      if (_envDebug) {
+        return {
+          enabled: _envDebug,
+          source: 'environment variable (auto-applied)'
+        };
+      } else if (isDev && currentDebug) {
+        return {
+          enabled: currentDebug,
+          source: 'development mode (auto-applied)'
+        };
+      } else {
+        return {
+          enabled: false,
+          source: 'disabled'
+        };
+      }
+    }
+    return {
+      enabled: process.env.DEBUG || false,
+      source: 'server-side'
+    };
+  },
+  /**
+   * Show available debug categories
+   */
+  showCategories: function showCategories() {
+    console.group('Available debug categories:');
+    console.log('� lobe-editor:kernel - Core editor functionality');
+    console.log('🔌 lobe-editor:plugin:* - All plugins');
+    console.log('🔍 lobe-editor:service:* - All services');
+    console.log('💬 lobe-editor:*:info - Info level messages');
+    console.log('⚠️ lobe-editor:*:warn - Warning messages');
+    console.log('❌ lobe-editor:*:error - Error messages');
+    console.groupEnd();
+    console.info('Usage: browserDebug.enable("lobe-editor:kernel,lobe-editor:plugin:*")');
+  },
+  /**
+   * Show current debug status and configuration
+   */
+  showStatus: function showStatus() {
+    var config = browserDebug.getConfig();
+    console.group('� LobeHub Editor Debug Status');
+    console.log("Status: ".concat(config.enabled ? '✅ Enabled' : '❌ Disabled'));
+    console.log("Configuration: ".concat(config.enabled || 'none'));
+    console.log("Source: ".concat(config.source));
+    console.groupEnd();
+    if (!config.enabled) {
+      console.info('💡 Zero-config setup: Set DEBUG=lobe-editor:* in your environment');
+    }
+  }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/editor",
-  "version": "1.5.2",
+  "version": "1.5.4",
   "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",