@serwist/recipes 8.0.0

package/.turbo/turbo-build.log

@@ -0,0 +1,10 @@
+
+> @serwist/recipes@8.0.0 build /home/runner/work/serwist/serwist/packages/recipes
+> rimraf dist && cross-env NODE_ENV=production rollup --config rollup.config.js
+
+(node:2995) ExperimentalWarning: Import assertions are not a stable feature of the JavaScript language. Avoid relying on their current behavior and syntax as those might change in a future version of Node.js.
+(Use `node --trace-warnings ...` to show where the warning was created)
+(node:2995) ExperimentalWarning: Importing JSON modules is an experimental feature and might change at any time
+
+src/index.ts → dist/index.old.cjs, dist/index.js...
+created dist/index.old.cjs, dist/index.js in 1.8s

package/.turbo/turbo-lint.log

@@ -0,0 +1,4 @@
+
+> @serwist/recipes@8.0.0 lint /home/runner/work/serwist/serwist/packages/recipes
+> eslint src --ext ts,tsx,js,jsx,cjs,mjs
+

package/.turbo/turbo-typecheck.log

@@ -0,0 +1,4 @@
+
+> @serwist/recipes@8.0.0 typecheck /home/runner/work/serwist/serwist/packages/recipes
+> tsc
+

package/CHANGELOG.md

@@ -0,0 +1,38 @@
+# @serwist/recipes
+
+## 8.0.0
+
+### Major Changes
+
+- [`e0313f0`](https://github.com/serwist/serwist/commit/e0313f02f661a07ccbe9edc64e44e1af6136c73e) Thanks [@DuCanhGH](https://github.com/DuCanhGH)! - chore: initial release
+
+  - Reimagined `@serwist/next`.
+    - Removed various options.
+      - Removed `aggressiveFrontEndNavCaching` to reassess its usefulness.
+      - Removed `browserslist`. Use `swcEnvTargets` instead (TODO: add this option).
+      - Custom workers have been removed. You should use `swSrc`.
+      - Removed `extendDefaultRuntimeCaching`. Use the spread syntax instead (use `import { defaultCache } from "@serwist/next/browser"` to import the default runtimeCaching array).
+      - Temporarily removed `fallbacks` to investigate module-friendly alternatives.
+      - Removed `swcMinify`.
+      - Removed `watchWorkersInDev`.
+      - Removed `cacheStartUrl`, `dynamicStartUrl`, and `dynamicStartUrl`. These shall be re-added only when their use cases are made more clear to me.
+    - Merged `workboxOptions` with the plugin's options.
+    - Removed `swc-loader`, `terser-minify`, `webpack-builders`,... (we now leverage `ChildCompilationPlugin` to compile workers - this change will be backported to `@ducanh2912/next-pwa@10`)
+    - Removed the ability to use GenerateSW. `@serwist/sw.installSerwist` is provided as a replacement.
+    - `swSrc` is now a required property.
+    - Moved minimum support Next.js version from `11.0.0` to `14.0.0`.
+  - Removed GenerateSW (replaced by `@serwist/sw.installSerwist`).
+    - See `examples/next-basic/app/sw.ts` to see how `installSerwist` should be used.
+  - Repurposed `@serwist/sw`.
+    - The old package might be reintroduced if there's demand.
+  - **Note:** This is just the initial release, and there is still a lot of ground to cover (a lot of legacy code to be removed, a lot of features to be reintroduced,...). Here's to a bright future for the project :\_)
+
+### Patch Changes
+
+- Updated dependencies [[`e0313f0`](https://github.com/serwist/serwist/commit/e0313f02f661a07ccbe9edc64e44e1af6136c73e)]:
+  - @serwist/cacheable-response@8.0.0
+  - @serwist/expiration@8.0.0
+  - @serwist/precaching@8.0.0
+  - @serwist/strategies@8.0.0
+  - @serwist/routing@8.0.0
+  - @serwist/core@8.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Google LLC, 2019 ShadowWalker w@weiw.io https://weiw.io, 2023 Serwist
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+This module's documentation can be found at https://developers.google.com/web/tools/workbox/modules/workbox-recipes

package/dist/googleFontsCache.d.ts

@@ -0,0 +1,22 @@
+export interface GoogleFontCacheOptions {
+    /**
+     * Cache prefix for caching stylesheets and webfonts. Defaults to google-fonts.
+     */
+    cachePrefix?: string;
+    /**
+     * Maximum age, in seconds, that font entries will be cached for. Defaults to 1 year.
+     */
+    maxAgeSeconds?: number;
+    /**
+     * Maximum number of fonts that will be cached. Defaults to 30.
+     */
+    maxEntries?: number;
+}
+/**
+ * An implementation of the [Google fonts](https://developers.google.com/web/tools/workbox/guides/common-recipes#google_fonts) caching recipe.
+ *
+ * @param options
+ */
+declare function googleFontsCache(options?: GoogleFontCacheOptions): void;
+export { googleFontsCache };
+//# sourceMappingURL=googleFontsCache.d.ts.map

package/dist/googleFontsCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"googleFontsCache.d.ts","sourceRoot":"","sources":["../src/googleFontsCache.ts"],"names":[],"mappings":"AAaA,MAAM,WAAW,sBAAsB;IACrC;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;GAIG;AACH,iBAAS,gBAAgB,CAAC,OAAO,GAAE,sBAA2B,GAAG,IAAI,CA8BpE;AAED,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/imageCache.d.ts

@@ -0,0 +1,35 @@
+import type { RouteMatchCallback, SerwistPlugin } from "@serwist/core";
+export interface ImageCacheOptions {
+    /**
+     * Name for cache. Defaults to images.
+     */
+    cacheName?: string;
+    /**
+     * Serwist callback function to call to match to. Defaults to request.destination === 'image'.
+     */
+    matchCallback?: RouteMatchCallback;
+    /**
+     * Maximum age, in seconds, that image entries will be cached for. Defaults to 30 days.
+     */
+    maxAgeSeconds?: number;
+    /**
+     * Maximum number of images that will be cached. Defaults to 60.
+     */
+    maxEntries?: number;
+    /**
+     * Additional plugins to use for this recipe.
+     */
+    plugins?: SerwistPlugin[];
+    /**
+     * Paths to call to use to warm this cache.
+     */
+    warmCache?: string[];
+}
+/**
+ * An implementation of the [image caching recipe](https://developers.google.com/web/tools/workbox/guides/common-recipes#caching_images).
+ *
+ * @param options
+ */
+declare function imageCache(options?: ImageCacheOptions): void;
+export { imageCache };
+//# sourceMappingURL=imageCache.d.ts.map

package/dist/imageCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"imageCache.d.ts","sourceRoot":"","sources":["../src/imageCache.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,kBAAkB,EAA6B,aAAa,EAAE,MAAM,eAAe,CAAC;AAOlG,MAAM,WAAW,iBAAiB;IAChC;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;OAEG;IACH,aAAa,CAAC,EAAE,kBAAkB,CAAC;IACnC;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;OAEG;IACH,OAAO,CAAC,EAAE,aAAa,EAAE,CAAC;IAC1B;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB;AAED;;;;GAIG;AACH,iBAAS,UAAU,CAAC,OAAO,GAAE,iBAAsB,GAAG,IAAI,CA+BzD;AAED,OAAO,EAAE,UAAU,EAAE,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+import type { GoogleFontCacheOptions } from "./googleFontsCache.js";
+import { googleFontsCache } from "./googleFontsCache.js";
+import type { ImageCacheOptions } from "./imageCache.js";
+import { imageCache } from "./imageCache.js";
+import type { OfflineFallbackOptions } from "./offlineFallback.js";
+import { offlineFallback } from "./offlineFallback.js";
+import type { PageCacheOptions } from "./pageCache.js";
+import { pageCache } from "./pageCache.js";
+import type { StaticResourceOptions } from "./staticResourceCache.js";
+import { staticResourceCache } from "./staticResourceCache.js";
+import type { WarmStrategyCacheOptions } from "./warmStrategyCache.js";
+import { warmStrategyCache } from "./warmStrategyCache.js";
+export { googleFontsCache, imageCache, offlineFallback, pageCache, staticResourceCache, warmStrategyCache };
+export type { GoogleFontCacheOptions, ImageCacheOptions, OfflineFallbackOptions, PageCacheOptions, StaticResourceOptions, WarmStrategyCacheOptions };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AACpE,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AACtE,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AACvE,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAE3D,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,eAAe,EAAE,SAAS,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,CAAC;AAC5G,YAAY,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,wBAAwB,EAAE,CAAC"}

package/dist/index.js

@@ -0,0 +1,187 @@
+import { CacheableResponsePlugin } from '@serwist/cacheable-response';
+import { ExpirationPlugin } from '@serwist/expiration';
+import { registerRoute, setCatchHandler } from '@serwist/routing';
+import { StaleWhileRevalidate, CacheFirst, NetworkFirst } from '@serwist/strategies';
+import { matchPrecache } from '@serwist/precaching';
+
+/**
+ * An implementation of the [Google fonts](https://developers.google.com/web/tools/workbox/guides/common-recipes#google_fonts) caching recipe.
+ *
+ * @param options
+ */ function googleFontsCache(options = {}) {
+    const sheetCacheName = `${options.cachePrefix || "google-fonts"}-stylesheets`;
+    const fontCacheName = `${options.cachePrefix || "google-fonts"}-webfonts`;
+    const maxAgeSeconds = options.maxAgeSeconds || 60 * 60 * 24 * 365;
+    const maxEntries = options.maxEntries || 30;
+    // Cache the Google Fonts stylesheets with a stale-while-revalidate strategy.
+    registerRoute(({ url })=>url.origin === "https://fonts.googleapis.com", new StaleWhileRevalidate({
+        cacheName: sheetCacheName
+    }));
+    // Cache the underlying font files with a cache-first strategy for 1 year.
+    registerRoute(({ url })=>url.origin === "https://fonts.gstatic.com", new CacheFirst({
+        cacheName: fontCacheName,
+        plugins: [
+            new CacheableResponsePlugin({
+                statuses: [
+                    0,
+                    200
+                ]
+            }),
+            new ExpirationPlugin({
+                maxAgeSeconds,
+                maxEntries
+            })
+        ]
+    }));
+}
+
+/**
+ * @param options
+ */ function warmStrategyCache(options) {
+    self.addEventListener("install", (event)=>{
+        const done = options.urls.map((path)=>options.strategy.handleAll({
+                event,
+                request: new Request(path)
+            })[1]);
+        event.waitUntil(Promise.all(done));
+    });
+}
+
+/**
+ * An implementation of the [image caching recipe](https://developers.google.com/web/tools/workbox/guides/common-recipes#caching_images).
+ *
+ * @param options
+ */ function imageCache(options = {}) {
+    const defaultMatchCallback = ({ request })=>request.destination === "image";
+    const cacheName = options.cacheName || "images";
+    const matchCallback = options.matchCallback || defaultMatchCallback;
+    const maxAgeSeconds = options.maxAgeSeconds || 30 * 24 * 60 * 60;
+    const maxEntries = options.maxEntries || 60;
+    const plugins = options.plugins || [];
+    plugins.push(new CacheableResponsePlugin({
+        statuses: [
+            0,
+            200
+        ]
+    }));
+    plugins.push(new ExpirationPlugin({
+        maxEntries,
+        maxAgeSeconds
+    }));
+    const strategy = new CacheFirst({
+        cacheName,
+        plugins
+    });
+    registerRoute(matchCallback, strategy);
+    // Warms the cache
+    if (options.warmCache) {
+        warmStrategyCache({
+            urls: options.warmCache,
+            strategy
+        });
+    }
+}
+
+/**
+ * An implementation of the [comprehensive fallbacks recipe](https://developers.google.com/web/tools/workbox/guides/advanced-recipes#comprehensive_fallbacks). 
+ * Be sure to include the fallbacks in your precache injection.
+
+ * @param options
+ */ function offlineFallback(options = {}) {
+    const pageFallback = options.pageFallback || "offline.html";
+    const imageFallback = options.imageFallback || false;
+    const fontFallback = options.fontFallback || false;
+    self.addEventListener("install", (event)=>{
+        const files = [
+            pageFallback
+        ];
+        if (imageFallback) {
+            files.push(imageFallback);
+        }
+        if (fontFallback) {
+            files.push(fontFallback);
+        }
+        event.waitUntil(self.caches.open("serwist-offline-fallbacks").then((cache)=>cache.addAll(files)));
+    });
+    const handler = async (options)=>{
+        const dest = options.request.destination;
+        const cache = await self.caches.open("serwist-offline-fallbacks");
+        if (dest === "document") {
+            const match = await matchPrecache(pageFallback) || await cache.match(pageFallback);
+            return match || Response.error();
+        }
+        if (dest === "image" && imageFallback !== false) {
+            const match = await matchPrecache(imageFallback) || await cache.match(imageFallback);
+            return match || Response.error();
+        }
+        if (dest === "font" && fontFallback !== false) {
+            const match = await matchPrecache(fontFallback) || await cache.match(fontFallback);
+            return match || Response.error();
+        }
+        return Response.error();
+    };
+    setCatchHandler(handler);
+}
+
+/**
+ * An implementation of a page caching recipe with a network timeout.
+ *
+ * @param options
+ */ function pageCache(options = {}) {
+    const defaultMatchCallback = ({ request })=>request.mode === "navigate";
+    const cacheName = options.cacheName || "pages";
+    const matchCallback = options.matchCallback || defaultMatchCallback;
+    const networkTimeoutSeconds = options.networkTimeoutSeconds || 3;
+    const plugins = options.plugins || [];
+    plugins.push(new CacheableResponsePlugin({
+        statuses: [
+            0,
+            200
+        ]
+    }));
+    const strategy = new NetworkFirst({
+        networkTimeoutSeconds,
+        cacheName,
+        plugins
+    });
+    // Registers the route
+    registerRoute(matchCallback, strategy);
+    // Warms the cache
+    if (options.warmCache) {
+        warmStrategyCache({
+            urls: options.warmCache,
+            strategy
+        });
+    }
+}
+
+/**
+ * An implementation of the [CSS and JavaScript files recipe](https://developers.google.com/web/tools/workbox/guides/common-recipes#cache_css_and_javascript_files).
+ *
+ * @param options
+ */ function staticResourceCache(options = {}) {
+    const defaultMatchCallback = ({ request })=>request.destination === "style" || request.destination === "script" || request.destination === "worker";
+    const cacheName = options.cacheName || "static-resources";
+    const matchCallback = options.matchCallback || defaultMatchCallback;
+    const plugins = options.plugins || [];
+    plugins.push(new CacheableResponsePlugin({
+        statuses: [
+            0,
+            200
+        ]
+    }));
+    const strategy = new StaleWhileRevalidate({
+        cacheName,
+        plugins
+    });
+    registerRoute(matchCallback, strategy);
+    // Warms the cache
+    if (options.warmCache) {
+        warmStrategyCache({
+            urls: options.warmCache,
+            strategy
+        });
+    }
+}
+
+export { googleFontsCache, imageCache, offlineFallback, pageCache, staticResourceCache, warmStrategyCache };

package/dist/index.old.cjs

@@ -0,0 +1,194 @@
+'use strict';
+
+var cacheableResponse = require('@serwist/cacheable-response');
+var expiration = require('@serwist/expiration');
+var routing = require('@serwist/routing');
+var strategies = require('@serwist/strategies');
+var precaching = require('@serwist/precaching');
+
+/**
+ * An implementation of the [Google fonts](https://developers.google.com/web/tools/workbox/guides/common-recipes#google_fonts) caching recipe.
+ *
+ * @param options
+ */ function googleFontsCache(options = {}) {
+    const sheetCacheName = `${options.cachePrefix || "google-fonts"}-stylesheets`;
+    const fontCacheName = `${options.cachePrefix || "google-fonts"}-webfonts`;
+    const maxAgeSeconds = options.maxAgeSeconds || 60 * 60 * 24 * 365;
+    const maxEntries = options.maxEntries || 30;
+    // Cache the Google Fonts stylesheets with a stale-while-revalidate strategy.
+    routing.registerRoute(({ url })=>url.origin === "https://fonts.googleapis.com", new strategies.StaleWhileRevalidate({
+        cacheName: sheetCacheName
+    }));
+    // Cache the underlying font files with a cache-first strategy for 1 year.
+    routing.registerRoute(({ url })=>url.origin === "https://fonts.gstatic.com", new strategies.CacheFirst({
+        cacheName: fontCacheName,
+        plugins: [
+            new cacheableResponse.CacheableResponsePlugin({
+                statuses: [
+                    0,
+                    200
+                ]
+            }),
+            new expiration.ExpirationPlugin({
+                maxAgeSeconds,
+                maxEntries
+            })
+        ]
+    }));
+}
+
+/**
+ * @param options
+ */ function warmStrategyCache(options) {
+    self.addEventListener("install", (event)=>{
+        const done = options.urls.map((path)=>options.strategy.handleAll({
+                event,
+                request: new Request(path)
+            })[1]);
+        event.waitUntil(Promise.all(done));
+    });
+}
+
+/**
+ * An implementation of the [image caching recipe](https://developers.google.com/web/tools/workbox/guides/common-recipes#caching_images).
+ *
+ * @param options
+ */ function imageCache(options = {}) {
+    const defaultMatchCallback = ({ request })=>request.destination === "image";
+    const cacheName = options.cacheName || "images";
+    const matchCallback = options.matchCallback || defaultMatchCallback;
+    const maxAgeSeconds = options.maxAgeSeconds || 30 * 24 * 60 * 60;
+    const maxEntries = options.maxEntries || 60;
+    const plugins = options.plugins || [];
+    plugins.push(new cacheableResponse.CacheableResponsePlugin({
+        statuses: [
+            0,
+            200
+        ]
+    }));
+    plugins.push(new expiration.ExpirationPlugin({
+        maxEntries,
+        maxAgeSeconds
+    }));
+    const strategy = new strategies.CacheFirst({
+        cacheName,
+        plugins
+    });
+    routing.registerRoute(matchCallback, strategy);
+    // Warms the cache
+    if (options.warmCache) {
+        warmStrategyCache({
+            urls: options.warmCache,
+            strategy
+        });
+    }
+}
+
+/**
+ * An implementation of the [comprehensive fallbacks recipe](https://developers.google.com/web/tools/workbox/guides/advanced-recipes#comprehensive_fallbacks). 
+ * Be sure to include the fallbacks in your precache injection.
+
+ * @param options
+ */ function offlineFallback(options = {}) {
+    const pageFallback = options.pageFallback || "offline.html";
+    const imageFallback = options.imageFallback || false;
+    const fontFallback = options.fontFallback || false;
+    self.addEventListener("install", (event)=>{
+        const files = [
+            pageFallback
+        ];
+        if (imageFallback) {
+            files.push(imageFallback);
+        }
+        if (fontFallback) {
+            files.push(fontFallback);
+        }
+        event.waitUntil(self.caches.open("serwist-offline-fallbacks").then((cache)=>cache.addAll(files)));
+    });
+    const handler = async (options)=>{
+        const dest = options.request.destination;
+        const cache = await self.caches.open("serwist-offline-fallbacks");
+        if (dest === "document") {
+            const match = await precaching.matchPrecache(pageFallback) || await cache.match(pageFallback);
+            return match || Response.error();
+        }
+        if (dest === "image" && imageFallback !== false) {
+            const match = await precaching.matchPrecache(imageFallback) || await cache.match(imageFallback);
+            return match || Response.error();
+        }
+        if (dest === "font" && fontFallback !== false) {
+            const match = await precaching.matchPrecache(fontFallback) || await cache.match(fontFallback);
+            return match || Response.error();
+        }
+        return Response.error();
+    };
+    routing.setCatchHandler(handler);
+}
+
+/**
+ * An implementation of a page caching recipe with a network timeout.
+ *
+ * @param options
+ */ function pageCache(options = {}) {
+    const defaultMatchCallback = ({ request })=>request.mode === "navigate";
+    const cacheName = options.cacheName || "pages";
+    const matchCallback = options.matchCallback || defaultMatchCallback;
+    const networkTimeoutSeconds = options.networkTimeoutSeconds || 3;
+    const plugins = options.plugins || [];
+    plugins.push(new cacheableResponse.CacheableResponsePlugin({
+        statuses: [
+            0,
+            200
+        ]
+    }));
+    const strategy = new strategies.NetworkFirst({
+        networkTimeoutSeconds,
+        cacheName,
+        plugins
+    });
+    // Registers the route
+    routing.registerRoute(matchCallback, strategy);
+    // Warms the cache
+    if (options.warmCache) {
+        warmStrategyCache({
+            urls: options.warmCache,
+            strategy
+        });
+    }
+}
+
+/**
+ * An implementation of the [CSS and JavaScript files recipe](https://developers.google.com/web/tools/workbox/guides/common-recipes#cache_css_and_javascript_files).
+ *
+ * @param options
+ */ function staticResourceCache(options = {}) {
+    const defaultMatchCallback = ({ request })=>request.destination === "style" || request.destination === "script" || request.destination === "worker";
+    const cacheName = options.cacheName || "static-resources";
+    const matchCallback = options.matchCallback || defaultMatchCallback;
+    const plugins = options.plugins || [];
+    plugins.push(new cacheableResponse.CacheableResponsePlugin({
+        statuses: [
+            0,
+            200
+        ]
+    }));
+    const strategy = new strategies.StaleWhileRevalidate({
+        cacheName,
+        plugins
+    });
+    routing.registerRoute(matchCallback, strategy);
+    // Warms the cache
+    if (options.warmCache) {
+        warmStrategyCache({
+            urls: options.warmCache,
+            strategy
+        });
+    }
+}
+
+exports.googleFontsCache = googleFontsCache;
+exports.imageCache = imageCache;
+exports.offlineFallback = offlineFallback;
+exports.pageCache = pageCache;
+exports.staticResourceCache = staticResourceCache;
+exports.warmStrategyCache = warmStrategyCache;

package/dist/offlineFallback.d.ts

@@ -0,0 +1,23 @@
+export interface OfflineFallbackOptions {
+    /**
+     * Precache name to match for page fallbacks. Defaults to offline.html.
+     */
+    pageFallback?: string;
+    /**
+     * Precache name to match for image fallbacks.
+     */
+    imageFallback?: string;
+    /**
+     * Precache name to match for font fallbacks.
+     */
+    fontFallback?: string;
+}
+/**
+ * An implementation of the [comprehensive fallbacks recipe](https://developers.google.com/web/tools/workbox/guides/advanced-recipes#comprehensive_fallbacks).
+ * Be sure to include the fallbacks in your precache injection.
+
+ * @param options
+ */
+declare function offlineFallback(options?: OfflineFallbackOptions): void;
+export { offlineFallback };
+//# sourceMappingURL=offlineFallback.d.ts.map

package/dist/offlineFallback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"offlineFallback.d.ts","sourceRoot":"","sources":["../src/offlineFallback.ts"],"names":[],"mappings":"AAYA,MAAM,WAAW,sBAAsB;IACrC;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAKD;;;;;GAKG;AACH,iBAAS,eAAe,CAAC,OAAO,GAAE,sBAA2B,GAAG,IAAI,CAwCnE;AAED,OAAO,EAAE,eAAe,EAAE,CAAC"}

package/dist/pageCache.d.ts

@@ -0,0 +1,33 @@
+import type { RouteMatchCallback, SerwistPlugin } from "@serwist/core";
+export interface PageCacheOptions {
+    /**
+     * Name for cache. Defaults to pages.
+     */
+    cacheName?: string;
+    /**
+     * Serwist callback function to call to match to. Defaults to request.mode === 'navigate'.
+     */
+    matchCallback?: RouteMatchCallback;
+    /**
+     * Maximum amount of time, in seconds, to wait on the network before falling back to cache.
+     *
+     * @default 3
+     */
+    networkTimeoutSeconds?: number;
+    /**
+     * Additional plugins to use for this recipe.
+     */
+    plugins?: SerwistPlugin[];
+    /**
+     * Paths to call to use to warm this cache
+     */
+    warmCache?: string[];
+}
+/**
+ * An implementation of a page caching recipe with a network timeout.
+ *
+ * @param options
+ */
+declare function pageCache(options?: PageCacheOptions): void;
+export { pageCache };
+//# sourceMappingURL=pageCache.d.ts.map

package/dist/pageCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pageCache.d.ts","sourceRoot":"","sources":["../src/pageCache.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,kBAAkB,EAA6B,aAAa,EAAE,MAAM,eAAe,CAAC;AAMlG,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;OAEG;IACH,aAAa,CAAC,EAAE,kBAAkB,CAAC;IACnC;;;;OAIG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B;;OAEG;IACH,OAAO,CAAC,EAAE,aAAa,EAAE,CAAC;IAC1B;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB;AAED;;;;GAIG;AACH,iBAAS,SAAS,CAAC,OAAO,GAAE,gBAAqB,GAAG,IAAI,CA0BvD;AAED,OAAO,EAAE,SAAS,EAAE,CAAC"}

package/dist/staticResourceCache.d.ts

@@ -0,0 +1,31 @@
+import type { RouteMatchCallback, SerwistPlugin } from "@serwist/core";
+export interface StaticResourceOptions {
+    /**
+     * Name for cache.
+     *
+     * @default "static-resources"
+     */
+    cacheName?: string;
+    /**
+     * Serwist callback function to call to match to.
+     *
+     * @default request.destination === 'style' || request.destination === 'script' || request.destination === 'worker'
+     */
+    matchCallback?: RouteMatchCallback;
+    /**
+     * Additional plugins to use for this recipe.
+     */
+    plugins?: SerwistPlugin[];
+    /**
+     * Paths to call to use to warm this cache.
+     */
+    warmCache?: string[];
+}
+/**
+ * An implementation of the [CSS and JavaScript files recipe](https://developers.google.com/web/tools/workbox/guides/common-recipes#cache_css_and_javascript_files).
+ *
+ * @param options
+ */
+declare function staticResourceCache(options?: StaticResourceOptions): void;
+export { staticResourceCache };
+//# sourceMappingURL=staticResourceCache.d.ts.map

package/dist/staticResourceCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"staticResourceCache.d.ts","sourceRoot":"","sources":["../src/staticResourceCache.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,kBAAkB,EAA6B,aAAa,EAAE,MAAM,eAAe,CAAC;AAMlG,MAAM,WAAW,qBAAqB;IACpC;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,aAAa,CAAC,EAAE,kBAAkB,CAAC;IACnC;;OAEG;IACH,OAAO,CAAC,EAAE,aAAa,EAAE,CAAC;IAC1B;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB;AAED;;;;GAIG;AACH,iBAAS,mBAAmB,CAAC,OAAO,GAAE,qBAA0B,GAAG,IAAI,CAwBtE;AAED,OAAO,EAAE,mBAAmB,EAAE,CAAC"}

package/dist/warmStrategyCache.d.ts

@@ -0,0 +1,17 @@
+import type { Strategy } from "@serwist/strategies";
+export interface WarmStrategyCacheOptions {
+    /**
+     * Paths to warm the strategy's cache with.
+     */
+    urls: string[];
+    /**
+     * Strategy to use.
+     */
+    strategy: Strategy;
+}
+/**
+ * @param options
+ */
+declare function warmStrategyCache(options: WarmStrategyCacheOptions): void;
+export { warmStrategyCache };
+//# sourceMappingURL=warmStrategyCache.d.ts.map

package/dist/warmStrategyCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"warmStrategyCache.d.ts","sourceRoot":"","sources":["../src/warmStrategyCache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAEpD,MAAM,WAAW,wBAAwB;IACvC;;OAEG;IACH,IAAI,EAAE,MAAM,EAAE,CAAC;IACf;;OAEG;IACH,QAAQ,EAAE,QAAQ,CAAC;CACpB;AAKD;;GAEG;AACH,iBAAS,iBAAiB,CAAC,OAAO,EAAE,wBAAwB,GAAG,IAAI,CAYlE;AAED,OAAO,EAAE,iBAAiB,EAAE,CAAC"}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@serwist/recipes",
+  "version": "8.0.0",
+  "type": "module",
+  "description": "A service worker helper library to manage common request and caching patterns",
+  "keywords": [
+    "serwist",
+    "serwistjs",
+    "service worker",
+    "sw",
+    "router",
+    "routing"
+  ],
+  "author": "Google's Web DevRel Team, Serwist's Team",
+  "license": "MIT",
+  "repository": "serwist/serwist",
+  "bugs": "https://github.com/serwist/serwist/issues",
+  "homepage": "https://ducanh-next-pwa.vercel.app",
+  "module": "./dist/index.js",
+  "main": "./dist/index.old.cjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.old.cjs",
+      "types": "./dist/index.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@serwist/cacheable-response": "8.0.0",
+    "@serwist/core": "8.0.0",
+    "@serwist/expiration": "8.0.0",
+    "@serwist/precaching": "8.0.0",
+    "@serwist/routing": "8.0.0",
+    "@serwist/strategies": "8.0.0"
+  },
+  "devDependencies": {
+    "rollup": "3.28.1",
+    "@serwist/constants": "8.0.0"
+  },
+  "scripts": {
+    "build": "rimraf dist && cross-env NODE_ENV=production rollup --config rollup.config.js",
+    "lint": "eslint src --ext ts,tsx,js,jsx,cjs,mjs",
+    "typecheck": "tsc"
+  }
+}

package/rollup.config.js

@@ -0,0 +1,27 @@
+// @ts-check
+import { getRollupOptions } from "@serwist/constants/rollup";
+
+import packageJson from "./package.json" assert { type: "json" };
+
+const isDev = process.env.NODE_ENV === "development";
+
+export default getRollupOptions({
+  packageJson,
+  jsFiles: [
+    {
+      input: "src/index.ts",
+      output: [
+        {
+          file: "dist/index.old.cjs",
+          format: "cjs",
+          exports: "named",
+        },
+        {
+          file: "dist/index.js",
+          format: "esm",
+        },
+      ],
+    },
+  ],
+  shouldEmitDeclaration: !isDev,
+});

package/src/googleFontsCache.ts

@@ -0,0 +1,66 @@
+/*
+  Copyright 2020 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+import { CacheableResponsePlugin } from "@serwist/cacheable-response";
+import { ExpirationPlugin } from "@serwist/expiration";
+import { registerRoute } from "@serwist/routing";
+import { CacheFirst, StaleWhileRevalidate } from "@serwist/strategies";
+
+export interface GoogleFontCacheOptions {
+  /**
+   * Cache prefix for caching stylesheets and webfonts. Defaults to google-fonts.
+   */
+  cachePrefix?: string;
+  /**
+   * Maximum age, in seconds, that font entries will be cached for. Defaults to 1 year.
+   */
+  maxAgeSeconds?: number;
+  /**
+   * Maximum number of fonts that will be cached. Defaults to 30.
+   */
+  maxEntries?: number;
+}
+
+/**
+ * An implementation of the [Google fonts](https://developers.google.com/web/tools/workbox/guides/common-recipes#google_fonts) caching recipe.
+ *
+ * @param options
+ */
+function googleFontsCache(options: GoogleFontCacheOptions = {}): void {
+  const sheetCacheName = `${options.cachePrefix || "google-fonts"}-stylesheets`;
+  const fontCacheName = `${options.cachePrefix || "google-fonts"}-webfonts`;
+  const maxAgeSeconds = options.maxAgeSeconds || 60 * 60 * 24 * 365;
+  const maxEntries = options.maxEntries || 30;
+
+  // Cache the Google Fonts stylesheets with a stale-while-revalidate strategy.
+  registerRoute(
+    ({ url }) => url.origin === "https://fonts.googleapis.com",
+    new StaleWhileRevalidate({
+      cacheName: sheetCacheName,
+    })
+  );
+
+  // Cache the underlying font files with a cache-first strategy for 1 year.
+  registerRoute(
+    ({ url }) => url.origin === "https://fonts.gstatic.com",
+    new CacheFirst({
+      cacheName: fontCacheName,
+      plugins: [
+        new CacheableResponsePlugin({
+          statuses: [0, 200],
+        }),
+        new ExpirationPlugin({
+          maxAgeSeconds,
+          maxEntries,
+        }),
+      ],
+    })
+  );
+}
+
+export { googleFontsCache };

package/src/imageCache.ts

@@ -0,0 +1,82 @@
+/*
+  Copyright 2020 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+import { CacheableResponsePlugin } from "@serwist/cacheable-response";
+import type { RouteMatchCallback, RouteMatchCallbackOptions, SerwistPlugin } from "@serwist/core";
+import { ExpirationPlugin } from "@serwist/expiration";
+import { registerRoute } from "@serwist/routing";
+import { CacheFirst } from "@serwist/strategies";
+
+import { warmStrategyCache } from "./warmStrategyCache.js";
+
+export interface ImageCacheOptions {
+  /**
+   * Name for cache. Defaults to images.
+   */
+  cacheName?: string;
+  /**
+   * Serwist callback function to call to match to. Defaults to request.destination === 'image'.
+   */
+  matchCallback?: RouteMatchCallback;
+  /**
+   * Maximum age, in seconds, that image entries will be cached for. Defaults to 30 days.
+   */
+  maxAgeSeconds?: number;
+  /**
+   * Maximum number of images that will be cached. Defaults to 60.
+   */
+  maxEntries?: number;
+  /**
+   * Additional plugins to use for this recipe.
+   */
+  plugins?: SerwistPlugin[];
+  /**
+   * Paths to call to use to warm this cache.
+   */
+  warmCache?: string[];
+}
+
+/**
+ * An implementation of the [image caching recipe](https://developers.google.com/web/tools/workbox/guides/common-recipes#caching_images).
+ *
+ * @param options
+ */
+function imageCache(options: ImageCacheOptions = {}): void {
+  const defaultMatchCallback = ({ request }: RouteMatchCallbackOptions) => request.destination === "image";
+
+  const cacheName = options.cacheName || "images";
+  const matchCallback = options.matchCallback || defaultMatchCallback;
+  const maxAgeSeconds = options.maxAgeSeconds || 30 * 24 * 60 * 60;
+  const maxEntries = options.maxEntries || 60;
+  const plugins = options.plugins || [];
+  plugins.push(
+    new CacheableResponsePlugin({
+      statuses: [0, 200],
+    })
+  );
+  plugins.push(
+    new ExpirationPlugin({
+      maxEntries,
+      maxAgeSeconds,
+    })
+  );
+
+  const strategy = new CacheFirst({
+    cacheName,
+    plugins,
+  });
+
+  registerRoute(matchCallback, strategy);
+
+  // Warms the cache
+  if (options.warmCache) {
+    warmStrategyCache({ urls: options.warmCache, strategy });
+  }
+}
+
+export { imageCache };

package/src/index.ts

@@ -0,0 +1,23 @@
+/*
+  Copyright 2020 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+import type { GoogleFontCacheOptions } from "./googleFontsCache.js";
+import { googleFontsCache } from "./googleFontsCache.js";
+import type { ImageCacheOptions } from "./imageCache.js";
+import { imageCache } from "./imageCache.js";
+import type { OfflineFallbackOptions } from "./offlineFallback.js";
+import { offlineFallback } from "./offlineFallback.js";
+import type { PageCacheOptions } from "./pageCache.js";
+import { pageCache } from "./pageCache.js";
+import type { StaticResourceOptions } from "./staticResourceCache.js";
+import { staticResourceCache } from "./staticResourceCache.js";
+import type { WarmStrategyCacheOptions } from "./warmStrategyCache.js";
+import { warmStrategyCache } from "./warmStrategyCache.js";
+
+export { googleFontsCache, imageCache, offlineFallback, pageCache, staticResourceCache, warmStrategyCache };
+export type { GoogleFontCacheOptions, ImageCacheOptions, OfflineFallbackOptions, PageCacheOptions, StaticResourceOptions, WarmStrategyCacheOptions };

package/src/offlineFallback.ts

@@ -0,0 +1,79 @@
+/*
+  Copyright 2020 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+import type { RouteHandler, RouteHandlerCallbackOptions } from "@serwist/core";
+import { matchPrecache } from "@serwist/precaching";
+import { setCatchHandler } from "@serwist/routing";
+
+export interface OfflineFallbackOptions {
+  /**
+   * Precache name to match for page fallbacks. Defaults to offline.html.
+   */
+  pageFallback?: string;
+  /**
+   * Precache name to match for image fallbacks.
+   */
+  imageFallback?: string;
+  /**
+   * Precache name to match for font fallbacks.
+   */
+  fontFallback?: string;
+}
+
+// Give TypeScript the correct global.
+declare let self: ServiceWorkerGlobalScope;
+
+/**
+ * An implementation of the [comprehensive fallbacks recipe](https://developers.google.com/web/tools/workbox/guides/advanced-recipes#comprehensive_fallbacks). 
+ * Be sure to include the fallbacks in your precache injection.
+
+ * @param options
+ */
+function offlineFallback(options: OfflineFallbackOptions = {}): void {
+  const pageFallback = options.pageFallback || "offline.html";
+  const imageFallback = options.imageFallback || false;
+  const fontFallback = options.fontFallback || false;
+
+  self.addEventListener("install", (event) => {
+    const files = [pageFallback];
+    if (imageFallback) {
+      files.push(imageFallback);
+    }
+    if (fontFallback) {
+      files.push(fontFallback);
+    }
+
+    event.waitUntil(self.caches.open("serwist-offline-fallbacks").then((cache) => cache.addAll(files)));
+  });
+
+  const handler: RouteHandler = async (options: RouteHandlerCallbackOptions) => {
+    const dest = options.request.destination;
+    const cache = await self.caches.open("serwist-offline-fallbacks");
+
+    if (dest === "document") {
+      const match = (await matchPrecache(pageFallback)) || (await cache.match(pageFallback));
+      return match || Response.error();
+    }
+
+    if (dest === "image" && imageFallback !== false) {
+      const match = (await matchPrecache(imageFallback)) || (await cache.match(imageFallback));
+      return match || Response.error();
+    }
+
+    if (dest === "font" && fontFallback !== false) {
+      const match = (await matchPrecache(fontFallback)) || (await cache.match(fontFallback));
+      return match || Response.error();
+    }
+
+    return Response.error();
+  };
+
+  setCatchHandler(handler);
+}
+
+export { offlineFallback };

package/src/pageCache.ts

@@ -0,0 +1,74 @@
+/*
+  Copyright 2020 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+import { CacheableResponsePlugin } from "@serwist/cacheable-response";
+import type { RouteMatchCallback, RouteMatchCallbackOptions, SerwistPlugin } from "@serwist/core";
+import { registerRoute } from "@serwist/routing";
+import { NetworkFirst } from "@serwist/strategies";
+
+import { warmStrategyCache } from "./warmStrategyCache.js";
+
+export interface PageCacheOptions {
+  /**
+   * Name for cache. Defaults to pages.
+   */
+  cacheName?: string;
+  /**
+   * Serwist callback function to call to match to. Defaults to request.mode === 'navigate'.
+   */
+  matchCallback?: RouteMatchCallback;
+  /**
+   * Maximum amount of time, in seconds, to wait on the network before falling back to cache.
+   *
+   * @default 3
+   */
+  networkTimeoutSeconds?: number;
+  /**
+   * Additional plugins to use for this recipe.
+   */
+  plugins?: SerwistPlugin[];
+  /**
+   * Paths to call to use to warm this cache
+   */
+  warmCache?: string[];
+}
+
+/**
+ * An implementation of a page caching recipe with a network timeout.
+ *
+ * @param options
+ */
+function pageCache(options: PageCacheOptions = {}): void {
+  const defaultMatchCallback = ({ request }: RouteMatchCallbackOptions) => request.mode === "navigate";
+
+  const cacheName = options.cacheName || "pages";
+  const matchCallback = options.matchCallback || defaultMatchCallback;
+  const networkTimeoutSeconds = options.networkTimeoutSeconds || 3;
+  const plugins = options.plugins || [];
+  plugins.push(
+    new CacheableResponsePlugin({
+      statuses: [0, 200],
+    })
+  );
+
+  const strategy = new NetworkFirst({
+    networkTimeoutSeconds,
+    cacheName,
+    plugins,
+  });
+
+  // Registers the route
+  registerRoute(matchCallback, strategy);
+
+  // Warms the cache
+  if (options.warmCache) {
+    warmStrategyCache({ urls: options.warmCache, strategy });
+  }
+}
+
+export { pageCache };

package/src/staticResourceCache.ts

@@ -0,0 +1,70 @@
+/*
+  Copyright 2020 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+import { CacheableResponsePlugin } from "@serwist/cacheable-response";
+import type { RouteMatchCallback, RouteMatchCallbackOptions, SerwistPlugin } from "@serwist/core";
+import { registerRoute } from "@serwist/routing";
+import { StaleWhileRevalidate } from "@serwist/strategies";
+
+import { warmStrategyCache } from "./warmStrategyCache.js";
+
+export interface StaticResourceOptions {
+  /**
+   * Name for cache.
+   *
+   * @default "static-resources"
+   */
+  cacheName?: string;
+  /**
+   * Serwist callback function to call to match to.
+   *
+   * @default request.destination === 'style' || request.destination === 'script' || request.destination === 'worker'
+   */
+  matchCallback?: RouteMatchCallback;
+  /**
+   * Additional plugins to use for this recipe.
+   */
+  plugins?: SerwistPlugin[];
+  /**
+   * Paths to call to use to warm this cache.
+   */
+  warmCache?: string[];
+}
+
+/**
+ * An implementation of the [CSS and JavaScript files recipe](https://developers.google.com/web/tools/workbox/guides/common-recipes#cache_css_and_javascript_files).
+ *
+ * @param options
+ */
+function staticResourceCache(options: StaticResourceOptions = {}): void {
+  const defaultMatchCallback = ({ request }: RouteMatchCallbackOptions) =>
+    request.destination === "style" || request.destination === "script" || request.destination === "worker";
+
+  const cacheName = options.cacheName || "static-resources";
+  const matchCallback = options.matchCallback || defaultMatchCallback;
+  const plugins = options.plugins || [];
+  plugins.push(
+    new CacheableResponsePlugin({
+      statuses: [0, 200],
+    })
+  );
+
+  const strategy = new StaleWhileRevalidate({
+    cacheName,
+    plugins,
+  });
+
+  registerRoute(matchCallback, strategy);
+
+  // Warms the cache
+  if (options.warmCache) {
+    warmStrategyCache({ urls: options.warmCache, strategy });
+  }
+}
+
+export { staticResourceCache };

package/src/warmStrategyCache.ts

@@ -0,0 +1,34 @@
+import type { Strategy } from "@serwist/strategies";
+
+export interface WarmStrategyCacheOptions {
+  /**
+   * Paths to warm the strategy's cache with.
+   */
+  urls: string[];
+  /**
+   * Strategy to use.
+   */
+  strategy: Strategy;
+}
+
+// Give TypeScript the correct global.
+declare let self: ServiceWorkerGlobalScope;
+
+/**
+ * @param options
+ */
+function warmStrategyCache(options: WarmStrategyCacheOptions): void {
+  self.addEventListener("install", (event) => {
+    const done = options.urls.map(
+      (path) =>
+        options.strategy.handleAll({
+          event,
+          request: new Request(path),
+        })[1]
+    );
+
+    event.waitUntil(Promise.all(done));
+  });
+}
+
+export { warmStrategyCache };

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "module": "NodeNext"
+  },
+  "include": ["**/*.ts", "rollup.config.js"],
+  "exclude": ["dist", "node_modules"]
+}