@smileid/usesmileid 12.0.1 → 12.0.2

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_objects.test.ts

@@ -38,7 +38,7 @@ const modelConfiguration: ModelConfiguration = {
   documentModel: {
     provider: ModelProvider.Smile,
     name: "noop_document_detector",
-    version: "12.0.1",
+    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.1",
+    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.1",
+      wrapperVersion: "12.0.2",
     });
     expect(value("wrapper_name", populated)).toBe("react_native_expo");
-    expect(value("wrapper_version", populated)).toBe("12.0.1");
+    expect(value("wrapper_version", populated)).toBe("12.0.2");
 
     const names = new UseSmileIDMetadata(fields())
       .toEntries()

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.1",
+    "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.1",
+      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.1",
+      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.1");
+    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.1",
+      sdkVersion: "12.0.2",
       sdk: "react-native-expo",
       deviceOs: "Android 14",
       deviceModel: "",

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

@@ -0,0 +1,234 @@
+import { describe, it, expect, afterEach, beforeEach, vi } from "vitest";
+import Module from "node:module";
+
+import {
+  loadExpoDevice,
+  loadExpoNetwork,
+  loadExpoBattery,
+  loadExpoCellular,
+  loadAsyncStorage,
+  loadExpoSensors,
+  loadExpoLocation,
+  _resetOptionalModulesForTesting,
+} from "../optional_native_modules";
+
+/**
+ * The optional peer bridges resolve through a dynamic `require()` so a
+ * partner who skips `expo-battery` / `expo-sensors` / async-storage
+ * still gets a bundle that builds. `vi.mock` can't reach a CommonJS
+ * `require`, so these tests intercept Node's module loader itself —
+ * that is the exact seam the production code depends on.
+ */
+
+type Loader = (id: string, parent: unknown, isMain: boolean) => unknown;
+
+const loaderHost = Module as unknown as { _load: Loader };
+const originalLoad: Loader = loaderHost._load;
+
+/** Resolution table consulted by the patched loader; unlisted ids fall through. */
+let resolutions: Record<string, unknown | (() => never)> = {};
+let requestedIds: string[] = [];
+
+beforeEach(() => {
+  resolutions = {};
+  requestedIds = [];
+  _resetOptionalModulesForTesting();
+  vi.spyOn(loaderHost, "_load").mockImplementation((id, parent, isMain) => {
+    requestedIds.push(id);
+    if (Object.prototype.hasOwnProperty.call(resolutions, id)) {
+      const entry = resolutions[id];
+      if (typeof entry === "function") return (entry as () => never)();
+      return entry;
+    }
+    return originalLoad.call(Module, id, parent, isMain);
+  });
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  _resetOptionalModulesForTesting();
+});
+
+function throwsMissing(id: string) {
+  return () => {
+    const error = new Error(`Cannot find module '${id}'`) as Error & {
+      code: string;
+    };
+    error.code = "MODULE_NOT_FOUND";
+    throw error;
+  };
+}
+
+/** Stands in for `expo-modules-core`'s non-throwing native-module lookup. */
+function expoCore(natives: Record<string, unknown>) {
+  return {
+    requireOptionalNativeModule: <T>(name: string): T | null =>
+      (natives[name] as T) ?? null,
+  };
+}
+
+describe("optional native module bridges", () => {
+  describe("expo-modules-core backed loaders", () => {
+    it("returns the raw ExpoDevice native module when it is linked", () => {
+      const native = { modelName: "Pixel 8", brand: "google" };
+      resolutions["expo-modules-core"] = expoCore({ ExpoDevice: native });
+
+      expect(loadExpoDevice()).toBe(native);
+    });
+
+    it("returns null when the native module is not linked", () => {
+      resolutions["expo-modules-core"] = expoCore({});
+
+      expect(loadExpoDevice()).toBeNull();
+      expect(loadExpoNetwork()).toBeNull();
+      expect(loadExpoBattery()).toBeNull();
+      expect(loadExpoCellular()).toBeNull();
+    });
+
+    it("returns null when expo-modules-core itself cannot be resolved", () => {
+      resolutions["expo-modules-core"] = throwsMissing("expo-modules-core");
+
+      expect(loadExpoDevice()).toBeNull();
+      expect(loadExpoNetwork()).toBeNull();
+      expect(loadExpoBattery()).toBeNull();
+      expect(loadExpoCellular()).toBeNull();
+    });
+
+    it("returns null when the core build predates requireOptionalNativeModule", () => {
+      resolutions["expo-modules-core"] = {};
+
+      expect(loadExpoDevice()).toBeNull();
+      expect(loadExpoBattery()).toBeNull();
+    });
+
+    it("resolves ExpoNetwork, ExpoBattery and ExpoCellular by name", () => {
+      const network = { getNetworkStateAsync: async () => ({ type: "WIFI" }) };
+      const battery = { getBatteryStateAsync: async () => 2 };
+      const cellular = { carrier: "MTN" };
+      resolutions["expo-modules-core"] = expoCore({
+        ExpoNetwork: network,
+        ExpoBattery: battery,
+        ExpoCellular: cellular,
+      });
+
+      expect(loadExpoNetwork()).toBe(network);
+      expect(loadExpoBattery()).toBe(battery);
+      expect(loadExpoCellular()).toBe(cellular);
+    });
+
+    it("caches the resolution — a second call never re-requires", () => {
+      const native = { modelName: "Pixel 8" };
+      resolutions["expo-modules-core"] = expoCore({ ExpoDevice: native });
+
+      expect(loadExpoDevice()).toBe(native);
+      const requiresAfterFirst = requestedIds.filter(
+        (id) => id === "expo-modules-core",
+      ).length;
+
+      // Swap the table: a cached loader must not observe the change.
+      resolutions["expo-modules-core"] = expoCore({
+        ExpoDevice: { modelName: "Different" },
+      });
+      expect(loadExpoDevice()).toBe(native);
+      expect(
+        requestedIds.filter((id) => id === "expo-modules-core").length,
+      ).toBe(requiresAfterFirst);
+    });
+
+    it("caches the null resolution too — a missing module is asked for once", () => {
+      resolutions["expo-modules-core"] = throwsMissing("expo-modules-core");
+
+      expect(loadExpoBattery()).toBeNull();
+      const count = requestedIds.filter(
+        (id) => id === "expo-modules-core",
+      ).length;
+      expect(loadExpoBattery()).toBeNull();
+      expect(
+        requestedIds.filter((id) => id === "expo-modules-core").length,
+      ).toBe(count);
+    });
+  });
+
+  describe("async storage", () => {
+    it("unwraps the CommonJS default export", () => {
+      const storage = {
+        getItem: async () => null,
+        setItem: async () => {},
+      };
+      resolutions["@react-native-async-storage/async-storage"] = {
+        default: storage,
+      };
+
+      expect(loadAsyncStorage()).toBe(storage);
+    });
+
+    it("accepts a namespace without a default export", () => {
+      const storage = {
+        getItem: async () => null,
+        setItem: async () => {},
+      };
+      resolutions["@react-native-async-storage/async-storage"] = storage;
+
+      expect(loadAsyncStorage()).toBe(storage);
+    });
+
+    it("returns null when the package is not installed", () => {
+      resolutions["@react-native-async-storage/async-storage"] = throwsMissing(
+        "@react-native-async-storage/async-storage",
+      );
+
+      expect(loadAsyncStorage()).toBeNull();
+    });
+  });
+
+  describe("expo-sensors and expo-location", () => {
+    it("returns the module namespace when installed", () => {
+      const sensors = {
+        Accelerometer: {
+          setUpdateInterval: () => {},
+          addListener: () => ({ remove: () => {} }),
+        },
+      };
+      const location = {
+        getForegroundPermissionsAsync: async () => ({ granted: true }),
+        getLastKnownPositionAsync: async () => null,
+      };
+      resolutions["expo-sensors"] = sensors;
+      resolutions["expo-location"] = location;
+
+      expect(loadExpoSensors()).toBe(sensors);
+      expect(loadExpoLocation()).toBe(location);
+    });
+
+    it("returns null when either peer dep is absent", () => {
+      resolutions["expo-sensors"] = throwsMissing("expo-sensors");
+      resolutions["expo-location"] = throwsMissing("expo-location");
+
+      expect(loadExpoSensors()).toBeNull();
+      expect(loadExpoLocation()).toBeNull();
+    });
+  });
+
+  it("_resetOptionalModulesForTesting clears every cached bridge", () => {
+    const first = { modelName: "First" };
+    resolutions["expo-modules-core"] = expoCore({ ExpoDevice: first });
+    resolutions["expo-sensors"] = { Accelerometer: {} };
+    expect(loadExpoDevice()).toBe(first);
+    expect(loadExpoSensors()).toEqual({ Accelerometer: {} });
+
+    _resetOptionalModulesForTesting();
+
+    const second = { modelName: "Second" };
+    resolutions["expo-modules-core"] = expoCore({ ExpoDevice: second });
+    resolutions["expo-sensors"] = throwsMissing("expo-sensors");
+    resolutions["expo-location"] = throwsMissing("expo-location");
+    resolutions["@react-native-async-storage/async-storage"] = throwsMissing(
+      "@react-native-async-storage/async-storage",
+    );
+
+    expect(loadExpoDevice()).toBe(second);
+    expect(loadExpoSensors()).toBeNull();
+    expect(loadExpoLocation()).toBeNull();
+    expect(loadAsyncStorage()).toBeNull();
+  });
+});

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

@@ -23,7 +23,7 @@ import { SdkConfigSource } from "../../data/model/sdk_config_source";
 // survive `toEntries()` from this fixture are the truly-always-present ones
 // (SDK constants, sessionId, sdk_config_source).
 const baseFields: UseSmileIDMetadataFields = Object.freeze({
-  sdkVersion: "12.0.1",
+  sdkVersion: "12.0.2",
   sdk: "react-native-expo",
   deviceOs: "",
   deviceModel: "",