index.d.ts 8.2 KB

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