@ahoo-wang/fetcher 2.6.9 → 2.6.12

package/dist/fetchExchange.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fetchExchange.d.ts","sourceRoot":"","sources":["../src/fetchExchange.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAEnE,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,SAAS,CAAC;AAC1C,OAAO,EAAE,eAAe,EAAoB,MAAM,mBAAmB,CAAC;AAGtE,MAAM,WAAW,iBAAiB;IAChC;;;;;;;;;;;;;OAaG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CACrD;AAED,MAAM,WAAW,iBAAkB,SAAQ,iBAAiB;IAC1D;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;IAEjB;;OAEG;IACH,OAAO,EAAE,YAAY,CAAC;IACtB,eAAe,CAAC,EAAE,eAAe,CAAC,GAAG,CAAC,CAAC;IAEvC;;OAEG;IACH,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAEpB;;OAEG;IACH,KAAK,CAAC,EAAE,KAAK,GAAG,GAAG,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,qBAAa,aACX,YAAW,UAAU,CAAC,iBAAiB,EAAE,YAAY,CAAC;IACtD;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;IAEjB;;OAEG;IACH,OAAO,EAAE,YAAY,CAAC;IAEtB;;;OAGG;IACH,eAAe,EAAE,eAAe,CAAC,GAAG,CAAC,CAAC;IACtC;;OAEG;IACH,OAAO,CAAC,SAAS,CAAC,CAAW;IAE7B;;OAEG;IACH,KAAK,CAAC,EAAE,KAAK,GAAG,GAAG,CAAC;IAEpB;;;OAGG;IACH,OAAO,CAAC,qBAAqB,CAAC,CAAqB;IACnD;;;;;;;;;;;;;OAaG;IACH,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;gBAEjB,YAAY,EAAE,iBAAiB;IAU3C;;;;;;;;OAQG;IACH,oBAAoB,IAAI,cAAc;IAOtC;;;;;;;;;;OAUG;IACH,sBAAsB,IAAI,QAAQ,CAAC,SAAS,CAAC;IAgB7C;;;;OAIG;IACH,QAAQ,IAAI,OAAO;IAInB;;;;;;OAMG;IACH,IAAI,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,SAAS,EAG1C;IAED;;;;OAIG;IACH,IAAI,QAAQ,IAAI,QAAQ,GAAG,SAAS,CAEnC;IAED;;;;OAIG;IACH,WAAW,IAAI,OAAO;IAItB;;;;;;;;;OASG;IACH,IAAI,gBAAgB,IAAI,QAAQ,CAQ/B;IAED;;;;;OAKG;IACG,aAAa,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC;CAOrC"}
+{"version":3,"file":"fetchExchange.d.ts","sourceRoot":"","sources":["../src/fetchExchange.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AACnE,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,SAAS,CAAC;AAC1C,OAAO,EAAE,eAAe,EAAoB,MAAM,mBAAmB,CAAC;AAItE,MAAM,WAAW,iBAAiB;IAChC;;;;;;;;;;;;;OAaG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CACrD;AAED,MAAM,WAAW,iBAAkB,SAAQ,iBAAiB;IAC1D;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;IAEjB;;OAEG;IACH,OAAO,EAAE,YAAY,CAAC;IACtB,eAAe,CAAC,EAAE,eAAe,CAAC,GAAG,CAAC,CAAC;IAEvC;;OAEG;IACH,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAEpB;;OAEG;IACH,KAAK,CAAC,EAAE,KAAK,GAAG,GAAG,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,qBAAa,aACX,YAAW,UAAU,CAAC,iBAAiB,EAAE,YAAY,CAAC;IACtD;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;IAEjB;;OAEG;IACH,OAAO,EAAE,YAAY,CAAC;IAEtB;;;OAGG;IACH,eAAe,EAAE,eAAe,CAAC,GAAG,CAAC,CAAC;IACtC;;OAEG;IACH,OAAO,CAAC,SAAS,CAAC,CAAW;IAE7B;;OAEG;IACH,KAAK,CAAC,EAAE,KAAK,GAAG,GAAG,CAAC;IAEpB;;;OAGG;IACH,OAAO,CAAC,qBAAqB,CAAC,CAAqB;IACnD;;;;;;;;;;;;;OAaG;IACH,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;gBAEjB,YAAY,EAAE,iBAAiB;IAU3C;;;;;;;;OAQG;IACH,oBAAoB,IAAI,cAAc;IAOtC;;;;;;;;;;OAUG;IACH,sBAAsB,IAAI,QAAQ,CAAC,SAAS,CAAC;IAgB7C;;;;OAIG;IACH,QAAQ,IAAI,OAAO;IAInB;;;;;;OAMG;IACH,IAAI,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,SAAS,EAG1C;IAED;;;;OAIG;IACH,IAAI,QAAQ,IAAI,QAAQ,GAAG,SAAS,CAEnC;IAED;;;;OAIG;IACH,WAAW,IAAI,OAAO;IAItB;;;;;;;;;OASG;IACH,IAAI,gBAAgB,IAAI,QAAQ,CAQ/B;IAED;;;;;OAKG;IACG,aAAa,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC;CAOrC"}

package/dist/fetcherError.d.ts

@@ -1,3 +1,4 @@
+import { FetchExchange } from './fetchExchange';
 /**
  * Base error class for all Fetcher-related errors.
  *
@@ -29,4 +30,36 @@ export declare class FetcherError extends Error {
      */
     constructor(errorMsg?: string, cause?: (Error | any) | undefined);
 }
+/**
+ * Custom error class for FetchExchange related errors.
+ *
+ * This error is thrown when there are issues with the HTTP exchange process,
+ * such as when a request fails and no response is generated. It provides
+ * comprehensive information about the failed request through the exchange object.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await fetcher.get('/api/users');
+ * } catch (error) {
+ *   if (error instanceof ExchangeError) {
+ *     console.log('Request URL:', error.exchange.request.url);
+ *     console.log('Request method:', error.exchange.request.method);
+ *     if (error.exchange.error) {
+ *       console.log('Underlying error:', error.exchange.error);
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export declare class ExchangeError extends FetcherError {
+    readonly exchange: FetchExchange;
+    /**
+     * Creates a new ExchangeError instance.
+     *
+     * @param exchange - The FetchExchange object containing request/response/error information.
+     * @param errorMsg - An optional error message.
+     */
+    constructor(exchange: FetchExchange, errorMsg?: string);
+}
 //# sourceMappingURL=fetcherError.d.ts.map

package/dist/fetcherError.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fetcherError.d.ts","sourceRoot":"","sources":["../src/fetcherError.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,YAAa,SAAQ,KAAK;aASnB,KAAK,CAAC,GAAE,KAAK,GAAG,GAAG;IARrC;;;;;OAKG;gBAED,QAAQ,CAAC,EAAE,MAAM,EACD,KAAK,CAAC,GAAE,KAAK,GAAG,GAAG,aAAA;CAetC"}
+{"version":3,"file":"fetcherError.d.ts","sourceRoot":"","sources":["../src/fetcherError.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,YAAa,SAAQ,KAAK;aASnB,KAAK,CAAC,GAAE,KAAK,GAAG,GAAG;IARrC;;;;;OAKG;gBAED,QAAQ,CAAC,EAAE,MAAM,EACD,KAAK,CAAC,GAAE,KAAK,GAAG,GAAG,aAAA;CAetC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,aAAc,SAAQ,YAAY;aAQ3B,QAAQ,EAAE,aAAa;IAPzC;;;;;OAKG;gBAEe,QAAQ,EAAE,aAAa,EACvC,QAAQ,CAAC,EAAE,MAAM;CAWpB"}

package/dist/index.es.js

@@ -229,7 +229,7 @@ class $ {
     return this.build(t.url, t.urlParams);
   }
 }
-class E extends Error {
+class p extends Error {
   /**
    * Creates a new FetcherError instance.
    *
@@ -238,10 +238,22 @@ class E extends Error {
    */
   constructor(t, r) {
     const s = t || r?.message || "An error occurred in the fetcher";
-    super(s), this.cause = r, this.name = "FetcherError", r?.stack && (this.stack = r.stack), Object.setPrototypeOf(this, E.prototype);
+    super(s), this.cause = r, this.name = "FetcherError", r?.stack && (this.stack = r.stack), Object.setPrototypeOf(this, p.prototype);
   }
 }
-class O extends E {
+class E extends p {
+  /**
+   * Creates a new ExchangeError instance.
+   *
+   * @param exchange - The FetchExchange object containing request/response/error information.
+   * @param errorMsg - An optional error message.
+   */
+  constructor(t, r) {
+    const s = r || t.error?.message || t.response?.statusText || `Request to ${t.request.url} failed during exchange`;
+    super(s, t.error), this.exchange = t, this.name = "ExchangeError", Object.setPrototypeOf(this, E.prototype);
+  }
+}
+class O extends p {
   /**
    * Creates a new FetchTimeoutError instance.
    *
@@ -277,10 +289,156 @@ async function V(e) {
     n && clearTimeout(n);
   }
 }
-const k = "UrlResolveInterceptor", C = Number.MIN_SAFE_INTEGER + 1e3;
-class J {
+const k = (e) => e, J = (e) => e.requiredResponse, Q = (e) => e.requiredResponse.json(), Y = (e) => e.requiredResponse.text(), z = (e) => e.requiredResponse.blob(), K = (e) => e.requiredResponse.arrayBuffer(), W = (e) => e.requiredResponse.bytes(), q = {
+  /**
+   * Returns the original FetchExchange object
+   */
+  Exchange: k,
+  /**
+   * Extracts the raw Response object
+   */
+  Response: J,
+  /**
+   * Parses and returns response body as JSON
+   */
+  Json: Q,
+  /**
+   * Returns response body as text
+   */
+  Text: Y,
+  /**
+   * Returns response body as a Blob
+   */
+  Blob: z,
+  /**
+   * Returns response body as an ArrayBuffer
+   */
+  ArrayBuffer: K,
+  /**
+   * Returns response body as a Uint8Array
+   */
+  Bytes: W
+};
+function S(e, t) {
+  if (!(e === void 0 && t === void 0))
+    return t === void 0 ? e : e === void 0 ? t : { ...e, ...t };
+}
+function Z(e, t) {
+  if (t ??= /* @__PURE__ */ new Map(), !e)
+    return t;
+  if (e instanceof Map) {
+    for (const [r, s] of e)
+      t.set(r, s);
+    return t;
+  }
+  for (const [r, s] of Object.entries(e))
+    t.set(r, s);
+  return t;
+}
+class tt {
+  constructor(t) {
+    this.fetcher = t.fetcher, this.request = t.request, this.resultExtractor = t.resultExtractor ?? q.Exchange, this.attributes = Z(t.attributes), this._response = t.response, this.error = t.error;
+  }
+  /**
+   * Ensures that request headers object exists, creating it if necessary.
+   *
+   * This method checks if the request headers object is present and initializes
+   * it as an empty object if it's missing. This guarantees that headers can
+   * be safely accessed and modified after calling this method.
+   *
+   * @returns The request headers object, guaranteed to be non-null
+   */
+  ensureRequestHeaders() {
+    return this.request.headers || (this.request.headers = {}), this.request.headers;
+  }
+  /**
+   * Ensures that request URL parameters object exists with all required properties,
+   * creating them if necessary.
+   *
+   * This method checks if the request URL parameters object is present and initializes
+   * it with empty path and query objects if it's missing. It also ensures that both
+   * path and query sub-objects exist. This guarantees that URL parameters can be
+   * safely accessed and modified after calling this method.
+   *
+   * @returns The request URL parameters object with guaranteed non-null path and query properties
+   */
+  ensureRequestUrlParams() {
+    return this.request.urlParams || (this.request.urlParams = {
+      path: {},
+      query: {}
+    }), this.request.urlParams.path || (this.request.urlParams.path = {}), this.request.urlParams.query || (this.request.urlParams.query = {}), this.request.urlParams;
+  }
+  /**
+   * Checks if the exchange has an error.
+   *
+   * @returns true if an error is present, false otherwise
+   */
+  hasError() {
+    return !!this.error;
+  }
+  /**
+   * Sets the response object for this exchange.
+   * Also invalidates the cached extracted result to ensure data consistency
+   * when the response changes.
+   *
+   * @param response - The Response object to set, or undefined to clear the response
+   */
+  set response(t) {
+    this._response = t, this.cachedExtractedResult = void 0;
+  }
+  /**
+   * Gets the response object for this exchange.
+   *
+   * @returns The response object if available, undefined otherwise
+   */
+  get response() {
+    return this._response;
+  }
+  /**
+   * Checks if the exchange has a response.
+   *
+   * @returns true if a response is present, false otherwise
+   */
+  hasResponse() {
+    return !!this.response;
+  }
+  /**
+   * Gets the required response object, throwing an error if no response is available.
+   *
+   * This getter ensures that a response object is available, and throws an ExchangeError
+   * with details about the request if no response was received. This is useful for
+   * guaranteeing that downstream code always has a valid Response object to work with.
+   *
+   * @throws {ExchangeError} If no response is available for the current exchange
+   * @returns The Response object for this exchange
+   */
+  get requiredResponse() {
+    if (!this.response)
+      throw new E(
+        this,
+        `Request to ${this.request.url} failed with no response`
+      );
+    return this.response;
+  }
+  /**
+   * Extracts the result by applying the result extractor to the exchange.
+   * The result is cached after the first computation to avoid repeated computations.
+   *
+   * @returns The extracted result
+   */
+  async extractResult() {
+    return this.cachedExtractedResult !== void 0 ? await this.cachedExtractedResult : (this.cachedExtractedResult = this.resultExtractor(this), await this.cachedExtractedResult);
+  }
+}
+var i = /* @__PURE__ */ ((e) => (e.GET = "GET", e.POST = "POST", e.PUT = "PUT", e.DELETE = "DELETE", e.PATCH = "PATCH", e.HEAD = "HEAD", e.OPTIONS = "OPTIONS", e.TRACE = "TRACE", e))(i || {});
+const c = "Content-Type", d = class d {
+};
+d.APPLICATION_JSON = "application/json", d.TEXT_EVENT_STREAM = "text/event-stream";
+let R = d;
+const et = "UrlResolveInterceptor", C = Number.MIN_SAFE_INTEGER + 1e3;
+class rt {
   constructor() {
-    this.name = k, this.order = C;
+    this.name = et, this.order = C;
   }
   /**
    * Resolves the final URL by combining the base URL, path parameters, and query parameters.
@@ -292,15 +450,10 @@ class J {
     r.url = t.fetcher.urlBuilder.resolveRequestUrl(r);
   }
 }
-var i = /* @__PURE__ */ ((e) => (e.GET = "GET", e.POST = "POST", e.PUT = "PUT", e.DELETE = "DELETE", e.PATCH = "PATCH", e.HEAD = "HEAD", e.OPTIONS = "OPTIONS", e.TRACE = "TRACE", e))(i || {});
-const c = "Content-Type", d = class d {
-};
-d.APPLICATION_JSON = "application/json", d.TEXT_EVENT_STREAM = "text/event-stream";
-let R = d;
-const Q = "RequestBodyInterceptor", Y = C + 1e3;
-class z {
+const st = "RequestBodyInterceptor", ot = C + 1e3;
+class nt {
   constructor() {
-    this.name = Q, this.order = Y;
+    this.name = st, this.order = ot;
   }
   /**
    * Checks if the provided body is of a supported complex type that doesn't require JSON serialization.
@@ -373,10 +526,10 @@ class z {
     this.isSupportedComplexBodyType(r.body) || (t.request.body = JSON.stringify(r.body), s[c] || (s[c] = R.APPLICATION_JSON));
   }
 }
-const K = "FetchInterceptor", W = Number.MAX_SAFE_INTEGER - 1e3;
-class Z {
+const it = "FetchInterceptor", at = Number.MAX_SAFE_INTEGER - 1e3;
+class ut {
   constructor() {
-    this.name = K, this.order = W;
+    this.name = it, this.order = at;
   }
   /**
    * Intercept and process HTTP requests.
@@ -503,21 +656,22 @@ class m {
       await r.intercept(t);
   }
 }
-class q extends E {
+class b extends E {
   constructor(t) {
     super(
+      t,
       `Request failed with status code ${t.response?.status} for ${t.request.url}`
-    ), this.exchange = t, this.name = "HttpStatusValidationError", Object.setPrototypeOf(this, q.prototype);
+    ), this.name = "HttpStatusValidationError", Object.setPrototypeOf(this, b.prototype);
   }
 }
-const tt = (e) => e >= 200 && e < 300, et = "ValidateStatusInterceptor", rt = Number.MAX_SAFE_INTEGER - 1e3;
-class st {
+const ct = (e) => e >= 200 && e < 300, ht = "ValidateStatusInterceptor", lt = Number.MAX_SAFE_INTEGER - 1e3;
+class Et {
   /**
    * Creates a new ValidateStatusInterceptor instance.
    *
    * @param validateStatus - Function that determines if a status code is valid
    */
-  constructor(t = tt) {
+  constructor(t = ct) {
     this.validateStatus = t;
   }
   /**
@@ -526,7 +680,7 @@ class st {
    * @returns The name of this interceptor
    */
   get name() {
-    return et;
+    return ht;
   }
   /**
    * Gets the order of this interceptor.
@@ -534,7 +688,7 @@ class st {
    * @returns VALIDATE_STATUS_INTERCEPTOR_ORDER, indicating this interceptor should execute early
    */
   get order() {
-    return rt;
+    return lt;
   }
   /**
    * Validates the response status code.
@@ -554,29 +708,17 @@ class st {
       return;
     const r = t.response.status;
     if (!this.validateStatus(r))
-      throw new q(t);
+      throw new b(t);
   }
 }
-class p extends E {
-  /**
-   * Creates a new ExchangeError instance.
-   *
-   * @param exchange - The FetchExchange object containing request/response/error information.
-   * @param errorMsg - An optional error message.
-   */
-  constructor(t, r) {
-    const s = r || t.error?.message || t.response?.statusText || `Request to ${t.request.url} failed during exchange`;
-    super(s, t.error), this.exchange = t, this.name = "ExchangeError", Object.setPrototypeOf(this, p.prototype);
-  }
-}
-class ot {
+class Rt {
   constructor() {
     this.request = new m([
-      new J(),
-      new z(),
-      new Z()
+      new rt(),
+      new nt(),
+      new ut()
     ]), this.response = new m([
-      new st()
+      new Et()
     ]), this.error = new m();
   }
   /**
@@ -671,151 +813,10 @@ class ot {
     } catch (r) {
       if (t.error = r, await this.error.intercept(t), !t.hasError())
         return t;
-      throw new p(t);
+      throw new E(t);
     }
   }
 }
-const nt = (e) => e, it = (e) => e.requiredResponse, at = (e) => e.requiredResponse.json(), ut = (e) => e.requiredResponse.text(), ct = (e) => e.requiredResponse.blob(), ht = (e) => e.requiredResponse.arrayBuffer(), lt = (e) => e.requiredResponse.bytes(), b = {
-  /**
-   * Returns the original FetchExchange object
-   */
-  Exchange: nt,
-  /**
-   * Extracts the raw Response object
-   */
-  Response: it,
-  /**
-   * Parses and returns response body as JSON
-   */
-  Json: at,
-  /**
-   * Returns response body as text
-   */
-  Text: ut,
-  /**
-   * Returns response body as a Blob
-   */
-  Blob: ct,
-  /**
-   * Returns response body as an ArrayBuffer
-   */
-  ArrayBuffer: ht,
-  /**
-   * Returns response body as a Uint8Array
-   */
-  Bytes: lt
-};
-function S(e, t) {
-  if (!(e === void 0 && t === void 0))
-    return t === void 0 ? e : e === void 0 ? t : { ...e, ...t };
-}
-function Et(e, t) {
-  if (t ??= /* @__PURE__ */ new Map(), !e)
-    return t;
-  if (e instanceof Map) {
-    for (const [r, s] of e)
-      t.set(r, s);
-    return t;
-  }
-  for (const [r, s] of Object.entries(e))
-    t.set(r, s);
-  return t;
-}
-class Rt {
-  constructor(t) {
-    this.fetcher = t.fetcher, this.request = t.request, this.resultExtractor = t.resultExtractor ?? b.Exchange, this.attributes = Et(t.attributes), this._response = t.response, this.error = t.error;
-  }
-  /**
-   * Ensures that request headers object exists, creating it if necessary.
-   *
-   * This method checks if the request headers object is present and initializes
-   * it as an empty object if it's missing. This guarantees that headers can
-   * be safely accessed and modified after calling this method.
-   *
-   * @returns The request headers object, guaranteed to be non-null
-   */
-  ensureRequestHeaders() {
-    return this.request.headers || (this.request.headers = {}), this.request.headers;
-  }
-  /**
-   * Ensures that request URL parameters object exists with all required properties,
-   * creating them if necessary.
-   *
-   * This method checks if the request URL parameters object is present and initializes
-   * it with empty path and query objects if it's missing. It also ensures that both
-   * path and query sub-objects exist. This guarantees that URL parameters can be
-   * safely accessed and modified after calling this method.
-   *
-   * @returns The request URL parameters object with guaranteed non-null path and query properties
-   */
-  ensureRequestUrlParams() {
-    return this.request.urlParams || (this.request.urlParams = {
-      path: {},
-      query: {}
-    }), this.request.urlParams.path || (this.request.urlParams.path = {}), this.request.urlParams.query || (this.request.urlParams.query = {}), this.request.urlParams;
-  }
-  /**
-   * Checks if the exchange has an error.
-   *
-   * @returns true if an error is present, false otherwise
-   */
-  hasError() {
-    return !!this.error;
-  }
-  /**
-   * Sets the response object for this exchange.
-   * Also invalidates the cached extracted result to ensure data consistency
-   * when the response changes.
-   *
-   * @param response - The Response object to set, or undefined to clear the response
-   */
-  set response(t) {
-    this._response = t, this.cachedExtractedResult = void 0;
-  }
-  /**
-   * Gets the response object for this exchange.
-   *
-   * @returns The response object if available, undefined otherwise
-   */
-  get response() {
-    return this._response;
-  }
-  /**
-   * Checks if the exchange has a response.
-   *
-   * @returns true if a response is present, false otherwise
-   */
-  hasResponse() {
-    return !!this.response;
-  }
-  /**
-   * Gets the required response object, throwing an error if no response is available.
-   *
-   * This getter ensures that a response object is available, and throws an ExchangeError
-   * with details about the request if no response was received. This is useful for
-   * guaranteeing that downstream code always has a valid Response object to work with.
-   *
-   * @throws {ExchangeError} If no response is available for the current exchange
-   * @returns The Response object for this exchange
-   */
-  get requiredResponse() {
-    if (!this.response)
-      throw new p(
-        this,
-        `Request to ${this.request.url} failed with no response`
-      );
-    return this.response;
-  }
-  /**
-   * Extracts the result by applying the result extractor to the exchange.
-   * The result is cached after the first computation to avoid repeated computations.
-   *
-   * @returns The extracted result
-   */
-  async extractResult() {
-    return this.cachedExtractedResult !== void 0 ? await this.cachedExtractedResult : (this.cachedExtractedResult = this.resultExtractor(this), await this.cachedExtractedResult);
-  }
-}
 function Tt(e, t) {
   if (Object.keys(e).length === 0)
     return t;
@@ -852,9 +853,9 @@ const w = {
   baseURL: "",
   headers: w
 }, v = {
-  resultExtractor: b.Exchange
+  resultExtractor: q.Exchange
 }, N = {
-  resultExtractor: b.Response
+  resultExtractor: q.Response
 };
 class D {
   /**
@@ -871,7 +872,7 @@ class D {
    * @param options.interceptors - Interceptor manager for processing requests and responses.
    */
   constructor(t = U) {
-    this.headers = w, this.urlBuilder = new $(t.baseURL, t.urlTemplateStyle), this.headers = t.headers ?? w, this.timeout = t.timeout, this.interceptors = t.interceptors ?? new ot();
+    this.headers = w, this.urlBuilder = new $(t.baseURL, t.urlTemplateStyle), this.headers = t.headers ?? w, this.timeout = t.timeout, this.interceptors = t.interceptors ?? new Rt();
   }
   /**
    * Processes an HTTP request through the Fetcher's internal workflow.
@@ -894,7 +895,7 @@ class D {
     }, { resultExtractor: n, attributes: a } = A(
       v,
       r
-    ), u = new Rt({
+    ), u = new tt({
       fetcher: this,
       request: o,
       resultExtractor: n,
@@ -1264,47 +1265,47 @@ class pt extends D {
 }
 const mt = new pt(g);
 export {
-  ht as ArrayBufferResultExtractor,
-  ct as BlobResultExtractor,
-  lt as BytesResultExtractor,
+  K as ArrayBufferResultExtractor,
+  z as BlobResultExtractor,
+  W as BytesResultExtractor,
   c as CONTENT_TYPE_HEADER,
   R as ContentTypeValues,
   g as DEFAULT_FETCHER_NAME,
   N as DEFAULT_FETCH_OPTIONS,
   U as DEFAULT_OPTIONS,
   v as DEFAULT_REQUEST_OPTIONS,
-  p as ExchangeError,
-  nt as ExchangeResultExtractor,
+  E as ExchangeError,
+  k as ExchangeResultExtractor,
   y as ExpressUrlTemplateResolver,
-  K as FETCH_INTERCEPTOR_NAME,
-  W as FETCH_INTERCEPTOR_ORDER,
-  Rt as FetchExchange,
-  Z as FetchInterceptor,
+  it as FETCH_INTERCEPTOR_NAME,
+  at as FETCH_INTERCEPTOR_ORDER,
+  tt as FetchExchange,
+  ut as FetchInterceptor,
   O as FetchTimeoutError,
   D as Fetcher,
-  E as FetcherError,
+  p as FetcherError,
   dt as FetcherRegistrar,
   i as HttpMethod,
-  q as HttpStatusValidationError,
-  ot as InterceptorManager,
+  b as HttpStatusValidationError,
+  Rt as InterceptorManager,
   m as InterceptorRegistry,
-  at as JsonResultExtractor,
+  Q as JsonResultExtractor,
   pt as NamedFetcher,
-  Q as REQUEST_BODY_INTERCEPTOR_NAME,
-  Y as REQUEST_BODY_INTERCEPTOR_ORDER,
-  z as RequestBodyInterceptor,
-  it as ResponseResultExtractor,
-  b as ResultExtractors,
-  ut as TextResultExtractor,
-  k as URL_RESOLVE_INTERCEPTOR_NAME,
+  st as REQUEST_BODY_INTERCEPTOR_NAME,
+  ot as REQUEST_BODY_INTERCEPTOR_ORDER,
+  nt as RequestBodyInterceptor,
+  J as ResponseResultExtractor,
+  q as ResultExtractors,
+  Y as TextResultExtractor,
+  et as URL_RESOLVE_INTERCEPTOR_NAME,
   C as URL_RESOLVE_INTERCEPTOR_ORDER,
   P as UriTemplateResolver,
   $ as UrlBuilder,
-  J as UrlResolveInterceptor,
+  rt as UrlResolveInterceptor,
   M as UrlTemplateStyle,
-  et as VALIDATE_STATUS_INTERCEPTOR_NAME,
-  rt as VALIDATE_STATUS_INTERCEPTOR_ORDER,
-  st as ValidateStatusInterceptor,
+  ht as VALIDATE_STATUS_INTERCEPTOR_NAME,
+  lt as VALIDATE_STATUS_INTERCEPTOR_ORDER,
+  Et as ValidateStatusInterceptor,
   B as combineURLs,
   j as expressUrlTemplateResolver,
   mt as fetcher,
@@ -1312,7 +1313,7 @@ export {
   ft as getFetcher,
   G as getUrlTemplateResolver,
   L as isAbsoluteURL,
-  Et as mergeRecordToMap,
+  Z as mergeRecordToMap,
   S as mergeRecords,
   Tt as mergeRequest,
   A as mergeRequestOptions,