From 6d58ed18c86b80af067f35a54ce556b8069418cf Mon Sep 17 00:00:00 2001 From: Attilio Grilli Date: Tue, 6 Jun 2023 16:03:26 +0200 Subject: [PATCH] Aggiunta una configurazione per PWA in vite.config.js adesso l'app si installa e parte landscape. manca la partenza in fullscreen e qualcosa per gestire un modal. il reset usa l'alert che scombina un po' tutto. --- dev-dist/registerSW.js | 1 + dev-dist/sw.js | 92 + dev-dist/workbox-5357ef54.js | 3394 ++++++++++++++++++++++++++++++++++ public/antoniana.jpg | Bin 0 -> 135240 bytes public/segnap-192x192.png | Bin 0 -> 49067 bytes public/segnap-512x512.png | Bin 0 -> 211143 bytes vite.config.js | 22 +- 7 files changed, 3508 insertions(+), 1 deletion(-) create mode 100644 dev-dist/registerSW.js create mode 100644 dev-dist/sw.js create mode 100644 dev-dist/workbox-5357ef54.js create mode 100644 public/antoniana.jpg create mode 100644 public/segnap-192x192.png create mode 100644 public/segnap-512x512.png diff --git a/dev-dist/registerSW.js b/dev-dist/registerSW.js new file mode 100644 index 0000000..1d5625f --- /dev/null +++ b/dev-dist/registerSW.js @@ -0,0 +1 @@ +if('serviceWorker' in navigator) navigator.serviceWorker.register('/dev-sw.js?dev-sw', { scope: '/', type: 'classic' }) \ No newline at end of file diff --git a/dev-dist/sw.js b/dev-dist/sw.js new file mode 100644 index 0000000..10ac4ad --- /dev/null +++ b/dev-dist/sw.js @@ -0,0 +1,92 @@ +/** + * Copyright 2018 Google Inc. All Rights Reserved. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * http://www.apache.org/licenses/LICENSE-2.0 + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// If the loader is already loaded, just stop. +if (!self.define) { + let registry = {}; + + // Used for `eval` and `importScripts` where we can't get script URL by other means. + // In both cases, it's safe to use a global var because those functions are synchronous. + let nextDefineUri; + + const singleRequire = (uri, parentUri) => { + uri = new URL(uri + ".js", parentUri).href; + return registry[uri] || ( + + new Promise(resolve => { + if ("document" in self) { + const script = document.createElement("script"); + script.src = uri; + script.onload = resolve; + document.head.appendChild(script); + } else { + nextDefineUri = uri; + importScripts(uri); + resolve(); + } + }) + + .then(() => { + let promise = registry[uri]; + if (!promise) { + throw new Error(`Module ${uri} didn’t register its module`); + } + return promise; + }) + ); + }; + + self.define = (depsNames, factory) => { + const uri = nextDefineUri || ("document" in self ? document.currentScript.src : "") || location.href; + if (registry[uri]) { + // Module is already loading or loaded. + return; + } + let exports = {}; + const require = depUri => singleRequire(depUri, uri); + const specialDeps = { + module: { uri }, + exports, + require + }; + registry[uri] = Promise.all(depsNames.map( + depName => specialDeps[depName] || require(depName) + )).then(deps => { + factory(...deps); + return exports; + }); + }; +} +define(['./workbox-5357ef54'], (function (workbox) { 'use strict'; + + self.skipWaiting(); + workbox.clientsClaim(); + + /** + * The precacheAndRoute() method efficiently caches and responds to + * requests for URLs in the manifest. + * See https://goo.gl/S9QRab + */ + workbox.precacheAndRoute([{ + "url": "registerSW.js", + "revision": "3ca0b8505b4bec776b69afdba2768812" + }, { + "revision": null, + "url": "index.html" + }], {}); + workbox.cleanupOutdatedCaches(); + workbox.registerRoute(new workbox.NavigationRoute(workbox.createHandlerBoundToURL("index.html"), { + allowlist: [/^\/$/] + })); + +})); diff --git a/dev-dist/workbox-5357ef54.js b/dev-dist/workbox-5357ef54.js new file mode 100644 index 0000000..62f106f --- /dev/null +++ b/dev-dist/workbox-5357ef54.js @@ -0,0 +1,3394 @@ +define(['exports'], (function (exports) { 'use strict'; + + // @ts-ignore + try { + self['workbox:core:7.0.0'] && _(); + } catch (e) {} + + /* + 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. + */ + /** + * Claim any currently available clients once the service worker + * becomes active. This is normally used in conjunction with `skipWaiting()`. + * + * @memberof workbox-core + */ + function clientsClaim() { + self.addEventListener('activate', () => self.clients.claim()); + } + + /* + 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. + */ + const logger = (() => { + // Don't overwrite this value if it's already set. + // See https://github.com/GoogleChrome/workbox/pull/2284#issuecomment-560470923 + if (!('__WB_DISABLE_DEV_LOGS' in globalThis)) { + self.__WB_DISABLE_DEV_LOGS = false; + } + let inGroup = false; + const methodToColorMap = { + debug: `#7f8c8d`, + log: `#2ecc71`, + warn: `#f39c12`, + error: `#c0392b`, + groupCollapsed: `#3498db`, + groupEnd: null // No colored prefix on groupEnd + }; + + const print = function (method, args) { + if (self.__WB_DISABLE_DEV_LOGS) { + return; + } + if (method === 'groupCollapsed') { + // Safari doesn't print all console.groupCollapsed() arguments: + // https://bugs.webkit.org/show_bug.cgi?id=182754 + if (/^((?!chrome|android).)*safari/i.test(navigator.userAgent)) { + console[method](...args); + return; + } + } + const styles = [`background: ${methodToColorMap[method]}`, `border-radius: 0.5em`, `color: white`, `font-weight: bold`, `padding: 2px 0.5em`]; + // When in a group, the workbox prefix is not displayed. + const logPrefix = inGroup ? [] : ['%cworkbox', styles.join(';')]; + console[method](...logPrefix, ...args); + if (method === 'groupCollapsed') { + inGroup = true; + } + if (method === 'groupEnd') { + inGroup = false; + } + }; + // eslint-disable-next-line @typescript-eslint/ban-types + const api = {}; + const loggerMethods = Object.keys(methodToColorMap); + for (const key of loggerMethods) { + const method = key; + api[method] = (...args) => { + print(method, args); + }; + } + return api; + })(); + + /* + 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. + */ + const messages = { + 'invalid-value': ({ + paramName, + validValueDescription, + value + }) => { + if (!paramName || !validValueDescription) { + throw new Error(`Unexpected input to 'invalid-value' error.`); + } + return `The '${paramName}' parameter was given a value with an ` + `unexpected value. ${validValueDescription} Received a value of ` + `${JSON.stringify(value)}.`; + }, + 'not-an-array': ({ + moduleName, + className, + funcName, + paramName + }) => { + if (!moduleName || !className || !funcName || !paramName) { + throw new Error(`Unexpected input to 'not-an-array' error.`); + } + return `The parameter '${paramName}' passed into ` + `'${moduleName}.${className}.${funcName}()' must be an array.`; + }, + 'incorrect-type': ({ + expectedType, + paramName, + moduleName, + className, + funcName + }) => { + if (!expectedType || !paramName || !moduleName || !funcName) { + throw new Error(`Unexpected input to 'incorrect-type' error.`); + } + const classNameStr = className ? `${className}.` : ''; + return `The parameter '${paramName}' passed into ` + `'${moduleName}.${classNameStr}` + `${funcName}()' must be of type ${expectedType}.`; + }, + 'incorrect-class': ({ + expectedClassName, + paramName, + moduleName, + className, + funcName, + isReturnValueProblem + }) => { + if (!expectedClassName || !moduleName || !funcName) { + throw new Error(`Unexpected input to 'incorrect-class' error.`); + } + const classNameStr = className ? `${className}.` : ''; + if (isReturnValueProblem) { + return `The return value from ` + `'${moduleName}.${classNameStr}${funcName}()' ` + `must be an instance of class ${expectedClassName}.`; + } + return `The parameter '${paramName}' passed into ` + `'${moduleName}.${classNameStr}${funcName}()' ` + `must be an instance of class ${expectedClassName}.`; + }, + 'missing-a-method': ({ + expectedMethod, + paramName, + moduleName, + className, + funcName + }) => { + if (!expectedMethod || !paramName || !moduleName || !className || !funcName) { + throw new Error(`Unexpected input to 'missing-a-method' error.`); + } + return `${moduleName}.${className}.${funcName}() expected the ` + `'${paramName}' parameter to expose a '${expectedMethod}' method.`; + }, + 'add-to-cache-list-unexpected-type': ({ + entry + }) => { + return `An unexpected entry was passed to ` + `'workbox-precaching.PrecacheController.addToCacheList()' The entry ` + `'${JSON.stringify(entry)}' isn't supported. You must supply an array of ` + `strings with one or more characters, objects with a url property or ` + `Request objects.`; + }, + 'add-to-cache-list-conflicting-entries': ({ + firstEntry, + secondEntry + }) => { + if (!firstEntry || !secondEntry) { + throw new Error(`Unexpected input to ` + `'add-to-cache-list-duplicate-entries' error.`); + } + return `Two of the entries passed to ` + `'workbox-precaching.PrecacheController.addToCacheList()' had the URL ` + `${firstEntry} but different revision details. Workbox is ` + `unable to cache and version the asset correctly. Please remove one ` + `of the entries.`; + }, + 'plugin-error-request-will-fetch': ({ + thrownErrorMessage + }) => { + if (!thrownErrorMessage) { + throw new Error(`Unexpected input to ` + `'plugin-error-request-will-fetch', error.`); + } + return `An error was thrown by a plugins 'requestWillFetch()' method. ` + `The thrown error message was: '${thrownErrorMessage}'.`; + }, + 'invalid-cache-name': ({ + cacheNameId, + value + }) => { + if (!cacheNameId) { + throw new Error(`Expected a 'cacheNameId' for error 'invalid-cache-name'`); + } + return `You must provide a name containing at least one character for ` + `setCacheDetails({${cacheNameId}: '...'}). Received a value of ` + `'${JSON.stringify(value)}'`; + }, + 'unregister-route-but-not-found-with-method': ({ + method + }) => { + if (!method) { + throw new Error(`Unexpected input to ` + `'unregister-route-but-not-found-with-method' error.`); + } + return `The route you're trying to unregister was not previously ` + `registered for the method type '${method}'.`; + }, + 'unregister-route-route-not-registered': () => { + return `The route you're trying to unregister was not previously ` + `registered.`; + }, + 'queue-replay-failed': ({ + name + }) => { + return `Replaying the background sync queue '${name}' failed.`; + }, + 'duplicate-queue-name': ({ + name + }) => { + return `The Queue name '${name}' is already being used. ` + `All instances of backgroundSync.Queue must be given unique names.`; + }, + 'expired-test-without-max-age': ({ + methodName, + paramName + }) => { + return `The '${methodName}()' method can only be used when the ` + `'${paramName}' is used in the constructor.`; + }, + 'unsupported-route-type': ({ + moduleName, + className, + funcName, + paramName + }) => { + return `The supplied '${paramName}' parameter was an unsupported type. ` + `Please check the docs for ${moduleName}.${className}.${funcName} for ` + `valid input types.`; + }, + 'not-array-of-class': ({ + value, + expectedClass, + moduleName, + className, + funcName, + paramName + }) => { + return `The supplied '${paramName}' parameter must be an array of ` + `'${expectedClass}' objects. Received '${JSON.stringify(value)},'. ` + `Please check the call to ${moduleName}.${className}.${funcName}() ` + `to fix the issue.`; + }, + 'max-entries-or-age-required': ({ + moduleName, + className, + funcName + }) => { + return `You must define either config.maxEntries or config.maxAgeSeconds` + `in ${moduleName}.${className}.${funcName}`; + }, + 'statuses-or-headers-required': ({ + moduleName, + className, + funcName + }) => { + return `You must define either config.statuses or config.headers` + `in ${moduleName}.${className}.${funcName}`; + }, + 'invalid-string': ({ + moduleName, + funcName, + paramName + }) => { + if (!paramName || !moduleName || !funcName) { + throw new Error(`Unexpected input to 'invalid-string' error.`); + } + return `When using strings, the '${paramName}' parameter must start with ` + `'http' (for cross-origin matches) or '/' (for same-origin matches). ` + `Please see the docs for ${moduleName}.${funcName}() for ` + `more info.`; + }, + 'channel-name-required': () => { + return `You must provide a channelName to construct a ` + `BroadcastCacheUpdate instance.`; + }, + 'invalid-responses-are-same-args': () => { + return `The arguments passed into responsesAreSame() appear to be ` + `invalid. Please ensure valid Responses are used.`; + }, + 'expire-custom-caches-only': () => { + return `You must provide a 'cacheName' property when using the ` + `expiration plugin with a runtime caching strategy.`; + }, + 'unit-must-be-bytes': ({ + normalizedRangeHeader + }) => { + if (!normalizedRangeHeader) { + throw new Error(`Unexpected input to 'unit-must-be-bytes' error.`); + } + return `The 'unit' portion of the Range header must be set to 'bytes'. ` + `The Range header provided was "${normalizedRangeHeader}"`; + }, + 'single-range-only': ({ + normalizedRangeHeader + }) => { + if (!normalizedRangeHeader) { + throw new Error(`Unexpected input to 'single-range-only' error.`); + } + return `Multiple ranges are not supported. Please use a single start ` + `value, and optional end value. The Range header provided was ` + `"${normalizedRangeHeader}"`; + }, + 'invalid-range-values': ({ + normalizedRangeHeader + }) => { + if (!normalizedRangeHeader) { + throw new Error(`Unexpected input to 'invalid-range-values' error.`); + } + return `The Range header is missing both start and end values. At least ` + `one of those values is needed. The Range header provided was ` + `"${normalizedRangeHeader}"`; + }, + 'no-range-header': () => { + return `No Range header was found in the Request provided.`; + }, + 'range-not-satisfiable': ({ + size, + start, + end + }) => { + return `The start (${start}) and end (${end}) values in the Range are ` + `not satisfiable by the cached response, which is ${size} bytes.`; + }, + 'attempt-to-cache-non-get-request': ({ + url, + method + }) => { + return `Unable to cache '${url}' because it is a '${method}' request and ` + `only 'GET' requests can be cached.`; + }, + 'cache-put-with-no-response': ({ + url + }) => { + return `There was an attempt to cache '${url}' but the response was not ` + `defined.`; + }, + 'no-response': ({ + url, + error + }) => { + let message = `The strategy could not generate a response for '${url}'.`; + if (error) { + message += ` The underlying error is ${error}.`; + } + return message; + }, + 'bad-precaching-response': ({ + url, + status + }) => { + return `The precaching request for '${url}' failed` + (status ? ` with an HTTP status of ${status}.` : `.`); + }, + 'non-precached-url': ({ + url + }) => { + return `createHandlerBoundToURL('${url}') was called, but that URL is ` + `not precached. Please pass in a URL that is precached instead.`; + }, + 'add-to-cache-list-conflicting-integrities': ({ + url + }) => { + return `Two of the entries passed to ` + `'workbox-precaching.PrecacheController.addToCacheList()' had the URL ` + `${url} with different integrity values. Please remove one of them.`; + }, + 'missing-precache-entry': ({ + cacheName, + url + }) => { + return `Unable to find a precached response in ${cacheName} for ${url}.`; + }, + 'cross-origin-copy-response': ({ + origin + }) => { + return `workbox-core.copyResponse() can only be used with same-origin ` + `responses. It was passed a response with origin ${origin}.`; + }, + 'opaque-streams-source': ({ + type + }) => { + const message = `One of the workbox-streams sources resulted in an ` + `'${type}' response.`; + if (type === 'opaqueredirect') { + return `${message} Please do not use a navigation request that results ` + `in a redirect as a source.`; + } + return `${message} Please ensure your sources are CORS-enabled.`; + } + }; + + /* + 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. + */ + const generatorFunction = (code, details = {}) => { + const message = messages[code]; + if (!message) { + throw new Error(`Unable to find message for code '${code}'.`); + } + return message(details); + }; + const messageGenerator = generatorFunction; + + /* + 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. + */ + /** + * Workbox errors should be thrown with this class. + * This allows use to ensure the type easily in tests, + * helps developers identify errors from workbox + * easily and allows use to optimise error + * messages correctly. + * + * @private + */ + class WorkboxError extends Error { + /** + * + * @param {string} errorCode The error code that + * identifies this particular error. + * @param {Object=} details Any relevant arguments + * that will help developers identify issues should + * be added as a key on the context object. + */ + constructor(errorCode, details) { + const message = messageGenerator(errorCode, details); + super(message); + this.name = errorCode; + this.details = details; + } + } + + /* + 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. + */ + /* + * This method throws if the supplied value is not an array. + * The destructed values are required to produce a meaningful error for users. + * The destructed and restructured object is so it's clear what is + * needed. + */ + const isArray = (value, details) => { + if (!Array.isArray(value)) { + throw new WorkboxError('not-an-array', details); + } + }; + const hasMethod = (object, expectedMethod, details) => { + const type = typeof object[expectedMethod]; + if (type !== 'function') { + details['expectedMethod'] = expectedMethod; + throw new WorkboxError('missing-a-method', details); + } + }; + const isType = (object, expectedType, details) => { + if (typeof object !== expectedType) { + details['expectedType'] = expectedType; + throw new WorkboxError('incorrect-type', details); + } + }; + const isInstance = (object, + // Need the general type to do the check later. + // eslint-disable-next-line @typescript-eslint/ban-types + expectedClass, details) => { + if (!(object instanceof expectedClass)) { + details['expectedClassName'] = expectedClass.name; + throw new WorkboxError('incorrect-class', details); + } + }; + const isOneOf = (value, validValues, details) => { + if (!validValues.includes(value)) { + details['validValueDescription'] = `Valid values are ${JSON.stringify(validValues)}.`; + throw new WorkboxError('invalid-value', details); + } + }; + const isArrayOfClass = (value, + // Need general type to do check later. + expectedClass, + // eslint-disable-line + details) => { + const error = new WorkboxError('not-array-of-class', details); + if (!Array.isArray(value)) { + throw error; + } + for (const item of value) { + if (!(item instanceof expectedClass)) { + throw error; + } + } + }; + const finalAssertExports = { + hasMethod, + isArray, + isInstance, + isOneOf, + isType, + isArrayOfClass + }; + + // @ts-ignore + try { + self['workbox:routing:7.0.0'] && _(); + } 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} + * + * @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') { + { + finalAssertExports.hasMethod(handler, 'handle', { + moduleName: 'workbox-routing', + className: 'Route', + funcName: 'constructor', + paramName: 'handler' + }); + } + return handler; + } else { + { + finalAssertExports.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 workbox-routing + */ + class Route { + /** + * Constructor for Route class. + * + * @param {workbox-routing~matchCallback} match + * A callback function that determines whether the route matches a given + * `fetch` event by returning a non-falsy value. + * @param {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) { + { + finalAssertExports.isType(match, 'function', { + moduleName: 'workbox-routing', + className: 'Route', + funcName: 'constructor', + paramName: 'match' + }); + if (method) { + finalAssertExports.isOneOf(method, validMethods, { + paramName: 'method' + }); + } + } + // These values are referenced directly by Router so cannot be + // altered by minificaton. + this.handler = normalizeHandler(handler); + this.match = match; + this.method = method; + } + /** + * + * @param {workbox-routing-handlerCallback} handler A callback + * function that returns a Promise resolving to a Response + */ + setCatchHandler(handler) { + this.catchHandler = normalizeHandler(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. + */ + /** + * RegExpRoute makes it easy to create a regular expression based + * {@link 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. + * + * @memberof workbox-routing + * @extends 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 + * {@link workbox-routing~handlerCallback} `params` + * argument. + * + * @param {RegExp} regExp The regular expression to match against URLs. + * @param {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) { + { + finalAssertExports.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.debug(`The regular expression '${regExp.toString()}' only partially matched ` + `against the cross-origin URL '${url.toString()}'. RegExpRoute's will only ` + `handle cross-origin requests if they match the entire URL.`); + } + return; + } + // If the route matches, but there aren't any capture groups defined, then + // this will return [], which is truthy and therefore sufficient to + // indicate a match. + // If there are capture groups, then it will return their values. + return result.slice(1); + }; + super(match, handler, method); + } + } + + /* + 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. + */ + const getFriendlyURL = url => { + const urlObj = new URL(String(url), location.href); + // See https://github.com/GoogleChrome/workbox/issues/2323 + // We want to include everything, except for the origin if it's same-origin. + return urlObj.href.replace(new RegExp(`^${location.origin}`), ''); + }; + + /* + 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` using one or more + * {@link workbox-routing.Route}, responding with a `Response` 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 workbox-routing + */ + class Router { + /** + * Initializes a new Router. + */ + constructor() { + this._routes = new Map(); + this._defaultHandlerMap = new Map(); + } + /** + * @return {Map>} 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 => { + // event.data is type 'any' + // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access + if (event.data && event.data.type === 'CACHE_URLS') { + // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment + const { + payload + } = event.data; + { + 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, + event + }); + // TODO(philipwalton): TypeScript errors without this typecast for + // some reason (probably a bug). The real type here should work but + // doesn't: `Array | undefined>`. + })); // TypeScript + event.waitUntil(requestPromises); + // If a MessageChannel was used, reply to the message on success. + if (event.ports && event.ports[0]) { + void 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. + * @param {ExtendableEvent} options.event The event that triggered the + * request. + * @return {Promise|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 + }) { + { + finalAssertExports.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.debug(`Workbox Router only supports URLs that start with 'http'.`); + } + return; + } + const sameOrigin = url.origin === location.origin; + const { + params, + route + } = this.findMatchingRoute({ + event, + request, + sameOrigin, + url + }); + 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. + const method = request.method; + if (!handler && this._defaultHandlerMap.has(method)) { + { + debugMessages.push(`Failed to find a matching route. Falling ` + `back to the default handler for ${method}.`); + } + handler = this._defaultHandlerMap.get(method); + } + 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.debug(`No route found for: ${getFriendlyURL(url)}`); + } + return; + } + { + // 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); + } + // Get route's catch handler, if it exists + const catchHandler = route && route.catchHandler; + if (responsePromise instanceof Promise && (this._catchHandler || catchHandler)) { + responsePromise = responsePromise.catch(async err => { + // If there's a route catch handler, process that first + if (catchHandler) { + { + // 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 route's Catch Handler.`); + logger.error(`Error thrown by:`, route); + logger.error(err); + logger.groupEnd(); + } + try { + return await catchHandler.handle({ + url, + request, + event, + params + }); + } catch (catchErr) { + if (catchErr instanceof Error) { + err = catchErr; + } + } + } + if (this._catchHandler) { + { + // 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 global Catch Handler.`); + logger.error(`Error thrown by:`, route); + logger.error(err); + logger.groupEnd(); + } + return this._catchHandler.handle({ + url, + request, + event + }); + } + throw err; + }); + } + 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 {boolean} options.sameOrigin The result of comparing `url.origin` + * against the current origin. + * @param {Request} options.request The request to match. + * @param {Event} options.event The corresponding event. + * @return {Object} An object with `route` and `params` properties. + * They are populated if a matching route was found or `undefined` + * otherwise. + */ + findMatchingRoute({ + url, + sameOrigin, + request, + event + }) { + const routes = this._routes.get(request.method) || []; + for (const route of routes) { + let params; + // route.match returns type any, not possible to change right now. + // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment + const matchResult = route.match({ + url, + sameOrigin, + request, + event + }); + if (matchResult) { + { + // Warn developers that using an async matchCallback is almost always + // not the right thing to do. + if (matchResult instanceof Promise) { + logger.warn(`While routing ${getFriendlyURL(url)}, an async ` + `matchCallback function was used. Please convert the ` + `following route to use a synchronous matchCallback function:`, route); + } + } + // See https://github.com/GoogleChrome/workbox/issues/2079 + // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment + params = matchResult; + if (Array.isArray(params) && params.length === 0) { + // Instead of passing an empty array in as params, use undefined. + params = undefined; + } else if (matchResult.constructor === Object && + // eslint-disable-line + 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. + * + * Each HTTP method ('GET', 'POST', etc.) gets its own default handler. + * + * Without a default handler, unmatched requests will go against the + * network as if there were no service worker present. + * + * @param {workbox-routing~handlerCallback} handler A callback + * function that returns a Promise resulting in a Response. + * @param {string} [method='GET'] The HTTP method to associate with this + * default handler. Each method has its own default. + */ + setDefaultHandler(handler, method = defaultMethod) { + this._defaultHandlerMap.set(method, 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 {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 {workbox-routing.Route} route The route to register. + */ + registerRoute(route) { + { + finalAssertExports.isType(route, 'object', { + moduleName: 'workbox-routing', + className: 'Router', + funcName: 'registerRoute', + paramName: 'route' + }); + finalAssertExports.hasMethod(route, 'match', { + moduleName: 'workbox-routing', + className: 'Router', + funcName: 'registerRoute', + paramName: 'route' + }); + finalAssertExports.isType(route.handler, 'object', { + moduleName: 'workbox-routing', + className: 'Router', + funcName: 'registerRoute', + paramName: 'route' + }); + finalAssertExports.hasMethod(route.handler, 'handle', { + moduleName: 'workbox-routing', + className: 'Router', + funcName: 'registerRoute', + paramName: 'route.handler' + }); + finalAssertExports.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 {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'); + } + } + } + + /* + 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 {@link workbox-routing.Router#registerRoute}. + * + * @param {RegExp|string|workbox-routing.Route~matchCallback|workbox-routing.Route} capture + * If the capture param is a `Route`, all other arguments will be ignored. + * @param {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 {workbox-routing.Route} The generated `Route`. + * + * @memberof 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('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 (url.pathname === captureUrl.pathname && url.origin !== captureUrl.origin) { + logger.debug(`${capture} only partially matches the cross-origin URL ` + `${url.toString()}. 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; + } + + /* + 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. + */ + const _cacheNameDetails = { + googleAnalytics: 'googleAnalytics', + precache: 'precache-v2', + prefix: 'workbox', + runtime: 'runtime', + suffix: typeof registration !== 'undefined' ? registration.scope : '' + }; + const _createCacheName = cacheName => { + return [_cacheNameDetails.prefix, cacheName, _cacheNameDetails.suffix].filter(value => value && value.length > 0).join('-'); + }; + const eachCacheNameDetail = fn => { + for (const key of Object.keys(_cacheNameDetails)) { + fn(key); + } + }; + const cacheNames = { + updateDetails: details => { + eachCacheNameDetail(key => { + if (typeof details[key] === 'string') { + _cacheNameDetails[key] = details[key]; + } + }); + }, + getGoogleAnalyticsName: userCacheName => { + return userCacheName || _createCacheName(_cacheNameDetails.googleAnalytics); + }, + getPrecacheName: userCacheName => { + return userCacheName || _createCacheName(_cacheNameDetails.precache); + }, + getPrefix: () => { + return _cacheNameDetails.prefix; + }, + getRuntimeName: userCacheName => { + return userCacheName || _createCacheName(_cacheNameDetails.runtime); + }, + getSuffix: () => { + return _cacheNameDetails.suffix; + } + }; + + /* + Copyright 2020 Google LLC + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * A utility method that makes it easier to use `event.waitUntil` with + * async functions and return the result. + * + * @param {ExtendableEvent} event + * @param {Function} asyncFn + * @return {Function} + * @private + */ + function waitUntil(event, asyncFn) { + const returnPromise = asyncFn(); + event.waitUntil(returnPromise); + return returnPromise; + } + + // @ts-ignore + try { + self['workbox:precaching:7.0.0'] && _(); + } 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. + */ + // Name of the search parameter used to store revision info. + const REVISION_SEARCH_PARAM = '__WB_REVISION__'; + /** + * Converts a manifest entry into a versioned URL suitable for precaching. + * + * @param {Object|string} entry + * @return {string} A URL with versioning info. + * + * @private + * @memberof workbox-precaching + */ + function createCacheKey(entry) { + if (!entry) { + throw new WorkboxError('add-to-cache-list-unexpected-type', { + entry + }); + } + // If a precache manifest entry is a string, it's assumed to be a versioned + // URL, like '/app.abcd1234.js'. Return as-is. + if (typeof entry === 'string') { + const urlObject = new URL(entry, location.href); + return { + cacheKey: urlObject.href, + url: urlObject.href + }; + } + const { + revision, + url + } = entry; + if (!url) { + throw new WorkboxError('add-to-cache-list-unexpected-type', { + entry + }); + } + // If there's just a URL and no revision, then it's also assumed to be a + // versioned URL. + if (!revision) { + const urlObject = new URL(url, location.href); + return { + cacheKey: urlObject.href, + url: urlObject.href + }; + } + // Otherwise, construct a properly versioned URL using the custom Workbox + // search parameter along with the revision info. + const cacheKeyURL = new URL(url, location.href); + const originalURL = new URL(url, location.href); + cacheKeyURL.searchParams.set(REVISION_SEARCH_PARAM, revision); + return { + cacheKey: cacheKeyURL.href, + url: originalURL.href + }; + } + + /* + Copyright 2020 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * A plugin, designed to be used with PrecacheController, to determine the + * of assets that were updated (or not updated) during the install event. + * + * @private + */ + class PrecacheInstallReportPlugin { + constructor() { + this.updatedURLs = []; + this.notUpdatedURLs = []; + this.handlerWillStart = async ({ + request, + state + }) => { + // TODO: `state` should never be undefined... + if (state) { + state.originalRequest = request; + } + }; + this.cachedResponseWillBeUsed = async ({ + event, + state, + cachedResponse + }) => { + if (event.type === 'install') { + if (state && state.originalRequest && state.originalRequest instanceof Request) { + // TODO: `state` should never be undefined... + const url = state.originalRequest.url; + if (cachedResponse) { + this.notUpdatedURLs.push(url); + } else { + this.updatedURLs.push(url); + } + } + } + return cachedResponse; + }; + } + } + + /* + Copyright 2020 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * A plugin, designed to be used with PrecacheController, to translate URLs into + * the corresponding cache key, based on the current revision info. + * + * @private + */ + class PrecacheCacheKeyPlugin { + constructor({ + precacheController + }) { + this.cacheKeyWillBeUsed = async ({ + request, + params + }) => { + // Params is type any, can't change right now. + /* eslint-disable */ + const cacheKey = (params === null || params === void 0 ? void 0 : params.cacheKey) || this._precacheController.getCacheKeyForURL(request.url); + /* eslint-enable */ + return cacheKey ? new Request(cacheKey, { + headers: request.headers + }) : request; + }; + this._precacheController = precacheController; + } + } + + /* + 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 {string} groupTitle + * @param {Array} deletedURLs + * + * @private + */ + const logGroup = (groupTitle, deletedURLs) => { + logger.groupCollapsed(groupTitle); + for (const url of deletedURLs) { + logger.log(url); + } + logger.groupEnd(); + }; + /** + * @param {Array} deletedURLs + * + * @private + * @memberof workbox-precaching + */ + function printCleanupDetails(deletedURLs) { + const deletionCount = deletedURLs.length; + if (deletionCount > 0) { + logger.groupCollapsed(`During precaching cleanup, ` + `${deletionCount} cached ` + `request${deletionCount === 1 ? ' was' : 's were'} deleted.`); + logGroup('Deleted Cache Requests', deletedURLs); + logger.groupEnd(); + } + } + + /* + 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 {string} groupTitle + * @param {Array} urls + * + * @private + */ + function _nestedGroup(groupTitle, urls) { + if (urls.length === 0) { + return; + } + logger.groupCollapsed(groupTitle); + for (const url of urls) { + logger.log(url); + } + logger.groupEnd(); + } + /** + * @param {Array} urlsToPrecache + * @param {Array} urlsAlreadyPrecached + * + * @private + * @memberof workbox-precaching + */ + function printInstallDetails(urlsToPrecache, urlsAlreadyPrecached) { + const precachedCount = urlsToPrecache.length; + const alreadyPrecachedCount = urlsAlreadyPrecached.length; + if (precachedCount || alreadyPrecachedCount) { + let message = `Precaching ${precachedCount} file${precachedCount === 1 ? '' : 's'}.`; + if (alreadyPrecachedCount > 0) { + message += ` ${alreadyPrecachedCount} ` + `file${alreadyPrecachedCount === 1 ? ' is' : 's are'} already cached.`; + } + logger.groupCollapsed(message); + _nestedGroup(`View newly precached URLs.`, urlsToPrecache); + _nestedGroup(`View previously precached URLs.`, urlsAlreadyPrecached); + logger.groupEnd(); + } + } + + /* + 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 supportStatus; + /** + * A utility function that determines whether the current browser supports + * constructing a new `Response` from a `response.body` stream. + * + * @return {boolean} `true`, if the current browser can successfully + * construct a `Response` from a `response.body` stream, `false` otherwise. + * + * @private + */ + function canConstructResponseFromBodyStream() { + if (supportStatus === undefined) { + const testResponse = new Response(''); + if ('body' in testResponse) { + try { + new Response(testResponse.body); + supportStatus = true; + } catch (error) { + supportStatus = false; + } + } + supportStatus = false; + } + return supportStatus; + } + + /* + 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. + */ + /** + * Allows developers to copy a response and modify its `headers`, `status`, + * or `statusText` values (the values settable via a + * [`ResponseInit`]{@link https://developer.mozilla.org/en-US/docs/Web/API/Response/Response#Syntax} + * object in the constructor). + * To modify these values, pass a function as the second argument. That + * function will be invoked with a single object with the response properties + * `{headers, status, statusText}`. The return value of this function will + * be used as the `ResponseInit` for the new `Response`. To change the values + * either modify the passed parameter(s) and return it, or return a totally + * new object. + * + * This method is intentionally limited to same-origin responses, regardless of + * whether CORS was used or not. + * + * @param {Response} response + * @param {Function} modifier + * @memberof workbox-core + */ + async function copyResponse(response, modifier) { + let origin = null; + // If response.url isn't set, assume it's cross-origin and keep origin null. + if (response.url) { + const responseURL = new URL(response.url); + origin = responseURL.origin; + } + if (origin !== self.location.origin) { + throw new WorkboxError('cross-origin-copy-response', { + origin + }); + } + const clonedResponse = response.clone(); + // Create a fresh `ResponseInit` object by cloning the headers. + const responseInit = { + headers: new Headers(clonedResponse.headers), + status: clonedResponse.status, + statusText: clonedResponse.statusText + }; + // Apply any user modifications. + const modifiedResponseInit = modifier ? modifier(responseInit) : responseInit; + // Create the new response from the body stream and `ResponseInit` + // modifications. Note: not all browsers support the Response.body stream, + // so fall back to reading the entire body into memory as a blob. + const body = canConstructResponseFromBodyStream() ? clonedResponse.body : await clonedResponse.blob(); + return new Response(body, modifiedResponseInit); + } + + /* + Copyright 2020 Google LLC + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + function stripParams(fullURL, ignoreParams) { + const strippedURL = new URL(fullURL); + for (const param of ignoreParams) { + strippedURL.searchParams.delete(param); + } + return strippedURL.href; + } + /** + * Matches an item in the cache, ignoring specific URL params. This is similar + * to the `ignoreSearch` option, but it allows you to ignore just specific + * params (while continuing to match on the others). + * + * @private + * @param {Cache} cache + * @param {Request} request + * @param {Object} matchOptions + * @param {Array} ignoreParams + * @return {Promise} + */ + async function cacheMatchIgnoreParams(cache, request, ignoreParams, matchOptions) { + const strippedRequestURL = stripParams(request.url, ignoreParams); + // If the request doesn't include any ignored params, match as normal. + if (request.url === strippedRequestURL) { + return cache.match(request, matchOptions); + } + // Otherwise, match by comparing keys + const keysOptions = Object.assign(Object.assign({}, matchOptions), { + ignoreSearch: true + }); + const cacheKeys = await cache.keys(request, keysOptions); + for (const cacheKey of cacheKeys) { + const strippedCacheKeyURL = stripParams(cacheKey.url, ignoreParams); + if (strippedRequestURL === strippedCacheKeyURL) { + return cache.match(cacheKey, matchOptions); + } + } + return; + } + + /* + 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 Deferred class composes Promises in a way that allows for them to be + * resolved or rejected from outside the constructor. In most cases promises + * should be used directly, but Deferreds can be necessary when the logic to + * resolve a promise must be separate. + * + * @private + */ + class Deferred { + /** + * Creates a promise and exposes its resolve and reject functions as methods. + */ + constructor() { + this.promise = new Promise((resolve, reject) => { + this.resolve = resolve; + this.reject = reject; + }); + } + } + + /* + 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. + */ + // Callbacks to be executed whenever there's a quota error. + // Can't change Function type right now. + // eslint-disable-next-line @typescript-eslint/ban-types + const quotaErrorCallbacks = new Set(); + + /* + 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. + */ + /** + * Runs all of the callback functions, one at a time sequentially, in the order + * in which they were registered. + * + * @memberof workbox-core + * @private + */ + async function executeQuotaErrorCallbacks() { + { + logger.log(`About to run ${quotaErrorCallbacks.size} ` + `callbacks to clean up caches.`); + } + for (const callback of quotaErrorCallbacks) { + await callback(); + { + logger.log(callback, 'is complete.'); + } + } + { + logger.log('Finished running callbacks.'); + } + } + + /* + 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. + */ + /** + * Returns a promise that resolves and the passed number of milliseconds. + * This utility is an async/await-friendly version of `setTimeout`. + * + * @param {number} ms + * @return {Promise} + * @private + */ + function timeout(ms) { + return new Promise(resolve => setTimeout(resolve, ms)); + } + + // @ts-ignore + try { + self['workbox:strategies:7.0.0'] && _(); + } catch (e) {} + + /* + Copyright 2020 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + function toRequest(input) { + return typeof input === 'string' ? new Request(input) : input; + } + /** + * A class created every time a Strategy instance instance calls + * {@link workbox-strategies.Strategy~handle} or + * {@link workbox-strategies.Strategy~handleAll} that wraps all fetch and + * cache actions around plugin callbacks and keeps track of when the strategy + * is "done" (i.e. all added `event.waitUntil()` promises have resolved). + * + * @memberof workbox-strategies + */ + class StrategyHandler { + /** + * Creates a new instance associated with the passed strategy and event + * that's handling the request. + * + * The constructor also initializes the state that will be passed to each of + * the plugins handling this request. + * + * @param {workbox-strategies.Strategy} strategy + * @param {Object} options + * @param {Request|string} options.request A request to run this strategy for. + * @param {ExtendableEvent} options.event The event associated with the + * request. + * @param {URL} [options.url] + * @param {*} [options.params] The return value from the + * {@link workbox-routing~matchCallback} (if applicable). + */ + constructor(strategy, options) { + this._cacheKeys = {}; + /** + * The request the strategy is performing (passed to the strategy's + * `handle()` or `handleAll()` method). + * @name request + * @instance + * @type {Request} + * @memberof workbox-strategies.StrategyHandler + */ + /** + * The event associated with this request. + * @name event + * @instance + * @type {ExtendableEvent} + * @memberof workbox-strategies.StrategyHandler + */ + /** + * A `URL` instance of `request.url` (if passed to the strategy's + * `handle()` or `handleAll()` method). + * Note: the `url` param will be present if the strategy was invoked + * from a workbox `Route` object. + * @name url + * @instance + * @type {URL|undefined} + * @memberof workbox-strategies.StrategyHandler + */ + /** + * A `param` value (if passed to the strategy's + * `handle()` or `handleAll()` method). + * Note: the `param` param will be present if the strategy was invoked + * from a workbox `Route` object and the + * {@link workbox-routing~matchCallback} returned + * a truthy value (it will be that value). + * @name params + * @instance + * @type {*|undefined} + * @memberof workbox-strategies.StrategyHandler + */ + { + finalAssertExports.isInstance(options.event, ExtendableEvent, { + moduleName: 'workbox-strategies', + className: 'StrategyHandler', + funcName: 'constructor', + paramName: 'options.event' + }); + } + Object.assign(this, options); + this.event = options.event; + this._strategy = strategy; + this._handlerDeferred = new Deferred(); + this._extendLifetimePromises = []; + // Copy the plugins list (since it's mutable on the strategy), + // so any mutations don't affect this handler instance. + this._plugins = [...strategy.plugins]; + this._pluginStateMap = new Map(); + for (const plugin of this._plugins) { + this._pluginStateMap.set(plugin, {}); + } + this.event.waitUntil(this._handlerDeferred.promise); + } + /** + * Fetches a given request (and invokes any applicable plugin callback + * methods) using the `fetchOptions` (for non-navigation requests) and + * `plugins` defined on the `Strategy` object. + * + * The following plugin lifecycle methods are invoked when using this method: + * - `requestWillFetch()` + * - `fetchDidSucceed()` + * - `fetchDidFail()` + * + * @param {Request|string} input The URL or request to fetch. + * @return {Promise} + */ + async fetch(input) { + const { + event + } = this; + let request = toRequest(input); + if (request.mode === 'navigate' && event instanceof FetchEvent && event.preloadResponse) { + const possiblePreloadResponse = await event.preloadResponse; + if (possiblePreloadResponse) { + { + logger.log(`Using a preloaded navigation response for ` + `'${getFriendlyURL(request.url)}'`); + } + return possiblePreloadResponse; + } + } + // If there is a fetchDidFail plugin, we need to save a clone of the + // original request before it's either modified by a requestWillFetch + // plugin or before the original request's body is consumed via fetch(). + const originalRequest = this.hasCallback('fetchDidFail') ? request.clone() : null; + try { + for (const cb of this.iterateCallbacks('requestWillFetch')) { + request = await cb({ + request: request.clone(), + event + }); + } + } catch (err) { + if (err instanceof Error) { + throw new WorkboxError('plugin-error-request-will-fetch', { + thrownErrorMessage: err.message + }); + } + } + // The request can be altered by plugins with `requestWillFetch` making + // the original request (most likely from a `fetch` event) different + // from the Request we make. Pass both to `fetchDidFail` to aid debugging. + const pluginFilteredRequest = request.clone(); + try { + let fetchResponse; + // See https://github.com/GoogleChrome/workbox/issues/1796 + fetchResponse = await fetch(request, request.mode === 'navigate' ? undefined : this._strategy.fetchOptions); + if ("development" !== 'production') { + logger.debug(`Network request for ` + `'${getFriendlyURL(request.url)}' returned a response with ` + `status '${fetchResponse.status}'.`); + } + for (const callback of this.iterateCallbacks('fetchDidSucceed')) { + fetchResponse = await callback({ + event, + request: pluginFilteredRequest, + response: fetchResponse + }); + } + return fetchResponse; + } catch (error) { + { + logger.log(`Network request for ` + `'${getFriendlyURL(request.url)}' threw an error.`, error); + } + // `originalRequest` will only exist if a `fetchDidFail` callback + // is being used (see above). + if (originalRequest) { + await this.runCallbacks('fetchDidFail', { + error: error, + event, + originalRequest: originalRequest.clone(), + request: pluginFilteredRequest.clone() + }); + } + throw error; + } + } + /** + * Calls `this.fetch()` and (in the background) runs `this.cachePut()` on + * the response generated by `this.fetch()`. + * + * The call to `this.cachePut()` automatically invokes `this.waitUntil()`, + * so you do not have to manually call `waitUntil()` on the event. + * + * @param {Request|string} input The request or URL to fetch and cache. + * @return {Promise} + */ + async fetchAndCachePut(input) { + const response = await this.fetch(input); + const responseClone = response.clone(); + void this.waitUntil(this.cachePut(input, responseClone)); + return response; + } + /** + * Matches a request from the cache (and invokes any applicable plugin + * callback methods) using the `cacheName`, `matchOptions`, and `plugins` + * defined on the strategy object. + * + * The following plugin lifecycle methods are invoked when using this method: + * - cacheKeyWillByUsed() + * - cachedResponseWillByUsed() + * + * @param {Request|string} key The Request or URL to use as the cache key. + * @return {Promise} A matching response, if found. + */ + async cacheMatch(key) { + const request = toRequest(key); + let cachedResponse; + const { + cacheName, + matchOptions + } = this._strategy; + const effectiveRequest = await this.getCacheKey(request, 'read'); + const multiMatchOptions = Object.assign(Object.assign({}, matchOptions), { + cacheName + }); + cachedResponse = await caches.match(effectiveRequest, multiMatchOptions); + { + if (cachedResponse) { + logger.debug(`Found a cached response in '${cacheName}'.`); + } else { + logger.debug(`No cached response found in '${cacheName}'.`); + } + } + for (const callback of this.iterateCallbacks('cachedResponseWillBeUsed')) { + cachedResponse = (await callback({ + cacheName, + matchOptions, + cachedResponse, + request: effectiveRequest, + event: this.event + })) || undefined; + } + return cachedResponse; + } + /** + * Puts a request/response pair in the cache (and invokes any applicable + * plugin callback methods) using the `cacheName` and `plugins` defined on + * the strategy object. + * + * The following plugin lifecycle methods are invoked when using this method: + * - cacheKeyWillByUsed() + * - cacheWillUpdate() + * - cacheDidUpdate() + * + * @param {Request|string} key The request or URL to use as the cache key. + * @param {Response} response The response to cache. + * @return {Promise} `false` if a cacheWillUpdate caused the response + * not be cached, and `true` otherwise. + */ + async cachePut(key, response) { + const request = toRequest(key); + // Run in the next task to avoid blocking other cache reads. + // https://github.com/w3c/ServiceWorker/issues/1397 + await timeout(0); + const effectiveRequest = await this.getCacheKey(request, 'write'); + { + if (effectiveRequest.method && effectiveRequest.method !== 'GET') { + throw new WorkboxError('attempt-to-cache-non-get-request', { + url: getFriendlyURL(effectiveRequest.url), + method: effectiveRequest.method + }); + } + // See https://github.com/GoogleChrome/workbox/issues/2818 + const vary = response.headers.get('Vary'); + if (vary) { + logger.debug(`The response for ${getFriendlyURL(effectiveRequest.url)} ` + `has a 'Vary: ${vary}' header. ` + `Consider setting the {ignoreVary: true} option on your strategy ` + `to ensure cache matching and deletion works as expected.`); + } + } + if (!response) { + { + logger.error(`Cannot cache non-existent response for ` + `'${getFriendlyURL(effectiveRequest.url)}'.`); + } + throw new WorkboxError('cache-put-with-no-response', { + url: getFriendlyURL(effectiveRequest.url) + }); + } + const responseToCache = await this._ensureResponseSafeToCache(response); + if (!responseToCache) { + { + logger.debug(`Response '${getFriendlyURL(effectiveRequest.url)}' ` + `will not be cached.`, responseToCache); + } + return false; + } + const { + cacheName, + matchOptions + } = this._strategy; + const cache = await self.caches.open(cacheName); + const hasCacheUpdateCallback = this.hasCallback('cacheDidUpdate'); + const oldResponse = hasCacheUpdateCallback ? await cacheMatchIgnoreParams( + // TODO(philipwalton): the `__WB_REVISION__` param is a precaching + // feature. Consider into ways to only add this behavior if using + // precaching. + cache, effectiveRequest.clone(), ['__WB_REVISION__'], matchOptions) : null; + { + logger.debug(`Updating the '${cacheName}' cache with a new Response ` + `for ${getFriendlyURL(effectiveRequest.url)}.`); + } + try { + await cache.put(effectiveRequest, hasCacheUpdateCallback ? responseToCache.clone() : responseToCache); + } catch (error) { + if (error instanceof Error) { + // See https://developer.mozilla.org/en-US/docs/Web/API/DOMException#exception-QuotaExceededError + if (error.name === 'QuotaExceededError') { + await executeQuotaErrorCallbacks(); + } + throw error; + } + } + for (const callback of this.iterateCallbacks('cacheDidUpdate')) { + await callback({ + cacheName, + oldResponse, + newResponse: responseToCache.clone(), + request: effectiveRequest, + event: this.event + }); + } + return true; + } + /** + * Checks the list of plugins for the `cacheKeyWillBeUsed` callback, and + * executes any of those callbacks found in sequence. The final `Request` + * object returned by the last plugin is treated as the cache key for cache + * reads and/or writes. If no `cacheKeyWillBeUsed` plugin callbacks have + * been registered, the passed request is returned unmodified + * + * @param {Request} request + * @param {string} mode + * @return {Promise} + */ + async getCacheKey(request, mode) { + const key = `${request.url} | ${mode}`; + if (!this._cacheKeys[key]) { + let effectiveRequest = request; + for (const callback of this.iterateCallbacks('cacheKeyWillBeUsed')) { + effectiveRequest = toRequest(await callback({ + mode, + request: effectiveRequest, + event: this.event, + // params has a type any can't change right now. + params: this.params // eslint-disable-line + })); + } + + this._cacheKeys[key] = effectiveRequest; + } + return this._cacheKeys[key]; + } + /** + * Returns true if the strategy has at least one plugin with the given + * callback. + * + * @param {string} name The name of the callback to check for. + * @return {boolean} + */ + hasCallback(name) { + for (const plugin of this._strategy.plugins) { + if (name in plugin) { + return true; + } + } + return false; + } + /** + * Runs all plugin callbacks matching the given name, in order, passing the + * given param object (merged ith the current plugin state) as the only + * argument. + * + * Note: since this method runs all plugins, it's not suitable for cases + * where the return value of a callback needs to be applied prior to calling + * the next callback. See + * {@link workbox-strategies.StrategyHandler#iterateCallbacks} + * below for how to handle that case. + * + * @param {string} name The name of the callback to run within each plugin. + * @param {Object} param The object to pass as the first (and only) param + * when executing each callback. This object will be merged with the + * current plugin state prior to callback execution. + */ + async runCallbacks(name, param) { + for (const callback of this.iterateCallbacks(name)) { + // TODO(philipwalton): not sure why `any` is needed. It seems like + // this should work with `as WorkboxPluginCallbackParam[C]`. + await callback(param); + } + } + /** + * Accepts a callback and returns an iterable of matching plugin callbacks, + * where each callback is wrapped with the current handler state (i.e. when + * you call each callback, whatever object parameter you pass it will + * be merged with the plugin's current state). + * + * @param {string} name The name fo the callback to run + * @return {Array} + */ + *iterateCallbacks(name) { + for (const plugin of this._strategy.plugins) { + if (typeof plugin[name] === 'function') { + const state = this._pluginStateMap.get(plugin); + const statefulCallback = param => { + const statefulParam = Object.assign(Object.assign({}, param), { + state + }); + // TODO(philipwalton): not sure why `any` is needed. It seems like + // this should work with `as WorkboxPluginCallbackParam[C]`. + return plugin[name](statefulParam); + }; + yield statefulCallback; + } + } + } + /** + * Adds a promise to the + * [extend lifetime promises]{@link https://w3c.github.io/ServiceWorker/#extendableevent-extend-lifetime-promises} + * of the event event associated with the request being handled (usually a + * `FetchEvent`). + * + * Note: you can await + * {@link workbox-strategies.StrategyHandler~doneWaiting} + * to know when all added promises have settled. + * + * @param {Promise} promise A promise to add to the extend lifetime promises + * of the event that triggered the request. + */ + waitUntil(promise) { + this._extendLifetimePromises.push(promise); + return promise; + } + /** + * Returns a promise that resolves once all promises passed to + * {@link workbox-strategies.StrategyHandler~waitUntil} + * have settled. + * + * Note: any work done after `doneWaiting()` settles should be manually + * passed to an event's `waitUntil()` method (not this handler's + * `waitUntil()` method), otherwise the service worker thread my be killed + * prior to your work completing. + */ + async doneWaiting() { + let promise; + while (promise = this._extendLifetimePromises.shift()) { + await promise; + } + } + /** + * Stops running the strategy and immediately resolves any pending + * `waitUntil()` promises. + */ + destroy() { + this._handlerDeferred.resolve(null); + } + /** + * This method will call cacheWillUpdate on the available plugins (or use + * status === 200) to determine if the Response is safe and valid to cache. + * + * @param {Request} options.request + * @param {Response} options.response + * @return {Promise} + * + * @private + */ + async _ensureResponseSafeToCache(response) { + let responseToCache = response; + let pluginsUsed = false; + for (const callback of this.iterateCallbacks('cacheWillUpdate')) { + responseToCache = (await callback({ + request: this.request, + response: responseToCache, + event: this.event + })) || undefined; + pluginsUsed = true; + if (!responseToCache) { + break; + } + } + if (!pluginsUsed) { + if (responseToCache && responseToCache.status !== 200) { + responseToCache = undefined; + } + { + if (responseToCache) { + if (responseToCache.status !== 200) { + if (responseToCache.status === 0) { + logger.warn(`The response for '${this.request.url}' ` + `is an opaque response. The caching strategy that you're ` + `using will not cache opaque responses by default.`); + } else { + logger.debug(`The response for '${this.request.url}' ` + `returned a status code of '${response.status}' and won't ` + `be cached as a result.`); + } + } + } + } + } + return responseToCache; + } + } + + /* + Copyright 2020 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * An abstract base class that all other strategy classes must extend from: + * + * @memberof workbox-strategies + */ + class Strategy { + /** + * Creates a new instance of the strategy and sets all documented option + * properties as public instance properties. + * + * Note: if a custom strategy class extends the base Strategy class and does + * not need more than these properties, it does not need to define its own + * constructor. + * + * @param {Object} [options] + * @param {string} [options.cacheName] Cache name to store and retrieve + * requests. Defaults to the cache names provided by + * {@link workbox-core.cacheNames}. + * @param {Array} [options.plugins] [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins} + * to use in conjunction with this caching strategy. + * @param {Object} [options.fetchOptions] Values passed along to the + * [`init`](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters) + * of [non-navigation](https://github.com/GoogleChrome/workbox/issues/1796) + * `fetch()` requests made by this strategy. + * @param {Object} [options.matchOptions] The + * [`CacheQueryOptions`]{@link https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions} + * for any `cache.match()` or `cache.put()` calls made by this strategy. + */ + constructor(options = {}) { + /** + * Cache name to store and retrieve + * requests. Defaults to the cache names provided by + * {@link workbox-core.cacheNames}. + * + * @type {string} + */ + this.cacheName = cacheNames.getRuntimeName(options.cacheName); + /** + * The list + * [Plugins]{@link https://developers.google.com/web/tools/workbox/guides/using-plugins} + * used by this strategy. + * + * @type {Array} + */ + this.plugins = options.plugins || []; + /** + * Values passed along to the + * [`init`]{@link https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters} + * of all fetch() requests made by this strategy. + * + * @type {Object} + */ + this.fetchOptions = options.fetchOptions; + /** + * The + * [`CacheQueryOptions`]{@link https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions} + * for any `cache.match()` or `cache.put()` calls made by this strategy. + * + * @type {Object} + */ + this.matchOptions = options.matchOptions; + } + /** + * Perform a request strategy and returns a `Promise` that will resolve with + * a `Response`, invoking all relevant plugin callbacks. + * + * When a strategy instance is registered with a Workbox + * {@link workbox-routing.Route}, this method is automatically + * called when the route matches. + * + * Alternatively, this method can be used in a standalone `FetchEvent` + * listener by passing it to `event.respondWith()`. + * + * @param {FetchEvent|Object} options A `FetchEvent` or an object with the + * properties listed below. + * @param {Request|string} options.request A request to run this strategy for. + * @param {ExtendableEvent} options.event The event associated with the + * request. + * @param {URL} [options.url] + * @param {*} [options.params] + */ + handle(options) { + const [responseDone] = this.handleAll(options); + return responseDone; + } + /** + * Similar to {@link workbox-strategies.Strategy~handle}, but + * instead of just returning a `Promise` that resolves to a `Response` it + * it will return an tuple of `[response, done]` promises, where the former + * (`response`) is equivalent to what `handle()` returns, and the latter is a + * Promise that will resolve once any promises that were added to + * `event.waitUntil()` as part of performing the strategy have completed. + * + * You can await the `done` promise to ensure any extra work performed by + * the strategy (usually caching responses) completes successfully. + * + * @param {FetchEvent|Object} options A `FetchEvent` or an object with the + * properties listed below. + * @param {Request|string} options.request A request to run this strategy for. + * @param {ExtendableEvent} options.event The event associated with the + * request. + * @param {URL} [options.url] + * @param {*} [options.params] + * @return {Array} A tuple of [response, done] + * promises that can be used to determine when the response resolves as + * well as when the handler has completed all its work. + */ + handleAll(options) { + // Allow for flexible options to be passed. + if (options instanceof FetchEvent) { + options = { + event: options, + request: options.request + }; + } + const event = options.event; + const request = typeof options.request === 'string' ? new Request(options.request) : options.request; + const params = 'params' in options ? options.params : undefined; + const handler = new StrategyHandler(this, { + event, + request, + params + }); + const responseDone = this._getResponse(handler, request, event); + const handlerDone = this._awaitComplete(responseDone, handler, request, event); + // Return an array of promises, suitable for use with Promise.all(). + return [responseDone, handlerDone]; + } + async _getResponse(handler, request, event) { + await handler.runCallbacks('handlerWillStart', { + event, + request + }); + let response = undefined; + try { + response = await this._handle(request, handler); + // The "official" Strategy subclasses all throw this error automatically, + // but in case a third-party Strategy doesn't, ensure that we have a + // consistent failure when there's no response or an error response. + if (!response || response.type === 'error') { + throw new WorkboxError('no-response', { + url: request.url + }); + } + } catch (error) { + if (error instanceof Error) { + for (const callback of handler.iterateCallbacks('handlerDidError')) { + response = await callback({ + error, + event, + request + }); + if (response) { + break; + } + } + } + if (!response) { + throw error; + } else { + logger.log(`While responding to '${getFriendlyURL(request.url)}', ` + `an ${error instanceof Error ? error.toString() : ''} error occurred. Using a fallback response provided by ` + `a handlerDidError plugin.`); + } + } + for (const callback of handler.iterateCallbacks('handlerWillRespond')) { + response = await callback({ + event, + request, + response + }); + } + return response; + } + async _awaitComplete(responseDone, handler, request, event) { + let response; + let error; + try { + response = await responseDone; + } catch (error) { + // Ignore errors, as response errors should be caught via the `response` + // promise above. The `done` promise will only throw for errors in + // promises passed to `handler.waitUntil()`. + } + try { + await handler.runCallbacks('handlerDidRespond', { + event, + request, + response + }); + await handler.doneWaiting(); + } catch (waitUntilError) { + if (waitUntilError instanceof Error) { + error = waitUntilError; + } + } + await handler.runCallbacks('handlerDidComplete', { + event, + request, + response, + error: error + }); + handler.destroy(); + if (error) { + throw error; + } + } + } + /** + * Classes extending the `Strategy` based class should implement this method, + * and leverage the {@link workbox-strategies.StrategyHandler} + * arg to perform all fetching and cache logic, which will ensure all relevant + * cache, cache options, fetch options and plugins are used (per the current + * strategy instance). + * + * @name _handle + * @instance + * @abstract + * @function + * @param {Request} request + * @param {workbox-strategies.StrategyHandler} handler + * @return {Promise} + * + * @memberof workbox-strategies.Strategy + */ + + /* + Copyright 2020 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * A {@link workbox-strategies.Strategy} implementation + * specifically designed to work with + * {@link workbox-precaching.PrecacheController} + * to both cache and fetch precached assets. + * + * Note: an instance of this class is created automatically when creating a + * `PrecacheController`; it's generally not necessary to create this yourself. + * + * @extends workbox-strategies.Strategy + * @memberof workbox-precaching + */ + class PrecacheStrategy extends Strategy { + /** + * + * @param {Object} [options] + * @param {string} [options.cacheName] Cache name to store and retrieve + * requests. Defaults to the cache names provided by + * {@link workbox-core.cacheNames}. + * @param {Array} [options.plugins] {@link https://developers.google.com/web/tools/workbox/guides/using-plugins|Plugins} + * to use in conjunction with this caching strategy. + * @param {Object} [options.fetchOptions] Values passed along to the + * {@link https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters|init} + * of all fetch() requests made by this strategy. + * @param {Object} [options.matchOptions] The + * {@link https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions|CacheQueryOptions} + * for any `cache.match()` or `cache.put()` calls made by this strategy. + * @param {boolean} [options.fallbackToNetwork=true] Whether to attempt to + * get the response from the network if there's a precache miss. + */ + constructor(options = {}) { + options.cacheName = cacheNames.getPrecacheName(options.cacheName); + super(options); + this._fallbackToNetwork = options.fallbackToNetwork === false ? false : true; + // Redirected responses cannot be used to satisfy a navigation request, so + // any redirected response must be "copied" rather than cloned, so the new + // response doesn't contain the `redirected` flag. See: + // https://bugs.chromium.org/p/chromium/issues/detail?id=669363&desc=2#c1 + this.plugins.push(PrecacheStrategy.copyRedirectedCacheableResponsesPlugin); + } + /** + * @private + * @param {Request|string} request A request to run this strategy for. + * @param {workbox-strategies.StrategyHandler} handler The event that + * triggered the request. + * @return {Promise} + */ + async _handle(request, handler) { + const response = await handler.cacheMatch(request); + if (response) { + return response; + } + // If this is an `install` event for an entry that isn't already cached, + // then populate the cache. + if (handler.event && handler.event.type === 'install') { + return await this._handleInstall(request, handler); + } + // Getting here means something went wrong. An entry that should have been + // precached wasn't found in the cache. + return await this._handleFetch(request, handler); + } + async _handleFetch(request, handler) { + let response; + const params = handler.params || {}; + // Fall back to the network if we're configured to do so. + if (this._fallbackToNetwork) { + { + logger.warn(`The precached response for ` + `${getFriendlyURL(request.url)} in ${this.cacheName} was not ` + `found. Falling back to the network.`); + } + const integrityInManifest = params.integrity; + const integrityInRequest = request.integrity; + const noIntegrityConflict = !integrityInRequest || integrityInRequest === integrityInManifest; + // Do not add integrity if the original request is no-cors + // See https://github.com/GoogleChrome/workbox/issues/3096 + response = await handler.fetch(new Request(request, { + integrity: request.mode !== 'no-cors' ? integrityInRequest || integrityInManifest : undefined + })); + // It's only "safe" to repair the cache if we're using SRI to guarantee + // that the response matches the precache manifest's expectations, + // and there's either a) no integrity property in the incoming request + // or b) there is an integrity, and it matches the precache manifest. + // See https://github.com/GoogleChrome/workbox/issues/2858 + // Also if the original request users no-cors we don't use integrity. + // See https://github.com/GoogleChrome/workbox/issues/3096 + if (integrityInManifest && noIntegrityConflict && request.mode !== 'no-cors') { + this._useDefaultCacheabilityPluginIfNeeded(); + const wasCached = await handler.cachePut(request, response.clone()); + { + if (wasCached) { + logger.log(`A response for ${getFriendlyURL(request.url)} ` + `was used to "repair" the precache.`); + } + } + } + } else { + // This shouldn't normally happen, but there are edge cases: + // https://github.com/GoogleChrome/workbox/issues/1441 + throw new WorkboxError('missing-precache-entry', { + cacheName: this.cacheName, + url: request.url + }); + } + { + const cacheKey = params.cacheKey || (await handler.getCacheKey(request, 'read')); + // Workbox is going to handle the route. + // print the routing details to the console. + logger.groupCollapsed(`Precaching is responding to: ` + getFriendlyURL(request.url)); + logger.log(`Serving the precached url: ${getFriendlyURL(cacheKey instanceof Request ? cacheKey.url : cacheKey)}`); + logger.groupCollapsed(`View request details here.`); + logger.log(request); + logger.groupEnd(); + logger.groupCollapsed(`View response details here.`); + logger.log(response); + logger.groupEnd(); + logger.groupEnd(); + } + return response; + } + async _handleInstall(request, handler) { + this._useDefaultCacheabilityPluginIfNeeded(); + const response = await handler.fetch(request); + // Make sure we defer cachePut() until after we know the response + // should be cached; see https://github.com/GoogleChrome/workbox/issues/2737 + const wasCached = await handler.cachePut(request, response.clone()); + if (!wasCached) { + // Throwing here will lead to the `install` handler failing, which + // we want to do if *any* of the responses aren't safe to cache. + throw new WorkboxError('bad-precaching-response', { + url: request.url, + status: response.status + }); + } + return response; + } + /** + * This method is complex, as there a number of things to account for: + * + * The `plugins` array can be set at construction, and/or it might be added to + * to at any time before the strategy is used. + * + * At the time the strategy is used (i.e. during an `install` event), there + * needs to be at least one plugin that implements `cacheWillUpdate` in the + * array, other than `copyRedirectedCacheableResponsesPlugin`. + * + * - If this method is called and there are no suitable `cacheWillUpdate` + * plugins, we need to add `defaultPrecacheCacheabilityPlugin`. + * + * - If this method is called and there is exactly one `cacheWillUpdate`, then + * we don't have to do anything (this might be a previously added + * `defaultPrecacheCacheabilityPlugin`, or it might be a custom plugin). + * + * - If this method is called and there is more than one `cacheWillUpdate`, + * then we need to check if one is `defaultPrecacheCacheabilityPlugin`. If so, + * we need to remove it. (This situation is unlikely, but it could happen if + * the strategy is used multiple times, the first without a `cacheWillUpdate`, + * and then later on after manually adding a custom `cacheWillUpdate`.) + * + * See https://github.com/GoogleChrome/workbox/issues/2737 for more context. + * + * @private + */ + _useDefaultCacheabilityPluginIfNeeded() { + let defaultPluginIndex = null; + let cacheWillUpdatePluginCount = 0; + for (const [index, plugin] of this.plugins.entries()) { + // Ignore the copy redirected plugin when determining what to do. + if (plugin === PrecacheStrategy.copyRedirectedCacheableResponsesPlugin) { + continue; + } + // Save the default plugin's index, in case it needs to be removed. + if (plugin === PrecacheStrategy.defaultPrecacheCacheabilityPlugin) { + defaultPluginIndex = index; + } + if (plugin.cacheWillUpdate) { + cacheWillUpdatePluginCount++; + } + } + if (cacheWillUpdatePluginCount === 0) { + this.plugins.push(PrecacheStrategy.defaultPrecacheCacheabilityPlugin); + } else if (cacheWillUpdatePluginCount > 1 && defaultPluginIndex !== null) { + // Only remove the default plugin; multiple custom plugins are allowed. + this.plugins.splice(defaultPluginIndex, 1); + } + // Nothing needs to be done if cacheWillUpdatePluginCount is 1 + } + } + + PrecacheStrategy.defaultPrecacheCacheabilityPlugin = { + async cacheWillUpdate({ + response + }) { + if (!response || response.status >= 400) { + return null; + } + return response; + } + }; + PrecacheStrategy.copyRedirectedCacheableResponsesPlugin = { + async cacheWillUpdate({ + response + }) { + return response.redirected ? await copyResponse(response) : response; + } + }; + + /* + 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. + */ + /** + * Performs efficient precaching of assets. + * + * @memberof workbox-precaching + */ + class PrecacheController { + /** + * Create a new PrecacheController. + * + * @param {Object} [options] + * @param {string} [options.cacheName] The cache to use for precaching. + * @param {string} [options.plugins] Plugins to use when precaching as well + * as responding to fetch events for precached assets. + * @param {boolean} [options.fallbackToNetwork=true] Whether to attempt to + * get the response from the network if there's a precache miss. + */ + constructor({ + cacheName, + plugins = [], + fallbackToNetwork = true + } = {}) { + this._urlsToCacheKeys = new Map(); + this._urlsToCacheModes = new Map(); + this._cacheKeysToIntegrities = new Map(); + this._strategy = new PrecacheStrategy({ + cacheName: cacheNames.getPrecacheName(cacheName), + plugins: [...plugins, new PrecacheCacheKeyPlugin({ + precacheController: this + })], + fallbackToNetwork + }); + // Bind the install and activate methods to the instance. + this.install = this.install.bind(this); + this.activate = this.activate.bind(this); + } + /** + * @type {workbox-precaching.PrecacheStrategy} The strategy created by this controller and + * used to cache assets and respond to fetch events. + */ + get strategy() { + return this._strategy; + } + /** + * Adds items to the precache list, removing any duplicates and + * stores the files in the + * {@link workbox-core.cacheNames|"precache cache"} when the service + * worker installs. + * + * This method can be called multiple times. + * + * @param {Array} [entries=[]] Array of entries to precache. + */ + precache(entries) { + this.addToCacheList(entries); + if (!this._installAndActiveListenersAdded) { + self.addEventListener('install', this.install); + self.addEventListener('activate', this.activate); + this._installAndActiveListenersAdded = true; + } + } + /** + * This method will add items to the precache list, removing duplicates + * and ensuring the information is valid. + * + * @param {Array} entries + * Array of entries to precache. + */ + addToCacheList(entries) { + { + finalAssertExports.isArray(entries, { + moduleName: 'workbox-precaching', + className: 'PrecacheController', + funcName: 'addToCacheList', + paramName: 'entries' + }); + } + const urlsToWarnAbout = []; + for (const entry of entries) { + // See https://github.com/GoogleChrome/workbox/issues/2259 + if (typeof entry === 'string') { + urlsToWarnAbout.push(entry); + } else if (entry && entry.revision === undefined) { + urlsToWarnAbout.push(entry.url); + } + const { + cacheKey, + url + } = createCacheKey(entry); + const cacheMode = typeof entry !== 'string' && entry.revision ? 'reload' : 'default'; + if (this._urlsToCacheKeys.has(url) && this._urlsToCacheKeys.get(url) !== cacheKey) { + throw new WorkboxError('add-to-cache-list-conflicting-entries', { + firstEntry: this._urlsToCacheKeys.get(url), + secondEntry: cacheKey + }); + } + if (typeof entry !== 'string' && entry.integrity) { + if (this._cacheKeysToIntegrities.has(cacheKey) && this._cacheKeysToIntegrities.get(cacheKey) !== entry.integrity) { + throw new WorkboxError('add-to-cache-list-conflicting-integrities', { + url + }); + } + this._cacheKeysToIntegrities.set(cacheKey, entry.integrity); + } + this._urlsToCacheKeys.set(url, cacheKey); + this._urlsToCacheModes.set(url, cacheMode); + if (urlsToWarnAbout.length > 0) { + const warningMessage = `Workbox is precaching URLs without revision ` + `info: ${urlsToWarnAbout.join(', ')}\nThis is generally NOT safe. ` + `Learn more at https://bit.ly/wb-precache`; + { + logger.warn(warningMessage); + } + } + } + } + /** + * Precaches new and updated assets. Call this method from the service worker + * install event. + * + * Note: this method calls `event.waitUntil()` for you, so you do not need + * to call it yourself in your event handlers. + * + * @param {ExtendableEvent} event + * @return {Promise} + */ + install(event) { + // waitUntil returns Promise + // eslint-disable-next-line @typescript-eslint/no-unsafe-return + return waitUntil(event, async () => { + const installReportPlugin = new PrecacheInstallReportPlugin(); + this.strategy.plugins.push(installReportPlugin); + // Cache entries one at a time. + // See https://github.com/GoogleChrome/workbox/issues/2528 + for (const [url, cacheKey] of this._urlsToCacheKeys) { + const integrity = this._cacheKeysToIntegrities.get(cacheKey); + const cacheMode = this._urlsToCacheModes.get(url); + const request = new Request(url, { + integrity, + cache: cacheMode, + credentials: 'same-origin' + }); + await Promise.all(this.strategy.handleAll({ + params: { + cacheKey + }, + request, + event + })); + } + const { + updatedURLs, + notUpdatedURLs + } = installReportPlugin; + { + printInstallDetails(updatedURLs, notUpdatedURLs); + } + return { + updatedURLs, + notUpdatedURLs + }; + }); + } + /** + * Deletes assets that are no longer present in the current precache manifest. + * Call this method from the service worker activate event. + * + * Note: this method calls `event.waitUntil()` for you, so you do not need + * to call it yourself in your event handlers. + * + * @param {ExtendableEvent} event + * @return {Promise} + */ + activate(event) { + // waitUntil returns Promise + // eslint-disable-next-line @typescript-eslint/no-unsafe-return + return waitUntil(event, async () => { + const cache = await self.caches.open(this.strategy.cacheName); + const currentlyCachedRequests = await cache.keys(); + const expectedCacheKeys = new Set(this._urlsToCacheKeys.values()); + const deletedURLs = []; + for (const request of currentlyCachedRequests) { + if (!expectedCacheKeys.has(request.url)) { + await cache.delete(request); + deletedURLs.push(request.url); + } + } + { + printCleanupDetails(deletedURLs); + } + return { + deletedURLs + }; + }); + } + /** + * Returns a mapping of a precached URL to the corresponding cache key, taking + * into account the revision information for the URL. + * + * @return {Map} A URL to cache key mapping. + */ + getURLsToCacheKeys() { + return this._urlsToCacheKeys; + } + /** + * Returns a list of all the URLs that have been precached by the current + * service worker. + * + * @return {Array} The precached URLs. + */ + getCachedURLs() { + return [...this._urlsToCacheKeys.keys()]; + } + /** + * Returns the cache key used for storing a given URL. If that URL is + * unversioned, like `/index.html', then the cache key will be the original + * URL with a search parameter appended to it. + * + * @param {string} url A URL whose cache key you want to look up. + * @return {string} The versioned URL that corresponds to a cache key + * for the original URL, or undefined if that URL isn't precached. + */ + getCacheKeyForURL(url) { + const urlObject = new URL(url, location.href); + return this._urlsToCacheKeys.get(urlObject.href); + } + /** + * @param {string} url A cache key whose SRI you want to look up. + * @return {string} The subresource integrity associated with the cache key, + * or undefined if it's not set. + */ + getIntegrityForCacheKey(cacheKey) { + return this._cacheKeysToIntegrities.get(cacheKey); + } + /** + * This acts as a drop-in replacement for + * [`cache.match()`](https://developer.mozilla.org/en-US/docs/Web/API/Cache/match) + * with the following differences: + * + * - It knows what the name of the precache is, and only checks in that cache. + * - It allows you to pass in an "original" URL without versioning parameters, + * and it will automatically look up the correct cache key for the currently + * active revision of that URL. + * + * E.g., `matchPrecache('index.html')` will find the correct precached + * response for the currently active service worker, even if the actual cache + * key is `'/index.html?__WB_REVISION__=1234abcd'`. + * + * @param {string|Request} request The key (without revisioning parameters) + * to look up in the precache. + * @return {Promise} + */ + async matchPrecache(request) { + const url = request instanceof Request ? request.url : request; + const cacheKey = this.getCacheKeyForURL(url); + if (cacheKey) { + const cache = await self.caches.open(this.strategy.cacheName); + return cache.match(cacheKey); + } + return undefined; + } + /** + * Returns a function that looks up `url` in the precache (taking into + * account revision information), and returns the corresponding `Response`. + * + * @param {string} url The precached URL which will be used to lookup the + * `Response`. + * @return {workbox-routing~handlerCallback} + */ + createHandlerBoundToURL(url) { + const cacheKey = this.getCacheKeyForURL(url); + if (!cacheKey) { + throw new WorkboxError('non-precached-url', { + url + }); + } + return options => { + options.request = new Request(url); + options.params = Object.assign({ + cacheKey + }, options.params); + return this.strategy.handle(options); + }; + } + } + + /* + 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 precacheController; + /** + * @return {PrecacheController} + * @private + */ + const getOrCreatePrecacheController = () => { + if (!precacheController) { + precacheController = new PrecacheController(); + } + return precacheController; + }; + + /* + Copyright 2018 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * Removes any URL search parameters that should be ignored. + * + * @param {URL} urlObject The original URL. + * @param {Array} ignoreURLParametersMatching RegExps to test against + * each search parameter name. Matches mean that the search parameter should be + * ignored. + * @return {URL} The URL with any ignored search parameters removed. + * + * @private + * @memberof workbox-precaching + */ + function removeIgnoredSearchParams(urlObject, ignoreURLParametersMatching = []) { + // Convert the iterable into an array at the start of the loop to make sure + // deletion doesn't mess up iteration. + for (const paramName of [...urlObject.searchParams.keys()]) { + if (ignoreURLParametersMatching.some(regExp => regExp.test(paramName))) { + urlObject.searchParams.delete(paramName); + } + } + return urlObject; + } + + /* + 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. + */ + /** + * Generator function that yields possible variations on the original URL to + * check, one at a time. + * + * @param {string} url + * @param {Object} options + * + * @private + * @memberof workbox-precaching + */ + function* generateURLVariations(url, { + ignoreURLParametersMatching = [/^utm_/, /^fbclid$/], + directoryIndex = 'index.html', + cleanURLs = true, + urlManipulation + } = {}) { + const urlObject = new URL(url, location.href); + urlObject.hash = ''; + yield urlObject.href; + const urlWithoutIgnoredParams = removeIgnoredSearchParams(urlObject, ignoreURLParametersMatching); + yield urlWithoutIgnoredParams.href; + if (directoryIndex && urlWithoutIgnoredParams.pathname.endsWith('/')) { + const directoryURL = new URL(urlWithoutIgnoredParams.href); + directoryURL.pathname += directoryIndex; + yield directoryURL.href; + } + if (cleanURLs) { + const cleanURL = new URL(urlWithoutIgnoredParams.href); + cleanURL.pathname += '.html'; + yield cleanURL.href; + } + if (urlManipulation) { + const additionalURLs = urlManipulation({ + url: urlObject + }); + for (const urlToAttempt of additionalURLs) { + yield urlToAttempt.href; + } + } + } + + /* + Copyright 2020 Google LLC + + Use of this source code is governed by an MIT-style + license that can be found in the LICENSE file or at + https://opensource.org/licenses/MIT. + */ + /** + * A subclass of {@link workbox-routing.Route} that takes a + * {@link workbox-precaching.PrecacheController} + * instance and uses it to match incoming requests and handle fetching + * responses from the precache. + * + * @memberof workbox-precaching + * @extends workbox-routing.Route + */ + class PrecacheRoute extends Route { + /** + * @param {PrecacheController} precacheController A `PrecacheController` + * instance used to both match requests and respond to fetch events. + * @param {Object} [options] Options to control how requests are matched + * against the list of precached URLs. + * @param {string} [options.directoryIndex=index.html] The `directoryIndex` will + * check cache entries for a URLs ending with '/' to see if there is a hit when + * appending the `directoryIndex` value. + * @param {Array} [options.ignoreURLParametersMatching=[/^utm_/, /^fbclid$/]] An + * array of regex's to remove search params when looking for a cache match. + * @param {boolean} [options.cleanURLs=true] The `cleanURLs` option will + * check the cache for the URL with a `.html` added to the end of the end. + * @param {workbox-precaching~urlManipulation} [options.urlManipulation] + * This is a function that should take a URL and return an array of + * alternative URLs that should be checked for precache matches. + */ + constructor(precacheController, options) { + const match = ({ + request + }) => { + const urlsToCacheKeys = precacheController.getURLsToCacheKeys(); + for (const possibleURL of generateURLVariations(request.url, options)) { + const cacheKey = urlsToCacheKeys.get(possibleURL); + if (cacheKey) { + const integrity = precacheController.getIntegrityForCacheKey(cacheKey); + return { + cacheKey, + integrity + }; + } + } + { + logger.debug(`Precaching did not find a match for ` + getFriendlyURL(request.url)); + } + return; + }; + super(match, precacheController.strategy); + } + } + + /* + 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. + */ + /** + * Add a `fetch` listener to the service worker that will + * respond to + * [network requests]{@link https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API/Using_Service_Workers#Custom_responses_to_requests} + * with precached assets. + * + * Requests for assets that aren't precached, the `FetchEvent` will not be + * responded to, allowing the event to fall through to other `fetch` event + * listeners. + * + * @param {Object} [options] See the {@link workbox-precaching.PrecacheRoute} + * options. + * + * @memberof workbox-precaching + */ + function addRoute(options) { + const precacheController = getOrCreatePrecacheController(); + const precacheRoute = new PrecacheRoute(precacheController, options); + registerRoute(precacheRoute); + } + + /* + 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. + */ + /** + * Adds items to the precache list, removing any duplicates and + * stores the files in the + * {@link workbox-core.cacheNames|"precache cache"} when the service + * worker installs. + * + * This method can be called multiple times. + * + * Please note: This method **will not** serve any of the cached files for you. + * It only precaches files. To respond to a network request you call + * {@link workbox-precaching.addRoute}. + * + * If you have a single array of files to precache, you can just call + * {@link workbox-precaching.precacheAndRoute}. + * + * @param {Array} [entries=[]] Array of entries to precache. + * + * @memberof workbox-precaching + */ + function precache(entries) { + const precacheController = getOrCreatePrecacheController(); + precacheController.precache(entries); + } + + /* + 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. + */ + /** + * This method will add entries to the precache list and add a route to + * respond to fetch events. + * + * This is a convenience method that will call + * {@link workbox-precaching.precache} and + * {@link workbox-precaching.addRoute} in a single call. + * + * @param {Array} entries Array of entries to precache. + * @param {Object} [options] See the + * {@link workbox-precaching.PrecacheRoute} options. + * + * @memberof workbox-precaching + */ + function precacheAndRoute(entries, options) { + precache(entries); + addRoute(options); + } + + /* + 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. + */ + const SUBSTRING_TO_FIND = '-precache-'; + /** + * Cleans up incompatible precaches that were created by older versions of + * Workbox, by a service worker registered under the current scope. + * + * This is meant to be called as part of the `activate` event. + * + * This should be safe to use as long as you don't include `substringToFind` + * (defaulting to `-precache-`) in your non-precache cache names. + * + * @param {string} currentPrecacheName The cache name currently in use for + * precaching. This cache won't be deleted. + * @param {string} [substringToFind='-precache-'] Cache names which include this + * substring will be deleted (excluding `currentPrecacheName`). + * @return {Array} A list of all the cache names that were deleted. + * + * @private + * @memberof workbox-precaching + */ + const deleteOutdatedCaches = async (currentPrecacheName, substringToFind = SUBSTRING_TO_FIND) => { + const cacheNames = await self.caches.keys(); + const cacheNamesToDelete = cacheNames.filter(cacheName => { + return cacheName.includes(substringToFind) && cacheName.includes(self.registration.scope) && cacheName !== currentPrecacheName; + }); + await Promise.all(cacheNamesToDelete.map(cacheName => self.caches.delete(cacheName))); + return cacheNamesToDelete; + }; + + /* + 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. + */ + /** + * Adds an `activate` event listener which will clean up incompatible + * precaches that were created by older versions of Workbox. + * + * @memberof workbox-precaching + */ + function cleanupOutdatedCaches() { + // See https://github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705 + self.addEventListener('activate', event => { + const cacheName = cacheNames.getPrecacheName(); + event.waitUntil(deleteOutdatedCaches(cacheName).then(cachesDeleted => { + { + if (cachesDeleted.length > 0) { + logger.log(`The following out-of-date precaches were cleaned up ` + `automatically:`, cachesDeleted); + } + } + })); + }); + } + + /* + 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 + * {@link 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 + * {@link https://fetch.spec.whatwg.org/#concept-request-mode|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 workbox-routing + * @extends 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. + * + * *Note*: These RegExps may be evaluated against every destination URL during + * a navigation. Avoid using + * [complex RegExps](https://github.com/GoogleChrome/workbox/issues/3077), + * or else your users may see delays when navigating your site. + * + * @param {workbox-routing~handlerCallback} handler A callback + * function that returns a Promise resulting in a Response. + * @param {Object} options + * @param {Array} [options.denylist] If any of these patterns match, + * the route will not handle the request (even if a allowlist RegExp matches). + * @param {Array} [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 = [] + } = {}) { + { + finalAssertExports.isArrayOfClass(allowlist, RegExp, { + moduleName: 'workbox-routing', + className: 'NavigationRoute', + funcName: 'constructor', + paramName: 'options.allowlist' + }); + finalAssertExports.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.log(`The navigation route ${pathnameAndSearch} is not ` + `being used, since the URL matches this denylist pattern: ` + `${regExp.toString()}`); + } + return false; + } + } + if (this._allowlist.some(regExp => regExp.test(pathnameAndSearch))) { + { + logger.debug(`The navigation route ${pathnameAndSearch} ` + `is being used.`); + } + return true; + } + { + logger.log(`The navigation route ${pathnameAndSearch} is not ` + `being used, since the URL being navigated to doesn't ` + `match the allowlist.`); + } + return false; + } + } + + /* + 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. + */ + /** + * Helper function that calls + * {@link PrecacheController#createHandlerBoundToURL} on the default + * {@link PrecacheController} instance. + * + * If you are creating your own {@link PrecacheController}, then call the + * {@link PrecacheController#createHandlerBoundToURL} on that instance, + * instead of using this function. + * + * @param {string} url The precached URL which will be used to lookup the + * `Response`. + * @param {boolean} [fallbackToNetwork=true] Whether to attempt to get the + * response from the network if there's a precache miss. + * @return {workbox-routing~handlerCallback} + * + * @memberof workbox-precaching + */ + function createHandlerBoundToURL(url) { + const precacheController = getOrCreatePrecacheController(); + return precacheController.createHandlerBoundToURL(url); + } + + exports.NavigationRoute = NavigationRoute; + exports.cleanupOutdatedCaches = cleanupOutdatedCaches; + exports.clientsClaim = clientsClaim; + exports.createHandlerBoundToURL = createHandlerBoundToURL; + exports.precacheAndRoute = precacheAndRoute; + exports.registerRoute = registerRoute; + +})); diff --git a/public/antoniana.jpg b/public/antoniana.jpg new file mode 100644 index 0000000000000000000000000000000000000000..68cb2660b2edca20c6d5eac67b1dc53fe107b2b9 GIT binary patch literal 135240 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 hhTuTdl|Jgx1LFxbi literal 0 HcmV?d00001 diff --git a/public/segnap-192x192.png b/public/segnap-192x192.png new file mode 100644 index 0000000000000000000000000000000000000000..ccb825c75d7863792192a198c98727ad4f87060b GIT binary patch literal 49067 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

*LT7b--(Sc4!LrSD6Uy>xj7?qg< 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�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 z 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%0AI)AZ&{w-8dI+b8ogdi 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
GTQ_gTKRIj&`2ZQNaXBYK0g9h&%o z9c`8TkB=$dbzDz{6S^nx#J`Y_{~Px)E0t5#d-Y+F;SA~z)rV!4&lv!+ zbs8KpwrLr%j7dX&f$=l1-CTBE+fL~hmX^Khmz);0b#(yaW<*SEbCE9k>Af{#zm`-A z?_LTxX3B+gIE4;0o5jbZ)4U)V!+3X6Ha{$r^m%9 z;v$TLOa0l2b#!M&?H=3e8Ar^+X~-gSM{mPIypM_0n+)!$MSbYPy0HALe!vL^<7F`k zWQ5y1y)yeNnHno9s>92?6|EynR1u|&wwuGL)f>Uj7Z)-vlN9ES@O;@-GtbZ~7~iKv zo5|*vm6qNnjbLSYM`T{C?uuL;?Y^=>Mrf!`z%WG5T8gyG^@Kaed3|gw5)YHcV-rf| z>b_iDIKuldeRf`C*^LvFx z(LCIJ^$E63VK#Kqnv+90a#?F_2|y1Q5GSXpub&2=pbO>05f#8pk5hX0qDLP>@eV?x zeRXW>%80;~So%1rG;82IoXD&X;x4N|aea1r>NFDBZ7Ps4vU#%cp1T0FG{UDpUZ|i_ zRB%dFq zlaKQBDSEJpe&{s!c7iW64szV=_&9mDcTdzyfoS+wJBQw!+H~|DYx>pOi3J2}xq&cM zLd)+wOUv89O|5-zCHqwlCZ?nB9yLu};RaOldOC^Sb%J+M&NJmpwQi1n4qux)2M5^- zf`9VF;j<_8$M#DkSD$vDu-u%Q4Qf?*f4DqJV!D`H*KOw^W+`{~UH@iuUq5I=$Ye$2 zWwH7GZXXB1-DTpsMt9f|Ald!c5R@M8gz%#BIoCwoj zw8;fN(j%bLQ&WmrBDWy5J{9!Ul9Hb;1L#Dh!0ia(n@3J?b{|N29_6gix1|l6(F?(?0GI8p43)T zp4=X%y=Dj47y4DY4-*`U)t|ZMFOO!2U#8+vD+ltIwYO^zu&t|Vp0>Od$NKm**#DiP z%k#YCZcRKr9>PRag}Al3Zn4`FNzoG@9%sx9-bfw!GvqtRq>sArR1w?X`SP1vVMGmK z!A??%X4_#Z83KY~ey0Nqw_RPEjohIeRQT)!jOZHugg6aL^eoL(LXL?STlmwX-|+k{ z&-~`Du6b=3W%k{j4;?do8Hc}>B&@Z!%)I12j(sufcDmaJ8}4fNre>-dWw{v&LVJ;q zG4%bb8V$eSth#H>yd6nz^csNnk%28F3qfSzW}j2K2BUd|$p*>*k>G)l&ck}T&n`d^ z%=$>;#ugyW7(l0-!0AWD`}Ygb#CU<2L?G|#2YBxCyU61w>O=K0+_p19_ctfdk|yWP zx1b__$ni8Y1M^)&j{J$GwkB0H%J{mpKY!uJE&o>{BjrtMVd$_aZ_7MD;{3|mxv*L!AZA`tMy{ss9g8<8r^cs`I)F{oXFl_ z>e;u00m3_?kdf!J%Y3EvBA5{doD(X$y?rKAIz_HZ zH8j(HalzE7-))w;`E;+MOW#P>@9(CluTE@OC)?V1a81Ty+XPQVxeC^9AlWf&GV{*m zyuv47SA$9KV<>#$#7-%GONFFLe|`Q2|z5+Le&z}+(WoWMZTXmw?!&HM5gaAN=c{nb@(4>AQ8>y>`WRY<<#vD0aB zEr)*qbjF8`yOkRWFr+A_wVo91uJn_4&$~Z%rFNLeAjp#_@1CN3KzHcQ4{wZ~&TMdX z8UYC;zlwgFp{{VA8fHJ5x#x@(z;qm8qa2*gA89m8aS*w^=#K{rnhXLK37PzOLM)mro7IJ z53ry1a;?WBW2mB(ZDb-DOmHm1+^Gb3O&S+?7}k^b^~6Sjo>@85>b`qg;xK|+&rLqrPor^(V4qLwDl z9*VN|kB`FZUPfA_-Z^NJzMv#2N5I zC=vUd%WXc_g-U5;z85B|=Kvhy1zxx%>P6AyqHXo{JQ>Pq2t0Le2BS4z^Y}l@?Vi2p z)Vaxh7E!=t-pPTxL2FU#Xs&25H)KN!KDg<#YU|+ePbf637e~7E9Yfpg@EPmM@icXY zV!)u*Dagdd~-h)+%N4=%%~5@(@(PsQ!Ox;I8T z-#nE}w6Fi16h&ipwH0f8-PfaB(m8EORDi-m81z#dNv6FfE%iP$l{sp^o9GVsepZS@ zP;w_HOC{`ZqO}=-!b@++YX-dqmkcNu!*rOa6?Eums@$;bHrRQQnG@I)I~53^TN#nI z5dYXme~a>-BI@jDzEd?7(o*7@wp9&|r53{bVFvW&{T~#%O_hS_kw{bGd~;M)DZdOhU$*|8)bwCHSW>?) zzvii2CDzs)6J7T66IlD841*3HhtWq+QDu;Lc*aLWV{6R#!G&mnJ-5-K0DcSn5jF?p zZYGx=3dQ``iQXMfh|9S=7`4Qv_Q`o=YHDh3?jkP6`@zx51LSo8!RzVzV3OlPZ9jZo z$$Hs4Z$2>xKCu1)koPjH+=dAtk@Ng9w-S)!L>jQa)rmyBwLt4@MQ?uNwr{`{~ zAG-G24JSmLCAu|d=Tf2~j&qC|%7Z5q^tcm|8Fc+ z|7Us(nXo75oWN=ctVMCArlk#+My&C@Ce4g9U>&TCKHSJB)OIGvTQflLdC+XtS1vbS zyuRPv8MGz4@J$W<6g?ag8rlk1NHip3DYQ?LuWO%j?PUh1x}$ZdG#*EHb>^$}HMAF# zZhqw^2SdKv@Z;)IAHS~7G$RrB4&ARmcgSykqJW2ELDTP4^o^#d2jls3X1!Xg{&?Cp z?VFK?O`i+XL>$K=xv$9#TCp>+1Qi&}kp?nOWuZ;B)`<)R(r#QXmlF+sM}0FDl5b0? zuKPyGn~$l<*N3Wvg?Jx!m9kU+sUX;RP##M;1}xz5WjUIu`9(_@2=>5)mQFwU&6jO? zb{F?a$4>s3wK;E^2&&bGOewbo>!M)*7lPPyi`TM@2#(>Zbxxl6YFS+Bfg-PQv_awZ z%D!+pT(pRfR-B;+muIu>_sgN1inF3O^7;k5Kbv4-6tN~u!DdB8t)xE-$efbH*ad#j&0>9b2HV_1`2U)9DcI<>DuZD*Mu?JNaVm!h&rB=4a< zZ_ik$d403~o7ZhGEc9tP`x>3dzb=sS$X{h6WsYaFDF3S;?cuNz0WHQ;6qJ^h79g0a z1rsSy5pSGavSBD4bt#?$N&=i}2r>5uk#Fi4olss{YGY$VEb4ocFP{MF*~y6sn69p_ zp32AXF7(B!+Y(k4fXPpPZE4tSJ$H@I;*lp!@da|cZO6^Vur>n;q z3qtwi=dJ1xTSl>lE0-l<1pp7rEpF|{18-Q{E=*-*Lm3okzQy%F zj<9xR!wCxWUgb@ArKss22B;gL0t0p1VkKzF*RL63HTMo#qSMgmyF|i z1`bcgf1@N6NPItk6E=RO^lBu_SAKx(<_>GLeJ}o$L9H9{x`0Mdl?kp!Q(IoAAJzQk z%c~DvKgx553sikcI7YSN&OAej{jMhOWPRIMac^4A?{7C9FH;Zs3)v)l&%Vy6XlZzJL3F-a_`fcoHd^f>v*#6;pz0fRnWSx;RSmAHv6CrSeNh(K2B zUg8(v(Sr4sZ&0C$gCLqVIx{GO`2_^^C8VhNxJ!0LFlKGlt-8+!>*dGmD4KIb>4AV;iv#zLGQUzo6{0$=`*hey-iKoZLRE>;` zz#dXpU%U1Nvr`M8C8f(yzHU3@i(cbUXsky>yHFGu{5^WLx>S8Ufi)|95mVP@IOP8I(^WMf%t5xl)koA(buX`aJ?3()pJyTp8S6AT!n?QU`JI_X$Kx1wsD)|0g2W}G|i>^iq{j3K%9gG&HEv)AaTvR(?#rH0(DB{o}~K*^D4$ z9ufhzOVNv8Oxl<-s)G^rq@$-gJo@uhyT&D4KZ^oU4pM~gC+yb4%JZ>w?WBDBT$mP} z&5eG&-w&(ez%-LL`2iR1WAZC*Kdoav>k_qDZOuzE0MX+HWVaN6d5&2zkJ!;kA8A}PTKeUxjfaX8)Nld-$H49;!Jb1=V~Q| zQYwlRO&!6IN$QKZseqq2YEM;^Awd}a=bz5WkUUI#%`OAJY&?s8)q~%A1TGs8KP3C` z(F^3ZuHfYQ*%1Kv@}^aCQWg_d@svXcYA=k20wX z=K3l05y`Z>U!ZO){62Tyh_iD~0?P%um(R%P!R$N}gHuo4MykHOnt@|kifA)|`emAa%l=oO13gLS`<sOMDPh@GF$l=z`UQ6}N1MWGG}u6iPNDi<{g>*I%qyCZn8mm2rtMN+w~;D25?I8ntt@V6hye-u~Ql_laTc?ym1@uT_7+JuCLB?qO@q1Y(+`+#^HV2u%U*}KCl-EV1US}oW(tDu5VTP*UZ$Sa^(heP>p&FP+^R}1Fe5U6D-o>s9@<_)Yn_B?@4jY@|h<9LJ0nM z5I>o~9Jdh~r63a>CW2?doj-pXtEi}GYis-Y-Gji3>+5SQQh}+-$;sJSUOql6Msf>k z8`ue(eBT~3^XkMAxzAUDt`s~i5~OalwMolNO}B-{I4HiU$kMdt)*L5*ElTcDojy!# zf22dS-442WA17pia08{n^xKpcO$cZ?Aa^HuG9J@3B{E}zp(bg^VkH{rfgMt@rd34J z<6t)tg-A+Df)^(gi~L}J9~jb`5P@5YJ|dzUFp4k&J1`hEp{LJ3Mi&vy+02s{zgN)jM(y)NzRngtSizEYq%AA~jmt_jnp&5-%B!~Yr-K$cu32(;- z^=(S_bQ<$}R2dONY8xPJ&8>_c|Cxn+ziVB4o!7a(VEs3KE-vgK=|#*pvKrhCpUK>= zE`W&+7tge2wA?cpsgyqs$#02zzgK_(7{Er5Gv=f}7!0p%9qtPzgo=n)i~ng%i=d8& z=@KL{x{{C$cHm0U$V;a_lQFQFfLe9)yAiRQ%JSw}m9O#fyrJtQ#eVXi!zBX2uDnOW zf1qyhdfO{2Af9cIww^TYRb&BfXFN2eP&X%<484=DDxX@DJVQZkMfTG=?tlJ$#Icme zXrH`fmzUp~6X*A>pi5)4f+r(LIJ`c@SETm@*z8oyhzM@Z&umQSE|)YIHArh7e1#Yf zk3{+Q#^lN@fpb`i)Bf`2i>T;#Y#fFODJUsvcK=*e%?uxdl3u(yBS93G8i{%}BQ8MS z3#DnFJp9!aN9(m8zokA1=y^O}%cuSPN2bpk+AW(TIz)suVup^4CKJf@x*Xs7cRUVz z_3+p;f%(7e5OA14Adm|c|5;k_=fk#yJX|*a`^*3TjsJJo<3Er2|9sg07r${odWU6z X`gN!8Dz^ZvC`4XbS*k+9IPiY~;90To literal 0 HcmV?d00001 diff --git a/vite.config.js b/vite.config.js index 2df787b..ebadfd0 100644 --- a/vite.config.js +++ b/vite.config.js @@ -8,7 +8,27 @@ export default defineConfig({ plugins: [ vue(), VitePWA({ - registerType: 'autoUpdate' + registerType: 'autoUpdate', + manifest: { + name: "app_segnap", + short_name: "segnap", + description: "Segnapunti standalone.", + background_color: "#eee", + theme_color: '#ffffff', + orientation: "landscape", + icons: [ + { + src: 'segnap-192x192.png', + sizes: '192x192', + type: 'image/png' + }, + { + src: 'segnap-512x512.png', + sizes: '512x512', + type: 'image/png' + } + ] + } }) ], })