serwist 9.1.0-preview.0 → 10.0.0-preview.2

package/src/legacy/getCacheKeyForURL.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 { getSingletonPrecacheController } from "./singletonPrecacheController.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.
- * @deprecated
- */
-export const getCacheKeyForURL = (url: string): string | undefined => {
-  const precacheController = getSingletonPrecacheController();
-  return precacheController.getCacheKeyForURL(url);
-};

package/src/legacy/handlePrecaching.ts

@@ -1,86 +0,0 @@
-import { NavigationRoute } from "../NavigationRoute.js";
-import type { PrecacheEntry, PrecacheRouteOptions } from "../types.js";
-import { cleanupOutdatedCaches as cleanupOutdatedCachesImpl } from "../utils/cleanupOutdatedCaches.js";
-import type { PrecacheController } from "./PrecacheController.js";
-import { PrecacheRoute } from "./PrecacheRoute.js";
-import type { Router } from "./Router.js";
-import { createHandlerBoundToURL } from "./createHandlerBoundToURL.js";
-import { getSingletonPrecacheController } from "./singletonPrecacheController.js";
-import { getSingletonRouter } from "./singletonRouter.js";
-
-/**
- * @deprecated
- */
-export interface HandlePrecachingOptions {
-  /**
-   * An optional {@linkcode PrecacheController} instance. If not provided, the singleton
-   * {@linkcode PrecacheController} will be used.
-   */
-  precacheController?: PrecacheController;
-  /**
-   * An optional {@linkcode Router} instance. If not provided, the singleton {@linkcode Router}
-   * will be used.
-   */
-  router?: Router;
-  /**
-   * A list of URLs that should be cached.
-   */
-  precacheEntries?: (PrecacheEntry | string)[];
-  /**
-   * Options to customize how Serwist precaches the URLs.
-   */
-  precacheOptions?: PrecacheRouteOptions;
-  /**
-   * Whether outdated caches should be removed.
-   *
-   * @default false
-   */
-  cleanupOutdatedCaches?: boolean;
-  /**
-   * An URL that should point to a HTML file with which navigation requests for URLs that aren't
-   * precached will be fulfilled.
-   */
-  navigateFallback?: string;
-  /**
-   * URLs that should be allowed to use the `navigateFallback` handler.
-   */
-  navigateFallbackAllowlist?: RegExp[];
-  /**
-   * URLs that should not be allowed to use the `navigateFallback` handler. This takes precedence
-   * over `navigateFallbackAllowlist`.
-   */
-  navigateFallbackDenylist?: RegExp[];
-}
-
-/**
- * Handles a list of precache entries and cleans up outdated caches.
- *
- * @param options
- * @deprecated
- */
-export const handlePrecaching = ({
-  precacheController = getSingletonPrecacheController(),
-  router = getSingletonRouter(),
-  precacheEntries,
-  precacheOptions,
-  cleanupOutdatedCaches = false,
-  navigateFallback,
-  navigateFallbackAllowlist,
-  navigateFallbackDenylist,
-}: HandlePrecachingOptions): void => {
-  if (!!precacheEntries && precacheEntries.length > 0) {
-    precacheController.precache(precacheEntries);
-    router.registerRoute(new PrecacheRoute(precacheController, precacheOptions));
-
-    if (cleanupOutdatedCaches) cleanupOutdatedCachesImpl();
-
-    if (navigateFallback) {
-      router.registerRoute(
-        new NavigationRoute(createHandlerBoundToURL(navigateFallback), {
-          allowlist: navigateFallbackAllowlist,
-          denylist: navigateFallbackDenylist,
-        }),
-      );
-    }
-  }
-};

package/src/legacy/initializeGoogleAnalytics.ts

@@ -1,218 +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.
-*/
-
-import { Route } from "../Route.js";
-import { BackgroundSyncPlugin } from "../lib/backgroundSync/BackgroundSyncPlugin.js";
-import type { BackgroundSyncQueue, BackgroundSyncQueueEntry } from "../lib/backgroundSync/BackgroundSyncQueue.js";
-import { NetworkFirst } from "../lib/strategies/NetworkFirst.js";
-import { NetworkOnly } from "../lib/strategies/NetworkOnly.js";
-import type { RouteMatchCallbackOptions } from "../types.js";
-import { cacheNames as privateCacheNames } from "../utils/cacheNames.js";
-import { getFriendlyURL } from "../utils/getFriendlyURL.js";
-import { logger } from "../utils/logger.js";
-import { Router } from "./Router.js";
-import {
-  ANALYTICS_JS_PATH,
-  COLLECT_PATHS_REGEX,
-  GOOGLE_ANALYTICS_HOST,
-  GTAG_JS_PATH,
-  GTM_HOST,
-  GTM_JS_PATH,
-  MAX_RETENTION_TIME,
-  QUEUE_NAME,
-} from "./constants.js";
-import { getSingletonRouter } from "./singletonRouter.js";
-
-/**
- * @deprecated
- */
-export interface GoogleAnalyticsInitializeOptions {
-  /**
-   * An optional {@linkcode Router} instance. If not provided, the singleton {@linkcode Router}
-   * will be used.
-   */
-  router?: Router;
-  /**
-   * The cache name to store and retrieve analytics.js. Defaults to Serwist's default cache names.
-   */
-  cacheName?: string;
-  /**
-   * [Measurement Protocol parameters](https://developers.google.com/analytics/devguides/collection/protocol/v1/parameters),
-   * expressed as key/value pairs, to be added to replayed Google Analytics
-   * requests. This can be used to, e.g., set a custom dimension indicating
-   * that the request was replayed.
-   */
-  parameterOverrides?: { [paramName: string]: string };
-  /**
-   * A function that allows you to modify the hit parameters prior to replaying
-   * the hit. The function is invoked with the original hit's URLSearchParams
-   * object as its only argument.
-   */
-  hitFilter?: (params: URLSearchParams) => void;
-}
-
-/**
- * Creates the requestWillDequeue callback to be used with the background
- * sync plugin. The callback takes the failed request and adds the
- * `qt` param based on the current time, as well as applies any other
- * user-defined hit modifications.
- *
- * @param config
- * @returns The requestWillDequeue callback function.
- * @private
- */
-const createOnSyncCallback = (config: Pick<GoogleAnalyticsInitializeOptions, "parameterOverrides" | "hitFilter">) => {
-  return async ({ queue }: { queue: BackgroundSyncQueue }) => {
-    let entry: BackgroundSyncQueueEntry | undefined = undefined;
-    while ((entry = await queue.shiftRequest())) {
-      const { request, timestamp } = entry;
-      const url = new URL(request.url);
-
-      try {
-        // Measurement protocol requests can set their payload parameters in
-        // either the URL query string (for GET requests) or the POST body.
-        const params = request.method === "POST" ? new URLSearchParams(await request.clone().text()) : url.searchParams;
-
-        // Calculate the qt param, accounting for the fact that an existing
-        // qt param may be present and should be updated rather than replaced.
-        const originalHitTime = timestamp! - (Number(params.get("qt")) || 0);
-        const queueTime = Date.now() - originalHitTime;
-
-        // Set the qt param prior to applying hitFilter or parameterOverrides.
-        params.set("qt", String(queueTime));
-
-        // Apply `parameterOverrides`, if set.
-        if (config.parameterOverrides) {
-          for (const param of Object.keys(config.parameterOverrides)) {
-            const value = config.parameterOverrides[param];
-            params.set(param, value);
-          }
-        }
-
-        // Apply `hitFilter`, if set.
-        if (typeof config.hitFilter === "function") {
-          config.hitFilter.call(null, params);
-        }
-
-        // Retry the fetch. Ignore URL search params from the URL as they're
-        // now in the post body.
-        await fetch(
-          new Request(url.origin + url.pathname, {
-            body: params.toString(),
-            method: "POST",
-            mode: "cors",
-            credentials: "omit",
-            headers: { "Content-Type": "text/plain" },
-          }),
-        );
-
-        if (process.env.NODE_ENV !== "production") {
-          logger.log(`Request for '${getFriendlyURL(url.href)}' has been replayed`);
-        }
-      } catch (err) {
-        await queue.unshiftRequest(entry);
-
-        if (process.env.NODE_ENV !== "production") {
-          logger.log(`Request for '${getFriendlyURL(url.href)}' failed to replay, putting it back in the queue.`);
-        }
-        throw err;
-      }
-    }
-    if (process.env.NODE_ENV !== "production") {
-      logger.log("All Google Analytics request successfully replayed; " + "the queue is now empty!");
-    }
-  };
-};
-
-/**
- * Creates GET and POST routes to catch failed Measurement Protocol hits.
- *
- * @param bgSyncPlugin
- * @returns The created routes.
- * @private
- */
-const createCollectRoutes = (bgSyncPlugin: BackgroundSyncPlugin) => {
-  const match = ({ url }: RouteMatchCallbackOptions) => url.hostname === GOOGLE_ANALYTICS_HOST && COLLECT_PATHS_REGEX.test(url.pathname);
-
-  const handler = new NetworkOnly({
-    plugins: [bgSyncPlugin],
-  });
-
-  return [new Route(match, handler, "GET"), new Route(match, handler, "POST")];
-};
-
-/**
- * Creates a route with a network first strategy for the analytics.js script.
- *
- * @param cacheName
- * @returns The created route.
- * @private
- */
-const createAnalyticsJsRoute = (cacheName: string) => {
-  const match = ({ url }: RouteMatchCallbackOptions) => url.hostname === GOOGLE_ANALYTICS_HOST && url.pathname === ANALYTICS_JS_PATH;
-
-  const handler = new NetworkFirst({ cacheName });
-
-  return new Route(match, handler, "GET");
-};
-
-/**
- * Creates a route with a network first strategy for the gtag.js script.
- *
- * @param cacheName
- * @returns The created route.
- * @private
- */
-const createGtagJsRoute = (cacheName: string) => {
-  const match = ({ url }: RouteMatchCallbackOptions) => url.hostname === GTM_HOST && url.pathname === GTAG_JS_PATH;
-
-  const handler = new NetworkFirst({ cacheName });
-
-  return new Route(match, handler, "GET");
-};
-
-/**
- * Creates a route with a network first strategy for the gtm.js script.
- *
- * @param cacheName
- * @returns The created route.
- * @private
- */
-const createGtmJsRoute = (cacheName: string) => {
-  const match = ({ url }: RouteMatchCallbackOptions) => url.hostname === GTM_HOST && url.pathname === GTM_JS_PATH;
-
-  const handler = new NetworkFirst({ cacheName });
-
-  return new Route(match, handler, "GET");
-};
-
-/**
- * Initialize Serwist's offline Google Analytics v3 support.
- *
- * @param options
- * @deprecated Use `serwist.initializeGoogleAnalytics` instead.
- */
-export const initializeGoogleAnalytics = ({ router = getSingletonRouter(), cacheName, ...options }: GoogleAnalyticsInitializeOptions = {}): void => {
-  const resolvedCacheName = privateCacheNames.getGoogleAnalyticsName(cacheName);
-
-  const bgSyncPlugin = new BackgroundSyncPlugin(QUEUE_NAME, {
-    maxRetentionTime: MAX_RETENTION_TIME,
-    onSync: createOnSyncCallback(options),
-  });
-
-  const routes = [
-    createGtmJsRoute(resolvedCacheName),
-    createAnalyticsJsRoute(resolvedCacheName),
-    createGtagJsRoute(resolvedCacheName),
-    ...createCollectRoutes(bgSyncPlugin),
-  ];
-
-  for (const route of routes) {
-    router.registerRoute(route);
-  }
-};

package/src/legacy/installSerwist.ts

@@ -1,170 +0,0 @@
-import { disableDevLogs as disableDevLogsImpl } from "../disableDevLogs.js";
-import { enableNavigationPreload } from "../navigationPreload.js";
-import { setCacheNameDetails } from "../setCacheNameDetails.js";
-import type { RuntimeCaching } from "../types.js";
-import { clientsClaim as clientsClaimImpl } from "../utils/clientsClaim.js";
-import type { PrecacheController } from "./PrecacheController.js";
-import type { Router } from "./Router.js";
-import type { FallbacksOptions } from "./fallbacks.js";
-import { fallbacks as fallbacksImpl } from "./fallbacks.js";
-import { type HandlePrecachingOptions, handlePrecaching } from "./handlePrecaching.js";
-import { initializeGoogleAnalytics } from "./initializeGoogleAnalytics.js";
-import type { GoogleAnalyticsInitializeOptions } from "./initializeGoogleAnalytics.js";
-import { registerRuntimeCaching } from "./registerRuntimeCaching.js";
-import { getSingletonPrecacheController } from "./singletonPrecacheController.js";
-import { getSingletonRouter } from "./singletonRouter.js";
-
-declare const self: ServiceWorkerGlobalScope;
-
-/**
- * Options for {@linkcode installSerwist}.
- *
- * @deprecated
- */
-export interface InstallSerwistOptions extends Omit<HandlePrecachingOptions, "precacheController" | "router"> {
-  /**
-   * An optional {@linkcode PrecacheController} instance. If not provided, the singleton
-   * {@linkcode PrecacheController} will be used.
-   */
-  precacheController?: PrecacheController;
-  /**
-   * An optional {@linkcode Router} instance. If not provided, the singleton {@linkcode Router}
-   * will be used.
-   */
-  router?: Router;
-  /**
-   * Forces the waiting service worker to become the active one.
-   *
-   * @see https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerGlobalScope/skipWaiting
-   */
-  skipWaiting?: boolean;
-  /**
-   * Imports external scripts. They are executed in the order they
-   * are passed.
-   *
-   * @see https://developer.mozilla.org/en-US/docs/Web/API/WorkerGlobalScope/importScripts
-   */
-  importScripts?: string[];
-  /**
-   * Enables navigation preloading if it is supported.
-   *
-   * @see https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerRegistration/navigationPreload
-   */
-  navigationPreload?: boolean;
-  /**
-   * Modifies the prefix of the default cache names used by Serwist packages.
-   */
-  cacheId?: string | undefined;
-  /**
-   * Claims any currently available clients once the service worker
-   * becomes active. This is normally used in conjunction with `skipWaiting()`.
-   *
-   * @default false
-   */
-  clientsClaim?: boolean;
-  /**
-   * A list of caching strategies.
-   */
-  runtimeCaching?: RuntimeCaching[];
-  /**
-   * Your configuration for `@serwist/google-analytics`. This plugin is
-   * only initialized when this option is not `undefined` or `false`.
-   */
-  offlineAnalyticsConfig?: GoogleAnalyticsInitializeOptions | boolean;
-  /**
-   * Disables Serwist's logging in development mode.
-   *
-   * @default false
-   */
-  disableDevLogs?: boolean;
-  /**
-   * Precaches routes so that they can be used as a fallback when
-   * a Strategy fails to generate a response.
-   */
-  fallbacks?: Pick<FallbacksOptions, "entries">;
-}
-
-/**
- * Abstracts away the core APIs of Serwist.
- *
- * @param options - `installSerwist` options.
- * @deprecated
- */
-export const installSerwist = ({
-  precacheController = getSingletonPrecacheController(),
-  router = getSingletonRouter(),
-  precacheEntries,
-  precacheOptions,
-  cleanupOutdatedCaches,
-  navigateFallback,
-  navigateFallbackAllowlist,
-  navigateFallbackDenylist,
-  skipWaiting,
-  importScripts,
-  navigationPreload = false,
-  cacheId,
-  clientsClaim = false,
-  runtimeCaching,
-  offlineAnalyticsConfig,
-  disableDevLogs = false,
-  fallbacks,
-}: InstallSerwistOptions): void => {
-  if (!!importScripts && importScripts.length > 0) self.importScripts(...importScripts);
-
-  if (navigationPreload) enableNavigationPreload();
-
-  if (cacheId !== undefined) {
-    setCacheNameDetails({
-      prefix: cacheId,
-    });
-  }
-
-  if (skipWaiting) {
-    self.skipWaiting();
-  } else {
-    self.addEventListener("message", (event) => {
-      if (event.data && event.data.type === "SKIP_WAITING") {
-        self.skipWaiting();
-      }
-    });
-  }
-
-  if (clientsClaim) clientsClaimImpl();
-
-  handlePrecaching({
-    precacheController,
-    router,
-    precacheEntries,
-    precacheOptions,
-    cleanupOutdatedCaches,
-    navigateFallback,
-    navigateFallbackAllowlist,
-    navigateFallbackDenylist,
-  });
-
-  if (runtimeCaching !== undefined) {
-    if (fallbacks !== undefined) {
-      runtimeCaching = fallbacksImpl({
-        precacheController,
-        router,
-        runtimeCaching,
-        entries: fallbacks.entries,
-        precacheOptions,
-      });
-    }
-    registerRuntimeCaching(...runtimeCaching);
-  }
-
-  if (offlineAnalyticsConfig !== undefined) {
-    if (typeof offlineAnalyticsConfig === "boolean") {
-      offlineAnalyticsConfig && initializeGoogleAnalytics({ router });
-    } else {
-      initializeGoogleAnalytics({
-        ...offlineAnalyticsConfig,
-        router,
-      });
-    }
-  }
-
-  if (disableDevLogs) disableDevLogsImpl();
-};

package/src/legacy/matchPrecache.ts

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

package/src/legacy/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 { getSingletonPrecacheController } from "./singletonPrecacheController.js";
-import type { addRoute } from "./addRoute.js";
-import type { precacheAndRoute } from "./precacheAndRoute.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
- * {@linkcode addRoute}.
- *
- * If you have a single array of files to precache, you can just call
- * {@linkcode precacheAndRoute}.
- *
- * @param entries Array of entries to precache.
- * @deprecated
- */
-export const precache = (entries: (PrecacheEntry | string)[]): void => {
-  getSingletonPrecacheController().precache(entries);
-};

package/src/legacy/precacheAndRoute.ts

@@ -1,27 +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
- * {@linkcode precache} and {@linkcode addRoute} in a single call.
- *
- * @param entries Array of entries to precache.
- * @param options See the {@linkcode PrecacheRouteOptions} options.
- * @deprecated
- */
-export const precacheAndRoute = (entries: (PrecacheEntry | string)[], options?: PrecacheRouteOptions): void => {
-  precache(entries);
-  addRoute(options);
-};

package/src/legacy/registerRoute.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 type { Router } from "./Router.js";
-import type { Route } from "../Route.js";
-import type { HTTPMethod } from "../constants.js";
-import type { RouteHandler, RouteMatchCallback } from "../types.js";
-import type { unregisterRoute } from "./unregisterRoute.js";
-import { getSingletonRouter } from "./singletonRouter.js";
-
-/**
- * Registers a `RegExp`, string, or function with a caching
- * strategy to a singleton {@linkcode Router} instance.
- *
- * @param capture If the capture param is a {@linkcode Route}, all other arguments will be ignored.
- * @param handler A callback function that returns a promise resulting in a response.
- * This parameter is required if `capture` is not a {@linkcode Route} object.
- * @param method The HTTP method to match the route against. Defaults to `'GET'`.
- * @returns The generated {@linkcode Route} object, which can then be provided to {@linkcode unregisterRoute} if needed.
- * @deprecated
- */
-export const registerRoute = (capture: RegExp | string | RouteMatchCallback | Route, handler?: RouteHandler, method?: HTTPMethod): Route => {
-  return getSingletonRouter().registerCapture(capture, handler, method);
-};

package/src/legacy/registerRuntimeCaching.ts

@@ -1,17 +0,0 @@
-import { registerRoute } from "./registerRoute.js";
-
-import type { RuntimeCaching } from "../types.js";
-
-/**
- * Registers caching strategies to a singleton Router instance. It is a simple
- * syntatic sugar for {@linkcode registerRoute}.
- *
- * @param runtimeCachingList
- * @returns
- * @deprecated
- */
-export const registerRuntimeCaching = (...runtimeCachingList: RuntimeCaching[]): void => {
-  for (const entry of runtimeCachingList) {
-    registerRoute(entry.matcher, entry.handler, entry.method);
-  }
-};

package/src/legacy/setCatchHandler.ts

@@ -1,21 +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 { RouteHandler } from "../types.js";
-import { getSingletonRouter } from "./singletonRouter.js";
-
-/**
- * If a route throws an error while handling a request, this handler
- * will be called and given a chance to provide a response.
- *
- * @param handler A callback function that returns a promise resulting in a response.
- * @deprecated
- */
-export const setCatchHandler = (handler: RouteHandler): void => {
-  getSingletonRouter().setCatchHandler(handler);
-};

package/src/legacy/setDefaultHandler.ts

@@ -1,24 +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 { RouteHandler } from "../types.js";
-import { getSingletonRouter } from "./singletonRouter.js";
-
-/**
- * Defines a default handler that's called when no routes explicitly
- * match the incoming request.
- *
- * Without a default handler, unmatched requests will go against the
- * network as if there were no service worker present.
- *
- * @param handler A callback function that returns a promise resulting in a response.
- * @deprecated
- */
-export const setDefaultHandler = (handler: RouteHandler): void => {
-  getSingletonRouter().setDefaultHandler(handler);
-};