{"version":3,"file":"umd/dev.js","mappings":"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","sources":["webpack://AxiosCacheInterceptor/webpack/universalModuleDefinition","webpack://AxiosCacheInterceptor/./node_modules/fast-defer/index.min.js","webpack://AxiosCacheInterceptor/./node_modules/object-code/index.min.js","webpack://AxiosCacheInterceptor/webpack/bootstrap","webpack://AxiosCacheInterceptor/webpack/runtime/define property getters","webpack://AxiosCacheInterceptor/webpack/runtime/hasOwnProperty shorthand","webpack://AxiosCacheInterceptor/webpack/runtime/make namespace object","webpack://AxiosCacheInterceptor/./node_modules/cache-parser/dist/index.mjs","webpack://AxiosCacheInterceptor/./src/header/headers.ts","webpack://AxiosCacheInterceptor/./src/header/interpreter.ts","webpack://AxiosCacheInterceptor/./src/interceptors/util.ts","webpack://AxiosCacheInterceptor/./src/interceptors/request.ts","webpack://AxiosCacheInterceptor/./src/util/cache-predicate.ts","webpack://AxiosCacheInterceptor/./src/util/update-cache.ts","webpack://AxiosCacheInterceptor/./src/interceptors/response.ts","webpack://AxiosCacheInterceptor/./src/storage/build.ts","webpack://AxiosCacheInterceptor/./src/storage/memory.ts","webpack://AxiosCacheInterceptor/./src/util/key-generator.ts","webpack://AxiosCacheInterceptor/./src/cache/create.ts","webpack://AxiosCacheInterceptor/./src/storage/web-api.ts","webpack://AxiosCacheInterceptor/./src/index.ts"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"AxiosCacheInterceptor\"] = factory();\n\telse\n\t\troot[\"AxiosCacheInterceptor\"] = factory();\n})(typeof self !== 'undefined' ? self : this, function() {\nreturn ","!function(e){var r=Symbol(\"fast-defer\");e.deferred=function(){var e,n,t=new Promise((function(r,t){e=r,n=t}));return t.resolve=e,t.reject=n,t[r]=1,t},e.isDeferred=function(e){return!!e&&!!e[r]}}(\"undefined\"!=typeof exports?exports:window.FastDefer||(window.FastDefer={}));","!function(r){r.transform=function(t){var n=typeof t;if(\"object\"===n&&t){if(t instanceof Date)return\"#\"+t.getTime();if(t instanceof RegExp)return\"#\"+t.toString();var o=Array.isArray(t)?[]:{};for(var e in t)o[e]=r.transform(t[e]);return\"#\"+String(t.constructor)+JSON.stringify(o,Object.keys(o).sort())}return n+String(t)+(\"symbol\"===n?Math.random():\"\")},r.code=function(t){t=r.transform(t);for(var n=7,o=0;o {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","var e=Symbol(\"cache-parser\");function a(a){return!(!a||!a[e])}function r(e){return(\"string\"==typeof e||\"number\"==typeof e)&&(e=Number(e))>=0&&e, :: GMT\n * ```\n *\n * @link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/If-Modified-Since\n */\n IfModifiedSince: 'if-modified-since',\n /**\n * ```txt\n * Last-Modified: , :: GMT\n * ```\n *\n * @link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Last-Modified\n */\n LastModified: 'last-modified',\n /**\n * ```txt\n * If-None-Match: \"\"\n * If-None-Match: \"\", \"\", …\n * If-None-Match: *\n * ```\n *\n * @link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/If-None-Match\n */\n IfNoneMatch: 'if-none-match',\n /**\n * ```txt\n * Cache-Control: max-age=604800\n * ```\n *\n * @link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control\n */\n CacheControl: 'cache-control',\n /**\n * ```txt\n * ETag: W / '';\n * ETag: '';\n * ```\n *\n * @link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/ETag\n */\n ETag: 'etag',\n /**\n * ```txt\n * Expires: \n * ```\n *\n * @link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Expires\n */\n Expires: 'expires',\n /**\n * ```txt\n * Age: \n * ```\n *\n * @link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Age\n */\n Age: 'age',\n /**\n * Used internally as metadata to mark the cache item as revalidatable and enabling\n * stale cache state Contains a string of ASCII characters that can be used as ETag for\n * `If-Match` header Provided by user using `cache.etag` value.\n *\n * ```txt\n * X-Axios-Cache-Etag: \"\"\n * ```\n */\n XAxiosCacheEtag: 'x-axios-cache-etag',\n /**\n * Used internally as metadata to mark the cache item as revalidatable and enabling\n * stale cache state may contain `'use-cache-timestamp'` if `cache.modifiedSince` is\n * `true`, otherwise will contain a date from `cache.modifiedSince`. If a date is\n * provided, it can be used for `If-Modified-Since` header, otherwise the cache\n * timestamp can be used for `If-Modified-Since` header.\n *\n * ```txt\n * X-Axios-Cache-Last-Modified: , :: GMT\n * X-Axios-Cache-Last-Modified: use-cache-timestamp\n * ```\n */\n XAxiosCacheLastModified: 'x-axios-cache-last-modified',\n /**\n * Used internally as metadata to mark the cache item able to be used if the server\n * returns an error. The stale-if-error response directive indicates that the cache can\n * reuse a stale response when any error occurs.\n *\n * ```txt\n * XAxiosCacheStaleIfError: \n * ```\n */\n XAxiosCacheStaleIfError: 'x-axios-cache-stale-if-error'\n});\n","import { parse } from 'cache-parser';\nimport { Header } from './headers';\nexport const defaultHeaderInterpreter = (headers) => {\n if (!headers)\n return 'not enough headers';\n const cacheControl = headers[Header.CacheControl];\n if (cacheControl) {\n const { noCache, noStore, mustRevalidate, maxAge, immutable } = parse(String(cacheControl));\n // Header told that this response should not be cached.\n if (noCache || noStore) {\n return 'dont cache';\n }\n if (immutable) {\n // 1 year is sufficient, as Infinity may cause more problems.\n // It might not be the best way, but a year is better than none.\n return 1000 * 60 * 60 * 24 * 365;\n }\n // Already out of date, for cache can be saved, but must be requested again\n if (mustRevalidate) {\n return 0;\n }\n if (maxAge) {\n const age = headers[Header.Age];\n if (!age) {\n return maxAge * 1000;\n }\n return (maxAge - Number(age)) * 1000;\n }\n }\n const expires = headers[Header.Expires];\n if (expires) {\n const milliseconds = Date.parse(String(expires)) - Date.now();\n return milliseconds >= 0 ? milliseconds : 'dont cache';\n }\n return 'not enough headers';\n};\n","import { Header } from '../header/headers';\n/**\n * Creates a new validateStatus function that will use the one already used and also\n * accept status code 304.\n */\nexport function createValidateStatus(oldValidate) {\n return oldValidate\n ? (status) => oldValidate(status) || status === 304\n : (status) => (status >= 200 && status < 300) || status === 304;\n}\n/** Checks if the given method is in the methods array */\nexport function isMethodIn(requestMethod = 'get', methodList = []) {\n requestMethod = requestMethod.toLowerCase();\n for (const method of methodList) {\n if (method.toLowerCase() === requestMethod) {\n return true;\n }\n }\n return false;\n}\n/**\n * This function updates the cache when the request is stale. So, the next request to the\n * server will be made with proper header / settings.\n */\nexport function updateStaleRequest(cache, config) {\n var _a;\n config.headers || (config.headers = {});\n const { etag, modifiedSince } = config.cache;\n if (etag) {\n const etagValue = etag === true ? (_a = cache.data) === null || _a === void 0 ? void 0 : _a.headers[Header.ETag] : etag;\n if (etagValue) {\n config.headers[Header.IfNoneMatch] = etagValue;\n }\n }\n if (modifiedSince) {\n config.headers[Header.IfModifiedSince] =\n modifiedSince === true\n ? // If last-modified is not present, use the createdAt timestamp\n cache.data.headers[Header.LastModified] ||\n new Date(cache.createdAt).toUTCString()\n : modifiedSince.toUTCString();\n }\n}\n/**\n * Creates the new date to the cache by the provided response. Also handles possible 304\n * Not Modified by updating response properties.\n */\nexport function createCacheResponse(response, cache) {\n if (response.status === 304 && cache) {\n // Set the cache information into the response object\n response.cached = true;\n response.data = cache.data;\n response.status = cache.status;\n response.statusText = cache.statusText;\n // Update possible new headers\n response.headers = Object.assign(Object.assign({}, cache.headers), response.headers);\n // return the old cache\n return cache;\n }\n // New Response\n return {\n data: response.data,\n status: response.status,\n statusText: response.statusText,\n headers: response.headers\n };\n}\n","import { deferred } from 'fast-defer';\nimport { createValidateStatus, isMethodIn, updateStaleRequest } from './util';\nexport function defaultRequestInterceptor(axios) {\n const onFulfilled = async (config) => {\n var _a, _b, _c, _d, _e, _f, _g, _h, _j;\n if (config.cache === false) {\n if (__ACI_DEV__) {\n (_a = axios.debug) === null || _a === void 0 ? void 0 : _a.call(axios, {\n msg: 'Ignoring cache because config.cache is false',\n data: config\n });\n }\n return config;\n }\n // merge defaults with per request configuration\n config.cache = Object.assign(Object.assign({}, axios.defaults.cache), config.cache);\n if (!isMethodIn(config.method, config.cache.methods)) {\n if (__ACI_DEV__) {\n (_b = axios.debug) === null || _b === void 0 ? void 0 : _b.call(axios, {\n msg: `Ignored because method (${config.method}) is not in cache.methods (${config.cache.methods})`\n });\n }\n return config;\n }\n const key = (config.id = axios.generateKey(config));\n // Assumes that the storage handled staled responses\n let cache = await axios.storage.get(key);\n // Not cached, continue the request, and mark it as fetching\n emptyOrStale: if (cache.state === 'empty' || cache.state === 'stale') {\n /**\n * This checks for simultaneous access to a new key. The js event loop jumps on the\n * first await statement, so the second (asynchronous call) request may have already\n * started executing.\n */\n if (axios.waiting[key]) {\n cache = (await axios.storage.get(key));\n if (__ACI_DEV__) {\n (_c = axios.debug) === null || _c === void 0 ? void 0 : _c.call(axios, {\n id: key,\n msg: 'Waiting list had an deferred for this key, waiting for it to finish'\n });\n }\n break emptyOrStale;\n }\n // Create a deferred to resolve other requests for the same key when it's completed\n axios.waiting[key] = deferred();\n /**\n * Add a default reject handler to catch when the request is aborted without others\n * waiting for it.\n */\n (_d = axios.waiting[key]) === null || _d === void 0 ? void 0 : _d.catch(() => undefined);\n await axios.storage.set(key, {\n state: 'loading',\n previous: cache.state,\n // Eslint complains a lot :)\n // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any\n data: cache.data,\n // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any\n createdAt: cache.createdAt\n });\n if (cache.state === 'stale') {\n updateStaleRequest(cache, config);\n if (__ACI_DEV__) {\n (_e = axios.debug) === null || _e === void 0 ? void 0 : _e.call(axios, {\n id: key,\n msg: 'Updated stale request'\n });\n }\n }\n config.validateStatus = createValidateStatus(config.validateStatus);\n if (__ACI_DEV__) {\n (_f = axios.debug) === null || _f === void 0 ? void 0 : _f.call(axios, {\n id: key,\n msg: 'Sending request, waiting for response'\n });\n }\n return config;\n }\n let cachedResponse;\n if (cache.state === 'loading') {\n const deferred = axios.waiting[key];\n // Just in case, the deferred doesn't exists.\n /* istanbul ignore if 'really hard to test' */\n if (!deferred) {\n await axios.storage.remove(key);\n return config;\n }\n if (__ACI_DEV__) {\n (_g = axios.debug) === null || _g === void 0 ? void 0 : _g.call(axios, {\n id: key,\n msg: 'Detected concurrent request, waiting for it to finish'\n });\n }\n try {\n cachedResponse = await deferred;\n }\n catch (err) {\n if (__ACI_DEV__) {\n (_h = axios.debug) === null || _h === void 0 ? void 0 : _h.call(axios, {\n id: key,\n msg: 'Deferred rejected, requesting again',\n data: err\n });\n }\n // The deferred is rejected when the request that we are waiting rejected cache.\n return config;\n }\n }\n else {\n cachedResponse = cache.data;\n }\n // Even though the response interceptor receives this one from here,\n // it has been configured to ignore cached responses = true\n config.adapter = () => Promise.resolve({\n config,\n data: cachedResponse.data,\n headers: cachedResponse.headers,\n status: cachedResponse.status,\n statusText: cachedResponse.statusText,\n cached: true,\n id: key\n });\n if (__ACI_DEV__) {\n (_j = axios.debug) === null || _j === void 0 ? void 0 : _j.call(axios, {\n id: key,\n msg: 'Returning cached response'\n });\n }\n return config;\n };\n return {\n onFulfilled,\n apply: () => axios.interceptors.request.use(onFulfilled)\n };\n}\n","/** Tests an response against a {@link CachePredicateObject}. */\nexport async function testCachePredicate(response, predicate) {\n var _a;\n if (typeof predicate === 'function') {\n return predicate(response);\n }\n const { statusCheck, responseMatch, containsHeaders } = predicate;\n if ((statusCheck && !(await statusCheck(response.status))) ||\n (responseMatch && !(await responseMatch(response)))) {\n return false;\n }\n if (containsHeaders) {\n for (const header in containsHeaders) {\n const predicate = containsHeaders[header];\n if (predicate &&\n !(await predicate(\n // Axios uses lowercase headers, but if for some reason it doesn't, we should\n // still be able to match.\n (_a = response.headers[header.toLowerCase()]) !== null && _a !== void 0 ? _a : response.headers[header]))) {\n return false;\n }\n }\n }\n return true;\n}\n","/** Function to update all caches, from CacheProperties.update, with the new data. */\nexport async function updateCache(storage, data, entries) {\n for (const cacheKey in entries) {\n // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n const value = entries[cacheKey];\n if (value === 'delete') {\n await storage.remove(cacheKey);\n continue;\n }\n const oldValue = await storage.get(cacheKey);\n if (oldValue.state === 'loading') {\n continue;\n }\n const newValue = await value(oldValue, data);\n if (newValue === 'delete') {\n await storage.remove(cacheKey);\n continue;\n }\n if (newValue === 'ignore') {\n continue;\n }\n await storage.set(cacheKey, newValue);\n }\n}\n","import { Header } from '../header/headers';\nimport { testCachePredicate } from '../util/cache-predicate';\nimport { updateCache } from '../util/update-cache';\nimport { createCacheResponse } from './util';\nexport function defaultResponseInterceptor(axios) {\n /**\n * Rejects cache for an response response.\n *\n * Also update the waiting list for this key by rejecting it.\n */\n const rejectResponse = async (responseId) => {\n var _a;\n // Update the cache to empty to prevent infinite loading state\n await axios.storage.remove(responseId);\n // Reject the deferred if present\n (_a = axios.waiting[responseId]) === null || _a === void 0 ? void 0 : _a.reject(null);\n delete axios.waiting[responseId];\n };\n const onFulfilled = async (response) => {\n var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;\n var _l;\n response.id = (_a = (_l = response.config).id) !== null && _a !== void 0 ? _a : (_l.id = axios.generateKey(response.config));\n (_b = response.cached) !== null && _b !== void 0 ? _b : (response.cached = false);\n // Response is already cached\n if (response.cached) {\n if (__ACI_DEV__) {\n (_c = axios.debug) === null || _c === void 0 ? void 0 : _c.call(axios, {\n id: response.id,\n msg: 'Returned cached response'\n });\n }\n return response;\n }\n // Skip cache: either false or weird behavior\n // config.cache should always exists, at least from global config merge.\n if (!response.config.cache) {\n if (__ACI_DEV__) {\n (_d = axios.debug) === null || _d === void 0 ? void 0 : _d.call(axios, {\n id: response.id,\n msg: 'Response with config.cache === false',\n data: response\n });\n }\n return Object.assign(Object.assign({}, response), { cached: false });\n }\n // Request interceptor merges defaults with per request configuration\n const cacheConfig = response.config.cache;\n const cache = await axios.storage.get(response.id);\n if (\n // If the request interceptor had a problem\n cache.state === 'stale' ||\n cache.state === 'empty' ||\n // Should not hit here because of previous response.cached check\n cache.state === 'cached') {\n if (__ACI_DEV__) {\n (_e = axios.debug) === null || _e === void 0 ? void 0 : _e.call(axios, {\n id: response.id,\n msg: 'Response not cached but storage is not loading',\n data: { cache, response }\n });\n }\n return response;\n }\n // Config told that this response should be cached.\n if (\n // For 'loading' values (post stale), this check was already run in the past.\n !cache.data &&\n !(await testCachePredicate(response, cacheConfig.cachePredicate))) {\n await rejectResponse(response.id);\n if (__ACI_DEV__) {\n (_f = axios.debug) === null || _f === void 0 ? void 0 : _f.call(axios, {\n id: response.id,\n msg: 'Cache predicate rejected this response'\n });\n }\n return response;\n }\n // avoid remnant headers from remote server to break implementation\n for (const header in Header) {\n if (!header.startsWith('XAxiosCache')) {\n continue;\n }\n delete response.headers[header];\n }\n if (cacheConfig.etag && cacheConfig.etag !== true) {\n response.headers[Header.XAxiosCacheEtag] = cacheConfig.etag;\n }\n if (cacheConfig.modifiedSince) {\n response.headers[Header.XAxiosCacheLastModified] =\n cacheConfig.modifiedSince === true\n ? 'use-cache-timestamp'\n : cacheConfig.modifiedSince.toUTCString();\n }\n let ttl = cacheConfig.ttl || -1; // always set from global config\n if (cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.interpretHeader) {\n const expirationTime = axios.headerInterpreter(response.headers);\n // Cache should not be used\n if (expirationTime === 'dont cache') {\n await rejectResponse(response.id);\n if (__ACI_DEV__) {\n (_g = axios.debug) === null || _g === void 0 ? void 0 : _g.call(axios, {\n id: response.id,\n msg: `Cache header interpreted as 'dont cache'`,\n data: {\n cache,\n response,\n expirationTime\n }\n });\n }\n return response;\n }\n ttl = expirationTime === 'not enough headers' ? ttl : expirationTime;\n }\n const data = createCacheResponse(response, cache.data);\n if (typeof ttl === 'function') {\n ttl = await ttl(response);\n }\n if (cacheConfig.staleIfError) {\n response.headers[Header.XAxiosCacheStaleIfError] = String(ttl);\n }\n if (__ACI_DEV__) {\n (_h = axios.debug) === null || _h === void 0 ? void 0 : _h.call(axios, {\n id: response.id,\n msg: 'Useful response configuration found',\n data: { cacheConfig, ttl, cacheResponse: data }\n });\n }\n // Update other entries before updating himself\n if (cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.update) {\n await updateCache(axios.storage, response, cacheConfig.update);\n }\n const newCache = {\n state: 'cached',\n ttl,\n createdAt: Date.now(),\n data\n };\n // Resolve all other requests waiting for this response\n const waiting = axios.waiting[response.id];\n if (waiting) {\n // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n waiting.resolve(newCache.data);\n delete axios.waiting[response.id];\n if (__ACI_DEV__) {\n (_j = axios.debug) === null || _j === void 0 ? void 0 : _j.call(axios, {\n id: response.id,\n msg: 'Found waiting deferred(s) and resolved them'\n });\n }\n }\n // Define this key as cache on the storage\n await axios.storage.set(response.id, newCache);\n if (__ACI_DEV__) {\n (_k = axios.debug) === null || _k === void 0 ? void 0 : _k.call(axios, {\n id: response.id,\n msg: 'Response cached',\n data: { cache: newCache, response }\n });\n }\n // Return the response with cached as false, because it was not cached at all\n return response;\n };\n const onRejected = async (error) => {\n var _a, _b, _c, _d, _e, _f;\n const config = error['config'];\n if (!config || config.cache === false || !config.id) {\n if (__ACI_DEV__) {\n (_a = axios.debug) === null || _a === void 0 ? void 0 : _a.call(axios, {\n msg: 'Web request returned an error but cache handling is not enabled',\n data: { error, config }\n });\n }\n throw error;\n }\n const cache = await axios.storage.get(config.id);\n const cacheConfig = config.cache;\n if (\n // This will only not be loading if the interceptor broke\n cache.state !== 'loading' ||\n cache.previous !== 'stale') {\n await rejectResponse(config.id);\n if (__ACI_DEV__) {\n (_b = axios.debug) === null || _b === void 0 ? void 0 : _b.call(axios, {\n msg: 'Caught an error in the request interceptor',\n data: { error, config }\n });\n }\n throw error;\n }\n if (cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.staleIfError) {\n const staleIfError = typeof cacheConfig.staleIfError === 'function'\n ? await cacheConfig.staleIfError(error.response, cache, error)\n : cacheConfig.staleIfError;\n if (__ACI_DEV__) {\n (_c = axios.debug) === null || _c === void 0 ? void 0 : _c.call(axios, {\n msg: 'Found cache if stale config for rejected response',\n data: { error, config, staleIfError }\n });\n }\n if (staleIfError === true ||\n // staleIfError is the number of seconds that stale is allowed to be used\n (typeof staleIfError === 'number' && cache.createdAt + staleIfError > Date.now())) {\n // Resolve all other requests waiting for this response\n (_d = axios.waiting[config.id]) === null || _d === void 0 ? void 0 : _d.resolve(cache.data);\n delete axios.waiting[config.id];\n // re-mark the cache as stale\n await axios.storage.set(config.id, {\n state: 'stale',\n createdAt: Date.now(),\n data: cache.data\n });\n if (__ACI_DEV__) {\n (_e = axios.debug) === null || _e === void 0 ? void 0 : _e.call(axios, {\n msg: 'staleIfError resolved this response with cached data',\n data: { error, config, cache }\n });\n }\n return {\n cached: true,\n config,\n id: config.id,\n data: cache.data.data,\n headers: cache.data.headers,\n status: cache.data.status,\n statusText: cache.data.statusText\n };\n }\n }\n if (__ACI_DEV__) {\n (_f = axios.debug) === null || _f === void 0 ? void 0 : _f.call(axios, {\n msg: 'Received an unknown error that could not be handled',\n data: { error, config }\n });\n }\n throw error;\n };\n return {\n onFulfilled,\n onRejected,\n apply: () => axios.interceptors.response.use(onFulfilled, onRejected)\n };\n}\n","import { Header } from '../header/headers';\nconst storage = Symbol();\n/** Returns true if the provided object was created from {@link buildStorage} function. */\nexport const isStorage = (obj) => !!obj && !!obj[storage];\n/**\n * Builds a custom storage.\n *\n * **Note**: You can only create an custom storage with this function.\n *\n * @example\n *\n * ```js\n * const myStorage = buildStorage({\n * find: () => {...},\n * set: () => {...},\n * remove: () => {...}\n * });\n *\n * const axios = setupCache(axios, { storage: myStorage });\n * ```\n */\nexport function buildStorage({ set, find, remove }) {\n return {\n //@ts-expect-error - we don't want to expose this\n [storage]: 1,\n set,\n remove,\n get: async (key) => {\n const value = await find(key);\n if (!value) {\n return { state: 'empty' };\n }\n if (\n // Not cached or fresh value\n value.state !== 'cached' ||\n value.createdAt + value.ttl > Date.now()) {\n return value;\n }\n if (value.data.headers &&\n // Any header below allows the response to stale\n (Header.ETag in value.data.headers ||\n Header.LastModified in value.data.headers ||\n Header.XAxiosCacheEtag in value.data.headers ||\n Header.XAxiosCacheStaleIfError in value.data.headers ||\n Header.XAxiosCacheLastModified in value.data.headers)) {\n const stale = {\n state: 'stale',\n createdAt: value.createdAt,\n data: value.data\n };\n await set(key, stale);\n return stale;\n }\n await remove(key);\n return { state: 'empty' };\n }\n };\n}\n","import { buildStorage } from './build';\n/**\n * Creates a simple in-memory storage. This means that if you need to persist data between\n * page or server reloads, this will not help.\n *\n * This is the storage used by default.\n *\n * If you need to modify it's data, you can do by the `data` property.\n *\n * @example\n *\n * ```js\n * const memoryStorage = buildMemoryStorage();\n *\n * setupCache(axios, { storage: memoryStorage });\n *\n * // Simple example to force delete the request cache\n *\n * const { id } = axios.get('url');\n *\n * delete memoryStorage.data[id];\n * ```\n */\nexport function buildMemoryStorage() {\n const storage = buildStorage({\n find: (key) => storage.data[key],\n set: (key, value) => {\n storage.data[key] = value;\n },\n remove: (key) => {\n delete storage.data[key];\n }\n });\n storage.data = Object.create(null);\n return storage;\n}\n","import { code } from 'object-code';\n// Remove first and last '/' char, if present\nconst SLASHES_REGEX = /^\\/|\\/$/g;\nexport function buildKeyGenerator(hash, generator) {\n return (request) => {\n if (request.id) {\n return request.id;\n }\n // Remove trailing slashes\n request.baseURL && (request.baseURL = request.baseURL.replace(SLASHES_REGEX, ''));\n request.url && (request.url = request.url.replace(SLASHES_REGEX, ''));\n // lowercase method\n request.method && (request.method = request.method.toLowerCase());\n const result = generator(request);\n return hash ? code(result).toString() : result;\n };\n}\nexport const defaultKeyGenerator = buildKeyGenerator(true, ({ baseURL = '', url = '', method = 'get', params, data }) => {\n return {\n url: baseURL + (baseURL && url ? '/' : '') + url,\n method,\n params: params,\n data\n };\n});\n","import { defaultHeaderInterpreter } from '../header/interpreter';\nimport { defaultRequestInterceptor } from '../interceptors/request';\nimport { defaultResponseInterceptor } from '../interceptors/response';\nimport { isStorage } from '../storage/build';\nimport { buildMemoryStorage } from '../storage/memory';\nimport { defaultKeyGenerator } from '../util/key-generator';\n/**\n * Apply the caching interceptors for a already created axios instance.\n *\n * @example\n *\n * ```ts\n * import Axios from 'axios';\n * import { setupCache, AxiosCacheInstance } from 'axios-cache-interceptor';\n *\n * // instance will have our custom typings from the return of this function\n * const instance = setupCache(\n * Axios.create({\n * // Axios options\n * }),\n * {\n * // Axios-cache-interceptor options\n * }\n * );\n *\n * // OR\n *\n * const instance = axios.create({\n * // Axios options\n * }) as AxiosCacheInstance;\n *\n * // As this functions returns the same axios instance but only with\n * // different typings, you can ignore the function return.\n * setupCache(instance, {\n * // Axios-cache-interceptor options\n * });\n * ```\n *\n * @param axios The already created axios instance\n * @param config The config for the caching interceptors\n * @returns The same instance with extended typescript types.\n */\nexport function setupCache(axios, options = {}) {\n var _a, _b, _c, _d, _e;\n const axiosCache = axios;\n axiosCache.storage = options.storage || buildMemoryStorage();\n if (!isStorage(axiosCache.storage)) {\n throw new Error('Use buildStorage() function');\n }\n axiosCache.generateKey = options.generateKey || defaultKeyGenerator;\n axiosCache.waiting = options.waiting || {};\n axiosCache.headerInterpreter = options.headerInterpreter || defaultHeaderInterpreter;\n axiosCache.requestInterceptor =\n options.requestInterceptor || defaultRequestInterceptor(axiosCache);\n axiosCache.responseInterceptor =\n options.responseInterceptor || defaultResponseInterceptor(axiosCache);\n axiosCache.debug = options.debug;\n // CacheRequestConfig values\n axiosCache.defaults.cache = {\n ttl: (_a = options.ttl) !== null && _a !== void 0 ? _a : 1000 * 60 * 5,\n interpretHeader: (_b = options.interpretHeader) !== null && _b !== void 0 ? _b : false,\n methods: options.methods || ['get'],\n cachePredicate: options.cachePredicate || {\n statusCheck: (status) => status >= 200 && status < 400\n },\n etag: (_c = options.etag) !== null && _c !== void 0 ? _c : false,\n modifiedSince: (_d = options.modifiedSince) !== null && _d !== void 0 ? _d : false,\n staleIfError: (_e = options.staleIfError) !== null && _e !== void 0 ? _e : false,\n update: options.update || {}\n };\n // Apply interceptors\n axiosCache.requestInterceptor.apply();\n axiosCache.responseInterceptor.apply();\n return axiosCache;\n}\n","import { buildStorage } from './build';\n/**\n * Creates a simple storage. You can persist his data by using `sessionStorage` or\n * `localStorage` with it.\n *\n * **ImplNote**: Without polyfill, this storage only works on browser environments.\n *\n * @example\n *\n * ```js\n * const fromLocalStorage = buildWebStorage(localStorage);\n * const fromSessionStorage = buildWebStorage(sessionStorage);\n *\n * const myStorage = new Storage();\n * const fromMyStorage = buildWebStorage(myStorage);\n * ```\n *\n * @param prefix The prefix to index the storage. Useful to prevent collision between\n * multiple places using the same storage.\n */\nexport function buildWebStorage(storage, prefix = '') {\n return buildStorage({\n find: (key) => {\n const json = storage.getItem(prefix + key);\n return json ? JSON.parse(json) : undefined;\n },\n set: (key, value) => {\n storage.setItem(prefix + key, JSON.stringify(value));\n },\n remove: (key) => {\n storage.removeItem(prefix + key);\n }\n });\n}\n","export * from './cache/axios';\nexport * from './cache/cache';\nexport * from './cache/create';\nexport * from './header/headers';\nexport * from './header/interpreter';\nexport * from './header/types';\nexport * from './interceptors/build';\nexport * from './interceptors/request';\nexport * from './interceptors/response';\nexport * from './interceptors/util';\nexport * from './storage/build';\nexport * from './storage/memory';\nexport * from './storage/types';\nexport * from './storage/web-api';\nexport * from './util/cache-predicate';\nexport * from './util/key-generator';\nexport * from './util/types';\nexport * from './util/update-cache';\nif (__ACI_DEV__) {\n console.error('You are using a development build. Make sure to use the correct build in production');\n console.error('https://axios-cache-interceptor.js.org/#/pages/installing');\n}\n"],"names":["root","factory","exports","module","define","amd","self","this","e","r","Symbol","deferred","n","t","Promise","resolve","reject","isDeferred","transform","Date","getTime","RegExp","toString","o","Array","isArray","String","constructor","JSON","stringify","Object","keys","sort","Math","random","code","length","charCodeAt","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","undefined","__webpack_modules__","d","definition","key","defineProperty","enumerable","get","obj","prop","prototype","hasOwnProperty","call","toStringTag","value","Number","Infinity","Header","freeze","IfModifiedSince","LastModified","IfNoneMatch","CacheControl","ETag","Expires","Age","XAxiosCacheEtag","XAxiosCacheLastModified","XAxiosCacheStaleIfError","defaultHeaderInterpreter","headers","cacheControl","noCache","noStore","mustRevalidate","maxAge","immutable","a","i","toLowerCase","replace","split","s","maxStale","minFresh","mustUnderstand","noTransform","onlyIfCached","private","proxyRevalidate","public","sMaxAge","staleIfError","staleWhileRevalidate","age","expires","milliseconds","parse","now","createValidateStatus","oldValidate","status","isMethodIn","requestMethod","methodList","method","updateStaleRequest","cache","config","_a","etag","modifiedSince","etagValue","data","createdAt","toUTCString","createCacheResponse","response","cached","statusText","assign","defaultRequestInterceptor","axios","onFulfilled","async","_b","_c","_d","_e","_f","_g","_h","_j","debug","msg","defaults","methods","id","generateKey","cachedResponse","storage","emptyOrStale","state","waiting","catch","set","previous","validateStatus","remove","err","adapter","apply","interceptors","request","use","testCachePredicate","predicate","statusCheck","responseMatch","containsHeaders","header","updateCache","entries","cacheKey","oldValue","newValue","defaultResponseInterceptor","rejectResponse","responseId","_k","_l","cacheConfig","cachePredicate","startsWith","ttl","interpretHeader","expirationTime","headerInterpreter","cacheResponse","update","newCache","onRejected","error","isStorage","buildStorage","find","stale","buildMemoryStorage","create","SLASHES_REGEX","buildKeyGenerator","hash","generator","baseURL","url","result","defaultKeyGenerator","params","setupCache","options","axiosCache","Error","requestInterceptor","responseInterceptor","buildWebStorage","prefix","json","getItem","setItem","removeItem","console"],"sourceRoot":""}