@rn-bridge-tools/expo 0.0.7 → 0.0.8

package/src/__tests__/createHandlers.test.ts

@@ -0,0 +1,88 @@
+import { describe, it, expect, vi } from 'vitest';
+
+// Mock react-native modules
+vi.mock('react-native', () => ({
+  Platform: { OS: 'ios', Version: '17.0' },
+  StatusBar: {
+    setBarStyle: vi.fn(),
+    setBackgroundColor: vi.fn(),
+    setHidden: vi.fn(),
+  },
+  Keyboard: { dismiss: vi.fn() },
+  Linking: { openURL: vi.fn(), openSettings: vi.fn() },
+}));
+
+vi.mock('@webview-bridge/react-native', () => ({
+  bridge: vi.fn((handlers: Record<string, unknown>) => handlers),
+  createWebView: vi.fn(() => ({
+    WebView: 'MockWebView',
+    postMessage: vi.fn(),
+  })),
+}));
+
+describe('createDefaultHandlers', () => {
+  it('should return handlers for all namespaces', async () => {
+    const { createDefaultHandlers } = await import('../createHandlers.js');
+
+    const handlers = createDefaultHandlers({
+      camera: true,
+      location: true,
+      file: true,
+      share: true,
+      device: true,
+      statusbar: true,
+      keyboard: true,
+      haptic: true,
+      clipboard: true,
+      scanner: true,
+      auth: true,
+      iap: true,
+      push: true,
+      permission: true,
+      preference: true,
+      navigation: true,
+      browser: true,
+    });
+
+    expect(handlers['camera.take']).toBeDefined();
+    expect(handlers['camera.pickImage']).toBeDefined();
+    expect(handlers['location.getCurrent']).toBeDefined();
+    expect(handlers['location.watchStart']).toBeDefined();
+    expect(handlers['location.watchStop']).toBeDefined();
+
+    const namespaces = [
+      'camera', 'location', 'file', 'share', 'device', 'statusbar',
+      'keyboard', 'haptic', 'clipboard', 'scanner', 'auth', 'iap',
+      'push', 'permission', 'preference', 'navigation', 'browser',
+    ];
+
+    for (const ns of namespaces) {
+      const nsHandlers = Object.keys(handlers).filter((k) => k.startsWith(`${ns}.`));
+      expect(nsHandlers.length).toBeGreaterThan(0);
+    }
+  });
+
+  it('should return disabled handlers when namespace is false', async () => {
+    const { createDefaultHandlers } = await import('../createHandlers.js');
+    const handlers = createDefaultHandlers({ camera: false });
+    const result = await (handlers['camera.take'] as (p: Record<string, unknown>) => Promise<{ success: boolean; error: string }>)({});
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('not_enabled');
+  });
+
+  it('should return disabled handlers by default', async () => {
+    const { createDefaultHandlers } = await import('../createHandlers.js');
+    const handlers = createDefaultHandlers();
+    const result = await (handlers['camera.take'] as (p: Record<string, unknown>) => Promise<{ success: boolean; error: string }>)({});
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('not_enabled');
+  });
+});
+
+describe('@rn-bridge-tools/expo exports', () => {
+  it('should export WebViewBridge and createDefaultHandlers', async () => {
+    const exports = await import('../index.js');
+    expect(exports.WebViewBridge).toBeDefined();
+    expect(exports.createDefaultHandlers).toBeDefined();
+  });
+});

package/src/createHandlers.ts

@@ -0,0 +1,67 @@
+import type { HandlerOptions } from '@rn-bridge-tools/core';
+import { cameraHandlers } from './handlers/camera.js';
+import { locationHandlers } from './handlers/location.js';
+import { fileHandlers } from './handlers/file.js';
+import { shareHandlers } from './handlers/share.js';
+import { deviceHandlers } from './handlers/device.js';
+import { statusbarHandlers } from './handlers/statusbar.js';
+import { keyboardHandlers } from './handlers/keyboard.js';
+import { hapticHandlers } from './handlers/haptic.js';
+import { clipboardHandlers } from './handlers/clipboard.js';
+import { scannerHandlers } from './handlers/scanner.js';
+import { authHandlers } from './handlers/auth.js';
+import { iapHandlers } from './handlers/iap.js';
+import { pushHandlers } from './handlers/push.js';
+import { permissionHandlers } from './handlers/permission.js';
+import { preferenceHandlers } from './handlers/preference.js';
+import { navigationHandlers } from './handlers/navigation.js';
+import { browserHandlers } from './handlers/browser.js';
+
+export type HandlerFn = (payload: never) => Promise<unknown> | unknown;
+export type HandlerMap = Record<string, HandlerFn>;
+
+const handlerRegistry: Record<string, Record<string, (payload: never) => Promise<unknown> | unknown>> = {
+  camera: cameraHandlers as Record<string, (payload: never) => Promise<unknown>>,
+  location: locationHandlers as Record<string, (payload: never) => Promise<unknown>>,
+  file: fileHandlers as Record<string, (payload: never) => Promise<unknown>>,
+  share: shareHandlers as Record<string, (payload: never) => Promise<unknown>>,
+  device: deviceHandlers as Record<string, (payload: never) => Promise<unknown>>,
+  statusbar: statusbarHandlers as Record<string, (payload: never) => Promise<unknown>>,
+  keyboard: keyboardHandlers as Record<string, (payload: never) => Promise<unknown>>,
+  haptic: hapticHandlers as Record<string, (payload: never) => Promise<unknown>>,
+  clipboard: clipboardHandlers as Record<string, (payload: never) => Promise<unknown>>,
+  scanner: scannerHandlers as Record<string, (payload: never) => Promise<unknown>>,
+  auth: authHandlers as Record<string, (payload: never) => Promise<unknown>>,
+  iap: iapHandlers as Record<string, (payload: never) => Promise<unknown>>,
+  push: pushHandlers as Record<string, (payload: never) => Promise<unknown>>,
+  permission: permissionHandlers as Record<string, (payload: never) => Promise<unknown>>,
+  preference: preferenceHandlers as Record<string, (payload: never) => Promise<unknown>>,
+  navigation: navigationHandlers as Record<string, (payload: never) => Promise<unknown>>,
+  browser: browserHandlers as Record<string, (payload: never) => Promise<unknown>>,
+};
+
+function createDisabledHandler(_namespace: string, _action: string): HandlerFn {
+  return async () => ({
+    success: false,
+    error: `not_enabled: ${_namespace}.${_action}`,
+  });
+}
+
+export function createDefaultHandlers(options: HandlerOptions = {}): HandlerMap {
+  const result: HandlerMap = {};
+
+  for (const [namespace, handlers] of Object.entries(handlerRegistry)) {
+    const enabled = options[namespace as keyof HandlerOptions] ?? false;
+
+    for (const [action, handler] of Object.entries(handlers)) {
+      if (enabled) {
+        result[action] = handler as HandlerFn;
+      } else {
+        const actionName = action.split('.')[1] ?? action;
+        result[action] = createDisabledHandler(namespace, actionName);
+      }
+    }
+  }
+
+  return result;
+}

package/src/handlers/auth.ts

@@ -0,0 +1,69 @@
+import type { AuthNamespace } from '@rn-bridge-tools/core';
+
+declare const require: (id: string) => unknown;
+
+interface LocalAuthModule {
+  authenticateAsync: (opts: {
+    promptMessage?: string;
+    cancelLabel?: string;
+    fallbackLabel?: string;
+  }) => Promise<{ success: boolean; error?: string }>;
+  hasHardwareAsync: () => Promise<boolean>;
+  supportedAuthenticationTypesAsync: () => Promise<number[]>;
+  AuthenticationType: {
+    FACIAL_RECOGNITION: number;
+    FINGERPRINT: number;
+    IRIS: number;
+  };
+}
+
+export const authHandlers = {
+  'auth.biometric': async (
+    payload: AuthNamespace['auth.biometric']['request'],
+  ): Promise<AuthNamespace['auth.biometric']['response']> => {
+    let LocalAuth: LocalAuthModule | null = null;
+    try { LocalAuth = require('expo-local-authentication') as LocalAuthModule; } catch {}
+    if (!LocalAuth) return { success: false, error: 'MODULE_NOT_INSTALLED: expo-local-authentication' } as never;
+
+    try {
+      const result = await LocalAuth.authenticateAsync({
+        promptMessage: payload.promptMessage ?? 'Authenticate',
+        cancelLabel: payload.cancelLabel,
+        fallbackLabel: payload.fallbackLabel,
+      });
+
+      if (result.success) {
+        return { success: true };
+      }
+      return { success: false, error: result.error };
+    } catch (err) {
+      return { success: false, error: String(err) };
+    }
+  },
+
+  'auth.isBiometricAvailable': async (
+    _payload: AuthNamespace['auth.isBiometricAvailable']['request'],
+  ): Promise<AuthNamespace['auth.isBiometricAvailable']['response']> => {
+    let LocalAuth: LocalAuthModule | null = null;
+    try { LocalAuth = require('expo-local-authentication') as LocalAuthModule; } catch {}
+    if (!LocalAuth) return { success: false, error: 'MODULE_NOT_INSTALLED: expo-local-authentication' } as never;
+
+    try {
+      const available = await LocalAuth.hasHardwareAsync();
+      const types = await LocalAuth.supportedAuthenticationTypesAsync();
+
+      let biometryType: 'fingerprint' | 'facial' | 'iris' | undefined;
+      if (types.includes(LocalAuth.AuthenticationType.FACIAL_RECOGNITION)) {
+        biometryType = 'facial';
+      } else if (types.includes(LocalAuth.AuthenticationType.FINGERPRINT)) {
+        biometryType = 'fingerprint';
+      } else if (types.includes(LocalAuth.AuthenticationType.IRIS)) {
+        biometryType = 'iris';
+      }
+
+      return { available, biometryType };
+    } catch {
+      return { available: false };
+    }
+  },
+};

package/src/handlers/browser.ts

@@ -0,0 +1,42 @@
+import type { BrowserNamespace } from '@rn-bridge-tools/core';
+import { Linking } from 'react-native';
+
+declare const require: (id: string) => unknown;
+
+interface WebBrowserModule {
+  openBrowserAsync: (
+    url: string,
+    opts?: { showTitle?: boolean; toolbarColor?: string },
+  ) => Promise<void>;
+}
+
+export const browserHandlers = {
+  'browser.openExternal': async (
+    payload: BrowserNamespace['browser.openExternal']['request'],
+  ): Promise<BrowserNamespace['browser.openExternal']['response']> => {
+    try {
+      await Linking.openURL(payload.url);
+      return { success: true };
+    } catch {
+      return { success: false };
+    }
+  },
+
+  'browser.openInternal': async (
+    payload: BrowserNamespace['browser.openInternal']['request'],
+  ): Promise<BrowserNamespace['browser.openInternal']['response']> => {
+    let WebBrowser: WebBrowserModule | null = null;
+    try { WebBrowser = require('expo-web-browser') as WebBrowserModule; } catch {}
+    if (!WebBrowser) return { success: false, error: 'MODULE_NOT_INSTALLED: expo-web-browser' } as never;
+
+    try {
+      await WebBrowser.openBrowserAsync(payload.url, {
+        showTitle: payload.showTitle,
+        toolbarColor: payload.toolbarColor,
+      });
+      return { success: true };
+    } catch {
+      return { success: false };
+    }
+  },
+};

package/src/handlers/camera.ts

@@ -0,0 +1,97 @@
+import type { CameraNamespace } from '@rn-bridge-tools/core';
+
+declare const require: (id: string) => unknown;
+
+interface ImagePickerModule {
+  launchCameraAsync: (opts: {
+    quality?: number;
+    cameraType?: unknown;
+    allowsEditing?: boolean;
+  }) => Promise<{
+    canceled: boolean;
+    assets: Array<{
+      uri: string;
+      width: number;
+      height: number;
+      fileSize?: number;
+      mimeType?: string | null;
+    }>;
+  }>;
+  launchImageLibraryAsync: (opts: {
+    allowsMultipleSelection?: boolean;
+    quality?: number;
+    selectionLimit?: number;
+  }) => Promise<{
+    canceled: boolean;
+    assets: Array<{
+      uri: string;
+      width: number;
+      height: number;
+      fileSize?: number;
+      mimeType?: string | null;
+    }>;
+  }>;
+  CameraType: { front: unknown; back: unknown };
+}
+
+export const cameraHandlers = {
+  'camera.take': async (
+    payload: CameraNamespace['camera.take']['request'],
+  ): Promise<CameraNamespace['camera.take']['response']> => {
+    let ImagePicker: ImagePickerModule | null = null;
+    try { ImagePicker = require('expo-image-picker') as ImagePickerModule; } catch {}
+    if (!ImagePicker) return { success: false, error: 'MODULE_NOT_INSTALLED: expo-image-picker' } as never;
+
+    const result = await ImagePicker.launchCameraAsync({
+      quality: payload.quality ?? 0.8,
+      cameraType:
+        payload.facing === 'front'
+          ? ImagePicker.CameraType.front
+          : ImagePicker.CameraType.back,
+      allowsEditing: payload.allowsEditing ?? false,
+    });
+
+    if (result.canceled) {
+      return { success: false, assets: [] } as never;
+    }
+
+    const asset = result.assets[0];
+    return {
+      success: true,
+      uri: asset.uri,
+      width: asset.width,
+      height: asset.height,
+      fileSize: asset.fileSize,
+      mimeType: asset.mimeType ?? undefined,
+    };
+  },
+
+  'camera.pickImage': async (
+    payload: CameraNamespace['camera.pickImage']['request'],
+  ): Promise<CameraNamespace['camera.pickImage']['response']> => {
+    let ImagePicker: ImagePickerModule | null = null;
+    try { ImagePicker = require('expo-image-picker') as ImagePickerModule; } catch {}
+    if (!ImagePicker) return { success: false, error: 'MODULE_NOT_INSTALLED: expo-image-picker' } as never;
+
+    const result = await ImagePicker.launchImageLibraryAsync({
+      allowsMultipleSelection: payload.allowsMultipleSelection ?? false,
+      quality: payload.quality ?? 0.8,
+      selectionLimit: payload.maxCount ?? 0,
+    });
+
+    if (result.canceled) {
+      return { success: false, assets: [] };
+    }
+
+    return {
+      success: true,
+      assets: result.assets.map((a) => ({
+        uri: a.uri,
+        width: a.width,
+        height: a.height,
+        fileSize: a.fileSize,
+        mimeType: a.mimeType ?? undefined,
+      })),
+    };
+  },
+};

package/src/handlers/clipboard.ts

@@ -0,0 +1,32 @@
+import type { ClipboardNamespace } from '@rn-bridge-tools/core';
+
+declare const require: (id: string) => unknown;
+
+interface ClipboardModule {
+  setStringAsync: (text: string) => Promise<void>;
+  getStringAsync: () => Promise<string>;
+}
+
+export const clipboardHandlers = {
+  'clipboard.copy': async (
+    payload: ClipboardNamespace['clipboard.copy']['request'],
+  ): Promise<ClipboardNamespace['clipboard.copy']['response']> => {
+    let Clipboard: ClipboardModule | null = null;
+    try { Clipboard = require('expo-clipboard') as ClipboardModule; } catch {}
+    if (!Clipboard) return { success: false, error: 'MODULE_NOT_INSTALLED: expo-clipboard' } as never;
+
+    await Clipboard.setStringAsync(payload.text);
+    return { success: true };
+  },
+
+  'clipboard.paste': async (
+    _payload: ClipboardNamespace['clipboard.paste']['request'],
+  ): Promise<ClipboardNamespace['clipboard.paste']['response']> => {
+    let Clipboard: ClipboardModule | null = null;
+    try { Clipboard = require('expo-clipboard') as ClipboardModule; } catch {}
+    if (!Clipboard) return { success: false, error: 'MODULE_NOT_INSTALLED: expo-clipboard' } as never;
+
+    const text = await Clipboard.getStringAsync();
+    return { text, hasContent: text.length > 0 };
+  },
+};

package/src/handlers/device.ts

@@ -0,0 +1,71 @@
+import type { DeviceNamespace } from '@rn-bridge-tools/core';
+import { Platform } from 'react-native';
+
+declare const require: (id: string) => unknown;
+
+interface DeviceModule {
+  modelName: string | null;
+  brand: string | null;
+  deviceType: number | null;
+  DeviceType: { TABLET: number };
+}
+
+export const deviceHandlers = {
+  'device.getInfo': async (
+    _payload: DeviceNamespace['device.getInfo']['request'],
+  ): Promise<DeviceNamespace['device.getInfo']['response']> => {
+    let Device: DeviceModule | null = null;
+    try { Device = require('expo-device') as DeviceModule; } catch {}
+    if (!Device) return { success: false, error: 'MODULE_NOT_INSTALLED: expo-device' } as never;
+
+    return {
+      os: Platform.OS as 'ios' | 'android',
+      osVersion: Platform.Version?.toString() ?? '',
+      model: Device.modelName ?? '',
+      brand: Device.brand ?? '',
+      isTablet: Device.deviceType === Device.DeviceType.TABLET,
+      appVersion: '1.0.0',
+      buildNumber: '1',
+      bundleId: '',
+    };
+  },
+
+  'device.getBattery': async (
+    _payload: DeviceNamespace['device.getBattery']['request'],
+  ): Promise<DeviceNamespace['device.getBattery']['response']> => {
+    try {
+      let Battery: { getBatteryLevelAsync: () => Promise<number>; getBatteryStateAsync: () => Promise<number>; BatteryState: { CHARGING: number } } | null = null;
+      try { Battery = require('expo-battery') as { getBatteryLevelAsync: () => Promise<number>; getBatteryStateAsync: () => Promise<number>; BatteryState: { CHARGING: number } }; } catch {}
+      if (!Battery) {
+        return { level: -1, isCharging: false };
+      }
+      const level = await Battery.getBatteryLevelAsync();
+      const state = await Battery.getBatteryStateAsync();
+      return {
+        level,
+        isCharging: state === Battery.BatteryState.CHARGING,
+      };
+    } catch {
+      return { level: -1, isCharging: false };
+    }
+  },
+
+  'device.getNetwork': async (
+    _payload: DeviceNamespace['device.getNetwork']['request'],
+  ): Promise<DeviceNamespace['device.getNetwork']['response']> => {
+    try {
+      let NetInfo: { fetch: () => Promise<{ type: string; isConnected: boolean | null }> } | null = null;
+      try { NetInfo = require('@react-native-community/netinfo') as { fetch: () => Promise<{ type: string; isConnected: boolean | null }> }; } catch {}
+      if (!NetInfo) {
+        return { type: 'unknown', isConnected: true };
+      }
+      const state = await NetInfo.fetch();
+      return {
+        type: (state.type as 'wifi' | 'cellular' | 'none' | 'unknown') ?? 'unknown',
+        isConnected: state.isConnected ?? false,
+      };
+    } catch {
+      return { type: 'unknown', isConnected: true };
+    }
+  },
+};

package/src/handlers/file.ts

@@ -0,0 +1,126 @@
+import type { FileNamespace } from '@rn-bridge-tools/core';
+
+declare const require: (id: string) => unknown;
+
+interface FileSystemModule {
+  Paths: {
+    document: { uri: string };
+    cache: { uri: string };
+  };
+  File: new (...uris: (string | { uri: string })[]) => {
+    uri: string;
+    text: () => Promise<string>;
+    write: (content: string) => void;
+    create: () => void;
+    exists: boolean;
+  };
+  Directory: new (...uris: (string | { uri: string })[]) => {
+    uri: string;
+    create: () => void;
+    exists: boolean;
+  };
+}
+
+interface DocumentPickerModule {
+  getDocumentAsync: (opts: {
+    type?: string[];
+    multiple?: boolean;
+  }) => Promise<{
+    canceled: boolean;
+    assets: Array<{
+      uri: string;
+      name: string;
+      size?: number;
+      mimeType?: string;
+    }>;
+  }>;
+}
+
+export const fileHandlers = {
+  'file.download': async (
+    payload: FileNamespace['file.download']['request'],
+  ): Promise<FileNamespace['file.download']['response']> => {
+    let FS: FileSystemModule | null = null;
+    try { FS = require('expo-file-system') as FileSystemModule; } catch {}
+    if (!FS) return { success: false, error: 'MODULE_NOT_INSTALLED: expo-file-system' } as never;
+
+    try {
+      const response = await fetch(payload.url);
+      const text = await response.text();
+      const file = new FS.File(FS.Paths.document, payload.filename);
+      file.write(text);
+      return { success: true, localUri: file.uri };
+    } catch (err) {
+      return { success: false, error: String(err) };
+    }
+  },
+
+  'file.read': async (
+    payload: FileNamespace['file.read']['request'],
+  ): Promise<FileNamespace['file.read']['response']> => {
+    let FS: FileSystemModule | null = null;
+    try { FS = require('expo-file-system') as FileSystemModule; } catch {}
+    if (!FS) return { success: false, error: 'MODULE_NOT_INSTALLED: expo-file-system' } as never;
+
+    try {
+      const file = new FS.File(payload.uri);
+      const content = await file.text();
+      return { success: true, content };
+    } catch (err) {
+      return { success: false, error: String(err) };
+    }
+  },
+
+  'file.write': async (
+    payload: FileNamespace['file.write']['request'],
+  ): Promise<FileNamespace['file.write']['response']> => {
+    let FS: FileSystemModule | null = null;
+    try { FS = require('expo-file-system') as FileSystemModule; } catch {}
+    if (!FS) return { success: false, error: 'MODULE_NOT_INSTALLED: expo-file-system' } as never;
+
+    try {
+      const dirMap = {
+        document: FS.Paths.document,
+        cache: FS.Paths.cache,
+        temp: FS.Paths.cache,
+      };
+      const baseDir = dirMap[payload.directory ?? 'document'];
+      const file = new FS.File(baseDir, payload.filename);
+      file.write(payload.content);
+      return { success: true, uri: file.uri };
+    } catch (err) {
+      return { success: false, error: String(err) };
+    }
+  },
+
+  'file.pick': async (
+    payload: FileNamespace['file.pick']['request'],
+  ): Promise<FileNamespace['file.pick']['response']> => {
+    let DocumentPicker: DocumentPickerModule | null = null;
+    try { DocumentPicker = require('expo-document-picker') as DocumentPickerModule; } catch {}
+    if (!DocumentPicker) return { success: false, error: 'MODULE_NOT_INSTALLED: expo-document-picker' } as never;
+
+    try {
+      const result = await DocumentPicker.getDocumentAsync({
+        type: payload.type ?? ['*/*'],
+        multiple: payload.multiple ?? false,
+      });
+
+      if (result.canceled) {
+        return { success: false, files: [] };
+      }
+
+      return {
+        success: true,
+        files: result.assets.map((a) => ({
+          uri: a.uri,
+          name: a.name,
+          size: a.size ?? 0,
+          mimeType: a.mimeType ?? 'application/octet-stream',
+        })),
+      };
+    } catch {
+      return { success: false, files: [] };
+    }
+  },
+};

package/src/handlers/haptic.ts

@@ -0,0 +1,56 @@
+import type { HapticNamespace } from '@rn-bridge-tools/core';
+
+declare const require: (id: string) => unknown;
+
+interface HapticsModule {
+  ImpactFeedbackStyle: { Light: unknown; Medium: unknown; Heavy: unknown };
+  NotificationFeedbackType: { Success: unknown; Warning: unknown; Error: unknown };
+  impactAsync: (style: never) => Promise<void>;
+  notificationAsync: (type: never) => Promise<void>;
+  selectionAsync: () => Promise<void>;
+}
+
+export const hapticHandlers = {
+  'haptic.impact': async (
+    payload: HapticNamespace['haptic.impact']['request'],
+  ): Promise<void> => {
+    let Haptics: HapticsModule | null = null;
+    try { Haptics = require('expo-haptics') as HapticsModule; } catch {}
+    if (!Haptics) {
+      return;
+    }
+
+    const styleMap: Record<string, unknown> = {
+      light: Haptics.ImpactFeedbackStyle.Light,
+      medium: Haptics.ImpactFeedbackStyle.Medium,
+      heavy: Haptics.ImpactFeedbackStyle.Heavy,
+    };
+    await Haptics.impactAsync(styleMap[payload.style] as never);
+  },
+
+  'haptic.notification': async (
+    payload: HapticNamespace['haptic.notification']['request'],
+  ): Promise<void> => {
+    let Haptics: HapticsModule | null = null;
+    try { Haptics = require('expo-haptics') as HapticsModule; } catch {}
+    if (!Haptics) {
+      return;
+    }
+
+    const typeMap: Record<string, unknown> = {
+      success: Haptics.NotificationFeedbackType.Success,
+      warning: Haptics.NotificationFeedbackType.Warning,
+      error: Haptics.NotificationFeedbackType.Error,
+    };
+    await Haptics.notificationAsync(typeMap[payload.type] as never);
+  },
+
+  'haptic.selection': async (): Promise<void> => {
+    let Haptics: HapticsModule | null = null;
+    try { Haptics = require('expo-haptics') as HapticsModule; } catch {}
+    if (!Haptics) {
+      return;
+    }
+    await Haptics.selectionAsync();
+  },
+};

package/src/handlers/iap.ts

@@ -0,0 +1,23 @@
+import type { IAPNamespace } from '@rn-bridge-tools/core';
+
+export const iapHandlers = {
+  'iap.getProducts': async (
+    _payload: IAPNamespace['iap.getProducts']['request'],
+  ): Promise<IAPNamespace['iap.getProducts']['response']> => {
+    // IAP requires react-native-iap or expo-in-app-purchases
+    // Placeholder implementation
+    return { products: [] };
+  },
+
+  'iap.purchase': async (
+    _payload: IAPNamespace['iap.purchase']['request'],
+  ): Promise<IAPNamespace['iap.purchase']['response']> => {
+    return { success: false, error: 'IAP not configured' };
+  },
+
+  'iap.restore': async (
+    _payload: IAPNamespace['iap.restore']['request'],
+  ): Promise<IAPNamespace['iap.restore']['response']> => {
+    return { purchases: [] };
+  },
+};