@flighthq/host-capacitor 0.1.0

package/src/capacitorFileSystem.test.ts

@@ -0,0 +1,88 @@
+import { createCapacitorFileSystemBackend } from './capacitorFileSystem';
+import type { CapacitorApi } from './capacitorModule';
+
+function fakeCapacitor() {
+  const files = new Map<string, { data: string; type: string }>();
+  const capacitor = {
+    filesystem: {
+      async readFile(options: { path: string; encoding?: string }) {
+        const entry = files.get(options.path);
+        if (entry === undefined) throw new Error('missing');
+        return { data: entry.data };
+      },
+      async writeFile(options: { path: string; data: string }) {
+        files.set(options.path, { data: options.data, type: 'file' });
+        return { uri: `file://${options.path}` };
+      },
+      async appendFile(options: { path: string; data: string }) {
+        const entry = files.get(options.path);
+        files.set(options.path, { data: (entry?.data ?? '') + options.data, type: 'file' });
+      },
+      async deleteFile(options: { path: string }) {
+        if (!files.delete(options.path)) throw new Error('missing');
+      },
+      async mkdir(options: { path: string }) {
+        files.set(options.path, { data: '', type: 'directory' });
+      },
+      async rmdir(options: { path: string }) {
+        files.delete(options.path);
+      },
+      async readdir(options: { path: string }) {
+        return {
+          files: [...files.keys()]
+            .filter((key) => key.startsWith(options.path))
+            .map((key) => ({ name: key, uri: `file://${key}`, type: files.get(key)!.type, size: 0, mtime: 0 })),
+        };
+      },
+      async stat(options: { path: string }) {
+        const entry = files.get(options.path);
+        if (entry === undefined) throw new Error('missing');
+        return { type: entry.type, size: entry.data.length, mtime: 100, ctime: 50, uri: `file://${options.path}` };
+      },
+      async rename() {},
+      async copy() {},
+    },
+  } as unknown as CapacitorApi;
+  return { capacitor, files };
+}
+
+describe('createCapacitorFileSystemBackend', () => {
+  it('round-trips a text file', async () => {
+    const backend = createCapacitorFileSystemBackend(fakeCapacitor().capacitor);
+    expect(await backend.writeTextFile('/a.txt', 'hello')).toBe(true);
+    expect(await backend.readTextFile('/a.txt')).toBe('hello');
+    expect(await backend.appendTextFile('/a.txt', '!')).toBe(true);
+    expect(await backend.readTextFile('/a.txt')).toBe('hello!');
+  });
+
+  it('round-trips a binary file through Base64', async () => {
+    const backend = createCapacitorFileSystemBackend(fakeCapacitor().capacitor);
+    const bytes = new Uint8Array([0, 1, 2, 254, 255]);
+    expect(await backend.writeBinaryFile('/b.bin', bytes)).toBe(true);
+    const read = await backend.readBinaryFile('/b.bin');
+    expect(read).not.toBeNull();
+    expect([...read!]).toEqual([0, 1, 2, 254, 255]);
+  });
+
+  it('maps exists/stat/remove and reports null for a missing file', async () => {
+    const backend = createCapacitorFileSystemBackend(fakeCapacitor().capacitor);
+    await backend.writeTextFile('/c.txt', 'x');
+    expect(await backend.fileExists('/c.txt')).toBe(true);
+    expect(await backend.directoryExists('/c.txt')).toBe(false);
+    const stat = await backend.statFile('/c.txt');
+    expect(stat).toMatchObject({ size: 1, isDirectory: false, createdTime: 50 });
+    expect(await backend.removeFile('/c.txt')).toBe(true);
+    expect(await backend.readTextFile('/c.txt')).toBeNull();
+    expect(await backend.statFile('/missing')).toBeNull();
+  });
+
+  it('reports sentinels for the unmodeled surface', async () => {
+    const backend = createCapacitorFileSystemBackend(fakeCapacitor().capacitor);
+    expect(await backend.readBinaryFileRange('/x', 0, 4)).toBeNull();
+    expect(await backend.getFilePermissions('/x')).toBeNull();
+    expect(await backend.canAccessFile('/x', 'readable')).toBe(false);
+    expect(await backend.getFileSystemUsage()).toBeNull();
+    expect(backend.getPath('home')).toBe('');
+    expect(typeof backend.watch('/x', () => {})).toBe('function');
+  });
+});

package/src/capacitorGeolocation.test.ts

@@ -0,0 +1,75 @@
+import { createCapacitorGeolocationBackend } from './capacitorGeolocation';
+import type { CapacitorApi, CapacitorPosition } from './capacitorModule';
+
+const flush = async () => {
+  await Promise.resolve();
+  await Promise.resolve();
+};
+
+function samplePosition(): CapacitorPosition {
+  return {
+    timestamp: 1234,
+    coords: {
+      latitude: 37.5,
+      longitude: -122.3,
+      accuracy: 5,
+      altitude: 10,
+      altitudeAccuracy: 2,
+      heading: 90,
+      speed: 1.5,
+    },
+  };
+}
+
+function fakeCapacitor(permission = 'granted') {
+  const cleared: string[] = [];
+  let watchCallback: ((position: CapacitorPosition | null, err?: unknown) => void) | null = null;
+  const capacitor = {
+    geolocation: {
+      async getCurrentPosition() {
+        return samplePosition();
+      },
+      async watchPosition(_options: unknown, callback: (position: CapacitorPosition | null, err?: unknown) => void) {
+        watchCallback = callback;
+        return 'watch-abc';
+      },
+      async clearWatch(options: { id: string }) {
+        cleared.push(options.id);
+      },
+      async checkPermissions() {
+        return { location: permission };
+      },
+      async requestPermissions() {
+        return { location: permission };
+      },
+    },
+  } as unknown as CapacitorApi;
+  return { capacitor, cleared, fire: (p: CapacitorPosition) => watchCallback?.(p) };
+}
+
+describe('createCapacitorGeolocationBackend', () => {
+  it('maps a Capacitor position onto a GeoPosition', async () => {
+    const backend = createCapacitorGeolocationBackend(fakeCapacitor().capacitor);
+    const position = await backend.getCurrentPosition({});
+    expect(position).toMatchObject({ latitude: 37.5, longitude: -122.3, accuracy: 5, heading: 90, floorLevel: 0 });
+  });
+
+  it('maps permission state', async () => {
+    const backend = createCapacitorGeolocationBackend(fakeCapacitor('denied').capacitor);
+    expect(await backend.getPermission()).toBe('denied');
+    expect(await backend.requestPermission()).toBe(false);
+  });
+
+  it('bridges the numeric watch id and clears the resolved string id', async () => {
+    const { capacitor, cleared, fire } = fakeCapacitor();
+    const backend = createCapacitorGeolocationBackend(capacitor);
+    let received = 0;
+    const id = backend.watchPosition(() => received++, {});
+    expect(typeof id).toBe('number');
+    await flush();
+    fire(samplePosition());
+    expect(received).toBe(1);
+    backend.clearWatch(id);
+    expect(cleared).toContain('watch-abc');
+  });
+});

package/src/capacitorHaptics.test.ts

@@ -0,0 +1,75 @@
+import type { HapticsCapabilities } from '@flighthq/types';
+
+import { createCapacitorHapticsBackend } from './capacitorHaptics';
+import type { CapacitorApi } from './capacitorModule';
+
+function fakeCapacitor() {
+  const calls: Array<{ method: string; arg?: unknown }> = [];
+  const capacitor = {
+    haptics: {
+      async impact(arg: unknown) {
+        calls.push({ method: 'impact', arg });
+      },
+      async notification(arg: unknown) {
+        calls.push({ method: 'notification', arg });
+      },
+      async selectionChanged() {
+        calls.push({ method: 'selectionChanged' });
+      },
+      async selectionStart() {
+        calls.push({ method: 'selectionStart' });
+      },
+      async selectionEnd() {
+        calls.push({ method: 'selectionEnd' });
+      },
+      async vibrate(arg: unknown) {
+        calls.push({ method: 'vibrate', arg });
+      },
+    },
+  } as unknown as CapacitorApi;
+  return { capacitor, calls };
+}
+
+describe('createCapacitorHapticsBackend', () => {
+  it('maps impact styles onto Capacitor enums', () => {
+    const { capacitor, calls } = fakeCapacitor();
+    const backend = createCapacitorHapticsBackend(capacitor);
+    expect(backend.impact('soft')).toBe(true);
+    expect(backend.impact('rigid')).toBe(true);
+    expect(calls[0].arg).toEqual({ style: 'LIGHT' });
+    expect(calls[1].arg).toEqual({ style: 'HEAVY' });
+  });
+
+  it('maps notification, selection, and vibrate', () => {
+    const { capacitor, calls } = fakeCapacitor();
+    const backend = createCapacitorHapticsBackend(capacitor);
+    expect(backend.notification('success')).toBe(true);
+    expect(backend.selection()).toBe(true);
+    expect(backend.vibrate(200)).toBe(true);
+    expect(calls.map((c) => c.method)).toEqual(['notification', 'selectionChanged', 'vibrate']);
+    expect(calls[0].arg).toEqual({ type: 'SUCCESS' });
+    expect(calls[2].arg).toEqual({ duration: 200 });
+  });
+
+  it('reports capabilities and unsupported operations', () => {
+    const backend = createCapacitorHapticsBackend(fakeCapacitor().capacitor);
+    const out: HapticsCapabilities = {
+      amplitudeControl: true,
+      customEvents: true,
+      intensity: true,
+      patterns: true,
+      supported: false,
+    };
+    expect(backend.capabilities(out)).toBe(out);
+    expect(out).toEqual({
+      amplitudeControl: false,
+      customEvents: false,
+      intensity: false,
+      patterns: false,
+      supported: true,
+    });
+    expect(backend.cancel()).toBe(false);
+    expect(backend.vibratePattern([10, 20])).toBe(false);
+    expect(backend.isSupported()).toBe(true);
+  });
+});

package/src/capacitorKeyboard.test.ts

@@ -0,0 +1,89 @@
+import type { SoftKeyboardInfo } from '@flighthq/types';
+import { SoftKeyboardResizeBodyKind } from '@flighthq/types';
+
+import { createCapacitorKeyboardBackend } from './capacitorKeyboard';
+import type { CapacitorApi } from './capacitorModule';
+
+const flush = async () => {
+  await Promise.resolve();
+  await Promise.resolve();
+};
+
+function fakeCapacitor() {
+  const calls: Array<{ method: string; arg?: unknown }> = [];
+  const listeners = new Map<string, Array<(info?: unknown) => void>>();
+  const capacitor = {
+    keyboard: {
+      async show() {
+        calls.push({ method: 'show' });
+      },
+      async hide() {
+        calls.push({ method: 'hide' });
+      },
+      async setAccessoryBarVisible(arg: unknown) {
+        calls.push({ method: 'setAccessoryBarVisible', arg });
+      },
+      async setResizeMode(arg: unknown) {
+        calls.push({ method: 'setResizeMode', arg });
+      },
+      async setScroll(arg: unknown) {
+        calls.push({ method: 'setScroll', arg });
+      },
+      async setStyle(arg: unknown) {
+        calls.push({ method: 'setStyle', arg });
+      },
+      async addListener(eventName: string, listener: (info?: unknown) => void) {
+        const list = listeners.get(eventName) ?? [];
+        list.push(listener);
+        listeners.set(eventName, list);
+        return { async remove() {} };
+      },
+    },
+  } as unknown as CapacitorApi;
+  const fire = (eventName: string, info?: unknown) => listeners.get(eventName)?.forEach((l) => l(info));
+  return { capacitor, calls, fire };
+}
+
+function blankInfo(): SoftKeyboardInfo {
+  return { visible: false, height: 0, x: 0, y: 0, width: 0 };
+}
+
+describe('createCapacitorKeyboardBackend', () => {
+  it('maps show/hide and setters onto the plugin', () => {
+    const { capacitor, calls } = fakeCapacitor();
+    const backend = createCapacitorKeyboardBackend(capacitor);
+    backend.show();
+    backend.hide();
+    backend.setResizeMode?.(SoftKeyboardResizeBodyKind);
+    backend.setScrollAssistEnabled?.(false);
+    expect(calls.map((c) => c.method)).toEqual(['show', 'hide', 'setResizeMode', 'setScroll']);
+    expect(calls[2].arg).toEqual({ mode: 'body' });
+    expect(calls[3].arg).toEqual({ isDisabled: true });
+  });
+
+  it('tracks the keyboard mirror from will-show/will-hide events', async () => {
+    const { capacitor, fire } = fakeCapacitor();
+    const backend = createCapacitorKeyboardBackend(capacitor);
+    await flush();
+    fire('keyboardWillShow', { keyboardHeight: 320 });
+    const shown = backend.getInfo(blankInfo());
+    expect(shown.visible).toBe(true);
+    expect(shown.height).toBe(320);
+    fire('keyboardWillHide');
+    expect(backend.getInfo(blankInfo()).visible).toBe(false);
+  });
+
+  it('delivers will-phase transitions to a subscriber', async () => {
+    const { capacitor, fire } = fakeCapacitor();
+    const backend = createCapacitorKeyboardBackend(capacitor);
+    const events: Array<{ phase: string; height: number }> = [];
+    backend.subscribe((phase, transition) => events.push({ phase, height: transition.height }));
+    await flush();
+    fire('keyboardWillShow', { keyboardHeight: 300 });
+    fire('keyboardWillHide');
+    expect(events).toEqual([
+      { phase: 'will', height: 300 },
+      { phase: 'will', height: 0 },
+    ]);
+  });
+});

package/src/capacitorNotification.test.ts

@@ -0,0 +1,95 @@
+import type { CapacitorApi } from './capacitorModule';
+import { createCapacitorNotificationBackend } from './capacitorNotification';
+
+const flush = async () => {
+  await Promise.resolve();
+  await Promise.resolve();
+};
+
+function fakeCapacitor(display = 'granted') {
+  const scheduled: Array<{ id: number; title: string }> = [];
+  const cancelled: number[] = [];
+  const actionListeners: Array<(action: { actionId: string; notification: { id: number } }) => void> = [];
+  const capacitor = {
+    localNotifications: {
+      async schedule(options: { notifications: Array<{ id: number; title: string }> }) {
+        scheduled.push(...options.notifications);
+        return { notifications: options.notifications.map((n) => ({ id: n.id })) };
+      },
+      async requestPermissions() {
+        return { display };
+      },
+      async checkPermissions() {
+        return { display };
+      },
+      async cancel(options: { notifications: Array<{ id: number }> }) {
+        cancelled.push(...options.notifications.map((n) => n.id));
+      },
+      async getPending() {
+        return { notifications: scheduled };
+      },
+      async addListener(
+        _eventName: string,
+        listener: (action: { actionId: string; notification: { id: number } }) => void,
+      ) {
+        actionListeners.push(listener);
+        return { async remove() {} };
+      },
+    },
+  } as unknown as CapacitorApi;
+  return {
+    capacitor,
+    scheduled,
+    cancelled,
+    fire: (a: { actionId: string; notification: { id: number } }) => actionListeners.forEach((l) => l(a)),
+  };
+}
+
+describe('createCapacitorNotificationBackend', () => {
+  it('schedules an immediate notification and returns the caller id', async () => {
+    const { capacitor, scheduled } = fakeCapacitor();
+    const backend = createCapacitorNotificationBackend(capacitor);
+    expect(await backend.notify({ id: 'welcome', title: 'Hi', body: 'there' })).toBe('welcome');
+    expect(scheduled).toHaveLength(1);
+    expect(scheduled[0].title).toBe('Hi');
+  });
+
+  it('serves permission from the prefetch cache and updates it on request', async () => {
+    const backend = createCapacitorNotificationBackend(fakeCapacitor('granted').capacitor);
+    // Reads 'default' until the construction-time prefetch settles.
+    expect(backend.getPermission()).toBe('default');
+    await flush();
+    expect(backend.getPermission()).toBe('granted');
+    expect(await backend.requestPermission()).toBe('granted');
+  });
+
+  it('cancels a scheduled notification by its caller id', async () => {
+    const { capacitor, cancelled } = fakeCapacitor();
+    const backend = createCapacitorNotificationBackend(capacitor);
+    await backend.scheduleNotification({ id: 'later', title: 'Later' }, { at: Date.now() + 1000 });
+    backend.cancelScheduledNotification('later');
+    await flush();
+    expect(cancelled).toHaveLength(1);
+  });
+
+  it('routes an action-performed event to click and action subscribers', async () => {
+    const { capacitor, fire } = fakeCapacitor();
+    const backend = createCapacitorNotificationBackend(capacitor);
+    let clicked = '';
+    let action = '';
+    backend.subscribeClick((id) => (clicked = id));
+    backend.subscribeAction((id, actionId) => (action = `${id}:${actionId}`));
+    await backend.notify({ id: 'welcome', title: 'Hi' });
+    await flush();
+    fire({ actionId: 'tap', notification: { id: 1 } });
+    expect(clicked).toBe('welcome');
+    expect(action).toBe('welcome:tap');
+  });
+
+  it('reports sentinels for the unmodeled surface', async () => {
+    const backend = createCapacitorNotificationBackend(fakeCapacitor().capacitor);
+    expect(await backend.getActiveNotifications()).toEqual([]);
+    expect(await backend.updateNotification('x', {})).toBe(false);
+    expect(await backend.getLaunchNotification()).toBeNull();
+  });
+});

package/src/capacitorRegister.test.ts

@@ -0,0 +1,104 @@
+import { getAppBackend, setAppBackend } from '@flighthq/app';
+import { readClipboardText, setClipboardBackend } from '@flighthq/clipboard';
+import { getConnectivityBackend, setConnectivityBackend } from '@flighthq/connectivity';
+import { getDeviceBackend, setDeviceBackend } from '@flighthq/device';
+import { setDialogBackend } from '@flighthq/dialog';
+import { getFileSystemBackend, setFileSystemBackend } from '@flighthq/filesystem';
+import { getGeolocationBackend, setGeolocationBackend } from '@flighthq/geolocation';
+import { getHapticsBackend, setHapticsBackend } from '@flighthq/haptics';
+import { getSoftKeyboardBackend, setSoftKeyboardBackend } from '@flighthq/keyboard';
+import { getNotificationBackend, setNotificationBackend } from '@flighthq/notification';
+import { getShareBackend, setShareBackend } from '@flighthq/share';
+import { getStatusBarBackend, setStatusBarBackend } from '@flighthq/statusbar';
+
+import type { CapacitorApi } from './capacitorModule';
+import { registerCapacitorBackends } from './capacitorRegister';
+
+// A fake Capacitor API broad enough that every createCapacitor*Backend constructs without touching
+// missing members. Backends close over `capacitor` and only call in when their methods run (plus the
+// app/notification/device/share/statusbar/connectivity prefetches), so a thin fake proves registration
+// routes the seams to the Capacitor backends.
+function fakeCapacitor(): CapacitorApi {
+  const asyncNoop = async () => {};
+  const asyncListener = async () => ({ async remove() {} });
+  return {
+    app: {
+      getInfo: async () => ({ name: 'FlightApp', id: 'com.flight.app', build: '1', version: '1.0.0' }),
+      exitApp: asyncNoop,
+      minimizeApp: asyncNoop,
+      addListener: asyncListener,
+    },
+    clipboard: {
+      read: async () => ({ value: 'CAP-TEXT', type: 'text/plain' }),
+      write: asyncNoop,
+    },
+    device: {
+      getInfo: async () => ({
+        model: 'M',
+        platform: 'ios',
+        operatingSystem: 'ios',
+        osVersion: '17',
+        manufacturer: 'Apple',
+        isVirtual: false,
+        webViewVersion: '17',
+      }),
+      getId: async () => ({ identifier: 'id' }),
+    },
+    dialog: {
+      alert: asyncNoop,
+      confirm: async () => ({ value: true }),
+      prompt: async () => ({ value: '', cancelled: true }),
+    },
+    filesystem: {},
+    geolocation: { checkPermissions: async () => ({ location: 'granted' }) },
+    haptics: {},
+    keyboard: { addListener: asyncListener },
+    localNotifications: {
+      schedule: async () => ({ notifications: [] }),
+      requestPermissions: async () => ({ display: 'granted' }),
+      checkPermissions: async () => ({ display: 'granted' }),
+      cancel: asyncNoop,
+      getPending: async () => ({ notifications: [] }),
+      addListener: asyncListener,
+    },
+    network: { getStatus: async () => ({ connected: true, connectionType: 'wifi' }), addListener: asyncListener },
+    share: { canShare: async () => ({ value: true }), share: async () => ({}) },
+    statusBar: { getInfo: async () => ({ visible: true, style: 'Default' }) },
+  } as unknown as CapacitorApi;
+}
+
+afterEach(() => {
+  setAppBackend(null);
+  setClipboardBackend(null);
+  setConnectivityBackend(null);
+  setDeviceBackend(null);
+  setDialogBackend(null);
+  setFileSystemBackend(null);
+  setGeolocationBackend(null);
+  setHapticsBackend(null);
+  setNotificationBackend(null);
+  setShareBackend(null);
+  setSoftKeyboardBackend(null);
+  setStatusBarBackend(null);
+});
+
+describe('registerCapacitorBackends', () => {
+  it('installs a backend for each covered capability', () => {
+    registerCapacitorBackends(fakeCapacitor());
+    expect(getAppBackend()).not.toBeNull();
+    expect(getConnectivityBackend()).not.toBeNull();
+    expect(getDeviceBackend()).not.toBeNull();
+    expect(getFileSystemBackend()).not.toBeNull();
+    expect(getGeolocationBackend()).not.toBeNull();
+    expect(getHapticsBackend()).not.toBeNull();
+    expect(getNotificationBackend()).not.toBeNull();
+    expect(getShareBackend()).not.toBeNull();
+    expect(getSoftKeyboardBackend()).not.toBeNull();
+    expect(getStatusBarBackend()).not.toBeNull();
+  });
+
+  it('routes a capability call through to the Capacitor backend', async () => {
+    registerCapacitorBackends(fakeCapacitor());
+    expect(await readClipboardText()).toBe('CAP-TEXT');
+  });
+});

package/src/capacitorShare.test.ts

@@ -0,0 +1,68 @@
+import type { CapacitorApi } from './capacitorModule';
+import { createCapacitorShareBackend } from './capacitorShare';
+
+const flush = async () => {
+  await Promise.resolve();
+  await Promise.resolve();
+};
+
+function fakeCapacitor(canShare = true, shareImpl?: () => Promise<{ activityType?: string }>) {
+  const shared: Array<{ title?: string; text?: string; url?: string }> = [];
+  const capacitor = {
+    share: {
+      async canShare() {
+        return { value: canShare };
+      },
+      async share(options: { title?: string; text?: string; url?: string }) {
+        shared.push(options);
+        return shareImpl ? await shareImpl() : { activityType: 'com.apple.UIKit.activity.Mail' };
+      },
+    },
+  } as unknown as CapacitorApi;
+  return { capacitor, shared };
+}
+
+describe('createCapacitorShareBackend', () => {
+  it('reports availability from the prefetch cache once it resolves', async () => {
+    const backend = createCapacitorShareBackend(fakeCapacitor(true).capacitor);
+    // Reads false until the construction-time canShare prefetch settles.
+    expect(backend.isAvailable()).toBe(false);
+    await flush();
+    expect(backend.isAvailable()).toBe(true);
+    expect(backend.canShare({ text: 'x' })).toBe(true);
+  });
+
+  it('shares title/text/url content', async () => {
+    const { capacitor, shared } = fakeCapacitor();
+    const backend = createCapacitorShareBackend(capacitor);
+    expect(await backend.share({ title: 'T', url: 'https://flight.dev' })).toBe(true);
+    expect(shared[0]).toMatchObject({ title: 'T', url: 'https://flight.dev' });
+  });
+
+  it('maps a completed share to a ShareResult with the activity type', async () => {
+    const backend = createCapacitorShareBackend(fakeCapacitor().capacitor);
+    expect(await backend.shareWithResult({ text: 'x' })).toEqual({
+      completed: true,
+      activityType: 'com.apple.UIKit.activity.Mail',
+      dismissed: false,
+    });
+  });
+
+  it('reports a dismissed ShareResult when the user cancels', async () => {
+    const backend = createCapacitorShareBackend(
+      fakeCapacitor(true, async () => {
+        throw new Error('cancelled');
+      }).capacitor,
+    );
+    expect(await backend.shareWithResult({ text: 'x' })).toEqual({
+      completed: false,
+      activityType: null,
+      dismissed: true,
+    });
+  });
+
+  it('refuses content with no shareable text', async () => {
+    const backend = createCapacitorShareBackend(fakeCapacitor().capacitor);
+    expect(await backend.share({})).toBe(false);
+  });
+});

package/src/capacitorStatusBar.test.ts

@@ -0,0 +1,66 @@
+import type { StatusBarInfo } from '@flighthq/types';
+
+import type { CapacitorApi } from './capacitorModule';
+import { createCapacitorStatusBarBackend } from './capacitorStatusBar';
+
+const flush = async () => {
+  await Promise.resolve();
+  await Promise.resolve();
+};
+
+function fakeCapacitor(info = { visible: true, style: 'Dark', color: '#112233', overlays: true }) {
+  const calls: Array<{ method: string; arg?: unknown }> = [];
+  const capacitor = {
+    statusBar: {
+      async getInfo() {
+        return info;
+      },
+      async setStyle(arg: unknown) {
+        calls.push({ method: 'setStyle', arg });
+      },
+      async setBackgroundColor(arg: unknown) {
+        calls.push({ method: 'setBackgroundColor', arg });
+      },
+      async setOverlaysWebView(arg: unknown) {
+        calls.push({ method: 'setOverlaysWebView', arg });
+      },
+      async show() {
+        calls.push({ method: 'show' });
+      },
+      async hide() {
+        calls.push({ method: 'hide' });
+      },
+    },
+  } as unknown as CapacitorApi;
+  return { capacitor, calls };
+}
+
+function blankInfo(): StatusBarInfo {
+  return { color: 1, height: 1, overlaysContent: false, style: 'default', visible: false };
+}
+
+describe('createCapacitorStatusBarBackend', () => {
+  it('maps setters onto the Capacitor plugin', () => {
+    const { capacitor, calls } = fakeCapacitor();
+    const backend = createCapacitorStatusBarBackend(capacitor);
+    backend.setStyle('light');
+    backend.setBackgroundColor(0x112233ff);
+    backend.setOverlaysContent(true);
+    backend.setVisible(false);
+    expect(calls[0].arg).toEqual({ style: 'Light' });
+    expect(calls[1].arg).toEqual({ color: '#112233' });
+    expect(calls[2].arg).toEqual({ overlay: true });
+    expect(calls[3].method).toBe('hide');
+  });
+
+  it('fills the info snapshot from the prefetch once it resolves', async () => {
+    const backend = createCapacitorStatusBarBackend(fakeCapacitor().capacitor);
+    await flush();
+    const info = backend.getInfo(blankInfo());
+    expect(info.visible).toBe(true);
+    expect(info.style).toBe('dark');
+    expect(info.color).toBe(0x112233ff);
+    expect(info.overlaysContent).toBe(true);
+    expect(info.height).toBe(-1);
+  });
+});