@umbrellio/ga-tracker - npm Package Compare versions

Comparing version 0.3.0 to 0.3.1

dist/tracker.cjs.js

 'use strict';
 
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+
 function _defineProperty(obj, key, value) {
@@ -52,2 +58,136 @@ if (key in obj) {
 
+function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      writable: true,
+      configurable: true
+    }
+  });
+  if (superClass) _setPrototypeOf(subClass, superClass);
+}
+
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
+  };
+  return _getPrototypeOf(o);
+}
+
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+
+  return _setPrototypeOf(o, p);
+}
+
+function _isNativeReflectConstruct() {
+  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+  if (Reflect.construct.sham) return false;
+  if (typeof Proxy === "function") return true;
+
+  try {
+    Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+function _construct(Parent, args, Class) {
+  if (_isNativeReflectConstruct()) {
+    _construct = Reflect.construct;
+  } else {
+    _construct = function _construct(Parent, args, Class) {
+      var a = [null];
+      a.push.apply(a, args);
+      var Constructor = Function.bind.apply(Parent, a);
+      var instance = new Constructor();
+      if (Class) _setPrototypeOf(instance, Class.prototype);
+      return instance;
+    };
+  }
+
+  return _construct.apply(null, arguments);
+}
+
+function _isNativeFunction(fn) {
+  return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+
+function _wrapNativeSuper(Class) {
+  var _cache = typeof Map === "function" ? new Map() : undefined;
+
+  _wrapNativeSuper = function _wrapNativeSuper(Class) {
+    if (Class === null || !_isNativeFunction(Class)) return Class;
+
+    if (typeof Class !== "function") {
+      throw new TypeError("Super expression must either be null or a function");
+    }
+
+    if (typeof _cache !== "undefined") {
+      if (_cache.has(Class)) return _cache.get(Class);
+
+      _cache.set(Class, Wrapper);
+    }
+
+    function Wrapper() {
+      return _construct(Class, arguments, _getPrototypeOf(this).constructor);
+    }
+
+    Wrapper.prototype = Object.create(Class.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    return _setPrototypeOf(Wrapper, Class);
+  };
+
+  return _wrapNativeSuper(Class);
+}
+
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+
+  return self;
+}
+
+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) {
@@ -125,2 +265,40 @@ return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
 
+var NetworkError = /*#__PURE__*/function (_Error) {
+  _inherits(NetworkError, _Error);
+
+  var _super = _createSuper(NetworkError);
+
+  function NetworkError(status, response) {
+    var _this;
+
+    _classCallCheck(this, NetworkError);
+
+    _this = _super.call(this);
+    _this.status = status;
+    _this.response = response;
+    return _this;
+  }
+
+  return NetworkError;
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+
+var ConnectionError = /*#__PURE__*/function (_Error2) {
+  _inherits(ConnectionError, _Error2);
+
+  var _super2 = _createSuper(ConnectionError);
+
+  function ConnectionError() {
+    _classCallCheck(this, ConnectionError);
+
+    return _super2.apply(this, arguments);
+  }
+
+  return ConnectionError;
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+
+var errors = {
+  NetworkError: NetworkError,
+  ConnectionError: ConnectionError
+};
+
 var makeRequest = function makeRequest(verb, url, body) {
@@ -139,6 +317,9 @@ return new Promise(function (resolve, reject) {
     xhr.onerror = function () {
-      return reject({
-        status: xhr.status,
-        response: xhr.response
-      });
+      var status = xhr.status;
+
+      if (!status) {
+        reject(new errors.ConnectionError());
+      } else {
+        reject(new errors.NetworkError(xhr.status, xhr.response));
+      }
     };
@@ -269,5 +450,6 @@
 var index = {
-  create: create
+  create: create,
+  Errors: errors
 };
 
 module.exports = index;

dist/tracker.es.js

@@ -0,1 +1,7 @@
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+
 function _defineProperty(obj, key, value) {
@@ -50,2 +56,136 @@ if (key in obj) {
 
+function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      writable: true,
+      configurable: true
+    }
+  });
+  if (superClass) _setPrototypeOf(subClass, superClass);
+}
+
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
+  };
+  return _getPrototypeOf(o);
+}
+
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+
+  return _setPrototypeOf(o, p);
+}
+
+function _isNativeReflectConstruct() {
+  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+  if (Reflect.construct.sham) return false;
+  if (typeof Proxy === "function") return true;
+
+  try {
+    Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+function _construct(Parent, args, Class) {
+  if (_isNativeReflectConstruct()) {
+    _construct = Reflect.construct;
+  } else {
+    _construct = function _construct(Parent, args, Class) {
+      var a = [null];
+      a.push.apply(a, args);
+      var Constructor = Function.bind.apply(Parent, a);
+      var instance = new Constructor();
+      if (Class) _setPrototypeOf(instance, Class.prototype);
+      return instance;
+    };
+  }
+
+  return _construct.apply(null, arguments);
+}
+
+function _isNativeFunction(fn) {
+  return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+
+function _wrapNativeSuper(Class) {
+  var _cache = typeof Map === "function" ? new Map() : undefined;
+
+  _wrapNativeSuper = function _wrapNativeSuper(Class) {
+    if (Class === null || !_isNativeFunction(Class)) return Class;
+
+    if (typeof Class !== "function") {
+      throw new TypeError("Super expression must either be null or a function");
+    }
+
+    if (typeof _cache !== "undefined") {
+      if (_cache.has(Class)) return _cache.get(Class);
+
+      _cache.set(Class, Wrapper);
+    }
+
+    function Wrapper() {
+      return _construct(Class, arguments, _getPrototypeOf(this).constructor);
+    }
+
+    Wrapper.prototype = Object.create(Class.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    return _setPrototypeOf(Wrapper, Class);
+  };
+
+  return _wrapNativeSuper(Class);
+}
+
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+
+  return self;
+}
+
+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) {
@@ -123,2 +263,40 @@ return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
 
+var NetworkError = /*#__PURE__*/function (_Error) {
+  _inherits(NetworkError, _Error);
+
+  var _super = _createSuper(NetworkError);
+
+  function NetworkError(status, response) {
+    var _this;
+
+    _classCallCheck(this, NetworkError);
+
+    _this = _super.call(this);
+    _this.status = status;
+    _this.response = response;
+    return _this;
+  }
+
+  return NetworkError;
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+
+var ConnectionError = /*#__PURE__*/function (_Error2) {
+  _inherits(ConnectionError, _Error2);
+
+  var _super2 = _createSuper(ConnectionError);
+
+  function ConnectionError() {
+    _classCallCheck(this, ConnectionError);
+
+    return _super2.apply(this, arguments);
+  }
+
+  return ConnectionError;
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+
+var errors = {
+  NetworkError: NetworkError,
+  ConnectionError: ConnectionError
+};
+
 var makeRequest = function makeRequest(verb, url, body) {
@@ -137,6 +315,9 @@ return new Promise(function (resolve, reject) {
     xhr.onerror = function () {
-      return reject({
-        status: xhr.status,
-        response: xhr.response
-      });
+      var status = xhr.status;
+
+      if (!status) {
+        reject(new errors.ConnectionError());
+      } else {
+        reject(new errors.NetworkError(xhr.status, xhr.response));
+      }
     };
@@ -267,5 +448,6 @@
 var index = {
-  create: create
+  create: create,
+  Errors: errors
 };
 
 export default index;

dist/tracker.iife.js

 var Tracker = (function () {
   'use strict';
 
+  function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+      throw new TypeError("Cannot call a class as a function");
+    }
+  }
+
   function _defineProperty(obj, key, value) {
@@ -53,2 +59,136 @@ if (key in obj) {
 
+  function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+      throw new TypeError("Super expression must either be null or a function");
+    }
+
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+      constructor: {
+        value: subClass,
+        writable: true,
+        configurable: true
+      }
+    });
+    if (superClass) _setPrototypeOf(subClass, superClass);
+  }
+
+  function _getPrototypeOf(o) {
+    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+      return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _getPrototypeOf(o);
+  }
+
+  function _setPrototypeOf(o, p) {
+    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+      o.__proto__ = p;
+      return o;
+    };
+
+    return _setPrototypeOf(o, p);
+  }
+
+  function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+
+    try {
+      Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  function _construct(Parent, args, Class) {
+    if (_isNativeReflectConstruct()) {
+      _construct = Reflect.construct;
+    } else {
+      _construct = function _construct(Parent, args, Class) {
+        var a = [null];
+        a.push.apply(a, args);
+        var Constructor = Function.bind.apply(Parent, a);
+        var instance = new Constructor();
+        if (Class) _setPrototypeOf(instance, Class.prototype);
+        return instance;
+      };
+    }
+
+    return _construct.apply(null, arguments);
+  }
+
+  function _isNativeFunction(fn) {
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
+  }
+
+  function _wrapNativeSuper(Class) {
+    var _cache = typeof Map === "function" ? new Map() : undefined;
+
+    _wrapNativeSuper = function _wrapNativeSuper(Class) {
+      if (Class === null || !_isNativeFunction(Class)) return Class;
+
+      if (typeof Class !== "function") {
+        throw new TypeError("Super expression must either be null or a function");
+      }
+
+      if (typeof _cache !== "undefined") {
+        if (_cache.has(Class)) return _cache.get(Class);
+
+        _cache.set(Class, Wrapper);
+      }
+
+      function Wrapper() {
+        return _construct(Class, arguments, _getPrototypeOf(this).constructor);
+      }
+
+      Wrapper.prototype = Object.create(Class.prototype, {
+        constructor: {
+          value: Wrapper,
+          enumerable: false,
+          writable: true,
+          configurable: true
+        }
+      });
+      return _setPrototypeOf(Wrapper, Class);
+    };
+
+    return _wrapNativeSuper(Class);
+  }
+
+  function _assertThisInitialized(self) {
+    if (self === void 0) {
+      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+
+    return self;
+  }
+
+  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) {
@@ -126,2 +266,40 @@ return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
 
+  var NetworkError = /*#__PURE__*/function (_Error) {
+    _inherits(NetworkError, _Error);
+
+    var _super = _createSuper(NetworkError);
+
+    function NetworkError(status, response) {
+      var _this;
+
+      _classCallCheck(this, NetworkError);
+
+      _this = _super.call(this);
+      _this.status = status;
+      _this.response = response;
+      return _this;
+    }
+
+    return NetworkError;
+  }( /*#__PURE__*/_wrapNativeSuper(Error));
+
+  var ConnectionError = /*#__PURE__*/function (_Error2) {
+    _inherits(ConnectionError, _Error2);
+
+    var _super2 = _createSuper(ConnectionError);
+
+    function ConnectionError() {
+      _classCallCheck(this, ConnectionError);
+
+      return _super2.apply(this, arguments);
+    }
+
+    return ConnectionError;
+  }( /*#__PURE__*/_wrapNativeSuper(Error));
+
+  var errors = {
+    NetworkError: NetworkError,
+    ConnectionError: ConnectionError
+  };
+
   var makeRequest = function makeRequest(verb, url, body) {
@@ -140,6 +318,9 @@ return new Promise(function (resolve, reject) {
       xhr.onerror = function () {
-        return reject({
-          status: xhr.status,
-          response: xhr.response
-        });
+        var status = xhr.status;
+
+        if (!status) {
+          reject(new errors.ConnectionError());
+        } else {
+          reject(new errors.NetworkError(xhr.status, xhr.response));
+        }
       };
@@ -270,3 +451,4 @@
   var index = {
-    create: create
+    create: create,
+    Errors: errors
   };
@@ -273,0 +455,0 @@

package.json

 {
   "name": "@umbrellio/ga-tracker",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Google Analytics tracker",
@@ -5,0 +5,0 @@ "author": "Aleksei Bespalov <[e-mail]>",

No alert changes

Improved metrics

Total package byte prevSize

43745

47.64%

Lines of code

1307

47.85%

No dependency changes