@smileid/usesmileid 12.0.1 → 12.1.0

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

@@ -1,134 +1 @@
-import { UseSmileIDOverlayState } from "../../state/use_smile_id_overlay_state";
-/**
- * Pure-logic feedback helpers. Feedback travels as a stable `si_*` key
- * so the coaching animation and copy resolution key off one value.
- */
-/**
- * Feedback key for a selfie overlay state with explicit guidance.
- * Lifecycle states return `null` (copy resolved by `mapCaptureUiState`).
- */
-export function selfieFeedbackKeyFor(state) {
-    switch (state) {
-        case UseSmileIDOverlayState.TOO_CLOSE:
-            return "si_capture_too_close";
-        case UseSmileIDOverlayState.TOO_FAR:
-            return "si_capture_too_far";
-        case UseSmileIDOverlayState.FACE_NOT_CENTERED:
-            return "si_capture_center_face";
-        case UseSmileIDOverlayState.MULTIPLE_FACES:
-            return "si_capture_multiple_faces";
-        case UseSmileIDOverlayState.LOW_LIGHT:
-            return "si_capture_low_light";
-        case UseSmileIDOverlayState.BRIGHT_LIGHT:
-            return "si_capture_bright_light";
-        case UseSmileIDOverlayState.WRONG_ORIENTATION:
-            return "si_capture_rotate_device";
-        case UseSmileIDOverlayState.NOT_SMILING:
-            return "si_capture_smile";
-        case UseSmileIDOverlayState.MOVE_LEFT:
-            return "si_capture_move_left";
-        case UseSmileIDOverlayState.MOVE_RIGHT:
-            return "si_capture_move_right";
-        case UseSmileIDOverlayState.MOVE_UP:
-            return "si_capture_move_higher";
-        case UseSmileIDOverlayState.MOVE_DOWN:
-            return "si_capture_move_lower";
-        default:
-            return null;
-    }
-}
-/** Document counterpart of {@link selfieFeedbackKeyFor}. */
-export function documentFeedbackKeyFor(state) {
-    switch (state) {
-        case UseSmileIDOverlayState.DOCUMENT_TOO_CLOSE:
-            return "si_document_too_close";
-        case UseSmileIDOverlayState.DOCUMENT_TOO_FAR:
-            return "si_document_too_far";
-        case UseSmileIDOverlayState.DOCUMENT_NOT_CENTERED:
-            return "si_document_center";
-        case UseSmileIDOverlayState.DOCUMENT_HOLD_STILL:
-            return "si_document_hold_still";
-        default:
-            return null;
-    }
-}
-/**
- * Feedback-key → localized-copy table; unmapped keys fall back to the
- * initial instruction so the guidance never blanks.
- */
-const FEEDBACK_COPY = {
-    si_capture_initial_instruction: (loc) => loc.siCaptureInitialInstruction,
-    si_start_capture_instruction: (loc) => loc.siStartCaptureInstruction,
-    si_capture_too_close: (loc) => loc.siCaptureTooClose,
-    si_capture_too_far: (loc) => loc.siCaptureTooFar,
-    si_capture_center_face: (loc) => loc.siCaptureCenterFace,
-    si_capture_multiple_faces: (loc) => loc.siCaptureMultipleFaces,
-    si_capture_low_light: (loc) => loc.siCaptureLowLight,
-    si_capture_bright_light: (loc) => loc.siCaptureBrightLight,
-    si_capture_rotate_device: (loc) => loc.siCaptureRotateDevice,
-    si_capture_smile: (loc) => loc.siCaptureSmile,
-    si_capture_move_left: (loc) => loc.siCaptureMoveLeft,
-    si_capture_move_right: (loc) => loc.siCaptureMoveRight,
-    si_capture_move_higher: (loc) => loc.siCaptureMoveHigher,
-    si_capture_move_lower: (loc) => loc.siCaptureMoveLower,
-    si_capture_ready: (loc) => loc.siCaptureReady,
-    si_capture_hold_steady: (loc) => loc.siCaptureHoldSteady,
-    si_capture_timeout: (loc) => loc.siCaptureTimeout,
-    si_capturing: (loc) => loc.siCapturing,
-    si_selfie_capture_complete: (loc) => loc.siSelfieCaptureComplete,
-    si_selfie_capture_timeout: (loc) => loc.siSelfieCaptureTimeout,
-    si_selfie_capture_unsatisfied: (loc) => loc.siSelfieCaptureUnsatisfied,
-    si_ess_capture_initial_instruction: (loc) => loc.siEssCaptureInitialInstruction,
-    si_ess_hold_still: (loc) => loc.siEssHoldStill,
-    si_ess_look_left: (loc) => loc.siEssLookLeft,
-    si_ess_look_right: (loc) => loc.siEssLookRight,
-    si_ess_look_up: (loc) => loc.siEssLookUp,
-    si_ess_look_at_camera: (loc) => loc.siEssLookAtCamera,
-    si_document_initial_instruction: (loc) => loc.siDocumentInitialInstruction,
-    si_document_ready: (loc) => loc.siDocumentReady,
-    si_document_capturing: (loc) => loc.siDocumentCapturing,
-    si_document_capture_complete: (loc) => loc.siDocumentCaptureComplete,
-    si_document_capture_unsatisfied: (loc) => loc.siDocumentCaptureUnsatisfied,
-    si_document_capture_timeout: (loc) => loc.siDocumentCaptureTimeout,
-    si_document_too_close: (loc) => loc.siDocumentTooClose,
-    si_document_too_far: (loc) => loc.siDocumentTooFar,
-    si_document_center: (loc) => loc.siDocumentCenter,
-    si_document_hold_still: (loc) => loc.siDocumentHoldStill,
-    si_document_gallery_image_too_small: (loc) => loc.siDocumentGalleryImageTooSmall,
-    si_document_gallery_image_failed: (loc) => loc.siDocumentGalleryImageFailed,
-};
-/** Resolve a stable feedback key to the active locale's copy. */
-export function resolveFeedbackCopy(key, loc) {
-    const resolve = FEEDBACK_COPY[key];
-    return resolve ? resolve(loc) : loc.siCaptureInitialInstruction;
-}
-/**
- * Overlay-state-only copy resolution for callers without a scan state;
- * `mapCaptureUiState` is the richer path that also handles Enhanced
- * Smart Selfie copy.
- */
-export function resolveCaptureFeedback(state, loc) {
-    const feedbackKey = selfieFeedbackKeyFor(state);
-    if (feedbackKey)
-        return resolveFeedbackCopy(feedbackKey, loc);
-    switch (state) {
-        case UseSmileIDOverlayState.HEAD_TURN:
-            return loc.siCaptureHoldSteady;
-        case UseSmileIDOverlayState.FACE_DETECTED:
-        case UseSmileIDOverlayState.READY:
-            return loc.siCaptureReady;
-        case UseSmileIDOverlayState.CAPTURING:
-            return loc.siCapturing;
-        default:
-            return loc.siCaptureInitialInstruction;
-    }
-}
-/**
- * Whether the start-capture button is enabled. "Start" begins the
- * analyzer pipeline (not a snapshot), so it's enabled exactly during
- * the pre-flight `INSTRUCTION` state — before the pipeline has started.
- */
-export function isStartCaptureEnabled(state) {
-    return state === UseSmileIDOverlayState.INSTRUCTION;
-}
-//# sourceMappingURL=capture_screen_helpers.js.map
+"use strict";import{UseSmileIDOverlayState as t}from"../../state/use_smile_id_overlay_state";export function selfieFeedbackKeyFor(e){switch(e){case t.TOO_CLOSE:return"si_capture_too_close";case t.TOO_FAR:return"si_capture_too_far";case t.FACE_NOT_CENTERED:return"si_capture_center_face";case t.LOW_LIGHT:return"si_capture_low_light";case t.BRIGHT_LIGHT:return"si_capture_bright_light";case t.WRONG_ORIENTATION:return"si_capture_rotate_device";case t.NOT_SMILING:return"si_capture_smile";case t.MOVE_LEFT:return"si_capture_move_left";case t.MOVE_RIGHT:return"si_capture_move_right";case t.MOVE_UP:return"si_capture_move_higher";case t.MOVE_DOWN:return"si_capture_move_lower";default:return null}}export function documentFeedbackKeyFor(e){switch(e){case t.DOCUMENT_TOO_CLOSE:return"si_document_too_close";case t.DOCUMENT_TOO_FAR:return"si_document_too_far";case t.DOCUMENT_NOT_CENTERED:return"si_document_center";case t.DOCUMENT_HOLD_STILL:return"si_document_hold_still";default:return null}}const _={si_capture_initial_instruction:e=>e.siCaptureInitialInstruction,si_start_capture_instruction:e=>e.siStartCaptureInstruction,si_capture_too_close:e=>e.siCaptureTooClose,si_capture_too_far:e=>e.siCaptureTooFar,si_capture_center_face:e=>e.siCaptureCenterFace,si_capture_low_light:e=>e.siCaptureLowLight,si_capture_bright_light:e=>e.siCaptureBrightLight,si_capture_rotate_device:e=>e.siCaptureRotateDevice,si_capture_smile:e=>e.siCaptureSmile,si_capture_move_left:e=>e.siCaptureMoveLeft,si_capture_move_right:e=>e.siCaptureMoveRight,si_capture_move_higher:e=>e.siCaptureMoveHigher,si_capture_move_lower:e=>e.siCaptureMoveLower,si_capture_ready:e=>e.siCaptureReady,si_capture_hold_steady:e=>e.siCaptureHoldSteady,si_capture_timeout:e=>e.siCaptureTimeout,si_capture_camera_unavailable:e=>e.siCaptureCameraUnavailable,si_capturing:e=>e.siCapturing,si_selfie_capture_complete:e=>e.siSelfieCaptureComplete,si_selfie_capture_timeout:e=>e.siSelfieCaptureTimeout,si_selfie_capture_unsatisfied:e=>e.siSelfieCaptureUnsatisfied,si_ess_capture_initial_instruction:e=>e.siEssCaptureInitialInstruction,si_ess_hold_still:e=>e.siEssHoldStill,si_ess_look_left:e=>e.siEssLookLeft,si_ess_look_right:e=>e.siEssLookRight,si_ess_look_up:e=>e.siEssLookUp,si_ess_look_at_camera:e=>e.siEssLookAtCamera,si_document_initial_instruction:e=>e.siDocumentInitialInstruction,si_document_ready:e=>e.siDocumentReady,si_document_capturing:e=>e.siDocumentCapturing,si_document_capture_complete:e=>e.siDocumentCaptureComplete,si_document_capture_unsatisfied:e=>e.siDocumentCaptureUnsatisfied,si_document_capture_timeout:e=>e.siDocumentCaptureTimeout,si_document_too_close:e=>e.siDocumentTooClose,si_document_too_far:e=>e.siDocumentTooFar,si_document_center:e=>e.siDocumentCenter,si_document_hold_still:e=>e.siDocumentHoldStill,si_doc_v_capture_directive_wrong_aspect_ratio:e=>e.siDocumentWrongAspectRatio,si_document_gallery_image_too_small:e=>e.siDocumentGalleryImageTooSmall,si_document_gallery_image_failed:e=>e.siDocumentGalleryImageFailed};export function resolveFeedbackCopy(e,i){const s=_[e];return s?s(i):i.siCaptureInitialInstruction}export function resolveCaptureFeedback(e,i){const s=selfieFeedbackKeyFor(e);if(s)return resolveFeedbackCopy(s,i);switch(e){case t.HEAD_TURN:return i.siCaptureHoldSteady;case t.FACE_DETECTED:case t.READY:return i.siCaptureReady;case t.CAPTURING:return i.siCapturing;default:return i.siCaptureInitialInstruction}}export function isStartCaptureEnabled(e){return e===t.INSTRUCTION}

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

@@ -51,4 +51,3 @@ export declare function mapCaptureUiState(scanState: UseSmileIDScanState, captur
 export declare function mapSelfieUiState(scanState: UseSmileIDScanState, enableEnhancedLiveness: boolean): UseSmileIDCaptureUiState;
 /** Document scan-state → UI-state mapping. */
 export declare function mapDocumentUiState(scanState: UseSmileIDScanState): UseSmileIDCaptureUiState;
-//# sourceMappingURL=capture_ui_state.d.ts.map

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

@@ -1,179 +1 @@
-import { UseSmileIDScanStateType } from "@smileid/usesmileid_bridge";
-import { CaptureType } from "../../../core/models/ml_config";
-import { UseSmileIDOverlayState } from "../../state/use_smile_id_overlay_state";
-import { mapScanStateToOverlayState } from "./scan_state_to_overlay_state";
-import { documentFeedbackKeyFor, selfieFeedbackKeyFor, } from "./capture_screen_helpers";
-function uiState(overlayState, feedbackKey, captureProgress) {
-    return {
-        overlayState,
-        feedbackKey,
-        captureProgress,
-        animationDirection: null,
-        poseMatched: false,
-    };
-}
-/**
- * Blocking conditions to surface mid-turn — the user cannot hold the pose
- * while any holds, so each must show and hide the arrow until it clears.
- * Order is the precedence orientation > light > position; the native side
- * sends one feedback code per frame, already dwelled (3 consecutive
- * frames), so no consumer-side debounce. Smile / motion-blur stay out — a
- * turning head always moves and they don't block the pose.
- */
-const ESS_HEAD_TURN_COACHING_KEYS = [
-    "si_capture_rotate_device",
-    "si_capture_low_light",
-    "si_capture_bright_light",
-    "si_capture_too_far",
-    "si_capture_too_close",
-    "si_capture_center_face",
-];
-/** The mid-turn coaching key, or `null` when the turn prompt should show. */
-function essHeadTurnCoachingKey(feedback) {
-    if (feedback === undefined)
-        return null;
-    // Match against the typed set so the result narrows to SiKey without a cast.
-    for (const key of ESS_HEAD_TURN_COACHING_KEYS) {
-        if (key === feedback)
-            return key;
-    }
-    return null;
-}
-/**
- * The oval never fills under Enhanced Smart Selfie — idempotent,
- * applied once at the mapping's exit.
- */
-export function withEnhancedLivenessPolicy(state, enableEnhancedLiveness) {
-    return enableEnhancedLiveness && state.captureProgress !== 0
-        ? { ...state, captureProgress: 0 }
-        : state;
-}
-/**
- * Terminal snapshot for a completed selfie scan — single source for
- * the `finished` mapping and any post-scan fallback.
- */
-export function scannedUiState(enableEnhancedLiveness) {
-    return withEnhancedLivenessPolicy(uiState(UseSmileIDOverlayState.PROCESSING, "si_selfie_capture_complete", 1), enableEnhancedLiveness);
-}
-/** Terminal snapshot for a completed document scan. */
-export function scannedDocumentUiState() {
-    return uiState(UseSmileIDOverlayState.PROCESSING, "si_document_capture_complete", 1);
-}
-/**
- * Snapshot shown before the first analyzed frame. The overlay stays
- * IDLE — eagerly mapping the initial scan state is the no-green-flash
- * regression — while the guidance primes with the flow's initial
- * instruction.
- */
-export function preCaptureUiState(captureType, enableEnhancedLiveness) {
-    // Selfie flows (including ESS) show the press-Start copy here; the
-    // ESS primer belongs to the scanning Initial state.
-    const feedbackKey = captureType === CaptureType.selfie
-        ? "si_start_capture_instruction"
-        : "si_document_initial_instruction";
-    return uiState(UseSmileIDOverlayState.IDLE, feedbackKey, 0);
-}
-/**
- * True when the native analyzer restarted evaluation: leaving
- * `unsatisfied`, or `timeout`/`finished` returning to `initial`.
- */
-export function isSessionBoundary(previous, next) {
-    if (previous.type === next.type)
-        return false;
-    if (previous.type === UseSmileIDScanStateType.Unsatisfied)
-        return true;
-    return ((previous.type === UseSmileIDScanStateType.Timeout ||
-        previous.type === UseSmileIDScanStateType.Finished) &&
-        next.type === UseSmileIDScanStateType.Initial);
-}
-/** Dispatch on capture type — see {@link mapSelfieUiState} / {@link mapDocumentUiState}. */
-export function mapCaptureUiState(scanState, captureType, enableEnhancedLiveness) {
-    return captureType === CaptureType.selfie
-        ? mapSelfieUiState(scanState, enableEnhancedLiveness)
-        : mapDocumentUiState(scanState);
-}
-/**
- * Selfie scan-state → UI-state mapping. Enhanced Smart Selfie switches
- * the copy (initial → head-turn primer; active capture → "Hold
- * still…") and zeroes the fill.
- */
-export function mapSelfieUiState(scanState, enableEnhancedLiveness) {
-    return withEnhancedLivenessPolicy(selfieUiState(scanState, enableEnhancedLiveness), enableEnhancedLiveness);
-}
-function selfieUiState(scanState, enableEnhancedLiveness) {
-    switch (scanState.type) {
-        case UseSmileIDScanStateType.Initial:
-            return uiState(UseSmileIDOverlayState.INSTRUCTION, enableEnhancedLiveness
-                ? "si_ess_capture_initial_instruction"
-                : "si_capture_initial_instruction", 0);
-        case UseSmileIDScanStateType.Found: {
-            const overlayState = mapScanStateToOverlayState(scanState, CaptureType.selfie);
-            const feedbackKey = selfieFeedbackKeyFor(overlayState) ??
-                (enableEnhancedLiveness ? "si_ess_hold_still" : "si_capturing");
-            return uiState(overlayState, feedbackKey, scanState.captureProgress ?? 0);
-        }
-        case UseSmileIDScanStateType.Satisfied:
-            // Progress forced to 1 so the ring completes even when the last
-            // interim frame undershot; transient before `finished`.
-            return uiState(UseSmileIDOverlayState.CAPTURING, enableEnhancedLiveness ? "si_ess_hold_still" : "si_capturing", 1);
-        case UseSmileIDScanStateType.Unsatisfied:
-            // Unsatisfied collapses onto one requirements-not-met copy —
-            // the per-check `reason` only feeds telemetry, not guidance.
-            return uiState(UseSmileIDOverlayState.FACE_DETECTED, "si_selfie_capture_unsatisfied", 0);
-        case UseSmileIDScanStateType.Finished:
-            return scannedUiState(enableEnhancedLiveness);
-        case UseSmileIDScanStateType.Timeout:
-            return uiState(UseSmileIDOverlayState.IDLE, "si_capture_timeout", 0);
-        case UseSmileIDScanStateType.HeadTurn: {
-            const direction = scanState.currentDirection ?? null;
-            const turnPrompt = direction === "left"
-                ? "si_ess_look_left"
-                : direction === "right"
-                    ? "si_ess_look_right"
-                    : direction === "up"
-                        ? "si_ess_look_up"
-                        : "si_capture_hold_steady";
-            // A blocking condition owns the copy and hides the arrow — showing
-            // "turn left" over "move closer" would mislead — and pauses pose-match
-            // latching. No coaching key ⇒ the turn prompt + arrow show.
-            const coachingKey = essHeadTurnCoachingKey(scanState.feedback);
-            return {
-                overlayState: UseSmileIDOverlayState.HEAD_TURN,
-                feedbackKey: coachingKey ?? turnPrompt,
-                captureProgress: 0,
-                animationDirection: coachingKey !== null ? null : direction,
-                poseMatched: coachingKey !== null ? false : (scanState.poseMatched ?? false),
-            };
-        }
-    }
-}
-/** Document scan-state → UI-state mapping. */
-export function mapDocumentUiState(scanState) {
-    switch (scanState.type) {
-        case UseSmileIDScanStateType.Initial:
-        // No head-turn phase for documents; a degenerate headTurn maps to
-        // the pre-capture instruction.
-        case UseSmileIDScanStateType.HeadTurn:
-            return uiState(UseSmileIDOverlayState.INSTRUCTION, "si_document_initial_instruction", 0);
-        case UseSmileIDScanStateType.Found: {
-            const overlayState = mapScanStateToOverlayState(scanState, CaptureType.document);
-            const feedbackKey = documentFeedbackKeyFor(overlayState);
-            // No validator warning ⇒ frames are being collected — show the
-            // in-capture copy, not the pre-capture "position your document".
-            return feedbackKey === null
-                ? uiState(UseSmileIDOverlayState.CAPTURING, "si_document_capturing", scanState.captureProgress ?? 0)
-                : uiState(overlayState, feedbackKey, scanState.captureProgress ?? 0);
-        }
-        // Documents collapse satisfied/finished onto the same terminal
-        // snapshot: the still is captured and the screen is moving on.
-        case UseSmileIDScanStateType.Satisfied:
-            return scannedDocumentUiState();
-        case UseSmileIDScanStateType.Unsatisfied:
-            return uiState(UseSmileIDOverlayState.IDLE, "si_document_capture_unsatisfied", 0);
-        case UseSmileIDScanStateType.Finished:
-            return scannedDocumentUiState();
-        case UseSmileIDScanStateType.Timeout:
-            return uiState(UseSmileIDOverlayState.IDLE, "si_document_capture_timeout", 0);
-    }
-}
-//# sourceMappingURL=capture_ui_state.js.map
+"use strict";import{UseSmileIDScanStateType as i}from"@smileid/usesmileid_bridge";import{CaptureType as u}from"../../../core/models/ml_config";import{UseSmileIDOverlayState as n}from"../../state/use_smile_id_overlay_state";import{mapScanStateToOverlayState as a,resolveFeedbackOverlay as _}from"./scan_state_to_overlay_state";import{documentFeedbackKeyFor as l,selfieFeedbackKeyFor as p}from"./capture_screen_helpers";function s(e,t,r){return{overlayState:e,feedbackKey:t,captureProgress:r,animationDirection:null,poseMatched:!1}}const f=["si_capture_rotate_device","si_capture_low_light","si_capture_bright_light","si_capture_too_far","si_capture_too_close","si_capture_center_face","si_ess_look_at_camera"];function d(e){if(e===void 0)return null;for(const t of f)if(t===e)return t;return null}export function withEnhancedLivenessPolicy(e,t){return t&&e.captureProgress!==0?{...e,captureProgress:0}:e}export function scannedUiState(e){return withEnhancedLivenessPolicy(s(n.PROCESSING,"si_selfie_capture_complete",1),e)}export function scannedDocumentUiState(){return s(n.PROCESSING,"si_document_capture_complete",1)}export function preCaptureUiState(e,t){const r=e===u.selfie?"si_start_capture_instruction":"si_document_initial_instruction";return s(n.IDLE,r,0)}export function isSessionBoundary(e,t){return e.type===t.type?!1:e.type===i.Unsatisfied?!0:(e.type===i.Timeout||e.type===i.Finished)&&t.type===i.Initial}export function mapCaptureUiState(e,t,r){return t===u.selfie?mapSelfieUiState(e,r):mapDocumentUiState(e)}export function mapSelfieUiState(e,t){return withEnhancedLivenessPolicy(m(e,t),t)}function m(e,t){switch(e.type){case i.Initial:return s(n.INSTRUCTION,t?"si_ess_capture_initial_instruction":"si_capture_initial_instruction",0);case i.Found:{const r=a(e,u.selfie),c=p(r)??(t?"si_ess_hold_still":"si_capturing");return s(r,c,e.captureProgress??0)}case i.Satisfied:return s(n.CAPTURING,t?"si_ess_hold_still":"si_capturing",1);case i.Unsatisfied:return s(n.FACE_DETECTED,"si_selfie_capture_unsatisfied",0);case i.Finished:return scannedUiState(t);case i.Timeout:return s(n.IDLE,"si_capture_timeout",0);case i.HeadTurn:{const r=e.currentDirection??null,c=r==="left"?"si_ess_look_left":r==="right"?"si_ess_look_right":r==="up"?"si_ess_look_up":"si_capture_hold_steady",o=d(e.feedback);return{overlayState:o!==null?_(o,u.selfie,n.HEAD_TURN):n.HEAD_TURN,feedbackKey:o??c,captureProgress:0,animationDirection:o!==null?null:r,poseMatched:o!==null?!1:e.poseMatched??!1}}}}export function mapDocumentUiState(e){switch(e.type){case i.Initial:case i.HeadTurn:return s(n.INSTRUCTION,"si_document_initial_instruction",0);case i.Found:{const t=a(e,u.document),r=l(t);return r===null?s(n.CAPTURING,"si_document_capturing",e.captureProgress??0):s(t,r,e.captureProgress??0)}case i.Satisfied:return scannedDocumentUiState();case i.Unsatisfied:return s(n.IDLE,"si_document_capture_unsatisfied",0);case i.Finished:return scannedDocumentUiState();case i.Timeout:return s(n.IDLE,"si_document_capture_timeout",0)}}

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

@@ -36,4 +36,3 @@ export type SubtitlePart = {
  * and `{partner}` without inline styling logic at the call site.
  */
 export declare function composeConsentSubtitleParts(partnerName: string, loc: Pick<UseSmileIDLocalizations, "siConsentSubtitle" | "siConsentSubtitleSmileId" | "siConsentAllow">): readonly SubtitlePart[];
-//# sourceMappingURL=consent_screen_helpers.d.ts.map

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

@@ -1,68 +1 @@
-/**
- * Build the four canonical "this may include processing" rows from
- * the localizations object: Contact → Personal → Biometric → Device.
- */
-export function buildConsentRows(loc) {
-    return [
-        { key: "contact", label: loc.siConsentContact },
-        { key: "personal", label: loc.siConsentPersonal },
-        { key: "biometric", label: loc.siConsentBiometric },
-        { key: "device", label: loc.siConsentDevice },
-    ];
-}
-/**
- * Compose the consent subtitle by substituting the `{allow}`,
- * `{smile_id}`, and `{partner}` tokens. The Allow / Smile ID values
- * come from localization (so translations remain coherent); the
- * partner name is partner-supplied.
- *
- * Substitution is done locally because `siConsentSubtitle` is a
- * non-parameterised getter.
- */
-export function composeConsentSubtitle(partnerName, loc) {
-    return loc.siConsentSubtitle
-        .split("{allow}")
-        .join(loc.siConsentAllow)
-        .split("{smile_id}")
-        .join(loc.siConsentSubtitleSmileId)
-        .split("{partner}")
-        .join(partnerName);
-}
-/**
- * Same as [composeConsentSubtitle] but returns the substring chunks
- * separately, marking each token replacement with `bold: true`. The
- * screen renders the array as a flow of plain + bold `<Text>` nodes
- * so partners see the canonical emphasis on `{allow}`, `{smile_id}`,
- * and `{partner}` without inline styling logic at the call site.
- */
-export function composeConsentSubtitleParts(partnerName, loc) {
-    const tokens = [
-        { token: "{allow}", value: loc.siConsentAllow },
-        { token: "{smile_id}", value: loc.siConsentSubtitleSmileId },
-        { token: "{partner}", value: partnerName },
-    ];
-    // Walk the template once, splitting at the next-occurring token and
-    // emitting plain / bold parts in order. Tokens that don't appear in
-    // the template (e.g. a future translation that drops one) are
-    // silently skipped — same fallback the upstream
-    // `composeConsentSubtitle` provides.
-    let remaining = loc.siConsentSubtitle;
-    const out = [];
-    while (remaining.length > 0) {
-        const next = tokens
-            .map((t) => ({ ...t, index: remaining.indexOf(t.token) }))
-            .filter((t) => t.index >= 0)
-            .sort((a, b) => a.index - b.index)[0];
-        if (!next) {
-            out.push({ text: remaining, bold: false });
-            break;
-        }
-        if (next.index > 0) {
-            out.push({ text: remaining.slice(0, next.index), bold: false });
-        }
-        out.push({ text: next.value, bold: true });
-        remaining = remaining.slice(next.index + next.token.length);
-    }
-    return out;
-}
-//# sourceMappingURL=consent_screen_helpers.js.map
+"use strict";export function buildConsentRows(e){return[{key:"contact",label:e.siConsentContact},{key:"personal",label:e.siConsentPersonal},{key:"biometric",label:e.siConsentBiometric},{key:"device",label:e.siConsentDevice}]}export function composeConsentSubtitle(e,t){return t.siConsentSubtitle.split("{allow}").join(t.siConsentAllow).split("{smile_id}").join(t.siConsentSubtitleSmileId).split("{partner}").join(e)}export function composeConsentSubtitleParts(e,t){const l=[{token:"{allow}",value:t.siConsentAllow},{token:"{smile_id}",value:t.siConsentSubtitleSmileId},{token:"{partner}",value:e}];let n=t.siConsentSubtitle;const o=[];for(;n.length>0;){const i=l.map(s=>({...s,index:n.indexOf(s.token)})).filter(s=>s.index>=0).sort((s,r)=>s.index-r.index)[0];if(!i){o.push({text:n,bold:!1});break}i.index>0&&o.push({text:n.slice(0,i.index),bold:!1}),o.push({text:i.value,bold:!0}),n=n.slice(i.index+i.token.length)}return o}

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

@@ -24,4 +24,3 @@ export declare function essTurnHaptic(previous: UseSmileIDScanState, next: UseSm
  * intentionally swallowed.
  */
 export declare function triggerEssTurnHaptic(kind: EssTurnHaptic): void;
-//# sourceMappingURL=ess_turn_haptics.d.ts.map

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

@@ -1,53 +1 @@
-import * as Haptics from "expo-haptics";
-import { UseSmileIDScanStateType } from "@smileid/usesmileid_bridge";
-/**
- * Decide which haptic (if any) an Enhanced Smart Selfie head-turn
- * transition warrants. Fires once per completed turn:
- *
- * - `"intermediate"` — one head-turn direction completes and the next
- *   begins (the requested direction advances).
- * - `"final"` — the last turn completes and the flow leaves the head-turn
- *   phase toward capture (`found` / `satisfied` / `finished`).
- *
- * Returns `null` for every other transition — crucially including the
- * reset paths (`headTurn → initial` / `headTurn → timeout`): a reset is
- * never a completion. `previous` must be the immediately-preceding raw
- * scan state so the same completion is reported exactly once.
- */
-export function essTurnHaptic(previous, next) {
-    // Only a transition out of an active, directed head turn can complete one.
-    if (previous.type !== UseSmileIDScanStateType.HeadTurn)
-        return null;
-    if (previous.currentDirection === undefined)
-        return null;
-    // The requested direction advanced — the previous turn completed.
-    if (next.type === UseSmileIDScanStateType.HeadTurn &&
-        next.currentDirection !== undefined &&
-        next.currentDirection !== previous.currentDirection) {
-        return "intermediate";
-    }
-    // Leaving the head-turn phase toward capture is the final turn's
-    // completion; `initial` / `timeout` are resets, not completions.
-    if (next.type === UseSmileIDScanStateType.Found ||
-        next.type === UseSmileIDScanStateType.Satisfied ||
-        next.type === UseSmileIDScanStateType.Finished) {
-        return "final";
-    }
-    return null;
-}
-/**
- * Fire the haptic for a completed head turn — a light impact between
- * turns, a success notification on the final turn. Best-effort UX
- * feedback: a device without a taptic engine simply no-ops, and a failure
- * here must never surface as a capture error, so the promise is
- * intentionally swallowed.
- */
-export function triggerEssTurnHaptic(kind) {
-    const run = kind === "final"
-        ? Haptics.notificationAsync(Haptics.NotificationFeedbackType.Success)
-        : Haptics.impactAsync(Haptics.ImpactFeedbackStyle.Light);
-    void run.catch(() => {
-        // Haptics are non-essential; ignore taptic-engine / permission failures.
-    });
-}
-//# sourceMappingURL=ess_turn_haptics.js.map
+"use strict";import*as n from"expo-haptics";import{UseSmileIDScanStateType as e}from"@smileid/usesmileid_bridge";export function essTurnHaptic(t,i){return t.type!==e.HeadTurn||t.currentDirection===void 0?null:i.type===e.HeadTurn&&i.currentDirection!==void 0&&i.currentDirection!==t.currentDirection?"intermediate":i.type===e.Found||i.type===e.Satisfied||i.type===e.Finished?"final":null}export function triggerEssTurnHaptic(t){(t==="final"?n.notificationAsync(n.NotificationFeedbackType.Success):n.impactAsync(n.ImpactFeedbackStyle.Light)).catch(()=>{})}

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

@@ -34,4 +34,3 @@ export declare class UseSmileIDFeedbackDebouncer<T> {
     private settle;
     private cancelTimer;
 }
-//# sourceMappingURL=feedback_debouncer.d.ts.map

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

@@ -1,77 +1 @@
-/**
- * Distinct-value trailing debouncer for the capture guidance feed.
- * The analyzer re-publishes feedback every analyzed frame (~10 Hz),
- * faster than the window — a naive trailing debounce that reschedules
- * on every call would never fire. Re-publishing the pending/emitted
- * value is a no-op (the in-flight window keeps counting); only an
- * actual change restarts it. `isImmediate` values bypass the window.
- */
-export class UseSmileIDFeedbackDebouncer {
-    emit;
-    delayMs;
-    isImmediate;
-    timer = null;
-    hasEmitted = false;
-    emittedValue;
-    pendingValue;
-    constructor(options) {
-        this.emit = options.emit;
-        this.delayMs = options.delayMs;
-        this.isImmediate = options.isImmediate ?? (() => false);
-        if (options.initialValue !== undefined) {
-            this.hasEmitted = true;
-            this.emittedValue = options.initialValue;
-        }
-    }
-    publish(value) {
-        if (this.timer !== null) {
-            if (value === this.pendingValue)
-                return;
-        }
-        else if (this.hasEmitted && value === this.emittedValue) {
-            return;
-        }
-        this.cancelTimer();
-        if (this.isImmediate(value)) {
-            this.settle(value);
-            return;
-        }
-        this.pendingValue = value;
-        this.timer = setTimeout(() => {
-            this.timer = null;
-            this.settle(value);
-        }, this.delayMs);
-    }
-    /**
-     * Forget all state so the next publish goes through even when it
-     * repeats the last emitted value (session reset).
-     */
-    reset() {
-        this.cancelTimer();
-        this.hasEmitted = false;
-        this.emittedValue = undefined;
-        this.pendingValue = undefined;
-    }
-    /** Emit `value` synchronously and mark it settled (post-reset re-seed). */
-    seed(value) {
-        this.cancelTimer();
-        this.settle(value);
-    }
-    /** Cancel any in-flight window without emitting. Call on unmount. */
-    dispose() {
-        this.cancelTimer();
-    }
-    settle(value) {
-        this.hasEmitted = true;
-        this.emittedValue = value;
-        this.pendingValue = undefined;
-        this.emit(value);
-    }
-    cancelTimer() {
-        if (this.timer !== null) {
-            clearTimeout(this.timer);
-            this.timer = null;
-        }
-    }
-}
-//# sourceMappingURL=feedback_debouncer.js.map
+"use strict";export class UseSmileIDFeedbackDebouncer{emit;delayMs;isImmediate;timer=null;hasEmitted=!1;emittedValue;pendingValue;constructor(e){this.emit=e.emit,this.delayMs=e.delayMs,this.isImmediate=e.isImmediate??(()=>!1),e.initialValue!==void 0&&(this.hasEmitted=!0,this.emittedValue=e.initialValue)}publish(e){if(this.timer!==null){if(e===this.pendingValue)return}else if(this.hasEmitted&&e===this.emittedValue)return;if(this.cancelTimer(),this.isImmediate(e)){this.settle(e);return}this.pendingValue=e,this.timer=setTimeout(()=>{this.timer=null,this.settle(e)},this.delayMs)}reset(){this.cancelTimer(),this.hasEmitted=!1,this.emittedValue=void 0,this.pendingValue=void 0}seed(e){this.cancelTimer(),this.settle(e)}dispose(){this.cancelTimer()}settle(e){this.hasEmitted=!0,this.emittedValue=e,this.pendingValue=void 0,this.emit(e)}cancelTimer(){this.timer!==null&&(clearTimeout(this.timer),this.timer=null)}}

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

@@ -10,7 +10,6 @@ export type InstructionsConfigInput = {
     readonly heroAnimation?: HeroAnimationSource;
     readonly guidelinesSectionTitle?: string;
     readonly guidelines?: readonly InstructionGuideline[];
-    readonly showAttribution?: boolean;
     readonly showHeroOval?: boolean;
 };
 /** Fully-resolved values handed to `UseSmileIDInstructionsScreen`. */
@@ -20,7 +19,6 @@ export type ResolvedInstructions = {
     readonly heroSource: HeroAnimationSource;
     readonly guidelinesSectionTitle: string;
     readonly guidelines: readonly InstructionGuideline[];
-    readonly showAttribution: boolean;
     readonly showHeroOval: boolean;
     readonly showHeroOvalProgress: boolean;
     readonly showCardBackground: boolean;
@@ -41,4 +39,3 @@ export declare function resolveInstructionsConfig(config: InstructionsConfigInpu
     readonly enhancedLivenessEnabled: boolean;
     readonly documentType?: DocumentType;
 }, localizations: Pick<UseSmileIDLocalizations, "siInstructionsTitlePrefix" | "siInstructionsEmphasisSelfie" | "siInstructionsCaptureGuidelines">): ResolvedInstructions;
-//# sourceMappingURL=instructions_screen_helpers.d.ts.map

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

@@ -1,54 +1 @@
-import { documentGuidelines, documentHeroAnimation, ESS_HERO_ANIMATION, SELFIE_GUIDELINES, SELFIE_HERO_ANIMATION, } from "../../flow/model/instructions_defaults";
-/**
- * Swaps the default selfie hero for the ESS hero when enhanced liveness is on
- * and the hero is unset; a partner-supplied hero is always respected.
- */
-export function resolvedHeroAnimation(heroAnimation, enhancedLivenessEnabled) {
-    if (enhancedLivenessEnabled && heroAnimation === undefined) {
-        return ESS_HERO_ANIMATION;
-    }
-    return heroAnimation ?? SELFIE_HERO_ANIMATION;
-}
-/**
- * Resolve the config into concrete screen props (explicit value > localized /
- * shared default). When `options.documentType` is set, renders the document
- * variant: title emphasis ← `displayName`, document hero + guidelines, face
- * oval forced off. Partner-set title/guidelines/hero still win; the oval does
- * not (a document has no face).
- */
-export function resolveInstructionsConfig(config, options, localizations) {
-    const enhanced = options.enhancedLivenessEnabled;
-    const documentType = options.documentType;
-    const isDocument = documentType !== undefined;
-    const defaultGuidelines = isDocument
-        ? documentGuidelines(documentType)
-        : SELFIE_GUIDELINES;
-    const guidelines = config.guidelines && config.guidelines.length > 0
-        ? config.guidelines
-        : defaultGuidelines;
-    const titleEmphasis = config.titleEmphasis ??
-        (isDocument
-            ? documentType.displayName
-            : localizations.siInstructionsEmphasisSelfie);
-    const heroSource = isDocument
-        ? (config.heroAnimation ?? documentHeroAnimation(documentType))
-        : resolvedHeroAnimation(config.heroAnimation, enhanced);
-    return {
-        titlePrefix: config.titlePrefix ?? localizations.siInstructionsTitlePrefix,
-        titleEmphasis,
-        heroSource,
-        guidelinesSectionTitle: config.guidelinesSectionTitle ??
-            localizations.siInstructionsCaptureGuidelines,
-        guidelines,
-        showAttribution: config.showAttribution ?? true,
-        // A document flow never shows the face oval — the override applies to
-        // selfie flows only (a document has no face to frame).
-        showHeroOval: isDocument ? false : (config.showHeroOval ?? true),
-        showHeroOvalProgress: isDocument ? false : !enhanced,
-        // Card hero is the document variant only — tied to the flow type, not to
-        // `!showHeroOval` (a selfie flow can disable the oval without becoming a
-        // document, and must not then render the document card).
-        showCardBackground: isDocument,
-    };
-}
-//# sourceMappingURL=instructions_screen_helpers.js.map
+"use strict";import{documentGuidelines as a,documentHeroAnimation as c,ESS_HERO_ANIMATION as m,SELFIE_GUIDELINES as E,SELFIE_HERO_ANIMATION as h}from"../../flow/model/instructions_defaults";export function resolvedHeroAnimation(e,t){return t&&e===void 0?m:e??h}export function resolveInstructionsConfig(e,t,s){const r=t.enhancedLivenessEnabled,i=t.documentType,n=i!==void 0,o=n?a(i):E,u=e.guidelines&&e.guidelines.length>0?e.guidelines:o,d=e.titleEmphasis??(n?i.displayName:s.siInstructionsEmphasisSelfie),l=n?e.heroAnimation??c(i):resolvedHeroAnimation(e.heroAnimation,r);return{titlePrefix:e.titlePrefix??s.siInstructionsTitlePrefix,titleEmphasis:d,heroSource:l,guidelinesSectionTitle:e.guidelinesSectionTitle??s.siInstructionsCaptureGuidelines,guidelines:u,showHeroOval:n?!1:e.showHeroOval??!0,showHeroOvalProgress:n?!1:!r,showCardBackground:n}}

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

@@ -26,4 +26,3 @@ export type PreviewStateInput = {
  *     hides — the user has already committed.
  */
 export declare function resolvePreviewState(props: PreviewStateInput): PreviewState;
-//# sourceMappingURL=preview_screen_helpers.d.ts.map