@smileid/usesmileid 12.0.2 → 12.1.0

package/src/presentation/screen/helpers/__tests__/use_capture_orientation_lock.test.tsx

@@ -1,212 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { create as createRenderer, act } from "react-test-renderer";
-import * as ScreenOrientation from "expo-screen-orientation";
-import { UseSmileIDCrashReporting } from "@smileid/usesmileid_bridge";
-import type { DocumentOrientation } from "../../../../core/models/document_type";
-import {
-  useCaptureOrientationLock,
-  resetUnsupportedLockWarningsForTesting,
-} from "../use_capture_orientation_lock";
-
-/**
- * Lifecycle tests for `useCaptureOrientationLock`:
- *   - mount asserts the screen's own orientation
- *   - unmount applies the configured exit lock (portrait-up by default)
- *   - a host build that cannot honour the lock is warned about (dev builds,
- *     once per target) and reported (every build)
- *
- * The `expo-screen-orientation` mock lives in `setup_react_native.ts`.
- * `__DEV__` is bundler-injected and deliberately NOT defined suite-wide —
- * each test sets exactly the build shape it pins.
- */
-
-const mockedLockAsync = vi.mocked(ScreenOrientation.lockAsync);
-const mockedSupportsLock = vi.mocked(
-  ScreenOrientation.supportsOrientationLockAsync,
-);
-
-const globalWithDev = globalThis as { __DEV__?: boolean };
-
-function LockHost(props: {
-  readonly orientation: DocumentOrientation;
-  readonly exitLock?: ScreenOrientation.OrientationLock;
-}) {
-  useCaptureOrientationLock(props.orientation, {
-    ...(props.exitLock !== undefined ? { exitLock: props.exitLock } : {}),
-  });
-  return null;
-}
-
-async function flushPromises(): Promise<void> {
-  // A macrotask tick drains every pending microtask chain first, so this stays
-  // correct if the hook gains or loses `await`s.
-  await new Promise<void>((resolve) => setTimeout(resolve, 0));
-}
-
-async function mountHost(
-  props: Parameters<typeof LockHost>[0],
-): Promise<ReturnType<typeof createRenderer>> {
-  let tree!: ReturnType<typeof createRenderer>;
-  act(() => {
-    tree = createRenderer(<LockHost {...props} />);
-  });
-  await act(async () => {
-    await flushPromises();
-  });
-  return tree;
-}
-
-describe("useCaptureOrientationLock", () => {
-  let savedDev: boolean | undefined;
-
-  beforeEach(() => {
-    savedDev = globalWithDev.__DEV__;
-    delete globalWithDev.__DEV__;
-    resetUnsupportedLockWarningsForTesting();
-    mockedLockAsync.mockReset();
-    mockedLockAsync.mockResolvedValue(undefined);
-    mockedSupportsLock.mockReset();
-    mockedSupportsLock.mockResolvedValue(true);
-  });
-
-  afterEach(() => {
-    if (savedDev === undefined) {
-      delete globalWithDev.__DEV__;
-    } else {
-      globalWithDev.__DEV__ = savedDev;
-    }
-    vi.restoreAllMocks();
-  });
-
-  it("locks landscape on mount for a landscape document", async () => {
-    const tree = await mountHost({ orientation: "Landscape" });
-
-    expect(mockedLockAsync).toHaveBeenCalledTimes(1);
-    expect(mockedLockAsync).toHaveBeenCalledWith(
-      ScreenOrientation.OrientationLock.LANDSCAPE,
-    );
-
-    await act(async () => {
-      tree.unmount();
-      await flushPromises();
-    });
-  });
-
-  it("restores portrait-up on unmount when no exit lock is configured", async () => {
-    const tree = await mountHost({ orientation: "Landscape" });
-    mockedLockAsync.mockClear();
-
-    await act(async () => {
-      tree.unmount();
-      await flushPromises();
-    });
-
-    expect(mockedLockAsync).toHaveBeenCalledTimes(1);
-    expect(mockedLockAsync).toHaveBeenCalledWith(
-      ScreenOrientation.OrientationLock.PORTRAIT_UP,
-    );
-  });
-
-  it("applies the configured exit lock on unmount instead of portrait-up", async () => {
-    const tree = await mountHost({
-      orientation: "Landscape",
-      exitLock: ScreenOrientation.OrientationLock.DEFAULT,
-    });
-    mockedLockAsync.mockClear();
-
-    await act(async () => {
-      tree.unmount();
-      await flushPromises();
-    });
-
-    expect(mockedLockAsync).toHaveBeenCalledTimes(1);
-    expect(mockedLockAsync).toHaveBeenCalledWith(
-      ScreenOrientation.OrientationLock.DEFAULT,
-    );
-    expect(mockedLockAsync).not.toHaveBeenCalledWith(
-      ScreenOrientation.OrientationLock.PORTRAIT_UP,
-    );
-  });
-
-  it("warns and reports once when the host build cannot honour the lock", async () => {
-    // Pins the reporting contract for any build where the platform declares
-    // the lock unsupported (lockAsync would resolve without rotating).
-    globalWithDev.__DEV__ = true;
-    mockedSupportsLock.mockResolvedValue(false);
-    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
-    const captureException = vi
-      .spyOn(UseSmileIDCrashReporting, "captureException")
-      .mockImplementation(() => {});
-
-    const tree = await mountHost({ orientation: "Landscape" });
-
-    expect(captureException).toHaveBeenCalledTimes(1);
-    expect(warn).toHaveBeenCalledTimes(1);
-    expect(warn.mock.calls[0]?.[0]).toContain("orientation");
-
-    await act(async () => {
-      tree.unmount();
-      await flushPromises();
-    });
-  });
-
-  it("reports without warning when __DEV__ is absent (production build)", async () => {
-    mockedSupportsLock.mockResolvedValue(false);
-    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
-    const captureException = vi
-      .spyOn(UseSmileIDCrashReporting, "captureException")
-      .mockImplementation(() => {});
-
-    const tree = await mountHost({ orientation: "Landscape" });
-
-    expect(captureException).toHaveBeenCalledTimes(1);
-    expect(warn).not.toHaveBeenCalled();
-
-    await act(async () => {
-      tree.unmount();
-      await flushPromises();
-    });
-  });
-
-  it("warns once across capture-screen remounts for the same target", async () => {
-    globalWithDev.__DEV__ = true;
-    mockedSupportsLock.mockResolvedValue(false);
-    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
-    const captureException = vi
-      .spyOn(UseSmileIDCrashReporting, "captureException")
-      .mockImplementation(() => {});
-
-    const first = await mountHost({ orientation: "Landscape" });
-    await act(async () => {
-      first.unmount();
-      await flushPromises();
-    });
-    const second = await mountHost({ orientation: "Landscape" });
-
-    expect(warn).toHaveBeenCalledTimes(1);
-    expect(captureException).toHaveBeenCalledTimes(2);
-
-    await act(async () => {
-      second.unmount();
-      await flushPromises();
-    });
-  });
-
-  it("stays silent when the host build permits the lock", async () => {
-    globalWithDev.__DEV__ = true;
-    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
-    const captureException = vi
-      .spyOn(UseSmileIDCrashReporting, "captureException")
-      .mockImplementation(() => {});
-
-    const tree = await mountHost({ orientation: "Portrait" });
-
-    expect(captureException).not.toHaveBeenCalled();
-    expect(warn).not.toHaveBeenCalled();
-
-    await act(async () => {
-      tree.unmount();
-      await flushPromises();
-    });
-  });
-});

package/src/presentation/screen/helpers/capture_screen_helpers.ts

@@ -1,153 +0,0 @@
-import { UseSmileIDOverlayState } from "../../state/use_smile_id_overlay_state";
-import type { UseSmileIDOverlayState as OverlayState } from "../../state/use_smile_id_overlay_state";
-import type { UseSmileIDLocalizations } from "../../../l10n/use_smile_id_localizations";
-import type { SiKey } from "../../../l10n/strings_en";
-
-/**
- * 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: OverlayState): SiKey | null {
-  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: OverlayState): SiKey | null {
-  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: Partial<
-  Record<SiKey, (loc: UseSmileIDLocalizations) => string>
-> = {
-  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_capture_camera_unavailable: (loc) => loc.siCaptureCameraUnavailable,
-  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: SiKey,
-  loc: UseSmileIDLocalizations,
-): string {
-  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: OverlayState,
-  loc: UseSmileIDLocalizations,
-): string {
-  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: OverlayState): boolean {
-  return state === UseSmileIDOverlayState.INSTRUCTION;
-}

package/src/presentation/screen/helpers/capture_ui_state.ts

@@ -1,298 +0,0 @@
-import type {
-  ScanHeadTurnDirection,
-  UseSmileIDScanState,
-} from "@smileid/usesmileid_bridge";
-import { UseSmileIDScanStateType } from "@smileid/usesmileid_bridge";
-import { CaptureType } from "../../../core/models/ml_config";
-import { UseSmileIDOverlayState } from "../../state/use_smile_id_overlay_state";
-import type { SiKey } from "../../../l10n/strings_en";
-import { mapScanStateToOverlayState } from "./scan_state_to_overlay_state";
-import {
-  documentFeedbackKeyFor,
-  selfieFeedbackKeyFor,
-} from "./capture_screen_helpers";
-
-/** Immutable per-frame UI snapshot derived from the native `UseSmileIDScanState`. */
-export type UseSmileIDCaptureUiState = {
-  readonly overlayState: UseSmileIDOverlayState;
-  /** Stable si_* key behind the guidance copy and the coaching-animation lookup. */
-  readonly feedbackKey: SiKey;
-  /** 0..1 oval fill; always 0 under Enhanced Smart Selfie. */
-  readonly captureProgress: number;
-  /** Active ESS head-turn direction, null outside a turn. */
-  readonly animationDirection: ScanHeadTurnDirection | null;
-  /**
-   * `true` while the head pose holds the current ESS direction — drives
-   * the grey→green direction arrow. Always `false` outside a head turn.
-   */
-  readonly poseMatched: boolean;
-};
-
-function uiState(
-  overlayState: UseSmileIDOverlayState,
-  feedbackKey: SiKey,
-  captureProgress: number,
-): UseSmileIDCaptureUiState {
-  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: readonly SiKey[] = [
-  "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: string | undefined): SiKey | null {
-  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: UseSmileIDCaptureUiState,
-  enableEnhancedLiveness: boolean,
-): UseSmileIDCaptureUiState {
-  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: boolean,
-): UseSmileIDCaptureUiState {
-  return withEnhancedLivenessPolicy(
-    uiState(UseSmileIDOverlayState.PROCESSING, "si_selfie_capture_complete", 1),
-    enableEnhancedLiveness,
-  );
-}
-
-/** Terminal snapshot for a completed document scan. */
-export function scannedDocumentUiState(): UseSmileIDCaptureUiState {
-  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: CaptureType,
-  enableEnhancedLiveness: boolean,
-): UseSmileIDCaptureUiState {
-  // Selfie flows (including ESS) show the press-Start copy here; the
-  // ESS primer belongs to the scanning Initial state.
-  const feedbackKey: SiKey =
-    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: UseSmileIDScanState,
-  next: UseSmileIDScanState,
-): boolean {
-  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: UseSmileIDScanState,
-  captureType: CaptureType,
-  enableEnhancedLiveness: boolean,
-): UseSmileIDCaptureUiState {
-  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: UseSmileIDScanState,
-  enableEnhancedLiveness: boolean,
-): UseSmileIDCaptureUiState {
-  return withEnhancedLivenessPolicy(
-    selfieUiState(scanState, enableEnhancedLiveness),
-    enableEnhancedLiveness,
-  );
-}
-
-function selfieUiState(
-  scanState: UseSmileIDScanState,
-  enableEnhancedLiveness: boolean,
-): UseSmileIDCaptureUiState {
-  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: SiKey =
-        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: UseSmileIDScanState,
-): UseSmileIDCaptureUiState {
-  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,
-      );
-  }
-}