@fishonfire/bubbles-expo 0.1.0

package/dist/chunk-6NPXFGQX.mjs

@@ -0,0 +1,1308 @@
+// src/config/runtime-config.ts
+import Constants from "expo-constants";
+
+// plugin/src/shared-config.ts
+var BUBBLES_NOTIFICATIONS_EXPO_EXTRA_KEY = "bubblesNotificationsExpo";
+var ANDROID_CHANNEL_IMPORTANCE_VALUES = [
+  "min",
+  "low",
+  "default",
+  "high",
+  "max"
+];
+
+// 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 getRequiredNonEmptyStringFromSource(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 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/config/runtime-config.ts
+var BUBBLES_NOTIFICATIONS_EXPO_EXTRA_KEY2 = BUBBLES_NOTIFICATIONS_EXPO_EXTRA_KEY;
+var ANDROID_CHANNEL_IMPORTANCE_VALUES2 = ANDROID_CHANNEL_IMPORTANCE_VALUES;
+function getAndroidChannelImportance(value, propertyPath) {
+  if (typeof value !== "string") {
+    failWithBubblesError(
+      `"${propertyPath}" must be one of: ${ANDROID_CHANNEL_IMPORTANCE_VALUES2.join(
+        ", "
+      )}.`
+    );
+  }
+  if (!ANDROID_CHANNEL_IMPORTANCE_VALUES2.includes(
+    value
+  )) {
+    failWithBubblesError(
+      `"${propertyPath}" must be one of: ${ANDROID_CHANNEL_IMPORTANCE_VALUES2.join(
+        ", "
+      )}.`
+    );
+  }
+  return value;
+}
+function getBubblesNotificationsRuntimeConfig() {
+  const expoConfig = Constants.expoConfig;
+  if (!expoConfig) {
+    failWithBubblesError(
+      "Expo runtime config is unavailable. Ensure the app is running with Expo config support."
+    );
+  }
+  if (!isPlainObject(expoConfig.extra)) {
+    failWithBubblesError(
+      `Missing "expo.extra.${BUBBLES_NOTIFICATIONS_EXPO_EXTRA_KEY2}". Configure the "@fishonfire/bubbles-expo" plugin in app.json.`
+    );
+  }
+  const runtimeConfig = expoConfig.extra[BUBBLES_NOTIFICATIONS_EXPO_EXTRA_KEY2];
+  if (!isPlainObject(runtimeConfig)) {
+    failWithBubblesError(
+      `Missing "expo.extra.${BUBBLES_NOTIFICATIONS_EXPO_EXTRA_KEY2}". Configure the "@fishonfire/bubbles-expo" plugin in app.json.`
+    );
+  }
+  return {
+    defaultChannelId: getRequiredNonEmptyString(
+      runtimeConfig.defaultChannelId,
+      `expo.extra.${BUBBLES_NOTIFICATIONS_EXPO_EXTRA_KEY2}.defaultChannelId`
+    ),
+    defaultChannelName: getRequiredNonEmptyString(
+      runtimeConfig.defaultChannelName,
+      `expo.extra.${BUBBLES_NOTIFICATIONS_EXPO_EXTRA_KEY2}.defaultChannelName`
+    ),
+    androidChannelImportance: getAndroidChannelImportance(
+      runtimeConfig.androidChannelImportance,
+      `expo.extra.${BUBBLES_NOTIFICATIONS_EXPO_EXTRA_KEY2}.androidChannelImportance`
+    )
+  };
+}
+
+// src/storage/device-state.ts
+import { File, Paths } from "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 File(Paths.document, STORED_DEVICE_STATE_FILE_NAME);
+}
+function getLegacyDeviceIdFile() {
+  return new File(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 normalizeStoredDeviceStateInput(value) {
+  if (!isPlainObject(value)) {
+    failWithBubblesError("Stored device state must be an object.");
+  }
+  return {
+    deviceId: getOptionalNonEmptyString(value.deviceId, "deviceId"),
+    apiBaseUrl: getOptionalNonEmptyString(value.apiBaseUrl, "apiBaseUrl"),
+    appKey: getOptionalNonEmptyString(value.appKey, "appKey")
+  };
+}
+function normalizeStoredDeviceStateUpdate(value) {
+  if (!isPlainObject(value)) {
+    failWithBubblesError("Stored device state update must be an object.");
+  }
+  const nextState = {};
+  if ("deviceId" in value) {
+    nextState.deviceId = getOptionalNonEmptyString(value.deviceId, "deviceId");
+  }
+  if ("apiBaseUrl" in value) {
+    nextState.apiBaseUrl = getOptionalNonEmptyString(
+      value.apiBaseUrl,
+      "apiBaseUrl"
+    );
+  }
+  if ("appKey" in value) {
+    nextState.appKey = getOptionalNonEmptyString(value.appKey, "appKey");
+  }
+  return nextState;
+}
+function serializeStoredDeviceState(state) {
+  const serializedState = {
+    version: STORED_DEVICE_STATE_VERSION
+  };
+  if (state.deviceId) {
+    serializedState.deviceId = state.deviceId;
+  }
+  if (state.apiBaseUrl) {
+    serializedState.apiBaseUrl = state.apiBaseUrl;
+  }
+  if (state.appKey) {
+    serializedState.appKey = state.appKey;
+  }
+  return serializedState;
+}
+function readStoredDeviceStateFileText() {
+  const storedDeviceStateFile = getStoredDeviceStateFile();
+  if (!storedDeviceStateFile.exists) {
+    return null;
+  }
+  const contents = storedDeviceStateFile.textSync().trim();
+  return contents.length > 0 ? contents : null;
+}
+function ensureStoredDeviceStateFile() {
+  const storedDeviceStateFile = getStoredDeviceStateFile();
+  if (!storedDeviceStateFile.exists) {
+    storedDeviceStateFile.create({ intermediates: true });
+  }
+  return storedDeviceStateFile;
+}
+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}"`)
+  );
+}
+function storeDeviceState(state) {
+  const normalizedState = normalizeStoredDeviceStateInput(state);
+  const storedDeviceStateFile = ensureStoredDeviceStateFile();
+  storedDeviceStateFile.write(
+    JSON.stringify(serializeStoredDeviceState(normalizedState), null, 2)
+  );
+  return normalizedState;
+}
+function patchStoredDeviceState(update) {
+  const normalizedUpdate = normalizeStoredDeviceStateUpdate(update);
+  return storeDeviceState({
+    ...readStoredDeviceState(),
+    ...normalizedUpdate
+  });
+}
+function readStoredDeviceId() {
+  return readStoredDeviceState().deviceId;
+}
+function readStoredApiBaseUrl() {
+  return readStoredDeviceState().apiBaseUrl;
+}
+function readStoredAppKey() {
+  return readStoredDeviceState().appKey;
+}
+function storeDeviceId(deviceId) {
+  return patchStoredDeviceState({ deviceId });
+}
+function storeApiBaseUrl(apiBaseUrl) {
+  return patchStoredDeviceState({ apiBaseUrl });
+}
+function storeAppKey(appKey) {
+  return patchStoredDeviceState({ appKey });
+}
+
+// src/api/device-payload.ts
+import {
+  getLocaleAndTimeZone
+} from "@fishonfire/bubbles-js";
+function normalizeOptionalString(value, fieldName) {
+  if (value == null) {
+    return null;
+  }
+  if (typeof value !== "string") {
+    failWithBubblesError(`"${fieldName}" must be a string when present.`);
+  }
+  const trimmedValue = value.trim();
+  return trimmedValue.length > 0 ? trimmedValue : null;
+}
+function normalizeRequiredNullableString(value, fieldName) {
+  if (value === null) {
+    return null;
+  }
+  if (value === void 0) {
+    failWithBubblesError(
+      `"${fieldName}" is required. Pass a push token string or null.`
+    );
+  }
+  return getRequiredNonEmptyString(value, fieldName);
+}
+function normalizeAppId(value) {
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      failWithBubblesError('"appId" must be a finite number.');
+    }
+    return value;
+  }
+  if (typeof value === "string") {
+    return getRequiredNonEmptyString(value, "appId");
+  }
+  failWithBubblesError('"appId" must be a string or number.');
+}
+function normalizePlatform(value) {
+  if (value === "android" || value === "ios") {
+    return value;
+  }
+  failWithBubblesError('"platform" must be either "android" or "ios".');
+}
+function normalizeAliasing(value) {
+  if (value == null) {
+    return [];
+  }
+  if (!Array.isArray(value)) {
+    failWithBubblesError('"aliasing" must be an array of strings when present.');
+  }
+  return value.map(
+    (entry, index) => normalizeOptionalString(entry, `aliasing[${index}]`)
+  ).filter((entry) => entry !== null);
+}
+function normalizeNotificationsEnabled(value) {
+  if (typeof value !== "boolean") {
+    failWithBubblesError('"notificationsEnabled" must be a boolean.');
+  }
+  return value;
+}
+function resolveLocaleAndTimeZone(input) {
+  const resolved = input ?? getLocaleAndTimeZone();
+  return {
+    locale: getRequiredNonEmptyString(resolved.locale, "locale"),
+    timeZone: normalizeOptionalString(resolved.timeZone, "timeZone")
+  };
+}
+function buildBaseDevicePayload(options) {
+  const { locale, timeZone } = resolveLocaleAndTimeZone(
+    options.localeAndTimeZone
+  );
+  const payload = {
+    user_id: getRequiredNonEmptyString(options.userId, "userId"),
+    aliasing: normalizeAliasing(options.aliasing),
+    platform: normalizePlatform(options.platform),
+    push_token: normalizeRequiredNullableString(options.pushToken, "pushToken"),
+    locale,
+    notifications_enabled: normalizeNotificationsEnabled(
+      options.notificationsEnabled
+    )
+  };
+  if ("fid" in options) {
+    payload.fid = normalizeOptionalString(options.fid, "fid");
+  }
+  const appVersion = normalizeOptionalString(options.appVersion, "appVersion");
+  if (appVersion) {
+    payload.app_version = appVersion;
+  }
+  if (timeZone) {
+    payload.timezone = timeZone;
+  }
+  return payload;
+}
+function buildCreateDevicePayload(options) {
+  return {
+    app_id: normalizeAppId(options.appId),
+    ...buildBaseDevicePayload(options)
+  };
+}
+function buildUpdateDevicePayload(options) {
+  return buildBaseDevicePayload(options);
+}
+
+// src/api/device-client.ts
+import {
+  DeviceClient
+} from "@fishonfire/bubbles-js";
+var APP_KEY_HEADER_NAME = "X-App-Key";
+var INVALID_APP_KEY_ERROR = "invalid app key for app";
+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 resolveDeviceClient(options) {
+  if (options.client) {
+    return options.client;
+  }
+  return createBubblesDeviceClient({
+    ...options.clientOptions,
+    appKey: options.appKey,
+    baseUrl: getRequiredNonEmptyString(options.apiBaseUrl, "apiBaseUrl")
+  });
+}
+function createBubblesDeviceClient(options) {
+  const { appKey: rawAppKey, ...clientOptions } = options;
+  const appKey = rawAppKey ? getRequiredNonEmptyString(rawAppKey, "appKey") : null;
+  return new DeviceClient({
+    ...clientOptions,
+    baseUrl: getRequiredNonEmptyString(clientOptions.baseUrl, "apiBaseUrl"),
+    defaultHeaders: {
+      ...clientOptions.defaultHeaders,
+      ...appKey ? { [APP_KEY_HEADER_NAME]: appKey } : {}
+    }
+  });
+}
+function withAppKeyHeader(appKey, requestOptions) {
+  return {
+    ...requestOptions,
+    headers: {
+      ...requestOptions?.headers,
+      [APP_KEY_HEADER_NAME]: 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_ERROR;
+}
+function throwAppAuthenticationError(error) {
+  if (isInvalidAppKeyResponse(error)) {
+    throw new BubblesAppAuthenticationError(error);
+  }
+  throw error;
+}
+function extractDeviceIdFromDeviceResponse(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  const id = Reflect.get(value, "id");
+  if (typeof id === "number") {
+    return Number.isFinite(id) ? String(id) : null;
+  }
+  if (typeof id === "string") {
+    const trimmedId = id.trim();
+    return trimmedId.length > 0 ? trimmedId : null;
+  }
+  return null;
+}
+async function createBubblesDevice(options) {
+  const client = resolveDeviceClient(options);
+  const payload = buildCreateDevicePayload(options);
+  try {
+    return await client.createDevice(
+      payload,
+      withAppKeyHeader(options.appKey, options.requestOptions)
+    );
+  } catch (error) {
+    throwAppAuthenticationError(error);
+  }
+}
+async function updateBubblesDevice(options) {
+  const client = resolveDeviceClient(options);
+  const payload = buildUpdateDevicePayload(options);
+  try {
+    return await client.updateDevice(
+      normalizeIdentifier(options.deviceId, "deviceId"),
+      payload,
+      withAppKeyHeader(options.appKey, options.requestOptions)
+    );
+  } catch (error) {
+    throwAppAuthenticationError(error);
+  }
+}
+async function syncBubblesDevice(options) {
+  const client = resolveDeviceClient(options);
+  if (options.deviceId !== null) {
+    const deviceId = normalizeIdentifier(options.deviceId, "deviceId");
+    let response2;
+    try {
+      response2 = await client.updateDevice(
+        deviceId,
+        buildUpdateDevicePayload(options),
+        withAppKeyHeader(options.appKey, options.updateRequestOptions)
+      );
+    } catch (error) {
+      throwAppAuthenticationError(error);
+    }
+    return {
+      action: "updated",
+      deviceId,
+      response: response2
+    };
+  }
+  let response;
+  try {
+    response = await client.createDevice(
+      buildCreateDevicePayload(options),
+      withAppKeyHeader(options.appKey, options.createRequestOptions)
+    );
+  } catch (error) {
+    throwAppAuthenticationError(error);
+  }
+  return {
+    action: "created",
+    deviceId: extractDeviceIdFromDeviceResponse(response),
+    response
+  };
+}
+
+// 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 resolveDeviceClient2(options) {
+  if (options.client) {
+    return options.client;
+  }
+  return createBubblesDeviceClient({
+    ...options.clientOptions,
+    appKey: getRequiredNonEmptyString(options.appKey, "appKey"),
+    baseUrl: getRequiredNonEmptyString(options.apiBaseUrl, "apiBaseUrl")
+  });
+}
+function withAppKeyHeader2(appKey, requestOptions) {
+  return {
+    ...requestOptions,
+    headers: {
+      ...requestOptions?.headers,
+      "X-App-Key": getRequiredNonEmptyString(appKey, "appKey")
+    }
+  };
+}
+function isInvalidAppKeyResponse2(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 = resolveDeviceClient2(options);
+  try {
+    await client.postDeliveryStatus(
+      normalizeIdentifier(options.deviceId, "deviceId"),
+      normalizeIdentifier(options.notificationId, "notificationId"),
+      buildBubblesDeliveryStatusPayload(options),
+      withAppKeyHeader2(options.appKey, options.requestOptions)
+    );
+  } catch (error) {
+    if (isInvalidAppKeyResponse2(error)) {
+      throw new BubblesAppAuthenticationError(error);
+    }
+    throw error;
+  }
+}
+
+// src/storage/delivery-status-ledger.ts
+import { File as File2, Paths as Paths2 } from "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 File2(Paths2.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/runtime/channels.ts
+import * as Notifications from "expo-notifications";
+import { Platform } from "react-native";
+var ANDROID_CHANNEL_IMPORTANCE_MAP = {
+  min: Notifications.AndroidImportance.MIN,
+  low: Notifications.AndroidImportance.LOW,
+  default: Notifications.AndroidImportance.DEFAULT,
+  high: Notifications.AndroidImportance.HIGH,
+  max: Notifications.AndroidImportance.MAX
+};
+function fail(message) {
+  throw new Error(`[@fishonfire/bubbles-expo] ${message}`);
+}
+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 getAndroidNotificationChannelImportance(value) {
+  return ANDROID_CHANNEL_IMPORTANCE_MAP[value];
+}
+function getDefaultNotificationChannelConfig(options) {
+  const runtimeConfig = getBubblesNotificationsRuntimeConfig();
+  return {
+    channelId: getRequiredNonEmptyString2(
+      options?.channelId ?? runtimeConfig.defaultChannelId,
+      "channelId"
+    ),
+    channelName: getRequiredNonEmptyString2(
+      options?.channelName ?? runtimeConfig.defaultChannelName,
+      "channelName"
+    ),
+    importance: options?.importance ?? runtimeConfig.androidChannelImportance
+  };
+}
+async function ensureDefaultNotificationChannel(options) {
+  if (Platform.OS !== "android") {
+    return null;
+  }
+  const channelConfig = getDefaultNotificationChannelConfig(options);
+  return Notifications.setNotificationChannelAsync(channelConfig.channelId, {
+    name: channelConfig.channelName,
+    importance: getAndroidNotificationChannelImportance(channelConfig.importance)
+  });
+}
+
+// src/runtime/permissions.ts
+import * as Notifications2 from "expo-notifications";
+import { Platform as Platform2 } from "react-native";
+
+// src/internal/platform.ts
+function isSupportedPlatform(value) {
+  return value === "android" || value === "ios";
+}
+function assertSupportedPlatform(value) {
+  if (isSupportedPlatform(value)) {
+    return;
+  }
+  failWithBubblesError(
+    `Unsupported platform: ${value}. This package only supports iOS and Android.`
+  );
+}
+function getSupportedPlatform(value) {
+  assertSupportedPlatform(value);
+  return value;
+}
+
+// src/runtime/permissions.ts
+var IOS_GRANTED_AUTHORIZATION_STATUSES = /* @__PURE__ */ new Set([
+  Notifications2.IosAuthorizationStatus.AUTHORIZED,
+  Notifications2.IosAuthorizationStatus.PROVISIONAL,
+  Notifications2.IosAuthorizationStatus.EPHEMERAL
+]);
+function isNotificationPermissionGranted(permissions) {
+  if (Platform2.OS === "ios" && permissions.ios?.status != null) {
+    return IOS_GRANTED_AUTHORIZATION_STATUSES.has(permissions.ios.status);
+  }
+  return permissions.granted;
+}
+function describeNotificationPermissionStatus(permissions) {
+  if (Platform2.OS === "ios" && permissions.ios?.status != null) {
+    return Notifications2.IosAuthorizationStatus[permissions.ios.status].toLowerCase();
+  }
+  return permissions.status;
+}
+async function getNotificationPermissions(options) {
+  assertSupportedPlatform(Platform2.OS);
+  await ensureDefaultNotificationChannel();
+  const existingPermissions = await Notifications2.getPermissionsAsync();
+  if (isNotificationPermissionGranted(existingPermissions) || options?.requestPermissions === false) {
+    return existingPermissions;
+  }
+  return Notifications2.requestPermissionsAsync(options?.permissionRequestOptions);
+}
+async function ensureNotificationPermissions(options) {
+  const permissions = await getNotificationPermissions(options);
+  if (!isNotificationPermissionGranted(permissions)) {
+    failWithBubblesError("Push notification permission was not granted.");
+  }
+  return permissions;
+}
+
+// src/background/firebase-message-handler.ts
+import {
+  getMessaging,
+  setBackgroundMessageHandler
+} from "@react-native-firebase/messaging";
+import * as Notifications4 from "expo-notifications";
+import { Platform as Platform3 } from "react-native";
+
+// src/notifications/local-notification.ts
+import * as Notifications3 from "expo-notifications";
+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: Notifications3.SchedulableTriggerInputTypes.TIME_INTERVAL,
+      seconds: 1
+    }
+  };
+}
+async function scheduleBubblesLocalNotification(options) {
+  if (!options.skipPermissionCheck) {
+    const permissions = await Notifications3.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 Notifications3.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 getBubblesNotificationDataFromNotification(notification) {
+  return getBubblesNotificationData(notification.request.content.data);
+}
+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 Platform3.OS === "android" || Platform3.OS === "ios";
+}
+function supportsBackgroundLocalNotificationPresentation() {
+  return Platform3.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 Notifications4.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 {
+    setBackgroundMessageHandler(
+      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;
+}
+
+export {
+  failWithBubblesError,
+  getErrorMessage,
+  getRequiredNonEmptyString,
+  getRequiredNonEmptyStringFromSource,
+  BUBBLES_NOTIFICATIONS_EXPO_EXTRA_KEY2 as BUBBLES_NOTIFICATIONS_EXPO_EXTRA_KEY,
+  ANDROID_CHANNEL_IMPORTANCE_VALUES2 as ANDROID_CHANNEL_IMPORTANCE_VALUES,
+  getBubblesNotificationsRuntimeConfig,
+  readStoredDeviceState,
+  storeDeviceState,
+  patchStoredDeviceState,
+  readStoredDeviceId,
+  readStoredApiBaseUrl,
+  readStoredAppKey,
+  storeDeviceId,
+  storeApiBaseUrl,
+  storeAppKey,
+  buildCreateDevicePayload,
+  buildUpdateDevicePayload,
+  BubblesAppAuthenticationError,
+  createBubblesDeviceClient,
+  extractDeviceIdFromDeviceResponse,
+  createBubblesDevice,
+  updateBubblesDevice,
+  syncBubblesDevice,
+  BUBBLES_DELIVERY_STATUSES,
+  buildBubblesDeliveryStatusPayload,
+  postBubblesDeliveryStatus,
+  buildStoredDeliveryStatusEventKey,
+  createStoredDeliveryStatusEvent,
+  readStoredDeliveryStatusLedger,
+  storeDeliveryStatusLedger,
+  enqueueStoredDeliveryStatusEvent,
+  markStoredDeliveryStatusEventPosted,
+  postStoredBubblesDeliveryStatus,
+  flushStoredBubblesDeliveryStatuses,
+  getAndroidNotificationChannelImportance,
+  getDefaultNotificationChannelConfig,
+  ensureDefaultNotificationChannel,
+  getSupportedPlatform,
+  isNotificationPermissionGranted,
+  describeNotificationPermissionStatus,
+  getNotificationPermissions,
+  ensureNotificationPermissions,
+  scheduleBubblesLocalNotification,
+  getBubblesNotificationDataFromNotification,
+  normalizeBubblesNotificationPayload,
+  getBubblesNotificationPayloadFromRemoteMessage,
+  hasFirebaseDisplayNotification,
+  registerBubblesBackgroundHandlers
+};