@ekyc_qoobiss/qbs-ect-cmp 1.5.27 → 1.6.0

package/dist/cjs/ApiCall-ef8d0136.js

@@ -0,0 +1,156 @@
+'use strict';
+
+const store = require('./store-fbfb5595.js');
+
+class ApiCall {
+  constructor() {
+    this.toBase64 = (file) => new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.readAsDataURL(file);
+      reader.onload = () => resolve(reader.result);
+      reader.onerror = error => reject(error);
+    });
+  }
+  async Post(url, data) {
+    try {
+      let resp = await fetch(store.state.apiBaseUrl + url, {
+        method: 'POST',
+        body: data,
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': 'IDKYC-TOKEN ' + store.state.token
+        },
+      });
+      if (!resp.ok) {
+        return new Error(resp.statusText);
+      }
+      return await resp.json();
+    }
+    catch (err) {
+      console.log(err);
+      return err;
+    }
+  }
+  async Get(url) {
+    try {
+      let resp = await fetch(store.state.apiBaseUrl + url, {
+        method: 'GET',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': 'IDKYC-TOKEN ' + store.state.token
+        },
+      });
+      if (!resp.ok) {
+        return new Error(resp.statusText);
+      }
+      return await resp.json();
+    }
+    catch (err) {
+      console.log(err);
+      return err;
+    }
+  }
+  async SendOTPCode(requestId, phoneNumber) {
+    let data = { requestId: requestId, phone: phoneNumber };
+    let jsonResp = await this.Post('/validation/otp/send', JSON.stringify(data));
+    if (typeof jsonResp != 'boolean') {
+      return false;
+    }
+    return jsonResp;
+  }
+  async CheckOTPCode(requestId, otpCode) {
+    let data = { requestId: requestId, otp: otpCode };
+    let jsonResp = await this.Post('/validation/otp/check', JSON.stringify(data));
+    if (typeof jsonResp != 'boolean') {
+      return false;
+    }
+    return jsonResp;
+  }
+  async AddIdentificationRequest(requestId, deviceInfo) {
+    let data = { requestId: requestId, clientDeviceInfo: deviceInfo };
+    let jsonResp = await this.Post('/validation/identity/insert', JSON.stringify(data));
+    if (typeof jsonResp.hasIdBack == 'boolean') {
+      store.state.hasIdBack = jsonResp.hasIdBack;
+      return true;
+    }
+    else {
+      return false;
+    }
+  }
+  async UploadFileForRequestB64(requestId, type, file) {
+    let data = {
+      requestId: requestId,
+      type: type,
+      data: await this.toBase64(file),
+    };
+    let respJson = await this.Post('/validation/upload/capture', JSON.stringify(data));
+    if (respJson && respJson.file_path) {
+      if (type == 'IdFront') {
+        return respJson.isValid;
+      }
+      return true;
+    }
+    else {
+      return false;
+    }
+  }
+  async UploadFileForRequest(requestId, type, file) {
+    try {
+      let data = new FormData();
+      data.append('requestId', requestId);
+      data.append('type', type);
+      data.append('file', file);
+      let resp = await fetch(store.state.apiBaseUrl + '/validation/upload/file', {
+        method: 'POST',
+        body: data,
+      });
+      if (!resp.ok) {
+        console.log(resp.statusText);
+        return false;
+      }
+      let respJson = await resp.json();
+      if (respJson && respJson.file_path) {
+        if (type == 'IdFront') {
+          return respJson.isValid;
+        }
+        return true;
+      }
+      else {
+        return false;
+      }
+    }
+    catch (err) {
+      console.log(err);
+      return false;
+    }
+  }
+  async GetAgreement(agreementType) {
+    try {
+      let resp = await this.Get('/validation/agreement/content?type=' + agreementType + '&requestId=' + store.state.requestId);
+      if (resp) {
+        return resp.htmlText;
+      }
+      return '';
+    }
+    catch (err) {
+      console.log(err);
+      return '';
+    }
+  }
+  async GenerateAgreement(agreementType) {
+    try {
+      let data = { requestId: store.state.requestId, documentType: agreementType };
+      let resp = await this.Post('/validation/agreement/generate', JSON.stringify(data));
+      if (typeof resp != 'boolean') {
+        return false;
+      }
+      return resp;
+    }
+    catch (err) {
+      console.log(err);
+      return false;
+    }
+  }
+}
+
+exports.ApiCall = ApiCall;

package/dist/cjs/Cameras-accbcbd2.js

@@ -0,0 +1,102 @@
+'use strict';
+
+class Cameras {
+  async GetCameras(deviceInfo) {
+    var allDevices = [];
+    const devices = await navigator.mediaDevices.enumerateDevices();
+    const videoDevices = devices.filter(device => device.kind === 'videoinput');
+    for (const device of videoDevices) {
+      const updatedConstraints = this.GetConstraints(device.deviceId, deviceInfo);
+      const stream = await navigator.mediaDevices.getUserMedia(updatedConstraints);
+      stream.getVideoTracks().forEach(track => {
+        if (deviceInfo.isFirefox) {
+          const settings = track.getSettings();
+          let facingMode = settings.facingMode && settings.facingMode.length > 0 ? settings.facingMode[0] : '';
+          facingMode = facingMode === 'e' ? 'environment' : facingMode;
+          allDevices.push({
+            deviceId: device.deviceId,
+            name: device.label,
+            height: settings.height,
+            width: settings.width,
+            frameRate: Number(settings.frameRate.max),
+            torch: false,
+            recommended: false,
+            facingMode: facingMode,
+          });
+        }
+        else {
+          const capabilities = track.getCapabilities();
+          let facingMode = capabilities.facingMode && capabilities.facingMode.length > 0 ? capabilities.facingMode[0] : '';
+          facingMode = facingMode === 'e' ? 'environment' : facingMode;
+          allDevices.push({
+            deviceId: device.deviceId,
+            name: device.label,
+            height: capabilities.height.max,
+            width: capabilities.width.max,
+            frameRate: Number(capabilities.frameRate.max),
+            torch: capabilities.torch,
+            recommended: false,
+            facingMode: facingMode,
+          });
+        }
+      });
+      stream.getTracks().forEach(track => {
+        track.stop();
+      });
+    }
+    if (allDevices.length > 0) {
+      allDevices = allDevices.sort((a, b) => b.frameRate - a.frameRate);
+      var firstOption = allDevices.find(i => i.name.indexOf('0,') != -1 && i.facingMode === 'environment');
+      if (firstOption) {
+        allDevices[allDevices.indexOf(firstOption)].recommended = true;
+      }
+      else {
+        var firstEnv = allDevices.find(i => i.facingMode === 'environment');
+        if (firstEnv) {
+          allDevices[allDevices.indexOf(firstEnv)].recommended = true;
+        }
+      }
+    }
+    return allDevices;
+  }
+  GetConstraints(selectedDeviceId, device, portrait = false) {
+    let constraints = {
+      audio: false,
+      video: {
+        frameRate: 30
+      }
+    };
+    if (selectedDeviceId) {
+      constraints.video.deviceId = {
+        exact: selectedDeviceId,
+      };
+    }
+    if (device.isWin) {
+      constraints.video.width = { ideal: 1280 };
+    }
+    else {
+      if (portrait) {
+        constraints.video.facingMode = 'user';
+        constraints.video.width = { ideal: 1280 };
+        constraints.video.height = { ideal: 720 };
+      }
+      else {
+        constraints.video.facingMode = 'environment';
+        constraints.video.width = { ideal: 1280 };
+        constraints.video.aspectRatio = 1;
+      }
+    }
+    return constraints;
+  }
+  GetRecommendedCamera(cameras) {
+    if (cameras && cameras.length > 0) {
+      var recommDevice = cameras.find(c => c.recommended);
+      if (recommDevice) {
+        return recommDevice;
+      }
+    }
+    return null;
+  }
+}
+
+exports.Cameras = Cameras;

package/dist/cjs/Events-68a316bc.js

@@ -0,0 +1,99 @@
+'use strict';
+
+class Events {
+  static init(element) {
+    this.cameraModule = element;
+  }
+  static flowStarted() {
+    this.cameraModule.dispatchEvent(new CustomEvent('ect-started', {
+      detail: {},
+      bubbles: true,
+      cancelable: true,
+      composed: true
+    }));
+  }
+  static flowCompleted() {
+    this.cameraModule.dispatchEvent(new CustomEvent('ect-completed', {
+      detail: {},
+      bubbles: true,
+      cancelable: true,
+      composed: true
+    }));
+  }
+  static captureEvent(photos) {
+    this.cameraModule.dispatchEvent(new CustomEvent('capture', {
+      detail: {
+        photos,
+      },
+      bubbles: true,
+      cancelable: true,
+      composed: true,
+    }));
+  }
+  static recordingAvailable(recording) {
+    this.cameraModule.dispatchEvent(new CustomEvent('recordingAvailable', {
+      detail: {
+        recording,
+      },
+      bubbles: true,
+      cancelable: true,
+      composed: true,
+    }));
+  }
+  static closeEvent() {
+    this.cameraModule.dispatchEvent(new CustomEvent('close', {
+      bubbles: false,
+      cancelable: true,
+      composed: true,
+    }));
+  }
+  static cameraReadyEvent() {
+    this.cameraModule.dispatchEvent(new CustomEvent('cameraReady', {
+      bubbles: false,
+      cancelable: true,
+      composed: true,
+    }));
+  }
+  static errorEvent(error) {
+    this.cameraModule.dispatchEvent(new CustomEvent('error', {
+      detail: {
+        error,
+      },
+      bubbles: true,
+      cancelable: true,
+      composed: true,
+    }));
+  }
+  static detectionError(error) {
+    this.cameraModule.dispatchEvent(new CustomEvent('detectionError', {
+      detail: {
+        error,
+      },
+      bubbles: true,
+      cancelable: true,
+      composed: true,
+    }));
+  }
+  static loadedModels(loadedModels) {
+    this.cameraModule.dispatchEvent(new CustomEvent('loadedModels', {
+      detail: {
+        loadedModels,
+      },
+      bubbles: true,
+      cancelable: true,
+      composed: true,
+    }));
+  }
+  static detectorInitialized(initializationTime) {
+    this.cameraModule.dispatchEvent(new CustomEvent('detectorInitialized', {
+      detail: {
+        initializationTime,
+      },
+      bubbles: true,
+      cancelable: true,
+      composed: true,
+    }));
+  }
+}
+
+exports.Events = Events;