@ekyc_qoobiss/qbs-ect-cmp 3.6.6 → 3.6.10

package/dist/collection/components/common/id-tilt/id-tilt.js

@@ -0,0 +1,194 @@
+import { h } from '@stencil/core';
+import { Cameras } from '../../../helpers/Cameras';
+import { Stream } from '../../../helpers/Stream';
+import { IdCaptureValues } from '../../../helpers/textValues';
+import { IDML5Detector } from '../../../libs/IDML5Detector/IDML5Detector';
+import { FaceML5Detector } from '../../../libs/FaceML5Detector/FaceML5Detector';
+import { IDPose } from '../../../libs/IDML5Detector/IDPose';
+import { delay } from '../../../utils/utils';
+import store from '../../../helpers/store';
+import { BaseComponent } from '../../base-component';
+import { FlowMoments, FlowSteps } from '../../../models/FlowSteps';
+import { VerificationMode } from '../../../models/IVerificationMode';
+// import { IDPose } from '../../libs/IDML5Detector/IDPose';
+export class IdTilt {
+  // @State() private animationPath: string;
+  constructor() {
+    this.photoIsReady = photos => {
+      //this.closeCamera();
+      this.eventPhotoCapture.emit(photos);
+    };
+    this.videoStarted = undefined;
+    this.cameraSize = undefined;
+    this.captureTaken = undefined;
+    this.verified = undefined;
+    this.titleMesage = undefined;
+    this.showDemo = undefined;
+    this.demoVideo = undefined;
+    this.captureTaken = false;
+    this.verified = false;
+    this.cameras = new Cameras();
+    this.showDemo = true;
+    this.baseComponent = new BaseComponent(FlowSteps.CiFrontHoldAnimation);
+  }
+  eventVideoStarted(event) {
+    this.videoStarted = true;
+    this.cameraSize = event.detail;
+  }
+  async componentWillLoad() {
+    this.titleMesage = IdCaptureValues.IDPoseMapping[1];
+    //this.videoDemoStyle = this.device.isMobile ? { 'width': window.screen.width + 'px', 'height': window.screen.height + 'px', 'object-fit': 'fill' } : {};
+    if (!navigator.mediaDevices) {
+      this.apiErrorEvent.emit({ message: 'This browser does not support webRTC' });
+    }
+  }
+  async componentDidLoad() {
+    await this.baseComponent.logStep(FlowSteps.CiFrontTiltAnimation, FlowMoments.Initialized);
+    this.demoVideo.src = IdCaptureValues.IDPoseDemoMapping[IDPose.Tilted];
+    this.demoVideo.play();
+    await delay(IdCaptureValues.VideoLenght);
+    this.showDemo = false;
+    await this.baseComponent.logStep(FlowSteps.CiFrontTiltAnimation, FlowMoments.Finalized);
+    this.openCamera();
+  }
+  async openCamera() {
+    await this.baseComponent.logStep(FlowSteps.CiTilt, FlowMoments.Initialized);
+    const constraints = this.cameras.GetConstraints(store.cameraId, store.device);
+    setTimeout(() => {
+      navigator.mediaDevices
+        .getUserMedia(constraints)
+        .then(stream => {
+        const superStream = Stream.getInstance(VerificationMode.Full);
+        superStream.initStream(stream);
+      })
+        .catch(e => {
+        this.closeCamera();
+        this.apiErrorEvent.emit(e);
+      });
+    }, 100);
+  }
+  closeCamera() {
+    if (Stream.instance) {
+      Stream.getInstance(VerificationMode.Full).dropStream();
+    }
+  }
+  disconnectedCallback() {
+    this.closeCamera();
+    Stream.instance = null;
+    IDML5Detector.instance = null;
+    FaceML5Detector.instance = null;
+  }
+  async takePhoto() {
+    if (this.captureTaken)
+      return;
+    this.captureTaken = true;
+    let res = await Stream.getInstance(VerificationMode.Full).takePhoto();
+    this.photoIsReady(res);
+    await this.baseComponent.logStep(FlowSteps.CiTilt, FlowMoments.Finalized);
+  }
+  async verificationFinished() {
+    if (this.verified)
+      return;
+    this.verified = true;
+    this.titleMesage = IdCaptureValues.Loading;
+    this.closeCamera();
+    this.showDemo = true;
+    this.demoVideo.src = 'https://ekyc.blob.core.windows.net/$web/animations/uploading_id.mp4';
+    this.demoVideo.loop = true;
+    this.demoVideo.play();
+  }
+  render() {
+    let cameraStyle;
+    let cameraStyleInner;
+    if (this.videoStarted) {
+      cameraStyle = {
+        width: Math.round(this.cameraSize.width) + 'px',
+        height: Math.round((this.cameraSize.width * 9) / 16) + 'px',
+        overflow: 'hidden',
+        borderRadius: '10px',
+      };
+      cameraStyleInner = { marginTop: Math.round((this.cameraSize.height - (this.cameraSize.width * 9) / 16) / 2) * -1 + 'px' };
+    }
+    let titleClass = this.verified ? 'color-black-2 text-center' : 'color-white text-center';
+    //let videoClass = this.device.isMobile ? '' : 'video-demo';
+    let bgDemo = this.verified ? 'container' : 'container bg-black';
+    return (h("div", { class: bgDemo }, h("div", { class: "container-video" }, h("div", { hidden: this.showDemo == false }, h("video", { id: "howtoFront", class: "video-demo", playsinline: true, ref: el => (this.demoVideo = el) }, h("source", { type: "video/mp4" }))), h("div", { hidden: this.showDemo }, h("div", { hidden: this.verified }, h("div", { class: "video-capture" }, h("div", { style: cameraStyle }, h("div", { style: cameraStyleInner }, h("camera-comp", { "capture-mode": "tilt" })))))), h("div", { class: "capture-title" }, h("h1", { class: titleClass }, this.titleMesage), h("p", { class: "main-text font-size-18 text-right mb-0" }, IdCaptureValues.FooterText)))));
+  }
+  static get is() { return "id-tilt"; }
+  static get originalStyleUrls() {
+    return {
+      "$": ["id-tilt.css"]
+    };
+  }
+  static get styleUrls() {
+    return {
+      "$": ["id-tilt.css"]
+    };
+  }
+  static get states() {
+    return {
+      "videoStarted": {},
+      "cameraSize": {},
+      "captureTaken": {},
+      "verified": {},
+      "titleMesage": {},
+      "showDemo": {},
+      "demoVideo": {}
+    };
+  }
+  static get events() {
+    return [{
+        "method": "eventPhotoCapture",
+        "name": "photoIdCapture",
+        "bubbles": true,
+        "cancelable": true,
+        "composed": true,
+        "docs": {
+          "tags": [],
+          "text": ""
+        },
+        "complexType": {
+          "original": "any",
+          "resolved": "any",
+          "references": {}
+        }
+      }, {
+        "method": "apiErrorEvent",
+        "name": "apiError",
+        "bubbles": true,
+        "cancelable": true,
+        "composed": true,
+        "docs": {
+          "tags": [],
+          "text": ""
+        },
+        "complexType": {
+          "original": "any",
+          "resolved": "any",
+          "references": {}
+        }
+      }];
+  }
+  static get elementRef() { return "component"; }
+  static get listeners() {
+    return [{
+        "name": "videoStarted",
+        "method": "eventVideoStarted",
+        "target": undefined,
+        "capture": false,
+        "passive": false
+      }, {
+        "name": "takePhoto",
+        "method": "takePhoto",
+        "target": undefined,
+        "capture": false,
+        "passive": false
+      }, {
+        "name": "verificationFinished",
+        "method": "verificationFinished",
+        "target": undefined,
+        "capture": false,
+        "passive": false
+      }];
+  }
+}

package/dist/collection/components/common/selfie-capture/selfie-capture.js

@@ -8,6 +8,7 @@ import { delay } from '../../../utils/utils';
 import store from '../../../helpers/store';
 import { BaseComponent } from '../../base-component';
 import { FlowMoments, FlowSteps } from '../../../models/FlowSteps';
+import { VerificationMode } from '../../../models/IVerificationMode';
 export class SelfieCapture {
   // @State() private animationPath: string;
   constructor() {
@@ -77,7 +78,7 @@ export class SelfieCapture {
       navigator.mediaDevices
         .getUserMedia(constraints)
         .then(stream => {
-        const superStream = Stream.getInstance();
+        const superStream = Stream.getInstance(VerificationMode.Full);
         superStream.initStream(stream);
       })
         .catch(e => {
@@ -88,7 +89,7 @@ export class SelfieCapture {
   }
   closeCamera() {
     if (Stream.instance) {
-      Stream.getInstance().dropStream();
+      Stream.getInstance(VerificationMode.Full).dropStream();
     }
   }
   disconnectedCallback() {
@@ -100,7 +101,7 @@ export class SelfieCapture {
     if (this.captureTaken)
       return;
     this.captureTaken = true;
-    let res = await Stream.getInstance().takePhoto();
+    let res = await Stream.getInstance(VerificationMode.Full).takePhoto();
     this.photoIsReady(res);
     await this.baseComponent.logStep(FlowSteps.SelfieHoldAnimation, FlowMoments.Finalized);
   }

package/dist/collection/components/controls/camera/camera.js

@@ -1,6 +1,7 @@
 import { Stream } from '../../../helpers/Stream';
 import { h } from '@stencil/core';
 import store from '../../../helpers/store';
+import { VerificationMode } from '../../../models/IVerificationMode';
 // import { PipelineResult } from '../../../libs/FaceDetector/PipelineResult';
 export class Camera {
   constructor() {
@@ -58,7 +59,8 @@ export class Camera {
     return (h("div", { class: "camera" }, h("video", { id: "video", loop: true, autoplay: true, playsinline: true, muted: true, class: cameraVideoClass, ref: el => (this.cameraVideo = el) }), h("canvas", { id: "output", class: cameraCanvasClass, ref: el => (this.cameraCanvas = el) })));
   }
   startStream() {
-    const stream = Stream.getInstance();
+    var captureMode = this.captureMode == 'tilt' ? VerificationMode.Tilt : VerificationMode.Full;
+    const stream = Stream.getInstance(captureMode);
     stream.updateHtmlElements(this.cameraVideo, this.cameraCanvas, this.component);
     if (this.captureMode == 'selfie') {
       stream.setFaceDetection(true);

package/dist/collection/components/flow/process-id/process-id.js

@@ -0,0 +1,375 @@
+import { h /*getAssetPath*/ } from '@stencil/core';
+import store from '../../../helpers/store';
+import { Stream } from '../../../helpers/Stream';
+import { FlowStatus } from '../../../models/FlowStatus';
+import { FlowSteps } from '../../../models/FlowSteps';
+import { getLogMessage } from '../../../utils/utils';
+import { BaseComponent } from '../../base-component';
+import { CaptureFlowStatus, CaptureUploadTypes } from '../../../models/CaptureFlow';
+// import { IDPose } from '../../libs/IDML5Detector/IDPose';
+export class ProcessId {
+  constructor() {
+    this.recordingResultCount = 0;
+    this.captureStep = undefined;
+    this.showTimeout = undefined;
+    this.showInvalid = undefined;
+    this.flow = undefined;
+    this.baseComponent = new BaseComponent(FlowSteps.CiBack);
+    this.baseComponent.setEventEmitter(this.apiErrorEvent);
+  }
+  componentWillLoad() {
+    this.captureRetryCount = 0;
+    this.flow = {
+      front: {
+        photoDone: false,
+        recordingDone: false,
+        fileName: 'idImage.png',
+        file: null,
+        recoding: null,
+        uploadType: CaptureUploadTypes.IdFront,
+      },
+      back: null,
+      tilt: null,
+      recordingData: [],
+      mimeType: '',
+    };
+    if (store.hasIdBack) {
+      this.flow.back = {
+        photoDone: false,
+        recordingDone: false,
+        fileName: 'idBackImage.png',
+        file: null,
+        recoding: null,
+        uploadType: CaptureUploadTypes.IdBack,
+      };
+    }
+    if (store.idTiltCheck) {
+      this.flow.tilt = {
+        photoDone: true,
+        recordingDone: false,
+        fileName: 'idTiltImage.png',
+        file: null,
+        recoding: null,
+        uploadType: CaptureUploadTypes.None,
+      };
+    }
+    this.captureStep = CaptureFlowStatus.HowToFront;
+  }
+  howToDone() {
+    if (this.captureStep == CaptureFlowStatus.HowToFront) {
+      this.captureStep = CaptureFlowStatus.IdFront;
+    }
+    if (this.captureStep == CaptureFlowStatus.HowToBack) {
+      this.captureStep = CaptureFlowStatus.IdBack;
+    }
+  }
+  timeElapsed() {
+    this.showTimeout = true;
+  }
+  captureErrorDone() {
+    if (this.showTimeout == true) {
+      this.showTimeout = false;
+    }
+    if (this.showInvalid == true) {
+      this.showInvalid = false;
+    }
+  }
+  async captureIdImage(event) {
+    let idPhoto = event.detail;
+    if (idPhoto.size == 0) {
+      await this.baseComponent.apiCall.AddLog({ message: 'Empty id photo', blobData: idPhoto }, getLogMessage());
+      this.triggerErrorFlow();
+      return;
+    }
+    try {
+      this.flow.front.file = new File([idPhoto], this.flow.front.fileName, { type: 'image/png' });
+      this.flow.front.photoDone = await this.uploadPhotos(this.flow.front.uploadType, this.flow.front.file);
+      await this.endFlow();
+    }
+    catch (e) {
+      this.apiErrorEvent.emit(e);
+    }
+  }
+  async captureIdBackImage(event) {
+    let idPhoto = event.detail;
+    if (idPhoto.size == 0) {
+      await this.baseComponent.apiCall.AddLog({ message: 'Empty id photo', blobData: idPhoto }, getLogMessage());
+      this.triggerErrorFlow();
+      return;
+    }
+    try {
+      this.flow.back.file = new File([idPhoto], this.flow.back.fileName, { type: 'image/png' });
+      this.flow.back.photoDone = await this.uploadPhotos(this.flow.back.uploadType, this.flow.back.file);
+      await this.endFlow();
+    }
+    catch (e) {
+      this.apiErrorEvent.emit(e);
+    }
+  }
+  async capturedIdRecording(event) {
+    var recResults = event.detail;
+    if (recResults.RecordingChunks.length == 0 && this.recordingResultCount == 0) {
+      this.recordingResultCount++;
+      return;
+    }
+    if (recResults.RecordingChunks.length == 0) {
+      await this.baseComponent.apiCall.AddLog({ message: 'Empty recording for ' + this.captureStep, blobData: recResults.RecordingChunks }, getLogMessage());
+      this.triggerErrorFlow();
+      return;
+    }
+    this.flow.mimeType = event.detail.MimeType;
+    if (this.captureStep == CaptureFlowStatus.IdFront) {
+      this.flow.front.recoding = recResults.RecordingChunks;
+      this.flow.front.recordingDone = true;
+    }
+    if (this.captureStep == CaptureFlowStatus.IdBack) {
+      this.flow.back.recoding = recResults.RecordingChunks;
+      this.flow.back.recordingDone = true;
+    }
+    if (this.captureStep == CaptureFlowStatus.Tilt) {
+      this.flow.tilt.recoding = recResults.RecordingChunks;
+      this.flow.tilt.recordingDone = true;
+    }
+    await this.endFlow();
+    this.recordingResultCount = 0;
+  }
+  async getRecordingFile() {
+    let idRecording = new Blob(this.flow.recordingData, {
+      type: this.flow.mimeType,
+    });
+    if (idRecording.size == 0) {
+      await this.baseComponent.apiCall.AddLog({ message: 'Empty recording', blobData: idRecording }, getLogMessage());
+      this.triggerErrorFlow(true);
+      return;
+    }
+    let mimeType = idRecording.type == Stream.mp4MimeType.type ? Stream.mp4MimeType : Stream.webmMimeType;
+    try {
+      var file = new File([idRecording], 'idVideo.' + mimeType.extension, { type: mimeType.type });
+      var uploadResult = this.uploadRecording('IdFrontVideo', file);
+      if (uploadResult) {
+        return true;
+      }
+      else {
+        this.triggerErrorFlow(true);
+      }
+    }
+    catch (e) {
+      this.triggerErrorFlow(true);
+    }
+  }
+  async componentDidLoad() {
+    await this.baseComponent.initialize();
+  }
+  async uploadPhotos(uploadType, photoFile) {
+    if (photoFile == null || uploadType == '') {
+      return false;
+    }
+    var uploadResult = await this.baseComponent.apiCall.UploadFileForRequestB64(store.requestId, uploadType, photoFile);
+    if (uploadResult) {
+      return true;
+    }
+    else {
+      this.switchCamera();
+      this.triggerErrorFlow();
+    }
+    return false;
+  }
+  async uploadRecording(uploadType, recordingFile) {
+    if (recordingFile == null) {
+      return;
+    }
+    var uploadResult = await this.baseComponent.apiCall.UploadFileForRequestB64(store.requestId, uploadType, recordingFile);
+    if (uploadResult) {
+      return true;
+    }
+    else {
+      this.triggerErrorFlow();
+    }
+    return false;
+  }
+  triggerErrorFlow(restart = false) {
+    if (restart) {
+      this.captureStep = CaptureFlowStatus.IdFront;
+    }
+    if (this.captureStep == CaptureFlowStatus.IdFront || restart) {
+      this.flow.front.file = null;
+      this.flow.front.photoDone = false;
+      this.flow.front.recordingDone = false;
+      this.flow.front.recoding = null;
+    }
+    if (this.captureStep == CaptureFlowStatus.IdBack || restart) {
+      this.flow.back.file = null;
+      this.flow.back.photoDone = false;
+      this.flow.back.recordingDone = false;
+      this.flow.back.recoding = null;
+    }
+    if (this.captureStep == CaptureFlowStatus.Tilt || restart) {
+      this.flow.tilt.photoDone = true;
+      this.flow.tilt.recordingDone = false;
+      this.flow.tilt.recoding = null;
+    }
+    this.showInvalid = true;
+  }
+  async endFlow() {
+    if (this.captureStep == CaptureFlowStatus.IdFront) {
+      if (this.flow.front.photoDone && this.flow.front.recordingDone) {
+        if (store.hasIdBack) {
+          this.captureStep = CaptureFlowStatus.IdBack;
+        }
+        else if (store.idTiltCheck) {
+          this.captureStep = CaptureFlowStatus.Tilt;
+        }
+        else {
+          this.captureStep = CaptureFlowStatus.End;
+        }
+      }
+      else {
+        return;
+      }
+    }
+    if (this.captureStep == CaptureFlowStatus.IdBack && store.hasIdBack) {
+      if (this.flow.back.photoDone && this.flow.back.recordingDone) {
+        if (store.idTiltCheck) {
+          this.captureStep = CaptureFlowStatus.Tilt;
+        }
+        else {
+          this.captureStep = CaptureFlowStatus.End;
+        }
+      }
+      else {
+        return;
+      }
+    }
+    if (this.captureStep == CaptureFlowStatus.Tilt && store.idTiltCheck) {
+      if (this.flow.tilt.photoDone && this.flow.tilt.recordingDone) {
+        this.flow.recordingData.push(...this.flow.front.recoding);
+        this.flow.recordingData.push(...this.flow.back.recoding);
+        this.flow.recordingData.push(...this.flow.tilt.recoding);
+        await this.getRecordingFile();
+        this.captureStep = CaptureFlowStatus.End;
+      }
+      else {
+        return;
+      }
+    }
+    if (this.captureStep != CaptureFlowStatus.End) {
+      return;
+    }
+    store.flowStatus = FlowStatus.LIVENESS;
+  }
+  async disconnectedCallback() {
+    await this.baseComponent.finalize();
+  }
+  switchCamera() {
+    if (this.captureRetryCount == 1) {
+      let camIndex = store.cameraIds.indexOf(store.cameraId);
+      store.cameraId = camIndex === store.cameraIds.length - 1 ? store.cameraIds[0] : store.cameraIds[camIndex + 1];
+      this.captureRetryCount = 0;
+    }
+    else {
+      this.captureRetryCount++;
+    }
+  }
+  render() {
+    let error = h("capture-error", { type: "ID" });
+    let frontCapture = h("id-capture", null);
+    let secondCapture = h("id-back-capture", null);
+    let tiltCapture = h("id-tilt", null);
+    let howToFront = h("how-to-info", { idSide: "front" });
+    let howToBack = h("how-to-info", { idSide: "back" });
+    if (this.showInvalid || this.showTimeout) {
+      return error;
+    }
+    if (this.captureStep == CaptureFlowStatus.HowToFront) {
+      return howToFront;
+    }
+    if (this.captureStep == CaptureFlowStatus.HowToBack) {
+      return howToBack;
+    }
+    if (this.captureStep == CaptureFlowStatus.IdFront) {
+      return frontCapture;
+    }
+    if (this.captureStep == CaptureFlowStatus.IdBack) {
+      return secondCapture;
+    }
+    if (this.captureStep == CaptureFlowStatus.Tilt) {
+      return tiltCapture;
+    }
+  }
+  static get is() { return "process-id"; }
+  static get originalStyleUrls() {
+    return {
+      "$": ["process-id.css"]
+    };
+  }
+  static get styleUrls() {
+    return {
+      "$": ["process-id.css"]
+    };
+  }
+  static get states() {
+    return {
+      "captureStep": {},
+      "showTimeout": {},
+      "showInvalid": {},
+      "flow": {}
+    };
+  }
+  static get events() {
+    return [{
+        "method": "apiErrorEvent",
+        "name": "apiError",
+        "bubbles": true,
+        "cancelable": true,
+        "composed": true,
+        "docs": {
+          "tags": [],
+          "text": ""
+        },
+        "complexType": {
+          "original": "any",
+          "resolved": "any",
+          "references": {}
+        }
+      }];
+  }
+  static get listeners() {
+    return [{
+        "name": "howToInfoDone",
+        "method": "howToDone",
+        "target": undefined,
+        "capture": false,
+        "passive": false
+      }, {
+        "name": "timeElapsed",
+        "method": "timeElapsed",
+        "target": undefined,
+        "capture": false,
+        "passive": false
+      }, {
+        "name": "captureErrorDone",
+        "method": "captureErrorDone",
+        "target": undefined,
+        "capture": false,
+        "passive": false
+      }, {
+        "name": "photoIdCapture",
+        "method": "captureIdImage",
+        "target": undefined,
+        "capture": false,
+        "passive": false
+      }, {
+        "name": "photoIdBackCapture",
+        "method": "captureIdBackImage",
+        "target": undefined,
+        "capture": false,
+        "passive": false
+      }, {
+        "name": "recordingIdCapture",
+        "method": "capturedIdRecording",
+        "target": undefined,
+        "capture": false,
+        "passive": false
+      }];
+  }
+}

package/dist/collection/components/identification-component/identification-component.js

@@ -261,11 +261,8 @@ export class IdentificationComponent {
     if (store.flowStatus == FlowStatus.CODEERROR) {
       currentBlock = h("sms-code-validation", null);
     }
-    if (store.flowStatus == FlowStatus.ID && !store.hasIdBack) {
-      currentBlock = h("id-single-side", { id: "idFront" });
-    }
-    if (store.flowStatus == FlowStatus.ID && store.hasIdBack) {
-      currentBlock = h("id-double-side", { id: "idFront" });
+    if (store.flowStatus == FlowStatus.ID) {
+      currentBlock = h("process-id", null);
     }
     if (store.flowStatus == FlowStatus.LIVENESS) {
       currentBlock = h("user-liveness", { id: "camera" });

package/dist/collection/helpers/Stream.js

@@ -46,7 +46,7 @@ export class Stream {
   setVerificationFinished(fun) {
     this.verificationFinished = fun;
   }
-  constructor() {
+  constructor(mode) {
     this.streamPaused = false;
     this.recordedChunks = [];
     this.videoSize = { width: 0, height: 0 };
@@ -59,10 +59,11 @@ export class Stream {
     };
     this.idML5Detector = IDML5Detector.getInstance(this, store.device.isMobile);
     this.faceML5Detector = FaceML5Detector.getInstance(this, store.device.isMobile);
+    this.verificationMode = mode;
   }
-  static getInstance() {
+  static getInstance(mode) {
     if (!Stream.instance) {
-      Stream.instance = new Stream();
+      Stream.instance = new Stream(mode);
     }
     return Stream.instance;
   }
@@ -134,10 +135,11 @@ export class Stream {
       this.recordedChunks.push(event.data);
     };
     this.mediaRecorder.onstop = _e => {
-      var blob = new Blob(this.recordedChunks, {
-        type: options.mimeType.split(';')[0],
-      });
-      this.callbackRecordingReady(blob);
+      var resp = {
+        RecordingChunks: this.recordedChunks,
+        MimeType: options.mimeType,
+      };
+      this.callbackRecordingReady(resp);
     };
     this.mediaRecorder.start(); // Start recording, and dump data every second
   }
@@ -196,7 +198,7 @@ export class Stream {
   async startIdDetection() {
     if (this.streamPaused)
       return;
-    this.idML5Detector.initDetector();
+    this.idML5Detector.initDetector(this.verificationMode);
   }
   async startFaceDetection() {
     if (this.streamPaused)

package/dist/collection/helpers/store.js

@@ -12,6 +12,7 @@ const { state, onChange } = createStore({
   cameraIds: [],
   cameraId: '',
   hasIdBack: false,
+  idTiltCheck: false,
   agreementsValidation: true,
   phoneValidation: true,
   phoneNumber: '',