@smileid/usesmileid 12.0.0-beta01

package/src/__tests__/enum_parity.test.ts

@@ -0,0 +1,84 @@
+import { describe, expect, it } from "vitest";
+import { CaptureType } from "../presentation/flow/dsl/builder/screens_builder";
+import { RetryStrategy } from "../data/dsl/builder/retry_config_builder";
+import { LogLevel } from "../core/models/network_config";
+import { StatusIndicatorState } from "../presentation/components/status_indicator_state";
+
+/**
+ * Enum string-value pinning tests. Every const-object enum must
+ * round-trip its keys to the canonical lowercase string names that
+ * appear in the wire format and partner-facing API. A drift here
+ * breaks partner code that pins on `RetryStrategy.exponential`
+ * resolving to `'exponential'`.
+ *
+ * Concrete failure mode: a future refactor renames
+ * `RetryStrategy.exponential` to `RetryStrategy.exp`. The test
+ * fails immediately rather than silently shipping a key whose
+ * runtime string value doesn't match the documented contract.
+ */
+
+describe("CaptureType — string-value pinning", () => {
+  it("exposes selfie/document keys with matching string values", () => {
+    expect(CaptureType.selfie).toBe("selfie");
+    expect(CaptureType.document).toBe("document");
+  });
+
+  it("lists exactly the canonical two kinds — no drift in either direction", () => {
+    expect(Object.keys(CaptureType).sort()).toEqual(["document", "selfie"]);
+  });
+});
+
+describe("RetryStrategy — string-value pinning", () => {
+  it("exposes exponential/fixed/none with matching string values", () => {
+    expect(RetryStrategy.exponential).toBe("exponential");
+    expect(RetryStrategy.fixed).toBe("fixed");
+    expect(RetryStrategy.none).toBe("none");
+  });
+
+  it("lists exactly the canonical three strategies", () => {
+    expect(Object.keys(RetryStrategy).sort()).toEqual([
+      "exponential",
+      "fixed",
+      "none",
+    ]);
+  });
+});
+
+describe("LogLevel — string-value pinning", () => {
+  it("exposes none/basic/headers/body with matching string values", () => {
+    expect(LogLevel.none).toBe("none");
+    expect(LogLevel.basic).toBe("basic");
+    expect(LogLevel.headers).toBe("headers");
+    expect(LogLevel.body).toBe("body");
+  });
+
+  it("lists exactly the canonical four verbosity levels", () => {
+    expect(Object.keys(LogLevel).sort()).toEqual([
+      "basic",
+      "body",
+      "headers",
+      "none",
+    ]);
+  });
+});
+
+describe("StatusIndicatorState — tri-state parity", () => {
+  it("exposes loading/success/failure with matching string values", () => {
+    expect(StatusIndicatorState.loading).toBe("loading");
+    expect(StatusIndicatorState.success).toBe("success");
+    expect(StatusIndicatorState.failure).toBe("failure");
+  });
+
+  it("lists exactly the canonical three states", () => {
+    expect(Object.keys(StatusIndicatorState).sort()).toEqual([
+      "failure",
+      "loading",
+      "success",
+    ]);
+  });
+
+  it("accepts the bare-string call style alongside the named accessor", () => {
+    const literal: StatusIndicatorState = "success";
+    expect(literal).toBe(StatusIndicatorState.success);
+  });
+});

package/src/__tests__/react_native_mock.tsx

@@ -0,0 +1,210 @@
+import * as React from "react";
+
+/**
+ * Pure-JS stand-in for `react-native` consumed by component tests.
+ *
+ * `react-native` from npm ships untransformed Flow source; vitest's
+ * default loader can't parse it. The vitest config aliases the
+ * package name to this file so tests render through plain host JSX
+ * tags that `react-test-renderer` accepts as primitives.
+ *
+ * Components forward `testID`, `accessibilityRole`, `style`, and
+ * `onPress` so `@testing-library/react-native` queries (`getByText`,
+ * `getByTestId`, `getByRole`) and event helpers (`fireEvent.press`)
+ * work as expected.
+ */
+
+type AnyProps = Record<string, unknown> & {
+  children?: React.ReactNode;
+  testID?: string;
+  accessibilityRole?: string;
+  accessibilityLabel?: string;
+  accessibilityState?: Record<string, unknown>;
+  accessibilityValue?: Record<string, unknown>;
+  style?: unknown;
+  onPress?: () => void;
+};
+
+function makeHostStub(displayName: string) {
+  function Stub(props: AnyProps) {
+    return React.createElement(
+      displayName,
+      {
+        testID: props.testID,
+        accessibilityRole: props.accessibilityRole,
+        accessibilityLabel: props.accessibilityLabel,
+        accessibilityState: props.accessibilityState,
+        accessibilityValue: props.accessibilityValue,
+        onPress: props.onPress,
+        style: props.style,
+      },
+      props.children,
+    );
+  }
+  Stub.displayName = displayName;
+  return Stub;
+}
+
+export const View = makeHostStub("View");
+export const Text = makeHostStub("Text");
+export const ScrollView = makeHostStub("ScrollView");
+export const Image = makeHostStub("Image");
+export const StatusBar = makeHostStub("StatusBar");
+
+export function Pressable(
+  props: AnyProps & {
+    style?: unknown | ((s: { pressed: boolean }) => unknown);
+  },
+) {
+  const flatStyle =
+    typeof props.style === "function"
+      ? props.style({ pressed: false })
+      : props.style;
+  return React.createElement(
+    "Pressable",
+    {
+      testID: props.testID,
+      accessibilityRole: props.accessibilityRole,
+      accessibilityLabel: props.accessibilityLabel,
+      accessibilityState: props.accessibilityState,
+      onPress: props.onPress,
+      style: flatStyle,
+    },
+    props.children,
+  );
+}
+
+export const StyleSheet = {
+  create<T extends Record<string, unknown>>(styles: T): T {
+    return styles;
+  },
+  absoluteFill: {} as Record<string, never>,
+  // RN semantics: nested style arrays merge left-to-right.
+  flatten(style: unknown): Record<string, unknown> {
+    if (Array.isArray(style)) {
+      return style.reduce<Record<string, unknown>>(
+        (acc, entry) => ({ ...acc, ...StyleSheet.flatten(entry) }),
+        {},
+      );
+    }
+    if (style && typeof style === "object") {
+      return style as Record<string, unknown>;
+    }
+    return {};
+  },
+  hairlineWidth: 1,
+};
+
+export const I18nManager = { isRTL: false };
+
+export const useColorScheme = (): "light" | "dark" | null => "light";
+
+export const Platform = {
+  OS: "ios" as const,
+  select<T>(spec: { ios?: T; android?: T; default?: T }): T | undefined {
+    return spec.ios ?? spec.default;
+  },
+};
+
+export const Appearance = {
+  getColorScheme: () => "light" as const,
+  addChangeListener: () => ({ remove: () => {} }),
+};
+
+export const Linking = {
+  openURL: (_url: string) => Promise.resolve(),
+  canOpenURL: (_url: string) => Promise.resolve(true),
+  addEventListener: () => ({ remove: () => {} }),
+  getInitialURL: () => Promise.resolve(null as string | null),
+};
+
+/**
+ * Minimal `Animated` shim covering the surface the SDK uses today —
+ * `Animated.View`, `Animated.Value`, `Animated.timing`. Native-thread
+ * animations have no analogue in node tests; the shim records the
+ * declared transitions but never advances them, so component trees
+ * render with their initial state. Tests that need a different
+ * animated state should pass the equivalent prop value directly.
+ */
+class AnimatedValue {
+  private _value: number;
+  constructor(initial: number) {
+    this._value = initial;
+  }
+  setValue(next: number): void {
+    this._value = next;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  interpolate(_config: {
+    inputRange: readonly number[];
+    outputRange: readonly (number | string)[];
+  }): AnimatedValue {
+    // Tests don't read interpolated output; return self so chained
+    // `.interpolate(...).interpolate(...)` calls type-check.
+    return this;
+  }
+}
+
+const AnimatedView = makeHostStub("AnimatedView");
+
+export const Animated = {
+  View: AnimatedView,
+  Text: makeHostStub("AnimatedText"),
+  Image: makeHostStub("AnimatedImage"),
+  ScrollView: makeHostStub("AnimatedScrollView"),
+  Value: AnimatedValue,
+  // Wraps a component so animated props resolve to their current
+  // value when read. The mock returns a passthrough that forwards
+  // all props as-is — sufficient for tests that only assert on the
+  // wrapped component's rendered output, not its animated behaviour.
+  createAnimatedComponent<P>(
+    component: React.ComponentType<P>,
+  ): React.ComponentType<P> {
+    return component;
+  },
+  timing: () => ({
+    start: (cb?: (info: { finished: boolean }) => void) => {
+      cb?.({ finished: true });
+    },
+    stop: () => {},
+    reset: () => {},
+  }),
+  parallel: (anims: ReadonlyArray<{ start: () => void }>) => ({
+    start: () => anims.forEach((a) => a.start()),
+    stop: () => {},
+  }),
+  sequence: (anims: ReadonlyArray<{ start: () => void }>) => ({
+    start: () => anims.forEach((a) => a.start()),
+    stop: () => {},
+  }),
+  loop: (anim: {
+    start: (cb?: (info: { finished: boolean }) => void) => void;
+    stop: () => void;
+  }) => ({
+    // The shim never advances frames; `start` runs the inner animation
+    // once (no actual looping) and `stop` is a no-op.
+    start: (cb?: (info: { finished: boolean }) => void) => anim.start?.(cb),
+    stop: () => anim.stop?.(),
+    reset: () => {},
+  }),
+};
+
+/**
+ * Minimal `AccessibilityInfo` shim. Reports reduced motion OFF and returns
+ * a no-op subscription so components can read the initial value and
+ * subscribe to changes without a native module.
+ */
+export const AccessibilityInfo = {
+  isReduceMotionEnabled: () => Promise.resolve(false),
+  addEventListener: () => ({ remove: () => {} }),
+};
+
+const easingPassthrough = (t: number) => t;
+export const Easing = {
+  ease: easingPassthrough,
+  linear: easingPassthrough,
+  in: (fn: (t: number) => number) => fn,
+  out: (fn: (t: number) => number) => fn,
+  inOut: (fn: (t: number) => number) => fn,
+  bezier: () => easingPassthrough,
+};

package/src/__tests__/setup_react_native.ts

@@ -0,0 +1,353 @@
+import { vi } from "vitest";
+import * as React from "react";
+
+/**
+ * Vitest setup for component-rendering tests.
+ *
+ * `react-native` itself is aliased to a pure-JS stub via
+ * `vitest.config.ts` (`./react_native_mock.tsx`). This file mocks
+ * the native peer libs (`lottie-react-native`,
+ * `react-native-safe-area-context`) whose entry points pull in
+ * native bindings Node can't initialize.
+ */
+
+type AnyProps = Record<string, unknown> & {
+  children?: React.ReactNode;
+  testID?: string;
+  style?: unknown;
+};
+
+vi.mock("lottie-react-native", () => {
+  // Forwards the playback props and exposes an imperative play() spy via ref.
+  const LottieView = React.forwardRef(function LottieViewStub(
+    props: {
+      testID?: string;
+      autoPlay?: boolean;
+      loop?: boolean;
+      progress?: number;
+      onAnimationFinish?: (isCancelled: boolean) => void;
+      [key: string]: unknown;
+    },
+    ref: React.Ref<{ play: (start?: number, end?: number) => void }>,
+  ) {
+    React.useImperativeHandle(ref, () => ({ play: vi.fn() }));
+    const { autoPlay, loop, progress, onAnimationFinish, ...rest } = props;
+    return React.createElement("LottieView", {
+      ...rest,
+      autoPlay,
+      loop,
+      progress,
+      onAnimationFinish,
+    });
+  });
+  return {
+    __esModule: true,
+    default: LottieView,
+  };
+});
+
+vi.mock("react-native-svg", () => {
+  // Host stub forwarding all props + children so tests can probe
+  // testIDs, stroke colors, and nesting without real SVG rendering.
+  function SvgHost(props: {
+    testID?: string;
+    children?: React.ReactNode;
+    [key: string]: unknown;
+  }) {
+    const { children, ...rest } = props;
+    return React.createElement("Svg", rest, children);
+  }
+  return {
+    __esModule: true,
+    default: SvgHost,
+    SvgXml: SvgHost,
+    Svg: SvgHost,
+    Path: SvgHost,
+    Rect: SvgHost,
+    Circle: SvgHost,
+    Ellipse: SvgHost,
+    Mask: SvgHost,
+    G: SvgHost,
+    Defs: SvgHost,
+    ClipPath: SvgHost,
+  };
+});
+
+vi.mock("react-native-safe-area-context", () => {
+  // Forwards all props (onLayout, pointerEvents, …) — screens use the
+  // root SafeAreaView for layout measurement, not just styling.
+  function SafeAreaView(props: AnyProps) {
+    const {
+      children,
+      edges: _edges,
+      ...rest
+    } = props as AnyProps & {
+      edges?: unknown;
+    };
+    return React.createElement("View", rest, children);
+  }
+  return {
+    __esModule: true,
+    SafeAreaView,
+    SafeAreaProvider: ({ children }: React.PropsWithChildren) => children,
+    useSafeAreaInsets: () => ({ top: 0, bottom: 0, left: 0, right: 0 }),
+  };
+});
+
+// `react-native-vision-camera` ships TurboModule + worklet bindings
+// that throw on import outside a real RN runtime. Replace with the
+// SDK's actual usage surface: a `<Camera>` host stub plus the hooks
+// the screens consume — `useCameraDevice`, `useCameraPermission`,
+// `useCameraFormat`, `useFrameProcessor`. Defaults to a granted
+// permission so the capture screen renders the preview branch in
+// tests. Tests that exercise the undetermined / denied branches
+// reset the mock per-test via `vi.mocked(useCameraPermission)`.
+vi.mock("react-native-vision-camera", () => {
+  function Camera(
+    props: AnyProps & {
+      device?: unknown;
+      isActive?: boolean;
+      photo?: boolean;
+    },
+  ) {
+    return React.createElement("Camera", {
+      testID: props.testID,
+      style: props.style,
+      device: props.device,
+      isActive: props.isActive,
+      photo: props.photo,
+    });
+  }
+  const fakeDevice = {
+    id: "test-front",
+    position: "front",
+    hasFlash: false,
+    hasTorch: false,
+    formats: [],
+    isMultiCam: false,
+    supportsRawCapture: false,
+    supportsLowLightBoost: false,
+    supportsFocus: true,
+    name: "Front Camera (test)",
+  };
+  Object.defineProperty(Camera, "getCameraPermissionStatus", {
+    value: vi.fn(() => "granted"),
+  });
+  Object.defineProperty(Camera, "requestCameraPermission", {
+    value: vi.fn(async () => "granted"),
+  });
+  return {
+    __esModule: true,
+    Camera,
+    useCameraDevice: vi.fn(() => fakeDevice),
+    useCameraFormat: vi.fn(() => undefined),
+    useCameraPermission: vi.fn(() => ({
+      hasPermission: true,
+      requestPermission: vi.fn(async () => true),
+    })),
+    useFrameProcessor: vi.fn(() => undefined),
+    // Frame-processor-plugin registry surface. Defaults to a plugin
+    // whose `call` returns an empty map; tests that exercise the
+    // missing-plugin branch override via
+    // `vi.mocked(VisionCameraProxy.initFrameProcessorPlugin)`.
+    VisionCameraProxy: {
+      initFrameProcessorPlugin: vi.fn(() => ({
+        call: vi.fn(() => ({})),
+      })),
+    },
+  };
+});
+
+// `react-native-worklets-core` registers a Reanimated-style runtime
+// at import. In tests we only need `Worklets.createRunOnJS` to be
+// callable and return a passthrough function.
+vi.mock("react-native-worklets-core", () => ({
+  __esModule: true,
+  Worklets: {
+    createRunOnJS:
+      <Args extends unknown[]>(fn: (...args: Args) => unknown) =>
+      (...args: Args) =>
+        fn(...args),
+  },
+}));
+
+// `expo-brightness` and `expo-keep-awake` are wrapped by the
+// `ForceMaxBrightness` component — provide controllable mocks so tests
+// can assert the lifecycle calls. The default exports a stable
+// `getBrightnessAsync` returning a known sentinel (0.5) and a
+// `setBrightnessAsync` spy. Tests that need to inspect call counts
+// import the mocked module via `vi.mocked(...)`.
+vi.mock("expo-brightness", () => ({
+  __esModule: true,
+  getBrightnessAsync: vi.fn(async () => 0.5),
+  setBrightnessAsync: vi.fn(async (_v: number) => {}),
+}));
+
+vi.mock("expo-keep-awake", () => ({
+  __esModule: true,
+  activateKeepAwakeAsync: vi.fn(async (_tag?: string) => {}),
+  deactivateKeepAwake: vi.fn((_tag?: string) => {}),
+}));
+
+// `expo-font` is dynamically imported by `useUseSmileIDFonts` when a
+// flow mounts. Stub the loader so tests that mount a flow never reach
+// the real native font registry.
+vi.mock("expo-font", () => ({
+  __esModule: true,
+  loadAsync: vi.fn(async (_map: Record<string, number>) => {}),
+}));
+
+// `expo-haptics` is fired imperatively by the capture screen on a
+// completed ESS head turn. Stub the impact / notification APIs and the
+// style enums so tests can assert which haptic fired without a native
+// taptic engine.
+vi.mock("expo-haptics", () => ({
+  __esModule: true,
+  impactAsync: vi.fn(async (_style?: string) => {}),
+  notificationAsync: vi.fn(async (_type?: string) => {}),
+  ImpactFeedbackStyle: {
+    Light: "light",
+    Medium: "medium",
+    Heavy: "heavy",
+    Soft: "soft",
+    Rigid: "rigid",
+  },
+  NotificationFeedbackType: {
+    Success: "success",
+    Warning: "warning",
+    Error: "error",
+  },
+}));
+
+// `expo-screen-orientation` drives the document capture orientation lock.
+// Its entry pulls in `expo-modules-core`, which references the RN `__DEV__`
+// global at import — stub the surface the lock hook uses.
+vi.mock("expo-screen-orientation", () => ({
+  __esModule: true,
+  OrientationLock: {
+    DEFAULT: 0,
+    ALL: 1,
+    PORTRAIT: 2,
+    PORTRAIT_UP: 3,
+    PORTRAIT_DOWN: 4,
+    LANDSCAPE: 5,
+    LANDSCAPE_LEFT: 6,
+    LANDSCAPE_RIGHT: 7,
+  },
+  lockAsync: vi.fn(async (_lock: number) => {}),
+  unlockAsync: vi.fn(async () => {}),
+  getOrientationAsync: vi.fn(async () => 1),
+}));
+
+// `expo-image-picker` backs the document gallery-upload control. Defaults to
+// a cancelled pick so a triggered upload is a no-op in tests.
+vi.mock("expo-image-picker", () => ({
+  __esModule: true,
+  requestMediaLibraryPermissionsAsync: vi.fn(async () => ({
+    granted: true,
+    status: "granted",
+  })),
+  launchImageLibraryAsync: vi.fn(async () => ({
+    canceled: true,
+    assets: null,
+  })),
+}));
+
+// `expo-image-manipulator` resamples imported document images. The chained
+// context returns a stable fake result; tests don't exercise the bytes.
+vi.mock("expo-image-manipulator", () => ({
+  __esModule: true,
+  SaveFormat: { JPEG: "jpeg", PNG: "png", WEBP: "webp" },
+  ImageManipulator: {
+    manipulate: vi.fn((_uri: string) => {
+      const context = {
+        resize: vi.fn(() => context),
+        rotate: vi.fn(() => context),
+        renderAsync: vi.fn(async () => ({
+          saveAsync: vi.fn(async () => ({
+            uri: "file:///mock/resampled.jpg",
+            width: 1600,
+            height: 1000,
+          })),
+        })),
+      };
+      return context;
+    }),
+  },
+}));
+
+// `expo-file-system` (new synchronous `File` / `Directory` API) writes the
+// canonical per-side artifact. Stub the constructors + accessors used.
+vi.mock("expo-file-system", () => {
+  class Directory {
+    readonly exists = true;
+    readonly uri = "file:///mock/cache/usesmileid_documents/";
+    create(_options?: unknown): void {}
+  }
+  class File {
+    readonly exists = false;
+    readonly uri = "file:///mock/cache/usesmileid_documents/document_front.jpg";
+    delete(): void {}
+    move(_destination: unknown): void {}
+  }
+  return {
+    __esModule: true,
+    Directory,
+    File,
+    Paths: { cache: new Directory() },
+  };
+});
+
+// `@sentry/react` is the actual import for `UseSmileIDCrashReporting`
+// (lives in `usesmileid_bridge`). `@sentry/browser`'s default integrations
+// install process-global hooks at `BrowserClient` construction time —
+// stubbed here so tests that exercise the SDK's flow don't accidentally
+// register globals or attempt network sends.
+vi.mock("@sentry/react", () => {
+  const noop = () => {};
+  function BrowserClient(this: unknown, _options: unknown) {
+    return {
+      init: noop,
+      close: () => Promise.resolve(true),
+    };
+  }
+  function Scope(this: unknown) {
+    return {
+      setClient: noop,
+      setTag: noop,
+      captureException: noop,
+      captureMessage: noop,
+      getClient: () => undefined,
+    };
+  }
+  return {
+    __esModule: true,
+    BrowserClient,
+    Scope,
+    defaultStackParser: noop,
+    makeFetchTransport: noop,
+  };
+});
+
+// Legacy `@sentry/react-native` mock retained for any partner-style
+// tests that simulate the partner's own Sentry usage. The SDK itself
+// no longer imports from `@sentry/react-native` (it uses `@sentry/react`
+// above), but leaving this mock in place keeps the import chain clean
+// if a test fixture references the partner-facing module.
+vi.mock("@sentry/react-native", () => {
+  const noop = () => {};
+  return {
+    __esModule: true,
+    init: noop,
+    close: noop,
+    captureException: noop,
+    captureMessage: noop,
+    addBreadcrumb: noop,
+    setUser: noop,
+    setTag: noop,
+    setContext: noop,
+    setExtra: noop,
+    withScope: (fn: (scope: unknown) => void) => fn({}),
+    Severity: { Error: "error", Warning: "warning", Info: "info" },
+  };
+});