@aws-amplify/ui-react-liveness 3.3.8 → 3.4.0

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

@@ -0,0 +1,140 @@
+import { __classPrivateFieldSet, __classPrivateFieldGet } from 'tslib';
+import { isFunction } from '@aws-amplify/ui';
+import { TICK_RATE } from '../constants.mjs';
+
+var _ColorSequenceDisplay_instances, _ColorSequenceDisplay_sequence, _ColorSequenceDisplay_previousSequence, _ColorSequenceDisplay_colorStage, _ColorSequenceDisplay_sequenceIndex, _ColorSequenceDisplay_colorSequences, _ColorSequenceDisplay_isFirstTick, _ColorSequenceDisplay_lastColorStageChangeTimestamp, _ColorSequenceDisplay_isFlatStage, _ColorSequenceDisplay_isScrollingStage, _ColorSequenceDisplay_startColorSequence, _ColorSequenceDisplay_handleSequenceChange;
+var ColorStageType;
+(function (ColorStageType) {
+    ColorStageType[ColorStageType["Scrolling"] = 0] = "Scrolling";
+    ColorStageType[ColorStageType["Flat"] = 1] = "Flat";
+})(ColorStageType || (ColorStageType = {}));
+class ColorSequenceDisplay {
+    /**
+     * Iterates over provided color sequences and executes sequence event callbacks
+     *
+     * @param {ColorSequences} colorSequences array of color sequences to iterate over
+     */
+    constructor(colorSequences) {
+        _ColorSequenceDisplay_instances.add(this);
+        /**
+         * the current color sequence used for flat display and the prev color when scrolling
+         */
+        _ColorSequenceDisplay_sequence.set(this, void 0);
+        /**
+         * previous color sequence, during flat display curr === prev and during scroll it is the prev indexed color
+         */
+        _ColorSequenceDisplay_previousSequence.set(this, void 0);
+        /**
+         * current ColorStage, initialize to 'FLAT'
+         */
+        _ColorSequenceDisplay_colorStage.set(this, ColorStageType.Flat);
+        /**
+         * current color sequence index (black flat, red scrolling, etc)
+         */
+        _ColorSequenceDisplay_sequenceIndex.set(this, 0);
+        _ColorSequenceDisplay_colorSequences.set(this, void 0);
+        _ColorSequenceDisplay_isFirstTick.set(this, true);
+        _ColorSequenceDisplay_lastColorStageChangeTimestamp.set(this, 0);
+        __classPrivateFieldSet(this, _ColorSequenceDisplay_colorSequences, colorSequences, "f");
+        __classPrivateFieldSet(this, _ColorSequenceDisplay_sequence, colorSequences[0], "f");
+        __classPrivateFieldSet(this, _ColorSequenceDisplay_previousSequence, colorSequences[0], "f");
+    }
+    /**
+     * Start sequence iteration and execute event callbacks
+     *
+     * @async
+     * @param {StartSequencesParams} params Sequence event handlers
+     * @returns {Promise<boolean>} Resolves to true when complete
+     */
+    async startSequences(params) {
+        return new Promise((resolve) => {
+            setTimeout(() => {
+                __classPrivateFieldGet(this, _ColorSequenceDisplay_instances, "m", _ColorSequenceDisplay_startColorSequence).call(this, { ...params, resolve });
+            }, Math.min(TICK_RATE));
+        });
+    }
+}
+_ColorSequenceDisplay_sequence = new WeakMap(), _ColorSequenceDisplay_previousSequence = new WeakMap(), _ColorSequenceDisplay_colorStage = new WeakMap(), _ColorSequenceDisplay_sequenceIndex = new WeakMap(), _ColorSequenceDisplay_colorSequences = new WeakMap(), _ColorSequenceDisplay_isFirstTick = new WeakMap(), _ColorSequenceDisplay_lastColorStageChangeTimestamp = new WeakMap(), _ColorSequenceDisplay_instances = new WeakSet(), _ColorSequenceDisplay_isFlatStage = function _ColorSequenceDisplay_isFlatStage() {
+    return __classPrivateFieldGet(this, _ColorSequenceDisplay_colorStage, "f") === ColorStageType.Flat;
+}, _ColorSequenceDisplay_isScrollingStage = function _ColorSequenceDisplay_isScrollingStage() {
+    return __classPrivateFieldGet(this, _ColorSequenceDisplay_colorStage, "f") === ColorStageType.Scrolling;
+}, _ColorSequenceDisplay_startColorSequence = function _ColorSequenceDisplay_startColorSequence({ onSequenceChange, onSequenceColorChange, onSequenceStart, onSequencesComplete, resolve, }) {
+    if (isFunction(onSequenceStart)) {
+        onSequenceStart();
+    }
+    const sequenceStartTime = Date.now();
+    let timeSinceLastColorStageChange = sequenceStartTime - __classPrivateFieldGet(this, _ColorSequenceDisplay_lastColorStageChangeTimestamp, "f");
+    // Send a colorStart time only for the first tick of the first color
+    if (__classPrivateFieldGet(this, _ColorSequenceDisplay_isFirstTick, "f")) {
+        __classPrivateFieldSet(this, _ColorSequenceDisplay_lastColorStageChangeTimestamp, Date.now(), "f");
+        __classPrivateFieldSet(this, _ColorSequenceDisplay_isFirstTick, false, "f");
+        // initial sequence change
+        if (isFunction(onSequenceChange)) {
+            onSequenceChange({
+                prevSequenceColor: __classPrivateFieldGet(this, _ColorSequenceDisplay_previousSequence, "f").color,
+                sequenceColor: __classPrivateFieldGet(this, _ColorSequenceDisplay_sequence, "f").color,
+                sequenceIndex: __classPrivateFieldGet(this, _ColorSequenceDisplay_sequenceIndex, "f"),
+                sequenceStartTime,
+            });
+        }
+    }
+    // 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 ((__classPrivateFieldGet(this, _ColorSequenceDisplay_instances, "m", _ColorSequenceDisplay_isFlatStage).call(this) &&
+        timeSinceLastColorStageChange >= __classPrivateFieldGet(this, _ColorSequenceDisplay_sequence, "f").flatDisplayDuration) ||
+        (__classPrivateFieldGet(this, _ColorSequenceDisplay_instances, "m", _ColorSequenceDisplay_isScrollingStage).call(this) &&
+            timeSinceLastColorStageChange >= __classPrivateFieldGet(this, _ColorSequenceDisplay_sequence, "f").downscrollDuration)) {
+        __classPrivateFieldGet(this, _ColorSequenceDisplay_instances, "m", _ColorSequenceDisplay_handleSequenceChange).call(this, { sequenceStartTime, onSequenceChange });
+        timeSinceLastColorStageChange = 0;
+    }
+    const hasRemainingSequences = __classPrivateFieldGet(this, _ColorSequenceDisplay_sequenceIndex, "f") < __classPrivateFieldGet(this, _ColorSequenceDisplay_colorSequences, "f").length;
+    // Every 10 ms tick we will update the colors displayed
+    if (hasRemainingSequences) {
+        const heightFraction = timeSinceLastColorStageChange /
+            (__classPrivateFieldGet(this, _ColorSequenceDisplay_instances, "m", _ColorSequenceDisplay_isScrollingStage).call(this)
+                ? __classPrivateFieldGet(this, _ColorSequenceDisplay_sequence, "f").downscrollDuration
+                : __classPrivateFieldGet(this, _ColorSequenceDisplay_sequence, "f").flatDisplayDuration);
+        if (isFunction(onSequenceColorChange)) {
+            onSequenceColorChange({
+                sequenceColor: __classPrivateFieldGet(this, _ColorSequenceDisplay_sequence, "f").color,
+                heightFraction,
+                prevSequenceColor: __classPrivateFieldGet(this, _ColorSequenceDisplay_previousSequence, "f").color,
+            });
+        }
+        resolve(false);
+    }
+    else {
+        if (isFunction(onSequencesComplete)) {
+            onSequencesComplete();
+        }
+        resolve(true);
+    }
+}, _ColorSequenceDisplay_handleSequenceChange = function _ColorSequenceDisplay_handleSequenceChange({ sequenceStartTime, onSequenceChange, }) {
+    __classPrivateFieldSet(this, _ColorSequenceDisplay_previousSequence, __classPrivateFieldGet(this, _ColorSequenceDisplay_sequence, "f"), "f");
+    if (__classPrivateFieldGet(this, _ColorSequenceDisplay_instances, "m", _ColorSequenceDisplay_isFlatStage).call(this)) {
+        __classPrivateFieldSet(this, _ColorSequenceDisplay_sequenceIndex, __classPrivateFieldGet(this, _ColorSequenceDisplay_sequenceIndex, "f") + 1, "f");
+        __classPrivateFieldSet(this, _ColorSequenceDisplay_colorStage, ColorStageType.Scrolling, "f");
+    }
+    else if (__classPrivateFieldGet(this, _ColorSequenceDisplay_instances, "m", _ColorSequenceDisplay_isScrollingStage).call(this)) {
+        const nextColorSequence = __classPrivateFieldGet(this, _ColorSequenceDisplay_colorSequences, "f")[__classPrivateFieldGet(this, _ColorSequenceDisplay_sequenceIndex, "f")];
+        if (nextColorSequence.flatDisplayDuration > 0) {
+            __classPrivateFieldSet(this, _ColorSequenceDisplay_colorStage, ColorStageType.Flat, "f");
+        }
+        else {
+            __classPrivateFieldSet(this, _ColorSequenceDisplay_sequenceIndex, __classPrivateFieldGet(this, _ColorSequenceDisplay_sequenceIndex, "f") + 1, "f");
+        }
+    }
+    __classPrivateFieldSet(this, _ColorSequenceDisplay_sequence, __classPrivateFieldGet(this, _ColorSequenceDisplay_colorSequences, "f")[__classPrivateFieldGet(this, _ColorSequenceDisplay_sequenceIndex, "f")], "f");
+    __classPrivateFieldSet(this, _ColorSequenceDisplay_lastColorStageChangeTimestamp, Date.now(), "f");
+    if (__classPrivateFieldGet(this, _ColorSequenceDisplay_sequence, "f")) {
+        if (isFunction(onSequenceChange)) {
+            onSequenceChange({
+                prevSequenceColor: __classPrivateFieldGet(this, _ColorSequenceDisplay_previousSequence, "f").color,
+                sequenceColor: __classPrivateFieldGet(this, _ColorSequenceDisplay_sequence, "f").color,
+                sequenceIndex: __classPrivateFieldGet(this, _ColorSequenceDisplay_sequenceIndex, "f"),
+                sequenceStartTime: sequenceStartTime,
+            });
+        }
+    }
+};
+
+export { ColorSequenceDisplay };

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

@@ -0,0 +1,171 @@
+import { __classPrivateFieldSet, __classPrivateFieldGet } from 'tslib';
+import { isUndefined } from '@aws-amplify/ui';
+import { TIME_SLICE } from '../constants.mjs';
+
+var _StreamRecorder_instances, _StreamRecorder_chunks, _StreamRecorder_recorder, _StreamRecorder_initialRecorder, _StreamRecorder_recordingStarted, _StreamRecorder_firstChunkTimestamp, _StreamRecorder_recorderEndTimestamp, _StreamRecorder_recorderStartTimestamp, _StreamRecorder_recordingStartTimestamp, _StreamRecorder_recorderStopped, _StreamRecorder_videoStream, _StreamRecorder_eventListeners, _StreamRecorder_clearRecordedChunks, _StreamRecorder_createReadableStream, _StreamRecorder_attachHandlers, _StreamRecorder_setupCallbacks, _StreamRecorder_cleanUpEventListeners;
+class StreamRecorder {
+    constructor(stream) {
+        _StreamRecorder_instances.add(this);
+        _StreamRecorder_chunks.set(this, void 0);
+        _StreamRecorder_recorder.set(this, void 0);
+        _StreamRecorder_initialRecorder.set(this, void 0);
+        _StreamRecorder_recordingStarted.set(this, false);
+        _StreamRecorder_firstChunkTimestamp.set(this, void 0);
+        _StreamRecorder_recorderEndTimestamp.set(this, void 0);
+        _StreamRecorder_recorderStartTimestamp.set(this, void 0);
+        _StreamRecorder_recordingStartTimestamp.set(this, void 0);
+        _StreamRecorder_recorderStopped.set(this, void 0);
+        _StreamRecorder_videoStream.set(this, void 0);
+        _StreamRecorder_eventListeners.set(this, void 0);
+        if (typeof MediaRecorder === 'undefined') {
+            throw Error('MediaRecorder is not supported by this browser');
+        }
+        __classPrivateFieldSet(this, _StreamRecorder_chunks, [], "f");
+        __classPrivateFieldSet(this, _StreamRecorder_recorder, new MediaRecorder(stream, { bitsPerSecond: 1000000 }), "f");
+        __classPrivateFieldSet(this, _StreamRecorder_initialRecorder, __classPrivateFieldGet(this, _StreamRecorder_recorder, "f"), "f");
+        __classPrivateFieldSet(this, _StreamRecorder_videoStream, __classPrivateFieldGet(this, _StreamRecorder_instances, "m", _StreamRecorder_createReadableStream).call(this), "f");
+        __classPrivateFieldSet(this, _StreamRecorder_eventListeners, {}, "f");
+    }
+    getVideoStream() {
+        return __classPrivateFieldGet(this, _StreamRecorder_videoStream, "f");
+    }
+    setNewVideoStream(stream) {
+        __classPrivateFieldGet(this, _StreamRecorder_instances, "m", _StreamRecorder_cleanUpEventListeners).call(this);
+        __classPrivateFieldSet(this, _StreamRecorder_recorder, new MediaRecorder(stream, { bitsPerSecond: 1000000 }), "f");
+        __classPrivateFieldGet(this, _StreamRecorder_instances, "m", _StreamRecorder_attachHandlers).call(this, __classPrivateFieldGet(this, _StreamRecorder_recorder, "f"));
+    }
+    dispatchStreamEvent(event) {
+        const { type } = event;
+        const data = type === 'streamStop' ? undefined : event.data;
+        __classPrivateFieldGet(this, _StreamRecorder_recorder, "f").dispatchEvent(new MessageEvent(type, { data }));
+    }
+    getRecordingStartTimestamp() {
+        if (isUndefined(__classPrivateFieldGet(this, _StreamRecorder_recorderStartTimestamp, "f")) ||
+            isUndefined(__classPrivateFieldGet(this, _StreamRecorder_recordingStartTimestamp, "f"))) {
+            throw new Error('Recording has not started');
+        }
+        /**
+         * This calculation is provided by Science team after doing analysis
+         * of unreliable .onstart() (this.#recorderStartTimestamp) timestamp that is
+         * returned from mediaRecorder.
+         */
+        return Math.round(0.73 * (__classPrivateFieldGet(this, _StreamRecorder_recorderStartTimestamp, "f") - __classPrivateFieldGet(this, _StreamRecorder_recordingStartTimestamp, "f")) +
+            __classPrivateFieldGet(this, _StreamRecorder_recordingStartTimestamp, "f"));
+    }
+    getRecordingEndedTimestamp() {
+        if (isUndefined(__classPrivateFieldGet(this, _StreamRecorder_recorderEndTimestamp, "f"))) {
+            throw new Error('Recording has not ended');
+        }
+        return __classPrivateFieldGet(this, _StreamRecorder_recorderEndTimestamp, "f");
+    }
+    startRecording() {
+        __classPrivateFieldGet(this, _StreamRecorder_instances, "m", _StreamRecorder_clearRecordedChunks).call(this);
+        __classPrivateFieldSet(this, _StreamRecorder_recordingStartTimestamp, Date.now(), "f");
+        __classPrivateFieldGet(this, _StreamRecorder_recorder, "f").start(TIME_SLICE);
+    }
+    isRecording() {
+        return __classPrivateFieldGet(this, _StreamRecorder_recorder, "f").state === 'recording';
+    }
+    getChunksLength() {
+        return __classPrivateFieldGet(this, _StreamRecorder_chunks, "f").length;
+    }
+    hasRecordingStarted() {
+        return __classPrivateFieldGet(this, _StreamRecorder_recordingStarted, "f") && __classPrivateFieldGet(this, _StreamRecorder_firstChunkTimestamp, "f") !== undefined;
+    }
+    async stopRecording() {
+        if (this.isRecording()) {
+            __classPrivateFieldGet(this, _StreamRecorder_recorder, "f").stop();
+        }
+        return __classPrivateFieldGet(this, _StreamRecorder_recorderStopped, "f");
+    }
+}
+_StreamRecorder_chunks = new WeakMap(), _StreamRecorder_recorder = new WeakMap(), _StreamRecorder_initialRecorder = new WeakMap(), _StreamRecorder_recordingStarted = new WeakMap(), _StreamRecorder_firstChunkTimestamp = new WeakMap(), _StreamRecorder_recorderEndTimestamp = new WeakMap(), _StreamRecorder_recorderStartTimestamp = new WeakMap(), _StreamRecorder_recordingStartTimestamp = new WeakMap(), _StreamRecorder_recorderStopped = new WeakMap(), _StreamRecorder_videoStream = new WeakMap(), _StreamRecorder_eventListeners = new WeakMap(), _StreamRecorder_instances = new WeakSet(), _StreamRecorder_clearRecordedChunks = function _StreamRecorder_clearRecordedChunks() {
+    __classPrivateFieldSet(this, _StreamRecorder_chunks, [], "f");
+}, _StreamRecorder_createReadableStream = function _StreamRecorder_createReadableStream() {
+    return new ReadableStream({
+        start: (controller) => {
+            __classPrivateFieldGet(this, _StreamRecorder_instances, "m", _StreamRecorder_attachHandlers).call(this, __classPrivateFieldGet(this, _StreamRecorder_recorder, "f"), controller);
+        },
+    });
+}, _StreamRecorder_attachHandlers = function _StreamRecorder_attachHandlers(recorder, controller) {
+    const onDataAvailableHandler = controller
+        ? ({ data }) => {
+            if (data && data.size > 0) {
+                if (__classPrivateFieldGet(this, _StreamRecorder_chunks, "f").length === 0) {
+                    __classPrivateFieldSet(this, _StreamRecorder_firstChunkTimestamp, Date.now(), "f");
+                }
+                __classPrivateFieldGet(this, _StreamRecorder_chunks, "f").push(data);
+                controller.enqueue({ type: 'streamVideo', data });
+            }
+        }
+        : ({ data }) => {
+            __classPrivateFieldGet(this, _StreamRecorder_initialRecorder, "f").dispatchEvent(new MessageEvent('dataavailable', { data }));
+        };
+    recorder.ondataavailable = onDataAvailableHandler;
+    const onSessionInfoHandler = controller
+        ? (e) => {
+            const { data } = e;
+            controller.enqueue({ type: 'sessionInfo', data });
+        }
+        : (e) => {
+            const { data } = e;
+            __classPrivateFieldGet(this, _StreamRecorder_initialRecorder, "f").dispatchEvent(new MessageEvent('sessionInfo', { data }));
+        };
+    recorder.addEventListener('sessionInfo', onSessionInfoHandler);
+    const onStreamStopHandler = controller
+        ? () => {
+            controller.enqueue({ type: 'streamStop' });
+        }
+        : () => {
+            __classPrivateFieldGet(this, _StreamRecorder_initialRecorder, "f").dispatchEvent(new MessageEvent('streamStop'));
+        };
+    recorder.addEventListener('streamStop', onStreamStopHandler);
+    const onCloseCodeHandler = controller
+        ? (e) => {
+            const { data } = e;
+            controller.enqueue({ type: 'closeCode', data });
+        }
+        : (e) => {
+            const { data } = e;
+            __classPrivateFieldGet(this, _StreamRecorder_initialRecorder, "f").dispatchEvent(new MessageEvent('closeCode', { data }));
+        };
+    recorder.addEventListener('closeCode', onCloseCodeHandler);
+    const onEndStreamHandler = controller
+        ? () => {
+            controller.close();
+        }
+        : () => {
+            __classPrivateFieldGet(this, _StreamRecorder_initialRecorder, "f").dispatchEvent(new MessageEvent('endStream'));
+        };
+    recorder.addEventListener('endStream', onEndStreamHandler);
+    __classPrivateFieldGet(this, _StreamRecorder_instances, "m", _StreamRecorder_setupCallbacks).call(this);
+    __classPrivateFieldSet(this, _StreamRecorder_eventListeners, {
+        endStream: onEndStreamHandler,
+        closeCode: onCloseCodeHandler,
+        streamStop: onStreamStopHandler,
+        sessionInfo: onSessionInfoHandler,
+        dataavailable: onDataAvailableHandler,
+    }, "f");
+}, _StreamRecorder_setupCallbacks = function _StreamRecorder_setupCallbacks() {
+    __classPrivateFieldGet(this, _StreamRecorder_recorder, "f").onstart = () => {
+        __classPrivateFieldSet(this, _StreamRecorder_recordingStarted, true, "f");
+        __classPrivateFieldSet(this, _StreamRecorder_recorderStartTimestamp, Date.now(), "f");
+    };
+    __classPrivateFieldSet(this, _StreamRecorder_recorderStopped, new Promise((resolve) => {
+        __classPrivateFieldGet(this, _StreamRecorder_recorder, "f").onstop = () => {
+            __classPrivateFieldSet(this, _StreamRecorder_recorderEndTimestamp, Date.now(), "f");
+            resolve();
+        };
+    }), "f");
+    __classPrivateFieldGet(this, _StreamRecorder_recorder, "f").onerror = () => {
+        this.stopRecording();
+    };
+}, _StreamRecorder_cleanUpEventListeners = function _StreamRecorder_cleanUpEventListeners() {
+    const eventNames = Object.keys(__classPrivateFieldGet(this, _StreamRecorder_eventListeners, "f"));
+    eventNames.forEach((name) => {
+        __classPrivateFieldGet(this, _StreamRecorder_recorder, "f").removeEventListener(name, __classPrivateFieldGet(this, _StreamRecorder_eventListeners, "f")[name]);
+    });
+    __classPrivateFieldSet(this, _StreamRecorder_eventListeners, {}, "f");
+};
+
+export { StreamRecorder };

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

@@ -0,0 +1,27 @@
+const DEFAULT_ATTEMPT_COUNT_TIMEOUT = 300000; // 5 minutes / 300000 ms
+// Telemetry data is for internal use only and should not be depended upon or used by the customer
+class TelemetryReporter {
+    static getAttemptCountAndUpdateTimestamp() {
+        const timeSinceLastAttempt = Date.now() - TelemetryReporter.timestamp;
+        if (timeSinceLastAttempt > DEFAULT_ATTEMPT_COUNT_TIMEOUT) {
+            TelemetryReporter.attemptCount = 1;
+        }
+        else {
+            TelemetryReporter.attemptCount += 1;
+        }
+        TelemetryReporter.timestamp = Date.now();
+        return TelemetryReporter.attemptCount;
+    }
+}
+TelemetryReporter.attemptCount = 0;
+TelemetryReporter.timestamp = Date.now();
+const createTelemetryReporterMiddleware = (attemptCount, preCheckViewEnabled) => (next) => async (args) => {
+    args.request.query['attempt-count'] =
+        attemptCount.toString();
+    args.request.query['precheck-view-enabled'] =
+        preCheckViewEnabled ? '1' : '0';
+    const result = await next(args);
+    return result;
+};
+
+export { TelemetryReporter, createTelemetryReporterMiddleware };

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

@@ -1,11 +1,5 @@
 // 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_DISTANCE_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;
 // Constants from science team to determine ocular distance (space between eyes)
 const PUPIL_DISTANCE_WEIGHT = 2.0;
 const FACE_HEIGHT_WEIGHT = 1.8;
@@ -14,6 +8,7 @@ const FACE_MATCH_RANGE_MIN = 0;
 const FACE_MATCH_RANGE_MAX = 1;
 const FACE_MATCH_WEIGHT_MIN = 0.25;
 const FACE_MATCH_WEIGHT_MAX = 0.75;
+const OVAL_HEIGHT_WIDTH_RATIO = 1.618;
 const WS_CLOSURE_CODE = {
     SUCCESS_CODE: 1000,
     DEFAULT_ERROR_CODE: 4000,
@@ -22,5 +17,33 @@ const WS_CLOSURE_CODE = {
     RUNTIME_ERROR: 4005,
     USER_ERROR_DURING_CONNECTION: 4007,
 };
+// number in milliseconds to record into each video chunk.
+// see https://developer.mozilla.org/en-US/docs/Web/API/MediaRecorder/start#timeslice
+const TIME_SLICE = 1000;
+// in MS, the rate at which colors are rendered/checked
+const TICK_RATE = 10;
+/**
+ * The number of seconds before the presigned URL expires.
+ * Used to override aws sdk default value of 60
+ */
+const REQUEST_EXPIRY = 299;
+/**
+ * The maximum time in milliseconds that the connection phase of a request
+ * may take before the connection attempt is abandoned.
+ */
+const CONNECTION_TIMEOUT = 10000;
+const FACE_MOVEMENT_AND_LIGHT_CHALLENGE = {
+    type: 'FaceMovementAndLightChallenge',
+    version: '1.0.0',
+};
+const FACE_MOVEMENT_CHALLENGE = {
+    type: 'FaceMovementChallenge',
+    version: '1.0.0',
+};
+const SUPPORTED_CHALLENGES = [
+    FACE_MOVEMENT_AND_LIGHT_CHALLENGE,
+    FACE_MOVEMENT_CHALLENGE,
+];
+const queryParameterString = SUPPORTED_CHALLENGES.map((challenge) => `${challenge.type}_${challenge.version}`).join(',');
 
-export { FACE_DISTANCE_THRESHOLD, FACE_HEIGHT_WEIGHT, FACE_MATCH_RANGE_MAX, FACE_MATCH_RANGE_MIN, FACE_MATCH_WEIGHT_MAX, FACE_MATCH_WEIGHT_MIN, PUPIL_DISTANCE_WEIGHT, REDUCED_THRESHOLD, REDUCED_THRESHOLD_MOBILE, WS_CLOSURE_CODE };
+export { CONNECTION_TIMEOUT, FACE_HEIGHT_WEIGHT, FACE_MATCH_RANGE_MAX, FACE_MATCH_RANGE_MIN, FACE_MATCH_WEIGHT_MAX, FACE_MATCH_WEIGHT_MIN, FACE_MOVEMENT_AND_LIGHT_CHALLENGE, FACE_MOVEMENT_CHALLENGE, OVAL_HEIGHT_WIDTH_RATIO, PUPIL_DISTANCE_WEIGHT, REQUEST_EXPIRY, SUPPORTED_CHALLENGES, TICK_RATE, TIME_SLICE, WS_CLOSURE_CODE, queryParameterString };

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

@@ -0,0 +1,32 @@
+import { createVideoEvent } from './utils.mjs';
+
+/**
+ * Creates an async generator that reads over the provided stream and yielding stream results
+ *
+ * @param {VideoStream} stream target video stream
+ * @returns {GetRequestStream} async request stream generator
+ */
+function createRequestStreamGenerator(stream) {
+    const reader = stream.getReader();
+    return {
+        getRequestStream: async function* () {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    return;
+                }
+                if (value.type === 'sessionInfo') {
+                    yield { ClientSessionInformationEvent: value.data };
+                }
+                else {
+                    // Unless value.type is closeCode we never want to send a 0 size video event as it signals end of stream
+                    if (value.type === 'streamVideo' && value.data.size < 1)
+                        continue;
+                    yield { VideoEvent: await createVideoEvent(value) };
+                }
+            }
+        },
+    };
+}
+
+export { createRequestStreamGenerator };

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

@@ -0,0 +1,148 @@
+import { isUndefined } from '@aws-amplify/ui';
+import { isFaceMovementChallenge, isFaceMovementAndLightChallenge } from '../sessionInformation.mjs';
+
+const createVideoEvent = async (result) => {
+    const { data, type } = result;
+    return {
+        VideoChunk: new Uint8Array(
+        // server expects an empty chunk on 'stopStream' event
+        type === 'streamVideo' ? await data.arrayBuffer() : []),
+        // @ts-expect-error for 'closeCode' event, `data` is an object which is
+        // unexpected by `VideoEvent` but is expected by the streaming service
+        TimestampMillis: type === 'closeCode' ? data : Date.now(),
+    };
+};
+const getTrackDimensions = (stream) => {
+    const { height: trackHeight, width: trackWidth } = stream
+        .getVideoTracks()[0]
+        .getSettings();
+    if (isUndefined(trackHeight) || isUndefined(trackWidth)) {
+        throw new Error(`Invalid Track Dimensions. height: ${trackHeight}, width: ${trackWidth} `);
+    }
+    return { trackHeight, trackWidth };
+};
+function getBoundingBox({ trackHeight, trackWidth, height, width, top, left, }) {
+    return {
+        Height: height / trackHeight,
+        Width: width / trackWidth,
+        Top: top / trackHeight,
+        Left: left / trackWidth,
+    };
+}
+const getFlippedInitialFaceLeft = (trackWidth, faceLeft, faceWidth) => trackWidth - faceLeft - faceWidth;
+const getInitialFaceBoundingBox = (params) => {
+    const { trackWidth, left, width } = params;
+    return getBoundingBox({
+        ...params,
+        left: getFlippedInitialFaceLeft(trackWidth, left, width),
+    });
+};
+const getTargetFaceBoundingBox = (params) => {
+    const { height, width, centerX, centerY } = params;
+    return getBoundingBox({
+        ...params,
+        top: centerY - height / 2,
+        left: centerX - width / 2,
+    });
+};
+function createClientSessionInformationEvent({ parsedSessionInformation, clientChallenge, }) {
+    if (isFaceMovementChallenge(parsedSessionInformation)) {
+        return {
+            Challenge: {
+                FaceMovementChallenge: clientChallenge,
+            },
+        };
+    }
+    if (isFaceMovementAndLightChallenge(parsedSessionInformation)) {
+        return {
+            Challenge: {
+                FaceMovementAndLightChallenge: clientChallenge,
+            },
+        };
+    }
+    throw new Error('Unable to create ClientSessionInformationEvent');
+}
+function createSessionEndEvent({ parsedSessionInformation, challengeId, faceMatchAssociatedParams, ovalAssociatedParams, recordingEndedTimestamp, trackHeight, trackWidth, }) {
+    const { initialFace, ovalDetails } = ovalAssociatedParams;
+    const { startFace, endFace } = faceMatchAssociatedParams;
+    const initialFaceBoundingBox = getInitialFaceBoundingBox({
+        trackHeight,
+        trackWidth,
+        ...initialFace,
+    });
+    const targetFaceBoundingBox = getTargetFaceBoundingBox({
+        trackHeight,
+        trackWidth,
+        ...ovalDetails,
+    });
+    const clientChallenge = {
+        ChallengeId: challengeId,
+        InitialFace: {
+            InitialFaceDetectedTimestamp: initialFace.timestampMs,
+            BoundingBox: initialFaceBoundingBox,
+        },
+        TargetFace: {
+            FaceDetectedInTargetPositionStartTimestamp: startFace.timestampMs,
+            FaceDetectedInTargetPositionEndTimestamp: endFace.timestampMs,
+            BoundingBox: targetFaceBoundingBox,
+        },
+        VideoEndTimestamp: recordingEndedTimestamp,
+    };
+    return createClientSessionInformationEvent({
+        parsedSessionInformation,
+        clientChallenge,
+    });
+}
+function createSessionStartEvent({ parsedSessionInformation, challengeId, ovalAssociatedParams, recordingStartedTimestamp, trackHeight, trackWidth, }) {
+    const { initialFace } = ovalAssociatedParams;
+    const initialFaceBoundingBox = getInitialFaceBoundingBox({
+        trackHeight,
+        trackWidth,
+        ...initialFace,
+    });
+    const clientChallenge = {
+        ChallengeId: challengeId,
+        VideoStartTimestamp: recordingStartedTimestamp,
+        InitialFace: {
+            InitialFaceDetectedTimestamp: initialFace.timestampMs,
+            BoundingBox: initialFaceBoundingBox,
+        },
+    };
+    return createClientSessionInformationEvent({
+        parsedSessionInformation,
+        clientChallenge,
+    });
+}
+/**
+ * Translates provided sequence color string to an RGB array
+ *
+ * @param {SequenceColorValue} color
+ * @returns {number[]}
+ */
+const colorToRgb = (color) => {
+    return color
+        .slice(color.indexOf('(') + 1, color.indexOf(')'))
+        .split(',')
+        .map((str) => parseInt(str));
+};
+function createColorDisplayEvent({ challengeId, sequenceStartTime, sequenceIndex, sequenceColor, prevSequenceColor, }) {
+    const CurrentColor = { RGB: colorToRgb(sequenceColor) };
+    const PreviousColor = {
+        RGB: colorToRgb(prevSequenceColor),
+    };
+    return {
+        Challenge: {
+            FaceMovementAndLightChallenge: {
+                ChallengeId: challengeId,
+                ColorDisplayed: {
+                    CurrentColor,
+                    PreviousColor,
+                    SequenceNumber: sequenceIndex,
+                    CurrentColorStartTimestamp: sequenceStartTime,
+                },
+            },
+        },
+    };
+}
+
+export { createColorDisplayEvent, createSessionEndEvent, createSessionStartEvent, createVideoEvent, getTrackDimensions };

package/dist/esm/components/FaceLivenessDetector/service/utils/createStreamingClient/Signer.mjs

@@ -1,7 +1,6 @@
 import { SignatureV4 } from '@smithy/signature-v4';
+import { REQUEST_EXPIRY } from '../constants.mjs';
 
-// override aws sdk default value of 60
-const REQUEST_EXPIRY = 299;
 class Signer extends SignatureV4 {
     presign(request, options) {
         return super.presign(request, {
@@ -15,4 +14,4 @@ class Signer extends SignatureV4 {
     }
 }
 
-export { REQUEST_EXPIRY, Signer };
+export { Signer };

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

@@ -1,16 +1,17 @@
-import { RekognitionStreamingClient } from '@aws-sdk/client-rekognitionstreaming';
+import { StartFaceLivenessSessionCommand, RekognitionStreamingClient } from '@aws-sdk/client-rekognitionstreaming';
 import { getAmplifyUserAgent } from '@aws-amplify/core/internals/utils';
+import { isString } from '@aws-amplify/ui';
 import { getLivenessUserAgent } from '../../../utils/platform.mjs';
+import { queryParameterString, CONNECTION_TIMEOUT } from '../constants.mjs';
 import { CustomWebSocketFetchHandler } from './CustomWebSocketFetchHandler.mjs';
 import { resolveCredentials } from './resolveCredentials.mjs';
 import { Signer } from './Signer.mjs';
+import { createTelemetryReporterMiddleware } from '../TelemetryReporter/TelemetryReporter.mjs';
 
-const CONNECTION_TIMEOUT = 10000;
 const CUSTOM_USER_AGENT = `${getAmplifyUserAgent()} ${getLivenessUserAgent()}`;
-async function createStreamingClient({ credentialsProvider, endpointOverride, region, systemClockOffset, }) {
-    const credentials = await resolveCredentials(credentialsProvider);
+async function getStreamingClient({ credentialsProvider, endpointOverride, region, systemClockOffset, }) {
     const clientconfig = {
-        credentials,
+        credentials: await resolveCredentials(credentialsProvider),
         customUserAgent: CUSTOM_USER_AGENT,
         region,
         requestHandler: new CustomWebSocketFetchHandler({
@@ -19,10 +20,39 @@ async function createStreamingClient({ credentialsProvider, endpointOverride, re
         signerConstructor: Signer,
         systemClockOffset,
     };
-    if (endpointOverride) {
+    if (isString(endpointOverride)) {
         clientconfig.endpointProvider = () => ({ url: new URL(endpointOverride) });
     }
     return new RekognitionStreamingClient(clientconfig);
 }
+const createCommandInput = ({ requestStream, sessionId, videoWidth, videoHeight, }) => ({
+    ChallengeVersions: queryParameterString,
+    SessionId: sessionId,
+    LivenessRequestStream: requestStream,
+    VideoWidth: videoWidth,
+    VideoHeight: videoHeight,
+});
+/**
+ * Initializes an instance of the Rekognition streaming client, returns `getResponseStream`
+ *
+ * @async
+ * @param clientConfig configuration fpr the client
+ * @returns {Promise<{ getResponseStream: GetReponseStream }>}
+ */
+async function createStreamingClient(clientConfig) {
+    const client = await getStreamingClient(clientConfig);
+    client.middlewareStack.add(createTelemetryReporterMiddleware(clientConfig.attemptCount, clientConfig.preCheckViewEnabled), {
+        step: 'build',
+        name: 'telemetryMiddleware',
+        tags: ['liveness', 'amplify-ui'],
+    });
+    return {
+        async getResponseStream(input) {
+            const command = new StartFaceLivenessSessionCommand(createCommandInput(input));
+            const { LivenessResponseStream } = await client.send(command);
+            return LivenessResponseStream;
+        },
+    };
+}
 
 export { createStreamingClient };