@pmate/bridge 0.1.2 → 0.1.4

package/global.d.ts

@@ -2,6 +2,8 @@ declare global {
   interface Window {
     PmateBridge?: {
       call: (functionName: string, params?: any) => Promise<any>
+      on?: (eventName: string, handler: (payload: any) => void) => () => void
+      __emit?: (eventName: string, payload: any) => void
       __notify: (event: any) => void
     }
     isPmate?: boolean

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmate/bridge",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "files": [
     "src",
     "global.d.ts"

package/src/index.ts

@@ -1,4 +1,17 @@
 export * from "./PmateBridgeProvider"
 export * from "./SafeAreaVarsProvider"
 export * from "./hooks"
+export {
+  connectBluetoothDevice,
+  disconnectBluetoothDevice,
+  getBluetoothCapabilities,
+  getConnectedBluetoothDevices,
+  onBluetoothEvent,
+  readBluetooth,
+  requestBluetoothPermission,
+  scanBluetoothDevices,
+  stopBluetoothScan,
+  subscribeBluetooth,
+  writeBluetooth,
+} from "./internal"
 export type * from "./types"

package/src/internal.ts

@@ -1,8 +1,26 @@
-import type { DeviceInfo, PermissionResult, PickedFile, SafeInsets } from "./types"
+import type {
+  BluetoothCapabilities,
+  BluetoothConnectOptions,
+  BluetoothConnection,
+  BluetoothDevice,
+  BluetoothEventName,
+  BluetoothPermissionResult,
+  BluetoothReadOptions,
+  BluetoothReadResult,
+  BluetoothScanOptions,
+  BluetoothScanResult,
+  BluetoothSubscribeOptions,
+  BluetoothWriteOptions,
+  DeviceInfo,
+  PermissionResult,
+  PickedFile,
+  SafeInsets,
+} from "./types"
 
 type PmateWindow = Window & {
   PmateBridge?: {
     call: <T>(functionName: string, params?: unknown) => Promise<T>
+    on?: (eventName: string, handler: (payload: unknown) => void) => () => void
   }
   isPmate?: boolean
 }
@@ -30,6 +48,13 @@ async function callBridge<T>(functionName: string, params?: unknown): Promise<T
   }
 }
 
+async function requireBridge<T>(functionName: string, params?: unknown): Promise<T> {
+  if (!hasWindow() || !(window as PmateWindow).PmateBridge?.call) {
+    throw new Error("Pmate bridge is unavailable")
+  }
+  return (window as PmateWindow).PmateBridge!.call<T>(functionName, params)
+}
+
 export function getFallbackSafeInsets(): SafeInsets {
   return { ...ZERO_SAFE_INSETS }
 }
@@ -73,3 +98,66 @@ export async function pickFileBridge(): Promise<PickedFile[]> {
   const files = await callBridge<PickedFile[]>("pickFile")
   return files ?? []
 }
+
+export function getBluetoothCapabilities(): Promise<BluetoothCapabilities> {
+  return requireBridge<BluetoothCapabilities>("bluetooth.getCapabilities")
+}
+
+export function requestBluetoothPermission(): Promise<BluetoothPermissionResult> {
+  return requireBridge<BluetoothPermissionResult>("bluetooth.requestPermission")
+}
+
+export function scanBluetoothDevices(options?: BluetoothScanOptions): Promise<BluetoothScanResult> {
+  return requireBridge<BluetoothScanResult>("bluetooth.scan", options)
+}
+
+export function stopBluetoothScan(): Promise<{ stopped: true }> {
+  return requireBridge<{ stopped: true }>("bluetooth.stopScan")
+}
+
+export function getConnectedBluetoothDevices(): Promise<{ devices: BluetoothDevice[] }> {
+  return requireBridge("bluetooth.getConnectedDevices")
+}
+
+export function connectBluetoothDevice(
+  deviceId: string,
+  options?: BluetoothConnectOptions
+): Promise<BluetoothConnection> {
+  return requireBridge<BluetoothConnection>("bluetooth.connect", { deviceId, options: options ?? null })
+}
+
+export function disconnectBluetoothDevice(connectionId: string): Promise<{ disconnected: true }> {
+  return requireBridge<{ disconnected: true }>("bluetooth.disconnect", { connectionId })
+}
+
+export function writeBluetooth(
+  connectionId: string,
+  data: string,
+  options: BluetoothWriteOptions
+): Promise<{ written: true }> {
+  return requireBridge<{ written: true }>("bluetooth.write", { connectionId, data, options })
+}
+
+export function readBluetooth(
+  connectionId: string,
+  options?: BluetoothReadOptions
+): Promise<BluetoothReadResult> {
+  return requireBridge<BluetoothReadResult>("bluetooth.read", { connectionId, options: options ?? null })
+}
+
+export function subscribeBluetooth(
+  connectionId: string,
+  options: BluetoothSubscribeOptions
+): Promise<{ subscribed: true }> {
+  return requireBridge<{ subscribed: true }>("bluetooth.subscribe", { connectionId, options })
+}
+
+export function onBluetoothEvent(
+  eventName: BluetoothEventName,
+  handler: (payload: unknown) => void
+): () => void {
+  if (!hasWindow() || !(window as PmateWindow).PmateBridge?.on) {
+    throw new Error("Pmate bridge event subscription is unavailable")
+  }
+  return (window as PmateWindow).PmateBridge!.on!(`bluetooth.${eventName}`, handler)
+}

package/src/types.ts

@@ -33,3 +33,96 @@ export interface PermissionResult {
   requested: unknown
   granted: boolean
 }
+
+export type BluetoothTransport = "ble" | "classic"
+export type BluetoothBinaryEncoding = "base64" | "hex" | "utf-8"
+export type BluetoothEventName =
+  | "scanResult"
+  | "scanStopped"
+  | "connected"
+  | "disconnected"
+  | "connectionLost"
+  | "data"
+  | "permissionChanged"
+  | "error"
+
+export interface BluetoothCapabilities {
+  supported: boolean
+  enabled: boolean
+  ble: boolean
+  classic: boolean
+  canScan: boolean
+  canConnect: boolean
+  transports: BluetoothTransport[]
+}
+
+export interface BluetoothPermissionResult {
+  requested: string[]
+  granted: boolean
+  missing: string[]
+}
+
+export interface BluetoothDevice {
+  id: string
+  name: string
+  kind: "unknown"
+  transport: BluetoothTransport
+  rssi: number | null
+  manufacturer: string | null
+  services: string[]
+  paired: boolean | null
+}
+
+export interface BluetoothScanOptions {
+  timeoutMs?: number
+  transports?: BluetoothTransport[]
+  services?: string[]
+  allowDuplicates?: boolean
+}
+
+export interface BluetoothScanResult {
+  scanId: string
+  devices?: BluetoothDevice[]
+  active: boolean
+}
+
+export interface BluetoothConnectOptions {
+  transport?: BluetoothTransport
+}
+
+export interface BluetoothConnection {
+  id: string
+  deviceId: string
+  transport: BluetoothTransport
+  state: "connected"
+}
+
+export interface BluetoothWriteOptions {
+  service?: string
+  characteristic?: string
+  encoding: BluetoothBinaryEncoding
+  withResponse?: boolean
+}
+
+export interface BluetoothReadOptions {
+  service?: string
+  characteristic?: string
+  encoding?: BluetoothBinaryEncoding
+}
+
+export type BluetoothSubscribeOptions = BluetoothReadOptions
+
+export interface BluetoothReadResult {
+  data: string
+  encoding: BluetoothBinaryEncoding
+}
+
+export interface BluetoothDataEvent {
+  connectionId: string
+  deviceId: string
+  service?: string
+  characteristic?: string
+  data: string
+  encoding: BluetoothBinaryEncoding
+  receivedAt: number
+}