@serwist/precaching 9.0.0-preview.2 → 9.0.0-preview.21

package/src/PrecacheStrategy.ts

@@ -1,239 +0,0 @@
-/*
-  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 { SerwistPlugin } from "@serwist/core";
-import { copyResponse } from "@serwist/core";
-import { SerwistError, getFriendlyURL, logger, privateCacheNames } from "@serwist/core/internal";
-import type { StrategyHandler, StrategyOptions } from "@serwist/strategies";
-import { Strategy } from "@serwist/strategies";
-
-interface PrecacheStrategyOptions extends StrategyOptions {
-  /**
-   * Whether to attempt to get the response from the network
-   * if there's a precache miss.
-   */
-  fallbackToNetwork?: boolean;
-}
-
-/**
- * A `@serwist/strategies.Strategy` implementation
- * specifically designed to work with
- * `@serwist/precaching.PrecacheController`
- * to both cache and fetch precached assets.
- *
- * Note: an instance of this class is created automatically when creating a
- * `PrecacheController`; it's generally not necessary to create this yourself.
- */
-class PrecacheStrategy extends Strategy {
-  private readonly _fallbackToNetwork: boolean;
-
-  static readonly defaultPrecacheCacheabilityPlugin: SerwistPlugin = {
-    async cacheWillUpdate({ response }) {
-      if (!response || response.status >= 400) {
-        return null;
-      }
-
-      return response;
-    },
-  };
-
-  static readonly copyRedirectedCacheableResponsesPlugin: SerwistPlugin = {
-    async cacheWillUpdate({ response }) {
-      return response.redirected ? await copyResponse(response) : response;
-    },
-  };
-
-  /**
-   * @param options
-   */
-  constructor(options: PrecacheStrategyOptions = {}) {
-    options.cacheName = privateCacheNames.getPrecacheName(options.cacheName);
-    super(options);
-
-    this._fallbackToNetwork = options.fallbackToNetwork === false ? false : true;
-
-    // Redirected responses cannot be used to satisfy a navigation request, so
-    // any redirected response must be "copied" rather than cloned, so the new
-    // response doesn't contain the `redirected` flag. See:
-    // https://bugs.chromium.org/p/chromium/issues/detail?id=669363&desc=2#c1
-    this.plugins.push(PrecacheStrategy.copyRedirectedCacheableResponsesPlugin);
-  }
-
-  /**
-   * @private
-   * @param request A request to run this strategy for.
-   * @param handler The event that triggered the request.
-   * @returns
-   */
-  async _handle(request: Request, handler: StrategyHandler): Promise<Response> {
-    const response = await handler.cacheMatch(request);
-    if (response) {
-      return response;
-    }
-
-    // If this is an `install` event for an entry that isn't already cached,
-    // then populate the cache.
-    if (handler.event && handler.event.type === "install") {
-      return await this._handleInstall(request, handler);
-    }
-
-    // Getting here means something went wrong. An entry that should have been
-    // precached wasn't found in the cache.
-    return await this._handleFetch(request, handler);
-  }
-
-  async _handleFetch(request: Request, handler: StrategyHandler): Promise<Response> {
-    let response: Response | undefined = undefined;
-    const params = (handler.params || {}) as {
-      cacheKey?: string;
-      integrity?: string;
-    };
-
-    // Fallback to the network if we're configured to do so.
-    if (this._fallbackToNetwork) {
-      if (process.env.NODE_ENV !== "production") {
-        logger.warn(`The precached response for ${getFriendlyURL(request.url)} in ${this.cacheName} was not found. Falling back to the network.`);
-      }
-
-      const integrityInManifest = params.integrity;
-      const integrityInRequest = request.integrity;
-      const noIntegrityConflict = !integrityInRequest || integrityInRequest === integrityInManifest;
-
-      // Do not add integrity if the original request is no-cors
-      // See https://github.com/GoogleChrome/workbox/issues/3096
-      response = await handler.fetch(
-        new Request(request, {
-          integrity: request.mode !== "no-cors" ? integrityInRequest || integrityInManifest : undefined,
-        }),
-      );
-
-      // It's only "safe" to repair the cache if we're using SRI to guarantee
-      // that the response matches the precache manifest's expectations,
-      // and there's either a) no integrity property in the incoming request
-      // or b) there is an integrity, and it matches the precache manifest.
-      // See https://github.com/GoogleChrome/workbox/issues/2858
-      // Also if the original request users no-cors we don't use integrity.
-      // See https://github.com/GoogleChrome/workbox/issues/3096
-      if (integrityInManifest && noIntegrityConflict && request.mode !== "no-cors") {
-        this._useDefaultCacheabilityPluginIfNeeded();
-        const wasCached = await handler.cachePut(request, response.clone());
-        if (process.env.NODE_ENV !== "production") {
-          if (wasCached) {
-            logger.log(`A response for ${getFriendlyURL(request.url)} was used to "repair" the precache.`);
-          }
-        }
-      }
-    } else {
-      // This shouldn't normally happen, but there are edge cases:
-      // https://github.com/GoogleChrome/workbox/issues/1441
-      throw new SerwistError("missing-precache-entry", {
-        cacheName: this.cacheName,
-        url: request.url,
-      });
-    }
-
-    if (process.env.NODE_ENV !== "production") {
-      const cacheKey = params.cacheKey || (await handler.getCacheKey(request, "read"));
-
-      // Serwist is going to handle the route.
-      // print the routing details to the console.
-      logger.groupCollapsed(`Precaching is responding to: ${getFriendlyURL(request.url)}`);
-      logger.log(`Serving the precached url: ${getFriendlyURL(cacheKey instanceof Request ? cacheKey.url : cacheKey)}`);
-
-      logger.groupCollapsed("View request details here.");
-      logger.log(request);
-      logger.groupEnd();
-
-      logger.groupCollapsed("View response details here.");
-      logger.log(response);
-      logger.groupEnd();
-
-      logger.groupEnd();
-    }
-
-    return response;
-  }
-
-  async _handleInstall(request: Request, handler: StrategyHandler): Promise<Response> {
-    this._useDefaultCacheabilityPluginIfNeeded();
-
-    const response = await handler.fetch(request);
-
-    // Make sure we defer cachePut() until after we know the response
-    // should be cached; see https://github.com/GoogleChrome/workbox/issues/2737
-    const wasCached = await handler.cachePut(request, response.clone());
-    if (!wasCached) {
-      // Throwing here will lead to the `install` handler failing, which
-      // we want to do if *any* of the responses aren't safe to cache.
-      throw new SerwistError("bad-precaching-response", {
-        url: request.url,
-        status: response.status,
-      });
-    }
-
-    return response;
-  }
-
-  /**
-   * This method is complex, as there a number of things to account for:
-   *
-   * The `plugins` array can be set at construction, and/or it might be added to
-   * to at any time before the strategy is used.
-   *
-   * At the time the strategy is used (i.e. during an `install` event), there
-   * needs to be at least one plugin that implements `cacheWillUpdate` in the
-   * array, other than `copyRedirectedCacheableResponsesPlugin`.
-   *
-   * - If this method is called and there are no suitable `cacheWillUpdate`
-   * plugins, we need to add `defaultPrecacheCacheabilityPlugin`.
-   *
-   * - If this method is called and there is exactly one `cacheWillUpdate`, then
-   * we don't have to do anything (this might be a previously added
-   * `defaultPrecacheCacheabilityPlugin`, or it might be a custom plugin).
-   *
-   * - If this method is called and there is more than one `cacheWillUpdate`,
-   * then we need to check if one is `defaultPrecacheCacheabilityPlugin`. If so,
-   * we need to remove it. (This situation is unlikely, but it could happen if
-   * the strategy is used multiple times, the first without a `cacheWillUpdate`,
-   * and then later on after manually adding a custom `cacheWillUpdate`.)
-   *
-   * See https://github.com/GoogleChrome/workbox/issues/2737 for more context.
-   *
-   * @private
-   */
-  _useDefaultCacheabilityPluginIfNeeded(): void {
-    let defaultPluginIndex: number | null = null;
-    let cacheWillUpdatePluginCount = 0;
-
-    for (const [index, plugin] of this.plugins.entries()) {
-      // Ignore the copy redirected plugin when determining what to do.
-      if (plugin === PrecacheStrategy.copyRedirectedCacheableResponsesPlugin) {
-        continue;
-      }
-
-      // Save the default plugin's index, in case it needs to be removed.
-      if (plugin === PrecacheStrategy.defaultPrecacheCacheabilityPlugin) {
-        defaultPluginIndex = index;
-      }
-
-      if (plugin.cacheWillUpdate) {
-        cacheWillUpdatePluginCount++;
-      }
-    }
-
-    if (cacheWillUpdatePluginCount === 0) {
-      this.plugins.push(PrecacheStrategy.defaultPrecacheCacheabilityPlugin);
-    } else if (cacheWillUpdatePluginCount > 1 && defaultPluginIndex !== null) {
-      // Only remove the default plugin; multiple custom plugins are allowed.
-      this.plugins.splice(defaultPluginIndex, 1);
-    }
-    // Nothing needs to be done if cacheWillUpdatePluginCount is 1
-  }
-}
-
-export { PrecacheStrategy };

package/src/_types.ts

@@ -1,46 +0,0 @@
-/*
-  Copyright 2018 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.
-*/
-
-export interface InstallResult {
-  updatedURLs: string[];
-  notUpdatedURLs: string[];
-}
-
-export interface CleanupResult {
-  deletedCacheRequests: string[];
-}
-
-export declare interface PrecacheEntry {
-  integrity?: string;
-  url: string;
-  revision?: string | null;
-}
-
-export interface PrecacheRouteOptions {
-  /**
-   * The `directoryIndex` will check cache entries for a URL ending with '/'
-   * to see if there is a hit when appending the `directoryIndex` value.
-   */
-  directoryIndex?: string | null;
-  /**
-   * An array of RegExp's to remove search params when looking for a cache match.
-   */
-  ignoreURLParametersMatching?: RegExp[];
-  /**
-   * The `cleanURLs` option will check the cache for the URL with a `.html` added
-   * to the end of the end.
-   */
-  cleanURLs?: boolean;
-  /**
-   * This is a function that should take a URL and return an array of
-   * alternative URLs that should be checked for precache matches.
-   */
-  urlManipulation?: urlManipulation;
-}
-
-export type urlManipulation = ({ url }: { url: URL }) => URL[];

package/src/addPlugins.ts

@@ -1,23 +0,0 @@
-/*
-  Copyright 2019 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 { SerwistPlugin } from "@serwist/core";
-
-import { getOrCreatePrecacheController } from "./utils/getOrCreatePrecacheController.js";
-
-/**
- * Adds plugins to the precaching strategy.
- *
- * @param plugins
- */
-function addPlugins(plugins: SerwistPlugin[]): void {
-  const precacheController = getOrCreatePrecacheController();
-  precacheController.strategy.plugins.push(...plugins);
-}
-
-export { addPlugins };

package/src/addRoute.ts

@@ -1,33 +0,0 @@
-/*
-  Copyright 2019 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 { registerRoute } from "@serwist/routing";
-
-import { PrecacheRoute } from "./PrecacheRoute.js";
-import type { PrecacheRouteOptions } from "./_types.js";
-import { getOrCreatePrecacheController } from "./utils/getOrCreatePrecacheController.js";
-
-/**
- * Add a `fetch` listener to the service worker that will
- * respond to
- * [network requests](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API/Using_Service_Workers#Custom_responses_to_requests)
- * with precached assets.
- *
- * Requests for assets that aren't precached, the `FetchEvent` will not be
- * responded to, allowing the event to fall through to other `fetch` event
- * listeners.
- *
- * @param options See the `@serwist/precaching.PrecacheRoute` options.
- */
-function addRoute(options?: PrecacheRouteOptions): void {
-  const precacheController = getOrCreatePrecacheController();
-
-  const precacheRoute = new PrecacheRoute(precacheController, options);
-  registerRoute(precacheRoute);
-}
-
-export { addRoute };

package/src/cleanupOutdatedCaches.ts

@@ -1,34 +0,0 @@
-/*
-  Copyright 2019 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 { logger, privateCacheNames } from "@serwist/core/internal";
-
-import { deleteOutdatedCaches } from "./utils/deleteOutdatedCaches.js";
-
-/**
- * Adds an `activate` event listener which will clean up incompatible
- * precaches that were created by older versions of Serwist.
- */
-function cleanupOutdatedCaches(): void {
-  // See https://github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705
-  self.addEventListener("activate", ((event: ExtendableEvent) => {
-    const cacheName = privateCacheNames.getPrecacheName();
-
-    event.waitUntil(
-      deleteOutdatedCaches(cacheName).then((cachesDeleted) => {
-        if (process.env.NODE_ENV !== "production") {
-          if (cachesDeleted.length > 0) {
-            logger.log("The following out-of-date precaches were cleaned up " + "automatically:", cachesDeleted);
-          }
-        }
-      }),
-    );
-  }) as EventListener);
-}
-
-export { cleanupOutdatedCaches };

package/src/createHandlerBoundToURL.ts

@@ -1,32 +0,0 @@
-/*
-  Copyright 2019 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 { RouteHandlerCallback } from "@serwist/core";
-
-import { getOrCreatePrecacheController } from "./utils/getOrCreatePrecacheController.js";
-
-/**
- * Helper function that calls `PrecacheController#createHandlerBoundToURL`
- * on the default `PrecacheController` instance.
- *
- * If you are creating your own `PrecacheController`, then call the
- * `PrecacheController#createHandlerBoundToURL` on that instance,
- * instead of using this function.
- *
- * @param url The precached URL which will be used to lookup the
- * `Response`.
- * @param fallbackToNetwork Whether to attempt to get the
- * response from the network if there's a precache miss.
- * @return
- */
-function createHandlerBoundToURL(url: string): RouteHandlerCallback {
-  const precacheController = getOrCreatePrecacheController();
-  return precacheController.createHandlerBoundToURL(url);
-}
-
-export { createHandlerBoundToURL };

package/src/getCacheKeyForURL.ts

@@ -1,33 +0,0 @@
-/*
-  Copyright 2019 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 { getOrCreatePrecacheController } from "./utils/getOrCreatePrecacheController.js";
-
-/**
- * Takes in a URL, and returns the corresponding URL that could be used to
- * lookup the entry in the precache.
- *
- * If a relative URL is provided, the location of the service worker file will
- * be used as the base.
- *
- * For precached entries without revision information, the cache key will be the
- * same as the original URL.
- *
- * For precached entries with revision information, the cache key will be the
- * original URL with the addition of a query parameter used for keeping track of
- * the revision info.
- *
- * @param url The URL whose cache key to look up.
- * @returns The cache key that corresponds to that URL.
- */
-function getCacheKeyForURL(url: string): string | undefined {
-  const precacheController = getOrCreatePrecacheController();
-  return precacheController.getCacheKeyForURL(url);
-}
-
-export { getCacheKeyForURL };

package/src/matchPrecache.ts

@@ -1,28 +0,0 @@
-/*
-  Copyright 2019 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 { getOrCreatePrecacheController } from "./utils/getOrCreatePrecacheController.js";
-
-/**
- * Helper function that calls `PrecacheController#matchPrecache`
- * on the default `PrecacheController` instance.
- *
- * If you are creating your own `PrecacheController`, then call
- * `PrecacheController#matchPrecache` on that instance,
- * instead of using this function.
- *
- * @param request The key (without revisioning parameters)
- * to look up in the precache.
- * @returns
- */
-function matchPrecache(request: string | Request): Promise<Response | undefined> {
-  const precacheController = getOrCreatePrecacheController();
-  return precacheController.matchPrecache(request);
-}
-
-export { matchPrecache };

package/src/precache.ts

@@ -1,33 +0,0 @@
-/*
-  Copyright 2019 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 { PrecacheEntry } from "./_types.js";
-import { getOrCreatePrecacheController } from "./utils/getOrCreatePrecacheController.js";
-
-/**
- * Adds items to the precache list, removing any duplicates and
- * stores the files in the precache cache when the service
- * worker installs.
- *
- * This method can be called multiple times.
- *
- * Please note: This method **will not** serve any of the cached files for you.
- * It only precaches files. To respond to a network request you call
- * `@serwist/precaching.addRoute`.
- *
- * If you have a single array of files to precache, you can just call
- * `@serwist/precaching.precacheAndRoute`.
- *
- * @param entries Array of entries to precache.
- */
-function precache(entries: (PrecacheEntry | string)[]): void {
-  const precacheController = getOrCreatePrecacheController();
-  precacheController.precache(entries);
-}
-
-export { precache };

package/src/precacheAndRoute.ts

@@ -1,29 +0,0 @@
-/*
-  Copyright 2019 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 { PrecacheEntry, PrecacheRouteOptions } from "./_types.js";
-import { addRoute } from "./addRoute.js";
-import { precache } from "./precache.js";
-
-/**
- * This method will add entries to the precache list and add a route to
- * respond to fetch events.
- *
- * This is a convenience method that will call
- * `@serwist/precaching.precache` and
- * `@serwist/precaching.addRoute` in a single call.
- *
- * @param entries Array of entries to precache.
- * @param options See the `@serwist/precaching.PrecacheRoute` options.
- */
-function precacheAndRoute(entries: (PrecacheEntry | string)[], options?: PrecacheRouteOptions): void {
-  precache(entries);
-  addRoute(options);
-}
-
-export { precacheAndRoute };

package/src/utils/PrecacheCacheKeyPlugin.ts

@@ -1,36 +0,0 @@
-/*
-  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 { SerwistPlugin, SerwistPluginCallbackParam } from "@serwist/core";
-
-import type { PrecacheController } from "../PrecacheController.js";
-
-/**
- * A plugin, designed to be used with PrecacheController, to translate URLs into
- * the corresponding cache key, based on the current revision info.
- *
- * @private
- */
-class PrecacheCacheKeyPlugin implements SerwistPlugin {
-  private readonly _precacheController: PrecacheController;
-
-  constructor({ precacheController }: { precacheController: PrecacheController }) {
-    this._precacheController = precacheController;
-  }
-
-  cacheKeyWillBeUsed: SerwistPlugin["cacheKeyWillBeUsed"] = async ({ request, params }: SerwistPluginCallbackParam["cacheKeyWillBeUsed"]) => {
-    // Params is type any, can't change right now.
-    /* eslint-disable */
-    const cacheKey = params?.cacheKey || this._precacheController.getCacheKeyForURL(request.url);
-    /* eslint-enable */
-
-    return cacheKey ? new Request(cacheKey, { headers: request.headers }) : request;
-  };
-}
-
-export { PrecacheCacheKeyPlugin };

package/src/utils/PrecacheInstallReportPlugin.ts

@@ -1,49 +0,0 @@
-/*
-  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 { SerwistPlugin, SerwistPluginCallbackParam } from "@serwist/core";
-
-/**
- * A plugin, designed to be used with PrecacheController, to determine the
- * of assets that were updated (or not updated) during the install event.
- *
- * @private
- */
-class PrecacheInstallReportPlugin implements SerwistPlugin {
-  updatedURLs: string[] = [];
-  notUpdatedURLs: string[] = [];
-
-  handlerWillStart: SerwistPlugin["handlerWillStart"] = async ({ request, state }: SerwistPluginCallbackParam["handlerWillStart"]) => {
-    // TODO: `state` should never be undefined...
-    if (state) {
-      state.originalRequest = request;
-    }
-  };
-
-  cachedResponseWillBeUsed: SerwistPlugin["cachedResponseWillBeUsed"] = async ({
-    event,
-    state,
-    cachedResponse,
-  }: SerwistPluginCallbackParam["cachedResponseWillBeUsed"]) => {
-    if (event.type === "install") {
-      if (state?.originalRequest && state.originalRequest instanceof Request) {
-        // TODO: `state` should never be undefined...
-        const url = state.originalRequest.url;
-
-        if (cachedResponse) {
-          this.notUpdatedURLs.push(url);
-        } else {
-          this.updatedURLs.push(url);
-        }
-      }
-    }
-    return cachedResponse;
-  };
-}
-
-export { PrecacheInstallReportPlugin };