sinch-rtc/npm/src/push/PushServiceWorker.js

RTC JavaScript/Web SDK

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ServiceWorkerFactory = exports.PushServiceWorker = void 0;
const utils_1 = require("../utils");
class PushServiceWorker {
    constructor(name, serviceWorker) {
        this.name = name;
        this.serviceWorker = serviceWorker;
    }
    register() {
        return __awaiter(this, void 0, void 0, function* () {
            this.serviceWorker.register(this.name);
            this.registration = yield this.serviceWorker.ready;
        });
    }
    unregister() {
        return __awaiter(this, void 0, void 0, function* () {
            if (this.registration) {
                yield this.registration.unregister();
                this.registration = undefined;
            }
        });
    }
    subscribe(applicationServerKey) {
        const keyUint8 = utils_1.Base64Helper.decodeUrlSafeToUint8Array(applicationServerKey);
        const keyAsArray = new Uint8Array(keyUint8);
        return this.serviceWorkerRegistration.pushManager.subscribe({
            userVisibleOnly: true,
            applicationServerKey: keyAsArray,
        });
    }
    unsubscribe(subscription) {
        return __awaiter(this, void 0, void 0, function* () {
            if (!(yield subscription.unsubscribe()))
                console.log("Unable to unsubscribe push notifications");
        });
    }
    getSubscription() {
        return this.serviceWorkerRegistration.pushManager.getSubscription();
    }
    showNotification(title, options) {
        this.serviceWorkerRegistration.showNotification(title, options);
    }
    addEventListener(listener) {
        if (this.registration) {
            this.serviceWorker.addEventListener("message", (event) => {
                listener.fire(event.data);
            });
        }
    }
    isPushManagerAvailable() {
        return (this.serviceWorkerRegistration.pushManager !== undefined &&
            this.serviceWorkerRegistration.pushManager !== null);
    }
    arePushPermissionsExplicitlyDenied() {
        return __awaiter(this, void 0, void 0, function* () {
            const permissionState = yield this.serviceWorkerRegistration.pushManager.permissionState({
                userVisibleOnly: true,
            });
            return permissionState === PushServiceWorker.PERMISSION_DENIED;
        });
    }
    get serviceWorkerRegistration() {
        if (!this.registration)
            throw new Error("No registered ServiceWorker");
        return this.registration;
    }
}
exports.PushServiceWorker = PushServiceWorker;
PushServiceWorker.PERMISSION_DENIED = "denied";
class ServiceWorkerFactory {
    static create(name) {
        if (!this.serviceWorker) {
            throw Error(`Unable to register ServiceWorker: ${name}`);
        }
        return new PushServiceWorker(name, this.serviceWorker);
    }
}
exports.ServiceWorkerFactory = ServiceWorkerFactory;
ServiceWorkerFactory.serviceWorker = typeof navigator !== "undefined" ? navigator.serviceWorker : undefined;
//# sourceMappingURL=PushServiceWorker.js.map