@pmate/bridge 0.1.4 → 0.1.6

package/package.json

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

package/src/PmateBridgeProvider.tsx

@@ -2,6 +2,8 @@ import { PropsWithChildren, ReactNode, useEffect, useMemo, useState } from "reac
 import { PmateBridgeContext } from "./context"
 import {
   getFallbackSafeInsets,
+  getNotificationStatus,
+  getPushToken,
   pickFileBridge,
   readDeviceInfo,
   readIsPmate,
@@ -84,6 +86,8 @@ export function PmateBridgeProvider({
       safeInsetsState,
       deviceInfoState,
       requestPermissions: requestPermissionsBridge,
+      getNotificationStatus,
+      getPushToken,
       pickFile: pickFileBridge,
     }),
     [deviceInfoState, isPmate, safeInsetsState]

package/src/context.tsx

@@ -1,8 +1,11 @@
 import { createContext, useContext } from "react"
 import type {
   DeviceInfoState,
+  NotificationStatus,
   PermissionResult,
   PickedFile,
+  PushTokenInfo,
+  PushTokenOptions,
   SafeInsetsState,
 } from "./types"
 
@@ -11,6 +14,8 @@ export interface PmateBridgeContextValue {
   safeInsetsState: SafeInsetsState
   deviceInfoState: DeviceInfoState
   requestPermissions: (permissions: string[]) => Promise<PermissionResult>
+  getNotificationStatus: () => Promise<NotificationStatus>
+  getPushToken: (options?: PushTokenOptions) => Promise<PushTokenInfo | undefined>
   pickFile: () => Promise<PickedFile[]>
 }
 

package/src/hooks.ts

@@ -2,13 +2,15 @@ import { useCallback, useEffect, useState } from "react"
 import { useOptionalPmateBridgeContext } from "./context"
 import {
   getFallbackSafeInsets,
+  getNotificationStatus,
+  getPushToken,
   pickFileBridge,
   readDeviceInfo,
   readIsPmate,
   readSafeInsets,
   requestPermissionsBridge,
 } from "./internal"
-import type { DeviceInfoState, SafeInsetsState } from "./types"
+import type { DeviceInfoState, PushTokenOptions, SafeInsetsState } from "./types"
 
 export function useIsPmate() {
   return useOptionalPmateBridgeContext()?.isPmate ?? readIsPmate()
@@ -93,3 +95,19 @@ export function useRequestPermissions() {
     [context]
   )
 }
+
+export function useNotificationStatus() {
+  const context = useOptionalPmateBridgeContext()
+  return useCallback(
+    () => context?.getNotificationStatus() ?? getNotificationStatus(),
+    [context]
+  )
+}
+
+export function useGetPushToken() {
+  const context = useOptionalPmateBridgeContext()
+  return useCallback(
+    (options?: PushTokenOptions) => context?.getPushToken(options) ?? getPushToken(options),
+    [context]
+  )
+}

package/src/index.ts

@@ -2,13 +2,22 @@ export * from "./PmateBridgeProvider"
 export * from "./SafeAreaVarsProvider"
 export * from "./hooks"
 export {
+  cancelAlarm,
+  cancelAllAlarms,
   connectBluetoothDevice,
   disconnectBluetoothDevice,
+  getAlarm,
+  getAlarmCapabilities,
   getBluetoothCapabilities,
   getConnectedBluetoothDevices,
+  getNotificationStatus,
+  getPushToken,
+  listAlarms,
+  onAlarmEvent,
   onBluetoothEvent,
   readBluetooth,
   requestBluetoothPermission,
+  scheduleAlarm,
   scanBluetoothDevices,
   stopBluetoothScan,
   subscribeBluetooth,

package/src/internal.ts

@@ -1,4 +1,7 @@
 import type {
+  Alarm,
+  AlarmCapabilities,
+  AlarmEventName,
   BluetoothCapabilities,
   BluetoothConnectOptions,
   BluetoothConnection,
@@ -12,9 +15,13 @@ import type {
   BluetoothSubscribeOptions,
   BluetoothWriteOptions,
   DeviceInfo,
+  NotificationStatus,
   PermissionResult,
   PickedFile,
+  PushTokenInfo,
+  PushTokenOptions,
   SafeInsets,
+  ScheduleAlarmInput,
 } from "./types"
 
 type PmateWindow = Window & {
@@ -90,15 +97,80 @@ export async function requestPermissionsBridge(
     result ?? {
       requested: permissions,
       granted: false,
+      state: "unsupported",
     }
   )
 }
 
+export async function getNotificationStatus(): Promise<NotificationStatus> {
+  const status = await callBridge<NotificationStatus>("notification.getStatus")
+  return (
+    status ?? {
+      supported: false,
+      permission: "unsupported",
+      providers: [],
+    }
+  )
+}
+
+export async function getPushToken(
+  options?: PushTokenOptions
+): Promise<PushTokenInfo | undefined> {
+  if (!hasWindow() || !(window as PmateWindow).PmateBridge?.call) {
+    return undefined
+  }
+  return requireBridge<PushTokenInfo>("notification.getPushToken", options ?? null)
+}
+
 export async function pickFileBridge(): Promise<PickedFile[]> {
   const files = await callBridge<PickedFile[]>("pickFile")
   return files ?? []
 }
 
+export async function getAlarmCapabilities(): Promise<AlarmCapabilities> {
+  const capabilities = await callBridge<AlarmCapabilities>("alarm.getCapabilities")
+  return (
+    capabilities ?? {
+      supported: false,
+      systemAlarm: false,
+      appAlarm: false,
+      exact: false,
+      repeating: false,
+      notificationPermission: "unsupported",
+    }
+  )
+}
+
+export function scheduleAlarm(input: ScheduleAlarmInput): Promise<Alarm> {
+  return requireBridge<Alarm>("alarm.schedule", input)
+}
+
+export async function getAlarm(id: string): Promise<Alarm | undefined> {
+  return callBridge<Alarm>("alarm.get", { id })
+}
+
+export function listAlarms(): Promise<{ alarms: Alarm[] }> {
+  return requireBridge<{ alarms: Alarm[] }>("alarm.list")
+}
+
+export function cancelAlarm(id: string): Promise<{ cancelled: true }> {
+  return requireBridge<{ cancelled: true }>("alarm.cancel", { id })
+}
+
+export function cancelAllAlarms(): Promise<{ cancelled: true }> {
+  return requireBridge<{ cancelled: true }>("alarm.cancelAll")
+}
+
+export function onAlarmEvent(
+  eventName: AlarmEventName,
+  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!(`alarm.${eventName}`, handler)
+}
+
 export function getBluetoothCapabilities(): Promise<BluetoothCapabilities> {
   return requireBridge<BluetoothCapabilities>("bluetooth.getCapabilities")
 }

package/src/types.ts

@@ -32,6 +32,86 @@ export interface PickedFile {
 export interface PermissionResult {
   requested: unknown
   granted: boolean
+  state?: PermissionState
+}
+
+export type PermissionState = "granted" | "denied" | "notDetermined" | "unsupported"
+export type NotificationPermissionState = PermissionState
+export type PushProvider = "apns" | "xiaomi"
+
+export interface NotificationStatus {
+  supported: boolean
+  permission: NotificationPermissionState
+  providers: PushProvider[]
+}
+
+export interface PushTokenInfo {
+  platform: "ios" | "android"
+  provider: PushProvider
+  token: string
+  environment?: "sandbox" | "production"
+  region?: string
+  bundleId?: string
+  packageName?: string
+  permission: NotificationPermissionState
+  vendor?: Record<string, unknown>
+}
+
+export interface PushTokenOptions {
+  providers?: PushProvider[]
+}
+
+export type AlarmDeliveryMode = "systemAlarm" | "appAlarm"
+export type AlarmDeliveryPreference =
+  | "preferSystemAlarm"
+  | "preferAppAlarm"
+  | "systemAlarmOnly"
+export type AlarmPermissionState =
+  | "granted"
+  | "denied"
+  | "notDetermined"
+  | "unsupported"
+export type AlarmRepeatRule =
+  | { type: "none" }
+  | { type: "interval"; intervalMs: number }
+  | { type: "daily"; timeOfDay: string; timezone?: string }
+export type AlarmState = "scheduled" | "triggered" | "cancelled"
+export type AlarmEventName = "triggered" | "cancelled" | "error"
+
+export interface AlarmCapabilities {
+  supported: boolean
+  systemAlarm: boolean
+  appAlarm: boolean
+  exact: boolean
+  repeating: boolean
+  notificationPermission: AlarmPermissionState
+  minimumIntervalMs?: number
+  maximumScheduledCount?: number
+}
+
+export interface Alarm {
+  id: string
+  title?: string
+  body?: string
+  deliveryMode: AlarmDeliveryMode
+  scheduledAt: number
+  repeat: AlarmRepeatRule
+  payload?: Record<string, unknown>
+  state: AlarmState
+  createdAt: number
+  updatedAt: number
+  lastTriggeredAt?: number
+  nextTriggerAt?: number
+}
+
+export interface ScheduleAlarmInput {
+  id?: string
+  title?: string
+  body?: string
+  scheduledAt: number
+  repeat?: AlarmRepeatRule
+  deliveryPreference?: AlarmDeliveryPreference
+  payload?: Record<string, unknown>
 }
 
 export type BluetoothTransport = "ble" | "classic"