onesignal-vue 1.0.2 → 2.0.0-beta.2

package/index.ts

@@ -1,80 +1,137 @@
 import Vue from 'vue';
 
 const ONESIGNAL_SDK_ID = 'onesignal-sdk';
-const ONE_SIGNAL_SCRIPT_SRC = 'https://cdn.onesignal.com/sdks/OneSignalSDK.js';
-const ONESIGNAL_NOT_SETUP_ERROR = 'OneSignal is not setup correctly.';
-const MAX_TIMEOUT = 30;
+const ONE_SIGNAL_SCRIPT_SRC = "https://cdn.onesignal.com/sdks/web/v16/OneSignalSDK.page.js";
 
-const VueApp: any = Vue;
+// true if the script is successfully loaded from CDN.
 let isOneSignalInitialized = false;
-const vueOneSignalFunctionQueue: IOneSignalFunctionCall[] = [];
+// true if the script fails to load from CDN. A separate flag is necessary
+// to disambiguate between a CDN load failure and a delayed call to
+// OneSignal#init.
+let isOneSignalScriptFailed = false;
+
+const VueApp: any = Vue;
+
+window.OneSignalDeferred = window.OneSignalDeferred || [];
+
+addSDKScript();
 
 /* H E L P E R S */
 
-const injectScript = () => {
+function handleOnError() {
+  isOneSignalScriptFailed = true;
+}
+
+function addSDKScript() {
   const script = document.createElement('script');
   script.id = ONESIGNAL_SDK_ID;
+  script.defer = true;
   script.src = ONE_SIGNAL_SCRIPT_SRC;
-  script.async = true;
-  document.head.appendChild(script);
-}
 
-const doesOneSignalExist = () => {
-  if (window.OneSignal) {
-    return true;
+  // Always resolve whether or not the script is successfully initialized.
+  // This is important for users who may block cdn.onesignal.com w/ adblock.
+  script.onerror = () => {
+    handleOnError();
   }
-  return false;
-}
 
-const processQueuedOneSignalFunctions = () => {
-  vueOneSignalFunctionQueue.forEach(element => {
-    const { name, args, promiseResolver } = element;
-
-    if (!!promiseResolver) {
-      OneSignalVue[name](...args).then((result: any) => {
-        promiseResolver(result);
-      });
-    } else {
-      window.OneSignal[name](...args);
-    }
-  });
-}
-
-const setupOneSignalIfMissing = () => {
-  if (!doesOneSignalExist()) {
-    window.OneSignal = window.OneSignal || [];
-  }
+  document.head.appendChild(script);
 }
 
 /* T Y P E   D E C L A R A T I O N S */
 
 declare module 'vue/types/vue' {
   interface Vue {
-    $OneSignal: IOneSignal;
+    $OneSignal: IOneSignalOneSignal;
   }
 }
 
 declare global {
   interface Window {
-    OneSignal: any;
+    OneSignalDeferred?: OneSignalDeferredLoadedCallback[];
+    OneSignal?: IOneSignalOneSignal;
+    safari?: {
+      pushNotification: any;
+    };
+  }
+}
+
+/* O N E S I G N A L   A P I  */
+
+/**
+ * @PublicApi
+ */
+ const init = (options: IInitObject): Promise<void> => {
+  if (isOneSignalInitialized) {
+    return Promise.reject(`OneSignal is already initialized.`);
+  }
+
+  if (!options || !options.appId) {
+    throw new Error('You need to provide your OneSignal appId.');
+  }
+
+  if (!document) {
+    return Promise.reject(`Document is not defined.`);
   }
+
+  return new Promise<void>((resolve) => {
+    window.OneSignalDeferred?.push((OneSignal) => {
+      OneSignal.init(options).then(() => {
+        isOneSignalInitialized = true;
+        resolve();
+      });
+    });
+  });
+};
+
+/**
+ * The following code is copied directly from the native SDK source file BrowserSupportsPush.ts
+ * S T A R T
+ */
+
+// Checks if the browser supports push notifications by checking if specific
+//   classes and properties on them exist
+function isPushNotificationsSupported() {
+  return supportsVapidPush() || supportsSafariPush();
+}
+
+function isMacOSSafariInIframe(): boolean {
+  // Fallback detection for Safari on macOS in an iframe context
+  return window.top !== window && // isContextIframe
+  navigator.vendor === "Apple Computer, Inc." && // isSafari
+  navigator.platform === "MacIntel"; // isMacOS
+}
+
+function supportsSafariPush(): boolean {
+  return (window.safari && typeof window.safari.pushNotification !== "undefined") ||
+          isMacOSSafariInIframe();
 }
 
-interface IOneSignalFunctionCall {
-  name: string;
-  args: IArguments;
-  promiseResolver?: Function;
+// Does the browser support the standard Push API
+function supportsVapidPush(): boolean {
+  return typeof PushSubscriptionOptions !== "undefined" &&
+         PushSubscriptionOptions.prototype.hasOwnProperty("applicationServerKey");
+}
+/* E N D */
+
+/**
+ * @PublicApi
+ */
+const isPushSupported = (): boolean => {
+  return isPushNotificationsSupported();
 }
 
 type Action<T> = (item: T) => void;
 interface AutoPromptOptions { force?: boolean; forceSlidedownOverNative?: boolean; slidedownPromptOptions?: IOneSignalAutoPromptOptions; }
-interface RegisterOptions { modalPrompt?: boolean; httpPermissionRequest?: boolean; slidedown?: boolean; autoAccept?: boolean }
-interface SetSMSOptions { identifierAuthHash?: string; }
-interface SetEmailOptions { identifierAuthHash?: string; emailAuthHash?: string; }
-interface TagsObject<T> { [key: string]: T; }
 interface IOneSignalAutoPromptOptions { force?: boolean; forceSlidedownOverNative?: boolean; isInUpdateMode?: boolean; categoryOptions?: IOneSignalCategories; }
 interface IOneSignalCategories { positiveUpdateButton: string; negativeUpdateButton: string; savingButtonText: string; errorButtonText: string; updateMessage: string; tags: IOneSignalTagCategory[]; }
 interface IOneSignalTagCategory { tag: string; label: string; checked?: boolean; }
+type PushSubscriptionNamespaceProperties = { id: string | null | undefined; token: string | null | undefined; optedIn: boolean; };
+type SubscriptionChangeEvent = { previous: PushSubscriptionNamespaceProperties; current: PushSubscriptionNamespaceProperties; };
+type NotificationEventName = 'click' | 'willDisplay' | 'dismiss' | 'permissionChange' | 'permissionPromptDisplay';
+interface NotificationButtonData { action?: string; title?: string; icon?: string; url?: string; }
+interface StructuredNotification { id: string; content: string; heading?: string; url?: string; data?: object; rr?: string; icon?: string; image?: string; tag?: string; badge?: string; vibrate?: string; buttons?: NotificationButtonData[]; }
+type SlidedownEventName = 'slidedownShown';
+type OneSignalDeferredLoadedCallback = (onesignal: IOneSignalOneSignal) => void;
 
 interface IInitObject {
   appId: string;
@@ -97,787 +154,534 @@ interface IInitObject {
   [key: string]: any;
 }
 
-interface IOneSignal {
-	init(options: IInitObject): Promise<void>
-	on(event: string, listener: () => void): void
-	off(event: string, listener: () => void): void
-	once(event: string, listener: () => void): void
-	isPushNotificationsEnabled(callback?: Action<boolean>): Promise<boolean>
-	showHttpPrompt(options?: AutoPromptOptions): Promise<void>
-	registerForPushNotifications(options?: RegisterOptions): Promise<void>
-	setDefaultNotificationUrl(url: string): Promise<void>
-	setDefaultTitle(title: string): Promise<void>
-	getTags(callback?: Action<any>): Promise<void>
-	sendTag(key: string, value: any, callback?: Action<Object>): Promise<Object | null>
-	sendTags(tags: TagsObject<any>, callback?: Action<Object>): Promise<Object | null>
-	deleteTag(tag: string): Promise<Array<string>>
-	deleteTags(tags: Array<string>, callback?: Action<Array<string>>): Promise<Array<string>>
-	addListenerForNotificationOpened(callback?: Action<Notification>): Promise<void>
-	setSubscription(newSubscription: boolean): Promise<void>
-	showHttpPermissionRequest(options?: AutoPromptOptions): Promise<any>
-	showNativePrompt(): Promise<void>
-	showSlidedownPrompt(options?: AutoPromptOptions): Promise<void>
-	showCategorySlidedown(options?: AutoPromptOptions): Promise<void>
-	showSmsSlidedown(options?: AutoPromptOptions): Promise<void>
-	showEmailSlidedown(options?: AutoPromptOptions): Promise<void>
-	showSmsAndEmailSlidedown(options?: AutoPromptOptions): Promise<void>
-	getNotificationPermission(onComplete?: Action<NotificationPermission>): Promise<NotificationPermission>
-	getUserId(callback?: Action<string | undefined | null>): Promise<string | undefined | null>
-	getSubscription(callback?: Action<boolean>): Promise<boolean>
-	setEmail(email: string, options?: SetEmailOptions): Promise<string|null>
-	setSMSNumber(smsNumber: string, options?: SetSMSOptions): Promise<string | null>
-	logoutEmail(): Promise<void>
-	logoutSMS(): Promise<void>
-	setExternalUserId(externalUserId: string | undefined | null, authHash?: string): Promise<void>
-	removeExternalUserId(): Promise<void>
-	getExternalUserId(): Promise<string | undefined | null>
-	provideUserConsent(consent: boolean): Promise<void>
-	getEmailId(callback?: Action<string | undefined>): Promise<string | null | undefined>
-	getSMSId(callback?: Action<string | undefined>): Promise<string | null | undefined>
-	sendOutcome(outcomeName: string, outcomeWeight?: number | undefined): Promise<void>
-	[index: string]: Function;
+interface IOneSignalOneSignal {
+	Slidedown: IOneSignalSlidedown;
+	Notifications: IOneSignalNotifications;
+	Session: IOneSignalSession;
+	User: IOneSignalUser;
+	Debug: IOneSignalDebug;
+	login(externalId: string, jwtToken?: string): Promise<void>;
+	logout(): Promise<void>;
+	init(options: IInitObject): Promise<void>;
+	setConsentGiven(consent: boolean): Promise<void>;
+	setConsentRequired(requiresConsent: boolean): Promise<void>;
+}
+interface IOneSignalNotifications {
+	setDefaultUrl(url: string): Promise<void>;
+	setDefaultTitle(title: string): Promise<void>;
+	isPushSupported(): boolean;
+	getPermissionStatus(onComplete: Action<NotificationPermission>): Promise<NotificationPermission>;
+	requestPermission(): Promise<void>;
+	addEventListener(event: NotificationEventName, listener: (obj: any) => void): void;
+	removeEventListener(event: NotificationEventName, listener: (obj: any) => void): void;
+}
+interface IOneSignalSlidedown {
+	promptPush(options?: AutoPromptOptions): Promise<void>;
+	promptPushCategories(options?: AutoPromptOptions): Promise<void>;
+	promptSms(options?: AutoPromptOptions): Promise<void>;
+	promptEmail(options?: AutoPromptOptions): Promise<void>;
+	promptSmsAndEmail(options?: AutoPromptOptions): Promise<void>;
+	addEventListener(event: SlidedownEventName, listener: (wasShown: boolean) => void): void;
+	removeEventListener(event: SlidedownEventName, listener: (wasShown: boolean) => void): void;
+}
+interface IOneSignalDebug {
+	setLogLevel(logLevel: string): void;
+}
+interface IOneSignalSession {
+	sendOutcome(outcomeName: string, outcomeWeight?: number): Promise<void>;
+	sendUniqueOutcome(outcomeName: string): Promise<void>;
+}
+interface IOneSignalUser {
+	PushSubscription: IOneSignalPushSubscription;
+	addAlias(label: string, id: string): void;
+	addAliases(aliases: { [key: string]: string }): void;
+	removeAlias(label: string): void;
+	removeAliases(labels: string[]): void;
+	addEmail(email: string): void;
+	removeEmail(email: string): void;
+	addSms(smsNumber: string): void;
+	removeSms(smsNumber: string): void;
+}
+interface IOneSignalPushSubscription {
+	id: string | null | undefined;
+	token: string | null | undefined;
+	optedIn: boolean | undefined;
+	optIn(): Promise<void>;
+	optOut(): Promise<void>;
+	addEventListener(event: 'subscriptionChange', listener: (change: SubscriptionChangeEvent) => void): void;
+	removeEventListener(event: 'subscriptionChange', listener: (change: SubscriptionChangeEvent) => void): void;
 }
 
-
-/* O N E S I G N A L   A P I  */
-
-function init(options: IInitObject) {
-  return new Promise<void>(resolve => {
-    if (isOneSignalInitialized) {
-      return;
+function oneSignalLogin(externalId: string, jwtToken?: string): Promise<void> {
+  return new Promise(function (resolve, reject) {
+    if (isOneSignalScriptFailed) {
+      reject();
     }
 
-    injectScript();
-    setupOneSignalIfMissing();
-    window.OneSignal.push(() => {
-      window.OneSignal.init(options);
-    })
-
-    const timeout = setTimeout(() => {
-      console.error(ONESIGNAL_NOT_SETUP_ERROR);
-    }, MAX_TIMEOUT * 1_000);
-
-    window.OneSignal.push(() => {
-      clearTimeout(timeout);
-      isOneSignalInitialized = true;
-      processQueuedOneSignalFunctions();
-      resolve();
-    });
+    try {
+      window.OneSignalDeferred?.push((OneSignal) => {
+        OneSignal.login(externalId, jwtToken)
+          .then(value => resolve(value))
+          .catch(error => reject(error));
+      });
+    } catch (error) {
+      reject(error);
+    }
   });
 }
 
-  function on(event: string, listener: () => void): void {
-    if (!doesOneSignalExist()) {
-      vueOneSignalFunctionQueue.push({
-        name: 'on',
-        args: arguments,
-      });
-      return;
+function oneSignalLogout(): Promise<void> {
+  return new Promise(function (resolve, reject) {
+    if (isOneSignalScriptFailed) {
+      reject();
     }
 
-    window.OneSignal.push(() => {
-      window.OneSignal.on(event, listener)
-    });
-  }
-
-  function off(event: string, listener: () => void): void {
-    if (!doesOneSignalExist()) {
-      vueOneSignalFunctionQueue.push({
-        name: 'off',
-        args: arguments,
+    try {
+      window.OneSignalDeferred?.push((OneSignal) => {
+        OneSignal.logout()
+          .then(value => resolve(value))
+          .catch(error => reject(error));
       });
-      return;
+    } catch (error) {
+      reject(error);
     }
+  });
+}
 
-    window.OneSignal.push(() => {
-      window.OneSignal.off(event, listener)
-    });
-  }
-
-  function once(event: string, listener: () => void): void {
-    if (!doesOneSignalExist()) {
-      vueOneSignalFunctionQueue.push({
-        name: 'once',
-        args: arguments,
-      });
-      return;
+function oneSignalSetConsentGiven(consent: boolean): Promise<void> {
+  return new Promise(function (resolve, reject) {
+    if (isOneSignalScriptFailed) {
+      reject();
     }
 
-    window.OneSignal.push(() => {
-      window.OneSignal.once(event, listener)
-    });
-  }
-
-  function isPushNotificationsEnabled(callback?: Action<boolean>): Promise<boolean> {
-    return new Promise(function (resolve, reject) {
-      if (!doesOneSignalExist()) {
-        vueOneSignalFunctionQueue.push({
-          name: 'isPushNotificationsEnabled',
-          args: arguments,
-          promiseResolver: resolve,
-        });
-        return;
-      }
-
-      window.OneSignal.push(() => {
-        window.OneSignal.isPushNotificationsEnabled(callback)
+    try {
+      window.OneSignalDeferred?.push((OneSignal) => {
+        OneSignal.setConsentGiven(consent)
           .then(value => resolve(value))
           .catch(error => reject(error));
       });
-    });
-  }
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
 
-  function showHttpPrompt(options?: AutoPromptOptions): Promise<void> {
-    return new Promise(function (resolve, reject) {
-      if (!doesOneSignalExist()) {
-        vueOneSignalFunctionQueue.push({
-          name: 'showHttpPrompt',
-          args: arguments,
-          promiseResolver: resolve,
-        });
-        return;
-      }
-
-      window.OneSignal.push(() => {
-        window.OneSignal.showHttpPrompt(options)
-          .then(value => resolve(value))
-          .catch(error => reject(error));
-      });
-    });
-  }
+function oneSignalSetConsentRequired(requiresConsent: boolean): Promise<void> {
+  return new Promise(function (resolve, reject) {
+    if (isOneSignalScriptFailed) {
+      reject();
+    }
 
-  function registerForPushNotifications(options?: RegisterOptions): Promise<void> {
-    return new Promise(function (resolve, reject) {
-      if (!doesOneSignalExist()) {
-        vueOneSignalFunctionQueue.push({
-          name: 'registerForPushNotifications',
-          args: arguments,
-          promiseResolver: resolve,
-        });
-        return;
-      }
-
-      window.OneSignal.push(() => {
-        window.OneSignal.registerForPushNotifications(options)
+    try {
+      window.OneSignalDeferred?.push((OneSignal) => {
+        OneSignal.setConsentRequired(requiresConsent)
           .then(value => resolve(value))
           .catch(error => reject(error));
       });
-    });
-  }
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
 
-  function setDefaultNotificationUrl(url: string): Promise<void> {
-    return new Promise(function (resolve, reject) {
-      if (!doesOneSignalExist()) {
-        vueOneSignalFunctionQueue.push({
-          name: 'setDefaultNotificationUrl',
-          args: arguments,
-          promiseResolver: resolve,
-        });
-        return;
-      }
-
-      window.OneSignal.push(() => {
-        window.OneSignal.setDefaultNotificationUrl(url)
-          .then(value => resolve(value))
-          .catch(error => reject(error));
-      });
-    });
-  }
+function slidedownPromptPush(options?: AutoPromptOptions): Promise<void> {
+  return new Promise(function (resolve, reject) {
+    if (isOneSignalScriptFailed) {
+      reject();
+    }
 
-  function setDefaultTitle(title: string): Promise<void> {
-    return new Promise(function (resolve, reject) {
-      if (!doesOneSignalExist()) {
-        vueOneSignalFunctionQueue.push({
-          name: 'setDefaultTitle',
-          args: arguments,
-          promiseResolver: resolve,
-        });
-        return;
-      }
-
-      window.OneSignal.push(() => {
-        window.OneSignal.setDefaultTitle(title)
+    try {
+      window.OneSignalDeferred?.push((OneSignal) => {
+        OneSignal.Slidedown.promptPush(options)
           .then(value => resolve(value))
           .catch(error => reject(error));
       });
-    });
-  }
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
 
-  function getTags(callback?: Action<any>): Promise<void> {
-    return new Promise(function (resolve, reject) {
-      if (!doesOneSignalExist()) {
-        vueOneSignalFunctionQueue.push({
-          name: 'getTags',
-          args: arguments,
-          promiseResolver: resolve,
-        });
-        return;
-      }
-
-      window.OneSignal.push(() => {
-        window.OneSignal.getTags(callback)
-          .then(value => resolve(value))
-          .catch(error => reject(error));
-      });
-    });
-  }
+function slidedownPromptPushCategories(options?: AutoPromptOptions): Promise<void> {
+  return new Promise(function (resolve, reject) {
+    if (isOneSignalScriptFailed) {
+      reject();
+    }
 
-  function sendTag(key: string, value: any, callback?: Action<Object>): Promise<Object | null> {
-    return new Promise(function (resolve, reject) {
-      if (!doesOneSignalExist()) {
-        vueOneSignalFunctionQueue.push({
-          name: 'sendTag',
-          args: arguments,
-          promiseResolver: resolve,
-        });
-        return;
-      }
-
-      window.OneSignal.push(() => {
-        window.OneSignal.sendTag(key, value, callback)
+    try {
+      window.OneSignalDeferred?.push((OneSignal) => {
+        OneSignal.Slidedown.promptPushCategories(options)
           .then(value => resolve(value))
           .catch(error => reject(error));
       });
-    });
-  }
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
 
-  function sendTags(tags: TagsObject<any>, callback?: Action<Object>): Promise<Object | null> {
-    return new Promise(function (resolve, reject) {
-      if (!doesOneSignalExist()) {
-        vueOneSignalFunctionQueue.push({
-          name: 'sendTags',
-          args: arguments,
-          promiseResolver: resolve,
-        });
-        return;
-      }
-
-      window.OneSignal.push(() => {
-        window.OneSignal.sendTags(tags, callback)
-          .then(value => resolve(value))
-          .catch(error => reject(error));
-      });
-    });
-  }
+function slidedownPromptSms(options?: AutoPromptOptions): Promise<void> {
+  return new Promise(function (resolve, reject) {
+    if (isOneSignalScriptFailed) {
+      reject();
+    }
 
-  function deleteTag(tag: string): Promise<Array<string>> {
-    return new Promise(function (resolve, reject) {
-      if (!doesOneSignalExist()) {
-        vueOneSignalFunctionQueue.push({
-          name: 'deleteTag',
-          args: arguments,
-          promiseResolver: resolve,
-        });
-        return;
-      }
-
-      window.OneSignal.push(() => {
-        window.OneSignal.deleteTag(tag)
+    try {
+      window.OneSignalDeferred?.push((OneSignal) => {
+        OneSignal.Slidedown.promptSms(options)
           .then(value => resolve(value))
           .catch(error => reject(error));
       });
-    });
-  }
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
 
-  function deleteTags(tags: Array<string>, callback?: Action<Array<string>>): Promise<Array<string>> {
-    return new Promise(function (resolve, reject) {
-      if (!doesOneSignalExist()) {
-        vueOneSignalFunctionQueue.push({
-          name: 'deleteTags',
-          args: arguments,
-          promiseResolver: resolve,
-        });
-        return;
-      }
-
-      window.OneSignal.push(() => {
-        window.OneSignal.deleteTags(tags, callback)
-          .then(value => resolve(value))
-          .catch(error => reject(error));
-      });
-    });
-  }
+function slidedownPromptEmail(options?: AutoPromptOptions): Promise<void> {
+  return new Promise(function (resolve, reject) {
+    if (isOneSignalScriptFailed) {
+      reject();
+    }
 
-  function addListenerForNotificationOpened(callback?: Action<Notification>): Promise<void> {
-    return new Promise(function (resolve, reject) {
-      if (!doesOneSignalExist()) {
-        vueOneSignalFunctionQueue.push({
-          name: 'addListenerForNotificationOpened',
-          args: arguments,
-          promiseResolver: resolve,
-        });
-        return;
-      }
-
-      window.OneSignal.push(() => {
-        window.OneSignal.addListenerForNotificationOpened(callback)
+    try {
+      window.OneSignalDeferred?.push((OneSignal) => {
+        OneSignal.Slidedown.promptEmail(options)
           .then(value => resolve(value))
           .catch(error => reject(error));
       });
-    });
-  }
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
 
-  function setSubscription(newSubscription: boolean): Promise<void> {
-    return new Promise(function (resolve, reject) {
-      if (!doesOneSignalExist()) {
-        vueOneSignalFunctionQueue.push({
-          name: 'setSubscription',
-          args: arguments,
-          promiseResolver: resolve,
-        });
-        return;
-      }
-
-      window.OneSignal.push(() => {
-        window.OneSignal.setSubscription(newSubscription)
-          .then(value => resolve(value))
-          .catch(error => reject(error));
-      });
-    });
-  }
+function slidedownPromptSmsAndEmail(options?: AutoPromptOptions): Promise<void> {
+  return new Promise(function (resolve, reject) {
+    if (isOneSignalScriptFailed) {
+      reject();
+    }
 
-  function showHttpPermissionRequest(options?: AutoPromptOptions): Promise<any> {
-    return new Promise(function (resolve, reject) {
-      if (!doesOneSignalExist()) {
-        vueOneSignalFunctionQueue.push({
-          name: 'showHttpPermissionRequest',
-          args: arguments,
-          promiseResolver: resolve,
-        });
-        return;
-      }
-
-      window.OneSignal.push(() => {
-        window.OneSignal.showHttpPermissionRequest(options)
+    try {
+      window.OneSignalDeferred?.push((OneSignal) => {
+        OneSignal.Slidedown.promptSmsAndEmail(options)
           .then(value => resolve(value))
           .catch(error => reject(error));
       });
-    });
-  }
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
 
-  function showNativePrompt(): Promise<void> {
-    return new Promise(function (resolve, reject) {
-      if (!doesOneSignalExist()) {
-        vueOneSignalFunctionQueue.push({
-          name: 'showNativePrompt',
-          args: arguments,
-          promiseResolver: resolve,
-        });
-        return;
-      }
-
-      window.OneSignal.push(() => {
-        window.OneSignal.showNativePrompt()
-          .then(value => resolve(value))
-          .catch(error => reject(error));
-      });
-    });
-  }
+function slidedownAddEventListener(event: SlidedownEventName, listener: (wasShown: boolean) => void): void {
+  window.OneSignalDeferred?.push((OneSignal) => {
+    OneSignal.Slidedown.addEventListener(event, listener)
+  });
+}
 
-  function showSlidedownPrompt(options?: AutoPromptOptions): Promise<void> {
-    return new Promise(function (resolve, reject) {
-      if (!doesOneSignalExist()) {
-        vueOneSignalFunctionQueue.push({
-          name: 'showSlidedownPrompt',
-          args: arguments,
-          promiseResolver: resolve,
-        });
-        return;
-      }
-
-      window.OneSignal.push(() => {
-        window.OneSignal.showSlidedownPrompt(options)
-          .then(value => resolve(value))
-          .catch(error => reject(error));
-      });
-    });
-  }
+function slidedownRemoveEventListener(event: SlidedownEventName, listener: (wasShown: boolean) => void): void {
+  window.OneSignalDeferred?.push((OneSignal) => {
+    OneSignal.Slidedown.removeEventListener(event, listener)
+  });
+}
 
-  function showCategorySlidedown(options?: AutoPromptOptions): Promise<void> {
-    return new Promise(function (resolve, reject) {
-      if (!doesOneSignalExist()) {
-        vueOneSignalFunctionQueue.push({
-          name: 'showCategorySlidedown',
-          args: arguments,
-          promiseResolver: resolve,
-        });
-        return;
-      }
-
-      window.OneSignal.push(() => {
-        window.OneSignal.showCategorySlidedown(options)
-          .then(value => resolve(value))
-          .catch(error => reject(error));
-      });
-    });
-  }
+function notificationsSetDefaultUrl(url: string): Promise<void> {
+  return new Promise(function (resolve, reject) {
+    if (isOneSignalScriptFailed) {
+      reject();
+    }
 
-  function showSmsSlidedown(options?: AutoPromptOptions): Promise<void> {
-    return new Promise(function (resolve, reject) {
-      if (!doesOneSignalExist()) {
-        vueOneSignalFunctionQueue.push({
-          name: 'showSmsSlidedown',
-          args: arguments,
-          promiseResolver: resolve,
-        });
-        return;
-      }
-
-      window.OneSignal.push(() => {
-        window.OneSignal.showSmsSlidedown(options)
+    try {
+      window.OneSignalDeferred?.push((OneSignal) => {
+        OneSignal.Notifications.setDefaultUrl(url)
           .then(value => resolve(value))
           .catch(error => reject(error));
       });
-    });
-  }
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
 
-  function showEmailSlidedown(options?: AutoPromptOptions): Promise<void> {
-    return new Promise(function (resolve, reject) {
-      if (!doesOneSignalExist()) {
-        vueOneSignalFunctionQueue.push({
-          name: 'showEmailSlidedown',
-          args: arguments,
-          promiseResolver: resolve,
-        });
-        return;
-      }
-
-      window.OneSignal.push(() => {
-        window.OneSignal.showEmailSlidedown(options)
-          .then(value => resolve(value))
-          .catch(error => reject(error));
-      });
-    });
-  }
+function notificationsSetDefaultTitle(title: string): Promise<void> {
+  return new Promise(function (resolve, reject) {
+    if (isOneSignalScriptFailed) {
+      reject();
+    }
 
-  function showSmsAndEmailSlidedown(options?: AutoPromptOptions): Promise<void> {
-    return new Promise(function (resolve, reject) {
-      if (!doesOneSignalExist()) {
-        vueOneSignalFunctionQueue.push({
-          name: 'showSmsAndEmailSlidedown',
-          args: arguments,
-          promiseResolver: resolve,
-        });
-        return;
-      }
-
-      window.OneSignal.push(() => {
-        window.OneSignal.showSmsAndEmailSlidedown(options)
+    try {
+      window.OneSignalDeferred?.push((OneSignal) => {
+        OneSignal.Notifications.setDefaultTitle(title)
           .then(value => resolve(value))
           .catch(error => reject(error));
       });
-    });
-  }
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
 
-  function getNotificationPermission(onComplete?: Action<NotificationPermission>): Promise<NotificationPermission> {
-    return new Promise(function (resolve, reject) {
-      if (!doesOneSignalExist()) {
-        vueOneSignalFunctionQueue.push({
-          name: 'getNotificationPermission',
-          args: arguments,
-          promiseResolver: resolve,
-        });
-        return;
-      }
-
-      window.OneSignal.push(() => {
-        window.OneSignal.getNotificationPermission(onComplete)
-          .then(value => resolve(value))
-          .catch(error => reject(error));
-      });
-    });
-  }
+function notificationsGetPermissionStatus(onComplete: Action<NotificationPermission>): Promise<NotificationPermission> {
+  return new Promise(function (resolve, reject) {
+    if (isOneSignalScriptFailed) {
+      reject();
+    }
 
-  function getUserId(callback?: Action<string | undefined | null>): Promise<string | undefined | null> {
-    return new Promise(function (resolve, reject) {
-      if (!doesOneSignalExist()) {
-        vueOneSignalFunctionQueue.push({
-          name: 'getUserId',
-          args: arguments,
-          promiseResolver: resolve,
-        });
-        return;
-      }
-
-      window.OneSignal.push(() => {
-        window.OneSignal.getUserId(callback)
+    try {
+      window.OneSignalDeferred?.push((OneSignal) => {
+        OneSignal.Notifications.getPermissionStatus(onComplete)
           .then(value => resolve(value))
           .catch(error => reject(error));
       });
-    });
-  }
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
 
-  function getSubscription(callback?: Action<boolean>): Promise<boolean> {
-    return new Promise(function (resolve, reject) {
-      if (!doesOneSignalExist()) {
-        vueOneSignalFunctionQueue.push({
-          name: 'getSubscription',
-          args: arguments,
-          promiseResolver: resolve,
-        });
-        return;
-      }
-
-      window.OneSignal.push(() => {
-        window.OneSignal.getSubscription(callback)
-          .then(value => resolve(value))
-          .catch(error => reject(error));
-      });
-    });
-  }
+function notificationsRequestPermission(): Promise<void> {
+  return new Promise(function (resolve, reject) {
+    if (isOneSignalScriptFailed) {
+      reject();
+    }
 
-  function setEmail(email: string, options?: SetEmailOptions): Promise<string|null> {
-    return new Promise(function (resolve, reject) {
-      if (!doesOneSignalExist()) {
-        vueOneSignalFunctionQueue.push({
-          name: 'setEmail',
-          args: arguments,
-          promiseResolver: resolve,
-        });
-        return;
-      }
-
-      window.OneSignal.push(() => {
-        window.OneSignal.setEmail(email, options)
+    try {
+      window.OneSignalDeferred?.push((OneSignal) => {
+        OneSignal.Notifications.requestPermission()
           .then(value => resolve(value))
           .catch(error => reject(error));
       });
-    });
-  }
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
 
-  function setSMSNumber(smsNumber: string, options?: SetSMSOptions): Promise<string | null> {
-    return new Promise(function (resolve, reject) {
-      if (!doesOneSignalExist()) {
-        vueOneSignalFunctionQueue.push({
-          name: 'setSMSNumber',
-          args: arguments,
-          promiseResolver: resolve,
-        });
-        return;
-      }
-
-      window.OneSignal.push(() => {
-        window.OneSignal.setSMSNumber(smsNumber, options)
-          .then(value => resolve(value))
-          .catch(error => reject(error));
-      });
-    });
-  }
+function notificationsAddEventListener(event: 'click' | 'willDisplay' | 'dismiss', listener: (obj: StructuredNotification) => void): void;
+function notificationsAddEventListener(event: 'permissionChange', listener: (obj: { to: NotificationPermission }) => void): void;
+function notificationsAddEventListener(event: 'permissionPromptDisplay', listener: () => void): void;
 
-  function logoutEmail(): Promise<void> {
-    return new Promise(function (resolve, reject) {
-      if (!doesOneSignalExist()) {
-        vueOneSignalFunctionQueue.push({
-          name: 'logoutEmail',
-          args: arguments,
-          promiseResolver: resolve,
-        });
-        return;
-      }
-
-      window.OneSignal.push(() => {
-        window.OneSignal.logoutEmail()
-          .then(value => resolve(value))
-          .catch(error => reject(error));
-      });
-    });
-  }
+function notificationsAddEventListener(event: NotificationEventName, listener: (obj: any) => void): void {
+  window.OneSignalDeferred?.push((OneSignal) => {
+    OneSignal.Notifications.addEventListener(event, listener)
+  });
+}
 
-  function logoutSMS(): Promise<void> {
-    return new Promise(function (resolve, reject) {
-      if (!doesOneSignalExist()) {
-        vueOneSignalFunctionQueue.push({
-          name: 'logoutSMS',
-          args: arguments,
-          promiseResolver: resolve,
-        });
-        return;
-      }
-
-      window.OneSignal.push(() => {
-        window.OneSignal.logoutSMS()
-          .then(value => resolve(value))
-          .catch(error => reject(error));
-      });
-    });
-  }
+function notificationsRemoveEventListener(event: 'click' | 'willDisplay' | 'dismiss', listener: (obj: StructuredNotification) => void): void;
+function notificationsRemoveEventListener(event: 'permissionChange', listener: (obj: { to: NotificationPermission }) => void): void;
+function notificationsRemoveEventListener(event: 'permissionPromptDisplay', listener: () => void): void;
 
-  function setExternalUserId(externalUserId: string | undefined | null, authHash?: string): Promise<void> {
-    return new Promise(function (resolve, reject) {
-      if (!doesOneSignalExist()) {
-        vueOneSignalFunctionQueue.push({
-          name: 'setExternalUserId',
-          args: arguments,
-          promiseResolver: resolve,
-        });
-        return;
-      }
-
-      window.OneSignal.push(() => {
-        window.OneSignal.setExternalUserId(externalUserId, authHash)
-          .then(value => resolve(value))
-          .catch(error => reject(error));
-      });
-    });
-  }
+function notificationsRemoveEventListener(event: NotificationEventName, listener: (obj: any) => void): void {
+  window.OneSignalDeferred?.push((OneSignal) => {
+    OneSignal.Notifications.removeEventListener(event, listener)
+  });
+}
 
-  function removeExternalUserId(): Promise<void> {
-    return new Promise(function (resolve, reject) {
-      if (!doesOneSignalExist()) {
-        vueOneSignalFunctionQueue.push({
-          name: 'removeExternalUserId',
-          args: arguments,
-          promiseResolver: resolve,
-        });
-        return;
-      }
-
-      window.OneSignal.push(() => {
-        window.OneSignal.removeExternalUserId()
-          .then(value => resolve(value))
-          .catch(error => reject(error));
-      });
-    });
-  }
+function sessionSendOutcome(outcomeName: string, outcomeWeight?: number): Promise<void> {
+  return new Promise(function (resolve, reject) {
+    if (isOneSignalScriptFailed) {
+      reject();
+    }
 
-  function getExternalUserId(): Promise<string | undefined | null> {
-    return new Promise(function (resolve, reject) {
-      if (!doesOneSignalExist()) {
-        vueOneSignalFunctionQueue.push({
-          name: 'getExternalUserId',
-          args: arguments,
-          promiseResolver: resolve,
-        });
-        return;
-      }
-
-      window.OneSignal.push(() => {
-        window.OneSignal.getExternalUserId()
+    try {
+      window.OneSignalDeferred?.push((OneSignal) => {
+        OneSignal.Session.sendOutcome(outcomeName, outcomeWeight)
           .then(value => resolve(value))
           .catch(error => reject(error));
       });
-    });
-  }
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
 
-  function provideUserConsent(consent: boolean): Promise<void> {
-    return new Promise(function (resolve, reject) {
-      if (!doesOneSignalExist()) {
-        vueOneSignalFunctionQueue.push({
-          name: 'provideUserConsent',
-          args: arguments,
-          promiseResolver: resolve,
-        });
-        return;
-      }
-
-      window.OneSignal.push(() => {
-        window.OneSignal.provideUserConsent(consent)
-          .then(value => resolve(value))
-          .catch(error => reject(error));
-      });
-    });
-  }
+function sessionSendUniqueOutcome(outcomeName: string): Promise<void> {
+  return new Promise(function (resolve, reject) {
+    if (isOneSignalScriptFailed) {
+      reject();
+    }
 
-  function getEmailId(callback?: Action<string | undefined>): Promise<string | null | undefined> {
-    return new Promise(function (resolve, reject) {
-      if (!doesOneSignalExist()) {
-        vueOneSignalFunctionQueue.push({
-          name: 'getEmailId',
-          args: arguments,
-          promiseResolver: resolve,
-        });
-        return;
-      }
-
-      window.OneSignal.push(() => {
-        window.OneSignal.getEmailId(callback)
+    try {
+      window.OneSignalDeferred?.push((OneSignal) => {
+        OneSignal.Session.sendUniqueOutcome(outcomeName)
           .then(value => resolve(value))
           .catch(error => reject(error));
       });
-    });
-  }
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+
+function userAddAlias(label: string, id: string): void {
+  window.OneSignalDeferred?.push((OneSignal) => {
+    OneSignal.User.addAlias(label, id)
+  });
+}
+
+function userAddAliases(aliases: { [key: string]: string }): void {
+  window.OneSignalDeferred?.push((OneSignal) => {
+    OneSignal.User.addAliases(aliases)
+  });
+}
+
+function userRemoveAlias(label: string): void {
+  window.OneSignalDeferred?.push((OneSignal) => {
+    OneSignal.User.removeAlias(label)
+  });
+}
+
+function userRemoveAliases(labels: string[]): void {
+  window.OneSignalDeferred?.push((OneSignal) => {
+    OneSignal.User.removeAliases(labels)
+  });
+}
+
+function userAddEmail(email: string): void {
+  window.OneSignalDeferred?.push((OneSignal) => {
+    OneSignal.User.addEmail(email)
+  });
+}
+
+function userRemoveEmail(email: string): void {
+  window.OneSignalDeferred?.push((OneSignal) => {
+    OneSignal.User.removeEmail(email)
+  });
+}
+
+function userAddSms(smsNumber: string): void {
+  window.OneSignalDeferred?.push((OneSignal) => {
+    OneSignal.User.addSms(smsNumber)
+  });
+}
+
+function userRemoveSms(smsNumber: string): void {
+  window.OneSignalDeferred?.push((OneSignal) => {
+    OneSignal.User.removeSms(smsNumber)
+  });
+}
+
+function pushSubscriptionOptIn(): Promise<void> {
+  return new Promise(function (resolve, reject) {
+    if (isOneSignalScriptFailed) {
+      reject();
+    }
 
-  function getSMSId(callback?: Action<string | undefined>): Promise<string | null | undefined> {
-    return new Promise(function (resolve, reject) {
-      if (!doesOneSignalExist()) {
-        vueOneSignalFunctionQueue.push({
-          name: 'getSMSId',
-          args: arguments,
-          promiseResolver: resolve,
-        });
-        return;
-      }
-
-      window.OneSignal.push(() => {
-        window.OneSignal.getSMSId(callback)
+    try {
+      window.OneSignalDeferred?.push((OneSignal) => {
+        OneSignal.User.PushSubscription.optIn()
           .then(value => resolve(value))
           .catch(error => reject(error));
       });
-    });
-  }
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+
+function pushSubscriptionOptOut(): Promise<void> {
+  return new Promise(function (resolve, reject) {
+    if (isOneSignalScriptFailed) {
+      reject();
+    }
 
-  function sendOutcome(outcomeName: string, outcomeWeight?: number | undefined): Promise<void> {
-    return new Promise(function (resolve, reject) {
-      if (!doesOneSignalExist()) {
-        vueOneSignalFunctionQueue.push({
-          name: 'sendOutcome',
-          args: arguments,
-          promiseResolver: resolve,
-        });
-        return;
-      }
-
-      window.OneSignal.push(() => {
-        window.OneSignal.sendOutcome(outcomeName, outcomeWeight)
+    try {
+      window.OneSignalDeferred?.push((OneSignal) => {
+        OneSignal.User.PushSubscription.optOut()
           .then(value => resolve(value))
           .catch(error => reject(error));
       });
-    });
-  }
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+
+function pushSubscriptionAddEventListener(event: 'subscriptionChange', listener: (change: SubscriptionChangeEvent) => void): void {
+  window.OneSignalDeferred?.push((OneSignal) => {
+    OneSignal.User.PushSubscription.addEventListener(event, listener)
+  });
+}
+
+function pushSubscriptionRemoveEventListener(event: 'subscriptionChange', listener: (change: SubscriptionChangeEvent) => void): void {
+  window.OneSignalDeferred?.push((OneSignal) => {
+    OneSignal.User.PushSubscription.removeEventListener(event, listener)
+  });
+}
+
+function debugSetLogLevel(logLevel: string): void {
+  window.OneSignalDeferred?.push((OneSignal) => {
+    OneSignal.Debug.setLogLevel(logLevel)
+  });
+}
+const PushSubscriptionNamespace: IOneSignalPushSubscription = {
+	get id(): string | null | undefined { return window.OneSignal?.User?.PushSubscription?.id },
+	get token(): string | null | undefined { return window.OneSignal?.User?.PushSubscription?.token },
+	get optedIn(): boolean | undefined { return window.OneSignal?.User?.PushSubscription?.optedIn },
+	optIn: pushSubscriptionOptIn,
+	optOut: pushSubscriptionOptOut,
+	addEventListener: pushSubscriptionAddEventListener,
+	removeEventListener: pushSubscriptionRemoveEventListener,
+};
+
+const UserNamespace: IOneSignalUser = {
+	addAlias: userAddAlias,
+	addAliases: userAddAliases,
+	removeAlias: userRemoveAlias,
+	removeAliases: userRemoveAliases,
+	addEmail: userAddEmail,
+	removeEmail: userRemoveEmail,
+	addSms: userAddSms,
+	removeSms: userRemoveSms,
+	PushSubscription: PushSubscriptionNamespace,
+};
+
+const SessionNamespace: IOneSignalSession = {
+	sendOutcome: sessionSendOutcome,
+	sendUniqueOutcome: sessionSendUniqueOutcome,
+};
+
+const DebugNamespace: IOneSignalDebug = {
+	setLogLevel: debugSetLogLevel,
+};
+
+const SlidedownNamespace: IOneSignalSlidedown = {
+	promptPush: slidedownPromptPush,
+	promptPushCategories: slidedownPromptPushCategories,
+	promptSms: slidedownPromptSms,
+	promptEmail: slidedownPromptEmail,
+	promptSmsAndEmail: slidedownPromptSmsAndEmail,
+	addEventListener: slidedownAddEventListener,
+	removeEventListener: slidedownRemoveEventListener,
+};
+
+const NotificationsNamespace: IOneSignalNotifications = {
+	setDefaultUrl: notificationsSetDefaultUrl,
+	setDefaultTitle: notificationsSetDefaultTitle,
+	isPushSupported,
+	getPermissionStatus: notificationsGetPermissionStatus,
+	requestPermission: notificationsRequestPermission,
+	addEventListener: notificationsAddEventListener,
+	removeEventListener: notificationsRemoveEventListener,
+};
 
-const OneSignalVue: IOneSignal = {
+const OneSignalNamespace: IOneSignalOneSignal = {
+	login: oneSignalLogin,
+	logout: oneSignalLogout,
 	init,
-	on,
-	off,
-	once,
-	isPushNotificationsEnabled,
-	showHttpPrompt,
-	registerForPushNotifications,
-	setDefaultNotificationUrl,
-	setDefaultTitle,
-	getTags,
-	sendTag,
-	sendTags,
-	deleteTag,
-	deleteTags,
-	addListenerForNotificationOpened,
-	setSubscription,
-	showHttpPermissionRequest,
-	showNativePrompt,
-	showSlidedownPrompt,
-	showCategorySlidedown,
-	showSmsSlidedown,
-	showEmailSlidedown,
-	showSmsAndEmailSlidedown,
-	getNotificationPermission,
-	getUserId,
-	getSubscription,
-	setEmail,
-	setSMSNumber,
-	logoutEmail,
-	logoutSMS,
-	setExternalUserId,
-	removeExternalUserId,
-	getExternalUserId,
-	provideUserConsent,
-	getEmailId,
-	getSMSId,
-	sendOutcome,
+	setConsentGiven: oneSignalSetConsentGiven,
+	setConsentRequired: oneSignalSetConsentRequired,
+	Slidedown: SlidedownNamespace,
+	Notifications: NotificationsNamespace,
+	Session: SessionNamespace,
+	User: UserNamespace,
+	Debug: DebugNamespace,
 };
 
 const OneSignalVuePlugin = {
   install(app: typeof VueApp) {
-    app.prototype.$OneSignal = OneSignalVue as IOneSignal;
+    app.prototype.$OneSignal = OneSignalNamespace as IOneSignalOneSignal;
   }
 }