/** * NodeJS.WritableStream "Like" * * We only call .write in this one form */ interface WritableStreamLike { write(chunk: any, encoding: 'utf8', callback?: (error: Error | null | undefined) => void): boolean; } type DefaultStreams = readonly [ emergency: WritableStreamLike, alert: WritableStreamLike, critical: WritableStreamLike, error: WritableStreamLike, warning: WritableStreamLike, notice: WritableStreamLike, info: WritableStreamLike, debug: WritableStreamLike, ] type DefaultOptions = Readonly<{ level: LoggerrConstructor['WARNING']; formatter: DefaultLoggerr.FormatterFunction; streams: DefaultStreams; debugStream?: WritableStreamLike }>; /** * Instantiates a {@link DefaultLoggerr} * * **This** is the type the consumer will interface with when they use the * `Loggerr` export (or `Loggerr` prop of the default export). */ interface LoggerrConstructor { CRITICAL: 2; DEBUG: 6; EMERGENCY: 0; ERROR: 3; INFO: 5; WARNING: 4; defaultOptions: DefaultOptions; levels: DefaultLoggerr.DefaultLevels; Loggerr: LoggerrConstructor; new ( options?: DefaultLoggerr.LoggerrOptions, ): DefaultLoggerr.Loggerr; } declare namespace DefaultLoggerr { /** * Builtin formatters */ type Formatter = | 'browser' | 'bunyan' | 'cli' | 'cli-simple' | 'default'; /** * This aligns the levels with the streams -- there should be a stream for * each level. */ type TupleOfLength = A extends { length: N; } ? A : TupleOfLength; /** * List of levels when instantiating a new `Loggerr` instance. * * @remarks You're gonna want at least one level. */ type Levels = readonly [string, ...string[]]; interface LoggerrOptions< T extends Levels = DefaultLevels, > { formatter?: Formatter | FormatterFunction; level?: LevelRef; levels?: T; streams?: TupleOfLength; } /** * Default levels for a new `Loggerr` instance (including the default instance) */ type DefaultLevels = readonly [ 'emergency', 'alert', 'critical', 'error', 'warning', 'notice', 'info', 'debug', ]; /** * The type of a formatter, whether {@link Formatters builtin} or not */ type FormatterFunction = ( date: Date, level: string, data: Record, ) => string; /** * Get the indices of a tuple; used for referencing a level by number */ type Indices = Exclude< Partial['length'], T['length'] >; /** * Possible ways to reference a level. * * If an array, it's the index _or_ the item. If an object, we can only use * the key, since the value is arbitrary. */ type LevelRef = T[number] | Indices /** * Each log level gets a method which is one of these. */ type LogFunction = ( msg: string | Error, extraOrDone?: Record | (() => void), done?: () => void, ) => void; /** * Defines the dynamic methods added to the {@link Loggerr_ class} instance * upon construction * * @privateRemarks * We don't use {@link LevelRef} here because we just want the level names */ type Loggerr = { formatter: FormatterFunction; level: Indices; streams: TupleOfLength levels: T; /** * All dynamically-created methods are bound to this method with their level * for the first argument. * * @param level Level to log at * @param msg Message or error * @param extra Extra data * @param done "Done" callback */ log( level: LevelRef, msg: string | Error, extra?: Record, done?: () => void, ): void; /** * Sets the log level * @param level Level to set */ setLevel(level: LevelRef): void; /** * Writes to a stream corresponding to the level * * @param level Level * @param msg Message * @param done "Done" callback */ write( level: LevelRef, msg: Uint8Array | string, done?: () => void, ): void; /** * Writes to a stream if level is satisfied * * @param level Level * @param msg Message * @param done "Done" callback */ writeLevel( level: LevelRef, msg: Uint8Array | string, done?: () => void, ): void; } & { [key in T[number]]: LogFunction; } } declare const DefaultLoggerr: DefaultLoggerr.Loggerr & {Loggerr: LoggerrConstructor} export = DefaultLoggerr