snapreq 0.0.4 → 0.0.5

package/src/response.js

@@ -1,197 +0,0 @@
-// @ts-check
-
-import SnapReqHeaders from "./headers.js"
-
-/**
- * Concatenates a list of byte chunks into a single `Uint8Array`.
- * @param {Uint8Array[]} chunks - Byte chunks in order.
- * @returns {Uint8Array} - The concatenated bytes.
- */
-function concatChunks(chunks) {
-  let total = 0
-
-  for (const chunk of chunks) total += chunk.byteLength
-
-  const result = new Uint8Array(total)
-  let offset = 0
-
-  for (const chunk of chunks) {
-    result.set(chunk, offset)
-    offset += chunk.byteLength
-  }
-
-  return result
-}
-
-/**
- * A platform-agnostic response. Transports build it with either a fully-read
- * body (`bytes`) or a `stream` (an async iterable of `Uint8Array`) that the
- * read helpers buffer on first use. The body can be read exactly once as a
- * stream; the buffering helpers may be called repeatedly because they cache.
- */
-export default class SnapReqResponse {
-  /**
-   * @param {object} options - Response data.
-   * @param {string} options.url - Fully resolved request URL.
-   * @param {string} options.method - HTTP method used for the request.
-   * @param {number} options.status - HTTP status code.
-   * @param {string} [options.statusText] - HTTP status text.
-   * @param {SnapReqHeaders} [options.headers] - Response headers.
-   * @param {Uint8Array} [options.bytes] - Fully-read body, when the transport already buffered it.
-   * @param {AsyncIterable<Uint8Array>} [options.stream] - Streamed body, when the transport supports streaming.
-   * @param {import("node:stream").Readable} [options.nodeStream] - Raw Node stream, when available, for advanced consumers.
-   * @param {() => void} [options.onBodyDone] - Callback fired when body reading finishes or fails.
-   * @param {(error: unknown) => unknown} [options.mapBodyError] - Maps body read errors before rethrowing.
-   */
-  constructor({url, method, status, statusText = "", headers, bytes, stream, nodeStream, onBodyDone, mapBodyError}) {
-    this.url = url
-    this.method = method
-    this.status = status
-    this.statusText = statusText
-    this.headers = headers || new SnapReqHeaders()
-    /** @type {Uint8Array | null} */
-    this._bytes = bytes ?? null
-    /** @type {AsyncIterable<Uint8Array> | null} */
-    this._stream = stream ?? null
-    /** @type {import("node:stream").Readable | undefined} */
-    this.nodeStream = nodeStream
-    this._streamConsumed = false
-    this._bodyDone = false
-    this._onBodyDone = onBodyDone
-    this._mapBodyError = mapBodyError
-
-    if (bytes !== undefined) this._finishBody()
-  }
-
-  /** @returns {boolean} - Whether the status is in the 2xx range. */
-  get ok() {
-    return this.status >= 200 && this.status < 300
-  }
-
-  /**
-   * Returns the response body as an async iterable of byte chunks. Can only be
-   * called once and only when the transport provided a stream.
-   * @returns {AsyncIterable<Uint8Array>} - The streamed body.
-   */
-  stream() {
-    if (!this._stream) {
-      throw new Error("This response has no readable stream (the body was already buffered by the transport).")
-    }
-
-    if (this._streamConsumed) {
-      throw new Error("This response stream has already been consumed.")
-    }
-
-    this._streamConsumed = true
-
-    return this._wrappedStream(this._stream)
-  }
-
-  /** @returns {boolean} - Whether the body is available as a stream that has not been read yet. */
-  get streamable() {
-    return Boolean(this._stream) && !this._streamConsumed
-  }
-
-  /**
-   * Reads the whole body into a `Uint8Array`, buffering the stream if needed.
-   * @returns {Promise<Uint8Array>} - The full response body.
-   */
-  async bytes() {
-    if (this._bytes) return this._bytes
-
-    if (!this._stream) {
-      this._bytes = new Uint8Array(0)
-      this._finishBody()
-
-      return this._bytes
-    }
-
-    /** @type {Uint8Array[]} */
-    const chunks = []
-
-    for await (const chunk of this.stream()) {
-      chunks.push(chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk))
-    }
-
-    this._bytes = concatChunks(chunks)
-
-    return this._bytes
-  }
-
-  /**
-   * Reads the whole body as a Node `Buffer`. Node-only convenience; throws when
-   * the `Buffer` global is unavailable.
-   * @returns {Promise<Buffer>} - The full response body as a Buffer.
-   */
-  async buffer() {
-    if (typeof Buffer === "undefined") {
-      throw new Error("Buffer is not available on this platform; use bytes() instead.")
-    }
-
-    const bytes = await this.bytes()
-
-    return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength)
-  }
-
-  /**
-   * Reads the whole body and decodes it as a UTF-8 string.
-   * @returns {Promise<string>} - The decoded response body.
-   */
-  async text() {
-    const bytes = await this.bytes()
-
-    return new TextDecoder("utf-8").decode(bytes)
-  }
-
-  /**
-   * Reads the whole body and parses it as JSON. Returns `null` for an empty
-   * body.
-   * @returns {Promise<any>} - The parsed JSON body.
-   */
-  async json() {
-    const text = await this.text()
-
-    if (!text) return null
-
-    return JSON.parse(text)
-  }
-
-  /**
-   * @param {AsyncIterable<Uint8Array>} source - Source response stream.
-   * @returns {AsyncIterable<Uint8Array>} - Stream with cleanup/error mapping.
-   */
-  _wrappedStream(source) {
-    const response = this
-
-    return (async function* () {
-      try {
-        for await (const chunk of source) {
-          yield chunk
-        }
-      } catch (error) {
-        throw response._mappedBodyError(error)
-      } finally {
-        response._finishBody()
-      }
-    })()
-  }
-
-  /**
-   * @param {unknown} error - Body read error.
-   * @returns {unknown} - Error to rethrow.
-   */
-  _mappedBodyError(error) {
-    if (this._mapBodyError) return this._mapBodyError(error)
-
-    return error
-  }
-
-  /** @returns {void} */
-  _finishBody() {
-    if (this._bodyDone) return
-
-    this._bodyDone = true
-
-    if (this._onBodyDone) this._onBodyDone()
-  }
-}

package/src/retry.js

@@ -1,107 +0,0 @@
-// @ts-check
-
-import {SnapReqHttpError, SnapReqTimeoutError} from "./errors.js"
-
-const RETRYABLE_ERROR_CODES = new Set(["ECONNREFUSED", "ECONNRESET", "EHOSTUNREACH", "ENOENT", "ETIMEDOUT", "EPIPE"])
-const DEFAULT_RETRYABLE_STATUSES = [502, 503, 504]
-
-/**
- * @typedef {object} RetryOptions
- * @property {number} [tries] - Maximum number of attempts. Defaults to 3.
- * @property {number} [waitMs] - Delay between attempts in milliseconds. Defaults to 500.
- * @property {number[]} [retryableStatuses] - HTTP status codes that should be retried. Defaults to 502/503/504.
- * @property {(error: unknown, attempt: number) => boolean} [shouldRetry] - Override the retryable-error classifier.
- */
-
-/**
- * @typedef {object} NormalizedRetryOptions
- * @property {number} tries - Maximum number of attempts.
- * @property {number} waitMs - Delay between attempts in milliseconds.
- * @property {number[]} retryableStatuses - HTTP status codes that should be retried.
- * @property {(error: unknown, attempt: number) => boolean} shouldRetry - Retryable-error classifier.
- */
-
-/**
- * The default network-error classifier. Exposed so callers can compose extra
- * rules on top of it (for example matching server-specific 500 messages).
- * @param {unknown} error - Error thrown by a transport.
- * @returns {boolean} - Whether the error is a transient network failure.
- */
-export function defaultRetryableError(error) {
-  if (error instanceof SnapReqTimeoutError) return true
-
-  if (!error || typeof error !== "object") return false
-
-  if ("code" in error && typeof error.code === "string" && RETRYABLE_ERROR_CODES.has(error.code)) {
-    return true
-  }
-
-  return error instanceof Error && error.message === "socket hang up"
-}
-
-/**
- * Normalizes the `retry` option into a complete set of retry settings, or
- * `null` when retries are disabled.
- * @param {boolean | RetryOptions | undefined} retry - Retry configuration.
- * @returns {NormalizedRetryOptions | null} - Normalized retry settings.
- */
-export function normalizeRetryOptions(retry) {
-  if (!retry) return null
-
-  const options = retry === true ? {} : retry
-  const retryableStatuses = options.retryableStatuses ?? DEFAULT_RETRYABLE_STATUSES
-  const shouldRetry = options.shouldRetry ?? ((/** @type {unknown} */ error) => defaultRetryableError(error))
-
-  return {
-    tries: options.tries ?? 3,
-    waitMs: options.waitMs ?? 500,
-    retryableStatuses,
-    shouldRetry
-  }
-}
-
-/**
- * @param {number} waitMs - Delay in milliseconds.
- * @returns {Promise<void>} - Resolves after the delay.
- */
-function wait(waitMs) {
-  return new Promise((resolve) => setTimeout(resolve, waitMs))
-}
-
-/**
- * Runs a request attempt, retrying transient network errors and retryable HTTP
- * statuses. Retries are only used for buffered requests — the caller must not
- * apply this to streamed responses.
- * @param {() => Promise<import("./response.js").default>} attempt - Performs one request attempt.
- * @param {NormalizedRetryOptions} retry - Normalized retry settings.
- * @returns {Promise<import("./response.js").default>} - The successful (or final) response.
- */
-export async function runWithRetry(attempt, retry) {
-  for (let tryNumber = 1; tryNumber <= retry.tries; tryNumber += 1) {
-    /** @type {import("./response.js").default} */
-    let response
-
-    try {
-      response = await attempt()
-    } catch (error) {
-      if (tryNumber >= retry.tries || !retry.shouldRetry(error, tryNumber)) throw error
-
-      await wait(retry.waitMs)
-      continue
-    }
-
-    if (tryNumber < retry.tries && retry.retryableStatuses.includes(response.status)) {
-      await wait(retry.waitMs)
-      continue
-    }
-
-    return response
-  }
-
-  throw new SnapReqHttpError({
-    message: "Retry loop exited without a response.",
-    method: "",
-    url: "",
-    status: 0
-  })
-}

package/src/snap-req.js

@@ -1,390 +0,0 @@
-// @ts-check
-
-import {SnapReqHttpError, SnapReqTimeoutError, SnapReqUnsupportedFeatureError} from "./errors.js"
-import SnapReqHeaders from "./headers.js"
-import {buildUrl, normalizeBody} from "./request.js"
-import {normalizeRetryOptions, runWithRetry} from "./retry.js"
-import {selectTransport} from "./transports/select.js"
-
-/**
- * @typedef {import("./request.js").CompressionEncoding} CompressionEncoding
- */
-
-/**
- * @typedef {object} NormalizedRequest
- * @property {string} method - Upper-cased HTTP method.
- * @property {string} url - Fully resolved request URL.
- * @property {SnapReqHeaders} headers - Request headers.
- * @property {import("./request.js").NormalizedBody} body - Normalized request body.
- * @property {CompressionEncoding} bodyCompression - Request body compression.
- * @property {AbortSignal} [signal] - Abort signal.
- * @property {number} [timeoutMs] - Request timeout in milliseconds.
- * @property {string} [credentials] - Fetch credentials mode ("omit" | "same-origin" | "include").
- */
-
-/**
- * @typedef {object} RequestOptions
- * @property {string} [method] - HTTP method. Defaults to GET.
- * @property {string} [path] - Request path (joined with the client `baseUrl`) or absolute URL.
- * @property {string} [url] - Alias for `path`.
- * @property {Record<string, string | number | boolean | null | undefined>} [query] - Query parameters.
- * @property {Record<string, string | number> | SnapReqHeaders} [headers] - Per-request headers.
- * @property {any} [body] - Request body: string, object (JSON), Uint8Array/ArrayBuffer, or a stream/async-iterable.
- * @property {CompressionEncoding} [bodyCompression] - Compress the request body (Node transport only).
- * @property {AbortSignal} [signal] - Abort signal for the request.
- * @property {number} [timeoutMs] - Request timeout in milliseconds. Set to `0` to disable a client default.
- * @property {string} [credentials] - Fetch credentials mode.
- * @property {boolean | import("./retry.js").RetryOptions} [retry] - Retry transient failures.
- * @property {boolean} [throwOnError] - Throw `SnapReqHttpError` on non-2xx responses.
- */
-
-/**
- * @typedef {object} RequestTimeout
- * @property {AbortSignal | undefined} signal - Signal to use for the request.
- * @property {() => void} clear - Clears timeout resources.
- * @property {(response: import("./response.js").default, request: NormalizedRequest) => import("./response.js").default} response - Attaches timeout handling to a response.
- * @property {(error: unknown, request: NormalizedRequest) => unknown} error - Maps a thrown error.
- */
-
-/**
- * A cross-platform HTTP client with one API across Node, web, Expo and React
- * Native. The right transport is chosen at runtime; features a platform cannot
- * provide raise `SnapReqUnsupportedFeatureError` rather than silently changing
- * behaviour.
- */
-export default class SnapReq {
-  /**
-   * @param {object} [config] - Client configuration.
-   * @param {string} [config.baseUrl] - Origin (and optional base path) prepended to relative paths.
-   * @param {string} [config.socketPath] - Unix domain socket path (Node transport only).
-   * @param {{ca?: string | Buffer, cert?: string | Buffer, key?: string | Buffer, rejectUnauthorized?: boolean}} [config.tls] - TLS material (Node transport only).
-   * @param {boolean} [config.keepAlive] - Reuse connections across requests (Node transport only). Defaults to true.
-   * @param {Record<string, string | number> | (() => Record<string, string | number>)} [config.headers] - Default headers (object or factory).
-   * @param {boolean | import("./retry.js").RetryOptions} [config.retry] - Default retry policy.
-   * @param {boolean} [config.throwOnError] - Throw `SnapReqHttpError` on non-2xx responses by default. Defaults to false.
-   * @param {number} [config.timeoutMs] - Default request timeout in milliseconds. Set per-request `timeoutMs: 0` to disable.
-   * @param {string} [config.credentials] - Default fetch credentials mode.
-   * @param {import("./transports/select.js").TransportName | import("./transports/select.js").Transport} [config.transport] - Transport preference or instance. Defaults to "auto".
-   */
-  constructor({baseUrl, socketPath, tls, keepAlive = true, headers, retry, throwOnError = false, timeoutMs, credentials, transport = "auto"} = {}) {
-    this.baseUrl = baseUrl
-    this.defaultHeaders = headers
-    this.defaultRetry = retry
-    this.throwOnError = throwOnError
-    this.timeoutMs = timeoutMs
-    this.credentials = credentials
-    this._transportPreference = transport
-    this._nodeConfig = {socketPath, tls, keepAlive}
-    /** @type {Promise<import("./transports/select.js").Transport> | null} */
-    this._transportPromise = null
-    /** @type {import("./transports/select.js").Transport | null} */
-    this._transport = null
-  }
-
-  /** @returns {Promise<import("./transports/select.js").Transport>} - The resolved transport. */
-  async _resolveTransport() {
-    this._transportPromise ||= selectTransport(this._transportPreference, this._nodeConfig)
-    this._transport = await this._transportPromise
-
-    return this._transport
-  }
-
-  /** @returns {Promise<import("./capabilities.js").TransportCapabilities>} - The active transport's capabilities. */
-  async capabilities() {
-    return (await this._resolveTransport()).capabilities
-  }
-
-  /** @returns {Promise<string>} - The active transport's name. */
-  async transportName() {
-    const transport = await this._resolveTransport()
-
-    return /** @type {any} */ (transport.constructor)?.transportName || "custom"
-  }
-
-  /**
-   * @param {RequestOptions} options - Request options.
-   * @returns {NormalizedRequest} - The normalized request.
-   */
-  _normalize(options) {
-    const headers = new SnapReqHeaders()
-    const defaults = typeof this.defaultHeaders === "function" ? this.defaultHeaders() : this.defaultHeaders
-
-    if (defaults) for (const [name, value] of new SnapReqHeaders(defaults).entries()) headers.set(name, value)
-    if (options.headers) for (const [name, value] of new SnapReqHeaders(options.headers).entries()) headers.set(name, value)
-
-    const url = buildUrl(this.baseUrl, options.path ?? options.url ?? "", options.query)
-    const body = normalizeBody(options.body, headers)
-
-    return {
-      method: (options.method || "GET").toUpperCase(),
-      url,
-      headers,
-      body,
-      bodyCompression: options.bodyCompression || "identity",
-      signal: options.signal,
-      timeoutMs: options.timeoutMs ?? this.timeoutMs,
-      credentials: options.credentials ?? this.credentials
-    }
-  }
-
-  /**
-   * @param {RequestOptions} options - Request options.
-   * @returns {RequestTimeout} - Timeout handling for one request attempt.
-   */
-  _requestTimeout(options) {
-    const timeoutMs = options.timeoutMs ?? this.timeoutMs
-
-    if (!timeoutMs || timeoutMs <= 0) {
-      return {
-        signal: options.signal,
-        clear: () => {},
-        response: (response) => response,
-        error: (error) => error
-      }
-    }
-
-    const timeoutController = new AbortController()
-    const composedSignal = this._composeSignal(options.signal, timeoutController.signal)
-    let timedOut = false
-    const timer = setTimeout(() => {
-      timedOut = true
-      timeoutController.abort()
-    }, timeoutMs)
-
-    if (typeof timer.unref === "function") timer.unref()
-
-    const clear = () => {
-      clearTimeout(timer)
-      composedSignal.clear()
-    }
-    const toError = (error, request) => {
-      if (timedOut) {
-        return new SnapReqTimeoutError({
-          method: request.method,
-          url: request.url,
-          timeoutMs
-        })
-      }
-
-      return error
-    }
-
-    return {
-      signal: composedSignal.signal,
-      clear,
-      response: (response, request) => {
-        if (response._bodyDone) {
-          clear()
-
-          return response
-        }
-
-        response._onBodyDone = this._chainBodyDone(response._onBodyDone, clear)
-        response._mapBodyError = this._chainBodyError(response._mapBodyError, (error) => toError(error, request))
-
-        return response
-      },
-      error: toError
-    }
-  }
-
-  /**
-   * @param {AbortSignal | undefined} callerSignal - Caller-supplied signal.
-   * @param {AbortSignal} timeoutSignal - Timeout signal.
-   * @returns {{signal: AbortSignal, clear: () => void}} - Signal that aborts when either source aborts.
-   */
-  _composeSignal(callerSignal, timeoutSignal) {
-    if (!callerSignal) return {signal: timeoutSignal, clear: () => {}}
-
-    const controller = new AbortController()
-    const abort = () => controller.abort()
-
-    if (callerSignal.aborted || timeoutSignal.aborted) {
-      controller.abort()
-    } else {
-      callerSignal.addEventListener("abort", abort, {once: true})
-      timeoutSignal.addEventListener("abort", abort, {once: true})
-    }
-
-    return {
-      signal: controller.signal,
-      clear: () => {
-        callerSignal.removeEventListener("abort", abort)
-        timeoutSignal.removeEventListener("abort", abort)
-      }
-    }
-  }
-
-  /**
-   * @param {(() => void) | undefined} existing - Existing body-done callback.
-   * @param {() => void} next - Callback to add.
-   * @returns {() => void} - Combined callback.
-   */
-  _chainBodyDone(existing, next) {
-    return () => {
-      if (existing) existing()
-      next()
-    }
-  }
-
-  /**
-   * @param {((error: unknown) => unknown) | undefined} existing - Existing error mapper.
-   * @param {(error: unknown) => unknown} next - Mapper to add.
-   * @returns {(error: unknown) => unknown} - Combined mapper.
-   */
-  _chainBodyError(existing, next) {
-    return (error) => next(existing ? existing(error) : error)
-  }
-
-  /**
-   * Performs a request and buffers nothing eagerly — read the body via the
-   * returned response (`json()`, `text()`, `bytes()`). Retries transient
-   * failures when a retry policy is configured (never for streamed bodies).
-   * @param {RequestOptions} options - Request options.
-   * @returns {Promise<import("./response.js").default>} - The response.
-   */
-  async request(options) {
-    const transport = await this._resolveTransport()
-    const throwOnError = options.throwOnError ?? this.throwOnError
-    const retry = normalizeRetryOptions(options.retry ?? this.defaultRetry)
-    const body = normalizeBody(options.body, new SnapReqHeaders(options.headers))
-    const canRetry = retry && body.kind !== "stream"
-    const attempt = async () => this._requestWithTimeout(options, (request) => transport.performRequest(request))
-    const response = canRetry ? await runWithRetry(attempt, /** @type {any} */ (retry)) : await attempt()
-
-    if (throwOnError && !response.ok) throw await this._httpError(response, this._normalize(options))
-
-    return response
-  }
-
-  /**
-   * Performs a request and returns the response with its body available as a
-   * stream (`response.stream()`). Requires a transport that supports response
-   * streaming; never retries.
-   * @param {RequestOptions} options - Request options.
-   * @returns {Promise<import("./response.js").default>} - The streaming response.
-   */
-  async requestStream(options) {
-    const transport = await this._resolveTransport()
-
-    if (!transport.capabilities.responseStreaming) {
-      throw new SnapReqUnsupportedFeatureError({
-        feature: "response streaming",
-        transport: /** @type {any} */ (transport.constructor)?.transportName || "custom"
-      })
-    }
-
-    const response = await this._requestWithTimeout(options, (request) => transport.performRequest(request))
-
-    if ((options.throwOnError ?? this.throwOnError) && !response.ok) {
-      throw await this._httpError(response, this._normalize(options))
-    }
-
-    return response
-  }
-
-  /**
-   * @param {RequestOptions} options - Request options.
-   * @param {(request: NormalizedRequest) => Promise<import("./response.js").default>} performRequest - Transport request runner.
-   * @returns {Promise<import("./response.js").default>} - Response with timeout handling attached.
-   */
-  async _requestWithTimeout(options, performRequest) {
-    const timeout = this._requestTimeout(options)
-    const normalized = this._normalize({...options, signal: timeout.signal})
-
-    try {
-      const response = await performRequest(normalized)
-
-      return timeout.response(response, normalized)
-    } catch (error) {
-      timeout.clear()
-
-      throw timeout.error(error, normalized)
-    }
-  }
-
-  /**
-   * @param {string} path - Request path or absolute URL.
-   * @param {RequestOptions} [options] - Request options.
-   * @returns {Promise<import("./response.js").default>} - The response.
-   */
-  get(path, options = {}) {
-    return this.request({...options, method: "GET", path})
-  }
-
-  /**
-   * @param {string} path - Request path or absolute URL.
-   * @param {any} [body] - Request body.
-   * @param {RequestOptions} [options] - Request options.
-   * @returns {Promise<import("./response.js").default>} - The response.
-   */
-  post(path, body, options = {}) {
-    return this.request({...options, method: "POST", path, body})
-  }
-
-  /**
-   * @param {string} path - Request path or absolute URL.
-   * @param {any} [body] - Request body.
-   * @param {RequestOptions} [options] - Request options.
-   * @returns {Promise<import("./response.js").default>} - The response.
-   */
-  put(path, body, options = {}) {
-    return this.request({...options, method: "PUT", path, body})
-  }
-
-  /**
-   * @param {string} path - Request path or absolute URL.
-   * @param {any} [body] - Request body.
-   * @param {RequestOptions} [options] - Request options.
-   * @returns {Promise<import("./response.js").default>} - The response.
-   */
-  patch(path, body, options = {}) {
-    return this.request({...options, method: "PATCH", path, body})
-  }
-
-  /**
-   * @param {string} path - Request path or absolute URL.
-   * @param {RequestOptions} [options] - Request options.
-   * @returns {Promise<import("./response.js").default>} - The response.
-   */
-  delete(path, options = {}) {
-    return this.request({...options, method: "DELETE", path})
-  }
-
-  /**
-   * @param {import("./response.js").default} response - The failed response.
-   * @param {NormalizedRequest} request - The request that produced it.
-   * @returns {Promise<SnapReqHttpError>} - An error describing the failure.
-   */
-  async _httpError(response, request) {
-    let responseText = ""
-
-    try {
-      responseText = await response.text()
-    } catch (error) {
-      if (error instanceof SnapReqTimeoutError) throw error
-
-      // Body unavailable (already streamed or read error) — fall back to status text.
-    }
-
-    const detail = responseText || response.statusText || ""
-
-    return new SnapReqHttpError({
-      message: `HTTP ${response.status} ${request.method} ${request.url}${detail ? `: ${detail}` : ""}`,
-      method: request.method,
-      url: request.url,
-      status: response.status,
-      statusText: response.statusText,
-      responseText,
-      response
-    })
-  }
-
-  /**
-   * Releases transport resources (for example Node keep-alive sockets).
-   * @returns {void}
-   */
-  close() {
-    this._transport?.close?.()
-  }
-}