@vercube/logger 0.0.48 → 1.0.0-beta.1

package/README.md

@@ -12,7 +12,7 @@
 ![GitHub License](<https://img.shields.io/github/license/vercube/vercube?style=for-the-badge&logo=gitbook&logoColor=rgba(255%2C%20255%2C%20255%2C%200.6)&labelColor=%23000&color=%232f2f2f>)
 ![Codecov](<https://img.shields.io/codecov/c/github/vercube/vercube?style=for-the-badge&logo=vitest&logoColor=rgba(255%2C%20255%2C%20255%2C%200.6)&labelColor=%23000&color=%232f2f2f>)
 
-**Structured logging with multiple outputs - console for dev, JSON for production, or whatever you need. Just inject `Logger` and go.**
+**Structured wide-event logging powered by [evlog](https://evlog.dev) - pretty in dev, JSON in production, with sampling, redaction and pluggable drains. Just inject `Logger` and go.**
 
 [Website](https://vercube.dev) • [Documentation](https://vercube.dev/docs/getting-started)
 
@@ -20,9 +20,10 @@
 
 ## ✨ Features
 
-- **Multiple providers** - console, JSON, or build your own
+- **Powered by evlog** - structured, wide-event logging under a simple `Logger` API
 - **Log levels** - debug, info, warn, error
-- **Per-provider config** - different levels for different outputs
+- **Wide events** - accumulate context with `set()` / `child()` and `emit()` once
+- **Drains & adapters** - ship logs to Axiom, OTLP, Sentry, Datadog and more
 - **DI integration** - just `@Inject(Logger)` wherever you need it
 
 ## 📦 Installation

package/dist/Toolkit.d.mts

@@ -0,0 +1 @@
+export * from "evlog/toolkit";

package/dist/Toolkit.mjs

@@ -0,0 +1,2 @@
+export * from "evlog/toolkit";
+export {};

package/dist/index.d.mts

@@ -1,108 +1,177 @@
-import { n as LoggerTypes } from "./LoggerProvider-BcdoeL8E.mjs";
+import { DrainContext, DrainFn, EnvironmentContext, ErrorOptions, EvlogError, Log, LogLevel, LogLevel as LogLevel$1, LoggerConfig, LoggerConfig as LoggerConfig$1, RedactConfig, RequestLogger, RequestLoggerOptions, SamplingConfig, WideEvent, createError, createLogger, createRequestLogger, defineError, defineErrorCatalog, initLogger, log, parseError } from "evlog";
 
+//#region src/Types/LoggerTypes.d.ts
+/**
+ * Types for the evlog-backed Vercube logger.
+ *
+ * @see https://evlog.dev
+ */
+declare namespace LoggerTypes {
+  /**
+   * Supported severity levels, aligned with evlog.
+   * Order: debug < info < warn < error.
+   */
+  type Level = LogLevel$1;
+  /**
+   * Any value accepted by the logger methods.
+   */
+  type Arg = unknown;
+  /**
+   * Structured context merged into emitted (wide) events.
+   */
+  type Context = Record<string, unknown>;
+  /**
+   * Logger configuration.
+   *
+   * Mirrors evlog's {@link LoggerConfig} and adds `logLevel` as a framework-level
+   * alias for evlog's `minLevel`.
+   */
+  interface Options extends LoggerConfig$1 {
+    /**
+     * Minimum severity for the simple log API.
+     * Alias for evlog's `minLevel`; takes precedence when both are provided.
+     */
+    logLevel?: Level;
+  }
+}
+//#endregion
 //#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.
+ * Abstract base class for the Vercube logger.
+ *
+ * Defines the dependency-injection contract used across the framework. The
+ * default implementation ({@link BaseLogger}) is backed by evlog
+ * (https://evlog.dev) and forwards calls to evlog's logging API.
  */
 declare abstract class Logger {
   /**
-   * Configures the logger with the provided options.
-   * This method should be called before using the logger to process logs.
+   * Configures the underlying logger.
+   * Maps to evlog's `initLogger` under the hood.
+   *
    * @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
+   * Logs a debug message.
+   * @param args - Values to log (strings, objects, errors)
    */
   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
+   * @param args - Values to log (strings, objects, errors)
    */
   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
+   * @param args - Values to log (strings, objects, errors)
    */
   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
+   * @param args - Values to log (strings, objects, errors)
    */
   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
+   * Merges structured context into every subsequent event emitted by this logger.
+   * Enables wide-event style logging without a request lifecycle.
+   *
+   * @param context - Structured fields to attach
+   */
+  abstract set(context: LoggerTypes.Context): void;
+  /**
+   * Returns a shallow copy of the context accumulated on this logger.
+   */
+  abstract getContext(): LoggerTypes.Context;
+  /**
+   * Creates a derived logger inheriting this logger's context, merged with
+   * the provided additional context.
+   *
+   * @param context - Extra context for the child logger
    */
-  private fLogLevel;
+  abstract child(context: LoggerTypes.Context): Logger;
   /**
-   * Hold providers
+   * Emits the accumulated context as a single consolidated wide event, then
+   * resets it.
+   *
+   * @param overrides - Additional fields merged into the emitted event
    */
-  private fProviders;
+  abstract emit(overrides?: LoggerTypes.Context): void;
+}
+//#endregion
+//#region src/Service/BaseLogger.d.ts
+/**
+ * Default {@link Logger} implementation backed by evlog (https://evlog.dev).
+ *
+ * `debug` / `info` / `warn` / `error` forward to evlog's simple `log` API
+ * (fire-and-forget, one event per call). Structured context registered via
+ * {@link BaseLogger.set} or {@link BaseLogger.child} is merged into every
+ * emitted event, providing wide-event style logging without a request
+ * lifecycle. For request-scoped wide events use the evlog toolkit
+ * (`@vercube/logger/toolkit`) together with the framework's request middleware.
+ */
+declare class BaseLogger extends Logger {
   /**
-   * Hold providers level
+   * Accumulated structured context merged into every emitted event.
    */
-  private fProvidersLevel;
+  private fContext;
   /**
-   * Configure logger
-   * @param options
+   * Configures the underlying evlog logger.
+   * @param options - Configuration 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
+   * Logs a debug message.
+   * @param args - Values to log
    */
   debug(...args: LoggerTypes.Arg[]): void;
   /**
    * Logs an informational message.
-   * @param args - Additional parameters to be logged
-   * @returns A value determined by the implementing class
+   * @param args - Values to log
    */
   info(...args: LoggerTypes.Arg[]): void;
   /**
    * Logs a warning message.
-   * @param args - Additional parameters to be logged
-   * @returns A value determined by the implementing class
+   * @param args - Values to log
    */
   warn(...args: LoggerTypes.Arg[]): void;
   /**
    * Logs an error message.
-   * @param args - Additional parameters to be logged
-   * @returns A value determined by the implementing class
+   * @param args - Values to log
    */
   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
+   * Merges structured context into every subsequent event.
+   * @param context - Structured fields to attach
+   */
+  set(context: LoggerTypes.Context): void;
+  /**
+   * Returns a shallow copy of the accumulated context.
    */
-  protected printMessage(message: LoggerTypes.Message): void;
+  getContext(): LoggerTypes.Context;
+  /**
+   * Creates a derived logger inheriting this logger's context plus extra context.
+   * @param context - Extra context for the child logger
+   */
+  child(context: LoggerTypes.Context): Logger;
+  /**
+   * Emits the accumulated context as a single wide event, then resets it.
+   * @param overrides - Additional fields merged into the emitted event
+   */
+  emit(overrides?: LoggerTypes.Context): void;
+  /**
+   * Translates the framework's variadic logging calls into evlog events.
+   *
+   * Supported call shapes (mirroring the previous @vercube/logger behaviour):
+   * - `('tag', 'message')`         → tagged log
+   * - `('message')`                → message-only event
+   * - `(error)` / `('tag', error)` → structured error event
+   * - `('tag', { ...fields })`     → wide event with extra fields
+   * - any mix of strings, objects and errors
+   *
+   * @param level - The severity level
+   * @param args - The raw arguments passed to the log method
+   */
+  private dispatch;
 }
 //#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 };
+export { BaseLogger, type DrainContext, type DrainFn, type EnvironmentContext, type ErrorOptions, EvlogError, type Log, type LogLevel, Logger, type LoggerConfig, LoggerTypes, type RedactConfig, type RequestLogger, type RequestLoggerOptions, type SamplingConfig, type WideEvent, createError, createLogger, createRequestLogger, defineError, defineErrorCatalog, initLogger, log, parseError };

package/dist/index.mjs

@@ -1,112 +1,143 @@
-import { n as colors, r as isLogLevelEnabled } from "./Utils-DZA2B0cS.mjs";
-import { Container, Inject } from "@vercube/di";
+import { EvlogError, createError, createLogger, createRequestLogger, defineError, defineErrorCatalog, initLogger, initLogger as initLogger$1, log, log as log$1, parseError } from "evlog";
 //#region 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.
+* Abstract base class for the Vercube logger.
+*
+* Defines the dependency-injection contract used across the framework. The
+* default implementation ({@link BaseLogger}) is backed by evlog
+* (https://evlog.dev) and forwards calls to evlog's logging API.
 */
 var Logger = class {};
 //#endregion
-//#region \0@oxc-project+runtime@0.130.0/helpers/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 src/Service/BaseLogger.ts
-var BaseLogger = class {
-	gContainer;
-	/**
-	* Hold the active log levels for the logger.
-	* Default: debug
-	*/
-	fLogLevel = "debug";
-	/**
-	* Hold providers
-	*/
-	fProviders = /* @__PURE__ */ new Map();
+/**
+* Default {@link Logger} implementation backed by evlog (https://evlog.dev).
+*
+* `debug` / `info` / `warn` / `error` forward to evlog's simple `log` API
+* (fire-and-forget, one event per call). Structured context registered via
+* {@link BaseLogger.set} or {@link BaseLogger.child} is merged into every
+* emitted event, providing wide-event style logging without a request
+* lifecycle. For request-scoped wide events use the evlog toolkit
+* (`@vercube/logger/toolkit`) together with the framework's request middleware.
+*/
+var BaseLogger = class BaseLogger extends Logger {
 	/**
-	* Hold providers level
+	* Accumulated structured context merged into every emitted event.
 	*/
-	fProvidersLevel = /* @__PURE__ */ new Map();
+	fContext = {};
 	/**
-	* Configure logger
-	* @param options
+	* Configures the underlying evlog logger.
+	* @param options - Configuration 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);
-		}
+		const { logLevel, ...config } = options ?? {};
+		initLogger$1({
+			...config,
+			minLevel: logLevel ?? config.minLevel
+		});
 	}
 	/**
-	* Logs an informational message.
-	* @param args - Additional parameters to be logged
-	* @returns A value determined by the implementing class
+	* Logs a debug message.
+	* @param args - Values to log
 	*/
 	debug(...args) {
-		this.printMessage({
-			level: "debug",
-			args
-		});
+		this.dispatch("debug", args);
 	}
 	/**
 	* Logs an informational message.
-	* @param args - Additional parameters to be logged
-	* @returns A value determined by the implementing class
+	* @param args - Values to log
 	*/
 	info(...args) {
-		this.printMessage({
-			level: "info",
-			args
-		});
+		this.dispatch("info", args);
 	}
 	/**
 	* Logs a warning message.
-	* @param args - Additional parameters to be logged
-	* @returns A value determined by the implementing class
+	* @param args - Values to log
 	*/
 	warn(...args) {
-		this.printMessage({
-			level: "warn",
-			args
-		});
+		this.dispatch("warn", args);
 	}
 	/**
 	* Logs an error message.
-	* @param args - Additional parameters to be logged
-	* @returns A value determined by the implementing class
+	* @param args - Values to log
 	*/
 	error(...args) {
-		this.printMessage({
-			level: "error",
-			args
-		});
+		this.dispatch("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
+	* Merges structured context into every subsequent event.
+	* @param context - Structured fields to attach
 	*/
-	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);
+	set(context) {
+		Object.assign(this.fContext, context);
+	}
+	/**
+	* Returns a shallow copy of the accumulated context.
+	*/
+	getContext() {
+		return { ...this.fContext };
+	}
+	/**
+	* Creates a derived logger inheriting this logger's context plus extra context.
+	* @param context - Extra context for the child logger
+	*/
+	child(context) {
+		const child = new BaseLogger();
+		child.fContext = {
+			...this.fContext,
+			...context
+		};
+		return child;
+	}
+	/**
+	* Emits the accumulated context as a single wide event, then resets it.
+	* @param overrides - Additional fields merged into the emitted event
+	*/
+	emit(overrides = {}) {
+		const event = {
+			...this.fContext,
+			...overrides
+		};
+		if (Object.keys(event).length === 0) return;
+		log$1.info(event);
+		this.fContext = {};
+	}
+	/**
+	* Translates the framework's variadic logging calls into evlog events.
+	*
+	* Supported call shapes (mirroring the previous @vercube/logger behaviour):
+	* - `('tag', 'message')`         → tagged log
+	* - `('message')`                → message-only event
+	* - `(error)` / `('tag', error)` → structured error event
+	* - `('tag', { ...fields })`     → wide event with extra fields
+	* - any mix of strings, objects and errors
+	*
+	* @param level - The severity level
+	* @param args - The raw arguments passed to the log method
+	*/
+	dispatch(level, args) {
+		if (!(Object.keys(this.fContext).length > 0) && args.length === 2 && typeof args[0] === "string" && typeof args[1] === "string") {
+			log$1[level](args[0], args[1]);
+			return;
+		}
+		const event = { ...this.fContext };
+		const messageParts = [];
+		let tag;
+		for (const arg of args) if (arg instanceof Error) event.error = {
+			name: arg.name,
+			message: arg.message,
+			stack: arg.stack
+		};
+		else if (arg !== null && typeof arg === "object") Object.assign(event, arg);
+		else if (typeof arg === "string" && tag === void 0) tag = arg;
+		else messageParts.push(String(arg));
+		if (tag !== void 0 && messageParts.length === 0) event.message = tag;
+		else {
+			if (tag !== void 0) event.tag = tag;
+			if (messageParts.length > 0) event.message = messageParts.join(" ");
+		}
+		log$1[level](event);
 	}
 };
-__decorate([Inject(Container)], BaseLogger.prototype, "gContainer", void 0);
 //#endregion
-export { BaseLogger, Logger, colors, isLogLevelEnabled };
+export { BaseLogger, EvlogError, Logger, createError, createLogger, createRequestLogger, defineError, defineErrorCatalog, initLogger, log, parseError };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercube/logger",
-  "version": "0.0.48",
+  "version": "1.0.0-beta.1",
   "description": "Logger module for Vercube framework",
   "repository": {
     "type": "git",
@@ -13,9 +13,16 @@
   "main": "./dist/index.mjs",
   "module": "./dist/index.mjs",
   "exports": {
-    ".": "./dist/index.mjs",
-    "./drivers/ConsoleProvider": "./dist/Drivers/ConsoleProvider.mjs",
-    "./drivers/JsonProvider": "./dist/Drivers/JsonProvider.mjs",
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./toolkit": {
+      "types": "./dist/Toolkit.d.mts",
+      "import": "./dist/Toolkit.mjs",
+      "default": "./dist/Toolkit.mjs"
+    },
     "./package.json": "./package.json"
   },
   "types": "./dist/index.d.mts",
@@ -24,7 +31,8 @@
     "README.md"
   ],
   "dependencies": {
-    "@vercube/di": "0.0.48"
+    "evlog": "^2.19.0",
+    "@vercube/di": "1.0.0-beta.1"
   },
   "publishConfig": {
     "access": "public"

package/dist/Drivers/ConsoleProvider.d.mts

@@ -1,21 +0,0 @@
-import { n as LoggerTypes, t as LoggerProvider } from "../LoggerProvider-BcdoeL8E.mjs";
-
-//#region src/Drivers/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/Drivers/ConsoleProvider.mjs

@@ -1,24 +0,0 @@
-import { t as LoggerProvider } from "../LoggerProvider-6Hyw8mz_.mjs";
-import { t as LOG_LEVEL_COLORS } from "../Utils-DZA2B0cS.mjs";
-//#region src/Drivers/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/Drivers/JsonProvider.d.mts

@@ -1,22 +0,0 @@
-import { n as LoggerTypes, t as LoggerProvider } from "../LoggerProvider-BcdoeL8E.mjs";
-
-//#region src/Drivers/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/Drivers/JsonProvider.mjs

@@ -1,26 +0,0 @@
-import { t as LoggerProvider } from "../LoggerProvider-6Hyw8mz_.mjs";
-//#region src/Drivers/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
-export { JSONProvider };

package/dist/LoggerProvider-6Hyw8mz_.mjs

@@ -1,11 +0,0 @@
-//#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 as t };

package/dist/LoggerProvider-BcdoeL8E.d.mts

@@ -1,57 +0,0 @@
-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 { LoggerTypes as n, LoggerProvider as t };

package/dist/Utils-DZA2B0cS.mjs

@@ -1,38 +0,0 @@
-//#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 { colors as n, isLogLevelEnabled as r, LOG_LEVEL_COLORS as t };