@smileid/usesmileid 12.0.0 → 12.0.1

package/src/presentation/screen/__tests__/use_smile_id_capture_screen.test.tsx

@@ -11,19 +11,37 @@ import * as Brightness from "expo-brightness";
 import { StatusBar } from "react-native";
 import { UseSmileIDCaptureScreen } from "../use_smile_id_capture_screen";
 import { CaptureType } from "../../../core/models/ml_config";
+import { DocumentCaptureMode } from "../../../core/models/document_capture_mode";
+import { mockedTakePhoto } from "../../../__tests__/setup_react_native";
 import { enStrings } from "../../../l10n/strings_en";
 import {
-  ScanStateType,
+  UseSmileIDScanStateType,
   CaptureReadyEventKind,
 } from "@smileid/usesmileid_bridge";
 import type {
-  ScanState,
+  UseSmileIDScanState,
   CaptureReadyEvent,
   FaceScanResult,
 } from "@smileid/usesmileid_bridge";
+import { scriptedFaceScanResults } from "../../../testing/scripted_scan_results";
+import { parseScriptedScenario } from "../../../testing/scenario_loader";
 import { isSessionBoundary } from "../helpers/capture_ui_state";
 import { UseSmileIDFeedbackDebouncer } from "../helpers/feedback_debouncer";
 import { UseSmileIDMotion } from "../../theme/use_smile_id_motion";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+// The shared scenario set lives at the repo root (e2e/scenarios/), outside this
+// package's tsc rootDir (./src), so the test reads selfie-happy-path.json at run
+// time. These minimal ambient decls keep the read typed without pulling
+// @types/node in (which would collide with react-native's global timer types).
+declare module "node:fs" {
+  export function readFileSync(path: string, encoding: "utf8"): string;
+}
+declare module "node:path" {
+  export function dirname(path: string): string;
+  export function join(...parts: string[]): string;
+}
 
 // Capture the screen's per-frame `onResult` so tests can drive synthetic
 // sequences — the vision-camera worklet can't run in vitest, and `onResult`
@@ -195,6 +213,18 @@ describe("UseSmileIDCaptureScreen", () => {
     expect(mockedUseCameraDevice).toHaveBeenCalledWith("back");
   });
 
+  it("uses the back lens for an agent-mode selfie capture", () => {
+    const { root } = render(
+      <UseSmileIDCaptureScreen
+        analyzer={fakeAnalyzer}
+        captureType={CaptureType.selfie}
+        allowAgentMode
+      />,
+    );
+    expect(findByTestID(root, "si_capture_camera_preview")).not.toBeNull();
+    expect(mockedUseCameraDevice).toHaveBeenCalledWith("back");
+  });
+
   it("shows a placeholder (not the camera) when permission is undetermined", () => {
     const requestPermission = vi.fn(async () => true);
     mockedUseCameraPermission.mockReturnValue({
@@ -278,9 +308,9 @@ describe("UseSmileIDCaptureScreen", () => {
   // NOTE: the legacy `overlayState` / `captureProgress` prop-driven tests
   // were removed in Phase 3 of the per-frame migration. The capture
   // screen now owns its overlay state internally (derived from the
-  // analyzer's per-frame ScanState), so there's no external prop to
+  // analyzer's per-frame UseSmileIDScanState), so there's no external prop to
   // pin against. Phase 4 follow-up re-authors these as analyzer-driven
-  // tests that feed synthetic ScanState transitions through a mock
+  // tests that feed synthetic UseSmileIDScanState transitions through a mock
   // analyzer + frame stream.
 
   it("forwards the back tap to onBack when the back button is supplied", () => {
@@ -331,7 +361,7 @@ describe("UseSmileIDCaptureScreen", () => {
   });
 
   // Removed in Phase 3 — feedback text is now driven by the analyzer's
-  // ScanState rather than a partner-supplied overlayState prop. Phase 4
+  // UseSmileIDScanState rather than a partner-supplied overlayState prop. Phase 4
   // re-authors this against a mock analyzer that yields a synthetic
   // "found + feedback=si_capture_low_light" result through the
   // frame stream.
@@ -507,22 +537,22 @@ describe("UseSmileIDCaptureScreen", () => {
     // Stale events → unsatisfied reset (drops them) → fresh events → finished.
     emit({
       output,
-      state: { type: ScanStateType.Found },
+      state: { type: UseSmileIDScanStateType.Found },
       capturedEvents: [staleSelfie, staleLiveness],
     });
     emit({
       output,
-      state: { type: ScanStateType.Unsatisfied },
+      state: { type: UseSmileIDScanStateType.Unsatisfied },
       capturedEvents: [],
     });
     emit({
       output,
-      state: { type: ScanStateType.Found },
+      state: { type: UseSmileIDScanStateType.Found },
       capturedEvents: [freshSelfie, freshLiveness],
     });
     emit({
       output,
-      state: { type: ScanStateType.Finished },
+      state: { type: UseSmileIDScanStateType.Finished },
       capturedEvents: [],
     });
 
@@ -541,6 +571,58 @@ describe("UseSmileIDCaptureScreen", () => {
       expect.objectContaining({ retries: 1 }),
     );
   });
+
+  it("replays the shared selfie scenario to a full capture completion", async () => {
+    // Drives the capture gap headlessly through the frame stream's onResult
+    // seam: the shared scenario replayed to `finished` must reach
+    // onCaptureComplete with the scripted selfie + liveness events.
+    const onCaptureComplete = vi.fn();
+    const analyzer = makeFakeAnalyzer();
+    capturedOnResult = null;
+    render(
+      <UseSmileIDCaptureScreen
+        analyzer={analyzer}
+        captureType={CaptureType.selfie}
+        onCaptureComplete={onCaptureComplete}
+      />,
+    );
+    expect(capturedOnResult).not.toBeNull();
+
+    // Consume the real shared scenario (not a hand-written copy) so a drift in
+    // the canonical script is caught here rather than silently diverging.
+    const scenarioDir = dirname(import.meta.url.replace(/^file:\/\//, ""));
+    const scenario = parseScriptedScenario(
+      JSON.parse(
+        readFileSync(
+          join(
+            scenarioDir,
+            "../../../../../e2e/scenarios/selfie-happy-path.json",
+          ),
+          "utf8",
+        ),
+      ),
+    );
+    for (const result of scriptedFaceScanResults(scenario, {
+      livenessCount: 2,
+    })) {
+      act(() => {
+        capturedOnResult!(result);
+      });
+    }
+    await act(async () => {
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+
+    expect(onCaptureComplete).toHaveBeenCalledTimes(1);
+    const events = onCaptureComplete.mock.calls[0][0] as CaptureReadyEvent[];
+    expect(
+      events.filter((e) => e.kind === CaptureReadyEventKind.Selfie),
+    ).toHaveLength(1);
+    expect(
+      events.filter((e) => e.kind === CaptureReadyEventKind.Liveness),
+    ).toHaveLength(2);
+  });
 });
 
 /**
@@ -566,9 +648,9 @@ describe("session-boundary epoch reset — debouncer regression", () => {
       isImmediate: () => false,
     });
 
-    let previousScanState: ScanState | null = null;
+    let previousScanState: UseSmileIDScanState | null = null;
     const processTransition = (
-      nextScanState: ScanState,
+      nextScanState: UseSmileIDScanState,
       nextFeedbackKey: string,
     ) => {
       const boundary =
@@ -585,7 +667,7 @@ describe("session-boundary epoch reset — debouncer regression", () => {
 
     // found — smile key settles after the debounce window.
     processTransition(
-      { type: ScanStateType.Found, feedback: "si_capture_smile" },
+      { type: UseSmileIDScanStateType.Found, feedback: "si_capture_smile" },
       "si_capture_smile",
     );
     vi.advanceTimersByTime(UseSmileIDMotion.feedbackDebounce);
@@ -593,7 +675,7 @@ describe("session-boundary epoch reset — debouncer regression", () => {
 
     // Entering unsatisfied is not a boundary — no reset.
     processTransition(
-      { type: ScanStateType.Unsatisfied },
+      { type: UseSmileIDScanStateType.Unsatisfied },
       "si_selfie_capture_unsatisfied",
     );
     vi.advanceTimersByTime(UseSmileIDMotion.feedbackDebounce);
@@ -605,7 +687,7 @@ describe("session-boundary epoch reset — debouncer regression", () => {
     // Leaving unsatisfied is a boundary — without the reset the repeated
     // smile key would be suppressed as a duplicate.
     processTransition(
-      { type: ScanStateType.Found, feedback: "si_capture_smile" },
+      { type: UseSmileIDScanStateType.Found, feedback: "si_capture_smile" },
       "si_capture_smile",
     );
     // seed() emits synchronously; no timer advance needed.
@@ -615,4 +697,84 @@ describe("session-boundary epoch reset — debouncer regression", () => {
       "si_capture_smile",
     ]);
   });
+
+  // Document capture has no Start button, so a scan timeout has to leave the
+  // user a way forward — the sibling SDKs surface the manual shutter as the
+  // recovery affordance (their shared scan state sets `showCaptureButton` on
+  // the timeout state). Without these, a timed-out flow is a dead end: only
+  // Back and ✕ remain.
+  describe("document capture timeout recovery", () => {
+    function renderDocumentScreen(props: {
+      readonly captureMode: ReturnType<typeof DocumentCaptureMode.AutoCapture>;
+      readonly allowGalleryUpload?: boolean;
+    }) {
+      const tree = render(
+        <UseSmileIDCaptureScreen
+          analyzer={fakeAnalyzer}
+          captureType={CaptureType.document}
+          captureMode={props.captureMode}
+          allowGalleryUpload={props.allowGalleryUpload ?? true}
+        />,
+      );
+      // The overlay and its controls only mount once the canvas is measured;
+      // `onLayout` never fires under the test renderer, so drive it (landscape,
+      // as a document capture screen is).
+      act(() => {
+        findByTestID(tree.root, "si_capture_screen")!.props.onLayout({
+          nativeEvent: { layout: { width: 800, height: 400 } },
+        });
+      });
+      return tree;
+    }
+
+    function emitTimeout() {
+      expect(capturedOnResult).not.toBeNull();
+      act(() => {
+        capturedOnResult!({
+          output: { faces: [], brightness: 0 },
+          state: { type: UseSmileIDScanStateType.Timeout },
+          capturedEvents: [],
+        });
+      });
+    }
+
+    it("offers the manual shutter after a timeout, in every capture mode", () => {
+      const { root } = renderDocumentScreen({
+        captureMode: DocumentCaptureMode.AutoCapture,
+      });
+
+      emitTimeout();
+
+      expect(findByTestID(root, "si_document_manual_shutter")).not.toBeNull();
+    });
+
+    it("keeps the gallery button available after a timeout", () => {
+      const { root } = renderDocumentScreen({
+        captureMode: DocumentCaptureMode.AutoCaptureWithManualFallback({
+          activateManualAfterMs: 3000,
+        }),
+      });
+
+      emitTimeout();
+
+      expect(findByTestID(root, "si_document_gallery_upload")).not.toBeNull();
+    });
+
+    it("leaves the manual shutter usable after a timeout", () => {
+      const { root } = renderDocumentScreen({
+        captureMode: DocumentCaptureMode.ManualCapture,
+      });
+
+      emitTimeout();
+
+      const shutter = findByTestID(root, "si_document_manual_shutter");
+      expect(shutter).not.toBeNull();
+      // The timeout must not latch the one-shot delivery gate, or the button
+      // renders but does nothing.
+      act(() => {
+        shutter!.props.onPress();
+      });
+      expect(mockedTakePhoto).toHaveBeenCalledTimes(1);
+    });
+  });
 });

package/src/presentation/screen/__tests__/use_smile_id_document_back_instructions.test.tsx

@@ -104,7 +104,7 @@ describe("UseSmileIDDocumentBackInstructions", () => {
     const skip = findByTestID(root, "si_document_skip_back_button");
     expect(skip).not.toBeNull();
     act(() => {
-      (skip!.props.onPress as () => void)();
+      (skip!.props.onClick as () => void)();
     });
     expect(onSkip).toHaveBeenCalledTimes(1);
   });

package/src/presentation/screen/__tests__/use_smile_id_preview_screen.test.tsx

@@ -5,7 +5,7 @@ import {
   act,
   type ReactTestInstance,
 } from "react-test-renderer";
-import { I18nManager, Pressable, StyleSheet, Text } from "react-native";
+import { I18nManager, StyleSheet, Text } from "react-native";
 import { UseSmileIDPreviewScreen } from "../use_smile_id_preview_screen";
 import { defaultLightTheme } from "../../theme/theme";
 
@@ -14,7 +14,7 @@ import { defaultLightTheme } from "../../theme/theme";
  *   - Image at the oval rect (not full-bleed)
  *   - Title + confirmation buttons + optional attribution in card
  *   - Accept / Retake gating from `resolvePreviewState`
- *   - Slot contract (any slot replaces the entire row)
+ *   - The confirm/retake pair is fixed (not customisable)
  */
 
 function render(element: React.ReactElement) {
@@ -164,46 +164,16 @@ describe("UseSmileIDPreviewScreen", () => {
     }
   });
 
-  it("replaces the entire row when any button slot is supplied", () => {
-    // Concrete scenario this test documents: the slot contract is
-    // "all-or-nothing" — providing only continueButton hides the
-    // default Retake. Partners must supply both slots to keep both
-    // affordances.
-    const onAccept = vi.fn();
-    const onReject = vi.fn();
+  it("always renders the fixed confirmation-button pair (not customisable)", () => {
+    // Preview buttons are intentionally not customisable: the screen always
+    // renders the fixed confirm/retake pair. Re-adding a slot API is a product
+    // decision, not a bug fix.
     const { root } = render(
-      <UseSmileIDPreviewScreen
-        capturedSelfiePath={PATH}
-        onAccept={onAccept}
-        onReject={onReject}
-        continueButton={({ onClick }) => (
-          <Pressable testID="si_custom_continue" onPress={onClick}>
-            <Text>Confirm</Text>
-          </Pressable>
-        )}
-        cancelButton={({ onClick }) => (
-          <Pressable testID="si_custom_cancel" onPress={onClick}>
-            <Text>Retake</Text>
-          </Pressable>
-        )}
-      />,
+      <UseSmileIDPreviewScreen capturedSelfiePath={PATH} />,
     );
-
-    expect(findByTestID(root, "si_custom_continue")).not.toBeNull();
-    expect(findByTestID(root, "si_custom_cancel")).not.toBeNull();
-    // Default row must be gone — guards against a future refactor
-    // that double-renders the row alongside the slots.
-    expect(findByTestID(root, "si_preview_confirmation_buttons")).toBeNull();
-
-    act(() => {
-      (findByTestID(root, "si_custom_continue")!.props.onPress as () => void)();
-    });
-    expect(onAccept).toHaveBeenCalledTimes(1);
-
-    act(() => {
-      (findByTestID(root, "si_custom_cancel")!.props.onPress as () => void)();
-    });
-    expect(onReject).toHaveBeenCalledTimes(1);
+    expect(
+      findByTestID(root, "si_preview_confirmation_buttons"),
+    ).not.toBeNull();
   });
 
   it("renders the card title in the theme primary color", () => {

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

@@ -0,0 +1,212 @@
+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();
+    });
+  });
+});