serwist 9.0.0-preview.24

package/src/cacheNames.ts

@@ -0,0 +1,39 @@
+/*
+  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 { cacheNames as privateCacheNames } from "./utils/cacheNames.js";
+
+/**
+ * Get the current cache names and prefix/suffix used by Serwist.
+ *
+ * `cacheNames.precache` is used for precached assets,
+ * `cacheNames.googleAnalytics` is used by `@serwist/google-analytics` to
+ * store `analytics.js`, and `cacheNames.runtime` is used for everything else.
+ *
+ * `cacheNames.prefix` can be used to retrieve just the current prefix value.
+ * `cacheNames.suffix` can be used to retrieve just the current suffix value.
+ *
+ * @returns An object with `precache`, `runtime`, `prefix`, and `googleAnalytics` properties.
+ */
+export const cacheNames = {
+  get googleAnalytics(): string {
+    return privateCacheNames.getGoogleAnalyticsName();
+  },
+  get precache(): string {
+    return privateCacheNames.getPrecacheName();
+  },
+  get prefix(): string {
+    return privateCacheNames.getPrefix();
+  },
+  get runtime(): string {
+    return privateCacheNames.getRuntimeName();
+  },
+  get suffix(): string {
+    return privateCacheNames.getSuffix();
+  },
+};

package/src/cleanupOutdatedCaches.ts

@@ -0,0 +1,32 @@
+/*
+  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 } from "./utils/logger.js";
+import { cacheNames as privateCacheNames } from "./utils/cacheNames.js";
+
+import { deleteOutdatedCaches } from "./utils/deleteOutdatedCaches.js";
+
+declare const self: ServiceWorkerGlobalScope;
+
+/**
+ * Adds an `activate` event listener which will clean up incompatible
+ * precaches that were created by older versions of Serwist.
+ */
+export const cleanupOutdatedCaches = (cacheName?: string): void => {
+  self.addEventListener("activate", (event: ExtendableEvent) => {
+    event.waitUntil(
+      deleteOutdatedCaches(privateCacheNames.getPrecacheName(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);
+          }
+        }
+      }),
+    );
+  });
+};

package/src/clientsClaim.ts

@@ -0,0 +1,18 @@
+/*
+  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.
+*/
+
+// Give TypeScript the correct global.
+declare let self: ServiceWorkerGlobalScope;
+
+/**
+ * Claims any currently available clients once the service worker
+ * becomes active. This is normally used in conjunction with `skipWaiting()`.
+ */
+export const clientsClaim = (): void => {
+  self.addEventListener("activate", () => self.clients.claim());
+};

package/src/constants.ts

@@ -0,0 +1,24 @@
+/*
+  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 type HTTPMethod = "DELETE" | "GET" | "HEAD" | "PATCH" | "POST" | "PUT";
+
+/**
+ * The default HTTP method, 'GET', used when there's no specific method
+ * configured for a route.
+ *
+ * @private
+ */
+export const defaultMethod = "GET" satisfies HTTPMethod;
+
+/**
+ * The list of valid HTTP methods associated with requests that could be routed.
+ *
+ * @private
+ */
+export const validMethods = ["DELETE", "GET", "HEAD", "PATCH", "POST", "PUT"] satisfies HTTPMethod[];

package/src/copyResponse.ts

@@ -0,0 +1,60 @@
+/*
+  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 { SerwistError } from "./utils/SerwistError.js";
+import { canConstructResponseFromBodyStream } from "./utils/canConstructResponseFromBodyStream.js";
+
+/**
+ * Allows developers to copy a response and modify its `headers`, `status`,
+ * or `statusText` values (the values settable via a
+ * [`ResponseInit`](https://developer.mozilla.org/en-US/docs/Web/API/Response/Response#Syntax)
+ * object in the constructor).
+ * To modify these values, pass a function as the second argument. That
+ * function will be invoked with a single object with the response properties
+ * `{headers, status, statusText}`. The return value of this function will
+ * be used as the `ResponseInit` for the new `Response`. To change the values
+ * either modify the passed parameter(s) and return it, or return a totally
+ * new object.
+ *
+ * This method is intentionally limited to same-origin responses, regardless of
+ * whether CORS was used or not.
+ *
+ * @param response
+ * @param modifier
+ */
+export const copyResponse = async (response: Response, modifier?: (responseInit: ResponseInit) => ResponseInit): Promise<Response> => {
+  let origin = null;
+  // If response.url isn't set, assume it's cross-origin and keep origin null.
+  if (response.url) {
+    const responseURL = new URL(response.url);
+    origin = responseURL.origin;
+  }
+
+  if (origin !== self.location.origin) {
+    throw new SerwistError("cross-origin-copy-response", { origin });
+  }
+
+  const clonedResponse = response.clone();
+
+  // Create a fresh `ResponseInit` object by cloning the headers.
+  const responseInit: ResponseInit = {
+    headers: new Headers(clonedResponse.headers),
+    status: clonedResponse.status,
+    statusText: clonedResponse.statusText,
+  };
+
+  // Apply any user modifications.
+  const modifiedResponseInit = modifier ? modifier(responseInit) : responseInit;
+
+  // Create the new response from the body stream and `ResponseInit`
+  // modifications. Note: not all browsers support the Response.body stream,
+  // so fall back to reading the entire body into memory as a blob.
+  const body = canConstructResponseFromBodyStream() ? clonedResponse.body : await clonedResponse.blob();
+
+  return new Response(body, modifiedResponseInit);
+};

package/src/disableDevLogs.ts

@@ -0,0 +1,10 @@
+declare const self: ServiceWorkerGlobalScope;
+
+/**
+ * Disables Serwist's logging in development mode.
+ *
+ * @see https://serwist.pages.dev/docs/sw/abstractions/disable-dev-logs
+ */
+export const disableDevLogs = (): void => {
+  self.__WB_DISABLE_DEV_LOGS = true;
+};

package/src/index.internal.ts

@@ -0,0 +1,33 @@
+import { Deferred } from "./utils/Deferred.js";
+import { SerwistError } from "./utils/SerwistError.js";
+import { assert } from "./utils/assert.js";
+import { cacheMatchIgnoreParams } from "./utils/cacheMatchIgnoreParams.js";
+import { cacheNames as privateCacheNames } from "./utils/cacheNames.js";
+import { canConstructReadableStream } from "./utils/canConstructReadableStream.js";
+import { canConstructResponseFromBodyStream } from "./utils/canConstructResponseFromBodyStream.js";
+import { dontWaitFor } from "./utils/dontWaitFor.js";
+import { executeQuotaErrorCallbacks } from "./utils/executeQuotaErrorCallbacks.js";
+import { getFriendlyURL } from "./utils/getFriendlyURL.js";
+import { logger } from "./utils/logger.js";
+import { resultingClientExists } from "./utils/resultingClientExists.js";
+import { timeout } from "./utils/timeout.js";
+import { waitUntil } from "./utils/waitUntil.js";
+
+// Serwist's internal functions, classes, variables, and more. Feel free to use them,
+// but they are not documented. Note: they do follow semver.
+export {
+  Deferred,
+  SerwistError,
+  assert,
+  cacheMatchIgnoreParams,
+  privateCacheNames,
+  canConstructReadableStream,
+  canConstructResponseFromBodyStream,
+  dontWaitFor,
+  executeQuotaErrorCallbacks,
+  getFriendlyURL,
+  logger,
+  resultingClientExists,
+  timeout,
+  waitUntil,
+};

package/src/index.legacy.ts

@@ -0,0 +1,66 @@
+import { NavigationRoute } from "./NavigationRoute.js";
+import { PrecacheStrategy } from "./PrecacheStrategy.js";
+import { RegExpRoute } from "./RegExpRoute.js";
+import { Route } from "./Route.js";
+import { cleanupOutdatedCaches } from "./cleanupOutdatedCaches.js";
+import { PrecacheController } from "./legacy/PrecacheController.js";
+import { PrecacheFallbackPlugin } from "./legacy/PrecacheFallbackPlugin.js";
+import type { PrecacheFallbackEntry, PrecacheFallbackPluginOptions } from "./legacy/PrecacheFallbackPlugin.js";
+import { PrecacheRoute } from "./legacy/PrecacheRoute.js";
+import { Router } from "./legacy/Router.js";
+import { addPlugins } from "./legacy/addPlugins.js";
+import { addRoute } from "./legacy/addRoute.js";
+import { createHandlerBoundToURL } from "./legacy/createHandlerBoundToURL.js";
+import type { FallbackEntry, FallbacksOptions } from "./legacy/fallbacks.js";
+import { fallbacks } from "./legacy/fallbacks.js";
+import { getCacheKeyForURL } from "./legacy/getCacheKeyForURL.js";
+import { type HandlePrecachingOptions, handlePrecaching } from "./legacy/handlePrecaching.js";
+import { type InstallSerwistOptions, installSerwist } from "./legacy/installSerwist.js";
+import { matchPrecache } from "./legacy/matchPrecache.js";
+import { precache } from "./legacy/precache.js";
+import { precacheAndRoute } from "./legacy/precacheAndRoute.js";
+import { registerRoute } from "./legacy/registerRoute.js";
+import { registerRuntimeCaching } from "./legacy/registerRuntimeCaching.js";
+import { setCatchHandler } from "./legacy/setCatchHandler.js";
+import { setDefaultHandler } from "./legacy/setDefaultHandler.js";
+import { getSingletonPrecacheController, setSingletonPrecacheController } from "./legacy/singletonPrecacheController.js";
+import { getSingletonRouter, setSingletonRouter } from "./legacy/singletonRouter.js";
+import { unregisterRoute } from "./legacy/unregisterRoute.js";
+import { parseRoute } from "./parseRoute.js";
+
+export {
+  // These are not deprecated, but we export them so legacy packages
+  // can re-export them without having to import both the normal and legacy
+  // import paths.
+  NavigationRoute,
+  PrecacheStrategy,
+  RegExpRoute,
+  Route,
+  cleanupOutdatedCaches,
+  parseRoute,
+  // Actual deprecated modules start here
+  addPlugins,
+  addRoute,
+  createHandlerBoundToURL,
+  getCacheKeyForURL,
+  fallbacks,
+  matchPrecache,
+  precache,
+  precacheAndRoute,
+  PrecacheController,
+  PrecacheFallbackPlugin,
+  PrecacheRoute,
+  getSingletonPrecacheController,
+  setSingletonPrecacheController,
+  handlePrecaching,
+  installSerwist,
+  registerRuntimeCaching,
+  registerRoute,
+  Router,
+  setCatchHandler,
+  setDefaultHandler,
+  getSingletonRouter,
+  setSingletonRouter,
+  unregisterRoute,
+};
+export type { HandlePrecachingOptions, InstallSerwistOptions, FallbackEntry, FallbacksOptions, PrecacheFallbackEntry, PrecacheFallbackPluginOptions };

package/src/index.plugins.ts

@@ -0,0 +1,95 @@
+import { BackgroundSyncPlugin } from "./plugins/backgroundSync/BackgroundSyncPlugin.js";
+import type { QueueEntry as BackgroundSyncQueueEntry, QueueOptions as BackgroundSyncQueueOptions } from "./plugins/backgroundSync/Queue.js";
+import { Queue as BackgroundSyncQueue } from "./plugins/backgroundSync/Queue.js";
+import { QueueStore as BackgroundSyncQueueStore } from "./plugins/backgroundSync/QueueStore.js";
+import { StorableRequest } from "./plugins/backgroundSync/StorableRequest.js";
+import { BroadcastCacheUpdate } from "./plugins/broadcastUpdate/BroadcastCacheUpdate.js";
+import { BroadcastUpdatePlugin } from "./plugins/broadcastUpdate/BroadcastUpdatePlugin.js";
+import {
+  CACHE_UPDATED_MESSAGE_META as BROADCAST_UPDATE_MESSAGE_META,
+  CACHE_UPDATED_MESSAGE_TYPE as BROADCAST_UPDATE_MESSAGE_TYPE,
+  defaultHeadersToCheck as BROADCAST_UPDATE_DEFAULT_HEADERS,
+} from "./plugins/broadcastUpdate/constants.js";
+import { responsesAreSame } from "./plugins/broadcastUpdate/responsesAreSame.js";
+import type { BroadcastCacheUpdateOptions, BroadcastMessage, BroadcastPayload, BroadcastPayloadGenerator } from "./plugins/broadcastUpdate/types.js";
+import type { CacheableResponseOptions } from "./plugins/cacheableResponse/CacheableResponse.js";
+import { CacheableResponse } from "./plugins/cacheableResponse/CacheableResponse.js";
+import { CacheableResponsePlugin } from "./plugins/cacheableResponse/CacheableResponsePlugin.js";
+import { CacheExpiration } from "./plugins/expiration/CacheExpiration.js";
+import type { ExpirationPluginOptions } from "./plugins/expiration/ExpirationPlugin.js";
+import { ExpirationPlugin } from "./plugins/expiration/ExpirationPlugin.js";
+import type { GoogleAnalyticsInitializeOptions } from "./plugins/googleAnalytics/initialize.js";
+import { initialize as initializeGoogleAnalytics } from "./plugins/googleAnalytics/initialize.js";
+import type { PrecacheFallbackEntry, PrecacheFallbackPluginOptions } from "./plugins/precaching/PrecacheFallbackPlugin.js";
+import { PrecacheFallbackPlugin } from "./plugins/precaching/PrecacheFallbackPlugin.js";
+import { RangeRequestsPlugin } from "./plugins/rangeRequests/RangeRequestsPlugin.js";
+import { createPartialResponse } from "./plugins/rangeRequests/createPartialResponse.js";
+
+// See https://github.com/GoogleChrome/workbox/issues/2946
+interface SyncManager {
+  getTags(): Promise<string[]>;
+  register(tag: string): Promise<void>;
+}
+
+declare global {
+  interface ServiceWorkerRegistration {
+    readonly sync: SyncManager;
+  }
+
+  interface SyncEvent extends ExtendableEvent {
+    readonly lastChance: boolean;
+    readonly tag: string;
+  }
+
+  interface ServiceWorkerGlobalScopeEventMap {
+    sync: SyncEvent;
+  }
+}
+
+export {
+  // Background synchronization
+  BackgroundSyncPlugin,
+  BackgroundSyncQueue,
+  BackgroundSyncQueueStore,
+  StorableRequest,
+  // Update broadcasting
+  BroadcastCacheUpdate,
+  BroadcastUpdatePlugin,
+  responsesAreSame,
+  BROADCAST_UPDATE_MESSAGE_META,
+  BROADCAST_UPDATE_MESSAGE_TYPE,
+  BROADCAST_UPDATE_DEFAULT_HEADERS,
+  // Cacheable responses
+  CacheableResponse,
+  CacheableResponsePlugin,
+  // Expiration
+  CacheExpiration,
+  ExpirationPlugin,
+  // Precaching
+  PrecacheFallbackPlugin,
+  // Range requests
+  createPartialResponse,
+  RangeRequestsPlugin,
+  // Google Analytics
+  initializeGoogleAnalytics,
+};
+
+export type {
+  // Background synchronization
+  BackgroundSyncQueueOptions,
+  BackgroundSyncQueueEntry,
+  // Update broadcasting
+  BroadcastCacheUpdateOptions,
+  BroadcastPayload,
+  BroadcastPayloadGenerator,
+  BroadcastMessage,
+  // Cacheable responses
+  CacheableResponseOptions,
+  // Expiration
+  ExpirationPluginOptions,
+  // Precaching
+  PrecacheFallbackEntry,
+  PrecacheFallbackPluginOptions,
+  // Google Analytics
+  GoogleAnalyticsInitializeOptions,
+};

package/src/index.strategies.ts

@@ -0,0 +1,26 @@
+import { CacheFirst } from "./strategies/CacheFirst.js";
+import { CacheOnly } from "./strategies/CacheOnly.js";
+import type { NetworkFirstOptions } from "./strategies/NetworkFirst.js";
+import { NetworkFirst } from "./strategies/NetworkFirst.js";
+import type { NetworkOnlyOptions } from "./strategies/NetworkOnly.js";
+import { NetworkOnly } from "./strategies/NetworkOnly.js";
+import { StaleWhileRevalidate } from "./strategies/StaleWhileRevalidate.js";
+import type { StrategyOptions } from "./strategies/Strategy.js";
+import { Strategy } from "./strategies/Strategy.js";
+import { StrategyHandler } from "./strategies/StrategyHandler.js";
+
+// See https://github.com/GoogleChrome/workbox/issues/2946
+declare global {
+  interface FetchEvent {
+    // See https://github.com/GoogleChrome/workbox/issues/2974
+    readonly preloadResponse: Promise<any>;
+  }
+}
+
+/**
+ * There are common caching strategies that most service workers will need
+ * and use. This module provides simple implementations of these strategies.
+ */
+export { CacheFirst, CacheOnly, NetworkFirst, NetworkOnly, StaleWhileRevalidate, Strategy, StrategyHandler };
+
+export type { NetworkFirstOptions, NetworkOnlyOptions, StrategyOptions };

package/src/index.ts

@@ -0,0 +1,39 @@
+import type { HTTPMethod } from "./constants.js";
+import { cacheNames } from "./cacheNames.js";
+import { cleanupOutdatedCaches } from "./cleanupOutdatedCaches.js";
+import { clientsClaim } from "./clientsClaim.js";
+import { copyResponse } from "./copyResponse.js";
+import { disableDevLogs } from "./disableDevLogs.js";
+import { disableNavigationPreload, enableNavigationPreload, isNavigationPreloadSupported } from "./navigationPreload.js";
+import type { NavigationRouteMatchOptions } from "./NavigationRoute.js";
+import { NavigationRoute } from "./NavigationRoute.js";
+import { parseRoute } from "./parseRoute.js";
+import { PrecacheRoute } from "./PrecacheRoute.js";
+import { PrecacheStrategy } from "./PrecacheStrategy.js";
+import { RegExpRoute } from "./RegExpRoute.js";
+import { registerQuotaErrorCallback } from "./registerQuotaErrorCallback.js";
+import { Route } from "./Route.js";
+import { Serwist, type SerwistOptions } from "./Serwist.js";
+import { setCacheNameDetails } from "./setCacheNameDetails.js";
+
+export {
+  NavigationRoute,
+  cacheNames,
+  cleanupOutdatedCaches,
+  clientsClaim,
+  copyResponse,
+  disableDevLogs,
+  disableNavigationPreload,
+  enableNavigationPreload,
+  isNavigationPreloadSupported,
+  parseRoute,
+  PrecacheRoute,
+  PrecacheStrategy,
+  RegExpRoute,
+  registerQuotaErrorCallback,
+  Route,
+  Serwist,
+  setCacheNameDetails,
+};
+export type { HTTPMethod, NavigationRouteMatchOptions, SerwistOptions };
+export type * from "./types.js";