@vercube/logger 0.0.3 → 0.0.4

package/dist/ConsoleProvider-CdK1M-7f.mjs

@@ -0,0 +1,26 @@
+import { LOG_LEVEL_COLORS } from "./Utils-5578ynXS.mjs";
+import { LoggerProvider } from "./LoggerProvider-DMxXOscV.mjs";
+
+//#region src/Providers/ConsoleProvider.ts
+/**
+* ConsoleProvider class for logging messages to the console.
+*/
+var ConsoleProvider = class extends LoggerProvider {
+	/**
+	* Initializes the appender with the provided options.
+	* This method should be called before using the appender to process messages.
+	*/
+	initialize() {}
+	/**
+	* Prints a log message according to the specified format and level.
+	* @param message - The log message object containing level, tag, and arguments
+	* @protected
+	*/
+	processMessage(message) {
+		const date = message.timestamp ? new Date(message.timestamp) : /* @__PURE__ */ new Date();
+		console[message.level](`%s%s${message?.tag ? "%s" : ""} %s`, LOG_LEVEL_COLORS[message.level](`[${date.toISOString().split("T")[1]?.replace("Z", "")}]`), LOG_LEVEL_COLORS[message.level](`[${message.level.toUpperCase().padEnd(5, " ")}]`), message?.tag ? LOG_LEVEL_COLORS[message.level](`[${message.tag}]`) : "", ...message.args);
+	}
+};
+
+//#endregion
+export { ConsoleProvider };

package/dist/ConsoleProvider-DXElZIwj.d.mts

@@ -0,0 +1,22 @@
+import { LoggerProvider, LoggerTypes } from "./LoggerProvider-eYcrAQ1D.mjs";
+
+//#region src/Providers/ConsoleProvider.d.ts
+
+/**
+ * ConsoleProvider class for logging messages to the console.
+ */
+declare class ConsoleProvider extends LoggerProvider {
+  /**
+   * Initializes the appender with the provided options.
+   * This method should be called before using the appender to process messages.
+   */
+  initialize(): void;
+  /**
+   * Prints a log message according to the specified format and level.
+   * @param message - The log message object containing level, tag, and arguments
+   * @protected
+   */
+  processMessage(message: LoggerTypes.Message): void;
+}
+//#endregion
+export { ConsoleProvider };

package/dist/JsonProvider-Cu-oM5SL.d.mts

@@ -0,0 +1,23 @@
+import { LoggerProvider, LoggerTypes } from "./LoggerProvider-eYcrAQ1D.mjs";
+
+//#region src/Providers/JsonProvider.d.ts
+
+/**
+ * A logger implementation that formats log messages as JSON.
+ */
+declare class JSONProvider extends LoggerProvider {
+  /**
+   * Initializes the appender with the provided options.
+   * This method should be called before using the appender to process messages.
+   *
+   */
+  initialize(): void;
+  /**
+   * Prints a log message according to the specified format and level.
+   * @param message - The log message object containing level, tag, and arguments
+   * @protected
+   */
+  processMessage(message: LoggerTypes.Message): void;
+}
+//#endregion
+export { JSONProvider };

package/dist/{Providers/JsonProvider.d.ts → JsonProvider-DuUvvoSw.mjs}

@@ -1,19 +1,28 @@
-import { LoggerProvider } from "../Common/LoggerProvider.js";
-import { LoggerTypes } from "../Types/LoggerTypes.js";
+import { LoggerProvider } from "./LoggerProvider-DMxXOscV.mjs";
+
+//#region src/Providers/JsonProvider.ts
 /**
 * A logger implementation that formats log messages as JSON.
 */
-export declare class JSONProvider extends LoggerProvider {
+var JSONProvider = class extends LoggerProvider {
 	/**
 	* Initializes the appender with the provided options.
 	* This method should be called before using the appender to process messages.
 	*
 	*/
-	initialize(): void;
+	initialize() {}
 	/**
 	* Prints a log message according to the specified format and level.
 	* @param message - The log message object containing level, tag, and arguments
 	* @protected
 	*/
-	processMessage(message: LoggerTypes.Message): void;
-}
+	processMessage(message) {
+		console.log(JSON.stringify({
+			type: message?.type ?? "application_log",
+			...message
+		}));
+	}
+};
+
+//#endregion
+export { JSONProvider };

package/dist/LoggerProvider-DMxXOscV.mjs

@@ -0,0 +1,12 @@
+//#region src/Common/LoggerProvider.ts
+/**
+* Abstract base class for implementing log provider.
+* Providers are responsible for processing and outputting log messages to various destinations.
+* Each appender can be initialized with custom options and handles message processing according to its implementation.
+*
+* @template T - The type of options used to initialize the appender
+*/
+var LoggerProvider = class {};
+
+//#endregion
+export { LoggerProvider };

package/dist/LoggerProvider-eYcrAQ1D.d.mts

@@ -0,0 +1,57 @@
+import { IOC } from "@vercube/di";
+
+//#region src/Types/LoggerTypes.d.ts
+declare namespace LoggerTypes {
+  type Level = 'debug' | 'info' | 'warn' | 'error';
+  type Arg = any;
+  interface Message {
+    level: Level;
+    args: Arg[];
+    tag?: string;
+    pid?: number;
+    type?: 'access_log' | 'application_log';
+    timestamp?: number;
+  }
+  type LogProviderOptions<T extends IOC.Newable<LoggerProvider>> = Parameters<InstanceType<T>['initialize']>[0] & {
+    logLevel?: Level;
+  };
+  interface LogAppender<T extends IOC.Newable<LoggerProvider>> {
+    name: string;
+    provider: T;
+    logLevel?: Level;
+    options?: LogProviderOptions<T>;
+  }
+  interface Options {
+    logLevel?: Level;
+    providers?: LogAppender<any>[];
+  }
+}
+//#endregion
+//#region src/Common/LoggerProvider.d.ts
+/**
+ * Abstract base class for implementing log provider.
+ * Providers are responsible for processing and outputting log messages to various destinations.
+ * Each appender can be initialized with custom options and handles message processing according to its implementation.
+ *
+ * @template T - The type of options used to initialize the appender
+ */
+declare abstract class LoggerProvider<T = unknown> {
+  /**
+   * Initializes the appender with the provided options.
+   * This method should be called before using the appender to process messages.
+   *
+   * @param options - Configuration options for the appender
+   * @returns void or Promise<void> if initialization is asynchronous
+   */
+  abstract initialize(options: T): void | Promise<void>;
+  /**
+   * Processes a log message according to the appender's implementation.
+   * This method handles the actual logging logic specific to each appender type.
+   *
+   * @param message - The log message to process, containing level, tag, and other metadata
+   * @returns void or Promise<void> if processing is asynchronous
+   */
+  abstract processMessage(message: LoggerTypes.Message): void | Promise<void>;
+}
+//#endregion
+export { LoggerProvider, LoggerTypes };

package/dist/Providers/ConsoleProvider.d.mts

@@ -0,0 +1,3 @@
+import "../LoggerProvider-eYcrAQ1D.mjs";
+import { ConsoleProvider } from "../ConsoleProvider-DXElZIwj.mjs";
+export { ConsoleProvider };

package/dist/Providers/ConsoleProvider.mjs

@@ -0,0 +1,5 @@
+import "../Utils-5578ynXS.mjs";
+import "../LoggerProvider-DMxXOscV.mjs";
+import { ConsoleProvider } from "../ConsoleProvider-CdK1M-7f.mjs";
+
+export { ConsoleProvider };

package/dist/Providers/JsonProvider.d.mts

@@ -0,0 +1,3 @@
+import "../LoggerProvider-eYcrAQ1D.mjs";
+import { JSONProvider } from "../JsonProvider-Cu-oM5SL.mjs";
+export { JSONProvider };

package/dist/Providers/JsonProvider.mjs

@@ -0,0 +1,4 @@
+import "../LoggerProvider-DMxXOscV.mjs";
+import { JSONProvider } from "../JsonProvider-DuUvvoSw.mjs";
+
+export { JSONProvider };

package/dist/Providers/index.d.mts

@@ -0,0 +1,4 @@
+import "../LoggerProvider-eYcrAQ1D.mjs";
+import { ConsoleProvider } from "../ConsoleProvider-DXElZIwj.mjs";
+import { JSONProvider } from "../JsonProvider-Cu-oM5SL.mjs";
+export { ConsoleProvider, JSONProvider };

package/dist/Providers/index.mjs

@@ -1,83 +1,6 @@
-//#region packages/logger/src/Common/LoggerProvider.ts
-/**
-* Abstract base class for implementing log provider.
-* Providers are responsible for processing and outputting log messages to various destinations.
-* Each appender can be initialized with custom options and handles message processing according to its implementation.
-*
-* @template T - The type of options used to initialize the appender
-*/
-var LoggerProvider = class {};
+import "../Utils-5578ynXS.mjs";
+import "../LoggerProvider-DMxXOscV.mjs";
+import { ConsoleProvider } from "../ConsoleProvider-CdK1M-7f.mjs";
+import { JSONProvider } from "../JsonProvider-DuUvvoSw.mjs";
 
-//#endregion
-//#region packages/logger/src/Providers/JsonProvider.ts
-/**
-* A logger implementation that formats log messages as JSON.
-*/
-var JSONProvider = class extends LoggerProvider {
-	/**
-	* Initializes the appender with the provided options.
-	* This method should be called before using the appender to process messages.
-	*
-	*/
-	initialize() {}
-	/**
-	* Prints a log message according to the specified format and level.
-	* @param message - The log message object containing level, tag, and arguments
-	* @protected
-	*/
-	processMessage(message) {
-		console.log(JSON.stringify({
-			type: message?.type ?? "application_log",
-			...message
-		}));
-	}
-};
-
-//#endregion
-//#region packages/logger/src/Utils/Utils.ts
-const isColorAllowed = () => !process.env.NO_COLOR;
-const colorIfAllowed = (colorFn) => {
-	const wrappedFn = (text) => {
-		return isColorAllowed() ? colorFn(text) : text;
-	};
-	return wrappedFn;
-};
-const colors = {
-	bold: colorIfAllowed((text) => `\x1B[1m${text}\x1B[0m`),
-	green: colorIfAllowed((text) => `\x1B[32m${text}\x1B[39m`),
-	yellow: colorIfAllowed((text) => `\x1B[33m${text}\x1B[39m`),
-	red: colorIfAllowed((text) => `\x1B[31m${text}\x1B[39m`),
-	magentaBright: colorIfAllowed((text) => `\x1B[95m${text}\x1B[39m`),
-	cyanBright: colorIfAllowed((text) => `\x1B[96m${text}\x1B[39m`)
-};
-const LOG_LEVEL_COLORS = {
-	debug: colors.green,
-	info: colors.bold,
-	warn: colors.yellow,
-	error: colors.red
-};
-
-//#endregion
-//#region packages/logger/src/Providers/ConsoleProvider.ts
-/**
-* ConsoleProvider class for logging messages to the console.
-*/
-var ConsoleProvider = class extends LoggerProvider {
-	/**
-	* Initializes the appender with the provided options.
-	* This method should be called before using the appender to process messages.
-	*/
-	initialize() {}
-	/**
-	* Prints a log message according to the specified format and level.
-	* @param message - The log message object containing level, tag, and arguments
-	* @protected
-	*/
-	processMessage(message) {
-		const date = message.timestamp ? new Date(message.timestamp) : new Date();
-		console[message.level](`%s%s${message?.tag ? "%s" : ""} %s`, LOG_LEVEL_COLORS[message.level](`[${date.toISOString().split("T")[1]?.replace("Z", "")}]`), LOG_LEVEL_COLORS[message.level](`[${message.level.toUpperCase().padEnd(5, " ")}]`), message?.tag ? LOG_LEVEL_COLORS[message.level](`[${message.tag}]`) : "", ...message.args);
-	}
-};
-
-//#endregion
 export { ConsoleProvider, JSONProvider };

package/dist/Utils-5578ynXS.mjs

@@ -0,0 +1,39 @@
+//#region src/Utils/Utils.ts
+const LOG_LEVEL_VALUES = {
+	debug: 1,
+	info: 2,
+	warn: 3,
+	error: 4
+};
+/**
+* Checks if target level is enabled.
+* @param targetLevel target level
+* @param logLevels array of enabled log levels
+*/
+function isLogLevelEnabled(targetLevel, currentLevel) {
+	return LOG_LEVEL_VALUES[targetLevel] >= LOG_LEVEL_VALUES[currentLevel];
+}
+const isColorAllowed = () => !process.env.NO_COLOR;
+const colorIfAllowed = (colorFn) => {
+	const wrappedFn = (text) => {
+		return isColorAllowed() ? colorFn(text) : text;
+	};
+	return wrappedFn;
+};
+const colors = {
+	bold: colorIfAllowed((text) => `\x1B[1m${text}\x1B[0m`),
+	green: colorIfAllowed((text) => `\x1B[32m${text}\x1B[39m`),
+	yellow: colorIfAllowed((text) => `\x1B[33m${text}\x1B[39m`),
+	red: colorIfAllowed((text) => `\x1B[31m${text}\x1B[39m`),
+	magentaBright: colorIfAllowed((text) => `\x1B[95m${text}\x1B[39m`),
+	cyanBright: colorIfAllowed((text) => `\x1B[96m${text}\x1B[39m`)
+};
+const LOG_LEVEL_COLORS = {
+	debug: colors.green,
+	info: colors.bold,
+	warn: colors.yellow,
+	error: colors.red
+};
+
+//#endregion
+export { LOG_LEVEL_COLORS, colors, isLogLevelEnabled };

package/dist/index.d.mts

@@ -0,0 +1,109 @@
+import { LoggerTypes } from "./LoggerProvider-eYcrAQ1D.mjs";
+
+//#region src/Common/Logger.d.ts
+
+/**
+ * Abstract base class for implementing logging services.
+ * Provides a standard interface for logging at different levels.
+ * Implementations can customize how logs are processed and stored.
+ */
+declare abstract class Logger {
+  /**
+   * Configures the logger with the provided options.
+   * This method should be called before using the logger to process logs.
+   * @param options - Configuration options for the logger
+   * @returns void or Promise<void> if configuration is asynchronous
+   */
+  abstract configure(options: LoggerTypes.Options): void;
+  /**
+   * Logs a message at the specified log level.
+   * @param args - Additional parameters to be logged
+   * @returns A value determined by the implementing class
+   */
+  abstract debug(...args: LoggerTypes.Arg[]): void;
+  /**
+   * Logs an informational message.
+   * @param args - Additional parameters to be logged
+   * @returns A value determined by the implementing class
+   */
+  abstract info(...args: LoggerTypes.Arg[]): void;
+  /**
+   * Logs a warning message.
+   * @param args - Additional parameters to be logged
+   * @returns A value determined by the implementing class
+   */
+  abstract warn(...args: LoggerTypes.Arg[]): void;
+  /**
+   * Logs an error message.
+   * @param args - Additional parameters to be logged
+   * @returns A value determined by the implementing class
+   */
+  abstract error(...args: LoggerTypes.Arg[]): void;
+}
+//#endregion
+//#region src/Service/BaseLogger.d.ts
+declare class BaseLogger implements Logger {
+  private gContainer;
+  /**
+   * Hold the active log levels for the logger.
+   * Default: debug
+   */
+  private fLogLevel;
+  /**
+   * Hold providers
+   */
+  private fProviders;
+  /**
+   * Hold providers level
+   */
+  private fProvidersLevel;
+  /**
+   * Configure logger
+   * @param options
+   */
+  configure(options: LoggerTypes.Options): void;
+  /**
+   * Logs an informational message.
+   * @param args - Additional parameters to be logged
+   * @returns A value determined by the implementing class
+   */
+  debug(...args: LoggerTypes.Arg[]): void;
+  /**
+   * Logs an informational message.
+   * @param args - Additional parameters to be logged
+   * @returns A value determined by the implementing class
+   */
+  info(...args: LoggerTypes.Arg[]): void;
+  /**
+   * Logs a warning message.
+   * @param args - Additional parameters to be logged
+   * @returns A value determined by the implementing class
+   */
+  warn(...args: LoggerTypes.Arg[]): void;
+  /**
+   * Logs an error message.
+   * @param args - Additional parameters to be logged
+   * @returns A value determined by the implementing class
+   */
+  error(...args: LoggerTypes.Arg[]): void;
+  /**
+   * Prints a log message according to the specified format and level.
+   * This is an abstract method that should be implemented by subclasses.
+   * @param message - The log message object containing level, tag, and arguments
+   * @throws {Error} When called directly on BaseLogger (must be implemented by subclass)
+   * @protected
+   */
+  protected printMessage(message: LoggerTypes.Message): void;
+}
+//#endregion
+//#region src/Utils/Utils.d.ts
+type ColorTextFn = (text: string) => string;
+/**
+ * Checks if target level is enabled.
+ * @param targetLevel target level
+ * @param logLevels array of enabled log levels
+ */
+declare function isLogLevelEnabled(targetLevel: LoggerTypes.Level, currentLevel: LoggerTypes.Level): boolean;
+declare const colors: Record<string, ColorTextFn>;
+//#endregion
+export { BaseLogger, Logger, LoggerTypes, colors, isLogLevelEnabled };

package/dist/index.mjs

@@ -1,6 +1,34 @@
+import { colors, isLogLevelEnabled } from "./Utils-5578ynXS.mjs";
+import "node:module";
 import { Container, Inject } from "@vercube/di";
 
-//#region packages/logger/src/Common/Logger.ts
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+//#region src/Common/Logger.ts
 /**
 * Abstract base class for implementing logging services.
 * Provides a standard interface for logging at different levels.
@@ -9,54 +37,20 @@ import { Container, Inject } from "@vercube/di";
 var Logger = class {};
 
 //#endregion
-//#region packages/logger/src/Utils/Utils.ts
-const LOG_LEVEL_VALUES = {
-	debug: 1,
-	info: 2,
-	warn: 3,
-	error: 4
-};
-/**
-* Checks if target level is enabled.
-* @param targetLevel target level
-* @param logLevels array of enabled log levels
-*/
-function isLogLevelEnabled(targetLevel, currentLevel) {
-	return LOG_LEVEL_VALUES[targetLevel] >= LOG_LEVEL_VALUES[currentLevel];
-}
-const isColorAllowed = () => !process.env.NO_COLOR;
-const colorIfAllowed = (colorFn) => {
-	const wrappedFn = (text) => {
-		return isColorAllowed() ? colorFn(text) : text;
-	};
-	return wrappedFn;
-};
-const colors = {
-	bold: colorIfAllowed((text) => `\x1B[1m${text}\x1B[0m`),
-	green: colorIfAllowed((text) => `\x1B[32m${text}\x1B[39m`),
-	yellow: colorIfAllowed((text) => `\x1B[33m${text}\x1B[39m`),
-	red: colorIfAllowed((text) => `\x1B[31m${text}\x1B[39m`),
-	magentaBright: colorIfAllowed((text) => `\x1B[95m${text}\x1B[39m`),
-	cyanBright: colorIfAllowed((text) => `\x1B[96m${text}\x1B[39m`)
-};
-const LOG_LEVEL_COLORS = {
-	debug: colors.green,
-	info: colors.bold,
-	warn: colors.yellow,
-	error: colors.red
-};
-
-//#endregion
-//#region node_modules/.pnpm/@oxc-project+runtime@0.67.0/node_modules/@oxc-project/runtime/src/helpers/esm/decorate.js
-function __decorate(decorators, target, key, desc) {
-	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-	return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
+//#region ../../node_modules/.pnpm/@oxc-project+runtime@0.72.1/node_modules/@oxc-project/runtime/src/helpers/decorate.js
+var require_decorate = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.1/node_modules/@oxc-project/runtime/src/helpers/decorate.js"(exports, module) {
+	function __decorate(decorators, target, key, desc) {
+		var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+		if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+		else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+		return c > 3 && r && Object.defineProperty(target, key, r), r;
+	}
+	module.exports = __decorate, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
 
 //#endregion
-//#region packages/logger/src/Service/BaseLogger.ts
+//#region src/Service/BaseLogger.ts
+var import_decorate = __toESM(require_decorate());
 var BaseLogger = class {
 	gContainer;
 	/**
@@ -67,11 +61,11 @@ var BaseLogger = class {
 	/**
 	* Hold providers
 	*/
-	fProviders = new Map();
+	fProviders = /* @__PURE__ */ new Map();
 	/**
 	* Hold providers level
 	*/
-	fProvidersLevel = new Map();
+	fProvidersLevel = /* @__PURE__ */ new Map();
 	/**
 	* Configure logger
 	* @param options 
@@ -147,7 +141,7 @@ var BaseLogger = class {
 		for (const [, provider] of providersToProcess) provider.processMessage(message);
 	}
 };
-__decorate([Inject(Container)], BaseLogger.prototype, "gContainer", void 0);
+(0, import_decorate.default)([Inject(Container)], BaseLogger.prototype, "gContainer", void 0);
 
 //#endregion
 export { BaseLogger, Logger, colors, isLogLevelEnabled };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercube/logger",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "Logger module for Vercube framework",
   "repository": "@vercube/logger",
   "license": "MIT",
@@ -9,24 +9,20 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.cjs"
+      "import": "./dist/index.mjs"
     },
     "./providers": {
       "types": "./dist/Providers/index.d.ts",
-      "import": "./dist/Providers/index.mjs",
-      "require": "./dist/Providers/index.cjs"
+      "import": "./dist/Providers/index.mjs"
     }
   },
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
   "files": [
     "dist",
     "README.md"
   ],
   "dependencies": {
-    "@vercube/di": "0.0.3"
+    "@vercube/di": "0.0.4"
   },
   "publishConfig": {
     "access": "public"

package/dist/Common/Logger.d.ts

@@ -1,39 +0,0 @@
-import { LoggerTypes } from "../Types/LoggerTypes.js";
-/**
-* Abstract base class for implementing logging services.
-* Provides a standard interface for logging at different levels.
-* Implementations can customize how logs are processed and stored.
-*/
-export declare abstract class Logger {
-	/**
-	* Configures the logger with the provided options.
-	* This method should be called before using the logger to process logs.
-	* @param options - Configuration options for the logger
-	* @returns void or Promise<void> if configuration is asynchronous
-	*/
-	abstract configure(options: LoggerTypes.Options): void;
-	/**
-	* Logs a message at the specified log level.
-	* @param args - Additional parameters to be logged
-	* @returns A value determined by the implementing class
-	*/
-	abstract debug(...args: LoggerTypes.Arg[]): void;
-	/**
-	* Logs an informational message.
-	* @param args - Additional parameters to be logged
-	* @returns A value determined by the implementing class
-	*/
-	abstract info(...args: LoggerTypes.Arg[]): void;
-	/**
-	* Logs a warning message.
-	* @param args - Additional parameters to be logged
-	* @returns A value determined by the implementing class
-	*/
-	abstract warn(...args: LoggerTypes.Arg[]): void;
-	/**
-	* Logs an error message.
-	* @param args - Additional parameters to be logged
-	* @returns A value determined by the implementing class
-	*/
-	abstract error(...args: LoggerTypes.Arg[]): void;
-}

package/dist/Common/LoggerProvider.d.ts

@@ -1,26 +0,0 @@
-import type { LoggerTypes } from "../Types/LoggerTypes.js";
-/**
-* Abstract base class for implementing log provider.
-* Providers are responsible for processing and outputting log messages to various destinations.
-* Each appender can be initialized with custom options and handles message processing according to its implementation.
-*
-* @template T - The type of options used to initialize the appender
-*/
-export declare abstract class LoggerProvider<T = unknown> {
-	/**
-	* Initializes the appender with the provided options.
-	* This method should be called before using the appender to process messages.
-	*
-	* @param options - Configuration options for the appender
-	* @returns void or Promise<void> if initialization is asynchronous
-	*/
-	abstract initialize(options: T): void | Promise<void>;
-	/**
-	* Processes a log message according to the appender's implementation.
-	* This method handles the actual logging logic specific to each appender type.
-	*
-	* @param message - The log message to process, containing level, tag, and other metadata
-	* @returns void or Promise<void> if processing is asynchronous
-	*/
-	abstract processMessage(message: LoggerTypes.Message): void | Promise<void>;
-}

package/dist/Providers/ConsoleProvider.d.ts

@@ -1,18 +0,0 @@
-import { LoggerProvider } from "../Common/LoggerProvider.js";
-import { LoggerTypes } from "../Types/LoggerTypes.js";
-/**
-* ConsoleProvider class for logging messages to the console.
-*/
-export declare class ConsoleProvider extends LoggerProvider {
-	/**
-	* Initializes the appender with the provided options.
-	* This method should be called before using the appender to process messages.
-	*/
-	initialize(): void;
-	/**
-	* Prints a log message according to the specified format and level.
-	* @param message - The log message object containing level, tag, and arguments
-	* @protected
-	*/
-	processMessage(message: LoggerTypes.Message): void;
-}

package/dist/Providers/index.cjs

@@ -1,86 +0,0 @@
-"use strict";
-
-//#region packages/logger/src/Common/LoggerProvider.ts
-/**
-* Abstract base class for implementing log provider.
-* Providers are responsible for processing and outputting log messages to various destinations.
-* Each appender can be initialized with custom options and handles message processing according to its implementation.
-*
-* @template T - The type of options used to initialize the appender
-*/
-var LoggerProvider = class {};
-
-//#endregion
-//#region packages/logger/src/Providers/JsonProvider.ts
-/**
-* A logger implementation that formats log messages as JSON.
-*/
-var JSONProvider = class extends LoggerProvider {
-	/**
-	* Initializes the appender with the provided options.
-	* This method should be called before using the appender to process messages.
-	*
-	*/
-	initialize() {}
-	/**
-	* Prints a log message according to the specified format and level.
-	* @param message - The log message object containing level, tag, and arguments
-	* @protected
-	*/
-	processMessage(message) {
-		console.log(JSON.stringify({
-			type: message?.type ?? "application_log",
-			...message
-		}));
-	}
-};
-
-//#endregion
-//#region packages/logger/src/Utils/Utils.ts
-const isColorAllowed = () => !process.env.NO_COLOR;
-const colorIfAllowed = (colorFn) => {
-	const wrappedFn = (text) => {
-		return isColorAllowed() ? colorFn(text) : text;
-	};
-	return wrappedFn;
-};
-const colors = {
-	bold: colorIfAllowed((text) => `\x1B[1m${text}\x1B[0m`),
-	green: colorIfAllowed((text) => `\x1B[32m${text}\x1B[39m`),
-	yellow: colorIfAllowed((text) => `\x1B[33m${text}\x1B[39m`),
-	red: colorIfAllowed((text) => `\x1B[31m${text}\x1B[39m`),
-	magentaBright: colorIfAllowed((text) => `\x1B[95m${text}\x1B[39m`),
-	cyanBright: colorIfAllowed((text) => `\x1B[96m${text}\x1B[39m`)
-};
-const LOG_LEVEL_COLORS = {
-	debug: colors.green,
-	info: colors.bold,
-	warn: colors.yellow,
-	error: colors.red
-};
-
-//#endregion
-//#region packages/logger/src/Providers/ConsoleProvider.ts
-/**
-* ConsoleProvider class for logging messages to the console.
-*/
-var ConsoleProvider = class extends LoggerProvider {
-	/**
-	* Initializes the appender with the provided options.
-	* This method should be called before using the appender to process messages.
-	*/
-	initialize() {}
-	/**
-	* Prints a log message according to the specified format and level.
-	* @param message - The log message object containing level, tag, and arguments
-	* @protected
-	*/
-	processMessage(message) {
-		const date = message.timestamp ? new Date(message.timestamp) : new Date();
-		console[message.level](`%s%s${message?.tag ? "%s" : ""} %s`, LOG_LEVEL_COLORS[message.level](`[${date.toISOString().split("T")[1]?.replace("Z", "")}]`), LOG_LEVEL_COLORS[message.level](`[${message.level.toUpperCase().padEnd(5, " ")}]`), message?.tag ? LOG_LEVEL_COLORS[message.level](`[${message.tag}]`) : "", ...message.args);
-	}
-};
-
-//#endregion
-exports.ConsoleProvider = ConsoleProvider
-exports.JSONProvider = JSONProvider

package/dist/Providers/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./JsonProvider.js";
-export * from "./ConsoleProvider.js";

package/dist/Service/BaseLogger.d.ts

@@ -1,55 +0,0 @@
-import type { LoggerTypes } from "../Types/LoggerTypes.js";
-import type { Logger } from "../Common/Logger.js";
-export declare class BaseLogger implements Logger {
-	private gContainer;
-	/**
-	* Hold the active log levels for the logger.
-	* Default: debug
-	*/
-	private fLogLevel;
-	/**
-	* Hold providers
-	*/
-	private fProviders;
-	/**
-	* Hold providers level
-	*/
-	private fProvidersLevel;
-	/**
-	* Configure logger
-	* @param options 
-	*/
-	configure(options: LoggerTypes.Options): void;
-	/**
-	* Logs an informational message.
-	* @param args - Additional parameters to be logged
-	* @returns A value determined by the implementing class
-	*/
-	debug(...args: LoggerTypes.Arg[]): void;
-	/**
-	* Logs an informational message.
-	* @param args - Additional parameters to be logged
-	* @returns A value determined by the implementing class
-	*/
-	info(...args: LoggerTypes.Arg[]): void;
-	/**
-	* Logs a warning message.
-	* @param args - Additional parameters to be logged
-	* @returns A value determined by the implementing class
-	*/
-	warn(...args: LoggerTypes.Arg[]): void;
-	/**
-	* Logs an error message.
-	* @param args - Additional parameters to be logged
-	* @returns A value determined by the implementing class
-	*/
-	error(...args: LoggerTypes.Arg[]): void;
-	/**
-	* Prints a log message according to the specified format and level.
-	* This is an abstract method that should be implemented by subclasses.
-	* @param message - The log message object containing level, tag, and arguments
-	* @throws {Error} When called directly on BaseLogger (must be implemented by subclass)
-	* @protected
-	*/
-	protected printMessage(message: LoggerTypes.Message): void;
-}

package/dist/Types/LoggerTypes.d.ts

@@ -1,27 +0,0 @@
-import type { IOC } from "@vercube/di";
-import type { LoggerProvider } from "../Common/LoggerProvider.js";
-export declare namespace LoggerTypes {
-	type Level = "debug" | "info" | "warn" | "error";
-	type Arg = any;
-	interface Message {
-		level: Level;
-		args: Arg[];
-		tag?: string;
-		pid?: number;
-		type?: "access_log" | "application_log";
-		timestamp?: number;
-	}
-	type LogProviderOptions<T extends IOC.Newable<LoggerProvider>> = Parameters<InstanceType<T>["initialize"]>[0] & {
-		logLevel?: Level
-	};
-	interface LogAppender<T extends IOC.Newable<LoggerProvider>> {
-		name: string;
-		provider: T;
-		logLevel?: Level;
-		options?: LogProviderOptions<T>;
-	}
-	interface Options {
-		logLevel?: Level;
-		providers?: LogAppender<any>[];
-	}
-}

package/dist/Utils/Utils.d.ts

@@ -1,11 +0,0 @@
-import type { LoggerTypes } from "../Types/LoggerTypes.js";
-type ColorTextFn = (text: string) => string;
-/**
-* Checks if target level is enabled.
-* @param targetLevel target level
-* @param logLevels array of enabled log levels
-*/
-export declare function isLogLevelEnabled(targetLevel: LoggerTypes.Level, currentLevel: LoggerTypes.Level): boolean;
-export declare const colors: Record<string, ColorTextFn>;
-export declare const LOG_LEVEL_COLORS: Record<LoggerTypes.Level, ColorTextFn>;
-export {};

package/dist/index.cjs

@@ -1,186 +0,0 @@
-//#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function() {
-	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
-const __vercube_di = __toESM(require("@vercube/di"));
-
-//#region packages/logger/src/Common/Logger.ts
-/**
-* Abstract base class for implementing logging services.
-* Provides a standard interface for logging at different levels.
-* Implementations can customize how logs are processed and stored.
-*/
-var Logger = class {};
-
-//#endregion
-//#region packages/logger/src/Utils/Utils.ts
-const LOG_LEVEL_VALUES = {
-	debug: 1,
-	info: 2,
-	warn: 3,
-	error: 4
-};
-/**
-* Checks if target level is enabled.
-* @param targetLevel target level
-* @param logLevels array of enabled log levels
-*/
-function isLogLevelEnabled(targetLevel, currentLevel) {
-	return LOG_LEVEL_VALUES[targetLevel] >= LOG_LEVEL_VALUES[currentLevel];
-}
-const isColorAllowed = () => !process.env.NO_COLOR;
-const colorIfAllowed = (colorFn) => {
-	const wrappedFn = (text) => {
-		return isColorAllowed() ? colorFn(text) : text;
-	};
-	return wrappedFn;
-};
-const colors = {
-	bold: colorIfAllowed((text) => `\x1B[1m${text}\x1B[0m`),
-	green: colorIfAllowed((text) => `\x1B[32m${text}\x1B[39m`),
-	yellow: colorIfAllowed((text) => `\x1B[33m${text}\x1B[39m`),
-	red: colorIfAllowed((text) => `\x1B[31m${text}\x1B[39m`),
-	magentaBright: colorIfAllowed((text) => `\x1B[95m${text}\x1B[39m`),
-	cyanBright: colorIfAllowed((text) => `\x1B[96m${text}\x1B[39m`)
-};
-const LOG_LEVEL_COLORS = {
-	debug: colors.green,
-	info: colors.bold,
-	warn: colors.yellow,
-	error: colors.red
-};
-
-//#endregion
-//#region node_modules/.pnpm/@oxc-project+runtime@0.67.0/node_modules/@oxc-project/runtime/src/helpers/decorate.js
-var require_decorate = __commonJS({ "node_modules/.pnpm/@oxc-project+runtime@0.67.0/node_modules/@oxc-project/runtime/src/helpers/decorate.js"(exports, module) {
-	function __decorate(decorators, target, key, desc) {
-		var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-		if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-		else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-		return c > 3 && r && Object.defineProperty(target, key, r), r;
-	}
-	module.exports = __decorate, module.exports.__esModule = true, module.exports["default"] = module.exports;
-} });
-var import_decorate = __toESM(require_decorate(), 1);
-
-//#endregion
-//#region packages/logger/src/Service/BaseLogger.ts
-var BaseLogger = class {
-	gContainer;
-	/**
-	* Hold the active log levels for the logger.
-	* Default: debug
-	*/
-	fLogLevel = "debug";
-	/**
-	* Hold providers
-	*/
-	fProviders = new Map();
-	/**
-	* Hold providers level
-	*/
-	fProvidersLevel = new Map();
-	/**
-	* Configure logger
-	* @param options 
-	*/
-	configure(options) {
-		this.fLogLevel = options?.logLevel ?? "debug";
-		if (!options?.providers?.length) return;
-		this.fProviders.clear();
-		for (const logger of options.providers) try {
-			const provider = this.gContainer.resolve(logger.provider);
-			provider.initialize(logger.options);
-			this.fProviders.set(logger.name, provider);
-			this.fProvidersLevel.set(logger.name, logger.logLevel ?? this.fLogLevel);
-		} catch (error) {
-			console.error(`Failed to initialize logger provider: ${logger.provider.name}`, error);
-		}
-	}
-	/**
-	* Logs an informational message.
-	* @param args - Additional parameters to be logged
-	* @returns A value determined by the implementing class
-	*/
-	debug(...args) {
-		this.printMessage({
-			level: "debug",
-			args
-		});
-	}
-	/**
-	* Logs an informational message.
-	* @param args - Additional parameters to be logged
-	* @returns A value determined by the implementing class
-	*/
-	info(...args) {
-		this.printMessage({
-			level: "info",
-			args
-		});
-	}
-	/**
-	* Logs a warning message.
-	* @param args - Additional parameters to be logged
-	* @returns A value determined by the implementing class
-	*/
-	warn(...args) {
-		this.printMessage({
-			level: "warn",
-			args
-		});
-	}
-	/**
-	* Logs an error message.
-	* @param args - Additional parameters to be logged
-	* @returns A value determined by the implementing class
-	*/
-	error(...args) {
-		this.printMessage({
-			level: "error",
-			args
-		});
-	}
-	/**
-	* Prints a log message according to the specified format and level.
-	* This is an abstract method that should be implemented by subclasses.
-	* @param message - The log message object containing level, tag, and arguments
-	* @throws {Error} When called directly on BaseLogger (must be implemented by subclass)
-	* @protected
-	*/
-	printMessage(message) {
-		const providersToProcess = [...this.fProviders.entries()].filter(([name]) => {
-			return isLogLevelEnabled(message.level, this.fProvidersLevel.get(name) ?? this.fLogLevel);
-		});
-		for (const [, provider] of providersToProcess) provider.processMessage(message);
-	}
-};
-(0, import_decorate.default)([(0, __vercube_di.Inject)(__vercube_di.Container)], BaseLogger.prototype, "gContainer", void 0);
-
-//#endregion
-exports.BaseLogger = BaseLogger
-exports.Logger = Logger
-exports.colors = colors
-exports.isLogLevelEnabled = isLogLevelEnabled

package/dist/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./Common/Logger.js";
-export * from "./Service/BaseLogger.js";
-export { isLogLevelEnabled, colors } from "./Utils/Utils.js";
-export * from "./Types/LoggerTypes.js";