@smileid/usesmileid 12.0.2 → 12.1.1

package/src/l10n/use_smile_id_localizations_provider.tsx

@@ -1,71 +0,0 @@
-import { createContext, useContext, useMemo, type ReactNode } from "react";
-import { UseSmileIDLocalizations } from "./use_smile_id_localizations";
-
-/**
- * React Context for the SDK's localized strings.
- *
- * `<UseSmileIDBuilder>` wraps its tree with this provider automatically
- * when `configuration.localizations` is set. Partners who render SDK
- * screens outside the orchestrator can wrap manually:
- *
- * ```tsx
- * <UseSmileIDLocalizationsProvider value={localizations}>
- *   <UseSmileIDConsentScreen partnerName="Acme" />
- * </UseSmileIDLocalizationsProvider>
- * ```
- *
- * Default value is an English-only `UseSmileIDLocalizations` so screens
- * rendered without an explicit provider still display the canonical
- * defaults rather than crashing with a "no provider" error.
- */
-const UseSmileIDLocalizationsContext = createContext<UseSmileIDLocalizations>(
-  new UseSmileIDLocalizations(),
-);
-
-export type UseSmileIDLocalizationsProviderProps = {
-  readonly value: UseSmileIDLocalizations;
-  readonly children: ReactNode;
-};
-
-export function UseSmileIDLocalizationsProvider({
-  value,
-  children,
-}: UseSmileIDLocalizationsProviderProps) {
-  return (
-    <UseSmileIDLocalizationsContext.Provider value={value}>
-      {children}
-    </UseSmileIDLocalizationsContext.Provider>
-  );
-}
-
-/**
- * Read the current `UseSmileIDLocalizations` from context. Returns the
- * English-only default if no `<UseSmileIDLocalizationsProvider>`
- * wraps the caller.
- */
-export function useUseSmileIDLocalizations(): UseSmileIDLocalizations {
-  return useContext(UseSmileIDLocalizationsContext);
-}
-
-/**
- * Memo helper for partners who construct a fresh `UseSmileIDLocalizations`
- * from a locale-resolved overrides map on every render. Without this,
- * the context value identity changes every render and every consumer
- * re-renders. Concrete scenario: a partner reads
- * `useUseSmileIDLocalizations()` in a deep tree of 50 SDK screens —
- * the unmemoized provider would re-render the lot on every parent
- * tick. Honest stub note: the SDK's screens are stubs today so the
- * cost is theoretical; the helper still ships so the fix is in place
- * before real screens land.
- */
-export function useStableLocalizations(
-  overrides: Partial<Record<string, string>>,
-): UseSmileIDLocalizations {
-  // Concrete reliability: useMemo's dep is the overrides object
-  // identity. Partners passing a stable module-level constant get
-  // one instance; partners passing inline `{ … }` get a fresh
-  // instance per render — they should hoist to module scope. The
-  // helper does what it can; a fully stable cache isn't possible
-  // without a deep-equal which would be its own perf drag.
-  return useMemo(() => new UseSmileIDLocalizations(overrides), [overrides]);
-}

package/src/metadata/__tests__/device_orientation_collector.test.ts

@@ -1,15 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { DeviceOrientationCollector } from "../device_orientation_collector";
-
-/**
- * Regression guard: with no accelerometer samples, `device_movement_detected` must be absent
- * (`null`) and `device_positions` empty — never a sentinel. Mirrored across all four SDKs.
- */
-describe("DeviceOrientationCollector", () => {
-  it("omits movement (null) and positions when no samples were collected", () => {
-    const collector = new DeviceOrientationCollector();
-    expect(collector.deviceMovementDetected).toBeNull();
-    expect(collector.devicePositions).toHaveLength(0);
-  });
-});

package/src/metadata/__tests__/device_orientation_sampling.test.ts

@@ -1,165 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-// `vi.mock` is hoisted above the imports, so anything its factory closes over
-// must be created with `vi.hoisted` or it is still in the TDZ when the factory
-// runs.
-const { loadExpoSensors } = vi.hoisted(() => ({ loadExpoSensors: vi.fn() }));
-
-vi.mock("../optional_native_modules", () => ({ loadExpoSensors }));
-
-import { DeviceOrientationCollector } from "../device_orientation_collector";
-
-/**
- * Sampling behaviour of the accelerometer collector: the ~15 Hz throttle,
- * the 90 s session cap, the movement-span computation, and the graceful
- * no-op when `expo-sensors` is absent. The empty-session contract is pinned
- * separately in `device_orientation_collector.test.ts`.
- */
-
-type Sample = { x: number; y: number; z: number };
-
-function makeSensors() {
-  const listeners: Array<(data: Sample) => void> = [];
-  const remove = vi.fn(() => {
-    listeners.length = 0;
-  });
-  const setUpdateInterval = vi.fn();
-  const addListener = vi.fn((listener: (data: Sample) => void) => {
-    listeners.push(listener);
-    return { remove };
-  });
-  return {
-    module: { Accelerometer: { setUpdateInterval, addListener } },
-    emit: (sample: Sample) => {
-      for (const listener of [...listeners]) listener(sample);
-    },
-    setUpdateInterval,
-    addListener,
-    remove,
-    listenerCount: () => listeners.length,
-  };
-}
-
-describe("DeviceOrientationCollector — sampling", () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-    vi.setSystemTime(new Date("2026-07-30T00:00:00.000Z"));
-    loadExpoSensors.mockReset();
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it("subscribes at the ~15 Hz sampling interval on start", () => {
-    const sensors = makeSensors();
-    loadExpoSensors.mockReturnValue(sensors.module);
-
-    new DeviceOrientationCollector().start();
-
-    expect(sensors.setUpdateInterval).toHaveBeenCalledWith(66);
-    expect(sensors.addListener).toHaveBeenCalledTimes(1);
-  });
-
-  it("records epoch-stamped samples and the movement span", () => {
-    const sensors = makeSensors();
-    loadExpoSensors.mockReturnValue(sensors.module);
-    const collector = new DeviceOrientationCollector();
-    collector.start();
-
-    const firstStamp = Date.now();
-    sensors.emit({ x: 0, y: 0, z: 1 });
-    vi.advanceTimersByTime(100);
-    const secondStamp = Date.now();
-    sensors.emit({ x: 0, y: 0, z: 2 });
-
-    expect(collector.devicePositions).toEqual([
-      `${firstStamp},0,0,1`,
-      `${secondStamp},0,0,2`,
-    ]);
-    // |1 − 0.981| = 0.019 and |2 − 0.981| = 1.019 → span 1.
-    expect(collector.deviceMovementDetected).toBeCloseTo(1, 10);
-  });
-
-  it("throttles samples arriving faster than the interval", () => {
-    const sensors = makeSensors();
-    loadExpoSensors.mockReturnValue(sensors.module);
-    const collector = new DeviceOrientationCollector();
-    collector.start();
-
-    sensors.emit({ x: 1, y: 0, z: 0 });
-    vi.advanceTimersByTime(10);
-    sensors.emit({ x: 2, y: 0, z: 0 });
-    vi.advanceTimersByTime(10);
-    sensors.emit({ x: 3, y: 0, z: 0 });
-
-    expect(collector.devicePositions).toHaveLength(1);
-    expect(collector.devicePositions[0]).toContain(",1,0,0");
-  });
-
-  it("stops sampling once the 90 s session cap is exceeded", () => {
-    const sensors = makeSensors();
-    loadExpoSensors.mockReturnValue(sensors.module);
-    const collector = new DeviceOrientationCollector();
-    collector.start();
-
-    sensors.emit({ x: 0, y: 0, z: 1 });
-    vi.advanceTimersByTime(90 * 1000 + 1);
-    sensors.emit({ x: 0, y: 0, z: 9 });
-
-    expect(collector.devicePositions).toHaveLength(1);
-    expect(sensors.remove).toHaveBeenCalledTimes(1);
-    expect(sensors.listenerCount()).toBe(0);
-  });
-
-  it("start() is idempotent while a session is already running", () => {
-    const sensors = makeSensors();
-    loadExpoSensors.mockReturnValue(sensors.module);
-    const collector = new DeviceOrientationCollector();
-
-    collector.start();
-    collector.start();
-
-    expect(sensors.addListener).toHaveBeenCalledTimes(1);
-  });
-
-  it("stop() unsubscribes but preserves the collected data", () => {
-    const sensors = makeSensors();
-    loadExpoSensors.mockReturnValue(sensors.module);
-    const collector = new DeviceOrientationCollector();
-    collector.start();
-    sensors.emit({ x: 0, y: 0, z: 1 });
-
-    collector.stop();
-
-    expect(sensors.remove).toHaveBeenCalledTimes(1);
-    expect(collector.devicePositions).toHaveLength(1);
-    // A second stop on an already-stopped collector is harmless.
-    collector.stop();
-    expect(sensors.remove).toHaveBeenCalledTimes(1);
-  });
-
-  it("a restart clears the previous session's samples", () => {
-    const sensors = makeSensors();
-    loadExpoSensors.mockReturnValue(sensors.module);
-    const collector = new DeviceOrientationCollector();
-    collector.start();
-    sensors.emit({ x: 0, y: 0, z: 1 });
-    collector.stop();
-
-    collector.start();
-    expect(collector.devicePositions).toHaveLength(0);
-    expect(collector.deviceMovementDetected).toBeNull();
-  });
-
-  it("no-ops when expo-sensors is not installed", () => {
-    loadExpoSensors.mockReturnValue(null);
-    const collector = new DeviceOrientationCollector();
-
-    collector.start();
-    collector.stop();
-
-    expect(collector.devicePositions).toHaveLength(0);
-    expect(collector.deviceMovementDetected).toBeNull();
-  });
-});

package/src/metadata/__tests__/geolocation.test.ts

@@ -1,150 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from "vitest";
-
-// `vi.mock` is hoisted above the imports, so anything its factory closes over
-// must be created with `vi.hoisted` or it is still in the TDZ when the factory
-// runs.
-const { loadExpoLocation } = vi.hoisted(() => ({
-  loadExpoLocation: vi.fn(),
-}));
-
-vi.mock("../optional_native_modules", () => ({ loadExpoLocation }));
-
-import { resolveGeolocation } from "../geolocation";
-
-function makeLocationModule(overrides: {
-  granted?: boolean;
-  position?: {
-    coords: { latitude: number; longitude: number; accuracy: number | null };
-  } | null;
-  permissionsError?: Error;
-  positionError?: Error;
-}) {
-  return {
-    getForegroundPermissionsAsync: vi.fn(async () => {
-      if (overrides.permissionsError) throw overrides.permissionsError;
-      return { granted: overrides.granted ?? true };
-    }),
-    getLastKnownPositionAsync: vi.fn(async () => {
-      if (overrides.positionError) throw overrides.positionError;
-      return overrides.position ?? null;
-    }),
-    requestForegroundPermissionsAsync: vi.fn(),
-  };
-}
-
-function position(accuracy: number | null) {
-  return { coords: { latitude: 6.5244, longitude: 3.3792, accuracy } };
-}
-
-beforeEach(() => {
-  loadExpoLocation.mockReset();
-});
-
-describe("resolveGeolocation", () => {
-  it("returns null when expo-location isn't installed", async () => {
-    loadExpoLocation.mockReturnValue(null);
-
-    await expect(resolveGeolocation()).resolves.toBeNull();
-  });
-
-  it("never prompts — it only reads an already-granted permission", async () => {
-    const location = makeLocationModule({
-      granted: true,
-      position: position(5),
-    });
-    loadExpoLocation.mockReturnValue(location);
-
-    await resolveGeolocation();
-
-    expect(location.getForegroundPermissionsAsync).toHaveBeenCalledTimes(1);
-    expect(location.requestForegroundPermissionsAsync).not.toHaveBeenCalled();
-  });
-
-  it("returns null and skips the location read when permission is absent", async () => {
-    const location = makeLocationModule({ granted: false });
-    loadExpoLocation.mockReturnValue(location);
-
-    await expect(resolveGeolocation()).resolves.toBeNull();
-    expect(location.getLastKnownPositionAsync).not.toHaveBeenCalled();
-  });
-
-  it("returns null when there is no cached fix", async () => {
-    loadExpoLocation.mockReturnValue(
-      makeLocationModule({ granted: true, position: null }),
-    );
-
-    await expect(resolveGeolocation()).resolves.toBeNull();
-  });
-
-  it("classifies a sub-20m fix as precise and tags the source as gps", async () => {
-    loadExpoLocation.mockReturnValue(
-      makeLocationModule({ granted: true, position: position(12) }),
-    );
-
-    await expect(resolveGeolocation()).resolves.toEqual({
-      latitude: 6.5244,
-      longitude: 3.3792,
-      accuracy: "precise",
-      source: "gps",
-    });
-  });
-
-  it("classifies a sub-100m fix as approximate", async () => {
-    loadExpoLocation.mockReturnValue(
-      makeLocationModule({ granted: true, position: position(45) }),
-    );
-
-    const result = await resolveGeolocation();
-
-    expect(result?.accuracy).toBe("approximate");
-  });
-
-  it("classifies a coarse fix as unknown rather than overstating precision", async () => {
-    loadExpoLocation.mockReturnValue(
-      makeLocationModule({ granted: true, position: position(250) }),
-    );
-
-    const result = await resolveGeolocation();
-
-    expect(result?.accuracy).toBe("unknown");
-  });
-
-  it("treats a missing accuracy reading as unknown", async () => {
-    loadExpoLocation.mockReturnValue(
-      makeLocationModule({ granted: true, position: position(null) }),
-    );
-
-    const result = await resolveGeolocation();
-
-    expect(result?.accuracy).toBe("unknown");
-  });
-
-  it("treats a non-positive accuracy reading as unknown", async () => {
-    loadExpoLocation.mockReturnValue(
-      makeLocationModule({ granted: true, position: position(0) }),
-    );
-
-    const result = await resolveGeolocation();
-
-    expect(result?.accuracy).toBe("unknown");
-  });
-
-  it("swallows a throwing permission check so metadata collection never fails", async () => {
-    loadExpoLocation.mockReturnValue(
-      makeLocationModule({ permissionsError: new Error("location off") }),
-    );
-
-    await expect(resolveGeolocation()).resolves.toBeNull();
-  });
-
-  it("swallows a throwing location read", async () => {
-    loadExpoLocation.mockReturnValue(
-      makeLocationModule({
-        granted: true,
-        positionError: new Error("provider unavailable"),
-      }),
-    );
-
-    await expect(resolveGeolocation()).resolves.toBeNull();
-  });
-});

package/src/metadata/__tests__/metadata_configuration_mappers.test.ts

@@ -1,254 +0,0 @@
-import {
-  AnalyzerFactoryKey,
-  faceConfigSchema,
-} from "@smileid/usesmileid_bridge";
-import { describe, expect, it } from "vitest";
-
-import { DocumentCaptureMode } from "../../core/models/document_capture_mode";
-import { CaptureType } from "../../core/models/ml_config";
-import type { FlowConfiguration } from "../../presentation/flow/config/flow_configuration";
-import { ScreensBuilder } from "../../presentation/flow/dsl/builder/screens_builder";
-import {
-  ModelProvider,
-  MODEL_DESCRIPTOR_UNKNOWN,
-} from "../model_configuration";
-import { GlobalPrivacyControl } from "../../core/models/global_privacy_control";
-import {
-  flowConfigurationToBuilderConfiguration,
-  flowConfigurationToModelConfiguration,
-  flowConfigurationToSelfieLivenessTelemetry,
-} from "../metadata_configuration_mappers";
-
-function flow(
-  buildScreens: (screens: ScreensBuilder) => void,
-  ml?: FlowConfiguration["ml"],
-): FlowConfiguration {
-  const screensBuilder = new ScreensBuilder();
-  buildScreens(screensBuilder);
-  return {
-    screens: screensBuilder.build(),
-    ...(ml ? { ml } : {}),
-    onResult: () => {},
-  };
-}
-
-describe("flowConfigurationToBuilderConfiguration", () => {
-  it("reflects the consent screen", () => {
-    const config = flowConfigurationToBuilderConfiguration(
-      flow((screens) => {
-        screens.consent((consent) => {
-          consent.partnerIcon = "icon";
-          consent.showAttribution = false;
-        });
-      }),
-    );
-    expect(config.consentScreenUsed).toBe(true);
-    expect(config.consentIconProvided).toBe(true);
-    // A React Native consent icon is a ReactNode with no measurable pixel size.
-    expect(config.consentIconDimensions).toBeNull();
-    expect(config.consentAttributionShown).toBe(false);
-  });
-
-  it("reports consent absent when there is no consent screen", () => {
-    const config = flowConfigurationToBuilderConfiguration(
-      flow((screens) => screens.instructions()),
-    );
-    expect(config.consentScreenUsed).toBe(false);
-    expect(config.consentIconProvided).toBe(false);
-  });
-
-  it("maps selfie capture flags", () => {
-    const config = flowConfigurationToBuilderConfiguration(
-      flow((screens) => {
-        screens.capture((capture) => {
-          capture.captureType = CaptureType.selfie;
-          capture.selfie((selfie) => {
-            selfie.allowAgentMode = true;
-            selfie.enableEnhancedLiveness = true;
-          });
-        });
-        screens.preview();
-      }),
-    );
-    expect(config.allowAgentMode).toBe(true);
-    expect(config.enhancedLivenessEnabled).toBe(true);
-    expect(config.selfiePreviewEnabled).toBe(true);
-    expect(config.documentPreviewEnabled).toBe(false);
-  });
-
-  it("maps document capture flags and capture mode", () => {
-    const config = flowConfigurationToBuilderConfiguration(
-      flow((screens) => {
-        screens.capture((capture) => {
-          capture.captureType = CaptureType.document;
-          capture.document((document) => {
-            document.captureMode = DocumentCaptureMode.ManualCapture;
-            document.allowGalleryUpload = true;
-            document.captureBothSides = false;
-            document.allowSkipBack = true;
-          });
-        });
-        screens.preview();
-      }),
-    );
-    expect(config.autoCaptureEnabled).toBe("manual");
-    expect(config.allowGalleryUpload).toBe(true);
-    expect(config.captureBothSides).toBe(false);
-    expect(config.allowSkipBack).toBe(true);
-    expect(config.documentPreviewEnabled).toBe(true);
-    expect(config.selfiePreviewEnabled).toBe(false);
-  });
-
-  it("maps each document capture mode to the wire enum", () => {
-    const modeFor = (captureMode: DocumentCaptureMode): string =>
-      flowConfigurationToBuilderConfiguration(
-        flow((screens) => {
-          screens.capture((capture) => {
-            capture.captureType = CaptureType.document;
-            capture.document((document) => {
-              document.captureMode = captureMode;
-            });
-          });
-        }),
-      ).autoCaptureEnabled;
-
-    expect(modeFor(DocumentCaptureMode.AutoCapture)).toBe("auto_capture_only");
-    expect(modeFor(DocumentCaptureMode.ManualCapture)).toBe("manual");
-    expect(modeFor(DocumentCaptureMode.AutoCaptureWithManualFallback())).toBe(
-      "autocapture_default",
-    );
-  });
-
-  it("reports submission skipped without a processing screen", () => {
-    const selfieOnly = (screens: ScreensBuilder) =>
-      screens.capture((capture) => {
-        capture.captureType = CaptureType.selfie;
-      });
-    expect(
-      flowConfigurationToBuilderConfiguration(flow(selfieOnly))
-        .submissionSkipped,
-    ).toBe(true);
-    expect(
-      flowConfigurationToBuilderConfiguration(
-        flow((screens) => {
-          selfieOnly(screens);
-          screens.processing();
-        }),
-      ).submissionSkipped,
-    ).toBe(false);
-  });
-});
-
-describe("flowConfigurationToModelConfiguration", () => {
-  it("maps the face backend key with the noop document fallback", () => {
-    const config = flow(
-      (screens) =>
-        screens.capture((capture) => {
-          capture.captureType = CaptureType.selfie;
-        }),
-      {
-        analyzers: {
-          selfieConfig: faceConfigSchema.parse({
-            analyzerFactoryKey: AnalyzerFactoryKey.MLKitFace,
-          }),
-        },
-      },
-    );
-    const model = flowConfigurationToModelConfiguration(config);
-    expect(model.faceModel.provider).toBe(ModelProvider.Google);
-    expect(model.faceModel.name).toBe("play-services-mlkit-face-detection");
-    expect(model.documentModel.provider).toBe(ModelProvider.Smile);
-  });
-
-  it("falls back to unknown for an ML-free flow", () => {
-    const model = flowConfigurationToModelConfiguration(
-      flow((screens) =>
-        screens.capture((capture) => {
-          capture.captureType = CaptureType.selfie;
-        }),
-      ),
-    );
-    expect(model.faceModel).toEqual(MODEL_DESCRIPTOR_UNKNOWN);
-    expect(model.documentModel.provider).toBe(ModelProvider.Smile);
-  });
-});
-
-describe("flowConfigurationToSelfieLivenessTelemetry", () => {
-  it("reports smile for a standard selfie flow", () => {
-    const telemetry = flowConfigurationToSelfieLivenessTelemetry(
-      flow((screens) =>
-        screens.capture((capture) => {
-          capture.captureType = CaptureType.selfie;
-          capture.selfie(() => {});
-        }),
-      ),
-    );
-    expect(telemetry.activeLivenessType).toBe("smile");
-    expect(telemetry.activeLivenessVersion).toBe("2.0.0");
-    expect(telemetry.selfieImageOrigin).toBe("front_camera");
-  });
-
-  it("reports head_pose when enhanced liveness is on", () => {
-    const telemetry = flowConfigurationToSelfieLivenessTelemetry(
-      flow((screens) =>
-        screens.capture((capture) => {
-          capture.captureType = CaptureType.selfie;
-          capture.selfie((selfie) => {
-            selfie.enableEnhancedLiveness = true;
-          });
-        }),
-      ),
-    );
-    expect(telemetry.activeLivenessType).toBe("head_pose");
-  });
-
-  it("reports back_camera in agent mode", () => {
-    const telemetry = flowConfigurationToSelfieLivenessTelemetry(
-      flow((screens) =>
-        screens.capture((capture) => {
-          capture.captureType = CaptureType.selfie;
-          capture.selfie((selfie) => {
-            selfie.allowAgentMode = true;
-          });
-        }),
-      ),
-    );
-    expect(telemetry.selfieImageOrigin).toBe("back_camera");
-    expect(telemetry.activeLivenessType).toBe("smile");
-  });
-
-  it("is all-null for a document-only flow", () => {
-    const telemetry = flowConfigurationToSelfieLivenessTelemetry(
-      flow((screens) =>
-        screens.capture((capture) => {
-          capture.captureType = CaptureType.document;
-        }),
-      ),
-    );
-    expect(telemetry.activeLivenessType).toBeNull();
-    expect(telemetry.selfieImageOrigin).toBeNull();
-  });
-
-  it("global privacy control lands in the configuration metadata", () => {
-    // Default posture: a snapshot without a config block reports the
-    // opt-out baseline.
-    expect(
-      flowConfigurationToBuilderConfiguration(flow(() => {}))
-        .globalPrivacyControl,
-    ).toBe("opt-out");
-
-    // Explicit legacy posture flows through the config snapshot.
-    const optIn: FlowConfiguration = {
-      ...flow(() => {}),
-      config: {
-        enableCrashReporting: true,
-        enableDebugMode: false,
-        allowOfflineMode: false,
-        globalPrivacyControl: GlobalPrivacyControl.OptIn,
-      },
-    };
-    expect(
-      flowConfigurationToBuilderConfiguration(optIn).globalPrivacyControl,
-    ).toBe("opt-in");
-  });
-});