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

package/classes/ScannerEventListener/index.js

@@ -4,86 +4,85 @@ import AppScanner from "../Scanner";
 /**
  * Allows anyone to listen for scan results based on scope, type or both.
  */
-class ScannerEventListener {
+let ScannerEventListener =
+/**
+ * @param {string|null} name A name for the listener object to refer to.
+ * @param {string|null} scope The scanner scope to listen for.
+ * @param {string|null} type THe type of scanner events to listen for.
+ * @param {Array} formats The formats which can be processed by the listener.
+ */
+function ScannerEventListener(name = null, scope = null, type = null, formats = []) {
+  /**
+   * Callback for an instance of an event listener. It is expected to return no value on success.
+   * Throw an Error() to force the scanner to restart.
+   *
+   * @callback ScannerEventListener~Handler
+   * @param {ScannerEvent} event The event which is emitted, when something was scanned.
+   * @returns {undefined|null} The return value is ignored. Returning a value will cause a warning.
+   * @throws {Error} Throwing an error will cause the Scanner to restart and scan again.
+   */
+  /**
+   * @param {Handler} handler The function which is called when a scan is done.
+   * @returns {ScannerEventListener}
+   */
+  this.setHandler = handler => {
+    if (typeof handler !== 'function') {
+      logger.error(new Error('The ScannerEventListener handler must be a function!'));
+    }
+    this.handler = handler;
+    return this;
+  };
+  /**
+   * Checks if the event fits to the handler.
+   * @param {ScannerEvent} event The scanner event which was emitted.
+   * @returns {boolean}
+   */
+  this.canHandleEvent = event => {
+    if (!this.handler) {
+      logger.warn(`No event handler defined for eventListener "${this.name}"`);
+      return false;
+    }
+    if (this.type && this.type !== event.getType()) {
+      return false;
+    }
+    if (this.scope && this.scope !== event.getScope()) {
+      return false;
+    }
+    const {
+      format
+    } = event.getPayload() || {};
+    if (this.formats.length && !this.formats.includes(format)) {
+      return false;
+    }
+    return true;
+  };
+  /**
+   * Attach the current event listener to the app scanner.
+   */
+  this.attach = () => {
+    AppScanner.addListener(this);
+  };
   /**
-   * @param {string|null} name A name for the listener object to refer to.
-   * @param {string|null} scope The scanner scope to listen for.
-   * @param {string|null} type THe type of scanner events to listen for.
-   * @param {Array} formats The formats which can be processed by the listener.
+   * Checks the event to see, if the listener is interested in it and call it's handler.
+   * @param {ScannerEvent} event The scanner event which was emitted.
    */
-  constructor(name = null, scope = null, type = null, formats = []) {
-    /**
-     * Callback for an instance of an event listener. It is expected to return no value on success.
-     * Throw an Error() to force the scanner to restart.
-     *
-     * @callback ScannerEventListener~Handler
-     * @param {ScannerEvent} event The event which is emitted, when something was scanned.
-     * @returns {undefined|null} The return value is ignored. Returning a value will cause a warning.
-     * @throws {Error} Throwing an error will cause the Scanner to restart and scan again.
-     */
-    /**
-     * @param {Handler} handler The function which is called when a scan is done.
-     * @returns {ScannerEventListener}
-     */
-    this.setHandler = handler => {
-      if (typeof handler !== 'function') {
-        logger.error(new Error('The ScannerEventListener handler must be a function!'));
-      }
-      this.handler = handler;
-      return this;
-    };
-    /**
-     * Checks if the event fits to the handler.
-     * @param {ScannerEvent} event The scanner event which was emitted.
-     * @returns {boolean}
-     */
-    this.canHandleEvent = event => {
-      if (!this.handler) {
-        logger.warn(`No event handler defined for eventListener "${this.name}"`);
-        return false;
-      }
-      if (this.type && this.type !== event.getType()) {
-        return false;
-      }
-      if (this.scope && this.scope !== event.getScope()) {
-        return false;
-      }
-      const {
-        format
-      } = event.getPayload() || {};
-      if (this.formats.length && !this.formats.includes(format)) {
-        return false;
-      }
-      return true;
-    };
-    /**
-     * Attach the current event listener to the app scanner.
-     */
-    this.attach = () => {
-      AppScanner.addListener(this);
-    };
-    /**
-     * Checks the event to see, if the listener is interested in it and call it's handler.
-     * @param {ScannerEvent} event The scanner event which was emitted.
-     */
-    this.notify = async event => {
-      if (!this.canHandleEvent(event)) {
-        return;
-      }
+  this.notify = async event => {
+    if (!this.canHandleEvent(event)) {
+      return;
+    }
 
-      // Call the listener which was previously registered
-      const handlerResult = await this.handler(event);
+    // Call the listener which was previously registered
+    const handlerResult = await this.handler(event);
 
-      // Don't expect anything else than undefined or null
-      if (handlerResult !== undefined && handlerResult !== null) {
-        logger.warn(`Expected the ScannerEventListener::Handler "${this.name}" to return no value,`, `but it returned "${handlerResult}"`);
-      }
-    };
-    this.name = name || 'unnamed';
-    this.scope = scope || null;
-    this.type = type || null;
-    this.formats = formats || [];
-    this.handler = null;
-  }
-}
+    // Don't expect anything else than undefined or null
+    if (handlerResult !== undefined && handlerResult !== null) {
+      logger.warn(`Expected the ScannerEventListener::Handler "${this.name}" to return no value,`, `but it returned "${handlerResult}"`);
+    }
+  };
+  this.name = name || 'unnamed';
+  this.scope = scope || null;
+  this.type = type || null;
+  this.formats = formats || [];
+  this.handler = null;
+};
 export default ScannerEventListener;

package/classes/ScannerManager/ScanProcessingError.js

@@ -1,17 +1,23 @@
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _wrapNativeSuper from "@babel/runtime/helpers/wrapNativeSuper";
 /**
  * The ScanProcessingError is supposed to be thrown in case of a processing error of the scanned
  * content. It's properties will be used to display an error message to the user.
  * @extends Error
  */
-class ScanProcessingError extends Error {
+let ScanProcessingError = /*#__PURE__*/function (_Error) {
   /**
    * Constructor for the ScanProcessingError
    * @param {string} message The message of the error.
    * @param {string} [title=null] The title of the error.
    */
-  constructor(message, title = null) {
-    super(message);
-    this.title = title;
+  function ScanProcessingError(message, title = null) {
+    var _this;
+    _this = _Error.call(this, message) || this;
+    _this.title = title;
+    return _this;
   }
-}
+  _inheritsLoose(ScanProcessingError, _Error);
+  return ScanProcessingError;
+}(/*#__PURE__*/_wrapNativeSuper(Error));
 export default ScanProcessingError;

package/classes/ScannerManager/index.js

@@ -3,7 +3,7 @@ import event from "../Event";
 import registerEvents from "../../commands/registerEvents";
 import broadcastEvent from "../../commands/broadcastEvent";
 import { SCANNER_MODE_ON, SCANNER_TYPE_BARCODE, SCANNER_TYPE_IMAGE } from "../../constants/Scanner";
-import { openScanner, closeScanner, startScanner } from "../../commands/scanner";
+import { openScanner as _openScanner, closeScanner as _closeScanner, startScanner } from "../../commands/scanner";
 export const APP_EVENT_CLOSE_SCANNER = 'closeScanner';
 export const APP_EVENT_SCANNER_DID_SCAN = 'scannerDidScan';
 export const APP_EVENT_SCANNER_ERROR_CONFIRMED = 'scannerErrorConfirmed';
@@ -22,14 +22,14 @@ let eventsRegistered = false;
  * register a handler callback to process the scanned content.
  * @deprecated This is a legacy implementation. Use Scanner instead.
  */
-class ScannerManager {
+let ScannerManager = /*#__PURE__*/function () {
   /**
    * The ScannerManager constructor.
    * @param {Object} options Options for the ScannerManager.
    * @param {boolean} [options.autoClose=true] If set to TRUE, the app scanner will close
    *  automatically after a successful scan.
    */
-  constructor(options = {}) {
+  function ScannerManager(options = {}) {
     this.autoClose = true;
     if (typeof options.autoClose === 'boolean') {
       this.autoClose = options.autoClose;
@@ -55,7 +55,8 @@ class ScannerManager {
    * @private
    * @param {Object} payload The event payload.
    */
-  scannerDidScanListener(payload) {
+  var _proto = ScannerManager.prototype;
+  _proto.scannerDidScanListener = function scannerDidScanListener(payload) {
     /**
      * Trigger a scannerResultProcessed event to inform the scanner view
      * about the outcome of the scan payload processing.
@@ -114,8 +115,8 @@ class ScannerManager {
    * since it provides the possibility to set a message and a title for the notification.
    * @param {scanHandler} handler The callback - async functions are supported.
    * @return {ScannerManager}
-   */
-  registerScanHandler(handler) {
+   */;
+  _proto.registerScanHandler = function registerScanHandler(handler) {
     if (typeof handler === 'function') {
       this.scanHandler = handler;
     }
@@ -127,8 +128,8 @@ class ScannerManager {
    * is active. For the image scanner user interaction is necessary.
    * @param {string} type The initially activated scanner type.
    * @return {ScannerManager}
-   */
-  openScanner(type = SCANNER_TYPE_BARCODE) {
+   */;
+  _proto.openScanner = function openScanner(type = SCANNER_TYPE_BARCODE) {
     if (!this.supportedTypes.includes(type)) {
       logger.error(`Scanner opening failed. ${type} is a not supported scanner type.`);
       return this;
@@ -141,7 +142,7 @@ class ScannerManager {
     // Add a listener to restart the scanner recognition after the user accepted the notification.
     event.addCallback(APP_EVENT_SCANNER_ERROR_CONFIRMED, startScanner);
     // Open the scanner webview.
-    openScanner({
+    _openScanner({
       modes: {
         [type]: SCANNER_MODE_ON
       }
@@ -152,16 +153,17 @@ class ScannerManager {
   /**
    * Close the scanner webview.
    * @return {ScannerManager}
-   */
-  closeScanner() {
+   */;
+  _proto.closeScanner = function closeScanner() {
     // Remove the listeners to avoid further execution by other instances.
     event.removeCallback(APP_EVENT_CLOSE_SCANNER, this.closeScanner);
     event.removeCallback(APP_EVENT_SCANNER_DID_SCAN, this.scannerDidScanListener);
     event.removeCallback(APP_EVENT_SCANNER_ERROR_CONFIRMED, startScanner);
 
     // Close the scanner webview.
-    closeScanner();
+    _closeScanner();
     return this;
-  }
-}
+  };
+  return ScannerManager;
+}();
 export default ScannerManager;

package/classes/WebStorageRequest/index.js

@@ -1,3 +1,4 @@
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
 import event from "../Event";
 import { logger } from "../../helpers";
 import logGroup from "../../helpers/logGroup";
@@ -9,23 +10,27 @@ let localSerial = 0;
 /**
  * The WebStorageRequest class.
  */
-class WebStorageRequest extends Request {
+let WebStorageRequest = /*#__PURE__*/function (_Request) {
   /**
    * @param {string} name The name of the WebStorage entry.
    */
-  constructor(name = '') {
-    super();
-    this.name = name;
-    this.params = null;
-    this.createSerial(this.name);
-    this.createEventCallbackName('webStorageResponse');
+  function WebStorageRequest(name = '') {
+    var _this;
+    _this = _Request.call(this) || this;
+    _this.name = name;
+    _this.params = null;
+    _this.createSerial(_this.name);
+    _this.createEventCallbackName('webStorageResponse');
+    return _this;
   }
 
   /**
    * Generates the serial for this web storage request. Since the setWebStorageEntry expects
    * a number value here, the default createSerial method cannot be used by now.
    */
-  createSerial() {
+  _inheritsLoose(WebStorageRequest, _Request);
+  var _proto = WebStorageRequest.prototype;
+  _proto.createSerial = function createSerial() {
     // Increase the local serial and use it for the request
     localSerial += 1;
     this.serial = localSerial;
@@ -35,8 +40,8 @@ class WebStorageRequest extends Request {
    * Dispatches the web storage request.
    * @param {Function} resolve The resolve() callback of the request promise.
    * @return {boolean}
-   */
-  onDispatch(resolve) {
+   */;
+  _proto.onDispatch = function onDispatch(resolve) {
     // Add the request to the buffer.
     requestBuffer.add(this, this.serial);
     const requestCallbackName = this.getEventCallbackName();
@@ -82,6 +87,7 @@ class WebStorageRequest extends Request {
       return false;
     }
     return true;
-  }
-}
+  };
+  return WebStorageRequest;
+}(Request);
 export default WebStorageRequest;

package/helpers/index.js

@@ -20,17 +20,17 @@ const convertLogArgs = args => {
  */
 export const logger = {
   ...console,
-  debug: (...args) => csl.debug(...convertLogArgs(args)),
-  dir: (...args) => csl.dir(...convertLogArgs(args)),
-  dirxml: (...args) => csl.dirxml(...convertLogArgs(args)),
+  debug: (...args) => csl.debug.apply(csl, convertLogArgs(args)),
+  dir: (...args) => csl.dir.apply(csl, convertLogArgs(args)),
+  dirxml: (...args) => csl.dirxml.apply(csl, convertLogArgs(args)),
   error: (...args) => {
     emitter.emit(SOURCE_CONSOLE, args);
-    csl.error(...convertLogArgs(args));
+    csl.error.apply(csl, convertLogArgs(args));
   },
-  info: (...args) => csl.info(...convertLogArgs(args)),
-  log: (...args) => csl.log(...convertLogArgs(args)),
-  warn: (...args) => csl.warn(...convertLogArgs(args)),
-  assert: (...args) => csl.assert(...convertLogArgs(args))
+  info: (...args) => csl.info.apply(csl, convertLogArgs(args)),
+  log: (...args) => csl.log.apply(csl, convertLogArgs(args)),
+  warn: (...args) => csl.warn.apply(csl, convertLogArgs(args)),
+  assert: (...args) => csl.assert.apply(csl, convertLogArgs(args))
 };
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shopgate/pwa-core",
-  "version": "7.30.0-alpha.10",
+  "version": "7.30.0-alpha.11",
   "description": "Core library for the Shopgate Connect PWA.",
   "author": "Support <support@shopgate.com>",
   "license": "Apache-2.0",