990 lines
30 KiB
JavaScript
990 lines
30 KiB
JavaScript
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
|