diff options
Diffstat (limited to 'node_modules/workbox-precaching')
16 files changed, 1537 insertions, 0 deletions
diff --git a/node_modules/workbox-precaching/LICENSE b/node_modules/workbox-precaching/LICENSE new file mode 100644 index 00000000..136b9039 --- /dev/null +++ b/node_modules/workbox-precaching/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "{}" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2017 Google, Inc. + + 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. diff --git a/node_modules/workbox-precaching/README.md b/node_modules/workbox-precaching/README.md new file mode 100644 index 00000000..c1f629bc --- /dev/null +++ b/node_modules/workbox-precaching/README.md @@ -0,0 +1 @@ +This module's documentation can be found at https://developers.google.com/web/tools/workbox/modules/workbox-precaching diff --git a/node_modules/workbox-precaching/_default.mjs b/node_modules/workbox-precaching/_default.mjs new file mode 100644 index 00000000..b791572d --- /dev/null +++ b/node_modules/workbox-precaching/_default.mjs @@ -0,0 +1,305 @@ +/* + Copyright 2017 Google Inc. + + 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 + + https://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. +*/ + +import {assert} from 'workbox-core/_private/assert.mjs'; +import {cacheNames} from 'workbox-core/_private/cacheNames.mjs'; +import {logger} from 'workbox-core/_private/logger.mjs'; +import {getFriendlyURL} from 'workbox-core/_private/getFriendlyURL.mjs'; +import PrecacheController from './controllers/PrecacheController.mjs'; +import './_version.mjs'; + +if (process.env.NODE_ENV !== 'production') { + assert.isSwEnv('workbox-precaching'); +} + +let installActivateListenersAdded = false; +let fetchListenersAdded = false; +let suppressWarnings = false; +let plugins = []; + +const cacheName = cacheNames.getPrecacheName(); +const precacheController = new PrecacheController(cacheName); + +const _removeIgnoreUrlParams = (origUrlObject, ignoreUrlParametersMatching) => { + // Exclude initial '?' + const searchString = origUrlObject.search.slice(1); + + // Split into an array of 'key=value' strings + const keyValueStrings = searchString.split('&'); + const keyValuePairs = keyValueStrings.map((keyValueString) => { + // Split each 'key=value' string into a [key, value] array + return keyValueString.split('='); + }); + const filteredKeyValuesPairs = keyValuePairs.filter((keyValuePair) => { + return ignoreUrlParametersMatching + .every((ignoredRegex) => { + // Return true iff the key doesn't match any of the regexes. + return !ignoredRegex.test(keyValuePair[0]); + }); + }); + const filteredStrings = filteredKeyValuesPairs.map((keyValuePair) => { + // Join each [key, value] array into a 'key=value' string + return keyValuePair.join('='); + }); + + // Join the array of 'key=value' strings into a string with '&' in + // between each + const urlClone = new URL(origUrlObject); + urlClone.search = filteredStrings.join('&'); + return urlClone; +}; + +/** + * This function will take the request URL and manipulate it based on the + * configuration options. + * + * @param {string} url + * @param {Object} options + * @return {string|null} Returns the URL in the cache that matches the request + * if available, other null. + * + * @private + */ +const _getPrecachedUrl = (url, { + ignoreUrlParametersMatching = [/^utm_/], + directoryIndex = 'index.html', + cleanUrls = true, + urlManipulation = null, +} = {}) => { + const urlObject = new URL(url, location); + + // Change '/some-url#123' => '/some-url' + urlObject.hash = ''; + + const urlWithoutIgnoredParams = _removeIgnoreUrlParams( + urlObject, ignoreUrlParametersMatching + ); + + let urlsToAttempt = [ + // Test the URL that was fetched + urlObject, + // Test the URL without search params + urlWithoutIgnoredParams, + ]; + + // Test the URL with a directory index + if (directoryIndex && urlWithoutIgnoredParams.pathname.endsWith('/')) { + const directoryUrl = new URL(urlWithoutIgnoredParams); + directoryUrl.pathname += directoryIndex; + urlsToAttempt.push(directoryUrl); + } + + // Test the URL with a '.html' extension + if (cleanUrls) { + const cleanUrl = new URL(urlWithoutIgnoredParams); + cleanUrl.pathname += '.html'; + urlsToAttempt.push(cleanUrl); + } + + if (urlManipulation) { + const additionalUrls = urlManipulation({url: urlObject}); + urlsToAttempt = urlsToAttempt.concat(additionalUrls); + } + + const cachedUrls = precacheController.getCachedUrls(); + for (const possibleUrl of urlsToAttempt) { + if (cachedUrls.indexOf(possibleUrl.href) !== -1) { + // It's a perfect match + if (process.env.NODE_ENV !== 'production') { + logger.debug(`Precaching found a match for ` + + getFriendlyURL(possibleUrl.toString())); + } + return possibleUrl.href; + } + } + + return null; +}; + +const moduleExports = {}; + +/** + * Add items to the precache list, removing any duplicates and + * store the files in the + * ["precache cache"]{@link module:workbox-core.cacheNames} 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 + * [addRoute()]{@link module:workbox-precaching.addRoute}. + * + * If you have a single array of files to precache, you can just call + * [precacheAndRoute()]{@link module:workbox-precaching.precacheAndRoute}. + * + * @param {Array<Object|string>} entries Array of entries to precache. + * + * @alias workbox.precaching.precache + */ +moduleExports.precache = (entries) => { + precacheController.addToCacheList(entries); + + if (installActivateListenersAdded || entries.length <= 0) { + return; + } + + installActivateListenersAdded = true; + self.addEventListener('install', (event) => { + event.waitUntil(precacheController.install({ + event, + plugins, + suppressWarnings, + })); + }); + self.addEventListener('activate', (event) => { + event.waitUntil(precacheController.activate({ + event, + plugins, + })); + }); +}; + +/** + * 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 + * @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<RegExp>} [options.ignoreUrlParametersMatching=[/^utm_/]] 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 URL's that should be checked for precache matches. + * + * @alias workbox.precaching.addRoute + */ +moduleExports.addRoute = (options) => { + if (fetchListenersAdded) { + // TODO: Throw error here. + return; + } + + fetchListenersAdded = true; + self.addEventListener('fetch', (event) => { + const precachedUrl = _getPrecachedUrl(event.request.url, options); + if (!precachedUrl) { + if (process.env.NODE_ENV !== 'production') { + logger.debug(`Precaching found no match for ` + + getFriendlyURL(event.request.url)); + } + return; + } + + let responsePromise = caches.open(cacheName) + .then((cache) => { + return cache.match(precachedUrl); + }).then((cachedResponse) => { + if (cachedResponse) { + return cachedResponse; + } + + // Fall back to the network if we don't have a cached response (perhaps + // due to manual cache cleanup). + if (process.env.NODE_ENV !== 'production') { + logger.debug(`The precached response for ` + + `${getFriendlyURL(precachedUrl)} in ${cacheName} was not found. ` + + `Falling back to the network instead.`); + } + + return fetch(precachedUrl); + }); + + if (process.env.NODE_ENV !== 'production') { + responsePromise = responsePromise.then((response) => { + // Workbox is going to handle the route. + // print the routing details to the console. + logger.groupCollapsed(`Precaching is responding to: ` + + getFriendlyURL(event.request.url)); + logger.log(`Serving the precached url: ${precachedUrl}`); + + // The Request and Response objects contains a great deal of + // information, hide it under a group in case developers want to see it. + logger.groupCollapsed(`View request details here.`); + logger.unprefixed.log(event.request); + logger.groupEnd(); + + logger.groupCollapsed(`View response details here.`); + logger.unprefixed.log(response); + logger.groupEnd(); + + logger.groupEnd(); + return response; + }); + } + event.respondWith(responsePromise); + }); +}; + +/** + * 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 + * [precache()]{@link module:workbox-precaching.precache} and + * [addRoute()]{@link module:workbox-precaching.addRoute} in a single call. + * + * @param {Array<Object|string>} entries Array of entries to precache. + * @param {Object} options See + * [addRoute() options]{@link module:workbox-precaching.addRoute}. + * + * @alias workbox.precaching.precacheAndRoute + */ +moduleExports.precacheAndRoute = (entries, options) => { + moduleExports.precache(entries); + moduleExports.addRoute(options); +}; + +/** + * Warnings will be logged if any of the precached assets are entered without + * a `revision` property. This is extremely dangerous if the URL's aren't + * revisioned. However, the warnings can be supressed with this method. + * + * @param {boolean} suppress + * + * @alias workbox.precaching.suppressWarnings + */ +moduleExports.suppressWarnings = (suppress) => { + suppressWarnings = suppress; +}; + +/** + * Add plugins to precaching. + * + * @param {Array<Object>} newPlugins + * + * @alias workbox.precaching.addPlugins + */ +moduleExports.addPlugins = (newPlugins) => { + plugins = plugins.concat(newPlugins); +}; + +export default moduleExports; diff --git a/node_modules/workbox-precaching/_public.mjs b/node_modules/workbox-precaching/_public.mjs new file mode 100644 index 00000000..f6733bf9 --- /dev/null +++ b/node_modules/workbox-precaching/_public.mjs @@ -0,0 +1,22 @@ +/* + Copyright 2017 Google Inc. + + 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 + + https://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. +*/ + +import PrecacheController from './controllers/PrecacheController.mjs'; +import './_version.mjs'; + +export { + PrecacheController, +}; diff --git a/node_modules/workbox-precaching/_types.mjs b/node_modules/workbox-precaching/_types.mjs new file mode 100644 index 00000000..224a195a --- /dev/null +++ b/node_modules/workbox-precaching/_types.mjs @@ -0,0 +1,65 @@ +/* + Copyright 2017 Google Inc. + + 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 + + https://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. +*/ + +import './_version.mjs'; + +/** + * @typedef {Object} InstallResult + * @property { + * Array<workbox.precaching.PrecacheEntry|string> + * } updatedEntries List of entries + * supplied for precaching that were precached. + * @property {Array<workbox.precaching.PrecacheEntry|string>} + * notUpdatedEntries List of entries + * supplied for precaching that were already precached. + * + * @memberof workbox.precaching + */ + +/** + * @typedef {Object} CleanupResult + * @property {Array<string>} deletedCacheRequests List of URLs that were + * deleted from the precache cache. + * @property {Array<string>} deletedRevisionDetails + * List of URLs that were deleted from the precache cache. + * + * @memberof workbox.precaching + */ + +/** + * @typedef {Object} PrecacheEntry + * @property {string} url URL to precache. + * @property {string} revision Revision information for the URL. + * + * @memberof workbox.precaching + */ + +/** + * The "urlManipulation" callback can be used to determine if there are any + * additional permutations of a URL that should be used to check against + * the available precached files. + * + * For example, Workbox supports checking for '/index.html' when the URL + * '/' is provided. This callback allows additional, custom checks. + * + * @callback ~urlManipulation + * @param {Object} context + * @param {URL} context.url The request's URL. + * @return {Array<URL>} To add additional urls to test, return an Array of + * URL's. Please note that these **should not be Strings**, but URL objects. + * + * @memberof workbox.precaching + */ diff --git a/node_modules/workbox-precaching/_version.mjs b/node_modules/workbox-precaching/_version.mjs new file mode 100644 index 00000000..0c59270d --- /dev/null +++ b/node_modules/workbox-precaching/_version.mjs @@ -0,0 +1 @@ +try{self.workbox.v['workbox:precaching:3.6.3']=1;}catch(e){} // eslint-disable-line
\ No newline at end of file diff --git a/node_modules/workbox-precaching/browser.mjs b/node_modules/workbox-precaching/browser.mjs new file mode 100644 index 00000000..20950ace --- /dev/null +++ b/node_modules/workbox-precaching/browser.mjs @@ -0,0 +1,23 @@ +/* + Copyright 2017 Google Inc. + + 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 + + https://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. +*/ + +import * as publicAPI from './_public.mjs'; +import defaultExport from './_default.mjs'; +import './_version.mjs'; + +const finalExport = Object.assign(defaultExport, publicAPI); + +export default finalExport; diff --git a/node_modules/workbox-precaching/controllers/PrecacheController.mjs b/node_modules/workbox-precaching/controllers/PrecacheController.mjs new file mode 100644 index 00000000..d4b704b3 --- /dev/null +++ b/node_modules/workbox-precaching/controllers/PrecacheController.mjs @@ -0,0 +1,393 @@ +/* + Copyright 2017 Google Inc. + + 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 + + https://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. +*/ + +import {cacheNames} from 'workbox-core/_private/cacheNames.mjs'; +import {WorkboxError} from 'workbox-core/_private/WorkboxError.mjs'; +import {fetchWrapper} from 'workbox-core/_private/fetchWrapper.mjs'; +import {cacheWrapper} from 'workbox-core/_private/cacheWrapper.mjs'; +import {assert} from 'workbox-core/_private/assert.mjs'; +import PrecacheEntry from '../models/PrecacheEntry.mjs'; +import PrecachedDetailsModel from '../models/PrecachedDetailsModel.mjs'; +import showWarningsIfNeeded from '../utils/showWarningsIfNeeded.mjs'; +import printInstallDetails from '../utils/printInstallDetails.mjs'; +import printCleanupDetails from '../utils/printCleanupDetails.mjs'; +import cleanRedirect from '../utils/cleanRedirect.mjs'; +import '../_version.mjs'; + +/** + * Performs efficient precaching of assets. + * + * @memberof workbox.precaching + */ +class PrecacheController { + /** + * Create a new PrecacheController. + * + * @param {string} cacheName + */ + constructor(cacheName) { + this._cacheName = cacheNames.getPrecacheName(cacheName); + this._entriesToCacheMap = new Map(); + this._precacheDetailsModel = new PrecachedDetailsModel(this._cacheName); + } + + /** + * This method will add items to the precache list, removing duplicates + * and ensuring the information is valid. + * + * @param { + * Array<module:workbox-precaching.PrecacheController.PrecacheEntry|string> + * } entries Array of entries to + * precache. + */ + addToCacheList(entries) { + if (process.env.NODE_ENV !== 'production') { + assert.isArray(entries, { + moduleName: 'workbox-precaching', + className: 'PrecacheController', + funcName: 'addToCacheList', + paramName: 'entries', + }); + } + + entries.map((userEntry) => { + this._addEntryToCacheList( + this._parseEntry(userEntry) + ); + }); + } + + /** + * This method returns a precache entry. + * + * @private + * @param {string|Object} input + * @return {PrecacheEntry} + */ + _parseEntry(input) { + switch (typeof input) { + case 'string': { + if (process.env.NODE_ENV !== 'production') { + if (input.length === 0) { + throw new WorkboxError( + 'add-to-cache-list-unexpected-type', { + entry: input, + } + ); + } + } + + return new PrecacheEntry(input, input, input); + } + case 'object': { + if (process.env.NODE_ENV !== 'production') { + if (!input || !input.url) { + throw new WorkboxError( + 'add-to-cache-list-unexpected-type', { + entry: input, + } + ); + } + } + + return new PrecacheEntry( + input, input.url, input.revision || input.url, !!input.revision); + } + default: + throw new WorkboxError('add-to-cache-list-unexpected-type', { + entry: input, + }); + } + } + + /** + * Adds an entry to the precache list, accounting for possible duplicates. + * + * @private + * @param {PrecacheEntry} entryToAdd + */ + _addEntryToCacheList(entryToAdd) { + // Check if the entry is already part of the map + const existingEntry = this._entriesToCacheMap.get(entryToAdd._entryId); + if (!existingEntry) { + this._entriesToCacheMap.set(entryToAdd._entryId, entryToAdd); + return; + } + + // Duplicates are fine, but make sure the revision information + // is the same. + if (existingEntry._revision !== entryToAdd._revision) { + throw new WorkboxError('add-to-cache-list-conflicting-entries', { + firstEntry: existingEntry._originalInput, + secondEntry: entryToAdd._originalInput, + }); + } + } + + /** + * Call this method from a service work install event to start + * precaching assets. + * + * @param {Object} options + * @param {boolean} [options.suppressWarnings] Suppress warning messages. + * @param {Event} [options.event] The install event (if needed). + * @param {Array<Object>} [options.plugins] Plugins to be used for fetching + * and caching during install. + * @return {Promise<workbox.precaching.InstallResult>} + */ + async install({suppressWarnings = false, event, plugins} = {}) { + if (process.env.NODE_ENV !== 'production') { + if (suppressWarnings !== true) { + showWarningsIfNeeded(this._entriesToCacheMap); + } + + if (plugins) { + assert.isArray(plugins, { + moduleName: 'workbox-precaching', + className: 'PrecacheController', + funcName: 'install', + paramName: 'plugins', + }); + } + } + + // Empty the temporary cache. + // NOTE: We remove all entries instead of deleting the cache as the cache + // may be marked for deletion but still exist until a later stage + // resulting in unexpected behavior of being deletect when all references + // are dropped. + // https://github.com/GoogleChrome/workbox/issues/1368 + const tempCache = await caches.open(this._getTempCacheName()); + const requests = await tempCache.keys(); + await Promise.all(requests.map((request) => { + return tempCache.delete(request); + })); + + const entriesToPrecache = []; + const entriesAlreadyPrecached = []; + + for (const precacheEntry of this._entriesToCacheMap.values()) { + if (await this._precacheDetailsModel._isEntryCached( + this._cacheName, precacheEntry)) { + entriesAlreadyPrecached.push(precacheEntry); + } else { + entriesToPrecache.push(precacheEntry); + } + } + + // Wait for all requests to be cached. + await Promise.all(entriesToPrecache.map((precacheEntry) => { + return this._cacheEntryInTemp({event, plugins, precacheEntry}); + })); + + if (process.env.NODE_ENV !== 'production') { + printInstallDetails(entriesToPrecache, entriesAlreadyPrecached); + } + + return { + updatedEntries: entriesToPrecache, + notUpdatedEntries: entriesAlreadyPrecached, + }; + } + + /** + * Takes the current set of temporary files and moves them to the final + * cache, deleting the temporary cache once copying is complete. + * + * @param {Object} options + * @param {Array<Object>} options.plugins Plugins to be used for fetching + * and caching during install. + * @return { + * Promise<workbox.precaching.CleanupResult>} + * Resolves with an object containing details of the deleted cache requests + * and precache revision details. + */ + async activate(options = {}) { + const tempCache = await caches.open(this._getTempCacheName()); + + const requests = await tempCache.keys(); + // Process each request/response one at a time, deleting the temporary entry + // when done, to help avoid triggering quota errors. + for (const request of requests) { + const response = await tempCache.match(request); + await cacheWrapper.put({ + cacheName: this._cacheName, + request, + response, + plugins: options.plugins, + }); + await tempCache.delete(request); + } + + return this._cleanup(); + } + + /** + * Returns the name of the temporary cache. + * + * @return {string} + * + * @private + */ + _getTempCacheName() { + return `${this._cacheName}-temp`; + } + + /** + * Requests the entry and saves it to the cache if the response + * is valid. + * + * @private + * @param {Object} options + * @param {BaseCacheEntry} options.precacheEntry The entry to fetch and cache. + * @param {Event} [options.event] The install event (if passed). + * @param {Array<Object>} [options.plugins] An array of plugins to apply to + * fetch and caching. + * @return {Promise<boolean>} Returns a promise that resolves once the entry + * has been fetched and cached or skipped if no update is needed. The + * promise resolves with true if the entry was cached / updated and + * false if the entry is already cached and up-to-date. + */ + async _cacheEntryInTemp({precacheEntry, event, plugins}) { + let response = await fetchWrapper.fetch({ + request: precacheEntry._networkRequest, + event, + fetchOptions: null, + plugins, + }); + + if (response.redirected) { + response = await cleanRedirect(response); + } + + await cacheWrapper.put({ + cacheName: this._getTempCacheName(), + request: precacheEntry._cacheRequest, + response, + event, + plugins, + }); + + await this._precacheDetailsModel._addEntry(precacheEntry); + + return true; + } + + /** + * Compare the URLs and determines which assets are no longer required + * in the cache. + * + * This should be called in the service worker activate event. + * + * @return { + * Promise<workbox.precaching.CleanupResult>} + * Resolves with an object containing details of the deleted cache requests + * and precache revision details. + * + * @private + */ + async _cleanup() { + const expectedCacheUrls = []; + this._entriesToCacheMap.forEach((entry) => { + const fullUrl = new URL(entry._cacheRequest.url, location).toString(); + expectedCacheUrls.push(fullUrl); + }); + + const [deletedCacheRequests, deletedRevisionDetails] = await Promise.all([ + this._cleanupCache(expectedCacheUrls), + this._cleanupDetailsModel(expectedCacheUrls), + ]); + + if (process.env.NODE_ENV !== 'production') { + printCleanupDetails(deletedCacheRequests, deletedRevisionDetails); + } + + return { + deletedCacheRequests, + deletedRevisionDetails, + }; + } + + /** + * Goes through all the cache entries and removes any that are + * outdated. + * + * @private + * @param {Array<string>} expectedCacheUrls Array of URLs that are + * expected to be cached. + * @return {Promise<Array<string>>} Resolves to an array of URLs + * of cached requests that were deleted. + */ + async _cleanupCache(expectedCacheUrls) { + if (!await caches.has(this._cacheName)) { + // Cache doesn't exist, so nothing to delete + return []; + } + + const cache = await caches.open(this._cacheName); + const cachedRequests = await cache.keys(); + const cachedRequestsToDelete = cachedRequests.filter((cachedRequest) => { + return !expectedCacheUrls.includes( + new URL(cachedRequest.url, location).toString() + ); + }); + + await Promise.all( + cachedRequestsToDelete.map((cacheUrl) => cache.delete(cacheUrl)) + ); + + return cachedRequestsToDelete.map((request) => request.url); + } + + /** + * Goes through all entries in indexedDB and removes any that are outdated. + * + * @private + * @param {Array<string>} expectedCacheUrls Array of URLs that are + * expected to be cached. + * @return {Promise<Array<string>>} Resolves to an array of URLs removed + * from indexedDB. + */ + async _cleanupDetailsModel(expectedCacheUrls) { + const revisionedEntries = await this._precacheDetailsModel._getAllEntries(); + const detailsToDelete = revisionedEntries + .filter((entry) => { + const fullUrl = new URL(entry.value.url, location).toString(); + return !expectedCacheUrls.includes(fullUrl); + }); + + await Promise.all( + detailsToDelete.map( + (entry) => this._precacheDetailsModel._deleteEntry(entry.primaryKey) + ) + ); + return detailsToDelete.map((entry) => { + return entry.value.url; + }); + } + + /** + * Returns an array of fully qualified URL's that will be precached. + * + * @return {Array<string>} An array of URLs. + */ + getCachedUrls() { + return Array.from(this._entriesToCacheMap.keys()) + .map((url) => new URL(url, location).href); + } +} + +export default PrecacheController; diff --git a/node_modules/workbox-precaching/index.mjs b/node_modules/workbox-precaching/index.mjs new file mode 100644 index 00000000..1b8c3bd2 --- /dev/null +++ b/node_modules/workbox-precaching/index.mjs @@ -0,0 +1,35 @@ +/* + Copyright 2017 Google Inc. + + 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 + + https://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. +*/ + +import defaultPrecachingExport from './_default.mjs'; +import './_version.mjs'; + +/** + * Most consumers of this module will want to use the + * [precacheAndRoute()]{@link workbox.precaching.precacheAndRoute} + * method to add assets to the Cache and respond to network requests with these + * cached assets. + * + * If you require finer grained control, you can use the + * [PrecacheController]{@link workbox.precaching.PrecacheController} + * to determine when performed. + * + * @namespace workbox.precaching + */ + +export * from './_public.mjs'; + +export default defaultPrecachingExport; diff --git a/node_modules/workbox-precaching/models/PrecacheEntry.mjs b/node_modules/workbox-precaching/models/PrecacheEntry.mjs new file mode 100644 index 00000000..8138edfa --- /dev/null +++ b/node_modules/workbox-precaching/models/PrecacheEntry.mjs @@ -0,0 +1,78 @@ +/* + Copyright 2017 Google Inc. + + 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 + + https://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. +*/ + +import '../_version.mjs'; + +/** + * Used as a consistent way of referencing a URL to precache. + * + * @private + * @memberof module:workbox-precaching + */ +export default class PrecacheEntry { +/** + * This class ensures all cache list entries are consistent and + * adds cache busting if required. + * + * @param {*} originalInput + * @param {string} url + * @param {string} revision + * @param {boolean} shouldCacheBust + */ + constructor(originalInput, url, revision, shouldCacheBust) { + this._originalInput = originalInput; + this._entryId = url; + this._revision = revision; + const requestAsCacheKey = new Request(url, {credentials: 'same-origin'}); + this._cacheRequest = requestAsCacheKey; + this._networkRequest = shouldCacheBust ? + this._cacheBustRequest(requestAsCacheKey) : requestAsCacheKey; + } + + /** + * This method will either use Request.cache option OR append a cache + * busting parameter to the URL. + * + * @param {Request} request The request to cache bust + * @return {Request} A cachebusted Request + * + * @private + */ + _cacheBustRequest(request) { + let url = request.url; + const requestOptions = { + credentials: 'same-origin', + }; + if ('cache' in Request.prototype) { + // Make use of the Request cache mode where we can. + // Reload skips the HTTP cache for outgoing requests and updates + // the cache with the returned response. + requestOptions.cache = 'reload'; + } else { + const parsedURL = new URL(url, location); + + // This is done so the minifier can mangle 'global.encodeURIComponent' + const _encodeURIComponent = encodeURIComponent; + + parsedURL.search += (parsedURL.search ? '&' : '') + + _encodeURIComponent(`_workbox-cache-bust`) + '=' + + _encodeURIComponent(this._revision); + url = parsedURL.toString(); + } + + return new Request(url, requestOptions); + } +} diff --git a/node_modules/workbox-precaching/models/PrecachedDetailsModel.mjs b/node_modules/workbox-precaching/models/PrecachedDetailsModel.mjs new file mode 100644 index 00000000..55f1420d --- /dev/null +++ b/node_modules/workbox-precaching/models/PrecachedDetailsModel.mjs @@ -0,0 +1,143 @@ +/* + Copyright 2017 Google Inc. + + 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 + + https://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. +*/ + +import {DBWrapper} from 'workbox-core/_private/DBWrapper.mjs'; +import '../_version.mjs'; + +// Allows minifier to mangle this name +const REVISON_IDB_FIELD = 'revision'; +const URL_IDB_FIELD = 'url'; +const DB_STORE_NAME = 'precached-details-models'; +/** + * This model will track the relevant information of entries that + * are cached and their matching revision details. + * + * @private + */ +class PrecachedDetailsModel { + /** + * Construct a new model for a specific cache. + * + * @param {string} dbName + * @private + */ + constructor(dbName) { + // This ensures the db name contains only letters, numbers, '-', '_' and '$' + const filteredDBName = dbName.replace(/[^\w-]/g, '_'); + this._db = new DBWrapper(filteredDBName, 2, { + onupgradeneeded: this._handleUpgrade, + }); + } + + /** + * Should perform an upgrade of indexedDB. + * + * @param {Event} evt + * + * @private + */ + _handleUpgrade(evt) { + const db = evt.target.result; + if (evt.oldVersion < 2) { + // IndexedDB version 1 used both 'workbox-precaching' and + // 'precached-details-model' before upgrading to version 2. + // Delete them and create a new store with latest schema. + if (db.objectStoreNames.contains('workbox-precaching')) { + db.deleteObjectStore('workbox-precaching'); + } + if (db.objectStoreNames.contains(DB_STORE_NAME)) { + db.deleteObjectStore(DB_STORE_NAME); + } + } + db.createObjectStore(DB_STORE_NAME); + } + + /** + * Check if an entry is already cached. Returns false if + * the entry isn't cached or the revision has changed. + * + * @param {string} cacheName + * @param {PrecacheEntry} precacheEntry + * @return {boolean} + * + * @private + */ + async _isEntryCached(cacheName, precacheEntry) { + const revisionDetails = await this._getRevision(precacheEntry._entryId); + if (revisionDetails !== precacheEntry._revision) { + return false; + } + + const openCache = await caches.open(cacheName); + const cachedResponse = await openCache.match(precacheEntry._cacheRequest); + return !!cachedResponse; + } + + /** + * @return {Promise<Array>} + * + * @private + */ + async _getAllEntries() { + return await this._db.getAllMatching(DB_STORE_NAME, { + includeKeys: true, + }); + } + + /** + * Get the current revision details. + * + * @param {Object} entryId + * @return {Promise<string|null>} + * + * @private + */ + async _getRevision(entryId) { + const data = await this._db.get(DB_STORE_NAME, entryId); + return data ? data[REVISON_IDB_FIELD] : null; + } + + /** + * Add an entry to the details model. + * + * @param {PrecacheEntry} precacheEntry + * + * @private + */ + async _addEntry(precacheEntry) { + await this._db.put( + DB_STORE_NAME, + { + [REVISON_IDB_FIELD]: precacheEntry._revision, + [URL_IDB_FIELD]: precacheEntry._cacheRequest.url, + }, + precacheEntry._entryId + ); + } + + /** + * Delete entry from details model. + * + * @param {string} entryId + * + * @private + */ + async _deleteEntry(entryId) { + await this._db.delete(DB_STORE_NAME, entryId); + } +} + +export default PrecachedDetailsModel; diff --git a/node_modules/workbox-precaching/package.json b/node_modules/workbox-precaching/package.json new file mode 100644 index 00000000..4c0c3494 --- /dev/null +++ b/node_modules/workbox-precaching/package.json @@ -0,0 +1,30 @@ +{ + "name": "workbox-precaching", + "version": "3.6.3", + "license": "Apache-2.0", + "author": "Google's Web DevRel Team", + "description": "This module efficiently precaches assets.", + "repository": "googlechrome/workbox", + "bugs": "https://github.com/googlechrome/workbox/issues", + "homepage": "https://github.com/GoogleChrome/workbox", + "keywords": [ + "workbox", + "workboxjs", + "service worker", + "sw" + ], + "scripts": { + "build": "gulp build-packages --package workbox-precaching", + "version": "npm run build", + "prepare": "npm run build" + }, + "workbox": { + "browserNamespace": "workbox.precaching", + "packageType": "browser" + }, + "main": "build/workbox-precaching.prod.js", + "module": "index.mjs", + "dependencies": { + "workbox-core": "^3.6.3" + } +} diff --git a/node_modules/workbox-precaching/utils/cleanRedirect.mjs b/node_modules/workbox-precaching/utils/cleanRedirect.mjs new file mode 100644 index 00000000..aa3013ed --- /dev/null +++ b/node_modules/workbox-precaching/utils/cleanRedirect.mjs @@ -0,0 +1,45 @@ +/* + Copyright 2017 Google Inc. + + 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 + + https://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. +*/ + +import '../_version.mjs'; + +/** + * @param {Response} response + * @return {Response} + * + * @private + * @memberof module:workbox-precaching + */ +const cleanRedirect = async (response) => { + const clonedResponse = response.clone(); + + // Not all browsers support the Response.body stream, so fall back + // to reading the entire body into memory as a blob. + const bodyPromise = 'body' in clonedResponse ? + Promise.resolve(clonedResponse.body) : + clonedResponse.blob(); + + const body = await bodyPromise; + + // new Response() is happy when passed either a stream or a Blob. + return new Response(body, { + headers: clonedResponse.headers, + status: clonedResponse.status, + statusText: clonedResponse.statusText, + }); +}; + +export default cleanRedirect; diff --git a/node_modules/workbox-precaching/utils/printCleanupDetails.mjs b/node_modules/workbox-precaching/utils/printCleanupDetails.mjs new file mode 100644 index 00000000..9138f820 --- /dev/null +++ b/node_modules/workbox-precaching/utils/printCleanupDetails.mjs @@ -0,0 +1,61 @@ +/* + Copyright 2017 Google Inc. + + 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 + + https://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. +*/ + +import {logger} from 'workbox-core/_private/logger.mjs'; +import '../_version.mjs'; + +const logGroup = (groupTitle, urls) => { + logger.groupCollapsed(groupTitle); + + urls.forEach((url) => { + logger.log(url); + }); + + logger.groupEnd(); +}; + +/** + * @param {Array<string>} deletedCacheRequests + * @param {Array<string>} deletedRevisionDetails + * + * @private + * @memberof module:workbox-precachig + */ +export default (deletedCacheRequests, deletedRevisionDetails) => { + if (deletedCacheRequests.length === 0 && + deletedRevisionDetails.length === 0) { + return; + } + + const cacheDeleteCount = deletedCacheRequests.length; + const revisionDeleteCount = deletedRevisionDetails.length; + + const cacheDeleteText = + `${cacheDeleteCount} cached ` + + `request${cacheDeleteCount === 1 ? ' was' : 's were'} deleted`; + const revisionDeleteText = + `${revisionDeleteCount} ` + + `${revisionDeleteCount === 1 ? 'entry' : 'entries'} ` + + `${revisionDeleteCount === 1 ? 'was' : 'were'} deleted from IndexedDB.`; + + logger.groupCollapsed( + `During precaching cleanup, ${cacheDeleteText} and ${revisionDeleteText}`); + + logGroup('Deleted Cache Requests', deletedCacheRequests); + logGroup('Revision Details Deleted from DB', deletedRevisionDetails); + + logger.groupEnd(); +}; diff --git a/node_modules/workbox-precaching/utils/printInstallDetails.mjs b/node_modules/workbox-precaching/utils/printInstallDetails.mjs new file mode 100644 index 00000000..13bf5339 --- /dev/null +++ b/node_modules/workbox-precaching/utils/printInstallDetails.mjs @@ -0,0 +1,71 @@ +/* + Copyright 2017 Google Inc. + + 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 + + https://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. +*/ + +import {logger} from 'workbox-core/_private/logger.mjs'; +import '../_version.mjs'; + +/** + * @param {string} groupTitle + * @param {Array<PrecacheEntry>} entries + * + * @private + */ +const _nestedGroup = (groupTitle, entries) => { + if (entries.length === 0) { + return; + } + + logger.groupCollapsed(groupTitle); + + entries.forEach((entry) => { + logger.log(entry._originalInput); + }); + + logger.groupEnd(); +}; + +/** + * @param {Array<Object>} entriesToPrecache + * @param {Array<Object>} alreadyPrecachedEntries + * + * @private + * @memberof module:workbox-precachig + */ +export default (entriesToPrecache, alreadyPrecachedEntries) => { + // Goal is to print the message: + // Precaching X files. + // Or: + // Precaching X files. Y files were cached and up-to-date. + + const precachedCount = entriesToPrecache.length; + const alreadyPrecachedCount = alreadyPrecachedEntries.length; + let printText = + `Precaching ${precachedCount} file${precachedCount === 1 ? '' : 's'}.`; + if (alreadyPrecachedCount > 0) { + printText += ` ${alreadyPrecachedCount} ` + + `file${alreadyPrecachedCount === 1 ? ' is' : 's are'} already cached.`; + } + + logger.groupCollapsed(printText); + + _nestedGroup( + `View precached URLs.`, + entriesToPrecache); + _nestedGroup( + `View URLs that were already precached.`, + alreadyPrecachedEntries); + logger.groupEnd(); +}; diff --git a/node_modules/workbox-precaching/utils/showWarningsIfNeeded.mjs b/node_modules/workbox-precaching/utils/showWarningsIfNeeded.mjs new file mode 100644 index 00000000..37bbcb36 --- /dev/null +++ b/node_modules/workbox-precaching/utils/showWarningsIfNeeded.mjs @@ -0,0 +1,63 @@ +/* + Copyright 2017 Google Inc. + + 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 + + https://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. +*/ + +import {logger} from 'workbox-core/_private/logger.mjs'; +import '../_version.mjs'; + +/** + * This method will print out a warning if a precache entry doesn't have + * a `revision` value. + * + * This is common if the asset if revisioned in the url like `index.1234.css`. + * + * @param {Map} entriesMap + * + * @private + * @memberof module:workbox-preaching + */ +export default (entriesMap) => { + const urlOnlyEntries = []; + entriesMap.forEach( + (entry) => { + if (typeof entry === 'string' || !entry._originalInput.revision) { + urlOnlyEntries.push(entry._originalInput); + } + } + ); + + if (urlOnlyEntries.length === 0) { + // No warnings needed. + return; + } + + logger.groupCollapsed('Are your precached assets revisioned?'); + + const urlsList = urlOnlyEntries.map((urlOnlyEntry) => { + return ` - ${JSON.stringify(urlOnlyEntry)}`; + }).join(`\n`); + + logger.warn( + `The following precache entries might not be revisioned:` + + `\n\n` + + urlsList + + `\n\n` + ); + + logger.unprefixed.warn(`You can learn more about why this might be a ` + + `problem here: https://developers.google.com/web/tools/workbox/modules/workbox-precaching`); + + logger.groupEnd(); +}; |