@fishonfire/bubbles-expo 0.1.0

package/dist/register-task.js

@@ -0,0 +1,818 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/register-task.ts
+var register_task_exports = {};
+module.exports = __toCommonJS(register_task_exports);
+
+// src/background/firebase-message-handler.ts
+var import_messaging = require("@react-native-firebase/messaging");
+var Notifications3 = __toESM(require("expo-notifications"));
+var import_react_native2 = require("react-native");
+
+// src/api/device-client.ts
+var import_bubbles_js = require("@fishonfire/bubbles-js");
+
+// src/internal/errors.ts
+function createBubblesError(message) {
+  return new Error(`[@fishonfire/bubbles-expo] ${message}`);
+}
+function failWithBubblesError(message) {
+  throw createBubblesError(message);
+}
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/internal/validation.ts
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function getRequiredNonEmptyString(value, fieldName) {
+  if (typeof value !== "string") {
+    failWithBubblesError(`"${fieldName}" must be a string.`);
+  }
+  const trimmedValue = value.trim();
+  if (!trimmedValue) {
+    failWithBubblesError(`"${fieldName}" must not be empty.`);
+  }
+  return trimmedValue;
+}
+function normalizeIdentifier(value, fieldName) {
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      failWithBubblesError(
+        `"${fieldName}" must be a finite number when it is numeric.`
+      );
+    }
+    return String(value);
+  }
+  if (typeof value !== "string") {
+    failWithBubblesError(`"${fieldName}" must be a string or number.`);
+  }
+  const trimmedValue = value.trim();
+  if (!trimmedValue) {
+    failWithBubblesError(`"${fieldName}" must not be empty.`);
+  }
+  return trimmedValue;
+}
+
+// src/api/device-client.ts
+var APP_KEY_HEADER_NAME = "X-App-Key";
+var BubblesAppAuthenticationError = class extends Error {
+  constructor(cause) {
+    super("Bubbles app configuration/authentication failed: invalid app key for app.");
+    this.name = "BubblesAppAuthenticationError";
+    this.cause = cause;
+  }
+};
+function createBubblesDeviceClient(options) {
+  const { appKey: rawAppKey, ...clientOptions } = options;
+  const appKey = rawAppKey ? getRequiredNonEmptyString(rawAppKey, "appKey") : null;
+  return new import_bubbles_js.DeviceClient({
+    ...clientOptions,
+    baseUrl: getRequiredNonEmptyString(clientOptions.baseUrl, "apiBaseUrl"),
+    defaultHeaders: {
+      ...clientOptions.defaultHeaders,
+      ...appKey ? { [APP_KEY_HEADER_NAME]: appKey } : {}
+    }
+  });
+}
+
+// src/api/delivery-status.ts
+var BUBBLES_DELIVERY_STATUSES = {
+  notificationReceived: "received",
+  notificationShown: "shown",
+  notificationClicked: "clicked",
+  notificationsDisabled: "disabled"
+};
+function normalizeError(value) {
+  if (value == null) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    failWithBubblesError('"error" must be a string when present.');
+  }
+  const trimmedValue = value.trim();
+  if (!trimmedValue) {
+    failWithBubblesError('"error" must not be empty when present.');
+  }
+  return trimmedValue;
+}
+function normalizeStatus(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const supportedValues = Object.values(BUBBLES_DELIVERY_STATUSES);
+  if (typeof value !== "string" || !supportedValues.includes(value)) {
+    failWithBubblesError(
+      `"status" must be one of: ${supportedValues.join(", ")}.`
+    );
+  }
+  return value;
+}
+function resolveDeviceClient(options) {
+  if (options.client) {
+    return options.client;
+  }
+  return createBubblesDeviceClient({
+    ...options.clientOptions,
+    appKey: getRequiredNonEmptyString(options.appKey, "appKey"),
+    baseUrl: getRequiredNonEmptyString(options.apiBaseUrl, "apiBaseUrl")
+  });
+}
+function withAppKeyHeader(appKey, requestOptions) {
+  return {
+    ...requestOptions,
+    headers: {
+      ...requestOptions?.headers,
+      "X-App-Key": getRequiredNonEmptyString(appKey, "appKey")
+    }
+  };
+}
+function isInvalidAppKeyResponse(error) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const status = Reflect.get(error, "status");
+  const body = Reflect.get(error, "body");
+  return status === 401 && !!body && typeof body === "object" && !Array.isArray(body) && Reflect.get(body, "error") === "invalid app key for app";
+}
+function buildBubblesDeliveryStatusPayload(options) {
+  const status = normalizeStatus(options.status);
+  const error = normalizeError(options.error);
+  if (!status && !error) {
+    failWithBubblesError(
+      'A delivery status payload must include "status" and/or "error".'
+    );
+  }
+  return {
+    ...status ? { status } : {},
+    ...error ? { error } : {}
+  };
+}
+async function postBubblesDeliveryStatus(options) {
+  const client = resolveDeviceClient(options);
+  try {
+    await client.postDeliveryStatus(
+      normalizeIdentifier(options.deviceId, "deviceId"),
+      normalizeIdentifier(options.notificationId, "notificationId"),
+      buildBubblesDeliveryStatusPayload(options),
+      withAppKeyHeader(options.appKey, options.requestOptions)
+    );
+  } catch (error) {
+    if (isInvalidAppKeyResponse(error)) {
+      throw new BubblesAppAuthenticationError(error);
+    }
+    throw error;
+  }
+}
+
+// src/storage/device-state.ts
+var import_expo_file_system = require("expo-file-system");
+var STORED_DEVICE_STATE_FILE_NAME = "bubbles-notifications-expo-state.json";
+var LEGACY_DEVICE_ID_FILE_NAME = "device-id.txt";
+var STORED_DEVICE_STATE_VERSION = 1;
+function getOptionalNonEmptyString(value, fieldName) {
+  if (value == null) {
+    return null;
+  }
+  if (typeof value !== "string") {
+    failWithBubblesError(`Stored "${fieldName}" must be a string when present.`);
+  }
+  const trimmedValue = value.trim();
+  return trimmedValue.length > 0 ? trimmedValue : null;
+}
+function getStoredDeviceStateFile() {
+  return new import_expo_file_system.File(import_expo_file_system.Paths.document, STORED_DEVICE_STATE_FILE_NAME);
+}
+function getLegacyDeviceIdFile() {
+  return new import_expo_file_system.File(import_expo_file_system.Paths.document, LEGACY_DEVICE_ID_FILE_NAME);
+}
+function readLegacyStoredDeviceId() {
+  const legacyDeviceIdFile = getLegacyDeviceIdFile();
+  if (!legacyDeviceIdFile.exists) {
+    return null;
+  }
+  const storedDeviceId = legacyDeviceIdFile.textSync().trim();
+  return storedDeviceId.length > 0 ? storedDeviceId : null;
+}
+function normalizeStoredDeviceState(value, sourceDescription) {
+  if (!isPlainObject(value)) {
+    failWithBubblesError(
+      `Stored device state in ${sourceDescription} must be a JSON object.`
+    );
+  }
+  if (value.version !== STORED_DEVICE_STATE_VERSION) {
+    failWithBubblesError(
+      `Stored device state in ${sourceDescription} uses unsupported schema version "${String(
+        value.version
+      )}".`
+    );
+  }
+  return {
+    deviceId: getOptionalNonEmptyString(value.deviceId, "deviceId"),
+    apiBaseUrl: getOptionalNonEmptyString(value.apiBaseUrl, "apiBaseUrl"),
+    appKey: getOptionalNonEmptyString(value.appKey, "appKey")
+  };
+}
+function readStoredDeviceStateFileText() {
+  const storedDeviceStateFile = getStoredDeviceStateFile();
+  if (!storedDeviceStateFile.exists) {
+    return null;
+  }
+  const contents = storedDeviceStateFile.textSync().trim();
+  return contents.length > 0 ? contents : null;
+}
+function withLegacyDeviceIdFallback(state) {
+  if (state.deviceId) {
+    return state;
+  }
+  const legacyDeviceId = readLegacyStoredDeviceId();
+  if (!legacyDeviceId) {
+    return state;
+  }
+  return {
+    ...state,
+    deviceId: legacyDeviceId
+  };
+}
+function readStoredDeviceState() {
+  const storedDeviceStateFile = getStoredDeviceStateFile();
+  const rawState = readStoredDeviceStateFileText();
+  if (rawState === null) {
+    return withLegacyDeviceIdFallback({
+      deviceId: null,
+      apiBaseUrl: null,
+      appKey: null
+    });
+  }
+  let parsedState;
+  try {
+    parsedState = JSON.parse(rawState);
+  } catch {
+    failWithBubblesError(
+      `Stored device state at "${storedDeviceStateFile.uri}" is not valid JSON.`
+    );
+  }
+  return withLegacyDeviceIdFallback(
+    normalizeStoredDeviceState(parsedState, `"${storedDeviceStateFile.uri}"`)
+  );
+}
+
+// src/storage/delivery-status-ledger.ts
+var import_expo_file_system2 = require("expo-file-system");
+var DELIVERY_STATUS_LEDGER_FILE_NAME = "bubbles-notifications-expo-delivery-status-ledger.json";
+var DELIVERY_STATUS_LEDGER_VERSION = 1;
+var MAX_POSTED_EVENT_KEYS = 200;
+function getDeliveryStatusLedgerFile() {
+  return new import_expo_file_system2.File(import_expo_file_system2.Paths.document, DELIVERY_STATUS_LEDGER_FILE_NAME);
+}
+function getOptionalNonEmptyString2(value) {
+  if (value == null) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmedValue = value.trim();
+  return trimmedValue.length > 0 ? trimmedValue : void 0;
+}
+function requireString(value, sourceDescription) {
+  if (typeof value !== "string") {
+    failWithBubblesError(`${sourceDescription} must be a string.`);
+  }
+  const trimmedValue = value.trim();
+  if (!trimmedValue) {
+    failWithBubblesError(`${sourceDescription} must not be empty.`);
+  }
+  return trimmedValue;
+}
+function buildStoredDeliveryStatusEventKey(options) {
+  return JSON.stringify([
+    options.notificationId,
+    options.status ?? null,
+    options.error ?? null,
+    options.actionId ?? null
+  ]);
+}
+function createStoredDeliveryStatusEvent(options) {
+  const error = getOptionalNonEmptyString2(options.error);
+  const actionId = getOptionalNonEmptyString2(options.actionId);
+  return {
+    key: buildStoredDeliveryStatusEventKey({
+      notificationId: options.notificationId,
+      status: options.status,
+      error,
+      actionId
+    }),
+    notificationId: options.notificationId,
+    ...options.status ? { status: options.status } : {},
+    ...error ? { error } : {},
+    ...actionId ? { actionId } : {},
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function normalizeStoredDeliveryStatusEvent(value, sourceDescription) {
+  if (!isPlainObject(value)) {
+    failWithBubblesError(`${sourceDescription} must be a JSON object.`);
+  }
+  const status = getOptionalNonEmptyString2(value.status);
+  const error = getOptionalNonEmptyString2(value.error);
+  const actionId = getOptionalNonEmptyString2(value.actionId);
+  return {
+    key: requireString(value.key, `${sourceDescription}.key`),
+    notificationId: requireString(
+      value.notificationId,
+      `${sourceDescription}.notificationId`
+    ),
+    ...status ? { status } : {},
+    ...error ? { error } : {},
+    ...actionId ? { actionId } : {},
+    createdAt: requireString(value.createdAt, `${sourceDescription}.createdAt`)
+  };
+}
+function normalizeStringArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((item) => getOptionalNonEmptyString2(item)).filter((item) => item !== void 0);
+}
+function normalizeDeliveryStatusLedger(value, sourceDescription) {
+  if (!isPlainObject(value)) {
+    failWithBubblesError(
+      `Stored delivery status ledger in ${sourceDescription} must be a JSON object.`
+    );
+  }
+  if (value.version !== DELIVERY_STATUS_LEDGER_VERSION) {
+    failWithBubblesError(
+      `Stored delivery status ledger in ${sourceDescription} uses unsupported schema version "${String(
+        value.version
+      )}".`
+    );
+  }
+  return {
+    pendingEvents: Array.isArray(value.pendingEvents) ? value.pendingEvents.map(
+      (event, index) => normalizeStoredDeliveryStatusEvent(
+        event,
+        `${sourceDescription}.pendingEvents[${index}]`
+      )
+    ) : [],
+    postedEventKeys: normalizeStringArray(value.postedEventKeys).slice(
+      -MAX_POSTED_EVENT_KEYS
+    )
+  };
+}
+function serializeDeliveryStatusLedger(ledger) {
+  return {
+    version: DELIVERY_STATUS_LEDGER_VERSION,
+    pendingEvents: ledger.pendingEvents,
+    postedEventKeys: ledger.postedEventKeys.slice(-MAX_POSTED_EVENT_KEYS)
+  };
+}
+function readDeliveryStatusLedgerFileText() {
+  const ledgerFile = getDeliveryStatusLedgerFile();
+  if (!ledgerFile.exists) {
+    return null;
+  }
+  const contents = ledgerFile.textSync().trim();
+  return contents.length > 0 ? contents : null;
+}
+function ensureDeliveryStatusLedgerFile() {
+  const ledgerFile = getDeliveryStatusLedgerFile();
+  if (!ledgerFile.exists) {
+    ledgerFile.create({ intermediates: true });
+  }
+  return ledgerFile;
+}
+function readStoredDeliveryStatusLedger() {
+  const ledgerFile = getDeliveryStatusLedgerFile();
+  const rawLedger = readDeliveryStatusLedgerFileText();
+  if (rawLedger === null) {
+    return {
+      pendingEvents: [],
+      postedEventKeys: []
+    };
+  }
+  let parsedLedger;
+  try {
+    parsedLedger = JSON.parse(rawLedger);
+  } catch {
+    failWithBubblesError(
+      `Stored delivery status ledger at "${ledgerFile.uri}" is not valid JSON.`
+    );
+  }
+  return normalizeDeliveryStatusLedger(
+    parsedLedger,
+    `"${ledgerFile.uri}"`
+  );
+}
+function storeDeliveryStatusLedger(ledger) {
+  const normalizedLedger = {
+    pendingEvents: ledger.pendingEvents,
+    postedEventKeys: ledger.postedEventKeys.slice(-MAX_POSTED_EVENT_KEYS)
+  };
+  const ledgerFile = ensureDeliveryStatusLedgerFile();
+  ledgerFile.write(
+    JSON.stringify(serializeDeliveryStatusLedger(normalizedLedger), null, 2)
+  );
+  return normalizedLedger;
+}
+function enqueueStoredDeliveryStatusEvent(event) {
+  const ledger = readStoredDeliveryStatusLedger();
+  if (ledger.postedEventKeys.includes(event.key) || ledger.pendingEvents.some((pendingEvent) => pendingEvent.key === event.key)) {
+    return ledger;
+  }
+  return storeDeliveryStatusLedger({
+    ...ledger,
+    pendingEvents: [...ledger.pendingEvents, event]
+  });
+}
+function markStoredDeliveryStatusEventPosted(event) {
+  const ledger = readStoredDeliveryStatusLedger();
+  const postedEventKeys = ledger.postedEventKeys.includes(event.key) ? ledger.postedEventKeys : [...ledger.postedEventKeys, event.key];
+  return storeDeliveryStatusLedger({
+    pendingEvents: ledger.pendingEvents.filter(
+      (pendingEvent) => pendingEvent.key !== event.key
+    ),
+    postedEventKeys
+  });
+}
+
+// src/notifications/delivery-status.ts
+function warnMissingApiBaseUrl(source) {
+  console.warn(
+    `[@fishonfire/bubbles-expo] Skipping ${source} delivery-status update because "apiBaseUrl" has not been persisted yet.`
+  );
+}
+function warnMissingAppKey(source) {
+  console.warn(
+    `[@fishonfire/bubbles-expo] Skipping ${source} delivery-status update because "appKey" has not been persisted yet.`
+  );
+}
+async function postStoredBubblesDeliveryStatus(options) {
+  const storedDeviceState = options.storedDeviceState ?? readStoredDeviceState();
+  const { deviceId, apiBaseUrl, appKey } = storedDeviceState;
+  if (!options.notificationId) {
+    return storedDeviceState;
+  }
+  const event = createStoredDeliveryStatusEvent({
+    notificationId: options.notificationId,
+    status: options.status,
+    error: options.error,
+    actionId: options.actionId
+  });
+  enqueueStoredDeliveryStatusEvent(event);
+  if (!deviceId) {
+    return storedDeviceState;
+  }
+  if (!apiBaseUrl) {
+    warnMissingApiBaseUrl(options.source);
+    return storedDeviceState;
+  }
+  if (!appKey) {
+    warnMissingAppKey(options.source);
+    return storedDeviceState;
+  }
+  await flushStoredBubblesDeliveryStatuses({
+    apiBaseUrl,
+    appKey,
+    deviceId
+  });
+  return storedDeviceState;
+}
+async function flushStoredBubblesDeliveryStatuses(storedDeviceState = readStoredDeviceState()) {
+  const { deviceId, apiBaseUrl, appKey } = storedDeviceState;
+  if (!deviceId || !apiBaseUrl || !appKey) {
+    return storedDeviceState;
+  }
+  const { pendingEvents } = readStoredDeliveryStatusLedger();
+  for (const event of pendingEvents) {
+    await postStoredDeliveryStatusEvent(apiBaseUrl, appKey, deviceId, event);
+    markStoredDeliveryStatusEventPosted(event);
+  }
+  return storedDeviceState;
+}
+async function postStoredDeliveryStatusEvent(apiBaseUrl, appKey, deviceId, event) {
+  await postBubblesDeliveryStatus({
+    apiBaseUrl,
+    appKey,
+    deviceId,
+    notificationId: event.notificationId,
+    status: event.status,
+    error: event.error
+  });
+}
+
+// src/notifications/local-notification.ts
+var Notifications2 = __toESM(require("expo-notifications"));
+
+// src/runtime/permissions.ts
+var Notifications = __toESM(require("expo-notifications"));
+var import_react_native = require("react-native");
+var IOS_GRANTED_AUTHORIZATION_STATUSES = /* @__PURE__ */ new Set([
+  Notifications.IosAuthorizationStatus.AUTHORIZED,
+  Notifications.IosAuthorizationStatus.PROVISIONAL,
+  Notifications.IosAuthorizationStatus.EPHEMERAL
+]);
+function isNotificationPermissionGranted(permissions) {
+  if (import_react_native.Platform.OS === "ios" && permissions.ios?.status != null) {
+    return IOS_GRANTED_AUTHORIZATION_STATUSES.has(permissions.ios.status);
+  }
+  return permissions.granted;
+}
+
+// src/notifications/local-notification.ts
+var DEFAULT_LOCAL_NOTIFICATION_TITLE = "Notification received";
+var DEFAULT_LOCAL_NOTIFICATION_BODY = "Open the app to view this update.";
+var DUPLICATE_NOTIFICATION_WINDOW_MS = 5e3;
+var recentlyScheduledNotificationKeys = /* @__PURE__ */ new Map();
+function getOptionalNonEmptyString3(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmedValue = value.trim();
+  return trimmedValue.length > 0 ? trimmedValue : null;
+}
+function buildDuplicateNotificationKey(payload) {
+  if (payload.notificationId) {
+    return `notification:${payload.notificationId}`;
+  }
+  const dataKeys = Object.keys(payload.data);
+  if (dataKeys.length === 0) {
+    return null;
+  }
+  try {
+    return `data:${JSON.stringify(payload.data)}`;
+  } catch {
+    return null;
+  }
+}
+function rememberScheduledNotificationKey(duplicateKey) {
+  const now = Date.now();
+  for (const [key, timestamp] of recentlyScheduledNotificationKeys) {
+    if (now - timestamp > DUPLICATE_NOTIFICATION_WINDOW_MS) {
+      recentlyScheduledNotificationKeys.delete(key);
+    }
+  }
+  const previousTimestamp = recentlyScheduledNotificationKeys.get(duplicateKey);
+  if (previousTimestamp !== void 0 && now - previousTimestamp <= DUPLICATE_NOTIFICATION_WINDOW_MS) {
+    return false;
+  }
+  recentlyScheduledNotificationKeys.set(duplicateKey, now);
+  return true;
+}
+async function postLocalNotificationShownDeliveryStatus(options) {
+  try {
+    await postStoredBubblesDeliveryStatus({
+      source: options.source,
+      notificationId: options.payload.notificationId,
+      status: BUBBLES_DELIVERY_STATUSES.notificationShown
+    });
+  } catch (error) {
+    console.error(
+      `[@fishonfire/bubbles-expo] Failed to post ${options.source} shown delivery status.`,
+      error
+    );
+  }
+}
+function buildBubblesLocalNotificationRequest(payload, options) {
+  return {
+    content: {
+      title: payload.messageTitle ?? getOptionalNonEmptyString3(options?.title) ?? DEFAULT_LOCAL_NOTIFICATION_TITLE,
+      body: payload.body ?? getOptionalNonEmptyString3(options?.body) ?? DEFAULT_LOCAL_NOTIFICATION_BODY,
+      data: payload.data
+    },
+    // Force app to trigger it 1 second from now instead of null.
+    // This prevents issues during background handling.
+    trigger: {
+      type: Notifications2.SchedulableTriggerInputTypes.TIME_INTERVAL,
+      seconds: 1
+    }
+  };
+}
+async function scheduleBubblesLocalNotification(options) {
+  if (!options.skipPermissionCheck) {
+    const permissions = await Notifications2.getPermissionsAsync();
+    const notificationsEnabled = isNotificationPermissionGranted(permissions);
+    if (!notificationsEnabled) {
+      return null;
+    }
+  }
+  const duplicateKey = buildDuplicateNotificationKey(options.payload);
+  if (duplicateKey !== null && !rememberScheduledNotificationKey(duplicateKey)) {
+    return null;
+  }
+  const notificationRequest = buildBubblesLocalNotificationRequest(
+    options.payload,
+    options
+  );
+  const scheduledNotificationId = await Notifications2.scheduleNotificationAsync(
+    notificationRequest
+  );
+  await postLocalNotificationShownDeliveryStatus(options);
+  return scheduledNotificationId;
+}
+
+// src/notifications/payload.ts
+function isPlainObject2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function getOptionalNonEmptyString4(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmedValue = value.trim();
+  return trimmedValue.length > 0 ? trimmedValue : null;
+}
+function getOptionalIdentifier(value) {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? String(value) : null;
+  }
+  return getOptionalNonEmptyString4(value);
+}
+function getBubblesNotificationData(value) {
+  return isPlainObject2(value) ? value : {};
+}
+function normalizeBubblesNotificationPayload(value) {
+  const data = getBubblesNotificationData(value);
+  return {
+    data,
+    notificationId: getOptionalIdentifier(data.notification_id),
+    messageTitle: getOptionalNonEmptyString4(data.message_title),
+    body: getOptionalNonEmptyString4(data.body),
+    source: getOptionalNonEmptyString4(data.source),
+    messageId: getOptionalIdentifier(data.message_id),
+    campaignId: getOptionalIdentifier(data.campaign_id),
+    url: getOptionalNonEmptyString4(data.url)
+  };
+}
+
+// src/notifications/remote-message.ts
+function getOptionalNonEmptyString5(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmedValue = value.trim();
+  return trimmedValue.length > 0 ? trimmedValue : null;
+}
+function getBubblesNotificationPayloadFromRemoteMessage(remoteMessage) {
+  const payload = normalizeBubblesNotificationPayload(
+    getBubblesNotificationData(remoteMessage.data)
+  );
+  return {
+    ...payload,
+    messageTitle: payload.messageTitle ?? getOptionalNonEmptyString5(remoteMessage.notification?.title),
+    body: payload.body ?? getOptionalNonEmptyString5(remoteMessage.notification?.body)
+  };
+}
+function hasFirebaseDisplayNotification(remoteMessage) {
+  return getOptionalNonEmptyString5(remoteMessage.notification?.title) !== null || getOptionalNonEmptyString5(remoteMessage.notification?.body) !== null;
+}
+
+// src/background/firebase-message-handler.ts
+var BACKGROUND_NOTIFICATION_SOURCE = "Firebase background message";
+var DEFAULT_BACKGROUND_NOTIFICATION_TITLE = "Background notification received";
+var DEFAULT_BACKGROUND_NOTIFICATION_BODY = "Open the app to view this update.";
+function supportsFirebaseBackgroundMessages() {
+  return import_react_native2.Platform.OS === "android" || import_react_native2.Platform.OS === "ios";
+}
+function supportsBackgroundLocalNotificationPresentation() {
+  return import_react_native2.Platform.OS === "android";
+}
+function logBackgroundStatusError(description, error) {
+  console.error(
+    `[@fishonfire/bubbles-expo] Failed to post ${BACKGROUND_NOTIFICATION_SOURCE} ${description} delivery status.`,
+    error
+  );
+}
+function getBackgroundNotificationErrorMessage(error) {
+  if (!(error instanceof Error)) {
+    return "Failed to show notification";
+  }
+  return `Failed to show notification: ${getErrorMessage(error)}`;
+}
+async function postBackgroundDeliveryStatus(notificationId, status) {
+  try {
+    await postStoredBubblesDeliveryStatus({
+      source: BACKGROUND_NOTIFICATION_SOURCE,
+      notificationId,
+      status
+    });
+  } catch (error) {
+    logBackgroundStatusError(status, error);
+  }
+}
+async function postBackgroundDeliveryError(notificationId, errorMessage) {
+  try {
+    await postStoredBubblesDeliveryStatus({
+      source: BACKGROUND_NOTIFICATION_SOURCE,
+      notificationId,
+      error: errorMessage
+    });
+  } catch (error) {
+    logBackgroundStatusError("error", error);
+  }
+}
+function postBackgroundNotificationReceived(notificationId) {
+  return postBackgroundDeliveryStatus(
+    notificationId,
+    BUBBLES_DELIVERY_STATUSES.notificationReceived
+  );
+}
+function postBackgroundNotificationsDisabled(notificationId) {
+  return postBackgroundDeliveryStatus(
+    notificationId,
+    BUBBLES_DELIVERY_STATUSES.notificationsDisabled
+  );
+}
+var hasRegisteredFirebaseBackgroundMessageHandler = false;
+var handleBubblesFirebaseBackgroundMessage = async (remoteMessage) => {
+  const payload = getBubblesNotificationPayloadFromRemoteMessage(remoteMessage);
+  const permissions = await Notifications3.getPermissionsAsync();
+  const notificationsEnabled = isNotificationPermissionGranted(permissions);
+  if (!notificationsEnabled) {
+    await postBackgroundNotificationsDisabled(payload.notificationId);
+    return;
+  }
+  await postBackgroundNotificationReceived(payload.notificationId);
+  if (hasFirebaseDisplayNotification(remoteMessage)) {
+    return;
+  }
+  if (!supportsBackgroundLocalNotificationPresentation()) {
+    return;
+  }
+  try {
+    const scheduledNotificationId = await scheduleBubblesLocalNotification({
+      source: BACKGROUND_NOTIFICATION_SOURCE,
+      payload,
+      title: DEFAULT_BACKGROUND_NOTIFICATION_TITLE,
+      body: DEFAULT_BACKGROUND_NOTIFICATION_BODY,
+      skipPermissionCheck: true
+    });
+    if (scheduledNotificationId === null) {
+      return;
+    }
+  } catch (error) {
+    await postBackgroundDeliveryError(
+      payload.notificationId,
+      getBackgroundNotificationErrorMessage(error)
+    );
+    throw error;
+  }
+};
+function registerBubblesFirebaseBackgroundMessageHandler() {
+  if (hasRegisteredFirebaseBackgroundMessageHandler) {
+    return;
+  }
+  if (!supportsFirebaseBackgroundMessages()) {
+    return;
+  }
+  try {
+    (0, import_messaging.setBackgroundMessageHandler)(
+      (0, import_messaging.getMessaging)(),
+      handleBubblesFirebaseBackgroundMessage
+    );
+    hasRegisteredFirebaseBackgroundMessageHandler = true;
+  } catch (error) {
+    console.error(
+      "[@fishonfire/bubbles-expo] Failed to register Firebase background message handler.",
+      error
+    );
+  }
+}
+
+// src/background/setup.ts
+var hasRegisteredBubblesBackgroundHandlers = false;
+function registerBubblesBackgroundHandlers() {
+  if (hasRegisteredBubblesBackgroundHandlers) {
+    return;
+  }
+  registerBubblesFirebaseBackgroundMessageHandler();
+  hasRegisteredBubblesBackgroundHandlers = true;
+}
+
+// src/register-task.ts
+registerBubblesBackgroundHandlers();