@aws-amplify/ui-react-liveness 2.0.10 → 3.0.0

package/dist/esm/components/FaceLivenessDetector/service/types/error.mjs

@@ -1 +1,16 @@
-const R={TIMEOUT:"TIMEOUT",RUNTIME_ERROR:"RUNTIME_ERROR",FRESHNESS_TIMEOUT:"FRESHNESS_TIMEOUT",SERVER_ERROR:"SERVER_ERROR",CAMERA_FRAMERATE_ERROR:"CAMERA_FRAMERATE_ERROR",CAMERA_ACCESS_ERROR:"CAMERA_ACCESS_ERROR",FACE_DISTANCE_ERROR:"FACE_DISTANCE_ERROR",MOBILE_LANDSCAPE_ERROR:"MOBILE_LANDSCAPE_ERROR",MULTIPLE_FACES_ERROR:"MULTIPLE_FACES_ERROR"};export{R as LivenessErrorState};
+/**
+ * The liveness error states
+ */
+const LivenessErrorState = {
+    TIMEOUT: 'TIMEOUT',
+    RUNTIME_ERROR: 'RUNTIME_ERROR',
+    FRESHNESS_TIMEOUT: 'FRESHNESS_TIMEOUT',
+    SERVER_ERROR: 'SERVER_ERROR',
+    CAMERA_FRAMERATE_ERROR: 'CAMERA_FRAMERATE_ERROR',
+    CAMERA_ACCESS_ERROR: 'CAMERA_ACCESS_ERROR',
+    FACE_DISTANCE_ERROR: 'FACE_DISTANCE_ERROR',
+    MOBILE_LANDSCAPE_ERROR: 'MOBILE_LANDSCAPE_ERROR',
+    MULTIPLE_FACES_ERROR: 'MULTIPLE_FACES_ERROR',
+};
+
+export { LivenessErrorState };

package/dist/esm/components/FaceLivenessDetector/service/types/faceDetection.mjs

@@ -1 +1,15 @@
-class o{triggerModelLoading(){this.modelLoadingPromise=this.loadModels()}}export{o as FaceDetection};
+/**
+ * The abstract class representing FaceDetection
+ * to be implemented for different libraries.
+ */
+class FaceDetection {
+    /**
+     * Triggers the `loadModels` method and stores
+     * the corresponding promise to be awaited later.
+     */
+    triggerModelLoading() {
+        this.modelLoadingPromise = this.loadModels();
+    }
+}
+
+export { FaceDetection };

package/dist/esm/components/FaceLivenessDetector/service/types/liveness.mjs

@@ -1 +1,23 @@
-var O,T;!function(O){O.DARK="dark",O.BRIGHT="bright",O.NORMAL="normal"}(O||(O={})),function(O){O.MATCHED="MATCHED",O.TOO_FAR="TOO FAR",O.TOO_CLOSE="TOO CLOSE",O.CANT_IDENTIFY="CANNOT IDENTIFY",O.FACE_IDENTIFIED="ONE FACE IDENTIFIED",O.TOO_MANY="TOO MANY FACES"}(T||(T={}));export{T as FaceMatchState,O as IlluminationState};
+/**
+ * The illumination states
+ */
+var IlluminationState;
+(function (IlluminationState) {
+    IlluminationState["DARK"] = "dark";
+    IlluminationState["BRIGHT"] = "bright";
+    IlluminationState["NORMAL"] = "normal";
+})(IlluminationState || (IlluminationState = {}));
+/**
+ * The detected face states with respect to the liveness oval
+ */
+var FaceMatchState;
+(function (FaceMatchState) {
+    FaceMatchState["MATCHED"] = "MATCHED";
+    FaceMatchState["TOO_FAR"] = "TOO FAR";
+    FaceMatchState["TOO_CLOSE"] = "TOO CLOSE";
+    FaceMatchState["CANT_IDENTIFY"] = "CANNOT IDENTIFY";
+    FaceMatchState["FACE_IDENTIFIED"] = "ONE FACE IDENTIFIED";
+    FaceMatchState["TOO_MANY"] = "TOO MANY FACES";
+})(FaceMatchState || (FaceMatchState = {}));
+
+export { FaceMatchState, IlluminationState };

package/dist/esm/components/FaceLivenessDetector/service/utils/CustomWebSocketFetchHandler.mjs

@@ -1 +1,200 @@
-import{__awaiter as t,__asyncGenerator as e,__await as o,__asyncValues as s}from"tslib";import{formatUrl as r}from"@aws-sdk/util-format-url";import{readableStreamtoIterable as n,iterableToReadableStream as i}from"@smithy/eventstream-serde-browser";import{FetchHttpHandler as c}from"@smithy/fetch-http-handler";import{HttpResponse as a}from"@smithy/protocol-http";import{WS_CLOSURE_CODE as l}from"./constants.mjs";const d=2e3,h=t=>{return t[Symbol.asyncIterator]?t:(s=t,"function"==typeof ReadableStream&&s instanceof ReadableStream?n(t):{[Symbol.asyncIterator]:function(){return e(this,arguments,(function*(){yield yield o(t)}))}});var s};class f{constructor(t,e=new c){this.metadata={handlerProtocol:"websocket/h1.1"},this.sockets={},this.utf8decoder=new TextDecoder,this.httpHandler=e,this.configPromise="function"==typeof t?t().then((t=>null!=t?t:{})):Promise.resolve(null!=t?t:{})}destroy(){for(const[t,e]of Object.entries(this.sockets)){for(const t of e)t.close(1e3,"Socket closed through destroy() call");delete this.sockets[t]}}handle(e){return t(this,void 0,void 0,(function*(){if(!(t=>"ws:"===t.protocol||"wss:"===t.protocol)(e))return this.httpHandler.handle(e);const t=r(e),o=new WebSocket(t);this.sockets[t]||(this.sockets[t]=[]),this.sockets[t].push(o),o.binaryType="arraybuffer";const{connectionTimeout:s=d}=yield this.configPromise;yield this.waitForReady(o,s);const{body:n}=e,c=h(n),l=(t=>"function"==typeof ReadableStream?i(t):t)(this.connect(o,c));return{response:new a({statusCode:200,body:l})}}))}removeNotUsableSockets(t){var e;this.sockets[t]=(null!==(e=this.sockets[t])&&void 0!==e?e:[]).filter((t=>![WebSocket.CLOSING,WebSocket.CLOSED].includes(t.readyState)))}waitForReady(t,e){return new Promise(((o,s)=>{const r=setTimeout((()=>{this.removeNotUsableSockets(t.url),s({$metadata:{httpStatusCode:500}})}),e);t.onopen=()=>{clearTimeout(r),o()}}))}connect(e,o){let r,n=!1,i=()=>{},c=()=>{};e.onmessage=t=>{c({done:!1,value:new Uint8Array(t.data)})},e.onerror=t=>{n=!0,e.close(),i(t)},e.onclose=()=>{this.removeNotUsableSockets(e.url),n||(r?i(r):c({done:!0,value:void 0}))};const a={[Symbol.asyncIterator]:()=>({next:()=>new Promise(((t,e)=>{c=t,i=e}))})};return(()=>{t(this,void 0,void 0,(function*(){var t,n,i,c;try{try{for(var a,d=!0,h=s(o);!(t=(a=yield h.next()).done);){c=a.value,d=!1;try{const t=c,o=this.utf8decoder.decode(t);if(o.includes("closeCode")){const t=o.match(/"closeCode":([0-9]*)/);if(t){const o=t[1];e.close(parseInt(o))}continue}e.send(t)}finally{d=!0}}}catch(t){n={error:t}}finally{try{d||t||!(i=h.return)||(yield i.call(h))}finally{if(n)throw n.error}}}catch(t){r=t}finally{e.close(l.SUCCESS_CODE)}}))})(),a}}export{f as CustomWebSocketFetchHandler};
+import { formatUrl } from '@aws-sdk/util-format-url';
+import { readableStreamtoIterable, iterableToReadableStream } from '@smithy/eventstream-serde-browser';
+import { FetchHttpHandler } from '@smithy/fetch-http-handler';
+import { HttpResponse } from '@smithy/protocol-http';
+import { WS_CLOSURE_CODE } from './constants.mjs';
+
+/**
+ * Note: This file was copied from https://github.com/aws/aws-sdk-js-v3/blob/main/packages/middleware-websocket/src/websocket-fetch-handler.ts#L176
+ * Because of this the file is not fully typed at this time but we should eventually work on fully typing this file.
+ */
+const DEFAULT_WS_CONNECTION_TIMEOUT_MS = 2000;
+const isWebSocketRequest = (request) => request.protocol === 'ws:' || request.protocol === 'wss:';
+const isReadableStream = (payload) => typeof ReadableStream === 'function' && payload instanceof ReadableStream;
+/**
+ * Transfer payload data to an AsyncIterable.
+ * When the ReadableStream API is available in the runtime(e.g. browser), and
+ * the request body is ReadableStream, so we need to transfer it to AsyncIterable
+ * to make the stream consumable by WebSocket.
+ */
+const getIterator = (stream) => {
+    // Noop if stream is already an async iterable
+    if (stream[Symbol.asyncIterator]) {
+        return stream;
+    }
+    if (isReadableStream(stream)) {
+        //If stream is a ReadableStream, transfer the ReadableStream to async iterable.
+        return readableStreamtoIterable(stream);
+    }
+    //For other types, just wrap them with an async iterable.
+    return {
+        [Symbol.asyncIterator]: async function* () {
+            yield stream;
+        },
+    };
+};
+/**
+ * Convert async iterable to a ReadableStream when ReadableStream API
+ * is available(browsers). Otherwise, leave as it is(ReactNative).
+ */
+const toReadableStream = (asyncIterable) => typeof ReadableStream === 'function'
+    ? iterableToReadableStream(asyncIterable)
+    : asyncIterable;
+/**
+ * Base handler for websocket requests and HTTP request. By default, the request input and output
+ * body will be in a ReadableStream, because of interface consistency among middleware.
+ * If ReadableStream is not available, like in React-Native, the response body
+ * will be an async iterable.
+ */
+class CustomWebSocketFetchHandler {
+    constructor(options, httpHandler = new FetchHttpHandler()) {
+        this.metadata = {
+            handlerProtocol: 'websocket/h1.1',
+        };
+        this.sockets = {};
+        this.utf8decoder = new TextDecoder(); // default 'utf-8' or 'utf8'
+        this.httpHandler = httpHandler;
+        if (typeof options === 'function') {
+            this.configPromise = options().then((opts) => opts ?? {});
+        }
+        else {
+            this.configPromise = Promise.resolve(options ?? {});
+        }
+    }
+    /**
+     * Destroys the WebSocketHandler.
+     * Closes all sockets from the socket pool.
+     */
+    destroy() {
+        for (const [key, sockets] of Object.entries(this.sockets)) {
+            for (const socket of sockets) {
+                socket.close(1000, `Socket closed through destroy() call`);
+            }
+            delete this.sockets[key];
+        }
+    }
+    async handle(request) {
+        if (!isWebSocketRequest(request)) {
+            return this.httpHandler.handle(request);
+        }
+        const url = formatUrl(request);
+        const socket = new WebSocket(url);
+        // Add socket to sockets pool
+        if (!this.sockets[url]) {
+            this.sockets[url] = [];
+        }
+        this.sockets[url].push(socket);
+        socket.binaryType = 'arraybuffer';
+        const { connectionTimeout = DEFAULT_WS_CONNECTION_TIMEOUT_MS } = await this
+            .configPromise;
+        await this.waitForReady(socket, connectionTimeout);
+        const { body } = request;
+        const bodyStream = getIterator(body);
+        const asyncIterable = this.connect(socket, bodyStream);
+        const outputPayload = toReadableStream(asyncIterable);
+        return {
+            response: new HttpResponse({
+                statusCode: 200,
+                body: outputPayload,
+            }),
+        };
+    }
+    /**
+     * Removes all closing/closed sockets from the socket pool for URL.
+     */
+    removeNotUsableSockets(url) {
+        this.sockets[url] = (this.sockets[url] ?? []).filter((socket) => ![WebSocket.CLOSING, WebSocket.CLOSED].includes(socket.readyState));
+    }
+    waitForReady(socket, connectionTimeout) {
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.removeNotUsableSockets(socket.url);
+                reject({
+                    $metadata: {
+                        httpStatusCode: 500,
+                    },
+                });
+            }, connectionTimeout);
+            socket.onopen = () => {
+                clearTimeout(timeout);
+                resolve();
+            };
+        });
+    }
+    connect(socket, data) {
+        // To notify output stream any error thrown after response
+        // is returned while data keeps streaming.
+        let streamError = undefined;
+        // To notify onclose event that error has occurred.
+        let socketErrorOccurred = false;
+        // initialize as no-op.
+        let reject = () => { };
+        let resolve = () => { };
+        socket.onmessage = (event) => {
+            resolve({
+                done: false,
+                value: new Uint8Array(event.data),
+            });
+        };
+        socket.onerror = (error) => {
+            socketErrorOccurred = true;
+            socket.close();
+            reject(error);
+        };
+        socket.onclose = () => {
+            this.removeNotUsableSockets(socket.url);
+            if (socketErrorOccurred)
+                return;
+            if (streamError) {
+                reject(streamError);
+            }
+            else {
+                resolve({
+                    done: true,
+                    value: undefined, // unchecked because done=true.
+                });
+            }
+        };
+        const outputStream = {
+            [Symbol.asyncIterator]: () => ({
+                next: () => {
+                    return new Promise((_resolve, _reject) => {
+                        resolve = _resolve;
+                        reject = _reject;
+                    });
+                },
+            }),
+        };
+        const send = async () => {
+            try {
+                for await (const inputChunk of data) {
+                    const decodedString = this.utf8decoder.decode(inputChunk);
+                    if (decodedString.includes('closeCode')) {
+                        const match = decodedString.match(/"closeCode":([0-9]*)/);
+                        if (match) {
+                            const closeCode = match[1];
+                            socket.close(parseInt(closeCode));
+                        }
+                        continue;
+                    }
+                    socket.send(inputChunk);
+                }
+            }
+            catch (err) {
+                // We don't throw the error here because the send()'s returned
+                // would already be settled by the time sending chunk throws error.
+                // Instead, the notify the output stream to throw if there's
+                // exceptions
+                streamError = err;
+            }
+            finally {
+                // WS status code: https://tools.ietf.org/html/rfc6455#section-7.4
+                socket.close(WS_CLOSURE_CODE.SUCCESS_CODE);
+            }
+        };
+        send();
+        return outputStream;
+    }
+}
+
+export { CustomWebSocketFetchHandler };

package/dist/esm/components/FaceLivenessDetector/service/utils/blazefaceFaceDetection.mjs

@@ -1 +1,102 @@
-import{__awaiter as e}from"tslib";import*as t from"@tensorflow/tfjs-core";import*as o from"@tensorflow-models/blazeface";import*as s from"@tensorflow/tfjs-backend-wasm";import"@tensorflow/tfjs-backend-cpu";import{jitteredExponentialRetry as a}from"@aws-amplify/core";import{isWebAssemblySupported as i}from"./support.mjs";import{FaceDetection as r}from"../types/faceDetection.mjs";import"../types/liveness.mjs";const n="0.0.7",l=`https://cdn.liveness.rekognition.amazonaws.com/face-detection/tensorflow-models/blazeface/${n}/model/model.json`,d=`https://cdn.liveness.rekognition.amazonaws.com/face-detection/tensorflow/tfjs-backend-wasm/${s.version_wasm}/`;class m extends r{constructor(e,t){super(),this.faceModelUrl=null!=t?t:l,this.binaryPath=null!=e?e:d}loadModels(){return e(this,void 0,void 0,(function*(){i()?yield this._loadWebAssemblyBackend():yield this._loadCPUBackend();try{yield t.ready(),this._model=yield a(o.load,[{modelUrl:this.faceModelUrl}])}catch(e){throw new Error("There was an error loading the blazeface model. If you are using a custom blazeface model url ensure that it is a fully qualified url that returns a json file.")}}))}detectFaces(t){return e(this,void 0,void 0,(function*(){const e=yield this._model.estimateFaces(t,!1,!0,!0),o=Date.now();return e.filter((e=>!!e.landmarks)).map((e=>{const{topLeft:t,bottomRight:s,probability:a,landmarks:i}=e,[r,n]=t,[l,d]=s,m=Math.abs(r-l),c=Math.abs(d-n),f=i[0],h=i[1],u=i[2],w=i[3];return{top:n,left:l,width:m,height:c,timestampMs:o,probability:a[0],rightEye:f,leftEye:h,mouth:w,nose:u}}))}))}_loadWebAssemblyBackend(){return e(this,void 0,void 0,(function*(){try{s.setWasmPaths(this.binaryPath),yield a((()=>e(this,void 0,void 0,(function*(){if(!(yield t.setBackend("wasm")))throw new Error("Initialization of backend wasm failed")}))),[]),this.modelBackend="wasm"}catch(e){throw new Error('There was an error loading the TFJS WASM backend. If you are using a custom WASM path ensure that it ends with "/" and that it is not the full URL as @tensorflow/tfjs-backend-wasm will append the wasm binary file name. Read more: https://github.com/tensorflow/tfjs/blob/master/tfjs-backend-wasm/src/backend_wasm.ts#L475.')}}))}_loadCPUBackend(){return e(this,void 0,void 0,(function*(){yield t.setBackend("cpu"),this.modelBackend="cpu"}))}}export{n as BLAZEFACE_VERSION,m as BlazeFaceFaceDetection,l as DEFAULT_BLAZEFACE_URL,d as DEFAULT_TFJS_WASM_URL};
+import { ready, setBackend } from '@tensorflow/tfjs-core';
+import { createDetector, SupportedModels } from '@tensorflow-models/face-detection';
+import { setWasmPaths, version_wasm } from '@tensorflow/tfjs-backend-wasm';
+import '@tensorflow/tfjs-backend-cpu';
+import { jitteredExponentialRetry } from '@aws-amplify/core/internals/utils';
+import { isWebAssemblySupported } from './support.mjs';
+import { FaceDetection } from '../types/faceDetection.mjs';
+import '../types/liveness.mjs';
+
+const BLAZEFACE_VERSION = '1.0.2';
+/**
+ *   WARNING: When updating these links,
+ *   also make sure to update documentation and the link in the canary/e2e test "canary/e2e/features/liveness/face-detect.feature"
+ */
+const DEFAULT_BLAZEFACE_URL = `https://cdn.liveness.rekognition.amazonaws.com/face-detection/tensorflow-models/blazeface/${BLAZEFACE_VERSION}/model/model.json`;
+const DEFAULT_TFJS_WASM_URL = `https://cdn.liveness.rekognition.amazonaws.com/face-detection/tensorflow/tfjs-backend-wasm/${version_wasm}/`;
+/**
+ * The BlazeFace implementation of the FaceDetection interface.
+ */
+class BlazeFaceFaceDetection extends FaceDetection {
+    constructor(binaryPath, faceModelUrl) {
+        super();
+        this.faceModelUrl = faceModelUrl ?? DEFAULT_BLAZEFACE_URL;
+        this.binaryPath = binaryPath ?? DEFAULT_TFJS_WASM_URL;
+    }
+    async loadModels() {
+        if (isWebAssemblySupported()) {
+            await this._loadWebAssemblyBackend();
+        }
+        else {
+            await this._loadCPUBackend();
+        }
+        try {
+            await ready();
+            this._model = await createDetector(SupportedModels.MediaPipeFaceDetector, {
+                runtime: 'tfjs',
+                detectorModelUrl: this.faceModelUrl,
+            });
+        }
+        catch (e) {
+            throw new Error('There was an error loading the blazeface model. If you are using a custom blazeface model url ensure that it is a fully qualified url that returns a json file.');
+        }
+    }
+    async detectFaces(videoEl) {
+        const flipHorizontal = true;
+        const predictions = await this._model.estimateFaces(videoEl, {
+            flipHorizontal,
+        });
+        const timestampMs = Date.now();
+        const faces = predictions.map((prediction) => {
+            const { box, keypoints } = prediction;
+            const { xMin: left, yMin: top, width, height } = box;
+            const rightEye = this._getCoordinate(keypoints, 'rightEye');
+            const leftEye = this._getCoordinate(keypoints, 'leftEye');
+            const nose = this._getCoordinate(keypoints, 'noseTip');
+            const mouth = this._getCoordinate(keypoints, 'mouthCenter');
+            const rightEar = this._getCoordinate(keypoints, 'rightEarTragion');
+            const leftEar = this._getCoordinate(keypoints, 'leftEarTragion');
+            const probability = [90];
+            return {
+                top,
+                left,
+                width,
+                height,
+                timestampMs,
+                probability: probability[0],
+                rightEye,
+                leftEye,
+                mouth,
+                nose,
+                rightEar,
+                leftEar,
+            };
+        });
+        return faces;
+    }
+    _getCoordinate(keypoints, name) {
+        const keypoint = keypoints.find((k) => k.name === name);
+        return [keypoint.x, keypoint.y];
+    }
+    async _loadWebAssemblyBackend() {
+        try {
+            setWasmPaths(this.binaryPath);
+            await jitteredExponentialRetry(async () => {
+                const success = await setBackend('wasm');
+                if (!success) {
+                    throw new Error(`Initialization of backend wasm failed`);
+                }
+            }, []);
+            this.modelBackend = 'wasm';
+        }
+        catch (e) {
+            throw new Error('There was an error loading the TFJS WASM backend. If you are using a custom WASM path ensure that it ends with "/" and that it is not the full URL as @tensorflow/tfjs-backend-wasm will append the wasm binary file name. Read more: https://github.com/tensorflow/tfjs/blob/master/tfjs-backend-wasm/src/backend_wasm.ts#L475.');
+        }
+    }
+    async _loadCPUBackend() {
+        await setBackend('cpu');
+        this.modelBackend = 'cpu';
+    }
+}
+
+export { BLAZEFACE_VERSION, BlazeFaceFaceDetection, DEFAULT_BLAZEFACE_URL, DEFAULT_TFJS_WASM_URL };

package/dist/esm/components/FaceLivenessDetector/service/utils/constants.mjs

@@ -1 +1,18 @@
-const E=.32,R=.4,_=.37,C={SUCCESS_CODE:1e3,DEFAULT_ERROR_CODE:4e3,FACE_FIT_TIMEOUT:4001,USER_CANCEL:4003,RUNTIME_ERROR:4005,USER_ERROR_DURING_CONNECTION:4007};export{E as FACE_DISTANCE_THRESHOLD,R as REDUCED_THRESHOLD,_ as REDUCED_THRESHOLD_MOBILE,C as WS_CLOSURE_CODE};
+// Face distance is calculated as pupilDistance / ovalWidth.
+// The further away you are from the camera the distance between your pupils will decrease, thus lowering the threshold values.
+// These FACE_DISTNACE_THRESHOLD values are determined by the science team and should only be changed with their approval.
+// We want to ensure at the start of a  check that the user's pupilDistance/ovalWidth is below FACE_DISTANCE_THRESHOLD to ensure that they are starting
+//  a certain distance away from the camera.
+const FACE_DISTANCE_THRESHOLD = 0.32;
+const REDUCED_THRESHOLD = 0.4;
+const REDUCED_THRESHOLD_MOBILE = 0.37;
+const WS_CLOSURE_CODE = {
+    SUCCESS_CODE: 1000,
+    DEFAULT_ERROR_CODE: 4000,
+    FACE_FIT_TIMEOUT: 4001,
+    USER_CANCEL: 4003,
+    RUNTIME_ERROR: 4005,
+    USER_ERROR_DURING_CONNECTION: 4007,
+};
+
+export { FACE_DISTANCE_THRESHOLD, REDUCED_THRESHOLD, REDUCED_THRESHOLD_MOBILE, WS_CLOSURE_CODE };

package/dist/esm/components/FaceLivenessDetector/service/utils/eventUtils.mjs

@@ -1 +1,30 @@
-const n=n=>!!(null==n?void 0:n.ServerSessionInformationEvent),e=n=>!!(null==n?void 0:n.DisconnectionEvent),i=n=>!!(null==n?void 0:n.ValidationException),o=n=>!!(null==n?void 0:n.InternalServerException),t=n=>!!(null==n?void 0:n.ThrottlingException),l=n=>!!(null==n?void 0:n.ServiceQuotaExceededException),r=n=>{const{message:e,name:i}=n;return"InvalidSignatureException"===i&&e.includes("valid region")};export{e as isDisconnectionEvent,o as isInternalServerExceptionEvent,r as isInvalidSignatureRegionException,n as isServerSesssionInformationEvent,l as isServiceQuotaExceededExceptionEvent,t as isThrottlingExceptionEvent,i as isValidationExceptionEvent};
+const isServerSesssionInformationEvent = (value) => {
+    return !!value
+        ?.ServerSessionInformationEvent;
+};
+const isDisconnectionEvent = (value) => {
+    return !!value
+        ?.DisconnectionEvent;
+};
+const isValidationExceptionEvent = (value) => {
+    return !!value
+        ?.ValidationException;
+};
+const isInternalServerExceptionEvent = (value) => {
+    return !!value
+        ?.InternalServerException;
+};
+const isThrottlingExceptionEvent = (value) => {
+    return !!value
+        ?.ThrottlingException;
+};
+const isServiceQuotaExceededExceptionEvent = (value) => {
+    return !!value
+        ?.ServiceQuotaExceededException;
+};
+const isInvalidSignatureRegionException = (error) => {
+    const { message, name } = error;
+    return (name === 'InvalidSignatureException' && message.includes('valid region'));
+};
+
+export { isDisconnectionEvent, isInternalServerExceptionEvent, isInvalidSignatureRegionException, isServerSesssionInformationEvent, isServiceQuotaExceededExceptionEvent, isThrottlingExceptionEvent, isValidationExceptionEvent };

package/dist/esm/components/FaceLivenessDetector/service/utils/freshnessColorDisplay.mjs

@@ -1 +1,131 @@
-import{__awaiter as e}from"tslib";import{fillOverlayCanvasFractional as r,getRGBArrayFromColorString as o}from"./liveness.mjs";var t;!function(e){e.SCROLLING="SCROLLING",e.FLAT="FLAT"}(t||(t={}));class s{constructor(e,r){this.context=e,this.freshnessColorsSequence=r,this.isFirstTick=!0}displayColorTick(){return e(this,void 0,void 0,(function*(){return new Promise(((e,r)=>{setTimeout((()=>{this.displayNextColorTick(e,r)}),Math.min(10))}))}))}init(){this.stageIndex=0,this.currColorIndex=0,this.currColorSequence=this.freshnessColorsSequence[0],this.prevColorSequence=this.freshnessColorsSequence[0],this.stage=t.FLAT,this.timeLastFlatOrScrollChange=Date.now(),this.timeLastFaceMatchChecked=Date.now()}displayNextColorTick(e,o){const{freshnessColorEl:s}=this.context.freshnessColorAssociatedParams,{ovalDetails:i,scaleFactor:l}=this.context.ovalAssociatedParams,{videoEl:n}=this.context.videoAssociatedParams,c=Date.now();this.isFirstTick&&(this.init(),this.isFirstTick=!1,this.sendColorStartTime({tickStartTime:c,currColor:this.currColorSequence.color,prevColor:this.currColorSequence.color,currColorIndex:this.stageIndex}));let a=c-this.timeLastFlatOrScrollChange;if(s.style.display="block",(this.stage===t.FLAT&&a>=this.currColorSequence.flatDisplayDuration||this.stage===t.SCROLLING&&a>=this.currColorSequence.downscrollDuration)&&(this.incrementStageIndex(c),a=0),this.currColorIndex<this.freshnessColorsSequence.length){const o=a/(this.stage===t.SCROLLING?this.currColorSequence.downscrollDuration:this.currColorSequence.flatDisplayDuration);r({overlayCanvas:s,prevColor:this.prevColorSequence.color,nextColor:this.currColorSequence.color,videoEl:n,ovalDetails:i,heightFraction:o,scaleFactor:l}),e(!1)}else s.style.display="none",e(!0)}incrementStageIndex(e){if(this.stageIndex+=1,this.prevColorSequence=this.freshnessColorsSequence[this.currColorIndex],this.stage===t.FLAT)this.currColorIndex+=1,this.stage=t.SCROLLING;else if(this.stage===t.SCROLLING){this.freshnessColorsSequence[this.currColorIndex].flatDisplayDuration>0?this.stage=t.FLAT:(this.stage=t.SCROLLING,this.currColorIndex+=1)}this.currColorSequence=this.freshnessColorsSequence[this.currColorIndex],this.timeLastFlatOrScrollChange=Date.now(),this.currColorSequence&&this.sendColorStartTime({tickStartTime:e,currColor:this.currColorSequence.color,prevColor:this.prevColorSequence.color,currColorIndex:this.stageIndex})}sendColorStartTime({tickStartTime:e,currColor:r,prevColor:t,currColorIndex:s}){const{livenessStreamProvider:i,challengeId:l}=this.context;i.sendClientInfo({Challenge:{FaceMovementAndLightChallenge:{ChallengeId:l,ColorDisplayed:{CurrentColor:{RGB:o(r)},PreviousColor:{RGB:o(t)},SequenceNumber:s,CurrentColorStartTimestamp:e}}}})}}export{s as FreshnessColorDisplay};
+import { fillOverlayCanvasFractional, getRGBArrayFromColorString } from './liveness.mjs';
+
+const TICK_RATE = 10; // ms -- the rate at which we will render/check colors
+var COLOR_STAGE;
+(function (COLOR_STAGE) {
+    COLOR_STAGE["SCROLLING"] = "SCROLLING";
+    COLOR_STAGE["FLAT"] = "FLAT";
+})(COLOR_STAGE || (COLOR_STAGE = {}));
+class FreshnessColorDisplay {
+    constructor(context, freshnessColorsSequence) {
+        this.context = context;
+        this.freshnessColorsSequence = freshnessColorsSequence;
+        this.isFirstTick = true;
+    }
+    async displayColorTick() {
+        return new Promise((resolve, reject) => {
+            setTimeout(() => {
+                this.displayNextColorTick(resolve, reject);
+            }, Math.min(TICK_RATE));
+        });
+    }
+    init() {
+        this.stageIndex = 0;
+        this.currColorIndex = 0;
+        this.currColorSequence = this.freshnessColorsSequence[0];
+        this.prevColorSequence = this.freshnessColorsSequence[0];
+        this.stage = COLOR_STAGE.FLAT;
+        this.timeLastFlatOrScrollChange = Date.now();
+        this.timeLastFaceMatchChecked = Date.now();
+    }
+    displayNextColorTick(resolve, _) {
+        const { freshnessColorEl } = this.context.freshnessColorAssociatedParams;
+        const { ovalDetails, scaleFactor } = this.context.ovalAssociatedParams;
+        const { videoEl } = this.context.videoAssociatedParams;
+        const tickStartTime = Date.now();
+        // Send a colorStart time only for the first tick of the first color
+        if (this.isFirstTick) {
+            this.init();
+            this.isFirstTick = false;
+            this.sendColorStartTime({
+                tickStartTime: tickStartTime,
+                currColor: this.currColorSequence.color,
+                prevColor: this.currColorSequence.color,
+                currColorIndex: this.stageIndex,
+            });
+        }
+        let timeSinceLastColorChange = tickStartTime - this.timeLastFlatOrScrollChange;
+        freshnessColorEl.style.display = 'block';
+        // Every 10 ms tick we will check if the threshold for flat or scrolling, if so we will try to go to the next stage
+        if ((this.stage === COLOR_STAGE.FLAT &&
+            timeSinceLastColorChange >=
+                this.currColorSequence.flatDisplayDuration) ||
+            (this.stage === COLOR_STAGE.SCROLLING &&
+                timeSinceLastColorChange >= this.currColorSequence.downscrollDuration)) {
+            this.incrementStageIndex(tickStartTime);
+            timeSinceLastColorChange = 0;
+        }
+        // Every 10 ms tick we will update the colors displayed
+        if (this.currColorIndex < this.freshnessColorsSequence.length) {
+            const heightFraction = timeSinceLastColorChange /
+                (this.stage === COLOR_STAGE.SCROLLING
+                    ? this.currColorSequence.downscrollDuration
+                    : this.currColorSequence.flatDisplayDuration);
+            fillOverlayCanvasFractional({
+                overlayCanvas: freshnessColorEl,
+                prevColor: this.prevColorSequence.color,
+                nextColor: this.currColorSequence.color,
+                videoEl: videoEl,
+                ovalDetails: ovalDetails,
+                heightFraction,
+                scaleFactor: scaleFactor,
+            });
+            resolve(false);
+        }
+        else {
+            freshnessColorEl.style.display = 'none';
+            resolve(true);
+        }
+    }
+    // FLAT - prev = 0, curr = 0
+    // SCROLL - prev = 0, curr = 1
+    // FLAT - prev = 1, curr = 1
+    // SCROLL - prev = 1, curr = 2
+    // SCROLL - prev = 2, curr = 3
+    incrementStageIndex(tickStartTime) {
+        this.stageIndex += 1;
+        this.prevColorSequence = this.freshnessColorsSequence[this.currColorIndex];
+        if (this.stage === COLOR_STAGE.FLAT) {
+            this.currColorIndex += 1;
+            this.stage = COLOR_STAGE.SCROLLING;
+        }
+        else if (this.stage === COLOR_STAGE.SCROLLING) {
+            const nextFlatColor = this.freshnessColorsSequence[this.currColorIndex];
+            if (nextFlatColor.flatDisplayDuration > 0) {
+                this.stage = COLOR_STAGE.FLAT;
+            }
+            else {
+                this.stage = COLOR_STAGE.SCROLLING;
+                this.currColorIndex += 1;
+            }
+        }
+        this.currColorSequence = this.freshnessColorsSequence[this.currColorIndex];
+        this.timeLastFlatOrScrollChange = Date.now();
+        if (this.currColorSequence) {
+            this.sendColorStartTime({
+                tickStartTime: tickStartTime,
+                currColor: this.currColorSequence.color,
+                prevColor: this.prevColorSequence.color,
+                currColorIndex: this.stageIndex,
+            });
+        }
+    }
+    sendColorStartTime({ tickStartTime, currColor, prevColor, currColorIndex, }) {
+        const { livenessStreamProvider, challengeId } = this.context;
+        livenessStreamProvider.sendClientInfo({
+            Challenge: {
+                FaceMovementAndLightChallenge: {
+                    ChallengeId: challengeId,
+                    ColorDisplayed: {
+                        CurrentColor: { RGB: getRGBArrayFromColorString(currColor) },
+                        PreviousColor: { RGB: getRGBArrayFromColorString(prevColor) },
+                        SequenceNumber: currColorIndex,
+                        CurrentColorStartTimestamp: tickStartTime,
+                    },
+                },
+            },
+        });
+    }
+}
+
+export { FreshnessColorDisplay };