@ahoo-wang/fetcher 1.6.1 → 1.6.3

package/dist/index.es.js

@@ -1,29 +1,29 @@
-function F(r) {
+function C(r) {
   return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(r);
 }
-function C(r, e) {
-  return F(e) ? e : e ? r.replace(/\/?\/$/, "") + "/" + e.replace(/^\/+/, "") : r;
+function U(r, t) {
+  return C(t) ? t : t ? r.replace(/\/?\/$/, "") + "/" + t.replace(/^\/+/, "") : r;
 }
-var U = /* @__PURE__ */ ((r) => (r[r.UriTemplate = 0] = "UriTemplate", r[r.Express = 1] = "Express", r))(U || {});
-function v(r) {
-  return r === 1 ? D : x;
+var v = /* @__PURE__ */ ((r) => (r[r.UriTemplate = 0] = "UriTemplate", r[r.Express = 1] = "Express", r))(v || {});
+function D(r) {
+  return r === 1 ? M : L;
 }
-function q(r, e, t) {
-  return t ? r.replace(e, (s, o) => {
-    const n = t[o];
+function w(r, t, e) {
+  return e ? r.replace(t, (s, o) => {
+    const n = e[o];
     if (n === void 0)
       throw new Error(`Missing required path parameter: ${o}`);
     return encodeURIComponent(n);
   }) : r;
 }
-function w(r, e) {
-  const t = [];
+function N(r, t) {
+  const e = [];
   let s;
-  for (; (s = e.exec(r)) !== null; )
-    t.push(s[1]);
-  return t;
+  for (; (s = t.exec(r)) !== null; )
+    e.push(s[1]);
+  return e;
 }
-const h = class h {
+const a = class a {
   /**
    * Extracts path parameters from a URL string.
    *
@@ -47,10 +47,10 @@ const h = class h {
    * // noParams = []
    * ```
    */
-  extractPathParams(e) {
-    return w(
-      e,
-      h.PATH_PARAM_REGEX
+  extractPathParams(t) {
+    return N(
+      t,
+      a.PATH_PARAM_REGEX
     );
   }
   /**
@@ -89,17 +89,17 @@ const h = class h {
    * }
    * ```
    */
-  resolve(e, t) {
-    return q(
-      e,
-      h.PATH_PARAM_REGEX,
-      t
+  resolve(t, e) {
+    return w(
+      t,
+      a.PATH_PARAM_REGEX,
+      e
     );
   }
 };
-h.PATH_PARAM_REGEX = /{([^}]+)}/g;
-let P = h;
-const x = new P(), l = class l {
+a.PATH_PARAM_REGEX = /{([^}]+)}/g;
+let f = a;
+const L = new f(), h = class h {
   /**
    * Extracts path parameters from an Express-style URL string.
    *
@@ -119,10 +119,10 @@ const x = new P(), l = class l {
    * // noParams = []
    * ```
    */
-  extractPathParams(e) {
-    return w(
-      e,
-      l.PATH_PARAM_REGEX
+  extractPathParams(t) {
+    return N(
+      t,
+      h.PATH_PARAM_REGEX
     );
   }
   /**
@@ -157,18 +157,18 @@ const x = new P(), l = class l {
    * }
    * ```
    */
-  resolve(e, t) {
-    return q(
-      e,
-      l.PATH_PARAM_REGEX,
-      t
+  resolve(t, e) {
+    return w(
+      t,
+      h.PATH_PARAM_REGEX,
+      e
     );
   }
 };
-l.PATH_PARAM_REGEX = /:([^/]+)/g;
-let A = l;
-const D = new A();
-class L {
+h.PATH_PARAM_REGEX = /:([^/]+)/g;
+let P = h;
+const M = new P();
+class G {
   /**
    * Initializes a new UrlBuilder instance.
    *
@@ -186,8 +186,8 @@ class L {
    * const expressUrlBuilder = new UrlBuilder('https://api.example.com', UrlTemplateStyle.Express);
    * ```
    */
-  constructor(e, t) {
-    this.baseURL = e, this.urlTemplateResolver = v(t);
+  constructor(t, e) {
+    this.baseURL = t, this.urlTemplateResolver = D(e);
   }
   /**
    * Builds a complete URL, including path parameter replacement and query parameter addition.
@@ -207,14 +207,14 @@ class L {
    * // Result: https://api.example.com/users/123/posts/456?filter=active&limit=10
    * ```
    */
-  build(e, t) {
-    const s = t?.path, o = t?.query, n = C(this.baseURL, e);
-    let u = this.urlTemplateResolver.resolve(n, s);
+  build(t, e) {
+    const s = e?.path, o = e?.query, n = U(this.baseURL, t);
+    let i = this.urlTemplateResolver.resolve(n, s);
     if (o) {
-      const a = new URLSearchParams(o).toString();
-      a && (u += "?" + a);
+      const u = new URLSearchParams(o).toString();
+      u && (i += "?" + u);
     }
-    return u;
+    return i;
   }
   /**
    * Resolves a complete URL from a FetchRequest.
@@ -225,82 +225,82 @@ class L {
    * @param request - The FetchRequest containing URL and URL parameters
    * @returns Complete resolved URL string
    */
-  resolveRequestUrl(e) {
-    return this.build(e.url, e.urlParams);
+  resolveRequestUrl(t) {
+    return this.build(t.url, t.urlParams);
   }
 }
-class d extends Error {
+class l extends Error {
   /**
    * Creates a new FetcherError instance.
    *
    * @param errorMsg - Optional error message. If not provided, will use the cause's message or a default message.
    * @param cause - Optional underlying error that caused this error.
    */
-  constructor(e, t) {
-    const s = e || t?.message || "An error occurred in the fetcher";
-    super(s), this.cause = t, this.name = "FetcherError", t?.stack && (this.stack = t.stack), Object.setPrototypeOf(this, d.prototype);
+  constructor(t, e) {
+    const s = t || e?.message || "An error occurred in the fetcher";
+    super(s), this.cause = e, this.name = "FetcherError", e?.stack && (this.stack = e.stack), Object.setPrototypeOf(this, l.prototype);
   }
 }
-class b extends d {
+class b extends l {
   /**
    * Creates a new FetchTimeoutError instance.
    *
    * @param request - The request options that timed out
    */
-  constructor(e) {
-    const t = e.method || "GET", s = `Request timeout of ${e.timeout}ms exceeded for ${t} ${e.url}`;
-    super(s), this.name = "FetchTimeoutError", this.request = e, Object.setPrototypeOf(this, b.prototype);
+  constructor(t) {
+    const e = t.method || "GET", s = `Request timeout of ${t.timeout}ms exceeded for ${e} ${t.url}`;
+    super(s), this.name = "FetchTimeoutError", this.request = t, Object.setPrototypeOf(this, b.prototype);
   }
 }
-function G(r, e) {
-  return typeof r < "u" ? r : e;
+function H(r, t) {
+  return typeof r < "u" ? r : t;
 }
-async function M(r) {
-  const e = r.url, t = r.timeout, s = r;
+async function j(r) {
+  const t = r.url, e = r.timeout, s = r;
   if (r.signal)
-    return fetch(e, s);
-  if (!t)
-    return r.abortController && (s.signal = r.abortController.signal), fetch(e, s);
+    return fetch(t, s);
+  if (!e)
+    return r.abortController && (s.signal = r.abortController.signal), fetch(t, s);
   const o = r.abortController ?? new AbortController();
   s.signal = o.signal;
   let n = null;
-  const u = new Promise((a, m) => {
+  const i = new Promise((u, p) => {
     n = setTimeout(() => {
       n && clearTimeout(n);
-      const g = new b(r);
-      o.abort(g), m(g);
-    }, t);
+      const I = new b(r);
+      o.abort(I), p(I);
+    }, e);
   });
   try {
-    return await Promise.race([fetch(e, s), u]);
+    return await Promise.race([fetch(t, s), i]);
   } finally {
     n && clearTimeout(n);
   }
 }
-const H = "UrlResolveInterceptor", N = Number.MIN_SAFE_INTEGER + 1e3;
-class j {
+const B = "UrlResolveInterceptor", S = Number.MIN_SAFE_INTEGER + 1e3;
+class $ {
   constructor() {
-    this.name = H, this.order = N;
+    this.name = B, this.order = S;
   }
   /**
    * Resolves the final URL by combining the base URL, path parameters, and query parameters.
    *
    * @param exchange - The fetch exchange containing the request information
    */
-  intercept(e) {
-    const t = e.request;
-    t.url = e.fetcher.urlBuilder.resolveRequestUrl(t);
+  intercept(t) {
+    const e = t.request;
+    e.url = t.fetcher.urlBuilder.resolveRequestUrl(e);
   }
 }
 var c = /* @__PURE__ */ ((r) => (r.GET = "GET", r.POST = "POST", r.PUT = "PUT", r.DELETE = "DELETE", r.PATCH = "PATCH", r.HEAD = "HEAD", r.OPTIONS = "OPTIONS", r))(c || {});
-const ce = "Content-Type", R = class R {
+const Et = "Content-Type", d = class d {
 };
-R.APPLICATION_JSON = "application/json", R.TEXT_EVENT_STREAM = "text/event-stream";
-let E = R;
-const B = "RequestBodyInterceptor", $ = N + 1e3;
-class X {
+d.APPLICATION_JSON = "application/json", d.TEXT_EVENT_STREAM = "text/event-stream";
+let E = d;
+const X = "RequestBodyInterceptor", V = S + 1e3;
+class k {
   constructor() {
-    this.name = B, this.order = $;
+    this.name = X, this.order = V;
   }
   /**
    * Attempts to convert request body to a valid fetch API body type.
@@ -339,20 +339,20 @@ class X {
    * // exchange.request.body will be '{"name":"John","age":30}'
    * // exchange.request.headers will include 'Content-Type: application/json'
    */
-  intercept(e) {
-    const t = e.request;
-    if (t.body === void 0 || t.body === null || typeof t.body != "object" || t.body instanceof ArrayBuffer || ArrayBuffer.isView(t.body) || // Includes TypedArray and DataView
-    t.body instanceof Blob || t.body instanceof File || t.body instanceof URLSearchParams || t.body instanceof FormData || t.body instanceof ReadableStream)
+  intercept(t) {
+    const e = t.request;
+    if (e.body === void 0 || e.body === null || typeof e.body != "object" || e.body instanceof ArrayBuffer || ArrayBuffer.isView(e.body) || // Includes TypedArray and DataView
+    e.body instanceof Blob || e.body instanceof File || e.body instanceof URLSearchParams || e.body instanceof FormData || e.body instanceof ReadableStream)
       return;
-    e.request.body = JSON.stringify(t.body);
-    const s = e.ensureRequestHeaders();
+    t.request.body = JSON.stringify(e.body);
+    const s = t.ensureRequestHeaders();
     s["Content-Type"] || (s["Content-Type"] = E.APPLICATION_JSON);
   }
 }
-const V = "FetchInterceptor", J = Number.MAX_SAFE_INTEGER - 1e3;
-class k {
+const J = "FetchInterceptor", Q = Number.MAX_SAFE_INTEGER - 1e3;
+class Y {
   constructor() {
-    this.name = V, this.order = J;
+    this.name = J, this.order = Q;
   }
   /**
    * Intercept and process HTTP requests.
@@ -379,14 +379,14 @@ class k {
    * await fetchInterceptor.intercept(exchange);
    * console.log(exchange.response); // HTTP response object
    */
-  async intercept(e) {
-    e.response = await M(e.request);
+  async intercept(t) {
+    t.response = await j(t.request);
   }
 }
-function T(r, e) {
-  return e ? r.filter(e).sort((t, s) => t.order - s.order) : [...r].sort((t, s) => t.order - s.order);
+function T(r, t) {
+  return t ? r.filter(t).sort((e, s) => e.order - s.order) : [...r].sort((e, s) => e.order - s.order);
 }
-class f {
+class m {
   /**
    * Initializes a new InterceptorRegistry instance.
    *
@@ -396,8 +396,8 @@ class f {
    * The provided interceptors will be sorted by their order property immediately
    * upon construction.
    */
-  constructor(e = []) {
-    this.sortedInterceptors = [], this.sortedInterceptors = T(e);
+  constructor(t = []) {
+    this.sortedInterceptors = [], this.sortedInterceptors = T(t);
   }
   /**
    * Gets the name of this interceptor registry.
@@ -434,10 +434,10 @@ class f {
    *
    * After adding, interceptors are automatically sorted by their order property.
    */
-  use(e) {
-    return this.sortedInterceptors.some((t) => t.name === e.name) ? !1 : (this.sortedInterceptors = T([
+  use(t) {
+    return this.sortedInterceptors.some((e) => e.name === t.name) ? !1 : (this.sortedInterceptors = T([
       ...this.sortedInterceptors,
-      e
+      t
     ]), !0);
   }
   /**
@@ -447,12 +447,12 @@ class f {
    * @returns True if an interceptor was removed, false if no interceptor with the
    *          given name was found
    */
-  eject(e) {
-    const t = this.sortedInterceptors;
+  eject(t) {
+    const e = this.sortedInterceptors;
     return this.sortedInterceptors = T(
-      t,
-      (s) => s.name !== e
-    ), t.length !== this.sortedInterceptors.length;
+      e,
+      (s) => s.name !== t
+    ), e.length !== this.sortedInterceptors.length;
   }
   /**
    * Removes all interceptors from this registry.
@@ -474,27 +474,27 @@ class f {
    * If any interceptor throws an error, the execution chain is broken and the error
    * is propagated to the caller.
    */
-  async intercept(e) {
-    for (const t of this.sortedInterceptors)
-      await t.intercept(e);
+  async intercept(t) {
+    for (const e of this.sortedInterceptors)
+      await e.intercept(t);
   }
 }
-class I extends d {
-  constructor(e) {
+class _ extends l {
+  constructor(t) {
     super(
-      `Request failed with status code ${e.response?.status} for ${e.request.url}`
-    ), this.exchange = e, this.name = "HttpStatusValidationError", Object.setPrototypeOf(this, I.prototype);
+      `Request failed with status code ${t.response?.status} for ${t.request.url}`
+    ), this.exchange = t, this.name = "HttpStatusValidationError", Object.setPrototypeOf(this, _.prototype);
   }
 }
-const Y = (r) => r >= 200 && r < 300, z = "ValidateStatusInterceptor", Q = Number.MAX_SAFE_INTEGER - 1e3;
-class K {
+const z = (r) => r >= 200 && r < 300, K = "ValidateStatusInterceptor", W = Number.MAX_SAFE_INTEGER - 1e3;
+class Z {
   /**
    * Creates a new ValidateStatusInterceptor instance.
    *
    * @param validateStatus - Function that determines if a status code is valid
    */
-  constructor(e = Y) {
-    this.validateStatus = e;
+  constructor(t = z) {
+    this.validateStatus = t;
   }
   /**
    * Gets the name of this interceptor.
@@ -502,7 +502,7 @@ class K {
    * @returns The name of this interceptor
    */
   get name() {
-    return z;
+    return K;
   }
   /**
    * Gets the order of this interceptor.
@@ -510,7 +510,7 @@ class K {
    * @returns VALIDATE_STATUS_INTERCEPTOR_ORDER, indicating this interceptor should execute early
    */
   get order() {
-    return Q;
+    return W;
   }
   /**
    * Validates the response status code.
@@ -525,35 +525,35 @@ class K {
    * preventing other response handlers from attempting to process them. Valid responses
    * proceed through the rest of the response interceptor chain normally.
    */
-  intercept(e) {
-    if (!e.response)
+  intercept(t) {
+    if (!t.response)
       return;
-    const t = e.response.status;
-    if (!this.validateStatus(t))
-      throw new I(e);
+    const e = t.response.status;
+    if (!this.validateStatus(e))
+      throw new _(t);
   }
 }
-class p extends d {
+class R extends l {
   /**
    * Creates a new ExchangeError instance.
    *
    * @param exchange - The FetchExchange object containing request/response/error information.
    * @param errorMsg - An optional error message.
    */
-  constructor(e, t) {
-    const s = t || e.error?.message || e.response?.statusText || `Request to ${e.request.url} failed during exchange`;
-    super(s, e.error), this.exchange = e, this.name = "ExchangeError", Object.setPrototypeOf(this, p.prototype);
+  constructor(t, e) {
+    const s = e || 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, R.prototype);
   }
 }
-class W {
+class tt {
   constructor() {
-    this.request = new f([
-      new j(),
-      new X(),
-      new k()
-    ]), this.response = new f([
-      new K()
-    ]), this.error = new f();
+    this.request = new m([
+      new $(),
+      new k(),
+      new Y()
+    ]), this.response = new m([
+      new Z()
+    ]), this.error = new m();
   }
   /**
    * Processes a FetchExchange through the interceptor pipeline.
@@ -641,25 +641,41 @@ class W {
    * const result = await fetcher.exchange(exchange);
    * ```
    */
-  async exchange(e) {
+  async exchange(t) {
     try {
-      return await this.request.intercept(e), await this.response.intercept(e), e;
-    } catch (t) {
-      if (e.error = t, await this.error.intercept(e), !e.hasError())
-        return e;
-      throw new p(e);
+      return await this.request.intercept(t), await this.response.intercept(t), t;
+    } catch (e) {
+      if (t.error = e, await this.error.intercept(t), !t.hasError())
+        return t;
+      throw new R(t);
     }
   }
 }
-const Z = (r) => r, ee = (r) => r.requiredResponse, te = (r) => r.requiredResponse.json(), re = (r) => r.requiredResponse.text(), i = {
-  Exchange: Z,
-  Response: ee,
-  Json: te,
-  Text: re
+const et = (r) => r, rt = (r) => r.requiredResponse, st = (r) => r.requiredResponse.json(), ot = (r) => r.requiredResponse.text(), O = {
+  Exchange: et,
+  Response: rt,
+  Json: st,
+  Text: ot
 };
-class se {
-  constructor(e) {
-    this.fetcher = e.fetcher, this.request = e.request, this.resultExtractor = e.resultExtractor ?? i.Exchange, this.attributes = e.attributes ?? {}, this._response = e.response, this.error = e.error;
+function g(r, t) {
+  if (!(r === void 0 && t === void 0))
+    return t === void 0 ? r : r === void 0 ? t : { ...r, ...t };
+}
+function nt(r, t) {
+  if (t ??= /* @__PURE__ */ new Map(), !r)
+    return t;
+  if (r instanceof Map) {
+    for (const [e, s] of r)
+      t.set(e, s);
+    return t;
+  }
+  for (const [e, s] of Object.entries(r))
+    t.set(e, s);
+  return t;
+}
+class it {
+  constructor(t) {
+    this.fetcher = t.fetcher, this.request = t.request, this.resultExtractor = t.resultExtractor ?? O.Exchange, this.attributes = nt(t.attributes), this._response = t.response, this.error = t.error;
   }
   /**
    * Ensures that request headers object exists, creating it if necessary.
@@ -705,8 +721,8 @@ class se {
    *
    * @param response - The Response object to set, or undefined to clear the response
    */
-  set response(e) {
-    this._response = e, this.cachedExtractedResult = void 0;
+  set response(t) {
+    this._response = t, this.cachedExtractedResult = void 0;
   }
   /**
    * Gets the response object for this exchange.
@@ -736,29 +752,61 @@ class se {
    */
   get requiredResponse() {
     if (!this.response)
-      throw new p(
+      throw new R(
         this,
         `Request to ${this.request.url} failed with no response`
       );
     return this.response;
   }
   /**
-   * Gets the extracted result by applying the result extractor to the exchange.
-   * The result is cached after the first computation.
+   * 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 or null if extraction failed
+   * @returns The extracted result
    */
-  typedExtractedResult() {
+  extractResult() {
     return this.cachedExtractedResult !== void 0 ? this.cachedExtractedResult : (this.cachedExtractedResult = this.resultExtractor(this), this.cachedExtractedResult);
   }
 }
-const y = {
+function dt(r, t) {
+  if (Object.keys(r).length === 0)
+    return t;
+  if (Object.keys(t).length === 0)
+    return r;
+  const e = {
+    path: g(r.urlParams?.path, t.urlParams?.path),
+    query: g(r.urlParams?.query, t.urlParams?.query)
+  }, s = {
+    ...r.headers,
+    ...t.headers
+  }, o = t.method ?? r.method, n = t.body ?? r.body, i = t.timeout ?? r.timeout, u = t.signal ?? r.signal, p = t.abortController ?? r.abortController;
+  return {
+    ...r,
+    ...t,
+    method: o,
+    urlParams: e,
+    headers: s,
+    body: n,
+    timeout: i,
+    signal: u,
+    abortController: p
+  };
+}
+function q(r, t) {
+  return t && t.resultExtractor && t.attributes ? t : {
+    resultExtractor: t?.resultExtractor ?? r?.resultExtractor ?? x.resultExtractor,
+    attributes: t?.attributes ?? r?.attributes
+  };
+}
+const A = {
   "Content-Type": E.APPLICATION_JSON
-}, S = {
+}, F = {
   baseURL: "",
-  headers: y
+  headers: A
+}, x = { resultExtractor: O.Exchange }, ut = {
+  resultExtractor: O.Response
 };
-class oe {
+class ct {
   /**
    * Initializes a new Fetcher instance with optional configuration.
    *
@@ -766,9 +814,14 @@ class oe {
    * If no interceptors are provided, a default set of interceptors will be used.
    *
    * @param options - Configuration options for the Fetcher instance
+   * @param options.baseURL - The base URL to prepend to all requests. Defaults to empty string.
+   * @param options.headers - Default headers to include in all requests. Defaults to JSON content type.
+   * @param options.timeout - Default timeout for requests in milliseconds. No timeout by default.
+   * @param options.urlTemplateStyle - Style for URL template parameter interpolation.
+   * @param options.interceptors - Interceptor manager for processing requests and responses.
    */
-  constructor(e = S) {
-    this.headers = y, this.urlBuilder = new L(e.baseURL, e.urlTemplateStyle), this.headers = e.headers ?? y, this.timeout = e.timeout, this.interceptors = e.interceptors ?? new W();
+  constructor(t = F) {
+    this.headers = A, this.urlBuilder = new G(t.baseURL, t.urlTemplateStyle), this.headers = t.headers ?? A, this.timeout = t.timeout, this.interceptors = t.interceptors ?? new tt();
   }
   /**
    * Processes an HTTP request through the Fetcher's internal workflow.
@@ -777,51 +830,57 @@ class oe {
    * creates a FetchExchange object, and passes it through the exchange method
    * for interceptor processing.
    *
+   * @template R - The type of the result to be returned
    * @param request - Complete request configuration object
-   * @param resultExtractor - Function to extract the desired result from the exchange.
-   *                          Defaults to ExchangeResultExtractor which returns the entire exchange object.
-   * @param attributes - Optional shared attributes that can be accessed by interceptors
-   *                     throughout the request lifecycle. These attributes allow passing
-   *                     custom data between different interceptors.
+   * @param options - Request options including result extractor and attributes
+   * @param options.resultExtractor - Function to extract the desired result from the exchange.
+   *                                  Defaults to ExchangeResultExtractor which returns the entire exchange object.
+   * @param options.attributes - Optional shared attributes that can be accessed by interceptors
+   *                             throughout the request lifecycle. These attributes allow passing
+   *                             custom data between different interceptors.
    * @returns Promise that resolves to the extracted result based on resultExtractor
    * @throws Error if an unhandled error occurs during request processing
    */
-  async request(e, t = i.Exchange, s) {
-    const o = {
+  async request(t, e) {
+    const s = {
       ...this.headers,
-      ...e.headers
-    }, n = {
-      ...e,
-      headers: o,
-      timeout: G(e.timeout, this.timeout)
-    }, u = new se({
+      ...t.headers
+    }, o = {
+      ...t,
+      headers: s,
+      timeout: H(t.timeout, this.timeout)
+    }, {
+      resultExtractor: n,
+      attributes: i
+    } = q(x, e), u = new it({
       fetcher: this,
-      request: n,
-      resultExtractor: t,
-      attributes: s
+      request: o,
+      resultExtractor: n,
+      attributes: i
     });
-    return await this.interceptors.exchange(u), u.typedExtractedResult();
+    return await this.interceptors.exchange(u), u.extractResult();
   }
   /**
-     * Executes an HTTP request with the specified URL and options.
-     *
-     * This is the primary method for making HTTP requests. It processes the request
-     * through the interceptor chain and returns the resulting Response.
-     *
-     * @param url - The URL path for the request (relative to baseURL if set)
-     * @param request - Request configuration including headers, body, parameters, etc.
-     * @param resultExtractor - Function to extract the desired result from the exchange.
-     *                          Defaults to ExchangeResultExtractor which returns the entire exchange object.
-     * @param attributes - Optional shared attributes that can be accessed by interceptors
-     *                     throughout the request lifecycle. These attributes allow passing
-     *                     custom data between different interceptors.
-  
-     * @returns Promise that resolves to the HTTP response
-     * @throws FetchError if the request fails and no response is generated
-     */
-  async fetch(e, t = {}, s = i.Response, o) {
-    const n = t;
-    return n.url = e, this.request(n, s, o);
+   * Executes an HTTP request with the specified URL and options.
+   *
+   * This is the primary method for making HTTP requests. It processes the request
+   * through the interceptor chain and returns the resulting Response.
+   *
+   * @template R - The type of the result to be returned
+   * @param url - The URL path for the request (relative to baseURL if set)
+   * @param request - Request configuration including headers, body, parameters, etc.
+   * @param options - Request options including result extractor and attributes
+   * @param options.resultExtractor - Function to extract the desired result from the exchange.
+   *                                  Defaults to ResponseResultExtractor which returns the entire exchange object.
+   * @param options.attributes - Optional shared attributes that can be accessed by interceptors
+   *                             throughout the request lifecycle. These attributes allow passing
+   *                             custom data between different interceptors.
+   * @returns Promise that resolves to the HTTP response
+   * @throws FetchError if the request fails and no response is generated
+   */
+  async fetch(t, e = {}, s) {
+    const o = e;
+    return o.url = t, this.request(o, q(ut, s));
   }
   /**
    * Internal helper method for making HTTP requests with a specific method.
@@ -829,25 +888,26 @@ class oe {
    * This private method is used by the public HTTP method methods (get, post, etc.)
    * to execute requests with the appropriate HTTP verb.
    *
+   * @template R - The type of the result to be returned
    * @param method - The HTTP method to use for the request
    * @param url - The URL path for the request
    * @param request - Additional request options
-   * @param resultExtractor - Function to extract the desired result from the exchange.
-   *                          Defaults to ExchangeResultExtractor which returns the entire exchange object.
-   * @param attributes - Optional shared attributes that can be accessed by interceptors
-   *                     throughout the request lifecycle. These attributes allow passing
-   *                     custom data between different interceptors.
+   * @param options - Request options including result extractor and attributes
+   * @param options.resultExtractor - Function to extract the desired result from the exchange.
+   *                                  Defaults to ResponseResultExtractor which returns the entire exchange object.
+   * @param options.attributes - Optional shared attributes that can be accessed by interceptors
+   *                             throughout the request lifecycle. These attributes allow passing
+   *                             custom data between different interceptors.
    * @returns Promise that resolves to the HTTP response
    */
-  async methodFetch(e, t, s = {}, o = i.Response, n) {
+  async methodFetch(t, e, s = {}, o) {
     return this.fetch(
-      t,
+      e,
       {
         ...s,
-        method: e
+        method: t
       },
-      o,
-      n
+      o
     );
   }
   /**
@@ -856,85 +916,95 @@ class oe {
    * Convenience method for making GET requests. The request body is omitted
    * as GET requests should not contain a body according to HTTP specification.
    *
+   * @template R - The type of the result to be returned
    * @param url - The URL path for the request
    * @param request - Request options excluding method and body
-   * @param resultExtractor - Function to extract the desired result from the exchange.
-   *                          Defaults to ExchangeResultExtractor which returns the entire exchange object.
-   * @param attributes - Optional shared attributes that can be accessed by interceptors
-   *                     throughout the request lifecycle. These attributes allow passing
-   *                     custom data between different interceptors.
+   * @param options - Request options including result extractor and attributes
+   * @param options.resultExtractor - Function to extract the desired result from the exchange.
+   *                                  Defaults to ResponseResultExtractor which returns the entire exchange object.
+   * @param options.attributes - Optional shared attributes that can be accessed by interceptors
+   *                             throughout the request lifecycle. These attributes allow passing
+   *                             custom data between different interceptors.
    * @returns Promise that resolves to the HTTP response
    */
-  async get(e, t = {}, s = i.Response, o) {
-    return this.methodFetch(c.GET, e, t, s, o);
+  async get(t, e = {}, s) {
+    return this.methodFetch(c.GET, t, e, s);
   }
   /**
-   * Makes a POST HTTP request.
+   * Makes a PUT HTTP request.
    *
-   * Convenience method for making POST requests, commonly used for creating resources.
+   * Convenience method for making PUT requests, commonly used for updating resources.
    *
+   * @template R - The type of the result to be returned
    * @param url - The URL path for the request
    * @param request - Request options including body and other parameters
-   * @param resultExtractor - Function to extract the desired result from the exchange.
-   *                          Defaults to ExchangeResultExtractor which returns the entire exchange object.
-   * @param attributes - Optional shared attributes that can be accessed by interceptors
-   *                     throughout the request lifecycle. These attributes allow passing
-   *                     custom data between different interceptors.
+   * @param options - Request options including result extractor and attributes
+   * @param options.resultExtractor - Function to extract the desired result from the exchange.
+   *                                  Defaults to ResponseResultExtractor which returns the entire exchange object.
+   * @param options.attributes - Optional shared attributes that can be accessed by interceptors
+   *                             throughout the request lifecycle. These attributes allow passing
+   *                             custom data between different interceptors.
    * @returns Promise that resolves to the HTTP response
    */
-  async post(e, t = {}, s = i.Response, o) {
-    return this.methodFetch(c.POST, e, t, s, o);
+  async put(t, e = {}, s) {
+    return this.methodFetch(c.PUT, t, e, s);
   }
   /**
-   * Makes a PUT HTTP request.
+   * Makes a POST HTTP request.
    *
-   * Convenience method for making PUT requests, commonly used for updating resources.
+   * Convenience method for making POST requests, commonly used for creating resources.
    *
+   * @template R - The type of the result to be returned
    * @param url - The URL path for the request
    * @param request - Request options including body and other parameters
-   * @param resultExtractor - Function to extract the desired result from the exchange.
-   *                          Defaults to ExchangeResultExtractor which returns the entire exchange object.
-   * @param attributes - Optional shared attributes that can be accessed by interceptors
-   *                     throughout the request lifecycle. These attributes allow passing
-   *                     custom data between different interceptors.
+   * @param options - Request options including result extractor and attributes
+   * @param options.resultExtractor - Function to extract the desired result from the exchange.
+   *                                  Defaults to ResponseResultExtractor which returns the entire exchange object.
+   * @param options.attributes - Optional shared attributes that can be accessed by interceptors
+   *                             throughout the request lifecycle. These attributes allow passing
+   *                             custom data between different interceptors.
    * @returns Promise that resolves to the HTTP response
    */
-  async put(e, t = {}, s = i.Response, o) {
-    return this.methodFetch(c.PUT, e, t, s, o);
+  async post(t, e = {}, s) {
+    return this.methodFetch(c.POST, t, e, s);
   }
   /**
-   * Makes a DELETE HTTP request.
+   * Makes a PATCH HTTP request.
    *
-   * Convenience method for making DELETE requests, commonly used for deleting resources.
+   * Convenience method for making PATCH requests, commonly used for partial updates.
    *
+   * @template R - The type of the result to be returned
    * @param url - The URL path for the request
-   * @param request - Request options excluding method and body
-   * @param resultExtractor - Function to extract the desired result from the exchange.
-   *                          Defaults to ExchangeResultExtractor which returns the entire exchange object.
-   * @param attributes - Optional shared attributes that can be accessed by interceptors
-   *                     throughout the request lifecycle. These attributes allow passing
-   *                     custom data between different interceptors.
+   * @param request - Request options including body and other parameters
+   * @param options - Request options including result extractor and attributes
+   * @param options.resultExtractor - Function to extract the desired result from the exchange.
+   *                                  Defaults to ResponseResultExtractor which returns the entire exchange object.
+   * @param options.attributes - Optional shared attributes that can be accessed by interceptors
+   *                             throughout the request lifecycle. These attributes allow passing
+   *                             custom data between different interceptors.
    * @returns Promise that resolves to the HTTP response
    */
-  async delete(e, t = {}, s = i.Response, o) {
-    return this.methodFetch(c.DELETE, e, t, s, o);
+  async patch(t, e = {}, s) {
+    return this.methodFetch(c.PATCH, t, e, s);
   }
   /**
-   * Makes a PATCH HTTP request.
+   * Makes a DELETE HTTP request.
    *
-   * Convenience method for making PATCH requests, commonly used for partial updates.
+   * Convenience method for making DELETE requests, commonly used for deleting resources.
    *
+   * @template R - The type of the result to be returned
    * @param url - The URL path for the request
-   * @param request - Request options including body and other parameters
-   * @param resultExtractor - Function to extract the desired result from the exchange.
-   *                          Defaults to ExchangeResultExtractor which returns the entire exchange object.
-   * @param attributes - Optional shared attributes that can be accessed by interceptors
-   *                     throughout the request lifecycle. These attributes allow passing
-   *                     custom data between different interceptors.
+   * @param request - Request options excluding method and body
+   * @param options - Request options including result extractor and attributes
+   * @param options.resultExtractor - Function to extract the desired result from the exchange.
+   *                                  Defaults to ResponseResultExtractor which returns the entire exchange object.
+   * @param options.attributes - Optional shared attributes that can be accessed by interceptors
+   *                             throughout the request lifecycle. These attributes allow passing
+   *                             custom data between different interceptors.
    * @returns Promise that resolves to the HTTP response
    */
-  async patch(e, t = {}, s = i.Response, o) {
-    return this.methodFetch(c.PATCH, e, t, s, o);
+  async delete(t, e = {}, s) {
+    return this.methodFetch(c.DELETE, t, e, s);
   }
   /**
    * Makes a HEAD HTTP request.
@@ -942,17 +1012,19 @@ class oe {
    * Convenience method for making HEAD requests, which retrieve headers only.
    * The request body is omitted as HEAD requests should not contain a body.
    *
+   * @template R - The type of the result to be returned
    * @param url - The URL path for the request
    * @param request - Request options excluding method and body
-   * @param resultExtractor - Function to extract the desired result from the exchange.
-   *                          Defaults to ExchangeResultExtractor which returns the entire exchange object.
-   * @param attributes - Optional shared attributes that can be accessed by interceptors
-   *                     throughout the request lifecycle. These attributes allow passing
-   *                     custom data between different interceptors.
+   * @param options - Request options including result extractor and attributes
+   * @param options.resultExtractor - Function to extract the desired result from the exchange.
+   *                                  Defaults to ResponseResultExtractor which returns the entire exchange object.
+   * @param options.attributes - Optional shared attributes that can be accessed by interceptors
+   *                             throughout the request lifecycle. These attributes allow passing
+   *                             custom data between different interceptors.
    * @returns Promise that resolves to the HTTP response
    */
-  async head(e, t = {}, s = i.Response, o) {
-    return this.methodFetch(c.HEAD, e, t, s, o);
+  async head(t, e = {}, s) {
+    return this.methodFetch(c.HEAD, t, e, s);
   }
   /**
    * Makes an OPTIONS HTTP request.
@@ -960,21 +1032,23 @@ class oe {
    * Convenience method for making OPTIONS requests, commonly used for CORS preflight.
    * The request body is omitted as OPTIONS requests typically don't contain a body.
    *
+   * @template R - The type of the result to be returned
    * @param url - The URL path for the request
    * @param request - Request options excluding method and body
-   * @param resultExtractor - Function to extract the desired result from the exchange.
-   *                          Defaults to ExchangeResultExtractor which returns the entire exchange object.
-   * @param attributes - Optional shared attributes that can be accessed by interceptors
-   *                     throughout the request lifecycle. These attributes allow passing
-   *                     custom data between different interceptors.
+   * @param options - Request options including result extractor and attributes
+   * @param options.resultExtractor - Function to extract the desired result from the exchange.
+   *                                  Defaults to ResponseResultExtractor which returns the entire exchange object.
+   * @param options.attributes - Optional shared attributes that can be accessed by interceptors
+   *                             throughout the request lifecycle. These attributes allow passing
+   *                             custom data between different interceptors.
    * @returns Promise that resolves to the HTTP response
    */
-  async options(e, t = {}, s = i.Response, o) {
-    return this.methodFetch(c.OPTIONS, e, t, s, o);
+  async options(t, e = {}, s) {
+    return this.methodFetch(c.OPTIONS, t, e, s);
   }
 }
-const _ = "default";
-class ne {
+const y = "default";
+class at {
   constructor() {
     this.registrar = /* @__PURE__ */ new Map();
   }
@@ -987,8 +1061,8 @@ class ne {
    * const fetcher = new Fetcher({ baseURL: 'https://api.example.com' });
    * fetcherRegistrar.register('api', fetcher);
    */
-  register(e, t) {
-    this.registrar.set(e, t);
+  register(t, e) {
+    this.registrar.set(t, e);
   }
   /**
    * Unregister a Fetcher instance by name
@@ -1001,8 +1075,8 @@ class ne {
    *   console.log('Fetcher unregistered successfully');
    * }
    */
-  unregister(e) {
-    return this.registrar.delete(e);
+  unregister(t) {
+    return this.registrar.delete(t);
   }
   /**
    * Get a Fetcher instance by name
@@ -1015,8 +1089,8 @@ class ne {
    *   // Use the fetcher
    * }
    */
-  get(e) {
-    return this.registrar.get(e);
+  get(t) {
+    return this.registrar.get(t);
   }
   /**
    * Get a Fetcher instance by name, throwing an error if not found
@@ -1032,11 +1106,11 @@ class ne {
    *   console.error('Fetcher not found:', error.message);
    * }
    */
-  requiredGet(e) {
-    const t = this.get(e);
-    if (!t)
-      throw new Error(`Fetcher ${e} not found`);
-    return t;
+  requiredGet(t) {
+    const e = this.get(t);
+    if (!e)
+      throw new Error(`Fetcher ${t} not found`);
+    return e;
   }
   /**
    * Get the default Fetcher instance
@@ -1047,7 +1121,7 @@ class ne {
    * const defaultFetcher = fetcherRegistrar.default;
    */
   get default() {
-    return this.requiredGet(_);
+    return this.requiredGet(y);
   }
   /**
    * Set the default Fetcher instance
@@ -1057,8 +1131,8 @@ class ne {
    * const fetcher = new Fetcher({ baseURL: 'https://api.example.com' });
    * fetcherRegistrar.default = fetcher;
    */
-  set default(e) {
-    this.register(_, e);
+  set default(t) {
+    this.register(y, t);
   }
   /**
    * Get a copy of all registered fetchers
@@ -1074,36 +1148,8 @@ class ne {
     return new Map(this.registrar);
   }
 }
-const ie = new ne();
-function O(r, e) {
-  if (!(r === void 0 && e === void 0))
-    return e === void 0 ? r : r === void 0 ? e : { ...r, ...e };
-}
-function ae(r, e) {
-  if (Object.keys(r).length === 0)
-    return e;
-  if (Object.keys(e).length === 0)
-    return r;
-  const t = {
-    path: O(r.urlParams?.path, e.urlParams?.path),
-    query: O(r.urlParams?.query, e.urlParams?.query)
-  }, s = {
-    ...r.headers,
-    ...e.headers
-  }, o = e.method ?? r.method, n = e.body ?? r.body, u = e.timeout ?? r.timeout, a = e.signal ?? r.signal, m = e.abortController ?? r.abortController;
-  return {
-    ...r,
-    ...e,
-    method: o,
-    urlParams: t,
-    headers: s,
-    body: n,
-    timeout: u,
-    signal: a,
-    abortController: m
-  };
-}
-class ue extends oe {
+const ht = new at();
+class lt extends ct {
   /**
    * Create a NamedFetcher instance and automatically register it with the global fetcherRegistrar
    *
@@ -1121,61 +1167,65 @@ class ue extends oe {
    *   headers: { 'Authorization': 'Bearer token' }
    * });
    */
-  constructor(e, t = S) {
-    super(t), this.name = e, ie.register(e, this);
+  constructor(t, e = F) {
+    super(e), this.name = t, ht.register(t, this);
   }
 }
-const he = new ue(_);
+const Rt = new lt(y);
 export {
-  ce as CONTENT_TYPE_HEADER,
+  Et as CONTENT_TYPE_HEADER,
   E as ContentTypeValues,
-  _ as DEFAULT_FETCHER_NAME,
-  S as DEFAULT_OPTIONS,
-  p as ExchangeError,
-  Z as ExchangeResultExtractor,
-  A as ExpressUrlTemplateResolver,
-  V as FETCH_INTERCEPTOR_NAME,
-  J as FETCH_INTERCEPTOR_ORDER,
-  se as FetchExchange,
-  k as FetchInterceptor,
+  y as DEFAULT_FETCHER_NAME,
+  ut as DEFAULT_FETCH_OPTIONS,
+  F as DEFAULT_OPTIONS,
+  x as DEFAULT_REQUEST_OPTIONS,
+  R as ExchangeError,
+  et as ExchangeResultExtractor,
+  P as ExpressUrlTemplateResolver,
+  J as FETCH_INTERCEPTOR_NAME,
+  Q as FETCH_INTERCEPTOR_ORDER,
+  it as FetchExchange,
+  Y as FetchInterceptor,
   b as FetchTimeoutError,
-  oe as Fetcher,
-  d as FetcherError,
-  ne as FetcherRegistrar,
+  ct as Fetcher,
+  l as FetcherError,
+  at as FetcherRegistrar,
   c as HttpMethod,
-  I as HttpStatusValidationError,
-  W as InterceptorManager,
-  f as InterceptorRegistry,
-  te as JsonResultExtractor,
-  ue as NamedFetcher,
-  B as REQUEST_BODY_INTERCEPTOR_NAME,
-  $ as REQUEST_BODY_INTERCEPTOR_ORDER,
-  X as RequestBodyInterceptor,
-  ee as ResponseResultExtractor,
-  i as ResultExtractors,
-  re as TextResultExtractor,
-  H as URL_RESOLVE_INTERCEPTOR_NAME,
-  N as URL_RESOLVE_INTERCEPTOR_ORDER,
-  P as UriTemplateResolver,
-  L as UrlBuilder,
-  j as UrlResolveInterceptor,
-  U as UrlTemplateStyle,
-  z as VALIDATE_STATUS_INTERCEPTOR_NAME,
-  Q as VALIDATE_STATUS_INTERCEPTOR_ORDER,
-  K as ValidateStatusInterceptor,
-  C as combineURLs,
-  D as expressUrlTemplateResolver,
-  he as fetcher,
-  ie as fetcherRegistrar,
-  v as getUrlTemplateResolver,
-  F as isAbsoluteURL,
-  O as mergeRecords,
-  ae as mergeRequest,
-  G as resolveTimeout,
-  M as timeoutFetch,
+  _ as HttpStatusValidationError,
+  tt as InterceptorManager,
+  m as InterceptorRegistry,
+  st as JsonResultExtractor,
+  lt as NamedFetcher,
+  X as REQUEST_BODY_INTERCEPTOR_NAME,
+  V as REQUEST_BODY_INTERCEPTOR_ORDER,
+  k as RequestBodyInterceptor,
+  rt as ResponseResultExtractor,
+  O as ResultExtractors,
+  ot as TextResultExtractor,
+  B as URL_RESOLVE_INTERCEPTOR_NAME,
+  S as URL_RESOLVE_INTERCEPTOR_ORDER,
+  f as UriTemplateResolver,
+  G as UrlBuilder,
+  $ as UrlResolveInterceptor,
+  v as UrlTemplateStyle,
+  K as VALIDATE_STATUS_INTERCEPTOR_NAME,
+  W as VALIDATE_STATUS_INTERCEPTOR_ORDER,
+  Z as ValidateStatusInterceptor,
+  U as combineURLs,
+  M as expressUrlTemplateResolver,
+  Rt as fetcher,
+  ht as fetcherRegistrar,
+  D as getUrlTemplateResolver,
+  C as isAbsoluteURL,
+  nt as mergeRecordToMap,
+  g as mergeRecords,
+  dt as mergeRequest,
+  q as mergeRequestOptions,
+  H as resolveTimeout,
+  j as timeoutFetch,
   T as toSorted,
-  x as uriTemplateResolver,
-  w as urlTemplateRegexExtract,
-  q as urlTemplateRegexResolve
+  L as uriTemplateResolver,
+  N as urlTemplateRegexExtract,
+  w as urlTemplateRegexResolve
 };
 //# sourceMappingURL=index.es.js.map