@smileid/usesmileid 12.0.2 → 12.1.0

package/src/__tests__/enum_parity.test.ts

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

@@ -1,240 +0,0 @@
-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";
-
-// Portrait window by default — the capture screen reads this for its
-// iOS preview-remount key (`cameraOrientationKey`); tests don't assert on
-// the key, so a stable portrait size just lets the component render.
-export const useWindowDimensions = (): { width: number; height: number } => ({
-  width: 390,
-  height: 844,
-});
-
-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: () => {} }),
-};
-
-const appStateListeners = new Set<(state: string) => void>();
-
-export const AppState: {
-  currentState: string;
-  addEventListener: (
-    type: string,
-    listener: (state: string) => void,
-  ) => { remove: () => void };
-  emit: (state: string) => void;
-} = {
-  currentState: "active",
-  addEventListener: (_type, listener) => {
-    appStateListeners.add(listener);
-    return { remove: () => appStateListeners.delete(listener) };
-  },
-  // Test-only hook — no `AppState.emit` exists in React Native.
-  emit: (state) => {
-    AppState.currentState = state;
-    for (const listener of appStateListeners) listener(state);
-  },
-};
-
-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

@@ -1,368 +0,0 @@
-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)`.
-// Stand-in for `CameraRef.takePhoto`, so tests can drive the manual shutter.
-// Reset per test by the shared `vi.clearAllMocks()`/`resetAllMocks()` hooks.
-export const mockedTakePhoto = vi.fn(async () => ({
-  path: "/tmp/manual-shutter.jpg",
-  width: 1600,
-  height: 1200,
-}));
-
-vi.mock("react-native-vision-camera", () => {
-  const Camera = React.forwardRef(function Camera(
-    props: AnyProps & {
-      device?: unknown;
-      isActive?: boolean;
-      photo?: boolean;
-    },
-    ref: React.Ref<unknown>,
-  ) {
-    // The screen reaches `takePhoto` through this ref; without it the manual
-    // shutter handler bails on a null camera and can't be tested.
-    React.useImperativeHandle(ref, () => ({ takePhoto: mockedTakePhoto }), []);
-    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),
-  // Defaults to a permissive host build; the lock preflight's unsupported
-  // path is opted into per-test.
-  supportsOrientationLockAsync: vi.fn(async (_lock: number) => true),
-}));
-
-// `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" },
-  };
-});