@smileid/usesmileid 12.0.0 → 12.0.2

package/src/presentation/screen/__tests__/feedback_copy_table.test.ts

@@ -0,0 +1,145 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  documentFeedbackKeyFor,
+  resolveFeedbackCopy,
+  selfieFeedbackKeyFor,
+} from "../helpers/capture_screen_helpers";
+import { UseSmileIDOverlayState } from "../../state/use_smile_id_overlay_state";
+import { UseSmileIDLocalizations } from "../../../l10n/use_smile_id_localizations";
+import { enStrings, type SiKey } from "../../../l10n/strings_en";
+
+/**
+ * The feedback-key → copy table is the single seam between the capture
+ * overlay's stable `si_*` keys and the partner's localization instance.
+ * Every entry must resolve to the canonical English default and must
+ * honour a partner override, otherwise a translated build silently
+ * shows English (or the wrong string) mid-capture.
+ */
+
+const loc = new UseSmileIDLocalizations({});
+
+// Every key the capture surface can emit as feedback.
+const FEEDBACK_KEYS: readonly SiKey[] = [
+  "si_capture_initial_instruction",
+  "si_start_capture_instruction",
+  "si_capture_too_close",
+  "si_capture_too_far",
+  "si_capture_center_face",
+  "si_capture_multiple_faces",
+  "si_capture_low_light",
+  "si_capture_bright_light",
+  "si_capture_rotate_device",
+  "si_capture_smile",
+  "si_capture_move_left",
+  "si_capture_move_right",
+  "si_capture_move_higher",
+  "si_capture_move_lower",
+  "si_capture_ready",
+  "si_capture_hold_steady",
+  "si_capture_timeout",
+  "si_capturing",
+  "si_selfie_capture_complete",
+  "si_selfie_capture_timeout",
+  "si_selfie_capture_unsatisfied",
+  "si_ess_capture_initial_instruction",
+  "si_ess_hold_still",
+  "si_ess_look_left",
+  "si_ess_look_right",
+  "si_ess_look_up",
+  "si_ess_look_at_camera",
+  "si_document_initial_instruction",
+  "si_document_ready",
+  "si_document_capturing",
+  "si_document_capture_complete",
+  "si_document_capture_unsatisfied",
+  "si_document_capture_timeout",
+  "si_document_too_close",
+  "si_document_too_far",
+  "si_document_center",
+  "si_document_hold_still",
+  "si_document_gallery_image_too_small",
+  "si_document_gallery_image_failed",
+];
+
+describe("resolveFeedbackCopy", () => {
+  for (const key of FEEDBACK_KEYS) {
+    it(`resolves ${key} to its canonical English default`, () => {
+      expect(resolveFeedbackCopy(key, loc)).toBe(enStrings[key]);
+    });
+  }
+
+  it("honours a partner override for every feedback key", () => {
+    const overrides = Object.fromEntries(
+      FEEDBACK_KEYS.map((key) => [key, `translated:${key}`]),
+    );
+    const translated = new UseSmileIDLocalizations(overrides);
+
+    for (const key of FEEDBACK_KEYS) {
+      expect(resolveFeedbackCopy(key, translated)).toBe(`translated:${key}`);
+    }
+  });
+
+  it("falls back to the initial instruction for a key outside the table", () => {
+    // `si_consent_title` is a real key that the capture surface never emits.
+    expect(resolveFeedbackCopy("si_consent_title" as SiKey, loc)).toBe(
+      loc.siCaptureInitialInstruction,
+    );
+  });
+});
+
+describe("documentFeedbackKeyFor", () => {
+  it("maps each document guidance state to its stable key", () => {
+    expect(
+      documentFeedbackKeyFor(UseSmileIDOverlayState.DOCUMENT_TOO_CLOSE),
+    ).toBe("si_document_too_close");
+    expect(
+      documentFeedbackKeyFor(UseSmileIDOverlayState.DOCUMENT_TOO_FAR),
+    ).toBe("si_document_too_far");
+    expect(
+      documentFeedbackKeyFor(UseSmileIDOverlayState.DOCUMENT_NOT_CENTERED),
+    ).toBe("si_document_center");
+    expect(
+      documentFeedbackKeyFor(UseSmileIDOverlayState.DOCUMENT_HOLD_STILL),
+    ).toBe("si_document_hold_still");
+  });
+
+  it("returns null for lifecycle states that carry no guidance", () => {
+    expect(
+      documentFeedbackKeyFor(UseSmileIDOverlayState.INSTRUCTION),
+    ).toBeNull();
+    expect(
+      documentFeedbackKeyFor(UseSmileIDOverlayState.DOCUMENT_READY),
+    ).toBeNull();
+    expect(documentFeedbackKeyFor(UseSmileIDOverlayState.CAPTURING)).toBeNull();
+    // A selfie-only guidance state must not leak into the document table.
+    expect(documentFeedbackKeyFor(UseSmileIDOverlayState.TOO_CLOSE)).toBeNull();
+  });
+
+  it("resolves every document key it emits through the copy table", () => {
+    const states = [
+      UseSmileIDOverlayState.DOCUMENT_TOO_CLOSE,
+      UseSmileIDOverlayState.DOCUMENT_TOO_FAR,
+      UseSmileIDOverlayState.DOCUMENT_NOT_CENTERED,
+      UseSmileIDOverlayState.DOCUMENT_HOLD_STILL,
+    ];
+    for (const state of states) {
+      const key = documentFeedbackKeyFor(state);
+      expect(key).not.toBeNull();
+      expect(resolveFeedbackCopy(key as SiKey, loc)).toBe(
+        enStrings[key as SiKey],
+      );
+    }
+  });
+});
+
+describe("selfieFeedbackKeyFor", () => {
+  it("returns null for the document-only states", () => {
+    expect(
+      selfieFeedbackKeyFor(UseSmileIDOverlayState.DOCUMENT_TOO_CLOSE),
+    ).toBeNull();
+    expect(
+      selfieFeedbackKeyFor(UseSmileIDOverlayState.DOCUMENT_HOLD_STILL),
+    ).toBeNull();
+  });
+});

package/src/presentation/screen/__tests__/scan_state_to_overlay_state.test.ts

@@ -1,13 +1,13 @@
 import { describe, expect, it } from "vitest";
-import { ScanStateType } from "@smileid/usesmileid_bridge";
-import type { ScanState } from "@smileid/usesmileid_bridge";
+import { UseSmileIDScanStateType } from "@smileid/usesmileid_bridge";
+import type { UseSmileIDScanState } from "@smileid/usesmileid_bridge";
 import { mapScanStateToOverlayState } from "../helpers/scan_state_to_overlay_state";
 import { UseSmileIDOverlayState } from "../../state/use_smile_id_overlay_state";
 import { CaptureType } from "../../../core/models/ml_config";
 
 /**
  * Pure-logic tests for the helper that translates the analyzer's
- * `ScanState` machine into the SDK's visual overlay enum. These cover
+ * `UseSmileIDScanState` machine into the SDK's visual overlay enum. These cover
  * what the legacy screen tests pinned via the now-removed
  * `overlayState=` prop — the screen now derives overlay state from
  * `scanState` per frame, so testing the mapping in isolation gives the
@@ -15,14 +15,18 @@ import { CaptureType } from "../../../core/models/ml_config";
  */
 describe("mapScanStateToOverlayState", () => {
   it("maps the initial state to INSTRUCTION for selfie", () => {
-    const state: ScanState = { type: ScanStateType.Initial };
+    const state: UseSmileIDScanState = {
+      type: UseSmileIDScanStateType.Initial,
+    };
     expect(mapScanStateToOverlayState(state, CaptureType.selfie)).toBe(
       UseSmileIDOverlayState.INSTRUCTION,
     );
   });
 
   it("maps the initial state to INSTRUCTION for document", () => {
-    const state: ScanState = { type: ScanStateType.Initial };
+    const state: UseSmileIDScanState = {
+      type: UseSmileIDScanStateType.Initial,
+    };
     expect(mapScanStateToOverlayState(state, CaptureType.document)).toBe(
       UseSmileIDOverlayState.INSTRUCTION,
     );
@@ -32,7 +36,9 @@ describe("mapScanStateToOverlayState", () => {
     // READY drives the bottom-to-top fill animation on the face oval —
     // the analyzer signalling "satisfied" means the pipeline is about
     // to emit captured frames.
-    const state: ScanState = { type: ScanStateType.Satisfied };
+    const state: UseSmileIDScanState = {
+      type: UseSmileIDScanStateType.Satisfied,
+    };
     expect(mapScanStateToOverlayState(state, CaptureType.selfie)).toBe(
       UseSmileIDOverlayState.READY,
     );
@@ -42,21 +48,27 @@ describe("mapScanStateToOverlayState", () => {
     // CAPTURING is the yellow-solid state — the analyzer has emitted
     // its captured artifacts and the orchestrator is about to call
     // flush().
-    const state: ScanState = { type: ScanStateType.Finished };
+    const state: UseSmileIDScanState = {
+      type: UseSmileIDScanStateType.Finished,
+    };
     expect(mapScanStateToOverlayState(state, CaptureType.selfie)).toBe(
       UseSmileIDOverlayState.CAPTURING,
     );
   });
 
   it("maps the headTurn state to HEAD_TURN", () => {
-    const state: ScanState = { type: ScanStateType.HeadTurn };
+    const state: UseSmileIDScanState = {
+      type: UseSmileIDScanStateType.HeadTurn,
+    };
     expect(mapScanStateToOverlayState(state, CaptureType.selfie)).toBe(
       UseSmileIDOverlayState.HEAD_TURN,
     );
   });
 
   it("maps timeout back to IDLE so the overlay returns to the gray pre-capture state", () => {
-    const state: ScanState = { type: ScanStateType.Timeout };
+    const state: UseSmileIDScanState = {
+      type: UseSmileIDScanStateType.Timeout,
+    };
     expect(mapScanStateToOverlayState(state, CaptureType.selfie)).toBe(
       UseSmileIDOverlayState.IDLE,
     );
@@ -87,8 +99,8 @@ describe("mapScanStateToOverlayState", () => {
 
     for (const [feedbackKey, expected] of cases) {
       it(`maps found+${feedbackKey} to ${expected}`, () => {
-        const state: ScanState = {
-          type: ScanStateType.Found,
+        const state: UseSmileIDScanState = {
+          type: UseSmileIDScanStateType.Found,
           feedback: feedbackKey,
         };
         expect(mapScanStateToOverlayState(state, CaptureType.selfie)).toBe(
@@ -98,7 +110,9 @@ describe("mapScanStateToOverlayState", () => {
     }
 
     it("falls back to FACE_DETECTED when found has no feedback key", () => {
-      const state: ScanState = { type: ScanStateType.Found };
+      const state: UseSmileIDScanState = {
+        type: UseSmileIDScanStateType.Found,
+      };
       expect(mapScanStateToOverlayState(state, CaptureType.selfie)).toBe(
         UseSmileIDOverlayState.FACE_DETECTED,
       );
@@ -109,8 +123,8 @@ describe("mapScanStateToOverlayState", () => {
       // si_capture_* key the JS side hasn't been updated for. The
       // overlay should stay alive (green-solid) rather than throwing
       // or rendering an empty state.
-      const state: ScanState = {
-        type: ScanStateType.Found,
+      const state: UseSmileIDScanState = {
+        type: UseSmileIDScanStateType.Found,
         feedback: "si_capture_future_feedback_key",
       };
       expect(mapScanStateToOverlayState(state, CaptureType.selfie)).toBe(
@@ -121,8 +135,8 @@ describe("mapScanStateToOverlayState", () => {
 
   describe("unsatisfied + reason (selfie)", () => {
     it("uses the reason key to drive the orange-solid overlay", () => {
-      const state: ScanState = {
-        type: ScanStateType.Unsatisfied,
+      const state: UseSmileIDScanState = {
+        type: UseSmileIDScanStateType.Unsatisfied,
         reason: "si_capture_too_close",
       };
       expect(mapScanStateToOverlayState(state, CaptureType.selfie)).toBe(
@@ -131,7 +145,9 @@ describe("mapScanStateToOverlayState", () => {
     });
 
     it("falls back to FACE_NOT_CENTERED on a missing reason key", () => {
-      const state: ScanState = { type: ScanStateType.Unsatisfied };
+      const state: UseSmileIDScanState = {
+        type: UseSmileIDScanStateType.Unsatisfied,
+      };
       expect(mapScanStateToOverlayState(state, CaptureType.selfie)).toBe(
         UseSmileIDOverlayState.FACE_NOT_CENTERED,
       );
@@ -140,15 +156,17 @@ describe("mapScanStateToOverlayState", () => {
 
   describe("document capture mappings", () => {
     it("maps found+document key to DOCUMENT_READY by default", () => {
-      const state: ScanState = { type: ScanStateType.Found };
+      const state: UseSmileIDScanState = {
+        type: UseSmileIDScanStateType.Found,
+      };
       expect(mapScanStateToOverlayState(state, CaptureType.document)).toBe(
         UseSmileIDOverlayState.DOCUMENT_READY,
       );
     });
 
     it("maps the si_document_too_close key to DOCUMENT_TOO_CLOSE", () => {
-      const state: ScanState = {
-        type: ScanStateType.Found,
+      const state: UseSmileIDScanState = {
+        type: UseSmileIDScanStateType.Found,
         feedback: "si_document_too_close",
       };
       expect(mapScanStateToOverlayState(state, CaptureType.document)).toBe(
@@ -161,8 +179,8 @@ describe("mapScanStateToOverlayState", () => {
       // si_document_* key or the shared si_capture_* one. Map both
       // to the document overlay enum so the bottom-feedback bubble
       // stays accurate either way.
-      const state: ScanState = {
-        type: ScanStateType.Found,
+      const state: UseSmileIDScanState = {
+        type: UseSmileIDScanStateType.Found,
         feedback: "si_capture_too_close",
       };
       expect(mapScanStateToOverlayState(state, CaptureType.document)).toBe(
@@ -171,15 +189,17 @@ describe("mapScanStateToOverlayState", () => {
     });
 
     it("maps unsatisfied+missing reason to DOCUMENT_NOT_CENTERED", () => {
-      const state: ScanState = { type: ScanStateType.Unsatisfied };
+      const state: UseSmileIDScanState = {
+        type: UseSmileIDScanStateType.Unsatisfied,
+      };
       expect(mapScanStateToOverlayState(state, CaptureType.document)).toBe(
         UseSmileIDOverlayState.DOCUMENT_NOT_CENTERED,
       );
     });
 
     it("maps si_document_hold_still to DOCUMENT_HOLD_STILL", () => {
-      const state: ScanState = {
-        type: ScanStateType.Found,
+      const state: UseSmileIDScanState = {
+        type: UseSmileIDScanStateType.Found,
         feedback: "si_document_hold_still",
       };
       expect(mapScanStateToOverlayState(state, CaptureType.document)).toBe(
@@ -191,8 +211,8 @@ describe("mapScanStateToOverlayState", () => {
       // `si_document_center` is the key the native side actually emits
       // for an off-centre document (the former `si_document_not_centered`
       // was never emitted).
-      const state: ScanState = {
-        type: ScanStateType.Found,
+      const state: UseSmileIDScanState = {
+        type: UseSmileIDScanStateType.Found,
         feedback: "si_document_center",
       };
       expect(mapScanStateToOverlayState(state, CaptureType.document)).toBe(