/* Copyright 2019 Google LLC Use of this source code is governed by an MIT-style license that can be found in the LICENSE file or at https://opensource.org/licenses/MIT. */ import {assert} from 'workbox-core/_private/assert.js'; import {cacheNames} from 'workbox-core/_private/cacheNames.js'; import {logger} from 'workbox-core/_private/logger.js'; import {WorkboxError} from 'workbox-core/_private/WorkboxError.js'; import {waitUntil} from 'workbox-core/_private/waitUntil.js'; import {Strategy} from 'workbox-strategies/Strategy.js'; import {RouteHandlerCallback, WorkboxPlugin} from 'workbox-core/types.js'; import {createCacheKey} from './utils/createCacheKey.js'; import {PrecacheInstallReportPlugin} from './utils/PrecacheInstallReportPlugin.js'; import {PrecacheCacheKeyPlugin} from './utils/PrecacheCacheKeyPlugin.js'; import {printCleanupDetails} from './utils/printCleanupDetails.js'; import {printInstallDetails} from './utils/printInstallDetails.js'; import {PrecacheStrategy} from './PrecacheStrategy.js'; import {PrecacheEntry, InstallResult, CleanupResult} from './_types.js'; import './_version.js'; // Give TypeScript the correct global. declare let self: ServiceWorkerGlobalScope; declare global { interface ServiceWorkerGlobalScope { __WB_MANIFEST: Array; } } interface PrecacheControllerOptions { cacheName?: string; plugins?: WorkboxPlugin[]; fallbackToNetwork?: boolean; } /** * Performs efficient precaching of assets. * * @memberof workbox-precaching */ class PrecacheController { private _installAndActiveListenersAdded?: boolean; private readonly _strategy: Strategy; private readonly _urlsToCacheKeys: Map = new Map(); private readonly _urlsToCacheModes: Map< string, | 'reload' | 'default' | 'no-store' | 'no-cache' | 'force-cache' | 'only-if-cached' > = new Map(); private readonly _cacheKeysToIntegrities: Map = new Map(); /** * Create a new PrecacheController. * * @param {Object} [options] * @param {string} [options.cacheName] The cache to use for precaching. * @param {string} [options.plugins] Plugins to use when precaching as well * as responding to fetch events for precached assets. * @param {boolean} [options.fallbackToNetwork=true] Whether to attempt to * get the response from the network if there's a precache miss. */ constructor({ cacheName, plugins = [], fallbackToNetwork = true, }: PrecacheControllerOptions = {}) { this._strategy = new PrecacheStrategy({ cacheName: cacheNames.getPrecacheName(cacheName), plugins: [ ...plugins, new PrecacheCacheKeyPlugin({precacheController: this}), ], fallbackToNetwork, }); // Bind the install and activate methods to the instance. this.install = this.install.bind(this); this.activate = this.activate.bind(this); } /** * @type {workbox-precaching.PrecacheStrategy} The strategy created by this controller and * used to cache assets and respond to fetch events. */ get strategy(): Strategy { return this._strategy; } /** * Adds items to the precache list, removing any duplicates and * stores the files in the * {@link workbox-core.cacheNames|"precache cache"} when the service * worker installs. * * This method can be called multiple times. * * @param {Array} [entries=[]] Array of entries to precache. */ precache(entries: Array): void { this.addToCacheList(entries); if (!this._installAndActiveListenersAdded) { self.addEventListener('install', this.install); self.addEventListener('activate', this.activate); this._installAndActiveListenersAdded = true; } } /** * This method will add items to the precache list, removing duplicates * and ensuring the information is valid. * * @param {Array} entries * Array of entries to precache. */ addToCacheList(entries: Array): void { if (process.env.NODE_ENV !== 'production') { assert!.isArray(entries, { moduleName: 'workbox-precaching', className: 'PrecacheController', funcName: 'addToCacheList', paramName: 'entries', }); } const urlsToWarnAbout: string[] = []; for (const entry of entries) { // See https://github.com/GoogleChrome/workbox/issues/2259 if (typeof entry === 'string') { urlsToWarnAbout.push(entry); } else if (entry && entry.revision === undefined) { urlsToWarnAbout.push(entry.url); } const {cacheKey, url} = createCacheKey(entry); const cacheMode = typeof entry !== 'string' && entry.revision ? 'reload' : 'default'; if ( this._urlsToCacheKeys.has(url) && this._urlsToCacheKeys.get(url) !== cacheKey ) { throw new WorkboxError('add-to-cache-list-conflicting-entries', { firstEntry: this._urlsToCacheKeys.get(url), secondEntry: cacheKey, }); } if (typeof entry !== 'string' && entry.integrity) { if ( this._cacheKeysToIntegrities.has(cacheKey) && this._cacheKeysToIntegrities.get(cacheKey) !== entry.integrity ) { throw new WorkboxError('add-to-cache-list-conflicting-integrities', { url, }); } this._cacheKeysToIntegrities.set(cacheKey, entry.integrity); } this._urlsToCacheKeys.set(url, cacheKey); this._urlsToCacheModes.set(url, cacheMode); if (urlsToWarnAbout.length > 0) { const warningMessage = `Workbox is precaching URLs without revision ` + `info: ${urlsToWarnAbout.join(', ')}\nThis is generally NOT safe. ` + `Learn more at https://bit.ly/wb-precache`; if (process.env.NODE_ENV === 'production') { // Use console directly to display this warning without bloating // bundle sizes by pulling in all of the logger codebase in prod. console.warn(warningMessage); } else { logger.warn(warningMessage); } } } } /** * Precaches new and updated assets. Call this method from the service worker * install event. * * Note: this method calls `event.waitUntil()` for you, so you do not need * to call it yourself in your event handlers. * * @param {ExtendableEvent} event * @return {Promise} */ install(event: ExtendableEvent): Promise { // waitUntil returns Promise // eslint-disable-next-line @typescript-eslint/no-unsafe-return return waitUntil(event, async () => { const installReportPlugin = new PrecacheInstallReportPlugin(); this.strategy.plugins.push(installReportPlugin); // Cache entries one at a time. // See https://github.com/GoogleChrome/workbox/issues/2528 for (const [url, cacheKey] of this._urlsToCacheKeys) { const integrity = this._cacheKeysToIntegrities.get(cacheKey); const cacheMode = this._urlsToCacheModes.get(url); const request = new Request(url, { integrity, cache: cacheMode, credentials: 'same-origin', }); await Promise.all( this.strategy.handleAll({ params: {cacheKey}, request, event, }), ); } const {updatedURLs, notUpdatedURLs} = installReportPlugin; if (process.env.NODE_ENV !== 'production') { printInstallDetails(updatedURLs, notUpdatedURLs); } return {updatedURLs, notUpdatedURLs}; }); } /** * Deletes assets that are no longer present in the current precache manifest. * Call this method from the service worker activate event. * * Note: this method calls `event.waitUntil()` for you, so you do not need * to call it yourself in your event handlers. * * @param {ExtendableEvent} event * @return {Promise} */ activate(event: ExtendableEvent): Promise { // waitUntil returns Promise // eslint-disable-next-line @typescript-eslint/no-unsafe-return return waitUntil(event, async () => { const cache = await self.caches.open(this.strategy.cacheName); const currentlyCachedRequests = await cache.keys(); const expectedCacheKeys = new Set(this._urlsToCacheKeys.values()); const deletedURLs = []; for (const request of currentlyCachedRequests) { if (!expectedCacheKeys.has(request.url)) { await cache.delete(request); deletedURLs.push(request.url); } } if (process.env.NODE_ENV !== 'production') { printCleanupDetails(deletedURLs); } return {deletedURLs}; }); } /** * Returns a mapping of a precached URL to the corresponding cache key, taking * into account the revision information for the URL. * * @return {Map} A URL to cache key mapping. */ getURLsToCacheKeys(): Map { return this._urlsToCacheKeys; } /** * Returns a list of all the URLs that have been precached by the current * service worker. * * @return {Array} The precached URLs. */ getCachedURLs(): Array { 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: string): string | undefined { const urlObject = new URL(url, location.href); return this._urlsToCacheKeys.get(urlObject.href); } /** * @param {string} url A cache key whose SRI you want to look up. * @return {string} The subresource integrity associated with the cache key, * or undefined if it's not set. */ getIntegrityForCacheKey(cacheKey: string): string | undefined { return this._cacheKeysToIntegrities.get(cacheKey); } /** * This acts as a drop-in replacement for * [`cache.match()`](https://developer.mozilla.org/en-US/docs/Web/API/Cache/match) * with the following differences: * * - It knows what the name of the precache is, and only checks in that cache. * - It allows you to pass in an "original" URL without versioning parameters, * and it will automatically look up the correct cache key for the currently * active revision of that URL. * * E.g., `matchPrecache('index.html')` will find the correct precached * response for the currently active service worker, even if the actual cache * key is `'/index.html?__WB_REVISION__=1234abcd'`. * * @param {string|Request} request The key (without revisioning parameters) * to look up in the precache. * @return {Promise} */ async matchPrecache( request: string | Request, ): Promise { const url = request instanceof Request ? request.url : request; const cacheKey = this.getCacheKeyForURL(url); if (cacheKey) { const cache = await self.caches.open(this.strategy.cacheName); return cache.match(cacheKey); } return undefined; } /** * Returns a function that looks up `url` in the precache (taking into * account revision information), and returns the corresponding `Response`. * * @param {string} url The precached URL which will be used to lookup the * `Response`. * @return {workbox-routing~handlerCallback} */ createHandlerBoundToURL(url: string): RouteHandlerCallback { const cacheKey = this.getCacheKeyForURL(url); if (!cacheKey) { throw new WorkboxError('non-precached-url', {url}); } return (options) => { options.request = new Request(url); options.params = {cacheKey, ...options.params}; return this.strategy.handle(options); }; } } export {PrecacheController};