@foxford/logger 1.0.1 → 1.1.0

package/index.d.ts

@@ -1,9 +1,161 @@
-// Generated by dts-bundle-generator v8.0.1
-
-import { Logger as LoglevelLogger, RootLogger } from 'loglevel';
-
-export type Id = `${string}-${string}-${string}-${string}-${string}`;
-export interface HierarchicalLogger extends LoglevelLogger {
+interface LogLevel {
+	TRACE: 0;
+	DEBUG: 1;
+	INFO: 2;
+	WARN: 3;
+	ERROR: 4;
+	SILENT: 5;
+}
+type LogLevelNumbers = LogLevel[keyof LogLevel];
+type LogLevelDesc = LogLevelNumbers | LogLevelNames | "silent" | keyof LogLevel;
+type LogLevelNames = "trace" | "debug" | "info" | "warn" | "error";
+type LoggingMethod = (...message: any[]) => void;
+type MethodFactory = (methodName: LogLevelNames, 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 resets the current log level to the default level (or `warn` if no explicit default was set) and clears
+	 * the persisted level if one was previously persisted.
+	 */
+	resetLevel(): 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;
+	/**
+	 * Rebuild the logging methods on this logger and its child loggers.
+	 *
+	 * This is mostly intended for plugin developers, but can be useful if you update a logger's `methodFactory` or
+	 * if you want to apply the root logger’s level to any *pre-existing* child loggers (this updates the level on
+	 * any child logger that hasn't used `setLevel()` or `setDefaultLevel()`).
+	 */
+	rebuild(): void;
+}
+type Id = `${string}-${string}-${string}-${string}-${string}`;
+export interface HierarchicalLogger extends Logger {
 	id: Id;
 	parent: HierarchicalLogger | null;
 	debugEnabled: boolean;
@@ -15,25 +167,32 @@ export interface HierarchicalLogger extends LoglevelLogger {
 	isDebugEnabled(): boolean;
 	getDebugPattern(): string | null;
 }
+declare global {
+	interface Window {
+		loggerCache: Map<Id, HierarchicalLogger>;
+		previousLevels: Map<Id, LogLevelDesc>;
+	}
+}
 /**
  * Плагин иерархического логгера для loglevel
  */
 export declare const hierarchicalPlugin: {
 	apply(rootLogger: RootLogger): void;
 };
-export type FormatFunction = (level: string, name: string, timestamp: Date) => string | string[];
-export interface PrefixOptions {
+type FormatFunction = (level: string, name: string, timestamp: Date) => string | string[];
+interface PrefixOptions {
 	format: FormatFunction;
 }
 export declare const prefixPlugin: {
-	apply(rootLogger: LoglevelLogger, options?: Partial<PrefixOptions>): void;
+	apply(rootLogger: Logger, options?: Partial<PrefixOptions>): void;
 };
-export interface Logger extends RootLogger {
+interface Logger$1 extends RootLogger {
 	getLogger(name: string): HierarchicalLogger;
 }
-declare const extendedLog: Logger;
+declare const extendedLog: Logger$1;
 
 export {
+	Logger$1 as Logger,
 	extendedLog as log,
 };