@lobehub/editor/es/utils/debug.js

A powerful and extensible rich text editor built on Meta's Lexical framework, providing a modern editing experience with React integration.

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

/**
 * 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 = typeof process !== 'undefined' ? process.env.DEBUG : undefined;
      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: (typeof process !== 'undefined' ? process.env.DEBUG : undefined) || 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');
    }
  }
};