serwist 9.1.1 → 10.0.0-preview.10

package/src/PrecacheRoute.ts

@@ -1,45 +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 { Route } from "./Route.js";
-import type { Serwist } from "./Serwist.js";
-import type { RouteMatchCallback, RouteMatchCallbackOptions } from "./types.js";
-import type { PrecacheRouteOptions } from "./types.js";
-import { generateURLVariations } from "./utils/generateURLVariations.js";
-import { getFriendlyURL } from "./utils/getFriendlyURL.js";
-import { logger } from "./utils/logger.js";
-
-/**
- * A subclass of {@linkcode Route} that takes a {@linkcode Serwist} instance and uses it to match
- * incoming requests and handle fetching responses from the precache.
- */
-export class PrecacheRoute extends Route {
-  /**
-   * @param serwist A {@linkcode Serwist} instance.
-   * @param options Options to control how requests are matched
-   * against the list of precached URLs.
-   */
-  constructor(serwist: Serwist, options?: PrecacheRouteOptions) {
-    const match: RouteMatchCallback = ({ request }: RouteMatchCallbackOptions) => {
-      const urlsToCacheKeys = serwist.getUrlsToPrecacheKeys();
-      for (const possibleURL of generateURLVariations(request.url, options)) {
-        const cacheKey = urlsToCacheKeys.get(possibleURL);
-        if (cacheKey) {
-          const integrity = serwist.getIntegrityForPrecacheKey(cacheKey);
-          return { cacheKey, integrity };
-        }
-      }
-      if (process.env.NODE_ENV !== "production") {
-        logger.debug(`Precaching did not find a match for ${getFriendlyURL(request.url)}.`);
-      }
-      return;
-    };
-
-    super(match, serwist.precacheStrategy);
-  }
-}

package/src/RegExpRoute.ts

@@ -1,74 +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 type { HTTPMethod } from "./constants.js";
-import type { RouteHandler, RouteMatchCallback, RouteMatchCallbackOptions } from "./types.js";
-import { assert } from "./utils/assert.js";
-import { logger } from "./utils/logger.js";
-
-/**
- * A class that makes it easy to create a {@linkcode Route} object with a regular expression.
- *
- * For same-origin requests the `RegExp` only needs to match part of the URL. For
- * requests against third-party servers, you must define a `RegExp` that matches
- * the start of the URL.
- */
-export class RegExpRoute extends Route {
-  /**
-   * If the regular expression contains
-   * [capture groups](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp#grouping-back-references),
-   * the captured values will be passed to the `params` argument.
-   *
-   * @param regExp The regular expression to match against URLs.
-   * @param handler A callback function that returns a `Promise` resulting in a `Response`.
-   * @param method The HTTP method to match the {@linkcode Route} against. Defaults to `GET`.
-   * against.
-   */
-  constructor(regExp: RegExp, handler: RouteHandler, method?: HTTPMethod) {
-    if (process.env.NODE_ENV !== "production") {
-      assert!.isInstance(regExp, RegExp, {
-        moduleName: "serwist",
-        className: "RegExpRoute",
-        funcName: "constructor",
-        paramName: "pattern",
-      });
-    }
-
-    const match: RouteMatchCallback = ({ url }: RouteMatchCallbackOptions) => {
-      const result = regExp.exec(url.href);
-
-      // Return immediately if there's no match.
-      if (!result) {
-        return;
-      }
-
-      // Require that the match start at the first character in the URL string
-      // if it's a cross-origin request.
-      // See https://github.com/GoogleChrome/workbox/issues/281 for the context
-      // behind this behavior.
-      if (url.origin !== location.origin && result.index !== 0) {
-        if (process.env.NODE_ENV !== "production") {
-          logger.debug(
-            `The regular expression '${regExp.toString()}' only partially matched against the cross-origin URL '${url.toString()}'. RegExpRoute's will only handle cross-origin requests if they match the entire URL.`,
-          );
-        }
-
-        return;
-      }
-
-      // If the route matches, but there aren't any capture groups defined, then
-      // this will return [], which is truthy and therefore sufficient to
-      // indicate a match.
-      // If there are capture groups, then it will return their values.
-      return result.slice(1);
-    };
-
-    super(match, handler, method);
-  }
-}

package/src/Route.ts

@@ -1,67 +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 type { HTTPMethod } from "./constants.js";
-import { defaultMethod, validMethods } from "./constants.js";
-import type { RouteHandler, RouteHandlerObject, RouteMatchCallback } from "./types.js";
-import { assert } from "./utils/assert.js";
-import { normalizeHandler } from "./utils/normalizeHandler.js";
-
-/**
- * A `Route` consists of a pair of callback functions, `match` and `handler`.
- * The `match` callback determines if a route should be used to handle a
- * request by returning a truthy value if it can. The `handler` callback
- * is called when the route matches and should return a promise that resolves
- * to a response.
- */
-export class Route {
-  handler: RouteHandlerObject;
-  match: RouteMatchCallback;
-  method: HTTPMethod;
-  catchHandler?: RouteHandlerObject;
-
-  /**
-   * Constructor for Route class.
-   *
-   * @param match A callback function that determines whether the
-   * route matches a given `fetch` event by returning a truthy value.
-   * @param handler A callback function that returns a `Promise` resolving
-   * to a `Response`.
-   * @param method The HTTP method to match the route against. Defaults
-   * to `GET`.
-   */
-  constructor(match: RouteMatchCallback, handler: RouteHandler, method: HTTPMethod = defaultMethod) {
-    if (process.env.NODE_ENV !== "production") {
-      assert!.isType(match, "function", {
-        moduleName: "serwist",
-        className: "Route",
-        funcName: "constructor",
-        paramName: "match",
-      });
-
-      if (method) {
-        assert!.isOneOf(method, validMethods, { paramName: "method" });
-      }
-    }
-
-    // These values are referenced directly by Router so cannot be
-    // altered by minificaton.
-    this.handler = normalizeHandler(handler);
-    this.match = match;
-    this.method = method;
-  }
-
-  /**
-   *
-   * @param handler A callback function that returns a Promise resolving
-   * to a Response.
-   */
-  setCatchHandler(handler: RouteHandler): void {
-    this.catchHandler = normalizeHandler(handler);
-  }
-}