@serwist/recipes 8.4.4 → 9.0.0-preview.1

package/dist/googleFontsCache.d.ts

@@ -19,3 +19,4 @@ export interface GoogleFontCacheOptions {
  */
 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

@@ -32,3 +32,4 @@ export interface ImageCacheOptions {
  */
 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

@@ -12,3 +12,4 @@ 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

@@ -4,20 +4,14 @@ 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 = {}) {
+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: [
@@ -35,9 +29,7 @@ import { matchPrecache } from '@serwist/precaching';
     }));
 }
 
-/**
- * @param options
- */ function warmStrategyCache(options) {
+function warmStrategyCache(options) {
     self.addEventListener("install", (event)=>{
         const done = options.urls.map((path)=>options.strategy.handleAll({
                 event,
@@ -47,11 +39,7 @@ import { matchPrecache } from '@serwist/precaching';
     });
 }
 
-/**
- * An implementation of the [image caching recipe](https://developers.google.com/web/tools/workbox/guides/common-recipes#caching_images).
- *
- * @param options
- */ function imageCache(options = {}) {
+function imageCache(options = {}) {
     const defaultMatchCallback = ({ request })=>request.destination === "image";
     const cacheName = options.cacheName || "images";
     const matchCallback = options.matchCallback || defaultMatchCallback;
@@ -73,7 +61,6 @@ import { matchPrecache } from '@serwist/precaching';
         plugins
     });
     registerRoute(matchCallback, strategy);
-    // Warms the cache
     if (options.warmCache) {
         warmStrategyCache({
             urls: options.warmCache,
@@ -82,12 +69,7 @@ import { matchPrecache } from '@serwist/precaching';
     }
 }
 
-/**
- * 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 = {}) {
+function offlineFallback(options = {}) {
     const pageFallback = options.pageFallback || "offline.html";
     const imageFallback = options.imageFallback || false;
     const fontFallback = options.fontFallback || false;
@@ -123,11 +105,7 @@ import { matchPrecache } from '@serwist/precaching';
     setCatchHandler(handler);
 }
 
-/**
- * An implementation of a page caching recipe with a network timeout.
- *
- * @param options
- */ function pageCache(options = {}) {
+function pageCache(options = {}) {
     const defaultMatchCallback = ({ request })=>request.mode === "navigate";
     const cacheName = options.cacheName || "pages";
     const matchCallback = options.matchCallback || defaultMatchCallback;
@@ -144,9 +122,7 @@ import { matchPrecache } from '@serwist/precaching';
         cacheName,
         plugins
     });
-    // Registers the route
     registerRoute(matchCallback, strategy);
-    // Warms the cache
     if (options.warmCache) {
         warmStrategyCache({
             urls: options.warmCache,
@@ -155,11 +131,7 @@ import { matchPrecache } from '@serwist/precaching';
     }
 }
 
-/**
- * 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 = {}) {
+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;
@@ -175,7 +147,6 @@ import { matchPrecache } from '@serwist/precaching';
         plugins
     });
     registerRoute(matchCallback, strategy);
-    // Warms the cache
     if (options.warmCache) {
         warmStrategyCache({
             urls: options.warmCache,

package/dist/offlineFallback.d.ts

@@ -20,3 +20,4 @@ export interface OfflineFallbackOptions {
  */
 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

@@ -30,3 +30,4 @@ export interface PageCacheOptions {
  */
 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

@@ -28,3 +28,4 @@ export interface StaticResourceOptions {
  */
 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

@@ -14,3 +14,4 @@ export interface WarmStrategyCacheOptions {
  */
 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

@@ -1,11 +1,11 @@
 {
   "name": "@serwist/recipes",
-  "version": "8.4.4",
+  "version": "9.0.0-preview.1",
   "type": "module",
   "description": "A service worker helper library to manage common request and caching patterns",
   "files": [
-    "dist",
-    "!dist/**/dts"
+    "src",
+    "dist"
   ],
   "keywords": [
     "serwist",
@@ -20,33 +20,35 @@
   "repository": "serwist/serwist",
   "bugs": "https://github.com/serwist/serwist/issues",
   "homepage": "https://serwist.pages.dev",
-  "module": "./dist/index.js",
-  "main": "./dist/index.cjs",
+  "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      },
-      "require": {
-        "types": "./dist/index.d.cts",
-        "default": "./dist/index.cjs"
-      }
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     },
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@serwist/cacheable-response": "8.4.4",
-    "@serwist/core": "8.4.4",
-    "@serwist/expiration": "8.4.4",
-    "@serwist/precaching": "8.4.4",
-    "@serwist/routing": "8.4.4",
-    "@serwist/strategies": "8.4.4"
+    "@serwist/cacheable-response": "9.0.0-preview.1",
+    "@serwist/core": "9.0.0-preview.1",
+    "@serwist/expiration": "9.0.0-preview.1",
+    "@serwist/precaching": "9.0.0-preview.1",
+    "@serwist/routing": "9.0.0-preview.1",
+    "@serwist/strategies": "9.0.0-preview.1"
   },
   "devDependencies": {
-    "rollup": "4.9.1",
-    "@serwist/constants": "8.4.4"
+    "rollup": "4.9.6",
+    "typescript": "5.4.0-dev.20240203",
+    "@serwist/constants": "9.0.0-preview.1"
+  },
+  "peerDependencies": {
+    "typescript": ">=5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
   },
   "scripts": {
     "build": "rimraf dist && cross-env NODE_ENV=production rollup --config rollup.config.js",

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/{dist/index.d.cts → src/index.ts}

@@ -1,3 +1,11 @@
+/*
+  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";
@@ -10,5 +18,6 @@ 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/dist/index.cjs

@@ -1,194 +0,0 @@
-'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;