GeezerVison

* **uri** `string` (required) - It can be passed either by a string or a object containing `uri` as string.

* **token** `string` (optional) - It can be passed by a string of token for authentication.

* **auth** `string` (**deprecated**) - Use token.

* **clientFactory** `(origin: URL, opts: Object) => Dispatcher` - Default: `(origin, opts) => new Pool(origin, opts)`

* **clientFactory** `(origin: URL, opts: Object) => Dispatcher` (optional) - Default: `(origin, opts) => new Pool(origin, opts)`

* **requestTls** `BuildOptions` (optional) - Options object passed when creating the underlying socket via the connector builder for the request. See [TLS](https://nodejs.org/api/tls.html#tlsconnectoptions-callback).

* **proxyTls** `BuildOptions` (optional) - Options object passed when creating the underlying socket via the connector builder for the proxy server. See [TLS](https://nodejs.org/api/tls.html#tlsconnectoptions-callback).

Examples:

const { addAbortListener } = require('../core/util')

const { RequestAbortedError } = require('../core/errors')

const kListener = Symbol('kListener')

abort(self)

}

if ('addEventListener' in self[kSignal]) {

self[kSignal].addEventListener('abort', self[kListener])

} else {

self[kSignal].addListener('abort', self[kListener])

}

addAbortListener(self[kSignal], self[kListener])

function removeSignal (self) {

const abortFn = () => {

this.destroy()

}

let signalListenerCleanup

if (signal) {

if (typeof signal !== 'object' || !('aborted' in signal)) {

throw new InvalidArgumentError('signal must be an AbortSignal')

}

util.throwIfAborted(signal)

signal.addEventListener('abort', abortFn, { once: true })

signalListenerCleanup = util.addAbortListener(signal, abortFn)

}

try {

for await (const chunk of this) {

} catch {

util.throwIfAborted(signal)

} finally {

if (signal) {

signal.removeEventListener('abort', abortFn)

if (typeof signalListenerCleanup === 'function') {

signalListenerCleanup()

} else if (signalListenerCleanup) {

signalListenerCleanup[Symbol.dispose]()

}

}

}

}

let events

function addAbortListener (signal, listener) {

if (typeof Symbol.dispose === 'symbol') {

if (!events) {

events = require('events')

}

if (typeof events.addAbortListener === 'function' && 'aborted' in signal) {

return events.addAbortListener(signal, listener)

}

}

if ('addEventListener' in signal) {

signal.addEventListener('abort', listener, { once: true })

return () => signal.removeEventListener('abort', listener)

}

signal.addListener('abort', listener)

return () => signal.removeListener('abort', listener)

const hasToWellFormed = !!String.prototype.toWellFormed

isFormDataLike,

buildURL,

throwIfAborted,

addAbortListener,

nodeMajor,

nodeMinor,

nodeHasAutoSelectFamily: nodeMajor > 18 || (nodeMajor === 18 && nodeMinor >= 13)

// Set source to a copy of the bytes held by object.

source = new Uint8Array(object.buffer.slice(object.byteOffset, object.byteOffset + object.byteLength))

} else if (util.isFormDataLike(object)) {

const boundary = `----formdata-undici-${Math.random()}`.replace('.', '').slice(0, 32)

const boundary = `----formdata-undici-0${`${Math.floor(Math.random() * 1e11)}`.padStart(11, '0')}`

const prefix = `--${boundary}\r\nContent-Disposition: form-data`

/*! formdata-polyfill. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */

const { kHeadersList } = require('../core/symbols')

const EE = require('events')

const { Readable, pipeline } = require('stream')

const { isErrored, isReadable, nodeMajor, nodeMinor } = require('../core/util')

const { addAbortListener, isErrored, isReadable, nodeMajor, nodeMinor } = require('../core/util')

const { dataURLProcessor, serializeAMimeType } = require('./dataURL')

const { TransformStream } = require('stream/web')

const { getGlobalDispatcher } = require('../global')

let controller = null

// 11. Add the following abort steps to requestObject’s signal:

requestObject.signal.addEventListener(

'abort',

addAbortListener(

requestObject.signal,

() => {

// 1. Set locallyAborted to true.

locallyAborted = true

// 2. Abort the fetch() call with p, request, responseObject,

// 2. Assert: controller is non-null.

assert(controller != null)

// 3. Abort controller with requestObject’s signal’s abort reason.

controller.abort(requestObject.signal.reason)

// 4. Abort the fetch() call with p, request, responseObject,

// and requestObject’s signal’s abort reason.

abortFetch(p, request, responseObject, requestObject.signal.reason)

// 3. If controller is not null, then abort controller.

if (controller != null) {

controller.abort()

}

},

{ once: true }

}

)

// 12. Let handleFetchDone given response response be to finalize and

function markResourceTiming (timingInfo, originalURL, initiatorType, globalThis, cacheState) {

if (nodeMajor > 18 || (nodeMajor === 18 && nodeMinor >= 2)) {

performance.markResourceTiming(timingInfo, originalURL, initiatorType, globalThis, cacheState)

performance.markResourceTiming(timingInfo, originalURL.href, initiatorType, globalThis, cacheState)

}

if (key.toLowerCase() === 'content-encoding') {

// https://www.rfc-editor.org/rfc/rfc7231#section-3.1.2.1

// "All content-coding values are case-insensitive..."

codings = val.toLowerCase().split(',').map((x) => x.trim())

codings = val.toLowerCase().split(',').map((x) => x.trim()).reverse()

} else if (key.toLowerCase() === 'location') {

location = val

}

for (const coding of codings) {

// https://www.rfc-editor.org/rfc/rfc9112.html#section-7.2

if (coding === 'x-gzip' || coding === 'gzip') {

decoders.push(zlib.createGunzip())

decoders.push(zlib.createGunzip({

// Be less strict when decoding compressed responses, since sometimes

// servers send slightly invalid responses that are still accepted

// by common browsers.

// Always using Z_SYNC_FLUSH is what cURL does.

flush: zlib.constants.Z_SYNC_FLUSH,

finishFlush: zlib.constants.Z_SYNC_FLUSH

}))

} else if (coding === 'deflate') {

decoders.push(zlib.createInflate())

} else if (coding === 'br') {

}

// 3. If one of the following is true

// parsedReferrer’s cannot-be-a-base-URL is true, scheme is "about",

// and path contains a single string "client"

// parsedReferrer’s origin is not same origin with origin

// - parsedReferrer’s scheme is "about" and path is the string "client"

// - parsedReferrer’s origin is not same origin with origin

// then set request’s referrer to "client".

// TODO

// 4. Otherwise, set request’s referrer to parsedReferrer.

request.referrer = parsedReferrer

if (

(parsedReferrer.protocol === 'about:' && parsedReferrer.hostname === 'client') ||

(origin && !sameOrigin(parsedReferrer, this[kRealm].settingsObject.baseUrl))

) {

request.referrer = 'client'

} else {

// 4. Otherwise, set request’s referrer to parsedReferrer.

request.referrer = parsedReferrer

}

}

}

// 28. Set this’s signal to a new AbortSignal object with this’s relevant

// Realm.

// TODO: could this be simplified with AbortSignal.any

// (https://dom.spec.whatwg.org/#dom-abortsignal-any)

const ac = new AbortController()

this[kSignal] = ac.signal

this[kSignal][kRealm] = this[kRealm]

}

} catch {}

signal.addEventListener('abort', abort, { once: true })

util.addAbortListener(signal, abort)

requestFinalizer.register(ac, { signal, abort })

}

}

if (this.signal.aborted) {

ac.abort(this.signal.reason)

} else {

this.signal.addEventListener(

'abort',

util.addAbortListener(

this.signal,

() => {

ac.abort(this.signal.reason)

},

{ once: true }

}

)

}

clonedRequestObject[kSignal] = ac.signal