@budarin/pluggable-serviceworker 1.2.1 → 1.5.0

package/dist/index.d.ts

@@ -30,42 +30,36 @@ export interface Logger {
     warn: (...data: unknown[]) => void;
     error: (...data: unknown[]) => void;
 }
-export interface SwContext {
+export interface PluginContext {
     logger?: Logger;
 }
-export interface ServiceWorkerInitOptions extends SwContext {
+export interface ServiceWorkerInitOptions extends PluginContext {
     onError?: (error: Error | unknown, event: Event, errorType?: ServiceWorkerErrorType) => void;
 }
 export type PushNotificationPayload = {
     title: string;
 } & NotificationOptions;
-export interface OfflineFirstContext extends SwContext {
-    assets: string[];
-    cacheName: string;
-    claimMessageType?: string;
-    cacheMatchIgnoreSearch?: boolean;
-}
 export declare function __resetServiceWorkerState(): void;
-export type ContextOfPlugin<P> = P extends ServiceWorkerPlugin<infer C> ? C : SwContext;
+export type ContextOfPlugin<P> = P extends ServiceWorkerPlugin<infer C> ? C : PluginContext;
 export type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-export type AnyServiceWorkerPlugin = ServiceWorkerPlugin<SwContext> | ServiceWorkerPlugin<OfflineFirstContext>;
-export type RequiredOptions<P extends readonly AnyServiceWorkerPlugin[]> = UnionToIntersection<ContextOfPlugin<P[number]>>;
-interface ServiceWorkerEventHandlers<C extends SwContext = SwContext> {
-    install?: (event: ExtendableEvent, context: C) => void | Promise<void>;
-    activate?: (event: ExtendableEvent, context: C) => void | Promise<void>;
-    fetch?: (event: FetchEvent, context: C) => Promise<Response | undefined>;
-    message?: (event: SwMessageEvent, context: C) => void;
-    sync?: (event: SyncEvent, context: C) => Promise<void>;
-    periodicsync?: (event: PeriodicSyncEvent, context: C) => Promise<void>;
-    push?: (event: PushEvent, context: C) => void | PushNotificationPayload | Promise<void | PushNotificationPayload>;
+export type RequiredOptions<P extends readonly unknown[]> = UnionToIntersection<ContextOfPlugin<P[number]>>;
+interface ServiceWorkerEventHandlers {
+    install?: (event: ExtendableEvent, logger: Logger) => void | Promise<void>;
+    activate?: (event: ExtendableEvent, logger: Logger) => void | Promise<void>;
+    fetch?: (event: FetchEvent, logger: Logger) => Promise<Response | undefined>;
+    message?: (event: SwMessageEvent, logger: Logger) => void;
+    sync?: (event: SyncEvent, logger: Logger) => Promise<void>;
+    periodicsync?: (event: PeriodicSyncEvent, logger: Logger) => Promise<void>;
+    push?: (event: PushEvent, logger: Logger) => void | PushNotificationPayload | false | Promise<void | PushNotificationPayload | false>;
 }
-export interface ServiceWorkerPlugin<C extends SwContext = SwContext> extends ServiceWorkerEventHandlers<C> {
+export interface ServiceWorkerPlugin<_C extends PluginContext = PluginContext> extends ServiceWorkerEventHandlers {
     name: string;
     order?: number;
 }
+export type Plugin = ServiceWorkerPlugin<PluginContext>;
 export type ServiceWorkerConfig = ServiceWorkerInitOptions;
 export type FetchResponse = Promise<Response | undefined>;
-export declare function createEventHandlers<C extends SwContext>(plugins: readonly ServiceWorkerPlugin<C>[], options: C & ServiceWorkerInitOptions): {
+export declare function createEventHandlers<_C extends PluginContext = PluginContext>(plugins: readonly ServiceWorkerPlugin<_C>[], options: _C & ServiceWorkerInitOptions): {
     install: (event: ExtendableEvent) => void;
     activate: (event: ExtendableEvent) => void;
     fetch: (event: FetchEvent) => void;
@@ -78,6 +72,5 @@ export declare function createEventHandlers<C extends SwContext>(plugins: readon
     unhandledrejection: (event: PromiseRejectionEvent) => void;
     rejectionhandled: (event: PromiseRejectionEvent) => void;
 };
-export declare function initServiceWorker<P extends readonly AnyServiceWorkerPlugin[]>(plugins: P, options: RequiredOptions<P> & ServiceWorkerInitOptions): void;
+export declare function initServiceWorker<P extends readonly unknown[]>(plugins: P, options: RequiredOptions<P> & ServiceWorkerInitOptions): void;
 export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,4 +1,4 @@
-import { SW_EVENT_PUSH, SW_EVENT_SYNC, SW_EVENT_ERROR, SW_EVENT_FETCH, SW_EVENT_INSTALL, SW_EVENT_MESSAGE, SW_EVENT_ACTIVATE, SW_EVENT_PERIODICSYNC, SW_EVENT_MESSAGEERROR, SW_EVENT_REJECTIONHANDLED, SW_EVENT_UNHANDLEDREJECTION, } from '@budarin/http-constants';
+import { SW_EVENT_PUSH, SW_EVENT_SYNC, SW_EVENT_ERROR, SW_EVENT_FETCH, SW_EVENT_INSTALL, SW_EVENT_MESSAGE, SW_EVENT_ACTIVATE, SW_EVENT_PERIODICSYNC, SW_EVENT_MESSAGEERROR, SW_EVENT_REJECTIONHANDLED, SW_EVENT_UNHANDLEDREJECTION, } from '@budarin/http-constants/service-worker';
 export var ServiceWorkerErrorType;
 (function (ServiceWorkerErrorType) {
     ServiceWorkerErrorType["ERROR"] = "error";
@@ -47,19 +47,19 @@ export function createEventHandlers(plugins, options) {
     return {
         install: (event) => {
             event.waitUntil(Promise.all(handlers.install.map((handler) => Promise.resolve()
-                .then(() => handler(event, options))
+                .then(() => handler(event, logger))
                 .catch((error) => options.onError?.(error, event, ServiceWorkerErrorType.PLUGIN_ERROR)))));
         },
         activate: (event) => {
             event.waitUntil(Promise.all(handlers.activate.map((handler) => Promise.resolve()
-                .then(() => handler(event, options))
+                .then(() => handler(event, logger))
                 .catch((error) => options.onError?.(error, event, ServiceWorkerErrorType.PLUGIN_ERROR)))));
         },
         fetch: (event) => {
             event.respondWith((async () => {
                 for (const handler of handlers.fetch) {
                     try {
-                        const result = await handler(event, options);
+                        const result = await handler(event, logger);
                         if (result !== undefined) {
                             return result;
                         }
@@ -83,7 +83,7 @@ export function createEventHandlers(plugins, options) {
         message: (event) => {
             handlers.message.forEach((handler) => {
                 try {
-                    handler(event, options);
+                    handler(event, logger);
                 }
                 catch (error) {
                     options.onError?.(error, event, ServiceWorkerErrorType.PLUGIN_ERROR);
@@ -92,31 +92,76 @@ export function createEventHandlers(plugins, options) {
         },
         sync: (event) => {
             event.waitUntil(Promise.all(handlers.sync.map((handler) => Promise.resolve()
-                .then(() => handler(event, options))
+                .then(() => handler(event, logger))
                 .catch((error) => options.onError?.(error, event, ServiceWorkerErrorType.PLUGIN_ERROR)))));
         },
         periodicsync: (event) => {
             event.waitUntil(Promise.all(handlers.periodicsync.map((handler) => Promise.resolve()
-                .then(() => handler(event, options))
+                .then(() => handler(event, logger))
                 .catch((error) => options.onError?.(error, event, ServiceWorkerErrorType.PLUGIN_ERROR)))));
         },
         push: (event) => {
             event.waitUntil((async () => {
+                const returns = [];
                 for (const handler of handlers.push) {
                     try {
-                        const result = await Promise.resolve(handler(event, options));
-                        if (result != null &&
-                            typeof result === 'object' &&
-                            'title' in result &&
-                            typeof result.title === 'string') {
-                            const { title, ...opts } = result;
-                            await self.registration.showNotification(title, opts);
-                            return;
-                        }
+                        const result = await Promise.resolve(handler(event, logger));
+                        returns.push(result);
                     }
                     catch (error) {
                         options.onError?.(error, event, ServiceWorkerErrorType.PLUGIN_ERROR);
+                        returns.push(undefined);
+                    }
+                }
+                const payloads = returns.filter((r) => r != null &&
+                    typeof r === 'object' &&
+                    !Array.isArray(r) &&
+                    'title' in r &&
+                    typeof r.title === 'string');
+                if (returns.length === handlers.push.length &&
+                    returns.every((r) => r === false)) {
+                    return;
+                }
+                for (const payload of payloads) {
+                    const { title, ...opts } = payload;
+                    await self.registration.showNotification(title, opts);
+                }
+                if (payloads.length > 0) {
+                    return;
+                }
+                if (!returns.every((r) => r === undefined))
+                    return;
+                try {
+                    const data = event.data;
+                    if (!data) {
+                        return;
                     }
+                    let payload;
+                    try {
+                        payload = await data.json();
+                    }
+                    catch {
+                        const text = data.text();
+                        payload = text.length > 0 ? { title: text } : null;
+                    }
+                    if (payload == null) {
+                        return;
+                    }
+                    const withTitle = typeof payload === 'object' &&
+                        payload !== null &&
+                        'title' in payload &&
+                        typeof payload.title ===
+                            'string'
+                        ? payload
+                        : null;
+                    if (withTitle == null) {
+                        return;
+                    }
+                    const { title, ...opts } = withTitle;
+                    await self.registration.showNotification(title, opts);
+                }
+                catch (error) {
+                    options.onError?.(error, event, ServiceWorkerErrorType.PLUGIN_ERROR);
                 }
             })());
         },
@@ -180,4 +225,3 @@ export function initServiceWorker(plugins, options) {
     self.addEventListener(SW_EVENT_PERIODICSYNC, handlers.periodicsync);
     self.addEventListener(SW_EVENT_PUSH, handlers.push);
 }
-//# sourceMappingURL=index.js.map

package/dist/plugins/cacheFirst.d.ts

@@ -1,3 +1,5 @@
-import type { ServiceWorkerPlugin, OfflineFirstContext } from '../index.js';
-export declare const cacheFirst: ServiceWorkerPlugin<OfflineFirstContext>;
-//# sourceMappingURL=cacheFirst.d.ts.map
+import type { Plugin } from '../index.js';
+export interface CacheFirstConfig {
+    cacheName: string;
+}
+export declare function cacheFirst(config: CacheFirstConfig): Plugin;

package/dist/plugins/cacheFirst.js

@@ -1,20 +1,23 @@
-export const cacheFirst = {
-    name: 'cacheFirst',
-    fetch: async (event, context) => {
-        const cache = await caches.open(context.cacheName);
-        const cached = await cache.match(event.request);
-        if (cached)
-            return cached;
-        try {
-            const response = await fetch(event.request);
-            if (response.ok) {
-                await cache.put(event.request, response.clone());
+export function cacheFirst(config) {
+    const { cacheName } = config;
+    return {
+        name: 'cacheFirst',
+        fetch: async (event) => {
+            const cache = await caches.open(cacheName);
+            const cached = await cache.match(event.request);
+            if (cached) {
+                return cached;
             }
-            return response;
-        }
-        catch {
-            return undefined;
-        }
-    },
-};
-//# sourceMappingURL=cacheFirst.js.map
+            try {
+                const response = await fetch(event.request);
+                if (response.ok) {
+                    await cache.put(event.request, response.clone());
+                }
+                return response;
+            }
+            catch {
+                return undefined;
+            }
+        },
+    };
+}

package/dist/plugins/claim.d.ts

@@ -1,3 +1,2 @@
-import type { ServiceWorkerPlugin } from '../index.js';
-export declare const claim: ServiceWorkerPlugin;
-//# sourceMappingURL=claim.d.ts.map
+import type { Plugin } from '../index.js';
+export declare function claim(): Plugin;

package/dist/plugins/claim.js

@@ -1,7 +1,6 @@
-export const claim = {
-    name: 'claim',
-    activate: (event, _context) => {
-        event.waitUntil(Promise.resolve().then(() => self.clients.claim()));
-    },
-};
-//# sourceMappingURL=claim.js.map
+export function claim() {
+    return {
+        name: 'claim',
+        activate: () => self.clients.claim(),
+    };
+}

package/dist/plugins/claimAndReloadClients.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from '../index.js';
+export declare function claimAndReloadClients(): Plugin;

package/dist/plugins/claimAndReloadClients.js

@@ -0,0 +1,10 @@
+export function claimAndReloadClients() {
+    return {
+        name: 'claimAndReloadClients',
+        activate: () => self.clients
+            .claim()
+            .then(() => self.clients
+            .matchAll({ type: 'window' })
+            .then((list) => Promise.all(list.map((client) => client.navigate(client.url))))),
+    };
+}

package/dist/plugins/index.d.ts

@@ -1,10 +1,14 @@
+export { claim } from './claim.js';
 export { precache } from './precache.js';
+export { cacheFirst } from './cacheFirst.js';
 export { skipWaiting } from './skipWaiting.js';
-export { claim } from './claim.js';
-export { claimOnMessage } from './claimOnMessage.js';
+export { networkFirst } from './networkFirst.js';
+export { reloadClients } from './reloadClients.js';
 export { serveFromCache } from './serveFromCache.js';
+export { precacheMissing } from './precacheMissing.js';
+export { pruneStaleCache } from './pruneStaleCache.js';
+export { precacheAndNotify } from './precacheAndNotify.js';
 export { restoreAssetToCache } from './restoreAssetToCache.js';
-export { cacheFirst } from './cacheFirst.js';
-export { networkFirst } from './networkFirst.js';
+export { skipWaitingOnMessage } from './skipWaitingOnMessage.js';
 export { staleWhileRevalidate } from './staleWhileRevalidate.js';
-//# sourceMappingURL=index.d.ts.map
+export { claimAndReloadClients } from './claimAndReloadClients.js';

package/dist/plugins/index.js

@@ -1,10 +1,14 @@
+export { claim } from './claim.js';
 export { precache } from './precache.js';
+export { cacheFirst } from './cacheFirst.js';
 export { skipWaiting } from './skipWaiting.js';
-export { claim } from './claim.js';
-export { claimOnMessage } from './claimOnMessage.js';
+export { networkFirst } from './networkFirst.js';
+export { reloadClients } from './reloadClients.js';
 export { serveFromCache } from './serveFromCache.js';
+export { precacheMissing } from './precacheMissing.js';
+export { pruneStaleCache } from './pruneStaleCache.js';
+export { precacheAndNotify } from './precacheAndNotify.js';
 export { restoreAssetToCache } from './restoreAssetToCache.js';
-export { cacheFirst } from './cacheFirst.js';
-export { networkFirst } from './networkFirst.js';
+export { skipWaitingOnMessage } from './skipWaitingOnMessage.js';
 export { staleWhileRevalidate } from './staleWhileRevalidate.js';
-//# sourceMappingURL=index.js.map
+export { claimAndReloadClients } from './claimAndReloadClients.js';

package/dist/plugins/networkFirst.d.ts

@@ -1,3 +1,5 @@
-import type { ServiceWorkerPlugin, OfflineFirstContext } from '../index.js';
-export declare const networkFirst: ServiceWorkerPlugin<OfflineFirstContext>;
-//# sourceMappingURL=networkFirst.d.ts.map
+import type { Plugin } from '../index.js';
+export interface NetworkFirstConfig {
+    cacheName: string;
+}
+export declare function networkFirst(config: NetworkFirstConfig): Plugin;

package/dist/plugins/networkFirst.js

@@ -1,17 +1,19 @@
-export const networkFirst = {
-    name: 'networkFirst',
-    fetch: async (event, context) => {
-        const cache = await caches.open(context.cacheName);
-        try {
-            const response = await fetch(event.request);
-            if (response.ok) {
-                await cache.put(event.request, response.clone());
+export function networkFirst(config) {
+    const { cacheName } = config;
+    return {
+        name: 'networkFirst',
+        fetch: async (event) => {
+            const cache = await caches.open(cacheName);
+            try {
+                const response = await fetch(event.request);
+                if (response.ok) {
+                    await cache.put(event.request, response.clone());
+                }
+                return response;
             }
-            return response;
-        }
-        catch {
-            return (await cache.match(event.request)) ?? undefined;
-        }
-    },
-};
-//# sourceMappingURL=networkFirst.js.map
+            catch {
+                return (await cache.match(event.request)) ?? undefined;
+            }
+        },
+    };
+}

package/dist/plugins/precache.d.ts

@@ -1,3 +1,6 @@
-import type { ServiceWorkerPlugin, OfflineFirstContext } from '../index.js';
-export declare const precache: ServiceWorkerPlugin<OfflineFirstContext>;
-//# sourceMappingURL=precache.d.ts.map
+import type { Plugin } from '../index.js';
+export interface PrecacheConfig {
+    cacheName: string;
+    assets: string[];
+}
+export declare function precache(config: PrecacheConfig): Plugin;

package/dist/plugins/precache.js

@@ -1,8 +1,10 @@
-export const precache = {
-    name: 'precache',
-    install: async (_event, context) => {
-        const cache = await caches.open(context.cacheName);
-        await cache.addAll(context.assets);
-    },
-};
-//# sourceMappingURL=precache.js.map
+export function precache(config) {
+    const { cacheName, assets } = config;
+    return {
+        name: 'precache',
+        install: async () => {
+            const cache = await caches.open(cacheName);
+            await cache.addAll(assets);
+        },
+    };
+}

package/dist/plugins/precacheAndNotify.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from '../index.js';
+import type { PrecacheConfig } from './precache.js';
+export interface PrecacheAndNotifyConfig extends PrecacheConfig {
+    messageType?: string;
+}
+export declare function precacheAndNotify(config: PrecacheAndNotifyConfig): Plugin;

package/dist/plugins/precacheAndNotify.js

@@ -0,0 +1,13 @@
+import { notifyClients } from '../utils/notifyClients.js';
+import { SW_MSG_INSTALLED } from '@budarin/http-constants/service-worker';
+export function precacheAndNotify(config) {
+    const { cacheName, assets, messageType = SW_MSG_INSTALLED } = config;
+    return {
+        name: 'precacheAndNotify',
+        install: async () => {
+            const cache = await caches.open(cacheName);
+            await cache.addAll(assets);
+            await notifyClients(messageType);
+        },
+    };
+}

package/dist/plugins/precacheMissing.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from '../index.js';
+export interface PrecacheMissingConfig {
+    cacheName: string;
+    assets: string[];
+}
+export declare function precacheMissing(config: PrecacheMissingConfig): Plugin;

package/dist/plugins/precacheMissing.js

@@ -0,0 +1,16 @@
+import { normalizeUrl } from '../utils/normalizeUrl.js';
+export function precacheMissing(config) {
+    const { cacheName, assets } = config;
+    return {
+        name: 'precacheMissing',
+        install: async () => {
+            const cache = await caches.open(cacheName);
+            const keys = await cache.keys();
+            const cachedHrefs = new Set(keys.map((r) => normalizeUrl(r.url)));
+            const missing = assets.filter((url) => !cachedHrefs.has(normalizeUrl(url)));
+            if (missing.length > 0) {
+                await cache.addAll(missing);
+            }
+        },
+    };
+}

package/dist/plugins/pruneStaleCache.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from '../index.js';
+export interface PruneStaleCacheConfig {
+    cacheName: string;
+    assets: string[];
+}
+export declare function pruneStaleCache(config: PruneStaleCacheConfig): Plugin;

package/dist/plugins/pruneStaleCache.js

@@ -0,0 +1,17 @@
+import { normalizeUrl } from '../utils/normalizeUrl.js';
+export function pruneStaleCache(config) {
+    const { cacheName, assets } = config;
+    const assetHrefs = new Set(assets.map((url) => normalizeUrl(url)));
+    return {
+        name: 'pruneStaleCache',
+        activate: async () => {
+            const cache = await caches.open(cacheName);
+            const keys = await cache.keys();
+            await Promise.all(keys.map(async (request) => {
+                if (!assetHrefs.has(normalizeUrl(request.url))) {
+                    await cache.delete(request);
+                }
+            }));
+        },
+    };
+}

package/dist/plugins/reloadClients.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from '../index.js';
+export declare function reloadClients(): Plugin;

package/dist/plugins/reloadClients.js

@@ -0,0 +1,9 @@
+export function reloadClients() {
+    return {
+        name: 'reloadClients',
+        activate: async () => {
+            const list = await self.clients.matchAll({ type: 'window' });
+            await Promise.all(list.map((client) => client.navigate(client.url)));
+        },
+    };
+}

package/dist/plugins/restoreAssetToCache.d.ts

@@ -1,3 +1,6 @@
-import type { ServiceWorkerPlugin, OfflineFirstContext } from '../index.js';
-export declare const restoreAssetToCache: ServiceWorkerPlugin<OfflineFirstContext>;
-//# sourceMappingURL=restoreAssetToCache.d.ts.map
+import type { Plugin } from '../index.js';
+export interface RestoreAssetToCacheConfig {
+    cacheName: string;
+    assets: string[];
+}
+export declare function restoreAssetToCache(config: RestoreAssetToCacheConfig): Plugin;

package/dist/plugins/restoreAssetToCache.js

@@ -1,42 +1,27 @@
-function isAssetRequest(requestUrl, assets) {
-    try {
-        const url = new URL(requestUrl);
-        const pathname = url.pathname;
-        return assets.some((asset) => {
+import { isRequestUrlInAssets } from '../utils/isRequestUrlInAssets.js';
+export function restoreAssetToCache(config) {
+    const { cacheName, assets } = config;
+    return {
+        name: 'restoreAssetToCache',
+        fetch: async (event) => {
+            if (!isRequestUrlInAssets(event.request.url, assets)) {
+                return undefined;
+            }
+            const cache = await caches.open(cacheName);
+            const cached = await cache.match(event.request);
+            if (cached) {
+                return cached;
+            }
             try {
-                const assetUrl = new URL(asset, self.location.origin);
-                return url.href === assetUrl.href;
+                const response = await fetch(event.request);
+                if (response.ok) {
+                    await cache.put(event.request, response.clone());
+                }
+                return response;
             }
             catch {
-                const norm = asset.startsWith('/') ? asset : `/${asset}`;
-                return pathname === norm;
+                return undefined;
             }
-        });
-    }
-    catch {
-        return false;
-    }
+        },
+    };
 }
-export const restoreAssetToCache = {
-    name: 'restoreAssetToCache',
-    fetch: async (event, context) => {
-        if (!isAssetRequest(event.request.url, context.assets))
-            return undefined;
-        const cache = await caches.open(context.cacheName);
-        const cached = await cache.match(event.request);
-        if (cached) {
-            return cached;
-        }
-        try {
-            const response = await fetch(event.request);
-            if (response.ok) {
-                await cache.put(event.request, response.clone());
-            }
-            return response;
-        }
-        catch {
-            return undefined;
-        }
-    },
-};
-//# sourceMappingURL=restoreAssetToCache.js.map

package/dist/plugins/serveFromCache.d.ts

@@ -1,3 +1,5 @@
-import type { ServiceWorkerPlugin, OfflineFirstContext } from '../index.js';
-export declare const serveFromCache: ServiceWorkerPlugin<OfflineFirstContext>;
-//# sourceMappingURL=serveFromCache.d.ts.map
+import type { Plugin } from '../index.js';
+export interface ServeFromCacheConfig {
+    cacheName: string;
+}
+export declare function serveFromCache(config: ServeFromCacheConfig): Plugin;

package/dist/plugins/serveFromCache.js

@@ -1,11 +1,10 @@
-export const serveFromCache = {
-    name: 'serveFromCache',
-    fetch: async (event, context) => {
-        const cache = await caches.open(context.cacheName);
-        const options = context.cacheMatchIgnoreSearch
-            ? { ignoreSearch: true }
-            : undefined;
-        return cache.match(event.request, options) ?? undefined;
-    },
-};
-//# sourceMappingURL=serveFromCache.js.map
+export function serveFromCache(config) {
+    const { cacheName } = config;
+    return {
+        name: 'serveFromCache',
+        fetch: async (event) => {
+            const cache = await caches.open(cacheName);
+            return cache.match(event.request) ?? undefined;
+        },
+    };
+}

package/dist/plugins/skipWaiting.d.ts

@@ -1,3 +1,2 @@
-import type { ServiceWorkerPlugin } from '../index.js';
-export declare const skipWaiting: ServiceWorkerPlugin;
-//# sourceMappingURL=skipWaiting.d.ts.map
+import type { Plugin } from '../index.js';
+export declare function skipWaiting(): Plugin;

package/dist/plugins/skipWaiting.js

@@ -1,7 +1,8 @@
-export const skipWaiting = {
-    name: 'skipWaiting',
-    install: (_event, _context) => {
-        self.skipWaiting();
-    },
-};
-//# sourceMappingURL=skipWaiting.js.map
+export function skipWaiting() {
+    return {
+        name: 'skipWaiting',
+        install: (_event, _logger) => {
+            self.skipWaiting();
+        },
+    };
+}

package/dist/plugins/skipWaitingOnMessage.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin } from '../index.js';
+export interface SkipWaitingOnMessageConfig {
+    messageType?: string;
+}
+export declare function skipWaitingOnMessage(config?: SkipWaitingOnMessageConfig): Plugin;