@ahmed_hani/dot-document-auto-capture 7.4.0

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@ahmed_hani/dot-document-auto-capture",
+  "private": false,
+  "version": "7.4.0",
+  "license": "sofa proprietary license",
+  "description": "Digital onboarding document capture",
+  "keywords": [
+    "document",
+    "capture",
+    "document capture",
+    "auto",
+    "automatic",
+    "identity",
+    "verification",
+    "detection",
+    "camera",
+    "video",
+    "selfie",
+    "scan",
+    "scanning",
+    "sdk",
+    "api"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Eng-AhmedHani/dot-js-kit.git"
+  },
+  "homepage": "https://github.com/Eng-AhmedHani/dot-js-kit.git",
+  "dependencies": {
+    "@preact/signals": "^2.0.4",
+    "comlink": "^4.4.2",
+    "preact": "^10.26.6",
+    "preact-custom-element": "^4.3.0",
+    "styled-components": "^6.1.18"
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "common/src/types/document.d.ts"
+      ],
+      "events": [
+        "document/src/events.d.ts"
+      ]
+    }
+  },
+  "types": "common/src/types/document.d.ts",
+  "exports": {
+    ".": {
+      "types": "./common/src/types/document.d.ts",
+      "import": "./index.mjs",
+      "require": "./index.umd.js"
+    },
+    "./events": {
+      "types": "./document/src/events.d.ts",
+      "import": "./events.mjs",
+      "require": "./events.umd.js"
+    }
+  },
+  "scripts": {
+    "dev": "vite",
+    "build:document": "LIB=document vite build",
+    "build:controller": "LIB=document vite build --config ../../config/vite-controller.config.ts",
+    "build:events": "LIB=events vite build",
+    "build": "tsc && pnpm build:document && pnpm build:events && pnpm build:types",
+    "build:watch": "pnpm build:document --watch",
+    "build:pack": "pnpm build && cd dist && pnpm pack --pack-destination ../",
+    "build:types": "tsc --project tsconfig.production.json && tsc-alias -p tsc-alias.json",
+    "preview": "vite preview",
+    "lint": "eslint \"src/**/*.{ts,tsx}\" --max-warnings 0",
+    "test": "vitest run --coverage",
+    "tsc": "tsc",
+    "bump:version": "npm pkg set version=$VERSION",
+    "update:changelog": "../../scripts/update-changelog.sh"
+  }
+}

package/ui-common/src/error/auto-capture-error.d.ts

@@ -0,0 +1,7 @@
+export declare class AutoCaptureError extends Error {
+    cause: Error | undefined;
+    constructor(message: string, cause?: Error);
+    static logError(error: unknown): void;
+    static fromCameraError(error: Error): AutoCaptureError;
+    static fromError(error: unknown): AutoCaptureError;
+}

package/ui-common/src/error/index.d.ts

@@ -0,0 +1 @@
+export * from './auto-capture-error';

package/ui-common/src/events/control.d.ts

@@ -0,0 +1,9 @@
+import type { ControlEventInstructionValues, DocumentCustomEvent, EyeGazeCustomEvent, FaceCustomEvent, MagnifEyeCustomEvent, PalmCustomEvent, RequestCaptureInstructionValues, SmileCustomEvent } from '../types/events';
+/**
+ * It dispatches a custom event with the given event name and event detail
+ * @param {DocumentCustomEvent.CONTROL | FaceCustomEvent.CONTROL |  PalmCustomEvent.CONTROL | SmileCustomEvent.CONTROL | EyeGazeCustomEvent.CONTROL | MagnifEyeCustomEvent.CONTROL} eventName - The name of the event to
+ * dispatch.
+ * @param {ControlEventInstruction} instruction - ControlEventInstruction
+ */
+export declare const dispatchControlEvent: (eventName: DocumentCustomEvent.CONTROL | FaceCustomEvent.CONTROL | PalmCustomEvent.CONTROL | SmileCustomEvent.CONTROL | EyeGazeCustomEvent.CONTROL | MagnifEyeCustomEvent.CONTROL, instruction: ControlEventInstructionValues) => void;
+export declare function dispatchCaptureEvent(instruction: RequestCaptureInstructionValues): void;

package/ui-common/src/events/custom.d.ts

@@ -0,0 +1 @@
+export declare const dispatchCustomEvent: (eventName: string, detail: Record<string, unknown>) => void;

package/ui-common/src/types/common.d.ts

@@ -0,0 +1,88 @@
+type CustomEvents<K extends string> = {
+    [key in K]: (event: CustomEvent) => void;
+};
+export type CustomElement<T, K extends string = ''> = Partial<T & HTMLElement & {
+    children: unknown;
+} & CustomEvents<`on${K}`> & {
+    ref?: unknown;
+}>;
+export type DeepRequired<T> = Required<{
+    [P in keyof T]: T[P] extends Record<string, unknown> | undefined ? DeepRequired<Required<T[P]>> : T[P];
+}>;
+export type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+export type RequireSome<T, K extends keyof T> = T & {
+    [P in K]-?: T[P];
+};
+export type ObjectValues<T> = T[keyof T];
+export declare const FacingMode: {
+    readonly FRONT: "user";
+    readonly REAR: "environment";
+};
+export type FacingModeValues = ObjectValues<typeof FacingMode>;
+export declare const CaptureMode: {
+    readonly AUTO_CAPTURE: "AUTO_CAPTURE";
+    readonly WAIT_FOR_REQUEST: "WAIT_FOR_REQUEST";
+};
+export type CaptureModeValues = ObjectValues<typeof CaptureMode>;
+export type BaseCameraProps<CallbackData> = {
+    assetsDirectoryPath?: string;
+    cameraFacing?: FacingModeValues;
+    candidateSelectionDurationMillis?: number;
+    captureMode?: CaptureModeValues;
+    onError: (e: Error) => void;
+    onPhotoTaken: (imageData: CallbackImage<CallbackData>, content: Uint8Array) => void;
+    sessionToken?: string;
+    styleTarget?: HTMLElement;
+};
+export type ImageParameters = {
+    brightness: number;
+    sharpness: number;
+};
+export type CameraSettings = MediaTrackSettings & {
+    deviceName?: string;
+};
+export type Resolution = {
+    height: number;
+    width: number;
+};
+export type Point = {
+    x: number;
+    y: number;
+};
+export declare const AppStateValues: {
+    readonly LOADING: "LOADING";
+    readonly ERROR: "ERROR";
+    readonly WAITING: "WAITING";
+    readonly RUNNING: "RUNNING";
+};
+export declare const LivenessStateValues: {
+    readonly DONE: "DONE";
+    readonly LOADING: "LOADING";
+    readonly ERROR: "ERROR";
+    readonly WAITING: "WAITING";
+    readonly RUNNING: "RUNNING";
+};
+export type AppState = ObjectValues<typeof AppStateValues>;
+export type Crop = {
+    height: number;
+    shiftX: number;
+    shiftY: number;
+    width: number;
+};
+export type CallbackImage<T> = {
+    data: T;
+    image: Blob;
+};
+export type DetectedCorners = {
+    bottomLeft: Point;
+    bottomRight: Point;
+    topLeft: Point;
+    topRight: Point;
+};
+export type ThresholdInterval = {
+    max: number;
+    min: number;
+};
+export {};

package/ui-common/src/types/document.d.ts

@@ -0,0 +1,30 @@
+import type { DetectedCorners, ImageParameters, ObjectValues } from './common';
+export declare const DocumentInstructionCodeValues: {
+    readonly CANDIDATE_SELECTION: "candidate_selection";
+    readonly DOCUMENT_CENTERING: "document_centering";
+    readonly DOCUMENT_NOT_PRESENT: "document_not_present";
+    readonly DOCUMENT_TOO_FAR: "document_too_far";
+    readonly SHARPNESS_TOO_LOW: "sharpness_too_low";
+    readonly BRIGHTNESS_TOO_LOW: "brightness_too_low";
+    readonly BRIGHTNESS_TOO_HIGH: "brightness_too_high";
+    readonly HOTSPOTS_PRESENT: "hotspots_present";
+};
+export declare const DocumentCheckToInstructionCodeMap: {
+    isPresent: "document_not_present";
+    isNotSmall: "document_too_far";
+    isNotOutOfBounds: "document_centering";
+    isSharp: "sharpness_too_low";
+    isNotDim: "brightness_too_low";
+    isNotBright: "brightness_too_high";
+    noHotspots: "hotspots_present";
+};
+export type DocumentInstructionCode = ObjectValues<typeof DocumentInstructionCodeValues>;
+export type DetectedDocumentCorners = DetectedCorners;
+export type DocumentImageParameters = ImageParameters & {
+    hotspots: number;
+};
+export type DetectedDocument = DocumentImageParameters & DetectedDocumentCorners & {
+    confidence: number;
+    smallestEdge: number;
+};
+export type DocumentEscalatedInstructionCodes = typeof DocumentInstructionCodeValues.DOCUMENT_TOO_FAR | typeof DocumentInstructionCodeValues.BRIGHTNESS_TOO_HIGH | typeof DocumentInstructionCodeValues.BRIGHTNESS_TOO_LOW | typeof DocumentInstructionCodeValues.SHARPNESS_TOO_LOW;

package/ui-common/src/types/events/common.d.ts

@@ -0,0 +1,74 @@
+import type { DocumentCustomEvent } from './document';
+import type { FaceCustomEvent } from './face';
+import type { PalmCustomEvent } from './palm';
+import type { AutoCaptureError } from '../../error/auto-capture-error';
+import type { AppState, ObjectValues, Resolution } from '../common';
+import type { DocumentInstructionCode } from '../document';
+import type { FaceInstructionCode } from '../face';
+import type { PalmInstructionCode } from '../palm';
+export declare const ControlEventInstruction: {
+    readonly CONTINUE_DETECTION: "continue-detection";
+    readonly SWITCH_CAMERA: "switch-camera";
+    readonly TOGGLE_MIRROR: "toggle-mirror";
+};
+export type ControlEventInstructionValues = ObjectValues<typeof ControlEventInstruction>;
+export declare const RequestCaptureInstruction: {
+    readonly FIRST_FRAME: "first-frame";
+    readonly FIRST_VALID_FRAME: "first-valid-frame";
+};
+export type RequestCaptureInstructionValues = ObjectValues<typeof RequestCaptureInstruction>;
+export declare const ComponentCustomEvent: {
+    readonly REQUEST_CAPTURE: "dot-custom-event:request-capture";
+};
+export type ComponentCustomEventValues = ObjectValues<typeof ComponentCustomEvent>;
+export type ControlEvent<T> = {
+    detail?: {
+        instruction: T;
+    };
+} & Event;
+export type CameraPropsChangeEvent = {
+    detail?: {
+        cameraResolution: Resolution;
+        isMirroring: boolean;
+    };
+} & Event;
+export type CameraStateChangeEvent = {
+    detail?: {
+        appState: AppState;
+        error?: AutoCaptureError;
+    };
+} & Event;
+export type InstructionChangeEvent<T> = {
+    detail?: {
+        instructionCode: T;
+        isEscalated: boolean;
+    };
+} & Event;
+export type InstructionEscalatedEvent<T> = {
+    detail?: {
+        instructionCode: T;
+    };
+} & Event;
+export type InstructionChangeEventCodeMap = {
+    [DocumentCustomEvent.INSTRUCTION_CHANGED]: DocumentInstructionCode;
+    [FaceCustomEvent.INSTRUCTION_CHANGED]: FaceInstructionCode;
+    [PalmCustomEvent.INSTRUCTION_CHANGED]: PalmInstructionCode;
+};
+export type CaptureCustomEvent = typeof PalmCustomEvent | typeof DocumentCustomEvent | typeof FaceCustomEvent;
+export type VideoElementSizeChangeEvent = {
+    detail?: {
+        size: DOMRect;
+    };
+} & Event;
+export type DetectionEvent<TDetectedObject, TInstructionCode extends string = string> = {
+    detail?: {
+        data: {
+            detection: TDetectedObject;
+            fps: number;
+            imageResolution: Resolution;
+            invalidValidators: Array<TInstructionCode>;
+            isInCandidateSelection: boolean;
+        };
+        image: HTMLCanvasElement;
+    };
+} & Event;

package/ui-common/src/types/events/document.d.ts

@@ -0,0 +1,23 @@
+import type { InstructionChangeEvent, InstructionEscalatedEvent } from './common';
+import type { DetectedDocument, DocumentInstructionCode } from '../document';
+export declare enum DocumentCustomEvent {
+    CAMERA_PROPS_CHANGED = "document-auto-capture:camera-props-changed",
+    CONTROL = "document-auto-capture:control",
+    DETECTED_DOCUMENT_CHANGED = "document-auto-capture:detected-document-changed",
+    DOCUMENT_DETECTION = "document-auto-capture:document-detection",
+    INSTRUCTION_CHANGED = "document-auto-capture:instruction-changed",
+    INSTRUCTION_ESCALATED = "document-auto-capture:instruction-escalated",
+    STATE_CHANGED = "document-auto-capture:state-changed",
+    VIDEO_ELEMENT_SIZE = "document-auto-capture:video-element-size"
+}
+export type DetectedDocumentChangeEvent = {
+    detail?: {
+        detectedObject: DetectedDocument;
+    };
+} & Event;
+export type DocumentInstructionChangeEvent = InstructionChangeEvent<DocumentInstructionCode>;
+export type DispatchDocumentDetectionEvent = {
+    detection: DetectedDocument;
+    eventName: DocumentCustomEvent.DOCUMENT_DETECTION;
+};
+export type DocumentInstructionEscalatedEvent = InstructionEscalatedEvent<DocumentInstructionCode>;

package/ui-common/src/types/events/eye-gaze.d.ts

@@ -0,0 +1,4 @@
+export declare enum EyeGazeCustomEvent {
+    CONTROL = "eye-gaze-auto-capture:control",
+    STATUS_CHANGED = "eye-gaze-auto-capture:status-changed"
+}

package/ui-common/src/types/events/face.d.ts

@@ -0,0 +1,21 @@
+import type { InstructionChangeEvent } from './common';
+import type { DetectedFace, FaceInstructionCode } from '../face';
+export declare enum FaceCustomEvent {
+    CAMERA_PROPS_CHANGED = "face-auto-capture:camera-props-changed",
+    CONTROL = "face-auto-capture:control",
+    DETECTED_FACE_CHANGED = "face-auto-capture:detected-face-changed",
+    FACE_DETECTION = "face-auto-capture:face-detection",
+    INSTRUCTION_CHANGED = "face-auto-capture:instruction-changed",
+    STATE_CHANGED = "face-auto-capture:state-changed",
+    VIDEO_ELEMENT_SIZE = "face-auto-capture:video-element-size"
+}
+export type DetectedFaceChangeEvent = {
+    detail?: {
+        detectedObject: DetectedFace;
+    };
+} & Event;
+export type FaceInstructionChangeEvent = InstructionChangeEvent<FaceInstructionCode>;
+export type DispatchFaceDetectionEvent = {
+    detection: DetectedFace;
+    eventName: FaceCustomEvent.FACE_DETECTION;
+};

package/ui-common/src/types/events/index.d.ts

@@ -0,0 +1,8 @@
+export * from './common';
+export * from './document';
+export * from './face';
+export * from './magnifeye';
+export * from './liveness';
+export * from './smile';
+export * from './palm';
+export * from './eye-gaze';

package/ui-common/src/types/events/liveness.d.ts

@@ -0,0 +1,13 @@
+import type { AutoCaptureError } from '../../error';
+export type AnimationEndEvent = {
+    detail?: {
+        animationEnd: boolean;
+    };
+} & Event;
+export type StatusChangeEvent<Phase, State> = {
+    detail?: {
+        error?: AutoCaptureError;
+        phase?: Phase;
+        state?: State;
+    };
+} & Event;

package/ui-common/src/types/events/magnifeye.d.ts

@@ -0,0 +1,5 @@
+export declare enum MagnifEyeCustomEvent {
+    ANIMATION_END = "magnifeye-auto-capture:animation-end",
+    CONTROL = "magnifeye-auto-capture:control",
+    STATUS_CHANGED = "magnifeye-auto-capture:status-changed"
+}

package/ui-common/src/types/events/palm.d.ts

@@ -0,0 +1,16 @@
+import type { InstructionChangeEvent } from './common';
+import type { DetectedPalm, PalmInstructionCode } from '../palm';
+export declare enum PalmCustomEvent {
+    CAMERA_PROPS_CHANGED = "palm-capture:camera-props-changed",
+    CONTROL = "palm-capture:control",
+    DETECTED_PALM_CHANGED = "palm-capture:detected-palm-changed",
+    INSTRUCTION_CHANGED = "palm-capture:instruction-changed",
+    STATE_CHANGED = "palm-capture:state-changed",
+    VIDEO_ELEMENT_SIZE = "palm-capture:video-element-size"
+}
+export type DetectedPalmChangeEvent = {
+    detail?: {
+        detectedObject: DetectedPalm;
+    };
+} & Event;
+export type PalmInstructionChangeEvent = InstructionChangeEvent<PalmInstructionCode>;

package/ui-common/src/types/events/smile.d.ts

@@ -0,0 +1,8 @@
+import type { InstructionEscalatedEvent } from './common';
+import type { SmileInstructionCode } from '../smile';
+export declare enum SmileCustomEvent {
+    CONTROL = "smile-auto-capture:control",
+    INSTRUCTION_ESCALATED = "smile:instruction-escalated",
+    STATUS_CHANGED = "smile-auto-capture:status-changed"
+}
+export type SmileInstructionEscalatedEvent = InstructionEscalatedEvent<SmileInstructionCode>;

package/ui-common/src/types/eye-gaze.d.ts

@@ -0,0 +1,39 @@
+import type { ObjectValues } from './common';
+export declare const EyeGazeInstructionCodeValues: {
+    readonly WATCH_THE_OBJECT: "watch_the_object";
+    readonly CANDIDATE_SELECTION: "candidate_selection";
+    readonly FACE_TOO_CLOSE: "face_too_close";
+    readonly FACE_TOO_FAR: "face_too_far";
+    readonly FACE_CENTERING: "face_centering";
+    readonly FACE_NOT_PRESENT: "face_not_present";
+    readonly SHARPNESS_TOO_LOW: "sharpness_too_low";
+    readonly BRIGHTNESS_TOO_LOW: "brightness_too_low";
+    readonly BRIGHTNESS_TOO_HIGH: "brightness_too_high";
+    readonly DEVICE_PITCHED: "device_pitched";
+    readonly LEFT_EYE_NOT_PRESENT: "left_eye_not_present";
+    readonly RIGHT_EYE_NOT_PRESENT: "right_eye_not_present";
+    readonly MOUTH_NOT_PRESENT: "mouth_not_present";
+    readonly MOUTH_SCORE_TOO_HIGH: "mouth_score_too_high";
+    readonly MOUTH_SCORE_TOO_LOW: "mouth_score_too_low";
+};
+export type EyeGazeInstructionCode = ObjectValues<typeof EyeGazeInstructionCodeValues>;
+export declare const EyeGazePhaseValues: {
+    readonly VALIDATION: "VALIDATION";
+    readonly COLLECTION: "COLLECTION";
+};
+export type EyeGazePhase = ObjectValues<typeof EyeGazePhaseValues>;
+export declare const EyeGazeStateValues: {
+    readonly DONE: "DONE";
+    readonly LOADING: "LOADING";
+    readonly ERROR: "ERROR";
+    readonly WAITING: "WAITING";
+    readonly RUNNING: "RUNNING";
+};
+export type EyeGazeState = ObjectValues<typeof EyeGazeStateValues>;
+export declare const Corner: {
+    readonly TOP_LEFT: "TOP_LEFT";
+    readonly TOP_RIGHT: "TOP_RIGHT";
+    readonly BOTTOM_RIGHT: "BOTTOM_RIGHT";
+    readonly BOTTOM_LEFT: "BOTTOM_LEFT";
+};
+export type CornerValues = ObjectValues<typeof Corner>;

package/ui-common/src/types/face.d.ts

@@ -0,0 +1,52 @@
+import type { ImageParameters, ObjectValues, Point } from './common';
+export declare const FaceInstructionCodeValues: {
+    readonly CANDIDATE_SELECTION: "candidate_selection";
+    readonly FACE_TOO_CLOSE: "face_too_close";
+    readonly FACE_TOO_FAR: "face_too_far";
+    readonly FACE_CENTERING: "face_centering";
+    readonly FACE_NOT_PRESENT: "face_not_present";
+    readonly SHARPNESS_TOO_LOW: "sharpness_too_low";
+    readonly BRIGHTNESS_TOO_LOW: "brightness_too_low";
+    readonly BRIGHTNESS_TOO_HIGH: "brightness_too_high";
+    readonly DEVICE_PITCHED: "device_pitched";
+    readonly LEFT_EYE_NOT_PRESENT: "left_eye_not_present";
+    readonly RIGHT_EYE_NOT_PRESENT: "right_eye_not_present";
+    readonly MOUTH_NOT_PRESENT: "mouth_not_present";
+    readonly MOUTH_SCORE_TOO_HIGH: "mouth_score_too_high";
+    readonly MOUTH_SCORE_TOO_LOW: "mouth_score_too_low";
+};
+export declare const FaceCheckToInstructionCodeMap: {
+    isPresent: "face_not_present";
+    isNotPitched: "device_pitched";
+    isNotSmall: "face_too_far";
+    isNotLarge: "face_too_close";
+    isNotOutOfBounds: "face_centering";
+    isNotDim: "brightness_too_low";
+    isNotBright: "brightness_too_high";
+    isSharp: "sharpness_too_low";
+    isLeftEyePresent: "left_eye_not_present";
+    isRightEyePresent: "right_eye_not_present";
+    isMouthPresent: "mouth_not_present";
+    isMouthScoreNotTooHigh: "mouth_score_too_high";
+    isMouthScoreNotTooLow: "mouth_score_too_low";
+};
+export type FaceInstructionCode = ObjectValues<typeof FaceInstructionCodeValues>;
+export type DetectedFacePart = {
+    center: Point;
+    confidence: number;
+    size: number;
+    status: number;
+};
+export type DetectedFace = FaceImageParameters & DetectedFaceCorners & {
+    confidence: number;
+    faceSize: number;
+    leftEye: DetectedFacePart;
+    mouth: DetectedFacePart;
+    rightEye: DetectedFacePart;
+};
+export type DetectedFaceCorners = {
+    bottomRight: Point;
+    faceCenter: Point;
+    topLeft: Point;
+};
+export type FaceImageParameters = ImageParameters;

package/ui-common/src/types/index.d.ts

@@ -0,0 +1,8 @@
+export * from './events';
+export * from './document';
+export * from './face';
+export * from './common';
+export * from './magnifeye';
+export * from './smile';
+export * from './palm';
+export * from './eye-gaze';

package/ui-common/src/types/magnifeye.d.ts

@@ -0,0 +1,32 @@
+import type { ObjectValues } from './common';
+export declare const MagnifEyeInstructionCodeValues: {
+    readonly FIT_YOUR_EYE: "fit_your_eye";
+    readonly CANDIDATE_SELECTION: "candidate_selection";
+    readonly FACE_TOO_CLOSE: "face_too_close";
+    readonly FACE_TOO_FAR: "face_too_far";
+    readonly FACE_CENTERING: "face_centering";
+    readonly FACE_NOT_PRESENT: "face_not_present";
+    readonly SHARPNESS_TOO_LOW: "sharpness_too_low";
+    readonly BRIGHTNESS_TOO_LOW: "brightness_too_low";
+    readonly BRIGHTNESS_TOO_HIGH: "brightness_too_high";
+    readonly DEVICE_PITCHED: "device_pitched";
+    readonly LEFT_EYE_NOT_PRESENT: "left_eye_not_present";
+    readonly RIGHT_EYE_NOT_PRESENT: "right_eye_not_present";
+    readonly MOUTH_NOT_PRESENT: "mouth_not_present";
+    readonly MOUTH_SCORE_TOO_HIGH: "mouth_score_too_high";
+    readonly MOUTH_SCORE_TOO_LOW: "mouth_score_too_low";
+};
+export type MagnifEyeInstructionCode = ObjectValues<typeof MagnifEyeInstructionCodeValues>;
+export declare enum MagnifEyePhase {
+    CLOSEUP = "CLOSEUP",
+    DISTANT = "DISTANT",
+    MIDDLE = "MIDDLE"
+}
+export declare const MagnifEyeStateValues: {
+    readonly DONE: "DONE";
+    readonly LOADING: "LOADING";
+    readonly ERROR: "ERROR";
+    readonly WAITING: "WAITING";
+    readonly RUNNING: "RUNNING";
+};
+export type MagnifEyeState = ObjectValues<typeof MagnifEyeStateValues>;

package/ui-common/src/types/palm.d.ts

@@ -0,0 +1,44 @@
+import type { DetectedCorners, ImageParameters, ObjectValues } from './common';
+export declare const PalmInstructionCodeValues: {
+    readonly CANDIDATE_SELECTION: "candidate_selection";
+    readonly PALM_CENTERING: "palm_centering";
+    readonly PALM_NOT_PRESENT: "palm_not_present";
+    readonly PALM_TOO_FAR: "palm_too_far";
+    readonly PALM_TOO_CLOSE: "palm_too_close";
+    readonly SHARPNESS_TOO_LOW: "sharpness_too_low";
+    readonly BRIGHTNESS_TOO_LOW: "brightness_too_low";
+    readonly BRIGHTNESS_TOO_HIGH: "brightness_too_high";
+    readonly DEVICE_PITCHED: "device_pitched";
+    readonly TEMPLATE_EXTRACTION_QUALITY_TOO_LOW: "template_extraction_quality_too_low";
+};
+export declare const PalmHandPosition: {
+    readonly LEFT: "Left";
+    readonly RIGHT: "Right";
+};
+export declare const PalmHandOrientation: {
+    readonly PALMAR: "Palmar";
+    readonly DORSAL: "Dorsal";
+};
+export declare const PalmCheckToInstructionCodeMap: {
+    isPresent: "palm_not_present";
+    isNotPitched: "device_pitched";
+    isNotSmall: "palm_too_far";
+    isNotOutOfBounds: "palm_centering";
+    isNotDim: "brightness_too_low";
+    isNotBright: "brightness_too_high";
+    isSharp: "sharpness_too_low";
+    isNotLarge: "palm_too_close";
+    isTemplateExtractionQualityHighEnough: "template_extraction_quality_too_low";
+};
+export type PalmInstructionCode = ObjectValues<typeof PalmInstructionCodeValues>;
+export type DetectedPalmCorners = DetectedCorners;
+export type PalmImageParameters = ImageParameters;
+export type PalmQualityAttributes = {
+    handOrientation: ObjectValues<typeof PalmHandOrientation>;
+    handPosition: ObjectValues<typeof PalmHandPosition>;
+    quality: number;
+};
+export type DetectedPalm = PalmQualityAttributes & PalmImageParameters & DetectedPalmCorners & {
+    confidence: number;
+    smallestEdge: number;
+};

package/ui-common/src/types/smile.d.ts

@@ -0,0 +1,36 @@
+import type { ObjectValues } from './common';
+export declare const SmileInstructionCodeValues: {
+    readonly SMILE: "smile";
+    readonly SMILE_CANDIDATE_SELECTION: "smile_candidate_selection";
+    readonly KEEP_NEUTRAL_EXPRESSION: "keep_neutral_expression";
+    readonly CANDIDATE_SELECTION: "candidate_selection";
+    readonly FACE_TOO_CLOSE: "face_too_close";
+    readonly FACE_TOO_FAR: "face_too_far";
+    readonly FACE_CENTERING: "face_centering";
+    readonly FACE_NOT_PRESENT: "face_not_present";
+    readonly SHARPNESS_TOO_LOW: "sharpness_too_low";
+    readonly BRIGHTNESS_TOO_LOW: "brightness_too_low";
+    readonly BRIGHTNESS_TOO_HIGH: "brightness_too_high";
+    readonly DEVICE_PITCHED: "device_pitched";
+    readonly LEFT_EYE_NOT_PRESENT: "left_eye_not_present";
+    readonly RIGHT_EYE_NOT_PRESENT: "right_eye_not_present";
+    readonly MOUTH_NOT_PRESENT: "mouth_not_present";
+    readonly MOUTH_SCORE_TOO_HIGH: "mouth_score_too_high";
+    readonly MOUTH_SCORE_TOO_LOW: "mouth_score_too_low";
+};
+export type SmileInstructionCode = ObjectValues<typeof SmileInstructionCodeValues>;
+export type CustomizableSmileInstructionCode = Exclude<SmileInstructionCode, 'mouth_score_too_low' | 'mouth_score_too_high'>;
+export declare const SmilePhaseValues: {
+    readonly NEUTRAL: "NEUTRAL";
+    readonly SMILE: "SMILE";
+};
+export type SmilePhase = ObjectValues<typeof SmilePhaseValues>;
+export declare const SmileStateValues: {
+    readonly DONE: "DONE";
+    readonly LOADING: "LOADING";
+    readonly ERROR: "ERROR";
+    readonly WAITING: "WAITING";
+    readonly RUNNING: "RUNNING";
+};
+export type SmileState = ObjectValues<typeof SmileStateValues>;
+export type SmileEscalatedInstructionCodes = typeof SmileInstructionCodeValues.SMILE | typeof SmileInstructionCodeValues.KEEP_NEUTRAL_EXPRESSION;