@shopgate/pwa-core 7.30.0-alpha.7 → 7.30.0-alpha.9

package/classes/DevServerBridge/index.js

@@ -1,29 +1,105 @@
-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;}import fetch from'isomorphic-fetch';import{logger}from"../../helpers";import event from"../Event";/**
+import { logger } from "../../helpers";
+import event from "../Event";
+
+/**
  * The DevServerBridge emulates the SGJavaScriptBridge within browser environments.
  * It routes supported app commands to the Frontend SDK which can mimic the behavior of the app.
- */var DevServerBridge=/*#__PURE__*/function(){/**
+ */
+class DevServerBridge {
+  /**
    * The constructor.
    * @param {string} ip The IP of the dev server.
    * @param {number} port The port of the dev server.
-   */function DevServerBridge(){var ip=arguments.length>0&&arguments[0]!==undefined?arguments[0]:process.env.IP;var port=arguments.length>1&&arguments[1]!==undefined?arguments[1]:process.env.PORT;_classCallCheck(this,DevServerBridge);this.ip=ip;this.port=port;this.supportedCommands=['sendPipelineRequest','sendHttpRequest','sendDataRequest','getWebStorageEntry'];}/**
+   */
+  constructor(ip = process.env.IP, port = process.env.PORT) {
+    this.ip = ip;
+    this.port = port;
+    this.supportedCommands = ['sendPipelineRequest', 'sendHttpRequest', 'sendDataRequest', 'getWebStorageEntry'];
+  }
+
+  /**
    * Dispatches multiple commands to the dev server.
    * @param {Array} commands The commands to dispatch.
    * @param {string} libVersion The lib version for the command.
    * @return {DevServerBridge}
-   */return _createClass(DevServerBridge,[{key:"dispatchCommandsForVersion",value:function dispatchCommandsForVersion(commands,libVersion){var _this=this;if(Array.isArray(commands)){commands.forEach(function(command){_this.dispatchCommandForVersion(command,libVersion);});}return this;}/**
+   */
+  dispatchCommandsForVersion(commands, libVersion) {
+    if (Array.isArray(commands)) {
+      commands.forEach(command => {
+        this.dispatchCommandForVersion(command, libVersion);
+      });
+    }
+    return this;
+  }
+
+  /**
    * Dispatches a single command to the dev server.
    * @param {Object} command The command to dispatch.
    * @param {string} libVersion The lib version for the command.
    * @return {DevServerBridge}
-   */},{key:"dispatchCommandForVersion",value:function dispatchCommandForVersion(command,libVersion){var _ref=command||{},name=_ref.c;if(this.supportedCommands.includes(name)){// Append an optional suffix for special command related endpoints
-var suffix='';if(name==='getWebStorageEntry'){suffix='web_storage';}else if(name==='sendHttpRequest'){suffix='http_request';}var url="http://".concat(this.ip,":").concat(this.port,"/").concat(suffix);var options={method:'post',headers:new Headers({'Content-Type':'application/json'}),body:JSON.stringify({cmds:[command],ver:libVersion})};fetch(url,options).then(function(response){return response.json();}).then(this.processDevServerResponse)["catch"](function(err){return err&&logger.error(err);});}return this;}/**
+   */
+  dispatchCommandForVersion(command, libVersion) {
+    const {
+      c: name
+    } = command || {};
+    if (this.supportedCommands.includes(name)) {
+      // Append an optional suffix for special command related endpoints
+      let suffix = '';
+      if (name === 'getWebStorageEntry') {
+        suffix = 'web_storage';
+      } else if (name === 'sendHttpRequest') {
+        suffix = 'http_request';
+      }
+      const url = `http://${this.ip}:${this.port}/${suffix}`;
+      const options = {
+        method: 'post',
+        headers: new Headers({
+          'Content-Type': 'application/json'
+        }),
+        body: JSON.stringify({
+          cmds: [command],
+          ver: libVersion
+        })
+      };
+      fetch(url, options).then(response => response.json()).then(this.processDevServerResponse).catch(err => err && logger.error(err));
+    }
+    return this;
+  }
+
+  /**
    * Handles a response of the dev server.
    * @param {Object} response The server response.
    * @return {DevServerBridge}
-   */},{key:"processDevServerResponse",value:function processDevServerResponse(response){var _ref2=response||{},_ref2$cmds=_ref2.cmds,cmds=_ref2$cmds===void 0?[]:_ref2$cmds;// Process the response commands.
-cmds.forEach(function(command){var name=command.c;var params=command.p;var args=[];/**
+   */
+  processDevServerResponse(response) {
+    const {
+      cmds = []
+    } = response || {};
+
+    // Process the response commands.
+    cmds.forEach(command => {
+      const name = command.c;
+      const params = command.p;
+      let args = [];
+
+      /**
        * The server returns a response command for a request command.
        * If the native app receives such a command, it calls a related event within the
        * webviews. Here the response parameters are sorted in the specified order for
        * the different response events.
-       */if(name==='pipelineResponse'){args=[params.error,params.serial,params.output];}else if(name==='httpResponse'){args=[params.error,params.serial,params.response];}else if(name==='dataResponse'){args=[params.serial,params.status,params.body,params.bodyContentType];}else if(name==='webStorageResponse'){args=[params.serial,params.age,params.value];}event.call(name,args);});return this;}}]);}();export default DevServerBridge;
+       */
+      if (name === 'pipelineResponse') {
+        args = [params.error, params.serial, params.output];
+      } else if (name === 'httpResponse') {
+        args = [params.error, params.serial, params.response];
+      } else if (name === 'dataResponse') {
+        args = [params.serial, params.status, params.body, params.bodyContentType];
+      } else if (name === 'webStorageResponse') {
+        args = [params.serial, params.age, params.value];
+      }
+      event.call(name, args);
+    });
+    return this;
+  }
+}
+export default DevServerBridge;

package/classes/DevServerBridge/spec.js

@@ -1,15 +1,231 @@
-function _slicedToArray(arr,i){return _arrayWithHoles(arr)||_iterableToArrayLimit(arr,i)||_nonIterableRest();}function _nonIterableRest(){throw new TypeError("Invalid attempt to destructure non-iterable instance");}function _iterableToArrayLimit(arr,i){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 _arrayWithHoles(arr){if(Array.isArray(arr))return arr;}import DevServerBridge from"./index";// A libVersion for the bridge method calls
-var libVersion='16.1';var devServerIp='192.168.0.1';var devServerPort='1337';// Mocks of the env variables.
-global.process.env={IP:devServerIp,PORT:devServerPort};// Mocks of the global Headers class.
-global.Headers=function(){};// Create a mock for the fetch method.
-var mockedFetchResponse={};var mockedFetch;jest.mock('isomorphic-fetch',function(){return function(){return mockedFetch.apply(void 0,arguments);};});// Create a mock for the Event class.
-var mockedEventCall=jest.fn();jest.mock("../Event",function(){return{call:function call(){return mockedEventCall.apply(void 0,arguments);}};});// Create a mock for the error logger.
-var mockedLoggerError=jest.fn();jest.mock("../../helpers",function(){return{logger:{error:function error(){mockedLoggerError.apply(void 0,arguments);}}};});var dispatchCommandSpy;var processResponseSpy;/**
+import DevServerBridge from "./index";
+
+// A libVersion for the bridge method calls
+const libVersion = '16.1';
+const devServerIp = '192.168.0.1';
+const devServerPort = '1337';
+
+// Mocks of the env variables.
+global.process.env = {
+  IP: devServerIp,
+  PORT: devServerPort
+};
+
+// Mocks of the global Headers class.
+global.Headers = class Headers {};
+
+// Create a mock for the fetch method.
+const mockedFetchResponse = {};
+let mockedFetch;
+beforeAll(() => {
+  global.fetch = jest.fn(); // mock fetch globally
+});
+
+// Create a mock for the Event class.
+const mockedEventCall = jest.fn();
+jest.mock("../Event", () => ({
+  call: (...args) => mockedEventCall(...args)
+}));
+
+// Create a mock for the error logger.
+const mockedLoggerError = jest.fn();
+jest.mock("../../helpers", () => ({
+  logger: {
+    error: (...args) => {
+      mockedLoggerError(...args);
+    }
+  }
+}));
+let dispatchCommandSpy;
+let processResponseSpy;
+
+/**
  * Updates the mock for the fetch module.
- * @param {boolean} throwError Wheater the mocked fetch shall throw an error.
- */var updateMockedFetch=function updateMockedFetch(){var throwError=arguments.length>0&&arguments[0]!==undefined?arguments[0]:false;if(!throwError){mockedFetch=jest.fn().mockResolvedValue({json:function json(){return mockedFetchResponse;}});}else{mockedFetch=jest.fn().mockRejectedValue(new Error());}};describe('DevServerBridge',function(){var instance;beforeEach(function(){mockedEventCall.mockClear();updateMockedFetch();instance=new DevServerBridge();dispatchCommandSpy=jest.spyOn(instance,'dispatchCommandForVersion');processResponseSpy=jest.spyOn(instance,'processDevServerResponse');});describe('.constructor()',function(){it('should work as expected without parameters',function(){expect(instance.ip).toBe(devServerIp);expect(instance.port).toBe(devServerPort);});it('should apply custom parameters',function(){var customIp='127.0.0.1';var customPort='4711';instance=new DevServerBridge(customIp,customPort);expect(instance.ip).toBe(customIp);expect(instance.port).toBe(customPort);});});describe('.dispatchCommandsForVersion()',function(){it('should call dispatchCommand for every single command',function(){var commands=[{c:'sendPipelineRequest'},{c:'openPage'}];var result=instance.dispatchCommandsForVersion(commands,libVersion);expect(result).toEqual(instance);expect(dispatchCommandSpy).toHaveBeenCalledTimes(2);expect(dispatchCommandSpy.mock.calls[0][0].c).toBe('sendPipelineRequest');expect(dispatchCommandSpy.mock.calls[0][1]).toBe(libVersion);expect(dispatchCommandSpy.mock.calls[1][0].c).toBe('openPage');expect(dispatchCommandSpy.mock.calls[1][1]).toBe(libVersion);});it('should call dispatchCommand when no commands where passed',function(){var result=instance.dispatchCommandsForVersion(null,libVersion);expect(result).toEqual(instance);expect(dispatchCommandSpy).toHaveBeenCalledTimes(0);});});describe('.dispatchCommandForVersion()',function(){it('should dispatch a webStorage entry command',function(done){var name='getWebStorageEntry';var command={c:name};var result=instance.dispatchCommandForVersion(command,libVersion);expect(result).toEqual(instance);// The dispatch method has async behavior. So we wait for the next tick before we check.
-setTimeout(function(){expect(mockedFetch).toHaveBeenCalledTimes(1);expect(mockedFetch.mock.calls[0][0].endsWith('web_storage')).toBe(true);expect(mockedFetch.mock.calls[0][1].body.includes(name)).toBe(true);expect(processResponseSpy).toHaveBeenCalledTimes(1);done();},0);});it('should dispatch a httpRequest command',function(done){var name='sendHttpRequest';var command={c:name};var result=instance.dispatchCommandForVersion(command,libVersion);expect(result).toEqual(instance);// The dispatch method has async behavior. So we wait for the next tick before we check.
-setTimeout(function(){expect(mockedFetch).toHaveBeenCalledTimes(1);expect(mockedFetch.mock.calls[0][0].endsWith('http_request')).toBe(true);expect(mockedFetch.mock.calls[0][1].body.includes(name)).toBe(true);expect(processResponseSpy).toHaveBeenCalledTimes(1);done();},0);});it('should not do anything if the command is not whitelisted',function(done){var command={c:'openPage'};var result=instance.dispatchCommandForVersion(command,libVersion);expect(result).toEqual(instance);// The dispatch method has async behavior. So we wait for the next tick before we check.
-setTimeout(function(){expect(mockedFetch).toHaveBeenCalledTimes(0);expect(processResponseSpy).toHaveBeenCalledTimes(0);done();},0);});it('should not do anything if the command is empty',function(done){var result=instance.dispatchCommandForVersion(null,libVersion);expect(result).toEqual(instance);// The dispatch method has async behavior. So we wait for the next tick before we check.
-setTimeout(function(){expect(mockedFetch).toHaveBeenCalledTimes(0);expect(processResponseSpy).toHaveBeenCalledTimes(0);done();},0);});it('should handle fetch errors',function(done){updateMockedFetch(true);var command={c:'sendPipelineRequest'};var result=instance.dispatchCommandForVersion(command,libVersion);expect(result).toEqual(instance);// The dispatch method has async behavior. So we wait for the next tick before we check.
-setTimeout(function(){expect(mockedFetch).toHaveBeenCalledTimes(1);expect(processResponseSpy).toHaveBeenCalledTimes(0);expect(mockedLoggerError).toHaveBeenCalledTimes(1);expect(mockedLoggerError.mock.calls[0][0]).toBeInstanceOf(Error);done();},0);});});describe('.processDevServerResponse()',function(){it('should handle a response commands as expected',function(){var serial='abc123';var commands=[{c:'pipelineResponse',p:{serial:serial,error:null,output:{}}},{c:'httpResponse',p:{serial:serial,error:null,response:{}}},{c:'dataResponse',p:{serial:serial,status:200,body:'',bodyContentType:''}},{c:'webStorageResponse',p:{serial:serial,age:40,value:{}}},{c:'unknownResponse',p:{}}];var result=instance.processDevServerResponse({cmds:commands});expect(result).toEqual(instance);expect(mockedEventCall).toHaveBeenCalledTimes(5);var _mockedEventCall$mock=_slicedToArray(mockedEventCall.mock.calls,5),pipelineResponse=_mockedEventCall$mock[0],httpResponse=_mockedEventCall$mock[1],dataResponse=_mockedEventCall$mock[2],webStorageResponse=_mockedEventCall$mock[3],unknownResponse=_mockedEventCall$mock[4];expect(pipelineResponse[0]).toBe('pipelineResponse');expect(pipelineResponse[1]).toHaveLength(3);expect(pipelineResponse[1][1]).toBe(serial);expect(httpResponse[0]).toBe('httpResponse');expect(httpResponse[1]).toHaveLength(3);expect(httpResponse[1][1]).toBe(serial);expect(dataResponse[0]).toBe('dataResponse');expect(dataResponse[1]).toHaveLength(4);expect(dataResponse[1][0]).toBe(serial);expect(webStorageResponse[0]).toBe('webStorageResponse');expect(webStorageResponse[1]).toHaveLength(3);expect(webStorageResponse[1][0]).toBe(serial);expect(unknownResponse[0]).toBe('unknownResponse');expect(unknownResponse[1]).toHaveLength(0);});it('should work as expected when nothing was passed',function(){var result=instance.processDevServerResponse(null);expect(result).toEqual(instance);expect(mockedEventCall).toHaveBeenCalledTimes(0);});});});
+ * @param {boolean} throwError Whether the mocked fetch shall throw an error.
+ */
+const updateMockedFetch = (throwError = false) => {
+  mockedFetch = throwError ? jest.fn().mockRejectedValue(new Error()) : jest.fn().mockResolvedValue({
+    json: () => mockedFetchResponse
+  });
+  global.fetch.mockImplementation((...args) => mockedFetch(...args));
+};
+describe('DevServerBridge', () => {
+  let instance;
+  beforeEach(() => {
+    mockedEventCall.mockClear();
+    updateMockedFetch();
+    instance = new DevServerBridge();
+    dispatchCommandSpy = jest.spyOn(instance, 'dispatchCommandForVersion');
+    processResponseSpy = jest.spyOn(instance, 'processDevServerResponse');
+  });
+  describe('.constructor()', () => {
+    it('should work as expected without parameters', () => {
+      expect(instance.ip).toBe(devServerIp);
+      expect(instance.port).toBe(devServerPort);
+    });
+    it('should apply custom parameters', () => {
+      const customIp = '127.0.0.1';
+      const customPort = '4711';
+      instance = new DevServerBridge(customIp, customPort);
+      expect(instance.ip).toBe(customIp);
+      expect(instance.port).toBe(customPort);
+    });
+  });
+  describe('.dispatchCommandsForVersion()', () => {
+    it('should call dispatchCommand for every single command', () => {
+      const commands = [{
+        c: 'sendPipelineRequest'
+      }, {
+        c: 'openPage'
+      }];
+      const result = instance.dispatchCommandsForVersion(commands, libVersion);
+      expect(result).toEqual(instance);
+      expect(dispatchCommandSpy).toHaveBeenCalledTimes(2);
+      expect(dispatchCommandSpy.mock.calls[0][0].c).toBe('sendPipelineRequest');
+      expect(dispatchCommandSpy.mock.calls[0][1]).toBe(libVersion);
+      expect(dispatchCommandSpy.mock.calls[1][0].c).toBe('openPage');
+      expect(dispatchCommandSpy.mock.calls[1][1]).toBe(libVersion);
+    });
+    it('should call dispatchCommand when no commands where passed', () => {
+      const result = instance.dispatchCommandsForVersion(null, libVersion);
+      expect(result).toEqual(instance);
+      expect(dispatchCommandSpy).toHaveBeenCalledTimes(0);
+    });
+  });
+  describe('.dispatchCommandForVersion()', () => {
+    it('should dispatch a webStorage entry command', done => {
+      const name = 'getWebStorageEntry';
+      const command = {
+        c: name
+      };
+      const result = instance.dispatchCommandForVersion(command, libVersion);
+      expect(result).toEqual(instance);
+      // The dispatch method has async behavior. So we wait for the next tick before we check.
+      setTimeout(() => {
+        expect(mockedFetch).toHaveBeenCalledTimes(1);
+        expect(mockedFetch.mock.calls[0][0].endsWith('web_storage')).toBe(true);
+        expect(mockedFetch.mock.calls[0][1].body.includes(name)).toBe(true);
+        expect(processResponseSpy).toHaveBeenCalledTimes(1);
+        done();
+      }, 0);
+    });
+    it('should dispatch a httpRequest command', done => {
+      const name = 'sendHttpRequest';
+      const command = {
+        c: name
+      };
+      const result = instance.dispatchCommandForVersion(command, libVersion);
+      expect(result).toEqual(instance);
+      // The dispatch method has async behavior. So we wait for the next tick before we check.
+      setTimeout(() => {
+        expect(mockedFetch).toHaveBeenCalledTimes(1);
+        expect(mockedFetch.mock.calls[0][0].endsWith('http_request')).toBe(true);
+        expect(mockedFetch.mock.calls[0][1].body.includes(name)).toBe(true);
+        expect(processResponseSpy).toHaveBeenCalledTimes(1);
+        done();
+      }, 0);
+    });
+    it('should not do anything if the command is not whitelisted', done => {
+      const command = {
+        c: 'openPage'
+      };
+      const result = instance.dispatchCommandForVersion(command, libVersion);
+      expect(result).toEqual(instance);
+      // The dispatch method has async behavior. So we wait for the next tick before we check.
+      setTimeout(() => {
+        expect(mockedFetch).toHaveBeenCalledTimes(0);
+        expect(processResponseSpy).toHaveBeenCalledTimes(0);
+        done();
+      }, 0);
+    });
+    it('should not do anything if the command is empty', done => {
+      const result = instance.dispatchCommandForVersion(null, libVersion);
+      expect(result).toEqual(instance);
+      // The dispatch method has async behavior. So we wait for the next tick before we check.
+      setTimeout(() => {
+        expect(mockedFetch).toHaveBeenCalledTimes(0);
+        expect(processResponseSpy).toHaveBeenCalledTimes(0);
+        done();
+      }, 0);
+    });
+    it('should handle fetch errors', done => {
+      updateMockedFetch(true);
+      const command = {
+        c: 'sendPipelineRequest'
+      };
+      const result = instance.dispatchCommandForVersion(command, libVersion);
+      expect(result).toEqual(instance);
+      // The dispatch method has async behavior. So we wait for the next tick before we check.
+      setTimeout(() => {
+        expect(mockedFetch).toHaveBeenCalledTimes(1);
+        expect(processResponseSpy).toHaveBeenCalledTimes(0);
+        expect(mockedLoggerError).toHaveBeenCalledTimes(1);
+        expect(mockedLoggerError.mock.calls[0][0]).toBeInstanceOf(Error);
+        done();
+      }, 0);
+    });
+  });
+  describe('.processDevServerResponse()', () => {
+    it('should handle a response commands as expected', () => {
+      const serial = 'abc123';
+      const commands = [{
+        c: 'pipelineResponse',
+        p: {
+          serial,
+          error: null,
+          output: {}
+        }
+      }, {
+        c: 'httpResponse',
+        p: {
+          serial,
+          error: null,
+          response: {}
+        }
+      }, {
+        c: 'dataResponse',
+        p: {
+          serial,
+          status: 200,
+          body: '',
+          bodyContentType: ''
+        }
+      }, {
+        c: 'webStorageResponse',
+        p: {
+          serial,
+          age: 40,
+          value: {}
+        }
+      }, {
+        c: 'unknownResponse',
+        p: {}
+      }];
+      const result = instance.processDevServerResponse({
+        cmds: commands
+      });
+      expect(result).toEqual(instance);
+      expect(mockedEventCall).toHaveBeenCalledTimes(5);
+      const [pipelineResponse, httpResponse, dataResponse, webStorageResponse, unknownResponse] = mockedEventCall.mock.calls;
+      expect(pipelineResponse[0]).toBe('pipelineResponse');
+      expect(pipelineResponse[1]).toHaveLength(3);
+      expect(pipelineResponse[1][1]).toBe(serial);
+      expect(httpResponse[0]).toBe('httpResponse');
+      expect(httpResponse[1]).toHaveLength(3);
+      expect(httpResponse[1][1]).toBe(serial);
+      expect(dataResponse[0]).toBe('dataResponse');
+      expect(dataResponse[1]).toHaveLength(4);
+      expect(dataResponse[1][0]).toBe(serial);
+      expect(webStorageResponse[0]).toBe('webStorageResponse');
+      expect(webStorageResponse[1]).toHaveLength(3);
+      expect(webStorageResponse[1][0]).toBe(serial);
+      expect(unknownResponse[0]).toBe('unknownResponse');
+      expect(unknownResponse[1]).toHaveLength(0);
+    });
+    it('should work as expected when nothing was passed', () => {
+      const result = instance.processDevServerResponse(null);
+      expect(result).toEqual(instance);
+      expect(mockedEventCall).toHaveBeenCalledTimes(0);
+    });
+  });
+});

package/classes/ErrorManager/index.js

@@ -1,26 +1,100 @@
-import _regeneratorRuntime from"@babel/runtime/regenerator";function _extends(){_extends=Object.assign||function(target){for(var i=1;i<arguments.length;i++){var source=arguments[i];for(var key in source){if(Object.prototype.hasOwnProperty.call(source,key)){target[key]=source[key];}}}return target;};return _extends.apply(this,arguments);}function asyncGeneratorStep(gen,resolve,reject,_next,_throw,key,arg){try{var info=gen[key](arg);var value=info.value;}catch(error){reject(error);return;}if(info.done){resolve(value);}else{Promise.resolve(value).then(_next,_throw);}}function _asyncToGenerator(fn){return function(){var self=this,args=arguments;return new Promise(function(resolve,reject){var gen=fn.apply(self,args);function _next(value){asyncGeneratorStep(gen,resolve,reject,_next,_throw,"next",value);}function _throw(err){asyncGeneratorStep(gen,resolve,reject,_next,_throw,"throw",err);}_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});}else{obj[key]=value;}return obj;}import EventEmitter from'events';import{DEFAULT_CONTEXT,SOURCE_PIPELINE,DEFAULT_SEVERITY}from"../../constants/ErrorManager";export var emitter=new EventEmitter();var pipelineVersionSuffix=/\.v\d+$/;/**
+import "core-js/modules/es.string.replace.js";
+import EventEmitter from 'events';
+import { DEFAULT_CONTEXT, SOURCE_PIPELINE, DEFAULT_SEVERITY } from "../../constants/ErrorManager";
+export const emitter = new EventEmitter();
+const pipelineVersionSuffix = /\.v\d+$/;
+
+/**
  * The ErrorManager class.
- */var ErrorManager=/*#__PURE__*/function(){/**
+ */
+class ErrorManager {
+  /**
    * Constructor.
-   */function ErrorManager(){var _this=this;_classCallCheck(this,ErrorManager);/**
-   * Calls dispatch() as an interval.
-   */_defineProperty(this,"startTimer",/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(){return _regeneratorRuntime.wrap(function _callee$(_context){while(1)switch(_context.prev=_context.next){case 0:_context.next=2;return _this.stopTimer();case 2:_this.timer=setInterval(_this.dispatch,500);case 3:case"end":return _context.stop();}},_callee);})));/**
-   * Clears the dispatch interval.
-   */_defineProperty(this,"stopTimer",/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2(){return _regeneratorRuntime.wrap(function _callee2$(_context2){while(1)switch(_context2.prev=_context2.next){case 0:_context2.next=2;return clearInterval(_this.timer);case 2:_this.timer=null;case 3:case"end":return _context2.stop();}},_callee2);})));/**
-   * Dispatched the stored error objects through the event emitter.
-   * @returns {boolean}
-   */_defineProperty(this,"dispatch",function(){if(_this.errorQueue.size===0){return false;}_this.errorQueue.forEach(function(error){emitter.emit(error.source,error);});_this.stopTimer();_this.errorQueue.clear();return true;});/**
-   * Validates an error object.
-   * @param {*} error The error object.
-   * @returns {boolean}
-   */_defineProperty(this,"validate",function(){var error=arguments.length>0&&arguments[0]!==undefined?arguments[0]:{};var _error$code=error.code,code=_error$code===void 0?null:_error$code,_error$message=error.message,message=_error$message===void 0?null:_error$message,_error$source=error.source,source=_error$source===void 0?null:_error$source;if(!code||!message||!source){return false;}if(typeof code!=='string'||typeof source!=='string'){return false;}return typeof message==='string'||typeof message==='function';});// Queue of errors that will be dispatched.
-this.errorQueue=new Map();// List of override message for specific errors.
-this.messages={};// A variable to handle the intervals.
-this.timer=null;}/**
+   */
+  constructor() {
+    /**
+     * Calls dispatch() as an interval.
+     */
+    this.startTimer = async () => {
+      await this.stopTimer();
+      this.timer = setInterval(this.dispatch, 500);
+    };
+    /**
+     * Clears the dispatch interval.
+     */
+    this.stopTimer = async () => {
+      await clearInterval(this.timer);
+      this.timer = null;
+    };
+    /**
+     * Dispatched the stored error objects through the event emitter.
+     * @returns {boolean}
+     */
+    this.dispatch = () => {
+      if (this.errorQueue.size === 0) {
+        return false;
+      }
+      this.errorQueue.forEach(error => {
+        emitter.emit(error.source, error);
+      });
+      this.stopTimer();
+      this.errorQueue.clear();
+      return true;
+    };
+    /**
+     * Validates an error object.
+     * @param {*} error The error object.
+     * @returns {boolean}
+     */
+    this.validate = (error = {}) => {
+      const {
+        code = null,
+        message = null,
+        source = null
+      } = error;
+      if (!code || !message || !source) {
+        return false;
+      }
+      if (typeof code !== 'string' || typeof source !== 'string') {
+        return false;
+      }
+      return typeof message === 'string' || typeof message === 'function';
+    };
+    // Queue of errors that will be dispatched.
+    this.errorQueue = new Map();
+
+    // List of override message for specific errors.
+    this.messages = {};
+
+    // A variable to handle the intervals.
+    this.timer = null;
+  }
+
+  /**
    * Gets a message by the given error.
    * @param {{ code: string, context: string, source: string }} error The error object.
    * @returns {string|null}
-   */return _createClass(ErrorManager,[{key:"getMessage",value:function getMessage(error){if(!this.validate(error)){return null;}var code=error.code,_error$context=error.context,context=_error$context===void 0?DEFAULT_CONTEXT:_error$context,source=error.source;var id="".concat(source,"-").concat(context,"-").concat(code);var unvId="".concat(source,"-").concat(context.replace(pipelineVersionSuffix,''),"-").concat(code);var defaultId="".concat(source,"-").concat(DEFAULT_CONTEXT,"-").concat(code);var message=this.messages[id]||this.messages[unvId]||this.messages[defaultId]||null;if(typeof message==='function'){message=message(error);}return message;}/**
+   */
+  getMessage(error) {
+    if (!this.validate(error)) {
+      return null;
+    }
+    const {
+      code,
+      context = DEFAULT_CONTEXT,
+      source
+    } = error;
+    const id = `${source}-${context}-${code}`;
+    const unvId = `${source}-${context.replace(pipelineVersionSuffix, '')}-${code}`;
+    const defaultId = `${source}-${DEFAULT_CONTEXT}-${code}`;
+    let message = this.messages[id] || this.messages[unvId] || this.messages[defaultId] || null;
+    if (typeof message === 'function') {
+      message = message(error);
+    }
+    return message;
+  }
+
+  /**
    * Sets an override for a specific error message.
    * @param {Object} errorTemplate The error object.
    * @param {string} errorTemplate.code The error code.
@@ -28,7 +102,24 @@ this.timer=null;}/**
    * @param {string} errorTemplate.message The default error message.
    * @param {string} [errorTemplate.source=SOURCE_PIPELINE] The source of the error.
    * @returns {ErrorManager}
-   */},{key:"setMessage",value:function setMessage(){var errorTemplate=arguments.length>0&&arguments[0]!==undefined?arguments[0]:{};var error=_extends({source:SOURCE_PIPELINE},errorTemplate);if(!this.validate(error)){return this;}var _error$context2=error.context,context=_error$context2===void 0?DEFAULT_CONTEXT:_error$context2;var id="".concat(error.source,"-").concat(context,"-").concat(error.code);this.messages[id]=error.message;return this;}/**
+   */
+  setMessage(errorTemplate = {}) {
+    const error = {
+      source: SOURCE_PIPELINE,
+      ...errorTemplate
+    };
+    if (!this.validate(error)) {
+      return this;
+    }
+    const {
+      context = DEFAULT_CONTEXT
+    } = error;
+    const id = `${error.source}-${context}-${error.code}`;
+    this.messages[id] = error.message;
+    return this;
+  }
+
+  /**
    * Adds a new error object to the queue.
    * @param {Object} error The error object.
    * @param {string} error.code The error code.
@@ -36,4 +127,37 @@ this.timer=null;}/**
    * @param {string} error.message The default error message.
    * @param {string} error.source The source of the error.
    * @param {Object} error.meta Some meta data.
-   */},{key:"queue",value:function queue(){var error=arguments.length>0&&arguments[0]!==undefined?arguments[0]:{};if(!this.validate(error)){return;}var code=error.code,_error$context3=error.context,context=_error$context3===void 0?DEFAULT_CONTEXT:_error$context3,message=error.message,source=error.source,meta=error.meta,_error$severity=error.severity,severity=_error$severity===void 0?DEFAULT_SEVERITY:_error$severity;var id="".concat(source,"-").concat(context,"-").concat(code);var overrideMessage=this.getMessage(error)||message;this.errorQueue.set(id,{id:id,code:code,context:context,message:overrideMessage,meta:_extends({},meta,{message:message}),source:source,severity:severity});if(!this.timer){this.startTimer();}}}]);}();/** @type {ErrorManager} */export default new ErrorManager();
+   */
+  queue(error = {}) {
+    if (!this.validate(error)) {
+      return;
+    }
+    const {
+      code,
+      context = DEFAULT_CONTEXT,
+      message,
+      source,
+      meta,
+      severity = DEFAULT_SEVERITY
+    } = error;
+    const id = `${source}-${context}-${code}`;
+    const overrideMessage = this.getMessage(error) || message;
+    this.errorQueue.set(id, {
+      id,
+      code,
+      context,
+      message: overrideMessage,
+      meta: {
+        ...meta,
+        message
+      },
+      source,
+      severity
+    });
+    if (!this.timer) {
+      this.startTimer();
+    }
+  }
+}
+/** @type {ErrorManager} */
+export default new ErrorManager();