@neodx/log/node/index.d.ts

A lightweight universal logging framework

import { A as AutoLoggerInput } from '../_internal/read-arguments-Bkk-Ifkg.js';
import {
  L as LogChunk,
  C as CreateLogger,
  a as LoggerParams,
  b as Logger
} from '../_internal/types-BxgckgWg.js';
export {
  C as CreateLoggerFactoryParams,
  D as DEFAULT_LOGGER_LEVELS,
  a as DEFAULT_LOGGER_PARAMS,
  b as DefaultLoggerLevel,
  L as LOGGER_SILENT_LEVEL,
  c as createLoggerFactory
} from '../_internal/shared-COvewc3V.js';
import { PathLike } from 'node:fs';
import { Writable } from 'node:stream';
import { Colors, ColorName } from '@neodx/colors';

interface PrintCodeFrameOptions {
  colors?: Colors;
  source: string;
  indent?: number;
  lineNumber: number;
  columnNumber: number;
  overscan?: number;
}
declare function printCodeFrame({
  colors,
  indent,
  columnNumber,
  lineNumber,
  source,
  overscan
}: PrintCodeFrameOptions): string;

interface ParsedStack {
  file: string;
  line: number;
  method: string;
  column: number;
}

interface PrintPrettyErrorOptions {
  cwd?: string;
  indent?: number;
  colors?: Colors;
  fullStack?: boolean;
  codeFrame?: boolean | 'auto' | GetHighlightStacks;
  stringify?: (value: unknown) => string;
  filterStack?: (stack: ParsedStack) => boolean;
}
type GetHighlightStacks = (stacks: ParsedStack[]) => ParsedStack | ParsedStack[];
declare function printPrettyError(
  originalError: unknown,
  options?: PrintPrettyErrorOptions
): string;

type LogSerializers = Record<string, LogSerializer>;
type LogSerializer = (value: any) => any;

interface JsonTargetParams {
  target?: Writable | ((...args: unknown[]) => void);
  dateKey?: string;
  errorKey?: string;
  messageKey?: string;
  serializers?: LogSerializers;
  levelValueKey?: string;
}
declare function file(
  filename: PathLike,
  options?: Omit<JsonTargetParams, 'target'>
): ({ msg, error, meta, level, name, date, __: { levels } }: LogChunk<string>) => void;
declare function json({
  target,
  dateKey,
  errorKey,
  messageKey,
  serializers,
  levelValueKey
}?: JsonTargetParams): ({
  msg,
  error,
  meta,
  level,
  name,
  date,
  __: { levels }
}: LogChunk<string>) => void;

interface PrettyTargetParams<Level extends string> {
  /**
   * Default handler for log messages without errors.
   */
  log?(...args: unknown[]): void;
  /**
   * Default handler for log messages with errors (e.g. `logger.error(new Error(), 'message')`).
   */
  logError?(...args: unknown[]): void;
  /**
   * Custom implementation of colors from `@neodx/colors` or other libraries with same contracts.
   * @example `createColors(false, false)` - disable colors completely
   */
  colors?: Colors;
  /**
   * Display milliseconds in log message (e.g. `12:34:56.789`).
   * Works only if `displayTime` is `true`.
   */
  displayMs?: boolean;
  serializers?: LogSerializers;
  /**
   * Display time in a log message
   */
  displayTime?: boolean;
  /**
   * Display log level in log message.
   */
  displayLevel?: boolean;
  prettyErrors?: boolean | Partial<PrintPrettyErrorOptions>;
  levelColors?: Partial<Record<Level, ColorName>> | null;
  levelBadges?: Partial<Record<Level, string>> | null;
}
/**
 * Creates a pretty log handler for development mode in node.
 */
declare function pretty<const Level extends string>({
  log,
  logError,
  colors,
  displayMs,
  serializers,
  displayTime,
  displayLevel,
  prettyErrors,
  levelColors,
  levelBadges
}?: PrettyTargetParams<Level>): (chunk: LogChunk<Level>) => void;
declare namespace pretty {
  var defaultBadges: Partial<
    Record<'error' | 'debug' | 'info' | 'done' | 'silent' | 'warn' | 'success' | 'verbose', string>
  >;
  var defaultColors: Partial<
    Record<
      'error' | 'debug' | 'info' | 'done' | 'silent' | 'warn' | 'success' | 'verbose',
      | 'reset'
      | 'bold'
      | 'dim'
      | 'italic'
      | 'overline'
      | 'underline'
      | 'inverse'
      | 'hidden'
      | 'strikethrough'
      | 'black'
      | 'red'
      | 'green'
      | 'yellow'
      | 'blue'
      | 'magenta'
      | 'cyan'
      | 'white'
      | 'gray'
      | 'redBright'
      | 'greenBright'
      | 'yellowBright'
      | 'blueBright'
      | 'magentaBright'
      | 'cyanBright'
      | 'whiteBright'
      | 'bgBlack'
      | 'bgRed'
      | 'bgGreen'
      | 'bgYellow'
      | 'bgBlue'
      | 'bgMagenta'
      | 'bgCyan'
      | 'bgWhite'
    >
  >;
}

declare const NODE_LOGGER_SYSTEM_INFO: {
  pid: number;
  hostname: string;
};
declare const createLogger: CreateLogger<
  'error' | 'debug' | 'info' | 'done' | 'silent' | 'warn' | 'success' | 'verbose'
>;
declare const createAutoLogger: <const Level extends string>(
  log: AutoLoggerInput<Level>,
  defaultParams?: Partial<LoggerParams<Level>> | undefined
) => Logger<Level>;

export {
  type JsonTargetParams,
  NODE_LOGGER_SYSTEM_INFO,
  type PrettyTargetParams,
  type PrintCodeFrameOptions,
  type PrintPrettyErrorOptions,
  createAutoLogger,
  createLogger,
  file,
  json,
  pretty,
  printCodeFrame,
  printPrettyError
};