@vercube/logger 0.0.1-alpha.15

package/dist/Common/Logger.d.ts

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,18 @@
+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/JsonProvider.d.ts

@@ -0,0 +1,19 @@
+import { LoggerProvider } from "../Common/LoggerProvider.js";
+import { LoggerTypes } from "../Types/LoggerTypes.js";
+/**
+* A logger implementation that formats log messages as JSON.
+*/
+export 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;
+}

package/dist/Providers/index.cjs

@@ -0,0 +1,73 @@
+"use strict";
+
+//#region packages/logger/src/Common/LoggerProvider.ts
+var LoggerProvider = class {};
+
+//#endregion
+//#region packages/logger/src/Providers/JsonProvider.ts
+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
+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

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

package/dist/Providers/index.mjs

@@ -0,0 +1,71 @@
+
+//#region packages/logger/src/Common/LoggerProvider.ts
+var LoggerProvider = class {};
+
+//#endregion
+//#region packages/logger/src/Providers/JsonProvider.ts
+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
+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/Service/BaseLogger.d.ts

@@ -0,0 +1,55 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,175 @@
+//#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
+var Logger = class {};
+
+//#endregion
+//#region packages/logger/src/Utils/Utils.ts
+const LOG_LEVEL_VALUES = {
+	debug: 1,
+	info: 2,
+	warn: 3,
+	error: 4
+};
+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.62.0/node_modules/@oxc-project/runtime/src/helpers/decorate.js
+var require_decorate = __commonJS({ "node_modules/.pnpm/@oxc-project+runtime@0.62.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.isLogLevelEnabled = isLogLevelEnabled

package/dist/index.d.ts

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

package/dist/index.mjs

@@ -0,0 +1,143 @@
+import { Container, Inject } from "@vercube/di";
+
+//#region packages/logger/src/Common/Logger.ts
+var Logger = class {};
+
+//#endregion
+//#region packages/logger/src/Utils/Utils.ts
+const LOG_LEVEL_VALUES = {
+	debug: 1,
+	info: 2,
+	warn: 3,
+	error: 4
+};
+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.62.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;
+}
+
+//#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);
+	}
+};
+__decorate([Inject(Container)], BaseLogger.prototype, "gContainer", void 0);
+
+//#endregion
+export { BaseLogger, Logger, isLogLevelEnabled };

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@vercube/logger",
+  "version": "0.0.1-alpha.15",
+  "description": "Logger module for Vercube framework",
+  "repository": "@vercube/logger",
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./providers": {
+      "types": "./dist/Providers/index.d.ts",
+      "import": "./dist/Providers/index.mjs",
+      "require": "./dist/Providers/index.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@vercube/di": "0.0.1-alpha.15"
+  },
+  "devDependencies": {},
+  "publishConfig": {
+    "access": "public"
+  }
+}