@jaak.ai/stamps 1.0.0-beta.1

package/dist/collection/components/shared/mb-tooltip-advanced/mb-tooltip-advanced.js

@@ -0,0 +1,96 @@
+import { Host, h } from "@stencil/core";
+export class MbTooltipAdvanced {
+  constructor() {
+    this.show = undefined;
+    this.message = undefined;
+    this.arrowPosition = undefined;
+    this.textAlign = undefined;
+  }
+  render() {
+    return (h(Host, null, h("p", { part: "tooltip", class: `mb-tooltip ${this.show ? "visible" : ""} ${this.arrowPosition ? this.arrowPosition : "arrow-none"} ${this.textAlign ? this.textAlign : "text-center"} ` }, this.message)));
+  }
+  static get is() { return "mb-tooltip-advanced"; }
+  static get encapsulation() { return "shadow"; }
+  static get originalStyleUrls() {
+    return {
+      "$": ["mb-tooltip-advanced.scss"]
+    };
+  }
+  static get styleUrls() {
+    return {
+      "$": ["mb-tooltip-advanced.css"]
+    };
+  }
+  static get properties() {
+    return {
+      "show": {
+        "type": "boolean",
+        "mutable": false,
+        "complexType": {
+          "original": "boolean",
+          "resolved": "boolean",
+          "references": {}
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": ""
+        },
+        "attribute": "show",
+        "reflect": false
+      },
+      "message": {
+        "type": "string",
+        "mutable": false,
+        "complexType": {
+          "original": "string",
+          "resolved": "string",
+          "references": {}
+        },
+        "required": false,
+        "optional": false,
+        "docs": {
+          "tags": [],
+          "text": ""
+        },
+        "attribute": "message",
+        "reflect": false
+      },
+      "arrowPosition": {
+        "type": "string",
+        "mutable": false,
+        "complexType": {
+          "original": "| \"arrow-left\"\n    | \"arrow-right\"\n    | \"arrow-up\"\n    | \"arrow-up-left\"\n    | \"arrow-up-right\"\n    | \"arrow-down\"\n    | \"arrow-down-left\"\n    | \"arrow-down-right\"",
+          "resolved": "\"arrow-down\" | \"arrow-down-left\" | \"arrow-down-right\" | \"arrow-left\" | \"arrow-right\" | \"arrow-up\" | \"arrow-up-left\" | \"arrow-up-right\"",
+          "references": {}
+        },
+        "required": false,
+        "optional": true,
+        "docs": {
+          "tags": [],
+          "text": ""
+        },
+        "attribute": "arrow-position",
+        "reflect": false
+      },
+      "textAlign": {
+        "type": "string",
+        "mutable": false,
+        "complexType": {
+          "original": "\"text-center\" | \"text-left\" | \"text-right\"",
+          "resolved": "\"text-center\" | \"text-left\" | \"text-right\"",
+          "references": {}
+        },
+        "required": false,
+        "optional": true,
+        "docs": {
+          "tags": [],
+          "text": ""
+        },
+        "attribute": "text-align",
+        "reflect": false
+      }
+    };
+  }
+}

package/dist/collection/index.js

@@ -0,0 +1 @@
+export * from "./components";

package/dist/collection/utils/data-structures.js

@@ -0,0 +1,189 @@
+export { SDKError, } from "@microblink/blinkid-in-browser-sdk";
+/**
+ * Events
+ */
+export class EventReady {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+}
+export class EventScanError {
+  constructor(code, fatal, message, recognizerName, details) {
+    this.code = code;
+    this.fatal = fatal;
+    this.message = message;
+    this.recognizerName = recognizerName;
+    if (details) {
+      this.details = details;
+    }
+  }
+}
+export class EventScanSuccess {
+  constructor(recognizer, recognizerName) {
+    this.recognizer = recognizer;
+    this.recognizerName = recognizerName;
+  }
+}
+/**
+ * Error codes
+ */
+export var Code;
+(function (Code) {
+  Code["EmptyResult"] = "EMPTY_RESULT";
+  Code["InvalidRecognizerOptions"] = "INVALID_RECOGNIZER_OPTIONS";
+  Code["NoImageFileFound"] = "NO_IMAGE_FILE_FOUND";
+  Code["NoFirstImageFileFound"] = "NO_FIRST_IMAGE_FILE_FOUND";
+  Code["NoSecondImageFileFound"] = "NO_SECOND_IMAGE_FILE_FOUND";
+  Code["GenericScanError"] = "GENERIC_SCAN_ERROR";
+  Code["CameraNotAllowed"] = "CAMERA_NOT_ALLOWED";
+  Code["CameraInUse"] = "CAMERA_IN_USE";
+  Code["CameraGenericError"] = "CAMERA_GENERIC_ERROR";
+})(Code || (Code = {}));
+/**
+ * Scan structures
+ */
+export const AvailableRecognizers = {
+  IdBarcodeRecognizer: "createIdBarcodeRecognizer",
+  BlinkIdSingleSideRecognizer: "createBlinkIdSingleSideRecognizer",
+  BlinkIdMultiSideRecognizer: "createBlinkIdMultiSideRecognizer",
+};
+export var ImageRecognitionType;
+(function (ImageRecognitionType) {
+  ImageRecognitionType["SingleSide"] = "SingleSide";
+  ImageRecognitionType["MultiSide"] = "MultiSide";
+})(ImageRecognitionType || (ImageRecognitionType = {}));
+export var MultiSideImageType;
+(function (MultiSideImageType) {
+  MultiSideImageType["First"] = "First";
+  MultiSideImageType["Second"] = "Second";
+})(MultiSideImageType || (MultiSideImageType = {}));
+export var RecognitionStatus;
+(function (RecognitionStatus) {
+  RecognitionStatus["NoImageFileFound"] = "NoImageFileFound";
+  RecognitionStatus["NoFirstImageFileFound"] = "NoFirstImageFileFound";
+  RecognitionStatus["NoSecondImageFileFound"] = "NoSecondImageFileFound";
+  RecognitionStatus["Preparing"] = "Preparing";
+  RecognitionStatus["Ready"] = "Ready";
+  RecognitionStatus["Processing"] = "Processing";
+  RecognitionStatus["DetectionFailed"] = "DetectionFailed";
+  RecognitionStatus["WrongSide"] = "WrongSide";
+  RecognitionStatus["FacePhotoCovered"] = "FacePhotoCovered";
+  RecognitionStatus["EmptyResultState"] = "EmptyResultState";
+  RecognitionStatus["OnFirstSideResult"] = "OnFirstSideResult";
+  RecognitionStatus["ScanSuccessful"] = "ScanSuccessful";
+  RecognitionStatus["DocumentClassified"] = "DocumentClassified";
+  // Camera states
+  RecognitionStatus["DetectionStatusChange"] = "DetectionStatusChange";
+  RecognitionStatus["NoSupportForMediaDevices"] = "NoSupportForMediaDevices";
+  RecognitionStatus["CameraNotFound"] = "CameraNotFound";
+  RecognitionStatus["CameraNotAllowed"] = "CameraNotAllowed";
+  RecognitionStatus["UnableToAccessCamera"] = "UnableToAccessCamera";
+  RecognitionStatus["CameraInUse"] = "CameraInUse";
+  RecognitionStatus["CameraGenericError"] = "CameraGenericError";
+  // Blur and glare
+  RecognitionStatus["BlurDetected"] = "BlurDetected";
+  RecognitionStatus["GlareDetected"] = "GlareDetected";
+  // Passport states
+  RecognitionStatus["MovePassportLeft"] = "MovePassportLeft";
+  RecognitionStatus["MovePassportRight"] = "MovePassportRight";
+  RecognitionStatus["MovePassportUp"] = "MovePassportUp";
+  RecognitionStatus["MovePassportDown"] = "MovePassportDown";
+  RecognitionStatus["MovePassportDownError"] = "MovePassportDownError";
+  RecognitionStatus["MovePassportUpError"] = "MovePassportUpError";
+  RecognitionStatus["MovePassportRightError"] = "MovePassportRightError";
+  RecognitionStatus["MovePassportLeftError"] = "MovePassportLeftError";
+  RecognitionStatus["ScanPassportLeft"] = "ScanPassportLeft";
+  RecognitionStatus["ScanPassportRight"] = "ScanPassportRight";
+  RecognitionStatus["ScanPassportUp"] = "ScanPassportUp";
+  RecognitionStatus["ScanPassportDown"] = "ScanPassportDown";
+  // Errors
+  RecognitionStatus["UnknownError"] = "UnknownError";
+  RecognitionStatus["BarcodeScanningStarted"] = "BarcodeScanningStarted";
+  // BlinkIDSDK.DetectionStatus
+  RecognitionStatus["DetectionStatusFail"] = "Fail";
+  RecognitionStatus["DetectionStatusSuccess"] = "Success";
+  RecognitionStatus["DetectionStatusCameraTooHigh"] = "CameraTooHigh";
+  RecognitionStatus["DetectionStatusFallbackSuccess"] = "FallbackSuccess";
+  RecognitionStatus["DetectionStatusPartial"] = "Partial";
+  RecognitionStatus["DetectionStatusCameraAtAngle"] = "CameraAtAngle";
+  RecognitionStatus["DetectionStatusCameraTooNear"] = "CameraTooNear";
+  RecognitionStatus["DetectionStatusDocumentTooCloseToEdge"] = "DocumentTooCloseToEdge";
+})(RecognitionStatus || (RecognitionStatus = {}));
+export var CameraExperience;
+(function (CameraExperience) {
+  CameraExperience["Barcode"] = "BARCODE";
+  CameraExperience["CardMultiSide"] = "CARD_MULTI_SIDE";
+  CameraExperience["CardSingleSide"] = "CARD_SINGLE_SIDE";
+  CameraExperience["PaymentCard"] = "PAYMENT_CARD";
+  CameraExperience["Passport"] = "PASSPORT";
+})(CameraExperience || (CameraExperience = {}));
+export var CameraExperienceState;
+(function (CameraExperienceState) {
+  CameraExperienceState["BarcodeScanning"] = "BarcodeScanning";
+  CameraExperienceState["AdjustAngle"] = "AdjustAngle";
+  CameraExperienceState["Classification"] = "Classification";
+  CameraExperienceState["Default"] = "Default";
+  CameraExperienceState["Detection"] = "Detection";
+  CameraExperienceState["Done"] = "Done";
+  CameraExperienceState["DoneAll"] = "DoneAll";
+  CameraExperienceState["Flip"] = "Flip";
+  CameraExperienceState["WrongSide"] = "WrongSide";
+  CameraExperienceState["MoveCloser"] = "MoveCloser";
+  CameraExperienceState["MoveFarther"] = "MoveFarther";
+  CameraExperienceState["BlurDetected"] = "BlurDetected";
+  CameraExperienceState["GlareDetected"] = "GlareDetected";
+  CameraExperienceState["FacePhotoCovered"] = "FacePhotoCovered";
+  // passport states
+  CameraExperienceState["MovePassportLeft"] = "MovePassportLeft";
+  CameraExperienceState["MovePassportRight"] = "MovePassportRight";
+  CameraExperienceState["MovePassportUp"] = "MovePassportUp";
+  CameraExperienceState["MovePassportDown"] = "MovePassportDown";
+  CameraExperienceState["ScanPassportLeft"] = "ScanPassportLeft";
+  CameraExperienceState["ScanPassportRight"] = "ScanPassportRight";
+  CameraExperienceState["ScanPassportUp"] = "ScanPassportUp";
+  CameraExperienceState["ScanPassportDown"] = "ScanPassportDown";
+  CameraExperienceState["MovePassportDownError"] = "MovePassportDownError";
+  CameraExperienceState["MovePassportUpError"] = "MovePassportUpError";
+  CameraExperienceState["MovePassportRightError"] = "MovePassportRightError";
+  CameraExperienceState["MovePassportLeftError"] = "MovePassportLeftError";
+})(CameraExperienceState || (CameraExperienceState = {}));
+export const CameraExperienceStateDuration = new Map([
+  [CameraExperienceState.BarcodeScanning, 3500],
+  [CameraExperienceState.AdjustAngle, 2500],
+  [CameraExperienceState.Default, 500],
+  [CameraExperienceState.Done, 1000],
+  [CameraExperienceState.DoneAll, 400],
+  [CameraExperienceState.Flip, 3500],
+  [CameraExperienceState.WrongSide, 1500],
+  [CameraExperienceState.MoveCloser, 2500],
+  [CameraExperienceState.MoveFarther, 2500],
+  [CameraExperienceState.BlurDetected, 2500],
+  [CameraExperienceState.GlareDetected, 2500],
+  [CameraExperienceState.FacePhotoCovered, 2500],
+  [CameraExperienceState.MovePassportLeft, 2500],
+  [CameraExperienceState.MovePassportRight, 2500],
+  [CameraExperienceState.MovePassportUp, 2500],
+  [CameraExperienceState.MovePassportDown, 2500],
+  [CameraExperienceState.ScanPassportLeft, 1500],
+  [CameraExperienceState.ScanPassportRight, 1500],
+  [CameraExperienceState.ScanPassportUp, 1500],
+  [CameraExperienceState.ScanPassportDown, 1500],
+  [CameraExperienceState.MovePassportDownError, 2500],
+  [CameraExperienceState.MovePassportUpError, 2500],
+  [CameraExperienceState.MovePassportRightError, 2500],
+  [CameraExperienceState.MovePassportLeftError, 2500],
+]);
+/**
+ * User feedback structures
+ */
+export var FeedbackCode;
+(function (FeedbackCode) {
+  FeedbackCode["CameraDisabled"] = "CAMERA_DISABLED";
+  FeedbackCode["CameraGenericError"] = "CAMERA_GENERIC_ERROR";
+  FeedbackCode["CameraInUse"] = "CAMERA_IN_USE";
+  FeedbackCode["CameraNotAllowed"] = "CAMERA_NOT_ALLOWED";
+  FeedbackCode["GenericScanError"] = "GENERIC_SCAN_ERROR";
+  FeedbackCode["ScanStarted"] = "SCAN_STARTED";
+  FeedbackCode["ScanUnsuccessful"] = "SCAN_UNSUCCESSFUL";
+  FeedbackCode["ScanSuccessful"] = "SCAN_SUCCESSFUL";
+})(FeedbackCode || (FeedbackCode = {}));

package/dist/collection/utils/device.helpers.js

@@ -0,0 +1,37 @@
+import * as BlinkIDSDK from "@microblink/blinkid-in-browser-sdk";
+export function hasVideoDevices() {
+  return new Promise((resolve) => {
+    if (!window.navigator ||
+      !window.navigator.mediaDevices ||
+      typeof window.navigator.mediaDevices.enumerateDevices !== "function") {
+      resolve(false);
+      return;
+    }
+    window.navigator.mediaDevices.enumerateDevices().then((devices) => {
+      devices = devices || [];
+      for (const device of devices) {
+        if (device && device.kind === "videoinput") {
+          resolve(true);
+          return;
+        }
+      }
+      resolve(false);
+    });
+  });
+}
+export function isWasmSupported() {
+  return new Promise((resolve) => {
+    const wasmSupport = BlinkIDSDK.isBrowserSupported();
+    resolve(wasmSupport);
+  });
+}
+export async function checkMandatoryCapabilites() {
+  const wasmSupport = await isWasmSupported();
+  return wasmSupport;
+}
+/**
+ * Determine whether this is a desktop device based on the screen resolution.
+ */
+export function isDesktop() {
+  return !/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
+}

package/dist/collection/utils/error-structures.js

@@ -0,0 +1,47 @@
+/* eslint-disable max-len */
+/**
+ * Structures of Error Codes, Error Messages, and CustomError compatible objects for the Error Generator utility.
+ * Error Code convention: SECTION_OBJECT_(ACTION)_PROBLEM
+ */
+export var ErrorCodes;
+(function (ErrorCodes) {
+  ErrorCodes["BrowserNotSupported"] = "BROWSER_NOT_SUPPORTED";
+  ErrorCodes["LicenseError"] = "LICENSE_ERROR";
+  ErrorCodes["SdkLoadFailed"] = "SDK_LOAD_FAILED";
+  ErrorCodes["InternetNotAvailable"] = "INTERNET_NOT_AVAILABLE";
+  ErrorCodes["InvalidRecognizers"] = "INVALID_RECOGNIZERS";
+  ErrorCodes["InvalidPingProxyUrl"] = "INVALID_PING_PROXY_URL";
+  ErrorCodes["PingProxyPermissionNotGranted"] = "PING_PROXY_PERMISSION_NOT_GRANTED";
+})(ErrorCodes || (ErrorCodes = {}));
+export var ErrorMessages;
+(function (ErrorMessages) {
+  ErrorMessages["BrowserNotSupported"] = "Browser is not supported!";
+  ErrorMessages["LicenseError"] = "Something is wrong with the license.";
+  ErrorMessages["SdkLoadFailed"] = "Failed to load SDK!";
+  ErrorMessages["InvalidPingProxyUrl"] = "Provided ping proxy URL is not a valid secure URL in format 'https://{host}:{port?}'.";
+  ErrorMessages["PingProxyPermissionNotGranted"] = "Allow ping proxy permission not found in license.";
+})(ErrorMessages || (ErrorMessages = {}));
+export const componentErrors = {
+  browserNotSupported: {
+    code: ErrorCodes.BrowserNotSupported,
+    message: ErrorMessages.BrowserNotSupported,
+  },
+  licenseError: {
+    code: ErrorCodes.LicenseError,
+    message: ErrorMessages.LicenseError,
+  },
+  sdkLoadFailed: {
+    code: ErrorCodes.SdkLoadFailed,
+    message: ErrorMessages.SdkLoadFailed,
+  },
+  pingProxyErrors: {
+    invalidProxyUrl: {
+      message: ErrorMessages.InvalidPingProxyUrl,
+      code: ErrorCodes.InvalidPingProxyUrl,
+    },
+    permissionNotGranted: {
+      message: ErrorMessages.PingProxyPermissionNotGranted,
+      code: ErrorCodes.PingProxyPermissionNotGranted,
+    },
+  },
+};

package/dist/collection/utils/generic.helpers.js

@@ -0,0 +1,82 @@
+export function stringToArray(inputString) {
+  if (!inputString || !inputString.length) {
+    return [];
+  }
+  return inputString.split(",").map((el) => el.trim());
+}
+export function stringToObject(inputString) {
+  if (!inputString || !inputString.length) {
+    return {};
+  }
+  return JSON.parse(inputString);
+}
+export function hasSupportedImageFiles(files) {
+  const imageRegex = RegExp(/^image\//);
+  for (let i = 0; i < files.length; ++i) {
+    if (imageRegex.exec(files[i].type)) {
+      return true;
+    }
+  }
+  return false;
+}
+export function extractFilenameFromPath(path) {
+  return path.split("\\").pop();
+}
+export function getImageFile(fileList) {
+  if (fileList === null) {
+    return null;
+  }
+  let image = null;
+  const imageRegex = RegExp(/^image\//);
+  for (let i = 0; i < fileList.length; ++i) {
+    if (imageRegex.exec(fileList[i].type)) {
+      image = fileList[i];
+    }
+  }
+  return image;
+}
+/**
+ * Inspired by https://github.com/JedWatson/classnames.
+ * @param classes Class names and their conditions.
+ * @returns Joined string of class names.
+ */
+export function classNames(classes) {
+  const result = [];
+  const keys = Object.keys(classes);
+  keys.forEach((key) => {
+    if (classes[key]) {
+      result.push(key);
+    }
+  });
+  return result.join(" ");
+}
+/**
+ * @param root shadowroot to apply the query from
+ * @returns array of part selectors
+ */
+export function getWebComponentParts(root) {
+  const nodesWithPart = root.querySelectorAll("[part]");
+  const parts = new Set();
+  nodesWithPart.forEach((el) => {
+    const partsArray = el.getAttribute("part").split(" ");
+    partsArray.forEach((partName) => parts.add(partName));
+  });
+  return [...parts];
+}
+export function getWebComponentExportedParts(root) {
+  const nodesWithPart = root.querySelectorAll("[exportparts]");
+  const exportedParts = new Set();
+  nodesWithPart.forEach((el) => {
+    const exportedPartsArray = el.getAttribute("exportparts").split(" ");
+    exportedPartsArray.forEach((partName) => exportedParts.add(partName));
+  });
+  return [...exportedParts];
+}
+export function setWebComponentParts(hostEl) {
+  const partParts = [hostEl.tagName.toLowerCase(), hostEl.getAttribute("id")];
+  hostEl.setAttribute("part", partParts.join(" ").trim());
+}
+export function uuidv4() {
+  return ([1e7] + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, (c) => (c ^
+    (crypto.getRandomValues(new Uint8Array(1))[0] & (15 >> (c / 4)))).toString(16));
+}