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

package/classes/Scanner/index.js

@@ -11,238 +11,237 @@ import { openScanner as openAppScanner, startScanner as startAppScanner, stopSca
 /**
  * Represents the app scanner.
  */
-export class Scanner {
+export let Scanner =
+/**
+ * Initializes the scanner
+ */
+function Scanner() {
   /**
-   * Initializes the scanner
+   * Reset Scanner state
    */
-  constructor() {
-    /**
-     * Reset Scanner state
-     */
-    this.reset = () => {
-      this.scope = null;
-      this.type = null;
-      this.opened = false;
-      this.running = false;
-      this.handling = false;
-      this.flashlightEnabled = false;
-      this.closeHandler = null;
-    };
-    /**
-     * Adds an event listener to the scanner.
-     * @param {ScannerEventListener} eventListener The eventListener to add.
-     */
-    this.addListener = eventListener => {
-      this.eventHandler.attach(eventListener);
-    };
-    /**
-     * @param {ScannerEventListener} eventListener The event listener to remove.
-     * @returns {boolean} Returns false if the listener was not found by id. Returns true otherwise.
-     */
-    this.removeListener = eventListener => this.eventHandler.detach(eventListener);
-    /**
-     * Callback for the close handler for the scanner. The scanner stops scanning and notifies
-     * the close handler when it's done. The close handler can either shut down the Scanner instance
-     * by calling its close() method or restart it to continue scanning.
-     *
-     * @callback Scanner~CloseHandler
-     * @param {Scanner} scannerInstance The instance of the scanner which requested closing.
-     * @returns {undefined|null} The return value is ignored.
-     */
-    /**
-     * Starts the app scanner. It will instantly start the scanning process for type
-     * "barcodeRecognition". The image scanner requires user interaction to scan.
-     * @param {string} scope The initially activated scanner scope.
-     * @param {ScannerType|string} type The initially activated scanner type.
-     * @param {CloseHandler|null} [closeHandler] This handler is called when the Scanner is closed.
-     * @param {string|null} [source] Tells the app which overlay to use, null for "current".
-     * @param {string|null} [animation] Tells the app what type of animation to apply when opening.
-     */
-    this.open = async (scope, type = SCANNER_TYPE_BARCODE, closeHandler = null, source = null, animation = null) => {
-      const errMsgPrefix = 'Failed to open scanner:';
+  this.reset = () => {
+    this.scope = null;
+    this.type = null;
+    this.opened = false;
+    this.running = false;
+    this.handling = false;
+    this.flashlightEnabled = false;
+    this.closeHandler = null;
+  };
+  /**
+   * Adds an event listener to the scanner.
+   * @param {ScannerEventListener} eventListener The eventListener to add.
+   */
+  this.addListener = eventListener => {
+    this.eventHandler.attach(eventListener);
+  };
+  /**
+   * @param {ScannerEventListener} eventListener The event listener to remove.
+   * @returns {boolean} Returns false if the listener was not found by id. Returns true otherwise.
+   */
+  this.removeListener = eventListener => this.eventHandler.detach(eventListener);
+  /**
+   * Callback for the close handler for the scanner. The scanner stops scanning and notifies
+   * the close handler when it's done. The close handler can either shut down the Scanner instance
+   * by calling its close() method or restart it to continue scanning.
+   *
+   * @callback Scanner~CloseHandler
+   * @param {Scanner} scannerInstance The instance of the scanner which requested closing.
+   * @returns {undefined|null} The return value is ignored.
+   */
+  /**
+   * Starts the app scanner. It will instantly start the scanning process for type
+   * "barcodeRecognition". The image scanner requires user interaction to scan.
+   * @param {string} scope The initially activated scanner scope.
+   * @param {ScannerType|string} type The initially activated scanner type.
+   * @param {CloseHandler|null} [closeHandler] This handler is called when the Scanner is closed.
+   * @param {string|null} [source] Tells the app which overlay to use, null for "current".
+   * @param {string|null} [animation] Tells the app what type of animation to apply when opening.
+   */
+  this.open = async (scope, type = SCANNER_TYPE_BARCODE, closeHandler = null, source = null, animation = null) => {
+    const errMsgPrefix = 'Failed to open scanner:';
 
-      // A minimum app lib version is required, which is defined above.
-      let libVersionResult;
-      try {
-        libVersionResult = await isLibVersionAtLeast(SCANNER_MIN_APP_LIB_VERSION);
-      } catch (err) {
-        logger.error(`${errMsgPrefix} Could not fetch app lib version. Instead received error:`, err);
-        return;
-      }
-      if (!libVersionResult) {
-        const err = new Error(`${errMsgPrefix} App lib version must be at least equal to or higher than ${SCANNER_MIN_APP_LIB_VERSION}.`);
-        logger.error(err);
-        return;
-      }
+    // A minimum app lib version is required, which is defined above.
+    let libVersionResult;
+    try {
+      libVersionResult = await isLibVersionAtLeast(SCANNER_MIN_APP_LIB_VERSION);
+    } catch (err) {
+      logger.error(`${errMsgPrefix} Could not fetch app lib version. Instead received error:`, err);
+      return;
+    }
+    if (!libVersionResult) {
+      const err = new Error(`${errMsgPrefix} App lib version must be at least equal to or higher than ${SCANNER_MIN_APP_LIB_VERSION}.`);
+      logger.error(err);
+      return;
+    }
 
-      // Make sure the scope was properly set
-      if (!scope || scope === '') {
-        const err = new Error(`${errMsgPrefix} Scope can not be empty.`);
-        logger.error(err);
-        return;
-      }
-      if (!this.supportedTypes.includes(type)) {
-        const err = new Error(`${errMsgPrefix} ${type} is a not supported scanner type.`);
-        logger.error(err);
-        return;
-      }
+    // Make sure the scope was properly set
+    if (!scope || scope === '') {
+      const err = new Error(`${errMsgPrefix} Scope can not be empty.`);
+      logger.error(err);
+      return;
+    }
+    if (!this.supportedTypes.includes(type)) {
+      const err = new Error(`${errMsgPrefix} ${type} is a not supported scanner type.`);
+      logger.error(err);
+      return;
+    }
 
-      // Only one instance can be running at the same time.
-      if (this.opened) {
-        const err = new Error(`${errMsgPrefix} An instance with scope "${this.scope}" is already running.`);
-        logger.error(err);
-        return;
-      }
-      if (closeHandler !== null && typeof closeHandler !== 'function') {
-        const err = new Error(`${errMsgPrefix} Close handler must be a function.`);
-        logger.error(err);
-        return;
-      }
+    // Only one instance can be running at the same time.
+    if (this.opened) {
+      const err = new Error(`${errMsgPrefix} An instance with scope "${this.scope}" is already running.`);
+      logger.error(err);
+      return;
+    }
+    if (closeHandler !== null && typeof closeHandler !== 'function') {
+      const err = new Error(`${errMsgPrefix} Close handler must be a function.`);
+      logger.error(err);
+      return;
+    }
 
-      // Add a listener to the scannerDidScan app event to process scanned data.
-      appEvent.addCallback(APP_EVENT_SCANNER_DID_SCAN, this.handleScan);
+    // Add a listener to the scannerDidScan app event to process scanned data.
+    appEvent.addCallback(APP_EVENT_SCANNER_DID_SCAN, this.handleScan);
 
-      // Open the app scanner.
-      openAppScanner({
-        src: source || '',
-        modes: {
-          [type]: SCANNER_MODE_ON
-        },
-        animation: animation || SCANNER_ANIMATION_NONE
-      });
+    // Open the app scanner.
+    openAppScanner({
+      src: source || '',
+      modes: {
+        [type]: SCANNER_MODE_ON
+      },
+      animation: animation || SCANNER_ANIMATION_NONE
+    });
 
-      // Initialize internal states
-      this.scope = scope;
-      this.type = type;
-      this.opened = true;
+    // Initialize internal states
+    this.scope = scope;
+    this.type = type;
+    this.opened = true;
 
-      // Image scanner does not automatically scan
-      this.running = this.type !== SCANNER_TYPE_IMAGE;
-      this.closeHandler = closeHandler || null;
-    };
-    /**
-     * Starts the Scanner if it is opened and not already running.
-     */
-    this.start = () => {
-      if (!this.opened) {
-        logger.error(new Error("Can't start Scanner: Scanner is not opened."));
-        return;
-      }
-      this.handling = false;
+    // Image scanner does not automatically scan
+    this.running = this.type !== SCANNER_TYPE_IMAGE;
+    this.closeHandler = closeHandler || null;
+  };
+  /**
+   * Starts the Scanner if it is opened and not already running.
+   */
+  this.start = () => {
+    if (!this.opened) {
+      logger.error(new Error("Can't start Scanner: Scanner is not opened."));
+      return;
+    }
+    this.handling = false;
 
-      // Start only if not already running.
-      if (!this.running) {
-        this.running = true;
-        startAppScanner();
-      }
-    };
-    /**
-     * Stops the scanner if it is opened and running.
-     */
-    this.stop = () => {
-      if (!this.opened) {
-        logger.error(new Error("Can't start Scanner: Scanner is not opened."));
-        return;
-      }
+    // Start only if not already running.
+    if (!this.running) {
+      this.running = true;
+      startAppScanner();
+    }
+  };
+  /**
+   * Stops the scanner if it is opened and running.
+   */
+  this.stop = () => {
+    if (!this.opened) {
+      logger.error(new Error("Can't start Scanner: Scanner is not opened."));
+      return;
+    }
 
-      // Stop only if is running at the moment.
-      if (this.isRunning) {
-        this.running = false;
-        stopAppScanner();
-      }
-    };
-    /**
-     * Close the app scanner.
-     */
-    this.close = () => {
-      if (!this.opened) {
-        logger.warn("Can't close Scanner: Scanner is not opened.");
-        return;
-      }
+    // Stop only if is running at the moment.
+    if (this.isRunning) {
+      this.running = false;
+      stopAppScanner();
+    }
+  };
+  /**
+   * Close the app scanner.
+   */
+  this.close = () => {
+    if (!this.opened) {
+      logger.warn("Can't close Scanner: Scanner is not opened.");
+      return;
+    }
 
-      // Remove the listener to avoid further scan results.
-      appEvent.removeCallback(APP_EVENT_SCANNER_DID_SCAN, this.handleScan);
+    // Remove the listener to avoid further scan results.
+    appEvent.removeCallback(APP_EVENT_SCANNER_DID_SCAN, this.handleScan);
 
-      // Switch off flashlight to make sure it does not stay enabled.
-      this.toggleFlashlight(false);
-      closeAppScanner();
-      this.reset();
-    };
-    /**
-     * Switches between the flashlight being on or off. The return result might not always
-     * be reliable when the app is brought into the background or if other apps interfere.
-     * Can only be toggled when the scanner is opened.
-     * @param {boolean|undefined} [enable] True/false to switch on/off or leave out for toggle.
-     * @returns {boolean} Returns the new flashlight on/off state.
-     */
-    this.toggleFlashlight = (enable = undefined) => {
-      if (!this.opened) {
-        logger.error(new Error("Can't toggle the flashlight: Scanner not opened!"));
-        return false;
-      }
-      if (enable !== undefined) {
-        this.flashlightEnabled = !!enable;
-      } else {
-        this.flashlightEnabled = !this.flashlightEnabled;
-      }
-      setAppScannerFlashlightMode(this.flashlightEnabled);
-      return this.flashlightEnabled;
-    };
-    /**
-     * Because opening the scanner can fail silently, this is a way to check if it was
-     * opened properly.
-     * @returns {boolean}
-     */
-    this.isOpened = () => this.opened;
-    /**
-     * Some scanner types don't start and all of them stop running after a successful scan.
-     * This method allows checking if a scan is currently in progress.
-     * @returns {boolean}
-     */
-    this.isRunning = () => this.running;
-    /**
-     * Helps checking the current state of the flashlight. This might not be reliable as the
-     * flashlight is turned off without notice, when the app is pushed into the background.
-     * @returns {boolean}
-     */
-    this.isFlashlightEnabled = () => this.flashlightEnabled;
-    /**
-     * The internal handler for the "scannerDidScan" app event.
-     * @private
-     * @param {ScannerEventPayload} payload The payload of the scanner event for the scanned result.
-     */
-    this.handleScan = async payload => {
-      const event = new ScannerEvent(this.scope, this.type, payload);
-      if (!this.eventHandler.hasListenersForEvent(event)) {
-        logger.warn('No scanner listeners', payload);
-        return;
-      }
-      if (this.handling) {
-        logger.warn('Scan result ignored in handling stage', payload);
-        return;
-      }
-      this.handling = true;
-      this.stop();
-      try {
-        // Ignore return values from handlers.
-        await this.eventHandler.notifyAllListeners(event);
+    // Switch off flashlight to make sure it does not stay enabled.
+    this.toggleFlashlight(false);
+    closeAppScanner();
+    this.reset();
+  };
+  /**
+   * Switches between the flashlight being on or off. The return result might not always
+   * be reliable when the app is brought into the background or if other apps interfere.
+   * Can only be toggled when the scanner is opened.
+   * @param {boolean|undefined} [enable] True/false to switch on/off or leave out for toggle.
+   * @returns {boolean} Returns the new flashlight on/off state.
+   */
+  this.toggleFlashlight = (enable = undefined) => {
+    if (!this.opened) {
+      logger.error(new Error("Can't toggle the flashlight: Scanner not opened!"));
+      return false;
+    }
+    if (enable !== undefined) {
+      this.flashlightEnabled = !!enable;
+    } else {
+      this.flashlightEnabled = !this.flashlightEnabled;
+    }
+    setAppScannerFlashlightMode(this.flashlightEnabled);
+    return this.flashlightEnabled;
+  };
+  /**
+   * Because opening the scanner can fail silently, this is a way to check if it was
+   * opened properly.
+   * @returns {boolean}
+   */
+  this.isOpened = () => this.opened;
+  /**
+   * Some scanner types don't start and all of them stop running after a successful scan.
+   * This method allows checking if a scan is currently in progress.
+   * @returns {boolean}
+   */
+  this.isRunning = () => this.running;
+  /**
+   * Helps checking the current state of the flashlight. This might not be reliable as the
+   * flashlight is turned off without notice, when the app is pushed into the background.
+   * @returns {boolean}
+   */
+  this.isFlashlightEnabled = () => this.flashlightEnabled;
+  /**
+   * The internal handler for the "scannerDidScan" app event.
+   * @private
+   * @param {ScannerEventPayload} payload The payload of the scanner event for the scanned result.
+   */
+  this.handleScan = async payload => {
+    const event = new ScannerEvent(this.scope, this.type, payload);
+    if (!this.eventHandler.hasListenersForEvent(event)) {
+      logger.warn('No scanner listeners', payload);
+      return;
+    }
+    if (this.handling) {
+      logger.warn('Scan result ignored in handling stage', payload);
+      return;
+    }
+    this.handling = true;
+    this.stop();
+    try {
+      // Ignore return values from handlers.
+      await this.eventHandler.notifyAllListeners(event);
 
-        // Notify the close handler that the Scanner is done doing his work.
-        if (this.closeHandler) {
-          this.closeHandler(this);
-        }
-      } catch (error) {
-        logger.warn('Scan handler threw error:', error);
-        // Force restart when a handler throws an error.
-        this.start();
-      }
-    };
-    this.supportedTypes = [SCANNER_TYPE_BARCODE, SCANNER_TYPE_IMAGE];
-    this.eventHandler = new ScannerEventHandler();
+      // Notify the close handler that the Scanner is done doing his work.
+      if (this.closeHandler) {
+        this.closeHandler(this);
+      }
+    } catch (error) {
+      logger.warn('Scan handler threw error:', error);
+      // Force restart when a handler throws an error.
+      this.start();
+    }
+  };
+  this.supportedTypes = [SCANNER_TYPE_BARCODE, SCANNER_TYPE_IMAGE];
+  this.eventHandler = new ScannerEventHandler();
 
-    // Register app scan event to listen for.
-    registerEvents([APP_EVENT_SCANNER_DID_SCAN]);
-    this.reset();
-  }
-}
+  // Register app scan event to listen for.
+  registerEvents([APP_EVENT_SCANNER_DID_SCAN]);
+  this.reset();
+};
 export default new Scanner();

package/classes/ScannerEvent/index.js

@@ -5,27 +5,27 @@
  *
  * Defines an event which is emitted when the scanner scans something.
  */
-export default class ScannerEvent {
+let ScannerEvent =
+/**
+ * @param {string} scope The scanner instance, that was running when this event was emitted.
+ * @param {string} type The type of scanner that produced this result.
+ * @param {ScannerEventPayload} payload The payload of the scan result.
+ */
+function ScannerEvent(scope, type, payload) {
+  /**
+   * @returns {string}
+   */
+  this.getScope = () => this.scope;
+  /**
+   * @returns {string}
+   */
+  this.getType = () => this.type;
   /**
-   * @param {string} scope The scanner instance, that was running when this event was emitted.
-   * @param {string} type The type of scanner that produced this result.
-   * @param {ScannerEventPayload} payload The payload of the scan result.
+   * @returns {ScannerEventPayload}
    */
-  constructor(scope, type, payload) {
-    /**
-     * @returns {string}
-     */
-    this.getScope = () => this.scope;
-    /**
-     * @returns {string}
-     */
-    this.getType = () => this.type;
-    /**
-     * @returns {ScannerEventPayload}
-     */
-    this.getPayload = () => this.payload;
-    this.scope = scope;
-    this.type = type;
-    this.payload = payload;
-  }
-}
+  this.getPayload = () => this.payload;
+  this.scope = scope;
+  this.type = type;
+  this.payload = payload;
+};
+export { ScannerEvent as default };

package/classes/ScannerEventHandler/index.js

@@ -1,41 +1,41 @@
 /**
  * Manages scanner event listeners.
  */
-export default class ScannerEventHandler {
+let ScannerEventHandler =
+/**
+ * Initializes the event handler.
+ */
+function ScannerEventHandler() {
+  /**
+   * @param {ScannerEventListener} eventListener The event listener to attach to the handler.
+   */
+  this.attach = eventListener => {
+    this.eventListeners.add(eventListener);
+  };
+  /**
+   * @param {ScannerEventListener} eventListener The event listener to detach from the handler.
+   * @returns {boolean} Returns true if the event listener was detached successfully.
+   */
+  this.detach = eventListener => this.eventListeners.delete(eventListener);
+  /**
+   * @param {ScannerEvent} event The event which has been emitted by the scanner.
+   * @returns {boolean}
+   */
+  this.hasListenersForEvent = event => Array.from(this.eventListeners).some(listener => listener.canHandleEvent(event));
   /**
-   * Initializes the event handler.
+   * @param {ScannerEvent} event The event which has been emitted by the scanner.
+   * @returns {Promise<undefined>}
+   * @throws {Error}
    */
-  constructor() {
-    /**
-     * @param {ScannerEventListener} eventListener The event listener to attach to the handler.
-     */
-    this.attach = eventListener => {
-      this.eventListeners.add(eventListener);
-    };
-    /**
-     * @param {ScannerEventListener} eventListener The event listener to detach from the handler.
-     * @returns {boolean} Returns true if the event listener was detached successfully.
-     */
-    this.detach = eventListener => this.eventListeners.delete(eventListener);
-    /**
-     * @param {ScannerEvent} event The event which has been emitted by the scanner.
-     * @returns {boolean}
-     */
-    this.hasListenersForEvent = event => Array.from(this.eventListeners).some(listener => listener.canHandleEvent(event));
-    /**
-     * @param {ScannerEvent} event The event which has been emitted by the scanner.
-     * @returns {Promise<undefined>}
-     * @throws {Error}
-     */
-    this.notifyAllListeners = event => {
-      const notifyResults = [];
-      this.eventListeners.forEach(listener => {
-        notifyResults.push(listener.notify(event));
-      });
+  this.notifyAllListeners = event => {
+    const notifyResults = [];
+    this.eventListeners.forEach(listener => {
+      notifyResults.push(listener.notify(event));
+    });
 
-      // Forward occurring errors only, because there should be no return value from "notify"
-      return Promise.all(notifyResults).then(() => {});
-    };
-    this.eventListeners = new Set();
-  }
-}
+    // Forward occurring errors only, because there should be no return value from "notify"
+    return Promise.all(notifyResults).then(() => {});
+  };
+  this.eventListeners = new Set();
+};
+export { ScannerEventHandler as default };