@ammarahmed/notifee-react-native 7.3.0

package/src/validators/validateAndroidChannel.ts

@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited
+ */
+
+import { objectHasProperty, isArray, isBoolean, isObject, isString } from '../utils';
+import { isValidColor, isValidVibratePattern } from './validate';
+
+import { AndroidImportance } from '../types/NotificationAndroid';
+import { AndroidChannel, AndroidVisibility } from '../types/NotificationAndroid';
+
+export default function validateAndroidChannel(channel: AndroidChannel): AndroidChannel {
+  if (!isObject(channel)) {
+    throw new Error("'channel' expected an object value.");
+  }
+
+  /**
+   * id
+   */
+  if (!isString(channel.id)) {
+    throw new Error("'channel.id' expected a string value.");
+  }
+
+  // empty check
+  if (!channel.id) {
+    throw new Error("'channel.id' expected a valid string id.");
+  }
+
+  /**
+   * name
+   */
+  if (!isString(channel.name)) {
+    throw new Error("'channel.name' expected a string value.");
+  }
+
+  // empty check
+  if (!channel.name) {
+    throw new Error("'channel.name' expected a valid channel name.");
+  }
+
+  /**
+   * Defaults
+   */
+  const out: AndroidChannel = {
+    id: channel.id,
+    name: channel.name,
+    bypassDnd: false,
+    lights: true,
+    vibration: true,
+    badge: true,
+    importance: AndroidImportance.DEFAULT,
+    visibility: AndroidVisibility.PRIVATE,
+  };
+
+  /**
+   * badge
+   */
+  if (objectHasProperty(channel, 'badge')) {
+    if (!isBoolean(channel.badge)) {
+      throw new Error("'channel.badge' expected a boolean value.");
+    }
+
+    out.badge = channel.badge;
+  }
+
+  /**
+   * bypassDnd
+   */
+  if (objectHasProperty(channel, 'bypassDnd')) {
+    if (!isBoolean(channel.bypassDnd)) {
+      throw new Error("'channel.bypassDnd' expected a boolean value.");
+    }
+
+    out.bypassDnd = channel.bypassDnd;
+  }
+
+  /**
+   * description
+   */
+  if (objectHasProperty(channel, 'description')) {
+    if (!isString(channel.description)) {
+      throw new Error("'channel.description' expected a string value.");
+    }
+
+    out.description = channel.description;
+  }
+
+  /**
+   * lights
+   */
+  if (objectHasProperty(channel, 'lights')) {
+    if (!isBoolean(channel.lights)) {
+      throw new Error("'channel.lights' expected a boolean value.");
+    }
+
+    out.lights = channel.lights;
+  }
+
+  /**
+   * vibration
+   */
+  if (objectHasProperty(channel, 'vibration')) {
+    if (!isBoolean(channel.vibration)) {
+      throw new Error("'channel.vibration' expected a boolean value.");
+    }
+
+    out.vibration = channel.vibration;
+  }
+
+  /**
+   * groupId
+   */
+  if (objectHasProperty(channel, 'groupId')) {
+    if (!isString(channel.groupId)) {
+      throw new Error("'channel.groupId' expected a string value.");
+    }
+
+    out.groupId = channel.groupId;
+  }
+
+  /**
+   * importance
+   */
+  if (objectHasProperty(channel, 'importance') && channel.importance !== undefined) {
+    if (!Object.values(AndroidImportance).includes(channel.importance)) {
+      throw new Error("'channel.importance' expected an Importance value.");
+    }
+
+    out.importance = channel.importance;
+  }
+
+  /**
+   * lightColor
+   */
+  if (objectHasProperty(channel, 'lightColor') && channel.lightColor !== undefined) {
+    if (!isString(channel.lightColor)) {
+      throw new Error("'channel.lightColor' expected a string value.");
+    }
+
+    if (!isValidColor(channel.lightColor)) {
+      throw new Error(
+        "'channel.lightColor' invalid color. Expected an AndroidColor or hexadecimal string value",
+      );
+    }
+
+    out.lightColor = channel.lightColor;
+  }
+
+  /**
+   * visibility
+   */
+  if (objectHasProperty(channel, 'visibility') && channel.visibility !== undefined) {
+    if (!Object.values(AndroidVisibility).includes(channel.visibility)) {
+      throw new Error("'channel.visibility' expected visibility to be an AndroidVisibility value.");
+    }
+
+    out.visibility = channel.visibility;
+  }
+
+  /**
+   * sound
+   */
+  if (objectHasProperty(channel, 'sound') && channel.sound !== undefined) {
+    if (!isString(channel.sound)) {
+      throw new Error("'channel.sound' expected a string value.");
+    }
+
+    out.sound = channel.sound;
+  }
+
+  /**
+   * vibrationPattern
+   */
+  if (objectHasProperty(channel, 'vibrationPattern') && channel.vibrationPattern !== undefined) {
+    if (!isArray(channel.vibrationPattern)) {
+      throw new Error("'channel.vibrationPattern' expected an array.");
+    }
+
+    if (!isValidVibratePattern(channel.vibrationPattern)) {
+      throw new Error(
+        "'channel.vibrationPattern' expected an array containing an even number of positive values.",
+      );
+    }
+
+    out.vibrationPattern = channel.vibrationPattern;
+  }
+
+  return out;
+}

package/src/validators/validateAndroidChannelGroup.ts

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited
+ */
+
+import { objectHasProperty, isObject, isString } from '../utils';
+import { AndroidChannelGroup } from '../types/NotificationAndroid';
+
+export default function validateAndroidChannelGroup(
+  group: AndroidChannelGroup,
+): AndroidChannelGroup {
+  if (!isObject(group)) {
+    throw new Error("'group' expected an object value.");
+  }
+
+  /**
+   * id
+   */
+  if (!isString(group.id) || !group.id) {
+    throw new Error("'group.id' expected a string value.");
+  }
+
+  /**
+   * name
+   */
+  if (!isString(group.name) || !group.name) {
+    throw new Error("'group.name' expected a string value.");
+  }
+
+  /**
+   * Defaults
+   */
+  const out: AndroidChannelGroup = {
+    id: group.id,
+    name: group.name,
+  };
+
+  /**
+   * description
+   */
+  if (objectHasProperty(group, 'description')) {
+    if (!isString(group.description)) {
+      throw new Error("'group.description' expected a string value.");
+    }
+
+    out.description = group.description;
+  }
+
+  return out;
+}

package/src/validators/validateAndroidFullScreenAction.ts

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

package/src/validators/validateAndroidInput.ts

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited
+ */
+
+import { AndroidInput } from '../types/NotificationAndroid';
+import { objectHasProperty, isArrayOfStrings, isBoolean, isString } from '../utils';
+
+export default function validateAndroidInput(input?: AndroidInput): AndroidInput {
+  const out: AndroidInput = {
+    allowFreeFormInput: true,
+    allowGeneratedReplies: true,
+  };
+
+  if (!input) {
+    return out;
+  }
+
+  if (objectHasProperty(input, 'allowFreeFormInput')) {
+    if (!isBoolean(input.allowFreeFormInput)) {
+      throw new Error("'input.allowFreeFormInput' expected a boolean value.");
+    }
+
+    out.allowFreeFormInput = input.allowFreeFormInput;
+  }
+
+  if (objectHasProperty(input, 'allowGeneratedReplies')) {
+    if (!isBoolean(input.allowGeneratedReplies)) {
+      throw new Error("'input.allowGeneratedReplies' expected a boolean value.");
+    }
+
+    out.allowGeneratedReplies = input.allowGeneratedReplies;
+  }
+
+  if (!out.allowFreeFormInput && (!input.choices || input.choices.length === 0)) {
+    throw new Error("'input.allowFreeFormInput' when false, you must provide at least one choice.");
+  }
+
+  if (objectHasProperty(input, 'choices')) {
+    if (!isArrayOfStrings(input.choices) || input.choices.length === 0) {
+      throw new Error("'input.choices' expected an array of string values.");
+    }
+
+    out.choices = input.choices;
+  }
+
+  if (objectHasProperty(input, 'editableChoices')) {
+    if (!isBoolean(input.editableChoices)) {
+      throw new Error("'input.editableChoices' expected a boolean value.");
+    }
+
+    out.editableChoices = input.editableChoices;
+  }
+
+  if (objectHasProperty(input, 'placeholder')) {
+    if (!isString(input.placeholder)) {
+      throw new Error("'input.placeholder' expected a string value.");
+    }
+
+    out.placeholder = input.placeholder;
+  }
+
+  if (out.editableChoices && !out.allowFreeFormInput) {
+    throw new Error("'input.editableChoices' when true, allowFreeFormInput must also be true.");
+  }
+
+  return out;
+}