nightingale-logger 14.2.1 → 16.0.0

package/dist/index-browser.es.js

@@ -1,26 +1,22 @@
-import _extends from '@babel/runtime/helpers/esm/extends';
 import { Level } from 'nightingale-levels';
 export { Level } from 'nightingale-levels';
 
-var globalOrWindow = typeof global !== 'undefined' ? global : window;
+const globalOrWindow = typeof globalThis !== "undefined" ? globalThis : globalThis;
 if (!globalOrWindow.__NIGHTINGALE_GET_CONFIG_FOR_LOGGER) {
-  globalOrWindow.__NIGHTINGALE_GET_CONFIG_FOR_LOGGER = function () {
-    return {
-      handlers: [],
-      processors: []
-    };
-  };
+  globalOrWindow.__NIGHTINGALE_GET_CONFIG_FOR_LOGGER = () => ({
+    handlers: [],
+    processors: []
+  });
 }
 if (!globalOrWindow.__NIGHTINGALE_GET_CONFIG_FOR_LOGGER_RECORD) {
-  globalOrWindow.__NIGHTINGALE_GET_CONFIG_FOR_LOGGER_RECORD = function (key, level) {
-    var _globalOrWindow$__NIG = globalOrWindow.__NIGHTINGALE_GET_CONFIG_FOR_LOGGER(key),
-      handlers = _globalOrWindow$__NIG.handlers,
-      processors = _globalOrWindow$__NIG.processors;
+  globalOrWindow.__NIGHTINGALE_GET_CONFIG_FOR_LOGGER_RECORD = (key, level) => {
+    const {
+      handlers,
+      processors
+    } = globalOrWindow.__NIGHTINGALE_GET_CONFIG_FOR_LOGGER(key);
     return {
-      handlers: handlers.filter(function (handler) {
-        return level >= handler.minLevel && (!handler.isHandling || handler.isHandling(level, key));
-      }),
-      processors: processors
+      handlers: handlers.filter(handler => level >= handler.minLevel && (!handler.isHandling || handler.isHandling(level, key))),
+      processors
     };
   };
 }
@@ -35,37 +31,36 @@ function isError(messageOrError) {
  * Interface that allows you to log records.
  * This records are treated by handlers
  */
-var Logger = /*#__PURE__*/function () {
+class Logger {
   /**
    * Create a new Logger
    *
    * @param {string} key
    * @param {string} [displayName]
    */
-  function Logger(key, displayName) {
+  constructor(key, displayName) {
     this.key = key;
     this.displayName = displayName;
-    if (process.env.NODE_ENV !== 'production' && key.includes('.')) {
-      throw new Error("nightingale: `.` in key is no longer supported, use `:` instead (key: " + key + ")");
+    if (process.env.NODE_ENV !== "production" && key.includes(".")) {
+      throw new Error(`nightingale: \`.\` in key is no longer supported, use \`:\` instead (key: ${key})`);
     }
   }
 
   /** @private */
-  var _proto = Logger.prototype;
-  _proto.getHandlersAndProcessors = function getHandlersAndProcessors(recordLevel) {
+  getHandlersAndProcessors(recordLevel) {
     return getConfigForLoggerRecord(this.key, recordLevel);
   }
 
-  /** @private */;
-  _proto.getConfig = function getConfig() {
+  /** @private */
+  getConfig() {
     return globalOrWindow.__NIGHTINGALE_GET_CONFIG_FOR_LOGGER(this.key);
   }
 
   /**
    * Create a child logger
-   */;
-  _proto.child = function child(childSuffixKey, childDisplayName) {
-    return new Logger(this.key + ":" + childSuffixKey, childDisplayName);
+   */
+  child(childSuffixKey, childDisplayName) {
+    return new Logger(`${this.key}:${childSuffixKey}`, childDisplayName);
   }
 
   /**
@@ -84,17 +79,17 @@ var Logger = /*#__PURE__*/function () {
    * }
    * ```
    *
-   */;
-  _proto.context = function context(_context) {
-    var logger = new Logger(this.key);
-    logger.setContext(_context);
+   */
+  context(context) {
+    const logger = new Logger(this.key);
+    logger.setContext(context);
     return logger;
   }
 
   /**
    * Get the context of this logger
-   */;
-  _proto.getContextObject = function getContextObject() {
+   */
+  getContextObject() {
     return this.contextObject;
   }
 
@@ -102,17 +97,17 @@ var Logger = /*#__PURE__*/function () {
    * Set the context of this logger
    *
    * @param {Object} context
-   */;
-  _proto.setContext = function setContext(context) {
+   */
+  setContext(context) {
     this.contextObject = context;
   }
 
   /**
    * Extends existing context of this logger
-   */;
-  _proto.extendsContext = function extendsContext(extendedContext) {
+   */
+  extendsContext(extendedContext) {
     if (this.contextObject === undefined) {
-      throw new Error('Cannot extends context that does not exists. Use setContext(context) first.');
+      throw new Error("Cannot extends context that does not exists. Use setContext(context) first.");
     }
     Object.assign(this.contextObject, extendedContext);
   }
@@ -121,15 +116,16 @@ var Logger = /*#__PURE__*/function () {
    * Handle a record
    *
    * Use this only if you know what you are doing.
-   */;
-  _proto.addRecord = function addRecord(record) {
-    var _this$getHandlersAndP = this.getHandlersAndProcessors(record.level),
-      handlers = _this$getHandlersAndP.handlers,
-      processors = _this$getHandlersAndP.processors;
+   */
+  addRecord(record) {
+    const {
+      handlers,
+      processors
+    } = this.getHandlersAndProcessors(record.level);
     if (handlers.length === 0) {
       if (record.level > Level.ERROR) {
         // eslint-disable-next-line no-console
-        console.log('[nightingale] no logger for > error level.', {
+        console.log("[nightingale] no logger for > error level.", {
           key: record.key,
           message: record.message
         });
@@ -137,86 +133,83 @@ var Logger = /*#__PURE__*/function () {
       return;
     }
     if (processors) {
-      processors.forEach(function (process) {
+      processors.forEach(process => {
         process(record, record.context);
       });
     }
-    handlers.some(function (handler) {
-      return handler.handle(record) === false;
-    });
+    handlers.some(handler => handler.handle(record) === false);
   }
 
   /**
    * Log a message
-   */;
-  _proto.log = function log(messageOrError, metadata, level, options) {
-    if (level === void 0) {
-      level = Level.INFO;
-    }
-    var isMessageError = isError(messageOrError);
-    var message = isMessageError ? messageOrError.name + ": " + messageOrError.message : messageOrError;
-    var extendedMetadata = isMessageError && !(metadata && Object.prototype.hasOwnProperty.call(metadata, 'error')) ? _extends({}, metadata, {
+   */
+  log(messageOrError, metadata, level = Level.INFO, options) {
+    const isMessageError = isError(messageOrError);
+    const message = isMessageError ? `${messageOrError.name}: ${messageOrError.message}` : messageOrError;
+    const extendedMetadata = isMessageError && !(metadata && Object.hasOwn(metadata, "error")) ? {
+      ...metadata,
       error: messageOrError
-    }) : metadata;
-    var context = extendedMetadata == null ? void 0 : extendedMetadata.context;
+    } : metadata;
+    const context = extendedMetadata?.context;
     if (extendedMetadata) {
       delete extendedMetadata.context;
     }
-    var record = _extends({
-      level: level,
+    const record = {
+      level,
       key: this.key,
       displayName: this.displayName,
       datetime: new Date(),
-      message: message,
+      message,
       context: context || this.contextObject,
       metadata: extendedMetadata,
-      extra: {}
-    }, options);
+      extra: {},
+      ...options
+    };
     this.addRecord(record);
   }
 
   /**
    * Log a trace message
-   */;
-  _proto.trace = function trace(messageOrError, metadata, metadataStyles) {
+   */
+  trace(messageOrError, metadata, metadataStyles) {
     this.log(messageOrError, metadata, Level.TRACE, {
-      metadataStyles: metadataStyles
+      metadataStyles
     });
   }
 
   /**
    * Log a debug message
-   */;
-  _proto.debug = function debug(messageOrError, metadata, metadataStyles) {
+   */
+  debug(messageOrError, metadata, metadataStyles) {
     this.log(messageOrError, metadata, Level.DEBUG, {
-      metadataStyles: metadataStyles
+      metadataStyles
     });
   }
 
   /**
    * Notice an info message
-   */;
-  _proto.notice = function notice(messageOrError, metadata, metadataStyles) {
+   */
+  notice(messageOrError, metadata, metadataStyles) {
     this.log(messageOrError, metadata, Level.NOTICE, {
-      metadataStyles: metadataStyles
+      metadataStyles
     });
   }
 
   /**
    * Log an info message
-   */;
-  _proto.info = function info(messageOrError, metadata, metadataStyles) {
+   */
+  info(messageOrError, metadata, metadataStyles) {
     this.log(messageOrError, metadata, Level.INFO, {
-      metadataStyles: metadataStyles
+      metadataStyles
     });
   }
 
   /**
    * Log a warn message
-   */;
-  _proto.warn = function warn(messageOrError, metadata, metadataStyles) {
+   */
+  warn(messageOrError, metadata, metadataStyles) {
     this.log(messageOrError, metadata, Level.WARN, {
-      metadataStyles: metadataStyles
+      metadataStyles
     });
   }
 
@@ -232,19 +225,19 @@ var Logger = /*#__PURE__*/function () {
    *   logger.error('caught error', { error });
    * }
    * ```
-   */;
-  _proto.error = function error(messageOrError, metadata, metadataStyles) {
+   */
+  error(messageOrError, metadata, metadataStyles) {
     this.log(messageOrError, metadata, Level.ERROR, {
-      metadataStyles: metadataStyles
+      metadataStyles
     });
   }
 
   /**
    * Log an critical message
-   */;
-  _proto.critical = function critical(messageOrError, metadata, metadataStyles) {
+   */
+  critical(messageOrError, metadata, metadataStyles) {
     this.log(messageOrError, metadata, Level.CRITICAL, {
-      metadataStyles: metadataStyles
+      metadataStyles
     });
   }
 
@@ -260,109 +253,106 @@ var Logger = /*#__PURE__*/function () {
    *   logger.error('caught error', { error });
    *   process.exit(1);
    * }
-   */;
-  _proto.fatal = function fatal(messageOrError, metadata, metadataStyles) {
+   */
+  fatal(messageOrError, metadata, metadataStyles) {
     this.log(messageOrError, metadata, Level.FATAL, {
-      metadataStyles: metadataStyles
+      metadataStyles
     });
   }
 
   /**
    * Log an alert message
-   */;
-  _proto.alert = function alert(messageOrError, metadata, metadataStyles) {
+   */
+  alert(messageOrError, metadata, metadataStyles) {
     this.log(messageOrError, metadata, Level.ALERT, {
-      metadataStyles: metadataStyles
+      metadataStyles
     });
   }
 
   /**
    * Log an inspected value
-   */;
-  _proto.inspectValue = function inspectValue() {
-    throw new Error('Not supported for the browser. Prefer `debugger;`');
+   */
+  inspectValue() {
+    throw new Error("Not supported for the browser. Prefer `debugger;`");
   }
 
   /**
    * Log a debugged var
-   */;
-  _proto.inspectVar = function inspectVar() {
-    throw new Error('Not supported for the browser. Prefer `debugger;`');
+   */
+  inspectVar() {
+    throw new Error("Not supported for the browser. Prefer `debugger;`");
   }
 
   /**
    * Alias for infoSuccess
-   */;
-  _proto.success = function success(message, metadata, metadataStyles) {
+   */
+  success(message, metadata, metadataStyles) {
     this.infoSuccess(message, metadata, metadataStyles);
   }
 
   /**
    * Log an info success message
-   */;
-  _proto.infoSuccess = function infoSuccess(message, metadata, metadataStyles) {
+   */
+  infoSuccess(message, metadata, metadataStyles) {
     this.log(message, metadata, Level.INFO, {
-      metadataStyles: metadataStyles,
-      symbol: '✔',
-      styles: ['green', 'bold']
+      metadataStyles,
+      symbol: "✔",
+      styles: ["green", "bold"]
     });
   }
 
   /**
    * Log an debug success message
-   */;
-  _proto.debugSuccess = function debugSuccess(message, metadata, metadataStyles) {
+   */
+  debugSuccess(message, metadata, metadataStyles) {
     this.log(message, metadata, Level.DEBUG, {
-      metadataStyles: metadataStyles,
-      symbol: '✔',
-      styles: ['green']
+      metadataStyles,
+      symbol: "✔",
+      styles: ["green"]
     });
   }
 
   /**
    * Alias for infoFail
-   */;
-  _proto.fail = function fail(messageOrError, metadata, metadataStyles) {
+   */
+  fail(messageOrError, metadata, metadataStyles) {
     this.infoFail(messageOrError, metadata, metadataStyles);
   }
 
   /**
    * Log an info fail message
-   */;
-  _proto.infoFail = function infoFail(messageOrError, metadata, metadataStyles) {
+   */
+  infoFail(messageOrError, metadata, metadataStyles) {
     this.log(messageOrError, metadata, Level.INFO, {
-      metadataStyles: metadataStyles,
-      symbol: '✖',
-      styles: ['red', 'bold']
+      metadataStyles,
+      symbol: "✖",
+      styles: ["red", "bold"]
     });
   }
 
   /**
    * Log an debug fail message
-   */;
-  _proto.debugFail = function debugFail(messageOrError, metadata, metadataStyles) {
+   */
+  debugFail(messageOrError, metadata, metadataStyles) {
     this.log(messageOrError, metadata, Level.DEBUG, {
-      metadataStyles: metadataStyles,
-      symbol: '✖',
-      styles: ['red']
+      metadataStyles,
+      symbol: "✖",
+      styles: ["red"]
     });
   }
 
   /**
    * @returns {number} time to pass to timeEnd
-   */;
-  _proto.time = function time(message, metadata, metadataStyles, level) {
-    if (level === void 0) {
-      level = Level.DEBUG;
-    }
+   */
+  time(message, metadata, metadataStyles, level = Level.DEBUG) {
     if (message) {
       this.log(message, metadata, level, {
-        metadataStyles: metadataStyles
+        metadataStyles
       });
     }
     return Date.now();
-  };
-  _proto.infoTime = function infoTime(message, metadata, metadataStyles) {
+  }
+  infoTime(message, metadata, metadataStyles) {
     return this.time(message, metadata, metadataStyles, Level.INFO);
   }
 
@@ -371,44 +361,42 @@ var Logger = /*#__PURE__*/function () {
    * was called and when the respective time method
    * was called, then logs out the difference
    * and deletes the original record
-   */;
-  _proto.timeEnd = function timeEnd(startTime, message, metadata, metadataStyles, level, options) {
-    if (level === void 0) {
-      level = Level.DEBUG;
-    }
-    var now = Date.now(),
-      seconds;
-    var diffTime = now - startTime;
-    var readableTime;
+   */
+  timeEnd(startTime, message, metadata, metadataStyles, level = Level.DEBUG, options) {
+    const now = Date.now();
+    const diffTime = now - startTime;
+    let readableTime;
     if (diffTime < 1000) {
-      readableTime = diffTime + "ms";
+      readableTime = `${diffTime}ms`;
     } else {
-      seconds = diffTime > 1000 ? Math.floor(diffTime / 1000) : 0;
-      readableTime = "" + (seconds ? seconds + "s and " : '') + (diffTime - seconds * 1000) + "ms";
+      const seconds = diffTime > 1000 ? Math.floor(diffTime / 1000) : 0;
+      readableTime = `${seconds ? `${seconds}s and ` : ""}${diffTime - seconds * 1000}ms`;
     }
-    var extendedMetadata = _extends({}, metadata, {
-      readableTime: readableTime,
+    const extendedMetadata = {
+      ...metadata,
+      readableTime,
       timeMs: diffTime
+    };
+    this.log(message, extendedMetadata, level, {
+      ...options,
+      metadataStyles
     });
-    this.log(message, extendedMetadata, level, _extends({}, options, {
-      metadataStyles: metadataStyles
-    }));
   }
 
   /**
    * Like timeEnd, but with INFO level
-   */;
-  _proto.infoTimeEnd = function infoTimeEnd(time, message, metadata, metadataStyles) {
+   */
+  infoTimeEnd(time, message, metadata, metadataStyles) {
     this.timeEnd(time, message, metadata, metadataStyles, Level.INFO);
   }
 
   /**
    * Like timeEnd, but with INFO level
-   */;
-  _proto.infoSuccessTimeEnd = function infoSuccessTimeEnd(time, message, metadata, metadataStyles) {
+   */
+  infoSuccessTimeEnd(time, message, metadata, metadataStyles) {
     this.timeEnd(time, message, metadata, metadataStyles, Level.INFO, {
-      symbol: '✔',
-      styles: ['green', 'bold']
+      symbol: "✔",
+      styles: ["green", "bold"]
     });
   }
 
@@ -425,13 +413,14 @@ var Logger = /*#__PURE__*/function () {
    * }
    * ```
    *
-   */;
-  _proto.enter = function enter(fn, metadata, metadataStyles) {
-    var extendedMetadata = _extends({}, metadata, {
+   */
+  enter(fn, metadata, metadataStyles) {
+    const extendedMetadata = {
+      ...metadata,
       functionName: fn.name
-    });
-    this.log('enter', extendedMetadata, Level.TRACE, {
-      metadataStyles: metadataStyles
+    };
+    this.log("enter", extendedMetadata, Level.TRACE, {
+      metadataStyles
     });
   }
 
@@ -448,13 +437,14 @@ var Logger = /*#__PURE__*/function () {
    *   }
    * }
    * ```
-   */;
-  _proto.exit = function exit(fn, metadata, metadataStyles) {
-    var extendedMetadata = _extends({}, metadata, {
+   */
+  exit(fn, metadata, metadataStyles) {
+    const extendedMetadata = {
+      ...metadata,
       functionName: fn.name
-    });
-    this.log('exit', extendedMetadata, Level.TRACE, {
-      metadataStyles: metadataStyles
+    };
+    this.log("exit", extendedMetadata, Level.TRACE, {
+      metadataStyles
     });
   }
 
@@ -472,15 +462,16 @@ var Logger = /*#__PURE__*/function () {
    *   }
    * }
    * ```
-   */;
-  _proto.wrap = function wrap(fn, option1, option2, callback) {
-    var metadata;
-    var metadataStyles;
-    if (typeof option1 === 'function') {
+   */
+
+  wrap(fn, option1, option2, callback) {
+    let metadata;
+    let metadataStyles;
+    if (typeof option1 === "function") {
       callback = option1;
     } else {
       metadata = option1;
-      if (typeof option2 === 'function') {
+      if (typeof option2 === "function") {
         callback = option2;
       } else {
         metadataStyles = option2;
@@ -489,9 +480,8 @@ var Logger = /*#__PURE__*/function () {
     this.enter(fn, metadata, metadataStyles);
     callback();
     this.exit(fn);
-  };
-  return Logger;
-}();
+  }
+}
 
 export { Logger };
 //# sourceMappingURL=index-browser.es.js.map