@rn-bridge-tools/expo 0.0.1

package/dist/index.js

@@ -0,0 +1,696 @@
+// src/WebViewBridge.tsx
+import { forwardRef, useImperativeHandle, useMemo, useRef } from "react";
+import { bridge, createWebView } from "@webview-bridge/react-native";
+import { jsx } from "react/jsx-runtime";
+var WebViewBridge = forwardRef(
+  function WebViewBridge2({ handlers, customHandlers, ...webViewProps }, ref) {
+    const handlersRef = useRef(handlers);
+    const customRef = useRef(customHandlers);
+    const { InternalWebView, postMessage } = useMemo(() => {
+      const allHandlers = {};
+      const mergedHandlers = { ...handlersRef.current, ...customRef.current };
+      for (const [key, handler] of Object.entries(mergedHandlers)) {
+        if (handler) {
+          allHandlers[key] = async (...args) => {
+            const payload = args[0] ?? {};
+            return handler(payload);
+          };
+        }
+      }
+      const appBridge = bridge(allHandlers);
+      const result = createWebView({
+        bridge: appBridge,
+        debug: __DEV__ ?? false
+      });
+      return { InternalWebView: result.WebView, postMessage: result.postMessage };
+    }, []);
+    useImperativeHandle(
+      ref,
+      () => ({
+        emit: (event, data) => {
+          postMessage(event, data);
+        }
+      }),
+      [postMessage]
+    );
+    return /* @__PURE__ */ jsx(InternalWebView, { ...webViewProps });
+  }
+);
+
+// src/handlers/camera.ts
+import { moduleNotInstalledError, tryImport } from "@rn-bridge-tools/core";
+var cameraHandlers = {
+  "camera.take": async (payload) => {
+    const ImagePicker = await tryImport("expo-image-picker");
+    if (!ImagePicker) return moduleNotInstalledError("expo-image-picker");
+    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: [] };
+    }
+    const asset = result.assets[0];
+    return {
+      success: true,
+      uri: asset.uri,
+      width: asset.width,
+      height: asset.height,
+      fileSize: asset.fileSize,
+      mimeType: asset.mimeType ?? void 0
+    };
+  },
+  "camera.pickImage": async (payload) => {
+    const ImagePicker = await tryImport("expo-image-picker");
+    if (!ImagePicker) return moduleNotInstalledError("expo-image-picker");
+    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 ?? void 0
+      }))
+    };
+  }
+};
+
+// src/handlers/location.ts
+import { moduleNotInstalledError as moduleNotInstalledError2, tryImport as tryImport2 } from "@rn-bridge-tools/core";
+var watchSubscriptions = /* @__PURE__ */ new Map();
+var watchCounter = 0;
+var locationHandlers = {
+  "location.getCurrent": async (payload) => {
+    const Location = await tryImport2("expo-location");
+    if (!Location) return moduleNotInstalledError2("expo-location");
+    const accuracyMap = {
+      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 ?? void 0,
+      accuracy: result.coords.accuracy ?? void 0,
+      timestamp: result.timestamp
+    };
+  },
+  "location.watchStart": async (payload) => {
+    const Location = await tryImport2("expo-location");
+    if (!Location) return moduleNotInstalledError2("expo-location");
+    watchCounter += 1;
+    const watchId = `watch_${watchCounter}`;
+    const accuracyMap = {
+      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) => {
+      }
+    );
+    watchSubscriptions.set(watchId, subscription);
+    return { watchId };
+  },
+  "location.watchStop": async (payload) => {
+    const subscription = watchSubscriptions.get(payload.watchId);
+    if (subscription) {
+      subscription.remove();
+      watchSubscriptions.delete(payload.watchId);
+      return { success: true };
+    }
+    return { success: false };
+  }
+};
+
+// src/handlers/file.ts
+import { moduleNotInstalledError as moduleNotInstalledError3, tryImport as tryImport3 } from "@rn-bridge-tools/core";
+var fileHandlers = {
+  "file.download": async (payload) => {
+    const FS = await tryImport3("expo-file-system");
+    if (!FS) return moduleNotInstalledError3("expo-file-system");
+    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) => {
+    const FS = await tryImport3("expo-file-system");
+    if (!FS) return moduleNotInstalledError3("expo-file-system");
+    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) => {
+    const FS = await tryImport3("expo-file-system");
+    if (!FS) return moduleNotInstalledError3("expo-file-system");
+    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) => {
+    const DocumentPicker = await tryImport3("expo-document-picker");
+    if (!DocumentPicker) return moduleNotInstalledError3("expo-document-picker");
+    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: [] };
+    }
+  }
+};
+
+// src/handlers/share.ts
+import { moduleNotInstalledError as moduleNotInstalledError4, tryImport as tryImport4 } from "@rn-bridge-tools/core";
+var shareHandlers = {
+  "share.open": async (payload) => {
+    const Sharing = await tryImport4("expo-sharing");
+    if (!Sharing) return moduleNotInstalledError4("expo-sharing");
+    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 };
+    }
+  }
+};
+
+// src/handlers/device.ts
+import { moduleNotInstalledError as moduleNotInstalledError5, tryImport as tryImport5 } from "@rn-bridge-tools/core";
+import { Platform } from "react-native";
+var deviceHandlers = {
+  "device.getInfo": async (_payload) => {
+    const Device = await tryImport5("expo-device");
+    if (!Device) return moduleNotInstalledError5("expo-device");
+    return {
+      os: Platform.OS,
+      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) => {
+    try {
+      const Battery = await tryImport5("expo-battery");
+      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) => {
+    try {
+      const NetInfo = await tryImport5("@react-native-community/netinfo");
+      if (!NetInfo) {
+        return { type: "unknown", isConnected: true };
+      }
+      const state = await NetInfo.fetch();
+      return {
+        type: state.type ?? "unknown",
+        isConnected: state.isConnected ?? false
+      };
+    } catch {
+      return { type: "unknown", isConnected: true };
+    }
+  }
+};
+
+// src/handlers/statusbar.ts
+import { StatusBar } from "react-native";
+var statusbarHandlers = {
+  "statusbar.setStyle": async (payload) => {
+    const styleMap = {
+      light: "light-content",
+      dark: "dark-content",
+      auto: "default"
+    };
+    StatusBar.setBarStyle(styleMap[payload.style] ?? "default");
+    return { success: true };
+  },
+  "statusbar.setBackgroundColor": async (payload) => {
+    StatusBar.setBackgroundColor(payload.color, payload.animated ?? false);
+    return { success: true };
+  },
+  "statusbar.setHidden": async (payload) => {
+    const animationMap = {
+      fade: "fade",
+      slide: "slide",
+      none: "none"
+    };
+    StatusBar.setHidden(payload.hidden, animationMap[payload.animation ?? "none"]);
+    return { success: true };
+  }
+};
+
+// src/handlers/keyboard.ts
+import { Keyboard } from "react-native";
+var keyboardHandlers = {
+  "keyboard.dismiss": async (_payload) => {
+    Keyboard.dismiss();
+    return { success: true };
+  },
+  "keyboard.getState": async (_payload) => {
+    return {
+      visible: false,
+      height: 0
+    };
+  }
+};
+
+// src/handlers/haptic.ts
+import { moduleNotInstalledError as moduleNotInstalledError6, tryImport as tryImport6 } from "@rn-bridge-tools/core";
+var hapticHandlers = {
+  "haptic.impact": async (payload) => {
+    const Haptics = await tryImport6("expo-haptics");
+    if (!Haptics) {
+      moduleNotInstalledError6("expo-haptics");
+      return;
+    }
+    const styleMap = {
+      light: Haptics.ImpactFeedbackStyle.Light,
+      medium: Haptics.ImpactFeedbackStyle.Medium,
+      heavy: Haptics.ImpactFeedbackStyle.Heavy
+    };
+    await Haptics.impactAsync(styleMap[payload.style]);
+  },
+  "haptic.notification": async (payload) => {
+    const Haptics = await tryImport6("expo-haptics");
+    if (!Haptics) {
+      moduleNotInstalledError6("expo-haptics");
+      return;
+    }
+    const typeMap = {
+      success: Haptics.NotificationFeedbackType.Success,
+      warning: Haptics.NotificationFeedbackType.Warning,
+      error: Haptics.NotificationFeedbackType.Error
+    };
+    await Haptics.notificationAsync(typeMap[payload.type]);
+  },
+  "haptic.selection": async () => {
+    const Haptics = await tryImport6("expo-haptics");
+    if (!Haptics) {
+      moduleNotInstalledError6("expo-haptics");
+      return;
+    }
+    await Haptics.selectionAsync();
+  }
+};
+
+// src/handlers/clipboard.ts
+import { moduleNotInstalledError as moduleNotInstalledError7, tryImport as tryImport7 } from "@rn-bridge-tools/core";
+var clipboardHandlers = {
+  "clipboard.copy": async (payload) => {
+    const Clipboard = await tryImport7("expo-clipboard");
+    if (!Clipboard) return moduleNotInstalledError7("expo-clipboard");
+    await Clipboard.setStringAsync(payload.text);
+    return { success: true };
+  },
+  "clipboard.paste": async (_payload) => {
+    const Clipboard = await tryImport7("expo-clipboard");
+    if (!Clipboard) return moduleNotInstalledError7("expo-clipboard");
+    const text = await Clipboard.getStringAsync();
+    return { text, hasContent: text.length > 0 };
+  }
+};
+
+// src/handlers/scanner.ts
+import { moduleNotInstalledError as moduleNotInstalledError8, tryImport as tryImport8 } from "@rn-bridge-tools/core";
+var scannerHandlers = {
+  "scanner.scanQR": async (_payload) => {
+    const Camera = await tryImport8("expo-camera");
+    if (!Camera) return moduleNotInstalledError8("expo-camera");
+    try {
+      const { status } = await Camera.Camera.requestCameraPermissionsAsync();
+      if (status !== "granted") {
+        return { success: false, cancelled: true };
+      }
+      return { success: false, error: "Use Camera component for QR scanning" };
+    } catch {
+      return { success: false };
+    }
+  }
+};
+
+// src/handlers/auth.ts
+import { moduleNotInstalledError as moduleNotInstalledError9, tryImport as tryImport9 } from "@rn-bridge-tools/core";
+var authHandlers = {
+  "auth.biometric": async (payload) => {
+    const LocalAuth = await tryImport9("expo-local-authentication");
+    if (!LocalAuth) return moduleNotInstalledError9("expo-local-authentication");
+    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) => {
+    const LocalAuth = await tryImport9("expo-local-authentication");
+    if (!LocalAuth) return moduleNotInstalledError9("expo-local-authentication");
+    try {
+      const available = await LocalAuth.hasHardwareAsync();
+      const types = await LocalAuth.supportedAuthenticationTypesAsync();
+      let biometryType;
+      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 };
+    }
+  }
+};
+
+// src/handlers/iap.ts
+var iapHandlers = {
+  "iap.getProducts": async (_payload) => {
+    return { products: [] };
+  },
+  "iap.purchase": async (_payload) => {
+    return { success: false, error: "IAP not configured" };
+  },
+  "iap.restore": async (_payload) => {
+    return { purchases: [] };
+  }
+};
+
+// src/handlers/push.ts
+import { moduleNotInstalledError as moduleNotInstalledError10, tryImport as tryImport10 } from "@rn-bridge-tools/core";
+import { Platform as Platform2 } from "react-native";
+var pushHandlers = {
+  "push.getToken": async (_payload) => {
+    const Notifications = await tryImport10("expo-notifications");
+    if (!Notifications) return moduleNotInstalledError10("expo-notifications");
+    try {
+      const token = await Notifications.getExpoPushTokenAsync();
+      return {
+        token: token.data,
+        platform: Platform2.OS === "ios" ? "apns" : "fcm"
+      };
+    } catch {
+      return { token: "", platform: Platform2.OS === "ios" ? "apns" : "fcm" };
+    }
+  },
+  "push.requestPermission": async (_payload) => {
+    const Notifications = await tryImport10("expo-notifications");
+    if (!Notifications) return moduleNotInstalledError10("expo-notifications");
+    try {
+      const { status } = await Notifications.requestPermissionsAsync();
+      return {
+        granted: status === "granted",
+        status
+      };
+    } catch {
+      return { granted: false, status: "denied" };
+    }
+  }
+};
+
+// src/handlers/permission.ts
+import { Linking } from "react-native";
+import { tryImport as tryImport11 } from "@rn-bridge-tools/core";
+async function getPermissionModule(permission) {
+  switch (permission) {
+    case "camera": {
+      const mod = await tryImport11("expo-camera");
+      return mod ? {
+        check: () => mod.Camera.getCameraPermissionsAsync(),
+        request: () => mod.Camera.requestCameraPermissionsAsync()
+      } : null;
+    }
+    case "location": {
+      const mod = await tryImport11("expo-location");
+      return mod ? {
+        check: () => mod.getForegroundPermissionsAsync(),
+        request: () => mod.requestForegroundPermissionsAsync()
+      } : null;
+    }
+    case "notifications": {
+      const mod = await tryImport11("expo-notifications");
+      return mod ? {
+        check: () => mod.getPermissionsAsync(),
+        request: () => mod.requestPermissionsAsync()
+      } : null;
+    }
+    default:
+      return null;
+  }
+}
+var permissionHandlers = {
+  "permission.check": async (payload) => {
+    const mod = await getPermissionModule(payload.permission);
+    if (!mod) {
+      return { status: "undetermined", canAskAgain: true };
+    }
+    try {
+      const result = await mod.check();
+      return {
+        status: result.status,
+        canAskAgain: result.canAskAgain ?? true
+      };
+    } catch {
+      return { status: "undetermined", canAskAgain: true };
+    }
+  },
+  "permission.request": async (payload) => {
+    const mod = await getPermissionModule(payload.permission);
+    if (!mod) {
+      return { status: "undetermined", canAskAgain: true };
+    }
+    try {
+      const result = await mod.request();
+      return {
+        status: result.status,
+        canAskAgain: result.canAskAgain ?? true
+      };
+    } catch {
+      return { status: "undetermined", canAskAgain: true };
+    }
+  },
+  "permission.openSettings": async (_payload) => {
+    try {
+      await Linking.openSettings();
+      return { success: true };
+    } catch {
+      return { success: false };
+    }
+  }
+};
+
+// src/handlers/preference.ts
+import { tryImport as tryImport12 } from "@rn-bridge-tools/core";
+var preferenceHandlers = {
+  "preference.get": async (payload) => {
+    const mod = await tryImport12("@react-native-async-storage/async-storage");
+    if (!mod) return { value: null };
+    const value = await mod.default.getItem(payload.key);
+    return { value };
+  },
+  "preference.set": async (payload) => {
+    const mod = await tryImport12("@react-native-async-storage/async-storage");
+    if (!mod) return { success: false };
+    await mod.default.setItem(payload.key, payload.value);
+    return { success: true };
+  },
+  "preference.remove": async (payload) => {
+    const mod = await tryImport12("@react-native-async-storage/async-storage");
+    if (!mod) return { success: false };
+    await mod.default.removeItem(payload.key);
+    return { success: true };
+  },
+  "preference.clear": async (_payload) => {
+    const mod = await tryImport12("@react-native-async-storage/async-storage");
+    if (!mod) return { success: false };
+    await mod.default.clear();
+    return { success: true };
+  }
+};
+
+// src/handlers/navigation.ts
+var navigationHandlers = {
+  "navigation.goBack": async (_payload) => {
+    return { success: true };
+  },
+  "navigation.push": async (_payload) => {
+    return { success: true };
+  },
+  "navigation.close": async (_payload) => {
+    return { success: true };
+  },
+  "navigation.setSwipeBack": async (_payload) => {
+    return { success: true };
+  }
+};
+
+// src/handlers/browser.ts
+import { moduleNotInstalledError as moduleNotInstalledError11, tryImport as tryImport13 } from "@rn-bridge-tools/core";
+import { Linking as Linking2 } from "react-native";
+var browserHandlers = {
+  "browser.openExternal": async (payload) => {
+    try {
+      await Linking2.openURL(payload.url);
+      return { success: true };
+    } catch {
+      return { success: false };
+    }
+  },
+  "browser.openInternal": async (payload) => {
+    const WebBrowser = await tryImport13("expo-web-browser");
+    if (!WebBrowser) return moduleNotInstalledError11("expo-web-browser");
+    try {
+      await WebBrowser.openBrowserAsync(payload.url, {
+        showTitle: payload.showTitle,
+        toolbarColor: payload.toolbarColor
+      });
+      return { success: true };
+    } catch {
+      return { success: false };
+    }
+  }
+};
+
+// src/createHandlers.ts
+var handlerRegistry = {
+  camera: cameraHandlers,
+  location: locationHandlers,
+  file: fileHandlers,
+  share: shareHandlers,
+  device: deviceHandlers,
+  statusbar: statusbarHandlers,
+  keyboard: keyboardHandlers,
+  haptic: hapticHandlers,
+  clipboard: clipboardHandlers,
+  scanner: scannerHandlers,
+  auth: authHandlers,
+  iap: iapHandlers,
+  push: pushHandlers,
+  permission: permissionHandlers,
+  preference: preferenceHandlers,
+  navigation: navigationHandlers,
+  browser: browserHandlers
+};
+function createDisabledHandler(_namespace, _action) {
+  return async () => ({
+    success: false,
+    error: `not_enabled: ${_namespace}.${_action}`
+  });
+}
+function createDefaultHandlers(options = {}) {
+  const result = {};
+  for (const [namespace, handlers] of Object.entries(handlerRegistry)) {
+    const enabled = options[namespace] ?? false;
+    for (const [action, handler] of Object.entries(handlers)) {
+      if (enabled) {
+        result[action] = handler;
+      } else {
+        const actionName = action.split(".")[1] ?? action;
+        result[action] = createDisabledHandler(namespace, actionName);
+      }
+    }
+  }
+  return result;
+}
+export {
+  WebViewBridge,
+  authHandlers,
+  browserHandlers,
+  cameraHandlers,
+  clipboardHandlers,
+  createDefaultHandlers,
+  deviceHandlers,
+  fileHandlers,
+  hapticHandlers,
+  iapHandlers,
+  keyboardHandlers,
+  locationHandlers,
+  navigationHandlers,
+  permissionHandlers,
+  preferenceHandlers,
+  pushHandlers,
+  scannerHandlers,
+  shareHandlers,
+  statusbarHandlers
+};
+//# sourceMappingURL=index.js.map