@tstdl/base 0.92.167 → 0.93.0

package/logger/formatters/index.d.ts

@@ -0,0 +1,2 @@
+export * from './json.js';
+export * from './pretty-print.js';

package/logger/formatters/index.js

@@ -0,0 +1,2 @@
+export * from './json.js';
+export * from './pretty-print.js';

package/logger/formatters/json.d.ts

@@ -0,0 +1,5 @@
+import { LogFormatter, type LogPayload } from '../formatter.js';
+/** Formats log entries as a JSON string. */
+export declare class JsonLogFormatter extends LogFormatter {
+    format(payload: LogPayload): string;
+}

package/logger/formatters/json.js

@@ -0,0 +1,33 @@
+var __decorate = (this && this.__decorate) || function (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;
+};
+import { Singleton } from '../../injector/decorators.js';
+import { enumValueName } from '../../utils/enum.js';
+import { formatError } from '../../utils/format-error.js';
+import { isNotNullOrUndefined } from '../../utils/type-guards.js';
+import { LogFormatter } from '../formatter.js';
+import { LogLevel } from '../level.js';
+/** Formats log entries as a JSON string. */
+let JsonLogFormatter = class JsonLogFormatter extends LogFormatter {
+    format(payload) {
+        const logObject = {
+            timestamp: payload.timestamp.toISOString(),
+            level: enumValueName(LogLevel, payload.level).toLowerCase(),
+            module: (payload.module.length > 0) ? payload.module.join('.') : null,
+            message: payload.message,
+            ...payload.context,
+        };
+        // Special handling for error objects to make them serializable
+        if (isNotNullOrUndefined(logObject['error'])) {
+            logObject['error'] = formatError(logObject['error'], { includeStack: true });
+        }
+        return JSON.stringify(logObject);
+    }
+};
+JsonLogFormatter = __decorate([
+    Singleton()
+], JsonLogFormatter);
+export { JsonLogFormatter };

package/logger/formatters/pretty-print.d.ts

@@ -0,0 +1,5 @@
+import { LogFormatter, type LogPayload } from '../formatter.js';
+/** Formats log entries in a human-readable, colorful format for development consoles. */
+export declare class PrettyPrintLogFormatter extends LogFormatter {
+    format(payload: LogPayload): string;
+}

package/logger/formatters/pretty-print.js

@@ -0,0 +1,55 @@
+var __decorate = (this && this.__decorate) || function (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;
+};
+import { Singleton } from '../../injector/decorators.js';
+import { enumValueName } from '../../utils/enum.js';
+import { formatError } from '../../utils/format-error.js';
+import { isNotNullOrUndefined } from '../../utils/type-guards.js';
+import { LogFormatter } from '../formatter.js';
+import { LogLevel } from '../level.js';
+const levelColorMap = {
+    [LogLevel.Error]: '\x1b[31m', // Red
+    [LogLevel.Warn]: '\x1b[33m', // Yellow
+    [LogLevel.Info]: '\x1b[32m', // Green
+    [LogLevel.Verbose]: '\x1b[36m', // Cyan
+    [LogLevel.Debug]: '\x1b[34m', // Blue
+    [LogLevel.Trace]: '\x1b[90m', // Gray
+};
+const resetColor = '\x1b[0m';
+const dimColor = '\x1b[2m';
+/** Formats log entries in a human-readable, colorful format for development consoles. */
+let PrettyPrintLogFormatter = class PrettyPrintLogFormatter extends LogFormatter {
+    format(payload) {
+        const color = levelColorMap[payload.level];
+        const levelName = enumValueName(LogLevel, payload.level).toUpperCase();
+        const levelString = `${levelName}:`.padEnd(8);
+        const moduleString = payload.module.map((m) => `[${m}]`).join(' ');
+        const metadata = { ...payload.context };
+        let metadataString = '';
+        let errorString = '';
+        if (Object.keys(metadata).length > 0) {
+            const displayMeta = {};
+            // Don't display metadata used in interpolation
+            const interpolationKeys = Array.from(payload.message.matchAll(/{([^{}]+)}/g)).map((match) => match[1]);
+            for (const key in metadata) {
+                if (!interpolationKeys.includes(key)) {
+                    displayMeta[key] = metadata[key];
+                }
+            }
+            if (Object.keys(displayMeta).length > 0) {
+                metadataString = ` ${dimColor}${JSON.stringify(displayMeta)}${resetColor}`;
+            }
+            if (isNotNullOrUndefined(metadata['error'])) {
+                errorString += `\n${formatError(metadata['error'], { includeStack: true })}`;
+            }
+        }
+        return `${dimColor}${payload.timestamp.toISOString()}${resetColor} ${color}${levelString}${resetColor} ${moduleString}${moduleString.length > 0 ? ' ' : ''}${payload.message}${metadataString}${errorString}`;
+    }
+};
+PrettyPrintLogFormatter = __decorate([
+    Singleton()
+], PrettyPrintLogFormatter);
+export { PrettyPrintLogFormatter };

package/logger/index.d.ts

@@ -3,8 +3,11 @@
  *
  * @module Logger
  */
-export * from './console/index.js';
+export * from './formatter.js';
+export * from './formatters/index.js';
 export * from './level.js';
 export * from './logger.js';
-export * from './noop/index.js';
+export * from './manager.js';
 export * from './tokens.js';
+export * from './transport.js';
+export * from './transports/index.js';

package/logger/index.js

@@ -3,8 +3,11 @@
  *
  * @module Logger
  */
-export * from './console/index.js';
+export * from './formatter.js';
+export * from './formatters/index.js';
 export * from './level.js';
 export * from './logger.js';
-export * from './noop/index.js';
+export * from './manager.js';
 export * from './tokens.js';
+export * from './transport.js';
+export * from './transports/index.js';

package/logger/level.d.ts

@@ -1,8 +1,10 @@
-export declare enum LogLevel {
-    Error = 0,
-    Warn = 1,
-    Info = 2,
-    Verbose = 3,
-    Debug = 4,
-    Trace = 5
-}
+import { type EnumType } from '../enumeration/enumeration.js';
+export declare const LogLevel: {
+    readonly Error: 0;
+    readonly Warn: 1;
+    readonly Info: 2;
+    readonly Verbose: 3;
+    readonly Debug: 4;
+    readonly Trace: 5;
+};
+export type LogLevel = EnumType<typeof LogLevel>;

package/logger/level.js

@@ -1,9 +1,9 @@
-export var LogLevel;
-(function (LogLevel) {
-    LogLevel[LogLevel["Error"] = 0] = "Error";
-    LogLevel[LogLevel["Warn"] = 1] = "Warn";
-    LogLevel[LogLevel["Info"] = 2] = "Info";
-    LogLevel[LogLevel["Verbose"] = 3] = "Verbose";
-    LogLevel[LogLevel["Debug"] = 4] = "Debug";
-    LogLevel[LogLevel["Trace"] = 5] = "Trace";
-})(LogLevel || (LogLevel = {}));
+import { defineEnum } from '../enumeration/enumeration.js';
+export const LogLevel = defineEnum('LogLevel', {
+    Error: 0,
+    Warn: 1,
+    Info: 2,
+    Verbose: 3,
+    Debug: 4,
+    Trace: 5,
+});

package/logger/logger.d.ts

@@ -1,41 +1,32 @@
 import type { Resolvable } from '../injector/index.js';
 import { resolveArgumentType } from '../injector/index.js';
+import type { Record } from '../types/types.js';
 import { LogLevel } from './level.js';
-export type LogEntry = string;
-export type LogEntryProvider = () => LogEntry;
-export type LogEntryOrProvider = LogEntry | LogEntryProvider;
-export type LoggerStatic = new (level: LogLevel) => Logger;
-export type LogErrorOptions = {
-    includeRest?: boolean;
-    includeStack?: boolean;
-};
-/** Either string as a module shorthand or object */
-export type LoggerArgument = string | undefined | {
-    level?: LogLevel;
+export type LoggerArgument = string | string[] | {
     module?: string | string[];
-    prefix?: string;
+    context?: Record<string>;
+    level?: LogLevel;
 };
 export type LoggerForkOptions = {
-    subModule?: string;
-    prefix?: string;
+    context?: Record<string>;
+    replaceContext?: boolean;
     level?: LogLevel;
 };
-export declare abstract class Logger implements Resolvable<LoggerArgument> {
-    readonly level: LogLevel;
-    readonly module?: string[];
-    readonly logPrefix: string;
+export declare class Logger implements Resolvable<LoggerArgument> {
+    #private;
+    readonly module: string[];
+    readonly context: Record<string>;
+    readonly level: LogLevel | undefined;
     readonly [resolveArgumentType]: LoggerArgument;
-    constructor(level: LogLevel, module?: string | string[], prefix?: string);
-    error(entry: LogEntryOrProvider): void;
-    error(error: unknown, options?: LogErrorOptions): void;
-    warn(entry: LogEntryOrProvider): void;
-    info(entry: LogEntryOrProvider): void;
-    verbose(entry: LogEntryOrProvider): void;
-    debug(entry: LogEntryOrProvider): void;
-    trace(entry: LogEntryOrProvider): void;
+    error(message: string, context?: Record<string>): void;
+    error(error: unknown, context?: Record<string>): void;
+    warn(message: string, context?: Record<string>): void;
+    info(message: string, context?: Record<string>): void;
+    verbose(message: string, context?: Record<string>): void;
+    debug(message: string, context?: Record<string>): void;
+    trace(message: string, context?: Record<string>): void;
+    fork(subModule: string | string[], options?: LoggerForkOptions): Logger;
+    fork(options: LoggerForkOptions): Logger;
+    with(context: Record<string>): Logger;
     private _log;
-    abstract fork(options: LoggerForkOptions): Logger;
-    abstract subModule(subModule: string): Logger;
-    abstract prefix(prefix: string): Logger;
-    protected abstract log(level: LogLevel, entry: LogEntry | Error, errorOptions?: LogErrorOptions): void;
 }

package/logger/logger.js

@@ -1,39 +1,111 @@
-import { resolveArgumentType } from '../injector/index.js';
+var __decorate = (this && this.__decorate) || function (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;
+};
+var Logger_1;
+import { createContextProvider } from '../context/context.js';
+import { inject, Injectable, injectArgument, isInInjectionContext, resolveArgumentType } from '../injector/index.js';
 import { toArray } from '../utils/array/array.js';
-import { isDefined, isFunction } from '../utils/type-guards.js';
+import { now } from '../utils/date-time.js';
+import { getCachedDereference } from '../utils/object/dereference.js';
+import { hasOwnProperty } from '../utils/object/object.js';
+import { isArray, isNotArray, isObject, isString } from '../utils/type-guards.js';
 import { LogLevel } from './level.js';
-export class Logger {
-    level;
-    module;
-    logPrefix;
-    constructor(level, module, prefix = '') {
-        this.level = level;
-        this.module = isDefined(module) ? toArray(module) : undefined;
-        this.logPrefix = prefix;
+import { LogManager } from './manager.js';
+const { getCurrentLoggerCreationContext, runInLoggerCreationContext, isInLoggerCreationContext } = createContextProvider('LoggerCreation');
+let Logger = Logger_1 = class Logger {
+    #manager = getCurrentLoggerCreationContext()?.manager ?? inject(LogManager);
+    #argument = isInInjectionContext() ? injectArgument(this, { optional: true }) : undefined;
+    module = getCurrentLoggerCreationContext()?.module ?? moduleFromArgument(this.#argument);
+    context = getCurrentLoggerCreationContext()?.context ?? ((isObject(this.#argument) && isNotArray(this.#argument)) ? (this.#argument.context ?? {}) : {});
+    level = isInLoggerCreationContext() ? getCurrentLoggerCreationContext().level : (isObject(this.#argument) && isNotArray(this.#argument)) ? this.#argument.level : undefined;
+    error(errorOrMessage, context) {
+        if (isString(errorOrMessage)) {
+            this._log(LogLevel.Error, errorOrMessage, context);
+        }
+        else {
+            const message = (errorOrMessage instanceof Error) ? errorOrMessage.message : 'Error';
+            this._log(LogLevel.Error, message, { ...context, error: errorOrMessage });
+        }
     }
-    error(errorOrEntry, options) {
-        this._log(LogLevel.Error, errorOrEntry, options);
+    warn(message, context) {
+        this._log(LogLevel.Warn, message, context);
     }
-    warn(entry) {
-        this._log(LogLevel.Warn, entry);
+    info(message, context) {
+        this._log(LogLevel.Info, message, context);
     }
-    info(entry) {
-        this._log(LogLevel.Info, entry);
+    verbose(message, context) {
+        this._log(LogLevel.Verbose, message, context);
     }
-    verbose(entry) {
-        this._log(LogLevel.Verbose, entry);
+    debug(message, context) {
+        this._log(LogLevel.Debug, message, context);
     }
-    debug(entry) {
-        this._log(LogLevel.Debug, entry);
+    trace(message, context) {
+        this._log(LogLevel.Trace, message, context);
     }
-    trace(entry) {
-        this._log(LogLevel.Trace, entry);
+    fork(subModuleOrOptions, optionsOrNothing) {
+        const subModule = (isString(subModuleOrOptions) || isArray(subModuleOrOptions)) ? subModuleOrOptions : [];
+        const options = (isString(subModuleOrOptions) || isArray(subModuleOrOptions)) ? optionsOrNothing : subModuleOrOptions;
+        const newModule = [...this.module, ...toArray(subModule)];
+        const creationContext = {
+            manager: this.#manager,
+            module: newModule,
+            context: (options?.replaceContext == true) ? (options.context ?? {}) : { ...this.context, ...options?.context },
+            level: options?.level ?? this.level,
+        };
+        return runInLoggerCreationContext(creationContext, () => new Logger_1());
     }
-    _log(level, entryOrProvider, errorOptions) {
-        if (this.level < level) {
+    with(context) {
+        const creationContext = {
+            manager: this.#manager,
+            module: this.module,
+            context: { ...this.context, ...context },
+            level: this.level,
+        };
+        return runInLoggerCreationContext(creationContext, () => new Logger_1());
+    }
+    _log(level, message, context = {}) {
+        const moduleLevel = this.level ?? this.#manager.getModuleLevel(this.module);
+        if (level > moduleLevel) {
             return;
         }
-        const entry = isFunction(entryOrProvider) ? entryOrProvider() : entryOrProvider;
-        this.log(level, entry, errorOptions);
+        const effectiveContext = { ...this.context, ...context };
+        const finalMessage = interpolateMessage(message, effectiveContext);
+        const payload = {
+            timestamp: now(),
+            level,
+            module: this.module,
+            message: finalMessage,
+            context: effectiveContext,
+        };
+        this.#manager.log(payload);
+    }
+};
+Logger = Logger_1 = __decorate([
+    Injectable()
+], Logger);
+export { Logger };
+function moduleFromArgument(argument) {
+    if (isString(argument)) {
+        return [argument];
     }
+    if (isArray(argument)) {
+        return argument;
+    }
+    if (isObject(argument)) {
+        return moduleFromArgument(argument.module);
+    }
+    return [];
+}
+const cachedDereference = getCachedDereference({ optional: true });
+function interpolateMessage(message, context) {
+    return message.replace(/{([^{}]+)}/g, (match, key) => {
+        if (hasOwnProperty(context, key)) {
+            const value = cachedDereference(context, key);
+            return String(value);
+        }
+        return match;
+    });
 }

package/logger/manager.d.ts

@@ -0,0 +1,20 @@
+import type { LogPayload } from './formatter.js';
+import { LogLevel } from './level.js';
+export declare class LogManager {
+    #private;
+    log(payload: LogPayload): void;
+    setDefaultLevel(level: LogLevel): void;
+    /**
+     * Sets the log level for a specific module.
+     * @param module The module (e.g., 'Api.Users' or ['Api', 'Users'])
+     * @param level The log level to set
+     */
+    setModuleLevel(module: string | string[], level: LogLevel): void;
+    /**
+     * Gets the effective log level for a given module path.
+     * It finds the most specific rule matching the module path.
+     * @param module Array of module names, e.g., ['Api', 'Users']
+     * @returns The effective log level
+     */
+    getModuleLevel(module?: string | string[]): LogLevel;
+}

package/logger/manager.js

@@ -0,0 +1,86 @@
+var __decorate = (this && this.__decorate) || function (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;
+};
+import { Singleton } from '../injector/decorators.js';
+import { inject, injectAll } from '../injector/inject.js';
+import { isDefined } from '../utils/type-guards.js';
+import { LogLevel } from './level.js';
+import { DEFAULT_LOG_LEVEL } from './tokens.js';
+import { LogTransport } from './transport.js';
+let LogManager = class LogManager {
+    #transports = injectAll(LogTransport);
+    #moduleLevelRules = new Map();
+    #moduleLevelCache = new Map();
+    #defaultLevel = inject(DEFAULT_LOG_LEVEL, undefined, { optional: true }) ?? LogLevel.Trace;
+    log(payload) {
+        for (const transport of this.#transports) {
+            if (payload.level <= transport.level) {
+                try {
+                    transport.log(payload);
+                }
+                catch (err) {
+                    try {
+                        const transportName = transport.constructor?.name ?? 'UnknownTransport';
+                        console.error(`[LogTransport Error] transport=${transportName} error=`, err, 'payload=', payload);
+                    }
+                    catch { /* swallow to avoid cascading failures. */ }
+                }
+            }
+        }
+    }
+    setDefaultLevel(level) {
+        this.#defaultLevel = level;
+        this.#moduleLevelCache.clear();
+    }
+    /**
+     * Sets the log level for a specific module.
+     * @param module The module (e.g., 'Api.Users' or ['Api', 'Users'])
+     * @param level The log level to set
+     */
+    setModuleLevel(module, level) {
+        const moduleString = Array.isArray(module) ? module.join('.') : module;
+        if (this.#moduleLevelRules.get(moduleString) === level) {
+            return;
+        }
+        this.#moduleLevelRules.set(moduleString, level);
+        this.#moduleLevelCache.clear();
+    }
+    /**
+     * Gets the effective log level for a given module path.
+     * It finds the most specific rule matching the module path.
+     * @param module Array of module names, e.g., ['Api', 'Users']
+     * @returns The effective log level
+     */
+    getModuleLevel(module) {
+        if (!isDefined(module) || (module.length == 0)) {
+            return this.#defaultLevel;
+        }
+        const path = Array.isArray(module) ? module.join('.') : module;
+        const cachedLevel = this.#moduleLevelCache.get(path);
+        if (isDefined(cachedLevel)) {
+            return cachedLevel;
+        }
+        let currentPath = path;
+        while (currentPath.length > 0) {
+            const level = this.#moduleLevelRules.get(currentPath);
+            if (isDefined(level)) {
+                this.#moduleLevelCache.set(path, level); // Cache the result for the original full path
+                return level;
+            }
+            const lastDotIndex = currentPath.lastIndexOf('.');
+            if (lastDotIndex === -1) {
+                break;
+            }
+            currentPath = currentPath.substring(0, lastDotIndex);
+        }
+        this.#moduleLevelCache.set(path, this.#defaultLevel);
+        return this.#defaultLevel;
+    }
+};
+LogManager = __decorate([
+    Singleton()
+], LogManager);
+export { LogManager };

package/logger/tokens.d.ts

@@ -1,2 +1,2 @@
 import type { LogLevel } from './level.js';
-export declare const LOG_LEVEL: import("../injector/token.js").InjectionToken<LogLevel, never>;
+export declare const DEFAULT_LOG_LEVEL: import("../injector/token.js").InjectionToken<LogLevel, never>;

package/logger/tokens.js

@@ -1,2 +1,2 @@
 import { injectionToken } from '../injector/token.js';
-export const LOG_LEVEL = injectionToken('log level');
+export const DEFAULT_LOG_LEVEL = injectionToken('default log level');

package/logger/transport.d.ts

@@ -0,0 +1,14 @@
+import type { ProvidersItem } from '../injector/injector.js';
+import type { Resolvable, resolveArgumentType } from '../injector/interfaces.js';
+import type { Provider } from '../injector/provider.js';
+import type { LogPayload } from './formatter.js';
+import { LogLevel } from './level.js';
+export declare class LogTransportOptions {
+    level?: LogLevel;
+}
+export declare abstract class LogTransport implements Resolvable<LogTransportOptions> {
+    readonly level: LogLevel;
+    readonly [resolveArgumentType]: LogTransportOptions;
+    abstract log(payload: LogPayload): void;
+}
+export declare function provideLogTransport<T extends LogTransport>(provider: Provider<T>): ProvidersItem;

package/logger/transport.js

@@ -0,0 +1,16 @@
+import { inject, injectArgument } from '../injector/inject.js';
+import { LogLevel } from './level.js';
+import { DEFAULT_LOG_LEVEL } from './tokens.js';
+export class LogTransportOptions {
+    level;
+}
+export class LogTransport {
+    level = injectArgument(this, { optional: true })?.level ?? inject(DEFAULT_LOG_LEVEL, undefined, { optional: true }) ?? LogLevel.Trace;
+}
+export function provideLogTransport(provider) {
+    return {
+        ...provider,
+        provide: LogTransport,
+        multi: true,
+    };
+}

package/logger/transports/console.d.ts

@@ -0,0 +1,14 @@
+import { type InjectionToken, type Resolvable, type resolveArgumentType } from '../../injector/index.js';
+import type { ProvidersItem } from '../../injector/injector.js';
+import type { LogFormatter, LogPayload } from '../formatter.js';
+import { LogLevel } from '../level.js';
+import { LogTransport, LogTransportOptions } from '../transport.js';
+export declare class ConsoleLogTransportOptions extends LogTransportOptions {
+    formatter: InjectionToken<LogFormatter>;
+}
+export declare class ConsoleLogTransport extends LogTransport implements Resolvable<ConsoleLogTransportOptions> {
+    #private;
+    readonly [resolveArgumentType]: ConsoleLogTransportOptions;
+    log(payload: LogPayload): void;
+}
+export declare function provideConsoleLogTransport(formatter: InjectionToken<LogFormatter>, level?: LogLevel): ProvidersItem;

package/logger/transports/console.js

@@ -0,0 +1,36 @@
+var __decorate = (this && this.__decorate) || function (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;
+};
+import { Singleton } from '../../injector/decorators.js';
+import { inject, injectArgument } from '../../injector/index.js';
+import { LogLevel } from '../level.js';
+import { LogTransport, LogTransportOptions, provideLogTransport } from '../transport.js';
+export class ConsoleLogTransportOptions extends LogTransportOptions {
+    formatter;
+}
+const consoleLevelFuncMap = {
+    [LogLevel.Error]: 'error',
+    [LogLevel.Warn]: 'warn',
+    [LogLevel.Info]: 'info',
+    [LogLevel.Verbose]: 'info',
+    [LogLevel.Debug]: 'debug',
+    [LogLevel.Trace]: 'debug',
+};
+let ConsoleLogTransport = class ConsoleLogTransport extends LogTransport {
+    #formatter = inject(injectArgument(this).formatter);
+    log(payload) {
+        const message = this.#formatter.format(payload);
+        const consoleFunc = consoleLevelFuncMap[payload.level];
+        console[consoleFunc](message);
+    }
+};
+ConsoleLogTransport = __decorate([
+    Singleton()
+], ConsoleLogTransport);
+export { ConsoleLogTransport };
+export function provideConsoleLogTransport(formatter, level) {
+    return provideLogTransport({ useToken: ConsoleLogTransport, defaultArgument: { formatter, level } });
+}

package/logger/transports/index.d.ts

@@ -0,0 +1 @@
+export * from './console.js';

package/logger/transports/index.js

@@ -0,0 +1 @@
+export * from './console.js';

package/mail/clients/nodemailer.mail-client.d.ts

@@ -1,4 +1,3 @@
-import type { Disposable } from '../../disposable/disposable.js';
 import { MailClient, MailClientConfig } from '../mail.client.js';
 import type { MailData, MailSendResult } from '../models/index.js';
 export declare class NodemailerMailClient extends MailClient implements Disposable {

package/mail/clients/nodemailer.mail-client.js

@@ -32,13 +32,13 @@ let NodemailerMailClient = class NodemailerMailClient extends MailClient {
             subject: data.subject,
             text: data.content.text,
             html: data.content.html,
-            headers: data.headers
+            headers: data.headers,
         });
         return {
             messageId: result.messageId,
             accepted: result.accepted,
             rejected: result.rejected,
-            pending: result.pending
+            pending: result.pending,
         };
     }
     getTransport(config) {
@@ -62,11 +62,13 @@ function convertConfig(config) {
         host: config.host,
         port: config.port,
         secure: config.secure ?? (config.port == 465),
-        auth: isUndefined(config.auth) ? undefined : {
-            type: 'login',
-            user: config.auth.user,
-            pass: config.auth.password
-        }
+        auth: isUndefined(config.auth)
+            ? undefined
+            : {
+                type: 'login',
+                user: config.auth.user,
+                pass: config.auth.password,
+            },
     };
 }
 /**