@beinformed/ui 1.20.8 → 1.20.9

package/esm/utils/fetch/xhr.js

@@ -1,17 +1,4 @@
-import _Object$getOwnPropertySymbols from "@babel/runtime-corejs3/core-js-stable/object/get-own-property-symbols";
-import _filterInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/filter";
-import _Object$getOwnPropertyDescriptor from "@babel/runtime-corejs3/core-js-stable/object/get-own-property-descriptor";
-import _Object$getOwnPropertyDescriptors from "@babel/runtime-corejs3/core-js-stable/object/get-own-property-descriptors";
-import _asyncToGenerator from "@babel/runtime-corejs3/helpers/esm/asyncToGenerator";
-import _classCallCheck from "@babel/runtime-corejs3/helpers/esm/classCallCheck";
-import _createClass from "@babel/runtime-corejs3/helpers/esm/createClass";
 import _defineProperty from "@babel/runtime-corejs3/helpers/esm/defineProperty";
-import _regeneratorRuntime from "@babel/runtime-corejs3/regenerator";
-
-function ownKeys(object, enumerableOnly) { var keys = _Object$keys(object); if (_Object$getOwnPropertySymbols) { var symbols = _Object$getOwnPropertySymbols(object); enumerableOnly && (symbols = _filterInstanceProperty(symbols).call(symbols, function (sym) { return _Object$getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : _Object$getOwnPropertyDescriptors ? Object.defineProperties(target, _Object$getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, _Object$getOwnPropertyDescriptor(source, key)); }); } return target; }
-
 import _includesInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/includes";
 import _concatInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/concat";
 import _Object$keys from "@babel/runtime-corejs3/core-js-stable/object/keys";
@@ -22,23 +9,21 @@ import { IllegalArgumentException, UnauthorizedException, FetchException, Timeou
 import Cache from "../browser/Cache";
 import { HTTP_METHODS } from "../../constants/Constants";
 import { getSetting } from "../../constants/Settings";
-var NETWORK_ERROR_CODE = 0;
-var SUCCESS_CODE = 200;
-var CLIENT_ERROR_CODE = 400;
-var UNAUTHORIZED_CODE = 401;
-var REDIRECTION_CODE = 300;
-var NOT_FOUND_CODE = 404;
-var JSON_TYPE = "application/json";
+const NETWORK_ERROR_CODE = 0;
+const SUCCESS_CODE = 200;
+const CLIENT_ERROR_CODE = 400;
+const UNAUTHORIZED_CODE = 401;
+const REDIRECTION_CODE = 300;
+const NOT_FOUND_CODE = 404;
+const JSON_TYPE = "application/json";
 /**
  * @private
  */
 
-var XHR = /*#__PURE__*/function () {
+class XHR {
   /**
    */
-  function XHR(options) {
-    _classCallCheck(this, XHR);
-
+  constructor(options) {
     _defineProperty(this, "_options", void 0);
 
     _defineProperty(this, "_xmlhttp", void 0);
@@ -52,403 +37,341 @@ var XHR = /*#__PURE__*/function () {
    */
 
 
-  _createClass(XHR, [{
-    key: "xmlhttp",
-    get: function get() {
-      return this._xmlhttp;
-    }
-    /**
-     */
-    ,
-    set: function set(xmlhttp) {
-      this._xmlhttp = xmlhttp;
-    }
-    /**
-     */
+  get xmlhttp() {
+    return this._xmlhttp;
+  }
+  /**
+   */
 
-  }, {
-    key: "options",
-    get: function get() {
-      return this._options;
-    }
-    /**
-     */
-    ,
-    set: function set(options) {
-      this._options = options;
-    }
-    /**
-     */
 
-  }, {
-    key: "attempts",
-    get: function get() {
-      return this._attempts;
-    }
-    /**
-     */
-    ,
-    set: function set(attempts) {
-      this._attempts = attempts;
-    }
-    /**
-     * Create and fix url when params or both querystring and params exist.
-     */
+  set xmlhttp(xmlhttp) {
+    this._xmlhttp = xmlhttp;
+  }
+  /**
+   */
+
+
+  get options() {
+    return this._options;
+  }
+  /**
+   */
+
+
+  set options(options) {
+    this._options = options;
+  }
+  /**
+   */
+
+
+  get attempts() {
+    return this._attempts;
+  }
+  /**
+   */
+
+
+  set attempts(attempts) {
+    this._attempts = attempts;
+  }
+  /**
+   * Create and fix url when params or both querystring and params exist.
+   */
 
-  }, {
-    key: "url",
-    get: function get() {
-      var url = this.options.url;
 
-      if (this.params !== "") {
-        var _context3;
+  get url() {
+    const {
+      url
+    } = this.options;
 
-        if (_includesInstanceProperty(url).call(url, "?")) {
-          var _context, _context2;
+    if (this.params !== "") {
+      var _context3;
 
-          var aUrl = url.split("?");
-          return _concatInstanceProperty(_context = _concatInstanceProperty(_context2 = "".concat(aUrl[0], "?")).call(_context2, aUrl[1], "&")).call(_context, this.params);
-        }
+      if (_includesInstanceProperty(url).call(url, "?")) {
+        var _context, _context2;
 
-        return _concatInstanceProperty(_context3 = "".concat(url, "?")).call(_context3, this.params);
+        const aUrl = url.split("?");
+        return _concatInstanceProperty(_context = _concatInstanceProperty(_context2 = "".concat(aUrl[0], "?")).call(_context2, aUrl[1], "&")).call(_context, this.params);
       }
 
-      return url;
+      return _concatInstanceProperty(_context3 = "".concat(url, "?")).call(_context3, this.params);
     }
-    /**
-     */
 
-  }, {
-    key: "params",
-    get: function get() {
-      return this.options.params || "";
-    }
-    /**
-     */
+    return url;
+  }
+  /**
+   */
 
-  }, {
-    key: "data",
-    get: function get() {
-      return this.options.data || null;
-    }
-    /**
-     */
 
-  }, {
-    key: "method",
-    get: function get() {
-      return this.options.method || HTTP_METHODS.GET;
-    }
-    /**
-     */
+  get params() {
+    return this.options.params || "";
+  }
+  /**
+   */
+
+
+  get data() {
+    return this.options.data || null;
+  }
+  /**
+   */
+
+
+  get method() {
+    return this.options.method || HTTP_METHODS.GET;
+  }
+  /**
+   */
 
-  }, {
-    key: "timeout",
-    get: function get() {
-      return this.options.timeout || getSetting("XHR_TIMEOUT_MS", 300000);
-    }
-    /**
-     */
 
-  }, {
-    key: "responseType",
-    get: function get() {
-      return this.options.responseType || "json";
+  get timeout() {
+    return this.options.timeout || getSetting("XHR_TIMEOUT_MS", 300000);
+  }
+  /**
+   */
+
+
+  get responseType() {
+    return this.options.responseType || "json";
+  }
+  /**
+   */
+
+
+  get onProgress() {
+    if (this.options.onProgress) {
+      return this.options.onProgress;
     }
-    /**
-     */
-
-  }, {
-    key: "onProgress",
-    get: function get() {
-      if (this.options.onProgress) {
-        return this.options.onProgress;
-      }
 
-      return function () {// do nothing
+    return () => {// do nothing
+    };
+  }
+  /**
+   */
+
+
+  get events() {
+    return this.options.events || {};
+  }
+  /**
+   */
+
+
+  get headers() {
+    const baseHeaders = {
+      Accept: JSON_TYPE,
+      "Content-Type": JSON_TYPE,
+      // needed for csrf, see: https://plaza.beinformed.com/amdoc/csrf-protection-in-modular-ui-services-40054554.html
+      "X-Requested-With": "XMLHttpRequest",
+      "Accept-Language": "en"
+    };
+
+    if (this.options.headers) {
+      // $FlowFixMe[cannot-spread-indexer]
+      return { ...baseHeaders,
+        ...this.options.headers
       };
     }
-    /**
-     */
 
-  }, {
-    key: "events",
-    get: function get() {
-      return this.options.events || {};
-    }
-    /**
-     */
-
-  }, {
-    key: "headers",
-    get: function get() {
-      var baseHeaders = {
-        Accept: JSON_TYPE,
-        "Content-Type": JSON_TYPE,
-        // needed for csrf, see: https://plaza.beinformed.com/amdoc/csrf-protection-in-modular-ui-services-40054554.html
-        "X-Requested-With": "XMLHttpRequest",
-        "Accept-Language": "en"
-      };
+    return baseHeaders;
+  }
+  /**
+   */
 
-      if (this.options.headers) {
-        // $FlowFixMe[cannot-spread-indexer]
-        return _objectSpread(_objectSpread({}, baseHeaders), this.options.headers);
-      }
 
-      return baseHeaders;
-    }
-    /**
-     */
+  timeoutHandler(reject) {
+    return reject(new TimeoutException(this.url, this.method));
+  }
+  /**
+   */
 
-  }, {
-    key: "timeoutHandler",
-    value: function timeoutHandler(reject) {
-      return reject(new TimeoutException(this.url, this.method));
-    }
-    /**
-     */
-
-  }, {
-    key: "errorHandler",
-    value: function errorHandler(reject) {
-      var responseJSON = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-      var status = this.xmlhttp.status;
-      var isReload = this.options.isReload;
-
-      if (status === NETWORK_ERROR_CODE) {
-        return reject(new NetworkException(this.url, this.method));
-      }
 
-      if (status === NOT_FOUND_CODE) {
-        return reject(new NotFoundException(this.url, this.method, isReload));
-      }
+  errorHandler(reject) {
+    let responseJSON = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    const {
+      status
+    } = this.xmlhttp;
+    const {
+      isReload
+    } = this.options;
 
-      if (status === UNAUTHORIZED_CODE) {
-        return reject(new UnauthorizedException(this.url, this.method, responseJSON));
-      }
+    if (status === NETWORK_ERROR_CODE) {
+      return reject(new NetworkException(this.url, this.method));
+    }
 
-      return reject(new FetchException(responseJSON, this.xmlhttp, this.options));
+    if (status === NOT_FOUND_CODE) {
+      return reject(new NotFoundException(this.url, this.method, isReload));
     }
-    /**
-     */
-
-  }, {
-    key: "getResponse",
-    value: function getResponse() {
-      var _this$xmlhttp = this.xmlhttp,
-          responseType = _this$xmlhttp.responseType,
-          response = _this$xmlhttp.response;
-
-      if ((responseType === "" || responseType === "text") && this.getResponseHeader("Content-Type") === JSON_TYPE) {
-        if (isPlainObject(response)) {
-          return response;
-        }
-
-        try {
-          return JSON.parse(response);
-        } catch (error) {
-          throw new JsonParseException(error);
-        }
-      }
 
-      return response;
+    if (status === UNAUTHORIZED_CODE) {
+      return reject(new UnauthorizedException(this.url, this.method, responseJSON));
     }
-    /**
-     */
 
-  }, {
-    key: "responseHandler",
-    value: function responseHandler(resolve, reject) {
-      var status = this.xmlhttp.status;
-      var response = null;
+    return reject(new FetchException(responseJSON, this.xmlhttp, this.options));
+  }
+  /**
+   */
+
+
+  getResponse() {
+    const {
+      responseType,
+      response
+    } = this.xmlhttp;
+
+    if ((responseType === "" || responseType === "text") && this.getResponseHeader("Content-Type") === JSON_TYPE) {
+      if (isPlainObject(response)) {
+        return response;
+      }
 
       try {
-        response = this.getResponse();
+        return JSON.parse(response);
       } catch (error) {
-        return reject(error);
+        throw new JsonParseException(error);
       }
+    }
 
-      if (status >= SUCCESS_CODE && status < REDIRECTION_CODE || status === CLIENT_ERROR_CODE && has(response, "formresponse")) {
-        return resolve(response);
-      }
+    return response;
+  }
+  /**
+   */
 
-      return this.errorHandler(reject, response);
-    }
-    /**
-     */
-
-  }, {
-    key: "setEventListeners",
-    value: function setEventListeners(resolve, reject) {
-      var _this = this;
-
-      if (this.options.onProgress) {
-        ["load", "loadend", "loadstart", "progress"].forEach(function (eventType) {
-          _this.xmlhttp.addEventListener(eventType, _this.onProgress);
-        });
-      }
 
-      ["abort", "error"].forEach(function (eventType) {
-        _this.xmlhttp.addEventListener(eventType, function () {
-          return _this.errorHandler(reject);
-        });
-      });
-      this.xmlhttp.addEventListener("timeout", function () {
-        return _this.timeoutHandler(reject);
-      });
-      this.xmlhttp.addEventListener("load", function () {
-        return _this.responseHandler(resolve, reject);
-      }); // Set custom events
+  responseHandler(resolve, reject) {
+    const {
+      status
+    } = this.xmlhttp;
+    let response = null;
 
-      _Object$keys(this.events).forEach(function (eventName) {
-        _this.xmlhttp.addEventListener(eventName, _this.events[eventName]);
-      });
+    try {
+      response = this.getResponse();
+    } catch (error) {
+      return reject(error);
     }
-    /**
-     */
 
-  }, {
-    key: "openConnection",
-    value: function openConnection() {
-      this.xmlhttp.open(this.method, this.url, true);
-    }
-    /**
-     */
-
-  }, {
-    key: "setBasicAuthentication",
-    value: function setBasicAuthentication() {
-      if (Cache.hasItem("basic")) {
-        this.xmlhttp.withCredentials = true;
-        var basicToken = Cache.getItem("basic");
-
-        if (typeof basicToken === "string") {
-          this.xmlhttp.setRequestHeader("Authorization", "Basic ".concat(basicToken));
-        }
-      }
+    if (status >= SUCCESS_CODE && status < REDIRECTION_CODE || status === CLIENT_ERROR_CODE && has(response, "formresponse")) {
+      return resolve(response);
     }
-    /**
-     */
 
-  }, {
-    key: "getResponseHeader",
-    value: function getResponseHeader(headerName) {
-      return this.xmlhttp.getResponseHeader(headerName);
-    }
-    /**
-     */
+    return this.errorHandler(reject, response);
+  }
+  /**
+   */
 
-  }, {
-    key: "setCustomHeaders",
-    value: function setCustomHeaders() {
-      var _this2 = this;
 
-      _Object$keys(this.headers).forEach(function (headerName) {
-        _this2.xmlhttp.setRequestHeader(headerName, _this2.headers[headerName]);
+  setEventListeners(resolve, reject) {
+    if (this.options.onProgress) {
+      ["load", "loadend", "loadstart", "progress"].forEach(eventType => {
+        this.xmlhttp.addEventListener(eventType, this.onProgress);
       });
     }
-    /**
-     */
-
-  }, {
-    key: "setOtherOptions",
-    value: function setOtherOptions() {
-      this.xmlhttp.responseType = this.responseType;
-      this.xmlhttp.timeout = this.timeout;
-    }
-    /**
-     */
-
-  }, {
-    key: "sendData",
-    value: function sendData() {
-      if (this.data == null) {
-        this.xmlhttp.send();
-      } else {
-        var stringData = isPlainObject(this.data) ? _JSON$stringify(this.data) : this.data;
-        this.xmlhttp.send(stringData);
+
+    ["abort", "error"].forEach(eventType => {
+      this.xmlhttp.addEventListener(eventType, () => this.errorHandler(reject));
+    });
+    this.xmlhttp.addEventListener("timeout", () => this.timeoutHandler(reject));
+    this.xmlhttp.addEventListener("load", () => this.responseHandler(resolve, reject)); // Set custom events
+
+    _Object$keys(this.events).forEach(eventName => {
+      this.xmlhttp.addEventListener(eventName, this.events[eventName]);
+    });
+  }
+  /**
+   */
+
+
+  openConnection() {
+    this.xmlhttp.open(this.method, this.url, true);
+  }
+  /**
+   */
+
+
+  setBasicAuthentication() {
+    if (Cache.hasItem("basic")) {
+      this.xmlhttp.withCredentials = true;
+      const basicToken = Cache.getItem("basic");
+
+      if (typeof basicToken === "string") {
+        this.xmlhttp.setRequestHeader("Authorization", "Basic ".concat(basicToken));
       }
     }
-    /**
-     */
+  }
+  /**
+   */
 
-  }, {
-    key: "setXMLHttpRequest",
-    value: function setXMLHttpRequest() {
-      var _this3 = this;
 
-      return new _Promise(function (resolve, reject) {
-        _this3.xmlhttp = new XMLHttpRequest();
+  getResponseHeader(headerName) {
+    return this.xmlhttp.getResponseHeader(headerName);
+  }
+  /**
+   */
 
-        _this3.setEventListeners(resolve, reject);
 
-        _this3.openConnection();
+  setCustomHeaders() {
+    _Object$keys(this.headers).forEach(headerName => {
+      this.xmlhttp.setRequestHeader(headerName, this.headers[headerName]);
+    });
+  }
+  /**
+   */
 
-        _this3.setBasicAuthentication();
 
-        _this3.setCustomHeaders();
+  setOtherOptions() {
+    this.xmlhttp.responseType = this.responseType;
+    this.xmlhttp.timeout = this.timeout;
+  }
+  /**
+   */
 
-        _this3.setOtherOptions();
 
-        _this3.sendData();
-      });
+  sendData() {
+    if (this.data == null) {
+      this.xmlhttp.send();
+    } else {
+      const stringData = isPlainObject(this.data) ? _JSON$stringify(this.data) : this.data;
+      this.xmlhttp.send(stringData);
     }
-    /**
-     */
-
-  }, {
-    key: "fetch",
-    value: function () {
-      var _fetch = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
-        return _regeneratorRuntime.wrap(function _callee$(_context4) {
-          while (1) {
-            switch (_context4.prev = _context4.next) {
-              case 0:
-                _context4.prev = 0;
-                _context4.next = 3;
-                return this.setXMLHttpRequest();
-
-              case 3:
-                return _context4.abrupt("return", _context4.sent);
-
-              case 6:
-                _context4.prev = 6;
-                _context4.t0 = _context4["catch"](0);
-
-                if (!(_context4.t0 instanceof NetworkException && this.attempts < 2)) {
-                  _context4.next = 11;
-                  break;
-                }
-
-                this.attempts += 1;
-                return _context4.abrupt("return", this.fetch());
-
-              case 11:
-                throw _context4.t0;
-
-              case 12:
-              case "end":
-                return _context4.stop();
-            }
-          }
-        }, _callee, this, [[0, 6]]);
-      }));
-
-      function fetch() {
-        return _fetch.apply(this, arguments);
+  }
+  /**
+   */
+
+
+  setXMLHttpRequest() {
+    return new _Promise((resolve, reject) => {
+      this.xmlhttp = new XMLHttpRequest();
+      this.setEventListeners(resolve, reject);
+      this.openConnection();
+      this.setBasicAuthentication();
+      this.setCustomHeaders();
+      this.setOtherOptions();
+      this.sendData();
+    });
+  }
+  /**
+   */
+
+
+  async fetch() {
+    try {
+      return await this.setXMLHttpRequest();
+    } catch (err) {
+      if (err instanceof NetworkException && this.attempts < 2) {
+        this.attempts += 1;
+        return this.fetch();
       }
 
-      return fetch;
-    }()
-  }]);
+      throw err;
+    }
+  }
 
-  return XHR;
-}();
+}
 /**
  */
 
 
-var validateInputArguments = function validateInputArguments(args) {
+const validateInputArguments = args => {
   if (args == null) {
     throw new IllegalArgumentException("Missing request options, expecting an object as argument for xhr");
   }
@@ -467,7 +390,7 @@ var validateInputArguments = function validateInputArguments(args) {
  */
 
 
-var xhr = function xhr(args) {
+const xhr = args => {
   validateInputArguments(args);
   return new XHR(args).fetch();
 };