@ammarahmed/notifee-react-native 7.3.0

package/src/types/PowerManagerInfo.ts

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited.
+ */
+
+/**
+ * The interface that represents the information returned from `getPowerManagerInfo()`.
+ *
+ * View the [Background Restrictions](/react-native/docs/android/background-restrictions) documentation to learn more.
+ *
+ * @platform android
+ */
+export interface PowerManagerInfo {
+  /**
+   * The device manufacturer.
+   *
+   * For example, Samsung.
+   */
+  manufacturer?: string;
+
+  /**
+   * The device model.
+   *
+   * For example, Galaxy S8
+   */
+  model?: string;
+
+  /**
+   * The Android version
+   *
+   * For example, Android 10
+   */
+  version?: string;
+
+  /**
+   * The activity that the user will be navigated to if `openPowerManagerSettings()` is called.
+   *
+   * Use this as an indicator of what steps the user may have to perform,
+   * in-order to prevent your app from being killed.
+   *
+   * If no activity can be found, value will be null.
+   */
+  activity?: string | null;
+}

package/src/types/Trigger.ts

@@ -0,0 +1,118 @@
+/**
+ * Interface for building a trigger with a timestamp.
+ *
+ * View the [Triggers](/react-native/docs/triggers) documentation to learn more.
+ */
+export interface TimestampTrigger {
+  /**
+   * Constant enum value used to identify the trigger type.
+   */
+  type: TriggerType.TIMESTAMP;
+  /**
+   * The timestamp when the notification should first be shown, in milliseconds since 1970.
+   */
+  timestamp: number;
+
+  /**
+   * The frequency at which the trigger repeats.
+   * If unset, the notification will only be displayed once.
+   *
+   * For example:
+   *  if set to `RepeatFrequency.HOURLY`, the notification will repeat every hour from the timestamp specified.
+   *  if set to `RepeatFrequency.DAILY`, the notification will repeat every day from the timestamp specified.
+   *  if set to `RepeatFrequency.WEEKLY`, the notification will repeat every week from the timestamp specified.
+   */
+  repeatFrequency?: RepeatFrequency;
+
+  /**
+   * Choose to schedule your trigger notification with Android's AlarmManager API.
+   *
+   * By default, trigger notifications are created with Android's WorkManager API.
+   *
+   * @platform android
+   */
+  alarmManager?: boolean | TimestampTriggerAlarmManager | undefined;
+}
+
+/**
+ * Interface to specify additional options for the AlarmManager which can be used with `TimestampTrigger.alarmManager`.
+ *
+ * View the [Triggers](/react-native/docs/triggers) documentation to learn more.
+ *
+ * @platform android
+ */
+export interface TimestampTriggerAlarmManager {
+  /**
+   * Sets whether your trigger notification should be displayed even when the system is in low-power idle modes.
+   *
+   * Defaults to `false`.
+   */
+  allowWhileIdle?: boolean;
+}
+
+/**
+ * An interface representing the different frequencies which can be used with `TimestampTrigger.repeatFrequency`.
+ *
+ * View the [Triggers](/react-native/docs/triggers) documentation to learn more.
+ */
+export enum RepeatFrequency {
+  NONE = -1,
+  HOURLY = 0,
+  DAILY = 1,
+  WEEKLY = 2,
+  MONTHLY = 3,
+}
+
+/**
+ * Interface for building a trigger that repeats at a specified interval.
+ *
+ * View the [Triggers](/react-native/docs/triggers) documentation to learn more.
+ */
+export interface IntervalTrigger {
+  /**
+   * Constant enum value used to identify the trigger type.
+   */
+  type: TriggerType.INTERVAL;
+
+  /**
+   * How frequently the notification should be repeated.
+   *
+   * For example, if set to 30, the notification will be displayed every 30 minutes.
+   *
+   * Must be set to a minimum of 15 minutes.
+   */
+  interval: number;
+
+  /**
+   * The unit of time that the `interval` is measured in.
+   *
+   * For example, if set to `TimeUnit.DAYS` and repeat interval is set to 3, the notification will repeat every 3 days.
+   *
+   * Defaults to `TimeUnit.SECONDS`
+   */
+  timeUnit?: TimeUnit | TimeUnit.SECONDS;
+}
+
+/**
+ * An interface representing the different units of time which can be used with `IntervalTrigger.timeUnit`.
+ *
+ * View the [Triggers](/react-native/docs/triggers) documentation to learn more.
+ */
+export enum TimeUnit {
+  SECONDS = 'SECONDS',
+  MINUTES = 'MINUTES',
+  HOURS = 'HOURS',
+  DAYS = 'DAYS',
+}
+
+/**
+ * Available Trigger Types.
+ *
+ * View the [Triggers](/react-native/docs/triggers) documentation to learn more with example usage.
+ */
+export enum TriggerType {
+  TIMESTAMP = 0,
+  INTERVAL = 1,
+}
+
+export declare type Trigger = TimestampTrigger | IntervalTrigger;

package/src/utils/id.ts

@@ -0,0 +1,13 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited
+ */
+
+const CHARACTERS = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+
+export function generateId(): string {
+  let newId = '';
+  for (let i = 0; i < 20; i++) {
+    newId += CHARACTERS.charAt(Math.floor(Math.random() * CHARACTERS.length));
+  }
+  return newId;
+}

package/src/utils/index.ts

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited
+ */
+
+import { Platform } from 'react-native';
+
+export * from './id';
+export * from './validate';
+
+/* eslint-disable-next-line @typescript-eslint/ban-types */
+export function isError(value: object): boolean {
+  if (Object.prototype.toString.call(value) === '[object Error]') {
+    return true;
+  }
+
+  return value instanceof Error;
+}
+
+export function objectHasProperty<T>(
+  target: T,
+  property: string | number | symbol,
+): property is keyof T {
+  return Object.hasOwnProperty.call(target, property);
+}
+
+export const isIOS = Platform.OS === 'ios';
+
+export const isAndroid = Platform.OS === 'android';
+
+export const isWeb = Platform.OS === 'web';
+
+export function noop(): void {
+  // noop-🐈
+}
+export const kReactNativeNotifeeForegroundServiceHeadlessTask =
+  'app.notifee.foreground-service-headless-task';
+
+export const kReactNativeNotifeeNotificationEvent = 'app.notifee.notification-event';
+
+export const kReactNativeNotifeeNotificationBackgroundEvent =
+  'app.notifee.notification-event-background';
+
+export enum NotificationType {
+  ALL = 0,
+  DISPLAYED = 1,
+  TRIGGER = 2,
+}

package/src/utils/validate.ts

@@ -0,0 +1,92 @@
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+/* eslint-disable @typescript-eslint/ban-types */
+/*
+ * Copyright (c) 2016-present Invertase Limited
+ */
+export function isNull(value: any): value is null {
+  return value === null;
+}
+
+export function isObject(value: any): value is object {
+  return value ? typeof value === 'object' && !Array.isArray(value) && !isNull(value) : false;
+}
+
+export function isFunction(value: any): value is Function {
+  return value ? typeof value === 'function' : false;
+}
+
+export function isString(value: any): value is string {
+  return typeof value === 'string';
+}
+
+export function isNumber(value: any): value is number {
+  return typeof value === 'number';
+}
+
+export function isBoolean(value: any): value is boolean {
+  return typeof value === 'boolean';
+}
+
+export function isArray(value: any): value is Array<any> {
+  return Array.isArray(value);
+}
+
+export function isArrayOfStrings(value: any): value is Array<string> {
+  if (!isArray(value)) return false;
+  for (let i = 0; i < value.length; i++) {
+    if (!isString(value[i])) return false;
+  }
+  return true;
+}
+
+export function isUndefined(value: any): value is undefined {
+  return value === undefined;
+}
+
+export function objectKeyValuesAreStrings(value: object): value is { [key: string]: string } {
+  if (!isObject(value)) {
+    return false;
+  }
+
+  const entries = Object.entries(value);
+
+  for (let i = 0; i < entries.length; i++) {
+    const [key, entryValue] = entries[i];
+    if (!isString(key) || !isString(entryValue)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * /^[a-zA-Z0-9_]+$/
+ *
+ * @param value
+ * @returns {boolean}
+ */
+const AlphaNumericUnderscore = /^[a-zA-Z0-9_]+$/;
+
+export function isAlphaNumericUnderscore(value: string): boolean {
+  return AlphaNumericUnderscore.test(value);
+}
+
+/**
+ * URL test
+ * @param url
+ * @returns {boolean}
+ */
+const IS_VALID_URL_REGEX = /^(http|https):\/\/[^ "]+$/;
+
+export function isValidUrl(url: string): boolean {
+  return IS_VALID_URL_REGEX.test(url);
+}
+
+export function isValidEnum(value: any, enumType: Record<string, any>): boolean {
+  if (!Object.values(enumType).includes(value)) {
+    return false;
+  }
+
+  return true;
+}

package/src/validators/iosCommunicationInfo/validateIOSCommunicationInfo.ts

@@ -0,0 +1,45 @@
+import { IOSCommunicationInfo } from '../../types/NotificationIOS';
+import { isObject, isString } from '../../utils';
+import validateIOSCommunicationInfoPerson from './validateIOSCommunicationInfoPerson';
+
+export default function validateIOSCommunicationInfo(
+  communicationInfo: IOSCommunicationInfo,
+): IOSCommunicationInfo {
+  if (!isObject(communicationInfo)) {
+    throw new Error('expected an object.');
+  }
+
+  if (
+    !isString(communicationInfo.conversationId) ||
+    communicationInfo.conversationId.length === 0
+  ) {
+    throw new Error("'conversationId' expected a valid string value.");
+  }
+
+  if (!communicationInfo.sender || !isObject(communicationInfo.sender)) {
+    throw new Error("'sender' expected a valid object value.");
+  }
+
+  let sender;
+
+  try {
+    sender = validateIOSCommunicationInfoPerson(communicationInfo.sender);
+  } catch (e: any) {
+    throw new Error(`'sender' ${e.message}.`);
+  }
+
+  const out: IOSCommunicationInfo = {
+    conversationId: communicationInfo.conversationId,
+    sender,
+  };
+
+  if (communicationInfo.body) {
+    if (!isString(communicationInfo.body)) {
+      throw new Error("'body' expected a valid string value.");
+    }
+
+    out.body = communicationInfo.body;
+  }
+
+  return out;
+}

package/src/validators/iosCommunicationInfo/validateIOSCommunicationInfoPerson.ts

@@ -0,0 +1,33 @@
+import { IOSCommunicationInfoPerson } from '../../types/NotificationIOS';
+import { objectHasProperty, isObject, isString, isUndefined } from '../../utils';
+
+export default function validateIOSCommunicationInfoPerson(
+  person: IOSCommunicationInfoPerson,
+): IOSCommunicationInfoPerson {
+  if (!isObject(person)) {
+    throw new Error("'person' expected an object.");
+  }
+
+  if (!isString(person.id) || person.id.length === 0) {
+    throw new Error('"person.id" expected a valid string value.');
+  }
+
+  if (!isString(person.displayName) || person.displayName.length === 0) {
+    throw new Error('"person.displayName" expected a valid string value.');
+  }
+
+  const out: IOSCommunicationInfoPerson = {
+    id: person.id,
+    displayName: person.displayName,
+  };
+
+  if (objectHasProperty(person, 'avatar') && !isUndefined(person.avatar)) {
+    if (!isString(person.avatar)) {
+      throw new Error('"person.avatar" expected a valid object value.');
+    }
+
+    out.avatar = person.avatar;
+  }
+
+  return out;
+}

package/src/validators/validate.ts

@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited
+ */
+
+import { AndroidColor } from '../types/NotificationAndroid';
+import { isNumber } from '../utils';
+
+/**
+ * Validates any hexadecimal (optional transparency)
+ * @param color
+ * @returns {boolean}
+ */
+export function isValidColor(color: string): boolean {
+  if (Object.values(AndroidColor).includes(color as AndroidColor)) {
+    return true;
+  }
+
+  if (!color.startsWith('#')) {
+    return false;
+  }
+
+  // exclude #
+  const length = color.length - 1;
+  return length === 6 || length === 8;
+}
+
+/**
+ * Checks the timestamp is at some point in the future.
+ * @param timestamp
+ * @returns {boolean}
+ */
+export function isValidTimestamp(timestamp: number): boolean {
+  return timestamp > 0;
+}
+
+/**
+ * Ensures all values in the pattern are valid
+ * @param pattern {array}
+ */
+export function isValidVibratePattern(pattern: number[]): boolean {
+  if (pattern.length % 2 !== 0) {
+    return false;
+  }
+  for (let i = 0; i < pattern.length; i++) {
+    const ms = pattern[i];
+    if (!isNumber(ms)) {
+      return false;
+    }
+    if (ms <= 0) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/**
+ * Ensures a given light pattern is valid
+ * @param pattern {array}
+ */
+type LightPattern = [string, number, number];
+type ValidLightPattern = [boolean] | [boolean, 'color' | 'onMs' | 'offMs'];
+
+export function isValidLightPattern(pattern: LightPattern): ValidLightPattern {
+  const [color, onMs, offMs] = pattern;
+
+  if (!isValidColor(color)) {
+    return [false, 'color'];
+  }
+
+  if (!isNumber(onMs)) {
+    return [false, 'onMs'];
+  }
+
+  if (!isNumber(offMs)) {
+    return [false, 'offMs'];
+  }
+  if (onMs < 1) {
+    return [false, 'onMs'];
+  }
+  if (offMs < 1) {
+    return [false, 'offMs'];
+  }
+
+  return [true];
+}

package/src/validators/validateAndroidAction.ts

@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited
+ */
+
+import { objectHasProperty, isObject, isString, isUndefined } from '../utils';
+
+import { AndroidAction } from '../types/NotificationAndroid';
+import validateAndroidPressAction from './validateAndroidPressAction';
+import validateAndroidInput from './validateAndroidInput';
+
+export default function validateAndroidAction(action: AndroidAction): AndroidAction {
+  if (!isObject(action)) {
+    throw new Error("'action' expected an object value.");
+  }
+
+  if (!isString(action.title) || !action.title) {
+    throw new Error("'action.title' expected a string value.");
+  }
+
+  let pressAction;
+
+  try {
+    pressAction = validateAndroidPressAction(action.pressAction);
+  } catch (e: any) {
+    throw new Error(`'action' ${e.message}.`);
+  }
+
+  const out: AndroidAction = {
+    title: action.title,
+    pressAction,
+  };
+
+  if (objectHasProperty(action, 'icon') && !isUndefined(action.icon)) {
+    if (!isString(action.icon) || !action.icon) {
+      throw new Error("'action.icon' expected a string value.");
+    }
+
+    out.icon = action.icon;
+  }
+
+  if (objectHasProperty(action, 'input') && !isUndefined(action.input)) {
+    if (action.input === true) {
+      out.input = validateAndroidInput();
+    } else {
+      try {
+        out.input = validateAndroidInput(action.input);
+      } catch (e: any) {
+        throw new Error(`'action.input' ${e.message}.`);
+      }
+    }
+  }
+
+  return out;
+}