@creejs/commons-logging 1.0.0 → 2.0.0

package/lib/index.js

@@ -54,7 +54,9 @@ function setLevel (level) {
   LogConfig.currentLevel = levelNumber
 
   // refresh existed factories
-  for (const [, factory] of LogConfig.listFactories()) {
+  // @ts-ignore
+  // eslint-disable-next-line no-unused-vars
+  for (const [typeName, factory] of LogConfig.listFactories()) {
     factory.setLevel(levelNumber)
   }
   // refresh existed Loggers

package/lib/log-config.js

@@ -1,4 +1,9 @@
 'use strict'
+/**
+ * @module LogConfig
+ * @description Provide Impl of Log Configuration
+ * @private
+ */
 // internal
 const { TypeAssert: { assertString } } = require('@creejs/commons-lang')
 // owned
@@ -36,11 +41,12 @@ const type2Provider = new Map()
  * @param {string} typeName - The type identifier for the provider.
  * @param {Provider} provider - The logging provider implementation.
  * @returns {void}
+ * @alias module:LogConfig.addProvider
  */
 function addProvider (typeName, provider) {
   assertString(typeName)
   Provider.assertProviderLike(provider)
-  type2Provider.set(typeName, provider)
+  type2Provider.set(typeName.toUpperCase(), provider)
 }
 
 /**
@@ -50,7 +56,7 @@ function addProvider (typeName, provider) {
  */
 function getProvider (typeName) {
   assertString(typeName)
-  return type2Provider.get(typeName)
+  return type2Provider.get(typeName.toUpperCase())
 }
 
 /**
@@ -60,7 +66,7 @@ function getProvider (typeName) {
  */
 function removeProvider (typeName) {
   assertString(typeName)
-  return type2Provider.delete(typeName)
+  return type2Provider.delete(typeName.toUpperCase())
 }
 
 function clearProviders () {
@@ -70,7 +76,7 @@ function clearProviders () {
 /**
  * Returns an array of all registered factory types and intances.
  * 1. Each entry is a [type, factory] pair
- * @returns {Array<[string, Provider]>} An array of factory entries.
+ * @returns {Array<{0:string, 1:Provider}>} An array of factory entries.
  */
 function listProviders () {
   return [...type2Provider.entries()]
@@ -91,7 +97,7 @@ const type2Factory = new Map()
 function addFactory (typeName, logFactory) {
   assertString(typeName)
   LogFactory.assertLogFactoryLike(logFactory)
-  type2Factory.set(typeName, logFactory)
+  type2Factory.set(typeName.toUpperCase(), logFactory)
 }
 
 /**
@@ -101,7 +107,7 @@ function addFactory (typeName, logFactory) {
  */
 function removeFactory (typeName) {
   assertString(typeName)
-  return type2Factory.delete(typeName)
+  return type2Factory.delete(typeName.toUpperCase())
 }
 
 /**
@@ -111,7 +117,7 @@ function removeFactory (typeName) {
  */
 function getFactory (typeName) {
   assertString(typeName)
-  return type2Factory.get(typeName)
+  return type2Factory.get(typeName.toUpperCase())
 }
 
 /**
@@ -125,7 +131,7 @@ function clearFactories () {
 /**
  * Returns an array of all registered factory types and intances.
  * 1. Each entry is a [type, factory] pair
- * @returns {Array<[string, LogFactory]>} An array of factory entries.
+ * @returns {Array<{0:string, 1:LogFactory}>} An array of factory entries.
  */
 function listFactories () {
   return [...type2Factory.entries()]

package/lib/log-level.js

@@ -102,6 +102,8 @@ function name2Value (name) {
  * 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)
@@ -111,6 +113,8 @@ function hasLevel (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)) {
@@ -123,6 +127,8 @@ function hasName (levelName) {
  * 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 (level) {
   if (!isNumber(level)) {

package/lib/provider-type.js

@@ -1,6 +1,15 @@
 'use strict'
+/**
+ * @type {string}
+ * @memberof ProviderType
+ */
 const Log4js = 'LOG4JS'
+/**
+ * @type {string}
+ * @memberof ProviderType
+ */
 const Console = 'CONSOLE'
+
 /**
  * @namespace ProviderType
  * @description Define the static types

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@creejs/commons-logging",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "Common Utils About Logging",
   "main": "index.js",
   "private": false,
@@ -10,6 +10,7 @@
     "types/",
     "README.md"
   ],
+  "types": "types/index.d.ts",
   "publishConfig": {
     "access": "public"
   },
@@ -19,16 +20,11 @@
   },
   "scripts": {
     "dts": "tsc",
-    "generate-docs": "node_modules/.bin/jsdoc -c ./jsdoc.json"
+    "generate-docs": "../../node_modules/.bin/jsdoc -c ./jsdoc.json"
   },
   "author": "rodney.vin@gmail.com",
   "license": "Apache-2.0",
   "dependencies": {
-    "@creejs/commons-lang": "1.x"
-  },
-  "devDependencies": {
-    "better-docs": "^2.7.3",
-    "jsdoc": "^4.0.4",
-    "log4js": "6.x"
+    "@creejs/commons-lang": "^2.0.0"
   }
 }

package/types/console/console-log-factory.d.ts

@@ -0,0 +1,19 @@
+export = ConsoleLogFactory;
+/**
+ * Use Console as the native library
+ */
+declare class ConsoleLogFactory extends LogFactory {
+    /**
+     * the underlying "Console" Object.
+     * @returns {{}}
+     */
+    get console(): {};
+    /**
+     * Gets the current logging settings
+     * @returns {{level:number}} The logging settings object containing the current log level.
+     */
+    get setting(): {
+        level: number;
+    };
+}
+import LogFactory = require("../log-factory");

package/types/console/console-log-provider.d.ts

@@ -0,0 +1,13 @@
+export = ConsoleProvider;
+declare class ConsoleProvider extends Provider {
+    /**
+   * 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
+   */
+    override createLogFactory(libraryModule: Object, setting: Object): ConsoleLogFactory;
+}
+import Provider = require("../provider");
+import ConsoleLogFactory = require("./console-log-factory");

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

@@ -0,0 +1,26 @@
+export = ConsoleLogger;
+/**
+ * A Simple Implementation of the Logger interface that logs to the console.
+ */
+declare 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: string, nativeLogger: any, level: number);
+    /**
+     * @type {{error:function, warn:function, debug:function, log:function, info:function, trace:function}}
+     */
+    console: {
+        error: Function;
+        warn: Function;
+        debug: Function;
+        log: Function;
+        info: Function;
+        trace: Function;
+    };
+}
+import Logger = require("../logger");

package/types/console/index.d.ts

@@ -0,0 +1,3 @@
+export = provider;
+declare const provider: ConsoleProvider;
+import ConsoleProvider = require("./console-log-provider");

package/types/index.d.ts

@@ -1,22 +1,68 @@
+import Provider = require("./provider");
+import LogFactory = require("./log-factory");
 import Logger = require("./logger");
-import LoggingLevel = require("./logging-level");
+import LogLevel = require("./log-level");
+import ProviderType = require("./provider-type");
 /**
- * Adds a logging provider with the specified library and settings.
- * @param {module} providerLib - The logging provider library to add.
- * @param {{}} setting - Configuration settings for the provider.
+ * 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.
  */
-export function addProvider(providerLib: any, setting: {}): void;
-/**
-   * Gets or creates a named logger instance with the specified log level.
-   * If a logger with the given name already exists, updates its log level if different.
-   * @param {string} name - The name identifier for the logger
-   * @param {'TRACE'|'DEBUG'|'INFO'|'WARN'|'ERROR'|'FATAL'|'OFF'|'trace'|'debug'|'info'|'warn'|'error'|'fatal'|'off'} [level='ERROR'] - The log level
-   * @returns {Logger} The logger instance for the given name
-   */
-export function getLogger(name: string, level?: "TRACE" | "DEBUG" | "INFO" | "WARN" | "ERROR" | "FATAL" | "OFF" | "trace" | "debug" | "info" | "warn" | "error" | "fatal" | "off"): Logger;
+export function getLogger(loggerName: string): Logger;
 /**
    * set Global logging level
    * @param {'TRACE'|'DEBUG'|'INFO'|'WARN'|'ERROR'|'FATAL'|'OFF'|'trace'|'debug'|'info'|'warn'|'error'|'fatal'|'off'} level - The log level
    */
 export function setLevel(level: "TRACE" | "DEBUG" | "INFO" | "WARN" | "ERROR" | "FATAL" | "OFF" | "trace" | "debug" | "info" | "warn" | "error" | "fatal" | "off"): void;
-export { Logger, LoggingLevel };
+/**
+ * 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.
+ */
+export function useProvider(typeName: string): void;
+/**
+ * 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.
+ */
+export function configureProvider(typeName: string, nativeLib?: any, setting?: any): void;
+/**
+ * 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.
+ */
+export function configureThenUseProvider(typeName: string, nativeLib: any, setting: any): void;
+/**
+ * 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}
+ */
+export function addProvider(provider: Provider): void;
+export function clearProviders(): void;
+export function currentProvider(): string;
+/**
+ * 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.
+ */
+export function removeProvider(typeName: string): boolean;
+import ConsoleProvider = require("./console");
+import Log4jsProvider = require("./log4js");
+export { Provider, LogFactory, Logger, LogLevel, ProviderType, useProvider as use, configureProvider as configure, configureThenUseProvider as configureThenUse, addProvider as add, currentProvider as current, removeProvider as remove, ConsoleProvider, Log4jsProvider };

package/types/log-config.d.ts

@@ -0,0 +1,89 @@
+/**
+ * type name of current provider
+ * @type {string}
+ * @public
+ */
+export let currentProvider: string;
+/**
+ * Global logging level
+ * @type {number}
+ * @public
+ */
+export let currentLevel: number;
+/**
+ * The map of registered logging libraries
+ * @type {Map<string,Provider>}
+ * @private
+ */
+export const type2Provider: Map<string, Provider>;
+/**
+ * Created LogFactories Index with type name
+ * @type {Map<string, LogFactory>}
+ * @public
+ */
+export const type2Factory: Map<string, LogFactory>;
+/**
+ * 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
+ */
+export function addProvider(typeName: string, provider: Provider): void;
+/**
+ * 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.
+ */
+export function getProvider(typeName: string): Provider | undefined;
+/**
+ * Removes a logging provider of the specified type.
+ * @param {string} typeName - The type name of the provider to remove.
+ * @returns {boolean}
+ */
+export function removeProvider(typeName: string): boolean;
+export function clearProviders(): void;
+/**
+ * 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.
+ */
+export function listProviders(): Array<{
+    0: string;
+    1: Provider;
+}>;
+/**
+ * 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.
+ */
+export function addFactory(typeName: string, logFactory: LogFactory): void;
+/**
+ * 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.
+ */
+export function getFactory(typeName: string): LogFactory | undefined;
+/**
+ * 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}
+ */
+export function removeFactory(typeName: string): boolean;
+/**
+ * Clears all registered factories from the type2Factory instance.
+ * This is typically used to reset the factory state during testing or teardown.
+ */
+export function clearFactories(): void;
+/**
+ * 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.
+ */
+export function listFactories(): Array<{
+    0: string;
+    1: LogFactory;
+}>;
+export function clear(): void;
+import Provider = require("./provider");
+import LogFactory = require("./log-factory");

package/types/log-factory.d.ts

@@ -0,0 +1,55 @@
+export = LogFactory;
+/**
+ * @abstract
+ */
+declare 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: any): boolean;
+    /**
+     * 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: any): void;
+    /**
+     * Creates a new logging provider instance.
+     * @param {{}} libraryModule - the library module
+     * @param {{}} setting - Configuration settings for the provider
+     */
+    constructor(libraryModule: {}, setting: {});
+    _libraryModule: {};
+    _setting: {};
+    get libraryModule(): {};
+    get 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(): Promise<void> | void;
+    /**
+     * 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: number): void;
+    /**
+     * 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: string): Logger;
+}
+import Logger = require("./logger");

package/types/log-level.d.ts

@@ -0,0 +1,93 @@
+/**
+ * *
+ */
+export type Name = string;
+export namespace Name {
+    export { TRACE };
+    export { DEBUG };
+    export { INFO };
+    export { WARN };
+    export { ERROR };
+    export { FATAL };
+    export { OFF };
+}
+/**
+ * *
+ */
+export type Level = number;
+export namespace Level {
+    let OFF_1: number;
+    export { OFF_1 as OFF };
+    let FATAL_1: number;
+    export { FATAL_1 as FATAL };
+    let ERROR_1: number;
+    export { ERROR_1 as ERROR };
+    let WARN_1: number;
+    export { WARN_1 as WARN };
+    let INFO_1: number;
+    export { INFO_1 as INFO };
+    let DEBUG_1: number;
+    export { DEBUG_1 as DEBUG };
+    let TRACE_1: number;
+    export { TRACE_1 as TRACE };
+    export let ALL: number;
+}
+/**
+ * The default logging level (ERROR)
+ * @type {number}
+ * @memberof LogLevel
+ * @static
+ */
+export const DefaultLevel: number;
+/**
+ * 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
+ */
+export function hasLevel(level: number): boolean;
+/**
+ * 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
+ */
+export function hasName(levelName: string): boolean;
+/**
+ * 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
+ */
+export function assertLevel(level: any): void;
+/**
+ * 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
+ */
+export function value2Name(value: number): string | undefined;
+/**
+ * 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
+ */
+export function name2Value(name: string): number | undefined;
+/**
+ * @namespace LogLevel
+ * @description Defines the logging levels and provides utilities for working with them.
+ */
+declare const TRACE: "TRACE";
+declare const DEBUG: "DEBUG";
+declare const INFO: "INFO";
+declare const WARN: "WARN";
+declare const ERROR: "ERROR";
+declare const FATAL: "FATAL";
+declare const OFF: "OFF";
+export { Name as LevelName, Level as LevelValue };

package/types/log4js/index.d.ts

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

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

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

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

@@ -0,0 +1,17 @@
+export = Log4jsFactory;
+/**
+ * Use log4js as the logging provider.
+ */
+declare class Log4jsFactory extends LogFactory {
+    /**
+     * the log4js module instance.
+     * @returns {{}} The log4js module instance.
+     */
+    get log4js(): {};
+    /**
+     * Initializes the log4js provider by configuring it with the provided settings.
+     * @override
+     */
+    override init(): void;
+}
+import LogFactory = require("../log-factory");

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

@@ -0,0 +1,13 @@
+export = Log4jsLogger;
+declare class Log4jsLogger extends Logger {
+    /**
+     * Creates a new ConsoleLogger instance.
+     * @constructor
+     * @param {string} name - The name of the logger.
+     * @param {*} nativeLogger - Log4js library
+     */
+    constructor(name: string, nativeLogger: any);
+    _level: any;
+    _logger: any;
+}
+import Logger = require("../logger");

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

@@ -0,0 +1,13 @@
+export = Log4jsProvider;
+declare class Log4jsProvider extends Provider {
+    /**
+     * 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
+     */
+    override createLogFactory(libraryModule: any, setting: any): Log4jsFactory;
+}
+import Provider = require("../provider");
+import Log4jsFactory = require("./log4js-factory");

package/types/logger.d.ts

@@ -1,111 +1,174 @@
 export = Logger;
 /**
- * Interface of All Logger
+ * Abstract Logger Class of All Logger
  * @abstract
  */
 declare class Logger {
     /**
-     * Creates a new ConsoleLog instance.
+     * Creates a new Logger instance.
      * @constructor
      * @param {string} name - The name identifier for the logger
-     * @param {number} [level=1] - The logging level, default is {@link DefaultLevel} error:1
-     * @param {module} [providerLib] - The provider library
+     * @param {*} [nativeLogger]
+     * @param {number} [level] - The logging level, default is Level.ERROR=1
      */
-    constructor(name: string, level?: number, providerLib?: any);
+    constructor(name: string, nativeLogger?: any, level?: number);
     _name: string;
-    level: number;
-    _providerLib: any;
+    _nativeLogger: any;
+    _level: number;
+    get nativeLogger(): any;
+    get level(): number;
     /**
      * Gets the name of the logger instance.
      * @returns {string} The name of the logger.
      */
     get name(): string;
+    /**
+     * Checks if FATAL level logging is enabled for this logger.
+     * @returns {boolean} True if FATAL level logging is enabled, false otherwise.
+     */
     get fatalEnabled(): boolean;
+    /**
+     * Checks if ERROR level logging is enabled for this logger.
+     * @returns {boolean} True if ERROR level logging is enabled, false otherwise.
+     */
     get errorEnabled(): boolean;
+    /**
+     * Checks if WARN level logging is enabled for this logger.
+     * @returns {boolean} True if WARN level logging is enabled, false otherwise.
+     */
     get warnEnabled(): boolean;
+    /**
+     * Checks if DEBUG level logging is enabled for this logger.
+     * @returns {boolean} True if DEBUG level logging is enabled, false otherwise.
+     */
     get debugEnabled(): boolean;
+    /**
+     * Checks if INFO level logging is enabled for this logger.
+     * @returns {boolean} True if INFO level logging is enabled, false otherwise.
+     */
     get infoEnabled(): boolean;
+    /**
+     * Checks if TRACE level logging is enabled for this logger.
+     * @returns {boolean} True if TRACE level logging is enabled, false otherwise.
+     */
     get traceEnabled(): boolean;
+    /**
+     * 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: number): void;
     /**
      * 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: any[]): void;
-    /**
-     * Override this method to implement fatal logging.
-     * @public
-     * @param {...*} args - Variable arguments
-     * @throws {Error} Always throws "Not Implemented Yet" error
-     */
-    public _fatal(...args: any[]): void;
     /**
      * 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: any[]): void;
-    /**
-     * Override this method to implement error logging.
-     * @public
-     * @param {...*} args - Variable arguments
-     * @throws {Error} Always throws "Not Implemented Yet" error
-     */
-    public _error(...args: any[]): void;
     /**
      * 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: any[]): void;
-    /**
-     * Override this method to implement warn logging.
-     * @public
-     * @param {...*} args - Variable arguments
-     * @throws {Error} Always throws "Not Implemented Yet" error
-     */
-    public _warn(...args: any[]): void;
     /**
      * Logs debug messages to console if debug mode is enabled.
      * @param {...any} args - The data to be logged
      */
     debug(...args: any[]): void;
-    /**
-     * Override this method to implement debug logging.
-     * @public
-     * @param {...*} args - Variable arguments
-     * @throws {Error} Always throws "Not Implemented Yet" error
-     */
-    public _debug(...args: any[]): void;
     /**
      * Logs an info message to the console with timestamp and logger name.
      * @param {...any} args - The data to be logged. Accepts multiple arguments.
-     * @example
-     * logger.info('Service started', { port: 3000 });
      */
     info(...args: any[]): void;
-    /**
-     * Override this method to implement info logging.
-     * @public
-     * @param {...*} args - Variable arguments
-     * @throws {Error} Always throws "Not Implemented Yet" error
-     */
-    public _info(...args: any[]): void;
     /**
      * 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: any[]): void;
     /**
-     * Override this method to implement trace logging.
-     * @public
-     * @param {...*} args - Variable arguments
-     * @throws {Error} Always throws "Not Implemented Yet" error
+     * Checks if FATAL level logging is enabled for this logger.
+     * @returns {boolean} True if FATAL level logging is enabled, false otherwise.
      */
-    public _trace(...args: any[]): void;
     isFatalEnabled(): boolean;
+    /**
+     * Checks if ERROR level logging is enabled for this logger.
+     * @returns {boolean} True if ERROR level logging is enabled, false otherwise.
+     */
     isErrorEnabled(): boolean;
+    /**
+     * Checks if WARN level logging is enabled for this logger.
+     * @returns {boolean} True if WARN level logging is enabled, false otherwise.
+     */
     isWarnEnabled(): boolean;
+    /**
+     * Checks if DEBUG level logging is enabled for this logger.
+     * @returns {boolean} True if DEBUG level logging is enabled, false otherwise.
+     */
     isDebugEnabled(): boolean;
+    /**
+     * Checks if INFO level logging is enabled for this logger.
+     * @returns {boolean} True if INFO level logging is enabled, false otherwise.
+     */
     isInfoEnabled(): boolean;
+    /**
+     * Checks if TRACE level logging is enabled for this logger.
+     * @returns {boolean} True if TRACE level logging is enabled, false otherwise.
+     */
     isTraceEnabled(): boolean;
+    /**
+     * Sets the logging level
+     * @param {number} level
+     * @throws {Error} Always throws "Not Impled Yet Yet" error.
+     * @protected
+     * @abstract
+     */
+    protected _setLevel(level: number): void;
+    /**
+     * Override this method to implement fatal logging.
+     * @protected
+     * @param {...*} args - Variable arguments
+     * @throws {Error} Always throws "Not Impled Yet Yet" error
+     */
+    protected _fatal(...args: any[]): void;
+    /**
+     * Override this method to implement error logging.
+     * @protected
+     * @param {...*} args - Variable arguments
+     * @throws {Error} Always throws "Not Impled Yet Yet" error
+     */
+    protected _error(...args: any[]): void;
+    /**
+     * Override this method to implement warn logging.
+     * @protected
+     * @param {...*} args - Variable arguments
+     * @throws {Error} Always throws "Not Impled Yet Yet" error
+     */
+    protected _warn(...args: any[]): void;
+    /**
+     * Override this method to implement debug logging.
+     * @protected
+     * @param {...*} args - Variable arguments
+     * @throws {Error} Always throws "Not Impled Yet Yet" error
+     */
+    protected _debug(...args: any[]): void;
+    /**
+     * Override this method to implement info logging.
+     * @protected
+     * @param {...*} args - Variable arguments
+     * @throws {Error} Always throws "Not Impled Yet Yet" error
+     */
+    protected _info(...args: any[]): void;
+    /**
+     * Override this method to implement trace logging.
+     * @protected
+     * @param {...*} args - Variable arguments
+     * @throws {Error} Always throws "Not Impled Yet Yet" error
+     */
+    protected _trace(...args: any[]): void;
 }

package/types/provider-type.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @type {string}
+ * @memberof ProviderType
+ */
+export const Log4js: string;
+/**
+ * @type {string}
+ * @memberof ProviderType
+ */
+export const Console: string;

package/types/provider.d.ts

@@ -0,0 +1,32 @@
+export = Provider;
+/**
+ * A interface that All Provider module must export
+ * @interface
+ */
+declare 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: any): boolean;
+    /**
+     * 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: any): void;
+    /**
+     * The Type Name of current Provider
+     * @return {String} The type of the provider.
+     */
+    getType(): string;
+    /**
+     * 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?: any, setting?: any): LogFactory;
+}
+import LogFactory = require("./log-factory");