loglevelnext

  • Version 6.0.0
  • Published
  • 54.3 kB
  • No dependencies
  • MPL-2.0 license

Install

npm i loglevelnext
yarn add loglevelnext
pnpm add loglevelnext

Overview

A modern logging library for Node.js and modern browsers that provides log level mapping to the console

Index

Variables

variable _default

const _default: DefaultLogger;

    variable defaultLevels

    const defaultLevels: FactoryLevels;

      variable instance

      const instance: Symbol;

        variable levels

        const levels: Symbol;

          Classes

          class LogLevel

          class LogLevel<TLevels extends FactoryLevels = typeof defaultLevels>
          implements LogLevelIndex {}

            constructor

            constructor(options: LogLevelOptions);

              property factory

              factory: Factory<TLevels>;

                property level

                level: number;

                  property levels

                  readonly levels: FactoryLevels;

                    property name

                    name: string;

                      property type

                      type: string;

                        method disable

                        disable: () => void;

                          method enable

                          enable: () => void;

                            class MethodFactory

                            class MethodFactory<TLevels extends FactoryLevels = typeof defaultLevels>
                            implements Factory<TLevels> {}

                              constructor

                              constructor(logger?: LogLevel<FactoryLevels>);

                                property [instance]

                                [instance]: LogLevel<FactoryLevels>;

                                  property [levels]

                                  [levels]: FactoryLevels;

                                    property levels

                                    readonly levels: FactoryLevels;

                                      property logger

                                      logger: LogLevel<FactoryLevels>;

                                        property methods

                                        readonly methods: string[];

                                          method bindMethod

                                          bindMethod: (obj: BindTarget, methodName: string) => any;

                                            method distillLevel

                                            distillLevel: (level: number | string) => number | null;

                                              method levelValid

                                              levelValid: (level: number) => boolean;

                                                method make

                                                make: (methodName: string) => Function;

                                                  method replaceMethods

                                                  replaceMethods: (logLevel: number | string) => void;

                                                    class PrefixFactory

                                                    class PrefixFactory extends MethodFactory {}

                                                      constructor

                                                      constructor(logger?: LogLevel<FactoryLevels>, options?: PrefixFactoryOptions);

                                                        method interpolate

                                                        interpolate: (level: string) => string;

                                                          method make

                                                          make: (methodName: string) => (...args: any[]) => void;

                                                            Interfaces

                                                            interface Factory

                                                            interface Factory<TLevels extends FactoryLevels = typeof defaultLevels> {}

                                                              property [instance]

                                                              [instance]: LogLevel | undefined;

                                                                property [levels]

                                                                [levels]: TLevels;

                                                                  property bindMethod

                                                                  bindMethod: (obj: BindTarget, methodName: string) => any;

                                                                    property distillLevel

                                                                    distillLevel: (level: number | string) => any;

                                                                      property levels

                                                                      levels: TLevels;

                                                                        property levelValid

                                                                        levelValid: (level: number) => boolean;

                                                                          property logger

                                                                          logger: LogLevel;

                                                                            property make

                                                                            make: (methodName: string) => Function;

                                                                              property methods

                                                                              methods?: string[];

                                                                                property replaceMethods

                                                                                replaceMethods: (logLevel: number | string) => void;

                                                                                  index signature

                                                                                  [key: string]: any;

                                                                                    interface LogLevelIndex

                                                                                    interface LogLevelIndex {}

                                                                                      index signature

                                                                                      [key: string]: any;

                                                                                        interface LogLevelOptions

                                                                                        interface LogLevelOptions {}

                                                                                          property factory

                                                                                          factory?: Factory;

                                                                                            property id

                                                                                            id?: string;

                                                                                              property level

                                                                                              level?: number | string;

                                                                                                property name

                                                                                                name?: string;

                                                                                                  property prefix

                                                                                                  prefix?: PrefixFactoryOptions;

                                                                                                    interface PrefixFactoryOptions

                                                                                                    interface PrefixFactoryOptions {}

                                                                                                      property level

                                                                                                      level?: PrefixTemplateFn;

                                                                                                        property name

                                                                                                        name?: PrefixTemplateFn;

                                                                                                          property template

                                                                                                          template?: string;

                                                                                                            property time

                                                                                                            time?: PrefixTemplateFn;

                                                                                                              index signature

                                                                                                              [key: string]: PrefixTemplateFn | string | undefined;

                                                                                                                interface PrefixTemplateOptions

                                                                                                                interface PrefixTemplateOptions {}

                                                                                                                  property level

                                                                                                                  level: string;

                                                                                                                    property logger

                                                                                                                    logger: LogLevel;

                                                                                                                      Type Aliases

                                                                                                                      type FactoryLevels

                                                                                                                      type FactoryLevels = Record<Uppercase<string>, number> & {
                                                                                                                      DEBUG: number;
                                                                                                                      ERROR: number;
                                                                                                                      INFO: number;
                                                                                                                      SILENT: number;
                                                                                                                      TRACE: number;
                                                                                                                      WARN: number;
                                                                                                                      };

                                                                                                                        type MethodFactoryLevels

                                                                                                                        type MethodFactoryLevels = Lowercase<keyof FactoryLevels>;

                                                                                                                          type PrefixTemplateFn

                                                                                                                          type PrefixTemplateFn = (options: PrefixTemplateOptions) => string;

                                                                                                                            Package Files (1)

                                                                                                                            Dependencies (0)

                                                                                                                            No dependencies.

                                                                                                                            Dev Dependencies (15)

                                                                                                                            Peer Dependencies (0)

                                                                                                                            No peer dependencies.

                                                                                                                            Badge

                                                                                                                            To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                            You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/loglevelnext.

                                                                                                                            • Markdown
                                                                                                                              [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/loglevelnext)
                                                                                                                            • HTML
                                                                                                                              <a href="https://www.jsdocs.io/package/loglevelnext"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>