idanoo/GoScrobble
1
0
Fork 0
mirror of https://github.com/idanoo/GoScrobble synced 2025-07-01 13:42:20 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

0.2.0 - Mid migration

Browse source
This commit is contained in:
Daniel Mason 2022-04-25 14:47:15 +12:00
parent 139e6a915e
commit 7e38fdbd7d
42393 changed files with 5358157 additions and 62 deletions
Download patch file Download diff file Expand all files Collapse all files

19
web/node_modules/workbox-routing/LICENSE generated vendored Normal file
View file

@ -0,0 +1,19 @@
Copyright 2018 Google LLC
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

58
web/node_modules/workbox-routing/NavigationRoute.d.ts generated vendored Normal file
View file

@ -0,0 +1,58 @@
import { Route } from './Route.js';
import { Handler } from './_types.js';
import './_version.js';
export interface NavigationRouteMatchOptions {
allowlist?: RegExp[];
denylist?: RegExp[];
}
/**
* NavigationRoute makes it easy to create a
* [Route]{@link module:workbox-routing.Route} that matches for browser
* [navigation requests]{@link 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`]{@link 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.
*
* @memberof module:workbox-routing
* @extends module:workbox-routing.Route
*/
declare class NavigationRoute extends Route {
private readonly _allowlist;
private readonly _denylist;
/**
* 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`]{@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLHyperlinkElementUtils/pathname}
* and [`search`]{@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLHyperlinkElementUtils/search}
* portions of the requested URL.
*
* @param {module:workbox-routing~handlerCallback} handler A callback
* function that returns a Promise resulting in a Response.
* @param {Object} options
* @param {Array<RegExp>} [options.denylist] If any of these patterns match,
* the route will not handle the request (even if a allowlist RegExp matches).
* @param {Array<RegExp>} [options.allowlist=[/./]] 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).
*/
constructor(handler: Handler, { allowlist, denylist }?: NavigationRouteMatchOptions);
/**
* Routes match handler.
*
* @param {Object} options
* @param {URL} options.url
* @param {Request} options.request
* @return {boolean}
*
* @private
*/
private _match;
}
export { NavigationRoute };

106
web/node_modules/workbox-routing/NavigationRoute.js generated vendored Normal file
View file

@ -0,0 +1,106 @@
/*
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 { assert } from 'workbox-core/_private/assert.js';
import { logger } from 'workbox-core/_private/logger.js';
import { Route } from './Route.js';
import './_version.js';
/**
* NavigationRoute makes it easy to create a
* [Route]{@link module:workbox-routing.Route} that matches for browser
* [navigation requests]{@link 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`]{@link 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.
*
* @memberof module:workbox-routing
* @extends module:workbox-routing.Route
*/
class NavigationRoute extends Route {
/**
* 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`]{@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLHyperlinkElementUtils/pathname}
* and [`search`]{@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLHyperlinkElementUtils/search}
* portions of the requested URL.
*
* @param {module:workbox-routing~handlerCallback} handler A callback
* function that returns a Promise resulting in a Response.
* @param {Object} options
* @param {Array<RegExp>} [options.denylist] If any of these patterns match,
* the route will not handle the request (even if a allowlist RegExp matches).
* @param {Array<RegExp>} [options.allowlist=[/./]] 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).
*/
constructor(handler, { allowlist = [/./], denylist = [] } = {}) {
if (process.env.NODE_ENV !== 'production') {
assert.isArrayOfClass(allowlist, RegExp, {
moduleName: 'workbox-routing',
className: 'NavigationRoute',
funcName: 'constructor',
paramName: 'options.allowlist',
});
assert.isArrayOfClass(denylist, RegExp, {
moduleName: 'workbox-routing',
className: 'NavigationRoute',
funcName: 'constructor',
paramName: 'options.denylist',
});
}
super((options) => this._match(options), handler);
this._allowlist = allowlist;
this._denylist = denylist;
}
/**
* Routes match handler.
*
* @param {Object} options
* @param {URL} options.url
* @param {Request} options.request
* @return {boolean}
*
* @private
*/
_match({ url, request }) {
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}`);
}
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;
}
}
export { NavigationRoute };

1
web/node_modules/workbox-routing/NavigationRoute.mjs generated vendored Normal file
View file

@ -0,0 +1 @@
export * from './NavigationRoute.js';

1
web/node_modules/workbox-routing/README.md generated vendored Normal file
View file

@ -0,0 +1 @@
This module's documentation can be found at https://developers.google.com/web/tools/workbox/modules/workbox-routing

34
web/node_modules/workbox-routing/RegExpRoute.d.ts generated vendored Normal file
View file

@ -0,0 +1,34 @@
import { HTTPMethod } from './utils/constants.js';
import { Route } from './Route.js';
import { Handler } from './_types.js';
import './_version.js';
/**
* RegExpRoute makes it easy to create a regular expression based
* [Route]{@link module:workbox-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.
*
* [See the module docs for info.]{@link https://developers.google.com/web/tools/workbox/modules/workbox-routing}
*
* @memberof module:workbox-routing
* @extends module:workbox-routing.Route
*/
declare class RegExpRoute extends Route {
/**
* If the regular expression contains
* [capture groups]{@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp#grouping-back-references},
* the captured values will be passed to the
* [handler's]{@link module:workbox-routing~handlerCallback} `params`
* argument.
*
* @param {RegExp} regExp The regular expression to match against URLs.
* @param {module:workbox-routing~handlerCallback} handler A callback
* function that returns a Promise resulting in a Response.
* @param {string} [method='GET'] The HTTP method to match the Route
* against.
*/
constructor(regExp: RegExp, handler: Handler, method?: HTTPMethod);
}
export { RegExpRoute };

75
web/node_modules/workbox-routing/RegExpRoute.js generated vendored Normal file
View file

@ -0,0 +1,75 @@
/*
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 { assert } from 'workbox-core/_private/assert.js';
import { logger } from 'workbox-core/_private/logger.js';
import { Route } from './Route.js';
import './_version.js';
/**
* RegExpRoute makes it easy to create a regular expression based
* [Route]{@link module:workbox-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.
*
* [See the module docs for info.]{@link https://developers.google.com/web/tools/workbox/modules/workbox-routing}
*
* @memberof module:workbox-routing
* @extends module:workbox-routing.Route
*/
class RegExpRoute extends Route {
/**
* If the regular expression contains
* [capture groups]{@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp#grouping-back-references},
* the captured values will be passed to the
* [handler's]{@link module:workbox-routing~handlerCallback} `params`
* argument.
*
* @param {RegExp} regExp The regular expression to match against URLs.
* @param {module:workbox-routing~handlerCallback} handler A callback
* function that returns a Promise resulting in a Response.
* @param {string} [method='GET'] The HTTP method to match the Route
* against.
*/
constructor(regExp, handler, method) {
if (process.env.NODE_ENV !== 'production') {
assert.isInstance(regExp, RegExp, {
moduleName: 'workbox-routing',
className: 'RegExpRoute',
funcName: 'constructor',
paramName: 'pattern',
});
}
const match = ({ url }) => {
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}' only partially matched ` +
`against the cross-origin URL '${url}'. 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);
}
}
export { RegExpRoute };

1
web/node_modules/workbox-routing/RegExpRoute.mjs generated vendored Normal file
View file

@ -0,0 +1 @@
export * from './RegExpRoute.js';

30
web/node_modules/workbox-routing/Route.d.ts generated vendored Normal file
View file

@ -0,0 +1,30 @@
import { HTTPMethod } from './utils/constants.js';
import { Handler, HandlerObject, MatchCallback } from './_types.js';
import './_version.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`.
*
* @memberof module:workbox-routing
*/
declare class Route {
handler: HandlerObject;
match: MatchCallback;
method: HTTPMethod;
/**
* Constructor for Route class.
*
* @param {module:workbox-routing~matchCallback} match
* A callback function that determines whether the route matches a given
* `fetch` event by returning a non-falsy value.
* @param {module:workbox-routing~handlerCallback} handler A callback
* function that returns a Promise resolving to a Response.
* @param {string} [method='GET'] The HTTP method to match the Route
* against.
*/
constructor(match: MatchCallback, handler: Handler, method?: HTTPMethod);
}
export { Route };

52
web/node_modules/workbox-routing/Route.js generated vendored Normal file
View file

@ -0,0 +1,52 @@
/*
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 { assert } from 'workbox-core/_private/assert.js';
import { defaultMethod, validMethods } from './utils/constants.js';
import { normalizeHandler } from './utils/normalizeHandler.js';
import './_version.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`.
*
* @memberof module:workbox-routing
*/
class Route {
/**
* Constructor for Route class.
*
* @param {module:workbox-routing~matchCallback} match
* A callback function that determines whether the route matches a given
* `fetch` event by returning a non-falsy value.
* @param {module:workbox-routing~handlerCallback} handler A callback
* function that returns a Promise resolving to a Response.
* @param {string} [method='GET'] The HTTP method to match the Route
* against.
*/
constructor(match, handler, method = defaultMethod) {
if (process.env.NODE_ENV !== 'production') {
assert.isType(match, 'function', {
moduleName: 'workbox-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;
}
}
export { Route };

1
web/node_modules/workbox-routing/Route.mjs generated vendored Normal file
View file

@ -0,0 +1 @@
export * from './Route.js';

134
web/node_modules/workbox-routing/Router.d.ts generated vendored Normal file
View file

@ -0,0 +1,134 @@
import { Route } from './Route.js';
import { HTTPMethod } from './utils/constants.js';
import { Handler, HandlerCallbackOptions } from './_types.js';
import './_version.js';
/**
* The Router can be used to process a FetchEvent through one or more
* [Routes]{@link module:workbox-routing.Route} responding with a Request if
* a matching route exists.
*
* If no route matches a given a request, the Router will use a "default"
* handler if one is defined.
*
* Should the matching Route throw an error, the Router will use a "catch"
* handler if one is defined to gracefully deal with issues and respond with a
* Request.
*
* If a request matches multiple routes, the **earliest** registered route will
* be used to respond to the request.
*
* @memberof module:workbox-routing
*/
declare class Router {
private readonly _routes;
private _defaultHandler?;
private _catchHandler?;
/**
* Initializes a new Router.
*/
constructor();
/**
* @return {Map<string, Array<module:workbox-routing.Route>>} routes A `Map` of HTTP
* method name ('GET', etc.) to an array of all the corresponding `Route`
* instances that are registered.
*/
get routes(): Map<HTTPMethod, Route[]>;
/**
* Adds a fetch event listener to respond to events when a route matches
* the event's request.
*/
addFetchListener(): void;
/**
* Adds a message event listener for URLs to cache from the window.
* This is useful to cache resources loaded on the page prior to when the
* service worker started controlling it.
*
* The format of the message data sent from the window should be as follows.
* Where the `urlsToCache` array may consist of URL strings or an array of
* URL string + `requestInit` object (the same as you'd pass to `fetch()`).
*
* ```
* {
* type: 'CACHE_URLS',
* payload: {
* urlsToCache: [
* './script1.js',
* './script2.js',
* ['./script3.js', {mode: 'no-cors'}],
* ],
* },
* }
* ```
*/
addCacheListener(): void;
/**
* Apply the routing rules to a FetchEvent object to get a Response from an
* appropriate Route's handler.
*
* @param {Object} options
* @param {Request} options.request The request to handle (this is usually
* from a fetch event, but it does not have to be).
* @param {FetchEvent} [options.event] The event that triggered the request,
* if applicable.
* @return {Promise<Response>|undefined} A promise is returned if a
* registered route can handle the request. If there is no matching
* route and there's no `defaultHandler`, `undefined` is returned.
*/
handleRequest({ request, event }: {
request: Request;
event?: ExtendableEvent;
}): Promise<Response> | undefined;
/**
* Checks a request and URL (and optionally an event) against the list of
* registered routes, and if there's a match, returns the corresponding
* route along with any params generated by the match.
*
* @param {Object} options
* @param {URL} options.url
* @param {Request} options.request The request to match.
* @param {Event} [options.event] The corresponding event (unless N/A).
* @return {Object} An object with `route` and `params` properties.
* They are populated if a matching route was found or `undefined`
* otherwise.
*/
findMatchingRoute({ url, request, event }: {
url: URL;
request: Request;
event?: ExtendableEvent;
}): {
route?: Route;
params?: HandlerCallbackOptions['params'];
};
/**
* Define 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 {module:workbox-routing~handlerCallback} handler A callback
* function that returns a Promise resulting in a Response.
*/
setDefaultHandler(handler: Handler): void;
/**
* If a Route throws an error while handling a request, this `handler`
* will be called and given a chance to provide a response.
*
* @param {module:workbox-routing~handlerCallback} handler A callback
* function that returns a Promise resulting in a Response.
*/
setCatchHandler(handler: Handler): void;
/**
* Registers a route with the router.
*
* @param {module:workbox-routing.Route} route The route to register.
*/
registerRoute(route: Route): void;
/**
* Unregisters a route with the router.
*
* @param {module:workbox-routing.Route} route The route to unregister.
*/
unregisterRoute(route: Route): void;
}
export { Router };

353
web/node_modules/workbox-routing/Router.js generated vendored Normal file
View file

@ -0,0 +1,353 @@
/*
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 { assert } from 'workbox-core/_private/assert.js';
import { logger } from 'workbox-core/_private/logger.js';
import { WorkboxError } from 'workbox-core/_private/WorkboxError.js';
import { getFriendlyURL } from 'workbox-core/_private/getFriendlyURL.js';
import { normalizeHandler } from './utils/normalizeHandler.js';
import './_version.js';
/**
* The Router can be used to process a FetchEvent through one or more
* [Routes]{@link module:workbox-routing.Route} responding with a Request if
* a matching route exists.
*
* If no route matches a given a request, the Router will use a "default"
* handler if one is defined.
*
* Should the matching Route throw an error, the Router will use a "catch"
* handler if one is defined to gracefully deal with issues and respond with a
* Request.
*
* If a request matches multiple routes, the **earliest** registered route will
* be used to respond to the request.
*
* @memberof module:workbox-routing
*/
class Router {
/**
* Initializes a new Router.
*/
constructor() {
this._routes = new Map();
}
/**
* @return {Map<string, Array<module:workbox-routing.Route>>} routes A `Map` of HTTP
* method name ('GET', etc.) to an array of all the corresponding `Route`
* instances that are registered.
*/
get routes() {
return this._routes;
}
/**
* Adds a fetch event listener to respond to events when a route matches
* the event's request.
*/
addFetchListener() {
// See https://github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705
self.addEventListener('fetch', ((event) => {
const { request } = event;
const responsePromise = this.handleRequest({ request, event });
if (responsePromise) {
event.respondWith(responsePromise);
}
}));
}
/**
* Adds a message event listener for URLs to cache from the window.
* This is useful to cache resources loaded on the page prior to when the
* service worker started controlling it.
*
* The format of the message data sent from the window should be as follows.
* Where the `urlsToCache` array may consist of URL strings or an array of
* URL string + `requestInit` object (the same as you'd pass to `fetch()`).
*
* ```
* {
* type: 'CACHE_URLS',
* payload: {
* urlsToCache: [
* './script1.js',
* './script2.js',
* ['./script3.js', {mode: 'no-cors'}],
* ],
* },
* }
* ```
*/
addCacheListener() {
// See https://github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705
self.addEventListener('message', ((event) => {
if (event.data && event.data.type === 'CACHE_URLS') {
const { payload } = event.data;
if (process.env.NODE_ENV !== 'production') {
logger.debug(`Caching URLs from the window`, payload.urlsToCache);
}
const requestPromises = Promise.all(payload.urlsToCache.map((entry) => {
if (typeof entry === 'string') {
entry = [entry];
}
const request = new Request(...entry);
return this.handleRequest({ request });
// TODO(philipwalton): TypeScript errors without this typecast for
// some reason (probably a bug). The real type here should work but
// doesn't: `Array<Promise<Response> | undefined>`.
})); // TypeScript
event.waitUntil(requestPromises);
// If a MessageChannel was used, reply to the message on success.
if (event.ports && event.ports[0]) {
requestPromises.then(() => event.ports[0].postMessage(true));
}
}
}));
}
/**
* Apply the routing rules to a FetchEvent object to get a Response from an
* appropriate Route's handler.
*
* @param {Object} options
* @param {Request} options.request The request to handle (this is usually
* from a fetch event, but it does not have to be).
* @param {FetchEvent} [options.event] The event that triggered the request,
* if applicable.
* @return {Promise<Response>|undefined} A promise is returned if a
* registered route can handle the request. If there is no matching
* route and there's no `defaultHandler`, `undefined` is returned.
*/
handleRequest({ request, event }) {
if (process.env.NODE_ENV !== 'production') {
assert.isInstance(request, Request, {
moduleName: 'workbox-routing',
className: 'Router',
funcName: 'handleRequest',
paramName: 'options.request',
});
}
const url = new URL(request.url, location.href);
if (!url.protocol.startsWith('http')) {
if (process.env.NODE_ENV !== 'production') {
logger.debug(`Workbox Router only supports URLs that start with 'http'.`);
}
return;
}
const { params, route } = this.findMatchingRoute({ url, request, event });
let handler = route && route.handler;
const debugMessages = [];
if (process.env.NODE_ENV !== 'production') {
if (handler) {
debugMessages.push([
`Found a route to handle this request:`, route,
]);
if (params) {
debugMessages.push([
`Passing the following params to the route's handler:`, params,
]);
}
}
}
// If we don't have a handler because there was no matching route, then
// fall back to defaultHandler if that's defined.
if (!handler && this._defaultHandler) {
if (process.env.NODE_ENV !== 'production') {
debugMessages.push(`Failed to find a matching route. Falling ` +
`back to the default handler.`);
}
handler = this._defaultHandler;
}
if (!handler) {
if (process.env.NODE_ENV !== 'production') {
// No handler so Workbox will do nothing. If logs is set of debug
// i.e. verbose, we should print out this information.
logger.debug(`No route found for: ${getFriendlyURL(url)}`);
}
return;
}
if (process.env.NODE_ENV !== 'production') {
// We have a handler, meaning Workbox is going to handle the route.
// print the routing details to the console.
logger.groupCollapsed(`Router is responding to: ${getFriendlyURL(url)}`);
debugMessages.forEach((msg) => {
if (Array.isArray(msg)) {
logger.log(...msg);
}
else {
logger.log(msg);
}
});
logger.groupEnd();
}
// Wrap in try and catch in case the handle method throws a synchronous
// error. It should still callback to the catch handler.
let responsePromise;
try {
responsePromise = handler.handle({ url, request, event, params });
}
catch (err) {
responsePromise = Promise.reject(err);
}
if (responsePromise instanceof Promise && this._catchHandler) {
responsePromise = responsePromise.catch((err) => {
if (process.env.NODE_ENV !== 'production') {
// Still include URL here as it will be async from the console group
// and may not make sense without the URL
logger.groupCollapsed(`Error thrown when responding to: ` +
` ${getFriendlyURL(url)}. Falling back to Catch Handler.`);
logger.error(`Error thrown by:`, route);
logger.error(err);
logger.groupEnd();
}
return this._catchHandler.handle({ url, request, event });
});
}
return responsePromise;
}
/**
* Checks a request and URL (and optionally an event) against the list of
* registered routes, and if there's a match, returns the corresponding
* route along with any params generated by the match.
*
* @param {Object} options
* @param {URL} options.url
* @param {Request} options.request The request to match.
* @param {Event} [options.event] The corresponding event (unless N/A).
* @return {Object} An object with `route` and `params` properties.
* They are populated if a matching route was found or `undefined`
* otherwise.
*/
findMatchingRoute({ url, request, event }) {
if (process.env.NODE_ENV !== 'production') {
assert.isInstance(url, URL, {
moduleName: 'workbox-routing',
className: 'Router',
funcName: 'findMatchingRoute',
paramName: 'options.url',
});
assert.isInstance(request, Request, {
moduleName: 'workbox-routing',
className: 'Router',
funcName: 'findMatchingRoute',
paramName: 'options.request',
});
}
const routes = this._routes.get(request.method) || [];
for (const route of routes) {
let params;
const matchResult = route.match({ url, request, event });
if (matchResult) {
// See https://github.com/GoogleChrome/workbox/issues/2079
params = matchResult;
if (Array.isArray(matchResult) && matchResult.length === 0) {
// Instead of passing an empty array in as params, use undefined.
params = undefined;
}
else if ((matchResult.constructor === Object &&
Object.keys(matchResult).length === 0)) {
// Instead of passing an empty object in as params, use undefined.
params = undefined;
}
else if (typeof matchResult === 'boolean') {
// For the boolean value true (rather than just something truth-y),
// don't set params.
// See https://github.com/GoogleChrome/workbox/pull/2134#issuecomment-513924353
params = undefined;
}
// Return early if have a match.
return { route, params };
}
}
// If no match was found above, return and empty object.
return {};
}
/**
* Define 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 {module:workbox-routing~handlerCallback} handler A callback
* function that returns a Promise resulting in a Response.
*/
setDefaultHandler(handler) {
this._defaultHandler = normalizeHandler(handler);
}
/**
* If a Route throws an error while handling a request, this `handler`
* will be called and given a chance to provide a response.
*
* @param {module:workbox-routing~handlerCallback} handler A callback
* function that returns a Promise resulting in a Response.
*/
setCatchHandler(handler) {
this._catchHandler = normalizeHandler(handler);
}
/**
* Registers a route with the router.
*
* @param {module:workbox-routing.Route} route The route to register.
*/
registerRoute(route) {
if (process.env.NODE_ENV !== 'production') {
assert.isType(route, 'object', {
moduleName: 'workbox-routing',
className: 'Router',
funcName: 'registerRoute',
paramName: 'route',
});
assert.hasMethod(route, 'match', {
moduleName: 'workbox-routing',
className: 'Router',
funcName: 'registerRoute',
paramName: 'route',
});
assert.isType(route.handler, 'object', {
moduleName: 'workbox-routing',
className: 'Router',
funcName: 'registerRoute',
paramName: 'route',
});
assert.hasMethod(route.handler, 'handle', {
moduleName: 'workbox-routing',
className: 'Router',
funcName: 'registerRoute',
paramName: 'route.handler',
});
assert.isType(route.method, 'string', {
moduleName: 'workbox-routing',
className: 'Router',
funcName: 'registerRoute',
paramName: 'route.method',
});
}
if (!this._routes.has(route.method)) {
this._routes.set(route.method, []);
}
// Give precedence to all of the earlier routes by adding this additional
// route to the end of the array.
this._routes.get(route.method).push(route);
}
/**
* Unregisters a route with the router.
*
* @param {module:workbox-routing.Route} route The route to unregister.
*/
unregisterRoute(route) {
if (!this._routes.has(route.method)) {
throw new WorkboxError('unregister-route-but-not-found-with-method', {
method: route.method,
});
}
const routeIndex = this._routes.get(route.method).indexOf(route);
if (routeIndex > -1) {
this._routes.get(route.method).splice(routeIndex, 1);
}
else {
throw new WorkboxError('unregister-route-route-not-registered');
}
}
}
export { Router };

1
web/node_modules/workbox-routing/Router.mjs generated vendored Normal file
View file

@ -0,0 +1 @@
export * from './Router.js';

49
web/node_modules/workbox-routing/_types.d.ts generated vendored Normal file
View file

@ -0,0 +1,49 @@
import { RouteHandler, RouteHandlerObject, RouteHandlerCallback, RouteHandlerCallbackOptions, RouteMatchCallback, RouteMatchCallbackOptions } from 'workbox-core/types.js';
import './_version.js';
export { RouteHandler as Handler, RouteHandlerObject as HandlerObject, RouteHandlerCallback as HandlerCallback, RouteHandlerCallbackOptions as HandlerCallbackOptions, RouteMatchCallback as MatchCallback, RouteMatchCallbackOptions as MatchCallbackOptions, };
/**
* The "match" callback is used to determine if a `Route` should apply for a
* particular URL. When matching occurs in response to a fetch event from the
* client, the `event` and `request` objects are supplied in addition to the
* URL. However, since the match callback can be invoked outside of a fetch
* event, matching logic should not assume the `event` or `request` objects
* will always be available (unlike URL, which is always available).
* If the match callback returns a truthy value, the matching route's
* [handler callback]{@link module:workbox-routing~handlerCallback} will be
* invoked immediately. If the value returned is a non-empty array or object,
* that value will be set on the handler's `context.params` argument.
*
* @callback ~matchCallback
* @param {Object} context
* @param {URL} context.url The request's URL.
* @param {Request} [context.request] The corresponding request,
* if available.
* @param {FetchEvent} [context.event] The corresponding event that triggered
* the request, if available.
* @return {*} To signify a match, return a truthy value.
*
* @memberof module:workbox-routing
*/
/**
* The "handler" callback is invoked whenever a `Router` matches a URL to a
* `Route` via its [match]{@link module:workbox-routing~handlerCallback}
* callback. This callback should return a Promise that resolves with a
* `Response`.
*
* If a non-empty array or object is returned by the
* [match callback]{@link module:workbox-routing~matchCallback} it
* will be passed in as the handler's `context.params` argument.
*
* @callback ~handlerCallback
* @param {Object} context
* @param {Request|string} context.request The corresponding request.
* @param {URL} [context.url] The URL that matched, if available.
* @param {FetchEvent} [context.event] The corresponding event that triggered
* the request, if available.
* @param {Object} [context.params] Array or Object parameters returned by the
* Route's [match callback]{@link module:workbox-routing~matchCallback}.
* This will be undefined if an empty array or object were returned.
* @return {Promise<Response>} The response that will fulfill the request.
*
* @memberof module:workbox-routing
*/

60
web/node_modules/workbox-routing/_types.js generated vendored Normal file
View file

@ -0,0 +1,60 @@
/*
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 './_version.js';
// * * * IMPORTANT! * * *
// ------------------------------------------------------------------------- //
// jdsoc type definitions cannot be declared above TypeScript definitions or
// they'll be stripped from the built `.js` files, and they'll only be in the
// `d.ts` files, which aren't read by the jsdoc generator. As a result we
// have to put declare them below.
/**
* The "match" callback is used to determine if a `Route` should apply for a
* particular URL. When matching occurs in response to a fetch event from the
* client, the `event` and `request` objects are supplied in addition to the
* URL. However, since the match callback can be invoked outside of a fetch
* event, matching logic should not assume the `event` or `request` objects
* will always be available (unlike URL, which is always available).
* If the match callback returns a truthy value, the matching route's
* [handler callback]{@link module:workbox-routing~handlerCallback} will be
* invoked immediately. If the value returned is a non-empty array or object,
* that value will be set on the handler's `context.params` argument.
*
* @callback ~matchCallback
* @param {Object} context
* @param {URL} context.url The request's URL.
* @param {Request} [context.request] The corresponding request,
* if available.
* @param {FetchEvent} [context.event] The corresponding event that triggered
* the request, if available.
* @return {*} To signify a match, return a truthy value.
*
* @memberof module:workbox-routing
*/
/**
* The "handler" callback is invoked whenever a `Router` matches a URL to a
* `Route` via its [match]{@link module:workbox-routing~handlerCallback}
* callback. This callback should return a Promise that resolves with a
* `Response`.
*
* If a non-empty array or object is returned by the
* [match callback]{@link module:workbox-routing~matchCallback} it
* will be passed in as the handler's `context.params` argument.
*
* @callback ~handlerCallback
* @param {Object} context
* @param {Request|string} context.request The corresponding request.
* @param {URL} [context.url] The URL that matched, if available.
* @param {FetchEvent} [context.event] The corresponding event that triggered
* the request, if available.
* @param {Object} [context.params] Array or Object parameters returned by the
* Route's [match callback]{@link module:workbox-routing~matchCallback}.
* This will be undefined if an empty array or object were returned.
* @return {Promise<Response>} The response that will fulfill the request.
*
* @memberof module:workbox-routing
*/

1
web/node_modules/workbox-routing/_types.mjs generated vendored Normal file
View file

@ -0,0 +1 @@
export * from './_types.js';

0
web/node_modules/workbox-routing/_version.d.ts generated vendored Normal file
View file

6
web/node_modules/workbox-routing/_version.js generated vendored Normal file
View file

@ -0,0 +1,6 @@
"use strict";
// @ts-ignore
try {
self['workbox:routing:5.1.4'] && _();
}
catch (e) { }

1
web/node_modules/workbox-routing/_version.mjs generated vendored Normal file
View file

@ -0,0 +1 @@
try{self['workbox:routing:5.1.4']&&_()}catch(e){}// eslint-disable-line

923
web/node_modules/workbox-routing/build/workbox-routing.dev.js generated vendored Normal file
View file

@ -0,0 +1,923 @@
this.workbox = this.workbox || {};
this.workbox.routing = (function (exports, assert_js, logger_js, WorkboxError_js, getFriendlyURL_js) {
'use strict';
try {
self['workbox:routing:5.1.4'] && _();
} catch (e) {}
/*
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.
*/
/**
* The default HTTP method, 'GET', used when there's no specific method
* configured for a route.
*
* @type {string}
*
* @private
*/
const defaultMethod = 'GET';
/**
* The list of valid HTTP methods associated with requests that could be routed.
*
* @type {Array<string>}
*
* @private
*/
const validMethods = ['DELETE', 'GET', 'HEAD', 'PATCH', 'POST', 'PUT'];
/*
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.
*/
/**
* @param {function()|Object} handler Either a function, or an object with a
* 'handle' method.
* @return {Object} An object with a handle method.
*
* @private
*/
const normalizeHandler = handler => {
if (handler && typeof handler === 'object') {
{
assert_js.assert.hasMethod(handler, 'handle', {
moduleName: 'workbox-routing',
className: 'Route',
funcName: 'constructor',
paramName: 'handler'
});
}
return handler;
} else {
{
assert_js.assert.isType(handler, 'function', {
moduleName: 'workbox-routing',
className: 'Route',
funcName: 'constructor',
paramName: 'handler'
});
}
return {
handle: handler
};
}
};
/*
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.
*/
/**
* 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`.
*
* @memberof module:workbox-routing
*/
class Route {
/**
* Constructor for Route class.
*
* @param {module:workbox-routing~matchCallback} match
* A callback function that determines whether the route matches a given
* `fetch` event by returning a non-falsy value.
* @param {module:workbox-routing~handlerCallback} handler A callback
* function that returns a Promise resolving to a Response.
* @param {string} [method='GET'] The HTTP method to match the Route
* against.
*/
constructor(match, handler, method = defaultMethod) {
{
assert_js.assert.isType(match, 'function', {
moduleName: 'workbox-routing',
className: 'Route',
funcName: 'constructor',
paramName: 'match'
});
if (method) {
assert_js.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;
}
}
/*
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.
*/
/**
* NavigationRoute makes it easy to create a
* [Route]{@link module:workbox-routing.Route} that matches for browser
* [navigation requests]{@link 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`]{@link 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.
*
* @memberof module:workbox-routing
* @extends module:workbox-routing.Route
*/
class NavigationRoute extends Route {
/**
* 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`]{@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLHyperlinkElementUtils/pathname}
* and [`search`]{@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLHyperlinkElementUtils/search}
* portions of the requested URL.
*
* @param {module:workbox-routing~handlerCallback} handler A callback
* function that returns a Promise resulting in a Response.
* @param {Object} options
* @param {Array<RegExp>} [options.denylist] If any of these patterns match,
* the route will not handle the request (even if a allowlist RegExp matches).
* @param {Array<RegExp>} [options.allowlist=[/./]] 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).
*/
constructor(handler, {
allowlist = [/./],
denylist = []
} = {}) {
{
assert_js.assert.isArrayOfClass(allowlist, RegExp, {
moduleName: 'workbox-routing',
className: 'NavigationRoute',
funcName: 'constructor',
paramName: 'options.allowlist'
});
assert_js.assert.isArrayOfClass(denylist, RegExp, {
moduleName: 'workbox-routing',
className: 'NavigationRoute',
funcName: 'constructor',
paramName: 'options.denylist'
});
}
super(options => this._match(options), handler);
this._allowlist = allowlist;
this._denylist = denylist;
}
/**
* Routes match handler.
*
* @param {Object} options
* @param {URL} options.url
* @param {Request} options.request
* @return {boolean}
*
* @private
*/
_match({
url,
request
}) {
if (request && request.mode !== 'navigate') {
return false;
}
const pathnameAndSearch = url.pathname + url.search;
for (const regExp of this._denylist) {
if (regExp.test(pathnameAndSearch)) {
{
logger_js.logger.log(`The navigation route ${pathnameAndSearch} is not ` + `being used, since the URL matches this denylist pattern: ` + `${regExp}`);
}
return false;
}
}
if (this._allowlist.some(regExp => regExp.test(pathnameAndSearch))) {
{
logger_js.logger.debug(`The navigation route ${pathnameAndSearch} ` + `is being used.`);
}
return true;
}
{
logger_js.logger.log(`The navigation route ${pathnameAndSearch} is not ` + `being used, since the URL being navigated to doesn't ` + `match the allowlist.`);
}
return false;
}
}
/*
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.
*/
/**
* RegExpRoute makes it easy to create a regular expression based
* [Route]{@link module:workbox-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.
*
* [See the module docs for info.]{@link https://developers.google.com/web/tools/workbox/modules/workbox-routing}
*
* @memberof module:workbox-routing
* @extends module:workbox-routing.Route
*/
class RegExpRoute extends Route {
/**
* If the regular expression contains
* [capture groups]{@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp#grouping-back-references},
* the captured values will be passed to the
* [handler's]{@link module:workbox-routing~handlerCallback} `params`
* argument.
*
* @param {RegExp} regExp The regular expression to match against URLs.
* @param {module:workbox-routing~handlerCallback} handler A callback
* function that returns a Promise resulting in a Response.
* @param {string} [method='GET'] The HTTP method to match the Route
* against.
*/
constructor(regExp, handler, method) {
{
assert_js.assert.isInstance(regExp, RegExp, {
moduleName: 'workbox-routing',
className: 'RegExpRoute',
funcName: 'constructor',
paramName: 'pattern'
});
}
const match = ({
url
}) => {
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) {
{
logger_js.logger.debug(`The regular expression '${regExp}' only partially matched ` + `against the cross-origin URL '${url}'. 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);
}
}
/*
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.
*/
/**
* The Router can be used to process a FetchEvent through one or more
* [Routes]{@link module:workbox-routing.Route} responding with a Request if
* a matching route exists.
*
* If no route matches a given a request, the Router will use a "default"
* handler if one is defined.
*
* Should the matching Route throw an error, the Router will use a "catch"
* handler if one is defined to gracefully deal with issues and respond with a
* Request.
*
* If a request matches multiple routes, the **earliest** registered route will
* be used to respond to the request.
*
* @memberof module:workbox-routing
*/
class Router {
/**
* Initializes a new Router.
*/
constructor() {
this._routes = new Map();
}
/**
* @return {Map<string, Array<module:workbox-routing.Route>>} routes A `Map` of HTTP
* method name ('GET', etc.) to an array of all the corresponding `Route`
* instances that are registered.
*/
get routes() {
return this._routes;
}
/**
* Adds a fetch event listener to respond to events when a route matches
* the event's request.
*/
addFetchListener() {
// See https://github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705
self.addEventListener('fetch', event => {
const {
request
} = event;
const responsePromise = this.handleRequest({
request,
event
});
if (responsePromise) {
event.respondWith(responsePromise);
}
});
}
/**
* Adds a message event listener for URLs to cache from the window.
* This is useful to cache resources loaded on the page prior to when the
* service worker started controlling it.
*
* The format of the message data sent from the window should be as follows.
* Where the `urlsToCache` array may consist of URL strings or an array of
* URL string + `requestInit` object (the same as you'd pass to `fetch()`).
*
* ```
* {
* type: 'CACHE_URLS',
* payload: {
* urlsToCache: [
* './script1.js',
* './script2.js',
* ['./script3.js', {mode: 'no-cors'}],
* ],
* },
* }
* ```
*/
addCacheListener() {
// See https://github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705
self.addEventListener('message', event => {
if (event.data && event.data.type === 'CACHE_URLS') {
const {
payload
} = event.data;
{
logger_js.logger.debug(`Caching URLs from the window`, payload.urlsToCache);
}
const requestPromises = Promise.all(payload.urlsToCache.map(entry => {
if (typeof entry === 'string') {
entry = [entry];
}
const request = new Request(...entry);
return this.handleRequest({
request
}); // TODO(philipwalton): TypeScript errors without this typecast for
// some reason (probably a bug). The real type here should work but
// doesn't: `Array<Promise<Response> | undefined>`.
})); // TypeScript
event.waitUntil(requestPromises); // If a MessageChannel was used, reply to the message on success.
if (event.ports && event.ports[0]) {
requestPromises.then(() => event.ports[0].postMessage(true));
}
}
});
}
/**
* Apply the routing rules to a FetchEvent object to get a Response from an
* appropriate Route's handler.
*
* @param {Object} options
* @param {Request} options.request The request to handle (this is usually
* from a fetch event, but it does not have to be).
* @param {FetchEvent} [options.event] The event that triggered the request,
* if applicable.
* @return {Promise<Response>|undefined} A promise is returned if a
* registered route can handle the request. If there is no matching
* route and there's no `defaultHandler`, `undefined` is returned.
*/
handleRequest({
request,
event
}) {
{
assert_js.assert.isInstance(request, Request, {
moduleName: 'workbox-routing',
className: 'Router',
funcName: 'handleRequest',
paramName: 'options.request'
});
}
const url = new URL(request.url, location.href);
if (!url.protocol.startsWith('http')) {
{
logger_js.logger.debug(`Workbox Router only supports URLs that start with 'http'.`);
}
return;
}
const {
params,
route
} = this.findMatchingRoute({
url,
request,
event
});
let handler = route && route.handler;
const debugMessages = [];
{
if (handler) {
debugMessages.push([`Found a route to handle this request:`, route]);
if (params) {
debugMessages.push([`Passing the following params to the route's handler:`, params]);
}
}
} // If we don't have a handler because there was no matching route, then
// fall back to defaultHandler if that's defined.
if (!handler && this._defaultHandler) {
{
debugMessages.push(`Failed to find a matching route. Falling ` + `back to the default handler.`);
}
handler = this._defaultHandler;
}
if (!handler) {
{
// No handler so Workbox will do nothing. If logs is set of debug
// i.e. verbose, we should print out this information.
logger_js.logger.debug(`No route found for: ${getFriendlyURL_js.getFriendlyURL(url)}`);
}
return;
}
{
// We have a handler, meaning Workbox is going to handle the route.
// print the routing details to the console.
logger_js.logger.groupCollapsed(`Router is responding to: ${getFriendlyURL_js.getFriendlyURL(url)}`);
debugMessages.forEach(msg => {
if (Array.isArray(msg)) {
logger_js.logger.log(...msg);
} else {
logger_js.logger.log(msg);
}
});
logger_js.logger.groupEnd();
} // Wrap in try and catch in case the handle method throws a synchronous
// error. It should still callback to the catch handler.
let responsePromise;
try {
responsePromise = handler.handle({
url,
request,
event,
params
});
} catch (err) {
responsePromise = Promise.reject(err);
}
if (responsePromise instanceof Promise && this._catchHandler) {
responsePromise = responsePromise.catch(err => {
{
// Still include URL here as it will be async from the console group
// and may not make sense without the URL
logger_js.logger.groupCollapsed(`Error thrown when responding to: ` + ` ${getFriendlyURL_js.getFriendlyURL(url)}. Falling back to Catch Handler.`);
logger_js.logger.error(`Error thrown by:`, route);
logger_js.logger.error(err);
logger_js.logger.groupEnd();
}
return this._catchHandler.handle({
url,
request,
event
});
});
}
return responsePromise;
}
/**
* Checks a request and URL (and optionally an event) against the list of
* registered routes, and if there's a match, returns the corresponding
* route along with any params generated by the match.
*
* @param {Object} options
* @param {URL} options.url
* @param {Request} options.request The request to match.
* @param {Event} [options.event] The corresponding event (unless N/A).
* @return {Object} An object with `route` and `params` properties.
* They are populated if a matching route was found or `undefined`
* otherwise.
*/
findMatchingRoute({
url,
request,
event
}) {
{
assert_js.assert.isInstance(url, URL, {
moduleName: 'workbox-routing',
className: 'Router',
funcName: 'findMatchingRoute',
paramName: 'options.url'
});
assert_js.assert.isInstance(request, Request, {
moduleName: 'workbox-routing',
className: 'Router',
funcName: 'findMatchingRoute',
paramName: 'options.request'
});
}
const routes = this._routes.get(request.method) || [];
for (const route of routes) {
let params;
const matchResult = route.match({
url,
request,
event
});
if (matchResult) {
// See https://github.com/GoogleChrome/workbox/issues/2079
params = matchResult;
if (Array.isArray(matchResult) && matchResult.length === 0) {
// Instead of passing an empty array in as params, use undefined.
params = undefined;
} else if (matchResult.constructor === Object && Object.keys(matchResult).length === 0) {
// Instead of passing an empty object in as params, use undefined.
params = undefined;
} else if (typeof matchResult === 'boolean') {
// For the boolean value true (rather than just something truth-y),
// don't set params.
// See https://github.com/GoogleChrome/workbox/pull/2134#issuecomment-513924353
params = undefined;
} // Return early if have a match.
return {
route,
params
};
}
} // If no match was found above, return and empty object.
return {};
}
/**
* Define 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 {module:workbox-routing~handlerCallback} handler A callback
* function that returns a Promise resulting in a Response.
*/
setDefaultHandler(handler) {
this._defaultHandler = normalizeHandler(handler);
}
/**
* If a Route throws an error while handling a request, this `handler`
* will be called and given a chance to provide a response.
*
* @param {module:workbox-routing~handlerCallback} handler A callback
* function that returns a Promise resulting in a Response.
*/
setCatchHandler(handler) {
this._catchHandler = normalizeHandler(handler);
}
/**
* Registers a route with the router.
*
* @param {module:workbox-routing.Route} route The route to register.
*/
registerRoute(route) {
{
assert_js.assert.isType(route, 'object', {
moduleName: 'workbox-routing',
className: 'Router',
funcName: 'registerRoute',
paramName: 'route'
});
assert_js.assert.hasMethod(route, 'match', {
moduleName: 'workbox-routing',
className: 'Router',
funcName: 'registerRoute',
paramName: 'route'
});
assert_js.assert.isType(route.handler, 'object', {
moduleName: 'workbox-routing',
className: 'Router',
funcName: 'registerRoute',
paramName: 'route'
});
assert_js.assert.hasMethod(route.handler, 'handle', {
moduleName: 'workbox-routing',
className: 'Router',
funcName: 'registerRoute',
paramName: 'route.handler'
});
assert_js.assert.isType(route.method, 'string', {
moduleName: 'workbox-routing',
className: 'Router',
funcName: 'registerRoute',
paramName: 'route.method'
});
}
if (!this._routes.has(route.method)) {
this._routes.set(route.method, []);
} // Give precedence to all of the earlier routes by adding this additional
// route to the end of the array.
this._routes.get(route.method).push(route);
}
/**
* Unregisters a route with the router.
*
* @param {module:workbox-routing.Route} route The route to unregister.
*/
unregisterRoute(route) {
if (!this._routes.has(route.method)) {
throw new WorkboxError_js.WorkboxError('unregister-route-but-not-found-with-method', {
method: route.method
});
}
const routeIndex = this._routes.get(route.method).indexOf(route);
if (routeIndex > -1) {
this._routes.get(route.method).splice(routeIndex, 1);
} else {
throw new WorkboxError_js.WorkboxError('unregister-route-route-not-registered');
}
}
}
/*
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.
*/
let defaultRouter;
/**
* Creates a new, singleton Router instance if one does not exist. If one
* does already exist, that instance is returned.
*
* @private
* @return {Router}
*/
const getOrCreateDefaultRouter = () => {
if (!defaultRouter) {
defaultRouter = new Router(); // The helpers that use the default Router assume these listeners exist.
defaultRouter.addFetchListener();
defaultRouter.addCacheListener();
}
return defaultRouter;
};
/*
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.
*/
/**
* Easily register a RegExp, string, or function with a caching
* strategy to a singleton Router instance.
*
* This method will generate a Route for you if needed and
* call [registerRoute()]{@link module:workbox-routing.Router#registerRoute}.
*
* @param {RegExp|string|module:workbox-routing.Route~matchCallback|module:workbox-routing.Route} capture
* If the capture param is a `Route`, all other arguments will be ignored.
* @param {module:workbox-routing~handlerCallback} [handler] A callback
* function that returns a Promise resulting in a Response. This parameter
* is required if `capture` is not a `Route` object.
* @param {string} [method='GET'] The HTTP method to match the Route
* against.
* @return {module:workbox-routing.Route} The generated `Route`(Useful for
* unregistering).
*
* @memberof module:workbox-routing
*/
function registerRoute(capture, handler, method) {
let route;
if (typeof capture === 'string') {
const captureUrl = new URL(capture, location.href);
{
if (!(capture.startsWith('/') || capture.startsWith('http'))) {
throw new WorkboxError_js.WorkboxError('invalid-string', {
moduleName: 'workbox-routing',
funcName: 'registerRoute',
paramName: 'capture'
});
} // We want to check if Express-style wildcards are in the pathname only.
// TODO: Remove this log message in v4.
const valueToCheck = capture.startsWith('http') ? captureUrl.pathname : capture; // See https://github.com/pillarjs/path-to-regexp#parameters
const wildcards = '[*:?+]';
if (new RegExp(`${wildcards}`).exec(valueToCheck)) {
logger_js.logger.debug(`The '$capture' parameter contains an Express-style wildcard ` + `character (${wildcards}). Strings are now always interpreted as ` + `exact matches; use a RegExp for partial or wildcard matches.`);
}
}
const matchCallback = ({
url
}) => {
{
if (url.pathname === captureUrl.pathname && url.origin !== captureUrl.origin) {
logger_js.logger.debug(`${capture} only partially matches the cross-origin URL ` + `${url}. This route will only handle cross-origin requests ` + `if they match the entire URL.`);
}
}
return url.href === captureUrl.href;
}; // If `capture` is a string then `handler` and `method` must be present.
route = new Route(matchCallback, handler, method);
} else if (capture instanceof RegExp) {
// If `capture` is a `RegExp` then `handler` and `method` must be present.
route = new RegExpRoute(capture, handler, method);
} else if (typeof capture === 'function') {
// If `capture` is a function then `handler` and `method` must be present.
route = new Route(capture, handler, method);
} else if (capture instanceof Route) {
route = capture;
} else {
throw new WorkboxError_js.WorkboxError('unsupported-route-type', {
moduleName: 'workbox-routing',
funcName: 'registerRoute',
paramName: 'capture'
});
}
const defaultRouter = getOrCreateDefaultRouter();
defaultRouter.registerRoute(route);
return route;
}
/*
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.
*/
/**
* If a Route throws an error while handling a request, this `handler`
* will be called and given a chance to provide a response.
*
* @param {module:workbox-routing~handlerCallback} handler A callback
* function that returns a Promise resulting in a Response.
*
* @memberof module:workbox-routing
*/
function setCatchHandler(handler) {
const defaultRouter = getOrCreateDefaultRouter();
defaultRouter.setCatchHandler(handler);
}
/*
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.
*/
/**
* Define 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 {module:workbox-routing~handlerCallback} handler A callback
* function that returns a Promise resulting in a Response.
*
* @memberof module:workbox-routing
*/
function setDefaultHandler(handler) {
const defaultRouter = getOrCreateDefaultRouter();
defaultRouter.setDefaultHandler(handler);
}
exports.NavigationRoute = NavigationRoute;
exports.RegExpRoute = RegExpRoute;
exports.Route = Route;
exports.Router = Router;
exports.registerRoute = registerRoute;
exports.setCatchHandler = setCatchHandler;
exports.setDefaultHandler = setDefaultHandler;
return exports;
}({}, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private));
//# sourceMappingURL=workbox-routing.dev.js.map

1
web/node_modules/workbox-routing/build/workbox-routing.dev.js.map generated vendored Normal file
View file

File diff suppressed because one or more lines are too long

2
web/node_modules/workbox-routing/build/workbox-routing.prod.js generated vendored Normal file
View file

@ -0,0 +1,2 @@
this.workbox=this.workbox||{},this.workbox.routing=function(t,e){"use strict";try{self["workbox:routing:5.1.4"]&&_()}catch(t){}const s=t=>t&&"object"==typeof t?t:{handle:t};class r{constructor(t,e,r="GET"){this.handler=s(e),this.match=t,this.method=r}}class n extends r{constructor(t,e,s){super(({url:e})=>{const s=t.exec(e.href);if(s&&(e.origin===location.origin||0===s.index))return s.slice(1)},e,s)}}class o{constructor(){this.t=new Map}get routes(){return this.t}addFetchListener(){self.addEventListener("fetch",t=>{const{request:e}=t,s=this.handleRequest({request:e,event:t});s&&t.respondWith(s)})}addCacheListener(){self.addEventListener("message",t=>{if(t.data&&"CACHE_URLS"===t.data.type){const{payload:e}=t.data,s=Promise.all(e.urlsToCache.map(t=>{"string"==typeof t&&(t=[t]);const e=new Request(...t);return this.handleRequest({request:e})}));t.waitUntil(s),t.ports&&t.ports[0]&&s.then(()=>t.ports[0].postMessage(!0))}})}handleRequest({request:t,event:e}){const s=new URL(t.url,location.href);if(!s.protocol.startsWith("http"))return;const{params:r,route:n}=this.findMatchingRoute({url:s,request:t,event:e});let o,i=n&&n.handler;if(!i&&this.s&&(i=this.s),i){try{o=i.handle({url:s,request:t,event:e,params:r})}catch(t){o=Promise.reject(t)}return o instanceof Promise&&this.o&&(o=o.catch(r=>this.o.handle({url:s,request:t,event:e}))),o}}findMatchingRoute({url:t,request:e,event:s}){const r=this.t.get(e.method)||[];for(const n of r){let r;const o=n.match({url:t,request:e,event:s});if(o)return r=o,(Array.isArray(o)&&0===o.length||o.constructor===Object&&0===Object.keys(o).length||"boolean"==typeof o)&&(r=void 0),{route:n,params:r}}return{}}setDefaultHandler(t){this.s=s(t)}setCatchHandler(t){this.o=s(t)}registerRoute(t){this.t.has(t.method)||this.t.set(t.method,[]),this.t.get(t.method).push(t)}unregisterRoute(t){if(!this.t.has(t.method))throw new e.WorkboxError("unregister-route-but-not-found-with-method",{method:t.method});const s=this.t.get(t.method).indexOf(t);if(!(s>-1))throw new e.WorkboxError("unregister-route-route-not-registered");this.t.get(t.method).splice(s,1)}}let i;const u=()=>(i||(i=new o,i.addFetchListener(),i.addCacheListener()),i);return t.NavigationRoute=class extends r{constructor(t,{allowlist:e=[/./],denylist:s=[]}={}){super(t=>this.i(t),t),this.u=e,this.h=s}i({url:t,request:e}){if(e&&"navigate"!==e.mode)return!1;const s=t.pathname+t.search;for(const t of this.h)if(t.test(s))return!1;return!!this.u.some(t=>t.test(s))}},t.RegExpRoute=n,t.Route=r,t.Router=o,t.registerRoute=function(t,s,o){let i;if("string"==typeof t){const e=new URL(t,location.href);i=new r(({url:t})=>t.href===e.href,s,o)}else if(t instanceof RegExp)i=new n(t,s,o);else if("function"==typeof t)i=new r(t,s,o);else{if(!(t instanceof r))throw new e.WorkboxError("unsupported-route-type",{moduleName:"workbox-routing",funcName:"registerRoute",paramName:"capture"});i=t}return u().registerRoute(i),i},t.setCatchHandler=function(t){u().setCatchHandler(t)},t.setDefaultHandler=function(t){u().setDefaultHandler(t)},t}({},workbox.core._private);
//# sourceMappingURL=workbox-routing.prod.js.map

1
web/node_modules/workbox-routing/build/workbox-routing.prod.js.map generated vendored Normal file
View file

File diff suppressed because one or more lines are too long

12
web/node_modules/workbox-routing/index.d.ts generated vendored Normal file
View file

@ -0,0 +1,12 @@
import { NavigationRoute } from './NavigationRoute.js';
import { RegExpRoute } from './RegExpRoute.js';
import { registerRoute } from './registerRoute.js';
import { Route } from './Route.js';
import { Router } from './Router.js';
import { setCatchHandler } from './setCatchHandler.js';
import { setDefaultHandler } from './setDefaultHandler.js';
import './_version.js';
/**
* @module workbox-routing
*/
export { NavigationRoute, RegExpRoute, registerRoute, Route, Router, setCatchHandler, setDefaultHandler, };

19
web/node_modules/workbox-routing/index.js generated vendored Normal file
View file

@ -0,0 +1,19 @@
/*
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 { NavigationRoute } from './NavigationRoute.js';
import { RegExpRoute } from './RegExpRoute.js';
import { registerRoute } from './registerRoute.js';
import { Route } from './Route.js';
import { Router } from './Router.js';
import { setCatchHandler } from './setCatchHandler.js';
import { setDefaultHandler } from './setDefaultHandler.js';
import './_version.js';
/**
* @module workbox-routing
*/
export { NavigationRoute, RegExpRoute, registerRoute, Route, Router, setCatchHandler, setDefaultHandler, };

1
web/node_modules/workbox-routing/index.mjs generated vendored Normal file
View file

@ -0,0 +1 @@
export * from './index.js';

34
web/node_modules/workbox-routing/package.json generated vendored Normal file
View file

@ -0,0 +1,34 @@
{
"name": "workbox-routing",
"version": "5.1.4",
"license": "MIT",
"author": "Google's Web DevRel Team",
"description": "A service worker helper library to route request URLs to handlers.",
"repository": "googlechrome/workbox",
"bugs": "https://github.com/googlechrome/workbox/issues",
"homepage": "https://github.com/GoogleChrome/workbox",
"keywords": [
"workbox",
"workboxjs",
"service worker",
"sw",
"router",
"routing"
],
"scripts": {
"build": "gulp build-packages --package workbox-routing",
"version": "npm run build",
"prepare": "npm run build"
},
"workbox": {
"browserNamespace": "workbox.routing",
"packageType": "browser"
},
"main": "index.js",
"module": "index.mjs",
"types": "index.d.ts",
"dependencies": {
"workbox-core": "^5.1.4"
},
"gitHead": "a95b6fd489c2a66574f1655b2de3acd2ece35fb3"
}

25
web/node_modules/workbox-routing/registerRoute.d.ts generated vendored Normal file
View file

@ -0,0 +1,25 @@
import { Route } from './Route.js';
import { HTTPMethod } from './utils/constants.js';
import { Handler, MatchCallback } from './_types.js';
import './_version.js';
/**
* Easily register a RegExp, string, or function with a caching
* strategy to a singleton Router instance.
*
* This method will generate a Route for you if needed and
* call [registerRoute()]{@link module:workbox-routing.Router#registerRoute}.
*
* @param {RegExp|string|module:workbox-routing.Route~matchCallback|module:workbox-routing.Route} capture
* If the capture param is a `Route`, all other arguments will be ignored.
* @param {module:workbox-routing~handlerCallback} [handler] A callback
* function that returns a Promise resulting in a Response. This parameter
* is required if `capture` is not a `Route` object.
* @param {string} [method='GET'] The HTTP method to match the Route
* against.
* @return {module:workbox-routing.Route} The generated `Route`(Useful for
* unregistering).
*
* @memberof module:workbox-routing
*/
declare function registerRoute(capture: RegExp | string | MatchCallback | Route, handler?: Handler, method?: HTTPMethod): Route;
export { registerRoute };

93
web/node_modules/workbox-routing/registerRoute.js generated vendored Normal file
View file

@ -0,0 +1,93 @@
/*
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 'workbox-core/_private/logger.js';
import { WorkboxError } from 'workbox-core/_private/WorkboxError.js';
import { Route } from './Route.js';
import { RegExpRoute } from './RegExpRoute.js';
import { getOrCreateDefaultRouter } from './utils/getOrCreateDefaultRouter.js';
import './_version.js';
/**
* Easily register a RegExp, string, or function with a caching
* strategy to a singleton Router instance.
*
* This method will generate a Route for you if needed and
* call [registerRoute()]{@link module:workbox-routing.Router#registerRoute}.
*
* @param {RegExp|string|module:workbox-routing.Route~matchCallback|module:workbox-routing.Route} capture
* If the capture param is a `Route`, all other arguments will be ignored.
* @param {module:workbox-routing~handlerCallback} [handler] A callback
* function that returns a Promise resulting in a Response. This parameter
* is required if `capture` is not a `Route` object.
* @param {string} [method='GET'] The HTTP method to match the Route
* against.
* @return {module:workbox-routing.Route} The generated `Route`(Useful for
* unregistering).
*
* @memberof module:workbox-routing
*/
function registerRoute(capture, handler, method) {
let route;
if (typeof capture === 'string') {
const captureUrl = new URL(capture, location.href);
if (process.env.NODE_ENV !== 'production') {
if (!(capture.startsWith('/') || capture.startsWith('http'))) {
throw new WorkboxError('invalid-string', {
moduleName: 'workbox-routing',
funcName: 'registerRoute',
paramName: 'capture',
});
}
// We want to check if Express-style wildcards are in the pathname only.
// TODO: Remove this log message in v4.
const valueToCheck = capture.startsWith('http') ?
captureUrl.pathname : capture;
// See https://github.com/pillarjs/path-to-regexp#parameters
const wildcards = '[*:?+]';
if ((new RegExp(`${wildcards}`)).exec(valueToCheck)) {
logger.debug(`The '$capture' parameter contains an Express-style wildcard ` +
`character (${wildcards}). Strings are now always interpreted as ` +
`exact matches; use a RegExp for partial or wildcard matches.`);
}
}
const matchCallback = ({ url }) => {
if (process.env.NODE_ENV !== 'production') {
if ((url.pathname === captureUrl.pathname) &&
(url.origin !== captureUrl.origin)) {
logger.debug(`${capture} only partially matches the cross-origin URL ` +
`${url}. This route will only handle cross-origin requests ` +
`if they match the entire URL.`);
}
}
return url.href === captureUrl.href;
};
// If `capture` is a string then `handler` and `method` must be present.
route = new Route(matchCallback, handler, method);
}
else if (capture instanceof RegExp) {
// If `capture` is a `RegExp` then `handler` and `method` must be present.
route = new RegExpRoute(capture, handler, method);
}
else if (typeof capture === 'function') {
// If `capture` is a function then `handler` and `method` must be present.
route = new Route(capture, handler, method);
}
else if (capture instanceof Route) {
route = capture;
}
else {
throw new WorkboxError('unsupported-route-type', {
moduleName: 'workbox-routing',
funcName: 'registerRoute',
paramName: 'capture',
});
}
const defaultRouter = getOrCreateDefaultRouter();
defaultRouter.registerRoute(route);
return route;
}
export { registerRoute };

1
web/node_modules/workbox-routing/registerRoute.mjs generated vendored Normal file
View file

@ -0,0 +1 @@
export * from './registerRoute.js';

13
web/node_modules/workbox-routing/setCatchHandler.d.ts generated vendored Normal file
View file

@ -0,0 +1,13 @@
import { Handler } from './_types.js';
import './_version.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 {module:workbox-routing~handlerCallback} handler A callback
* function that returns a Promise resulting in a Response.
*
* @memberof module:workbox-routing
*/
declare function setCatchHandler(handler: Handler): void;
export { setCatchHandler };

23
web/node_modules/workbox-routing/setCatchHandler.js generated vendored Normal file
View file

@ -0,0 +1,23 @@
/*
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 { getOrCreateDefaultRouter } from './utils/getOrCreateDefaultRouter.js';
import './_version.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 {module:workbox-routing~handlerCallback} handler A callback
* function that returns a Promise resulting in a Response.
*
* @memberof module:workbox-routing
*/
function setCatchHandler(handler) {
const defaultRouter = getOrCreateDefaultRouter();
defaultRouter.setCatchHandler(handler);
}
export { setCatchHandler };

1
web/node_modules/workbox-routing/setCatchHandler.mjs generated vendored Normal file
View file

@ -0,0 +1 @@
export * from './setCatchHandler.js';

16
web/node_modules/workbox-routing/setDefaultHandler.d.ts generated vendored Normal file
View file

@ -0,0 +1,16 @@
import { Handler } from './_types.js';
import './_version.js';
/**
* Define 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 {module:workbox-routing~handlerCallback} handler A callback
* function that returns a Promise resulting in a Response.
*
* @memberof module:workbox-routing
*/
declare function setDefaultHandler(handler: Handler): void;
export { setDefaultHandler };

26
web/node_modules/workbox-routing/setDefaultHandler.js generated vendored Normal file
View file

@ -0,0 +1,26 @@
/*
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 { getOrCreateDefaultRouter } from './utils/getOrCreateDefaultRouter.js';
import './_version.js';
/**
* Define 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 {module:workbox-routing~handlerCallback} handler A callback
* function that returns a Promise resulting in a Response.
*
* @memberof module:workbox-routing
*/
function setDefaultHandler(handler) {
const defaultRouter = getOrCreateDefaultRouter();
defaultRouter.setDefaultHandler(handler);
}
export { setDefaultHandler };

1
web/node_modules/workbox-routing/setDefaultHandler.mjs generated vendored Normal file
View file

@ -0,0 +1 @@
export * from './setDefaultHandler.js';

126
web/node_modules/workbox-routing/src/NavigationRoute.ts generated vendored Normal file
View file

@ -0,0 +1,126 @@
/*
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 {assert} from 'workbox-core/_private/assert.js';
import {logger} from 'workbox-core/_private/logger.js';
import {Route} from './Route.js';
import {Handler, MatchCallbackOptions} from './_types.js';
import './_version.js';
export interface NavigationRouteMatchOptions {
allowlist?: RegExp[];
denylist?: RegExp[];
}
/**
* NavigationRoute makes it easy to create a
* [Route]{@link module:workbox-routing.Route} that matches for browser
* [navigation requests]{@link 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`]{@link 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.
*
* @memberof module:workbox-routing
* @extends module:workbox-routing.Route
*/
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`]{@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLHyperlinkElementUtils/pathname}
* and [`search`]{@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLHyperlinkElementUtils/search}
* portions of the requested URL.
*
* @param {module:workbox-routing~handlerCallback} handler A callback
* function that returns a Promise resulting in a Response.
* @param {Object} options
* @param {Array<RegExp>} [options.denylist] If any of these patterns match,
* the route will not handle the request (even if a allowlist RegExp matches).
* @param {Array<RegExp>} [options.allowlist=[/./]] 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).
*/
constructor(handler: Handler,
{allowlist = [/./], denylist = []}: NavigationRouteMatchOptions = {}) {
if (process.env.NODE_ENV !== 'production') {
assert!.isArrayOfClass(allowlist, RegExp, {
moduleName: 'workbox-routing',
className: 'NavigationRoute',
funcName: 'constructor',
paramName: 'options.allowlist',
});
assert!.isArrayOfClass(denylist, RegExp, {
moduleName: 'workbox-routing',
className: 'NavigationRoute',
funcName: 'constructor',
paramName: 'options.denylist',
});
}
super((options: MatchCallbackOptions) => this._match(options), handler);
this._allowlist = allowlist;
this._denylist = denylist;
}
/**
* Routes match handler.
*
* @param {Object} options
* @param {URL} options.url
* @param {Request} options.request
* @return {boolean}
*
* @private
*/
private _match({url, request}: MatchCallbackOptions): 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}`);
}
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;
}
}
export {NavigationRoute};

89
web/node_modules/workbox-routing/src/RegExpRoute.ts generated vendored Normal file
View file

@ -0,0 +1,89 @@
/*
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 {assert} from 'workbox-core/_private/assert.js';
import {logger} from 'workbox-core/_private/logger.js';
import {HTTPMethod} from './utils/constants.js';
import {Route} from './Route.js';
import {Handler, MatchCallbackOptions, MatchCallback} from './_types.js';
import './_version.js';
/**
* RegExpRoute makes it easy to create a regular expression based
* [Route]{@link module:workbox-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.
*
* [See the module docs for info.]{@link https://developers.google.com/web/tools/workbox/modules/workbox-routing}
*
* @memberof module:workbox-routing
* @extends module:workbox-routing.Route
*/
class RegExpRoute extends Route {
/**
* If the regular expression contains
* [capture groups]{@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp#grouping-back-references},
* the captured values will be passed to the
* [handler's]{@link module:workbox-routing~handlerCallback} `params`
* argument.
*
* @param {RegExp} regExp The regular expression to match against URLs.
* @param {module:workbox-routing~handlerCallback} handler A callback
* function that returns a Promise resulting in a Response.
* @param {string} [method='GET'] The HTTP method to match the Route
* against.
*/
constructor(regExp: RegExp, handler: Handler, method?: HTTPMethod) {
if (process.env.NODE_ENV !== 'production') {
assert!.isInstance(regExp, RegExp, {
moduleName: 'workbox-routing',
className: 'RegExpRoute',
funcName: 'constructor',
paramName: 'pattern',
});
}
const match: MatchCallback = ({url}: MatchCallbackOptions) => {
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}' only partially matched ` +
`against the cross-origin URL '${url}'. 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);
}
}
export {RegExpRoute};

66
web/node_modules/workbox-routing/src/Route.ts generated vendored Normal file
View file

@ -0,0 +1,66 @@
/*
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 {assert} from 'workbox-core/_private/assert.js';
import {HTTPMethod, defaultMethod, validMethods} from './utils/constants.js';
import {normalizeHandler} from './utils/normalizeHandler.js';
import {Handler, HandlerObject, MatchCallback} from './_types.js';
import './_version.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`.
*
* @memberof module:workbox-routing
*/
class Route {
handler: HandlerObject;
match: MatchCallback;
method: HTTPMethod;
/**
* Constructor for Route class.
*
* @param {module:workbox-routing~matchCallback} match
* A callback function that determines whether the route matches a given
* `fetch` event by returning a non-falsy value.
* @param {module:workbox-routing~handlerCallback} handler A callback
* function that returns a Promise resolving to a Response.
* @param {string} [method='GET'] The HTTP method to match the Route
* against.
*/
constructor(
match: MatchCallback,
handler: Handler,
method: HTTPMethod = defaultMethod) {
if (process.env.NODE_ENV !== 'production') {
assert!.isType(match, 'function', {
moduleName: 'workbox-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;
}
}
export {Route};

416
web/node_modules/workbox-routing/src/Router.ts generated vendored Normal file
View file

@ -0,0 +1,416 @@
/*
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 {assert} from 'workbox-core/_private/assert.js';
import {logger} from 'workbox-core/_private/logger.js';
import {WorkboxError} from 'workbox-core/_private/WorkboxError.js';
import {getFriendlyURL} from 'workbox-core/_private/getFriendlyURL.js';
import {Route} from './Route.js';
import {HTTPMethod} from './utils/constants.js';
import {normalizeHandler} from './utils/normalizeHandler.js';
import {Handler, HandlerObject, HandlerCallbackOptions} from './_types.js';
import './_version.js';
type RequestArgs = string | [string, RequestInit?];
interface CacheURLsMessageData {
type: string;
payload: {
urlsToCache: RequestArgs[];
};
}
/**
* The Router can be used to process a FetchEvent through one or more
* [Routes]{@link module:workbox-routing.Route} responding with a Request if
* a matching route exists.
*
* If no route matches a given a request, the Router will use a "default"
* handler if one is defined.
*
* Should the matching Route throw an error, the Router will use a "catch"
* handler if one is defined to gracefully deal with issues and respond with a
* Request.
*
* If a request matches multiple routes, the **earliest** registered route will
* be used to respond to the request.
*
* @memberof module:workbox-routing
*/
class Router {
private readonly _routes: Map<HTTPMethod, Route[]>;
private _defaultHandler?: HandlerObject;
private _catchHandler?: HandlerObject;
/**
* Initializes a new Router.
*/
constructor() {
this._routes = new Map();
}
/**
* @return {Map<string, Array<module:workbox-routing.Route>>} routes A `Map` of HTTP
* method name ('GET', etc.) to an array of all the corresponding `Route`
* instances that are registered.
*/
get routes() {
return this._routes;
}
/**
* Adds a fetch event listener to respond to events when a route matches
* the event's request.
*/
addFetchListener() {
// See https://github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705
self.addEventListener('fetch', ((event: FetchEvent) => {
const {request} = event;
const responsePromise = this.handleRequest({request, event});
if (responsePromise) {
event.respondWith(responsePromise);
}
}) as EventListener);
}
/**
* Adds a message event listener for URLs to cache from the window.
* This is useful to cache resources loaded on the page prior to when the
* service worker started controlling it.
*
* The format of the message data sent from the window should be as follows.
* Where the `urlsToCache` array may consist of URL strings or an array of
* URL string + `requestInit` object (the same as you'd pass to `fetch()`).
*
* ```
* {
* type: 'CACHE_URLS',
* payload: {
* urlsToCache: [
* './script1.js',
* './script2.js',
* ['./script3.js', {mode: 'no-cors'}],
* ],
* },
* }
* ```
*/
addCacheListener() {
// See https://github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705
self.addEventListener('message', ((event: ExtendableMessageEvent) => {
if (event.data && event.data.type === 'CACHE_URLS') {
const {payload}: CacheURLsMessageData = event.data;
if (process.env.NODE_ENV !== 'production') {
logger.debug(`Caching URLs from the window`, payload.urlsToCache);
}
const requestPromises = Promise.all(payload.urlsToCache.map(
(entry: string | [string, RequestInit?]) => {
if (typeof entry === 'string') {
entry = [entry];
}
const request = new Request(...entry);
return this.handleRequest({request});
// TODO(philipwalton): TypeScript errors without this typecast for
// some reason (probably a bug). The real type here should work but
// doesn't: `Array<Promise<Response> | undefined>`.
}) as any[]); // TypeScript
event.waitUntil(requestPromises);
// If a MessageChannel was used, reply to the message on success.
if (event.ports && event.ports[0]) {
requestPromises.then(() => event.ports[0].postMessage(true));
}
}
}) as EventListener);
}
/**
* Apply the routing rules to a FetchEvent object to get a Response from an
* appropriate Route's handler.
*
* @param {Object} options
* @param {Request} options.request The request to handle (this is usually
* from a fetch event, but it does not have to be).
* @param {FetchEvent} [options.event] The event that triggered the request,
* if applicable.
* @return {Promise<Response>|undefined} A promise is returned if a
* registered route can handle the request. If there is no matching
* route and there's no `defaultHandler`, `undefined` is returned.
*/
handleRequest({request, event}: {
request: Request;
event?: ExtendableEvent;
}): Promise<Response> | undefined {
if (process.env.NODE_ENV !== 'production') {
assert!.isInstance(request, Request, {
moduleName: 'workbox-routing',
className: 'Router',
funcName: 'handleRequest',
paramName: 'options.request',
});
}
const url = new URL(request.url, location.href);
if (!url.protocol.startsWith('http')) {
if (process.env.NODE_ENV !== 'production') {
logger.debug(
`Workbox Router only supports URLs that start with 'http'.`);
}
return;
}
const {params, route} = this.findMatchingRoute({url, request, event});
let handler = route && route.handler;
const debugMessages = [];
if (process.env.NODE_ENV !== 'production') {
if (handler) {
debugMessages.push([
`Found a route to handle this request:`, route,
]);
if (params) {
debugMessages.push([
`Passing the following params to the route's handler:`, params,
]);
}
}
}
// If we don't have a handler because there was no matching route, then
// fall back to defaultHandler if that's defined.
if (!handler && this._defaultHandler) {
if (process.env.NODE_ENV !== 'production') {
debugMessages.push(`Failed to find a matching route. Falling ` +
`back to the default handler.`);
}
handler = this._defaultHandler;
}
if (!handler) {
if (process.env.NODE_ENV !== 'production') {
// No handler so Workbox will do nothing. If logs is set of debug
// i.e. verbose, we should print out this information.
logger.debug(`No route found for: ${getFriendlyURL(url)}`);
}
return;
}
if (process.env.NODE_ENV !== 'production') {
// We have a handler, meaning Workbox is going to handle the route.
// print the routing details to the console.
logger.groupCollapsed(`Router is responding to: ${getFriendlyURL(url)}`);
debugMessages.forEach((msg) => {
if (Array.isArray(msg)) {
logger.log(...msg);
} else {
logger.log(msg);
}
});
logger.groupEnd();
}
// Wrap in try and catch in case the handle method throws a synchronous
// error. It should still callback to the catch handler.
let responsePromise;
try {
responsePromise = handler.handle({url, request, event, params});
} catch (err) {
responsePromise = Promise.reject(err);
}
if (responsePromise instanceof Promise && this._catchHandler) {
responsePromise = responsePromise.catch((err) => {
if (process.env.NODE_ENV !== 'production') {
// Still include URL here as it will be async from the console group
// and may not make sense without the URL
logger.groupCollapsed(`Error thrown when responding to: ` +
` ${getFriendlyURL(url)}. Falling back to Catch Handler.`);
logger.error(`Error thrown by:`, route);
logger.error(err);
logger.groupEnd();
}
return this._catchHandler!.handle({url, request, event});
});
}
return responsePromise;
}
/**
* Checks a request and URL (and optionally an event) against the list of
* registered routes, and if there's a match, returns the corresponding
* route along with any params generated by the match.
*
* @param {Object} options
* @param {URL} options.url
* @param {Request} options.request The request to match.
* @param {Event} [options.event] The corresponding event (unless N/A).
* @return {Object} An object with `route` and `params` properties.
* They are populated if a matching route was found or `undefined`
* otherwise.
*/
findMatchingRoute({url, request, event}: {
url: URL;
request: Request;
event?: ExtendableEvent;
}): {route?: Route; params?: HandlerCallbackOptions['params']} {
if (process.env.NODE_ENV !== 'production') {
assert!.isInstance(url, URL, {
moduleName: 'workbox-routing',
className: 'Router',
funcName: 'findMatchingRoute',
paramName: 'options.url',
});
assert!.isInstance(request, Request, {
moduleName: 'workbox-routing',
className: 'Router',
funcName: 'findMatchingRoute',
paramName: 'options.request',
});
}
const routes = this._routes.get(request.method as HTTPMethod) || [];
for (const route of routes) {
let params;
const matchResult = route.match({url, request, event});
if (matchResult) {
// See https://github.com/GoogleChrome/workbox/issues/2079
params = matchResult;
if (Array.isArray(matchResult) && matchResult.length === 0) {
// Instead of passing an empty array in as params, use undefined.
params = undefined;
} else if ((matchResult.constructor === Object &&
Object.keys(matchResult).length === 0)) {
// Instead of passing an empty object in as params, use undefined.
params = undefined;
} else if (typeof matchResult === 'boolean') {
// For the boolean value true (rather than just something truth-y),
// don't set params.
// See https://github.com/GoogleChrome/workbox/pull/2134#issuecomment-513924353
params = undefined;
}
// Return early if have a match.
return {route, params};
}
}
// If no match was found above, return and empty object.
return {};
}
/**
* Define 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 {module:workbox-routing~handlerCallback} handler A callback
* function that returns a Promise resulting in a Response.
*/
setDefaultHandler(handler: Handler) {
this._defaultHandler = normalizeHandler(handler);
}
/**
* If a Route throws an error while handling a request, this `handler`
* will be called and given a chance to provide a response.
*
* @param {module:workbox-routing~handlerCallback} handler A callback
* function that returns a Promise resulting in a Response.
*/
setCatchHandler(handler: Handler) {
this._catchHandler = normalizeHandler(handler);
}
/**
* Registers a route with the router.
*
* @param {module:workbox-routing.Route} route The route to register.
*/
registerRoute(route: Route) {
if (process.env.NODE_ENV !== 'production') {
assert!.isType(route, 'object', {
moduleName: 'workbox-routing',
className: 'Router',
funcName: 'registerRoute',
paramName: 'route',
});
assert!.hasMethod(route, 'match', {
moduleName: 'workbox-routing',
className: 'Router',
funcName: 'registerRoute',
paramName: 'route',
});
assert!.isType(route.handler, 'object', {
moduleName: 'workbox-routing',
className: 'Router',
funcName: 'registerRoute',
paramName: 'route',
});
assert!.hasMethod(route.handler, 'handle', {
moduleName: 'workbox-routing',
className: 'Router',
funcName: 'registerRoute',
paramName: 'route.handler',
});
assert!.isType(route.method, 'string', {
moduleName: 'workbox-routing',
className: 'Router',
funcName: 'registerRoute',
paramName: 'route.method',
});
}
if (!this._routes.has(route.method)) {
this._routes.set(route.method, []);
}
// Give precedence to all of the earlier routes by adding this additional
// route to the end of the array.
this._routes.get(route.method)!.push(route);
}
/**
* Unregisters a route with the router.
*
* @param {module:workbox-routing.Route} route The route to unregister.
*/
unregisterRoute(route: Route) {
if (!this._routes.has(route.method)) {
throw new WorkboxError(
'unregister-route-but-not-found-with-method', {
method: route.method,
}
);
}
const routeIndex = this._routes.get(route.method)!.indexOf(route);
if (routeIndex > -1) {
this._routes.get(route.method)!.splice(routeIndex, 1);
} else {
throw new WorkboxError('unregister-route-route-not-registered');
}
}
}
export {Router};

81
web/node_modules/workbox-routing/src/_types.ts generated vendored Normal file
View file

@ -0,0 +1,81 @@
/*
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 {
RouteHandler,
RouteHandlerObject,
RouteHandlerCallback,
RouteHandlerCallbackOptions,
RouteMatchCallback,
RouteMatchCallbackOptions
} from 'workbox-core/types.js';
import './_version.js';
export {
RouteHandler as Handler,
RouteHandlerObject as HandlerObject,
RouteHandlerCallback as HandlerCallback,
RouteHandlerCallbackOptions as HandlerCallbackOptions,
RouteMatchCallback as MatchCallback,
RouteMatchCallbackOptions as MatchCallbackOptions,
}
// * * * IMPORTANT! * * *
// ------------------------------------------------------------------------- //
// jdsoc type definitions cannot be declared above TypeScript definitions or
// they'll be stripped from the built `.js` files, and they'll only be in the
// `d.ts` files, which aren't read by the jsdoc generator. As a result we
// have to put declare them below.
/**
* The "match" callback is used to determine if a `Route` should apply for a
* particular URL. When matching occurs in response to a fetch event from the
* client, the `event` and `request` objects are supplied in addition to the
* URL. However, since the match callback can be invoked outside of a fetch
* event, matching logic should not assume the `event` or `request` objects
* will always be available (unlike URL, which is always available).
* If the match callback returns a truthy value, the matching route's
* [handler callback]{@link module:workbox-routing~handlerCallback} will be
* invoked immediately. If the value returned is a non-empty array or object,
* that value will be set on the handler's `context.params` argument.
*
* @callback ~matchCallback
* @param {Object} context
* @param {URL} context.url The request's URL.
* @param {Request} [context.request] The corresponding request,
* if available.
* @param {FetchEvent} [context.event] The corresponding event that triggered
* the request, if available.
* @return {*} To signify a match, return a truthy value.
*
* @memberof module:workbox-routing
*/
/**
* The "handler" callback is invoked whenever a `Router` matches a URL to a
* `Route` via its [match]{@link module:workbox-routing~handlerCallback}
* callback. This callback should return a Promise that resolves with a
* `Response`.
*
* If a non-empty array or object is returned by the
* [match callback]{@link module:workbox-routing~matchCallback} it
* will be passed in as the handler's `context.params` argument.
*
* @callback ~handlerCallback
* @param {Object} context
* @param {Request|string} context.request The corresponding request.
* @param {URL} [context.url] The URL that matched, if available.
* @param {FetchEvent} [context.event] The corresponding event that triggered
* the request, if available.
* @param {Object} [context.params] Array or Object parameters returned by the
* Route's [match callback]{@link module:workbox-routing~matchCallback}.
* This will be undefined if an empty array or object were returned.
* @return {Promise<Response>} The response that will fulfill the request.
*
* @memberof module:workbox-routing
*/

2
web/node_modules/workbox-routing/src/_version.ts generated vendored Normal file
View file

@ -0,0 +1,2 @@
// @ts-ignore
try{self['workbox:routing:5.1.4']&&_()}catch(e){}

32
web/node_modules/workbox-routing/src/index.ts generated vendored Normal file
View file

@ -0,0 +1,32 @@
/*
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 {NavigationRoute} from './NavigationRoute.js';
import {RegExpRoute} from './RegExpRoute.js';
import {registerRoute} from './registerRoute.js';
import {Route} from './Route.js';
import {Router} from './Router.js';
import {setCatchHandler} from './setCatchHandler.js';
import {setDefaultHandler} from './setDefaultHandler.js';
import './_version.js';
/**
* @module workbox-routing
*/
export {
NavigationRoute,
RegExpRoute,
registerRoute,
Route,
Router,
setCatchHandler,
setDefaultHandler,
};

110
web/node_modules/workbox-routing/src/registerRoute.ts generated vendored Normal file
View file

@ -0,0 +1,110 @@
/*
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 'workbox-core/_private/logger.js';
import {WorkboxError} from 'workbox-core/_private/WorkboxError.js';
import {Route} from './Route.js';
import {RegExpRoute} from './RegExpRoute.js';
import {HTTPMethod} from './utils/constants.js';
import {getOrCreateDefaultRouter} from './utils/getOrCreateDefaultRouter.js';
import {Handler, MatchCallback} from './_types.js';
import './_version.js';
/**
* Easily register a RegExp, string, or function with a caching
* strategy to a singleton Router instance.
*
* This method will generate a Route for you if needed and
* call [registerRoute()]{@link module:workbox-routing.Router#registerRoute}.
*
* @param {RegExp|string|module:workbox-routing.Route~matchCallback|module:workbox-routing.Route} capture
* If the capture param is a `Route`, all other arguments will be ignored.
* @param {module:workbox-routing~handlerCallback} [handler] A callback
* function that returns a Promise resulting in a Response. This parameter
* is required if `capture` is not a `Route` object.
* @param {string} [method='GET'] The HTTP method to match the Route
* against.
* @return {module:workbox-routing.Route} The generated `Route`(Useful for
* unregistering).
*
* @memberof module:workbox-routing
*/
function registerRoute(
capture: RegExp | string | MatchCallback | Route,
handler?: Handler,
method?: HTTPMethod): Route {
let route;
if (typeof capture === 'string') {
const captureUrl = new URL(capture, location.href);
if (process.env.NODE_ENV !== 'production') {
if (!(capture.startsWith('/') || capture.startsWith('http'))) {
throw new WorkboxError('invalid-string', {
moduleName: 'workbox-routing',
funcName: 'registerRoute',
paramName: 'capture',
});
}
// We want to check if Express-style wildcards are in the pathname only.
// TODO: Remove this log message in v4.
const valueToCheck = capture.startsWith('http') ?
captureUrl.pathname : capture;
// See https://github.com/pillarjs/path-to-regexp#parameters
const wildcards = '[*:?+]';
if ((new RegExp(`${wildcards}`)).exec(valueToCheck)) {
logger.debug(
`The '$capture' parameter contains an Express-style wildcard ` +
`character (${wildcards}). Strings are now always interpreted as ` +
`exact matches; use a RegExp for partial or wildcard matches.`
);
}
}
const matchCallback: MatchCallback = ({url}) => {
if (process.env.NODE_ENV !== 'production') {
if ((url.pathname === captureUrl.pathname) &&
(url.origin !== captureUrl.origin)) {
logger.debug(
`${capture} only partially matches the cross-origin URL ` +
`${url}. This route will only handle cross-origin requests ` +
`if they match the entire URL.`);
}
}
return url.href === captureUrl.href;
};
// If `capture` is a string then `handler` and `method` must be present.
route = new Route(matchCallback, handler!, method);
} else if (capture instanceof RegExp) {
// If `capture` is a `RegExp` then `handler` and `method` must be present.
route = new RegExpRoute(capture, handler!, method);
} else if (typeof capture === 'function') {
// If `capture` is a function then `handler` and `method` must be present.
route = new Route(capture, handler!, method);
} else if (capture instanceof Route) {
route = capture;
} else {
throw new WorkboxError('unsupported-route-type', {
moduleName: 'workbox-routing',
funcName: 'registerRoute',
paramName: 'capture',
});
}
const defaultRouter = getOrCreateDefaultRouter();
defaultRouter.registerRoute(route);
return route;
}
export {registerRoute}

27
web/node_modules/workbox-routing/src/setCatchHandler.ts generated vendored Normal file
View file

@ -0,0 +1,27 @@
/*
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 {getOrCreateDefaultRouter} from './utils/getOrCreateDefaultRouter.js';
import {Handler} from './_types.js';
import './_version.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 {module:workbox-routing~handlerCallback} handler A callback
* function that returns a Promise resulting in a Response.
*
* @memberof module:workbox-routing
*/
function setCatchHandler(handler: Handler) {
const defaultRouter = getOrCreateDefaultRouter();
defaultRouter.setCatchHandler(handler);
}
export {setCatchHandler}

31
web/node_modules/workbox-routing/src/setDefaultHandler.ts generated vendored Normal file
View file

@ -0,0 +1,31 @@
/*
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 {getOrCreateDefaultRouter} from './utils/getOrCreateDefaultRouter.js';
import {Handler} from './_types.js';
import './_version.js';
/**
* Define 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 {module:workbox-routing~handlerCallback} handler A callback
* function that returns a Promise resulting in a Response.
*
* @memberof module:workbox-routing
*/
function setDefaultHandler(handler: Handler) {
const defaultRouter = getOrCreateDefaultRouter();
defaultRouter.setDefaultHandler(handler);
}
export {setDefaultHandler}

38
web/node_modules/workbox-routing/src/utils/constants.ts generated vendored Normal file
View file

@ -0,0 +1,38 @@
/*
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 '../_version.js';
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.
*
* @type {string}
*
* @private
*/
export const defaultMethod: HTTPMethod = 'GET';
/**
* The list of valid HTTP methods associated with requests that could be routed.
*
* @type {Array<string>}
*
* @private
*/
export const validMethods: HTTPMethod[] = [
'DELETE',
'GET',
'HEAD',
'PATCH',
'POST',
'PUT',
];

30
web/node_modules/workbox-routing/src/utils/getOrCreateDefaultRouter.ts generated vendored Normal file
View file

@ -0,0 +1,30 @@
/*
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 {Router} from '../Router.js';
import '../_version.js';
let defaultRouter: Router;
/**
* Creates a new, singleton Router instance if one does not exist. If one
* does already exist, that instance is returned.
*
* @private
* @return {Router}
*/
export const getOrCreateDefaultRouter = (): Router => {
if (!defaultRouter) {
defaultRouter = new Router();
// The helpers that use the default Router assume these listeners exist.
defaultRouter.addFetchListener();
defaultRouter.addCacheListener();
}
return defaultRouter;
};

45
web/node_modules/workbox-routing/src/utils/normalizeHandler.ts generated vendored Normal file
View file

@ -0,0 +1,45 @@
/*
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 {assert} from 'workbox-core/_private/assert.js';
import {Handler, HandlerObject} from '../_types.js';
import '../_version.js';
/**
* @param {function()|Object} handler Either a function, or an object with a
* 'handle' method.
* @return {Object} An object with a handle method.
*
* @private
*/
export const normalizeHandler = (
handler: Handler
): HandlerObject => {
if (handler && typeof handler === 'object') {
if (process.env.NODE_ENV !== 'production') {
assert!.hasMethod(handler, 'handle', {
moduleName: 'workbox-routing',
className: 'Route',
funcName: 'constructor',
paramName: 'handler',
});
}
return handler;
} else {
if (process.env.NODE_ENV !== 'production') {
assert!.isType(handler, 'function', {
moduleName: 'workbox-routing',
className: 'Route',
funcName: 'constructor',
paramName: 'handler',
});
}
return {handle: handler};
}
};

14
web/node_modules/workbox-routing/tsconfig.json generated vendored Normal file
View file

@ -0,0 +1,14 @@
{
"extends": "../../tsconfig",
"compilerOptions": {
"outDir": "./",
"rootDir": "./src",
"tsBuildInfoFile": "./tsconfig.tsbuildinfo"
},
"include": [
"src/**/*.ts"
],
"references": [
{ "path": "../workbox-core/" }
]
}

2644
web/node_modules/workbox-routing/tsconfig.tsbuildinfo generated vendored Normal file
View file

File diff suppressed because it is too large Load diff

19
web/node_modules/workbox-routing/utils/constants.d.ts generated vendored Normal file
View file

@ -0,0 +1,19 @@
import '../_version.js';
export declare type HTTPMethod = 'DELETE' | 'GET' | 'HEAD' | 'PATCH' | 'POST' | 'PUT';
/**
* The default HTTP method, 'GET', used when there's no specific method
* configured for a route.
*
* @type {string}
*
* @private
*/
export declare const defaultMethod: HTTPMethod;
/**
* The list of valid HTTP methods associated with requests that could be routed.
*
* @type {Array<string>}
*
* @private
*/
export declare const validMethods: HTTPMethod[];

32
web/node_modules/workbox-routing/utils/constants.js generated vendored Normal file
View file

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

1
web/node_modules/workbox-routing/utils/constants.mjs generated vendored Normal file
View file

@ -0,0 +1 @@
export * from './constants.js';

10
web/node_modules/workbox-routing/utils/getOrCreateDefaultRouter.d.ts generated vendored Normal file
View file

@ -0,0 +1,10 @@
import { Router } from '../Router.js';
import '../_version.js';
/**
* Creates a new, singleton Router instance if one does not exist. If one
* does already exist, that instance is returned.
*
* @private
* @return {Router}
*/
export declare const getOrCreateDefaultRouter: () => Router;

26
web/node_modules/workbox-routing/utils/getOrCreateDefaultRouter.js generated vendored Normal file
View file

@ -0,0 +1,26 @@
/*
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 { Router } from '../Router.js';
import '../_version.js';
let defaultRouter;
/**
* Creates a new, singleton Router instance if one does not exist. If one
* does already exist, that instance is returned.
*
* @private
* @return {Router}
*/
export const getOrCreateDefaultRouter = () => {
if (!defaultRouter) {
defaultRouter = new Router();
// The helpers that use the default Router assume these listeners exist.
defaultRouter.addFetchListener();
defaultRouter.addCacheListener();
}
return defaultRouter;
};

1
web/node_modules/workbox-routing/utils/getOrCreateDefaultRouter.mjs generated vendored Normal file
View file

@ -0,0 +1 @@
export * from './getOrCreateDefaultRouter.js';

10
web/node_modules/workbox-routing/utils/normalizeHandler.d.ts generated vendored Normal file
View file

@ -0,0 +1,10 @@
import { Handler, HandlerObject } from '../_types.js';
import '../_version.js';
/**
* @param {function()|Object} handler Either a function, or an object with a
* 'handle' method.
* @return {Object} An object with a handle method.
*
* @private
*/
export declare const normalizeHandler: (handler: Handler) => HandlerObject;

40
web/node_modules/workbox-routing/utils/normalizeHandler.js generated vendored Normal file
View file

@ -0,0 +1,40 @@
/*
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 { assert } from 'workbox-core/_private/assert.js';
import '../_version.js';
/**
* @param {function()|Object} handler Either a function, or an object with a
* 'handle' method.
* @return {Object} An object with a handle method.
*
* @private
*/
export const normalizeHandler = (handler) => {
if (handler && typeof handler === 'object') {
if (process.env.NODE_ENV !== 'production') {
assert.hasMethod(handler, 'handle', {
moduleName: 'workbox-routing',
className: 'Route',
funcName: 'constructor',
paramName: 'handler',
});
}
return handler;
}
else {
if (process.env.NODE_ENV !== 'production') {
assert.isType(handler, 'function', {
moduleName: 'workbox-routing',
className: 'Route',
funcName: 'constructor',
paramName: 'handler',
});
}
return { handle: handler };
}
};

1
web/node_modules/workbox-routing/utils/normalizeHandler.mjs generated vendored Normal file
View file

@ -0,0 +1 @@
export * from './normalizeHandler.js';