@shopgate/pwa-core 7.30.0-alpha.10 → 7.30.0-alpha.11

package/classes/PipelineRequest/mock.js

@@ -1,3 +1,5 @@
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _createClass from "@babel/runtime/helpers/createClass";
 import { logger } from "../../helpers";
 import * as errorHandleTypes from "../../constants/ErrorHandleTypes";
 import * as processTypes from "../../constants/ProcessTypes";
@@ -8,21 +10,12 @@ import * as processTypes from "../../constants/ProcessTypes";
  *
  * For more information and usage examples, please check the README.
  */
-class MockedPipelineRequest {
-  /**
-   * Getter for mockedDispatchResolver which is an additional helper function for custom, mock-only
-   * `dispatch()` resolver.
-   * @return {Function}
-   */
-  static get mockedDispatchResolver() {
-    return () => {};
-  }
-
+let MockedPipelineRequest = /*#__PURE__*/function () {
   /**
    * Initializes the MockedPipelineRequest object.
    * @param {string} name The pipeline name.
    */
-  constructor(name) {
+  function MockedPipelineRequest(name) {
     this.name = name;
     this.input = {};
     this.handleErrors = errorHandleTypes.ERROR_HANDLE_DEFAULT;
@@ -36,7 +29,8 @@ class MockedPipelineRequest {
    * @param {Object} [mockedInput={}] The payload to send with the request.
    * @returns {MockedPipelineRequest}
    */
-  setInput(mockedInput = {}) {
+  var _proto = MockedPipelineRequest.prototype;
+  _proto.setInput = function setInput(mockedInput = {}) {
     this.input = mockedInput;
     return this;
   }
@@ -45,8 +39,8 @@ class MockedPipelineRequest {
    * Sets a timeout.
    * @param {number} timeout Timeout.
    * @returns {MockedPipelineRequest}
-   */
-  setTimeout(timeout) {
+   */;
+  _proto.setTimeout = function setTimeout(timeout) {
     this.timeout = timeout;
     return this;
   }
@@ -54,8 +48,8 @@ class MockedPipelineRequest {
   /**
    * @param {number} retries The number of retries this pipeline request should perform.
    * @return {PipelineRequest}
-   */
-  setRetries(retries = 3) {
+   */;
+  _proto.setRetries = function setRetries(retries = 3) {
     if (typeof retries !== 'number') throw new TypeError(`Expected 'number'. Received: '${typeof retries}'`);
     if (retries < 0) throw new Error(`Expected positive integer. Received: '${retries}'`);
     if (retries >= 5) throw new Error(`Max retries exceeded. Received: '${retries}'`);
@@ -66,8 +60,8 @@ class MockedPipelineRequest {
   /**
    * Returns promise and calls `MockedPipelineRequest.mockedDispatchResolver()`.
    * @returns {Promise}
-   */
-  dispatch() {
+   */;
+  _proto.dispatch = function dispatch() {
     return new Promise((resolve, reject) => {
       this.constructor.mockedDispatchResolver(this, resolve, reject);
     });
@@ -76,8 +70,8 @@ class MockedPipelineRequest {
   /**
    * @param {string} processed The response process type.
    * @return {PipelineRequest}
-   */
-  setResponseProcessed(processed = processTypes.DEFAULT_PROCESSED) {
+   */;
+  _proto.setResponseProcessed = function setResponseProcessed(processed = processTypes.DEFAULT_PROCESSED) {
     if (typeof processed !== 'string') throw new TypeError(`Expected 'string'. Received: '${typeof processed}'`);
     if (!Object.values(processTypes).includes(processed)) {
       throw new Error(`The value '${processed}' is not supported!`);
@@ -91,8 +85,8 @@ class MockedPipelineRequest {
    * Can be used for custom error handling outside.
    * @param {Object} errors - Array of error codes
    * @return {PipelineRequest}
-   */
-  setErrorBlacklist(errors = []) {
+   */;
+  _proto.setErrorBlacklist = function setErrorBlacklist(errors = []) {
     this.errorBlacklist = errors;
     return this;
   }
@@ -100,8 +94,8 @@ class MockedPipelineRequest {
   /**
    * @param {string} handle The handle errors type.
    * @return {PipelineRequest}
-   */
-  setHandleErrors(handle = errorHandleTypes.ERROR_HANDLE_DEFAULT) {
+   */;
+  _proto.setHandleErrors = function setHandleErrors(handle = errorHandleTypes.ERROR_HANDLE_DEFAULT) {
     if (typeof handle !== 'string') throw new TypeError(`Expected 'string'. Received: '${typeof handle}'`);
     if (!Object.values(errorHandleTypes).includes(handle)) {
       throw new Error(`The value '${handle}' is not supported!`);
@@ -115,8 +109,8 @@ class MockedPipelineRequest {
    * @param {Array} errors Blacklisted errors.
    * @returns {MockedPipelineRequest}
    * @deprecated
-   */
-  setHandledErrors(errors = []) {
+   */;
+  _proto.setHandledErrors = function setHandledErrors(errors = []) {
     logger.warn('Deprecated: setHandledErrors() will be removed in favor of setErrorBlacklist()!');
     this.setErrorBlacklist(errors);
     return this;
@@ -128,26 +122,45 @@ class MockedPipelineRequest {
    * @param {boolean} value Value.
    * @return {PipelineRequest}
    * @deprecated
-   */
-  setSuppressErrors(value) {
+   */;
+  _proto.setSuppressErrors = function setSuppressErrors(value) {
     logger.warn('Deprecated: setSuppressErrors() will be removed. Use setHandleErrors() instead!');
     const handle = value ? errorHandleTypes.ERROR_HANDLE_SUPPRESS : errorHandleTypes.ERROR_HANDLE_DEFAULT;
     this.setHandleErrors(handle);
     return this;
-  }
-}
-
+  };
+  return _createClass(MockedPipelineRequest, null, [{
+    key: "mockedDispatchResolver",
+    get:
+    /**
+     * Getter for mockedDispatchResolver which is an additional helper function for custom, mock-only
+     * `dispatch()` resolver.
+     * @return {Function}
+     */
+    function () {
+      return () => {};
+    }
+  }]);
+}();
 /**
  * Factory which creates an instance of MockedPipelineRequest.
  * @param {Function} callback Resolver callback.
  * @returns {MockedPipelineRequest}
  */
-export const mockedPipelineRequestFactory = callback => class extends MockedPipelineRequest {
-  /**
-   * Getter for custom mocked resolver.
-   * @return {Function}
-   */
-  static get mockedDispatchResolver() {
-    return callback;
+export const mockedPipelineRequestFactory = callback => /*#__PURE__*/function (_MockedPipelineReques) {
+  function _class() {
+    return _MockedPipelineReques.apply(this, arguments) || this;
   }
-};
+  _inheritsLoose(_class, _MockedPipelineReques);
+  return _createClass(_class, null, [{
+    key: "mockedDispatchResolver",
+    get:
+    /**
+     * Getter for custom mocked resolver.
+     * @return {Function}
+     */
+    function () {
+      return callback;
+    }
+  }]);
+}(MockedPipelineRequest);

package/classes/PipelineRequest/spec.js

@@ -5,7 +5,7 @@ let request;
 const mockedWarn = jest.fn();
 jest.mock("../../helpers", () => ({
   logger: {
-    warn: (...args) => mockedWarn(...args)
+    warn: (...args) => mockedWarn.apply(void 0, args)
   }
 }));
 describe('PipelineRequest', () => {

package/classes/PipelineSequence/index.js

@@ -1,11 +1,11 @@
 /**
  * A sequence of pipeline requests.
  */
-class PipelineSequence {
+let PipelineSequence = /*#__PURE__*/function () {
   /**
    * Constructor.
    */
-  constructor() {
+  function PipelineSequence() {
     this.sequence = [];
   }
 
@@ -13,7 +13,8 @@ class PipelineSequence {
    * Adds a new serial to the sequence.
    * @param {string} serial The pipeline request serial.
    */
-  set(serial) {
+  var _proto = PipelineSequence.prototype;
+  _proto.set = function set(serial) {
     const index = this.sequence.indexOf(serial);
     if (index < 0) {
       this.sequence.push(serial);
@@ -23,20 +24,21 @@ class PipelineSequence {
   /**
    * Returns the sequence.
    * @return {Array}
-   */
-  get() {
+   */;
+  _proto.get = function get() {
     return this.sequence;
   }
 
   /**
    * Removes a serial from the sequence.
    * @param {string} serial The pipeline request serial.
-   */
-  remove(serial) {
+   */;
+  _proto.remove = function remove(serial) {
     const index = this.sequence.indexOf(serial);
     if (index >= 0) {
       this.sequence.splice(index, 1);
     }
-  }
-}
+  };
+  return PipelineSequence;
+}();
 export default new PipelineSequence();

package/classes/Request/index.js

@@ -8,12 +8,12 @@ const defaultRequestManager = new RequestManager();
 /**
  * The request class.
  */
-class Request {
+let Request = /*#__PURE__*/function () {
   /**
    * The constructor.
    * @param {RequestManager} [manager] The manager for this request.
    */
-  constructor(manager) {
+  function Request(manager) {
     /**
      * Creates the event callback name from the data request serial.
      * @param {string} callbackKey The callback key to use.
@@ -29,32 +29,33 @@ class Request {
   /**
    * @return {boolean} Whether there are pending requests of this type.
    */
-  hasPendingRequests() {
+  var _proto = Request.prototype;
+  _proto.hasPendingRequests = function hasPendingRequests() {
     return this.manager.pendingRequests > 0;
   }
 
   /**
    * Generates the serial for this data request.
    * @param {string} serialKey The serial key.
-   */
-  createSerial(serialKey) {
+   */;
+  _proto.createSerial = function createSerial(serialKey) {
     if (!this.serial) {
       this.serial = CryptoJs.MD5(`${serialKey}${Date.now() + Math.random()}`).toString();
     }
-  }
+  };
   /**
    * Returns the event callback name.
    * @returns {string}
    */
-  getEventCallbackName() {
+  _proto.getEventCallbackName = function getEventCallbackName() {
     return this.callbackName;
   }
 
   /**
    * Dispatches the request.
    * @return {Promise} A promise that is fulfilled when a response is received for this request.
-   */
-  dispatch() {
+   */;
+  _proto.dispatch = function dispatch() {
     return new Promise((resolve, reject) => {
       this.manager.handleDispatch(this, resolve, reject);
     });
@@ -64,11 +65,12 @@ class Request {
    * On timeout log error. Can be overridden by child classes.
    * @param {Function} resolve The resolve() callback of the request promise.
    * @param {Function} reject The reject() callback of the request promise.
-   */
-  onTimeout(resolve, reject) {
+   */;
+  _proto.onTimeout = function onTimeout(resolve, reject) {
     // eslint-disable-line class-methods-use-this
     logger.error('Request timeout');
     reject('Request timeout');
-  }
-}
+  };
+  return Request;
+}();
 export default Request;

package/classes/RequestBuffer/index.js

@@ -5,17 +5,18 @@ const REQUEST_BUFFER = 'RequestBuffer';
  * The RequestBuffer class.
  * It stores instances of performing request.
  */
-class RequestBuffer {
-  constructor() {
+let RequestBuffer = /*#__PURE__*/function () {
+  function RequestBuffer() {
     // Holds the ongoing requests.
     this.requests = {};
   }
+  var _proto = RequestBuffer.prototype;
   /**
    * Adds a new data request to the buffer store.
    * @param {Object} req The request to store.
    * @param {string} serial The serial for the request.
    */
-  add(req, serial) {
+  _proto.add = function add(req, serial) {
     const request = this.requests[serial];
     if (request) {
       logger.error(`${REQUEST_BUFFER}: a request with the serial '${serial}' already exists!`);
@@ -28,8 +29,8 @@ class RequestBuffer {
    * Retrieves a data request from the buffer.
    * @param {string} serial The serial for the request.
    * @returns {DataRequest}
-   */
-  get(serial) {
+   */;
+  _proto.get = function get(serial) {
     const request = this.requests[serial];
     if (!request) {
       logger.error(`${REQUEST_BUFFER}: no stored request for the serial '${serial}' found!`);
@@ -41,13 +42,14 @@ class RequestBuffer {
   /**
    * Removes the data request from the buffer.
    * @param {string} serial The serial for the request.
-   */
-  remove(serial) {
+   */;
+  _proto.remove = function remove(serial) {
     try {
       delete this.requests[serial];
     } catch (e) {
       logger.error(e);
     }
-  }
-}
+  };
+  return RequestBuffer;
+}();
 export default new RequestBuffer();

package/classes/RequestManager/index.js

@@ -1,3 +1,4 @@
+import _createClass from "@babel/runtime/helpers/createClass";
 import { logger } from "../../helpers";
 import { PROCESS_ANY, PROCESS_LAST_REQUEST, PROCESS_FIRST_RESPONSE, PROCESS_SEQUENTIALLY, PROCESS_ORDERED_REQUEST, PROPAGATE_REJECT, PROPAGATE_SINGLE } from "../../constants/RequestManagerModes";
 import { EPIPELINERESPONSEREJECTED } from "../../constants/Pipeline";
@@ -134,7 +135,7 @@ const processSequentially = (self, response, resolve) => {
  * The request manager handles processing of requests and
  * propagation of received responses.
  */
-class RequestManager {
+let RequestManager = /*#__PURE__*/function () {
   /**
    * Creates a new request manager.
    * @param {Object} options The options.
@@ -142,7 +143,7 @@ class RequestManager {
    * @param {string} options.propagationMode The propagation mode for queued requests.
    * @param {number|false} options.timeout Requests timeout duration.
    */
-  constructor({
+  function RequestManager({
     processingMode = PROCESS_ANY,
     propagationMode = PROPAGATE_SINGLE,
     timeout = false
@@ -162,7 +163,8 @@ class RequestManager {
    * @param {Function} resolve The resolve() callback of the request promise.
    * @param {Function} reject The reject() callback of the request promise.
    */
-  enqueueRequest(request, resolve, reject) {
+  var _proto = RequestManager.prototype;
+  _proto.enqueueRequest = function enqueueRequest(request, resolve, reject) {
     // Get the current timestamp.
     const timestamp = this.currentTime;
 
@@ -189,8 +191,8 @@ class RequestManager {
    * @param {Request} request The request.
    * @param {Function} resolve The resolve() callback of the request promise.
    * @param {Function} reject The reject() callback of the request promise.
-   */
-  handleDispatch(request, resolve, reject) {
+   */;
+  _proto.handleDispatch = function handleDispatch(request, resolve, reject) {
     if (this.processingMode !== PROCESS_ANY) {
       // Enqueue this request if it requires special handling.
       this.enqueueRequest(request, resolve, reject);
@@ -211,8 +213,8 @@ class RequestManager {
    * @param {Request} request The request this response belongs to.
    * @param {Function} reject The reject() callback of the request promise.
    * @param {Object} [message] The error object.
-   */
-  handleError(request, reject, message) {
+   */;
+  _proto.handleError = function handleError(request, reject, message) {
     clearTimeout(this.timers[request.serial]);
     delete this.timers[request.serial];
     if (this.processingMode === PROCESS_ANY) {
@@ -232,8 +234,8 @@ class RequestManager {
    * @param {Request} request The request this response belongs to.
    * @param {Function} resolve The resolve() callback of the request promise.
    * @param {Object} response The response.
-   */
-  handleResponse(request, resolve, response) {
+   */;
+  _proto.handleResponse = function handleResponse(request, resolve, response) {
     clearTimeout(this.timers[request.serial]);
     delete this.timers[request.serial];
     this.pendingRequests -= 1;
@@ -258,10 +260,13 @@ class RequestManager {
 
   /**
    * @return {number} The current unix timestamp.
-   */
-  get currentTime() {
-    // eslint-disable-line class-methods-use-this
-    return Date.now();
-  }
-}
+   */;
+  return _createClass(RequestManager, [{
+    key: "currentTime",
+    get: function () {
+      // eslint-disable-line class-methods-use-this
+      return Date.now();
+    }
+  }]);
+}();
 export default RequestManager;

package/classes/RequestManager/spec.js

@@ -1,42 +1,57 @@
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
 import Request from "../Request";
 import RequestManager from '.';
 import { PROCESS_ANY, PROCESS_LAST_REQUEST, PROCESS_FIRST_RESPONSE, PROCESS_SEQUENTIALLY, PROCESS_ORDERED_REQUEST, PROPAGATE_REJECT, PROPAGATE_SINGLE } from "../../constants/RequestManagerModes";
 
 /* eslint-disable require-jsdoc, no-unused-vars, class-methods-use-this */
-class SuccessfulRequest extends Request {
-  constructor(manager, payload = 42, timeout = 1000) {
-    super(manager);
-    this.createSerial('foo');
-    this.payload = payload;
-    this.timeout = timeout;
+let SuccessfulRequest = /*#__PURE__*/function (_Request) {
+  function SuccessfulRequest(manager, payload = 42, timeout = 1000) {
+    var _this;
+    _this = _Request.call(this, manager) || this;
+    _this.createSerial('foo');
+    _this.payload = payload;
+    _this.timeout = timeout;
+    return _this;
   }
-  onDispatch(resolve, reject) {
+  _inheritsLoose(SuccessfulRequest, _Request);
+  var _proto = SuccessfulRequest.prototype;
+  _proto.onDispatch = function onDispatch(resolve, reject) {
     setTimeout(() => {
       this.manager.handleResponse(this, resolve, this.payload);
     }, this.timeout);
+  };
+  return SuccessfulRequest;
+}(Request);
+let FailingRequest = /*#__PURE__*/function (_Request2) {
+  function FailingRequest(manager) {
+    var _this2;
+    _this2 = _Request2.call(this, manager) || this;
+    _this2.createSerial('foo');
+    return _this2;
   }
-}
-class FailingRequest extends Request {
-  constructor(manager) {
-    super(manager);
-    this.createSerial('foo');
-  }
-  onDispatch(resolve, reject) {
+  _inheritsLoose(FailingRequest, _Request2);
+  var _proto2 = FailingRequest.prototype;
+  _proto2.onDispatch = function onDispatch(resolve, reject) {
     this.manager.handleError(this, reject);
+  };
+  return FailingRequest;
+}(Request);
+let NeverResolvingRequest = /*#__PURE__*/function (_Request3) {
+  function NeverResolvingRequest(manager) {
+    var _this3;
+    _this3 = _Request3.call(this, manager) || this;
+    _this3.createSerial('foo');
+    return _this3;
   }
-}
-class NeverResolvingRequest extends Request {
-  constructor(manager) {
-    super(manager);
-    this.createSerial('foo');
-  }
-  onDispatch(resolve, reject) {}
-  onTimeout(resolve, reject) {
+  _inheritsLoose(NeverResolvingRequest, _Request3);
+  var _proto3 = NeverResolvingRequest.prototype;
+  _proto3.onDispatch = function onDispatch(resolve, reject) {};
+  _proto3.onTimeout = function onTimeout(resolve, reject) {
     this.manager.handleError(this, reject);
-  }
-}
+  };
+  return NeverResolvingRequest;
+}(Request);
 /* eslint-enable require-jsdoc, no-unused-vars, class-methods-use-this */
-
 describe.skip('RequestManager', () => {
   jest.useFakeTimers();
   let timestamp = 0;