@onesignal/onesignal-vue3 1.0.0

package/dist/index.js

@@ -0,0 +1,710 @@
+import { inject } 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;
+let isOneSignalInitialized = false;
+const vueOneSignalFunctionQueue = [];
+/* H E L P E R S */
+const injectScript = () => {
+    const script = document.createElement('script');
+    script.id = ONESIGNAL_SDK_ID;
+    script.src = ONE_SIGNAL_SCRIPT_SRC;
+    script.async = true;
+    document.head.appendChild(script);
+};
+const doesOneSignalExist = () => {
+    if (window.OneSignal) {
+        return true;
+    }
+    return false;
+};
+const processQueuedOneSignalFunctions = () => {
+    vueOneSignalFunctionQueue.forEach(element => {
+        const { name, args, promiseResolver } = element;
+        if (!!promiseResolver) {
+            OneSignalVue[name](...args).then((result) => {
+                promiseResolver(result);
+            });
+        }
+        else {
+            window.OneSignal[name](...args);
+        }
+    });
+};
+const setupOneSignalIfMissing = () => {
+    if (!doesOneSignalExist()) {
+        window.OneSignal = window.OneSignal || [];
+    }
+};
+/* O N E S I G N A L   A P I  */
+function init(options) {
+    return new Promise(resolve => {
+        if (isOneSignalInitialized) {
+            return;
+        }
+        injectScript();
+        setupOneSignalIfMissing();
+        window.OneSignal.push(() => {
+            window.OneSignal.init(options);
+        });
+        const timeout = setTimeout(() => {
+            console.error(ONESIGNAL_NOT_SETUP_ERROR);
+        }, MAX_TIMEOUT * 1000);
+        window.OneSignal.push(() => {
+            clearTimeout(timeout);
+            isOneSignalInitialized = true;
+            processQueuedOneSignalFunctions();
+            resolve();
+        });
+    });
+}
+function on(event, listener) {
+    if (!doesOneSignalExist()) {
+        vueOneSignalFunctionQueue.push({
+            name: 'on',
+            args: arguments,
+        });
+        return;
+    }
+    window.OneSignal.push(() => {
+        window.OneSignal.on(event, listener);
+    });
+}
+function off(event, listener) {
+    if (!doesOneSignalExist()) {
+        vueOneSignalFunctionQueue.push({
+            name: 'off',
+            args: arguments,
+        });
+        return;
+    }
+    window.OneSignal.push(() => {
+        window.OneSignal.off(event, listener);
+    });
+}
+function once(event, listener) {
+    if (!doesOneSignalExist()) {
+        vueOneSignalFunctionQueue.push({
+            name: 'once',
+            args: arguments,
+        });
+        return;
+    }
+    window.OneSignal.push(() => {
+        window.OneSignal.once(event, listener);
+    });
+}
+function isPushNotificationsEnabled(callback) {
+    return new Promise(function (resolve, reject) {
+        if (!doesOneSignalExist()) {
+            vueOneSignalFunctionQueue.push({
+                name: 'isPushNotificationsEnabled',
+                args: arguments,
+                promiseResolver: resolve,
+            });
+            return;
+        }
+        window.OneSignal.push(() => {
+            window.OneSignal.isPushNotificationsEnabled(callback)
+                .then(value => resolve(value))
+                .catch(error => reject(error));
+        });
+    });
+}
+function showHttpPrompt(options) {
+    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 registerForPushNotifications(options) {
+    return new Promise(function (resolve, reject) {
+        if (!doesOneSignalExist()) {
+            vueOneSignalFunctionQueue.push({
+                name: 'registerForPushNotifications',
+                args: arguments,
+                promiseResolver: resolve,
+            });
+            return;
+        }
+        window.OneSignal.push(() => {
+            window.OneSignal.registerForPushNotifications(options)
+                .then(value => resolve(value))
+                .catch(error => reject(error));
+        });
+    });
+}
+function setDefaultNotificationUrl(url) {
+    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 setDefaultTitle(title) {
+    return new Promise(function (resolve, reject) {
+        if (!doesOneSignalExist()) {
+            vueOneSignalFunctionQueue.push({
+                name: 'setDefaultTitle',
+                args: arguments,
+                promiseResolver: resolve,
+            });
+            return;
+        }
+        window.OneSignal.push(() => {
+            window.OneSignal.setDefaultTitle(title)
+                .then(value => resolve(value))
+                .catch(error => reject(error));
+        });
+    });
+}
+function getTags(callback) {
+    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 sendTag(key, value, callback) {
+    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)
+                .then(value => resolve(value))
+                .catch(error => reject(error));
+        });
+    });
+}
+function sendTags(tags, callback) {
+    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 deleteTag(tag) {
+    return new Promise(function (resolve, reject) {
+        if (!doesOneSignalExist()) {
+            vueOneSignalFunctionQueue.push({
+                name: 'deleteTag',
+                args: arguments,
+                promiseResolver: resolve,
+            });
+            return;
+        }
+        window.OneSignal.push(() => {
+            window.OneSignal.deleteTag(tag)
+                .then(value => resolve(value))
+                .catch(error => reject(error));
+        });
+    });
+}
+function deleteTags(tags, callback) {
+    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 addListenerForNotificationOpened(callback) {
+    return new Promise(function (resolve, reject) {
+        if (!doesOneSignalExist()) {
+            vueOneSignalFunctionQueue.push({
+                name: 'addListenerForNotificationOpened',
+                args: arguments,
+                promiseResolver: resolve,
+            });
+            return;
+        }
+        window.OneSignal.push(() => {
+            window.OneSignal.addListenerForNotificationOpened(callback)
+                .then(value => resolve(value))
+                .catch(error => reject(error));
+        });
+    });
+}
+function setSubscription(newSubscription) {
+    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 showHttpPermissionRequest(options) {
+    return new Promise(function (resolve, reject) {
+        if (!doesOneSignalExist()) {
+            vueOneSignalFunctionQueue.push({
+                name: 'showHttpPermissionRequest',
+                args: arguments,
+                promiseResolver: resolve,
+            });
+            return;
+        }
+        window.OneSignal.push(() => {
+            window.OneSignal.showHttpPermissionRequest(options)
+                .then(value => resolve(value))
+                .catch(error => reject(error));
+        });
+    });
+}
+function showNativePrompt() {
+    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 showSlidedownPrompt(options) {
+    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 showCategorySlidedown(options) {
+    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 showSmsSlidedown(options) {
+    return new Promise(function (resolve, reject) {
+        if (!doesOneSignalExist()) {
+            vueOneSignalFunctionQueue.push({
+                name: 'showSmsSlidedown',
+                args: arguments,
+                promiseResolver: resolve,
+            });
+            return;
+        }
+        window.OneSignal.push(() => {
+            window.OneSignal.showSmsSlidedown(options)
+                .then(value => resolve(value))
+                .catch(error => reject(error));
+        });
+    });
+}
+function showEmailSlidedown(options) {
+    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 showSmsAndEmailSlidedown(options) {
+    return new Promise(function (resolve, reject) {
+        if (!doesOneSignalExist()) {
+            vueOneSignalFunctionQueue.push({
+                name: 'showSmsAndEmailSlidedown',
+                args: arguments,
+                promiseResolver: resolve,
+            });
+            return;
+        }
+        window.OneSignal.push(() => {
+            window.OneSignal.showSmsAndEmailSlidedown(options)
+                .then(value => resolve(value))
+                .catch(error => reject(error));
+        });
+    });
+}
+function getNotificationPermission(onComplete) {
+    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 getUserId(callback) {
+    return new Promise(function (resolve, reject) {
+        if (!doesOneSignalExist()) {
+            vueOneSignalFunctionQueue.push({
+                name: 'getUserId',
+                args: arguments,
+                promiseResolver: resolve,
+            });
+            return;
+        }
+        window.OneSignal.push(() => {
+            window.OneSignal.getUserId(callback)
+                .then(value => resolve(value))
+                .catch(error => reject(error));
+        });
+    });
+}
+function getSubscription(callback) {
+    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 setEmail(email, options) {
+    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)
+                .then(value => resolve(value))
+                .catch(error => reject(error));
+        });
+    });
+}
+function setSMSNumber(smsNumber, options) {
+    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 logoutEmail() {
+    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 logoutSMS() {
+    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 setExternalUserId(externalUserId, authHash) {
+    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 removeExternalUserId() {
+    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 getExternalUserId() {
+    return new Promise(function (resolve, reject) {
+        if (!doesOneSignalExist()) {
+            vueOneSignalFunctionQueue.push({
+                name: 'getExternalUserId',
+                args: arguments,
+                promiseResolver: resolve,
+            });
+            return;
+        }
+        window.OneSignal.push(() => {
+            window.OneSignal.getExternalUserId()
+                .then(value => resolve(value))
+                .catch(error => reject(error));
+        });
+    });
+}
+function provideUserConsent(consent) {
+    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 getEmailId(callback) {
+    return new Promise(function (resolve, reject) {
+        if (!doesOneSignalExist()) {
+            vueOneSignalFunctionQueue.push({
+                name: 'getEmailId',
+                args: arguments,
+                promiseResolver: resolve,
+            });
+            return;
+        }
+        window.OneSignal.push(() => {
+            window.OneSignal.getEmailId(callback)
+                .then(value => resolve(value))
+                .catch(error => reject(error));
+        });
+    });
+}
+function getSMSId(callback) {
+    return new Promise(function (resolve, reject) {
+        if (!doesOneSignalExist()) {
+            vueOneSignalFunctionQueue.push({
+                name: 'getSMSId',
+                args: arguments,
+                promiseResolver: resolve,
+            });
+            return;
+        }
+        window.OneSignal.push(() => {
+            window.OneSignal.getSMSId(callback)
+                .then(value => resolve(value))
+                .catch(error => reject(error));
+        });
+    });
+}
+function sendOutcome(outcomeName, outcomeWeight) {
+    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)
+                .then(value => resolve(value))
+                .catch(error => reject(error));
+        });
+    });
+}
+const OneSignalVue = {
+    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,
+};
+const INJECT_KEY = "onesignal";
+export const useOneSignal = () => {
+    return inject(INJECT_KEY);
+};
+const OneSignalVuePlugin = {
+    install(app, options) {
+        app.config.globalProperties.$OneSignal = OneSignalVue;
+        app.config.globalProperties.$OneSignal.init(options);
+        app.provide(INJECT_KEY, OneSignalVue);
+    }
+};
+export default OneSignalVuePlugin;
+//# sourceMappingURL=index.js.map