gnx/GNX-mailEnterprise
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Mail

Browse Source
This commit is contained in:
Iliyan Angelov
2025-09-14 23:24:25 +03:00
commit c67067a2a4
71311 changed files with 6800714 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
frontend/node_modules/workbox-precaching/LICENSE generated vendored Normal file
View File

@@ -0,0 +1,19 @@
Copyright 2018 Google LLC
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

142
frontend/node_modules/workbox-precaching/PrecacheController.d.ts generated vendored Normal file
View File

@@ -0,0 +1,142 @@
import { Strategy } from 'workbox-strategies/Strategy.js';
import { RouteHandlerCallback, WorkboxPlugin } from 'workbox-core/types.js';
import { PrecacheEntry, InstallResult, CleanupResult } from './_types.js';
import './_version.js';
declare global {
interface ServiceWorkerGlobalScope {
__WB_MANIFEST: Array<PrecacheEntry | string>;
}
}
interface PrecacheControllerOptions {
cacheName?: string;
plugins?: WorkboxPlugin[];
fallbackToNetwork?: boolean;
}
/**
* Performs efficient precaching of assets.
*
* @memberof workbox-precaching
*/
declare class PrecacheController {
private _installAndActiveListenersAdded?;
private readonly _strategy;
private readonly _urlsToCacheKeys;
private readonly _urlsToCacheModes;
private readonly _cacheKeysToIntegrities;
/**
* 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, }?: PrecacheControllerOptions);
/**
* @type {workbox-precaching.PrecacheStrategy} The strategy created by this controller and
* used to cache assets and respond to fetch events.
*/
get strategy(): 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<Object|string>} [entries=[]] Array of entries to precache.
*/
precache(entries: Array<PrecacheEntry | string>): void;
/**
* This method will add items to the precache list, removing duplicates
* and ensuring the information is valid.
*
* @param {Array<workbox-precaching.PrecacheController.PrecacheEntry|string>} entries
* Array of entries to precache.
*/
addToCacheList(entries: Array<PrecacheEntry | string>): void;
/**
* 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<workbox-precaching.InstallResult>}
*/
install(event: ExtendableEvent): Promise<InstallResult>;
/**
* 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<workbox-precaching.CleanupResult>}
*/
activate(event: ExtendableEvent): Promise<CleanupResult>;
/**
* 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(): Map<string, string>;
/**
* Returns a list of all the URLs that have been precached by the current
* service worker.
*
* @return {Array<string>} The precached URLs.
*/
getCachedURLs(): Array<string>;
/**
* 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;
/**
* @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;
/**
* 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<Response|undefined>}
*/
matchPrecache(request: string | Request): Promise<Response | 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;
}
export { PrecacheController };

292
frontend/node_modules/workbox-precaching/PrecacheController.js generated vendored Normal file
View File

@@ -0,0 +1,292 @@
/*
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 { 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 './_version.js';
/**
* Performs efficient precaching of assets.
*
* @memberof workbox-precaching
*/
class PrecacheController {
/**
* 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, } = {}) {
this._urlsToCacheKeys = new Map();
this._urlsToCacheModes = new Map();
this._cacheKeysToIntegrities = new Map();
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() {
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<Object|string>} [entries=[]] Array of entries to precache.
*/
precache(entries) {
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<workbox-precaching.PrecacheController.PrecacheEntry|string>} entries
* Array of entries to precache.
*/
addToCacheList(entries) {
if (process.env.NODE_ENV !== 'production') {
assert.isArray(entries, {
moduleName: 'workbox-precaching',
className: 'PrecacheController',
funcName: 'addToCacheList',
paramName: 'entries',
});
}
const urlsToWarnAbout = [];
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<workbox-precaching.InstallResult>}
*/
install(event) {
// waitUntil returns Promise<any>
// 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<workbox-precaching.CleanupResult>}
*/
activate(event) {
// waitUntil returns Promise<any>
// 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<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.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) {
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<Response|undefined>}
*/
async matchPrecache(request) {
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) {
const cacheKey = this.getCacheKeyForURL(url);
if (!cacheKey) {
throw new WorkboxError('non-precached-url', { url });
}
return (options) => {
options.request = new Request(url);
options.params = Object.assign({ cacheKey }, options.params);
return this.strategy.handle(options);
};
}
}
export { PrecacheController };

1
frontend/node_modules/workbox-precaching/PrecacheController.mjs generated vendored Normal file
View File

@@ -0,0 +1 @@
export * from './PrecacheController.js';

42
frontend/node_modules/workbox-precaching/PrecacheFallbackPlugin.d.ts generated vendored Normal file
View File

@@ -0,0 +1,42 @@
import { WorkboxPlugin } from 'workbox-core/types.js';
import { PrecacheController } from './PrecacheController.js';
import './_version.js';
/**
* `PrecacheFallbackPlugin` allows you to specify an "offline fallback"
* response to be used when a given strategy is unable to generate a response.
*
* It does this by intercepting the `handlerDidError` plugin callback
* and returning a precached response, taking the expected revision parameter
* into account automatically.
*
* Unless you explicitly pass in a `PrecacheController` instance to the
* constructor, the default instance will be used. Generally speaking, most
* developers will end up using the default.
*
* @memberof workbox-precaching
*/
declare class PrecacheFallbackPlugin implements WorkboxPlugin {
private readonly _fallbackURL;
private readonly _precacheController;
/**
* Constructs a new PrecacheFallbackPlugin with the associated fallbackURL.
*
* @param {Object} config
* @param {string} config.fallbackURL A precached URL to use as the fallback
* if the associated strategy can't generate a response.
* @param {PrecacheController} [config.precacheController] An optional
* PrecacheController instance. If not provided, the default
* PrecacheController will be used.
*/
constructor({ fallbackURL, precacheController, }: {
fallbackURL: string;
precacheController?: PrecacheController;
});
/**
* @return {Promise<Response>} The precache response for the fallback URL.
*
* @private
*/
handlerDidError: WorkboxPlugin['handlerDidError'];
}
export { PrecacheFallbackPlugin };

47
frontend/node_modules/workbox-precaching/PrecacheFallbackPlugin.js generated vendored Normal file
View File

@@ -0,0 +1,47 @@
/*
Copyright 2020 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 { getOrCreatePrecacheController } from './utils/getOrCreatePrecacheController.js';
import './_version.js';
/**
* `PrecacheFallbackPlugin` allows you to specify an "offline fallback"
* response to be used when a given strategy is unable to generate a response.
*
* It does this by intercepting the `handlerDidError` plugin callback
* and returning a precached response, taking the expected revision parameter
* into account automatically.
*
* Unless you explicitly pass in a `PrecacheController` instance to the
* constructor, the default instance will be used. Generally speaking, most
* developers will end up using the default.
*
* @memberof workbox-precaching
*/
class PrecacheFallbackPlugin {
/**
* Constructs a new PrecacheFallbackPlugin with the associated fallbackURL.
*
* @param {Object} config
* @param {string} config.fallbackURL A precached URL to use as the fallback
* if the associated strategy can't generate a response.
* @param {PrecacheController} [config.precacheController] An optional
* PrecacheController instance. If not provided, the default
* PrecacheController will be used.
*/
constructor({ fallbackURL, precacheController, }) {
/**
* @return {Promise<Response>} The precache response for the fallback URL.
*
* @private
*/
this.handlerDidError = () => this._precacheController.matchPrecache(this._fallbackURL);
this._fallbackURL = fallbackURL;
this._precacheController =
precacheController || getOrCreatePrecacheController();
}
}
export { PrecacheFallbackPlugin };

1
frontend/node_modules/workbox-precaching/PrecacheFallbackPlugin.mjs generated vendored Normal file
View File

@@ -0,0 +1 @@
export * from './PrecacheFallbackPlugin.js';

33
frontend/node_modules/workbox-precaching/PrecacheRoute.d.ts generated vendored Normal file
View File

@@ -0,0 +1,33 @@
import { Route } from 'workbox-routing/Route.js';
import { PrecacheRouteOptions } from './_types.js';
import { PrecacheController } from './PrecacheController.js';
import './_version.js';
/**
* A subclass of {@link workbox-routing.Route} that takes a
* {@link workbox-precaching.PrecacheController}
* instance and uses it to match incoming requests and handle fetching
* responses from the precache.
*
* @memberof workbox-precaching
* @extends workbox-routing.Route
*/
declare class PrecacheRoute extends Route {
/**
* @param {PrecacheController} precacheController A `PrecacheController`
* instance used to both match requests and respond to fetch events.
* @param {Object} [options] Options to control how requests are matched
* against the list of precached URLs.
* @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_/, /^fbclid$/]] 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 URLs that should be checked for precache matches.
*/
constructor(precacheController: PrecacheController, options?: PrecacheRouteOptions);
}
export { PrecacheRoute };

57
frontend/node_modules/workbox-precaching/PrecacheRoute.js generated vendored Normal file
View File

@@ -0,0 +1,57 @@
/*
Copyright 2020 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 { logger } from 'workbox-core/_private/logger.js';
import { getFriendlyURL } from 'workbox-core/_private/getFriendlyURL.js';
import { Route } from 'workbox-routing/Route.js';
import { generateURLVariations } from './utils/generateURLVariations.js';
import './_version.js';
/**
* A subclass of {@link workbox-routing.Route} that takes a
* {@link workbox-precaching.PrecacheController}
* instance and uses it to match incoming requests and handle fetching
* responses from the precache.
*
* @memberof workbox-precaching
* @extends workbox-routing.Route
*/
class PrecacheRoute extends Route {
/**
* @param {PrecacheController} precacheController A `PrecacheController`
* instance used to both match requests and respond to fetch events.
* @param {Object} [options] Options to control how requests are matched
* against the list of precached URLs.
* @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_/, /^fbclid$/]] 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 URLs that should be checked for precache matches.
*/
constructor(precacheController, options) {
const match = ({ request, }) => {
const urlsToCacheKeys = precacheController.getURLsToCacheKeys();
for (const possibleURL of generateURLVariations(request.url, options)) {
const cacheKey = urlsToCacheKeys.get(possibleURL);
if (cacheKey) {
const integrity = precacheController.getIntegrityForCacheKey(cacheKey);
return { cacheKey, integrity };
}
}
if (process.env.NODE_ENV !== 'production') {
logger.debug(`Precaching did not find a match for ` + getFriendlyURL(request.url));
}
return;
};
super(match, precacheController.strategy);
}
}
export { PrecacheRoute };

1
frontend/node_modules/workbox-precaching/PrecacheRoute.mjs generated vendored Normal file
View File

@@ -0,0 +1 @@
export * from './PrecacheRoute.js';

81
frontend/node_modules/workbox-precaching/PrecacheStrategy.d.ts generated vendored Normal file
View File

@@ -0,0 +1,81 @@
import { WorkboxPlugin } from 'workbox-core/types.js';
import { Strategy, StrategyOptions } from 'workbox-strategies/Strategy.js';
import { StrategyHandler } from 'workbox-strategies/StrategyHandler.js';
import './_version.js';
interface PrecacheStrategyOptions extends StrategyOptions {
fallbackToNetwork?: boolean;
}
/**
* A {@link workbox-strategies.Strategy} implementation
* specifically designed to work with
* {@link workbox-precaching.PrecacheController}
* to both cache and fetch precached assets.
*
* Note: an instance of this class is created automatically when creating a
* `PrecacheController`; it's generally not necessary to create this yourself.
*
* @extends workbox-strategies.Strategy
* @memberof workbox-precaching
*/
declare class PrecacheStrategy extends Strategy {
private readonly _fallbackToNetwork;
static readonly defaultPrecacheCacheabilityPlugin: WorkboxPlugin;
static readonly copyRedirectedCacheableResponsesPlugin: WorkboxPlugin;
/**
*
* @param {Object} [options]
* @param {string} [options.cacheName] Cache name to store and retrieve
* requests. Defaults to the cache names provided by
* {@link workbox-core.cacheNames}.
* @param {Array<Object>} [options.plugins] {@link https://developers.google.com/web/tools/workbox/guides/using-plugins|Plugins}
* to use in conjunction with this caching strategy.
* @param {Object} [options.fetchOptions] Values passed along to the
* {@link https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters|init}
* of all fetch() requests made by this strategy.
* @param {Object} [options.matchOptions] The
* {@link https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions|CacheQueryOptions}
* for any `cache.match()` or `cache.put()` calls made by this strategy.
* @param {boolean} [options.fallbackToNetwork=true] Whether to attempt to
* get the response from the network if there's a precache miss.
*/
constructor(options?: PrecacheStrategyOptions);
/**
* @private
* @param {Request|string} request A request to run this strategy for.
* @param {workbox-strategies.StrategyHandler} handler The event that
* triggered the request.
* @return {Promise<Response>}
*/
_handle(request: Request, handler: StrategyHandler): Promise<Response>;
_handleFetch(request: Request, handler: StrategyHandler): Promise<Response>;
_handleInstall(request: Request, handler: StrategyHandler): Promise<Response>;
/**
* This method is complex, as there a number of things to account for:
*
* The `plugins` array can be set at construction, and/or it might be added to
* to at any time before the strategy is used.
*
* At the time the strategy is used (i.e. during an `install` event), there
* needs to be at least one plugin that implements `cacheWillUpdate` in the
* array, other than `copyRedirectedCacheableResponsesPlugin`.
*
* - If this method is called and there are no suitable `cacheWillUpdate`
* plugins, we need to add `defaultPrecacheCacheabilityPlugin`.
*
* - If this method is called and there is exactly one `cacheWillUpdate`, then
* we don't have to do anything (this might be a previously added
* `defaultPrecacheCacheabilityPlugin`, or it might be a custom plugin).
*
* - If this method is called and there is more than one `cacheWillUpdate`,
* then we need to check if one is `defaultPrecacheCacheabilityPlugin`. If so,
* we need to remove it. (This situation is unlikely, but it could happen if
* the strategy is used multiple times, the first without a `cacheWillUpdate`,
* and then later on after manually adding a custom `cacheWillUpdate`.)
*
* See https://github.com/GoogleChrome/workbox/issues/2737 for more context.
*
* @private
*/
_useDefaultCacheabilityPluginIfNeeded(): void;
}
export { PrecacheStrategy };

223
frontend/node_modules/workbox-precaching/PrecacheStrategy.js generated vendored Normal file
View File

@@ -0,0 +1,223 @@
/*
Copyright 2020 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 { copyResponse } from 'workbox-core/copyResponse.js';
import { cacheNames } from 'workbox-core/_private/cacheNames.js';
import { getFriendlyURL } from 'workbox-core/_private/getFriendlyURL.js';
import { logger } from 'workbox-core/_private/logger.js';
import { WorkboxError } from 'workbox-core/_private/WorkboxError.js';
import { Strategy } from 'workbox-strategies/Strategy.js';
import './_version.js';
/**
* A {@link workbox-strategies.Strategy} implementation
* specifically designed to work with
* {@link workbox-precaching.PrecacheController}
* to both cache and fetch precached assets.
*
* Note: an instance of this class is created automatically when creating a
* `PrecacheController`; it's generally not necessary to create this yourself.
*
* @extends workbox-strategies.Strategy
* @memberof workbox-precaching
*/
class PrecacheStrategy extends Strategy {
/**
*
* @param {Object} [options]
* @param {string} [options.cacheName] Cache name to store and retrieve
* requests. Defaults to the cache names provided by
* {@link workbox-core.cacheNames}.
* @param {Array<Object>} [options.plugins] {@link https://developers.google.com/web/tools/workbox/guides/using-plugins|Plugins}
* to use in conjunction with this caching strategy.
* @param {Object} [options.fetchOptions] Values passed along to the
* {@link https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters|init}
* of all fetch() requests made by this strategy.
* @param {Object} [options.matchOptions] The
* {@link https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions|CacheQueryOptions}
* for any `cache.match()` or `cache.put()` calls made by this strategy.
* @param {boolean} [options.fallbackToNetwork=true] Whether to attempt to
* get the response from the network if there's a precache miss.
*/
constructor(options = {}) {
options.cacheName = cacheNames.getPrecacheName(options.cacheName);
super(options);
this._fallbackToNetwork =
options.fallbackToNetwork === false ? false : true;
// Redirected responses cannot be used to satisfy a navigation request, so
// any redirected response must be "copied" rather than cloned, so the new
// response doesn't contain the `redirected` flag. See:
// https://bugs.chromium.org/p/chromium/issues/detail?id=669363&desc=2#c1
this.plugins.push(PrecacheStrategy.copyRedirectedCacheableResponsesPlugin);
}
/**
* @private
* @param {Request|string} request A request to run this strategy for.
* @param {workbox-strategies.StrategyHandler} handler The event that
* triggered the request.
* @return {Promise<Response>}
*/
async _handle(request, handler) {
const response = await handler.cacheMatch(request);
if (response) {
return response;
}
// If this is an `install` event for an entry that isn't already cached,
// then populate the cache.
if (handler.event && handler.event.type === 'install') {
return await this._handleInstall(request, handler);
}
// Getting here means something went wrong. An entry that should have been
// precached wasn't found in the cache.
return await this._handleFetch(request, handler);
}
async _handleFetch(request, handler) {
let response;
const params = (handler.params || {});
// Fall back to the network if we're configured to do so.
if (this._fallbackToNetwork) {
if (process.env.NODE_ENV !== 'production') {
logger.warn(`The precached response for ` +
`${getFriendlyURL(request.url)} in ${this.cacheName} was not ` +
`found. Falling back to the network.`);
}
const integrityInManifest = params.integrity;
const integrityInRequest = request.integrity;
const noIntegrityConflict = !integrityInRequest || integrityInRequest === integrityInManifest;
// Do not add integrity if the original request is no-cors
// See https://github.com/GoogleChrome/workbox/issues/3096
response = await handler.fetch(new Request(request, {
integrity: request.mode !== 'no-cors'
? integrityInRequest || integrityInManifest
: undefined,
}));
// It's only "safe" to repair the cache if we're using SRI to guarantee
// that the response matches the precache manifest's expectations,
// and there's either a) no integrity property in the incoming request
// or b) there is an integrity, and it matches the precache manifest.
// See https://github.com/GoogleChrome/workbox/issues/2858
// Also if the original request users no-cors we don't use integrity.
// See https://github.com/GoogleChrome/workbox/issues/3096
if (integrityInManifest &&
noIntegrityConflict &&
request.mode !== 'no-cors') {
this._useDefaultCacheabilityPluginIfNeeded();
const wasCached = await handler.cachePut(request, response.clone());
if (process.env.NODE_ENV !== 'production') {
if (wasCached) {
logger.log(`A response for ${getFriendlyURL(request.url)} ` +
`was used to "repair" the precache.`);
}
}
}
}
else {
// This shouldn't normally happen, but there are edge cases:
// https://github.com/GoogleChrome/workbox/issues/1441
throw new WorkboxError('missing-precache-entry', {
cacheName: this.cacheName,
url: request.url,
});
}
if (process.env.NODE_ENV !== 'production') {
const cacheKey = params.cacheKey || (await handler.getCacheKey(request, 'read'));
// Workbox is going to handle the route.
// print the routing details to the console.
logger.groupCollapsed(`Precaching is responding to: ` + getFriendlyURL(request.url));
logger.log(`Serving the precached url: ${getFriendlyURL(cacheKey instanceof Request ? cacheKey.url : cacheKey)}`);
logger.groupCollapsed(`View request details here.`);
logger.log(request);
logger.groupEnd();
logger.groupCollapsed(`View response details here.`);
logger.log(response);
logger.groupEnd();
logger.groupEnd();
}
return response;
}
async _handleInstall(request, handler) {
this._useDefaultCacheabilityPluginIfNeeded();
const response = await handler.fetch(request);
// Make sure we defer cachePut() until after we know the response
// should be cached; see https://github.com/GoogleChrome/workbox/issues/2737
const wasCached = await handler.cachePut(request, response.clone());
if (!wasCached) {
// Throwing here will lead to the `install` handler failing, which
// we want to do if *any* of the responses aren't safe to cache.
throw new WorkboxError('bad-precaching-response', {
url: request.url,
status: response.status,
});
}
return response;
}
/**
* This method is complex, as there a number of things to account for:
*
* The `plugins` array can be set at construction, and/or it might be added to
* to at any time before the strategy is used.
*
* At the time the strategy is used (i.e. during an `install` event), there
* needs to be at least one plugin that implements `cacheWillUpdate` in the
* array, other than `copyRedirectedCacheableResponsesPlugin`.
*
* - If this method is called and there are no suitable `cacheWillUpdate`
* plugins, we need to add `defaultPrecacheCacheabilityPlugin`.
*
* - If this method is called and there is exactly one `cacheWillUpdate`, then
* we don't have to do anything (this might be a previously added
* `defaultPrecacheCacheabilityPlugin`, or it might be a custom plugin).
*
* - If this method is called and there is more than one `cacheWillUpdate`,
* then we need to check if one is `defaultPrecacheCacheabilityPlugin`. If so,
* we need to remove it. (This situation is unlikely, but it could happen if
* the strategy is used multiple times, the first without a `cacheWillUpdate`,
* and then later on after manually adding a custom `cacheWillUpdate`.)
*
* See https://github.com/GoogleChrome/workbox/issues/2737 for more context.
*
* @private
*/
_useDefaultCacheabilityPluginIfNeeded() {
let defaultPluginIndex = null;
let cacheWillUpdatePluginCount = 0;
for (const [index, plugin] of this.plugins.entries()) {
// Ignore the copy redirected plugin when determining what to do.
if (plugin === PrecacheStrategy.copyRedirectedCacheableResponsesPlugin) {
continue;
}
// Save the default plugin's index, in case it needs to be removed.
if (plugin === PrecacheStrategy.defaultPrecacheCacheabilityPlugin) {
defaultPluginIndex = index;
}
if (plugin.cacheWillUpdate) {
cacheWillUpdatePluginCount++;
}
}
if (cacheWillUpdatePluginCount === 0) {
this.plugins.push(PrecacheStrategy.defaultPrecacheCacheabilityPlugin);
}
else if (cacheWillUpdatePluginCount > 1 && defaultPluginIndex !== null) {
// Only remove the default plugin; multiple custom plugins are allowed.
this.plugins.splice(defaultPluginIndex, 1);
}
// Nothing needs to be done if cacheWillUpdatePluginCount is 1
}
}
PrecacheStrategy.defaultPrecacheCacheabilityPlugin = {
async cacheWillUpdate({ response }) {
if (!response || response.status >= 400) {
return null;
}
return response;
},
};
PrecacheStrategy.copyRedirectedCacheableResponsesPlugin = {
async cacheWillUpdate({ response }) {
return response.redirected ? await copyResponse(response) : response;
},
};
export { PrecacheStrategy };

1
frontend/node_modules/workbox-precaching/PrecacheStrategy.mjs generated vendored Normal file
View File

@@ -0,0 +1 @@
export * from './PrecacheStrategy.js';

1
frontend/node_modules/workbox-precaching/README.md generated vendored Normal file
View File

@@ -0,0 +1 @@
This module's documentation can be found at https://developers.google.com/web/tools/workbox/modules/workbox-precaching

63
frontend/node_modules/workbox-precaching/_types.d.ts generated vendored Normal file
View File

@@ -0,0 +1,63 @@
import './_version.js';
export interface InstallResult {
updatedURLs: string[];
notUpdatedURLs: string[];
}
export interface CleanupResult {
deletedCacheRequests: string[];
}
export declare interface PrecacheEntry {
integrity?: string;
url: string;
revision?: string | null;
}
export interface PrecacheRouteOptions {
directoryIndex?: string;
ignoreURLParametersMatching?: RegExp[];
cleanURLs?: boolean;
urlManipulation?: urlManipulation;
}
export type urlManipulation = ({ url }: {
url: URL;
}) => URL[];
/**
* @typedef {Object} InstallResult
* @property {Array<string>} updatedURLs List of URLs that were updated during
* installation.
* @property {Array<string>} notUpdatedURLs List of URLs that were already up to
* date.
*
* @memberof workbox-precaching
*/
/**
* @typedef {Object} CleanupResult
* @property {Array<string>} deletedCacheRequests List of URLs that were deleted
* while cleaning up the cache.
*
* @memberof workbox-precaching
*/
/**
* @typedef {Object} PrecacheEntry
* @property {string} url URL to precache.
* @property {string} [revision] Revision information for the URL.
* @property {string} [integrity] Integrity metadata that will be used when
* making the network request for the URL.
*
* @memberof workbox-precaching
*/
/**
* The "urlManipulation" callback can be used to determine if there are any
* additional permutations of a URL that should be used to check against
* the available precached files.
*
* For example, Workbox supports checking for '/index.html' when the URL
* '/' is provided. This callback allows additional, custom checks.
*
* @callback ~urlManipulation
* @param {Object} context
* @param {URL} context.url The request's URL.
* @return {Array<URL>} To add additional urls to test, return an Array of
* URLs. Please note that these **should not be strings**, but URL objects.
*
* @memberof workbox-precaching
*/

55
frontend/node_modules/workbox-precaching/_types.js generated vendored Normal file
View File

@@ -0,0 +1,55 @@
/*
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.
*/
import './_version.js';
// * * * IMPORTANT! * * *
// ------------------------------------------------------------------------- //
// jdsoc type definitions cannot be declared above TypeScript definitions or
// they'll be stripped from the built `.js` files, and they'll only be in the
// `d.ts` files, which aren't read by the jsdoc generator. As a result we
// have to put declare them below.
/**
* @typedef {Object} InstallResult
* @property {Array<string>} updatedURLs List of URLs that were updated during
* installation.
* @property {Array<string>} notUpdatedURLs List of URLs that were already up to
* date.
*
* @memberof workbox-precaching
*/
/**
* @typedef {Object} CleanupResult
* @property {Array<string>} deletedCacheRequests List of URLs that were deleted
* while cleaning up the cache.
*
* @memberof workbox-precaching
*/
/**
* @typedef {Object} PrecacheEntry
* @property {string} url URL to precache.
* @property {string} [revision] Revision information for the URL.
* @property {string} [integrity] Integrity metadata that will be used when
* making the network request for the URL.
*
* @memberof workbox-precaching
*/
/**
* The "urlManipulation" callback can be used to determine if there are any
* additional permutations of a URL that should be used to check against
* the available precached files.
*
* For example, Workbox supports checking for '/index.html' when the URL
* '/' is provided. This callback allows additional, custom checks.
*
* @callback ~urlManipulation
* @param {Object} context
* @param {URL} context.url The request's URL.
* @return {Array<URL>} To add additional urls to test, return an Array of
* URLs. Please note that these **should not be strings**, but URL objects.
*
* @memberof workbox-precaching
*/

1
frontend/node_modules/workbox-precaching/_types.mjs generated vendored Normal file
View File

@@ -0,0 +1 @@
export * from './_types.js';

0
frontend/node_modules/workbox-precaching/_version.d.ts generated vendored Normal file
View File

6
frontend/node_modules/workbox-precaching/_version.js generated vendored Normal file
View File

@@ -0,0 +1,6 @@
"use strict";
// @ts-ignore
try {
self['workbox:precaching:6.5.4'] && _();
}
catch (e) { }

1
frontend/node_modules/workbox-precaching/_version.mjs generated vendored Normal file
View File

@@ -0,0 +1 @@
try{self['workbox:precaching:6.6.0']&&_()}catch(e){}// eslint-disable-line

11
frontend/node_modules/workbox-precaching/addPlugins.d.ts generated vendored Normal file
View File

@@ -0,0 +1,11 @@
import { WorkboxPlugin } from 'workbox-core/types.js';
import './_version.js';
/**
* Adds plugins to the precaching strategy.
*
* @param {Array<Object>} plugins
*
* @memberof workbox-precaching
*/
declare function addPlugins(plugins: WorkboxPlugin[]): void;
export { addPlugins };

21
frontend/node_modules/workbox-precaching/addPlugins.js generated vendored Normal file
View File

@@ -0,0 +1,21 @@
/*
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 { getOrCreatePrecacheController } from './utils/getOrCreatePrecacheController.js';
import './_version.js';
/**
* Adds plugins to the precaching strategy.
*
* @param {Array<Object>} plugins
*
* @memberof workbox-precaching
*/
function addPlugins(plugins) {
const precacheController = getOrCreatePrecacheController();
precacheController.strategy.plugins.push(...plugins);
}
export { addPlugins };

1
frontend/node_modules/workbox-precaching/addPlugins.mjs generated vendored Normal file
View File

@@ -0,0 +1 @@
export * from './addPlugins.js';

19
frontend/node_modules/workbox-precaching/addRoute.d.ts generated vendored Normal file
View File

@@ -0,0 +1,19 @@
import { PrecacheRouteOptions } from './_types.js';
import './_version.js';
/**
* 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] See the {@link workbox-precaching.PrecacheRoute}
* options.
*
* @memberof workbox-precaching
*/
declare function addRoute(options?: PrecacheRouteOptions): void;
export { addRoute };

31
frontend/node_modules/workbox-precaching/addRoute.js generated vendored Normal file
View File

@@ -0,0 +1,31 @@
/*
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 { registerRoute } from 'workbox-routing/registerRoute.js';
import { getOrCreatePrecacheController } from './utils/getOrCreatePrecacheController.js';
import { PrecacheRoute } from './PrecacheRoute.js';
import './_version.js';
/**
* 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] See the {@link workbox-precaching.PrecacheRoute}
* options.
*
* @memberof workbox-precaching
*/
function addRoute(options) {
const precacheController = getOrCreatePrecacheController();
const precacheRoute = new PrecacheRoute(precacheController, options);
registerRoute(precacheRoute);
}
export { addRoute };

1
frontend/node_modules/workbox-precaching/addRoute.mjs generated vendored Normal file
View File

@@ -0,0 +1 @@
export * from './addRoute.js';

1338
frontend/node_modules/workbox-precaching/build/workbox-precaching.dev.js generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

1
frontend/node_modules/workbox-precaching/build/workbox-precaching.dev.js.map generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

2
frontend/node_modules/workbox-precaching/build/workbox-precaching.prod.js generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

1
frontend/node_modules/workbox-precaching/build/workbox-precaching.prod.js.map generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

9
frontend/node_modules/workbox-precaching/cleanupOutdatedCaches.d.ts generated vendored Normal file
View File

@@ -0,0 +1,9 @@
import './_version.js';
/**
* Adds an `activate` event listener which will clean up incompatible
* precaches that were created by older versions of Workbox.
*
* @memberof workbox-precaching
*/
declare function cleanupOutdatedCaches(): void;
export { cleanupOutdatedCaches };

32
frontend/node_modules/workbox-precaching/cleanupOutdatedCaches.js generated vendored Normal file
View File

@@ -0,0 +1,32 @@
/*
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 { cacheNames } from 'workbox-core/_private/cacheNames.js';
import { logger } from 'workbox-core/_private/logger.js';
import { deleteOutdatedCaches } from './utils/deleteOutdatedCaches.js';
import './_version.js';
/**
* Adds an `activate` event listener which will clean up incompatible
* precaches that were created by older versions of Workbox.
*
* @memberof workbox-precaching
*/
function cleanupOutdatedCaches() {
// See https://github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705
self.addEventListener('activate', ((event) => {
const cacheName = cacheNames.getPrecacheName();
event.waitUntil(deleteOutdatedCaches(cacheName).then((cachesDeleted) => {
if (process.env.NODE_ENV !== 'production') {
if (cachesDeleted.length > 0) {
logger.log(`The following out-of-date precaches were cleaned up ` +
`automatically:`, cachesDeleted);
}
}
}));
}));
}
export { cleanupOutdatedCaches };

1
frontend/node_modules/workbox-precaching/cleanupOutdatedCaches.mjs generated vendored Normal file
View File

@@ -0,0 +1 @@
export * from './cleanupOutdatedCaches.js';

21
frontend/node_modules/workbox-precaching/createHandlerBoundToURL.d.ts generated vendored Normal file
View File

@@ -0,0 +1,21 @@
import { RouteHandlerCallback } from 'workbox-core/types.js';
import './_version.js';
/**
* Helper function that calls
* {@link PrecacheController#createHandlerBoundToURL} on the default
* {@link PrecacheController} instance.
*
* If you are creating your own {@link PrecacheController}, then call the
* {@link PrecacheController#createHandlerBoundToURL} on that instance,
* instead of using this function.
*
* @param {string} url The precached URL which will be used to lookup the
* `Response`.
* @param {boolean} [fallbackToNetwork=true] Whether to attempt to get the
* response from the network if there's a precache miss.
* @return {workbox-routing~handlerCallback}
*
* @memberof workbox-precaching
*/
declare function createHandlerBoundToURL(url: string): RouteHandlerCallback;
export { createHandlerBoundToURL };

31
frontend/node_modules/workbox-precaching/createHandlerBoundToURL.js generated vendored Normal file
View File

@@ -0,0 +1,31 @@
/*
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 { getOrCreatePrecacheController } from './utils/getOrCreatePrecacheController.js';
import './_version.js';
/**
* Helper function that calls
* {@link PrecacheController#createHandlerBoundToURL} on the default
* {@link PrecacheController} instance.
*
* If you are creating your own {@link PrecacheController}, then call the
* {@link PrecacheController#createHandlerBoundToURL} on that instance,
* instead of using this function.
*
* @param {string} url The precached URL which will be used to lookup the
* `Response`.
* @param {boolean} [fallbackToNetwork=true] Whether to attempt to get the
* response from the network if there's a precache miss.
* @return {workbox-routing~handlerCallback}
*
* @memberof workbox-precaching
*/
function createHandlerBoundToURL(url) {
const precacheController = getOrCreatePrecacheController();
return precacheController.createHandlerBoundToURL(url);
}
export { createHandlerBoundToURL };

1
frontend/node_modules/workbox-precaching/createHandlerBoundToURL.mjs generated vendored Normal file
View File

@@ -0,0 +1 @@
export * from './createHandlerBoundToURL.js';

22
frontend/node_modules/workbox-precaching/getCacheKeyForURL.d.ts generated vendored Normal file
View File

@@ -0,0 +1,22 @@
import './_version.js';
/**
* 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.
*
* @memberof workbox-precaching
*/
declare function getCacheKeyForURL(url: string): string | undefined;
export { getCacheKeyForURL };

33
frontend/node_modules/workbox-precaching/getCacheKeyForURL.js generated vendored Normal file
View File

@@ -0,0 +1,33 @@
/*
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 { getOrCreatePrecacheController } from './utils/getOrCreatePrecacheController.js';
import './_version.js';
/**
* 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.
*
* @memberof workbox-precaching
*/
function getCacheKeyForURL(url) {
const precacheController = getOrCreatePrecacheController();
return precacheController.getCacheKeyForURL(url);
}
export { getCacheKeyForURL };

1
frontend/node_modules/workbox-precaching/getCacheKeyForURL.mjs generated vendored Normal file
View File

@@ -0,0 +1 @@
export * from './getCacheKeyForURL.js';

27
frontend/node_modules/workbox-precaching/index.d.ts generated vendored Normal file
View File

@@ -0,0 +1,27 @@
import { addPlugins } from './addPlugins.js';
import { addRoute } from './addRoute.js';
import { cleanupOutdatedCaches } from './cleanupOutdatedCaches.js';
import { createHandlerBoundToURL } from './createHandlerBoundToURL.js';
import { getCacheKeyForURL } from './getCacheKeyForURL.js';
import { matchPrecache } from './matchPrecache.js';
import { precache } from './precache.js';
import { precacheAndRoute } from './precacheAndRoute.js';
import { PrecacheController } from './PrecacheController.js';
import { PrecacheRoute } from './PrecacheRoute.js';
import { PrecacheStrategy } from './PrecacheStrategy.js';
import { PrecacheFallbackPlugin } from './PrecacheFallbackPlugin.js';
import './_version.js';
/**
* Most consumers of this module will want to use the
* {@link workbox-precaching.precacheAndRoute}
* method to add assets to the cache and respond to network requests with these
* cached assets.
*
* If you require more control over caching and routing, you can use the
* {@link workbox-precaching.PrecacheController}
* interface.
*
* @module workbox-precaching
*/
export { addPlugins, addRoute, cleanupOutdatedCaches, createHandlerBoundToURL, getCacheKeyForURL, matchPrecache, precache, precacheAndRoute, PrecacheController, PrecacheRoute, PrecacheStrategy, PrecacheFallbackPlugin, };
export * from './_types.js';

34
frontend/node_modules/workbox-precaching/index.js generated vendored Normal file
View File

@@ -0,0 +1,34 @@
/*
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.
*/
import { addPlugins } from './addPlugins.js';
import { addRoute } from './addRoute.js';
import { cleanupOutdatedCaches } from './cleanupOutdatedCaches.js';
import { createHandlerBoundToURL } from './createHandlerBoundToURL.js';
import { getCacheKeyForURL } from './getCacheKeyForURL.js';
import { matchPrecache } from './matchPrecache.js';
import { precache } from './precache.js';
import { precacheAndRoute } from './precacheAndRoute.js';
import { PrecacheController } from './PrecacheController.js';
import { PrecacheRoute } from './PrecacheRoute.js';
import { PrecacheStrategy } from './PrecacheStrategy.js';
import { PrecacheFallbackPlugin } from './PrecacheFallbackPlugin.js';
import './_version.js';
/**
* Most consumers of this module will want to use the
* {@link workbox-precaching.precacheAndRoute}
* method to add assets to the cache and respond to network requests with these
* cached assets.
*
* If you require more control over caching and routing, you can use the
* {@link workbox-precaching.PrecacheController}
* interface.
*
* @module workbox-precaching
*/
export { addPlugins, addRoute, cleanupOutdatedCaches, createHandlerBoundToURL, getCacheKeyForURL, matchPrecache, precache, precacheAndRoute, PrecacheController, PrecacheRoute, PrecacheStrategy, PrecacheFallbackPlugin, };
export * from './_types.js';

1
frontend/node_modules/workbox-precaching/index.mjs generated vendored Normal file
View File

@@ -0,0 +1 @@
export * from './index.js';

18
frontend/node_modules/workbox-precaching/matchPrecache.d.ts generated vendored Normal file
View File

@@ -0,0 +1,18 @@
import './_version.js';
/**
* Helper function that calls
* {@link PrecacheController#matchPrecache} on the default
* {@link PrecacheController} instance.
*
* If you are creating your own {@link PrecacheController}, then call
* {@link PrecacheController#matchPrecache} on that instance,
* instead of using this function.
*
* @param {string|Request} request The key (without revisioning parameters)
* to look up in the precache.
* @return {Promise<Response|undefined>}
*
* @memberof workbox-precaching
*/
declare function matchPrecache(request: string | Request): Promise<Response | undefined>;
export { matchPrecache };

29
frontend/node_modules/workbox-precaching/matchPrecache.js generated vendored Normal file
View File

@@ -0,0 +1,29 @@
/*
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 { getOrCreatePrecacheController } from './utils/getOrCreatePrecacheController.js';
import './_version.js';
/**
* Helper function that calls
* {@link PrecacheController#matchPrecache} on the default
* {@link PrecacheController} instance.
*
* If you are creating your own {@link PrecacheController}, then call
* {@link PrecacheController#matchPrecache} on that instance,
* instead of using this function.
*
* @param {string|Request} request The key (without revisioning parameters)
* to look up in the precache.
* @return {Promise<Response|undefined>}
*
* @memberof workbox-precaching
*/
function matchPrecache(request) {
const precacheController = getOrCreatePrecacheController();
return precacheController.matchPrecache(request);
}
export { matchPrecache };

1
frontend/node_modules/workbox-precaching/matchPrecache.mjs generated vendored Normal file
View File

@@ -0,0 +1 @@
export * from './matchPrecache.js';

29
frontend/node_modules/workbox-precaching/package.json generated vendored Normal file
View File

@@ -0,0 +1,29 @@
{
"name": "workbox-precaching",
"version": "6.6.0",
"license": "MIT",
"author": "Google's Web DevRel Team",
"description": "This module efficiently precaches assets.",
"repository": "googlechrome/workbox",
"bugs": "https://github.com/googlechrome/workbox/issues",
"homepage": "https://github.com/GoogleChrome/workbox",
"keywords": [
"workbox",
"workboxjs",
"service worker",
"sw"
],
"workbox": {
"browserNamespace": "workbox.precaching",
"packageType": "sw"
},
"main": "index.js",
"module": "index.mjs",
"types": "index.d.ts",
"dependencies": {
"workbox-core": "6.6.0",
"workbox-routing": "6.6.0",
"workbox-strategies": "6.6.0"
},
"gitHead": "252644491d9bb5a67518935ede6df530107c9475"
}

23
frontend/node_modules/workbox-precaching/precache.d.ts generated vendored Normal file
View File

@@ -0,0 +1,23 @@
import { PrecacheEntry } from './_types.js';
import './_version.js';
/**
* 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.
*
* 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
* {@link workbox-precaching.addRoute}.
*
* If you have a single array of files to precache, you can just call
* {@link workbox-precaching.precacheAndRoute}.
*
* @param {Array<Object|string>} [entries=[]] Array of entries to precache.
*
* @memberof workbox-precaching
*/
declare function precache(entries: Array<PrecacheEntry | string>): void;
export { precache };

33
frontend/node_modules/workbox-precaching/precache.js generated vendored Normal file
View File

@@ -0,0 +1,33 @@
/*
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 { getOrCreatePrecacheController } from './utils/getOrCreatePrecacheController.js';
import './_version.js';
/**
* 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.
*
* 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
* {@link workbox-precaching.addRoute}.
*
* If you have a single array of files to precache, you can just call
* {@link workbox-precaching.precacheAndRoute}.
*
* @param {Array<Object|string>} [entries=[]] Array of entries to precache.
*
* @memberof workbox-precaching
*/
function precache(entries) {
const precacheController = getOrCreatePrecacheController();
precacheController.precache(entries);
}
export { precache };

1
frontend/node_modules/workbox-precaching/precache.mjs generated vendored Normal file
View File

@@ -0,0 +1 @@
export * from './precache.js';

18
frontend/node_modules/workbox-precaching/precacheAndRoute.d.ts generated vendored Normal file
View File

@@ -0,0 +1,18 @@
import { PrecacheRouteOptions, PrecacheEntry } from './_types.js';
import './_version.js';
/**
* 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
* {@link workbox-precaching.precache} and
* {@link workbox-precaching.addRoute} in a single call.
*
* @param {Array<Object|string>} entries Array of entries to precache.
* @param {Object} [options] See the
* {@link workbox-precaching.PrecacheRoute} options.
*
* @memberof workbox-precaching
*/
declare function precacheAndRoute(entries: Array<PrecacheEntry | string>, options?: PrecacheRouteOptions): void;
export { precacheAndRoute };

29
frontend/node_modules/workbox-precaching/precacheAndRoute.js generated vendored Normal file
View File

@@ -0,0 +1,29 @@
/*
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 { addRoute } from './addRoute.js';
import { precache } from './precache.js';
import './_version.js';
/**
* 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
* {@link workbox-precaching.precache} and
* {@link workbox-precaching.addRoute} in a single call.
*
* @param {Array<Object|string>} entries Array of entries to precache.
* @param {Object} [options] See the
* {@link workbox-precaching.PrecacheRoute} options.
*
* @memberof workbox-precaching
*/
function precacheAndRoute(entries, options) {
precache(entries);
addRoute(options);
}
export { precacheAndRoute };

1
frontend/node_modules/workbox-precaching/precacheAndRoute.mjs generated vendored Normal file
View File

@@ -0,0 +1 @@
export * from './precacheAndRoute.js';

366
frontend/node_modules/workbox-precaching/src/PrecacheController.ts generated vendored Normal file
View File

@@ -0,0 +1,366 @@
/*
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<PrecacheEntry | string>;
}
}
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<string, string> = new Map();
private readonly _urlsToCacheModes: Map<
string,
| 'reload'
| 'default'
| 'no-store'
| 'no-cache'
| 'force-cache'
| 'only-if-cached'
> = new Map();
private readonly _cacheKeysToIntegrities: Map<string, string> = 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<Object|string>} [entries=[]] Array of entries to precache.
*/
precache(entries: Array<PrecacheEntry | string>): 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<workbox-precaching.PrecacheController.PrecacheEntry|string>} entries
* Array of entries to precache.
*/
addToCacheList(entries: Array<PrecacheEntry | string>): 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<workbox-precaching.InstallResult>}
*/
install(event: ExtendableEvent): Promise<InstallResult> {
// waitUntil returns Promise<any>
// 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<workbox-precaching.CleanupResult>}
*/
activate(event: ExtendableEvent): Promise<CleanupResult> {
// waitUntil returns Promise<any>
// 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<string, string>} A URL to cache key mapping.
*/
getURLsToCacheKeys(): Map<string, string> {
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(): Array<string> {
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<Response|undefined>}
*/
async matchPrecache(
request: string | Request,
): Promise<Response | undefined> {
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};

65
frontend/node_modules/workbox-precaching/src/PrecacheFallbackPlugin.ts generated vendored Normal file
View File

@@ -0,0 +1,65 @@
/*
Copyright 2020 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 {WorkboxPlugin} from 'workbox-core/types.js';
import {getOrCreatePrecacheController} from './utils/getOrCreatePrecacheController.js';
import {PrecacheController} from './PrecacheController.js';
import './_version.js';
/**
* `PrecacheFallbackPlugin` allows you to specify an "offline fallback"
* response to be used when a given strategy is unable to generate a response.
*
* It does this by intercepting the `handlerDidError` plugin callback
* and returning a precached response, taking the expected revision parameter
* into account automatically.
*
* Unless you explicitly pass in a `PrecacheController` instance to the
* constructor, the default instance will be used. Generally speaking, most
* developers will end up using the default.
*
* @memberof workbox-precaching
*/
class PrecacheFallbackPlugin implements WorkboxPlugin {
private readonly _fallbackURL: string;
private readonly _precacheController: PrecacheController;
/**
* Constructs a new PrecacheFallbackPlugin with the associated fallbackURL.
*
* @param {Object} config
* @param {string} config.fallbackURL A precached URL to use as the fallback
* if the associated strategy can't generate a response.
* @param {PrecacheController} [config.precacheController] An optional
* PrecacheController instance. If not provided, the default
* PrecacheController will be used.
*/
constructor({
fallbackURL,
precacheController,
}: {
fallbackURL: string;
precacheController?: PrecacheController;
}) {
this._fallbackURL = fallbackURL;
this._precacheController =
precacheController || getOrCreatePrecacheController();
}
/**
* @return {Promise<Response>} The precache response for the fallback URL.
*
* @private
*/
handlerDidError: WorkboxPlugin['handlerDidError'] = () =>
this._precacheController.matchPrecache(this._fallbackURL);
}
export {PrecacheFallbackPlugin};

77
frontend/node_modules/workbox-precaching/src/PrecacheRoute.ts generated vendored Normal file
View File

@@ -0,0 +1,77 @@
/*
Copyright 2020 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 {logger} from 'workbox-core/_private/logger.js';
import {getFriendlyURL} from 'workbox-core/_private/getFriendlyURL.js';
import {
RouteMatchCallback,
RouteMatchCallbackOptions,
} from 'workbox-core/types.js';
import {Route} from 'workbox-routing/Route.js';
import {PrecacheRouteOptions} from './_types.js';
import {PrecacheController} from './PrecacheController.js';
import {generateURLVariations} from './utils/generateURLVariations.js';
import './_version.js';
/**
* A subclass of {@link workbox-routing.Route} that takes a
* {@link workbox-precaching.PrecacheController}
* instance and uses it to match incoming requests and handle fetching
* responses from the precache.
*
* @memberof workbox-precaching
* @extends workbox-routing.Route
*/
class PrecacheRoute extends Route {
/**
* @param {PrecacheController} precacheController A `PrecacheController`
* instance used to both match requests and respond to fetch events.
* @param {Object} [options] Options to control how requests are matched
* against the list of precached URLs.
* @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_/, /^fbclid$/]] 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 URLs that should be checked for precache matches.
*/
constructor(
precacheController: PrecacheController,
options?: PrecacheRouteOptions,
) {
const match: RouteMatchCallback = ({
request,
}: RouteMatchCallbackOptions) => {
const urlsToCacheKeys = precacheController.getURLsToCacheKeys();
for (const possibleURL of generateURLVariations(request.url, options)) {
const cacheKey = urlsToCacheKeys.get(possibleURL);
if (cacheKey) {
const integrity =
precacheController.getIntegrityForCacheKey(cacheKey);
return {cacheKey, integrity};
}
}
if (process.env.NODE_ENV !== 'production') {
logger.debug(
`Precaching did not find a match for ` + getFriendlyURL(request.url),
);
}
return;
};
super(match, precacheController.strategy);
}
}
export {PrecacheRoute};

287
frontend/node_modules/workbox-precaching/src/PrecacheStrategy.ts generated vendored Normal file
View File

@@ -0,0 +1,287 @@
/*
Copyright 2020 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 {copyResponse} from 'workbox-core/copyResponse.js';
import {cacheNames} from 'workbox-core/_private/cacheNames.js';
import {getFriendlyURL} from 'workbox-core/_private/getFriendlyURL.js';
import {logger} from 'workbox-core/_private/logger.js';
import {WorkboxError} from 'workbox-core/_private/WorkboxError.js';
import {WorkboxPlugin} from 'workbox-core/types.js';
import {Strategy, StrategyOptions} from 'workbox-strategies/Strategy.js';
import {StrategyHandler} from 'workbox-strategies/StrategyHandler.js';
import './_version.js';
interface PrecacheStrategyOptions extends StrategyOptions {
fallbackToNetwork?: boolean;
}
/**
* A {@link workbox-strategies.Strategy} implementation
* specifically designed to work with
* {@link workbox-precaching.PrecacheController}
* to both cache and fetch precached assets.
*
* Note: an instance of this class is created automatically when creating a
* `PrecacheController`; it's generally not necessary to create this yourself.
*
* @extends workbox-strategies.Strategy
* @memberof workbox-precaching
*/
class PrecacheStrategy extends Strategy {
private readonly _fallbackToNetwork: boolean;
static readonly defaultPrecacheCacheabilityPlugin: WorkboxPlugin = {
async cacheWillUpdate({response}) {
if (!response || response.status >= 400) {
return null;
}
return response;
},
};
static readonly copyRedirectedCacheableResponsesPlugin: WorkboxPlugin = {
async cacheWillUpdate({response}) {
return response.redirected ? await copyResponse(response) : response;
},
};
/**
*
* @param {Object} [options]
* @param {string} [options.cacheName] Cache name to store and retrieve
* requests. Defaults to the cache names provided by
* {@link workbox-core.cacheNames}.
* @param {Array<Object>} [options.plugins] {@link https://developers.google.com/web/tools/workbox/guides/using-plugins|Plugins}
* to use in conjunction with this caching strategy.
* @param {Object} [options.fetchOptions] Values passed along to the
* {@link https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch#Parameters|init}
* of all fetch() requests made by this strategy.
* @param {Object} [options.matchOptions] The
* {@link https://w3c.github.io/ServiceWorker/#dictdef-cachequeryoptions|CacheQueryOptions}
* for any `cache.match()` or `cache.put()` calls made by this strategy.
* @param {boolean} [options.fallbackToNetwork=true] Whether to attempt to
* get the response from the network if there's a precache miss.
*/
constructor(options: PrecacheStrategyOptions = {}) {
options.cacheName = cacheNames.getPrecacheName(options.cacheName);
super(options);
this._fallbackToNetwork =
options.fallbackToNetwork === false ? false : true;
// Redirected responses cannot be used to satisfy a navigation request, so
// any redirected response must be "copied" rather than cloned, so the new
// response doesn't contain the `redirected` flag. See:
// https://bugs.chromium.org/p/chromium/issues/detail?id=669363&desc=2#c1
this.plugins.push(PrecacheStrategy.copyRedirectedCacheableResponsesPlugin);
}
/**
* @private
* @param {Request|string} request A request to run this strategy for.
* @param {workbox-strategies.StrategyHandler} handler The event that
* triggered the request.
* @return {Promise<Response>}
*/
async _handle(request: Request, handler: StrategyHandler): Promise<Response> {
const response = await handler.cacheMatch(request);
if (response) {
return response;
}
// If this is an `install` event for an entry that isn't already cached,
// then populate the cache.
if (handler.event && handler.event.type === 'install') {
return await this._handleInstall(request, handler);
}
// Getting here means something went wrong. An entry that should have been
// precached wasn't found in the cache.
return await this._handleFetch(request, handler);
}
async _handleFetch(
request: Request,
handler: StrategyHandler,
): Promise<Response> {
let response;
const params = (handler.params || {}) as {
cacheKey?: string;
integrity?: string;
};
// Fall back to the network if we're configured to do so.
if (this._fallbackToNetwork) {
if (process.env.NODE_ENV !== 'production') {
logger.warn(
`The precached response for ` +
`${getFriendlyURL(request.url)} in ${this.cacheName} was not ` +
`found. Falling back to the network.`,
);
}
const integrityInManifest = params.integrity;
const integrityInRequest = request.integrity;
const noIntegrityConflict =
!integrityInRequest || integrityInRequest === integrityInManifest;
// Do not add integrity if the original request is no-cors
// See https://github.com/GoogleChrome/workbox/issues/3096
response = await handler.fetch(
new Request(request, {
integrity:
request.mode !== 'no-cors'
? integrityInRequest || integrityInManifest
: undefined,
}),
);
// It's only "safe" to repair the cache if we're using SRI to guarantee
// that the response matches the precache manifest's expectations,
// and there's either a) no integrity property in the incoming request
// or b) there is an integrity, and it matches the precache manifest.
// See https://github.com/GoogleChrome/workbox/issues/2858
// Also if the original request users no-cors we don't use integrity.
// See https://github.com/GoogleChrome/workbox/issues/3096
if (
integrityInManifest &&
noIntegrityConflict &&
request.mode !== 'no-cors'
) {
this._useDefaultCacheabilityPluginIfNeeded();
const wasCached = await handler.cachePut(request, response.clone());
if (process.env.NODE_ENV !== 'production') {
if (wasCached) {
logger.log(
`A response for ${getFriendlyURL(request.url)} ` +
`was used to "repair" the precache.`,
);
}
}
}
} else {
// This shouldn't normally happen, but there are edge cases:
// https://github.com/GoogleChrome/workbox/issues/1441
throw new WorkboxError('missing-precache-entry', {
cacheName: this.cacheName,
url: request.url,
});
}
if (process.env.NODE_ENV !== 'production') {
const cacheKey =
params.cacheKey || (await handler.getCacheKey(request, 'read'));
// Workbox is going to handle the route.
// print the routing details to the console.
logger.groupCollapsed(
`Precaching is responding to: ` + getFriendlyURL(request.url),
);
logger.log(
`Serving the precached url: ${getFriendlyURL(
cacheKey instanceof Request ? cacheKey.url : cacheKey,
)}`,
);
logger.groupCollapsed(`View request details here.`);
logger.log(request);
logger.groupEnd();
logger.groupCollapsed(`View response details here.`);
logger.log(response);
logger.groupEnd();
logger.groupEnd();
}
return response;
}
async _handleInstall(
request: Request,
handler: StrategyHandler,
): Promise<Response> {
this._useDefaultCacheabilityPluginIfNeeded();
const response = await handler.fetch(request);
// Make sure we defer cachePut() until after we know the response
// should be cached; see https://github.com/GoogleChrome/workbox/issues/2737
const wasCached = await handler.cachePut(request, response.clone());
if (!wasCached) {
// Throwing here will lead to the `install` handler failing, which
// we want to do if *any* of the responses aren't safe to cache.
throw new WorkboxError('bad-precaching-response', {
url: request.url,
status: response.status,
});
}
return response;
}
/**
* This method is complex, as there a number of things to account for:
*
* The `plugins` array can be set at construction, and/or it might be added to
* to at any time before the strategy is used.
*
* At the time the strategy is used (i.e. during an `install` event), there
* needs to be at least one plugin that implements `cacheWillUpdate` in the
* array, other than `copyRedirectedCacheableResponsesPlugin`.
*
* - If this method is called and there are no suitable `cacheWillUpdate`
* plugins, we need to add `defaultPrecacheCacheabilityPlugin`.
*
* - If this method is called and there is exactly one `cacheWillUpdate`, then
* we don't have to do anything (this might be a previously added
* `defaultPrecacheCacheabilityPlugin`, or it might be a custom plugin).
*
* - If this method is called and there is more than one `cacheWillUpdate`,
* then we need to check if one is `defaultPrecacheCacheabilityPlugin`. If so,
* we need to remove it. (This situation is unlikely, but it could happen if
* the strategy is used multiple times, the first without a `cacheWillUpdate`,
* and then later on after manually adding a custom `cacheWillUpdate`.)
*
* See https://github.com/GoogleChrome/workbox/issues/2737 for more context.
*
* @private
*/
_useDefaultCacheabilityPluginIfNeeded(): void {
let defaultPluginIndex: number | null = null;
let cacheWillUpdatePluginCount = 0;
for (const [index, plugin] of this.plugins.entries()) {
// Ignore the copy redirected plugin when determining what to do.
if (plugin === PrecacheStrategy.copyRedirectedCacheableResponsesPlugin) {
continue;
}
// Save the default plugin's index, in case it needs to be removed.
if (plugin === PrecacheStrategy.defaultPrecacheCacheabilityPlugin) {
defaultPluginIndex = index;
}
if (plugin.cacheWillUpdate) {
cacheWillUpdatePluginCount++;
}
}
if (cacheWillUpdatePluginCount === 0) {
this.plugins.push(PrecacheStrategy.defaultPrecacheCacheabilityPlugin);
} else if (cacheWillUpdatePluginCount > 1 && defaultPluginIndex !== null) {
// Only remove the default plugin; multiple custom plugins are allowed.
this.plugins.splice(defaultPluginIndex, 1);
}
// Nothing needs to be done if cacheWillUpdatePluginCount is 1
}
}
export {PrecacheStrategy};

85
frontend/node_modules/workbox-precaching/src/_types.ts generated vendored Normal file
View File

@@ -0,0 +1,85 @@
/*
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.
*/
import './_version.js';
export interface InstallResult {
updatedURLs: string[];
notUpdatedURLs: string[];
}
export interface CleanupResult {
deletedCacheRequests: string[];
}
export declare interface PrecacheEntry {
integrity?: string;
url: string;
revision?: string | null;
}
export interface PrecacheRouteOptions {
directoryIndex?: string;
ignoreURLParametersMatching?: RegExp[];
cleanURLs?: boolean;
urlManipulation?: urlManipulation;
}
export type urlManipulation = ({url}: {url: URL}) => URL[];
// * * * IMPORTANT! * * *
// ------------------------------------------------------------------------- //
// jdsoc type definitions cannot be declared above TypeScript definitions or
// they'll be stripped from the built `.js` files, and they'll only be in the
// `d.ts` files, which aren't read by the jsdoc generator. As a result we
// have to put declare them below.
/**
* @typedef {Object} InstallResult
* @property {Array<string>} updatedURLs List of URLs that were updated during
* installation.
* @property {Array<string>} notUpdatedURLs List of URLs that were already up to
* date.
*
* @memberof workbox-precaching
*/
/**
* @typedef {Object} CleanupResult
* @property {Array<string>} deletedCacheRequests List of URLs that were deleted
* while cleaning up the cache.
*
* @memberof workbox-precaching
*/
/**
* @typedef {Object} PrecacheEntry
* @property {string} url URL to precache.
* @property {string} [revision] Revision information for the URL.
* @property {string} [integrity] Integrity metadata that will be used when
* making the network request for the URL.
*
* @memberof workbox-precaching
*/
/**
* The "urlManipulation" callback can be used to determine if there are any
* additional permutations of a URL that should be used to check against
* the available precached files.
*
* For example, Workbox supports checking for '/index.html' when the URL
* '/' is provided. This callback allows additional, custom checks.
*
* @callback ~urlManipulation
* @param {Object} context
* @param {URL} context.url The request's URL.
* @return {Array<URL>} To add additional urls to test, return an Array of
* URLs. Please note that these **should not be strings**, but URL objects.
*
* @memberof workbox-precaching
*/

2
frontend/node_modules/workbox-precaching/src/_version.ts generated vendored Normal file
View File

@@ -0,0 +1,2 @@
// @ts-ignore
try{self['workbox:precaching:6.6.0']&&_()}catch(e){}

25
frontend/node_modules/workbox-precaching/src/addPlugins.ts generated vendored Normal file
View File

@@ -0,0 +1,25 @@
/*
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 {WorkboxPlugin} from 'workbox-core/types.js';
import {getOrCreatePrecacheController} from './utils/getOrCreatePrecacheController.js';
import './_version.js';
/**
* Adds plugins to the precaching strategy.
*
* @param {Array<Object>} plugins
*
* @memberof workbox-precaching
*/
function addPlugins(plugins: WorkboxPlugin[]): void {
const precacheController = getOrCreatePrecacheController();
precacheController.strategy.plugins.push(...plugins);
}
export {addPlugins};

38
frontend/node_modules/workbox-precaching/src/addRoute.ts generated vendored Normal file
View File

@@ -0,0 +1,38 @@
/*
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 {registerRoute} from 'workbox-routing/registerRoute.js';
import {getOrCreatePrecacheController} from './utils/getOrCreatePrecacheController.js';
import {PrecacheRoute} from './PrecacheRoute.js';
import {PrecacheRouteOptions} from './_types.js';
import './_version.js';
/**
* 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] See the {@link workbox-precaching.PrecacheRoute}
* options.
*
* @memberof workbox-precaching
*/
function addRoute(options?: PrecacheRouteOptions): void {
const precacheController = getOrCreatePrecacheController();
const precacheRoute = new PrecacheRoute(precacheController, options);
registerRoute(precacheRoute);
}
export {addRoute};

41
frontend/node_modules/workbox-precaching/src/cleanupOutdatedCaches.ts generated vendored Normal file
View File

@@ -0,0 +1,41 @@
/*
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 {cacheNames} from 'workbox-core/_private/cacheNames.js';
import {logger} from 'workbox-core/_private/logger.js';
import {deleteOutdatedCaches} from './utils/deleteOutdatedCaches.js';
import './_version.js';
/**
* Adds an `activate` event listener which will clean up incompatible
* precaches that were created by older versions of Workbox.
*
* @memberof workbox-precaching
*/
function cleanupOutdatedCaches(): void {
// See https://github.com/Microsoft/TypeScript/issues/28357#issuecomment-436484705
self.addEventListener('activate', ((event: ExtendableEvent) => {
const cacheName = cacheNames.getPrecacheName();
event.waitUntil(
deleteOutdatedCaches(cacheName).then((cachesDeleted) => {
if (process.env.NODE_ENV !== 'production') {
if (cachesDeleted.length > 0) {
logger.log(
`The following out-of-date precaches were cleaned up ` +
`automatically:`,
cachesDeleted,
);
}
}
}),
);
}) as EventListener);
}
export {cleanupOutdatedCaches};

35
frontend/node_modules/workbox-precaching/src/createHandlerBoundToURL.ts generated vendored Normal file
View File

@@ -0,0 +1,35 @@
/*
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 {getOrCreatePrecacheController} from './utils/getOrCreatePrecacheController.js';
import {RouteHandlerCallback} from 'workbox-core/types.js';
import './_version.js';
/**
* Helper function that calls
* {@link PrecacheController#createHandlerBoundToURL} on the default
* {@link PrecacheController} instance.
*
* If you are creating your own {@link PrecacheController}, then call the
* {@link PrecacheController#createHandlerBoundToURL} on that instance,
* instead of using this function.
*
* @param {string} url The precached URL which will be used to lookup the
* `Response`.
* @param {boolean} [fallbackToNetwork=true] Whether to attempt to get the
* response from the network if there's a precache miss.
* @return {workbox-routing~handlerCallback}
*
* @memberof workbox-precaching
*/
function createHandlerBoundToURL(url: string): RouteHandlerCallback {
const precacheController = getOrCreatePrecacheController();
return precacheController.createHandlerBoundToURL(url);
}
export {createHandlerBoundToURL};

36
frontend/node_modules/workbox-precaching/src/getCacheKeyForURL.ts generated vendored Normal file
View File

@@ -0,0 +1,36 @@
/*
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 {getOrCreatePrecacheController} from './utils/getOrCreatePrecacheController.js';
import './_version.js';
/**
* 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.
*
* @memberof workbox-precaching
*/
function getCacheKeyForURL(url: string): string | undefined {
const precacheController = getOrCreatePrecacheController();
return precacheController.getCacheKeyForURL(url);
}
export {getCacheKeyForURL};

52
frontend/node_modules/workbox-precaching/src/index.ts generated vendored Normal file
View File

@@ -0,0 +1,52 @@
/*
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.
*/
import {addPlugins} from './addPlugins.js';
import {addRoute} from './addRoute.js';
import {cleanupOutdatedCaches} from './cleanupOutdatedCaches.js';
import {createHandlerBoundToURL} from './createHandlerBoundToURL.js';
import {getCacheKeyForURL} from './getCacheKeyForURL.js';
import {matchPrecache} from './matchPrecache.js';
import {precache} from './precache.js';
import {precacheAndRoute} from './precacheAndRoute.js';
import {PrecacheController} from './PrecacheController.js';
import {PrecacheRoute} from './PrecacheRoute.js';
import {PrecacheStrategy} from './PrecacheStrategy.js';
import {PrecacheFallbackPlugin} from './PrecacheFallbackPlugin.js';
import './_version.js';
/**
* Most consumers of this module will want to use the
* {@link workbox-precaching.precacheAndRoute}
* method to add assets to the cache and respond to network requests with these
* cached assets.
*
* If you require more control over caching and routing, you can use the
* {@link workbox-precaching.PrecacheController}
* interface.
*
* @module workbox-precaching
*/
export {
addPlugins,
addRoute,
cleanupOutdatedCaches,
createHandlerBoundToURL,
getCacheKeyForURL,
matchPrecache,
precache,
precacheAndRoute,
PrecacheController,
PrecacheRoute,
PrecacheStrategy,
PrecacheFallbackPlugin,
};
export * from './_types.js';

35
frontend/node_modules/workbox-precaching/src/matchPrecache.ts generated vendored Normal file
View File

@@ -0,0 +1,35 @@
/*
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 {getOrCreatePrecacheController} from './utils/getOrCreatePrecacheController.js';
import './_version.js';
/**
* Helper function that calls
* {@link PrecacheController#matchPrecache} on the default
* {@link PrecacheController} instance.
*
* If you are creating your own {@link PrecacheController}, then call
* {@link PrecacheController#matchPrecache} on that instance,
* instead of using this function.
*
* @param {string|Request} request The key (without revisioning parameters)
* to look up in the precache.
* @return {Promise<Response|undefined>}
*
* @memberof workbox-precaching
*/
function matchPrecache(
request: string | Request,
): Promise<Response | undefined> {
const precacheController = getOrCreatePrecacheController();
return precacheController.matchPrecache(request);
}
export {matchPrecache};

37
frontend/node_modules/workbox-precaching/src/precache.ts generated vendored Normal file
View File

@@ -0,0 +1,37 @@
/*
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 {getOrCreatePrecacheController} from './utils/getOrCreatePrecacheController.js';
import {PrecacheEntry} from './_types.js';
import './_version.js';
/**
* 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.
*
* 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
* {@link workbox-precaching.addRoute}.
*
* If you have a single array of files to precache, you can just call
* {@link workbox-precaching.precacheAndRoute}.
*
* @param {Array<Object|string>} [entries=[]] Array of entries to precache.
*
* @memberof workbox-precaching
*/
function precache(entries: Array<PrecacheEntry | string>): void {
const precacheController = getOrCreatePrecacheController();
precacheController.precache(entries);
}
export {precache};

36
frontend/node_modules/workbox-precaching/src/precacheAndRoute.ts generated vendored Normal file
View File

@@ -0,0 +1,36 @@
/*
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 {addRoute} from './addRoute.js';
import {precache} from './precache.js';
import {PrecacheRouteOptions, PrecacheEntry} from './_types.js';
import './_version.js';
/**
* 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
* {@link workbox-precaching.precache} and
* {@link workbox-precaching.addRoute} in a single call.
*
* @param {Array<Object|string>} entries Array of entries to precache.
* @param {Object} [options] See the
* {@link workbox-precaching.PrecacheRoute} options.
*
* @memberof workbox-precaching
*/
function precacheAndRoute(
entries: Array<PrecacheEntry | string>,
options?: PrecacheRouteOptions,
): void {
precache(entries);
addRoute(options);
}
export {precacheAndRoute};

45
frontend/node_modules/workbox-precaching/src/utils/PrecacheCacheKeyPlugin.ts generated vendored Normal file
View File

@@ -0,0 +1,45 @@
/*
Copyright 2020 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 {WorkboxPlugin, WorkboxPluginCallbackParam} from 'workbox-core/types.js';
import {PrecacheController} from '../PrecacheController.js';
import '../_version.js';
/**
* A plugin, designed to be used with PrecacheController, to translate URLs into
* the corresponding cache key, based on the current revision info.
*
* @private
*/
class PrecacheCacheKeyPlugin implements WorkboxPlugin {
private readonly _precacheController: PrecacheController;
constructor({precacheController}: {precacheController: PrecacheController}) {
this._precacheController = precacheController;
}
cacheKeyWillBeUsed: WorkboxPlugin['cacheKeyWillBeUsed'] = async ({
request,
params,
}: WorkboxPluginCallbackParam['cacheKeyWillBeUsed']) => {
// Params is type any, can't change right now.
/* eslint-disable */
const cacheKey =
params?.cacheKey ||
this._precacheController.getCacheKeyForURL(request.url);
/* eslint-enable */
return cacheKey
? new Request(cacheKey, {headers: request.headers})
: request;
};
}
export {PrecacheCacheKeyPlugin};

58
frontend/node_modules/workbox-precaching/src/utils/PrecacheInstallReportPlugin.ts generated vendored Normal file
View File

@@ -0,0 +1,58 @@
/*
Copyright 2020 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 {WorkboxPlugin, WorkboxPluginCallbackParam} from 'workbox-core/types.js';
import '../_version.js';
/**
* A plugin, designed to be used with PrecacheController, to determine the
* of assets that were updated (or not updated) during the install event.
*
* @private
*/
class PrecacheInstallReportPlugin implements WorkboxPlugin {
updatedURLs: string[] = [];
notUpdatedURLs: string[] = [];
handlerWillStart: WorkboxPlugin['handlerWillStart'] = async ({
request,
state,
}: WorkboxPluginCallbackParam['handlerWillStart']) => {
// TODO: `state` should never be undefined...
if (state) {
state.originalRequest = request;
}
};
cachedResponseWillBeUsed: WorkboxPlugin['cachedResponseWillBeUsed'] = async ({
event,
state,
cachedResponse,
}: WorkboxPluginCallbackParam['cachedResponseWillBeUsed']) => {
if (event.type === 'install') {
if (
state &&
state.originalRequest &&
state.originalRequest instanceof Request
) {
// TODO: `state` should never be undefined...
const url = state.originalRequest.url;
if (cachedResponse) {
this.notUpdatedURLs.push(url);
} else {
this.updatedURLs.push(url);
}
}
}
return cachedResponse;
};
}
export {PrecacheInstallReportPlugin};

69
frontend/node_modules/workbox-precaching/src/utils/createCacheKey.ts generated vendored Normal file
View File

@@ -0,0 +1,69 @@
/*
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.
*/
import {WorkboxError} from 'workbox-core/_private/WorkboxError.js';
import {PrecacheEntry} from '../_types.js';
import '../_version.js';
interface CacheKey {
cacheKey: string;
url: string;
}
// Name of the search parameter used to store revision info.
const REVISION_SEARCH_PARAM = '__WB_REVISION__';
/**
* Converts a manifest entry into a versioned URL suitable for precaching.
*
* @param {Object|string} entry
* @return {string} A URL with versioning info.
*
* @private
* @memberof workbox-precaching
*/
export function createCacheKey(entry: PrecacheEntry | string): CacheKey {
if (!entry) {
throw new 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.href);
return {
cacheKey: urlObject.href,
url: urlObject.href,
};
}
const {revision, url} = entry;
if (!url) {
throw new 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.href);
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 cacheKeyURL = new URL(url, location.href);
const originalURL = new URL(url, location.href);
cacheKeyURL.searchParams.set(REVISION_SEARCH_PARAM, revision);
return {
cacheKey: cacheKeyURL.href,
url: originalURL.href,
};
}

55
frontend/node_modules/workbox-precaching/src/utils/deleteOutdatedCaches.ts generated vendored Normal file
View File

@@ -0,0 +1,55 @@
/*
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.
*/
import '../_version.js';
// Give TypeScript the correct global.
declare let self: ServiceWorkerGlobalScope;
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 workbox-precaching
*/
const deleteOutdatedCaches = async (
currentPrecacheName: string,
substringToFind: string = SUBSTRING_TO_FIND,
): Promise<string[]> => {
const cacheNames = await self.caches.keys();
const cacheNamesToDelete = cacheNames.filter((cacheName) => {
return (
cacheName.includes(substringToFind) &&
cacheName.includes(self.registration.scope) &&
cacheName !== currentPrecacheName
);
});
await Promise.all(
cacheNamesToDelete.map((cacheName) => self.caches.delete(cacheName)),
);
return cacheNamesToDelete;
};
export {deleteOutdatedCaches};

60
frontend/node_modules/workbox-precaching/src/utils/generateURLVariations.ts generated vendored Normal file
View File

@@ -0,0 +1,60 @@
/*
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 {removeIgnoredSearchParams} from './removeIgnoredSearchParams.js';
import {PrecacheRouteOptions} from '../_types.js';
import '../_version.js';
/**
* Generator function that yields possible variations on the original URL to
* check, one at a time.
*
* @param {string} url
* @param {Object} options
*
* @private
* @memberof workbox-precaching
*/
export function* generateURLVariations(
url: string,
{
ignoreURLParametersMatching = [/^utm_/, /^fbclid$/],
directoryIndex = 'index.html',
cleanURLs = true,
urlManipulation,
}: PrecacheRouteOptions = {},
): Generator<string, void, unknown> {
const urlObject = new URL(url, location.href);
urlObject.hash = '';
yield urlObject.href;
const urlWithoutIgnoredParams = removeIgnoredSearchParams(
urlObject,
ignoreURLParametersMatching,
);
yield urlWithoutIgnoredParams.href;
if (directoryIndex && urlWithoutIgnoredParams.pathname.endsWith('/')) {
const directoryURL = new URL(urlWithoutIgnoredParams.href);
directoryURL.pathname += directoryIndex;
yield directoryURL.href;
}
if (cleanURLs) {
const cleanURL = new URL(urlWithoutIgnoredParams.href);
cleanURL.pathname += '.html';
yield cleanURL.href;
}
if (urlManipulation) {
const additionalURLs = urlManipulation({url: urlObject});
for (const urlToAttempt of additionalURLs) {
yield urlToAttempt.href;
}
}
}

38
frontend/node_modules/workbox-precaching/src/utils/getCacheKeyForURL.ts generated vendored Normal file
View File

@@ -0,0 +1,38 @@
/*
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 {getOrCreatePrecacheController} from './getOrCreatePrecacheController.js';
import {generateURLVariations} from './generateURLVariations.js';
import {PrecacheRouteOptions} from '../_types.js';
import '../_version.js';
/**
* 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
*/
export const getCacheKeyForURL = (
url: string,
options: PrecacheRouteOptions,
): string | void => {
const precacheController = getOrCreatePrecacheController();
const urlsToCacheKeys = precacheController.getURLsToCacheKeys();
for (const possibleURL of generateURLVariations(url, options)) {
const possibleCacheKey = urlsToCacheKeys.get(possibleURL);
if (possibleCacheKey) {
return possibleCacheKey;
}
}
};

23
frontend/node_modules/workbox-precaching/src/utils/getOrCreatePrecacheController.ts generated vendored Normal file
View File

@@ -0,0 +1,23 @@
/*
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 {PrecacheController} from '../PrecacheController.js';
import '../_version.js';
let precacheController: PrecacheController | undefined;
/**
* @return {PrecacheController}
* @private
*/
export const getOrCreatePrecacheController = (): PrecacheController => {
if (!precacheController) {
precacheController = new PrecacheController();
}
return precacheController;
};

45
frontend/node_modules/workbox-precaching/src/utils/printCleanupDetails.ts generated vendored Normal file
View File

@@ -0,0 +1,45 @@
/*
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.
*/
import {logger} from 'workbox-core/_private/logger.js';
import '../_version.js';
/**
* @param {string} groupTitle
* @param {Array<string>} deletedURLs
*
* @private
*/
const logGroup = (groupTitle: string, deletedURLs: string[]) => {
logger.groupCollapsed(groupTitle);
for (const url of deletedURLs) {
logger.log(url);
}
logger.groupEnd();
};
/**
* @param {Array<string>} deletedURLs
*
* @private
* @memberof workbox-precaching
*/
export function printCleanupDetails(deletedURLs: string[]): void {
const deletionCount = deletedURLs.length;
if (deletionCount > 0) {
logger.groupCollapsed(
`During precaching cleanup, ` +
`${deletionCount} cached ` +
`request${deletionCount === 1 ? ' was' : 's were'} deleted.`,
);
logGroup('Deleted Cache Requests', deletedURLs);
logger.groupEnd();
}
}

63
frontend/node_modules/workbox-precaching/src/utils/printInstallDetails.ts generated vendored Normal file
View File

@@ -0,0 +1,63 @@
/*
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.
*/
import {logger} from 'workbox-core/_private/logger.js';
import '../_version.js';
/**
* @param {string} groupTitle
* @param {Array<string>} urls
*
* @private
*/
function _nestedGroup(groupTitle: string, urls: string[]): void {
if (urls.length === 0) {
return;
}
logger.groupCollapsed(groupTitle);
for (const url of urls) {
logger.log(url);
}
logger.groupEnd();
}
/**
* @param {Array<string>} urlsToPrecache
* @param {Array<string>} urlsAlreadyPrecached
*
* @private
* @memberof workbox-precaching
*/
export function printInstallDetails(
urlsToPrecache: string[],
urlsAlreadyPrecached: string[],
): void {
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.groupCollapsed(message);
_nestedGroup(`View newly precached URLs.`, urlsToPrecache);
_nestedGroup(`View previously precached URLs.`, urlsAlreadyPrecached);
logger.groupEnd();
}
}

36
frontend/node_modules/workbox-precaching/src/utils/removeIgnoredSearchParams.ts generated vendored Normal file
View File

@@ -0,0 +1,36 @@
/*
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.
*/
import '../_version.js';
/**
* 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 workbox-precaching
*/
export function removeIgnoredSearchParams(
urlObject: URL,
ignoreURLParametersMatching: RegExp[] = [],
): URL {
// 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;
}

14
frontend/node_modules/workbox-precaching/tsconfig.json generated vendored Normal file
View File

@@ -0,0 +1,14 @@
{
"extends": "../../tsconfig",
"compilerOptions": {
"outDir": "./",
"rootDir": "./src",
"tsBuildInfoFile": "./tsconfig.tsbuildinfo"
},
"include": ["src/**/*.ts"],
"references": [
{"path": "../workbox-core/"},
{"path": "../workbox-routing/"},
{"path": "../workbox-strategies/"}
]
}

1
frontend/node_modules/workbox-precaching/tsconfig.tsbuildinfo generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

17
frontend/node_modules/workbox-precaching/utils/PrecacheCacheKeyPlugin.d.ts generated vendored Normal file
View File

@@ -0,0 +1,17 @@
import { WorkboxPlugin } from 'workbox-core/types.js';
import { PrecacheController } from '../PrecacheController.js';
import '../_version.js';
/**
* A plugin, designed to be used with PrecacheController, to translate URLs into
* the corresponding cache key, based on the current revision info.
*
* @private
*/
declare class PrecacheCacheKeyPlugin implements WorkboxPlugin {
private readonly _precacheController;
constructor({ precacheController }: {
precacheController: PrecacheController;
});
cacheKeyWillBeUsed: WorkboxPlugin['cacheKeyWillBeUsed'];
}
export { PrecacheCacheKeyPlugin };

30
frontend/node_modules/workbox-precaching/utils/PrecacheCacheKeyPlugin.js generated vendored Normal file
View File

@@ -0,0 +1,30 @@
/*
Copyright 2020 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 '../_version.js';
/**
* A plugin, designed to be used with PrecacheController, to translate URLs into
* the corresponding cache key, based on the current revision info.
*
* @private
*/
class PrecacheCacheKeyPlugin {
constructor({ precacheController }) {
this.cacheKeyWillBeUsed = async ({ request, params, }) => {
// Params is type any, can't change right now.
/* eslint-disable */
const cacheKey = (params === null || params === void 0 ? void 0 : params.cacheKey) ||
this._precacheController.getCacheKeyForURL(request.url);
/* eslint-enable */
return cacheKey
? new Request(cacheKey, { headers: request.headers })
: request;
};
this._precacheController = precacheController;
}
}
export { PrecacheCacheKeyPlugin };

1
frontend/node_modules/workbox-precaching/utils/PrecacheCacheKeyPlugin.mjs generated vendored Normal file
View File

@@ -0,0 +1 @@
export * from './PrecacheCacheKeyPlugin.js';

15
frontend/node_modules/workbox-precaching/utils/PrecacheInstallReportPlugin.d.ts generated vendored Normal file
View File

@@ -0,0 +1,15 @@
import { WorkboxPlugin } from 'workbox-core/types.js';
import '../_version.js';
/**
* A plugin, designed to be used with PrecacheController, to determine the
* of assets that were updated (or not updated) during the install event.
*
* @private
*/
declare class PrecacheInstallReportPlugin implements WorkboxPlugin {
updatedURLs: string[];
notUpdatedURLs: string[];
handlerWillStart: WorkboxPlugin['handlerWillStart'];
cachedResponseWillBeUsed: WorkboxPlugin['cachedResponseWillBeUsed'];
}
export { PrecacheInstallReportPlugin };

44
frontend/node_modules/workbox-precaching/utils/PrecacheInstallReportPlugin.js generated vendored Normal file
View File

@@ -0,0 +1,44 @@
/*
Copyright 2020 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 '../_version.js';
/**
* A plugin, designed to be used with PrecacheController, to determine the
* of assets that were updated (or not updated) during the install event.
*
* @private
*/
class PrecacheInstallReportPlugin {
constructor() {
this.updatedURLs = [];
this.notUpdatedURLs = [];
this.handlerWillStart = async ({ request, state, }) => {
// TODO: `state` should never be undefined...
if (state) {
state.originalRequest = request;
}
};
this.cachedResponseWillBeUsed = async ({ event, state, cachedResponse, }) => {
if (event.type === 'install') {
if (state &&
state.originalRequest &&
state.originalRequest instanceof Request) {
// TODO: `state` should never be undefined...
const url = state.originalRequest.url;
if (cachedResponse) {
this.notUpdatedURLs.push(url);
}
else {
this.updatedURLs.push(url);
}
}
}
return cachedResponse;
};
}
}
export { PrecacheInstallReportPlugin };

1
frontend/node_modules/workbox-precaching/utils/PrecacheInstallReportPlugin.mjs generated vendored Normal file
View File

@@ -0,0 +1 @@
export * from './PrecacheInstallReportPlugin.js';

17
frontend/node_modules/workbox-precaching/utils/createCacheKey.d.ts generated vendored Normal file
View File

@@ -0,0 +1,17 @@
import { PrecacheEntry } from '../_types.js';
import '../_version.js';
interface CacheKey {
cacheKey: string;
url: string;
}
/**
* Converts a manifest entry into a versioned URL suitable for precaching.
*
* @param {Object|string} entry
* @return {string} A URL with versioning info.
*
* @private
* @memberof workbox-precaching
*/
export declare function createCacheKey(entry: PrecacheEntry | string): CacheKey;
export {};

56
frontend/node_modules/workbox-precaching/utils/createCacheKey.js generated vendored Normal file
View File

@@ -0,0 +1,56 @@
/*
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.
*/
import { WorkboxError } from 'workbox-core/_private/WorkboxError.js';
import '../_version.js';
// Name of the search parameter used to store revision info.
const REVISION_SEARCH_PARAM = '__WB_REVISION__';
/**
* Converts a manifest entry into a versioned URL suitable for precaching.
*
* @param {Object|string} entry
* @return {string} A URL with versioning info.
*
* @private
* @memberof workbox-precaching
*/
export function createCacheKey(entry) {
if (!entry) {
throw new 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.href);
return {
cacheKey: urlObject.href,
url: urlObject.href,
};
}
const { revision, url } = entry;
if (!url) {
throw new 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.href);
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 cacheKeyURL = new URL(url, location.href);
const originalURL = new URL(url, location.href);
cacheKeyURL.searchParams.set(REVISION_SEARCH_PARAM, revision);
return {
cacheKey: cacheKeyURL.href,
url: originalURL.href,
};
}

1
frontend/node_modules/workbox-precaching/utils/createCacheKey.mjs generated vendored Normal file
View File

@@ -0,0 +1 @@
export * from './createCacheKey.js';

21
frontend/node_modules/workbox-precaching/utils/deleteOutdatedCaches.d.ts generated vendored Normal file
View File

@@ -0,0 +1,21 @@
import '../_version.js';
/**
* 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 workbox-precaching
*/
declare const deleteOutdatedCaches: (currentPrecacheName: string, substringToFind?: string) => Promise<string[]>;
export { deleteOutdatedCaches };

38
frontend/node_modules/workbox-precaching/utils/deleteOutdatedCaches.js generated vendored Normal file
View File

@@ -0,0 +1,38 @@
/*
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.
*/
import '../_version.js';
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 workbox-precaching
*/
const deleteOutdatedCaches = async (currentPrecacheName, substringToFind = SUBSTRING_TO_FIND) => {
const cacheNames = await self.caches.keys();
const cacheNamesToDelete = cacheNames.filter((cacheName) => {
return (cacheName.includes(substringToFind) &&
cacheName.includes(self.registration.scope) &&
cacheName !== currentPrecacheName);
});
await Promise.all(cacheNamesToDelete.map((cacheName) => self.caches.delete(cacheName)));
return cacheNamesToDelete;
};
export { deleteOutdatedCaches };

1
frontend/node_modules/workbox-precaching/utils/deleteOutdatedCaches.mjs generated vendored Normal file
View File

@@ -0,0 +1 @@
export * from './deleteOutdatedCaches.js';

13
frontend/node_modules/workbox-precaching/utils/generateURLVariations.d.ts generated vendored Normal file
View File

@@ -0,0 +1,13 @@
import { PrecacheRouteOptions } from '../_types.js';
import '../_version.js';
/**
* Generator function that yields possible variations on the original URL to
* check, one at a time.
*
* @param {string} url
* @param {Object} options
*
* @private
* @memberof workbox-precaching
*/
export declare function generateURLVariations(url: string, { ignoreURLParametersMatching, directoryIndex, cleanURLs, urlManipulation, }?: PrecacheRouteOptions): Generator<string, void, unknown>;

42
frontend/node_modules/workbox-precaching/utils/generateURLVariations.js generated vendored Normal file
View File

@@ -0,0 +1,42 @@
/*
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 { removeIgnoredSearchParams } from './removeIgnoredSearchParams.js';
import '../_version.js';
/**
* Generator function that yields possible variations on the original URL to
* check, one at a time.
*
* @param {string} url
* @param {Object} options
*
* @private
* @memberof workbox-precaching
*/
export function* generateURLVariations(url, { ignoreURLParametersMatching = [/^utm_/, /^fbclid$/], directoryIndex = 'index.html', cleanURLs = true, urlManipulation, } = {}) {
const urlObject = new URL(url, location.href);
urlObject.hash = '';
yield urlObject.href;
const urlWithoutIgnoredParams = removeIgnoredSearchParams(urlObject, ignoreURLParametersMatching);
yield urlWithoutIgnoredParams.href;
if (directoryIndex && urlWithoutIgnoredParams.pathname.endsWith('/')) {
const directoryURL = new URL(urlWithoutIgnoredParams.href);
directoryURL.pathname += directoryIndex;
yield directoryURL.href;
}
if (cleanURLs) {
const cleanURL = new URL(urlWithoutIgnoredParams.href);
cleanURL.pathname += '.html';
yield cleanURL.href;
}
if (urlManipulation) {
const additionalURLs = urlManipulation({ url: urlObject });
for (const urlToAttempt of additionalURLs) {
yield urlToAttempt.href;
}
}
}

1
frontend/node_modules/workbox-precaching/utils/generateURLVariations.mjs generated vendored Normal file
View File

@@ -0,0 +1 @@
export * from './generateURLVariations.js';

14
frontend/node_modules/workbox-precaching/utils/getCacheKeyForURL.d.ts generated vendored Normal file
View File

@@ -0,0 +1,14 @@
import { PrecacheRouteOptions } from '../_types.js';
import '../_version.js';
/**
* 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
*/
export declare const getCacheKeyForURL: (url: string, options: PrecacheRouteOptions) => string | void;

31
frontend/node_modules/workbox-precaching/utils/getCacheKeyForURL.js generated vendored Normal file
View File

@@ -0,0 +1,31 @@
/*
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 { getOrCreatePrecacheController } from './getOrCreatePrecacheController.js';
import { generateURLVariations } from './generateURLVariations.js';
import '../_version.js';
/**
* 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
*/
export 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;
}
}
};

1
frontend/node_modules/workbox-precaching/utils/getCacheKeyForURL.mjs generated vendored Normal file
View File

@@ -0,0 +1 @@
export * from './getCacheKeyForURL.js';

7
frontend/node_modules/workbox-precaching/utils/getOrCreatePrecacheController.d.ts generated vendored Normal file
View File

@@ -0,0 +1,7 @@
import { PrecacheController } from '../PrecacheController.js';
import '../_version.js';
/**
* @return {PrecacheController}
* @private
*/
export declare const getOrCreatePrecacheController: () => PrecacheController;

20
frontend/node_modules/workbox-precaching/utils/getOrCreatePrecacheController.js generated vendored Normal file
View File

@@ -0,0 +1,20 @@
/*
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 { PrecacheController } from '../PrecacheController.js';
import '../_version.js';
let precacheController;
/**
* @return {PrecacheController}
* @private
*/
export const getOrCreatePrecacheController = () => {
if (!precacheController) {
precacheController = new PrecacheController();
}
return precacheController;
};

1
frontend/node_modules/workbox-precaching/utils/getOrCreatePrecacheController.mjs generated vendored Normal file
View File

@@ -0,0 +1 @@
export * from './getOrCreatePrecacheController.js';

Some files were not shown because too many files have changed in this diff Show More