source: trip-planner-front/node_modules/loglevel/index.d.ts@ eed0bf8

Last change on this file since eed0bf8 was 6a3a178, checked in by Ema <ema_spirova@…>, 3 years ago

initial commit

  • Property mode set to 100644
File size: 8.2 KB
Line 
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
7declare const log: log.RootLogger;
8export = log;
9
10declare 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}
Note: See TracBrowser for help on using the repository browser.