.config/coc/extensions/node_modules/coc-prettier/node_modules/loglevel/index.d.ts

   1 // Originally from Definitely Typed, see:
   2 // https://github.com/DefinitelyTyped/DefinitelyTyped/blob/b4683d7/types/loglevel/index.d.ts
   3 // Original definitions by: Stefan Profanter <https://github.com/Pro>
   4 //                          Gabor Szmetanko <https://github.com/szmeti>
   5 //                          Christian Rackerseder <https://github.com/screendriver>
   6
   7 declare const log: log.RootLogger;
   8 export = log;
   9
  10 declare namespace log {
  11     /**
  12      * Log levels
  13      */
  14     interface LogLevel {
  15         TRACE: 0;
  16         DEBUG: 1;
  17         INFO: 2;
  18         WARN: 3;
  19         ERROR: 4;
  20         SILENT: 5;
  21     }
  22
  23     /**
  24      * Possible log level numbers.
  25      */
  26     type LogLevelNumbers = LogLevel[keyof LogLevel];
  27
  28     /**
  29      * Possible log level descriptors, may be string, lower or upper case, or number.
  30      */
  31     type LogLevelDesc = LogLevelNumbers
  32         | 'trace'
  33         | 'debug'
  34         | 'info'
  35         | 'warn'
  36         | 'error'
  37         | 'silent'
  38         | keyof LogLevel;
  39
  40     type LoggingMethod = (...message: any[]) => void;
  41
  42     type MethodFactory = (methodName: string, level: LogLevelNumbers, loggerName: string | symbol) => LoggingMethod;
  43
  44     interface RootLogger extends Logger {
  45         /**
  46          * If you're using another JavaScript library that exposes a 'log' global, you can run into conflicts with loglevel.
  47          * Similarly to jQuery, you can solve this by putting loglevel into no-conflict mode immediately after it is loaded
  48          * onto the page. This resets to 'log' global to its value before loglevel was loaded (typically undefined), and
  49          * returns the loglevel object, which you can then bind to another name yourself.
  50          */
  51         noConflict(): any;
  52
  53         /**
  54          * This gets you a new logger object that works exactly like the root log object, but can have its level and
  55          * logging methods set independently. All loggers must have a name (which is a non-empty string or a symbol)
  56          * Calling * getLogger() multiple times with the same name will return an identical logger object.
  57          * In large applications, it can be incredibly useful to turn logging on and off for particular modules as you are
  58          * working with them. Using the getLogger() method lets you create a separate logger for each part of your
  59          * application with its own logging level. Likewise, for small, independent modules, using a named logger instead
  60          * of the default root logger allows developers using your module to selectively turn on deep, trace-level logging
  61          * when trying to debug problems, while logging only errors or silencing logging altogether under normal
  62          * circumstances.
  63          * @param name The name of the produced logger
  64          */
  65         getLogger(name: string | symbol): Logger;
  66
  67         /**
  68          * This will return you the dictionary of all loggers created with getLogger, keyed off of their names.
  69          */
  70         getLoggers(): { [name: string]: Logger };
  71
  72         /**
  73          * A .default property for ES6 default import compatibility
  74          */
  75         default: RootLogger;
  76     }
  77
  78     interface Logger {
  79         /**
  80          * Available log levels.
  81          */
  82         readonly levels: LogLevel;
  83
  84         /**
  85          * Plugin API entry point. This will be called for each enabled method each time the level is set
  86          * (including initially), and should return a MethodFactory to be used for the given log method, at the given level,
  87          * for a logger with the given name. If you'd like to retain all the reliability and features of loglevel, it's
  88          * recommended that this wraps the initially provided value of log.methodFactory
  89          */
  90         methodFactory: MethodFactory;
  91
  92         /**
  93          * Output trace message to console.
  94          * This will also include a full stack trace
  95          *
  96          * @param msg any data to log to the console
  97          */
  98         trace(...msg: any[]): void;
  99
 100         /**
 101          * Output debug message to console including appropriate icons
 102          *
 103          * @param msg any data to log to the console
 104          */
 105         debug(...msg: any[]): void;
 106
 107         /**
 108          * Output debug message to console including appropriate icons
 109          *
 110          * @param msg any data to log to the console
 111          */
 112         log(...msg: any[]): void;
 113
 114         /**
 115          * Output info message to console including appropriate icons
 116          *
 117          * @param msg any data to log to the console
 118          */
 119         info(...msg: any[]): void;
 120
 121         /**
 122          * Output warn message to console including appropriate icons
 123          *
 124          * @param msg any data to log to the console
 125          */
 126         warn(...msg: any[]): void;
 127
 128         /**
 129          * Output error message to console including appropriate icons
 130          *
 131          * @param msg any data to log to the console
 132          */
 133         error(...msg: any[]): void;
 134
 135         /**
 136          * This disables all logging below the given level, so that after a log.setLevel("warn") call log.warn("something")
 137          * or log.error("something") will output messages, but log.info("something") will not.
 138          *
 139          * @param level as a string, like 'error' (case-insensitive) or as a number from 0 to 5 (or as log.levels. values)
 140          * @param persist Where possible the log level will be persisted. LocalStorage will be used if available, falling
 141          *     back to cookies if not. If neither is available in the current environment (i.e. in Node), or if you pass
 142          *     false as the optional 'persist' second argument, persistence will be skipped.
 143          */
 144         setLevel(level: LogLevelDesc, persist?: boolean): void;
 145
 146         /**
 147          * Returns the current logging level, as a value from LogLevel.
 148          * It's very unlikely you'll need to use this for normal application logging; it's provided partly to help plugin
 149          * development, and partly to let you optimize logging code as below, where debug data is only generated if the
 150          * level is set such that it'll actually be logged. This probably doesn't affect you, unless you've run profiling
 151          * on your code and you have hard numbers telling you that your log data generation is a real performance problem.
 152          */
 153         getLevel(): LogLevel[keyof LogLevel];
 154
 155         /**
 156          * This sets the current log level only if one has not been persisted and can’t be loaded. This is useful when
 157          * initializing scripts; if a developer or user has previously called setLevel(), this won’t alter their settings.
 158          * For example, your application might set the log level to error in a production environment, but when debugging
 159          * an issue, you might call setLevel("trace") on the console to see all the logs. If that error setting was set
 160          * using setDefaultLevel(), it will still say as trace on subsequent page loads and refreshes instead of resetting
 161          * to error.
 162          *
 163          * The level argument takes is the same values that you might pass to setLevel(). Levels set using
 164          * setDefaultLevel() never persist to subsequent page loads.
 165          *
 166          * @param level as a string, like 'error' (case-insensitive) or as a number from 0 to 5 (or as log.levels. values)
 167          */
 168         setDefaultLevel(level: LogLevelDesc): void;
 169
 170         /**
 171          * This enables all log messages, and is equivalent to log.setLevel("trace").
 172          *
 173          * @param persist Where possible the log level will be persisted. LocalStorage will be used if available, falling
 174          *     back to cookies if not. If neither is available in the current environment (i.e. in Node), or if you pass
 175          *     false as the optional 'persist' second argument, persistence will be skipped.
 176          */
 177         enableAll(persist?: boolean): void;
 178
 179         /**
 180          * This disables all log messages, and is equivalent to log.setLevel("silent").
 181          *
 182          * @param persist Where possible the log level will be persisted. LocalStorage will be used if available, falling
 183          *     back to cookies if not. If neither is available in the current environment (i.e. in Node), or if you pass
 184          *     false as the optional 'persist' second argument, persistence will be skipped.
 185          */
 186         disableAll(persist?: boolean): void;
 187     }
 188 }