react-native-image-stitcher 0.15.2 → 0.16.0

package/src/camera/__tests__/useContentRotation.test.ts

@@ -1,89 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Unit tests for `contentRotationDeg` — the pure rotation computation
- * behind `useContentRotation`, which keeps control content (AR toggle,
- * lens/zoom pill, flash, thumbnails) upright relative to gravity
- * regardless of host portrait-lock state.
- *
- * Covers the full truth table from the hook's docstring plus the
- * mid-rotation transients (jsLandscape=true with a non-landscape device
- * reading, which can briefly happen while the OS catches up).
- *
- * Pure-TS test per jest.config.js.  `useContentRotation` transitively
- * imports `useDeviceOrientation` → `react-native-sensors` (an ES module
- * the no-RN-preset jest infra can't parse), so stub it before importing
- * the SUT.  We only call the pure `contentRotationDeg` export.
- */
-
-jest.mock('react-native-sensors', () => ({
-  accelerometer: { subscribe: jest.fn(() => ({ unsubscribe: jest.fn() })) },
-  gyroscope: { subscribe: jest.fn(() => ({ unsubscribe: jest.fn() })) },
-  setUpdateIntervalForType: jest.fn(),
-  SensorTypes: { accelerometer: 'accelerometer', gyroscope: 'gyroscope' },
-}));
-
-import { contentRotationDeg } from '../useContentRotation';
-
-describe('contentRotationDeg', () => {
-  // Locked-portrait host: jsLandscape is ALWAYS false (window dims stay
-  // portrait regardless of device tilt).  The OS doesn't rotate the
-  // framebuffer, so content rotation must match device-physical for
-  // labels to read upright.  THIS is the case task #5b targets.
-
-  it('locked-portrait + device-portrait → 0° (no-op)', () => {
-    expect(contentRotationDeg(false, 'portrait')).toBe(0);
-  });
-
-  it('locked-portrait + device-landscape-left → 90° (CW)', () => {
-    expect(contentRotationDeg(false, 'landscape-left')).toBe(90);
-  });
-
-  it('locked-portrait + device-landscape-right → -90° (CCW)', () => {
-    expect(contentRotationDeg(false, 'landscape-right')).toBe(-90);
-  });
-
-  it('locked-portrait + device-upside-down → 180°', () => {
-    expect(contentRotationDeg(false, 'portrait-upside-down')).toBe(180);
-  });
-
-  // Non-locked host + device-landscape: OS rotated the framebuffer for
-  // us; we must NOT double-rotate.  Net rotation must be 0.
-
-  it('non-locked + device-landscape-left (jsLandscape=true) → 0°', () => {
-    expect(contentRotationDeg(true, 'landscape-left')).toBe(0);
-  });
-
-  it('non-locked + device-landscape-right (jsLandscape=true) → 0°', () => {
-    expect(contentRotationDeg(true, 'landscape-right')).toBe(0);
-  });
-
-  it('non-locked + device-portrait (jsLandscape=false) → 0°', () => {
-    expect(contentRotationDeg(false, 'portrait')).toBe(0);
-  });
-
-  // Mid-rotation transients: jsLandscape=true with a non-landscape
-  // device reading.  Falls through to 0 framebuffer rotation and
-  // applies device rotation directly; settles once the transient clears.
-
-  it('jsLandscape=true mid-rotation with device-portrait → 0°', () => {
-    expect(contentRotationDeg(true, 'portrait')).toBe(0);
-  });
-
-  it('jsLandscape=true mid-rotation with device-upside-down → 180°', () => {
-    expect(contentRotationDeg(true, 'portrait-upside-down')).toBe(180);
-  });
-
-  it('all returned values are in {0, 90, -90, 180} (no off-by-360°)', () => {
-    const orientations = [
-      'portrait',
-      'portrait-upside-down',
-      'landscape-left',
-      'landscape-right',
-    ] as const;
-    for (const o of orientations) {
-      for (const jsl of [true, false]) {
-        expect([0, 90, -90, 180]).toContain(contentRotationDeg(jsl, o));
-      }
-    }
-  });
-});

package/src/camera/__tests__/useOrientationDrift.test.ts

@@ -1,169 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Unit tests for `useOrientationDrift` — exercises the pure
- * state-transition function `_computeDriftStateForTests` directly.
- *
- * Why not test the hook end-to-end via render: the lib's jest
- * config is `preset: 'ts-jest'` + `testEnvironment: 'node'` — no
- * React Native preset, no `@testing-library/react-native`.  See the
- * jest.config.js header comment: "If we ever add component-render
- * tests we'd flip to the RN preset then."  The component-render
- * tests for `<OrientationDriftModal>`, `<PanoramaBandOverlay>`,
- * `<ViewportCropOverlay>`, and `<Camera>` composition (all called
- * out in the v0.12 plan) will all need that flip.  Setting it up
- * is grouped in Phase 5 of the plan (Tests) rather than scattered
- * across each PR.  For PR-1, the pure state-transition function
- * carries the full behavioural contract — same approach
- * `useThrottledFrameProcessor.test.ts` uses for its throttle gate.
- *
- * The 5 cases below cover the full state machine per the plan
- * (lines 119, 277):
- *
- *   (a) no change → not drifted
- *   (b) orientation changes during active=true → drifted
- *   (c) drift state survives further changes (latching)
- *   (d) inactive → captureOrientation undefined
- *   (e) active resets snapshot (false → true → false → true cycle)
- */
-
-// Mock `react-native-sensors` BEFORE importing the SUT.  The hook
-// itself transitively pulls in `useDeviceOrientation` which imports
-// `accelerometer` from `react-native-sensors` — an ES module that
-// jest can't parse without the RN preset (which jest.config.js
-// intentionally avoids; see config header comment).  We're only
-// testing the pure transition function below, but TS imports are
-// transitive so we still need to silence the chain.
-jest.mock('react-native-sensors', () => ({
-  accelerometer: { subscribe: jest.fn(() => ({ unsubscribe: jest.fn() })) },
-  setUpdateIntervalForType: jest.fn(),
-  SensorTypes: { accelerometer: 'accelerometer' },
-}));
-
-// eslint-disable-next-line import/first
-import { _computeDriftStateForTests } from '../useOrientationDrift';
-
-const INITIAL = { captureOrientation: undefined, drifted: false };
-
-describe('_computeDriftStateForTests (useOrientationDrift core logic)', () => {
-  describe('(a) no change → not drifted', () => {
-    it('stays in initial state when active is false from the start', () => {
-      const next = _computeDriftStateForTests(INITIAL, false, 'portrait');
-      expect(next).toEqual({ captureOrientation: undefined, drifted: false });
-    });
-
-    it('snapshots orientation when active flips true, drifted starts false', () => {
-      const next = _computeDriftStateForTests(INITIAL, true, 'portrait');
-      expect(next).toEqual({ captureOrientation: 'portrait', drifted: false });
-    });
-
-    it('stays clean when active=true and orientation does not change', () => {
-      const after1 = _computeDriftStateForTests(INITIAL, true, 'portrait');
-      const after2 = _computeDriftStateForTests(after1, true, 'portrait');
-      const after3 = _computeDriftStateForTests(after2, true, 'portrait');
-      expect(after3).toEqual({ captureOrientation: 'portrait', drifted: false });
-      // Reference equality: once steady, returns the prev ref so
-      // React's setState becomes a no-op (no re-render).
-      expect(after2).toBe(after1);
-      expect(after3).toBe(after2);
-    });
-  });
-
-  describe('(b) orientation changes during active=true → drifted', () => {
-    it('latches drifted=true when orientation changes mid-active', () => {
-      const after1 = _computeDriftStateForTests(INITIAL, true, 'portrait');
-      const after2 = _computeDriftStateForTests(after1, true, 'landscape-left');
-      expect(after2).toEqual({ captureOrientation: 'portrait', drifted: true });
-    });
-
-    it('captures the ORIGINAL orientation in captureOrientation, not the new one', () => {
-      const after1 = _computeDriftStateForTests(INITIAL, true, 'portrait');
-      const after2 = _computeDriftStateForTests(after1, true, 'landscape-right');
-      // captureOrientation MUST remain the snapshot (portrait), not
-      // the current rotation — that's how the drift modal copy
-      // ("captured in PORTRAIT, now LANDSCAPE-RIGHT") works.
-      expect(after2.captureOrientation).toBe('portrait');
-    });
-
-    it('detects drift to any of the 3 other orientations', () => {
-      const cases: Array<['portrait', 'portrait-upside-down' | 'landscape-left' | 'landscape-right']> = [
-        ['portrait', 'portrait-upside-down'],
-        ['portrait', 'landscape-left'],
-        ['portrait', 'landscape-right'],
-      ];
-      for (const [captured, drifted] of cases) {
-        const after1 = _computeDriftStateForTests(INITIAL, true, captured);
-        const after2 = _computeDriftStateForTests(after1, true, drifted);
-        expect(after2.drifted).toBe(true);
-      }
-    });
-  });
-
-  describe('(c) drift state survives further changes (latching)', () => {
-    it('stays drifted even if the user rotates back to the captured orientation', () => {
-      // User rotates portrait → landscape (drift triggers) → portrait
-      // (back to original).  The flag MUST stay latched.  Rationale:
-      // the engine docstring says cross-mode capture is "best-effort,
-      // not supported" — a brief rotation pollutes the buffer even
-      // if the user rotates back, so the safe action is decisive
-      // abandonment regardless of post-detection orientation.
-      const after1 = _computeDriftStateForTests(INITIAL, true, 'portrait');
-      const after2 = _computeDriftStateForTests(after1, true, 'landscape-left');
-      const after3 = _computeDriftStateForTests(after2, true, 'portrait');
-      expect(after3).toEqual({ captureOrientation: 'portrait', drifted: true });
-    });
-
-    it('stays drifted across multiple subsequent orientation changes', () => {
-      const after1 = _computeDriftStateForTests(INITIAL, true, 'portrait');
-      const after2 = _computeDriftStateForTests(after1, true, 'landscape-left');
-      const after3 = _computeDriftStateForTests(after2, true, 'landscape-right');
-      const after4 = _computeDriftStateForTests(after3, true, 'portrait-upside-down');
-      expect(after4.drifted).toBe(true);
-      expect(after4.captureOrientation).toBe('portrait');
-    });
-  });
-
-  describe('(d) inactive → captureOrientation undefined', () => {
-    it('clears the snapshot when active flips back to false', () => {
-      const after1 = _computeDriftStateForTests(INITIAL, true, 'portrait');
-      const after2 = _computeDriftStateForTests(after1, false, 'portrait');
-      expect(after2).toEqual({ captureOrientation: undefined, drifted: false });
-    });
-
-    it('clears the drift flag when active flips back to false', () => {
-      const after1 = _computeDriftStateForTests(INITIAL, true, 'portrait');
-      const after2 = _computeDriftStateForTests(after1, true, 'landscape-left');
-      expect(after2.drifted).toBe(true);
-      const after3 = _computeDriftStateForTests(after2, false, 'landscape-left');
-      expect(after3).toEqual({ captureOrientation: undefined, drifted: false });
-    });
-
-    it('is idempotent — no state change when inactive and already clear', () => {
-      const after1 = _computeDriftStateForTests(INITIAL, false, 'portrait');
-      const after2 = _computeDriftStateForTests(after1, false, 'landscape-left');
-      // Same ref → setState becomes a no-op.
-      expect(after2).toBe(after1);
-    });
-  });
-
-  describe('(e) active resets snapshot', () => {
-    it('re-snapshots on a fresh active cycle (false → true → false → true)', () => {
-      // Cycle 1: capture in portrait, drift.
-      const c1a = _computeDriftStateForTests(INITIAL, true, 'portrait');
-      const c1b = _computeDriftStateForTests(c1a, true, 'landscape-left');
-      expect(c1b).toEqual({ captureOrientation: 'portrait', drifted: true });
-
-      // Stop the capture.
-      const cleared = _computeDriftStateForTests(c1b, false, 'landscape-left');
-      expect(cleared).toEqual({ captureOrientation: undefined, drifted: false });
-
-      // Cycle 2: re-capture, now in landscape-left.  Snapshot
-      // should be landscape-left, NOT carry over the old portrait.
-      const c2a = _computeDriftStateForTests(cleared, true, 'landscape-left');
-      expect(c2a).toEqual({ captureOrientation: 'landscape-left', drifted: false });
-
-      // And staying in landscape-left should not drift.
-      const c2b = _computeDriftStateForTests(c2a, true, 'landscape-left');
-      expect(c2b.drifted).toBe(false);
-    });
-  });
-});

package/src/stitching/__tests__/subscribeIncrementalState.refine.test.ts

@@ -1,276 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Unit + integration coverage for the v0.10.0 PR B refine-progress
- * lifecycle on the `IncrementalStateUpdate` channel.
- *
- * What this test is for:
- *
- *   - Contract: native emits a 4-stage sequence
- *     `validating → stitching → writing → done` (and the failure
- *     variant `validating → error`) with `refineStage` /
- *     `refineProgress` / `refineFrames` / `refineError` keys.
- *   - Regression: catches a future renamer of any of those keys
- *     (subscribeIncrementalState would silently deliver `undefined`
- *     for the missing fields, and the host's progress pill would
- *     stop rendering — exactly the bug class we hit on iOS in PR B
- *     before the bridgeless-interop fix).
- *
- * What this test is NOT for:
- *
- *   - Exercising the real native bridge — RCTEventEmitter under RN
- *     bridgeless interop can only be tested on-device.  The bug we
- *     fixed in PR B (sendEvent silently no-ops for certain body
- *     shapes) is verified via the manual smoke test recorded in
- *     CHANGELOG.md "Fixed — v0.10.0 PR B (iOS)".  This file pins
- *     the JS-side contract that bridge fix has to satisfy.
- *
- * Mock surface: per-test `jest.mock('react-native', ...)` so the
- * shared `jest.mocks/react-native.js` stays minimal (per the comment
- * in that file).  We stub `NativeModules.IncrementalStitcher` and
- * `NativeEventEmitter` together because `subscribeIncrementalState`
- * wires them together internally.
- */
-
-import type { IncrementalState } from '../incremental';
-
-// Hand-rolled event-emitter fake we can drive synchronously from
-// tests.  Modelled on RN's NativeEventEmitter shape: addListener
-// returns an object with a `.remove()` method.
-type Listener = (state: IncrementalState) => void;
-
-class FakeNativeEventEmitter {
-  private listeners: Map<string, Set<Listener>> = new Map();
-
-  constructor(_nativeModule: unknown) {
-    // No-op: real RN reads addListener/removeListeners off the
-    // native module for the listener-count contract; we don't.
-  }
-
-  addListener(eventType: string, listener: Listener) {
-    let set = this.listeners.get(eventType);
-    if (!set) {
-      set = new Set();
-      this.listeners.set(eventType, set);
-    }
-    set.add(listener);
-    return {
-      remove: () => {
-        set!.delete(listener);
-      },
-    };
-  }
-
-  // Test-only helper: drive an event into all subscribers.
-  _emit(eventType: string, state: IncrementalState) {
-    const set = this.listeners.get(eventType);
-    if (!set) return;
-    for (const listener of set) {
-      listener(state);
-    }
-  }
-}
-
-// Shared emitter handle the per-test setup writes its asserts
-// against.  The mock factory below has to construct via `new`, so we
-// stash the latest instance here for the test to drive.
-let lastEmitter: FakeNativeEventEmitter | null = null;
-
-jest.mock('react-native', () => ({
-  NativeModules: {
-    IncrementalStitcher: {
-      // RCTEventEmitter / NativeEventEmitter contract — RN's runtime
-      // calls these when JS subscribes / unsubscribes so the native
-      // side can track listener count.  We just stub them.
-      addListener: jest.fn(),
-      removeListeners: jest.fn(),
-    },
-  },
-  NativeEventEmitter: jest.fn().mockImplementation((nativeModule: unknown) => {
-    lastEmitter = new FakeNativeEventEmitter(nativeModule);
-    return lastEmitter;
-  }),
-  Platform: { OS: 'ios', select: (spec: { ios?: unknown; default?: unknown }) => spec.ios ?? spec.default },
-}));
-
-// Import AFTER jest.mock so the SUT picks up the mocked module.
-import { subscribeIncrementalState } from '../incremental';
-
-// Build the base state shape the native side emits — matches the
-// fields IncrementalStateObject.asDictionary() includes on iOS and
-// Arguments.createMap() includes on Android.
-function makeBaseState(): IncrementalState {
-  return {
-    width: 1920,
-    height: 1080,
-    acceptedCount: 3,
-    outcome: 8, // acceptedHigh
-    confidence: 0.92,
-    overlapPercent: 18.5,
-    processingMs: 0,
-    isLandscape: false,
-    paintedExtent: 1920,
-    panExtent: 1920,
-    keyframeMax: 0,
-  } as IncrementalState;
-}
-
-describe('subscribeIncrementalState — refine progress lifecycle (v0.10.0 PR B)', () => {
-  beforeEach(() => {
-    lastEmitter = null;
-    jest.clearAllMocks();
-  });
-
-  it('returns null when the native IncrementalStitcher module is missing', () => {
-    // Temporarily blank the module.
-    const RN = jest.requireMock('react-native') as { NativeModules: Record<string, unknown> };
-    const saved = RN.NativeModules.IncrementalStitcher;
-    RN.NativeModules.IncrementalStitcher = undefined;
-    try {
-      expect(subscribeIncrementalState(() => {})).toBeNull();
-    } finally {
-      RN.NativeModules.IncrementalStitcher = saved;
-    }
-  });
-
-  it('returns an EmitterSubscription when subscribed; remove() stops delivery', () => {
-    const events: IncrementalState[] = [];
-    const sub = subscribeIncrementalState((s) => events.push(s));
-    expect(sub).not.toBeNull();
-    expect(lastEmitter).not.toBeNull();
-
-    lastEmitter!._emit('IncrementalStateUpdate', {
-      ...makeBaseState(),
-      refineStage: 'validating',
-      refineProgress: 0.05,
-      refineFrames: 3,
-    } as IncrementalState);
-    expect(events).toHaveLength(1);
-
-    sub!.remove();
-    lastEmitter!._emit('IncrementalStateUpdate', {
-      ...makeBaseState(),
-      refineStage: 'done',
-      refineProgress: 1.0,
-      refineFrames: 3,
-    } as IncrementalState);
-    expect(events).toHaveLength(1); // unchanged after remove()
-  });
-
-  it('happy-path: delivers validating → stitching → writing → done in order with correct refineStage', () => {
-    const stages: Array<{ stage: string | undefined; progress: number | undefined }> = [];
-    subscribeIncrementalState((s) => {
-      stages.push({ stage: s.refineStage, progress: s.refineProgress });
-    });
-
-    const sequence: Array<Pick<IncrementalState, 'refineStage' | 'refineProgress' | 'refineFrames'>> = [
-      { refineStage: 'validating', refineProgress: 0.05, refineFrames: 3 },
-      { refineStage: 'stitching',  refineProgress: 0.10, refineFrames: 3 },
-      { refineStage: 'writing',    refineProgress: 0.90, refineFrames: 3 },
-      { refineStage: 'done',       refineProgress: 1.00, refineFrames: 3 },
-    ];
-    for (const ev of sequence) {
-      lastEmitter!._emit('IncrementalStateUpdate', { ...makeBaseState(), ...ev } as IncrementalState);
-    }
-
-    expect(stages).toEqual([
-      { stage: 'validating', progress: 0.05 },
-      { stage: 'stitching',  progress: 0.10 },
-      { stage: 'writing',    progress: 0.90 },
-      { stage: 'done',       progress: 1.00 },
-    ]);
-  });
-
-  it('refineProgress is non-decreasing across the happy-path sequence (monotonicity contract)', () => {
-    const progresses: number[] = [];
-    subscribeIncrementalState((s) => {
-      if (s.refineProgress !== undefined) progresses.push(s.refineProgress);
-    });
-
-    for (const p of [0.05, 0.10, 0.90, 1.00]) {
-      lastEmitter!._emit('IncrementalStateUpdate', {
-        ...makeBaseState(),
-        refineStage: 'stitching', // stage is irrelevant for this assertion
-        refineProgress: p,
-        refineFrames: 3,
-      } as IncrementalState);
-    }
-
-    expect(progresses).toEqual([0.05, 0.10, 0.90, 1.00]);
-    for (let i = 1; i < progresses.length; i++) {
-      expect(progresses[i]).toBeGreaterThanOrEqual(progresses[i - 1]);
-    }
-  });
-
-  it('failure-path: validating → error carries refineError; no further stages emitted', () => {
-    const events: IncrementalState[] = [];
-    subscribeIncrementalState((s) => events.push(s));
-
-    lastEmitter!._emit('IncrementalStateUpdate', {
-      ...makeBaseState(),
-      refineStage: 'validating',
-      refineProgress: 0.05,
-      refineFrames: 3,
-    } as IncrementalState);
-    lastEmitter!._emit('IncrementalStateUpdate', {
-      ...makeBaseState(),
-      refineStage: 'error',
-      refineProgress: 1.0,
-      refineFrames: 3,
-      refineError: 'INVALID_FRAMES: missing JPEG at index 1',
-    } as IncrementalState);
-
-    expect(events).toHaveLength(2);
-    expect(events[0].refineStage).toBe('validating');
-    expect(events[1].refineStage).toBe('error');
-    expect(events[1].refineError).toBe('INVALID_FRAMES: missing JPEG at index 1');
-    // refineError is absent on the validating event.
-    expect(events[0].refineError).toBeUndefined();
-  });
-
-  it('refineFrames passes through unchanged (regression guard for key rename)', () => {
-    const seen: Array<number | undefined> = [];
-    subscribeIncrementalState((s) => seen.push(s.refineFrames));
-
-    for (const n of [3, 5, 8]) {
-      lastEmitter!._emit('IncrementalStateUpdate', {
-        ...makeBaseState(),
-        refineStage: 'stitching',
-        refineProgress: 0.5,
-        refineFrames: n,
-      } as IncrementalState);
-    }
-    expect(seen).toEqual([3, 5, 8]);
-  });
-
-  it('live (non-refine) state events leave refine fields undefined', () => {
-    // Asserts that the contract is "refine fields are only populated
-    // during a refine call" — so the example app's `if
-    // (s.refineStage === undefined) return;` short-circuit is sound.
-    const events: IncrementalState[] = [];
-    subscribeIncrementalState((s) => events.push(s));
-
-    lastEmitter!._emit('IncrementalStateUpdate', makeBaseState());
-    expect(events).toHaveLength(1);
-    expect(events[0].refineStage).toBeUndefined();
-    expect(events[0].refineProgress).toBeUndefined();
-    expect(events[0].refineFrames).toBeUndefined();
-    expect(events[0].refineError).toBeUndefined();
-  });
-
-  it('subscribes on the correct channel name "IncrementalStateUpdate" (cross-platform contract)', () => {
-    // If anyone renames the event constant on either side, the
-    // subscriber stops receiving events.  Pin the literal here.
-    let receivedOnRight = false;
-    let receivedOnWrong = false;
-    subscribeIncrementalState(() => {
-      receivedOnRight = true;
-    });
-    // Fire on a deliberately-wrong channel — should NOT deliver.
-    lastEmitter!._emit('SomeOtherChannel', makeBaseState());
-    expect(receivedOnRight).toBe(false);
-    expect(receivedOnWrong).toBe(false);
-    // Fire on the right channel — should deliver.
-    lastEmitter!._emit('IncrementalStateUpdate', makeBaseState());
-    expect(receivedOnRight).toBe(true);
-  });
-});