@smileid/usesmileid 12.0.0-beta01 → 12.0.1

package/src/presentation/utils/locale_utils.ts

@@ -1,3 +1,4 @@
+import { GlobalPrivacyControl } from "../../core/models/global_privacy_control";
 const EU_COUNTRY_CODES: ReadonlySet<string> = new Set([
   "AT",
   "BE",
@@ -59,13 +60,21 @@ export function isDeviceLocaleInEU(
 }
 
 /**
- * Returns the default consent checkbox state based on the device locale.
+ * Returns the default consent checkbox state for the partner-declared
+ * `GlobalPrivacyControl` posture.
  *
- * - EU locales: unticked (`false`) to comply with GDPR opt-in.
- * - Non-EU locales: ticked (`true`).
+ * - `GlobalPrivacyControl.OptOut` (default): ticked (`true`) universally —
+ *   the opt-out layout is enforced for every session and the device region
+ *   is never consulted.
+ * - `GlobalPrivacyControl.OptIn`: legacy regional mechanics — EU locales
+ *   start unticked (`false`, explicit opt-in per GDPR), everywhere else
+ *   starts ticked (`true`).
  */
 export function getDefaultConsentState(
+  globalPrivacyControl: GlobalPrivacyControl = GlobalPrivacyControl.OptOut,
   locale: string = getDeviceLocale(),
 ): boolean {
-  return !isDeviceLocaleInEU(locale);
+  return globalPrivacyControl === GlobalPrivacyControl.OptOut
+    ? true
+    : !isDeviceLocaleInEU(locale);
 }

package/src/testing/__tests__/fake_face_analyzer.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it } from "vitest";
+import { makeFakeFaceAnalyzer } from "../fake_face_analyzer";
+
+const scenario = {
+  name: "selfie-happy-path",
+  captureType: "selfie",
+  steps: [
+    { emit: "noFace", holdFrames: 2 },
+    { emit: "faceCentered", holdFrames: 3 },
+    { emit: "satisfied" },
+  ],
+} as const;
+
+describe("FakeFaceAnalyzer", () => {
+  it("replays holdFrames per step and repeats the final step indefinitely", () => {
+    const fake = makeFakeFaceAnalyzer(scenario);
+    const emits = Array.from({ length: 9 }, () => fake.nextEmit());
+    expect(emits).toEqual([
+      "noFace",
+      "noFace",
+      "faceCentered",
+      "faceCentered",
+      "faceCentered",
+      "satisfied",
+      "satisfied",
+      "satisfied",
+      "satisfied",
+    ]);
+  });
+
+  it("records the JS lifecycle calls", async () => {
+    const fake = makeFakeFaceAnalyzer(scenario);
+    await fake.configure();
+    await fake.reset();
+    await fake.flush();
+    await fake.close();
+    expect(fake.configureCallCount).toBe(1);
+    expect(fake.resetCallCount).toBe(1);
+    expect(fake.flushCallCount).toBe(1);
+    expect(fake.closeCallCount).toBe(1);
+  });
+});

package/src/testing/__tests__/scenario_expectations.test.ts

@@ -0,0 +1,110 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+import {
+  expectSubsetInOrder,
+  parseScenarioExpectations,
+} from "../scenario_expectations";
+
+// Read the canonical shared scenario at run time (see the capture-screen test
+// for the same rationale) so a drift in the shared `expected` block is caught
+// here per-PR rather than silently diverging.
+const scenarioDir = dirname(fileURLToPath(import.meta.url));
+const selfieScenario = JSON.parse(
+  readFileSync(
+    join(scenarioDir, "../../../../e2e/scenarios/selfie-happy-path.json"),
+    "utf8",
+  ),
+) as unknown;
+
+const agentModeScenario = JSON.parse(
+  readFileSync(
+    join(scenarioDir, "../../../../e2e/scenarios/selfie-agent-mode.json"),
+    "utf8",
+  ),
+) as unknown;
+
+describe("parseScenarioExpectations", () => {
+  // Nothing is relaxed for the agent, so the shared script must carry the same
+  // terminal contract as the front-camera happy path.
+  it("gives the shared agent-mode scenario the same terminal contract as the happy path", () => {
+    const agentMode = parseScenarioExpectations(agentModeScenario);
+    const happyPath = parseScenarioExpectations(selfieScenario);
+    expect(agentMode.screens).toEqual(happyPath.screens);
+    expect(agentMode.events).toEqual(happyPath.events);
+    expect(agentMode.terminal).toBe("submitted");
+  });
+
+  it("surfaces the shared selfie scenario's expected screens/events/terminal", () => {
+    const expected = parseScenarioExpectations(selfieScenario);
+    expect(expected.screens).toEqual([
+      "consent",
+      "instructions",
+      "capture",
+      "preview",
+      "processing",
+    ]);
+    expect(expected.events).toEqual([
+      "flow_started",
+      "consent_captured",
+      "selfie_captured",
+      "job_submitted",
+      "flow_completed",
+    ]);
+    expect(expected.terminal).toBe("submitted");
+  });
+
+  it("defaults to empty arrays when the block is absent", () => {
+    const expected = parseScenarioExpectations({ name: "x" });
+    expect(expected.screens).toEqual([]);
+    expect(expected.events).toEqual([]);
+  });
+
+  it("rejects a malformed expected block", () => {
+    expect(() =>
+      parseScenarioExpectations({ expected: { screens: [1, 2] } }),
+    ).toThrow(/must be an array of strings/);
+    expect(() =>
+      parseScenarioExpectations({ expected: { terminal: "exploded" } }),
+    ).toThrow(/terminal must be one of/);
+  });
+});
+
+describe("expectSubsetInOrder", () => {
+  it("passes when every expected item appears in order (interleaving allowed)", () => {
+    const { screens, events } = parseScenarioExpectations(selfieScenario);
+    // Recorded stream may carry extra, unlisted events between the required
+    // ones — the contract is subset-in-order, not exact match.
+    const recordedEvents = [
+      "flow_started",
+      "screen_viewed",
+      "consent_captured",
+      "screen_viewed",
+      "selfie_captured",
+      "image_quality_ok",
+      "job_submitted",
+      "flow_completed",
+    ];
+    expect(() => expectSubsetInOrder(recordedEvents, events)).not.toThrow();
+    expect(() => expectSubsetInOrder([...screens], screens)).not.toThrow();
+  });
+
+  it("throws when an expected item is missing", () => {
+    expect(() =>
+      expectSubsetInOrder(
+        ["flow_started", "flow_completed"],
+        ["flow_started", "job_submitted", "flow_completed"],
+      ),
+    ).toThrow(/job_submitted/);
+  });
+
+  it("throws when expected items appear out of order", () => {
+    expect(() =>
+      expectSubsetInOrder(
+        ["flow_completed", "flow_started"],
+        ["flow_started", "flow_completed"],
+      ),
+    ).toThrow(/to appear in order/);
+  });
+});

package/src/testing/__tests__/scenario_loader.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from "vitest";
+import { parseScriptedScenario } from "../scenario_loader";
+
+describe("parseScriptedScenario", () => {
+  const valid = {
+    name: "selfie-happy-path",
+    captureType: "selfie",
+    steps: [
+      { emit: "noFace", holdFrames: 10 },
+      { emit: "faceCentered", holdFrames: 20 },
+      { emit: "satisfied" },
+    ],
+    // An `expected` block may ride alongside; the loader ignores extra keys.
+    expected: { screens: [], events: [], terminal: "submitted" },
+  };
+
+  it("returns the typed scenario for a valid shape", () => {
+    const scenario = parseScriptedScenario(valid);
+    expect(scenario.name).toBe("selfie-happy-path");
+    expect(scenario.captureType).toBe("selfie");
+    expect(scenario.steps).toHaveLength(3);
+    expect(scenario.steps[2]).toEqual({ emit: "satisfied" });
+  });
+
+  it("rejects an unknown emit (vocabulary drift)", () => {
+    expect(() =>
+      parseScriptedScenario({
+        name: "x",
+        captureType: "selfie",
+        steps: [{ emit: "wink" }],
+      }),
+    ).toThrow(/not a known emission/);
+  });
+
+  it("rejects an unknown captureType", () => {
+    expect(() =>
+      parseScriptedScenario({
+        name: "x",
+        captureType: "iris",
+        steps: [{ emit: "noFace" }],
+      }),
+    ).toThrow(/captureType/);
+  });
+
+  it("rejects empty steps", () => {
+    expect(() =>
+      parseScriptedScenario({ name: "x", captureType: "selfie", steps: [] }),
+    ).toThrow(/non-empty/);
+  });
+
+  it("rejects a non-integer holdFrames", () => {
+    expect(() =>
+      parseScriptedScenario({
+        name: "x",
+        captureType: "selfie",
+        steps: [{ emit: "noFace", holdFrames: 1.5 }],
+      }),
+    ).toThrow(/holdFrames/);
+  });
+
+  it("rejects a non-object input", () => {
+    expect(() => parseScriptedScenario("nope")).toThrow(/JSON object/);
+  });
+});

package/src/testing/fake_face_analyzer.ts

@@ -0,0 +1,82 @@
+import type { FaceAnalyzer } from "@smileid/usesmileid_platform_interface";
+import { AnalyzerFactoryKey } from "@smileid/usesmileid_bridge";
+
+/**
+ * Deterministic fake face analyzer for scripted-scenario E2E runs. Exported
+ * only behind the `@smileid/usesmileid/testing` subpath so it cannot leak into
+ * partner production bundles.
+ *
+ * Per-frame detection runs in the provider's native frame-processor plugin
+ * (pixels never cross into JS), so `frameProcessorPluginName` points at a
+ * plugin that does not exist — the capture screen surfaces that as its
+ * camera-unavailable state. This fake covers the DSL registration seam and the
+ * capture-free flows; capture progression is driven via `onResult` instead.
+ */
+export interface ScriptedScenarioStep {
+  readonly emit: string;
+  readonly holdFrames?: number;
+}
+
+export interface ScriptedScenario {
+  readonly name: string;
+  readonly captureType: string;
+  readonly steps: readonly ScriptedScenarioStep[];
+}
+
+export class FakeFaceAnalyzer implements FaceAnalyzer {
+  readonly kind = "face" as const;
+  readonly key: AnalyzerFactoryKey = AnalyzerFactoryKey.MLKitFace;
+  readonly frameProcessorPluginName = "e2e-fake-face";
+
+  configureCallCount = 0;
+  resetCallCount = 0;
+  flushCallCount = 0;
+  closeCallCount = 0;
+
+  private stepIndex = 0;
+  private framesLeftInStep: number;
+
+  constructor(private readonly scenario: ScriptedScenario) {
+    this.framesLeftInStep = scenario.steps[0]?.holdFrames ?? 1;
+  }
+
+  /** Frame-by-frame cursor; the final step repeats indefinitely. */
+  nextEmit(): string {
+    const steps = this.scenario.steps;
+    const step = steps[this.stepIndex];
+    if (step === undefined) return "noFace";
+    if (this.stepIndex === steps.length - 1) return step.emit;
+    this.framesLeftInStep -= 1;
+    if (this.framesLeftInStep <= 0) {
+      this.stepIndex += 1;
+      this.framesLeftInStep = steps[this.stepIndex]?.holdFrames ?? 1;
+    }
+    return step.emit;
+  }
+
+  configure(): Promise<void> {
+    this.configureCallCount += 1;
+    return Promise.resolve();
+  }
+
+  reset(): Promise<void> {
+    this.resetCallCount += 1;
+    return Promise.resolve();
+  }
+
+  flush(): Promise<void> {
+    this.flushCallCount += 1;
+    return Promise.resolve();
+  }
+
+  close(): Promise<void> {
+    this.closeCallCount += 1;
+    return Promise.resolve();
+  }
+}
+
+export function makeFakeFaceAnalyzer(
+  scenario: ScriptedScenario,
+): FakeFaceAnalyzer {
+  return new FakeFaceAnalyzer(scenario);
+}

package/src/testing/index.ts

@@ -0,0 +1,15 @@
+// Test-support entry — exported behind the `@smileid/usesmileid/testing`
+// subpath only. Nothing here may be re-exported from the main index.
+export {
+  FakeFaceAnalyzer,
+  makeFakeFaceAnalyzer,
+  type ScriptedScenario,
+  type ScriptedScenarioStep,
+} from "./fake_face_analyzer";
+export { scriptedFaceScanResults } from "./scripted_scan_results";
+export { parseScriptedScenario } from "./scenario_loader";
+export {
+  type ScenarioExpectations,
+  parseScenarioExpectations,
+  expectSubsetInOrder,
+} from "./scenario_expectations";

package/src/testing/scenario_expectations.ts

@@ -0,0 +1,87 @@
+/**
+ * Capture-scoped expectations from the shared `e2e-scenarios` schema's `expected`
+ * block (screen + analytics-event names, terminal state). Framework-agnostic (no
+ * vitest/jest import) so a partner app's own e2e runner can reuse it.
+ */
+export interface ScenarioExpectations {
+  /** Ordered `screen_viewed` sequence for the canonical consent-first flow. */
+  readonly screens: readonly string[];
+  /** Ordered analytics event types that must fire (subset-in-order). */
+  readonly events: readonly string[];
+  /** How the capture session ends. */
+  readonly terminal?: "submitted" | "timeout" | "unsatisfied";
+}
+
+const TERMINALS: ReadonlySet<string> = new Set([
+  "submitted",
+  "timeout",
+  "unsatisfied",
+]);
+
+/**
+ * Extracts and validates the `expected` block from an already-parsed shared
+ * scenario JSON object. Returns empty screen/event arrays when the block is
+ * absent (older scenarios), and throws on a malformed block so drift fails
+ * loudly rather than silently weakening the contract.
+ */
+export function parseScenarioExpectations(raw: unknown): ScenarioExpectations {
+  if (typeof raw !== "object" || raw === null) {
+    throw new Error("scenario must be a JSON object");
+  }
+  const expected = (raw as Record<string, unknown>).expected;
+  if (expected === undefined) {
+    return { screens: [], events: [] };
+  }
+  if (typeof expected !== "object" || expected === null) {
+    throw new Error("scenario.expected must be an object when present");
+  }
+  const record = expected as Record<string, unknown>;
+  const screens = readStringArray(record.screens, "scenario.expected.screens");
+  const events = readStringArray(record.events, "scenario.expected.events");
+  const terminal = record.terminal;
+  if (terminal === undefined) {
+    return { screens, events };
+  }
+  if (typeof terminal !== "string" || !TERMINALS.has(terminal)) {
+    throw new Error(
+      `scenario.expected.terminal must be one of ${[...TERMINALS].join(", ")}, got ${String(terminal)}`,
+    );
+  }
+  return {
+    screens,
+    events,
+    terminal: terminal as "submitted" | "timeout" | "unsatisfied",
+  };
+}
+
+function readStringArray(value: unknown, label: string): readonly string[] {
+  if (value === undefined) return [];
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    throw new Error(`${label} must be an array of strings`);
+  }
+  return value as string[];
+}
+
+/**
+ * Asserts that every element of [expected] appears in [recorded] in the same
+ * relative order (a minimal ordered-subset match — unlisted items may
+ * interleave, exact-match is deliberately NOT required). Throws a descriptive
+ * Error on failure so it works under any test runner.
+ */
+export function expectSubsetInOrder(
+  recorded: readonly string[],
+  expected: readonly string[],
+  label = "sequence",
+): void {
+  let cursor = 0;
+  for (const item of recorded) {
+    if (cursor < expected.length && item === expected[cursor]) cursor += 1;
+  }
+  if (cursor !== expected.length) {
+    throw new Error(
+      `${label}: expected [${expected
+        .slice(cursor)
+        .join(", ")}] to appear in order within [${recorded.join(", ")}]`,
+    );
+  }
+}

package/src/testing/scenario_loader.ts

@@ -0,0 +1,83 @@
+import type {
+  ScriptedScenario,
+  ScriptedScenarioStep,
+} from "./fake_face_analyzer";
+
+/**
+ * Emission vocabulary of the shared `e2e-scenarios` schema (`schema.json` in
+ * every repo's scenario folder). A step whose `emit` is outside this set is a
+ * drift bug — the loader rejects it rather than letting the fake silently treat
+ * it as "no detection".
+ */
+const KNOWN_EMITS: ReadonlySet<string> = new Set([
+  "noFace",
+  "faceTooFar",
+  "faceCentered",
+  "headTurnLeft",
+  "headTurnRight",
+  "headTurnUp",
+  "satisfied",
+  "noDocument",
+  "documentFound",
+  "documentUnstable",
+]);
+
+const CAPTURE_TYPES: ReadonlySet<string> = new Set(["selfie", "document"]);
+
+/**
+ * Validates a parsed shared-scenario JSON object and returns the typed
+ * [ScriptedScenario]. Kept I/O-free (takes an already-parsed object) so the
+ * `@smileid/usesmileid/testing` subpath stays environment-agnostic — the caller
+ * owns how the JSON is read. Throws with a specific message on any shape drift
+ * so a malformed or vocabulary-drifted script fails loudly at load time instead
+ * of producing a misleading capture sequence.
+ */
+export function parseScriptedScenario(raw: unknown): ScriptedScenario {
+  if (typeof raw !== "object" || raw === null) {
+    throw new Error("scenario must be a JSON object");
+  }
+  const record = raw as Record<string, unknown>;
+
+  const name = record.name;
+  if (typeof name !== "string" || name.length === 0) {
+    throw new Error("scenario.name must be a non-empty string");
+  }
+
+  const captureType = record.captureType;
+  if (typeof captureType !== "string" || !CAPTURE_TYPES.has(captureType)) {
+    throw new Error(
+      `scenario.captureType must be one of ${[...CAPTURE_TYPES].join(", ")}, got ${String(captureType)}`,
+    );
+  }
+
+  if (!Array.isArray(record.steps) || record.steps.length === 0) {
+    throw new Error(`scenario.steps must be a non-empty array in ${name}`);
+  }
+
+  const steps: ScriptedScenarioStep[] = record.steps.map((step, index) => {
+    if (typeof step !== "object" || step === null) {
+      throw new Error(`scenario.steps[${index}] must be an object in ${name}`);
+    }
+    const stepRecord = step as Record<string, unknown>;
+    const emit = stepRecord.emit;
+    if (typeof emit !== "string" || !KNOWN_EMITS.has(emit)) {
+      throw new Error(
+        `scenario.steps[${index}].emit "${String(emit)}" is not a known emission in ${name}`,
+      );
+    }
+    const holdFrames = stepRecord.holdFrames;
+    if (
+      holdFrames !== undefined &&
+      (typeof holdFrames !== "number" ||
+        !Number.isInteger(holdFrames) ||
+        holdFrames < 1)
+    ) {
+      throw new Error(
+        `scenario.steps[${index}].holdFrames must be a positive integer in ${name}`,
+      );
+    }
+    return holdFrames === undefined ? { emit } : { emit, holdFrames };
+  });
+
+  return { name, captureType, steps };
+}

package/src/testing/scripted_scan_results.ts

@@ -0,0 +1,66 @@
+import {
+  CaptureReadyEventKind,
+  UseSmileIDScanStateType,
+} from "@smileid/usesmileid_bridge";
+import type {
+  CaptureReadyEvent,
+  FaceScanResult,
+} from "@smileid/usesmileid_bridge";
+import type { ScriptedScenario } from "./fake_face_analyzer";
+
+/**
+ * Turns a shared E2E scenario into the `FaceScanResult` sequence a capture
+ * screen receives frame-by-frame, so a headless test can replay the shared
+ * script through the frame stream's `onResult` seam (per-frame detection is a
+ * native frame-processor concern; pixels never reach JS).
+ *
+ * `noFace` → `initial`; `faceTooFar` / `faceCentered` → `found`; the terminal
+ * `satisfied` → one `finished` result carrying a `selfie` event plus
+ * [livenessCount] `liveness` events at opaque `file://` URLs the screen never
+ * reads. Exported only behind the `@smileid/usesmileid/testing` subpath.
+ */
+export function scriptedFaceScanResults(
+  scenario: ScriptedScenario,
+  options: { readonly livenessCount?: number } = {},
+): FaceScanResult[] {
+  const livenessCount = options.livenessCount ?? 2;
+  const output: FaceScanResult["output"] = { faces: [], brightness: 128 };
+  const results: FaceScanResult[] = [];
+
+  for (const step of scenario.steps) {
+    if (step.emit === "satisfied") {
+      results.push({
+        output,
+        state: { type: UseSmileIDScanStateType.Finished },
+        capturedEvents: captureEvents(livenessCount),
+      });
+      return results;
+    }
+    const type =
+      step.emit === "noFace"
+        ? UseSmileIDScanStateType.Initial
+        : UseSmileIDScanStateType.Found;
+    for (let frame = 0; frame < (step.holdFrames ?? 1); frame++) {
+      results.push({ output, state: { type }, capturedEvents: [] });
+    }
+  }
+  return results;
+}
+
+function captureEvents(livenessCount: number): CaptureReadyEvent[] {
+  const events: CaptureReadyEvent[] = [
+    {
+      kind: CaptureReadyEventKind.Selfie,
+      captureIndex: 0,
+      url: "file://selfie-0.jpg",
+    },
+  ];
+  for (let index = 1; index <= livenessCount; index++) {
+    events.push({
+      kind: CaptureReadyEventKind.Liveness,
+      captureIndex: index,
+      url: `file://liveness-${index}.jpg`,
+    });
+  }
+  return events;
+}

package/dist/camera/frame_processor_plugin.d.ts

@@ -1,28 +0,0 @@
-import type { HybridObject } from "react-native-nitro-modules";
-import type { Frame } from "react-native-vision-camera";
-/**
- * A provider's frame-processor Nitro HybridObject. Each provider module
- * registers a platform-native implementation (Swift on iOS, Kotlin on
- * Android) under its `frameProcessorPluginName`; the SDK resolves it by
- * that key with {@link resolveFrameProcessorPlugin}.
- *
- * `call` runs the provider's scan session on the frame and returns the
- * scan-result map serialised as a JSON string — pixels never enter JS.
- * Frame-level failures return `{"error":"<reason>"}`; absent optional
- * keys are omitted (never `null`). The worklet must `dispose()` the
- * frame after the call.
- */
-export interface UseSmileIDFrameProcessorPlugin extends HybridObject<{}> {
-    call(frame: Frame, rotation: number): string;
-}
-/**
- * Resolve a provider's frame-processor HybridObject by name, or `null`
- * if it isn't registered natively.
- *
- * VisionCamera v5's `NitroModules.createHybridObject(...)` throws when the
- * key is missing (v4's `VisionCameraProxy.initFrameProcessorPlugin`
- * returned `null`). The throw is mapped back to `null` here so callers
- * keep the v4 report-once-then-no-op behaviour for a missing plugin.
- */
-export declare function resolveFrameProcessorPlugin(name: string): UseSmileIDFrameProcessorPlugin | null;
-//# sourceMappingURL=frame_processor_plugin.d.ts.map

package/dist/camera/frame_processor_plugin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"frame_processor_plugin.d.ts","sourceRoot":"","sources":["../../src/camera/frame_processor_plugin.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAC;AAExD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,8BAA+B,SAAQ,YAAY,CAAC,EAAE,CAAC;IACtE,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;CAC9C;AAED;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,MAAM,GACX,8BAA8B,GAAG,IAAI,CAUvC"}

package/dist/camera/frame_processor_plugin.js

@@ -1,21 +0,0 @@
-import { NitroModules } from "react-native-nitro-modules";
-/**
- * Resolve a provider's frame-processor HybridObject by name, or `null`
- * if it isn't registered natively.
- *
- * VisionCamera v5's `NitroModules.createHybridObject(...)` throws when the
- * key is missing (v4's `VisionCameraProxy.initFrameProcessorPlugin`
- * returned `null`). The throw is mapped back to `null` here so callers
- * keep the v4 report-once-then-no-op behaviour for a missing plugin.
- */
-export function resolveFrameProcessorPlugin(name) {
-    try {
-        return NitroModules.createHybridObject(name);
-    }
-    catch {
-        // Not registered natively — the caller surfaces a typed
-        // FrameProcessorPluginNotRegisteredException once on its own.
-        return null;
-    }
-}
-//# sourceMappingURL=frame_processor_plugin.js.map

package/dist/camera/frame_processor_plugin.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"frame_processor_plugin.js","sourceRoot":"","sources":["../../src/camera/frame_processor_plugin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAoB1D;;;;;;;;GAQG;AACH,MAAM,UAAU,2BAA2B,CACzC,IAAY;IAEZ,IAAI,CAAC;QACH,OAAO,YAAY,CAAC,kBAAkB,CACpC,IAAI,CACL,CAAC;IACJ,CAAC;IAAC,MAAM,CAAC;QACP,wDAAwD;QACxD,8DAA8D;QAC9D,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC"}

package/dist/camera/use_smile_id_frame_processor.d.ts

@@ -1,38 +0,0 @@
-import type { HybridObject } from "react-native-nitro-modules";
-import type { Frame } from "react-native-vision-camera";
-/**
- * Shared shape of every provider's native VisionCamera v5 Nitro
- * frame-processor HybridObject.
- *
- * Each provider package (`usesmileid_vision_face`,
- * `usesmileid_mlkit_face`, …) ships a Nitro `HybridObject`
- * implementation registered — via Nitro autolinking — under the name
- * the analyzer exposes as `frameProcessorPluginName`. The camera layer
- * resolves it by that name with
- * `NitroModules.createHybridObject<UseSmileIDFrameProcessor>(name)`,
- * keeping the cross-bridge identifier in the single per-provider
- * `identifiers` registry (no second string literal here).
- *
- * `call` runs the provider's native scan session on the frame and
- * returns the scan-result map serialised as JSON — pixels never enter
- * the JS runtime. Frame-level failures return `{"error":"<reason>"}`.
- * The JSON is parsed and Zod-validated on the JS thread by
- * `useSmileIDFrameStream`; absent optional keys are omitted natively
- * (never serialised as `null`, which the wire schemas reject).
- *
- * The platform tag here is only structural — it satisfies the
- * `createHybridObject` generic bound. Each provider's own `.nitro.ts`
- * spec declares its real (iOS-only or Android-only) platform.
- */
-export interface UseSmileIDFrameProcessor extends HybridObject<{
-    ios: "swift";
-    android: "kotlin";
-}> {
-    /**
-     * Run the native scan on `frame` with the physical device tilt
-     * `rotation` (clockwise degrees, `0` = upright portrait). Returns the
-     * scan-result map as a JSON string.
-     */
-    call(frame: Frame, rotation: number): string;
-}
-//# sourceMappingURL=use_smile_id_frame_processor.d.ts.map