@ekyc_qoobiss/qbs-ect-cmp 3.6.27 → 3.6.28

package/dist/collection/libs/FaceML5Detector/FaceML5Detector.js

@@ -0,0 +1,182 @@
+import { ML5 } from '../../helpers/ML5';
+// import { getVideoRatio } from '../../helpers/canvas';
+import { FacePose } from '../FaceML5Detector/FacePose';
+import { FaceLandmarks } from '../FaceML5Detector/FacePose';
+// @ts-ignore
+import face_white_svg from '../../assets/canvas-masks/face_white.svg';
+// @ts-ignore
+import face_green_svg from '../../assets/canvas-masks/face_green.svg';
+import store from '../../helpers/store';
+import { delay } from '../../utils/utils';
+import { VerificationMode } from '../../models/IVerificationMode';
+export class FaceML5Detector {
+  static getInstance(stream, isMobile) {
+    if (!FaceML5Detector.instance) {
+      FaceML5Detector.instance = new FaceML5Detector(stream, isMobile);
+    }
+    return FaceML5Detector.instance;
+  }
+  constructor(stream, isMobile) {
+    this.MAX_DETECTION = 1000 * 30;
+    this.initTime = null;
+    this.validFaceFound = false;
+    this.start = null;
+    this.frontFace = null;
+    this.presentedFacePose = null;
+    this.validFacePose = false;
+    this.checkPose = false;
+    this.MAX_NUMBER_FACES = 1;
+    this.MIN_FACE_SCORE = 0.65;
+    // private readonly MIN_FACE_SIZE_FOR_MOBILE = 200;
+    // private readonly MIN_FACE_SIZE_FOR_DESKTOP = 350;
+    this.MIN_OCCUPIED_SPACE_FOR_DESKTOP = 15;
+    this.MIN_OCCUPIED_SPACE_FOR_MOBILE = 20;
+    this.X_OFFSET_FROM_FRAME = 0;
+    this.Y_OFFSET_FROM_FRAME = 0;
+    this.stream = stream;
+    this.ml5 = ML5.getInstance();
+    this.isMobile = isMobile;
+  }
+  updateHtmlElements(videoElement, canvasElement, _component) {
+    this.videoElement = videoElement;
+    this.canvasElement = canvasElement;
+    // this.component = component;
+  }
+  initDetector(mode) {
+    this.initTime = Date.now();
+    this.continue = true;
+    this.checkPose = mode == VerificationMode.Tilt;
+    this.width = this.videoElement.videoWidth;
+    this.height = this.videoElement.videoHeight;
+    // this.videoRatio = getVideoRatio(this.videoElement);
+    this.drawFrame('white');
+    delay(2000).then(() => this.detectFaces());
+  }
+  detectFaces() {
+    if (this.validFaceFound || this.validFacePose) {
+      if (this.start == null)
+        this.start = Date.now();
+      if (Date.now() > this.start + 3000) {
+        this.continue = false;
+        this.stream.verificationReady();
+      }
+    }
+    else if (Date.now() - this.initTime >= this.MAX_DETECTION) {
+      this.continue = false;
+      this.stream.timeElapsed();
+    }
+    // if (this.presentedFacePose != null && !this.validFacePose) {
+    //   this.continue = false;
+    //   this.stream.timeElapsed();
+    // }
+    if (this.continue)
+      this.ml5.faceapi.detect(this.videoElement, this.gotResults.bind(this));
+  }
+  async gotResults(error, results) {
+    if (error) {
+      alert(error);
+      this.stream.timeElapsed();
+      return;
+    }
+    if (results.length > 0) {
+      if (this.checkPose) {
+        await this.checkFacePose(results);
+      }
+      else {
+        if (this.isSingleFace(results) && this.checkProbability(results) && this.checkFaceSize(results) && this.checkFaceIndent(results)) {
+          if (!this.validFaceFound) {
+            this.validFaceFound = true;
+            this.stream.autoCapturing();
+            // this.frontFace = new FaceLandmarks(results[0], this.width, this.height);
+            await this.drawFrame('green', true);
+          }
+        }
+      }
+    }
+    this.detectFaces();
+  }
+  async drawFrame(color, persistent = false) {
+    return new Promise(resolve => {
+      const img = new Image();
+      if (color == 'green')
+        img.src = face_green_svg;
+      else
+        img.src = face_white_svg;
+      img.onload = async () => {
+        const canvas = this.canvasElement;
+        const canvasContext = canvas.getContext('2d');
+        const hRatio = canvas.width / img.width;
+        const vRatio = canvas.height / img.height;
+        const ratio = Math.min(hRatio, vRatio);
+        const portraitOrientation = canvas.width < canvas.height;
+        const paddingX = !portraitOrientation ? 40 : 80;
+        const paddingY = portraitOrientation ? 160 : 80;
+        const centerShift_x = (canvas.width - img.width * ratio) / 2;
+        const centerShift_y = (canvas.height - img.height * ratio) / 2;
+        canvasContext.drawImage(img, 0, 0, img.width, img.height, centerShift_x + paddingX, centerShift_y + paddingY, img.width * ratio - paddingX * 2, img.height * ratio - paddingY * 2);
+        if (color != 'white' && !persistent) {
+          await delay(1000);
+          this.drawFrame('white');
+        }
+        resolve();
+      };
+    });
+  }
+  isSingleFace(results) {
+    return results.length == this.MAX_NUMBER_FACES;
+  }
+  checkProbability(result) {
+    // console.log('prob: ' + result[0].detection.score);
+    return result[0].detection.score > this.MIN_FACE_SCORE;
+  }
+  checkFaceSize(result) {
+    const faceBox = result[0].detection.box;
+    const { area } = faceBox;
+    // const { width, height, area } = faceBox;
+    const { imageHeight, imageWidth } = result[0].detection;
+    const occupiedSize = 100 / ((imageHeight * imageWidth) / area);
+    // const minSide = Math.min(width / this.videoRatio, height / this.videoRatio);
+    // console.log('size: ' + occupiedSize +'/'+(this.isMobile ? this.MIN_OCCUPIED_SPACE_FOR_MOBILE : this.MIN_OCCUPIED_SPACE_FOR_DESKTOP));
+    return (
+    // minSide > (this.isMobile ? this.MIN_FACE_SIZE_FOR_MOBILE : this.MIN_FACE_SIZE_FOR_DESKTOP) &&
+    occupiedSize > (this.isMobile ? this.MIN_OCCUPIED_SPACE_FOR_MOBILE : this.MIN_OCCUPIED_SPACE_FOR_DESKTOP));
+  }
+  checkFaceIndent(result) {
+    const faceBox = result[0].detection.box;
+    const { top, left, bottom, right } = faceBox;
+    const { imageHeight, imageWidth } = result[0].detection;
+    const topIndent = (top * 100) / imageHeight;
+    const leftIndent = (left * 100) / imageWidth;
+    const rightIndent = ((imageWidth - right) * 100) / imageWidth;
+    const bottomIndent = ((imageHeight - bottom) * 100) / imageHeight;
+    // console.log('indent: '+topIndent+' | '+leftIndent+' | '+rightIndent+' | '+bottomIndent);
+    return !(topIndent < this.Y_OFFSET_FROM_FRAME || leftIndent < this.X_OFFSET_FROM_FRAME || rightIndent < this.X_OFFSET_FROM_FRAME || bottomIndent < this.Y_OFFSET_FROM_FRAME);
+  }
+  async checkFacePose(results) {
+    let face = new FaceLandmarks(results[0], this.width, this.height);
+    // this.drawLandmarks(results);
+    // this.drawPoints(face);
+    if (this.frontFace == null) {
+      this.frontFace = face;
+      // await this.drawFrame('green');
+      if (store.debug)
+        console.log('face ok');
+    }
+    else if (this.frontFace != null && this.presentedFacePose == null) {
+      let ff = this.frontFace;
+      if (face.nose.y < ff.nose.y - ff.eyesDistance() * 0.4)
+        this.presentedFacePose = FacePose.LookUp;
+      if (face.nose.y > ff.nose.y + ff.eyesDistance() * 0.4)
+        this.presentedFacePose = FacePose.LookDown;
+      if (face.nose.x > ff.nose.x + ff.eyesDistance() * 0.5)
+        this.presentedFacePose = FacePose.LookLeft;
+      if (face.nose.x < ff.nose.x - ff.eyesDistance() * 0.5)
+        this.presentedFacePose = FacePose.LookRight;
+      if (this.stream.facePose !== null) {
+        await delay(3000);
+        this.validFacePose = true;
+        await this.drawFrame('green', true);
+      }
+    }
+  }
+}

package/dist/collection/libs/FaceML5Detector/FacePose.js

@@ -0,0 +1,85 @@
+export var FacePose;
+(function (FacePose) {
+  FacePose[FacePose["LookLeft"] = 0] = "LookLeft";
+  FacePose[FacePose["LookRight"] = 1] = "LookRight";
+  FacePose[FacePose["LookUp"] = 2] = "LookUp";
+  FacePose[FacePose["LookDown"] = 3] = "LookDown";
+  //TiltLeft,
+  //TiltRight,
+  FacePose[FacePose["Main"] = 4] = "Main";
+})(FacePose || (FacePose = {}));
+export class FacePosePick {
+  static randomEnum(anEnum) {
+    const enumValues = Object.keys(anEnum)
+      .map(n => Number.parseInt(n))
+      .filter(n => !Number.isNaN(n));
+    const randomIndex = Math.floor(Math.random() * (enumValues.length - 1));
+    const randomEnumValue = enumValues[randomIndex];
+    return randomEnumValue;
+  }
+}
+export class FaceLandmarks {
+  constructor(result, w, h) {
+    this.leftEye = this.centerOfPoints(result.parts.rightEye, w, h);
+    this.rightEye = this.centerOfPoints(result.parts.leftEye, w, h);
+    this.leftEyeBrow = this.centerOfPoints(result.parts.rightEyeBrow, w, h);
+    this.rightEyeBrow = this.centerOfPoints(result.parts.leftEyeBrow, w, h);
+    this.mouth = this.centerOfPoints(result.parts.mouth, w, h);
+    this.nose = this.centerOfPoints(result.parts.nose, w, h);
+  }
+  eyesDistance() {
+    return Math.round(Math.hypot(this.leftEye.x - this.rightEye.x, this.leftEye.y - this.rightEye.y));
+  }
+  eyesLevel() {
+    return Math.round(this.leftEye.y - this.rightEye.y);
+  }
+  eyesCenter() {
+    var fp = new FacePoint();
+    fp.x = Math.round((this.leftEye.x + this.rightEye.x) / 2);
+    fp.y = Math.round((this.leftEye.y + this.rightEye.y) / 2);
+    return fp;
+  }
+  leftEyeNoseDistanceX() {
+    return Math.abs(this.leftEye.x - this.nose.x);
+  }
+  rightEyeNoseDistanceX() {
+    return Math.abs(this.rightEye.x - this.nose.x);
+  }
+  leftEyeNoseDistanceY() {
+    return Math.abs(this.leftEye.y - this.nose.y);
+  }
+  rightEyeNoseDistanceY() {
+    return Math.abs(this.rightEye.y - this.nose.y);
+  }
+  eyesNoseDistance() {
+    return Math.round(Math.hypot(this.eyesCenter().x - this.nose.x, this.eyesCenter().y - this.nose.y));
+  }
+  noseMouthDistance() {
+    return Math.round(Math.hypot(this.nose.x - this.mouth.x, this.nose.y - this.mouth.y));
+  }
+  eyesMouthDistance() {
+    return Math.round(Math.hypot(this.eyesCenter().x - this.mouth.x, this.eyesCenter().y - this.mouth.y));
+  }
+  leftEyeEyeBrowDistance() {
+    return Math.round(Math.hypot(this.leftEye.x - this.leftEyeBrow.x, this.leftEye.y - this.leftEyeBrow.y));
+  }
+  rightEyeEyeBrowDistance() {
+    return Math.round(Math.hypot(this.rightEye.x - this.rightEyeBrow.x, this.rightEye.y - this.rightEyeBrow.y));
+  }
+  centerOfPoints(arr, _width, _height) {
+    var minX, maxX, minY, maxY;
+    for (var i = 0; i < arr.length; i++) {
+      minX = arr[i].x < minX || minX == null ? arr[i].x : minX;
+      maxX = arr[i].x > maxX || maxX == null ? arr[i].x : maxX;
+      minY = arr[i].y < minY || minY == null ? arr[i].y : minY;
+      maxY = arr[i].y > maxY || maxY == null ? arr[i].y : maxY;
+    }
+    var point = [(minX + maxX) / 2, (minY + maxY) / 2];
+    var fp = new FacePoint();
+    fp.x = Math.round(point[0]);
+    fp.y = Math.round(point[1]);
+    return fp;
+  }
+}
+export class FacePoint {
+}

package/dist/collection/libs/IDML5Detector/IDML5Detector.js

@@ -0,0 +1,99 @@
+import { ML5 } from '../../helpers/ML5';
+// @ts-ignore
+import id_white_svg from '../../assets/canvas-masks/id_white.svg';
+// @ts-ignore
+import id_green_svg from '../../assets/canvas-masks/id_green.svg';
+import { delay } from '../../utils/utils';
+import { VerificationMode } from '../../models/IVerificationMode';
+export class IDML5Detector {
+  static getInstance(stream, isMobile) {
+    if (!IDML5Detector.instance) {
+      IDML5Detector.instance = new IDML5Detector(stream, isMobile);
+    }
+    return IDML5Detector.instance;
+  }
+  constructor(stream, _isMobile) {
+    this.MAX_DETECTION = 1000 * 25;
+    this.initTime = null;
+    this.checked = false;
+    this.start = null;
+    this.stream = stream;
+    this.ml5 = ML5.getInstance();
+  }
+  updateHtmlElements(videoElement, canvasElement, _component) {
+    this.videoElement = videoElement;
+    this.canvasElement = canvasElement;
+    // this.component = component;
+  }
+  initDetector(mode) {
+    this.initTime = Date.now();
+    this.continue = true;
+    if (mode == VerificationMode.Full)
+      this.targetedLabel = 'full';
+    else
+      this.targetedLabel = 'tilted';
+    // this.width = this.videoElement.videoWidth;
+    // this.height = this.videoElement.videoHeight;
+    this.drawFrame('white');
+    delay(2000).then(() => this.classifyVideo());
+  }
+  classifyVideo() {
+    if (this.checked) {
+      if (this.start == null)
+        this.start = Date.now();
+      if (Date.now() > this.start + 500) {
+        this.continue = false;
+        this.stream.verificationReady();
+      }
+    }
+    if (Date.now() - this.initTime >= this.MAX_DETECTION) {
+      this.continue = false;
+      this.stream.timeElapsed();
+    }
+    if (this.continue)
+      this.ml5.classifier.classify(this.videoElement, this.gotResults.bind(this));
+  }
+  async gotResults(error, results) {
+    if (error) {
+      alert(error);
+      this.stream.timeElapsed();
+      return;
+    }
+    if (results[0].label == this.targetedLabel && results[0].confidence > 0.9 && !this.checked) {
+      this.checked = true;
+      this.stream.autoCapturing();
+      await this.drawFrame('green');
+    }
+    if (results[0].label == this.targetedLabel && results[0].confidence > 0.8 && !this.checked) {
+      this.checked = true;
+      await this.drawFrame('green');
+    }
+    this.classifyVideo();
+  }
+  async drawFrame(color, persistent = false) {
+    return new Promise(resolve => {
+      const img = new Image();
+      if (color == 'green')
+        img.src = id_green_svg;
+      else
+        img.src = id_white_svg;
+      img.onload = async () => {
+        const canvas = this.canvasElement;
+        const canvasContext = canvas.getContext('2d');
+        const hRatio = canvas.width / img.width;
+        const vRatio = canvas.height / img.height;
+        const ratio = Math.min(hRatio, vRatio);
+        const paddingX = 150;
+        const paddingY = 150;
+        const centerShift_x = (canvas.width - img.width * ratio) / 2;
+        const centerShift_y = (canvas.height - img.height * ratio) / 2;
+        canvasContext.drawImage(img, 0, 0, img.width, img.height, centerShift_x + paddingX, centerShift_y + paddingY, img.width * ratio - paddingX * 2, img.height * ratio - paddingY * 2);
+        if (color != 'white' && !persistent) {
+          await delay(1000);
+          this.drawFrame('white');
+        }
+        resolve();
+      };
+    });
+  }
+}

package/dist/{qbs-ect-cmp/IDPose-181bcb25.js → collection/libs/IDML5Detector/IDPose.js}

@@ -1,10 +1,8 @@
-var IDPose;
+export var IDPose;
 (function (IDPose) {
   IDPose[IDPose["Straight"] = 0] = "Straight";
   IDPose[IDPose["Tilted"] = 1] = "Tilted";
   IDPose[IDPose["Rotate"] = 2] = "Rotate";
   IDPose[IDPose["BackStraight"] = 3] = "BackStraight";
   IDPose[IDPose["BackTilted"] = 4] = "BackTilted";
-})(IDPose || (IDPose = {}));
-
-export { IDPose as I };
+})(IDPose || (IDPose = {}));

package/dist/{qbs-ect-cmp/CaptureFlow-db5d90a4.js → collection/models/CaptureFlow.js}

@@ -1,4 +1,4 @@
-var CaptureUploadTypes;
+export var CaptureUploadTypes;
 (function (CaptureUploadTypes) {
   CaptureUploadTypes["IdFront"] = "IdFront";
   CaptureUploadTypes["IdBack"] = "IdBack";
@@ -10,7 +10,7 @@ var CaptureUploadTypes;
   CaptureUploadTypes["TiltVideo"] = "TiltVideo";
   CaptureUploadTypes["None"] = "None";
 })(CaptureUploadTypes || (CaptureUploadTypes = {}));
-var IdCaptureFlowStatus;
+export var IdCaptureFlowStatus;
 (function (IdCaptureFlowStatus) {
   IdCaptureFlowStatus[IdCaptureFlowStatus["HowToFront"] = 0] = "HowToFront";
   IdCaptureFlowStatus[IdCaptureFlowStatus["IdFront"] = 1] = "IdFront";
@@ -19,12 +19,10 @@ var IdCaptureFlowStatus;
   IdCaptureFlowStatus[IdCaptureFlowStatus["Tilt"] = 4] = "Tilt";
   IdCaptureFlowStatus[IdCaptureFlowStatus["End"] = 5] = "End";
 })(IdCaptureFlowStatus || (IdCaptureFlowStatus = {}));
-var SelfieFlowStatus;
+export var SelfieFlowStatus;
 (function (SelfieFlowStatus) {
   SelfieFlowStatus[SelfieFlowStatus["HowToSelfie"] = 0] = "HowToSelfie";
   SelfieFlowStatus[SelfieFlowStatus["Selfie"] = 1] = "Selfie";
   SelfieFlowStatus[SelfieFlowStatus["Gesture"] = 2] = "Gesture";
   SelfieFlowStatus[SelfieFlowStatus["End"] = 3] = "End";
-})(SelfieFlowStatus || (SelfieFlowStatus = {}));
-
-export { CaptureUploadTypes as C, IdCaptureFlowStatus as I, SelfieFlowStatus as S };
+})(SelfieFlowStatus || (SelfieFlowStatus = {}));

package/dist/collection/models/FlowStatus.js

@@ -0,0 +1,14 @@
+export var FlowStatus;
+(function (FlowStatus) {
+  FlowStatus[FlowStatus["LANDING"] = 0] = "LANDING";
+  FlowStatus[FlowStatus["AGREEMENT"] = 1] = "AGREEMENT";
+  FlowStatus[FlowStatus["PHONE"] = 2] = "PHONE";
+  FlowStatus[FlowStatus["CODE"] = 3] = "CODE";
+  FlowStatus[FlowStatus["CODEERROR"] = 4] = "CODEERROR";
+  FlowStatus[FlowStatus["ID"] = 5] = "ID";
+  FlowStatus[FlowStatus["LIVENESS"] = 6] = "LIVENESS";
+  FlowStatus[FlowStatus["COMPLETE"] = 7] = "COMPLETE";
+  FlowStatus[FlowStatus["ERROREND"] = 8] = "ERROREND";
+  FlowStatus[FlowStatus["CAMERAERROR"] = 9] = "CAMERAERROR";
+  FlowStatus[FlowStatus["NONE"] = 10] = "NONE";
+})(FlowStatus || (FlowStatus = {}));

package/dist/collection/models/FlowSteps.js

@@ -0,0 +1,30 @@
+export var FlowSteps;
+(function (FlowSteps) {
+  FlowSteps[FlowSteps["ComponentLoaded"] = 'component-loaded'] = "ComponentLoaded";
+  FlowSteps[FlowSteps["MobileRedirect"] = 'mobile-redirect'] = "MobileRedirect";
+  FlowSteps[FlowSteps["Landing"] = 'landing'] = "Landing";
+  FlowSteps[FlowSteps["Agreements"] = 'agreements'] = "Agreements";
+  FlowSteps[FlowSteps["OtpSend"] = 'otp-send'] = "OtpSend";
+  FlowSteps[FlowSteps["OtpCheck"] = 'otp-check'] = "OtpCheck";
+  FlowSteps[FlowSteps["CiFront"] = 'ci-front'] = "CiFront";
+  FlowSteps[FlowSteps["CiFrontHowTo"] = 'ci-front-how-to'] = "CiFrontHowTo";
+  FlowSteps[FlowSteps["CiFrontCapture"] = 'ci-front-capture'] = "CiFrontCapture";
+  FlowSteps[FlowSteps["CiBack"] = 'ci-back'] = "CiBack";
+  FlowSteps[FlowSteps["CiBackHowTo"] = 'ci-back-how-to'] = "CiBackHowTo";
+  FlowSteps[FlowSteps["CiBackCapture"] = 'ci-back-capture'] = "CiBackCapture";
+  FlowSteps[FlowSteps["CiTilt"] = 'ci-tilt'] = "CiTilt";
+  FlowSteps[FlowSteps["CiError"] = 'ci-error'] = "CiError";
+  FlowSteps[FlowSteps["SelfieHowTo"] = 'selfie-how-to'] = "SelfieHowTo";
+  FlowSteps[FlowSteps["SelfieTilt"] = 'selfie-tilt'] = "SelfieTilt";
+  FlowSteps[FlowSteps["SelfieCapture"] = 'selfie-capture'] = "SelfieCapture";
+  FlowSteps[FlowSteps["Selfie"] = 'selfie'] = "Selfie";
+  FlowSteps[FlowSteps["SelfieError"] = 'selfie-error'] = "SelfieError";
+  FlowSteps[FlowSteps["End"] = 'end'] = "End";
+  FlowSteps[FlowSteps["CameraError"] = 'camera-error'] = "CameraError";
+})(FlowSteps || (FlowSteps = {}));
+export var FlowMoments;
+(function (FlowMoments) {
+  FlowMoments[FlowMoments["Initialized"] = 'initialized'] = "Initialized";
+  FlowMoments[FlowMoments["Finalized"] = 'finalized'] = "Finalized";
+  FlowMoments[FlowMoments["None"] = 'none'] = "None";
+})(FlowMoments || (FlowMoments = {}));

package/dist/collection/models/IAbortResult.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/models/IAddRequest.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/models/IAgreement.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/models/ICamera.js

@@ -0,0 +1 @@
+export {};

package/dist/{qbs-ect-cmp/IDevice-15ecfdeb.js → collection/models/IDevice.js}

@@ -1,11 +1,11 @@
-var MobileOS;
+export var MobileOS;
 (function (MobileOS) {
   MobileOS["Android"] = "android";
   MobileOS["iOS"] = "ios";
   MobileOS["Unknown"] = "unknown";
   MobileOS["WindowsPhone"] = "Windows Phone";
 })(MobileOS || (MobileOS = {}));
-var DesktopOS;
+export var DesktopOS;
 (function (DesktopOS) {
   DesktopOS["Linux"] = "linux";
   DesktopOS["MacOS"] = "mac_os";
@@ -13,13 +13,11 @@ var DesktopOS;
   DesktopOS["Unknown"] = "unknown";
   DesktopOS["Windows"] = "windows";
 })(DesktopOS || (DesktopOS = {}));
-var Browser;
+export var Browser;
 (function (Browser) {
   Browser["Chrome"] = "chrome";
   Browser["Firefox"] = "firefox";
   Browser["Safari"] = "safari";
   Browser["Mi"] = "mi";
   Browser["Unknown"] = "unknown";
-})(Browser || (Browser = {}));
-
-export { Browser as B, DesktopOS as D, MobileOS as M };
+})(Browser || (Browser = {}));

package/dist/collection/models/IEctStore.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/models/IGeneration.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/models/ILinkSend.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/models/ILogResult.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/models/IOrderStatus.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/models/IOtpCheck.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/models/IOtpSend.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/models/ITranslationValues.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/models/IUploadFile.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/models/IVerificationMode.js

@@ -0,0 +1,5 @@
+export var VerificationMode;
+(function (VerificationMode) {
+  VerificationMode[VerificationMode["Full"] = 0] = "Full";
+  VerificationMode[VerificationMode["Tilt"] = 1] = "Tilt";
+})(VerificationMode || (VerificationMode = {}));

package/dist/collection/models/OrderStatuses.js

@@ -0,0 +1,8 @@
+export var OrderStatuses;
+(function (OrderStatuses) {
+  OrderStatuses[OrderStatuses["Capturing"] = 0] = "Capturing";
+  OrderStatuses[OrderStatuses["FinishedCapturing"] = 1] = "FinishedCapturing";
+  OrderStatuses[OrderStatuses["Waiting"] = 2] = "Waiting";
+  OrderStatuses[OrderStatuses["NotFound"] = 3] = "NotFound";
+  OrderStatuses[OrderStatuses["Aborted"] = 4] = "Aborted";
+})(OrderStatuses || (OrderStatuses = {}));

package/dist/{qbs-ect-cmp/utils-8225f0b7.js → collection/utils/utils.js}

@@ -1,22 +1,20 @@
-import { s as state, S as SessionKeys } from './textValues-6bcc85dd.js';
-
-function format(first, middle, last) {
+import store from '../helpers/store';
+import { SessionKeys } from '../helpers/textValues';
+export function format(first, middle, last) {
   return (first || '') + (middle ? ` ${middle}` : '') + (last ? ` ${last}` : '');
 }
-const blobToBase64 = (blob) => {
+export const blobToBase64 = (blob) => {
   return new Promise((resolve, _) => {
     const reader = new FileReader();
     reader.onloadend = () => resolve(reader.result);
     reader.readAsDataURL(blob);
   });
 };
-const delay = ms => new Promise(res => setTimeout(res, ms));
-const getLogMessage = (param_req_id = '', param_redirect_id = '', param_token = '') => {
+export const delay = ms => new Promise(res => setTimeout(res, ms));
+export const getLogMessage = (param_req_id = '', param_redirect_id = '', param_token = '') => {
   return {
-    store_values: { request_id: state.requestId, redirect_id: state.redirectId, token: state.token },
+    store_values: { request_id: store.requestId, redirect_id: store.redirectId, token: store.token },
     session_values: { request_id: sessionStorage.getItem(SessionKeys.RequestIdKey), token: sessionStorage.getItem(SessionKeys.TokenKey) },
     parameter_values: { request_id: param_req_id, redirect_id: param_redirect_id, token: param_token },
   };
-};
-
-export { blobToBase64 as b, delay as d, getLogMessage as g };
+};