@smileid/usesmileid 12.0.2 → 12.1.1

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

@@ -1,82 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import * as Haptics from "expo-haptics";
-import type { UseSmileIDScanState } from "@smileid/usesmileid_bridge";
-import { UseSmileIDScanStateType } from "@smileid/usesmileid_bridge";
-import {
-  essTurnHaptic,
-  triggerEssTurnHaptic,
-} from "../helpers/ess_turn_haptics";
-
-const headTurn = (direction?: "left" | "right" | "up"): UseSmileIDScanState =>
-  direction === undefined
-    ? { type: UseSmileIDScanStateType.HeadTurn }
-    : { type: UseSmileIDScanStateType.HeadTurn, currentDirection: direction };
-
-describe("essTurnHaptic", () => {
-  it("fires intermediate when the requested direction advances", () => {
-    expect(essTurnHaptic(headTurn("left"), headTurn("right"))).toBe(
-      "intermediate",
-    );
-    expect(essTurnHaptic(headTurn("right"), headTurn("up"))).toBe(
-      "intermediate",
-    );
-  });
-
-  it("fires final when leaving the head-turn phase toward capture", () => {
-    for (const next of [
-      UseSmileIDScanStateType.Found,
-      UseSmileIDScanStateType.Satisfied,
-      UseSmileIDScanStateType.Finished,
-    ] as const) {
-      expect(essTurnHaptic(headTurn("up"), { type: next })).toBe("final");
-    }
-  });
-
-  it("never fires on a reset (head turn abandoned to initial / timeout)", () => {
-    expect(
-      essTurnHaptic(headTurn("left"), {
-        type: UseSmileIDScanStateType.Initial,
-      }),
-    ).toBeNull();
-    expect(
-      essTurnHaptic(headTurn("left"), {
-        type: UseSmileIDScanStateType.Timeout,
-      }),
-    ).toBeNull();
-  });
-
-  it("does not fire when the same direction repeats (no completion yet)", () => {
-    expect(essTurnHaptic(headTurn("left"), headTurn("left"))).toBeNull();
-  });
-
-  it("does not fire when the previous state was not a directed head turn", () => {
-    // Entering a head turn is not completing one.
-    expect(
-      essTurnHaptic({ type: UseSmileIDScanStateType.Found }, headTurn("left")),
-    ).toBeNull();
-    // A head turn with no direction yet has nothing to complete.
-    expect(essTurnHaptic(headTurn(), headTurn("left"))).toBeNull();
-  });
-});
-
-describe("triggerEssTurnHaptic", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("plays a light impact between turns", () => {
-    triggerEssTurnHaptic("intermediate");
-    expect(Haptics.impactAsync).toHaveBeenCalledWith(
-      Haptics.ImpactFeedbackStyle.Light,
-    );
-    expect(Haptics.notificationAsync).not.toHaveBeenCalled();
-  });
-
-  it("plays a success notification on the final turn", () => {
-    triggerEssTurnHaptic("final");
-    expect(Haptics.notificationAsync).toHaveBeenCalledWith(
-      Haptics.NotificationFeedbackType.Success,
-    );
-    expect(Haptics.impactAsync).not.toHaveBeenCalled();
-  });
-});

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

@@ -1,145 +0,0 @@
-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__/feedback_debouncer.test.ts

@@ -1,111 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { UseSmileIDFeedbackDebouncer } from "../helpers/feedback_debouncer";
-
-const DELAY = 300;
-
-describe("UseSmileIDFeedbackDebouncer", () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-  });
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  function makeDebouncer(options?: {
-    isImmediate?: (value: string) => boolean;
-    initialValue?: string;
-  }) {
-    const emitted: string[] = [];
-    const debouncer = new UseSmileIDFeedbackDebouncer<string>({
-      emit: (value) => emitted.push(value),
-      delayMs: DELAY,
-      ...(options?.isImmediate ? { isImmediate: options.isImmediate } : {}),
-      ...(options?.initialValue !== undefined
-        ? { initialValue: options.initialValue }
-        : {}),
-    });
-    return { debouncer, emitted };
-  }
-
-  it("fires exactly once for a steady stream of the same value", () => {
-    // Frames republish every 100 ms — faster than the 300 ms window; a
-    // naive trailing debounce would never fire.
-    const { debouncer, emitted } = makeDebouncer();
-    for (let i = 0; i < 10; i++) {
-      debouncer.publish("si_capture_smile");
-      vi.advanceTimersByTime(100);
-    }
-    expect(emitted).toEqual(["si_capture_smile"]);
-    vi.advanceTimersByTime(1000);
-    expect(emitted).toEqual(["si_capture_smile"]);
-  });
-
-  it("settles a changing stream to the latest value", () => {
-    const { debouncer, emitted } = makeDebouncer();
-    debouncer.publish("si_capture_too_close");
-    vi.advanceTimersByTime(100);
-    debouncer.publish("si_capture_too_far");
-    vi.advanceTimersByTime(100);
-    debouncer.publish("si_capture_center_face");
-    expect(emitted).toEqual([]);
-    vi.advanceTimersByTime(DELAY);
-    expect(emitted).toEqual(["si_capture_center_face"]);
-  });
-
-  it("re-publishing the settled value is a no-op", () => {
-    const { debouncer, emitted } = makeDebouncer();
-    debouncer.publish("si_capture_smile");
-    vi.advanceTimersByTime(DELAY);
-    debouncer.publish("si_capture_smile");
-    vi.advanceTimersByTime(DELAY);
-    expect(emitted).toEqual(["si_capture_smile"]);
-  });
-
-  it("treats the initial value as already settled", () => {
-    const { debouncer, emitted } = makeDebouncer({
-      initialValue: "si_capture_initial_instruction",
-    });
-    debouncer.publish("si_capture_initial_instruction");
-    vi.advanceTimersByTime(DELAY);
-    expect(emitted).toEqual([]);
-  });
-
-  it("emits immediate values synchronously, bypassing the window", () => {
-    const { debouncer, emitted } = makeDebouncer({
-      isImmediate: (value) => value === "si_selfie_capture_complete",
-    });
-    debouncer.publish("si_capturing");
-    vi.advanceTimersByTime(100);
-    debouncer.publish("si_selfie_capture_complete");
-    expect(emitted).toEqual(["si_selfie_capture_complete"]);
-    vi.advanceTimersByTime(1000);
-    expect(emitted).toEqual(["si_selfie_capture_complete"]);
-  });
-
-  it("re-emits even a repeated value after reset", () => {
-    const { debouncer, emitted } = makeDebouncer();
-    debouncer.publish("si_capture_smile");
-    vi.advanceTimersByTime(DELAY);
-    debouncer.reset();
-    debouncer.publish("si_capture_smile");
-    vi.advanceTimersByTime(DELAY);
-    expect(emitted).toEqual(["si_capture_smile", "si_capture_smile"]);
-  });
-
-  it("seed emits synchronously and counts as settled", () => {
-    const { debouncer, emitted } = makeDebouncer();
-    debouncer.seed("si_ess_capture_initial_instruction");
-    expect(emitted).toEqual(["si_ess_capture_initial_instruction"]);
-    debouncer.publish("si_ess_capture_initial_instruction");
-    vi.advanceTimersByTime(DELAY);
-    expect(emitted).toEqual(["si_ess_capture_initial_instruction"]);
-  });
-
-  it("dispose cancels the in-flight window without emitting", () => {
-    const { debouncer, emitted } = makeDebouncer();
-    debouncer.publish("si_capture_smile");
-    debouncer.dispose();
-    vi.advanceTimersByTime(1000);
-    expect(emitted).toEqual([]);
-  });
-});

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

@@ -1,154 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { UseSmileIDLocalizations } from "../../../l10n/use_smile_id_localizations";
-import {
-  resolveInstructionsConfig,
-  resolvedHeroAnimation,
-} from "../helpers/instructions_screen_helpers";
-import {
-  DOCUMENT_GREEN_BOOK_HERO_ANIMATION,
-  DOCUMENT_GUIDELINES_GENERIC,
-  DOCUMENT_GUIDELINES_GREEN_BOOK,
-  DOCUMENT_GUIDELINES_PASSPORT,
-  DOCUMENT_HERO_ANIMATION,
-  ESS_HERO_ANIMATION,
-  SELFIE_GUIDELINES,
-  SELFIE_HERO_ANIMATION,
-} from "../../flow/model/instructions_defaults";
-import type { InstructionGuideline } from "../../flow/model/instruction_guideline";
-import { DocumentType } from "../../../core/models/document_type";
-
-const loc = new UseSmileIDLocalizations({});
-// A partner-supplied hero can be a string asset path (a valid HeroAnimationSource).
-const CUSTOM_HERO = "partner-hero.json";
-
-describe("resolveInstructionsConfig", () => {
-  it("falls back to localized defaults and the shared guidelines when unset", () => {
-    const resolved = resolveInstructionsConfig(
-      {},
-      { enhancedLivenessEnabled: false },
-      loc,
-    );
-    expect(resolved.titlePrefix).toBe(loc.siInstructionsTitlePrefix);
-    expect(resolved.titleEmphasis).toBe(loc.siInstructionsEmphasisSelfie);
-    expect(resolved.guidelinesSectionTitle).toBe(
-      loc.siInstructionsCaptureGuidelines,
-    );
-    // Empty guidelines resolve to the shared frozen default (same reference).
-    expect(resolved.guidelines).toBe(SELFIE_GUIDELINES);
-    expect(resolved.heroSource).toBe(SELFIE_HERO_ANIMATION);
-    expect(resolved.showAttribution).toBe(true);
-    expect(resolved.showHeroOval).toBe(true);
-    expect(resolved.showHeroOvalProgress).toBe(true);
-  });
-
-  it("honors explicit overrides verbatim", () => {
-    const guidelines: InstructionGuideline[] = [SELFIE_GUIDELINES[0]!];
-    const resolved = resolveInstructionsConfig(
-      {
-        titlePrefix: "Ready for your",
-        titleEmphasis: "scan",
-        guidelinesSectionTitle: "Tips",
-        guidelines,
-        showAttribution: false,
-        showHeroOval: false,
-      },
-      { enhancedLivenessEnabled: false },
-      loc,
-    );
-    expect(resolved.titlePrefix).toBe("Ready for your");
-    expect(resolved.titleEmphasis).toBe("scan");
-    expect(resolved.guidelinesSectionTitle).toBe("Tips");
-    expect(resolved.guidelines).toBe(guidelines);
-    expect(resolved.showAttribution).toBe(false);
-    expect(resolved.showHeroOval).toBe(false);
-  });
-
-  it("suppresses the rising oval progress fill under Enhanced Smart Selfie", () => {
-    // ESS capture has no single rising-progress ring to preview.
-    expect(
-      resolveInstructionsConfig({}, { enhancedLivenessEnabled: true }, loc)
-        .showHeroOvalProgress,
-    ).toBe(false);
-    expect(
-      resolveInstructionsConfig({}, { enhancedLivenessEnabled: false }, loc)
-        .showHeroOvalProgress,
-    ).toBe(true);
-  });
-});
-
-describe("resolveInstructionsConfig — document variant", () => {
-  it("uses the document displayName, document guidelines, per-type hero, and no oval", () => {
-    const resolved = resolveInstructionsConfig(
-      {},
-      {
-        enhancedLivenessEnabled: false,
-        documentType: DocumentType.SouthAfricaGreenBook,
-      },
-      loc,
-    );
-    expect(resolved.titleEmphasis).toBe("Green Book");
-    expect(resolved.guidelines).toBe(DOCUMENT_GUIDELINES_GREEN_BOOK);
-    expect(resolved.heroSource).toBe(DOCUMENT_GREEN_BOOK_HERO_ANIMATION);
-    expect(resolved.showHeroOval).toBe(false);
-    expect(resolved.showHeroOvalProgress).toBe(false);
-    // The prefix still comes from the shared localized default.
-    expect(resolved.titlePrefix).toBe(loc.siInstructionsTitlePrefix);
-  });
-
-  it("falls back to the generic document hero + guidelines for GenericDocument", () => {
-    const resolved = resolveInstructionsConfig(
-      {},
-      {
-        enhancedLivenessEnabled: false,
-        documentType: DocumentType.GenericDocument(),
-      },
-      loc,
-    );
-    expect(resolved.heroSource).toBe(DOCUMENT_HERO_ANIMATION);
-    expect(resolved.guidelines).toBe(DOCUMENT_GUIDELINES_GENERIC);
-    expect(resolved.titleEmphasis).toBe("Document");
-  });
-
-  it("uses the passport guidelines for a passport document", () => {
-    const resolved = resolveInstructionsConfig(
-      {},
-      { enhancedLivenessEnabled: false, documentType: DocumentType.Passport },
-      loc,
-    );
-    expect(resolved.guidelines).toBe(DOCUMENT_GUIDELINES_PASSPORT);
-  });
-
-  it("respects partner title/guideline overrides but always hides the oval for documents", () => {
-    const customGuidelines: InstructionGuideline[] = [SELFIE_GUIDELINES[0]!];
-    const resolved = resolveInstructionsConfig(
-      {
-        titleEmphasis: "My ID",
-        guidelines: customGuidelines,
-        showHeroOval: true,
-      },
-      { enhancedLivenessEnabled: false, documentType: DocumentType.Passport },
-      loc,
-    );
-    // Title + guidelines respect the partner override…
-    expect(resolved.titleEmphasis).toBe("My ID");
-    expect(resolved.guidelines).toBe(customGuidelines);
-    // …but a document flow never shows the face oval, even when asked.
-    expect(resolved.showHeroOval).toBe(false);
-  });
-});
-
-describe("resolvedHeroAnimation", () => {
-  it("uses the bundled selfie hero by default", () => {
-    expect(resolvedHeroAnimation(undefined, false)).toBe(SELFIE_HERO_ANIMATION);
-  });
-
-  it("swaps the default hero for the ESS hero when enhanced liveness is on", () => {
-    expect(resolvedHeroAnimation(undefined, true)).toBe(ESS_HERO_ANIMATION);
-  });
-
-  it("respects a partner-supplied hero even under enhanced liveness", () => {
-    // Concrete scenario: a partner set their own hero; ESS must not clobber it.
-    expect(resolvedHeroAnimation(CUSTOM_HERO, true)).toBe(CUSTOM_HERO);
-    expect(resolvedHeroAnimation(CUSTOM_HERO, false)).toBe(CUSTOM_HERO);
-  });
-});

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

@@ -1,53 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { resolvePreviewState } from "../helpers/preview_screen_helpers";
-
-describe("resolvePreviewState", () => {
-  it("reports no image when capturedSelfiePath is omitted", () => {
-    // Concrete scenario: the user lands on the preview screen
-    // without a successful capture (e.g. orchestrator routed here
-    // by mistake). Both Accept and Retake should be disabled —
-    // there's nothing to act on.
-    const state = resolvePreviewState({});
-    expect(state.hasImage).toBe(false);
-    expect(state.canAccept).toBe(false);
-    expect(state.canRetake).toBe(false);
-  });
-
-  it("treats an empty-string path the same as no image", () => {
-    // Concrete scenario: a future bug sets `capturedSelfiePath = ''`
-    // instead of leaving it undefined. The image card would render
-    // a broken `file:///` source. Pin the empty-string fallback so
-    // the screen stays in the "no image" branch.
-    const state = resolvePreviewState({ capturedSelfiePath: "" });
-    expect(state.hasImage).toBe(false);
-    expect(state.canAccept).toBe(false);
-  });
-
-  it("enables Accept and Retake when a path is present and retake is allowed", () => {
-    const state = resolvePreviewState({
-      capturedSelfiePath: "file:///selfie.jpg",
-    });
-    expect(state.hasImage).toBe(true);
-    expect(state.canAccept).toBe(true);
-    expect(state.canRetake).toBe(true);
-  });
-
-  it("disables Retake when partner forces allowRetake=false but keeps Accept enabled", () => {
-    // Concrete scenario: partner with a strict capture policy
-    // commits the user to the first capture. Accept must still
-    // work; Reject must hide.
-    const state = resolvePreviewState({
-      capturedSelfiePath: "file:///selfie.jpg",
-      allowRetake: false,
-    });
-    expect(state.canAccept).toBe(true);
-    expect(state.canRetake).toBe(false);
-  });
-
-  it("defaults allowRetake to true when omitted", () => {
-    const state = resolvePreviewState({
-      capturedSelfiePath: "file:///selfie.jpg",
-    });
-    expect(state.canRetake).toBe(true);
-  });
-});

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

@@ -1,39 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { resolveOverlayStateForProcessing } from "../helpers/processing_screen_helpers";
-import { UseSmileIDOverlayState } from "../../state/use_smile_id_overlay_state";
-
-describe("resolveOverlayStateForProcessing", () => {
-  it("maps loading → PROCESSING (capture-progress border)", () => {
-    // Concrete scenario: while submitting, the oval should pulse
-    // with the capture-progress colour to telegraph "active work".
-    expect(resolveOverlayStateForProcessing("loading")).toBe(
-      UseSmileIDOverlayState.PROCESSING,
-    );
-  });
-
-  it("maps success → READY (green border)", () => {
-    // Concrete scenario: server confirmed the job. Oval flips to
-    // the green ovalActive colour so the user gets an immediate
-    // affirmative cue under the bottom-card success content.
-    expect(resolveOverlayStateForProcessing("success")).toBe(
-      UseSmileIDOverlayState.READY,
-    );
-  });
-
-  it("maps failed → IDLE (neutral border, not warning)", () => {
-    // Concrete scenario: server rejected. The bottom-card already
-    // surfaces the failure (warning indicator + Retry/Exit). The
-    // oval drops to neutral so the failure messaging isn't
-    // visually duplicated by an angry red border.
-    expect(resolveOverlayStateForProcessing("failed")).toBe(
-      UseSmileIDOverlayState.IDLE,
-    );
-  });
-
-  it("is exhaustive over the three processing kinds", () => {
-    const kinds = ["loading", "success", "failed"] as const;
-    for (const k of kinds) {
-      expect(resolveOverlayStateForProcessing(k)).toBeTruthy();
-    }
-  });
-});