@amazon-devices/expo-notifications 2.0.9000000000-rn-83

package/src/scheduleNotificationAsync.ts

@@ -0,0 +1,335 @@
+import * as Crypto from '@amazon-devices/expo-crypto';
+import { Platform, UnavailabilityError } from 'expo-modules-core';
+
+import NotificationScheduler from './NotificationScheduler';
+import { NotificationTriggerInput as NativeNotificationTriggerInput } from './NotificationScheduler.types';
+import {
+  NotificationRequestInput,
+  NotificationTriggerInput,
+  DailyTriggerInput,
+  WeeklyTriggerInput,
+  YearlyTriggerInput,
+  CalendarTriggerInput,
+  TimeIntervalTriggerInput,
+  DateTriggerInput,
+  ChannelAwareTriggerInput,
+  SchedulableNotificationTriggerInput,
+} from './Notifications.types';
+
+/**
+ * Schedules a notification to be triggered in the future.
+ * > **Note:** Please note that this does not mean that the notification will be presented when it is triggered.
+ * For the notification to be presented you have to set a notification handler with [`setNotificationHandler`](#notificationssetnotificationhandlerhandler)
+ * that will return an appropriate notification behavior. For more information see the example below.
+ * @param request An object describing the notification to be triggered.
+ * @return Returns a Promise resolving to a string which is a notification identifier you can later use to cancel the notification or to identify an incoming notification.
+ * @example
+ * # Schedule the notification that will trigger once, in one minute from now
+ * ```ts
+ * import * as Notifications from '@amazon-devices/expo-notifications';
+ *
+ * Notifications.scheduleNotificationAsync({
+ *   content: {
+ *     title: "Time's up!",
+ *     body: 'Change sides!',
+ *   },
+ *   trigger: {
+ *     seconds: 60,
+ *   },
+ * });
+ * ```
+ *
+ * # Schedule the notification that will trigger repeatedly, every 20 minutes
+ * ```ts
+ * import * as Notifications from '@amazon-devices/expo-notifications';
+ *
+ * Notifications.scheduleNotificationAsync({
+ *   content: {
+ *     title: 'Remember to drink water!',
+ *   },
+ *   trigger: {
+ *     seconds: 60 * 20,
+ *     repeats: true,
+ *   },
+ * });
+ * ```
+ *
+ * # Schedule the notification that will trigger once, at the beginning of next hour
+ * ```ts
+ * import * as Notifications from '@amazon-devices/expo-notifications';
+ *
+ * const trigger = new Date(Date.now() + 60 * 60 * 1000);
+ * trigger.setMinutes(0);
+ * trigger.setSeconds(0);
+ *
+ * Notifications.scheduleNotificationAsync({
+ *   content: {
+ *     title: 'Happy new hour!',
+ *   },
+ *   trigger,
+ * });
+ * ```
+ * @header schedule
+ */
+export default async function scheduleNotificationAsync(
+  request: NotificationRequestInput
+): Promise<string> {
+  if (!NotificationScheduler.scheduleNotificationAsync) {
+    throw new UnavailabilityError('Notifications', 'scheduleNotificationAsync');
+  }
+
+  return await NotificationScheduler.scheduleNotificationAsync(
+    request.identifier ?? Crypto.randomUUID(),
+    request.content,
+    parseTrigger(request.trigger)
+  );
+}
+
+type ValidTriggerDateComponents = 'month' | 'day' | 'weekday' | 'hour' | 'minute';
+
+const DAILY_TRIGGER_EXPECTED_DATE_COMPONENTS: readonly ValidTriggerDateComponents[] = [
+  'hour',
+  'minute',
+];
+const WEEKLY_TRIGGER_EXPECTED_DATE_COMPONENTS: readonly ValidTriggerDateComponents[] = [
+  'weekday',
+  'hour',
+  'minute',
+];
+const YEARLY_TRIGGER_EXPECTED_DATE_COMPONENTS: readonly ValidTriggerDateComponents[] = [
+  'day',
+  'month',
+  'hour',
+  'minute',
+];
+
+export function parseTrigger(
+  userFacingTrigger: NotificationTriggerInput
+): NativeNotificationTriggerInput {
+  if (userFacingTrigger === null) {
+    return null;
+  }
+
+  if (userFacingTrigger === undefined) {
+    throw new TypeError(
+      'Encountered an `undefined` notification trigger. If you want to trigger the notification immediately, pass in an explicit `null` value.'
+    );
+  }
+
+  if (isDateTrigger(userFacingTrigger)) {
+    return parseDateTrigger(userFacingTrigger);
+  } else if (isDailyTriggerInput(userFacingTrigger)) {
+    validateDateComponentsInTrigger(userFacingTrigger, DAILY_TRIGGER_EXPECTED_DATE_COMPONENTS);
+    return {
+      type: 'daily',
+      channelId: userFacingTrigger.channelId,
+      hour: userFacingTrigger.hour,
+      minute: userFacingTrigger.minute,
+    };
+  } else if (isWeeklyTriggerInput(userFacingTrigger)) {
+    validateDateComponentsInTrigger(userFacingTrigger, WEEKLY_TRIGGER_EXPECTED_DATE_COMPONENTS);
+    return {
+      type: 'weekly',
+      channelId: userFacingTrigger.channelId,
+      weekday: userFacingTrigger.weekday,
+      hour: userFacingTrigger.hour,
+      minute: userFacingTrigger.minute,
+    };
+  } else if (isYearlyTriggerInput(userFacingTrigger)) {
+    validateDateComponentsInTrigger(userFacingTrigger, YEARLY_TRIGGER_EXPECTED_DATE_COMPONENTS);
+    return {
+      type: 'yearly',
+      channelId: userFacingTrigger.channelId,
+      day: userFacingTrigger.day,
+      month: userFacingTrigger.month,
+      hour: userFacingTrigger.hour,
+      minute: userFacingTrigger.minute,
+    };
+  } else if (isSecondsPropertyMisusedInCalendarTriggerInput(userFacingTrigger)) {
+    throw new TypeError(
+      'Could not have inferred the notification trigger type: if you want to use a time interval trigger, pass in only `seconds` with or without `repeats` property; if you want to use calendar-based trigger, pass in `second`.'
+    );
+  } else if ('seconds' in userFacingTrigger) {
+    return {
+      type: 'timeInterval',
+      channelId: userFacingTrigger.channelId,
+      seconds: userFacingTrigger.seconds,
+      repeats: userFacingTrigger.repeats ?? false,
+    };
+  } else if (isCalendarTrigger(userFacingTrigger)) {
+    const { repeats, ...calendarTrigger } = userFacingTrigger;
+    return { type: 'calendar', value: calendarTrigger, repeats };
+  } else {
+    return Platform.select({
+      default: null, // There's no notion of channels on platforms other than Android.
+      android: { type: 'channel', channelId: userFacingTrigger.channelId },
+    });
+  }
+}
+
+function isCalendarTrigger(
+  trigger: CalendarTriggerInput | ChannelAwareTriggerInput
+): trigger is CalendarTriggerInput {
+  const { channelId, ...triggerWithoutChannelId } = trigger;
+  return Object.keys(triggerWithoutChannelId).length > 0;
+}
+
+function isDateTrigger(
+  trigger:
+    | DateTriggerInput
+    | WeeklyTriggerInput
+    | DailyTriggerInput
+    | CalendarTriggerInput
+    | TimeIntervalTriggerInput
+): trigger is DateTriggerInput {
+  return (
+    trigger instanceof Date ||
+    typeof trigger === 'number' ||
+    (typeof trigger === 'object' && 'date' in trigger)
+  );
+}
+
+function parseDateTrigger(trigger: DateTriggerInput): NativeNotificationTriggerInput {
+  if (trigger instanceof Date || typeof trigger === 'number') {
+    return { type: 'date', timestamp: toTimestamp(trigger) };
+  }
+  return { type: 'date', timestamp: toTimestamp(trigger.date), channelId: trigger.channelId };
+}
+
+function toTimestamp(date: number | Date) {
+  if (date instanceof Date) {
+    return date.getTime();
+  }
+  return date;
+}
+
+function isDailyTriggerInput(
+  trigger: SchedulableNotificationTriggerInput
+): trigger is DailyTriggerInput {
+  if (typeof trigger !== 'object') return false;
+  const { channelId, ...triggerWithoutChannelId } = trigger as DailyTriggerInput;
+  return (
+    Object.keys(triggerWithoutChannelId).length ===
+      DAILY_TRIGGER_EXPECTED_DATE_COMPONENTS.length + 1 &&
+    DAILY_TRIGGER_EXPECTED_DATE_COMPONENTS.every(
+      (component) => component in triggerWithoutChannelId
+    ) &&
+    'repeats' in triggerWithoutChannelId &&
+    triggerWithoutChannelId.repeats === true
+  );
+}
+
+function isWeeklyTriggerInput(
+  trigger: SchedulableNotificationTriggerInput
+): trigger is WeeklyTriggerInput {
+  if (typeof trigger !== 'object') return false;
+  const { channelId, ...triggerWithoutChannelId } = trigger as WeeklyTriggerInput;
+  return (
+    Object.keys(triggerWithoutChannelId).length ===
+      WEEKLY_TRIGGER_EXPECTED_DATE_COMPONENTS.length + 1 &&
+    WEEKLY_TRIGGER_EXPECTED_DATE_COMPONENTS.every(
+      (component) => component in triggerWithoutChannelId
+    ) &&
+    'repeats' in triggerWithoutChannelId &&
+    triggerWithoutChannelId.repeats === true
+  );
+}
+
+function isYearlyTriggerInput(
+  trigger: SchedulableNotificationTriggerInput
+): trigger is YearlyTriggerInput {
+  if (typeof trigger !== 'object') return false;
+  const { channelId, ...triggerWithoutChannelId } = trigger as YearlyTriggerInput;
+  return (
+    Object.keys(triggerWithoutChannelId).length ===
+      YEARLY_TRIGGER_EXPECTED_DATE_COMPONENTS.length + 1 &&
+    YEARLY_TRIGGER_EXPECTED_DATE_COMPONENTS.every(
+      (component) => component in triggerWithoutChannelId
+    ) &&
+    'repeats' in triggerWithoutChannelId &&
+    triggerWithoutChannelId.repeats === true
+  );
+}
+
+function isSecondsPropertyMisusedInCalendarTriggerInput(
+  trigger: TimeIntervalTriggerInput | CalendarTriggerInput
+) {
+  const { channelId, ...triggerWithoutChannelId } = trigger;
+  return (
+    // eg. { seconds: ..., repeats: ..., hour: ... }
+    ('seconds' in triggerWithoutChannelId &&
+      'repeats' in triggerWithoutChannelId &&
+      Object.keys(triggerWithoutChannelId).length > 2) ||
+    // eg. { seconds: ..., hour: ... }
+    ('seconds' in triggerWithoutChannelId &&
+      !('repeats' in triggerWithoutChannelId) &&
+      Object.keys(triggerWithoutChannelId).length > 1)
+  );
+}
+
+function validateDateComponentsInTrigger(
+  trigger: NonNullable<NotificationTriggerInput>,
+  components: readonly ValidTriggerDateComponents[]
+) {
+  const anyTriggerType = trigger as any;
+  components.forEach((component) => {
+    if (!(component in anyTriggerType)) {
+      throw new TypeError(`The ${component} parameter needs to be present`);
+    }
+    if (typeof anyTriggerType[component] !== 'number') {
+      throw new TypeError(`The ${component} parameter should be a number`);
+    }
+    switch (component) {
+      case 'month': {
+        const { month } = anyTriggerType;
+        if (month < 0 || month > 11) {
+          throw new RangeError(`The month parameter needs to be between 0 and 11. Found: ${month}`);
+        }
+        break;
+      }
+      case 'day': {
+        const { day, month } = anyTriggerType;
+        const daysInGivenMonth = daysInMonth(month);
+        if (day < 1 || day > daysInGivenMonth) {
+          throw new RangeError(
+            `The day parameter for month ${month} must be between 1 and ${daysInGivenMonth}. Found: ${day}`
+          );
+        }
+        break;
+      }
+      case 'weekday': {
+        const { weekday } = anyTriggerType;
+        if (weekday < 1 || weekday > 7) {
+          throw new RangeError(
+            `The weekday parameter needs to be between 1 and 7. Found: ${weekday}`
+          );
+        }
+        break;
+      }
+      case 'hour': {
+        const { hour } = anyTriggerType;
+        if (hour < 0 || hour > 23) {
+          throw new RangeError(`The hour parameter needs to be between 0 and 23. Found: ${hour}`);
+        }
+        break;
+      }
+      case 'minute': {
+        const { minute } = anyTriggerType;
+        if (minute < 0 || minute > 59) {
+          throw new RangeError(
+            `The minute parameter needs to be between 0 and 59. Found: ${minute}`
+          );
+        }
+        break;
+      }
+    }
+  });
+}
+
+/**
+ * Determines the number of days in the given month (or January if omitted).
+ * If year is specified, it will include leap year logic, else it will always assume a leap year
+ */
+function daysInMonth(month: number = 0, year?: number) {
+  return new Date(year ?? 2000, month + 1, 0).getDate();
+}

package/src/setBadgeCountAsync.ts

@@ -0,0 +1,32 @@
+import { UnavailabilityError, Platform } from 'expo-modules-core';
+
+import BadgeModule from './BadgeModule';
+import { WebSetBadgeCountOptions } from './BadgeModule.types';
+
+export interface SetBadgeCountOptions {
+  /**
+   * A configuration object described [in the `badgin` documentation](https://github.com/jaulz/badgin#options).
+   */
+  web?: WebSetBadgeCountOptions;
+}
+
+/**
+ * Sets the badge of the app's icon to the specified number. Setting it to `0` clears the badge. On iOS, this method requires that you have requested
+ * the user's permission for `allowBadge` via [`requestPermissionsAsync`](#notificationsrequestpermissionsasyncpermissions),
+ * otherwise it will automatically return `false`.
+ * > **Note:** Not all Android launchers support application badges. If the launcher does not support icon badges, the method will resolve to `false`.
+ * @param badgeCount The count which should appear on the badge. A value of `0` will clear the badge.
+ * @param options An object of options configuring behavior applied in Web environment.
+ * @return It returns a Promise resolving to a boolean representing whether the setting of the badge succeeded.
+ * @header badge
+ */
+export default async function setBadgeCountAsync(
+  badgeCount: number,
+  options?: SetBadgeCountOptions
+): Promise<boolean> {
+  if (!BadgeModule.setBadgeCountAsync) {
+    throw new UnavailabilityError('ExpoNotifications', 'setBadgeCountAsync');
+  }
+
+  return await BadgeModule.setBadgeCountAsync(badgeCount, options?.[Platform.OS]);
+}

package/src/setNotificationCategoryAsync.ts

@@ -0,0 +1,37 @@
+import { UnavailabilityError } from 'expo-modules-core';
+
+// @amznmod_react - Changed .native import to one without postfix
+import NotificationCategoriesModule from './NotificationCategoriesModule';
+import {
+  NotificationCategory,
+  NotificationAction,
+  NotificationCategoryOptions,
+} from './Notifications.types';
+
+/**
+ * Sets the new notification category.
+ * @param identifier A string to associate as the ID of this category. You will pass this string in as the `categoryIdentifier`
+ * in your [`NotificationContent`](#notificationcontent) to associate a notification with this category.
+ * > Don't use the characters `:` or `-` in your category identifier. If you do, categories might not work as expected.
+ * @param actions An array of [`NotificationAction`s](#notificationaction), which describe the actions associated with this category.
+ * @param options An optional object of additional configuration options for your category.
+ * @return A Promise which resolves to the category you just have created.
+ * @platform android
+ * @platform ios
+ * @header categories
+ */
+export default async function setNotificationCategoryAsync(
+  identifier: string,
+  actions: NotificationAction[],
+  options?: NotificationCategoryOptions
+): Promise<NotificationCategory> {
+  if (!NotificationCategoriesModule.setNotificationCategoryAsync) {
+    throw new UnavailabilityError('Notifications', 'setNotificationCategoryAsync');
+  }
+
+  return await NotificationCategoriesModule.setNotificationCategoryAsync(
+    identifier,
+    actions,
+    options
+  );
+}

package/src/setNotificationChannelAsync.android.ts

@@ -0,0 +1,15 @@
+import { UnavailabilityError } from 'expo-modules-core';
+
+import NotificationChannelManager from './NotificationChannelManager';
+import { NotificationChannelInput, NotificationChannel } from './NotificationChannelManager.types';
+
+export default async function setNotificationChannelAsync(
+  channelId: string,
+  channel: NotificationChannelInput
+): Promise<NotificationChannel | null> {
+  if (!NotificationChannelManager.setNotificationChannelAsync) {
+    throw new UnavailabilityError('Notifications', 'setNotificationChannelAsync');
+  }
+
+  return await NotificationChannelManager.setNotificationChannelAsync(channelId, channel);
+}

package/src/setNotificationChannelAsync.ts

@@ -0,0 +1,28 @@
+import { NotificationChannel, NotificationChannelInput } from './NotificationChannelManager.types';
+
+/**
+ * Assigns the channel configuration to a channel of a specified name (creating it if need be).
+ * This method lets you assign given notification channel to a notification channel group.
+ *
+ * > **Note:** For some settings to be applied on all Android versions, it may be necessary to duplicate the configuration across both
+ * > a single notification and its respective notification channel.
+ *
+ * For example, for a notification to play a custom sound on Android versions **below** 8.0,
+ * the custom notification sound has to be set on the notification (through the [`NotificationContentInput`](#notificationcontentinput)),
+ * and for the custom sound to play on Android versions **above** 8.0, the relevant notification channel must have the custom sound configured
+ * (through the [`NotificationChannelInput`](#notificationchannelinput)). For more information,
+ * see [Set custom notification sounds on Android](#set-custom-notification-sounds).
+ * @param channelId The channel identifier.
+ * @param channel Object representing the channel's configuration.
+ * @return A Promise which resolving to the object (of type [`NotificationChannel`](#notificationchannel)) describing the modified channel
+ * or to `null` if the platform does not support notification channels.
+ * @platform android
+ * @header channels
+ */
+export default async function setNotificationChannelAsync(
+  channelId: string,
+  channel: NotificationChannelInput
+): Promise<NotificationChannel | null> {
+  console.debug('Notification channels feature is only supported on Android.');
+  return null;
+}

package/src/setNotificationChannelGroupAsync.android.ts

@@ -0,0 +1,18 @@
+import { UnavailabilityError } from 'expo-modules-core';
+
+import NotificationChannelGroupManager from './NotificationChannelGroupManager';
+import {
+  NotificationChannelGroup,
+  NotificationChannelGroupInput,
+} from './NotificationChannelGroupManager.types';
+
+export default async function setNotificationChannelGroupAsync(
+  groupId: string,
+  group: NotificationChannelGroupInput
+): Promise<NotificationChannelGroup | null> {
+  if (!NotificationChannelGroupManager.setNotificationChannelGroupAsync) {
+    throw new UnavailabilityError('Notifications', 'setNotificationChannelGroupAsync');
+  }
+
+  return await NotificationChannelGroupManager.setNotificationChannelGroupAsync(groupId, group);
+}

package/src/setNotificationChannelGroupAsync.ts

@@ -0,0 +1,21 @@
+import {
+  NotificationChannelGroup,
+  NotificationChannelGroupInput,
+} from './NotificationChannelGroupManager.types';
+
+/**
+ * Assigns the channel group configuration to a channel group of a specified name (creating it if need be).
+ * @param groupId The channel group's identifier.
+ * @param group Object representing the channel group configuration.
+ * @return A `Promise` resolving to the object (of type [`NotificationChannelGroup`](#notificationchannelgroup))
+ * describing the modified channel group or to `null` if the platform does not support notification channels.
+ * @platform android
+ * @header channels
+ */
+export default async function setNotificationChannelGroupAsync(
+  groupId: string,
+  group: NotificationChannelGroupInput
+): Promise<NotificationChannelGroup | null> {
+  console.debug('Notification channels feature is only supported on Android.');
+  return null;
+}

package/src/unregisterForNotificationsAsync.ts

@@ -0,0 +1,11 @@
+import { UnavailabilityError } from 'expo-modules-core';
+
+import PushTokenManager from './PushTokenManager';
+
+// @docsMissing
+export default async function unregisterForNotificationsAsync(): Promise<void> {
+  if (!PushTokenManager.unregisterForNotificationsAsync) {
+    throw new UnavailabilityError('ExpoNotifications', 'unregisterForNotificationsAsync');
+  }
+  return PushTokenManager.unregisterForNotificationsAsync();
+}

package/src/unregisterTaskAsync.ts

@@ -0,0 +1,17 @@
+import { UnavailabilityError } from 'expo-modules-core';
+
+// @amznmod_react - Changed .native import to one without postfix
+import BackgroundNotificationTasksModule from './BackgroundNotificationTasksModule';
+
+/**
+ * Used to unregister tasks registered with `registerTaskAsync` method.
+ * @param taskName The string you passed to `registerTaskAsync` as the `taskName` parameter.
+ * @header inBackground
+ */
+export default async function unregisterTaskAsync(taskName: string): Promise<null> {
+  if (!BackgroundNotificationTasksModule.unregisterTaskAsync) {
+    throw new UnavailabilityError('Notifications', 'unregisterTaskAsync');
+  }
+
+  return await BackgroundNotificationTasksModule.unregisterTaskAsync(taskName);
+}

package/src/useLastNotificationResponse.ts

@@ -0,0 +1,70 @@
+import { useEffect, useLayoutEffect, useState } from 'react';
+
+import { NotificationResponse } from './Notifications.types';
+import { addNotificationResponseReceivedListener } from './NotificationsEmitter';
+import NotificationsEmitterModule from './NotificationsEmitterModule';
+
+/**
+ * A React hook always returns the notification response that was received most recently
+ * (a notification response designates an interaction with a notification, such as tapping on it).
+ *
+ * > If you don't want to use a hook, you can use `Notifications.getLastNotificationResponseAsync()` instead.
+ *
+ * @return The hook may return one of these three types/values:
+ * - `undefined` - until we're sure of what to return,
+ * - `null` - if no notification response has been received yet,
+ * - a [`NotificationResponse`](#notificationresponse) object - if a notification response was received.
+ *
+ * @example Responding to a notification tap by opening a URL that could be put into the notification's `data`
+ * (opening the URL is your responsibility and is not a part of the `expo-notifications` API):
+ * ```jsx
+ * import * as Notifications from '@amazon-devices/expo-notifications';
+ * import { Linking } from 'react-native';
+ *
+ * export default function App() {
+ *   const lastNotificationResponse = Notifications.useLastNotificationResponse();
+ *   React.useEffect(() => {
+ *     if (
+ *       lastNotificationResponse &&
+ *       lastNotificationResponse.notification.request.content.data.url &&
+ *       lastNotificationResponse.actionIdentifier === Notifications.DEFAULT_ACTION_IDENTIFIER
+ *     ) {
+ *       Linking.openURL(lastNotificationResponse.notification.request.content.data.url);
+ *     }
+ *   }, [lastNotificationResponse]);
+ *   return (
+ *     // Your app content
+ *   );
+ * }
+ * ```
+ * @header listen
+ */
+export default function useLastNotificationResponse() {
+  const [lastNotificationResponse, setLastNotificationResponse] = useState<
+    NotificationResponse | null | undefined
+  >(undefined);
+
+  // useLayoutEffect ensures the listener is registered as soon as possible
+  useLayoutEffect(() => {
+    const subscription = addNotificationResponseReceivedListener((response) => {
+      setLastNotificationResponse(response);
+    });
+    return () => {
+      subscription.remove();
+    };
+  }, []);
+
+  // On each mount of this hook we fetch last notification response
+  // from the native module which is an "always active listener"
+  // and always returns the most recent response.
+  useEffect(() => {
+    NotificationsEmitterModule.getLastNotificationResponseAsync?.().then((response) => {
+      // We only update the state with the resolved value if it's empty,
+      // because if it's not empty it must have been populated by the `useLayoutEffect`
+      // listener which returns "live" values.
+      setLastNotificationResponse((currentResponse) => currentResponse ?? response);
+    });
+  }, []);
+
+  return lastNotificationResponse;
+}

package/src/utils/keplerUuidUtils.ts

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+import { Uuid } from '../kepler';
+import * as NotificationManagerTypes from '../kepler/types/NotificationManagerTypes';
+
+export function stringifyNotificationUuid(uuid: NotificationManagerTypes.Uuid): string {
+  let idx = 0;
+  const base = 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX';
+
+  const numArray = uuid.bytes.map((b) => (b < 0 ? b + 256 : b));
+
+  return base.replace(/XX/g, () => numArray[idx++].toString(16).padStart(2, '0'));
+}
+
+export function parseNotificationUuid(uuidString: string): Uuid {
+  const base = uuidString.replace(/-/g, '').match(/.{1,2}/g);
+  if (base == null || base.length !== 16) {
+    throw new Error('Invalid UUID');
+  }
+
+  const bytes = base.map((n) => parseInt(n, 16)).map((n) => (n > 127 ? n - 256 : n));
+
+  return { bytes };
+}