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