@creejs/commons-logging 2.0.0 → 2.0.2

package/dist/cjs/index-dev.cjs

@@ -0,0 +1,1450 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var r={isFunction:u,isNumber:y,isNil:l,isString:d};function u(t){return "function"==typeof t}function l(t){return null==t}function y(t){return null!=t&&"number"==typeof t}function d(t){return null!=t&&"string"==typeof t}var N={assertNotNil:function(t,e){if(l(t))throw new Error((e?'"'+e+'" ':" ")+"Should Not Nil")},assertString:b};function b(t,e){if(!d(t))throw new Error(`${e?'"'+e+'" ':" "}Not String: type=${typeof t} value=${JSON.stringify(t)}`)}
+
+const { isNumber, isString } = r;
+/**
+ * @namespace LogLevel
+ * @description Defines the logging levels and provides utilities for working with them.
+ */
+// module vars
+const TRACE = 'TRACE';
+const DEBUG = 'DEBUG';
+const INFO = 'INFO';
+const WARN = 'WARN';
+const ERROR = 'ERROR';
+const FATAL = 'FATAL';
+const OFF = 'OFF';
+const ALL = 'ALL';
+
+const Names = new Set([TRACE, DEBUG, INFO, WARN, ERROR, FATAL, OFF, ALL]);
+/**
+ * The logging level numbers, where OFF=-1, FATAL=0, ERROR=1, WARN=2, INFO=3, DEBUG=4, TRACE=5, ALL=6
+ * @enum {number}
+ * @memberof LogLevel
+ * @static
+ */
+const Level$1 = {
+  OFF: -1,
+  FATAL: 0,
+  ERROR: 1,
+  WARN: 2,
+  INFO: 3,
+  DEBUG: 4,
+  TRACE: 5,
+  ALL: 6
+};
+
+/**
+ * Standard logging level names
+ * @enum {string}
+ * @memberof LogLevel
+ * @static
+ * @constant
+ */
+const Name = {
+  TRACE,
+  DEBUG,
+  INFO,
+  WARN,
+  ERROR,
+  FATAL,
+  OFF
+};
+
+/**
+ * Internal map for quick lookup of level names by their numeric values
+ * @type {Map<number, string>}
+ * @private
+ */
+const Value2Name = new Map();
+for (const [name, value] of Object.entries(Level$1)) {
+  Value2Name.set(value, name);
+}
+
+/**
+ * The default logging level (ERROR)
+ * @type {number}
+ * @memberof LogLevel
+ * @static
+ */
+const DefaultLevel$1 = Level$1.ERROR;
+
+/**
+ * Converts a numeric logging level value to its corresponding name.
+ * @param {number} value - The numeric logging level value to convert.
+ * @returns {string|undefined} The name associated with the given logging level value, from {@link LogLevel.Name}.
+ * @memberof LogLevel
+ * @static
+ */
+function value2Name (value) {
+  if (!isNumber(value)) {
+    return undefined
+  }
+  return Value2Name.get(value)
+}
+
+/**
+ * Converts a logging level name to its corresponding numeric value.
+ * @param {string} name - The name of the logging level.
+ * @returns {number|undefined} The numeric value of the logging level from {@link LogLevel.Level}, or undefined if name is not supported.
+ * @memberof LogLevel
+ * @static
+ */
+function name2Value (name) {
+  if (!isString(name)) {
+    return undefined
+  }
+  // @ts-ignore
+  return Level$1[name.toUpperCase()]
+}
+
+/**
+ * Checks if the given level is a valid log level.
+ * @param {number} level - The log level to check.
+ * @returns {boolean} True if the level is valid, false otherwise.
+ * @memberof LogLevel
+ * @static
+ */
+function hasLevel (level) {
+  return Value2Name.has(level)
+}
+
+/**
+ * Checks if the given level name exists in the Name enum/object.
+ * @param {string} levelName - The name of the log level to check.
+ * @returns {boolean} True if the level name exists, false otherwise.
+ * @memberof LogLevel
+ * @static
+ */
+function hasName (levelName) {
+  if (!isString(levelName)) {
+    return false
+  }
+  return Names.has(levelName.toUpperCase())
+}
+
+/**
+ * Validates that a given level is a number and falls within the valid range.
+ * @param {*} level - The log level to validate
+ * @throws {Error} If level is not a number or outside valid range (Level.OFF to Level.ALL)
+ * @memberof LogLevel
+ * @static
+ */
+function assertLevel$1 (level) {
+  if (!isNumber(level)) {
+    throw new Error(`Level Not Number: type=${typeof level} value=${level}`)
+  }
+  if (level < Level$1.OFF || level > Level$1.ALL) {
+    throw new Error(`Not Valid Level: ${level}, Expect between ${Level$1.OFF} and ${Level$1.ALL}`)
+  }
+}
+
+const LogLevel = {
+  Name,
+  Level: Level$1,
+  DefaultLevel: DefaultLevel$1,
+  hasLevel,
+  hasName,
+  assertLevel: assertLevel$1,
+  /**
+   *  Same with [Name]{@link LogLevel.Name}
+   *  @type {Object}
+   *  @memberof LogLevel
+   *  @static
+   */
+  LevelName: Name,
+  /**
+   *  Same with [Level]{@link LogLevel.Level}
+   *  @type {Object}
+   *  @memberof LogLevel
+   *  @static
+   */
+  LevelValue: Level$1,
+
+  value2Name,
+
+  name2Value
+};
+
+// internal
+
+const { Level, DefaultLevel, assertLevel } = LogLevel;
+const { assertString: assertString$3 } = N;
+/**
+ * Abstract Logger Class of All Logger
+ * @abstract
+ */
+class Logger {
+  /**
+   * Creates a new Logger instance.
+   * @constructor
+   * @param {string} name - The name identifier for the logger
+   * @param {*} [nativeLogger]
+   * @param {number} [level] - The logging level, default is Level.ERROR=1
+   */
+  constructor (name, nativeLogger, level = DefaultLevel) {
+    assertString$3(name);
+    assertLevel(level);
+    this._name = name;
+    this._nativeLogger = nativeLogger;
+    this._level = level;
+  }
+
+  get nativeLogger () {
+    return this._nativeLogger
+  }
+
+  get level () {
+    return this._level
+  }
+
+  /**
+   * Gets the name of the logger instance.
+   * @returns {string} The name of the logger.
+   */
+  get name () {
+    return this._name
+  }
+
+  /**
+   * Checks if FATAL level logging is enabled for this logger.
+   * @returns {boolean} True if FATAL level logging is enabled, false otherwise.
+   */
+  get fatalEnabled () {
+    return this.level >= Level.FATAL
+  }
+
+  /**
+   * Checks if ERROR level logging is enabled for this logger.
+   * @returns {boolean} True if ERROR level logging is enabled, false otherwise.
+   */
+  get errorEnabled () {
+    return this.level >= Level.ERROR
+  }
+
+  /**
+   * Checks if WARN level logging is enabled for this logger.
+   * @returns {boolean} True if WARN level logging is enabled, false otherwise.
+   */
+  get warnEnabled () {
+    return this.level >= Level.WARN
+  }
+
+  /**
+   * Checks if DEBUG level logging is enabled for this logger.
+   * @returns {boolean} True if DEBUG level logging is enabled, false otherwise.
+   */
+  get debugEnabled () {
+    return this.level >= Level.DEBUG
+  }
+
+  /**
+   * Checks if INFO level logging is enabled for this logger.
+   * @returns {boolean} True if INFO level logging is enabled, false otherwise.
+   */
+  get infoEnabled () {
+    return this.level >= Level.INFO
+  }
+
+  /**
+   * Checks if TRACE level logging is enabled for this logger.
+   * @returns {boolean} True if TRACE level logging is enabled, false otherwise.
+   */
+  get traceEnabled () {
+    return this.level >= Level.TRACE
+  }
+
+  /**
+   * change log level for current logger instance.
+   * @param {number} level - new log level to set
+   * @throws {Error} Currently throws an error as this method is Not Impled Yet.
+   * @abstract
+   */
+  setLevel (level) {
+    LogLevel.assertLevel(level);
+    this._setLevel(level);
+    this._level = level;
+  }
+
+  /**
+   * Logs a fatal error message with timestamp and logger name.
+   * Only outputs if fatal logging is enabled for this logger instance.
+   * @param {...any} args - Arguments to log (will be space-separated)
+   */
+  fatal (...args) {
+    if (this.fatalEnabled) {
+      this._fatal(...args);
+    }
+  }
+
+  /**
+   * Logs an error message to the console with timestamp and logger name.
+   * Only logs if error logging is enabled for this logger instance.
+   * @param {...any} args - Arguments to be logged as error message
+   */
+  error (...args) {
+    if (this.errorEnabled) {
+      this._error(...args);
+    }
+  }
+
+  /**
+   * Logs a warning message to the console if warn logging is enabled.
+   * @param {...any} args - The arguments to log as a warning message.
+   */
+  warn (...args) {
+    if (this.warnEnabled) {
+      this._warn(...args);
+    }
+  }
+
+  /**
+   * Logs debug messages to console if debug mode is enabled.
+   * @param {...any} args - The data to be logged
+   */
+  debug (...args) {
+    if (this.debugEnabled) {
+      this._debug(...args);
+    }
+  }
+
+  /**
+   * Logs an info message to the console with timestamp and logger name.
+   * @param {...any} args - The data to be logged. Accepts multiple arguments.
+   */
+  info (...args) {
+    if (this.infoEnabled) {
+      this._info(...args);
+    }
+  }
+
+  /**
+   * Logs a trace message with timestamp and logger name if trace logging is enabled.
+   * @param {...any} args - Data to be logged as trace message.
+   */
+  trace (...args) {
+    if (this.traceEnabled) {
+      this._trace(...args);
+    }
+  }
+
+  /**
+   * Checks if FATAL level logging is enabled for this logger.
+   * @returns {boolean} True if FATAL level logging is enabled, false otherwise.
+   */
+  isFatalEnabled () {
+    return this.fatalEnabled
+  }
+
+  /**
+   * Checks if ERROR level logging is enabled for this logger.
+   * @returns {boolean} True if ERROR level logging is enabled, false otherwise.
+   */
+  isErrorEnabled () {
+    return this.errorEnabled
+  }
+
+  /**
+   * Checks if WARN level logging is enabled for this logger.
+   * @returns {boolean} True if WARN level logging is enabled, false otherwise.
+   */
+  isWarnEnabled () {
+    return this.warnEnabled
+  }
+
+  /**
+   * Checks if DEBUG level logging is enabled for this logger.
+   * @returns {boolean} True if DEBUG level logging is enabled, false otherwise.
+   */
+  isDebugEnabled () {
+    return this.debugEnabled
+  }
+
+  /**
+   * Checks if INFO level logging is enabled for this logger.
+   * @returns {boolean} True if INFO level logging is enabled, false otherwise.
+   */
+  isInfoEnabled () {
+    return this.infoEnabled
+  }
+
+  /**
+   * Checks if TRACE level logging is enabled for this logger.
+   * @returns {boolean} True if TRACE level logging is enabled, false otherwise.
+   */
+  isTraceEnabled () {
+    return this.traceEnabled
+  }
+
+  /**
+   * Sets the logging level
+   * @param {number} level
+   * @throws {Error} Always throws "Not Impled Yet Yet" error.
+   * @protected
+   * @abstract
+   */
+  _setLevel (level) {
+    throw new Error('Not Impled Yet')
+  }
+
+  /**
+   * Override this method to implement fatal logging.
+   * @protected
+   * @param {...*} args - Variable arguments
+   * @throws {Error} Always throws "Not Impled Yet Yet" error
+   */
+  _fatal (...args) {
+    throw new Error('Not Impled Yet')
+  }
+
+  /**
+   * Override this method to implement error logging.
+   * @protected
+   * @param {...*} args - Variable arguments
+   * @throws {Error} Always throws "Not Impled Yet Yet" error
+   */
+  _error (...args) {
+    throw new Error('Not Impled Yet')
+  }
+
+  /**
+   * Override this method to implement warn logging.
+   * @protected
+   * @param {...*} args - Variable arguments
+   * @throws {Error} Always throws "Not Impled Yet Yet" error
+   */
+  _warn (...args) {
+    throw new Error('Not Impled Yet')
+  }
+
+  /**
+   * Override this method to implement debug logging.
+   * @protected
+   * @param {...*} args - Variable arguments
+   * @throws {Error} Always throws "Not Impled Yet Yet" error
+   */
+  _debug (...args) {
+    throw new Error('Not Impled Yet')
+  }
+
+  /**
+   * Override this method to implement info logging.
+   * @protected
+   * @param {...*} args - Variable arguments
+   * @throws {Error} Always throws "Not Impled Yet Yet" error
+   */
+  _info (...args) {
+    throw new Error('Not Impled Yet')
+  }
+
+  /**
+   * Override this method to implement trace logging.
+   * @protected
+   * @param {...*} args - Variable arguments
+   * @throws {Error} Always throws "Not Impled Yet Yet" error
+   */
+  _trace (...args) {
+    throw new Error('Not Impled Yet')
+  }
+}
+
+// owned
+// eslint-disable-next-line no-unused-vars
+
+/**
+ * @abstract
+ */
+class LogFactory {
+  /**
+   * Checks if a value resembles a LogFactory by verifying it has required methods.
+   * @param {*} value - The value to check
+   * @returns {boolean}
+   */
+  static isLogFactoryLike (value) {
+    if (value == null) {
+      return false
+    }
+    return typeof value === 'object' && typeof value.createLogger === 'function' && typeof value.setLevel === 'function'
+  }
+
+  /**
+   * Asserts that the given value is a valid LogFactory-Like object.
+   * @throws {Error} Throws an error if the value is not LogFactory-Like
+   * @param {*} value - The value to check.
+   */
+  static assertLogFactoryLike (value) {
+    if (!this.isLogFactoryLike(value)) {
+      throw new Error('Not LogFactory')
+    }
+  }
+
+  /**
+   * Creates a new logging provider instance.
+   * @param {{}} libraryModule - the library module
+   * @param {{}} setting - Configuration settings for the provider
+   */
+  constructor (libraryModule, setting) {
+    this._libraryModule = libraryModule;
+    this._setting = setting;
+  }
+
+  get libraryModule () {
+    return this._libraryModule
+  }
+
+  get setting () {
+    return this._setting
+  }
+
+  /**
+   * Initializes the logging provider.
+   * 1. Do nothing in the default implementation.
+   * 2. Override this method to initialize the provider.
+   * @returns {Promise<void>|void}
+   */
+  init () {
+    // do nothing
+  }
+
+  /**
+   * Update factory's Log Level
+   * 1. Only Provider knows how to update
+   *    * update level in "setting", so the new created Logger will use the new level
+   * 2. called when users want to change global log level via CommonsLogging.setLevel()
+   * @param {number} level - The log level to set, see {@link LogLevel.Level}
+   * @returns {void}
+   * @throws {Error} Throws an error as this method is Not Impled Yet.
+   * @abstract
+   */
+  setLevel (level) {
+    throw new Error('Not Impled Yet')
+  }
+
+  /**
+   * Creates a new logger named with the "loggerName"
+   * @param {string} loggerName - The name to associate with the logger instance.
+   * @throws {Error} Throws an error indicating the method is Not Impled Yet yet.
+   * @returns {Logger} A new logger intance
+   * @abstract
+   */
+  createLogger (loggerName) {
+    throw new Error('Not Impled Yet')
+  }
+}
+
+/**
+ * @type {string}
+ * @memberof ProviderType
+ */
+const Log4js = 'LOG4JS';
+/**
+ * @type {string}
+ * @memberof ProviderType
+ */
+const Console = 'CONSOLE';
+
+/**
+ * @namespace ProviderType
+ * @description Define the static types
+ */
+var ProviderType = {
+  Log4js,
+  Console
+};
+
+// owned
+// eslint-disable-next-line no-unused-vars
+
+/**
+ * A interface that All Provider module must export
+ * @interface
+ */
+class Provider {
+  /**
+   * Checks if a value resembles a logging provider by verifying it has required methods.
+   * @param {*} value - The value to check
+   * @returns {boolean}
+   */
+  static isProviderLike (value) {
+    if (value == null) {
+      return false
+    }
+    return typeof value === 'object' && typeof value.createLogFactory === 'function' && typeof value.getType === 'function'
+  }
+
+  /**
+   * Asserts that the given value is a valid provider-like object.
+   * @throws {Error} Throws an error if the value is not provider-like.
+   * @param {*} value - The value to check.
+   */
+  static assertProviderLike (value) {
+    if (!this.isProviderLike(value)) {
+      throw new Error('Not LogProvider')
+    }
+  }
+
+  /**
+   * The Type Name of current Provider
+   * @return {String} The type of the provider.
+   */
+  getType () {
+    throw new Error('Not Impled Yet')
+  }
+
+  /**
+   * Create a new LogFactory instance
+   * @param {*} [nativeLib] - The native library to use for logging.
+   * @param {*} [setting] - Configuration settings for the logging provider.
+   * @returns {LogFactory} A new instance of LogFactory.
+   */
+  createLogFactory (nativeLib, setting) {
+    throw new Error('Not Impled Yet')
+  }
+}
+
+// internal
+
+const { assertString: assertString$2 } = N;
+
+/**
+ * @module LogConfig
+ * @description Provide Impl of Log Configuration
+ * @private
+ */
+
+/**
+ * type name of current provider
+ * @type {string}
+ * @public
+ */
+// @ts-ignore
+// eslint-disable-next-line prefer-const
+let currentProvider$1 = null;
+
+/**
+ * Global logging level
+ * @type {number}
+ * @public
+ */
+// @ts-ignore
+// eslint-disable-next-line prefer-const
+let currentLevel = DefaultLevel$1;
+
+/**
+ * The map of registered logging libraries
+ * @type {Map<string,Provider>}
+ * @private
+ */
+const type2Provider = new Map();
+
+/**
+ * Adds a logging provider for the specified type.
+ * @param {string} typeName - The type identifier for the provider.
+ * @param {Provider} provider - The logging provider implementation.
+ * @returns {void}
+ * @alias module:LogConfig.addProvider
+ */
+function addProvider$1 (typeName, provider) {
+  assertString$2(typeName);
+  Provider.assertProviderLike(provider);
+  type2Provider.set(typeName.toUpperCase(), provider);
+}
+
+/**
+ * Gets the logging provider for the specified type name.
+ * @param {string} typeName - The type name to look up in the provider map.
+ * @returns {Provider|undefined} The logging provider instance if found, otherwise undefined.
+ */
+function getProvider (typeName) {
+  assertString$2(typeName);
+  return type2Provider.get(typeName.toUpperCase())
+}
+
+/**
+ * Removes a logging provider of the specified type.
+ * @param {string} typeName - The type name of the provider to remove.
+ * @returns {boolean}
+ */
+function removeProvider$1 (typeName) {
+  assertString$2(typeName);
+  return type2Provider.delete(typeName.toUpperCase())
+}
+
+function clearProviders$1 () {
+  type2Provider.clear();
+}
+
+/**
+ * Returns an array of all registered factory types and intances.
+ * 1. Each entry is a [type, factory] pair
+ * @returns {Array<{0:string, 1:Provider}>} An array of factory entries.
+ */
+function listProviders () {
+  return [...type2Provider.entries()]
+}
+
+/**
+ * Created LogFactories Index with type name
+ * @type {Map<string, LogFactory>}
+ * @public
+ */
+const type2Factory = new Map();
+
+/**
+ * Registers a log factory for a given type name.
+ * @param {string} typeName - The name of the log type to register.
+ * @param {LogFactory} logFactory - Factory function that creates a logger for the specified type.
+ */
+function addFactory (typeName, logFactory) {
+  assertString$2(typeName);
+  LogFactory.assertLogFactoryLike(logFactory);
+  type2Factory.set(typeName.toUpperCase(), logFactory);
+}
+
+/**
+ * Removes a factory of the given type from the type-to-factory mapping.
+ * @param {string} typeName - The name of the type whose factory should be removed.
+ * @returns {boolean}
+ */
+function removeFactory (typeName) {
+  assertString$2(typeName);
+  return type2Factory.delete(typeName.toUpperCase())
+}
+
+/**
+ * Gets the factory function associated with the given type name.
+ * @param {string} typeName - The name of the type to look up.
+ * @returns {LogFactory|undefined} The factory function for the specified type.
+ */
+function getFactory (typeName) {
+  assertString$2(typeName);
+  return type2Factory.get(typeName.toUpperCase())
+}
+
+/**
+ * Clears all registered factories from the type2Factory instance.
+ * This is typically used to reset the factory state during testing or teardown.
+ */
+function clearFactories () {
+  type2Factory.clear();
+}
+
+/**
+ * Returns an array of all registered factory types and intances.
+ * 1. Each entry is a [type, factory] pair
+ * @returns {Array<{0:string, 1:LogFactory}>} An array of factory entries.
+ */
+function listFactories () {
+  return [...type2Factory.entries()]
+}
+
+function clear () {
+  clearProviders$1();
+  clearFactories();
+}
+
+var LogConfig = {
+  currentProvider: currentProvider$1,
+  currentLevel,
+  type2Provider,
+  type2Factory,
+  addProvider: addProvider$1,
+  getProvider,
+  removeProvider: removeProvider$1,
+  clearProviders: clearProviders$1,
+  listProviders,
+  addFactory,
+  getFactory,
+  removeFactory,
+  clearFactories,
+  listFactories,
+  clear
+};
+
+// 3rd
+// internal
+// owned
+// module vars
+/**
+ * A Simple Implementation of the Logger interface that logs to the console.
+ */
+class ConsoleLogger extends Logger {
+  /**
+   * Creates a ConsoleLogger instance.
+   * @constructor
+   * @param {string} name - The logger name.
+   * @param {*} nativeLogger - The native console object to use for logging.
+   * @param {number} level - The initial log level.
+   */
+  constructor (name, nativeLogger, level) {
+    super(name, nativeLogger, level);
+    /**
+     * @type {{error:function, warn:function, debug:function, log:function, info:function, trace:function}}
+     */
+    this.console = nativeLogger;
+  }
+
+  /**
+   * For ConsoleLogger, Nothing to do
+   * @param {number} level
+   * @override
+   * @protectd
+   */
+  _setLevel (level) {
+    // do nothing
+  }
+
+  /**
+   * Logs a fatal error message with timestamp and logger name.
+   * Only outputs if fatal logging is enabled for this logger instance.
+   * @param {...any} args
+   */
+  _fatal (...args) {
+    this.console.error(new Date().toISOString(), this.name, '[Fatal]', ...args);
+  }
+
+  /**
+   * Logs an error message to the console with timestamp and logger name.
+   * Only logs if error logging is enabled for this logger instance.
+   * @param {...any} args
+   */
+  _error (...args) {
+    this.console.error(new Date().toISOString(), this.name, '[Error]', ...args);
+  }
+
+  /**
+   * Logs a warning message to the console if warn logging is enabled.
+   * @param {...any} args
+   */
+  _warn (...args) {
+    this.console.warn(new Date().toISOString(), this.name, '[Warn]', ...args);
+  }
+
+  /**
+   * Logs debug messages to console if debug mode is enabled.
+   * @param {...any} args
+   */
+  _debug (...args) {
+    this.console.debug(new Date().toISOString(), this.name, '[Debug]', ...args);
+  }
+
+  /**
+   * Logs an info message to the console with timestamp and logger name.
+   * @param {...any} args
+   */
+  _info (...args) {
+    this.console.log(new Date().toISOString(), this.name, '[Info]', ...args);
+  }
+
+  /**
+   * Logs a trace message with timestamp and logger name if trace logging is enabled.
+   * @param {...any} args
+   */
+  _trace (...args) {
+    this.console.log(new Date().toISOString(), this.name, '[Trace]', ...args);
+  }
+}
+
+// owned
+// eslint-disable-next-line no-unused-vars
+
+/**
+ * Use Console as the native library
+ */
+class ConsoleLogFactory extends LogFactory {
+  /**
+   * the underlying "Console" Object.
+   * @returns {{}}
+   */
+  get console () {
+    return this._libraryModule // it's the embedded "console" object
+  }
+
+  /**
+   * Gets the current logging settings
+   * @returns {{level:number}} The logging settings object containing the current log level.
+   */
+  get setting () {
+    if (this._setting == null) {
+      this._setting = {
+        level: LogConfig.currentLevel
+      };
+    }
+    // @ts-ignore
+    return this._setting
+  }
+
+  /**
+   * Update factory's Log Level
+   * 1. Only Provider knows how to update
+   * @param {number} level - The log level to set, see {@link LogLevel.Level}
+   * @returns {void}
+   * @throws {Error} Throws an error as this method is Not Impled Yet.
+   * @abstract
+   */
+  setLevel (level) {
+    assertLevel$1(level);
+    if (level !== this.setting.level) {
+      this.setting.level = level;
+    }
+    // init again
+    this.init();
+  }
+
+  /**
+   * Initializes the log4js provider by configuring it with the provided settings.
+   * @async
+   * @override
+   * @returns {Promise<void>|void}
+   */
+  init () {
+    // do nothing
+  }
+
+  /**
+   * Creates a new logger instance with the specified name and log level.
+   * @param {string} loggerName - The name of the logger to create.
+   * @returns {Logger} A new logger instance configured with the given name and level.
+   * @override
+   */
+  createLogger (loggerName) {
+    return new ConsoleLogger(loggerName, this.console, this.setting.level)
+  }
+}
+
+// owned
+
+class ConsoleProvider extends Provider {
+  /**
+   * Gets the provider type (Console).
+   * @returns {string} "CONSOLE"
+   * @override
+   */
+  getType () {
+    return ProviderType.Console
+  }
+
+  /**
+ * Creates a new Provider instance.
+ * @param {Object} libraryModule - The library module to be used.
+ * @param {Object} setting - Configuration settings for the provider.
+ * @returns {ConsoleLogFactory} A new instance of ConsoleProvider.
+ * @override
+ */
+  createLogFactory (libraryModule, setting) {
+    return new ConsoleLogFactory(libraryModule, setting)
+  }
+}
+
+// internal
+
+
+// module vars
+const provider = new ConsoleProvider();
+
+// 3rd
+// internal
+// owned
+// module vars
+
+class Log4jsLogger extends Logger {
+  /**
+   * Creates a new ConsoleLogger instance.
+   * @constructor
+   * @param {string} name - The name of the logger.
+   * @param {*} nativeLogger - Log4js library
+   */
+  constructor (name, nativeLogger) {
+    super(name, nativeLogger);
+    // @ts-ignore
+    this._level = undefined; // MUST NOT accept level from outside
+    this._logger = nativeLogger;
+  }
+
+  /**
+   * 1. log4js may have many categories(loggerName) with diffirent level
+   * 2. return the underlying log4js native logger's level
+   * @returns {number} The current log level.
+   */
+  get level () {
+    if (this._level == null) {
+      const levelName = this._logger.level.levelStr;
+      if (levelName == null) {
+        return Level$1.OFF
+      }
+      const level = name2Value(levelName);
+      if (level == null) {
+        throw new Error(`Unknown level name: ${levelName}`)
+      }
+      return level
+    }
+    return this._level
+  }
+
+  /**
+   * set log4js native logger's level
+   * @param {number} level
+   * @override
+   * @protectd
+   */
+  _setLevel (level) {
+    assertLevel$1(level);
+    const levelName = value2Name(level);
+    if (levelName == null) {
+      throw new Error(`Invalid log level: ${level}`)
+    }
+    // log4js use string level, eg. 'error, trace'
+    this._logger.level = levelName.toLowerCase();
+  }
+
+  /**
+   * Logs a fatal error message with timestamp and logger name.
+   * Only outputs if fatal logging is enabled for this logger instance.
+   * @param {...any} args - Arguments to log (will be space-separated)
+   */
+  _fatal (...args) {
+    this._logger.fatal(...args);
+  }
+
+  /**
+   * Logs an error message to the console with timestamp and logger name.
+   * Only logs if error logging is enabled for this logger instance.
+   * @param {...any} args - Arguments to be logged as error message
+   */
+  _error (...args) {
+    this._logger.error(...args);
+  }
+
+  /**
+   * Logs a warning message to the console if warn logging is enabled.
+   * @param {...any} args - The arguments to log as a warning message.
+   */
+  _warn (...args) {
+    this._logger.warn(...args);
+  }
+
+  /**
+   * Logs debug messages to console if debug mode is enabled.
+   * @param {...any} args - The data to be logged
+   */
+  _debug (...args) {
+    this._logger.debug(...args);
+  }
+
+  /**
+   * Logs an info message to the console with timestamp and logger name.
+   * @param {...any} args - The data to be logged. Accepts multiple arguments.
+   */
+  _info (...args) {
+    this._logger.info(...args);
+  }
+
+  /**
+   * Logs a trace message with timestamp and logger name if trace logging is enabled.
+   * @param {...any} args - Data to be logged as trace message.
+   */
+  _trace (...args) {
+    this._logger.trace(...args);
+  }
+}
+
+const DefaultConfig = { // 6x fromat
+  appenders: {
+    out: { type: 'console' }
+  },
+  categories: {
+    default: { appenders: ['out'], level: 'error' }
+  }
+};
+
+// internal
+
+const { assertString: assertString$1 } = N;
+
+/**
+ * Use log4js as the logging provider.
+ */
+class Log4jsFactory extends LogFactory {
+  /**
+   * the log4js module instance.
+   * @returns {{}} The log4js module instance.
+   */
+  get log4js () {
+    return this._libraryModule
+  }
+
+  get setting () {
+    if (this._setting == null) {
+      this._setting = cloneDefaultConfig();
+    }
+    return this._setting
+  }
+
+  /**
+   * Initializes the log4js provider by configuring it with the provided settings.
+   * @override
+   */
+  init () {
+    // @ts-ignore
+    this.log4js.configure(this.setting);
+  }
+
+  /**
+   * Update factory's Log Level
+   * 1. Only Provider knows how to update
+   * @param {number} level - The log level to set, see {@link LogLevel.Level}
+   * @returns {void}
+   * @throws {Error} Throws an error as this method is Not Impled Yet.
+   * @abstract
+   */
+  setLevel (level) {
+    let levelName = value2Name(level);
+    if (levelName == null) {
+      throw new Error(`Invalid log level: ${level}`)
+    }
+    levelName = levelName.toLowerCase();
+    let updated = false;
+    // @ts-ignore
+    const { categories } = this.setting;
+    for (const categoryKey in categories) {
+      const category = categories[categoryKey];
+      const { level: categoryLevel } = category;
+      if (categoryLevel !== levelName) {
+        category.level = levelName.toLowerCase();
+        updated = true;
+      }
+    }
+    // init log4js again
+    updated && this.init();
+  }
+
+  /**
+   * Creates a new logger instance with the specified name and log level.
+   * @param {string} loggerName - The name of the logger to create.
+   * @returns {Logger} A new logger instance configured with the given name and level.
+   * @override
+   */
+  createLogger (loggerName) {
+    assertString$1(loggerName);
+    // @ts-ignore
+    const nativeLogger = this.log4js.getLogger(loggerName);
+    const logger = new Log4jsLogger(loggerName, nativeLogger);
+    return logger
+  }
+}
+
+function cloneDefaultConfig () {
+  return JSON.parse(JSON.stringify(DefaultConfig))
+}
+
+// internal
+
+const { assertNotNil: assertNotNil$1 } = N;
+
+class Log4jsProvider extends Provider {
+  /**
+   * Gets the provider type (Log4js).
+   * @returns {string} "LOG4JS"
+   * @override
+   */
+  getType () {
+    return ProviderType.Log4js
+  }
+
+  /**
+   * Creates a new Provider instance.
+   * @param {*} libraryModule - The library module to be used.
+   * @param {*} setting - Configuration settings for the provider.
+   * @returns {Log4jsFactory} A new instance of Log4jsFactory.
+   * @override
+   */
+  createLogFactory (libraryModule, setting) {
+    assertNotNil$1(libraryModule);
+    const factory = new Log4jsFactory(libraryModule, setting);
+    factory.init();
+    return factory
+  }
+}
+
+// internal
+
+
+// module vars
+const log4jsProvider = new Log4jsProvider();
+
+/**
+ * @module CommonsLogging
+ * @description Common logging library
+ *
+ * Follow the sequence to init log system: addProvider() -> use() -> configure() -> getLogger()
+ * 1. Add ability to handle the type of library
+ *    * eg. after adding Log4jsProvider, we can use Log4js library
+ * 2. But we MAY NOT use it now.
+ *    * call useProvider(typeName) to select which kind of LogProvider Implementation to use.
+ *    * call configure(typeName, nativeLib, setting) to LogProvider Implementation
+ */
+// 3rd
+// internal
+
+const { assertNotNil, assertString } = N;
+const { isFunction, isNil } = r;
+
+/**
+ * "default" export to support "import CommonsLogging from '@creejs/commons-logging'"
+ */
+var index = {
+  Provider,
+  LogFactory,
+  Logger,
+  LogLevel,
+  ProviderType,
+  getLogger,
+  setLevel,
+  useProvider,
+  /**
+   * alias for {@link CommonsLogging.useProvider}
+   * @see {@link CommonsLogging.useProvider}
+   * @function
+   * @alias module:CommonsLogging.use
+   */
+  use: useProvider,
+  configureProvider,
+  /**
+   * @function
+   * @alias module:CommonsLogging.confiure
+   */
+  configure: configureProvider,
+  configureThenUseProvider,
+  /**
+   * @function
+   * @alias module:CommonsLogging.configureThenUseProvider
+   */
+  configureThenUse: configureThenUseProvider,
+  addProvider,
+  add: addProvider,
+  clearProviders,
+  currentProvider,
+  /**
+   * @function
+   * @alias module:CommonsLogging.current
+   */
+  current: currentProvider,
+  removeProvider,
+  /**
+   * @function
+   * @alias module:CommonsLogging.remove
+   */
+  remove: removeProvider,
+  /**
+   * @alias module:CommonsLogging.ConsoleProvider
+   */
+  ConsoleProvider: provider,
+  /**
+   * @alias module:CommonsLogging.Log4jsProvider
+   */
+  Log4jsProvider: log4jsProvider
+};
+
+// module vars
+
+/**
+ * Store Created Loggers, indexed with Names
+ * @type {Map<string, Logger>}
+ * @private
+ */
+const name2Logger = new Map();
+
+/**
+   * set Global logging level
+   * @param {'TRACE'|'DEBUG'|'INFO'|'WARN'|'ERROR'|'FATAL'|'OFF'|'trace'|'debug'|'info'|'warn'|'error'|'fatal'|'off'} level - The log level
+   */
+function setLevel (level) {
+  assertString(level);
+  const upperLevel = level.toUpperCase();
+  const levelNumber = LogLevel.name2Value(upperLevel);
+  if (levelNumber == null) {
+    throw new Error(`Invalid log level: ${level}`)
+  }
+  if (levelNumber === LogConfig.currentLevel) {
+    return // no change
+  }
+  LogConfig.currentLevel = levelNumber;
+
+  // refresh existed factories
+  // @ts-ignore
+  // eslint-disable-next-line no-unused-vars
+  for (const [typeName, factory] of LogConfig.listFactories()) {
+    factory.setLevel(levelNumber);
+  }
+  // refresh existed Loggers
+  for (const logger of name2Logger.values()) {
+    if (logger.level !== levelNumber) {
+      logger.setLevel(levelNumber);
+    }
+  }
+}
+
+function currentProvider () {
+  return LogConfig.currentProvider
+}
+
+/**
+ * Set the provider using currently
+ * @param {string} typeName - The type name of the logging provider to use.
+ * @returns {void}
+ * @throws {Error} If the provider name is unknown.
+ */
+function useProvider (typeName) {
+  assertString(typeName);
+  typeName = typeName.toUpperCase();
+  const provider = LogConfig.getProvider(typeName);
+  if (provider == null) {
+    throw new Error(`No Provider Named with: ${typeName}`)
+  }
+  LogConfig.currentProvider = typeName;
+}
+
+/**
+ * Removes and returns the provider associated with the given type name.
+ * If no provider exists for the type name, the function returns undefined.
+ *
+ * @param {string} typeName - The type name of the provider to remove.
+ * @returns {boolean} The removed provider, or undefined if not found.
+ */
+function removeProvider (typeName) {
+  if (typeName == null) {
+    return false
+  }
+  assertString(typeName);
+  typeName = typeName.toUpperCase();
+  return LogConfig.removeProvider(typeName)
+}
+
+/**
+ * Add a type of Provider
+ *
+ * More:
+ * 1. A Provider is a Module
+ * 2. The module must include the following functions:
+ *   1. getType() - Returns the type name of the provider.
+ *   2. createLogFactory() - Creates a new LogFactory instance.
+ * @param {Provider} provider - Logging Library Module
+ * @returns {void}
+ */
+function addProvider (provider) {
+  assertNotNil(provider);
+  const { getType, createLogFactory } = provider;
+  if (!isFunction(getType) || !isFunction(createLogFactory)) {
+    throw new Error('Invalid Provider Module, missing getType(), createLogFactory() functions')
+  }
+  let typeName = provider.getType();
+  assertString(typeName);
+  typeName = typeName.toUpperCase();
+  LogConfig.addProvider(typeName, provider);
+  // set current provider if not set yet
+  if (isNil(currentProvider())) {
+    useProvider(typeName);
+  }
+}
+
+function clearProviders () {
+  name2Logger.clear();
+  LogConfig.clear();
+}
+
+/**
+ * configure provider to initialize its LogFactory
+ * 1. find the LogProvider Implementation of "typeName"
+ *    * if type is not supported, throw error
+ * 2. use the nativeLib and setting to initialize the LogProvider
+ * 3. create a LogFactory via teh LogProvider
+ * @param {string} typeName - The type of logging provider to configure.
+ * @param {*} [nativeLib] - The native library to use for logging.
+ * @param {*} [setting] - Configuration settings for the logging provider.
+ * @throws {Error} If the typeName is not recognized.
+ */
+function configureProvider (typeName, nativeLib, setting) {
+  assertString(typeName);
+  typeName = typeName.toUpperCase();
+  const provider = LogConfig.getProvider(typeName);
+  if (provider == null) {
+    throw new Error(`No Provider: ${typeName}`)
+  }
+  const factory = provider.createLogFactory(nativeLib, setting);
+  LogConfig.addFactory(typeName, factory);
+}
+
+/**
+ * Configures and immediately uses a logging provider with the given settings.
+ * @param {string} typeName - The type/name identifier for the provider.
+ * @param {*} nativeLib - The native library implementation to configure.
+ * @param {*} setting - Configuration settings for the provider.
+ */
+function configureThenUseProvider (typeName, nativeLib, setting) {
+  configureProvider(typeName, nativeLib, setting);
+  useProvider(typeName);
+}
+
+/**
+ * Gets a logger instance for the specified logger name using the current provider.
+ * @param {string} loggerName - The name of the logger to retrieve.
+ * @returns {Logger} The logger instance.
+ * @throws {Error} If no default provider is set or if the current provider is not initialized.
+ */
+function getLogger (loggerName) {
+  // if logger already exists, return it
+  let logger = name2Logger.get(loggerName);
+  if (logger != null) {
+    return logger
+  }
+  // create a new logger via the current provider's LogFactory
+  const currentTypeName = currentProvider();
+  if (currentTypeName == null) {
+    throw new Error('No Default LogProvider, call useProvider(typeName)')
+  }
+  const factory = LogConfig.getFactory(currentTypeName);
+  if (factory == null) {
+    throw new Error('configureProvider(typeName, nativeLib, settting) before getting logger via Provider')
+  }
+  logger = factory.createLogger(loggerName);
+  name2Logger.set(loggerName, logger);
+  return logger
+}
+
+function initLogSystem () {
+  addProvider(log4jsProvider);
+  // ConsoleProvider as default impl
+  addProvider(provider);
+  configureProvider(ProviderType.Console, console);
+  useProvider(ProviderType.Console); // Use ConsoleLogger as default
+}
+
+initLogSystem();
+
+exports.ConsoleProvider = provider;
+exports.Log4jsProvider = log4jsProvider;
+exports.LogFactory = LogFactory;
+exports.LogLevel = LogLevel;
+exports.Logger = Logger;
+exports.Provider = Provider;
+exports.ProviderType = ProviderType;
+exports.add = addProvider;
+exports.addProvider = addProvider;
+exports.clearProviders = clearProviders;
+exports.configure = configureProvider;
+exports.configureProvider = configureProvider;
+exports.configureThenUse = configureThenUseProvider;
+exports.configureThenUseProvider = configureThenUseProvider;
+exports.current = currentProvider;
+exports.currentProvider = currentProvider;
+exports.default = index;
+exports.getLogger = getLogger;
+exports.remove = removeProvider;
+exports.removeProvider = removeProvider;
+exports.setLevel = setLevel;
+exports.use = useProvider;
+exports.useProvider = useProvider;
+//# sourceMappingURL=index-dev.cjs.map