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

package/dist/types/components/FaceLivenessDetector/service/utils/liveness.d.ts

@@ -1,7 +1,6 @@
-import { LivenessOvalDetails, IlluminationState, Face, FaceMatchState, BoundingBox, ErrorState } from '../types';
-import { FaceDetection } from '../types/faceDetection';
-import { ClientFreshnessColorSequence } from '../types/service';
-import { SessionInformation } from '@aws-sdk/client-rekognitionstreaming';
+import type { LivenessOvalDetails, Face, BoundingBox, ErrorState, ParsedSessionInformation, FaceDetection } from '../types';
+import { IlluminationState, FaceMatchState } from '../types';
+import type { ColorSequence } from './ColorSequenceDisplay';
 interface OvalBoundingBox {
     ovalBoundingBox: BoundingBox;
     minOvalX: number;
@@ -21,20 +20,21 @@ export declare function getIntersectionOverUnion(box1: BoundingBox, box2: Boundi
  * Returns the details of a randomly generated liveness oval
  * from SDK
  */
-export declare function getOvalDetailsFromSessionInformation({ sessionInformation, videoWidth, }: {
-    sessionInformation: SessionInformation;
+export declare function getOvalDetailsFromSessionInformation({ parsedSessionInformation, videoWidth, }: {
+    parsedSessionInformation: ParsedSessionInformation;
     videoWidth: number;
 }): LivenessOvalDetails;
 /**
  * Returns the details of a statically generated liveness oval based on the video dimensions
  */
-export declare function getStaticLivenessOvalDetails({ width, height, widthSeed, centerXSeed, centerYSeed, ratioMultiplier, }: {
+export declare function getStaticLivenessOvalDetails({ width, height, widthSeed, centerXSeed, centerYSeed, ratioMultiplier, ovalHeightWidthRatio, }: {
     width: number;
     height: number;
     widthSeed?: number;
     centerXSeed?: number;
     centerYSeed?: number;
     ratioMultiplier?: number;
+    ovalHeightWidthRatio?: number;
 }): LivenessOvalDetails;
 /**
  * Draws the provided liveness oval on the canvas.
@@ -50,7 +50,12 @@ export declare function drawStaticOval(canvasEl: HTMLCanvasElement, videoEl: HTM
 export declare function clearOvalCanvas({ canvas, }: {
     canvas: HTMLCanvasElement;
 }): void;
-export declare function generateBboxFromLandmarks(face: Face, oval: LivenessOvalDetails, frameHeight: number): BoundingBox;
+export declare function generateBboxFromLandmarks({ ovalHeightWidthRatio, face, oval, frameHeight, }: {
+    ovalHeightWidthRatio?: number;
+    face: Face;
+    oval: LivenessOvalDetails;
+    frameHeight: number;
+}): BoundingBox;
 /**
  * Returns the illumination state in the provided video frame.
  */
@@ -82,31 +87,16 @@ interface FillOverlayCanvasFractionalInput {
     scaleFactor: number;
 }
 export declare function fillOverlayCanvasFractional({ overlayCanvas, prevColor, nextColor, videoEl, ovalDetails, heightFraction, scaleFactor, }: FillOverlayCanvasFractionalInput): void;
-export declare const isClientFreshnessColorSequence: (obj: ClientFreshnessColorSequence | undefined) => obj is ClientFreshnessColorSequence;
-export declare function getColorsSequencesFromSessionInformation(sessionInformation: SessionInformation): ClientFreshnessColorSequence[];
-export declare function getRGBArrayFromColorString(colorStr: string): number[];
+export declare function getColorsSequencesFromSessionInformation(parsedSessionInformation: ParsedSessionInformation): ColorSequence[];
 export declare function getFaceMatchState(faceDetector: FaceDetection, videoEl: HTMLVideoElement): Promise<FaceMatchState>;
-export declare function isFaceDistanceBelowThreshold({ faceDetector, videoEl, ovalDetails, reduceThreshold, isMobile, }: {
+export declare function isFaceDistanceBelowThreshold({ parsedSessionInformation, faceDetector, videoEl, ovalDetails, reduceThreshold, }: {
+    parsedSessionInformation: ParsedSessionInformation;
     faceDetector: FaceDetection;
     videoEl: HTMLVideoElement;
     ovalDetails: LivenessOvalDetails;
     reduceThreshold?: boolean;
-    isMobile?: boolean;
 }): Promise<{
     isDistanceBelowThreshold: boolean;
     error?: ErrorState;
 }>;
-export declare function getBoundingBox({ deviceHeight, deviceWidth, height, width, top, left, }: {
-    deviceHeight: number;
-    deviceWidth: number;
-    height: number;
-    width: number;
-    top: number;
-    left: number;
-}): {
-    Height: number;
-    Width: number;
-    Top: number;
-    Left: number;
-};
 export {};

package/dist/types/components/FaceLivenessDetector/service/utils/{eventUtils.d.ts → responseStreamEvent.d.ts}

@@ -1,5 +1,5 @@
-import { LivenessResponseStream } from '@aws-sdk/client-rekognitionstreaming';
-export declare const isServerSesssionInformationEvent: (value: unknown) => value is LivenessResponseStream.ServerSessionInformationEventMember;
+import type { LivenessResponseStream } from '@aws-sdk/client-rekognitionstreaming';
+export declare const isServerSessionInformationEvent: (value: unknown) => value is LivenessResponseStream.ServerSessionInformationEventMember;
 export declare const isConnectionTimeoutError: (error: unknown) => error is Error;
 export declare const isDisconnectionEvent: (value: unknown) => value is LivenessResponseStream.DisconnectionEventMember;
 export declare const isValidationExceptionEvent: (value: unknown) => value is LivenessResponseStream.ValidationExceptionMember;

package/dist/types/components/FaceLivenessDetector/service/utils/sessionInformation.d.ts

@@ -0,0 +1,7 @@
+import type { FaceMovementServerChallenge, FaceMovementAndLightServerChallenge, SessionInformation as ServerSessionInformation } from '@aws-sdk/client-rekognitionstreaming';
+import type { FaceMovementAndLightChallenge, FaceMovementChallenge, ParsedSessionInformation } from '../types';
+export declare const isFaceMovementAndLightChallenge: (value: unknown) => value is FaceMovementAndLightChallenge;
+export declare const isFaceMovementChallenge: (value: unknown) => value is FaceMovementChallenge;
+export declare const isFaceMovementAndLightServerChallenge: (value: unknown) => value is FaceMovementAndLightServerChallenge;
+export declare const isFaceMovementServerChallenge: (value: unknown) => value is FaceMovementServerChallenge;
+export declare const createSessionInfoFromServerSessionInformation: (serverSessionInformation: ServerSessionInformation) => ParsedSessionInformation;

package/dist/types/components/FaceLivenessDetector/service/utils/types.d.ts

@@ -0,0 +1,21 @@
+import type { ClientSessionInformationEvent, LivenessRequestStream } from '@aws-sdk/client-rekognitionstreaming';
+export interface RequestStream extends AsyncGenerator<LivenessRequestStream> {
+}
+export interface VideoStream extends ReadableStream<StreamResult> {
+}
+export type StreamResultType = 'closeCode' | 'sessionInfo' | 'streamStop' | 'streamVideo';
+export type StreamResult<T extends StreamResultType = StreamResultType> = T extends 'closeCode' ? {
+    type: T;
+    data: {
+        closeCode: number;
+    };
+} : T extends 'streamVideo' ? {
+    type: T;
+    data: Blob;
+} : T extends 'sessionInfo' ? {
+    type: T;
+    data: ClientSessionInformationEvent;
+} : T extends 'streamStop' ? {
+    type: T;
+    data?: never;
+} : never;

package/dist/types/components/FaceLivenessDetector/shared/DefaultStartScreenComponents.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import { CheckScreenComponents } from './FaceLivenessErrorModal';
+import type { CheckScreenComponents } from './FaceLivenessErrorModal';
 export type FaceLivenessDetectorComponents = StartScreenComponents & CheckScreenComponents;
 export interface StartScreenComponents {
     PhotosensitiveWarning?: React.ComponentType;

package/dist/types/components/FaceLivenessDetector/shared/FaceLivenessErrorModal.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
-import { ErrorState } from '../service';
-import { ErrorDisplayText } from '../displayText';
+import type { ErrorState } from '../service';
+import type { ErrorDisplayText } from '../displayText';
 export interface CheckScreenComponents {
     ErrorView?: React.ComponentType<FaceLivenessErrorModalProps>;
 }

package/dist/types/components/FaceLivenessDetector/shared/Hint.d.ts

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import { IlluminationState, FaceMatchState } from '../service';
-import { HintDisplayText } from '../displayText';
+import type { HintDisplayText } from '../displayText';
 export declare const selectErrorState: import("../hooks").LivenessSelectorFn<"CONNECTION_TIMEOUT" | "TIMEOUT" | "RUNTIME_ERROR" | "FRESHNESS_TIMEOUT" | "SERVER_ERROR" | "CAMERA_FRAMERATE_ERROR" | "CAMERA_ACCESS_ERROR" | "FACE_DISTANCE_ERROR" | "MOBILE_LANDSCAPE_ERROR" | "MULTIPLE_FACES_ERROR" | undefined>;
 export declare const selectFaceMatchState: import("../hooks").LivenessSelectorFn<FaceMatchState | undefined>;
 export declare const selectIlluminationState: import("../hooks").LivenessSelectorFn<IlluminationState | undefined>;

package/dist/types/components/FaceLivenessDetector/shared/Overlay.d.ts

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import { FlexProps } from '@aws-amplify/ui-react';
+import type { FlexProps } from '@aws-amplify/ui-react';
 interface OverlayProps extends FlexProps {
     horizontal?: 'start' | 'center' | 'end';
     vertical?: 'start' | 'center' | 'end' | 'space-between';

package/dist/types/components/FaceLivenessDetector/shared/Toast.d.ts

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import { ViewProps } from '@aws-amplify/ui-react';
+import type { ViewProps } from '@aws-amplify/ui-react';
 interface ToastProps extends ViewProps {
     variation?: 'default' | 'primary' | 'error';
     size?: 'medium' | 'large';

package/dist/types/components/FaceLivenessDetector/types/classNames.d.ts

@@ -2,6 +2,8 @@ export declare enum LivenessClassNames {
     CameraModule = "amplify-liveness-camera-module",
     CancelContainer = "amplify-liveness-cancel-container",
     CancelButton = "amplify-liveness-cancel-button",
+    CenteredLoader = "amplify-liveness-centered-loader",
+    ConnectingLoader = "amplify-liveness-connecting-loader",
     CountdownContainer = "amplify-liveness-countdown-container",
     DescriptionBullet = "amplify-liveness-description-bullet",
     DescriptionBulletIndex = "amplify-liveness-description-bullet__index",
@@ -41,6 +43,7 @@ export declare enum LivenessClassNames {
     Toast = "amplify-liveness-toast",
     ToastContainer = "amplify-liveness-toast__container",
     ToastMessage = "amplify-liveness-toast__message",
+    UserFacingVideo = "amplify-liveness-video--user-facing",
     Video = "amplify-liveness-video",
     VideoAnchor = "amplify-liveness-video-anchor"
 }

package/dist/types/components/FaceLivenessDetector/utils/device.d.ts

@@ -1,4 +1,5 @@
 export declare function isMobileScreen(): boolean;
+export declare function isDeviceUserFacing(deviceId: string | undefined): Promise<boolean>;
 export declare function isIOS(): boolean;
 export declare function isPortrait(): boolean;
 /**

package/dist/types/components/FaceLivenessDetector/utils/getDisplayText.d.ts

@@ -1,4 +1,4 @@
-import { LivenessDisplayText, HintDisplayText, CameraDisplayText, InstructionDisplayText, StreamDisplayText, ErrorDisplayText } from '../displayText';
+import type { LivenessDisplayText, HintDisplayText, CameraDisplayText, InstructionDisplayText, StreamDisplayText, ErrorDisplayText } from '../displayText';
 interface LivenessDisplayTextInterface {
     hintDisplayText: Required<HintDisplayText>;
     cameraDisplayText: Required<CameraDisplayText>;

package/dist/types/index.d.ts

@@ -1 +1,2 @@
-export { FaceLivenessDetector, FaceLivenessDetectorProps, FaceLivenessDetectorCore, FaceLivenessDetectorCoreProps, AwsCredentialProvider, AwsCredentials, AwsTemporaryCredentials, ErrorState, } from './components';
+export type { FaceLivenessDetectorProps, FaceLivenessDetectorCoreProps, AwsCredentialProvider, AwsCredentials, AwsTemporaryCredentials, ErrorState, } from './components';
+export { FaceLivenessDetector, FaceLivenessDetectorCore } from './components';

package/dist/types/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "3.3.8";
+export declare const VERSION = "3.4.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-amplify/ui-react-liveness",
-  "version": "3.3.8",
+  "version": "3.4.0",
   "main": "dist/index.js",
   "module": "dist/esm/index.mjs",
   "exports": {
@@ -48,15 +48,15 @@
     "react-dom": "^16.14 || ^17 || ^18 || ^19"
   },
   "dependencies": {
-    "@aws-amplify/ui": "6.10.2",
-    "@aws-amplify/ui-react": "6.11.1",
-    "@aws-sdk/client-rekognitionstreaming": "3.621.0",
+    "@aws-amplify/ui": "6.10.3",
+    "@aws-amplify/ui-react": "6.11.2",
+    "@aws-sdk/client-rekognitionstreaming": "3.828.0",
     "@aws-sdk/util-format-url": "3.609.0",
-    "@smithy/eventstream-serde-browser": "^2.0.4",
-    "@smithy/fetch-http-handler": "^2.1.3",
+    "@smithy/eventstream-serde-browser": "^4.0.4",
+    "@smithy/fetch-http-handler": "^5.0.4",
     "@smithy/protocol-http": "^3.0.3",
-    "@smithy/signature-v4": "2.1.4",
-    "@smithy/types": "^3.3.0",
+    "@smithy/signature-v4": "5.1.2",
+    "@smithy/types": "^4.3.1",
     "@mediapipe/face_detection": "~0.4.0",
     "@tensorflow-models/face-detection": "1.0.2",
     "@tensorflow/tfjs-backend-cpu": "4.11.0",
@@ -64,8 +64,8 @@
     "@tensorflow/tfjs-converter": "4.11.0",
     "@tensorflow/tfjs-core": "4.11.0",
     "@xstate/react": "^3.2.2",
-    "nanoid": "3.3.8",
     "tslib": "^2.5.2",
+    "uuid": "^11.1.0",
     "xstate": "^4.33.6"
   },
   "devDependencies": {
@@ -85,4 +85,4 @@
       "limit": "225 kB"
     }
   ]
-}
+}

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

@@ -1,131 +0,0 @@
-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 };

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

@@ -1,126 +0,0 @@
-import { StartFaceLivenessSessionCommand } from '@aws-sdk/client-rekognitionstreaming';
-import { VideoRecorder } from './videoRecorder.mjs';
-import { createStreamingClient } from './createStreamingClient/createStreamingClient.mjs';
-
-const TIME_SLICE = 1000;
-function isBlob(obj) {
-    return obj.arrayBuffer !== undefined;
-}
-function isClientSessionInformationEvent(obj) {
-    return obj.Challenge !== undefined;
-}
-function isEndStreamWithCodeEvent(obj) {
-    return obj.code !== undefined;
-}
-class LivenessStreamProvider {
-    constructor({ sessionId, region, stream, videoEl, credentialProvider, endpointOverride, systemClockOffset, }) {
-        this.sessionId = sessionId;
-        this.region = region;
-        this.stream = stream;
-        this.videoEl = videoEl;
-        this.videoRecorder = new VideoRecorder(stream);
-        this.credentialProvider = credentialProvider;
-        this.endpointOverride = endpointOverride;
-        this.systemClockOffset = systemClockOffset;
-        this.initPromise = this.init();
-    }
-    async getResponseStream() {
-        await this.initPromise;
-        return this.responseStream;
-    }
-    startRecordingLivenessVideo() {
-        this.videoRecorder.start(TIME_SLICE);
-    }
-    sendClientInfo(clientInfo) {
-        this.videoRecorder.dispatch(new MessageEvent('clientSesssionInfo', { data: { clientInfo } }));
-    }
-    async stopVideo() {
-        await this.videoRecorder.stop();
-    }
-    dispatchStopVideoEvent() {
-        this.videoRecorder.dispatch(new Event('stopVideo'));
-    }
-    async endStreamWithCode(code) {
-        if (this.videoRecorder.getState() === 'recording') {
-            await this.stopVideo();
-        }
-        this.videoRecorder.dispatch(new MessageEvent('endStreamWithCode', { data: { code } }));
-        return;
-    }
-    async init() {
-        this._client = await createStreamingClient({
-            credentialsProvider: this.credentialProvider,
-            endpointOverride: this.endpointOverride,
-            region: this.region,
-            systemClockOffset: this.systemClockOffset,
-        });
-        this.responseStream = await this.startLivenessVideoConnection();
-    }
-    // Creates a generator from a stream of video chunks and livenessActionDocuments and yields VideoEvent and ClientEvents
-    getAsyncGeneratorFromReadableStream(stream) {
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        const current = this;
-        this._reader = stream.getReader();
-        return async function* () {
-            while (true) {
-                const { done, value } = (await current._reader.read());
-                if (done) {
-                    return;
-                }
-                // Video chunks blobs should be sent as video events
-                if (value === 'stopVideo') {
-                    // sending an empty video chunk signals that we have ended sending video
-                    yield {
-                        VideoEvent: {
-                            VideoChunk: new Uint8Array([]),
-                            TimestampMillis: Date.now(),
-                        },
-                    };
-                }
-                else if (isBlob(value)) {
-                    const buffer = await value.arrayBuffer();
-                    const chunk = new Uint8Array(buffer);
-                    if (chunk.length > 0) {
-                        yield {
-                            VideoEvent: {
-                                VideoChunk: chunk,
-                                TimestampMillis: Date.now(),
-                            },
-                        };
-                    }
-                }
-                else if (isClientSessionInformationEvent(value)) {
-                    yield {
-                        ClientSessionInformationEvent: {
-                            Challenge: value.Challenge,
-                        },
-                    };
-                }
-                else if (isEndStreamWithCodeEvent(value)) {
-                    yield {
-                        VideoEvent: {
-                            VideoChunk: new Uint8Array([]),
-                            // this is a custom type that does not match LivenessRequestStream.
-                            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                            TimestampMillis: { closeCode: value.code },
-                        },
-                    };
-                }
-            }
-        };
-    }
-    async startLivenessVideoConnection() {
-        const livenessRequestGenerator = this.getAsyncGeneratorFromReadableStream(this.videoRecorder.videoStream)();
-        const mediaSettings = this.stream.getTracks()[0].getSettings();
-        const response = await this._client.send(new StartFaceLivenessSessionCommand({
-            ChallengeVersions: 'FaceMovementAndLightChallenge_1.0.0',
-            SessionId: this.sessionId,
-            LivenessRequestStream: livenessRequestGenerator,
-            VideoWidth: (mediaSettings.width ?? this.videoEl.width).toString(),
-            VideoHeight: (mediaSettings.height ?? this.videoEl.height).toString(),
-        }));
-        return response.LivenessResponseStream;
-    }
-}
-
-export { LivenessStreamProvider };

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

@@ -1,108 +0,0 @@
-import { isAndroidChromeWithBrokenH264 } from '../../utils/device.mjs';
-
-// Equivalent to 2 Kbps - needed for maintaining video quality at 60 FPS
-const BITS_PER_SECOND = 2000000;
-// Only to be used with Chrome for the Android Chrome H264 Bug - https://issues.chromium.org/issues/343199623
-const ALTERNATE_CHROME_MIME_TYPE = 'video/x-matroska;codecs=vp8';
-/**
- * Helper wrapper class over the native MediaRecorder.
- */
-class VideoRecorder {
-    constructor(stream) {
-        if (typeof MediaRecorder === 'undefined') {
-            throw Error('MediaRecorder is not supported by this browser');
-        }
-        this._stream = stream;
-        this._chunks = [];
-        this._recorder = new MediaRecorder(stream, {
-            bitsPerSecond: BITS_PER_SECOND,
-            mimeType: isAndroidChromeWithBrokenH264()
-                ? ALTERNATE_CHROME_MIME_TYPE
-                : undefined,
-        });
-        this._setupCallbacks();
-    }
-    getState() {
-        return this._recorder.state;
-    }
-    start(timeSlice) {
-        this.clearRecordedData();
-        this.recordingStartApiTimestamp = Date.now();
-        this._recorder.start(timeSlice);
-    }
-    async stop() {
-        if (this.getState() === 'recording') {
-            this._recorder.stop();
-        }
-        return this._recorderStopped;
-    }
-    pause() {
-        this._recorder.pause();
-    }
-    clearRecordedData() {
-        this._chunks = [];
-    }
-    dispatch(event) {
-        this._recorder.dispatchEvent(event);
-    }
-    getVideoChunkSize() {
-        return this._chunks.length;
-    }
-    _setupCallbacks() {
-        // Creates a Readablestream of video chunks. Waits to receive a clientSessionInfo event before pushing
-        //  a livenessActionDocument to the ReadableStream and finally closing the ReadableStream
-        this.videoStream = new ReadableStream({
-            start: (controller) => {
-                if (!this._recorder) {
-                    return;
-                }
-                this._recorder.ondataavailable = (e) => {
-                    if (e.data && e.data.size > 0) {
-                        if (this._chunks.length === 0) {
-                            this.firstChunkTimestamp = Date.now();
-                        }
-                        this._chunks.push(e.data);
-                        controller.enqueue(e.data);
-                    }
-                };
-                this._recorder.addEventListener('clientSesssionInfo', (e) => {
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access
-                    controller.enqueue(e.data.clientInfo);
-                });
-                this._recorder.addEventListener('stopVideo', () => {
-                    controller.enqueue('stopVideo');
-                });
-                this._recorder.addEventListener('endStream', () => {
-                    controller.close();
-                });
-                this._recorder.addEventListener('endStreamWithCode', (e) => {
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access
-                    controller.enqueue({
-                        type: 'endStreamWithCode',
-                        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-                        code: e.data.code,
-                    });
-                });
-            },
-        });
-        this.recorderStarted = new Promise((resolve) => {
-            this._recorder.onstart = () => {
-                this.recorderStartTimestamp = Date.now();
-                resolve();
-            };
-        });
-        this._recorderStopped = new Promise((resolve) => {
-            this._recorder.onstop = () => {
-                this.recorderEndTimestamp = Date.now();
-                resolve();
-            };
-        });
-        this._recorder.onerror = () => {
-            if (this.getState() !== 'stopped') {
-                this.stop();
-            }
-        };
-    }
-}
-
-export { VideoRecorder };

package/dist/types/components/FaceLivenessDetector/service/types/service.d.ts

@@ -1,5 +0,0 @@
-export interface ClientFreshnessColorSequence {
-    color: string;
-    downscrollDuration: number;
-    flatDisplayDuration: number;
-}

package/dist/types/components/FaceLivenessDetector/service/utils/freshnessColorDisplay.d.ts

@@ -1,21 +0,0 @@
-import { LivenessContext } from '../types/machine';
-import { ClientFreshnessColorSequence } from '../types/service';
-export declare class FreshnessColorDisplay {
-    private freshnessColorsSequence;
-    private context;
-    private stageIndex;
-    private stage;
-    private currColorIndex;
-    private currColorSequence;
-    private prevColorSequence;
-    private timeLastFlatOrScrollChange;
-    private timeFaceMatched;
-    private timeLastFaceMatchChecked;
-    private isFirstTick;
-    constructor(context: LivenessContext, freshnessColorsSequence: ClientFreshnessColorSequence[]);
-    displayColorTick(): Promise<boolean>;
-    private init;
-    private displayNextColorTick;
-    private incrementStageIndex;
-    private sendColorStartTime;
-}