@markwharton/pwa-push 1.1.0 → 1.2.1

package/dist/__tests__/client/subscribe.test.js

@@ -0,0 +1,268 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+// Mock factory for client dependencies (needed after vi.resetModules)
+function mockClientDependencies() {
+    vitest_1.vi.mock('../../client/deviceId', () => ({
+        getDeviceId: vitest_1.vi.fn(() => 'mock-device-id')
+    }));
+    vitest_1.vi.mock('../../client/indexedDb', () => ({
+        saveSubscriptionData: vitest_1.vi.fn(() => Promise.resolve())
+    }));
+    vitest_1.vi.mock('../../client/encoding', () => ({
+        urlBase64ToUint8Array: vitest_1.vi.fn(() => new Uint8Array([1, 2, 3]))
+    }));
+}
+// Initial mock setup (hoisted by Vitest)
+mockClientDependencies();
+// Setup browser mocks
+const mockSubscription = {
+    endpoint: 'https://fcm.googleapis.com/test',
+    toJSON: () => ({
+        endpoint: 'https://fcm.googleapis.com/test',
+        keys: {
+            p256dh: 'test-p256dh',
+            auth: 'test-auth'
+        }
+    }),
+    unsubscribe: vitest_1.vi.fn(() => Promise.resolve(true))
+};
+const mockPushManager = {
+    subscribe: vitest_1.vi.fn(() => Promise.resolve(mockSubscription)),
+    getSubscription: vitest_1.vi.fn(() => Promise.resolve(mockSubscription))
+};
+const mockRegistration = {
+    pushManager: mockPushManager
+};
+// Helper to setup navigator with serviceWorker
+function setupNavigatorWithServiceWorker() {
+    Object.defineProperty(global, 'navigator', {
+        value: {
+            serviceWorker: {
+                ready: Promise.resolve(mockRegistration)
+            }
+        },
+        writable: true,
+        configurable: true
+    });
+}
+// Helper to setup empty navigator (no serviceWorker)
+function setupEmptyNavigator() {
+    Object.defineProperty(global, 'navigator', {
+        value: {},
+        writable: true,
+        configurable: true
+    });
+}
+(0, vitest_1.beforeEach)(() => {
+    vitest_1.vi.clearAllMocks();
+    // Mock Notification
+    global.Notification = {
+        permission: 'default',
+        requestPermission: vitest_1.vi.fn(() => Promise.resolve('granted'))
+    };
+    setupNavigatorWithServiceWorker();
+    // Mock window.PushManager
+    global.window = {
+        PushManager: {}
+    };
+});
+(0, vitest_1.describe)('Push subscription client', () => {
+    (0, vitest_1.describe)('getPermissionState', () => {
+        (0, vitest_1.it)('returns current notification permission', async () => {
+            global.Notification.permission = 'granted';
+            const { getPermissionState } = await Promise.resolve().then(() => __importStar(require('../../client/subscribe')));
+            (0, vitest_1.expect)(getPermissionState()).toBe('granted');
+        });
+        (0, vitest_1.it)('returns denied permission', async () => {
+            global.Notification.permission = 'denied';
+            const { getPermissionState } = await Promise.resolve().then(() => __importStar(require('../../client/subscribe')));
+            (0, vitest_1.expect)(getPermissionState()).toBe('denied');
+        });
+        (0, vitest_1.it)('returns default permission', async () => {
+            global.Notification.permission = 'default';
+            const { getPermissionState } = await Promise.resolve().then(() => __importStar(require('../../client/subscribe')));
+            (0, vitest_1.expect)(getPermissionState()).toBe('default');
+        });
+    });
+    (0, vitest_1.describe)('requestPermission', () => {
+        (0, vitest_1.it)('requests permission and returns result', async () => {
+            global.Notification.requestPermission.mockResolvedValue('granted');
+            const { requestPermission } = await Promise.resolve().then(() => __importStar(require('../../client/subscribe')));
+            const result = await requestPermission();
+            (0, vitest_1.expect)(result).toBe('granted');
+            (0, vitest_1.expect)(global.Notification.requestPermission).toHaveBeenCalled();
+        });
+        (0, vitest_1.it)('returns denied when user denies', async () => {
+            global.Notification.requestPermission.mockResolvedValue('denied');
+            const { requestPermission } = await Promise.resolve().then(() => __importStar(require('../../client/subscribe')));
+            const result = await requestPermission();
+            (0, vitest_1.expect)(result).toBe('denied');
+        });
+    });
+    (0, vitest_1.describe)('isPushSupported', () => {
+        (0, vitest_1.it)('returns true when serviceWorker and PushManager available', async () => {
+            const { isPushSupported } = await Promise.resolve().then(() => __importStar(require('../../client/subscribe')));
+            (0, vitest_1.expect)(isPushSupported()).toBe(true);
+        });
+        (0, vitest_1.it)('returns false when serviceWorker missing', async () => {
+            setupEmptyNavigator();
+            vitest_1.vi.resetModules();
+            const { isPushSupported } = await Promise.resolve().then(() => __importStar(require('../../client/subscribe')));
+            (0, vitest_1.expect)(isPushSupported()).toBe(false);
+        });
+        (0, vitest_1.it)('returns false when PushManager missing', async () => {
+            delete global.window.PushManager;
+            vitest_1.vi.resetModules();
+            const { isPushSupported } = await Promise.resolve().then(() => __importStar(require('../../client/subscribe')));
+            (0, vitest_1.expect)(isPushSupported()).toBe(false);
+        });
+    });
+    (0, vitest_1.describe)('toPushSubscription', () => {
+        (0, vitest_1.it)('converts browser subscription to internal format', async () => {
+            const { toPushSubscription } = await Promise.resolve().then(() => __importStar(require('../../client/subscribe')));
+            const result = toPushSubscription(mockSubscription);
+            (0, vitest_1.expect)(result.endpoint).toBe('https://fcm.googleapis.com/test');
+            (0, vitest_1.expect)(result.keys.p256dh).toBe('test-p256dh');
+            (0, vitest_1.expect)(result.keys.auth).toBe('test-auth');
+        });
+        (0, vitest_1.it)('handles missing keys', async () => {
+            const { toPushSubscription } = await Promise.resolve().then(() => __importStar(require('../../client/subscribe')));
+            const subWithoutKeys = {
+                endpoint: 'https://example.com',
+                toJSON: () => ({ endpoint: 'https://example.com', keys: undefined })
+            };
+            const result = toPushSubscription(subWithoutKeys);
+            (0, vitest_1.expect)(result.keys.p256dh).toBe('');
+            (0, vitest_1.expect)(result.keys.auth).toBe('');
+        });
+    });
+    (0, vitest_1.describe)('subscribeToPush', () => {
+        (0, vitest_1.it)('returns error when push not supported', async () => {
+            setupEmptyNavigator();
+            vitest_1.vi.resetModules();
+            mockClientDependencies();
+            const { subscribeToPush } = await Promise.resolve().then(() => __importStar(require('../../client/subscribe')));
+            const result = await subscribeToPush('vapid-key');
+            (0, vitest_1.expect)(result.ok).toBe(false);
+            (0, vitest_1.expect)(result.error).toBe('Push notifications not supported');
+        });
+        (0, vitest_1.it)('returns error when permission denied', async () => {
+            global.Notification.requestPermission.mockResolvedValue('denied');
+            const { subscribeToPush } = await Promise.resolve().then(() => __importStar(require('../../client/subscribe')));
+            const result = await subscribeToPush('vapid-key');
+            (0, vitest_1.expect)(result.ok).toBe(false);
+            (0, vitest_1.expect)(result.error).toBe('Push permission denied');
+        });
+        (0, vitest_1.it)('returns subscription request on success', async () => {
+            global.Notification.requestPermission.mockResolvedValue('granted');
+            const { subscribeToPush } = await Promise.resolve().then(() => __importStar(require('../../client/subscribe')));
+            const result = await subscribeToPush('vapid-key', '/app');
+            (0, vitest_1.expect)(result.ok).toBe(true);
+            (0, vitest_1.expect)(result.data?.deviceId).toBe('mock-device-id');
+            (0, vitest_1.expect)(result.data?.basePath).toBe('/app');
+            (0, vitest_1.expect)(result.data?.subscription.endpoint).toBe('https://fcm.googleapis.com/test');
+        });
+        (0, vitest_1.it)('saves subscription data to IndexedDB', async () => {
+            global.Notification.requestPermission.mockResolvedValue('granted');
+            const { saveSubscriptionData } = await Promise.resolve().then(() => __importStar(require('../../client/indexedDb')));
+            const { subscribeToPush } = await Promise.resolve().then(() => __importStar(require('../../client/subscribe')));
+            await subscribeToPush('vapid-key', '/myapp');
+            (0, vitest_1.expect)(saveSubscriptionData).toHaveBeenCalledWith({
+                publicKey: 'vapid-key',
+                deviceId: 'mock-device-id',
+                basePath: '/myapp'
+            });
+        });
+        (0, vitest_1.it)('uses default basePath of "/"', async () => {
+            global.Notification.requestPermission.mockResolvedValue('granted');
+            const { subscribeToPush } = await Promise.resolve().then(() => __importStar(require('../../client/subscribe')));
+            const result = await subscribeToPush('vapid-key');
+            (0, vitest_1.expect)(result.data?.basePath).toBe('/');
+        });
+        (0, vitest_1.it)('handles subscription error', async () => {
+            global.Notification.requestPermission.mockResolvedValue('granted');
+            mockPushManager.subscribe.mockRejectedValueOnce(new Error('Network error'));
+            const { subscribeToPush } = await Promise.resolve().then(() => __importStar(require('../../client/subscribe')));
+            const result = await subscribeToPush('vapid-key');
+            (0, vitest_1.expect)(result.ok).toBe(false);
+            (0, vitest_1.expect)(result.error).toBe('Network error');
+        });
+    });
+    (0, vitest_1.describe)('unsubscribeFromPush', () => {
+        (0, vitest_1.it)('unsubscribes successfully', async () => {
+            const { unsubscribeFromPush } = await Promise.resolve().then(() => __importStar(require('../../client/subscribe')));
+            const result = await unsubscribeFromPush();
+            (0, vitest_1.expect)(result.ok).toBe(true);
+            (0, vitest_1.expect)(mockSubscription.unsubscribe).toHaveBeenCalled();
+        });
+        (0, vitest_1.it)('succeeds when no subscription exists', async () => {
+            mockPushManager.getSubscription.mockResolvedValueOnce(null);
+            const { unsubscribeFromPush } = await Promise.resolve().then(() => __importStar(require('../../client/subscribe')));
+            const result = await unsubscribeFromPush();
+            (0, vitest_1.expect)(result.ok).toBe(true);
+        });
+        (0, vitest_1.it)('handles unsubscribe error', async () => {
+            mockPushManager.getSubscription.mockRejectedValueOnce(new Error('Failed'));
+            const { unsubscribeFromPush } = await Promise.resolve().then(() => __importStar(require('../../client/subscribe')));
+            const result = await unsubscribeFromPush();
+            (0, vitest_1.expect)(result.ok).toBe(false);
+            (0, vitest_1.expect)(result.error).toBe('Failed');
+        });
+    });
+    (0, vitest_1.describe)('getCurrentSubscription', () => {
+        (0, vitest_1.it)('returns current subscription', async () => {
+            const { getCurrentSubscription } = await Promise.resolve().then(() => __importStar(require('../../client/subscribe')));
+            const result = await getCurrentSubscription();
+            (0, vitest_1.expect)(result.ok).toBe(true);
+            (0, vitest_1.expect)(result.data?.endpoint).toBe('https://fcm.googleapis.com/test');
+        });
+        (0, vitest_1.it)('returns error when no subscription', async () => {
+            mockPushManager.getSubscription.mockResolvedValueOnce(null);
+            const { getCurrentSubscription } = await Promise.resolve().then(() => __importStar(require('../../client/subscribe')));
+            const result = await getCurrentSubscription();
+            (0, vitest_1.expect)(result.ok).toBe(false);
+            (0, vitest_1.expect)(result.error).toBe('No active subscription');
+        });
+        (0, vitest_1.it)('handles error', async () => {
+            mockPushManager.getSubscription.mockRejectedValueOnce(new Error('Service worker error'));
+            const { getCurrentSubscription } = await Promise.resolve().then(() => __importStar(require('../../client/subscribe')));
+            const result = await getCurrentSubscription();
+            (0, vitest_1.expect)(result.ok).toBe(false);
+            (0, vitest_1.expect)(result.error).toBe('Service worker error');
+        });
+    });
+});

package/dist/__tests__/server/send.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/server/send.test.js

@@ -0,0 +1,217 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+// Mock web-push
+vitest_1.vi.mock('web-push', () => ({
+    default: {
+        setVapidDetails: vitest_1.vi.fn(),
+        sendNotification: vitest_1.vi.fn()
+    }
+}));
+const web_push_1 = __importDefault(require("web-push"));
+(0, vitest_1.describe)('Push server', () => {
+    const validConfig = {
+        publicKey: 'BEl62iUYgUivxIkv69yViEuiBIa-Ib9-SkvMeAtA3LFgDzkrxZJjSgSnfckjBJuBkr3qBUYIHBQFLXYp5Nksh8U',
+        privateKey: 'UUxI4O8-FbRouAevSmBQ6o18hgE4nSG3qwvJTfKc-ls',
+        subject: 'mailto:test@example.com'
+    };
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.resetModules();
+        vitest_1.vi.clearAllMocks();
+    });
+    (0, vitest_1.describe)('initPush', () => {
+        (0, vitest_1.it)('initializes with valid config', async () => {
+            const { initPush, getVapidPublicKey } = await Promise.resolve().then(() => __importStar(require('../../server/send')));
+            initPush(validConfig);
+            (0, vitest_1.expect)(getVapidPublicKey()).toBe(validConfig.publicKey);
+            (0, vitest_1.expect)(web_push_1.default.setVapidDetails).toHaveBeenCalledWith(validConfig.subject, validConfig.publicKey, validConfig.privateKey);
+        });
+        (0, vitest_1.it)('throws if publicKey is missing', async () => {
+            const { initPush } = await Promise.resolve().then(() => __importStar(require('../../server/send')));
+            (0, vitest_1.expect)(() => initPush({ ...validConfig, publicKey: undefined })).toThrow('VAPID keys required');
+        });
+        (0, vitest_1.it)('throws if privateKey is missing', async () => {
+            const { initPush } = await Promise.resolve().then(() => __importStar(require('../../server/send')));
+            (0, vitest_1.expect)(() => initPush({ ...validConfig, privateKey: undefined })).toThrow('VAPID keys required');
+        });
+        (0, vitest_1.it)('throws if subject is missing', async () => {
+            const { initPush } = await Promise.resolve().then(() => __importStar(require('../../server/send')));
+            (0, vitest_1.expect)(() => initPush({ ...validConfig, subject: undefined })).toThrow('VAPID subject required');
+        });
+    });
+    (0, vitest_1.describe)('initPushFromEnv', () => {
+        (0, vitest_1.it)('reads from environment variables', async () => {
+            process.env.VAPID_PUBLIC_KEY = validConfig.publicKey;
+            process.env.VAPID_PRIVATE_KEY = validConfig.privateKey;
+            process.env.VAPID_SUBJECT = validConfig.subject;
+            const { initPushFromEnv, getVapidPublicKey } = await Promise.resolve().then(() => __importStar(require('../../server/send')));
+            initPushFromEnv();
+            (0, vitest_1.expect)(getVapidPublicKey()).toBe(validConfig.publicKey);
+            delete process.env.VAPID_PUBLIC_KEY;
+            delete process.env.VAPID_PRIVATE_KEY;
+            delete process.env.VAPID_SUBJECT;
+        });
+    });
+    (0, vitest_1.describe)('getVapidPublicKey', () => {
+        (0, vitest_1.it)('throws if not initialized', async () => {
+            const { getVapidPublicKey } = await Promise.resolve().then(() => __importStar(require('../../server/send')));
+            (0, vitest_1.expect)(() => getVapidPublicKey()).toThrow('Push not initialized');
+        });
+        (0, vitest_1.it)('returns public key after initialization', async () => {
+            const { initPush, getVapidPublicKey } = await Promise.resolve().then(() => __importStar(require('../../server/send')));
+            initPush(validConfig);
+            (0, vitest_1.expect)(getVapidPublicKey()).toBe(validConfig.publicKey);
+        });
+    });
+    (0, vitest_1.describe)('sendPushNotification', () => {
+        const subscription = {
+            endpoint: 'https://fcm.googleapis.com/fcm/send/abc123',
+            keys: {
+                p256dh: 'testkey',
+                auth: 'testauthkey'
+            }
+        };
+        const payload = {
+            title: 'Test',
+            body: 'Test message'
+        };
+        (0, vitest_1.it)('returns ok on success', async () => {
+            vitest_1.vi.mocked(web_push_1.default.sendNotification).mockResolvedValue({});
+            const { initPush, sendPushNotification } = await Promise.resolve().then(() => __importStar(require('../../server/send')));
+            initPush(validConfig);
+            const result = await sendPushNotification(subscription, payload);
+            (0, vitest_1.expect)(result.ok).toBe(true);
+        });
+        (0, vitest_1.it)('returns error on failure', async () => {
+            vitest_1.vi.mocked(web_push_1.default.sendNotification).mockRejectedValue({
+                statusCode: 410,
+                message: 'Gone'
+            });
+            const { initPush, sendPushNotification } = await Promise.resolve().then(() => __importStar(require('../../server/send')));
+            initPush(validConfig);
+            const result = await sendPushNotification(subscription, payload);
+            (0, vitest_1.expect)(result.ok).toBe(false);
+            (0, vitest_1.expect)(result.error).toBe('Gone');
+            (0, vitest_1.expect)(result.statusCode).toBe(410);
+        });
+        (0, vitest_1.it)('returns error if not initialized', async () => {
+            const { sendPushNotification } = await Promise.resolve().then(() => __importStar(require('../../server/send')));
+            const result = await sendPushNotification(subscription, payload);
+            (0, vitest_1.expect)(result.ok).toBe(false);
+            (0, vitest_1.expect)(result.error).toBe('Push not initialized');
+        });
+    });
+    (0, vitest_1.describe)('sendPushToAll', () => {
+        const subscriptions = [
+            { endpoint: 'https://example.com/1', keys: { p256dh: 'k1', auth: 'a1' } },
+            { endpoint: 'https://example.com/2', keys: { p256dh: 'k2', auth: 'a2' } }
+        ];
+        const payload = { title: 'Broadcast', body: 'Hello all' };
+        (0, vitest_1.it)('sends to all subscriptions', async () => {
+            vitest_1.vi.mocked(web_push_1.default.sendNotification).mockResolvedValue({});
+            const { initPush, sendPushToAll } = await Promise.resolve().then(() => __importStar(require('../../server/send')));
+            initPush(validConfig);
+            const results = await sendPushToAll(subscriptions, payload);
+            (0, vitest_1.expect)(results).toHaveLength(2);
+            (0, vitest_1.expect)(results.every(r => r.ok)).toBe(true);
+        });
+        (0, vitest_1.it)('handles mixed success/failure', async () => {
+            vitest_1.vi.mocked(web_push_1.default.sendNotification)
+                .mockResolvedValueOnce({})
+                .mockRejectedValueOnce({ statusCode: 410, message: 'Gone' });
+            const { initPush, sendPushToAll } = await Promise.resolve().then(() => __importStar(require('../../server/send')));
+            initPush(validConfig);
+            const results = await sendPushToAll(subscriptions, payload);
+            (0, vitest_1.expect)(results[0].ok).toBe(true);
+            (0, vitest_1.expect)(results[1].ok).toBe(false);
+        });
+    });
+    (0, vitest_1.describe)('sendPushWithDetails', () => {
+        const subscription = {
+            endpoint: 'https://fcm.googleapis.com/fcm/send/abc123',
+            keys: { p256dh: 'testkey', auth: 'testauthkey' },
+            basePath: '/app'
+        };
+        (0, vitest_1.it)('injects basePath from subscription', async () => {
+            vitest_1.vi.mocked(web_push_1.default.sendNotification).mockResolvedValue({});
+            const { initPush, sendPushWithDetails } = await Promise.resolve().then(() => __importStar(require('../../server/send')));
+            initPush(validConfig);
+            await sendPushWithDetails(subscription, { title: 'Test', body: 'Hello' });
+            (0, vitest_1.expect)(web_push_1.default.sendNotification).toHaveBeenCalledWith(subscription, vitest_1.expect.stringContaining('"basePath":"/app"'));
+        });
+        (0, vitest_1.it)('uses payload basePath over subscription basePath', async () => {
+            vitest_1.vi.mocked(web_push_1.default.sendNotification).mockResolvedValue({});
+            const { initPush, sendPushWithDetails } = await Promise.resolve().then(() => __importStar(require('../../server/send')));
+            initPush(validConfig);
+            await sendPushWithDetails(subscription, {
+                title: 'Test',
+                body: 'Hello',
+                basePath: '/override'
+            });
+            (0, vitest_1.expect)(web_push_1.default.sendNotification).toHaveBeenCalledWith(subscription, vitest_1.expect.stringContaining('"basePath":"/override"'));
+        });
+        (0, vitest_1.it)('defaults basePath to "/" when not specified', async () => {
+            vitest_1.vi.mocked(web_push_1.default.sendNotification).mockResolvedValue({});
+            const { initPush, sendPushWithDetails } = await Promise.resolve().then(() => __importStar(require('../../server/send')));
+            initPush(validConfig);
+            const subWithoutBasePath = {
+                endpoint: 'https://example.com',
+                keys: { p256dh: 'k', auth: 'a' }
+            };
+            await sendPushWithDetails(subWithoutBasePath, { title: 'Test', body: 'Hello' });
+            (0, vitest_1.expect)(web_push_1.default.sendNotification).toHaveBeenCalledWith(subWithoutBasePath, vitest_1.expect.stringContaining('"basePath":"/"'));
+        });
+    });
+    (0, vitest_1.describe)('isSubscriptionExpired', () => {
+        (0, vitest_1.it)('returns true for 410 status', async () => {
+            const { isSubscriptionExpired } = await Promise.resolve().then(() => __importStar(require('../../server/send')));
+            (0, vitest_1.expect)(isSubscriptionExpired(410)).toBe(true);
+        });
+        (0, vitest_1.it)('returns false for other statuses', async () => {
+            const { isSubscriptionExpired } = await Promise.resolve().then(() => __importStar(require('../../server/send')));
+            (0, vitest_1.expect)(isSubscriptionExpired(400)).toBe(false);
+            (0, vitest_1.expect)(isSubscriptionExpired(401)).toBe(false);
+            (0, vitest_1.expect)(isSubscriptionExpired(500)).toBe(false);
+        });
+        (0, vitest_1.it)('returns false for undefined', async () => {
+            const { isSubscriptionExpired } = await Promise.resolve().then(() => __importStar(require('../../server/send')));
+            (0, vitest_1.expect)(isSubscriptionExpired(undefined)).toBe(false);
+        });
+    });
+});

package/dist/client/deviceId.d.ts

@@ -3,11 +3,21 @@
  * Prevents duplicate subscriptions when service worker re-registers
  */
 /**
- * Get or create a persistent device ID
- * Uses localStorage (main thread only)
+ * Gets or creates a persistent device ID for subscription deduplication.
+ * The ID is stored in localStorage and persists across sessions.
+ * Uses localStorage (main thread only - not available in service workers).
+ * @returns The device ID string (UUID v4 format)
+ * @example
+ * const deviceId = getDeviceId();
+ * // Use deviceId in subscription requests to identify this device
  */
 export declare function getDeviceId(): string;
 /**
- * Clear the device ID (for testing or logout)
+ * Clears the device ID from localStorage.
+ * Use for testing or when user logs out and wants a fresh device identity.
+ * @example
+ * // On user logout
+ * await unsubscribeFromPush();
+ * clearDeviceId();
  */
 export declare function clearDeviceId(): void;

package/dist/client/deviceId.js

@@ -8,7 +8,9 @@ exports.getDeviceId = getDeviceId;
 exports.clearDeviceId = clearDeviceId;
 const DEVICE_ID_KEY = 'push_device_id';
 /**
- * Generate a cryptographically secure UUID v4
+ * Generates a cryptographically secure UUID v4.
+ * Uses Web Crypto API for secure random number generation.
+ * @returns A UUID v4 string (e.g., '550e8400-e29b-41d4-a716-446655440000')
  */
 function generateUUID() {
     const bytes = crypto.getRandomValues(new Uint8Array(16));
@@ -18,8 +20,13 @@ function generateUUID() {
     return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
 }
 /**
- * Get or create a persistent device ID
- * Uses localStorage (main thread only)
+ * Gets or creates a persistent device ID for subscription deduplication.
+ * The ID is stored in localStorage and persists across sessions.
+ * Uses localStorage (main thread only - not available in service workers).
+ * @returns The device ID string (UUID v4 format)
+ * @example
+ * const deviceId = getDeviceId();
+ * // Use deviceId in subscription requests to identify this device
  */
 function getDeviceId() {
     let deviceId = localStorage.getItem(DEVICE_ID_KEY);
@@ -30,7 +37,12 @@ function getDeviceId() {
     return deviceId;
 }
 /**
- * Clear the device ID (for testing or logout)
+ * Clears the device ID from localStorage.
+ * Use for testing or when user logs out and wants a fresh device identity.
+ * @example
+ * // On user logout
+ * await unsubscribeFromPush();
+ * clearDeviceId();
  */
 function clearDeviceId() {
     localStorage.removeItem(DEVICE_ID_KEY);

package/dist/client/encoding.d.ts

@@ -2,8 +2,16 @@
  * Encoding utilities for push notification client
  */
 /**
- * Convert base64 URL-encoded string to Uint8Array
- * Used to convert VAPID public keys for the PushManager API
- * Works in both main thread and service worker contexts
+ * Converts a base64 URL-encoded string to a Uint8Array.
+ * Used to convert VAPID public keys for the PushManager API.
+ * Works in both main thread and service worker contexts.
+ * @param base64String - The base64 URL-encoded string to convert
+ * @returns A Uint8Array containing the decoded bytes
+ * @example
+ * const applicationServerKey = urlBase64ToUint8Array(vapidPublicKey);
+ * await registration.pushManager.subscribe({
+ *   userVisibleOnly: true,
+ *   applicationServerKey
+ * });
  */
 export declare function urlBase64ToUint8Array(base64String: string): Uint8Array<ArrayBuffer>;

package/dist/client/encoding.js

@@ -5,9 +5,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.urlBase64ToUint8Array = urlBase64ToUint8Array;
 /**
- * Convert base64 URL-encoded string to Uint8Array
- * Used to convert VAPID public keys for the PushManager API
- * Works in both main thread and service worker contexts
+ * Converts a base64 URL-encoded string to a Uint8Array.
+ * Used to convert VAPID public keys for the PushManager API.
+ * Works in both main thread and service worker contexts.
+ * @param base64String - The base64 URL-encoded string to convert
+ * @returns A Uint8Array containing the decoded bytes
+ * @example
+ * const applicationServerKey = urlBase64ToUint8Array(vapidPublicKey);
+ * await registration.pushManager.subscribe({
+ *   userVisibleOnly: true,
+ *   applicationServerKey
+ * });
  */
 function urlBase64ToUint8Array(base64String) {
     const padding = '='.repeat((4 - (base64String.length % 4)) % 4);

package/dist/client/indexedDb.d.ts

@@ -4,14 +4,35 @@
  */
 import { SubscriptionData } from '../types';
 /**
- * Save subscription data to IndexedDB (for service worker access)
+ * Saves subscription data to IndexedDB for service worker access.
+ * This data is used for subscription renewal when the browser rotates keys.
+ * @param data - The subscription data to persist (VAPID key, deviceId, basePath)
+ * @returns Promise that resolves when data is saved
+ * @example
+ * await saveSubscriptionData({
+ *   publicKey: vapidPublicKey,
+ *   deviceId: getDeviceId(),
+ *   basePath: '/app'
+ * });
  */
 export declare function saveSubscriptionData(data: SubscriptionData): Promise<void>;
 /**
- * Get subscription data from IndexedDB
+ * Retrieves subscription data from IndexedDB.
+ * Used by service workers during subscription renewal.
+ * @returns The stored subscription data, or null if not found
+ * @example
+ * const data = await getSubscriptionData();
+ * if (data) {
+ *   console.log('Device ID:', data.deviceId);
+ * }
  */
 export declare function getSubscriptionData(): Promise<SubscriptionData | null>;
 /**
- * Clear subscription data from IndexedDB
+ * Clears subscription data from IndexedDB.
+ * Call when unsubscribing or during cleanup.
+ * @returns Promise that resolves when data is cleared
+ * @example
+ * await unsubscribeFromPush();
+ * await clearSubscriptionData();
  */
 export declare function clearSubscriptionData(): Promise<void>;