@markwharton/pwa-push 1.0.0

package/dist/client/deviceId.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Device ID utilities for subscription deduplication
+ * Prevents duplicate subscriptions when service worker re-registers
+ */
+/**
+ * Get or create a persistent device ID
+ * Uses localStorage (main thread only)
+ */
+export declare function getDeviceId(): string;
+/**
+ * Clear the device ID (for testing or logout)
+ */
+export declare function clearDeviceId(): void;

package/dist/client/deviceId.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * Device ID utilities for subscription deduplication
+ * Prevents duplicate subscriptions when service worker re-registers
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDeviceId = getDeviceId;
+exports.clearDeviceId = clearDeviceId;
+const DEVICE_ID_KEY = 'push_device_id';
+/**
+ * Generate a UUID v4
+ */
+function generateUUID() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0;
+        const v = c === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+/**
+ * Get or create a persistent device ID
+ * Uses localStorage (main thread only)
+ */
+function getDeviceId() {
+    let deviceId = localStorage.getItem(DEVICE_ID_KEY);
+    if (!deviceId) {
+        deviceId = generateUUID();
+        localStorage.setItem(DEVICE_ID_KEY, deviceId);
+    }
+    return deviceId;
+}
+/**
+ * Clear the device ID (for testing or logout)
+ */
+function clearDeviceId() {
+    localStorage.removeItem(DEVICE_ID_KEY);
+}

package/dist/client/index.d.ts

@@ -0,0 +1,4 @@
+export { getDeviceId, clearDeviceId } from './deviceId';
+export { saveSubscriptionData, getSubscriptionData, clearSubscriptionData } from './indexedDb';
+export { getPermissionState, requestPermission, isPushSupported, subscribeToPush, unsubscribeFromPush, getCurrentSubscription } from './subscribe';
+export { handleSubscriptionChange } from './renewal';

package/dist/client/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleSubscriptionChange = exports.getCurrentSubscription = exports.unsubscribeFromPush = exports.subscribeToPush = exports.isPushSupported = exports.requestPermission = exports.getPermissionState = exports.clearSubscriptionData = exports.getSubscriptionData = exports.saveSubscriptionData = exports.clearDeviceId = exports.getDeviceId = void 0;
+var deviceId_1 = require("./deviceId");
+Object.defineProperty(exports, "getDeviceId", { enumerable: true, get: function () { return deviceId_1.getDeviceId; } });
+Object.defineProperty(exports, "clearDeviceId", { enumerable: true, get: function () { return deviceId_1.clearDeviceId; } });
+var indexedDb_1 = require("./indexedDb");
+Object.defineProperty(exports, "saveSubscriptionData", { enumerable: true, get: function () { return indexedDb_1.saveSubscriptionData; } });
+Object.defineProperty(exports, "getSubscriptionData", { enumerable: true, get: function () { return indexedDb_1.getSubscriptionData; } });
+Object.defineProperty(exports, "clearSubscriptionData", { enumerable: true, get: function () { return indexedDb_1.clearSubscriptionData; } });
+var subscribe_1 = require("./subscribe");
+Object.defineProperty(exports, "getPermissionState", { enumerable: true, get: function () { return subscribe_1.getPermissionState; } });
+Object.defineProperty(exports, "requestPermission", { enumerable: true, get: function () { return subscribe_1.requestPermission; } });
+Object.defineProperty(exports, "isPushSupported", { enumerable: true, get: function () { return subscribe_1.isPushSupported; } });
+Object.defineProperty(exports, "subscribeToPush", { enumerable: true, get: function () { return subscribe_1.subscribeToPush; } });
+Object.defineProperty(exports, "unsubscribeFromPush", { enumerable: true, get: function () { return subscribe_1.unsubscribeFromPush; } });
+Object.defineProperty(exports, "getCurrentSubscription", { enumerable: true, get: function () { return subscribe_1.getCurrentSubscription; } });
+var renewal_1 = require("./renewal");
+Object.defineProperty(exports, "handleSubscriptionChange", { enumerable: true, get: function () { return renewal_1.handleSubscriptionChange; } });

package/dist/client/indexedDb.d.ts

@@ -0,0 +1,17 @@
+/**
+ * IndexedDB utilities for service worker data persistence
+ * Service workers cannot access localStorage, so we use IndexedDB
+ */
+import { SubscriptionData } from '../types';
+/**
+ * Save subscription data to IndexedDB (for service worker access)
+ */
+export declare function saveSubscriptionData(data: SubscriptionData): Promise<void>;
+/**
+ * Get subscription data from IndexedDB
+ */
+export declare function getSubscriptionData(): Promise<SubscriptionData | null>;
+/**
+ * Clear subscription data from IndexedDB
+ */
+export declare function clearSubscriptionData(): Promise<void>;

package/dist/client/indexedDb.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * IndexedDB utilities for service worker data persistence
+ * Service workers cannot access localStorage, so we use IndexedDB
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveSubscriptionData = saveSubscriptionData;
+exports.getSubscriptionData = getSubscriptionData;
+exports.clearSubscriptionData = clearSubscriptionData;
+const DB_NAME = 'PushSubscriptionDB';
+const STORE_NAME = 'subscriptionData';
+const DATA_KEY = 'current';
+/**
+ * Open the IndexedDB database
+ */
+function openDatabase() {
+    return new Promise((resolve, reject) => {
+        const request = indexedDB.open(DB_NAME, 1);
+        request.onerror = () => reject(request.error);
+        request.onsuccess = () => resolve(request.result);
+        request.onupgradeneeded = (event) => {
+            const db = event.target.result;
+            if (!db.objectStoreNames.contains(STORE_NAME)) {
+                db.createObjectStore(STORE_NAME);
+            }
+        };
+    });
+}
+/**
+ * Save subscription data to IndexedDB (for service worker access)
+ */
+async function saveSubscriptionData(data) {
+    const db = await openDatabase();
+    return new Promise((resolve, reject) => {
+        const transaction = db.transaction(STORE_NAME, 'readwrite');
+        const store = transaction.objectStore(STORE_NAME);
+        const request = store.put(data, DATA_KEY);
+        request.onerror = () => reject(request.error);
+        request.onsuccess = () => resolve();
+        transaction.oncomplete = () => db.close();
+    });
+}
+/**
+ * Get subscription data from IndexedDB
+ */
+async function getSubscriptionData() {
+    const db = await openDatabase();
+    return new Promise((resolve, reject) => {
+        const transaction = db.transaction(STORE_NAME, 'readonly');
+        const store = transaction.objectStore(STORE_NAME);
+        const request = store.get(DATA_KEY);
+        request.onerror = () => reject(request.error);
+        request.onsuccess = () => resolve(request.result || null);
+        transaction.oncomplete = () => db.close();
+    });
+}
+/**
+ * Clear subscription data from IndexedDB
+ */
+async function clearSubscriptionData() {
+    const db = await openDatabase();
+    return new Promise((resolve, reject) => {
+        const transaction = db.transaction(STORE_NAME, 'readwrite');
+        const store = transaction.objectStore(STORE_NAME);
+        const request = store.delete(DATA_KEY);
+        request.onerror = () => reject(request.error);
+        request.onsuccess = () => resolve();
+        transaction.oncomplete = () => db.close();
+    });
+}

package/dist/client/renewal.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Push subscription renewal handler for service worker
+ * Handles the 'pushsubscriptionchange' event when browser rotates subscriptions
+ */
+/**
+ * Handle pushsubscriptionchange event in service worker
+ * Call this from your service worker's event listener
+ *
+ * Usage in sw.js:
+ * ```
+ * self.addEventListener('pushsubscriptionchange', (event) => {
+ *     event.waitUntil(handleSubscriptionChange(event, '/api/push/renew'));
+ * });
+ * ```
+ */
+export declare function handleSubscriptionChange(event: PushSubscriptionChangeEvent, renewEndpoint: string): Promise<boolean>;
+/**
+ * Type for pushsubscriptionchange event
+ */
+interface PushSubscriptionChangeEvent extends ExtendableEvent {
+    oldSubscription?: PushSubscription;
+    newSubscription?: PushSubscription;
+}
+export {};

package/dist/client/renewal.js

@@ -0,0 +1,99 @@
+"use strict";
+/**
+ * Push subscription renewal handler for service worker
+ * Handles the 'pushsubscriptionchange' event when browser rotates subscriptions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleSubscriptionChange = handleSubscriptionChange;
+const indexedDb_1 = require("./indexedDb");
+/**
+ * Handle pushsubscriptionchange event in service worker
+ * Call this from your service worker's event listener
+ *
+ * Usage in sw.js:
+ * ```
+ * self.addEventListener('pushsubscriptionchange', (event) => {
+ *     event.waitUntil(handleSubscriptionChange(event, '/api/push/renew'));
+ * });
+ * ```
+ */
+async function handleSubscriptionChange(event, renewEndpoint) {
+    try {
+        // Get stored data from IndexedDB
+        const data = await (0, indexedDb_1.getSubscriptionData)();
+        if (!data) {
+            console.error('No subscription data found for renewal');
+            return false;
+        }
+        // Resubscribe with same VAPID key
+        const newSubscription = await resubscribe(data);
+        if (!newSubscription) {
+            console.error('Failed to create new subscription');
+            return false;
+        }
+        // Build renewal request
+        const renewalRequest = {
+            subscription: newSubscription,
+            deviceId: data.deviceId,
+            basePath: data.basePath
+        };
+        // Send to backend
+        const response = await fetch(renewEndpoint, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(renewalRequest)
+        });
+        if (!response.ok) {
+            console.error('Renewal request failed:', response.status);
+            return false;
+        }
+        console.log('Push subscription renewed successfully');
+        return true;
+    }
+    catch (error) {
+        console.error('Subscription renewal failed:', error);
+        return false;
+    }
+}
+/**
+ * Resubscribe to push with stored VAPID key
+ */
+async function resubscribe(data) {
+    try {
+        const self = globalThis;
+        const registration = self.registration;
+        const applicationServerKey = urlBase64ToUint8Array(data.publicKey);
+        const subscription = await registration.pushManager.subscribe({
+            userVisibleOnly: true,
+            applicationServerKey
+        });
+        const json = subscription.toJSON();
+        return {
+            endpoint: subscription.endpoint,
+            keys: {
+                p256dh: json.keys?.p256dh || '',
+                auth: json.keys?.auth || ''
+            }
+        };
+    }
+    catch (error) {
+        console.error('Resubscribe failed:', error);
+        return null;
+    }
+}
+/**
+ * Convert base64 URL-encoded string to Uint8Array (service worker version)
+ */
+function urlBase64ToUint8Array(base64String) {
+    const padding = '='.repeat((4 - (base64String.length % 4)) % 4);
+    const base64 = (base64String + padding)
+        .replace(/-/g, '+')
+        .replace(/_/g, '/');
+    const rawData = atob(base64);
+    const buffer = new ArrayBuffer(rawData.length);
+    const outputArray = new Uint8Array(buffer);
+    for (let i = 0; i < rawData.length; ++i) {
+        outputArray[i] = rawData.charCodeAt(i);
+    }
+    return outputArray;
+}

package/dist/client/subscribe.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Push subscription helpers for main thread
+ */
+import { PushSubscription, SubscriptionRequest, PushPermissionState } from '../types';
+/**
+ * Check current notification permission state
+ */
+export declare function getPermissionState(): PushPermissionState;
+/**
+ * Request notification permission from user
+ */
+export declare function requestPermission(): Promise<PushPermissionState>;
+/**
+ * Check if push notifications are supported
+ */
+export declare function isPushSupported(): boolean;
+/**
+ * Subscribe to push notifications
+ * Returns subscription request ready to send to backend
+ */
+export declare function subscribeToPush(vapidPublicKey: string, basePath?: string): Promise<SubscriptionRequest | null>;
+/**
+ * Unsubscribe from push notifications
+ */
+export declare function unsubscribeFromPush(): Promise<boolean>;
+/**
+ * Get current push subscription if exists
+ */
+export declare function getCurrentSubscription(): Promise<PushSubscription | null>;

package/dist/client/subscribe.js

@@ -0,0 +1,128 @@
+"use strict";
+/**
+ * Push subscription helpers for main thread
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPermissionState = getPermissionState;
+exports.requestPermission = requestPermission;
+exports.isPushSupported = isPushSupported;
+exports.subscribeToPush = subscribeToPush;
+exports.unsubscribeFromPush = unsubscribeFromPush;
+exports.getCurrentSubscription = getCurrentSubscription;
+const deviceId_1 = require("./deviceId");
+const indexedDb_1 = require("./indexedDb");
+/**
+ * Check current notification permission state
+ */
+function getPermissionState() {
+    return Notification.permission;
+}
+/**
+ * Request notification permission from user
+ */
+async function requestPermission() {
+    const result = await Notification.requestPermission();
+    return result;
+}
+/**
+ * Check if push notifications are supported
+ */
+function isPushSupported() {
+    return 'serviceWorker' in navigator && 'PushManager' in window;
+}
+/**
+ * Convert browser PushSubscription to our format
+ */
+function toPushSubscription(browserSub) {
+    const json = browserSub.toJSON();
+    return {
+        endpoint: browserSub.endpoint,
+        keys: {
+            p256dh: json.keys?.p256dh || '',
+            auth: json.keys?.auth || ''
+        }
+    };
+}
+/**
+ * Subscribe to push notifications
+ * Returns subscription request ready to send to backend
+ */
+async function subscribeToPush(vapidPublicKey, basePath = '/') {
+    if (!isPushSupported()) {
+        console.error('Push notifications not supported');
+        return null;
+    }
+    const permission = await requestPermission();
+    if (permission !== 'granted') {
+        console.warn('Push permission denied');
+        return null;
+    }
+    const registration = await navigator.serviceWorker.ready;
+    const deviceId = (0, deviceId_1.getDeviceId)();
+    // Convert VAPID key to Uint8Array
+    const applicationServerKey = urlBase64ToUint8Array(vapidPublicKey);
+    const browserSub = await registration.pushManager.subscribe({
+        userVisibleOnly: true,
+        applicationServerKey
+    });
+    // Save data for service worker renewal
+    await (0, indexedDb_1.saveSubscriptionData)({
+        publicKey: vapidPublicKey,
+        deviceId,
+        basePath
+    });
+    return {
+        subscription: toPushSubscription(browserSub),
+        deviceId,
+        basePath
+    };
+}
+/**
+ * Unsubscribe from push notifications
+ */
+async function unsubscribeFromPush() {
+    try {
+        const registration = await navigator.serviceWorker.ready;
+        const subscription = await registration.pushManager.getSubscription();
+        if (subscription) {
+            await subscription.unsubscribe();
+        }
+        return true;
+    }
+    catch (error) {
+        console.error('Unsubscribe failed:', error);
+        return false;
+    }
+}
+/**
+ * Get current push subscription if exists
+ */
+async function getCurrentSubscription() {
+    try {
+        const registration = await navigator.serviceWorker.ready;
+        const subscription = await registration.pushManager.getSubscription();
+        if (!subscription) {
+            return null;
+        }
+        return toPushSubscription(subscription);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Convert base64 URL-encoded string to Uint8Array
+ */
+function urlBase64ToUint8Array(base64String) {
+    const padding = '='.repeat((4 - (base64String.length % 4)) % 4);
+    const base64 = (base64String + padding)
+        .replace(/-/g, '+')
+        .replace(/_/g, '/');
+    const rawData = window.atob(base64);
+    const buffer = new ArrayBuffer(rawData.length);
+    const outputArray = new Uint8Array(buffer);
+    for (let i = 0; i < rawData.length; ++i) {
+        outputArray[i] = rawData.charCodeAt(i);
+    }
+    return outputArray;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './server';

package/dist/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Re-export types
+__exportStar(require("./types"), exports);
+// Re-export server utilities (for backend)
+__exportStar(require("./server"), exports);
+// Note: Client utilities should be imported from '@markwharton/pwa-push/client'
+// to avoid including browser-only code in Node.js bundles

package/dist/server/index.d.ts

@@ -0,0 +1 @@
+export { initPush, initPushFromEnv, getVapidPublicKey, sendPushNotification, sendPushToAll, sendPushWithDetails, isSubscriptionExpired } from './send';

package/dist/server/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSubscriptionExpired = exports.sendPushWithDetails = exports.sendPushToAll = exports.sendPushNotification = exports.getVapidPublicKey = exports.initPushFromEnv = exports.initPush = void 0;
+var send_1 = require("./send");
+Object.defineProperty(exports, "initPush", { enumerable: true, get: function () { return send_1.initPush; } });
+Object.defineProperty(exports, "initPushFromEnv", { enumerable: true, get: function () { return send_1.initPushFromEnv; } });
+Object.defineProperty(exports, "getVapidPublicKey", { enumerable: true, get: function () { return send_1.getVapidPublicKey; } });
+Object.defineProperty(exports, "sendPushNotification", { enumerable: true, get: function () { return send_1.sendPushNotification; } });
+Object.defineProperty(exports, "sendPushToAll", { enumerable: true, get: function () { return send_1.sendPushToAll; } });
+Object.defineProperty(exports, "sendPushWithDetails", { enumerable: true, get: function () { return send_1.sendPushWithDetails; } });
+Object.defineProperty(exports, "isSubscriptionExpired", { enumerable: true, get: function () { return send_1.isSubscriptionExpired; } });

package/dist/server/send.d.ts

@@ -0,0 +1,35 @@
+import { PushSubscription, NotificationPayload, SendResult } from '../types';
+/**
+ * Initialize VAPID configuration - call once at startup
+ * Fails fast if keys are missing
+ */
+export declare function initPush(config: {
+    publicKey?: string;
+    privateKey?: string;
+    subject?: string;
+}): void;
+/**
+ * Auto-initialize from environment variables
+ */
+export declare function initPushFromEnv(): void;
+/**
+ * Get the VAPID public key (for client subscription)
+ */
+export declare function getVapidPublicKey(): string;
+/**
+ * Send a push notification to a single subscription
+ */
+export declare function sendPushNotification(subscription: PushSubscription, payload: NotificationPayload): Promise<boolean>;
+/**
+ * Send a push notification to multiple subscriptions
+ * Returns array of results
+ */
+export declare function sendPushToAll(subscriptions: PushSubscription[], payload: NotificationPayload): Promise<SendResult[]>;
+/**
+ * Send push notification with detailed error information
+ */
+export declare function sendPushWithDetails(subscription: PushSubscription, payload: NotificationPayload): Promise<SendResult>;
+/**
+ * Check if a subscription is expired (410 Gone)
+ */
+export declare function isSubscriptionExpired(statusCode: number | undefined): boolean;

package/dist/server/send.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initPush = initPush;
+exports.initPushFromEnv = initPushFromEnv;
+exports.getVapidPublicKey = getVapidPublicKey;
+exports.sendPushNotification = sendPushNotification;
+exports.sendPushToAll = sendPushToAll;
+exports.sendPushWithDetails = sendPushWithDetails;
+exports.isSubscriptionExpired = isSubscriptionExpired;
+const web_push_1 = __importDefault(require("web-push"));
+/**
+ * Server-side Web Push notification utilities
+ */
+let vapidConfig = null;
+/**
+ * Initialize VAPID configuration - call once at startup
+ * Fails fast if keys are missing
+ */
+function initPush(config) {
+    const { publicKey, privateKey, subject } = config;
+    if (!publicKey || !privateKey) {
+        throw new Error('VAPID keys required. Set VAPID_PUBLIC_KEY and VAPID_PRIVATE_KEY.');
+    }
+    if (!subject) {
+        throw new Error('VAPID subject required. Set VAPID_SUBJECT (e.g., mailto:you@example.com).');
+    }
+    vapidConfig = { publicKey, privateKey, subject };
+    web_push_1.default.setVapidDetails(subject, publicKey, privateKey);
+}
+/**
+ * Auto-initialize from environment variables
+ */
+function initPushFromEnv() {
+    initPush({
+        publicKey: process.env.VAPID_PUBLIC_KEY,
+        privateKey: process.env.VAPID_PRIVATE_KEY,
+        subject: process.env.VAPID_SUBJECT
+    });
+}
+/**
+ * Get the VAPID public key (for client subscription)
+ */
+function getVapidPublicKey() {
+    if (!vapidConfig) {
+        throw new Error('Push not initialized. Call initPush() first.');
+    }
+    return vapidConfig.publicKey;
+}
+/**
+ * Send a push notification to a single subscription
+ */
+async function sendPushNotification(subscription, payload) {
+    const result = await sendPushWithDetails(subscription, payload);
+    return result.success;
+}
+/**
+ * Send a push notification to multiple subscriptions
+ * Returns array of results
+ */
+async function sendPushToAll(subscriptions, payload) {
+    const results = await Promise.all(subscriptions.map(sub => sendPushWithDetails(sub, payload)));
+    return results;
+}
+/**
+ * Send push notification with detailed error information
+ */
+async function sendPushWithDetails(subscription, payload) {
+    if (!vapidConfig) {
+        return { success: false, error: 'Push not initialized' };
+    }
+    try {
+        await web_push_1.default.sendNotification(subscription, JSON.stringify(payload));
+        return { success: true };
+    }
+    catch (error) {
+        const webPushError = error;
+        return {
+            success: false,
+            error: webPushError.message || 'Unknown error',
+            statusCode: webPushError.statusCode
+        };
+    }
+}
+/**
+ * Check if a subscription is expired (410 Gone)
+ */
+function isSubscriptionExpired(statusCode) {
+    return statusCode === 410;
+}

package/dist/types.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Push notification types - shared between server and client
+ */
+export interface PushSubscription {
+    endpoint: string;
+    keys: {
+        p256dh: string;
+        auth: string;
+    };
+}
+export interface NotificationPayload {
+    title: string;
+    body: string;
+    type?: string;
+    url?: string;
+    tag?: string;
+    data?: Record<string, unknown>;
+}
+export interface VapidConfig {
+    publicKey: string;
+    privateKey: string;
+    subject: string;
+}
+export interface SendResult {
+    success: boolean;
+    error?: string;
+    statusCode?: number;
+}
+export interface SubscriptionRequest {
+    subscription: PushSubscription;
+    deviceId: string;
+    basePath?: string;
+}
+export interface RenewalRequest {
+    subscription: PushSubscription;
+    deviceId: string;
+    basePath?: string;
+}
+export interface SubscriptionData {
+    publicKey: string;
+    deviceId: string;
+    basePath: string;
+}
+export type PushPermissionState = 'granted' | 'denied' | 'default';

package/dist/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Push notification types - shared between server and client
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@markwharton/pwa-push",
+  "version": "1.0.0",
+  "description": "Web push notifications for Azure PWA projects",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./server": "./dist/server/index.js",
+    "./client": "./dist/client/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist"
+  },
+  "peerDependencies": {
+    "web-push": "^3.6.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "@types/web-push": "^3.6.4",
+    "typescript": "^5.3.0",
+    "web-push": "^3.6.7"
+  },
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/MarkWharton/pwa-packages.git",
+    "directory": "packages/push"
+  },
+  "author": "Mark Wharton",
+  "license": "MIT"
+}