@creejs/commons-logging 2.0.0 → 2.0.2

package/types/log-factory.d.ts

@@ -1,8 +1,7 @@
-export = LogFactory;
 /**
  * @abstract
  */
-declare class LogFactory {
+export default class LogFactory {
     /**
      * Checks if a value resembles a LogFactory by verifying it has required methods.
      * @param {*} value - The value to check
@@ -52,4 +51,4 @@ declare class LogFactory {
      */
     createLogger(loggerName: string): Logger;
 }
-import Logger = require("./logger");
+import Logger from "./logger.js";

package/types/log-level.d.ts

@@ -1,3 +1,16 @@
+export default LogLevel;
+declare namespace LogLevel {
+    export { Name };
+    export { Level };
+    export { DefaultLevel };
+    export { hasLevel };
+    export { hasName };
+    export { assertLevel };
+    export { Name as LevelName };
+    export { Level as LevelValue };
+    export { value2Name };
+    export { name2Value };
+}
 /**
  * *
  */
@@ -16,21 +29,21 @@ export namespace Name {
  */
 export type Level = number;
 export namespace Level {
-    let OFF_1: number;
+    const OFF_1: number;
     export { OFF_1 as OFF };
-    let FATAL_1: number;
+    const FATAL_1: number;
     export { FATAL_1 as FATAL };
-    let ERROR_1: number;
+    const ERROR_1: number;
     export { ERROR_1 as ERROR };
-    let WARN_1: number;
+    const WARN_1: number;
     export { WARN_1 as WARN };
-    let INFO_1: number;
+    const INFO_1: number;
     export { INFO_1 as INFO };
-    let DEBUG_1: number;
+    const DEBUG_1: number;
     export { DEBUG_1 as DEBUG };
-    let TRACE_1: number;
+    const TRACE_1: number;
     export { TRACE_1 as TRACE };
-    export let ALL: number;
+    export const ALL: number;
 }
 /**
  * The default logging level (ERROR)

package/types/log4js/index.d.ts

@@ -1,3 +1,3 @@
-export = log4jsProvider;
+export default log4jsProvider;
 declare const log4jsProvider: Log4jsProvider;
-import Log4jsProvider = require("./log4js-provider");
+import Log4jsProvider from "./log4js-provider.js";

package/types/log4js/log4js-6x-config.d.ts

@@ -1,13 +1,16 @@
-export namespace appenders {
-    namespace out {
-        let type: string;
+export default DefaultConfig;
+export namespace DefaultConfig {
+    namespace appenders {
+        namespace out {
+            const type: string;
+        }
     }
-}
-export namespace categories {
-    namespace _default {
-        let appenders_1: string[];
-        export { appenders_1 as appenders };
-        export let level: string;
+    namespace categories {
+        namespace _default {
+            const appenders_1: string[];
+            export { appenders_1 as appenders };
+            export const level: string;
+        }
+        export { _default as default };
     }
-    export { _default as default };
 }

package/types/log4js/log4js-factory.d.ts

@@ -1,8 +1,7 @@
-export = Log4jsFactory;
 /**
  * Use log4js as the logging provider.
  */
-declare class Log4jsFactory extends LogFactory {
+export default class Log4jsFactory extends LogFactory {
     /**
      * the log4js module instance.
      * @returns {{}} The log4js module instance.
@@ -14,4 +13,4 @@ declare class Log4jsFactory extends LogFactory {
      */
     override init(): void;
 }
-import LogFactory = require("../log-factory");
+import LogFactory from "../log-factory.js";

package/types/log4js/log4js-logger.d.ts

@@ -1,5 +1,4 @@
-export = Log4jsLogger;
-declare class Log4jsLogger extends Logger {
+export default class Log4jsLogger extends Logger {
     /**
      * Creates a new ConsoleLogger instance.
      * @constructor
@@ -10,4 +9,4 @@ declare class Log4jsLogger extends Logger {
     _level: any;
     _logger: any;
 }
-import Logger = require("../logger");
+import Logger from "../logger.js";

package/types/log4js/log4js-provider.d.ts

@@ -1,5 +1,4 @@
-export = Log4jsProvider;
-declare class Log4jsProvider extends Provider {
+export default class Log4jsProvider extends Provider {
     /**
      * Creates a new Provider instance.
      * @param {*} libraryModule - The library module to be used.
@@ -9,5 +8,5 @@ declare class Log4jsProvider extends Provider {
      */
     override createLogFactory(libraryModule: any, setting: any): Log4jsFactory;
 }
-import Provider = require("../provider");
-import Log4jsFactory = require("./log4js-factory");
+import Provider from "../provider.js";
+import Log4jsFactory from "./log4js-factory.js";

package/types/logger.d.ts

@@ -1,9 +1,8 @@
-export = Logger;
 /**
  * Abstract Logger Class of All Logger
  * @abstract
  */
-declare class Logger {
+export default class Logger {
     /**
      * Creates a new Logger instance.
      * @constructor
@@ -11,7 +10,7 @@ declare class Logger {
      * @param {*} [nativeLogger]
      * @param {number} [level] - The logging level, default is Level.ERROR=1
      */
-    constructor(name: string, nativeLogger?: any, level?: number);
+    constructor(name: string, nativeLogger?: any, level?: number | undefined);
     _name: string;
     _nativeLogger: any;
     _level: number;

package/types/provider-type.d.ts

@@ -8,3 +8,8 @@ export const Log4js: string;
  * @memberof ProviderType
  */
 export const Console: string;
+declare namespace _default {
+    export { Log4js };
+    export { Console };
+}
+export default _default;

package/types/provider.d.ts

@@ -1,9 +1,8 @@
-export = Provider;
 /**
  * A interface that All Provider module must export
  * @interface
  */
-declare class Provider {
+export default class Provider {
     /**
      * Checks if a value resembles a logging provider by verifying it has required methods.
      * @param {*} value - The value to check
@@ -29,4 +28,4 @@ declare class Provider {
      */
     createLogFactory(nativeLib?: any, setting?: any): LogFactory;
 }
-import LogFactory = require("./log-factory");
+import LogFactory from "./log-factory.js";

package/lib/console/console-log-factory.js

@@ -1,76 +0,0 @@
-'use strict'
-
-// owned
-// eslint-disable-next-line no-unused-vars
-const Logger = require('../logger')
-// eslint-disable-next-line no-unused-vars
-const { Level, assertLevel } = require('../log-level')
-const LogFactory = require('../log-factory')
-const ConsoleLogger = require('./console-logger')
-const LogConfig = require('../log-config')
-
-/**
- * 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(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)
-  }
-}
-
-module.exports = ConsoleLogFactory

package/lib/console/console-log-provider.js

@@ -1,29 +0,0 @@
-'use strict'
-
-const ProviderType = require('../provider-type')
-const Provider = require('../provider')
-const ConsoleLogFactory = require('./console-log-factory')
-
-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)
-  }
-}
-
-module.exports = ConsoleProvider

package/lib/console/console-logger.js

@@ -1,88 +0,0 @@
-'use strict'
-
-// 3rd
-// internal
-// owned
-const Logger = require('../logger')
-// 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)
-  }
-}
-
-module.exports = ConsoleLogger

package/lib/console/index.js

@@ -1,11 +0,0 @@
-'use strict'
-
-// internal
-
-// owned
-const ConsoleProvider = require('./console-log-provider')
-
-// module vars
-const provider = new ConsoleProvider()
-
-module.exports = provider

package/lib/index.js

@@ -1,259 +0,0 @@
-'use strict'
-/**
- * @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 {
-  TypeAssert: { assertNotNil, assertString },
-  TypeUtils: { isFunction, isNil }
-} = require('@creejs/commons-lang')
-
-// owned
-const LogFactory = require('./log-factory')
-const Logger = require('./logger')
-const ProviderType = require('./provider-type')
-const LogLevel = require('./log-level')
-const LogConfig = require('./log-config')
-
-const ConsoleProvider = require('./console')
-const Log4jsProvider = require('./log4js')
-const Provider = require('./provider')
-
-// 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(ConsoleProvider)
-  configureProvider(ProviderType.Console, console)
-  useProvider(ProviderType.Console) // Use ConsoleLogger as default
-}
-
-initLogSystem()
-
-const CommonsLogging = {
-  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,
-  /**
-   * @alias module:CommonsLogging.Log4jsProvider
-   */
-  Log4jsProvider
-}
-module.exports = CommonsLogging