@rn-bridge-tools/expo 0.0.7 → 0.0.9

package/src/handlers/keyboard.ts

@@ -0,0 +1,20 @@
+import type { KeyboardNamespace } from '@rn-bridge-tools/core';
+import { Keyboard } from 'react-native';
+
+export const keyboardHandlers = {
+  'keyboard.dismiss': async (
+    _payload: KeyboardNamespace['keyboard.dismiss']['request'],
+  ): Promise<KeyboardNamespace['keyboard.dismiss']['response']> => {
+    Keyboard.dismiss();
+    return { success: true };
+  },
+
+  'keyboard.getState': async (
+    _payload: KeyboardNamespace['keyboard.getState']['request'],
+  ): Promise<KeyboardNamespace['keyboard.getState']['response']> => {
+    return {
+      visible: false,
+      height: 0,
+    };
+  },
+};

package/src/handlers/location.ts

@@ -0,0 +1,104 @@
+import type { LocationNamespace } from '@rn-bridge-tools/core';
+
+declare const require: (id: string) => unknown;
+
+interface ExpoLocationModule {
+  Accuracy: {
+    Lowest: number;
+    Low: number;
+    Balanced: number;
+    High: number;
+    Highest: number;
+  };
+  getCurrentPositionAsync: (opts: {
+    accuracy?: number;
+  }) => Promise<{
+    coords: {
+      latitude: number;
+      longitude: number;
+      altitude: number | null;
+      accuracy: number | null;
+    };
+    timestamp: number;
+  }>;
+  watchPositionAsync: (
+    opts: { accuracy?: number; distanceInterval?: number; timeInterval?: number },
+    callback: (location: unknown) => void,
+  ) => Promise<{ remove: () => void }>;
+}
+
+const watchSubscriptions = new Map<string, { remove: () => void }>();
+let watchCounter = 0;
+
+export const locationHandlers = {
+  'location.getCurrent': async (
+    payload: LocationNamespace['location.getCurrent']['request'],
+  ): Promise<LocationNamespace['location.getCurrent']['response']> => {
+    let Location: ExpoLocationModule | null = null;
+    try { Location = require('expo-location') as ExpoLocationModule; } catch {}
+    if (!Location) return { success: false, error: 'MODULE_NOT_INSTALLED: expo-location' } as never;
+
+    const accuracyMap: Record<string, number> = {
+      lowest: Location.Accuracy.Lowest,
+      low: Location.Accuracy.Low,
+      balanced: Location.Accuracy.Balanced,
+      high: Location.Accuracy.High,
+      highest: Location.Accuracy.Highest,
+    };
+
+    const result = await Location.getCurrentPositionAsync({
+      accuracy: accuracyMap[payload.accuracy ?? 'balanced'] ?? Location.Accuracy.Balanced,
+    });
+
+    return {
+      lat: result.coords.latitude,
+      lng: result.coords.longitude,
+      altitude: result.coords.altitude ?? undefined,
+      accuracy: result.coords.accuracy ?? undefined,
+      timestamp: result.timestamp,
+    };
+  },
+
+  'location.watchStart': async (
+    payload: LocationNamespace['location.watchStart']['request'],
+  ): Promise<LocationNamespace['location.watchStart']['response']> => {
+    let Location: ExpoLocationModule | null = null;
+    try { Location = require('expo-location') as ExpoLocationModule; } catch {}
+    if (!Location) return { success: false, error: 'MODULE_NOT_INSTALLED: expo-location' } as never;
+
+    watchCounter += 1;
+    const watchId = `watch_${watchCounter}`;
+
+    const accuracyMap: Record<string, number> = {
+      low: Location.Accuracy.Low,
+      balanced: Location.Accuracy.Balanced,
+      high: Location.Accuracy.High,
+    };
+
+    const subscription = await Location.watchPositionAsync(
+      {
+        accuracy: accuracyMap[payload.accuracy ?? 'balanced'] ?? Location.Accuracy.Balanced,
+        distanceInterval: payload.distanceInterval,
+        timeInterval: payload.timeInterval,
+      },
+      (_location) => {
+        // Event push is handled by the WebViewBridge component via emit
+      },
+    );
+
+    watchSubscriptions.set(watchId, subscription);
+    return { watchId };
+  },
+
+  'location.watchStop': async (
+    payload: LocationNamespace['location.watchStop']['request'],
+  ): Promise<LocationNamespace['location.watchStop']['response']> => {
+    const subscription = watchSubscriptions.get(payload.watchId);
+    if (subscription) {
+      subscription.remove();
+      watchSubscriptions.delete(payload.watchId);
+      return { success: true };
+    }
+    return { success: false };
+  },
+};

package/src/handlers/navigation.ts

@@ -0,0 +1,29 @@
+import type { NavigationNamespace } from '@rn-bridge-tools/core';
+
+export const navigationHandlers = {
+  'navigation.goBack': async (
+    _payload: NavigationNamespace['navigation.goBack']['request'],
+  ): Promise<NavigationNamespace['navigation.goBack']['response']> => {
+    // WebView goBack is handled by the WebViewBridge component
+    return { success: true };
+  },
+
+  'navigation.push': async (
+    _payload: NavigationNamespace['navigation.push']['request'],
+  ): Promise<NavigationNamespace['navigation.push']['response']> => {
+    // Navigation push requires access to the navigation context
+    return { success: true };
+  },
+
+  'navigation.close': async (
+    _payload: NavigationNamespace['navigation.close']['request'],
+  ): Promise<NavigationNamespace['navigation.close']['response']> => {
+    return { success: true };
+  },
+
+  'navigation.setSwipeBack': async (
+    _payload: NavigationNamespace['navigation.setSwipeBack']['request'],
+  ): Promise<NavigationNamespace['navigation.setSwipeBack']['response']> => {
+    return { success: true };
+  },
+};

package/src/handlers/permission.ts

@@ -0,0 +1,107 @@
+import type { PermissionNamespace, PermissionType } from '@rn-bridge-tools/core';
+import { Linking } from 'react-native';
+
+declare const require: (id: string) => unknown;
+
+interface PermissionCameraModule {
+  Camera: {
+    getCameraPermissionsAsync: () => Promise<{ status: string; canAskAgain?: boolean }>;
+    requestCameraPermissionsAsync: () => Promise<{ status: string; canAskAgain?: boolean }>;
+  };
+}
+
+interface PermissionLocationModule {
+  getForegroundPermissionsAsync: () => Promise<{ status: string; canAskAgain?: boolean }>;
+  requestForegroundPermissionsAsync: () => Promise<{ status: string; canAskAgain?: boolean }>;
+}
+
+interface PermissionNotificationsModule {
+  getPermissionsAsync: () => Promise<{ status: string; canAskAgain?: boolean }>;
+  requestPermissionsAsync: () => Promise<{ status: string; canAskAgain?: boolean }>;
+}
+
+function getPermissionModule(permission: PermissionType) {
+  switch (permission) {
+    case 'camera': {
+      let mod: PermissionCameraModule | null = null;
+      try { mod = require('expo-camera') as PermissionCameraModule; } catch {}
+      return mod
+        ? {
+            check: () => mod.Camera.getCameraPermissionsAsync(),
+            request: () => mod.Camera.requestCameraPermissionsAsync(),
+          }
+        : null;
+    }
+    case 'location': {
+      let mod: PermissionLocationModule | null = null;
+      try { mod = require('expo-location') as PermissionLocationModule; } catch {}
+      return mod
+        ? {
+            check: () => mod.getForegroundPermissionsAsync(),
+            request: () => mod.requestForegroundPermissionsAsync(),
+          }
+        : null;
+    }
+    case 'notifications': {
+      let mod: PermissionNotificationsModule | null = null;
+      try { mod = require('expo-notifications') as PermissionNotificationsModule; } catch {}
+      return mod
+        ? {
+            check: () => mod.getPermissionsAsync(),
+            request: () => mod.requestPermissionsAsync(),
+          }
+        : null;
+    }
+    default:
+      return null;
+  }
+}
+
+export const permissionHandlers = {
+  'permission.check': async (
+    payload: PermissionNamespace['permission.check']['request'],
+  ): Promise<PermissionNamespace['permission.check']['response']> => {
+    const mod = getPermissionModule(payload.permission);
+    if (!mod) {
+      return { status: 'undetermined', canAskAgain: true };
+    }
+    try {
+      const result = await mod.check();
+      return {
+        status: result.status as 'granted' | 'denied' | 'undetermined',
+        canAskAgain: result.canAskAgain ?? true,
+      };
+    } catch {
+      return { status: 'undetermined', canAskAgain: true };
+    }
+  },
+
+  'permission.request': async (
+    payload: PermissionNamespace['permission.request']['request'],
+  ): Promise<PermissionNamespace['permission.request']['response']> => {
+    const mod = getPermissionModule(payload.permission);
+    if (!mod) {
+      return { status: 'undetermined', canAskAgain: true };
+    }
+    try {
+      const result = await mod.request();
+      return {
+        status: result.status as 'granted' | 'denied' | 'undetermined',
+        canAskAgain: result.canAskAgain ?? true,
+      };
+    } catch {
+      return { status: 'undetermined', canAskAgain: true };
+    }
+  },
+
+  'permission.openSettings': async (
+    _payload: PermissionNamespace['permission.openSettings']['request'],
+  ): Promise<PermissionNamespace['permission.openSettings']['response']> => {
+    try {
+      await Linking.openSettings();
+      return { success: true };
+    } catch {
+      return { success: false };
+    }
+  },
+};

package/src/handlers/preference.ts

@@ -0,0 +1,58 @@
+import type { PreferenceNamespace } from '@rn-bridge-tools/core';
+
+declare const require: (id: string) => unknown;
+
+type AsyncStorage = {
+  default: {
+    getItem: (key: string) => Promise<string | null>;
+    setItem: (key: string, value: string) => Promise<void>;
+    removeItem: (key: string) => Promise<void>;
+    clear: () => Promise<void>;
+  };
+};
+
+export const preferenceHandlers = {
+  'preference.get': async (
+    payload: PreferenceNamespace['preference.get']['request'],
+  ): Promise<PreferenceNamespace['preference.get']['response']> => {
+    let mod: AsyncStorage | null = null;
+    try { mod = require('@react-native-async-storage/async-storage') as AsyncStorage; } catch {}
+    if (!mod) return { value: null };
+
+    const value = await mod.default.getItem(payload.key);
+    return { value };
+  },
+
+  'preference.set': async (
+    payload: PreferenceNamespace['preference.set']['request'],
+  ): Promise<PreferenceNamespace['preference.set']['response']> => {
+    let mod: AsyncStorage | null = null;
+    try { mod = require('@react-native-async-storage/async-storage') as AsyncStorage; } catch {}
+    if (!mod) return { success: false };
+
+    await mod.default.setItem(payload.key, payload.value);
+    return { success: true };
+  },
+
+  'preference.remove': async (
+    payload: PreferenceNamespace['preference.remove']['request'],
+  ): Promise<PreferenceNamespace['preference.remove']['response']> => {
+    let mod: AsyncStorage | null = null;
+    try { mod = require('@react-native-async-storage/async-storage') as AsyncStorage; } catch {}
+    if (!mod) return { success: false };
+
+    await mod.default.removeItem(payload.key);
+    return { success: true };
+  },
+
+  'preference.clear': async (
+    _payload: PreferenceNamespace['preference.clear']['request'],
+  ): Promise<PreferenceNamespace['preference.clear']['response']> => {
+    let mod: AsyncStorage | null = null;
+    try { mod = require('@react-native-async-storage/async-storage') as AsyncStorage; } catch {}
+    if (!mod) return { success: false };
+
+    await mod.default.clear();
+    return { success: true };
+  },
+};

package/src/handlers/push.ts

@@ -0,0 +1,47 @@
+import type { PushNamespace } from '@rn-bridge-tools/core';
+import { Platform } from 'react-native';
+
+declare const require: (id: string) => unknown;
+
+interface NotificationsModule {
+  getExpoPushTokenAsync: () => Promise<{ data: string }>;
+  requestPermissionsAsync: () => Promise<{ status: string }>;
+}
+
+export const pushHandlers = {
+  'push.getToken': async (
+    _payload: PushNamespace['push.getToken']['request'],
+  ): Promise<PushNamespace['push.getToken']['response']> => {
+    let Notifications: NotificationsModule | null = null;
+    try { Notifications = require('expo-notifications') as NotificationsModule; } catch {}
+    if (!Notifications) return { success: false, error: 'MODULE_NOT_INSTALLED: expo-notifications' } as never;
+
+    try {
+      const token = await Notifications.getExpoPushTokenAsync();
+      return {
+        token: token.data,
+        platform: Platform.OS === 'ios' ? 'apns' : 'fcm',
+      };
+    } catch {
+      return { token: '', platform: Platform.OS === 'ios' ? 'apns' : 'fcm' };
+    }
+  },
+
+  'push.requestPermission': async (
+    _payload: PushNamespace['push.requestPermission']['request'],
+  ): Promise<PushNamespace['push.requestPermission']['response']> => {
+    let Notifications: NotificationsModule | null = null;
+    try { Notifications = require('expo-notifications') as NotificationsModule; } catch {}
+    if (!Notifications) return { success: false, error: 'MODULE_NOT_INSTALLED: expo-notifications' } as never;
+
+    try {
+      const { status } = await Notifications.requestPermissionsAsync();
+      return {
+        granted: status === 'granted',
+        status: status as 'granted' | 'denied' | 'undetermined',
+      };
+    } catch {
+      return { granted: false, status: 'denied' };
+    }
+  },
+};

package/src/handlers/scanner.ts

@@ -0,0 +1,31 @@
+import type { ScannerNamespace } from '@rn-bridge-tools/core';
+
+declare const require: (id: string) => unknown;
+
+interface CameraModule {
+  Camera: {
+    requestCameraPermissionsAsync: () => Promise<{ status: string }>;
+  };
+}
+
+export const scannerHandlers = {
+  'scanner.scanQR': async (
+    _payload: ScannerNamespace['scanner.scanQR']['request'],
+  ): Promise<ScannerNamespace['scanner.scanQR']['response']> => {
+    let Camera: CameraModule | null = null;
+    try { Camera = require('expo-camera') as CameraModule; } catch {}
+    if (!Camera) return { success: false, error: 'MODULE_NOT_INSTALLED: expo-camera' } as never;
+
+    try {
+      const { status } = await Camera.Camera.requestCameraPermissionsAsync();
+      if (status !== 'granted') {
+        return { success: false, cancelled: true };
+      }
+      // QR scanning is typically handled via a component, not a direct call.
+      // Return a placeholder indicating the scanner should be opened.
+      return { success: false, error: 'Use Camera component for QR scanning' } as never;
+    } catch {
+      return { success: false };
+    }
+  },
+};

package/src/handlers/share.ts

@@ -0,0 +1,31 @@
+import type { ShareNamespace } from '@rn-bridge-tools/core';
+
+declare const require: (id: string) => unknown;
+
+interface SharingModule {
+  isAvailableAsync: () => Promise<boolean>;
+  shareAsync: (url: string, opts?: { dialogTitle?: string }) => Promise<void>;
+}
+
+export const shareHandlers = {
+  'share.open': async (
+    payload: ShareNamespace['share.open']['request'],
+  ): Promise<ShareNamespace['share.open']['response']> => {
+    let Sharing: SharingModule | null = null;
+    try { Sharing = require('expo-sharing') as SharingModule; } catch {}
+    if (!Sharing) return { success: false, error: 'MODULE_NOT_INSTALLED: expo-sharing' } as never;
+
+    try {
+      const isAvailable = await Sharing.isAvailableAsync();
+      if (!isAvailable) {
+        return { success: false };
+      }
+      await Sharing.shareAsync(payload.url ?? '', {
+        dialogTitle: payload.title,
+      });
+      return { success: true };
+    } catch {
+      return { success: false };
+    }
+  },
+};

package/src/handlers/statusbar.ts

@@ -0,0 +1,35 @@
+import type { StatusBarNamespace } from '@rn-bridge-tools/core';
+import { StatusBar } from 'react-native';
+
+export const statusbarHandlers = {
+  'statusbar.setStyle': async (
+    payload: StatusBarNamespace['statusbar.setStyle']['request'],
+  ): Promise<StatusBarNamespace['statusbar.setStyle']['response']> => {
+    const styleMap: Record<string, 'default' | 'light-content' | 'dark-content'> = {
+      light: 'light-content',
+      dark: 'dark-content',
+      auto: 'default',
+    };
+    StatusBar.setBarStyle(styleMap[payload.style] ?? 'default');
+    return { success: true };
+  },
+
+  'statusbar.setBackgroundColor': async (
+    payload: StatusBarNamespace['statusbar.setBackgroundColor']['request'],
+  ): Promise<StatusBarNamespace['statusbar.setBackgroundColor']['response']> => {
+    StatusBar.setBackgroundColor(payload.color, payload.animated ?? false);
+    return { success: true };
+  },
+
+  'statusbar.setHidden': async (
+    payload: StatusBarNamespace['statusbar.setHidden']['request'],
+  ): Promise<StatusBarNamespace['statusbar.setHidden']['response']> => {
+    const animationMap: Record<string, 'fade' | 'slide' | 'none'> = {
+      fade: 'fade',
+      slide: 'slide',
+      none: 'none',
+    };
+    StatusBar.setHidden(payload.hidden, animationMap[payload.animation ?? 'none']);
+    return { success: true };
+  },
+};

package/src/index.ts

@@ -0,0 +1,23 @@
+export { WebViewBridge, createBridgeWebView } from './WebViewBridge';
+export type { WebViewBridgeProps, WebViewBridgeRef } from './WebViewBridge';
+export { createDefaultHandlers } from './createHandlers';
+export type { HandlerFn, HandlerMap } from './createHandlers';
+
+// Re-export handler maps for advanced usage
+export { cameraHandlers } from './handlers/camera';
+export { locationHandlers } from './handlers/location';
+export { fileHandlers } from './handlers/file';
+export { shareHandlers } from './handlers/share';
+export { deviceHandlers } from './handlers/device';
+export { statusbarHandlers } from './handlers/statusbar';
+export { keyboardHandlers } from './handlers/keyboard';
+export { hapticHandlers } from './handlers/haptic';
+export { clipboardHandlers } from './handlers/clipboard';
+export { scannerHandlers } from './handlers/scanner';
+export { authHandlers } from './handlers/auth';
+export { iapHandlers } from './handlers/iap';
+export { pushHandlers } from './handlers/push';
+export { permissionHandlers } from './handlers/permission';
+export { preferenceHandlers } from './handlers/preference';
+export { navigationHandlers } from './handlers/navigation';
+export { browserHandlers } from './handlers/browser';