onesignal-vue 1.0.0-beta2 → 1.0.1

package/index.ts

@@ -66,7 +66,7 @@ interface IOneSignalFunctionCall {
   promiseResolver?: Function;
 }
 
-interface Action<T>{ (item: T): void; }
+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; }
@@ -74,14 +74,34 @@ 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[]; }
-export interface IOneSignalTagCategory { tag: string; label: string; checked?: boolean; }
-
+interface IOneSignalTagCategory { tag: string; label: string; checked?: boolean; }
+
+interface IInitObject {
+  appId: string;
+  subdomainName?: string;
+  requiresUserPrivacyConsent?: boolean;
+  promptOptions?: object;
+  welcomeNotification?: object;
+  notifyButton?: object;
+  persistNotification?: boolean;
+  webhooks?: object;
+  autoResubscribe?: boolean;
+  autoRegister?: boolean;
+  notificationClickHandlerMatch?: string;
+  notificationClickHandlerAction?: string;
+  serviceWorkerParam?: { scope: string };
+  serviceWorkerPath?: string;
+  serviceWorkerUpdaterPath?: string;
+  path?: string;
+  allowLocalhostAsSecureOrigin?: boolean;
+  [key: string]: any;
+}
 
 interface IOneSignal {
-	init(options?: any): Promise<void>
-	on(event: string, listener: Function): void
-	off(event: string, listener: Function): void
-	once(event: string, listener: Function): void
+	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>
@@ -121,7 +141,7 @@ interface IOneSignal {
 
 /* O N E S I G N A L   A P I  */
 
-function init(options: Object = {}) {
+function init(options: IInitObject) {
   return new Promise<void>(resolve => {
     if (isOneSignalInitialized) {
       return;
@@ -149,7 +169,7 @@ function init(options: Object = {}) {
   function on(event, listener): void {
     if (!doesOneSignalExist()) {
       vueOneSignalFunctionQueue.push({
-        name: "on",
+        name: 'on',
         args: arguments,
       });
       return;
@@ -158,12 +178,12 @@ function init(options: Object = {}) {
     window.OneSignal.push(() => {
       window.OneSignal.on(event, listener)
     });
-  };
+  }
 
   function off(event, listener): void {
     if (!doesOneSignalExist()) {
       vueOneSignalFunctionQueue.push({
-        name: "off",
+        name: 'off',
         args: arguments,
       });
       return;
@@ -172,12 +192,12 @@ function init(options: Object = {}) {
     window.OneSignal.push(() => {
       window.OneSignal.off(event, listener)
     });
-  };
+  }
 
   function once(event, listener): void {
     if (!doesOneSignalExist()) {
       vueOneSignalFunctionQueue.push({
-        name: "once",
+        name: 'once',
         args: arguments,
       });
       return;
@@ -186,13 +206,13 @@ function init(options: Object = {}) {
     window.OneSignal.push(() => {
       window.OneSignal.once(event, listener)
     });
-  };
+  }
 
   function isPushNotificationsEnabled(callback): Promise<boolean> {
     return new Promise(function (resolve, reject) {
       if (!doesOneSignalExist()) {
         vueOneSignalFunctionQueue.push({
-          name: "isPushNotificationsEnabled",
+          name: 'isPushNotificationsEnabled',
           args: arguments,
           promiseResolver: resolve,
         });
@@ -205,13 +225,13 @@ function init(options: Object = {}) {
           .catch((error) => reject(error));
       });
     });
-  };
+  }
 
   function showHttpPrompt(options): Promise<void> {
     return new Promise(function (resolve, reject) {
       if (!doesOneSignalExist()) {
         vueOneSignalFunctionQueue.push({
-          name: "showHttpPrompt",
+          name: 'showHttpPrompt',
           args: arguments,
           promiseResolver: resolve,
         });
@@ -224,13 +244,13 @@ function init(options: Object = {}) {
           .catch((error) => reject(error));
       });
     });
-  };
+  }
 
   function registerForPushNotifications(options): Promise<void> {
     return new Promise(function (resolve, reject) {
       if (!doesOneSignalExist()) {
         vueOneSignalFunctionQueue.push({
-          name: "registerForPushNotifications",
+          name: 'registerForPushNotifications',
           args: arguments,
           promiseResolver: resolve,
         });
@@ -243,13 +263,13 @@ function init(options: Object = {}) {
           .catch((error) => reject(error));
       });
     });
-  };
+  }
 
   function setDefaultNotificationUrl(url): Promise<void> {
     return new Promise(function (resolve, reject) {
       if (!doesOneSignalExist()) {
         vueOneSignalFunctionQueue.push({
-          name: "setDefaultNotificationUrl",
+          name: 'setDefaultNotificationUrl',
           args: arguments,
           promiseResolver: resolve,
         });
@@ -262,13 +282,13 @@ function init(options: Object = {}) {
           .catch((error) => reject(error));
       });
     });
-  };
+  }
 
   function setDefaultTitle(title): Promise<void> {
     return new Promise(function (resolve, reject) {
       if (!doesOneSignalExist()) {
         vueOneSignalFunctionQueue.push({
-          name: "setDefaultTitle",
+          name: 'setDefaultTitle',
           args: arguments,
           promiseResolver: resolve,
         });
@@ -281,13 +301,13 @@ function init(options: Object = {}) {
           .catch((error) => reject(error));
       });
     });
-  };
+  }
 
   function getTags(callback): Promise<void> {
     return new Promise(function (resolve, reject) {
       if (!doesOneSignalExist()) {
         vueOneSignalFunctionQueue.push({
-          name: "getTags",
+          name: 'getTags',
           args: arguments,
           promiseResolver: resolve,
         });
@@ -300,13 +320,13 @@ function init(options: Object = {}) {
           .catch((error) => reject(error));
       });
     });
-  };
+  }
 
   function sendTag(key, value, callback): Promise<Object | null> {
     return new Promise(function (resolve, reject) {
       if (!doesOneSignalExist()) {
         vueOneSignalFunctionQueue.push({
-          name: "sendTag",
+          name: 'sendTag',
           args: arguments,
           promiseResolver: resolve,
         });
@@ -319,13 +339,13 @@ function init(options: Object = {}) {
           .catch((error) => reject(error));
       });
     });
-  };
+  }
 
   function sendTags(tags, callback): Promise<Object | null> {
     return new Promise(function (resolve, reject) {
       if (!doesOneSignalExist()) {
         vueOneSignalFunctionQueue.push({
-          name: "sendTags",
+          name: 'sendTags',
           args: arguments,
           promiseResolver: resolve,
         });
@@ -338,13 +358,13 @@ function init(options: Object = {}) {
           .catch((error) => reject(error));
       });
     });
-  };
+  }
 
   function deleteTag(tag): Promise<Array<string>> {
     return new Promise(function (resolve, reject) {
       if (!doesOneSignalExist()) {
         vueOneSignalFunctionQueue.push({
-          name: "deleteTag",
+          name: 'deleteTag',
           args: arguments,
           promiseResolver: resolve,
         });
@@ -357,13 +377,13 @@ function init(options: Object = {}) {
           .catch((error) => reject(error));
       });
     });
-  };
+  }
 
   function deleteTags(tags, callback): Promise<Array<string>> {
     return new Promise(function (resolve, reject) {
       if (!doesOneSignalExist()) {
         vueOneSignalFunctionQueue.push({
-          name: "deleteTags",
+          name: 'deleteTags',
           args: arguments,
           promiseResolver: resolve,
         });
@@ -376,13 +396,13 @@ function init(options: Object = {}) {
           .catch((error) => reject(error));
       });
     });
-  };
+  }
 
   function addListenerForNotificationOpened(callback): Promise<void> {
     return new Promise(function (resolve, reject) {
       if (!doesOneSignalExist()) {
         vueOneSignalFunctionQueue.push({
-          name: "addListenerForNotificationOpened",
+          name: 'addListenerForNotificationOpened',
           args: arguments,
           promiseResolver: resolve,
         });
@@ -395,13 +415,13 @@ function init(options: Object = {}) {
           .catch((error) => reject(error));
       });
     });
-  };
+  }
 
   function setSubscription(newSubscription): Promise<void> {
     return new Promise(function (resolve, reject) {
       if (!doesOneSignalExist()) {
         vueOneSignalFunctionQueue.push({
-          name: "setSubscription",
+          name: 'setSubscription',
           args: arguments,
           promiseResolver: resolve,
         });
@@ -414,13 +434,13 @@ function init(options: Object = {}) {
           .catch((error) => reject(error));
       });
     });
-  };
+  }
 
   function showHttpPermissionRequest(options): Promise<any> {
     return new Promise(function (resolve, reject) {
       if (!doesOneSignalExist()) {
         vueOneSignalFunctionQueue.push({
-          name: "showHttpPermissionRequest",
+          name: 'showHttpPermissionRequest',
           args: arguments,
           promiseResolver: resolve,
         });
@@ -433,13 +453,13 @@ function init(options: Object = {}) {
           .catch((error) => reject(error));
       });
     });
-  };
+  }
 
   function showNativePrompt(): Promise<void> {
     return new Promise(function (resolve, reject) {
       if (!doesOneSignalExist()) {
         vueOneSignalFunctionQueue.push({
-          name: "showNativePrompt",
+          name: 'showNativePrompt',
           args: arguments,
           promiseResolver: resolve,
         });
@@ -452,13 +472,13 @@ function init(options: Object = {}) {
           .catch((error) => reject(error));
       });
     });
-  };
+  }
 
   function showSlidedownPrompt(options): Promise<void> {
     return new Promise(function (resolve, reject) {
       if (!doesOneSignalExist()) {
         vueOneSignalFunctionQueue.push({
-          name: "showSlidedownPrompt",
+          name: 'showSlidedownPrompt',
           args: arguments,
           promiseResolver: resolve,
         });
@@ -471,13 +491,13 @@ function init(options: Object = {}) {
           .catch((error) => reject(error));
       });
     });
-  };
+  }
 
   function showCategorySlidedown(options): Promise<void> {
     return new Promise(function (resolve, reject) {
       if (!doesOneSignalExist()) {
         vueOneSignalFunctionQueue.push({
-          name: "showCategorySlidedown",
+          name: 'showCategorySlidedown',
           args: arguments,
           promiseResolver: resolve,
         });
@@ -490,13 +510,13 @@ function init(options: Object = {}) {
           .catch((error) => reject(error));
       });
     });
-  };
+  }
 
   function showSmsSlidedown(options): Promise<void> {
     return new Promise(function (resolve, reject) {
       if (!doesOneSignalExist()) {
         vueOneSignalFunctionQueue.push({
-          name: "showSmsSlidedown",
+          name: 'showSmsSlidedown',
           args: arguments,
           promiseResolver: resolve,
         });
@@ -509,13 +529,13 @@ function init(options: Object = {}) {
           .catch((error) => reject(error));
       });
     });
-  };
+  }
 
   function showEmailSlidedown(options): Promise<void> {
     return new Promise(function (resolve, reject) {
       if (!doesOneSignalExist()) {
         vueOneSignalFunctionQueue.push({
-          name: "showEmailSlidedown",
+          name: 'showEmailSlidedown',
           args: arguments,
           promiseResolver: resolve,
         });
@@ -528,13 +548,13 @@ function init(options: Object = {}) {
           .catch((error) => reject(error));
       });
     });
-  };
+  }
 
   function showSmsAndEmailSlidedown(options): Promise<void> {
     return new Promise(function (resolve, reject) {
       if (!doesOneSignalExist()) {
         vueOneSignalFunctionQueue.push({
-          name: "showSmsAndEmailSlidedown",
+          name: 'showSmsAndEmailSlidedown',
           args: arguments,
           promiseResolver: resolve,
         });
@@ -547,13 +567,13 @@ function init(options: Object = {}) {
           .catch((error) => reject(error));
       });
     });
-  };
+  }
 
   function getNotificationPermission(onComplete): Promise<NotificationPermission> {
     return new Promise(function (resolve, reject) {
       if (!doesOneSignalExist()) {
         vueOneSignalFunctionQueue.push({
-          name: "getNotificationPermission",
+          name: 'getNotificationPermission',
           args: arguments,
           promiseResolver: resolve,
         });
@@ -566,13 +586,13 @@ function init(options: Object = {}) {
           .catch((error) => reject(error));
       });
     });
-  };
+  }
 
   function getUserId(callback): Promise<string | undefined | null> {
     return new Promise(function (resolve, reject) {
       if (!doesOneSignalExist()) {
         vueOneSignalFunctionQueue.push({
-          name: "getUserId",
+          name: 'getUserId',
           args: arguments,
           promiseResolver: resolve,
         });
@@ -585,13 +605,13 @@ function init(options: Object = {}) {
           .catch((error) => reject(error));
       });
     });
-  };
+  }
 
   function getSubscription(callback): Promise<boolean> {
     return new Promise(function (resolve, reject) {
       if (!doesOneSignalExist()) {
         vueOneSignalFunctionQueue.push({
-          name: "getSubscription",
+          name: 'getSubscription',
           args: arguments,
           promiseResolver: resolve,
         });
@@ -604,13 +624,13 @@ function init(options: Object = {}) {
           .catch((error) => reject(error));
       });
     });
-  };
+  }
 
   function setEmail(email, options): Promise<string|null> {
     return new Promise(function (resolve, reject) {
       if (!doesOneSignalExist()) {
         vueOneSignalFunctionQueue.push({
-          name: "setEmail",
+          name: 'setEmail',
           args: arguments,
           promiseResolver: resolve,
         });
@@ -623,13 +643,13 @@ function init(options: Object = {}) {
           .catch((error) => reject(error));
       });
     });
-  };
+  }
 
   function setSMSNumber(smsNumber, options): Promise<string | null> {
     return new Promise(function (resolve, reject) {
       if (!doesOneSignalExist()) {
         vueOneSignalFunctionQueue.push({
-          name: "setSMSNumber",
+          name: 'setSMSNumber',
           args: arguments,
           promiseResolver: resolve,
         });
@@ -642,13 +662,13 @@ function init(options: Object = {}) {
           .catch((error) => reject(error));
       });
     });
-  };
+  }
 
   function logoutEmail(): Promise<void> {
     return new Promise(function (resolve, reject) {
       if (!doesOneSignalExist()) {
         vueOneSignalFunctionQueue.push({
-          name: "logoutEmail",
+          name: 'logoutEmail',
           args: arguments,
           promiseResolver: resolve,
         });
@@ -661,13 +681,13 @@ function init(options: Object = {}) {
           .catch((error) => reject(error));
       });
     });
-  };
+  }
 
   function logoutSMS(): Promise<void> {
     return new Promise(function (resolve, reject) {
       if (!doesOneSignalExist()) {
         vueOneSignalFunctionQueue.push({
-          name: "logoutSMS",
+          name: 'logoutSMS',
           args: arguments,
           promiseResolver: resolve,
         });
@@ -680,13 +700,13 @@ function init(options: Object = {}) {
           .catch((error) => reject(error));
       });
     });
-  };
+  }
 
   function setExternalUserId(externalUserId, authHash): Promise<void> {
     return new Promise(function (resolve, reject) {
       if (!doesOneSignalExist()) {
         vueOneSignalFunctionQueue.push({
-          name: "setExternalUserId",
+          name: 'setExternalUserId',
           args: arguments,
           promiseResolver: resolve,
         });
@@ -699,13 +719,13 @@ function init(options: Object = {}) {
           .catch((error) => reject(error));
       });
     });
-  };
+  }
 
   function removeExternalUserId(): Promise<void> {
     return new Promise(function (resolve, reject) {
       if (!doesOneSignalExist()) {
         vueOneSignalFunctionQueue.push({
-          name: "removeExternalUserId",
+          name: 'removeExternalUserId',
           args: arguments,
           promiseResolver: resolve,
         });
@@ -718,13 +738,13 @@ function init(options: Object = {}) {
           .catch((error) => reject(error));
       });
     });
-  };
+  }
 
   function getExternalUserId(): Promise<string | undefined | null> {
     return new Promise(function (resolve, reject) {
       if (!doesOneSignalExist()) {
         vueOneSignalFunctionQueue.push({
-          name: "getExternalUserId",
+          name: 'getExternalUserId',
           args: arguments,
           promiseResolver: resolve,
         });
@@ -737,13 +757,13 @@ function init(options: Object = {}) {
           .catch((error) => reject(error));
       });
     });
-  };
+  }
 
   function provideUserConsent(consent): Promise<void> {
     return new Promise(function (resolve, reject) {
       if (!doesOneSignalExist()) {
         vueOneSignalFunctionQueue.push({
-          name: "provideUserConsent",
+          name: 'provideUserConsent',
           args: arguments,
           promiseResolver: resolve,
         });
@@ -756,13 +776,13 @@ function init(options: Object = {}) {
           .catch((error) => reject(error));
       });
     });
-  };
+  }
 
   function getEmailId(callback): Promise<string | null | undefined> {
     return new Promise(function (resolve, reject) {
       if (!doesOneSignalExist()) {
         vueOneSignalFunctionQueue.push({
-          name: "getEmailId",
+          name: 'getEmailId',
           args: arguments,
           promiseResolver: resolve,
         });
@@ -775,13 +795,13 @@ function init(options: Object = {}) {
           .catch((error) => reject(error));
       });
     });
-  };
+  }
 
   function getSMSId(callback): Promise<string | null | undefined> {
     return new Promise(function (resolve, reject) {
       if (!doesOneSignalExist()) {
         vueOneSignalFunctionQueue.push({
-          name: "getSMSId",
+          name: 'getSMSId',
           args: arguments,
           promiseResolver: resolve,
         });
@@ -794,13 +814,13 @@ function init(options: Object = {}) {
           .catch((error) => reject(error));
       });
     });
-  };
+  }
 
   function sendOutcome(outcomeName, outcomeWeight): Promise<void> {
     return new Promise(function (resolve, reject) {
       if (!doesOneSignalExist()) {
         vueOneSignalFunctionQueue.push({
-          name: "sendOutcome",
+          name: 'sendOutcome',
           args: arguments,
           promiseResolver: resolve,
         });
@@ -813,7 +833,7 @@ function init(options: Object = {}) {
           .catch((error) => reject(error));
       });
     });
-  };
+  }
 
 const OneSignalVue: IOneSignal = {
 	init,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onesignal-vue",
-  "version": "1.0.0-beta2",
+  "version": "1.0.1",
   "description": "Vue OneSignal Plugin: Make it easy to integrate OneSignal with your Vue App!",
   "author": "rgomezp",
   "contributors": [{ "name": "Rodrigo Gomez-Palacio" }],

package/rollup.config.js

@@ -34,4 +34,3 @@ export default {
     commonjs(),
   ],
 };
-

package/index.d.ts

@@ -1,53 +0,0 @@
-declare module 'vue-onesignal' {
-	interface 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[]; }
-	export interface IOneSignalTagCategory { tag: string; label: string; checked?: boolean; }
-
-	interface IOneSignal {
-		init(options?: any): Promise<void>
-		on(event: string, listener: Function): void
-		off(event: string, listener: Function): void
-		once(event: string, listener: Function): 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?: Function): 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>
-	}
-	const OneSignalVue: IOneSignal;
-	export default OneSignalVue;
-}