You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 

142 lines
5.7 KiB

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 };