@smileid/usesmileid 12.0.2 → 12.1.1

package/dist/presentation/screen/helpers/preview_screen_helpers.js

@@ -1,27 +1 @@
-/**
- * Pure-logic helpers for `UseSmileIDPreviewScreen`. Extracted so the
- * accept-button enablement rule and image-presence guard can be
- * unit-tested without an RN renderer.
- */
-/**
- * Resolve the screen's button enablement state.
- *
- *   - `hasImage`: there's something to preview. Drives the visual
- *     branch (image card vs. empty fallback).
- *   - `canAccept`: an image must exist; otherwise the Accept button
- *     would advance the flow on a non-existent capture.
- *   - `canRetake`: image must exist AND `allowRetake !== false`. When
- *     the partner forces `allowRetake: false`, the Reject button
- *     hides — the user has already committed.
- */
-export function resolvePreviewState(props) {
-    const hasImage = typeof props.capturedSelfiePath === "string" &&
-        props.capturedSelfiePath.length > 0;
-    const allowRetake = props.allowRetake ?? true;
-    return {
-        hasImage,
-        canAccept: hasImage,
-        canRetake: hasImage && allowRetake,
-    };
-}
-//# sourceMappingURL=preview_screen_helpers.js.map
+"use strict";export function resolvePreviewState(e){const t=typeof e.capturedSelfiePath=="string"&&e.capturedSelfiePath.length>0,a=e.allowRetake??!0;return{hasImage:t,canAccept:t,canRetake:t&&a}}

package/dist/presentation/screen/helpers/processing_screen_helpers.d.ts

@@ -10,4 +10,3 @@ import type { UseSmileIDOverlayState as OverlayState } from "../../state/use_smi
  */
 export type ProcessingStateKind = "loading" | "success" | "failed";
 export declare function resolveOverlayStateForProcessing(kind: ProcessingStateKind): OverlayState;
-//# sourceMappingURL=processing_screen_helpers.d.ts.map

package/dist/presentation/screen/helpers/processing_screen_helpers.js

@@ -1,12 +1 @@
-import { UseSmileIDOverlayState } from "../../state/use_smile_id_overlay_state";
-export function resolveOverlayStateForProcessing(kind) {
-    switch (kind) {
-        case "loading":
-            return UseSmileIDOverlayState.PROCESSING;
-        case "success":
-            return UseSmileIDOverlayState.READY;
-        case "failed":
-            return UseSmileIDOverlayState.IDLE;
-    }
-}
-//# sourceMappingURL=processing_screen_helpers.js.map
+"use strict";import{UseSmileIDOverlayState as e}from"../../state/use_smile_id_overlay_state";export function resolveOverlayStateForProcessing(r){switch(r){case"loading":return e.PROCESSING;case"success":return e.READY;case"failed":return e.IDLE}}

package/dist/presentation/screen/helpers/scan_state_to_overlay_state.d.ts

@@ -18,4 +18,10 @@ import { UseSmileIDOverlayState } from "../../state/use_smile_id_overlay_state";
  * a new feedback key the JS side hasn't been updated for.
  */
 export declare function mapScanStateToOverlayState(scanState: UseSmileIDScanState, captureType: CaptureType): UseSmileIDOverlayState;
-//# sourceMappingURL=scan_state_to_overlay_state.d.ts.map
+/**
+ * Translate a native `si_capture_*` feedback / reason key into the
+ * corresponding overlay state. Unknown keys return the supplied
+ * `fallback` so the overlay keeps animating even when the native
+ * plugin emits a key the JS side hasn't been updated for.
+ */
+export declare function resolveFeedbackOverlay(key: string | undefined, captureType: CaptureType, fallback: UseSmileIDOverlayState): UseSmileIDOverlayState;

package/dist/presentation/screen/helpers/scan_state_to_overlay_state.js

@@ -1,107 +1 @@
-import { UseSmileIDScanStateType } from "@smileid/usesmileid_bridge";
-import { CaptureType } from "../../../core/models/ml_config";
-import { UseSmileIDOverlayState } from "../../state/use_smile_id_overlay_state";
-/**
- * Map an analyzer's `UseSmileIDScanState` into the SDK's visual `OverlayState`.
- *
- * The overlay enum drives the face/document oval's border colour, dash
- * pattern, and fill animation — it's a presentation concept layered on
- * top of the scan-state machine. The mapping reads `state.feedback`
- * (when `type === UseSmileIDScanStateType.Found`) and `state.reason` (when
- * `type === UseSmileIDScanStateType.Unsatisfied`) to pick the fine-grained
- * overlay state; other scan-state types map coarsely to the matching
- * lifecycle entry.
- *
- * Unrecognised feedback / reason strings fall back to the green-solid
- * `FACE_DETECTED` / orange-solid `FACE_NOT_CENTERED` defaults rather
- * than throwing — keeps the overlay alive when a native plugin emits
- * a new feedback key the JS side hasn't been updated for.
- */
-export function mapScanStateToOverlayState(scanState, captureType) {
-    switch (scanState.type) {
-        case UseSmileIDScanStateType.Initial:
-            return UseSmileIDOverlayState.INSTRUCTION;
-        case UseSmileIDScanStateType.Found:
-            // `feedback` is the canonical `si_capture_*` key the native side
-            // emits; partner code never sees raw English copy.
-            return resolveFeedbackOverlay(scanState.feedback, captureType, captureType === CaptureType.selfie
-                ? UseSmileIDOverlayState.FACE_DETECTED
-                : UseSmileIDOverlayState.DOCUMENT_READY);
-        case UseSmileIDScanStateType.Satisfied:
-            return UseSmileIDOverlayState.READY;
-        case UseSmileIDScanStateType.Unsatisfied:
-            return resolveFeedbackOverlay(scanState.reason, captureType, captureType === CaptureType.selfie
-                ? UseSmileIDOverlayState.FACE_NOT_CENTERED
-                : UseSmileIDOverlayState.DOCUMENT_NOT_CENTERED);
-        case UseSmileIDScanStateType.Finished:
-            return UseSmileIDOverlayState.CAPTURING;
-        case UseSmileIDScanStateType.HeadTurn:
-            return UseSmileIDOverlayState.HEAD_TURN;
-        case UseSmileIDScanStateType.Timeout:
-            // Back to the gray pre-capture state while partners re-prompt.
-            return UseSmileIDOverlayState.IDLE;
-    }
-}
-/**
- * Translate a native `si_capture_*` feedback / reason key into the
- * corresponding overlay state. Unknown keys return the supplied
- * `fallback` so the overlay keeps animating even when the native
- * plugin emits a key the JS side hasn't been updated for.
- */
-function resolveFeedbackOverlay(key, captureType, fallback) {
-    if (!key)
-        return fallback;
-    if (captureType === CaptureType.selfie) {
-        switch (key) {
-            case "si_capture_too_close":
-                return UseSmileIDOverlayState.TOO_CLOSE;
-            case "si_capture_too_far":
-                return UseSmileIDOverlayState.TOO_FAR;
-            case "si_capture_multiple_faces":
-                return UseSmileIDOverlayState.MULTIPLE_FACES;
-            case "si_capture_center_face":
-                return UseSmileIDOverlayState.FACE_NOT_CENTERED;
-            case "si_capture_low_light":
-                return UseSmileIDOverlayState.LOW_LIGHT;
-            case "si_capture_bright_light":
-                return UseSmileIDOverlayState.BRIGHT_LIGHT;
-            case "si_capture_wrong_orientation":
-            case "si_capture_rotate_device":
-                return UseSmileIDOverlayState.WRONG_ORIENTATION;
-            case "si_capture_smile":
-                return UseSmileIDOverlayState.NOT_SMILING;
-            // Directional hints: "higher"/"lower" name the device motion,
-            // mapping to the top/bottom oval edge.
-            case "si_capture_move_left":
-                return UseSmileIDOverlayState.MOVE_LEFT;
-            case "si_capture_move_right":
-                return UseSmileIDOverlayState.MOVE_RIGHT;
-            case "si_capture_move_higher":
-                return UseSmileIDOverlayState.MOVE_UP;
-            case "si_capture_move_lower":
-                return UseSmileIDOverlayState.MOVE_DOWN;
-            // ESS re-center gate between head-turn directions
-            case "si_ess_look_at_camera":
-                return UseSmileIDOverlayState.FACE_NOT_CENTERED;
-            default:
-                return fallback;
-        }
-    }
-    // captureType === "document"
-    switch (key) {
-        case "si_capture_too_close":
-        case "si_document_too_close":
-            return UseSmileIDOverlayState.DOCUMENT_TOO_CLOSE;
-        case "si_capture_too_far":
-        case "si_document_too_far":
-            return UseSmileIDOverlayState.DOCUMENT_TOO_FAR;
-        case "si_document_center":
-            return UseSmileIDOverlayState.DOCUMENT_NOT_CENTERED;
-        case "si_capture_hold_still":
-        case "si_document_hold_still":
-            return UseSmileIDOverlayState.DOCUMENT_HOLD_STILL;
-        default:
-            return fallback;
-    }
-}
-//# sourceMappingURL=scan_state_to_overlay_state.js.map
+"use strict";import{UseSmileIDScanStateType as _}from"@smileid/usesmileid_bridge";import{CaptureType as a}from"../../../core/models/ml_config";import{UseSmileIDOverlayState as e}from"../../state/use_smile_id_overlay_state";export function mapScanStateToOverlayState(r,t){switch(r.type){case _.Initial:return e.INSTRUCTION;case _.Found:return resolveFeedbackOverlay(r.feedback,t,t===a.selfie?e.FACE_DETECTED:e.DOCUMENT_READY);case _.Satisfied:return e.READY;case _.Unsatisfied:return resolveFeedbackOverlay(r.reason,t,t===a.selfie?e.FACE_NOT_CENTERED:e.DOCUMENT_NOT_CENTERED);case _.Finished:return e.CAPTURING;case _.HeadTurn:return e.HEAD_TURN;case _.Timeout:return e.IDLE}}export function resolveFeedbackOverlay(r,t,s){if(!r)return s;if(t===a.selfie)switch(r){case"si_capture_too_close":return e.TOO_CLOSE;case"si_capture_too_far":return e.TOO_FAR;case"si_capture_center_face":return e.FACE_NOT_CENTERED;case"si_capture_low_light":return e.LOW_LIGHT;case"si_capture_bright_light":return e.BRIGHT_LIGHT;case"si_capture_wrong_orientation":case"si_capture_rotate_device":return e.WRONG_ORIENTATION;case"si_capture_smile":return e.NOT_SMILING;case"si_capture_move_left":return e.MOVE_LEFT;case"si_capture_move_right":return e.MOVE_RIGHT;case"si_capture_move_higher":return e.MOVE_UP;case"si_capture_move_lower":return e.MOVE_DOWN;case"si_ess_look_at_camera":return e.FACE_NOT_CENTERED;default:return s}switch(r){case"si_capture_too_close":case"si_document_too_close":return e.DOCUMENT_TOO_CLOSE;case"si_capture_too_far":case"si_document_too_far":return e.DOCUMENT_TOO_FAR;case"si_document_center":case"si_doc_v_capture_directive_wrong_aspect_ratio":return e.DOCUMENT_NOT_CENTERED;case"si_capture_hold_still":case"si_document_hold_still":return e.DOCUMENT_HOLD_STILL;default:return s}}

package/dist/presentation/screen/helpers/use_capture_orientation_lock.d.ts

@@ -23,4 +23,3 @@ export type CaptureOrientationOptions = {
 export declare function useCaptureOrientationLock(orientation: DocumentOrientation, { exitLock, }?: CaptureOrientationOptions): void;
 /** Test seam: clears the once-per-target dev-warning dedupe. */
 export declare function resetUnsupportedLockWarningsForTesting(): void;
-//# sourceMappingURL=use_capture_orientation_lock.d.ts.map

package/dist/presentation/screen/helpers/use_capture_orientation_lock.js

@@ -1,79 +1 @@
-import { useEffect } from "react";
-import * as ScreenOrientation from "expo-screen-orientation";
-import { UseSmileIDCrashReporting } from "@smileid/usesmileid_bridge";
-/**
- * Lock device orientation for a capture screen, scoped to its lifetime
- * (`"Landscape"` → landscape, `"Portrait"` → portrait-up).
- *
- * Each screen asserts its OWN orientation on mount, so document → selfie
- * reverts deterministically rather than depending on the previous
- * screen's teardown winning a race against the next camera initialising.
- *
- * Locks are global: the host app must permit the locked orientations at
- * the OS level (iOS `UISupportedInterfaceOrientations`, Android activity
- * `screenOrientation`) for the lock to take effect — a host that does not
- * is warned about and reported rather than silently staying upright.
- */
-export function useCaptureOrientationLock(orientation, { exitLock = ScreenOrientation.OrientationLock.PORTRAIT_UP, } = {}) {
-    useEffect(() => {
-        const target = orientation === "Landscape"
-            ? ScreenOrientation.OrientationLock.LANDSCAPE
-            : ScreenOrientation.OrientationLock.PORTRAIT_UP;
-        void reportIfLockUnsupported(target);
-        void lockOrientation(target);
-        return () => {
-            void lockOrientation(exitLock);
-        };
-    }, [orientation, exitLock]);
-}
-/**
- * Surface a host build that cannot honour `target`. `lockAsync` resolves
- * successfully in that case, so without this preflight the capture screen
- * just stays in the wrong orientation with no signal. (Expo's `app.json`
- * `orientation` value is not such a case: the module's app-delegate hook
- * outranks the baked `Info.plist` on iOS — device-verified.)
- */
-async function reportIfLockUnsupported(target) {
-    let supported;
-    try {
-        supported = await ScreenOrientation.supportsOrientationLockAsync(target);
-    }
-    catch (error) {
-        reportOrientationFailure(error);
-        return;
-    }
-    if (supported)
-        return;
-    // `typeof` guard: `__DEV__` is bundler-injected and absent outside Metro-like
-    // environments, where a bare reference throws rather than reading falsy.
-    const isDevBuild = typeof __DEV__ !== "undefined" && __DEV__;
-    if (isDevBuild && !warnedUnsupportedTargets.has(target)) {
-        warnedUnsupportedTargets.add(target);
-        console.warn("[UseSmileID] The capture screen needs to lock the device orientation, " +
-            "but this build does not permit it. Allow the required orientations " +
-            "in your app's iOS Info.plist / Android manifest.");
-    }
-    reportOrientationFailure(new Error(`orientation lock unsupported by host build: ${target}`));
-}
-/**
- * Dedupes the dev warning per target: a flow remounts the capture screen for the back
- * side and interstitial, and the misconfiguration can't change mid-session.
- */
-const warnedUnsupportedTargets = new Set();
-/** Test seam: clears the once-per-target dev-warning dedupe. */
-export function resetUnsupportedLockWarningsForTesting() {
-    warnedUnsupportedTargets.clear();
-}
-/** Lock to `target`, routing a native failure through crash reporting. */
-async function lockOrientation(target) {
-    try {
-        await ScreenOrientation.lockAsync(target);
-    }
-    catch (error) {
-        reportOrientationFailure(error);
-    }
-}
-function reportOrientationFailure(error) {
-    UseSmileIDCrashReporting.captureException(error instanceof Error ? error : new Error(String(error)));
-}
-//# sourceMappingURL=use_capture_orientation_lock.js.map
+"use strict";import{useEffect as a}from"react";import*as e from"expo-screen-orientation";import{UseSmileIDCrashReporting as p}from"@smileid/usesmileid_bridge";export function useCaptureOrientationLock(t,{exitLock:n=e.OrientationLock.PORTRAIT_UP}={}){a(()=>{const o=t==="Landscape"?e.OrientationLock.LANDSCAPE:e.OrientationLock.PORTRAIT_UP;return u(o),s(o),()=>{s(n)}},[t,n])}async function u(t){let n;try{n=await e.supportsOrientationLockAsync(t)}catch(c){i(c);return}if(n)return;typeof __DEV__<"u"&&__DEV__&&!r.has(t)&&(r.add(t),console.warn("[UseSmileID] The capture screen needs to lock the device orientation, but this build does not permit it. Allow the required orientations in your app's iOS Info.plist / Android manifest.")),i(new Error(`orientation lock unsupported by host build: ${t}`))}const r=new Set;export function resetUnsupportedLockWarningsForTesting(){r.clear()}async function s(t){try{await e.lockAsync(t)}catch(n){i(n)}}function i(t){p.captureException(t instanceof Error?t:new Error(String(t)))}

package/dist/presentation/screen/helpers/use_debounced_feedback_key.d.ts

@@ -6,4 +6,3 @@ import type { SiKey } from "../../../l10n/strings_en";
  * Bump `sessionEpoch` on a session restart to reset and re-seed.
  */
 export declare function useDebouncedFeedbackKey(feedbackKey: SiKey, sessionEpoch?: number): SiKey;
-//# sourceMappingURL=use_debounced_feedback_key.d.ts.map

package/dist/presentation/screen/helpers/use_debounced_feedback_key.js

@@ -1,44 +1 @@
-import { useEffect, useRef, useState } from "react";
-import { UseSmileIDMotion } from "../../theme/use_smile_id_motion";
-import { UseSmileIDFeedbackDebouncer } from "./feedback_debouncer";
-/** Terminal copy that must appear the instant the scan completes. */
-const IMMEDIATE_FEEDBACK_KEYS = new Set([
-    "si_selfie_capture_complete",
-    "si_document_capture_complete",
-]);
-/**
- * Settle the guidance key over `UseSmileIDMotion.feedbackDebounce` so
- * per-frame churn doesn't flicker the copy or the coaching animation.
- * The rim, fill, and head-turn direction must NOT go through this hook.
- * Bump `sessionEpoch` on a session restart to reset and re-seed.
- */
-export function useDebouncedFeedbackKey(feedbackKey, sessionEpoch = 0) {
-    const [settledKey, setSettledKey] = useState(feedbackKey);
-    const debouncerRef = useRef(null);
-    if (debouncerRef.current === null) {
-        debouncerRef.current = new UseSmileIDFeedbackDebouncer({
-            emit: setSettledKey,
-            delayMs: UseSmileIDMotion.feedbackDebounce,
-            isImmediate: (value) => IMMEDIATE_FEEDBACK_KEYS.has(value),
-            initialValue: feedbackKey,
-        });
-    }
-    const lastEpochRef = useRef(sessionEpoch);
-    useEffect(() => {
-        const debouncer = debouncerRef.current;
-        if (!debouncer)
-            return;
-        if (lastEpochRef.current !== sessionEpoch) {
-            lastEpochRef.current = sessionEpoch;
-            debouncer.reset();
-            debouncer.seed(feedbackKey);
-            return;
-        }
-        debouncer.publish(feedbackKey);
-    }, [feedbackKey, sessionEpoch]);
-    // Cancel the in-flight window so the timer never lands a setState
-    // on an unmounted component.
-    useEffect(() => () => debouncerRef.current?.dispose(), []);
-    return settledKey;
-}
-//# sourceMappingURL=use_debounced_feedback_key.js.map
+"use strict";import{useEffect as c,useRef as o,useState as s}from"react";import{UseSmileIDMotion as m}from"../../theme/use_smile_id_motion";import{UseSmileIDFeedbackDebouncer as f}from"./feedback_debouncer";const d=new Set(["si_selfie_capture_complete","si_document_capture_complete"]);export function useDebouncedFeedbackKey(t,r=0){const[i,l]=s(t),u=o(null);u.current===null&&(u.current=new f({emit:l,delayMs:m.feedbackDebounce,isImmediate:e=>d.has(e),initialValue:t}));const n=o(r);return c(()=>{const e=u.current;if(e){if(n.current!==r){n.current=r,e.reset(),e.seed(t);return}e.publish(t)}},[t,r]),c(()=>()=>u.current?.dispose(),[]),i}

package/dist/presentation/screen/use_smile_id_capture_screen.d.ts

@@ -7,6 +7,7 @@ import type { DocumentCaptureMode } from "../../core/models/document_capture_mod
 import type { DocumentType } from "../../core/models/document_type";
 import { type UseSmileIDTheme } from "../theme/theme";
 import { DocumentImageOrigin } from "../../metadata/document_image_origin";
+import { type KameraSessionLike } from "../../camera/use_smile_id_kamera_camera_system";
 /** Capture telemetry surfaced alongside the captured artifacts at completion. */
 export interface CaptureTelemetry {
     /** Elapsed time in ms from the first analyzed frame to completion. */
@@ -40,6 +41,13 @@ export type UseSmileIDCaptureScreenProps = {
     readonly onDocumentOrigin?: (origin: DocumentImageOrigin) => void;
     /** Fires when the state machine reaches `"timeout"`; the screen stops streaming. */
     readonly onCaptureTimeout?: (state: UseSmileIDScanState) => void;
+    /**
+     * Fires on a terminal kamera error. On iOS a denied camera permission arrives only here (the
+     * permission gate reports granted optimistically), so without it the user is stranded on a dead preview.
+     */
+    readonly onCameraError?: (code: string, message?: string) => void;
+    /** Testing seam: overrides the kamera session factory so a fake session can drive the screen. */
+    readonly createCameraSession?: () => KameraSessionLike;
     readonly onBack?: () => void;
     readonly showAttribution?: boolean;
     /** Keeps the oval rim neutral through CAPTURING/PROCESSING — ESS has no green oval treatment. */
@@ -75,15 +83,4 @@ export type UseSmileIDCaptureScreenProps = {
     }) => ReactNode;
     readonly theme?: UseSmileIDTheme;
 };
-/**
- * Capture route — owns the camera session, frame streaming, analyzer
- * results, and effects; derives an immutable `UseSmileIDCaptureContentState`
- * per scan-state update and delegates rendering to the stateless
- * `UseSmileIDCaptureContent` (camera preview injected through its slot).
- *
- * Flow: Start → frame processor runs the native plugin per frame
- * (`useSmileIDFrameStream` validates results) → on `finished`, `flush()`
- * then `onCaptureComplete`; on `timeout`, `onCaptureTimeout`.
- */
 export declare function UseSmileIDCaptureScreen(props: UseSmileIDCaptureScreenProps): import("react").JSX.Element;
-//# sourceMappingURL=use_smile_id_capture_screen.d.ts.map