@percy/logger - npm Package Compare versions

Comparing version 1.0.0-beta.42 to 1.0.0-beta.43

dist/bundle.js

@@ -1,354 +0,96 @@
-(function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-  typeof define === 'function' && define.amd ? define(['exports'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.PercyLogger = {}));
-}(this, (function (exports) { 'use strict';
+(function() {
+  (function (exports) {
+    'use strict';
 
-  const process = (typeof globalThis !== "undefined" && globalThis.process) || {};
-  process.env = process.env || {};
-  process.env.__PERCY_BROWSERIFIED__ = true;
+    const process = (typeof globalThis !== "undefined" && globalThis.process) || {};
+    process.env = process.env || {};
+    process.env.__PERCY_BROWSERIFIED__ = true;
 
-  function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
-    try {
-      var info = gen[key](arg);
-      var value = info.value;
-    } catch (error) {
-      reject(error);
-      return;
-    }
+    const {
+      assign,
+      entries
+    } = Object; // matches ansi escape sequences
 
-    if (info.done) {
-      resolve(value);
-    } else {
-      Promise.resolve(value).then(_next, _throw);
-    }
-  }
+    const ANSI_REG = new RegExp('[\\u001B\\u009B][[\\]()#;?]*((?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)' + '|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))', 'g'); // color names by ansi escape code
 
-  function _asyncToGenerator(fn) {
-    return function () {
-      var self = this,
-          args = arguments;
-      return new Promise(function (resolve, reject) {
-        var gen = fn.apply(self, args);
+    const ANSI_COLORS = {
+      '31m': 'red',
+      '33m': 'yellow',
+      '34m': 'blue',
+      '35m': 'magenta',
+      '90m': 'grey'
+    }; // colorize each line of a string using an ansi escape sequence
 
-        function _next(value) {
-          asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
-        }
+    const LINE_REG = /^.*$/gm;
 
-        function _throw(err) {
-          asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
-        }
+    function colorize(code, str) {
+      return str.replace(LINE_REG, line => `\u001b[${code}${line}\u001b[39m`);
+    } // map ansi colors to bound colorize functions
 
-        _next(undefined);
-      });
-    };
-  }
 
-  function _classCallCheck(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-      throw new TypeError("Cannot call a class as a function");
-    }
-  }
-
-  function _defineProperties(target, props) {
-    for (var i = 0; i < props.length; i++) {
-      var descriptor = props[i];
-      descriptor.enumerable = descriptor.enumerable || false;
-      descriptor.configurable = true;
-      if ("value" in descriptor) descriptor.writable = true;
-      Object.defineProperty(target, descriptor.key, descriptor);
-    }
-  }
-
-  function _createClass(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties(Constructor, staticProps);
-    return Constructor;
-  }
-
-  function _defineProperty(obj, key, value) {
-    if (key in obj) {
-      Object.defineProperty(obj, key, {
-        value: value,
-        enumerable: true,
-        configurable: true,
-        writable: true
+    const colors = entries(ANSI_COLORS).reduce((colors, [code, name]) => {
+      return assign(colors, {
+        [name]: colorize.bind(null, code)
       });
-    } else {
-      obj[key] = value;
-    }
+    }, {});
 
-    return obj;
-  }
-
-  function ownKeys(object, enumerableOnly) {
-    var keys = Object.keys(object);
-
-    if (Object.getOwnPropertySymbols) {
-      var symbols = Object.getOwnPropertySymbols(object);
-      if (enumerableOnly) symbols = symbols.filter(function (sym) {
-        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-      });
-      keys.push.apply(keys, symbols);
-    }
-
-    return keys;
-  }
-
-  function _objectSpread2(target) {
-    for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i] != null ? arguments[i] : {};
-
-      if (i % 2) {
-        ownKeys(Object(source), true).forEach(function (key) {
-          _defineProperty(target, key, source[key]);
+    function _defineProperty(obj, key, value) {
+      if (key in obj) {
+        Object.defineProperty(obj, key, {
+          value: value,
+          enumerable: true,
+          configurable: true,
+          writable: true
         });
-      } else if (Object.getOwnPropertyDescriptors) {
-        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
       } else {
-        ownKeys(Object(source)).forEach(function (key) {
-          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-        });
+        obj[key] = value;
       }
-    }
 
-    return target;
-  }
-
-  function _inherits(subClass, superClass) {
-    if (typeof superClass !== "function" && superClass !== null) {
-      throw new TypeError("Super expression must either be null or a function");
+      return obj;
     }
 
-    subClass.prototype = Object.create(superClass && superClass.prototype, {
-      constructor: {
-        value: subClass,
-        writable: true,
-        configurable: true
-      }
-    });
-    if (superClass) _setPrototypeOf(subClass, superClass);
-  }
+    const URL_REGEXP = /\bhttps?:\/\/[^\s/$.?#].[^\s]*\b/i;
+    const LOG_LEVELS = {
+      debug: 0,
+      info: 1,
+      warn: 2,
+      error: 3
+    }; // A PercyLogger instance retains logs in-memory for quick lookups while also writing log
+    // messages to stdout and stderr depending on the log level and debug string.
 
-  function _getPrototypeOf(o) {
-    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
-      return o.__proto__ || Object.getPrototypeOf(o);
-    };
-    return _getPrototypeOf(o);
-  }
+    class PercyLogger {
+      // default log level
+      // namespace regular expressions used to determine which debug logs to write
+      // in-memory store for logs and meta info
+      // track deprecations to limit noisy logging
+      // static vars can be overriden for testing
+      // Handles setting env var values and returns a singleton
+      constructor() {
+        _defineProperty(this, "level", 'info');
 
-  function _setPrototypeOf(o, p) {
-    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
-      o.__proto__ = p;
-      return o;
-    };
+        _defineProperty(this, "namespaces", {
+          include: [/^.*?$/],
+          exclude: []
+        });
 
-    return _setPrototypeOf(o, p);
-  }
+        _defineProperty(this, "messages", new Set());
 
-  function _isNativeReflectConstruct() {
-    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
-    if (Reflect.construct.sham) return false;
-    if (typeof Proxy === "function") return true;
+        _defineProperty(this, "deprecations", new Set());
 
-    try {
-      Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
-      return true;
-    } catch (e) {
-      return false;
-    }
-  }
+        let {
+          instance = this
+        } = this.constructor;
 
-  function _assertThisInitialized(self) {
-    if (self === void 0) {
-      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-    }
+        if (process.env.PERCY_DEBUG) {
+          instance.debug(process.env.PERCY_DEBUG);
+        } else if (process.env.PERCY_LOGLEVEL) {
+          instance.loglevel(process.env.PERCY_LOGLEVEL);
+        }
 
-    return self;
-  }
+        this.constructor.instance = instance;
+        return instance;
+      } // Change log level at any time or return the current log level
 
-  function _possibleConstructorReturn(self, call) {
-    if (call && (typeof call === "object" || typeof call === "function")) {
-      return call;
-    }
 
-    return _assertThisInitialized(self);
-  }
-
-  function _createSuper(Derived) {
-    var hasNativeReflectConstruct = _isNativeReflectConstruct();
-
-    return function _createSuperInternal() {
-      var Super = _getPrototypeOf(Derived),
-          result;
-
-      if (hasNativeReflectConstruct) {
-        var NewTarget = _getPrototypeOf(this).constructor;
-
-        result = Reflect.construct(Super, arguments, NewTarget);
-      } else {
-        result = Super.apply(this, arguments);
-      }
-
-      return _possibleConstructorReturn(this, result);
-    };
-  }
-
-  function _slicedToArray(arr, i) {
-    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
-  }
-
-  function _toConsumableArray(arr) {
-    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
-  }
-
-  function _arrayWithoutHoles(arr) {
-    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
-  }
-
-  function _arrayWithHoles(arr) {
-    if (Array.isArray(arr)) return arr;
-  }
-
-  function _iterableToArray(iter) {
-    if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
-  }
-
-  function _iterableToArrayLimit(arr, i) {
-    if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
-    var _arr = [];
-    var _n = true;
-    var _d = false;
-    var _e = undefined;
-
-    try {
-      for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
-        _arr.push(_s.value);
-
-        if (i && _arr.length === i) break;
-      }
-    } catch (err) {
-      _d = true;
-      _e = err;
-    } finally {
-      try {
-        if (!_n && _i["return"] != null) _i["return"]();
-      } finally {
-        if (_d) throw _e;
-      }
-    }
-
-    return _arr;
-  }
-
-  function _unsupportedIterableToArray(o, minLen) {
-    if (!o) return;
-    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-    var n = Object.prototype.toString.call(o).slice(8, -1);
-    if (n === "Object" && o.constructor) n = o.constructor.name;
-    if (n === "Map" || n === "Set") return Array.from(o);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
-  }
-
-  function _arrayLikeToArray(arr, len) {
-    if (len == null || len > arr.length) len = arr.length;
-
-    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
-
-    return arr2;
-  }
-
-  function _nonIterableSpread() {
-    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-  }
-
-  function _nonIterableRest() {
-    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-  }
-
-  var assign = Object.assign,
-      entries = Object.entries; // matches ansi escape sequences
-
-  var ANSI_REG = new RegExp("[\\u001B\\u009B][[\\]()#;?]*((?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)" + '|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))', 'g'); // color names by ansi escape code
-
-  var ANSI_COLORS = {
-    '31m': 'red',
-    '33m': 'yellow',
-    '34m': 'blue',
-    '35m': 'magenta',
-    '90m': 'grey'
-  }; // colorize each line of a string using an ansi escape sequence
-
-  var LINE_REG = /^.*$/gm;
-
-  function colorize(code, str) {
-    return str.replace(LINE_REG, function (line) {
-      return "\x1B[".concat(code).concat(line, "\x1B[39m");
-    });
-  } // map ansi colors to bound colorize functions
-
-
-  var colors = entries(ANSI_COLORS).reduce(function (colors, _ref) {
-    var _ref2 = _slicedToArray(_ref, 2),
-        code = _ref2[0],
-        name = _ref2[1];
-
-    return assign(colors, _defineProperty({}, name, colorize.bind(null, code)));
-  }, {}); // adds an event listener and returns a teardown function
-
-  function listen(subject, event, handler, teardown) {
-    subject.addEventListener(event, handler);
-    return function () {
-      subject.removeEventListener(event, handler);
-      return teardown === null || teardown === void 0 ? void 0 : teardown();
-    };
-  }
-
-  var URL_REGEXP = /\bhttps?:\/\/[^\s/$.?#].[^\s]*\b/i;
-  var LOG_LEVELS = {
-    debug: 0,
-    info: 1,
-    warn: 2,
-    error: 3
-  }; // A PercyLogger instance retains logs in-memory for quick lookups while also writing log
-  // messages to stdout and stderr depending on the log level and debug string.
-
-  var PercyLogger = /*#__PURE__*/function () {
-    // default log level
-    // namespace regular expressions used to determine which debug logs to write
-    // in-memory store for logs and meta info
-    // track deprecations to limit noisy logging
-    // static vars can be overriden for testing
-    // Handles setting env var values and returns a singleton
-    function PercyLogger() {
-      _classCallCheck(this, PercyLogger);
-
-      _defineProperty(this, "level", 'info');
-
-      _defineProperty(this, "namespaces", {
-        include: [/^.*?$/],
-        exclude: []
-      });
-
-      _defineProperty(this, "messages", new Set());
-
-      _defineProperty(this, "deprecations", new Set());
-
-      var _this$constructor$ins = this.constructor.instance,
-          instance = _this$constructor$ins === void 0 ? this : _this$constructor$ins;
-
-      if (process.env.PERCY_DEBUG) {
-        instance.debug(process.env.PERCY_DEBUG);
-      } else if (process.env.PERCY_LOGLEVEL) {
-        instance.loglevel(process.env.PERCY_LOGLEVEL);
-      }
-
-      this.constructor.instance = instance;
-      return instance;
-    } // Change log level at any time or return the current log level
-
-
-    _createClass(PercyLogger, [{
-      key: "loglevel",
-      value: function loglevel(level) {
+      loglevel(level) {
         if (!level) return this.level;
@@ -359,5 +101,4 @@ this.level = level;
 
-    }, {
-      key: "debug",
-      value: function debug(namespaces) {
+
+      debug(namespaces) {
         if (this.namespaces.string === namespaces) return;
@@ -368,6 +109,4 @@ this.namespaces.string = namespaces;
         this.loglevel('debug');
-        this.namespaces = namespaces.reduce(function (namespaces, ns) {
-          ns = ns.replace(/:?\*/g, function (m) {
-            return m[0] === ':' ? ':?.*?' : '.*?';
-          });
+        this.namespaces = namespaces.reduce((namespaces, ns) => {
+          ns = ns.replace(/:?\*/g, m => m[0] === ':' ? ':?.*?' : '.*?');
 
@@ -388,10 +127,7 @@ if (ns[0] === '-') {
 
-    }, {
-      key: "group",
-      value: function group(name) {
-        var _this = this;
 
-        return Object.keys(LOG_LEVELS).reduce(function (group, level) {
-          return Object.assign(group, _defineProperty({}, level, _this.log.bind(_this, name, level)));
-        }, {
+      group(name) {
+        return Object.keys(LOG_LEVELS).reduce((group, level) => Object.assign(group, {
+          [level]: this.log.bind(this, name, level)
+        }), {
           deprecated: this.deprecated.bind(this, name),
@@ -402,20 +138,18 @@ shouldLog: this.shouldLog.bind(this, name)
 
-    }, {
-      key: "query",
-      value: function query(filter) {
+
+      query(filter) {
         return Array.from(this.messages).filter(filter);
       } // Formats messages before they are logged to stdio
 
-    }, {
-      key: "format",
-      value: function format(message, debug, level, elapsed) {
-        var label = 'percy';
-        var suffix = '';
 
+      format(message, debug, level, elapsed) {
+        let label = 'percy';
+        let suffix = '';
+
         if (this.level === 'debug') {
           // include debug info in the label
-          if (debug) label += ":".concat(debug); // include elapsed time since last log
+          if (debug) label += `:${debug}`; // include elapsed time since last log
 
           if (elapsed != null) {
-            suffix = ' ' + colors.grey("(".concat(elapsed, "ms)"));
+            suffix = ' ' + colors.grey(`(${elapsed}ms)`);
           }
@@ -437,26 +171,19 @@ }
 
-        return "[".concat(label, "] ").concat(message).concat(suffix);
+        return `[${label}] ${message}${suffix}`;
       } // Returns true or false if the level and debug group can write messages to stdio
 
-    }, {
-      key: "shouldLog",
-      value: function shouldLog(debug, level) {
-        return LOG_LEVELS[level] != null && LOG_LEVELS[level] >= LOG_LEVELS[this.level] && !this.namespaces.exclude.some(function (ns) {
-          return ns.test(debug);
-        }) && this.namespaces.include.some(function (ns) {
-          return ns.test(debug);
-        });
+
+      shouldLog(debug, level) {
+        return LOG_LEVELS[level] != null && LOG_LEVELS[level] >= LOG_LEVELS[this.level] && !this.namespaces.exclude.some(ns => ns.test(debug)) && this.namespaces.include.some(ns => ns.test(debug));
       } // Ensures that deprecation messages are not logged more than once
 
-    }, {
-      key: "deprecated",
-      value: function deprecated(debug, message, meta) {
+
+      deprecated(debug, message, meta) {
         if (this.deprecations.has(message)) return;
         this.deprecations.add(message);
-        this.log(debug, 'warn', "Warning: ".concat(message), meta);
+        this.log(debug, 'warn', `Warning: ${message}`, meta);
       } // Returns true if a socket is present and ready
 
-    }, {
-      key: "isRemote",
-      get: function get() {
+
+      get isRemote() {
         var _this$socket;
@@ -468,9 +195,7 @@
 
-    }, {
-      key: "log",
-      value: function log(debug, level, message) {
-        var meta = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+
+      log(debug, level, message, meta = {}) {
         // message might be an error object
-        var isError = typeof message !== 'string' && (level === 'error' || level === 'debug');
-        var error = isError && message; // if remote, send logs there
+        let isError = typeof message !== 'string' && (level === 'error' || level === 'debug');
+        let error = isError && message; // if remote, send logs there
 
@@ -484,5 +209,6 @@ if (this.isRemote) {
           return this.socket.send(JSON.stringify({
-            log: [debug, level, message, _objectSpread2({
-              remote: true
-            }, meta)]
+            log: [debug, level, message, {
+              remote: true,
+              ...meta
+            }]
           }));
@@ -494,9 +220,9 @@ } // ensure the message is a string
 
-        var timestamp = Date.now();
-        var entry = {
-          debug: debug,
-          level: level,
-          message: message,
-          meta: meta,
-          timestamp: timestamp
+        let timestamp = Date.now();
+        let entry = {
+          debug,
+          level,
+          message,
+          meta,
+          timestamp
         };
@@ -506,3 +232,3 @@ this.messages.add(entry); // maybe write the message to stdio
         if (this.shouldLog(debug, level)) {
-          var elapsed = timestamp - (this.lastlog || timestamp);
+          let elapsed = timestamp - (this.lastlog || timestamp);
           if (isError && this.level !== 'debug') message = error.toString();
@@ -514,264 +240,185 @@ this.write(level, this.format(message, debug, error ? 'error' : level, elapsed));
 
-    }, {
-      key: "write",
-      value: function write(level, message) {
-        var stdio = level === 'info' ? 'stdout' : 'stderr';
+
+      write(level, message) {
+        let stdio = level === 'info' ? 'stdout' : 'stderr';
         this.constructor[stdio].write(message + '\n');
       } // Opens a socket logging connection
 
-    }, {
-      key: "connect",
-      value: function connect(socket) {
-        var _this2 = this;
 
+      connect(socket) {
         // send logging environment info
-        var PERCY_DEBUG = process.env.PERCY_DEBUG;
-        var PERCY_LOGLEVEL = process.env.PERCY_LOGLEVEL || this.loglevel();
+        let PERCY_DEBUG = process.env.PERCY_DEBUG;
+        let PERCY_LOGLEVEL = process.env.PERCY_LOGLEVEL || this.loglevel();
         socket.send(JSON.stringify({
           env: {
-            PERCY_DEBUG: PERCY_DEBUG,
-            PERCY_LOGLEVEL: PERCY_LOGLEVEL
+            PERCY_DEBUG,
+            PERCY_LOGLEVEL
           }
-        })); // attach remote logging handler and return a cleanup function
+        })); // attach remote logging handler
 
-        return listen(socket, 'message', function (_ref) {
-          var data = _ref.data;
+        socket.onmessage = ({
+          data
+        }) => {
+          let {
+            log,
+            logAll
+          } = JSON.parse(data);
+          if (logAll) logAll.forEach(e => this.messages.add(e));
+          if (log) this.log(...log);
+        }; // return a cleanup function
 
-          var _JSON$parse = JSON.parse(data),
-              log = _JSON$parse.log,
-              logAll = _JSON$parse.logAll;
 
-          if (logAll) logAll.forEach(function (e) {
-            return _this2.messages.add(e);
-          });
-          if (log) _this2.log.apply(_this2, _toConsumableArray(log));
-        });
+        return () => {
+          socket.onmessage = null;
+        };
       } // Connects to a remote logger
 
-    }, {
-      key: "remote",
-      value: function () {
-        var _remote = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(socket) {
-          var _this3 = this;
 
-          var timeout,
-              err,
-              _args = arguments;
-          return regeneratorRuntime.wrap(function _callee$(_context) {
-            while (1) {
-              switch (_context.prev = _context.next) {
-                case 0:
-                  timeout = _args.length > 1 && _args[1] !== undefined ? _args[1] : 1000;
+      async remote(socket, timeout = 1000) {
+        if (this.isRemote) return;
+        this.socket = socket;
+        let err; // if not already connected, wait until the timeout
 
-                  if (!this.isRemote) {
-                    _context.next = 3;
-                    break;
-                  }
+        if (!this.isRemote) {
+          err = await new Promise(resolve => {
+            let done = event => {
+              clearTimeout(timeoutid);
+              socket.onopen = socket.onerror = null;
+              resolve((event === null || event === void 0 ? void 0 : event.error) || (event === null || event === void 0 ? void 0 : event.type) === 'error' && 'Error: Socket connection failed');
+            };
 
-                  return _context.abrupt("return");
+            let timeoutid = setTimeout(done, timeout, {
+              error: 'Error: Socket connection timed out'
+            });
+            socket.onopen = socket.onerror = done;
+          });
+        } // there was an error connecting, will fallback to normal logging
 
-                case 3:
-                  this.socket = socket;
 
-                  if (this.isRemote) {
-                    _context.next = 8;
-                    break;
-                  }
+        if (err) {
+          this.log('logger', 'debug', 'Unable to connect to remote logger');
+          this.log('logger', 'debug', err);
+          return;
+        } // send any messages already logged in this environment
 
-                  _context.next = 7;
-                  return new Promise(function (resolve) {
-                    var done = function done(error) {
-                      socket.removeEventListener('error', done);
-                      socket.removeEventListener('open', done);
-                      clearTimeout(timeoutid);
-                      resolve(error);
-                    };
 
-                    var timeoutid = setTimeout(done, timeout, 'Error: Socket connection timed out');
-                    socket.addEventListener('open', function () {
-                      return done();
-                    });
-                    socket.addEventListener('error', function (_ref2) {
-                      var error = _ref2.error;
-                      return done(error);
-                    });
-                  });
-
-                case 7:
-                  err = _context.sent;
-
-                case 8:
-                  if (!err) {
-                    _context.next = 12;
-                    break;
-                  }
-
-                  this.log('logger', 'debug', 'Unable to connect to remote logger');
-                  this.log('logger', 'debug', err);
-                  return _context.abrupt("return");
-
-                case 12:
-                  // send any messages already logged in this environment
-                  if (this.messages.size) {
-                    socket.send(JSON.stringify({
-                      logAll: Array.from(this.messages).map(function (entry) {
-                        return _objectSpread2(_objectSpread2({}, entry), {}, {
-                          meta: _objectSpread2({
-                            remote: true
-                          }, entry.meta)
-                        });
-                      })
-                    }));
-                  } // attach an incoming message handler and return a cleanup function
-
-
-                  return _context.abrupt("return", listen(socket, 'message', function (_ref3) {
-                    var data = _ref3.data;
-
-                    var _JSON$parse2 = JSON.parse(data),
-                        env = _JSON$parse2.env; // update local environment info
-
-
-                    if (env) Object.assign(process.env, env);
-                  }, function () {
-                    return _this3.socket = null;
-                  }));
-
-                case 14:
-                case "end":
-                  return _context.stop();
+        if (this.messages.size) {
+          socket.send(JSON.stringify({
+            logAll: Array.from(this.messages).map(entry => ({ ...entry,
+              meta: {
+                remote: true,
+                ...entry.meta
               }
-            }
-          }, _callee, this);
-        }));
+            }))
+          }));
+        } // attach an incoming message handler
 
-        function remote(_x) {
-          return _remote.apply(this, arguments);
-        }
 
-        return remote;
-      }()
-    }]);
+        socket.onmessage = ({
+          data
+        }) => {
+          let {
+            env
+          } = JSON.parse(data); // update local environment info
 
-    return PercyLogger;
-  }();
+          if (env) Object.assign(process.env, env);
+        }; // return a cleanup function
 
-  _defineProperty(PercyLogger, "stdout", process.stdout);
 
-  _defineProperty(PercyLogger, "stderr", process.stderr);
+        return () => {
+          socket.onmessage = null;
+          this.socket = null;
+        };
+      }
 
-  var logger$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    'default': PercyLogger
-  });
+    }
 
-  var BrowserLogger = /*#__PURE__*/function (_PercyLogger) {
-    _inherits(BrowserLogger, _PercyLogger);
+    _defineProperty(PercyLogger, "stdout", process.stdout);
 
-    var _super = _createSuper(BrowserLogger);
+    _defineProperty(PercyLogger, "stderr", process.stderr);
 
-    function BrowserLogger() {
-      _classCallCheck(this, BrowserLogger);
+    var logger$1 = /*#__PURE__*/Object.freeze({
+      __proto__: null,
+      'default': PercyLogger
+    });
 
-      return _super.apply(this, arguments);
-    }
-
-    _createClass(BrowserLogger, [{
-      key: "write",
-      value: function write(level, message) {
-        var _console;
-
-        var out = ['warn', 'error'].includes(level) ? level : 'log';
-        var colors = [];
-        message = message.replace(ANSI_REG, function (_, ansi) {
-          colors.push("color:".concat(ANSI_COLORS[ansi] || 'inherit'));
+    class BrowserLogger extends PercyLogger {
+      write(level, message) {
+        let out = ['warn', 'error'].includes(level) ? level : 'log';
+        let colors = [];
+        message = message.replace(ANSI_REG, (_, ansi) => {
+          colors.push(`color:${ANSI_COLORS[ansi] || 'inherit'}`);
           return '%c';
         });
-
-        (_console = console)[out].apply(_console, [message].concat(colors));
+        console[out](message, ...colors);
       }
-    }]);
 
-    return BrowserLogger;
-  }(PercyLogger);
+    }
 
-  var browser = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    'default': BrowserLogger
-  });
+    var browser = /*#__PURE__*/Object.freeze({
+      __proto__: null,
+      'default': BrowserLogger
+    });
 
-  function getAugmentedNamespace(n) {
-  	if (n.__esModule) return n;
-  	var a = Object.defineProperty({}, '__esModule', {value: true});
-  	Object.keys(n).forEach(function (k) {
-  		var d = Object.getOwnPropertyDescriptor(n, k);
-  		Object.defineProperty(a, k, d.get ? d : {
-  			enumerable: true,
-  			get: function () {
-  				return n[k];
-  			}
-  		});
-  	});
-  	return a;
-  }
+    function getAugmentedNamespace(n) {
+    	if (n.__esModule) return n;
+    	var a = Object.defineProperty({}, '__esModule', {value: true});
+    	Object.keys(n).forEach(function (k) {
+    		var d = Object.getOwnPropertyDescriptor(n, k);
+    		Object.defineProperty(a, k, d.get ? d : {
+    			enumerable: true,
+    			get: function () {
+    				return n[k];
+    			}
+    		});
+    	});
+    	return a;
+    }
 
-  var require$$0 = /*@__PURE__*/getAugmentedNamespace(browser);
+    var require$$0 = /*@__PURE__*/getAugmentedNamespace(browser);
 
-  var require$$1 = /*@__PURE__*/getAugmentedNamespace(logger$1);
+    var require$$1 = /*@__PURE__*/getAugmentedNamespace(logger$1);
 
-  var _ref = process.env.__PERCY_BROWSERIFIED__ ? require$$0 : require$$1,
-      Logger = _ref.default;
+    const {
+      default: Logger
+    } = process.env.__PERCY_BROWSERIFIED__ ? require$$0 : require$$1;
 
-  function logger(name) {
-    return new Logger().group(name);
-  }
+    function logger(name) {
+      return new Logger().group(name);
+    }
 
-  Object.assign(logger, {
-    format: function format() {
-      var _Logger;
+    Object.assign(logger, {
+      format: (...args) => new Logger().format(...args),
+      query: (...args) => new Logger().query(...args),
+      connect: (...args) => new Logger().connect(...args),
+      remote: (...args) => new Logger().remote(...args),
 
-      return (_Logger = new Logger()).format.apply(_Logger, arguments);
-    },
-    query: function query() {
-      var _Logger2;
+      loglevel(level, flags = {}) {
+        if (flags.verbose) level = 'debug';else if (flags.quiet) level = 'warn';else if (flags.silent) level = 'silent';
+        return new Logger().loglevel(level);
+      }
 
-      return (_Logger2 = new Logger()).query.apply(_Logger2, arguments);
-    },
-    connect: function connect() {
-      var _Logger3;
+    });
+    Object.defineProperties(logger, {
+      Logger: {
+        get: () => Logger
+      },
+      stdout: {
+        get: () => Logger.stdout
+      },
+      stderr: {
+        get: () => Logger.stderr
+      }
+    });
+    var src = logger;
 
-      return (_Logger3 = new Logger()).connect.apply(_Logger3, arguments);
-    },
-    remote: function remote() {
-      var _Logger4;
+    exports.default = src;
 
-      return (_Logger4 = new Logger()).remote.apply(_Logger4, arguments);
-    },
-    loglevel: function loglevel(level) {
-      var flags = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-      if (flags.verbose) level = 'debug';else if (flags.quiet) level = 'warn';else if (flags.silent) level = 'silent';
-      return new Logger().loglevel(level);
-    }
-  });
-  Object.defineProperties(logger, {
-    stdout: {
-      get: function get() {
-        return Logger.stdout;
-      }
-    },
-    stderr: {
-      get: function get() {
-        return Logger.stderr;
-      }
-    }
-  });
-  var src = logger;
-  var Logger_1 = Logger;
-  src.Logger = Logger_1;
+    Object.defineProperty(exports, '__esModule', { value: true });
 
-  exports.Logger = Logger_1;
-  exports.default = src;
+  }(this.PercyLogger = this.PercyLogger || {}));
+}).call(window);
 
-  Object.defineProperty(exports, '__esModule', { value: true });
-
-})));
+if (typeof exports === "object" && typeof module !== "undefined") {
+  module.exports = window.PercyLogger;
+}

dist/index.js

@@ -24,2 +24,5 @@ "use strict";
 Object.defineProperties(logger, {
+  Logger: {
+    get: () => Logger
+  },
   stdout: {
@@ -32,3 +35,2 @@ get: () => Logger.stdout
 });
-module.exports = logger;
-module.exports.Logger = Logger;
+module.exports = logger;

dist/logger.js

@@ -207,5 +207,5 @@ "use strict";
       }
-    })); // attach remote logging handler and return a cleanup function
+    })); // attach remote logging handler
 
-    return (0, _util.listen)(socket, 'message', ({
+    socket.onmessage = ({
       data
@@ -219,3 +219,8 @@ }) => {
       if (log) this.log(...log);
-    });
+    }; // return a cleanup function
+
+
+    return () => {
+      socket.onmessage = null;
+    };
   } // Connects to a remote logger
@@ -231,14 +236,12 @@
       err = await new Promise(resolve => {
-        let done = error => {
-          socket.removeEventListener('error', done);
-          socket.removeEventListener('open', done);
+        let done = event => {
           clearTimeout(timeoutid);
-          resolve(error);
+          socket.onopen = socket.onerror = null;
+          resolve((event === null || event === void 0 ? void 0 : event.error) || (event === null || event === void 0 ? void 0 : event.type) === 'error' && 'Error: Socket connection failed');
         };
 
-        let timeoutid = setTimeout(done, timeout, 'Error: Socket connection timed out');
-        socket.addEventListener('open', () => done());
-        socket.addEventListener('error', ({
-          error
-        }) => done(error));
+        let timeoutid = setTimeout(done, timeout, {
+          error: 'Error: Socket connection timed out'
+        });
+        socket.onopen = socket.onerror = done;
       });
@@ -264,6 +267,6 @@ } // there was an error connecting, will fallback to normal logging
       }));
-    } // attach an incoming message handler and return a cleanup function
+    } // attach an incoming message handler
 
 
-    return (0, _util.listen)(socket, 'message', ({
+    socket.onmessage = ({
       data
@@ -276,3 +279,9 @@ }) => {
       if (env) Object.assign(process.env, env);
-    }, () => this.socket = null);
+    }; // return a cleanup function
+
+
+    return () => {
+      socket.onmessage = null;
+      this.socket = null;
+    };
   }
@@ -279,0 +288,0 @@

dist/util.js

@@ -6,3 +6,2 @@ "use strict";
 });
-exports.listen = listen;
 exports.colors = exports.ANSI_COLORS = exports.ANSI_REG = void 0;
@@ -37,12 +36,3 @@ const {
   });
-}, {}); // adds an event listener and returns a teardown function
-
-exports.colors = colors;
-
-function listen(subject, event, handler, teardown) {
-  subject.addEventListener(event, handler);
-  return () => {
-    subject.removeEventListener(event, handler);
-    return teardown === null || teardown === void 0 ? void 0 : teardown();
-  };
-}
+}, {});
+exports.colors = colors;

package.json

 {
   "name": "@percy/logger",
-  "version": "1.0.0-beta.42",
+  "version": "1.0.0-beta.43",
   "license": "MIT",
@@ -9,3 +9,4 @@ "main": "dist/index.js",
     "dist",
-    "test/helper.js"
+    "test/helpers.js",
+    "test/client.js"
   ],
@@ -29,3 +30,3 @@ "engines": {
   },
-  "gitHead": "1feffb5149eff71114ea583e10c098f75f497544"
+  "gitHead": "4eb85cf34665859cfd6dd2d3d09b1089e5f70144"
 }

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Improved metrics

Number of package files

10

increased by11.11%

Worsened metrics

Total package byte prevSize

36826

decreased by-12.34%

Lines of code

882

decreased by-11.98%

No dependency changes