diff options
Diffstat (limited to 'public/workbox-v4.3.1/workbox-precaching.dev.js')
| -rw-r--r-- | public/workbox-v4.3.1/workbox-precaching.dev.js | 989 |
1 files changed, 989 insertions, 0 deletions
diff --git a/public/workbox-v4.3.1/workbox-precaching.dev.js b/public/workbox-v4.3.1/workbox-precaching.dev.js new file mode 100644 index 0000000..fb69211 --- /dev/null +++ b/public/workbox-v4.3.1/workbox-precaching.dev.js @@ -0,0 +1,989 @@ +this.workbox = this.workbox || {}; +this.workbox.precaching = (function (exports, assert_mjs, cacheNames_mjs, getFriendlyURL_mjs, logger_mjs, cacheWrapper_mjs, fetchWrapper_mjs, WorkboxError_mjs) { + 'use strict'; + + try { + self['workbox:precaching:4.3.1'] && _(); + } catch (e) {} // eslint-disable-line + + /* + 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 plugins = []; + const precachePlugins = { + /* + * @return {Array} + * @private + */ + get() { + return plugins; + }, + + /* + * @param {Array} newPlugins + * @private + */ + add(newPlugins) { + plugins.push(...newPlugins); + } + + }; + + /* + 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 plugins to precaching. + * + * @param {Array<Object>} newPlugins + * + * @alias workbox.precaching.addPlugins + */ + + const addPlugins = newPlugins => { + precachePlugins.add(newPlugins); + }; + + /* + 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 {Response} response + * @return {Response} + * + * @private + * @memberof module:workbox-precaching + */ + + async function cleanRedirect(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 + }); + } + + /* + 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 REVISION_SEARCH_PARAM = '__WB_REVISION__'; + /** + * Converts a manifest entry into a versioned URL suitable for precaching. + * + * @param {Object} entry + * @return {string} A URL with versioning info. + * + * @private + * @memberof module:workbox-precaching + */ + + function createCacheKey(entry) { + if (!entry) { + throw new WorkboxError_mjs.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); + return { + cacheKey: urlObject.href, + url: urlObject.href + }; + } + + const { + revision, + url + } = entry; + + if (!url) { + throw new WorkboxError_mjs.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); + 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 originalURL = new URL(url, location); + const cacheKeyURL = new URL(url, location); + cacheKeyURL.searchParams.set(REVISION_SEARCH_PARAM, revision); + return { + cacheKey: cacheKeyURL.href, + url: originalURL.href + }; + } + + /* + 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 logGroup = (groupTitle, deletedURLs) => { + logger_mjs.logger.groupCollapsed(groupTitle); + + for (const url of deletedURLs) { + logger_mjs.logger.log(url); + } + + logger_mjs.logger.groupEnd(); + }; + /** + * @param {Array<string>} deletedURLs + * + * @private + * @memberof module:workbox-precaching + */ + + + function printCleanupDetails(deletedURLs) { + const deletionCount = deletedURLs.length; + + if (deletionCount > 0) { + logger_mjs.logger.groupCollapsed(`During precaching cleanup, ` + `${deletionCount} cached ` + `request${deletionCount === 1 ? ' was' : 's were'} deleted.`); + logGroup('Deleted Cache Requests', deletedURLs); + logger_mjs.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<string>} urls + * + * @private + */ + + function _nestedGroup(groupTitle, urls) { + if (urls.length === 0) { + return; + } + + logger_mjs.logger.groupCollapsed(groupTitle); + + for (const url of urls) { + logger_mjs.logger.log(url); + } + + logger_mjs.logger.groupEnd(); + } + /** + * @param {Array<string>} urlsToPrecache + * @param {Array<string>} urlsAlreadyPrecached + * + * @private + * @memberof module: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_mjs.logger.groupCollapsed(message); + + _nestedGroup(`View newly precached URLs.`, urlsToPrecache); + + _nestedGroup(`View previously precached URLs.`, urlsAlreadyPrecached); + + logger_mjs.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. + */ + /** + * Performs efficient precaching of assets. + * + * @memberof module:workbox-precaching + */ + + class PrecacheController { + /** + * Create a new PrecacheController. + * + * @param {string} [cacheName] An optional name for the cache, to override + * the default precache name. + */ + constructor(cacheName) { + this._cacheName = cacheNames_mjs.cacheNames.getPrecacheName(cacheName); + this._urlsToCacheKeys = new Map(); + } + /** + * 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) { + { + assert_mjs.assert.isArray(entries, { + moduleName: 'workbox-precaching', + className: 'PrecacheController', + funcName: 'addToCacheList', + paramName: 'entries' + }); + } + + for (const entry of entries) { + const { + cacheKey, + url + } = createCacheKey(entry); + + if (this._urlsToCacheKeys.has(url) && this._urlsToCacheKeys.get(url) !== cacheKey) { + throw new WorkboxError_mjs.WorkboxError('add-to-cache-list-conflicting-entries', { + firstEntry: this._urlsToCacheKeys.get(url), + secondEntry: cacheKey + }); + } + + this._urlsToCacheKeys.set(url, cacheKey); + } + } + /** + * Precaches new and updated assets. Call this method from the service worker + * install event. + * + * @param {Object} options + * @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({ + event, + plugins + } = {}) { + { + if (plugins) { + assert_mjs.assert.isArray(plugins, { + moduleName: 'workbox-precaching', + className: 'PrecacheController', + funcName: 'install', + paramName: 'plugins' + }); + } + } + + const urlsToPrecache = []; + const urlsAlreadyPrecached = []; + const cache = await caches.open(this._cacheName); + const alreadyCachedRequests = await cache.keys(); + const alreadyCachedURLs = new Set(alreadyCachedRequests.map(request => request.url)); + + for (const cacheKey of this._urlsToCacheKeys.values()) { + if (alreadyCachedURLs.has(cacheKey)) { + urlsAlreadyPrecached.push(cacheKey); + } else { + urlsToPrecache.push(cacheKey); + } + } + + const precacheRequests = urlsToPrecache.map(url => { + return this._addURLToCache({ + event, + plugins, + url + }); + }); + await Promise.all(precacheRequests); + + { + printInstallDetails(urlsToPrecache, urlsAlreadyPrecached); + } + + return { + updatedURLs: urlsToPrecache, + notUpdatedURLs: urlsAlreadyPrecached + }; + } + /** + * Deletes assets that are no longer present in the current precache manifest. + * Call this method from the service worker activate event. + * + * @return {Promise<workbox.precaching.CleanupResult>} + */ + + + async activate() { + const cache = await caches.open(this._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 + }; + } + /** + * Requests the entry and saves it to the cache if the response is valid. + * By default, any response with a status code of less than 400 (including + * opaque responses) is considered valid. + * + * If you need to use custom criteria to determine what's valid and what + * isn't, then pass in an item in `options.plugins` that implements the + * `cacheWillUpdate()` lifecycle event. + * + * @private + * @param {Object} options + * @param {string} options.url The URL 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. + */ + + + async _addURLToCache({ + url, + event, + plugins + }) { + const request = new Request(url, { + credentials: 'same-origin' + }); + let response = await fetchWrapper_mjs.fetchWrapper.fetch({ + event, + plugins, + request + }); // Allow developers to override the default logic about what is and isn't + // valid by passing in a plugin implementing cacheWillUpdate(), e.g. + // a workbox.cacheableResponse.Plugin instance. + + let cacheWillUpdateCallback; + + for (const plugin of plugins || []) { + if ('cacheWillUpdate' in plugin) { + cacheWillUpdateCallback = plugin.cacheWillUpdate.bind(plugin); + } + } + + const isValidResponse = cacheWillUpdateCallback ? // Use a callback if provided. It returns a truthy value if valid. + cacheWillUpdateCallback({ + event, + request, + response + }) : // Otherwise, default to considering any response status under 400 valid. + // This includes, by default, considering opaque responses valid. + response.status < 400; // Consider this a failure, leading to the `install` handler failing, if + // we get back an invalid response. + + if (!isValidResponse) { + throw new WorkboxError_mjs.WorkboxError('bad-precaching-response', { + url, + status: response.status + }); + } + + if (response.redirected) { + response = await cleanRedirect(response); + } + + await cacheWrapper_mjs.cacheWrapper.put({ + event, + plugins, + request, + response, + cacheName: this._cacheName, + matchOptions: { + ignoreSearch: true + } + }); + } + /** + * Returns a mapping of a precached URL to the corresponding cache key, taking + * into account the revision information for the URL. + * + * @return {Map<string, string>} 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<string>} 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); + return this._urlsToCacheKeys.get(urlObject.href); + } + + } + + /* + 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<RegExp>} 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 module: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 module:workbox-precaching + */ + + function* generateURLVariations(url, { + ignoreURLParametersMatching, + directoryIndex, + cleanURLs, + urlManipulation + } = {}) { + const urlObject = new URL(url, location); + urlObject.hash = ''; + yield urlObject.href; + const urlWithoutIgnoredParams = removeIgnoredSearchParams(urlObject, ignoreURLParametersMatching); + yield urlWithoutIgnoredParams.href; + + if (directoryIndex && urlWithoutIgnoredParams.pathname.endsWith('/')) { + const directoryURL = new URL(urlWithoutIgnoredParams); + directoryURL.pathname += directoryIndex; + yield directoryURL.href; + } + + if (cleanURLs) { + const cleanURL = new URL(urlWithoutIgnoredParams); + cleanURL.pathname += '.html'; + yield cleanURL.href; + } + + if (urlManipulation) { + const additionalURLs = urlManipulation({ + url: urlObject + }); + + for (const urlToAttempt of additionalURLs) { + yield urlToAttempt.href; + } + } + } + + /* + 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 function will take the request URL and manipulate it based on the + * configuration options. + * + * @param {string} url + * @param {Object} options + * @return {string} Returns the URL in the cache that matches the request, + * if possible. + * + * @private + */ + + const getCacheKeyForURL = (url, options) => { + const precacheController = getOrCreatePrecacheController(); + const urlsToCacheKeys = precacheController.getURLsToCacheKeys(); + + for (const possibleURL of generateURLVariations(url, options)) { + const possibleCacheKey = urlsToCacheKeys.get(possibleURL); + + if (possibleCacheKey) { + return possibleCacheKey; + } + } + }; + + /* + 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 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. + * + * NOTE: when called more than once this method will replace the previously set + * configuration options. Calling it more than once is not recommended outside + * of tests. + * + * @private + * @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. + */ + + const addFetchListener = ({ + ignoreURLParametersMatching = [/^utm_/], + directoryIndex = 'index.html', + cleanURLs = true, + urlManipulation = null + } = {}) => { + const cacheName = cacheNames_mjs.cacheNames.getPrecacheName(); + addEventListener('fetch', event => { + const precachedURL = getCacheKeyForURL(event.request.url, { + cleanURLs, + directoryIndex, + ignoreURLParametersMatching, + urlManipulation + }); + + if (!precachedURL) { + { + logger_mjs.logger.debug(`Precaching did not find a match for ` + getFriendlyURL_mjs.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). + + + { + logger_mjs.logger.warn(`The precached response for ` + `${getFriendlyURL_mjs.getFriendlyURL(precachedURL)} in ${cacheName} was not found. ` + `Falling back to the network instead.`); + } + + return fetch(precachedURL); + }); + + { + responsePromise = responsePromise.then(response => { + // Workbox is going to handle the route. + // print the routing details to the console. + logger_mjs.logger.groupCollapsed(`Precaching is responding to: ` + getFriendlyURL_mjs.getFriendlyURL(event.request.url)); + logger_mjs.logger.log(`Serving the precached url: ${precachedURL}`); + logger_mjs.logger.groupCollapsed(`View request details here.`); + logger_mjs.logger.log(event.request); + logger_mjs.logger.groupEnd(); + logger_mjs.logger.groupCollapsed(`View response details here.`); + logger_mjs.logger.log(response); + logger_mjs.logger.groupEnd(); + logger_mjs.logger.groupEnd(); + return response; + }); + } + + event.respondWith(responsePromise); + }); + }; + + /* + 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 listenerAdded = false; + /** + * 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 + */ + + const addRoute = options => { + if (!listenerAdded) { + addFetchListener(options); + listenerAdded = true; + } + }; + + /* + 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<string>} A list of all the cache names that were deleted. + * + * @private + * @memberof module:workbox-precaching + */ + + const deleteOutdatedCaches = async (currentPrecacheName, substringToFind = SUBSTRING_TO_FIND) => { + const cacheNames = await caches.keys(); + const cacheNamesToDelete = cacheNames.filter(cacheName => { + return cacheName.includes(substringToFind) && cacheName.includes(self.registration.scope) && cacheName !== currentPrecacheName; + }); + await Promise.all(cacheNamesToDelete.map(cacheName => 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. + * + * @alias workbox.precaching.cleanupOutdatedCaches + */ + + const cleanupOutdatedCaches = () => { + addEventListener('activate', event => { + const cacheName = cacheNames_mjs.cacheNames.getPrecacheName(); + event.waitUntil(deleteOutdatedCaches(cacheName).then(cachesDeleted => { + { + if (cachesDeleted.length > 0) { + logger_mjs.logger.log(`The following out-of-date precaches were cleaned up ` + `automatically:`, cachesDeleted); + } + } + })); + }); + }; + + /* + 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. + */ + /** + * Takes in a URL, and returns the corresponding URL that could be used to + * lookup the entry in the precache. + * + * If a relative URL is provided, the location of the service worker file will + * be used as the base. + * + * For precached entries without revision information, the cache key will be the + * same as the original URL. + * + * For precached entries with revision information, the cache key will be the + * original URL with the addition of a query parameter used for keeping track of + * the revision info. + * + * @param {string} url The URL whose cache key to look up. + * @return {string} The cache key that corresponds to that URL. + * + * @alias workbox.precaching.getCacheKeyForURL + */ + + const getCacheKeyForURL$1 = url => { + const precacheController = getOrCreatePrecacheController(); + return precacheController.getCacheKeyForURL(url); + }; + + /* + 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 installListener = event => { + const precacheController = getOrCreatePrecacheController(); + const plugins = precachePlugins.get(); + event.waitUntil(precacheController.install({ + event, + plugins + }).catch(error => { + { + logger_mjs.logger.error(`Service worker installation failed. It will ` + `be retried automatically during the next navigation.`); + } // Re-throw the error to ensure installation fails. + + + throw error; + })); + }; + + const activateListener = event => { + const precacheController = getOrCreatePrecacheController(); + const plugins = precachePlugins.get(); + event.waitUntil(precacheController.activate({ + event, + plugins + })); + }; + /** + * Adds items to the precache list, removing any duplicates and + * stores 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 + */ + + + const precache = entries => { + const precacheController = getOrCreatePrecacheController(); + precacheController.addToCacheList(entries); + + if (entries.length > 0) { + // NOTE: these listeners will only be added once (even if the `precache()` + // method is called multiple times) because event listeners are implemented + // as a set, where each listener must be unique. + addEventListener('install', installListener); + addEventListener('activate', activateListener); + } + }; + + /* + 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 + * [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 + */ + + const 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. + */ + + { + assert_mjs.assert.isSWEnv('workbox-precaching'); + } + + exports.addPlugins = addPlugins; + exports.addRoute = addRoute; + exports.cleanupOutdatedCaches = cleanupOutdatedCaches; + exports.getCacheKeyForURL = getCacheKeyForURL$1; + exports.precache = precache; + exports.precacheAndRoute = precacheAndRoute; + exports.PrecacheController = PrecacheController; + + return exports; + +}({}, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private)); +//# sourceMappingURL=workbox-precaching.dev.js.map |