snapreq 0.0.3 → 0.0.5

package/README.md

@@ -63,6 +63,7 @@ new SnapReq({
   headers,        // default headers — object or a factory `() => ({...})` for dynamic auth
   retry,          // default retry policy (see below)
   throwOnError,   // throw SnapReqHttpError on non-2xx (default false)
+  timeoutMs,      // default request/body timeout in milliseconds; per-request 0 disables it
   credentials,    // fetch credentials mode: "omit" | "same-origin" | "include"
   transport,      // "auto" (default) | "node" | "fetch" | "xhr" | a transport instance
 
@@ -73,6 +74,17 @@ new SnapReq({
 })
 ```
 
+### Timeouts
+
+Set `timeoutMs` on the client or a single request to abort stalled requests. The timeout covers the response headers and body reads through `json()`, `text()`, `bytes()`, `buffer()`, or `stream()`. A timed-out request rejects with `SnapReqTimeoutError`.
+
+```js
+const client = new SnapReq({baseUrl: "https://api.example.com", timeoutMs: 120000})
+
+await client.get("/slow", {timeoutMs: 5000})
+await client.get("/long-running", {timeoutMs: 0}) // disable the client default for this call
+```
+
 ### Retry
 
 Retries transient network errors and retryable HTTP statuses (502/503/504 by default). Only applies to buffered requests — never to streamed bodies.

package/{types → build}/capabilities.d.ts

@@ -45,3 +45,4 @@ export type TransportCapabilities = {
      */
     abort: boolean;
 };
+//# sourceMappingURL=capabilities.d.ts.map

package/build/capabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../src/capabilities.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AAEH;;;;;GAKG;AACH,6CAHW,OAAO,CAAC,qBAAqB,CAAC,GAC5B,qBAAqB,CAajC;;;;;gBA1Ba,OAAO;;;;mBACP,OAAO;;;;wBACP,OAAO;;;;uBACP,OAAO;;;;sBACP,OAAO;;;;eACP,OAAO;;;;WACP,OAAO"}

package/{src → build}/capabilities.js

@@ -1,5 +1,4 @@
 // @ts-check
-
 /**
  * @typedef {object} TransportCapabilities
  * @property {boolean} unixSocket - Connect over a Unix domain socket.
@@ -10,7 +9,6 @@
  * @property {boolean} keepAlive - Reuse connections across requests (HTTP keep-alive).
  * @property {boolean} abort - Cancel an in-flight request via an `AbortSignal`.
  */
-
 /**
  * Builds a fully-populated capability object so callers can read every flag
  * without undefined checks.
@@ -18,14 +16,15 @@
  * @returns {TransportCapabilities} - Complete capability flags.
  */
 export function buildCapabilities(overrides) {
-  return {
-    unixSocket: false,
-    tlsClientCert: false,
-    requestCompression: false,
-    responseStreaming: false,
-    requestStreaming: false,
-    keepAlive: false,
-    abort: false,
-    ...overrides
-  }
+    return {
+        unixSocket: false,
+        tlsClientCert: false,
+        requestCompression: false,
+        responseStreaming: false,
+        requestStreaming: false,
+        keepAlive: false,
+        abort: false,
+        ...overrides
+    };
 }
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FwYWJpbGl0aWVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2NhcGFiaWxpdGllcy5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxZQUFZO0FBRVo7Ozs7Ozs7OztHQVNHO0FBRUg7Ozs7O0dBS0c7QUFDSCxNQUFNLFVBQVUsaUJBQWlCLENBQUMsU0FBUztJQUN6QyxPQUFPO1FBQ0wsVUFBVSxFQUFFLEtBQUs7UUFDakIsYUFBYSxFQUFFLEtBQUs7UUFDcEIsa0JBQWtCLEVBQUUsS0FBSztRQUN6QixpQkFBaUIsRUFBRSxLQUFLO1FBQ3hCLGdCQUFnQixFQUFFLEtBQUs7UUFDdkIsU0FBUyxFQUFFLEtBQUs7UUFDaEIsS0FBSyxFQUFFLEtBQUs7UUFDWixHQUFHLFNBQVM7S0FDYixDQUFBO0FBQ0gsQ0FBQyJ9

package/{types → build}/errors.d.ts

@@ -62,3 +62,21 @@ export class SnapReqAbortError extends SnapReqError {
     /** @param {string} [message] - Human readable description. */
     constructor(message?: string);
 }
+/** Thrown when a request exceeds its configured timeout. */
+export class SnapReqTimeoutError extends SnapReqError {
+    /**
+     * @param {object} options - Error metadata.
+     * @param {string} options.method - HTTP method used for the request.
+     * @param {string} options.url - Fully resolved request URL.
+     * @param {number} options.timeoutMs - Timeout in milliseconds.
+     */
+    constructor({ method, url, timeoutMs }: {
+        method: string;
+        url: string;
+        timeoutMs: number;
+    });
+    method: string;
+    url: string;
+    timeoutMs: number;
+}
+//# sourceMappingURL=errors.d.ts.map

package/build/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.js"],"names":[],"mappings":"AAEA,oDAAoD;AACpD;IACE,4DAA4D;IAC5D,qBADY,MAAM,EAIjB;CACF;AAED;;;;;GAKG;AACH;IACE;;;;;;;;;OASG;IACH,kFARG;QAAwB,OAAO,EAAvB,MAAM;QACU,MAAM,EAAtB,MAAM;QACU,GAAG,EAAnB,MAAM;QACU,MAAM,EAAtB,MAAM;QACW,UAAU,GAA3B,MAAM;QACW,YAAY,GAA7B,MAAM;QACoC,QAAQ,GAAlD,OAAO,eAAe,EAAE,OAAO;KACzC,EAUA;IANC,eAAoB;IACpB,YAAc;IACd,eAAoB;IACpB,mBAA4B;IAC5B,qBAAgC;IAChC,0CAAwB;CAE3B;AAED;;;;;GAKG;AACH;IACE;;;;;OAKG;IACH,4CAJG;QAAwB,OAAO,EAAvB,MAAM;QACU,SAAS,EAAzB,MAAM;QACW,MAAM,GAAvB,MAAM;KAChB,EAMA;IAFC,gBAAsB;IACtB,kBAA0B;CAE7B;AAED,6DAA6D;AAC7D;IACE,8DAA8D;IAC9D,sBADY,MAAM,EAIjB;CACF;AAED,4DAA4D;AAC5D;IACE;;;;;OAKG;IACH,wCAJG;QAAwB,MAAM,EAAtB,MAAM;QACU,GAAG,EAAnB,MAAM;QACU,SAAS,EAAzB,MAAM;KAChB,EAOA;IAHC,eAAoB;IACpB,YAAc;IACd,kBAA0B;CAE7B"}

package/build/errors.js

@@ -0,0 +1,82 @@
+// @ts-check
+/** Base class for every error thrown by snapreq. */
+export class SnapReqError extends Error {
+    /** @param {string} message - Human readable description. */
+    constructor(message) {
+        super(message);
+        this.name = "SnapReqError";
+    }
+}
+/**
+ * Thrown when a request completes with a non-2xx status and the caller asked
+ * snapreq to treat error statuses as failures (`throwOnError`, the default for
+ * the high-level helpers). Carries enough metadata to build a friendly message
+ * without re-reading the response.
+ */
+export class SnapReqHttpError extends SnapReqError {
+    /**
+     * @param {object} options - Error metadata.
+     * @param {string} options.message - Human readable description.
+     * @param {string} options.method - HTTP method used for the request.
+     * @param {string} options.url - Fully resolved request URL.
+     * @param {number} options.status - HTTP status code returned by the server.
+     * @param {string} [options.statusText] - HTTP status text returned by the server.
+     * @param {string} [options.responseText] - Decoded response body, when available.
+     * @param {import("./response.js").default} [options.response] - The response that failed.
+     */
+    constructor({ message, method, url, status, statusText, responseText, response }) {
+        super(message);
+        this.name = "SnapReqHttpError";
+        this.method = method;
+        this.url = url;
+        this.status = status;
+        this.statusText = statusText;
+        this.responseText = responseText;
+        this.response = response;
+    }
+}
+/**
+ * Thrown when a request asks for a capability the active transport cannot
+ * provide on the current platform (for example a Unix socket or request-body
+ * compression in a browser). The API stays identical across platforms; this
+ * error is how snapreq tells you a specific feature had to be left out.
+ */
+export class SnapReqUnsupportedFeatureError extends SnapReqError {
+    /**
+     * @param {object} options - Error metadata.
+     * @param {string} options.feature - The capability that is not supported.
+     * @param {string} options.transport - Name of the active transport.
+     * @param {string} [options.detail] - Optional extra context.
+     */
+    constructor({ feature, transport, detail }) {
+        super(`The "${transport}" transport does not support ${feature}${detail ? `: ${detail}` : ""}.`);
+        this.name = "SnapReqUnsupportedFeatureError";
+        this.feature = feature;
+        this.transport = transport;
+    }
+}
+/** Thrown when a request is aborted via an `AbortSignal`. */
+export class SnapReqAbortError extends SnapReqError {
+    /** @param {string} [message] - Human readable description. */
+    constructor(message = "Request aborted.") {
+        super(message);
+        this.name = "SnapReqAbortError";
+    }
+}
+/** Thrown when a request exceeds its configured timeout. */
+export class SnapReqTimeoutError extends SnapReqError {
+    /**
+     * @param {object} options - Error metadata.
+     * @param {string} options.method - HTTP method used for the request.
+     * @param {string} options.url - Fully resolved request URL.
+     * @param {number} options.timeoutMs - Timeout in milliseconds.
+     */
+    constructor({ method, url, timeoutMs }) {
+        super(`Request timed out after ${timeoutMs}ms: ${method} ${url}`);
+        this.name = "SnapReqTimeoutError";
+        this.method = method;
+        this.url = url;
+        this.timeoutMs = timeoutMs;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/{types → build}/headers.d.ts

@@ -48,3 +48,4 @@ export default class SnapReqHeaders {
      */
     toObject(): Record<string, string>;
 }
+//# sourceMappingURL=headers.d.ts.map

package/build/headers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"headers.d.ts","sourceRoot":"","sources":["../src/headers.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH;IACE;;OAEG;IACH,mBAFW,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,CAAC,GAAG,cAAc,GAAG,QAAQ,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAqBlG;IAlBC,sFAAsF;IACtF,MADW,GAAG,CAAC,MAAM,EAAE;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC,CAAC,CAChC;IAmBvB;;;;OAIG;IACH,UAJW,MAAM,SACN,MAAM,GAAG,MAAM,GACb,IAAI,CAIhB;IAED;;;OAGG;IACH,UAHW,MAAM,GACJ,MAAM,GAAG,IAAI,CAIzB;IAED;;;OAGG;IACH,UAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,aAHW,MAAM,GACJ,IAAI,CAIhB;IAED;;;OAGG;IACH,WAFa,gBAAgB,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAI9C;IAED,mFAAmF;IACnF,WADc,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAG/B;IAED;;;;OAIG;IACH,YAFa,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CASlC;CACF"}

package/build/headers.js

@@ -0,0 +1,89 @@
+// @ts-check
+/**
+ * A tiny case-insensitive header bag. Works the same on every platform and
+ * avoids depending on the DOM `Headers` global (absent in some runtimes) or on
+ * Node's header handling. Header values are always stored as strings.
+ */
+export default class SnapReqHeaders {
+    /**
+     * @param {Record<string, string | number | string[]> | SnapReqHeaders | Iterable<[string, string]>} [init] - Initial headers.
+     */
+    constructor(init) {
+        /** @type {Map<string, {name: string, value: string}>} - Keyed by lower-cased name. */
+        this._map = new Map();
+        if (!init)
+            return;
+        if (init instanceof SnapReqHeaders) {
+            for (const [name, value] of init.entries())
+                this.set(name, value);
+        }
+        else if (typeof ( /** @type {any} */(init)[Symbol.iterator]) === "function") {
+            for (const [name, value] of /** @type {Iterable<[string, string]>} */ (init))
+                this.set(name, value);
+        }
+        else {
+            for (const [name, value] of Object.entries(init)) {
+                if (Array.isArray(value)) {
+                    this.set(name, value.join(", "));
+                }
+                else if (value !== undefined && value !== null) {
+                    this.set(name, String(value));
+                }
+            }
+        }
+    }
+    /**
+     * @param {string} name - Header name (case-insensitive).
+     * @param {string | number} value - Header value.
+     * @returns {void}
+     */
+    set(name, value) {
+        this._map.set(name.toLowerCase(), { name, value: String(value) });
+    }
+    /**
+     * @param {string} name - Header name (case-insensitive).
+     * @returns {string | null} - The header value or null when absent.
+     */
+    get(name) {
+        return this._map.get(name.toLowerCase())?.value ?? null;
+    }
+    /**
+     * @param {string} name - Header name (case-insensitive).
+     * @returns {boolean} - Whether the header is present.
+     */
+    has(name) {
+        return this._map.has(name.toLowerCase());
+    }
+    /**
+     * @param {string} name - Header name (case-insensitive).
+     * @returns {void}
+     */
+    delete(name) {
+        this._map.delete(name.toLowerCase());
+    }
+    /**
+     * @yields {[string, string]} - Name/value pair preserving original casing.
+     * @returns {IterableIterator<[string, string]>} - Name/value pairs preserving original casing.
+     */
+    *entries() {
+        for (const { name, value } of this._map.values())
+            yield [name, value];
+    }
+    /** @returns {[string, string][]} - Name/value pairs preserving original casing. */
+    toArray() {
+        return [...this.entries()];
+    }
+    /**
+     * Plain object form keyed by the original header casing. Suitable for
+     * passing straight to `http.request` or `fetch`.
+     * @returns {Record<string, string>} - Header object.
+     */
+    toObject() {
+        /** @type {Record<string, string>} */
+        const object = {};
+        for (const { name, value } of this._map.values())
+            object[name] = value;
+        return object;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/{types → build}/request.d.ts

@@ -33,3 +33,4 @@ export type NormalizedBody = {
     value: string | Uint8Array | AsyncIterable<Uint8Array> | null;
 };
 import SnapReqHeaders from "./headers.js";
+//# sourceMappingURL=request.d.ts.map

package/build/request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.d.ts","sourceRoot":"","sources":["../src/request.js"],"names":[],"mappings":"AAgBA;;;;;;;GAOG;AACH,kCALW,MAAM,GAAG,SAAS,QAClB,MAAM,SACN,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,CAAC,GAAG,SAAS,GACtE,MAAM,CA2BlB;AAED;;;;GAIG;AACH,mCAHW,OAAO,GACL,OAAO,CAUnB;AAED;;;;;;GAMG;AACH,oCAJW,OAAO,WACP,cAAc,GACZ,cAAc,CAgC1B;kCAlGY,UAAU,GAAG,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,MAAM;;;;;UAK9C,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ;;;;WACpC,MAAM,GAAG,UAAU,GAAG,aAAa,CAAC,UAAU,CAAC,GAAG,IAAI;;2BATzC,cAAc"}

package/build/request.js

@@ -0,0 +1,89 @@
+// @ts-check
+import SnapReqHeaders from "./headers.js";
+/**
+ * @typedef {"identity" | "gzip" | "deflate" | "br" | "zstd"} CompressionEncoding
+ */
+/**
+ * @typedef {object} NormalizedBody
+ * @property {"none" | "text" | "bytes" | "stream"} kind - Shape of the body payload.
+ * @property {string | Uint8Array | AsyncIterable<Uint8Array> | null} value - The payload itself.
+ */
+const ABSOLUTE_URL_REGEX = /^[a-z][a-z0-9+.-]*:\/\//i;
+/**
+ * Joins a base URL and a path and appends query parameters. `path` may be a
+ * fully-qualified URL, in which case the base is ignored.
+ * @param {string | undefined} baseUrl - Origin (and optional base path).
+ * @param {string} path - Path or absolute URL.
+ * @param {Record<string, string | number | boolean | null | undefined> | undefined} query - Query parameters.
+ * @returns {string} - Resolved absolute URL.
+ */
+export function buildUrl(baseUrl, path, query) {
+    /** @type {string} */
+    let resolved;
+    if (ABSOLUTE_URL_REGEX.test(path)) {
+        resolved = path;
+    }
+    else if (baseUrl) {
+        resolved = `${baseUrl.replace(/\/$/, "")}/${path.replace(/^\//, "")}`;
+    }
+    else {
+        resolved = path;
+    }
+    if (!query)
+        return resolved;
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(query)) {
+        if (value !== undefined && value !== null)
+            params.append(key, String(value));
+    }
+    const queryString = params.toString();
+    if (!queryString)
+        return resolved;
+    return resolved.includes("?") ? `${resolved}&${queryString}` : `${resolved}?${queryString}`;
+}
+/**
+ * Determines whether a value should be sent as a streamed request body.
+ * @param {unknown} body - Candidate body value.
+ * @returns {boolean} - Whether the body is a stream.
+ */
+export function isStreamBody(body) {
+    return Boolean(body &&
+        typeof body === "object" &&
+        !(body instanceof Uint8Array) &&
+        !(body instanceof ArrayBuffer) &&
+        (typeof ( /** @type {any} */(body).pipe) === "function" || typeof ( /** @type {any} */(body)[Symbol.asyncIterator]) === "function"));
+}
+/**
+ * Normalizes a user-supplied body into one of a small set of shapes and applies
+ * a default `Content-Type` header when the caller did not set one.
+ * @param {unknown} body - Raw body value.
+ * @param {SnapReqHeaders} headers - Headers to receive a default `Content-Type`.
+ * @returns {NormalizedBody} - Normalized body descriptor.
+ */
+export function normalizeBody(body, headers) {
+    if (body === undefined || body === null) {
+        return { kind: "none", value: null };
+    }
+    if (body instanceof Uint8Array) {
+        if (!headers.has("content-type"))
+            headers.set("Content-Type", "application/octet-stream");
+        return { kind: "bytes", value: body };
+    }
+    if (body instanceof ArrayBuffer) {
+        if (!headers.has("content-type"))
+            headers.set("Content-Type", "application/octet-stream");
+        return { kind: "bytes", value: new Uint8Array(body) };
+    }
+    if (isStreamBody(body)) {
+        if (!headers.has("content-type"))
+            headers.set("Content-Type", "application/octet-stream");
+        return { kind: "stream", value: /** @type {AsyncIterable<Uint8Array>} */ (body) };
+    }
+    if (typeof body === "string") {
+        return { kind: "text", value: body };
+    }
+    if (!headers.has("content-type"))
+        headers.set("Content-Type", "application/json");
+    return { kind: "text", value: JSON.stringify(body) };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/{types → build}/response.d.ts

@@ -15,8 +15,10 @@ export default class SnapReqResponse {
      * @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 }: {
+    constructor({ url, method, status, statusText, headers, bytes, stream, nodeStream, onBodyDone, mapBodyError }: {
         url: string;
         method: string;
         status: number;
@@ -25,6 +27,8 @@ export default class SnapReqResponse {
         bytes?: Uint8Array;
         stream?: AsyncIterable<Uint8Array>;
         nodeStream?: import("node:stream").Readable;
+        onBodyDone?: () => void;
+        mapBodyError?: (error: unknown) => unknown;
     });
     url: string;
     method: string;
@@ -38,6 +42,9 @@ export default class SnapReqResponse {
     /** @type {import("node:stream").Readable | undefined} */
     nodeStream: import("node:stream").Readable | undefined;
     _streamConsumed: boolean;
+    _bodyDone: boolean;
+    _onBodyDone: () => void;
+    _mapBodyError: (error: unknown) => unknown;
     /** @returns {boolean} - Whether the status is in the 2xx range. */
     get ok(): boolean;
     /**
@@ -70,5 +77,18 @@ export default class SnapReqResponse {
      * @returns {Promise<any>} - The parsed JSON body.
      */
     json(): Promise<any>;
+    /**
+     * @param {AsyncIterable<Uint8Array>} source - Source response stream.
+     * @returns {AsyncIterable<Uint8Array>} - Stream with cleanup/error mapping.
+     */
+    _wrappedStream(source: AsyncIterable<Uint8Array>): AsyncIterable<Uint8Array>;
+    /**
+     * @param {unknown} error - Body read error.
+     * @returns {unknown} - Error to rethrow.
+     */
+    _mappedBodyError(error: unknown): unknown;
+    /** @returns {void} */
+    _finishBody(): void;
 }
 import SnapReqHeaders from "./headers.js";
+//# sourceMappingURL=response.d.ts.map

package/build/response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response.d.ts","sourceRoot":"","sources":["../src/response.js"],"names":[],"mappings":"AAyBA;;;;;GAKG;AACH;IACE;;;;;;;;;;;;OAYG;IACH,+GAXG;QAAwB,GAAG,EAAnB,MAAM;QACU,MAAM,EAAtB,MAAM;QACU,MAAM,EAAtB,MAAM;QACW,UAAU,GAA3B,MAAM;QACmB,OAAO,GAAhC,cAAc;QACO,KAAK,GAA1B,UAAU;QAC0B,MAAM,GAA1C,aAAa,CAAC,UAAU,CAAC;QACgB,UAAU,GAAnD,OAAO,aAAa,EAAE,QAAQ;QACT,UAAU,GAA/B,MAAM,IAAI;QAC4B,YAAY,GAAlD,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO;KACrC,EAmBA;IAjBC,YAAc;IACd,eAAoB;IACpB,eAAoB;IACpB,mBAA4B;IAC5B,wBAA8C;IAC9C,gCAAgC;IAChC,QADW,UAAU,GAAG,IAAI,CACD;IAC3B,+CAA+C;IAC/C,SADW,aAAa,CAAC,UAAU,CAAC,GAAG,IAAI,CACd;IAC7B,yDAAyD;IACzD,YADW,OAAO,aAAa,EAAE,QAAQ,GAAG,SAAS,CACzB;IAC5B,yBAA4B;IAC5B,mBAAsB;IACtB,mBAjBe,IAAI,CAiBU;IAC7B,uBAjBiB,OAAO,KAAK,OAAO,CAiBH;IAKnC,mEAAmE;IACnE,UADc,OAAO,CAGpB;IAED;;;;OAIG;IACH,UAFa,aAAa,CAAC,UAAU,CAAC,CAcrC;IAED,iGAAiG;IACjG,kBADc,OAAO,CAGpB;IAED;;;OAGG;IACH,SAFa,OAAO,CAAC,UAAU,CAAC,CAsB/B;IAED;;;;OAIG;IACH,UAFa,OAAO,CAAC,MAAM,CAAC,CAU3B;IAED;;;OAGG;IACH,QAFa,OAAO,CAAC,MAAM,CAAC,CAM3B;IAED;;;;OAIG;IACH,QAFa,OAAO,CAAC,GAAG,CAAC,CAQxB;IAED;;;OAGG;IACH,uBAHW,aAAa,CAAC,UAAU,CAAC,GACvB,aAAa,CAAC,UAAU,CAAC,CAgBrC;IAED;;;OAGG;IACH,wBAHW,OAAO,GACL,OAAO,CAMnB;IAED,sBAAsB;IACtB,eADc,IAAI,CAOjB;CACF;2BAlM0B,cAAc"}

package/build/response.js

@@ -0,0 +1,171 @@
+// @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();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/{types → build}/retry.d.ts

@@ -71,3 +71,4 @@ export type NormalizedRetryOptions = {
      */
     shouldRetry: (error: unknown, attempt: number) => boolean;
 };
+//# sourceMappingURL=retry.d.ts.map

package/build/retry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../src/retry.js"],"names":[],"mappings":"AAOA;;;;;;GAMG;AAEH;;;;;;GAMG;AAEH;;;;;GAKG;AACH,6CAHW,OAAO,GACL,OAAO,CAYnB;AAED;;;;;GAKG;AACH,6CAHW,OAAO,GAAG,YAAY,GAAG,SAAS,GAChC,sBAAsB,GAAG,IAAI,CAezC;AAUD;;;;;;;GAOG;AACH,sCAJW,MAAM,OAAO,CAAC,OAAO,eAAe,EAAE,OAAO,CAAC,SAC9C,sBAAsB,GACpB,OAAO,CAAC,OAAO,eAAe,EAAE,OAAO,CAAC,CA8BpD;;;;;YAjGa,MAAM;;;;aACN,MAAM;;;;wBACN,MAAM,EAAE;;;;kBACR,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO;;;;;;WAK5C,MAAM;;;;YACN,MAAM;;;;uBACN,MAAM,EAAE;;;;iBACR,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO"}