@rn-bridge-tools/expo 0.0.1

package/dist/index.cjs

@@ -0,0 +1,741 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  WebViewBridge: () => WebViewBridge,
+  authHandlers: () => authHandlers,
+  browserHandlers: () => browserHandlers,
+  cameraHandlers: () => cameraHandlers,
+  clipboardHandlers: () => clipboardHandlers,
+  createDefaultHandlers: () => createDefaultHandlers,
+  deviceHandlers: () => deviceHandlers,
+  fileHandlers: () => fileHandlers,
+  hapticHandlers: () => hapticHandlers,
+  iapHandlers: () => iapHandlers,
+  keyboardHandlers: () => keyboardHandlers,
+  locationHandlers: () => locationHandlers,
+  navigationHandlers: () => navigationHandlers,
+  permissionHandlers: () => permissionHandlers,
+  preferenceHandlers: () => preferenceHandlers,
+  pushHandlers: () => pushHandlers,
+  scannerHandlers: () => scannerHandlers,
+  shareHandlers: () => shareHandlers,
+  statusbarHandlers: () => statusbarHandlers
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/WebViewBridge.tsx
+var import_react = require("react");
+var import_react_native = require("@webview-bridge/react-native");
+var import_jsx_runtime = require("react/jsx-runtime");
+var WebViewBridge = (0, import_react.forwardRef)(
+  function WebViewBridge2({ handlers, customHandlers, ...webViewProps }, ref) {
+    const handlersRef = (0, import_react.useRef)(handlers);
+    const customRef = (0, import_react.useRef)(customHandlers);
+    const { InternalWebView, postMessage } = (0, import_react.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 = (0, import_react_native.bridge)(allHandlers);
+      const result = (0, import_react_native.createWebView)({
+        bridge: appBridge,
+        debug: __DEV__ ?? false
+      });
+      return { InternalWebView: result.WebView, postMessage: result.postMessage };
+    }, []);
+    (0, import_react.useImperativeHandle)(
+      ref,
+      () => ({
+        emit: (event, data) => {
+          postMessage(event, data);
+        }
+      }),
+      [postMessage]
+    );
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(InternalWebView, { ...webViewProps });
+  }
+);
+
+// src/handlers/camera.ts
+var import_core = require("@rn-bridge-tools/core");
+var cameraHandlers = {
+  "camera.take": async (payload) => {
+    const ImagePicker = await (0, import_core.tryImport)("expo-image-picker");
+    if (!ImagePicker) return (0, import_core.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 (0, import_core.tryImport)("expo-image-picker");
+    if (!ImagePicker) return (0, import_core.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
+var import_core2 = require("@rn-bridge-tools/core");
+var watchSubscriptions = /* @__PURE__ */ new Map();
+var watchCounter = 0;
+var locationHandlers = {
+  "location.getCurrent": async (payload) => {
+    const Location = await (0, import_core2.tryImport)("expo-location");
+    if (!Location) return (0, import_core2.moduleNotInstalledError)("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 (0, import_core2.tryImport)("expo-location");
+    if (!Location) return (0, import_core2.moduleNotInstalledError)("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
+var import_core3 = require("@rn-bridge-tools/core");
+var fileHandlers = {
+  "file.download": async (payload) => {
+    const FS = await (0, import_core3.tryImport)("expo-file-system");
+    if (!FS) return (0, import_core3.moduleNotInstalledError)("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 (0, import_core3.tryImport)("expo-file-system");
+    if (!FS) return (0, import_core3.moduleNotInstalledError)("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 (0, import_core3.tryImport)("expo-file-system");
+    if (!FS) return (0, import_core3.moduleNotInstalledError)("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 (0, import_core3.tryImport)("expo-document-picker");
+    if (!DocumentPicker) return (0, import_core3.moduleNotInstalledError)("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
+var import_core4 = require("@rn-bridge-tools/core");
+var shareHandlers = {
+  "share.open": async (payload) => {
+    const Sharing = await (0, import_core4.tryImport)("expo-sharing");
+    if (!Sharing) return (0, import_core4.moduleNotInstalledError)("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
+var import_core5 = require("@rn-bridge-tools/core");
+var import_react_native2 = require("react-native");
+var deviceHandlers = {
+  "device.getInfo": async (_payload) => {
+    const Device = await (0, import_core5.tryImport)("expo-device");
+    if (!Device) return (0, import_core5.moduleNotInstalledError)("expo-device");
+    return {
+      os: import_react_native2.Platform.OS,
+      osVersion: import_react_native2.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 (0, import_core5.tryImport)("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 (0, import_core5.tryImport)("@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
+var import_react_native3 = require("react-native");
+var statusbarHandlers = {
+  "statusbar.setStyle": async (payload) => {
+    const styleMap = {
+      light: "light-content",
+      dark: "dark-content",
+      auto: "default"
+    };
+    import_react_native3.StatusBar.setBarStyle(styleMap[payload.style] ?? "default");
+    return { success: true };
+  },
+  "statusbar.setBackgroundColor": async (payload) => {
+    import_react_native3.StatusBar.setBackgroundColor(payload.color, payload.animated ?? false);
+    return { success: true };
+  },
+  "statusbar.setHidden": async (payload) => {
+    const animationMap = {
+      fade: "fade",
+      slide: "slide",
+      none: "none"
+    };
+    import_react_native3.StatusBar.setHidden(payload.hidden, animationMap[payload.animation ?? "none"]);
+    return { success: true };
+  }
+};
+
+// src/handlers/keyboard.ts
+var import_react_native4 = require("react-native");
+var keyboardHandlers = {
+  "keyboard.dismiss": async (_payload) => {
+    import_react_native4.Keyboard.dismiss();
+    return { success: true };
+  },
+  "keyboard.getState": async (_payload) => {
+    return {
+      visible: false,
+      height: 0
+    };
+  }
+};
+
+// src/handlers/haptic.ts
+var import_core6 = require("@rn-bridge-tools/core");
+var hapticHandlers = {
+  "haptic.impact": async (payload) => {
+    const Haptics = await (0, import_core6.tryImport)("expo-haptics");
+    if (!Haptics) {
+      (0, import_core6.moduleNotInstalledError)("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 (0, import_core6.tryImport)("expo-haptics");
+    if (!Haptics) {
+      (0, import_core6.moduleNotInstalledError)("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 (0, import_core6.tryImport)("expo-haptics");
+    if (!Haptics) {
+      (0, import_core6.moduleNotInstalledError)("expo-haptics");
+      return;
+    }
+    await Haptics.selectionAsync();
+  }
+};
+
+// src/handlers/clipboard.ts
+var import_core7 = require("@rn-bridge-tools/core");
+var clipboardHandlers = {
+  "clipboard.copy": async (payload) => {
+    const Clipboard = await (0, import_core7.tryImport)("expo-clipboard");
+    if (!Clipboard) return (0, import_core7.moduleNotInstalledError)("expo-clipboard");
+    await Clipboard.setStringAsync(payload.text);
+    return { success: true };
+  },
+  "clipboard.paste": async (_payload) => {
+    const Clipboard = await (0, import_core7.tryImport)("expo-clipboard");
+    if (!Clipboard) return (0, import_core7.moduleNotInstalledError)("expo-clipboard");
+    const text = await Clipboard.getStringAsync();
+    return { text, hasContent: text.length > 0 };
+  }
+};
+
+// src/handlers/scanner.ts
+var import_core8 = require("@rn-bridge-tools/core");
+var scannerHandlers = {
+  "scanner.scanQR": async (_payload) => {
+    const Camera = await (0, import_core8.tryImport)("expo-camera");
+    if (!Camera) return (0, import_core8.moduleNotInstalledError)("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
+var import_core9 = require("@rn-bridge-tools/core");
+var authHandlers = {
+  "auth.biometric": async (payload) => {
+    const LocalAuth = await (0, import_core9.tryImport)("expo-local-authentication");
+    if (!LocalAuth) return (0, import_core9.moduleNotInstalledError)("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 (0, import_core9.tryImport)("expo-local-authentication");
+    if (!LocalAuth) return (0, import_core9.moduleNotInstalledError)("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
+var import_core10 = require("@rn-bridge-tools/core");
+var import_react_native5 = require("react-native");
+var pushHandlers = {
+  "push.getToken": async (_payload) => {
+    const Notifications = await (0, import_core10.tryImport)("expo-notifications");
+    if (!Notifications) return (0, import_core10.moduleNotInstalledError)("expo-notifications");
+    try {
+      const token = await Notifications.getExpoPushTokenAsync();
+      return {
+        token: token.data,
+        platform: import_react_native5.Platform.OS === "ios" ? "apns" : "fcm"
+      };
+    } catch {
+      return { token: "", platform: import_react_native5.Platform.OS === "ios" ? "apns" : "fcm" };
+    }
+  },
+  "push.requestPermission": async (_payload) => {
+    const Notifications = await (0, import_core10.tryImport)("expo-notifications");
+    if (!Notifications) return (0, import_core10.moduleNotInstalledError)("expo-notifications");
+    try {
+      const { status } = await Notifications.requestPermissionsAsync();
+      return {
+        granted: status === "granted",
+        status
+      };
+    } catch {
+      return { granted: false, status: "denied" };
+    }
+  }
+};
+
+// src/handlers/permission.ts
+var import_react_native6 = require("react-native");
+var import_core11 = require("@rn-bridge-tools/core");
+async function getPermissionModule(permission) {
+  switch (permission) {
+    case "camera": {
+      const mod = await (0, import_core11.tryImport)("expo-camera");
+      return mod ? {
+        check: () => mod.Camera.getCameraPermissionsAsync(),
+        request: () => mod.Camera.requestCameraPermissionsAsync()
+      } : null;
+    }
+    case "location": {
+      const mod = await (0, import_core11.tryImport)("expo-location");
+      return mod ? {
+        check: () => mod.getForegroundPermissionsAsync(),
+        request: () => mod.requestForegroundPermissionsAsync()
+      } : null;
+    }
+    case "notifications": {
+      const mod = await (0, import_core11.tryImport)("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 import_react_native6.Linking.openSettings();
+      return { success: true };
+    } catch {
+      return { success: false };
+    }
+  }
+};
+
+// src/handlers/preference.ts
+var import_core12 = require("@rn-bridge-tools/core");
+var preferenceHandlers = {
+  "preference.get": async (payload) => {
+    const mod = await (0, import_core12.tryImport)("@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 (0, import_core12.tryImport)("@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 (0, import_core12.tryImport)("@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 (0, import_core12.tryImport)("@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
+var import_core13 = require("@rn-bridge-tools/core");
+var import_react_native7 = require("react-native");
+var browserHandlers = {
+  "browser.openExternal": async (payload) => {
+    try {
+      await import_react_native7.Linking.openURL(payload.url);
+      return { success: true };
+    } catch {
+      return { success: false };
+    }
+  },
+  "browser.openInternal": async (payload) => {
+    const WebBrowser = await (0, import_core13.tryImport)("expo-web-browser");
+    if (!WebBrowser) return (0, import_core13.moduleNotInstalledError)("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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WebViewBridge,
+  authHandlers,
+  browserHandlers,
+  cameraHandlers,
+  clipboardHandlers,
+  createDefaultHandlers,
+  deviceHandlers,
+  fileHandlers,
+  hapticHandlers,
+  iapHandlers,
+  keyboardHandlers,
+  locationHandlers,
+  navigationHandlers,
+  permissionHandlers,
+  preferenceHandlers,
+  pushHandlers,
+  scannerHandlers,
+  shareHandlers,
+  statusbarHandlers
+});
+//# sourceMappingURL=index.cjs.map