@fishonfire/bubbles-expo 0.1.0

package/dist/index.mjs

@@ -0,0 +1,789 @@
+import {
+  ANDROID_CHANNEL_IMPORTANCE_VALUES,
+  BUBBLES_DELIVERY_STATUSES,
+  BUBBLES_NOTIFICATIONS_EXPO_EXTRA_KEY,
+  BubblesAppAuthenticationError,
+  buildBubblesDeliveryStatusPayload,
+  buildCreateDevicePayload,
+  buildStoredDeliveryStatusEventKey,
+  buildUpdateDevicePayload,
+  createBubblesDevice,
+  createBubblesDeviceClient,
+  createStoredDeliveryStatusEvent,
+  describeNotificationPermissionStatus,
+  enqueueStoredDeliveryStatusEvent,
+  ensureDefaultNotificationChannel,
+  ensureNotificationPermissions,
+  extractDeviceIdFromDeviceResponse,
+  failWithBubblesError,
+  flushStoredBubblesDeliveryStatuses,
+  getAndroidNotificationChannelImportance,
+  getBubblesNotificationDataFromNotification,
+  getBubblesNotificationPayloadFromRemoteMessage,
+  getBubblesNotificationsRuntimeConfig,
+  getDefaultNotificationChannelConfig,
+  getErrorMessage,
+  getNotificationPermissions,
+  getRequiredNonEmptyString,
+  getRequiredNonEmptyStringFromSource,
+  getSupportedPlatform,
+  hasFirebaseDisplayNotification,
+  isNotificationPermissionGranted,
+  markStoredDeliveryStatusEventPosted,
+  normalizeBubblesNotificationPayload,
+  patchStoredDeviceState,
+  postBubblesDeliveryStatus,
+  postStoredBubblesDeliveryStatus,
+  readStoredApiBaseUrl,
+  readStoredAppKey,
+  readStoredDeliveryStatusLedger,
+  readStoredDeviceId,
+  readStoredDeviceState,
+  registerBubblesBackgroundHandlers,
+  scheduleBubblesLocalNotification,
+  storeApiBaseUrl,
+  storeAppKey,
+  storeDeliveryStatusLedger,
+  storeDeviceId,
+  storeDeviceState,
+  syncBubblesDevice,
+  updateBubblesDevice
+} from "./chunk-6NPXFGQX.mjs";
+
+// src/runtime/tokens.ts
+import {
+  getMessaging,
+  getToken,
+  isDeviceRegisteredForRemoteMessages,
+  registerDeviceForRemoteMessages
+} from "@react-native-firebase/messaging";
+import { Platform } from "react-native";
+async function getFirebaseMessagingToken(platform) {
+  try {
+    const messagingInstance = getMessaging();
+    if (!isDeviceRegisteredForRemoteMessages(messagingInstance)) {
+      await registerDeviceForRemoteMessages(messagingInstance);
+    }
+    const token = await getToken(messagingInstance);
+    return getRequiredNonEmptyStringFromSource(
+      token,
+      `${platform} FCM token from Firebase Messaging`
+    );
+  } catch (error) {
+    const reason = getErrorMessage(error);
+    const platformSpecificSetupHint = platform === "ios" ? " On iOS, also ensure Firebase APNs setup is complete and `expo.ios.googleServicesFile` is configured." : " On Android, ensure `google-services.json` is configured and the native app has been rebuilt.";
+    failWithBubblesError(
+      `Failed to get a ${platform} FCM token from Firebase Messaging. Ensure "@react-native-firebase/app" and "@react-native-firebase/messaging" are installed, the Expo app includes the "@react-native-firebase/messaging" config plugin, and Firebase is configured for this platform.${platformSpecificSetupHint} Original error: ${reason}`
+    );
+  }
+}
+async function getDeviceRegistrationState(options) {
+  const platform = getSupportedPlatform(Platform.OS);
+  const permissions = await getNotificationPermissions(options);
+  const permissionStatus = describeNotificationPermissionStatus(permissions);
+  const notificationsEnabled = isNotificationPermissionGranted(permissions);
+  if (!notificationsEnabled) {
+    return {
+      platform,
+      tokenType: null,
+      token: null,
+      permissionStatus,
+      notificationsEnabled: false
+    };
+  }
+  const token = await getFirebaseMessagingToken(platform);
+  return {
+    platform,
+    tokenType: "fcm",
+    token,
+    permissionStatus,
+    notificationsEnabled: true
+  };
+}
+async function getDeviceToken(options) {
+  const registrationState = await getDeviceRegistrationState(options);
+  if (!registrationState.notificationsEnabled || !registrationState.token) {
+    failWithBubblesError("Push notification permission was not granted.");
+  }
+  return {
+    platform: registrationState.platform,
+    tokenType: "fcm",
+    token: registrationState.token
+  };
+}
+async function getFCMToken(options) {
+  const tokenResult = await getDeviceToken(options);
+  return tokenResult.token;
+}
+
+// src/runtime/BubblesNotificationsProvider.tsx
+import { useCallback as useCallback2, useEffect, useRef as useRef2, useState } from "react";
+
+// src/runtime/context.ts
+import { createContext } from "react";
+var BubblesNotificationsContext = createContext(null);
+
+// src/runtime/notification-handler.ts
+import * as Notifications from "expo-notifications";
+var DEFAULT_FOREGROUND_PRESENTATION = {
+  shouldShowBanner: true,
+  shouldShowList: true,
+  shouldPlaySound: false,
+  shouldSetBadge: false
+};
+function applyBubblesNotificationHandler(options) {
+  Notifications.setNotificationHandler({
+    handleNotification: async (notification) => {
+      const presentation = {
+        shouldShowBanner: options?.shouldShowBanner ?? DEFAULT_FOREGROUND_PRESENTATION.shouldShowBanner,
+        shouldShowList: options?.shouldShowList ?? DEFAULT_FOREGROUND_PRESENTATION.shouldShowList,
+        shouldPlaySound: options?.shouldPlaySound ?? DEFAULT_FOREGROUND_PRESENTATION.shouldPlaySound,
+        shouldSetBadge: options?.shouldSetBadge ?? DEFAULT_FOREGROUND_PRESENTATION.shouldSetBadge
+      };
+      return presentation;
+    }
+  });
+}
+function clearBubblesNotificationHandler() {
+  Notifications.setNotificationHandler(null);
+}
+
+// src/runtime/response-observer.ts
+import * as Notifications2 from "expo-notifications";
+function buildNotificationResponseKey(response) {
+  const payload = normalizeBubblesNotificationPayload(
+    getBubblesNotificationDataFromNotification(response.notification)
+  );
+  if (payload.notificationId) {
+    return `notification:${payload.notificationId}:action:${response.actionIdentifier}`;
+  }
+  return `request:${response.notification.request.identifier}:action:${response.actionIdentifier}`;
+}
+function logNotificationResponseError(description, error) {
+  console.error(
+    `[@fishonfire/bubbles-expo] Failed during notification response ${description}.`,
+    error
+  );
+}
+function buildObservedNotificationResponse(response, storedDeviceState) {
+  const payload = normalizeBubblesNotificationPayload(
+    getBubblesNotificationDataFromNotification(response.notification)
+  );
+  return {
+    notificationId: payload.notificationId,
+    event: {
+      notification: response.notification,
+      url: payload.url,
+      notificationId: payload.notificationId,
+      deviceId: storedDeviceState.deviceId,
+      data: payload.data
+    }
+  };
+}
+function postNotificationClickedDeliveryStatus(storedDeviceState, notificationId, actionId) {
+  void postStoredBubblesDeliveryStatus({
+    source: "notification response",
+    storedDeviceState,
+    notificationId,
+    status: BUBBLES_DELIVERY_STATUSES.notificationClicked,
+    actionId
+  }).catch((error) => {
+    logNotificationResponseError("delivery-status update", error);
+  });
+}
+function handleNotificationResponse(response, options, source) {
+  const storedDeviceState = readStoredDeviceState();
+  const observedResponse = buildObservedNotificationResponse(
+    response,
+    storedDeviceState
+  );
+  postNotificationClickedDeliveryStatus(
+    storedDeviceState,
+    observedResponse.notificationId,
+    response.actionIdentifier
+  );
+  options.onNotificationResponse?.(observedResponse.event);
+}
+function processStartupNotificationResponse(processNotificationResponse) {
+  try {
+    const lastResponse = Notifications2.getLastNotificationResponse();
+    if (!lastResponse) {
+      return;
+    }
+    processNotificationResponse(lastResponse);
+    Notifications2.clearLastNotificationResponse();
+  } catch (error) {
+    logNotificationResponseError("initial response handling", error);
+  }
+}
+function observeBubblesNotificationResponses(options) {
+  let lastHandledResponseKey = null;
+  const processNotificationResponse = (response) => {
+    const responseKey = buildNotificationResponseKey(response);
+    if (lastHandledResponseKey === responseKey) {
+      return;
+    }
+    lastHandledResponseKey = responseKey;
+    handleNotificationResponse(response, options, "listener");
+  };
+  processStartupNotificationResponse((response) => {
+    const responseKey = buildNotificationResponseKey(response);
+    lastHandledResponseKey = responseKey;
+    handleNotificationResponse(response, options, "startup");
+  });
+  const subscription = Notifications2.addNotificationResponseReceivedListener(
+    processNotificationResponse
+  );
+  return () => {
+    subscription.remove();
+  };
+}
+
+// src/runtime/presentation.ts
+function applyBubblesForegroundPresentation(options) {
+  applyBubblesNotificationHandler(options);
+}
+function clearBubblesForegroundPresentation() {
+  clearBubblesNotificationHandler();
+}
+function observeBubblesNotificationOpenEvents(options) {
+  return observeBubblesNotificationResponses(options);
+}
+async function prepareBubblesNotificationPresentation(options) {
+  return ensureDefaultNotificationChannel(options);
+}
+
+// src/runtime/foreground-message-observer.ts
+import {
+  getMessaging as getMessaging2,
+  onMessage
+} from "@react-native-firebase/messaging";
+import { Platform as Platform2 } from "react-native";
+function supportsFirebaseForegroundMessages() {
+  return Platform2.OS === "android" || Platform2.OS === "ios";
+}
+async function handleFirebaseForegroundMessage(remoteMessage) {
+  const payload = getBubblesNotificationPayloadFromRemoteMessage(remoteMessage);
+  if (!hasFirebaseDisplayNotification(remoteMessage)) {
+    return;
+  }
+  await scheduleBubblesLocalNotification({
+    source: "Firebase foreground message",
+    payload
+  });
+}
+function observeBubblesForegroundMessages() {
+  if (!supportsFirebaseForegroundMessages()) {
+    return () => {
+    };
+  }
+  const unsubscribe = onMessage(
+    getMessaging2(),
+    (remoteMessage) => {
+      void handleFirebaseForegroundMessage(remoteMessage).catch(
+        (error) => {
+          console.error(
+            "[@fishonfire/bubbles-expo] Failed while handling a Firebase foreground message.",
+            error
+          );
+        }
+      );
+    }
+  );
+  return () => {
+    unsubscribe();
+  };
+}
+
+// src/runtime/installations.ts
+import { getId, getInstallations } from "@react-native-firebase/installations";
+async function getFirebaseInstallationId(platform) {
+  try {
+    const installationsInstance = getInstallations();
+    const installationId = await getId(installationsInstance);
+    return getRequiredNonEmptyStringFromSource(
+      installationId,
+      `${platform} Firebase installation id from Firebase Installations`
+    );
+  } catch (error) {
+    const reason = getErrorMessage(error);
+    const platformSpecificSetupHint = platform === "ios" ? " On iOS, ensure `expo.ios.googleServicesFile` is configured and the native app has been rebuilt." : " On Android, ensure `expo.android.googleServicesFile` is configured and the native app has been rebuilt.";
+    failWithBubblesError(
+      `Failed to get a ${platform} Firebase installation id from Firebase Installations. Ensure "@react-native-firebase/app" and "@react-native-firebase/installations" are installed and Firebase is configured for this platform.${platformSpecificSetupHint} Original error: ${reason}`
+    );
+  }
+}
+
+// src/runtime/transport.ts
+function observeBubblesForegroundRemoteMessages() {
+  return observeBubblesForegroundMessages();
+}
+async function getBubblesDeviceRegistrationState(options) {
+  return getDeviceRegistrationState(options);
+}
+async function getBubblesInstallationId(platform) {
+  return getFirebaseInstallationId(platform);
+}
+
+// src/runtime/sync-device.ts
+var BubblesNotificationsSyncError = class extends Error {
+  constructor(message, snapshot, cause) {
+    super(message);
+    this.name = "BubblesNotificationsSyncError";
+    this.snapshot = snapshot;
+    this.cause = cause;
+  }
+};
+function fail(message) {
+  throw new Error(`[@fishonfire/bubbles-expo] ${message}`);
+}
+function toError(error) {
+  if (error instanceof Error) {
+    return error;
+  }
+  return new Error(String(error));
+}
+function getRequiredNonEmptyString2(value, fieldName) {
+  if (typeof value !== "string") {
+    fail(`"${fieldName}" must be a string.`);
+  }
+  const trimmedValue = value.trim();
+  if (!trimmedValue) {
+    fail(`"${fieldName}" must not be empty.`);
+  }
+  return trimmedValue;
+}
+function buildRuntimeSnapshot(deviceId, registrationState) {
+  return {
+    deviceId,
+    pushToken: registrationState.token,
+    tokenType: registrationState.tokenType,
+    permissionStatus: registrationState.permissionStatus,
+    notificationsEnabled: registrationState.notificationsEnabled
+  };
+}
+async function syncDeviceRegistrationState(options) {
+  const apiBaseUrl = getRequiredNonEmptyString2(options.apiBaseUrl, "apiBaseUrl");
+  const appKey = getRequiredNonEmptyString2(options.appKey, "appKey");
+  storeApiBaseUrl(apiBaseUrl);
+  storeAppKey(appKey);
+  const snapshot = buildRuntimeSnapshot(
+    options.deviceId,
+    options.registrationState
+  );
+  try {
+    const installationId = options.registrationState.notificationsEnabled ? await getBubblesInstallationId(options.registrationState.platform) : null;
+    const syncResult = await syncBubblesDevice({
+      apiBaseUrl,
+      appId: options.appId,
+      appKey,
+      userId: options.userId,
+      aliasing: options.aliasing,
+      appVersion: options.appVersion,
+      deviceId: options.deviceId,
+      platform: options.registrationState.platform,
+      pushToken: options.registrationState.token,
+      fid: installationId,
+      notificationsEnabled: options.registrationState.notificationsEnabled
+    });
+    const nextDeviceId = syncResult.deviceId ?? options.deviceId;
+    storeDeviceId(nextDeviceId);
+    return {
+      ...snapshot,
+      action: syncResult.action,
+      deviceId: nextDeviceId
+    };
+  } catch (error) {
+    const normalizedError = toError(error);
+    throw new BubblesNotificationsSyncError(
+      normalizedError.message,
+      snapshot,
+      error
+    );
+  }
+}
+async function syncExistingBubblesDevice(options) {
+  const registrationState = await getBubblesDeviceRegistrationState({
+    requestPermissions: false
+  });
+  return syncDeviceRegistrationState({
+    ...options,
+    deviceId: options.deviceId,
+    registrationState
+  });
+}
+
+// src/runtime/register-device.ts
+var DEFAULT_PERMISSION_REQUEST_OPTIONS = {
+  ios: {
+    allowAlert: true,
+    allowBadge: true,
+    allowSound: true
+  }
+};
+function buildRegistrationOptions(options) {
+  if (options?.requestPermissions === false) {
+    return {
+      requestPermissions: false,
+      permissionRequestOptions: options.permissionRequestOptions
+    };
+  }
+  return {
+    requestPermissions: options?.requestPermissions,
+    permissionRequestOptions: options?.permissionRequestOptions ?? DEFAULT_PERMISSION_REQUEST_OPTIONS
+  };
+}
+async function registerBubblesDevice(options) {
+  const registrationState = await getBubblesDeviceRegistrationState(
+    buildRegistrationOptions(options.registrationOptions)
+  );
+  return syncDeviceRegistrationState({
+    ...options,
+    deviceId: options.deviceId,
+    registrationState
+  });
+}
+
+// src/runtime/provider-operation-queue.ts
+import {
+  useCallback,
+  useRef
+} from "react";
+
+// src/runtime/provider-state.ts
+function createInitialRuntimeState(deviceId, error) {
+  return {
+    deviceId,
+    pushToken: null,
+    tokenType: null,
+    permissionStatus: "unknown",
+    notificationsEnabled: false,
+    isSyncing: false,
+    error
+  };
+}
+function normalizeProviderError(error) {
+  if (error instanceof Error) {
+    return error;
+  }
+  return new Error(String(error));
+}
+function normalizeUserId(value) {
+  if (value === null) {
+    return null;
+  }
+  const trimmedValue = value.trim();
+  return trimmedValue.length > 0 ? trimmedValue : null;
+}
+function getAutomaticSyncSignature(input) {
+  return JSON.stringify({
+    appId: input.appId,
+    appKey: input.appKey,
+    apiBaseUrl: input.apiBaseUrl,
+    userId: input.userId,
+    aliasing: input.aliasing ?? [],
+    appVersion: input.appVersion ?? null,
+    deviceId: input.deviceId
+  });
+}
+function getRuntimeStateUpdate(snapshot) {
+  return {
+    deviceId: snapshot.deviceId,
+    pushToken: snapshot.pushToken,
+    tokenType: snapshot.tokenType,
+    permissionStatus: snapshot.permissionStatus,
+    notificationsEnabled: snapshot.notificationsEnabled
+  };
+}
+function getInitialRuntimeState() {
+  try {
+    return createInitialRuntimeState(readStoredDeviceId(), null);
+  } catch (error) {
+    return createInitialRuntimeState(
+      null,
+      normalizeProviderError(error)
+    );
+  }
+}
+
+// src/runtime/provider-operation-queue.ts
+function useBubblesRuntimeOperationQueue(setState) {
+  const isMountedRef = useRef(true);
+  const pendingOperationsRef = useRef(0);
+  const operationQueueRef = useRef(Promise.resolve());
+  const enqueueOperation = useCallback((operation) => {
+    pendingOperationsRef.current += 1;
+    setState((currentState) => ({
+      ...currentState,
+      isSyncing: true,
+      error: null
+    }));
+    const queuedOperation = operationQueueRef.current.catch(() => void 0).then(operation);
+    operationQueueRef.current = queuedOperation.then(
+      () => void 0,
+      () => void 0
+    );
+    return queuedOperation.then(
+      (result) => {
+        pendingOperationsRef.current -= 1;
+        if (!isMountedRef.current) {
+          return;
+        }
+        setState((currentState) => ({
+          ...currentState,
+          ...result ?? {},
+          isSyncing: pendingOperationsRef.current > 0,
+          error: null
+        }));
+      },
+      (error) => {
+        pendingOperationsRef.current -= 1;
+        const normalizedError = normalizeProviderError(error);
+        const snapshot = error instanceof BubblesNotificationsSyncError ? error.snapshot : void 0;
+        if (isMountedRef.current) {
+          setState((currentState) => ({
+            ...currentState,
+            ...snapshot ? getRuntimeStateUpdate(snapshot) : {},
+            isSyncing: pendingOperationsRef.current > 0,
+            error: normalizedError
+          }));
+        }
+        throw normalizedError;
+      }
+    );
+  }, [setState]);
+  return {
+    enqueueOperation,
+    isMountedRef
+  };
+}
+
+// src/runtime/BubblesNotificationsProvider.tsx
+import { jsx } from "react/jsx-runtime";
+function BubblesNotificationsProvider(props) {
+  const {
+    appId,
+    appKey,
+    apiBaseUrl,
+    ready,
+    userId,
+    aliasing,
+    appVersion,
+    onLogout,
+    foregroundPresentation,
+    onNotificationResponse,
+    children
+  } = props;
+  const normalizedUserId = normalizeUserId(userId);
+  const [state, setState] = useState(getInitialRuntimeState);
+  const { enqueueOperation, isMountedRef } = useBubblesRuntimeOperationQueue(setState);
+  const lastAutomaticSyncSignatureRef = useRef2(null);
+  const previousUserIdRef = useRef2(normalizedUserId);
+  const buildAutomaticSyncSignature = useCallback2((deviceId) => {
+    return getAutomaticSyncSignature({
+      appId,
+      appKey,
+      apiBaseUrl,
+      userId: normalizedUserId,
+      aliasing,
+      appVersion,
+      deviceId
+    });
+  }, [
+    appId,
+    appKey,
+    apiBaseUrl,
+    normalizedUserId,
+    aliasing,
+    appVersion
+  ]);
+  useEffect(() => {
+    return () => {
+      isMountedRef.current = false;
+      clearBubblesForegroundPresentation();
+    };
+  }, [isMountedRef]);
+  useEffect(() => {
+    let isCancelled = false;
+    void (async () => {
+      try {
+        storeApiBaseUrl(getRequiredNonEmptyString(apiBaseUrl, "apiBaseUrl"));
+        storeAppKey(getRequiredNonEmptyString(appKey, "appKey"));
+        await prepareBubblesNotificationPresentation();
+      } catch (error) {
+        if (!isCancelled && isMountedRef.current) {
+          setState((currentState) => ({
+            ...currentState,
+            error: normalizeProviderError(error)
+          }));
+        }
+      }
+    })();
+    return () => {
+      isCancelled = true;
+    };
+  }, [apiBaseUrl, appKey, isMountedRef]);
+  useEffect(() => {
+    applyBubblesForegroundPresentation(foregroundPresentation);
+  }, [foregroundPresentation]);
+  useEffect(() => {
+    return observeBubblesForegroundRemoteMessages();
+  }, []);
+  useEffect(() => {
+    return observeBubblesNotificationOpenEvents({
+      onNotificationResponse
+    });
+  }, [onNotificationResponse]);
+  useEffect(() => {
+    const previousUserId = previousUserIdRef.current;
+    if (previousUserId !== null && normalizedUserId === null) {
+      lastAutomaticSyncSignatureRef.current = null;
+      if (onLogout) {
+        void enqueueOperation(async () => {
+          await onLogout({
+            previousUserId,
+            deviceId: state.deviceId
+          });
+        });
+      }
+    }
+    previousUserIdRef.current = normalizedUserId;
+  }, [enqueueOperation, normalizedUserId, onLogout, state.deviceId]);
+  useEffect(() => {
+    if (!ready || normalizedUserId === null || state.deviceId === null) {
+      lastAutomaticSyncSignatureRef.current = null;
+      return;
+    }
+    const syncSignature = buildAutomaticSyncSignature(state.deviceId);
+    if (lastAutomaticSyncSignatureRef.current === syncSignature) {
+      return;
+    }
+    lastAutomaticSyncSignatureRef.current = syncSignature;
+    const storedDeviceId = state.deviceId;
+    void enqueueOperation(async () => {
+      const result = await syncExistingBubblesDevice({
+        appId,
+        appKey,
+        apiBaseUrl,
+        userId: normalizedUserId,
+        aliasing,
+        appVersion,
+        deviceId: storedDeviceId
+      });
+      return getRuntimeStateUpdate(result);
+    });
+  }, [
+    ready,
+    normalizedUserId,
+    state.deviceId,
+    appId,
+    appKey,
+    apiBaseUrl,
+    aliasing,
+    appVersion,
+    buildAutomaticSyncSignature,
+    enqueueOperation
+  ]);
+  function registerDevice(options) {
+    return enqueueOperation(async () => {
+      if (!ready) {
+        failWithBubblesError(
+          '"registerDevice()" requires "ready" to be true before the device can be synced.'
+        );
+      }
+      if (normalizedUserId === null) {
+        failWithBubblesError(
+          '"registerDevice()" requires a non-null "userId" before the device can be synced.'
+        );
+      }
+      const result = await registerBubblesDevice({
+        appId,
+        appKey,
+        apiBaseUrl,
+        userId: normalizedUserId,
+        aliasing,
+        appVersion,
+        deviceId: state.deviceId,
+        registrationOptions: options
+      });
+      if (result.deviceId !== null) {
+        lastAutomaticSyncSignatureRef.current = buildAutomaticSyncSignature(
+          result.deviceId
+        );
+      }
+      return getRuntimeStateUpdate(result);
+    });
+  }
+  const contextValue = {
+    registerDevice,
+    deviceId: state.deviceId,
+    pushToken: state.pushToken,
+    tokenType: state.tokenType,
+    permissionStatus: state.permissionStatus,
+    notificationsEnabled: state.notificationsEnabled,
+    isSyncing: state.isSyncing,
+    error: state.error
+  };
+  return /* @__PURE__ */ jsx(BubblesNotificationsContext.Provider, { value: contextValue, children });
+}
+
+// src/runtime/useBubblesNotifications.ts
+import { useContext } from "react";
+function fail2(message) {
+  throw new Error(`[@fishonfire/bubbles-expo] ${message}`);
+}
+function useBubblesNotifications() {
+  const context = useContext(BubblesNotificationsContext);
+  if (context === null) {
+    fail2(
+      '"useBubblesNotifications()" must be used inside "BubblesNotificationsProvider".'
+    );
+  }
+  return context;
+}
+export {
+  ANDROID_CHANNEL_IMPORTANCE_VALUES,
+  BUBBLES_DELIVERY_STATUSES,
+  BUBBLES_NOTIFICATIONS_EXPO_EXTRA_KEY,
+  BubblesAppAuthenticationError,
+  BubblesNotificationsProvider,
+  buildBubblesDeliveryStatusPayload,
+  buildCreateDevicePayload,
+  buildStoredDeliveryStatusEventKey,
+  buildUpdateDevicePayload,
+  createBubblesDevice,
+  createBubblesDeviceClient,
+  createStoredDeliveryStatusEvent,
+  describeNotificationPermissionStatus,
+  enqueueStoredDeliveryStatusEvent,
+  ensureDefaultNotificationChannel,
+  ensureNotificationPermissions,
+  extractDeviceIdFromDeviceResponse,
+  flushStoredBubblesDeliveryStatuses,
+  getAndroidNotificationChannelImportance,
+  getBubblesNotificationsRuntimeConfig,
+  getDefaultNotificationChannelConfig,
+  getDeviceRegistrationState,
+  getDeviceToken,
+  getFCMToken,
+  getNotificationPermissions,
+  isNotificationPermissionGranted,
+  markStoredDeliveryStatusEventPosted,
+  patchStoredDeviceState,
+  postBubblesDeliveryStatus,
+  postStoredBubblesDeliveryStatus,
+  readStoredApiBaseUrl,
+  readStoredAppKey,
+  readStoredDeliveryStatusLedger,
+  readStoredDeviceId,
+  readStoredDeviceState,
+  registerBubblesBackgroundHandlers,
+  storeApiBaseUrl,
+  storeAppKey,
+  storeDeliveryStatusLedger,
+  storeDeviceId,
+  storeDeviceState,
+  syncBubblesDevice,
+  updateBubblesDevice,
+  useBubblesNotifications
+};