@4players/odin-common/utility/log.d.ts

A collection of commonly used type definitions and utility functions across ODIN web projects

import { type Result } from './result.ts';
export declare enum LogVerbosity {
    NONE = 0,
    ERROR = 1,
    WARN = 2,
    INFO = 3,
    DEBUG = 4
}
export type LogLevel = (typeof LogVerbosity)[LogLevelName];
export type LogLevelName = Exclude<keyof typeof LogVerbosity, number>;
export declare const LogLevels: LogLevel[];
export declare const LogLevelNames: LogLevelName[];
export declare const LogSymbols: {
    [Level in LogLevel]: string;
};
export declare const LogFunctions: {
    [Level in LogLevel]: (...data: unknown[]) => void;
};
export declare function getLevelByName(name: LogLevelName): Result<LogLevel>;
export declare function getLevelName(level: LogLevel): Result<LogLevelName>;
export interface LoggerOptions {
    handlers?: LogHandler[];
}
export declare function getLogger(name?: string): Logger;
export declare function error<T>(msg: () => T, ...args: unknown[]): T | undefined;
export declare function error<T>(msg: T extends GenericFunction ? never : T, ...args: unknown[]): T;
export declare function warn<T>(msg: () => T, ...args: unknown[]): T | undefined;
export declare function warn<T>(msg: T extends GenericFunction ? never : T, ...args: unknown[]): T;
export declare function info<T>(msg: () => T, ...args: unknown[]): T | undefined;
export declare function info<T>(msg: T extends GenericFunction ? never : T, ...args: unknown[]): T;
export declare function debug<T>(msg: () => T, ...args: unknown[]): T | undefined;
export declare function debug<T>(msg: T extends GenericFunction ? never : T, ...args: unknown[]): T;
export declare class Logger {
    readonly name: string;
    private _Level;
    private _Handlers;
    constructor(level: LogLevel | LogLevelName, name?: string, options?: LoggerOptions);
    get level(): LogLevel;
    set level(value: LogLevel);
    get levelName(): LogLevelName;
    set levelName(value: LogLevelName);
    get handlers(): LogHandler[];
    addHandler(handler: LogHandler): void;
    removeHandler(handler: LogHandler): void;
    log<T>(level: LogLevel, msg: (T extends GenericFunction ? never : T) | (() => T), ...args: unknown[]): T | undefined;
    error<T>(msg: () => T, ...args: unknown[]): T | undefined;
    error<T>(msg: T extends GenericFunction ? never : T, ...args: unknown[]): T;
    warn<T>(msg: () => T, ...args: unknown[]): T | undefined;
    warn<T>(msg: T extends GenericFunction ? never : T, ...args: unknown[]): T;
    info<T>(msg: () => T, ...args: unknown[]): T | undefined;
    info<T>(msg: T extends GenericFunction ? never : T, ...args: unknown[]): T;
    debug<T>(msg: () => T, ...args: unknown[]): T | undefined;
    debug<T>(msg: T extends GenericFunction ? never : T, ...args: unknown[]): T;
    private asString;
}
type GenericFunction = (...args: unknown[]) => unknown;
type FormatterFunction = (record: LogRecord) => string;
export interface LogRecord {
    readonly date: Date;
    readonly level: LogLevel;
    readonly levelName: LogLevelName;
    readonly logger: string;
    readonly message: string;
    readonly args: unknown[];
}
export declare const DEFAULT_FORMATTER: FormatterFunction;
export declare const PRETTY_FORMATTER: FormatterFunction;
export declare class LogHandler {
    private _Level;
    private _FormatterFn;
    constructor(level: LogLevel | LogLevelName, formatter?: FormatterFunction);
    get level(): LogLevel;
    set level(value: LogLevel);
    get levelName(): LogLevelName;
    set levelName(value: LogLevelName);
    handle(record: LogRecord): void;
    log(formattedString: string, record: LogRecord): void;
}
export {};