@serwist/sw 9.0.0-preview.20 → 9.0.0-preview.24

package/src/precaching/utils/printInstallDetails.ts

@@ -1,53 +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 { logger } from "@serwist/core/internal";
-
-/**
- * @param groupTitle
- * @param urls
- *
- * @private
- */
-function _nestedGroup(groupTitle: string, urls: string[]): void {
-  if (urls.length === 0) {
-    return;
-  }
-
-  logger.groupCollapsed(groupTitle);
-
-  for (const url of urls) {
-    logger.log(url);
-  }
-
-  logger.groupEnd();
-}
-
-/**
- * @param urlsToPrecache
- * @param  urlsAlreadyPrecached
- * @private
- */
-export function printInstallDetails(urlsToPrecache: string[], urlsAlreadyPrecached: string[]): void {
-  const precachedCount = urlsToPrecache.length;
-  const alreadyPrecachedCount = urlsAlreadyPrecached.length;
-
-  if (precachedCount || alreadyPrecachedCount) {
-    let message = `Precaching ${precachedCount} file${precachedCount === 1 ? "" : "s"}.`;
-
-    if (alreadyPrecachedCount > 0) {
-      message += ` ${alreadyPrecachedCount} ` + `file${alreadyPrecachedCount === 1 ? " is" : "s are"} already cached.`;
-    }
-
-    logger.groupCollapsed(message);
-
-    _nestedGroup("View newly precached URLs.", urlsToPrecache);
-    _nestedGroup("View previously precached URLs.", urlsAlreadyPrecached);
-    logger.groupEnd();
-  }
-}

package/src/precaching/utils/removeIgnoredSearchParams.ts

@@ -1,29 +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.
-*/
-
-/**
- * Removes any URL search parameters that should be ignored.
- *
- * @param urlObject The original URL.
- * @param ignoreURLParametersMatching RegExps to test against
- * each search parameter name. Matches mean that the search parameter should be
- * ignored.
- * @returns The URL with any ignored search parameters removed.
- * @private
- */
-export function removeIgnoredSearchParams(urlObject: URL, ignoreURLParametersMatching: RegExp[] = []): URL {
-  // Convert the iterable into an array at the start of the loop to make sure
-  // deletion doesn't mess up iteration.
-  for (const paramName of [...urlObject.searchParams.keys()]) {
-    if (ignoreURLParametersMatching.some((regExp) => regExp.test(paramName))) {
-      urlObject.searchParams.delete(paramName);
-    }
-  }
-
-  return urlObject;
-}

package/src/routing/NavigationRoute.ts

@@ -1,119 +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 { RouteHandler, RouteMatchCallbackOptions } from "@serwist/core";
-import { assert, logger } from "@serwist/core/internal";
-
-import { Route } from "./Route.js";
-
-export interface NavigationRouteMatchOptions {
-  /**
-   * If any of these patterns
-   * match the URL's pathname and search parameter, the route will handle the
-   * request (assuming the denylist doesn't match).
-   *
-   * @default [/./]
-   */
-  allowlist?: RegExp[];
-  /**
-   * If any of these patterns match, the route will not handle the request (even if a allowlist RegExp matches).
-   */
-  denylist?: RegExp[];
-}
-
-/**
- * NavigationRoute makes it easy to create a `@serwist/routing` Route that matches for browser
- * [navigation requests](https://developers.google.com/web/fundamentals/primers/service-workers/high-performance-loading#first_what_are_navigation_requests).
- *
- * It will only match incoming Requests whose [mode](https://fetch.spec.whatwg.org/#concept-request-mode) is set to `navigate`.
- *
- * You can optionally only apply this route to a subset of navigation requests
- * by using one or both of the `denylist` and `allowlist` parameters.
- */
-export class NavigationRoute extends Route {
-  private readonly _allowlist: RegExp[];
-  private readonly _denylist: RegExp[];
-
-  /**
-   * If both `denylist` and `allowlist` are provided, the `denylist` will
-   * take precedence and the request will not match this route.
-   *
-   * The regular expressions in `allowlist` and `denylist`
-   * are matched against the concatenated
-   * [`pathname`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLHyperlinkElementUtils/pathname)
-   * and [`search`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLHyperlinkElementUtils/search)
-   * portions of the requested URL.
-   *
-   * *Note*: These RegExps may be evaluated against every destination URL during
-   * a navigation. Avoid using
-   * [complex RegExps](https://github.com/GoogleChrome/workbox/issues/3077),
-   * or else your users may see delays when navigating your site.
-   *
-   * @param handler A callback function that returns a Promise resulting in a Response.
-   * @param options
-   */
-  constructor(handler: RouteHandler, { allowlist = [/./], denylist = [] }: NavigationRouteMatchOptions = {}) {
-    if (process.env.NODE_ENV !== "production") {
-      assert!.isArrayOfClass(allowlist, RegExp, {
-        moduleName: "@serwist/routing",
-        className: "NavigationRoute",
-        funcName: "constructor",
-        paramName: "options.allowlist",
-      });
-      assert!.isArrayOfClass(denylist, RegExp, {
-        moduleName: "@serwist/routing",
-        className: "NavigationRoute",
-        funcName: "constructor",
-        paramName: "options.denylist",
-      });
-    }
-
-    super((options: RouteMatchCallbackOptions) => this._match(options), handler);
-
-    this._allowlist = allowlist;
-    this._denylist = denylist;
-  }
-
-  /**
-   * Routes match handler.
-   *
-   * @param options
-   * @returns
-   * @private
-   */
-  private _match({ url, request }: RouteMatchCallbackOptions): boolean {
-    if (request && request.mode !== "navigate") {
-      return false;
-    }
-
-    const pathnameAndSearch = url.pathname + url.search;
-
-    for (const regExp of this._denylist) {
-      if (regExp.test(pathnameAndSearch)) {
-        if (process.env.NODE_ENV !== "production") {
-          logger.log(
-            `The navigation route ${pathnameAndSearch} is not being used, since the URL matches this denylist pattern: ${regExp.toString()}`,
-          );
-        }
-        return false;
-      }
-    }
-
-    if (this._allowlist.some((regExp) => regExp.test(pathnameAndSearch))) {
-      if (process.env.NODE_ENV !== "production") {
-        logger.debug(`The navigation route ${pathnameAndSearch} is being used.`);
-      }
-      return true;
-    }
-
-    if (process.env.NODE_ENV !== "production") {
-      logger.log(`The navigation route ${pathnameAndSearch} is not being used, since the URL being navigated to doesn't match the allowlist.`);
-    }
-    return false;
-  }
-}

package/src/routing/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 type { RouteHandler, RouteMatchCallback, RouteMatchCallbackOptions } from "@serwist/core";
-import { assert, logger } from "@serwist/core/internal";
-
-import { Route } from "./Route.js";
-import type { HTTPMethod } from "./utils/constants.js";
-
-/**
- * `RegExpRoute` makes it easy to create a regular expression based on a `@serwist/routing` Route.
- *
- * 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 Route, defaults to GET.
-   * against.
-   */
-  constructor(regExp: RegExp, handler: RouteHandler, method?: HTTPMethod) {
-    if (process.env.NODE_ENV !== "production") {
-      assert!.isInstance(regExp, RegExp, {
-        moduleName: "@serwist/routing",
-        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/routing/Route.ts

@@ -1,68 +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 { RouteHandler, RouteHandlerObject, RouteMatchCallback } from "@serwist/core";
-import { assert } from "@serwist/core/internal";
-
-import type { HTTPMethod } from "./utils/constants.js";
-import { defaultMethod, validMethods } from "./utils/constants.js";
-import { normalizeHandler } from "./utils/normalizeHandler.js";
-
-/**
- * A `Route` consists of a pair of callback functions, "match" and "handler".
- * The "match" callback determine if a route should be used to "handle" a
- * request by returning a non-falsy value if it can. The "handler" callback
- * is called when there is a match 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 non-falsy 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/routing",
-        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);
-  }
-}