@smileid/usesmileid 12.0.0 → 12.0.2

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

@@ -0,0 +1,165 @@
+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

@@ -0,0 +1,150 @@
+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

@@ -12,6 +12,7 @@ import {
   ModelProvider,
   MODEL_DESCRIPTOR_UNKNOWN,
 } from "../model_configuration";
+import { GlobalPrivacyControl } from "../../core/models/global_privacy_control";
 import {
   flowConfigurationToBuilderConfiguration,
   flowConfigurationToModelConfiguration,
@@ -201,6 +202,21 @@ describe("flowConfigurationToSelfieLivenessTelemetry", () => {
     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) =>
@@ -212,4 +228,27 @@ describe("flowConfigurationToSelfieLivenessTelemetry", () => {
     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");
+  });
 });

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

@@ -25,6 +25,7 @@ const builderConfiguration: BuilderConfiguration = {
   allowGalleryUpload: true,
   captureBothSides: true,
   allowSkipBack: false,
+  globalPrivacyControl: "opt-out",
 };
 
 const modelConfiguration: ModelConfiguration = {
@@ -37,7 +38,7 @@ const modelConfiguration: ModelConfiguration = {
   documentModel: {
     provider: ModelProvider.Smile,
     name: "noop_document_detector",
-    version: "12.0.0",
+    version: "12.0.2",
     bundled: true,
   },
 };

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

@@ -9,7 +9,7 @@ function fields(
   overrides: Partial<UseSmileIDMetadataFields> = {},
 ): UseSmileIDMetadataFields {
   return {
-    sdkVersion: "12.0.0",
+    sdkVersion: "12.0.2",
     sdk: "react-native-expo",
     deviceOs: "Android 14",
     deviceModel: "",
@@ -89,10 +89,10 @@ describe("device-context keys (62-key parity)", () => {
   it("emits wrapper identity when present and omits it when blank", () => {
     const populated = fields({
       wrapperName: "react_native_expo",
-      wrapperVersion: "12.0.0",
+      wrapperVersion: "12.0.2",
     });
     expect(value("wrapper_name", populated)).toBe("react_native_expo");
-    expect(value("wrapper_version", populated)).toBe("12.0.0");
+    expect(value("wrapper_version", populated)).toBe("12.0.2");
 
     const names = new UseSmileIDMetadata(fields())
       .toEntries()

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

@@ -0,0 +1,18 @@
+import { describe, expect, it, vi } from "vitest";
+
+vi.mock("react-native", () => ({
+  Platform: { OS: "android", Version: 31, constants: { Release: "12" } },
+  Dimensions: {
+    get: () => ({ width: 1080, height: 2400, scale: 3 }),
+  },
+}));
+
+import { UseSmileIDMetadataFactory } from "../use_smile_id_metadata_factory";
+
+describe("device_os on Android", () => {
+  it("reports the release version, not the API level", () => {
+    const factory = new UseSmileIDMetadataFactory();
+
+    expect(factory.make().toFields().deviceOs).toBe("Android 12");
+  });
+});

package/src/metadata/__tests__/metadata_golden_fixture.json

@@ -1,7 +1,7 @@
 {
   "_comment": "Shared cross-SDK golden parity vectors. These metadata keys must serialise to the EXACT same wire value on Android, iOS, Flutter, and React Native for the standard fully-populated golden snapshot. Each SDK's metadata-payload golden test asserts its payload contains every entry below verbatim. Maintained manually — keep the four copies (android/ios/flutter/react-native-expo test dirs) in sync.",
   "expected": {
-    "sdk_version": "12.0.0",
+    "sdk_version": "12.0.2",
     "proxy": "true",
     "proximity_sensor": "true",
     "sdk_config_source": "sdk_config",

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

@@ -17,7 +17,7 @@ import goldenFixture from "./metadata_golden_fixture.json";
 describe("metadata payload (golden, device-context fields)", () => {
   function fullyPopulated(): UseSmileIDMetadataFields {
     return {
-      sdkVersion: "12.0.0",
+      sdkVersion: "12.0.2",
       sdk: "react-native-expo",
       deviceOs: "Android 14",
       deviceModel: "Google Pixel 8",
@@ -56,7 +56,7 @@ describe("metadata payload (golden, device-context fields)", () => {
       vpn: false,
       certificateDigest: ["AA:BB", "CC:DD"],
       wrapperName: "react_native_expo",
-      wrapperVersion: "12.0.0",
+      wrapperVersion: "12.0.2",
       sdkLaunchCount: 5,
       geolocation: {
         latitude: 1.5,
@@ -128,7 +128,7 @@ describe("metadata payload (golden, device-context fields)", () => {
 
   it("emits scalar + meaningful-falsey + JSON-shaped values correctly", () => {
     const map = entriesOf(fullyPopulated());
-    expect(map.get("sdk_version")).toBe("12.0.0");
+    expect(map.get("sdk_version")).toBe("12.0.2");
     expect(map.get("proxy")).toBe("true");
     expect(map.get("battery_status")).toBe("0"); // 0 is meaningful
     expect(map.get("sdk_config_source")).toBe("sdk_config");
@@ -153,7 +153,7 @@ describe("metadata payload (golden, device-context fields)", () => {
 
   it("default snapshot emits only the always-present keys", () => {
     const minimal: UseSmileIDMetadataFields = {
-      sdkVersion: "12.0.0",
+      sdkVersion: "12.0.2",
       sdk: "react-native-expo",
       deviceOs: "Android 14",
       deviceModel: "",