GeezerVison

Undici exposes a W3C spec-compliant implementation of [CacheStorage](https://developer.mozilla.org/en-US/docs/Web/API/CacheStorage) and [Cache](https://developer.mozilla.org/en-US/docs/Web/API/Cache).

Undici exports a top-level CacheStorage instance. You can open a new Cache, or duplicate a Cache with an existing name, by using `CacheStorage.prototype.open`. If you open a Cache with the same name as an already-existing Cache, its list of cached Responses will be shared between both instances.

import { caches } from 'undici'

const cache_1 = await caches.open('v1')

const cache_2 = await caches.open('v1')

assert(cache_1 !== cache_2)

assert.deepStrictEqual(await cache_1.match('/req'), await cache_2.match('/req'))

If a Cache is deleted, the cached Responses/Requests can still be used.

const response = await cache_1.match('/req')

await caches.delete('v1')

await response.text() // the Response's body

import { errors } from 'undici'

| Error | Error Codes | Description |

| ------------------------------------ | ------------------------------------- | -------------------------------------------------- |

| `InvalidArgumentError` | `UND_ERR_INVALID_ARG` | passed an invalid argument. |

| `InvalidReturnValueError` | `UND_ERR_INVALID_RETURN_VALUE` | returned an invalid value. |

| `RequestAbortedError` | `UND_ERR_ABORTED` | the request has been aborted by the user |

| `ClientDestroyedError` | `UND_ERR_DESTROYED` | trying to use a destroyed client. |

| `ClientClosedError` | `UND_ERR_CLOSED` | trying to use a closed client. |

| `SocketError` | `UND_ERR_SOCKET` | there is an error with the socket. |

| `NotSupportedError` | `UND_ERR_NOT_SUPPORTED` | encountered unsupported functionality. |

| `RequestContentLengthMismatchError` | `UND_ERR_REQ_CONTENT_LENGTH_MISMATCH` | request body does not match content-length header |

| `ResponseContentLengthMismatchError` | `UND_ERR_RES_CONTENT_LENGTH_MISMATCH` | response body does not match content-length header |

| `InformationalError` | `UND_ERR_INFO` | expected error with reason |

| `ResponseExceededMaxSizeError` | `UND_ERR_RES_EXCEEDED_MAX_SIZE` | response body exceed the max size allowed |

| Error | Error Codes | Description |

| ------------------------------------ | ------------------------------------- | ------------------------------------------------------------------------- |

| `UndiciError` | `UND_ERR` | all errors below are extended from `UndiciError`. |

| `ConnectTimeoutError` | `UND_ERR_CONNECT_TIMEOUT` | socket is destroyed due to connect timeout. |

| `HeadersTimeoutError` | `UND_ERR_HEADERS_TIMEOUT` | socket is destroyed due to headers timeout. |

| `HeadersOverflowError` | `UND_ERR_HEADERS_OVERFLOW` | socket is destroyed due to headers' max size being exceeded. |

| `BodyTimeoutError` | `UND_ERR_BODY_TIMEOUT` | socket is destroyed due to body timeout. |

| `ResponseStatusCodeError` | `UND_ERR_RESPONSE_STATUS_CODE` | an error is thrown when `throwOnError` is `true` for status codes >= 400. |

| `InvalidArgumentError` | `UND_ERR_INVALID_ARG` | passed an invalid argument. |

| `InvalidReturnValueError` | `UND_ERR_INVALID_RETURN_VALUE` | returned an invalid value. |

| `RequestAbortedError` | `UND_ERR_ABORTED` | the request has been aborted by the user |

| `ClientDestroyedError` | `UND_ERR_DESTROYED` | trying to use a destroyed client. |

| `ClientClosedError` | `UND_ERR_CLOSED` | trying to use a closed client. |

| `SocketError` | `UND_ERR_SOCKET` | there is an error with the socket. |

| `NotSupportedError` | `UND_ERR_NOT_SUPPORTED` | encountered unsupported functionality. |

| `RequestContentLengthMismatchError` | `UND_ERR_REQ_CONTENT_LENGTH_MISMATCH` | request body does not match content-length header |

| `ResponseContentLengthMismatchError` | `UND_ERR_RES_CONTENT_LENGTH_MISMATCH` | response body does not match content-length header |

| `InformationalError` | `UND_ERR_INFO` | expected error with reason |

| `ResponseExceededMaxSizeError` | `UND_ERR_RES_EXCEEDED_MAX_SIZE` | response body exceed the max size allowed |

This API is implemented as per the standard, you can find documentation on [MDN](https://developer.mozilla.org/en-US/docs/Web/API/File)

In Node versions v18.13.0 and above and v19.2.0 and above, undici will default to using Node's [File](https://nodejs.org/api/buffer.html#class-file) class. In versions where it's not available, it will default to the undici one.

This API is implemented as per the standard, you can find documentation on [MDN](https://developer.mozilla.org/en-US/docs/Web/API/FormData)

Extends: [`EventTarget`](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget)

The WebSocket object provides a way to manage a WebSocket connection to a server, allowing bidirectional communication. The API follows the [WebSocket spec](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket).

The WebSocket object provides a way to manage a WebSocket connection to a server, allowing bidirectional communication. The API follows the [WebSocket spec](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket) and [RFC 6455](https://datatracker.ietf.org/doc/html/rfc6455).

Arguments:

* **url** `URL | string` - The url's protocol *must* be `ws` or `wss`.

* **protocol** `string | string[]` (optional) - Subprotocol(s) to request the server use.

* **protocol** `string | string[] | WebSocketInit` (optional) - Subprotocol(s) to request the server use, or a [`Dispatcher`](./Dispatcher.md).

This example will not work in browsers or other platforms that don't allow passing an object.

import { WebSocket, ProxyAgent } from 'undici'

const proxyAgent = new ProxyAgent('my.proxy.server')

const ws = new WebSocket('wss://echo.websocket.events', {

dispatcher: proxyAgent,

protocols: ['echo', 'chat']

})

If you do not need a custom Dispatcher, it's recommended to use the following pattern:

import { WebSocket } from 'undici'

const ws = new WebSocket('wss://echo.websocket.events', ['echo', 'chat'])

export * from './types/diagnostics-channel'

export * from './types/websocket'

export * from './types/content-type'

export * from './types/cache'

export { Interceptable } from './types/mock-interceptor'

export { Dispatcher, BalancedPool, Pool, Client, buildConnector, errors, Agent, request, stream, pipeline, connect, upgrade, setGlobalDispatcher, getGlobalDispatcher, setGlobalOrigin, getGlobalOrigin, MockClient, MockPool, MockAgent, mockErrors, ProxyAgent, RedirectHandler, DecoratorHandler }

var MockAgent: typeof import('./types/mock-agent').default;

var mockErrors: typeof import('./types/mock-errors').default;

var fetch: typeof import('./types/fetch').fetch;

var caches: typeof import('./types/cache').caches;

module.exports.setGlobalOrigin = setGlobalOrigin

module.exports.getGlobalOrigin = getGlobalOrigin

const { CacheStorage } = require('./lib/cache/cachestorage')

const { kConstruct } = require('./lib/cache/symbols')

// Cache & CacheStorage are tightly coupled with fetch. Even if it may run

// in an older version of Node, it doesn't have any use without fetch.

module.exports.caches = new CacheStorage(kConstruct)

if (util.nodeMajor >= 16) {