@ammarahmed/notifee-react-native 7.3.0

package/src/validators/validateAndroidPressAction.ts

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited
+ */
+
+import { NotificationPressAction } from '../types/Notification';
+import { isObject, isString, isUndefined, isArray, isNumber } from '../utils';
+
+const LAUNCH_ACTIVITY_DEFAULT_VALUE = 'default';
+const PRESS_ACTION_DEFAULT_VALUE = 'default';
+
+export default function validateAndroidPressAction(
+  pressAction: NotificationPressAction,
+): NotificationPressAction {
+  if (!isObject(pressAction)) {
+    throw new Error("'pressAction' expected an object value.");
+  }
+
+  if (!isString(pressAction.id) || pressAction.id.length === 0) {
+    throw new Error("'id' expected a non-empty string value.");
+  }
+
+  const out: NotificationPressAction = {
+    id: pressAction.id,
+  };
+
+  if (!isUndefined(pressAction.launchActivity)) {
+    if (!isString(pressAction.launchActivity)) {
+      throw new Error("'launchActivity' expected a string value.");
+    }
+
+    out.launchActivity = pressAction.launchActivity;
+  } else if (pressAction.id === PRESS_ACTION_DEFAULT_VALUE) {
+    // Set default value for launchActivity
+    out.launchActivity = LAUNCH_ACTIVITY_DEFAULT_VALUE;
+  }
+
+  if (!isUndefined(pressAction.launchActivityFlags)) {
+    if (!isArray(pressAction.launchActivityFlags)) {
+      throw new Error(
+        "'launchActivityFlags' must be an array of `AndroidLaunchActivityFlag` values.",
+      );
+    }
+
+    // quick sanity check on first item only
+    if (pressAction.launchActivityFlags.length) {
+      if (!isNumber(pressAction.launchActivityFlags[0])) {
+        throw new Error(
+          "'launchActivityFlags' must be an array of `AndroidLaunchActivityFlag` values.",
+        );
+      }
+    }
+
+    out.launchActivityFlags = pressAction.launchActivityFlags;
+  }
+
+  if (!isUndefined(pressAction.mainComponent)) {
+    if (!isString(pressAction.mainComponent)) {
+      throw new Error("'mainComponent' expected a string value.");
+    }
+
+    out.mainComponent = pressAction.mainComponent;
+  }
+
+  return out;
+}

package/src/validators/validateAndroidStyle.ts

@@ -0,0 +1,315 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited
+ */
+import { Image } from 'react-native';
+import {
+  AndroidBigPictureStyle,
+  AndroidBigTextStyle,
+  AndroidInboxStyle,
+  AndroidMessagingStyle,
+  AndroidMessagingStyleMessage,
+  AndroidPerson,
+  AndroidStyle,
+} from '../types/NotificationAndroid';
+import { objectHasProperty, isArray, isBoolean, isNumber, isObject, isString } from '../utils';
+
+/**
+ * Validates a BigPictureStyle
+ */
+export function validateAndroidBigPictureStyle(
+  style: AndroidBigPictureStyle,
+): AndroidBigPictureStyle {
+  if (
+    (!isString(style.picture) && !isNumber(style.picture) && !isObject(style.picture)) ||
+    (isString(style.picture) && !style.picture.length)
+  ) {
+    throw new Error(
+      "'notification.android.style' BigPictureStyle: 'picture' expected a number or object created using the 'require()' method or a valid string URL.",
+    );
+  }
+
+  // Defaults
+  const out: AndroidBigPictureStyle = {
+    type: AndroidStyle.BIGPICTURE,
+    picture: style.picture,
+  };
+
+  if (isNumber(style.picture) || isObject(style.picture)) {
+    const image = Image.resolveAssetSource(style.picture);
+
+    out.picture = image.uri;
+  }
+
+  if (objectHasProperty(style, 'largeIcon')) {
+    if (
+      style.largeIcon !== null &&
+      !isString(style.largeIcon) &&
+      !isNumber(style.largeIcon) &&
+      !isObject(style.largeIcon)
+    ) {
+      throw new Error(
+        "'notification.android.style' BigPictureStyle: 'largeIcon' expected a React Native ImageResource value or a valid string URL.",
+      );
+    }
+    if (isNumber(style.largeIcon) || isObject(style.largeIcon)) {
+      const image = Image.resolveAssetSource(style.largeIcon);
+
+      out.largeIcon = image.uri;
+    } else {
+      out.largeIcon = style.largeIcon;
+    }
+  }
+
+  if (objectHasProperty(style, 'title')) {
+    if (!isString(style.title)) {
+      throw new Error(
+        "'notification.android.style' BigPictureStyle: 'title' expected a string value.",
+      );
+    }
+
+    out.title = style.title;
+  }
+
+  if (objectHasProperty(style, 'summary')) {
+    if (!isString(style.summary)) {
+      throw new Error(
+        "'notification.android.style' BigPictureStyle: 'summary' expected a string value.",
+      );
+    }
+
+    out.summary = style.summary;
+  }
+
+  return out;
+}
+
+/**
+ * Validates a BigTextStyle
+ */
+export function validateAndroidBigTextStyle(style: AndroidBigTextStyle): AndroidBigTextStyle {
+  if (!isString(style.text) || !style.text) {
+    throw new Error(
+      "'notification.android.style' BigTextStyle: 'text' expected a valid string value.",
+    );
+  }
+
+  // Defaults
+  const out: AndroidBigTextStyle = {
+    type: AndroidStyle.BIGTEXT,
+    text: style.text,
+  };
+
+  if (objectHasProperty(style, 'title')) {
+    if (!isString(style.title)) {
+      throw new Error(
+        "'notification.android.style' BigTextStyle: 'title' expected a string value.",
+      );
+    }
+
+    out.title = style.title;
+  }
+
+  if (objectHasProperty(style, 'summary')) {
+    if (!isString(style.summary)) {
+      throw new Error(
+        "'notification.android.style' BigTextStyle: 'summary' expected a string value.",
+      );
+    }
+
+    out.summary = style.summary;
+  }
+
+  return out;
+}
+
+/**
+ * Validates a InboxStyle
+ */
+export function validateAndroidInboxStyle(style: AndroidInboxStyle): AndroidInboxStyle {
+  if (!isArray(style.lines)) {
+    throw new Error("'notification.android.style' InboxStyle: 'lines' expected an array.");
+  }
+
+  for (let i = 0; i < style.lines.length; i++) {
+    const line = style.lines[i];
+
+    if (!isString(line)) {
+      throw new Error(
+        `'notification.android.style' InboxStyle: 'lines' expected a string value at array index ${i}.`,
+      );
+    }
+  }
+
+  const out: AndroidInboxStyle = {
+    type: AndroidStyle.INBOX,
+    lines: style.lines,
+  };
+
+  if (objectHasProperty(style, 'title')) {
+    if (!isString(style.title)) {
+      throw new Error("'notification.android.style' InboxStyle: 'title' expected a string value.");
+    }
+
+    out.title = style.title;
+  }
+
+  if (objectHasProperty(style, 'summary')) {
+    if (!isString(style.summary)) {
+      throw new Error(
+        "'notification.android.style' InboxStyle: 'summary' expected a string value.",
+      );
+    }
+
+    out.summary = style.summary;
+  }
+
+  return out;
+}
+
+/**
+ * Validates an AndroidPerson
+ */
+export function validateAndroidPerson(person: AndroidPerson): AndroidPerson {
+  if (!isString(person.name)) {
+    throw new Error("'person.name' expected a string value.");
+  }
+
+  const out: AndroidPerson = {
+    name: person.name,
+    bot: false,
+    important: false,
+  };
+
+  if (objectHasProperty(person, 'id')) {
+    if (!isString(person.id)) {
+      throw new Error("'person.id' expected a string value.");
+    }
+
+    out.id = person.id;
+  }
+
+  if (objectHasProperty(person, 'bot')) {
+    if (!isBoolean(person.bot)) {
+      throw new Error("'person.bot' expected a boolean value.");
+    }
+
+    out.bot = person.bot;
+  }
+
+  if (objectHasProperty(person, 'important')) {
+    if (!isBoolean(person.important)) {
+      throw new Error("'person.important' expected a boolean value.");
+    }
+
+    out.important = person.important;
+  }
+
+  if (objectHasProperty(person, 'icon')) {
+    if (!isString(person.icon)) {
+      throw new Error("'person.icon' expected a string value.");
+    }
+
+    out.icon = person.icon;
+  }
+
+  if (objectHasProperty(person, 'uri')) {
+    if (!isString(person.uri)) {
+      throw new Error("'person.uri' expected a string value.");
+    }
+
+    out.uri = person.uri;
+  }
+
+  return out;
+}
+
+export function validateAndroidMessagingStyleMessage(
+  message: AndroidMessagingStyleMessage,
+): AndroidMessagingStyleMessage {
+  //text, timestamp, person
+  if (!isString(message.text)) {
+    throw new Error("'message.text' expected a string value.");
+  }
+
+  if (!isNumber(message.timestamp)) {
+    throw new Error("'message.timestamp' expected a number value.");
+  }
+
+  const out: AndroidMessagingStyleMessage = {
+    text: message.text,
+    timestamp: message.timestamp,
+  };
+
+  if (objectHasProperty(message, 'person') && message.person !== undefined) {
+    try {
+      out.person = validateAndroidPerson(message.person);
+    } catch (e: any) {
+      throw new Error(`'message.person' is invalid. ${e.message}`);
+    }
+  }
+
+  return out;
+}
+
+/**
+ * Validates a MessagingStyle
+ */
+export function validateAndroidMessagingStyle(style: AndroidMessagingStyle): AndroidMessagingStyle {
+  if (!isObject(style.person)) {
+    throw new Error("'notification.android.style' MessagingStyle: 'person' an object value.");
+  }
+
+  let person;
+  const messages: AndroidMessagingStyleMessage[] = [];
+
+  try {
+    person = validateAndroidPerson(style.person);
+  } catch (e: any) {
+    throw new Error(`'notification.android.style' MessagingStyle: ${e.message}.`);
+  }
+
+  if (!isArray(style.messages)) {
+    throw new Error(
+      "'notification.android.style' MessagingStyle: 'messages' expected an array value.",
+    );
+  }
+
+  for (let i = 0; i < style.messages.length; i++) {
+    try {
+      messages.push(validateAndroidMessagingStyleMessage(style.messages[i]));
+    } catch (e: any) {
+      throw new Error(
+        `'notification.android.style' MessagingStyle: invalid message at index ${i}. ${e.message}`,
+      );
+    }
+  }
+
+  const out: AndroidMessagingStyle = {
+    type: AndroidStyle.MESSAGING,
+    person,
+    messages,
+    group: false,
+  };
+
+  if (objectHasProperty(style, 'title')) {
+    if (!isString(style.title)) {
+      throw new Error(
+        "'notification.android.style' MessagingStyle: 'title' expected a string value.",
+      );
+    }
+
+    out.title = style.title;
+  }
+
+  if (objectHasProperty(style, 'group')) {
+    if (!isBoolean(style.group)) {
+      throw new Error(
+        "'notification.android.style' MessagingStyle: 'group' expected a boolean value.",
+      );
+    }
+
+    out.group = style.group;
+  }
+
+  return out;
+}

package/src/validators/validateIOSAttachment.ts

@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited
+ */
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+import { Image } from 'react-native';
+
+import {
+  generateId,
+  isBoolean,
+  isNumber,
+  isObject,
+  isString,
+  isUndefined,
+  objectHasProperty,
+} from '../utils';
+import {
+  IOSAttachmentThumbnailClippingRect,
+  IOSNotificationAttachment,
+} from '../types/NotificationIOS';
+
+export default function validateIOSAttachment(
+  attachment: IOSNotificationAttachment,
+): IOSNotificationAttachment {
+  if (!isObject(attachment)) {
+    throw new Error("'attachment' expected an object value.");
+  }
+
+  if (
+    (!isString(attachment.url) && !isNumber(attachment.url) && !isObject(attachment.url)) ||
+    (isString(attachment.url) && !attachment.url.length)
+  ) {
+    throw new Error(
+      "'attachment.url' expected a React Native ImageResource value or a valid string URL.",
+    );
+  }
+
+  const out: IOSNotificationAttachment = {
+    url: attachment.url,
+    thumbnailHidden: false,
+  };
+
+  if (isNumber(attachment.url) || isObject(attachment.url)) {
+    const image = Image.resolveAssetSource(attachment.url);
+    out.url = image.uri;
+  }
+
+  if (objectHasProperty(attachment, 'id') && !isUndefined(attachment.id)) {
+    if (!isString(attachment.id)) {
+      throw new Error("'attachment.id' expected a string value.");
+    }
+    out.id = attachment.id;
+  } else {
+    out.id = generateId();
+  }
+
+  if (objectHasProperty(attachment, 'typeHint') && !isUndefined(attachment.typeHint)) {
+    if (!isString(attachment.typeHint)) {
+      throw new Error("'attachment.typeHint' expected a string value.");
+    }
+
+    out.typeHint = attachment.typeHint;
+  }
+
+  if (
+    objectHasProperty(attachment, 'thumbnailClippingRect') &&
+    !isUndefined(attachment.thumbnailClippingRect)
+  ) {
+    try {
+      out.thumbnailClippingRect = validateThumbnailClippingRect(attachment.thumbnailClippingRect);
+    } catch (e: any) {
+      throw new Error(`'attachment.thumbnailClippingRect' is invalid. ${e.message}`);
+    }
+  }
+
+  if (
+    objectHasProperty(attachment, 'thumbnailHidden') &&
+    !isUndefined(attachment.thumbnailHidden)
+  ) {
+    if (!isBoolean(attachment.thumbnailHidden)) {
+      throw new Error("'attachment.thumbnailHidden' must be a boolean value if specified.");
+    }
+
+    out.thumbnailHidden = attachment.thumbnailHidden;
+  }
+
+  if (objectHasProperty(attachment, 'thumbnailTime') && !isUndefined(attachment.thumbnailTime)) {
+    if (!isNumber(attachment.thumbnailTime)) {
+      throw new Error("'attachment.thumbnailTime' must be a number value if specified.");
+    } else {
+      out.thumbnailTime = attachment.thumbnailTime;
+    }
+  }
+
+  return out;
+}
+
+/**
+ * Validates a ThumbnailClippingRect
+ */
+export function validateThumbnailClippingRect(
+  thumbnailClippingRect: IOSAttachmentThumbnailClippingRect,
+): IOSAttachmentThumbnailClippingRect {
+  if (objectHasProperty(thumbnailClippingRect, 'x')) {
+    if (!isNumber(thumbnailClippingRect.x)) {
+      throw new Error("'thumbnailClippingRect.x' expected a number value.");
+    }
+  }
+
+  if (objectHasProperty(thumbnailClippingRect, 'y')) {
+    if (!isNumber(thumbnailClippingRect.y)) {
+      throw new Error("'thumbnailClippingRect.y' expected a number value.");
+    }
+  }
+
+  if (objectHasProperty(thumbnailClippingRect, 'width')) {
+    if (!isNumber(thumbnailClippingRect.width)) {
+      throw new Error("'thumbnailClippingRect.width' expected a number value.");
+    }
+  }
+
+  if (objectHasProperty(thumbnailClippingRect, 'height')) {
+    if (!isNumber(thumbnailClippingRect.height)) {
+      throw new Error("'thumbnailClippingRect.height' expected a number value.");
+    }
+  }
+
+  // Defaults
+  return {
+    x: thumbnailClippingRect.x,
+    y: thumbnailClippingRect.y,
+    height: thumbnailClippingRect.height,
+    width: thumbnailClippingRect.width,
+  };
+}

package/src/validators/validateIOSCategory.ts

@@ -0,0 +1,150 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited
+ */
+import {
+  IOSIntentIdentifier,
+  IOSNotificationCategory,
+  IOSNotificationCategoryAction,
+} from '../types/NotificationIOS';
+import { objectHasProperty, isArray, isObject, isString, isBoolean } from '../utils';
+import validateIOSCategoryAction from './validateIOSCategoryAction';
+
+export default function validateIOSCategory(
+  category: IOSNotificationCategory,
+): IOSNotificationCategory {
+  if (!isObject(category)) {
+    throw new Error("'category' expected an object value.");
+  }
+
+  /**
+   * id
+   */
+  if (!isString(category.id)) {
+    throw new Error("'category.id' expected a string value.");
+  }
+
+  // empty check
+  if (!category.id) {
+    throw new Error("'category.id' expected a valid string id.");
+  }
+
+  const out: IOSNotificationCategory = {
+    id: category.id,
+    allowInCarPlay: false,
+    allowAnnouncement: false,
+    hiddenPreviewsShowTitle: false,
+    hiddenPreviewsShowSubtitle: false,
+  };
+
+  /**
+   * summaryFormat
+   */
+  if (objectHasProperty(category, 'summaryFormat')) {
+    if (!isString(category.summaryFormat)) {
+      throw new Error("'category.summaryFormat' expected a string value.");
+    }
+
+    out.summaryFormat = category.summaryFormat;
+  }
+
+  /**
+   * allowInCarPlay
+   */
+  if (objectHasProperty(category, 'allowInCarPlay')) {
+    if (!isBoolean(category.allowInCarPlay)) {
+      throw new Error("'category.allowInCarPlay' expected a boolean value.");
+    }
+
+    out.allowInCarPlay = category.allowInCarPlay;
+  }
+
+  /**
+   * allowAnnouncement
+   */
+  if (objectHasProperty(category, 'allowAnnouncement')) {
+    if (!isBoolean(category.allowAnnouncement)) {
+      throw new Error("'category.allowAnnouncement' expected a boolean value.");
+    }
+
+    out.allowAnnouncement = category.allowAnnouncement;
+  }
+
+  /**
+   * hiddenPreviewsShowTitle
+   */
+  if (objectHasProperty(category, 'hiddenPreviewsShowTitle')) {
+    if (!isBoolean(category.hiddenPreviewsShowTitle)) {
+      throw new Error("'category.hiddenPreviewsShowTitle' expected a boolean value.");
+    }
+
+    out.hiddenPreviewsShowTitle = category.hiddenPreviewsShowTitle;
+  }
+
+  /**
+   * hiddenPreviewsShowSubtitle
+   */
+  if (objectHasProperty(category, 'hiddenPreviewsShowSubtitle')) {
+    if (!isBoolean(category.hiddenPreviewsShowSubtitle)) {
+      throw new Error("'category.hiddenPreviewsShowSubtitle' expected a boolean value.");
+    }
+
+    out.hiddenPreviewsShowSubtitle = category.hiddenPreviewsShowSubtitle;
+  }
+
+  /**
+   * summaryFormat
+   */
+  if (objectHasProperty(category, 'hiddenPreviewsBodyPlaceholder')) {
+    if (!isString(category.hiddenPreviewsBodyPlaceholder)) {
+      throw new Error("'category.hiddenPreviewsBodyPlaceholder' expected a string value.");
+    }
+
+    out.hiddenPreviewsBodyPlaceholder = category.hiddenPreviewsBodyPlaceholder;
+  }
+
+  /**
+   * intentIdentifiers
+   */
+  if (objectHasProperty(category, 'intentIdentifiers')) {
+    if (!isArray(category.intentIdentifiers)) {
+      throw new Error("'category.intentIdentifiers' expected an array value.");
+    }
+
+    const identifiers = Object.values(IOSIntentIdentifier);
+
+    for (let i = 0; i < category.intentIdentifiers.length; i++) {
+      const intentIdentifier = category.intentIdentifiers[i];
+
+      if (!identifiers.includes(intentIdentifier)) {
+        throw new Error(
+          `'category.intentIdentifiers' unexpected intentIdentifier "${intentIdentifier}" at array index "${i}".`,
+        );
+      }
+    }
+
+    out.intentIdentifiers = category.intentIdentifiers;
+  }
+
+  /**
+   * actions
+   */
+  if (objectHasProperty(category, 'actions')) {
+    if (!isArray(category.actions)) {
+      throw new Error("'category.actions' expected an array value.");
+    }
+
+    const actions: IOSNotificationCategoryAction[] = [];
+
+    for (let i = 0; i < category.actions.length; i++) {
+      try {
+        actions[i] = validateIOSCategoryAction(category.actions[i]);
+      } catch (e) {
+        throw new Error(`'category.actions' invalid action at index "${i}". ${e}`);
+      }
+    }
+
+    out.actions = actions;
+  }
+
+  return out;
+}