make JS match TS

Author: cbaker6

index.d.ts

@@ -223,10 +223,10 @@ export class MultiProvider extends EventEmitter {
   shutdown(callback?: () => void): void;
 }
 
-export type ChannelAction = 'create' | 'read' | 'readAll' | 'delete';
-
 export type NotificationPushType = 'background' | 'alert' | 'voip' | 'pushtotalk' | 'liveactivity' | 'location' | 'complication' | 'fileprovider' | 'mdm';
 
+export type ChannelAction = 'create' | 'read' | 'readAll' | 'delete';
+
 export interface NotificationAlertOptions {
   title?: string;
   subtitle?: string;

lib/notification/index.js

@@ -103,6 +103,27 @@ Notification.prototype.headers = function headers() {
   return headers;
 };
 
+Notification.prototype.removeNonChannelRelatedProperties = function () {
+  this.priority = undefined;
+  this.id = undefined;
+  this.collapseId = undefined;
+  this.expiry = undefined;
+  this.topic = undefined;
+  this.pushType = undefined;
+};
+
+/**
+ * Add live activity push type if it's not already provided.
+ *
+ * @remarks
+ * LiveActivity is the only current type supported.
+ */
+Notification.prototype.addPushTypeToPayloadIfNeeded = function () {
+  if (this.rawPayload == undefined && this.payload['push-type'] == undefined) {
+    this.payload['push-type'] = 'liveactivity';
+  }
+};
+
 /**
  * Compile a notification down to its JSON format. Compilation is final, changes made to the notification after this method is called will not be reflected in further calls.
  * @returns {String} JSON payload for the notification.

lib/provider.js

@@ -16,7 +16,7 @@ module.exports = function (dependencies) {
 
   Provider.prototype = Object.create(EventEmitter.prototype);
 
-  Provider.prototype.send = function send(notification, recipients) {
+  Provider.prototype.send = async function send(notification, recipients) {
     const builtNotification = {
       headers: notification.headers(),
       body: notification.compile(),
@@ -26,38 +26,41 @@ module.exports = function (dependencies) {
       recipients = [recipients];
     }
 
-    return Promise.all(
-      recipients.map(token => this.client.write(builtNotification, token, 'device', 'post'))
-    ).then(responses => {
-      const sent = [];
-      const failed = [];
-
-      responses.forEach(response => {
-        if (response.status || response.error) {
-          failed.push(response);
-        } else {
-          sent.push(response);
-        }
-      });
-      return { sent, failed };
+    const sentNotifications = await Promise.all(
+      recipients.map(
+        async token => await this.client.write(builtNotification, token, 'device', 'post')
+      )
+    );
+    const sent = [];
+    const failed = [];
+
+    sentNotifications.forEach(sentNotification => {
+      if (sentNotification.status || sentNotification.error) {
+        failed.push(sentNotification);
+      } else {
+        sent.push(sentNotification);
+      }
     });
+
+    return { sent, failed };
   };
 
-  Provider.prototype.manageChannels = function manageChannels(notification, bundleId, action) {
+  Provider.prototype.manageChannels = async function manageChannels(
+    notifications,
+    bundleId,
+    action
+  ) {
     let type = 'channels';
     let method = 'post';
 
+    if (!Array.isArray(notifications)) {
+      notifications = [notifications];
+    }
+
     switch (action) {
       case 'create':
         type = 'channels';
         method = 'post';
-        if (notification['push-type'] == null) {
-          // Add live activity push type if it's not already provided.
-          // Live activity is the only current type supported.
-          // Note, this seems like it should be lower cased, but the
-          // docs shows it in the current format.
-          notification['push-type'] = 'LiveActivity';
-        }
         break;
       case 'read':
         type = 'channels';
@@ -76,25 +79,64 @@ module.exports = function (dependencies) {
           bundleId,
           error: new VError(`the action "${action}" is not supported`),
         };
-        return Promise.resolve(error);
+        return error;
       }
     }
 
-    const builtNotification = {
-      headers: notification.headers(),
-      body: notification.compile(),
-    };
+    const sentNotifications = await Promise.all(
+      notifications.map(async notification => {
+        if (action == 'create') {
+          notification.addPushTypeToPayloadIfNeeded();
+        }
+        const builtNotification = {
+          headers: notification.headers(),
+          body: notification.compile(),
+        };
 
-    return this.client.write(builtNotification, bundleId, type, method);
+        return await this.client.write(builtNotification, bundleId, type, method);
+      })
+    );
+    const sent = [];
+    const failed = [];
+
+    sentNotifications.forEach(sentNotification => {
+      if (sentNotification.status || sentNotification.error) {
+        failed.push(sentNotification);
+      } else {
+        sent.push(sentNotification);
+      }
+    });
+
+    return { sent, failed };
   };
 
-  Provider.prototype.broadcast = function broadcast(notification, bundleId) {
-    const builtNotification = {
-      headers: notification.headers(),
-      body: notification.compile(),
-    };
+  Provider.prototype.broadcast = async function broadcast(notifications, bundleId) {
+    if (!Array.isArray(notifications)) {
+      notifications = [notifications];
+    }
+
+    const sentNotifications = await Promise.all(
+      notifications.map(async notification => {
+        const builtNotification = {
+          headers: notification.headers(),
+          body: notification.compile(),
+        };
+
+        return await this.client.write(builtNotification, bundleId, 'broadcasts', 'post');
+      })
+    );
+    const sent = [];
+    const failed = [];
+
+    sentNotifications.forEach(sentNotification => {
+      if (sentNotification.status || sentNotification.error) {
+        failed.push(sentNotification);
+      } else {
+        sent.push(sentNotification);
+      }
+    });
 
-    return this.client.write(builtNotification, bundleId, 'broadcasts', 'post');
+    return { sent, failed };
   };
 
   Provider.prototype.shutdown = function shutdown(callback) {