@creejs/commons-logging 2.0.0 → 2.0.2

package/dist/umd/index.dev.js

@@ -0,0 +1,1456 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.CommonsLang = {}));
+})(this, (function (exports) { 'use strict';
+
+  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;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=index.dev.js.map