653 lines
21 KiB
JavaScript
653 lines
21 KiB
JavaScript
|
this.workbox = this.workbox || {};
|
||
|
|
this.workbox.expiration = (function (exports, DBWrapper_mjs, deleteDatabase_mjs, WorkboxError_mjs, assert_mjs, logger_mjs, cacheNames_mjs, getFriendlyURL_mjs, registerQuotaErrorCallback_mjs) {
|
||
|
|
'use strict';
|
||
|
|
|
||
|
|
try {
|
||
|
|
self['workbox:expiration:4.3.1'] && _();
|
||
|
|
} catch (e) {} // eslint-disable-line
|
||
|
|
|
||
|
|
/*
|
||
|
|
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 DB_NAME = 'workbox-expiration';
|
||
|
|
const OBJECT_STORE_NAME = 'cache-entries';
|
||
|
|
|
||
|
|
const normalizeURL = unNormalizedUrl => {
|
||
|
|
const url = new URL(unNormalizedUrl, location);
|
||
|
|
url.hash = '';
|
||
|
|
return url.href;
|
||
|
|
};
|
||
|
|
/**
|
||
|
|
* Returns the timestamp model.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
class CacheTimestampsModel {
|
||
|
|
/**
|
||
|
|
*
|
||
|
|
* @param {string} cacheName
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
*/
|
||
|
|
constructor(cacheName) {
|
||
|
|
this._cacheName = cacheName;
|
||
|
|
this._db = new DBWrapper_mjs.DBWrapper(DB_NAME, 1, {
|
||
|
|
onupgradeneeded: event => this._handleUpgrade(event)
|
||
|
|
});
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Should perform an upgrade of indexedDB.
|
||
|
|
*
|
||
|
|
* @param {Event} event
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
_handleUpgrade(event) {
|
||
|
|
const db = event.target.result; // TODO(philipwalton): EdgeHTML doesn't support arrays as a keyPath, so we
|
||
|
|
// have to use the `id` keyPath here and create our own values (a
|
||
|
|
// concatenation of `url + cacheName`) instead of simply using
|
||
|
|
// `keyPath: ['url', 'cacheName']`, which is supported in other browsers.
|
||
|
|
|
||
|
|
const objStore = db.createObjectStore(OBJECT_STORE_NAME, {
|
||
|
|
keyPath: 'id'
|
||
|
|
}); // TODO(philipwalton): once we don't have to support EdgeHTML, we can
|
||
|
|
// create a single index with the keyPath `['cacheName', 'timestamp']`
|
||
|
|
// instead of doing both these indexes.
|
||
|
|
|
||
|
|
objStore.createIndex('cacheName', 'cacheName', {
|
||
|
|
unique: false
|
||
|
|
});
|
||
|
|
objStore.createIndex('timestamp', 'timestamp', {
|
||
|
|
unique: false
|
||
|
|
}); // Previous versions of `workbox-expiration` used `this._cacheName`
|
||
|
|
// as the IDBDatabase name.
|
||
|
|
|
||
|
|
deleteDatabase_mjs.deleteDatabase(this._cacheName);
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* @param {string} url
|
||
|
|
* @param {number} timestamp
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
async setTimestamp(url, timestamp) {
|
||
|
|
url = normalizeURL(url);
|
||
|
|
await this._db.put(OBJECT_STORE_NAME, {
|
||
|
|
url,
|
||
|
|
timestamp,
|
||
|
|
cacheName: this._cacheName,
|
||
|
|
// Creating an ID from the URL and cache name won't be necessary once
|
||
|
|
// Edge switches to Chromium and all browsers we support work with
|
||
|
|
// array keyPaths.
|
||
|
|
id: this._getId(url)
|
||
|
|
});
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Returns the timestamp stored for a given URL.
|
||
|
|
*
|
||
|
|
* @param {string} url
|
||
|
|
* @return {number}
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
async getTimestamp(url) {
|
||
|
|
const entry = await this._db.get(OBJECT_STORE_NAME, this._getId(url));
|
||
|
|
return entry.timestamp;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Iterates through all the entries in the object store (from newest to
|
||
|
|
* oldest) and removes entries once either `maxCount` is reached or the
|
||
|
|
* entry's timestamp is less than `minTimestamp`.
|
||
|
|
*
|
||
|
|
* @param {number} minTimestamp
|
||
|
|
* @param {number} maxCount
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
async expireEntries(minTimestamp, maxCount) {
|
||
|
|
const entriesToDelete = await this._db.transaction(OBJECT_STORE_NAME, 'readwrite', (txn, done) => {
|
||
|
|
const store = txn.objectStore(OBJECT_STORE_NAME);
|
||
|
|
const entriesToDelete = [];
|
||
|
|
let entriesNotDeletedCount = 0;
|
||
|
|
|
||
|
|
store.index('timestamp').openCursor(null, 'prev').onsuccess = ({
|
||
|
|
target
|
||
|
|
}) => {
|
||
|
|
const cursor = target.result;
|
||
|
|
|
||
|
|
if (cursor) {
|
||
|
|
const result = cursor.value; // TODO(philipwalton): once we can use a multi-key index, we
|
||
|
|
// won't have to check `cacheName` here.
|
||
|
|
|
||
|
|
if (result.cacheName === this._cacheName) {
|
||
|
|
// Delete an entry if it's older than the max age or
|
||
|
|
// if we already have the max number allowed.
|
||
|
|
if (minTimestamp && result.timestamp < minTimestamp || maxCount && entriesNotDeletedCount >= maxCount) {
|
||
|
|
// TODO(philipwalton): we should be able to delete the
|
||
|
|
// entry right here, but doing so causes an iteration
|
||
|
|
// bug in Safari stable (fixed in TP). Instead we can
|
||
|
|
// store the keys of the entries to delete, and then
|
||
|
|
// delete the separate transactions.
|
||
|
|
// https://github.com/GoogleChrome/workbox/issues/1978
|
||
|
|
// cursor.delete();
|
||
|
|
// We only need to return the URL, not the whole entry.
|
||
|
|
entriesToDelete.push(cursor.value);
|
||
|
|
} else {
|
||
|
|
entriesNotDeletedCount++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
cursor.continue();
|
||
|
|
} else {
|
||
|
|
done(entriesToDelete);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}); // TODO(philipwalton): once the Safari bug in the following issue is fixed,
|
||
|
|
// we should be able to remove this loop and do the entry deletion in the
|
||
|
|
// cursor loop above:
|
||
|
|
// https://github.com/GoogleChrome/workbox/issues/1978
|
||
|
|
|
||
|
|
const urlsDeleted = [];
|
||
|
|
|
||
|
|
for (const entry of entriesToDelete) {
|
||
|
|
await this._db.delete(OBJECT_STORE_NAME, entry.id);
|
||
|
|
urlsDeleted.push(entry.url);
|
||
|
|
}
|
||
|
|
|
||
|
|
return urlsDeleted;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Takes a URL and returns an ID that will be unique in the object store.
|
||
|
|
*
|
||
|
|
* @param {string} url
|
||
|
|
* @return {string}
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
_getId(url) {
|
||
|
|
// Creating an ID from the URL and cache name won't be necessary once
|
||
|
|
// Edge switches to Chromium and all browsers we support work with
|
||
|
|
// array keyPaths.
|
||
|
|
return this._cacheName + '|' + normalizeURL(url);
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
Copyright 2018 Google LLC
|
||
|
|
|
||
|
|
Use of this source code is governed by an MIT-style
|
||
|
|
license that can be found in the LICENSE file or at
|
||
|
|
https://opensource.org/licenses/MIT.
|
||
|
|
*/
|
||
|
|
/**
|
||
|
|
* The `CacheExpiration` class allows you define an expiration and / or
|
||
|
|
* limit on the number of responses stored in a
|
||
|
|
* [`Cache`](https://developer.mozilla.org/en-US/docs/Web/API/Cache).
|
||
|
|
*
|
||
|
|
* @memberof workbox.expiration
|
||
|
|
*/
|
||
|
|
|
||
|
|
class CacheExpiration {
|
||
|
|
/**
|
||
|
|
* To construct a new CacheExpiration instance you must provide at least
|
||
|
|
* one of the `config` properties.
|
||
|
|
*
|
||
|
|
* @param {string} cacheName Name of the cache to apply restrictions to.
|
||
|
|
* @param {Object} config
|
||
|
|
* @param {number} [config.maxEntries] The maximum number of entries to cache.
|
||
|
|
* Entries used the least will be removed as the maximum is reached.
|
||
|
|
* @param {number} [config.maxAgeSeconds] The maximum age of an entry before
|
||
|
|
* it's treated as stale and removed.
|
||
|
|
*/
|
||
|
|
constructor(cacheName, config = {}) {
|
||
|
|
{
|
||
|
|
assert_mjs.assert.isType(cacheName, 'string', {
|
||
|
|
moduleName: 'workbox-expiration',
|
||
|
|
className: 'CacheExpiration',
|
||
|
|
funcName: 'constructor',
|
||
|
|
paramName: 'cacheName'
|
||
|
|
});
|
||
|
|
|
||
|
|
if (!(config.maxEntries || config.maxAgeSeconds)) {
|
||
|
|
throw new WorkboxError_mjs.WorkboxError('max-entries-or-age-required', {
|
||
|
|
moduleName: 'workbox-expiration',
|
||
|
|
className: 'CacheExpiration',
|
||
|
|
funcName: 'constructor'
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
if (config.maxEntries) {
|
||
|
|
assert_mjs.assert.isType(config.maxEntries, 'number', {
|
||
|
|
moduleName: 'workbox-expiration',
|
||
|
|
className: 'CacheExpiration',
|
||
|
|
funcName: 'constructor',
|
||
|
|
paramName: 'config.maxEntries'
|
||
|
|
}); // TODO: Assert is positive
|
||
|
|
}
|
||
|
|
|
||
|
|
if (config.maxAgeSeconds) {
|
||
|
|
assert_mjs.assert.isType(config.maxAgeSeconds, 'number', {
|
||
|
|
moduleName: 'workbox-expiration',
|
||
|
|
className: 'CacheExpiration',
|
||
|
|
funcName: 'constructor',
|
||
|
|
paramName: 'config.maxAgeSeconds'
|
||
|
|
}); // TODO: Assert is positive
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
this._isRunning = false;
|
||
|
|
this._rerunRequested = false;
|
||
|
|
this._maxEntries = config.maxEntries;
|
||
|
|
this._maxAgeSeconds = config.maxAgeSeconds;
|
||
|
|
this._cacheName = cacheName;
|
||
|
|
this._timestampModel = new CacheTimestampsModel(cacheName);
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Expires entries for the given cache and given criteria.
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
async expireEntries() {
|
||
|
|
if (this._isRunning) {
|
||
|
|
this._rerunRequested = true;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
this._isRunning = true;
|
||
|
|
const minTimestamp = this._maxAgeSeconds ? Date.now() - this._maxAgeSeconds * 1000 : undefined;
|
||
|
|
const urlsExpired = await this._timestampModel.expireEntries(minTimestamp, this._maxEntries); // Delete URLs from the cache
|
||
|
|
|
||
|
|
const cache = await caches.open(this._cacheName);
|
||
|
|
|
||
|
|
for (const url of urlsExpired) {
|
||
|
|
await cache.delete(url);
|
||
|
|
}
|
||
|
|
|
||
|
|
{
|
||
|
|
if (urlsExpired.length > 0) {
|
||
|
|
logger_mjs.logger.groupCollapsed(`Expired ${urlsExpired.length} ` + `${urlsExpired.length === 1 ? 'entry' : 'entries'} and removed ` + `${urlsExpired.length === 1 ? 'it' : 'them'} from the ` + `'${this._cacheName}' cache.`);
|
||
|
|
logger_mjs.logger.log(`Expired the following ${urlsExpired.length === 1 ? 'URL' : 'URLs'}:`);
|
||
|
|
urlsExpired.forEach(url => logger_mjs.logger.log(` ${url}`));
|
||
|
|
logger_mjs.logger.groupEnd();
|
||
|
|
} else {
|
||
|
|
logger_mjs.logger.debug(`Cache expiration ran and found no entries to remove.`);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
this._isRunning = false;
|
||
|
|
|
||
|
|
if (this._rerunRequested) {
|
||
|
|
this._rerunRequested = false;
|
||
|
|
this.expireEntries();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Update the timestamp for the given URL. This ensures the when
|
||
|
|
* removing entries based on maximum entries, most recently used
|
||
|
|
* is accurate or when expiring, the timestamp is up-to-date.
|
||
|
|
*
|
||
|
|
* @param {string} url
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
async updateTimestamp(url) {
|
||
|
|
{
|
||
|
|
assert_mjs.assert.isType(url, 'string', {
|
||
|
|
moduleName: 'workbox-expiration',
|
||
|
|
className: 'CacheExpiration',
|
||
|
|
funcName: 'updateTimestamp',
|
||
|
|
paramName: 'url'
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
await this._timestampModel.setTimestamp(url, Date.now());
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Can be used to check if a URL has expired or not before it's used.
|
||
|
|
*
|
||
|
|
* This requires a look up from IndexedDB, so can be slow.
|
||
|
|
*
|
||
|
|
* Note: This method will not remove the cached entry, call
|
||
|
|
* `expireEntries()` to remove indexedDB and Cache entries.
|
||
|
|
*
|
||
|
|
* @param {string} url
|
||
|
|
* @return {boolean}
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
async isURLExpired(url) {
|
||
|
|
{
|
||
|
|
if (!this._maxAgeSeconds) {
|
||
|
|
throw new WorkboxError_mjs.WorkboxError(`expired-test-without-max-age`, {
|
||
|
|
methodName: 'isURLExpired',
|
||
|
|
paramName: 'maxAgeSeconds'
|
||
|
|
});
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
const timestamp = await this._timestampModel.getTimestamp(url);
|
||
|
|
const expireOlderThan = Date.now() - this._maxAgeSeconds * 1000;
|
||
|
|
return timestamp < expireOlderThan;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* Removes the IndexedDB object store used to keep track of cache expiration
|
||
|
|
* metadata.
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
async delete() {
|
||
|
|
// Make sure we don't attempt another rerun if we're called in the middle of
|
||
|
|
// a cache expiration.
|
||
|
|
this._rerunRequested = false;
|
||
|
|
await this._timestampModel.expireEntries(Infinity); // Expires all.
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
Copyright 2018 Google LLC
|
||
|
|
|
||
|
|
Use of this source code is governed by an MIT-style
|
||
|
|
license that can be found in the LICENSE file or at
|
||
|
|
https://opensource.org/licenses/MIT.
|
||
|
|
*/
|
||
|
|
/**
|
||
|
|
* This plugin can be used in the Workbox APIs to regularly enforce a
|
||
|
|
* limit on the age and / or the number of cached requests.
|
||
|
|
*
|
||
|
|
* Whenever a cached request is used or updated, this plugin will look
|
||
|
|
* at the used Cache and remove any old or extra requests.
|
||
|
|
*
|
||
|
|
* When using `maxAgeSeconds`, requests may be used *once* after expiring
|
||
|
|
* because the expiration clean up will not have occurred until *after* the
|
||
|
|
* cached request has been used. If the request has a "Date" header, then
|
||
|
|
* a light weight expiration check is performed and the request will not be
|
||
|
|
* used immediately.
|
||
|
|
*
|
||
|
|
* When using `maxEntries`, the entry least-recently requested will be removed from the cache first.
|
||
|
|
*
|
||
|
|
* @memberof workbox.expiration
|
||
|
|
*/
|
||
|
|
|
||
|
|
class Plugin {
|
||
|
|
/**
|
||
|
|
* @param {Object} config
|
||
|
|
* @param {number} [config.maxEntries] The maximum number of entries to cache.
|
||
|
|
* Entries used the least will be removed as the maximum is reached.
|
||
|
|
* @param {number} [config.maxAgeSeconds] The maximum age of an entry before
|
||
|
|
* it's treated as stale and removed.
|
||
|
|
* @param {boolean} [config.purgeOnQuotaError] Whether to opt this cache in to
|
||
|
|
* automatic deletion if the available storage quota has been exceeded.
|
||
|
|
*/
|
||
|
|
constructor(config = {}) {
|
||
|
|
{
|
||
|
|
if (!(config.maxEntries || config.maxAgeSeconds)) {
|
||
|
|
throw new WorkboxError_mjs.WorkboxError('max-entries-or-age-required', {
|
||
|
|
moduleName: 'workbox-expiration',
|
||
|
|
className: 'Plugin',
|
||
|
|
funcName: 'constructor'
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
if (config.maxEntries) {
|
||
|
|
assert_mjs.assert.isType(config.maxEntries, 'number', {
|
||
|
|
moduleName: 'workbox-expiration',
|
||
|
|
className: 'Plugin',
|
||
|
|
funcName: 'constructor',
|
||
|
|
paramName: 'config.maxEntries'
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
if (config.maxAgeSeconds) {
|
||
|
|
assert_mjs.assert.isType(config.maxAgeSeconds, 'number', {
|
||
|
|
moduleName: 'workbox-expiration',
|
||
|
|
className: 'Plugin',
|
||
|
|
funcName: 'constructor',
|
||
|
|
paramName: 'config.maxAgeSeconds'
|
||
|
|
});
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
this._config = config;
|
||
|
|
this._maxAgeSeconds = config.maxAgeSeconds;
|
||
|
|
this._cacheExpirations = new Map();
|
||
|
|
|
||
|
|
if (config.purgeOnQuotaError) {
|
||
|
|
registerQuotaErrorCallback_mjs.registerQuotaErrorCallback(() => this.deleteCacheAndMetadata());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* A simple helper method to return a CacheExpiration instance for a given
|
||
|
|
* cache name.
|
||
|
|
*
|
||
|
|
* @param {string} cacheName
|
||
|
|
* @return {CacheExpiration}
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
_getCacheExpiration(cacheName) {
|
||
|
|
if (cacheName === cacheNames_mjs.cacheNames.getRuntimeName()) {
|
||
|
|
throw new WorkboxError_mjs.WorkboxError('expire-custom-caches-only');
|
||
|
|
}
|
||
|
|
|
||
|
|
let cacheExpiration = this._cacheExpirations.get(cacheName);
|
||
|
|
|
||
|
|
if (!cacheExpiration) {
|
||
|
|
cacheExpiration = new CacheExpiration(cacheName, this._config);
|
||
|
|
|
||
|
|
this._cacheExpirations.set(cacheName, cacheExpiration);
|
||
|
|
}
|
||
|
|
|
||
|
|
return cacheExpiration;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* A "lifecycle" callback that will be triggered automatically by the
|
||
|
|
* `workbox.strategies` handlers when a `Response` is about to be returned
|
||
|
|
* from a [Cache](https://developer.mozilla.org/en-US/docs/Web/API/Cache) to
|
||
|
|
* the handler. It allows the `Response` to be inspected for freshness and
|
||
|
|
* prevents it from being used if the `Response`'s `Date` header value is
|
||
|
|
* older than the configured `maxAgeSeconds`.
|
||
|
|
*
|
||
|
|
* @param {Object} options
|
||
|
|
* @param {string} options.cacheName Name of the cache the response is in.
|
||
|
|
* @param {Response} options.cachedResponse The `Response` object that's been
|
||
|
|
* read from a cache and whose freshness should be checked.
|
||
|
|
* @return {Response} Either the `cachedResponse`, if it's
|
||
|
|
* fresh, or `null` if the `Response` is older than `maxAgeSeconds`.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
cachedResponseWillBeUsed({
|
||
|
|
event,
|
||
|
|
request,
|
||
|
|
cacheName,
|
||
|
|
cachedResponse
|
||
|
|
}) {
|
||
|
|
if (!cachedResponse) {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
let isFresh = this._isResponseDateFresh(cachedResponse); // Expire entries to ensure that even if the expiration date has
|
||
|
|
// expired, it'll only be used once.
|
||
|
|
|
||
|
|
|
||
|
|
const cacheExpiration = this._getCacheExpiration(cacheName);
|
||
|
|
|
||
|
|
cacheExpiration.expireEntries(); // Update the metadata for the request URL to the current timestamp,
|
||
|
|
// but don't `await` it as we don't want to block the response.
|
||
|
|
|
||
|
|
const updateTimestampDone = cacheExpiration.updateTimestamp(request.url);
|
||
|
|
|
||
|
|
if (event) {
|
||
|
|
try {
|
||
|
|
event.waitUntil(updateTimestampDone);
|
||
|
|
} catch (error) {
|
||
|
|
{
|
||
|
|
logger_mjs.logger.warn(`Unable to ensure service worker stays alive when ` + `updating cache entry for '${getFriendlyURL_mjs.getFriendlyURL(event.request.url)}'.`);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return isFresh ? cachedResponse : null;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* @param {Response} cachedResponse
|
||
|
|
* @return {boolean}
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
_isResponseDateFresh(cachedResponse) {
|
||
|
|
if (!this._maxAgeSeconds) {
|
||
|
|
// We aren't expiring by age, so return true, it's fresh
|
||
|
|
return true;
|
||
|
|
} // Check if the 'date' header will suffice a quick expiration check.
|
||
|
|
// See https://github.com/GoogleChromeLabs/sw-toolbox/issues/164 for
|
||
|
|
// discussion.
|
||
|
|
|
||
|
|
|
||
|
|
const dateHeaderTimestamp = this._getDateHeaderTimestamp(cachedResponse);
|
||
|
|
|
||
|
|
if (dateHeaderTimestamp === null) {
|
||
|
|
// Unable to parse date, so assume it's fresh.
|
||
|
|
return true;
|
||
|
|
} // If we have a valid headerTime, then our response is fresh iff the
|
||
|
|
// headerTime plus maxAgeSeconds is greater than the current time.
|
||
|
|
|
||
|
|
|
||
|
|
const now = Date.now();
|
||
|
|
return dateHeaderTimestamp >= now - this._maxAgeSeconds * 1000;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* This method will extract the data header and parse it into a useful
|
||
|
|
* value.
|
||
|
|
*
|
||
|
|
* @param {Response} cachedResponse
|
||
|
|
* @return {number}
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
_getDateHeaderTimestamp(cachedResponse) {
|
||
|
|
if (!cachedResponse.headers.has('date')) {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
const dateHeader = cachedResponse.headers.get('date');
|
||
|
|
const parsedDate = new Date(dateHeader);
|
||
|
|
const headerTime = parsedDate.getTime(); // If the Date header was invalid for some reason, parsedDate.getTime()
|
||
|
|
// will return NaN.
|
||
|
|
|
||
|
|
if (isNaN(headerTime)) {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
return headerTime;
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* A "lifecycle" callback that will be triggered automatically by the
|
||
|
|
* `workbox.strategies` handlers when an entry is added to a cache.
|
||
|
|
*
|
||
|
|
* @param {Object} options
|
||
|
|
* @param {string} options.cacheName Name of the cache that was updated.
|
||
|
|
* @param {string} options.request The Request for the cached entry.
|
||
|
|
*
|
||
|
|
* @private
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
async cacheDidUpdate({
|
||
|
|
cacheName,
|
||
|
|
request
|
||
|
|
}) {
|
||
|
|
{
|
||
|
|
assert_mjs.assert.isType(cacheName, 'string', {
|
||
|
|
moduleName: 'workbox-expiration',
|
||
|
|
className: 'Plugin',
|
||
|
|
funcName: 'cacheDidUpdate',
|
||
|
|
paramName: 'cacheName'
|
||
|
|
});
|
||
|
|
assert_mjs.assert.isInstance(request, Request, {
|
||
|
|
moduleName: 'workbox-expiration',
|
||
|
|
className: 'Plugin',
|
||
|
|
funcName: 'cacheDidUpdate',
|
||
|
|
paramName: 'request'
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
const cacheExpiration = this._getCacheExpiration(cacheName);
|
||
|
|
|
||
|
|
await cacheExpiration.updateTimestamp(request.url);
|
||
|
|
await cacheExpiration.expireEntries();
|
||
|
|
}
|
||
|
|
/**
|
||
|
|
* This is a helper method that performs two operations:
|
||
|
|
*
|
||
|
|
* - Deletes *all* the underlying Cache instances associated with this plugin
|
||
|
|
* instance, by calling caches.delete() on your behalf.
|
||
|
|
* - Deletes the metadata from IndexedDB used to keep track of expiration
|
||
|
|
* details for each Cache instance.
|
||
|
|
*
|
||
|
|
* When using cache expiration, calling this method is preferable to calling
|
||
|
|
* `caches.delete()` directly, since this will ensure that the IndexedDB
|
||
|
|
* metadata is also cleanly removed and open IndexedDB instances are deleted.
|
||
|
|
*
|
||
|
|
* Note that if you're *not* using cache expiration for a given cache, calling
|
||
|
|
* `caches.delete()` and passing in the cache's name should be sufficient.
|
||
|
|
* There is no Workbox-specific method needed for cleanup in that case.
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
async deleteCacheAndMetadata() {
|
||
|
|
// Do this one at a time instead of all at once via `Promise.all()` to
|
||
|
|
// reduce the chance of inconsistency if a promise rejects.
|
||
|
|
for (const [cacheName, cacheExpiration] of this._cacheExpirations) {
|
||
|
|
await caches.delete(cacheName);
|
||
|
|
await cacheExpiration.delete();
|
||
|
|
} // Reset this._cacheExpirations to its initial state.
|
||
|
|
|
||
|
|
|
||
|
|
this._cacheExpirations = new Map();
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
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.
|
||
|
|
*/
|
||
|
|
|
||
|
|
exports.CacheExpiration = CacheExpiration;
|
||
|
|
exports.Plugin = Plugin;
|
||
|
|
|
||
|
|
return exports;
|
||
|
|
|
||
|
|
}({}, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core._private, workbox.core));
|
||
|
|
//# sourceMappingURL=workbox-expiration.dev.js.map
|