@ahoo-wang/fetcher 0.9.1 → 0.9.5

package/dist/index.es.js

@@ -1,10 +1,10 @@
-function I(r) {
+function b(r) {
   return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(r);
 }
-function b(r, e) {
-  return I(e) ? e : e ? r.replace(/\/?\/$/, "") + "/" + e.replace(/^\/+/, "") : r;
+function g(r, t) {
+  return b(t) ? t : t ? r.replace(/\/?\/$/, "") + "/" + t.replace(/^\/+/, "") : r;
 }
-class g {
+class w {
   /**
    * Initializes a new UrlBuilder instance.
    *
@@ -15,8 +15,8 @@ class g {
    * const urlBuilder = new UrlBuilder('https://api.example.com');
    * ```
    */
-  constructor(e) {
-    this.baseURL = e;
+  constructor(t) {
+    this.baseURL = t;
   }
   /**
    * Builds a complete URL, including path parameter replacement and query parameter addition.
@@ -36,14 +36,14 @@ class g {
    * // Result: https://api.example.com/users/123/posts/456?filter=active&limit=10
    * ```
    */
-  build(e, t) {
-    const s = t?.path, n = t?.query, i = b(this.baseURL, e);
-    let o = this.interpolateUrl(i, s);
-    if (n) {
-      const u = new URLSearchParams(n).toString();
-      u && (o += "?" + u);
+  build(t, e) {
+    const s = e?.path, o = e?.query, i = g(this.baseURL, t);
+    let n = this.interpolateUrl(i, s);
+    if (o) {
+      const u = new URLSearchParams(o).toString();
+      u && (n += "?" + u);
     }
-    return o;
+    return n;
   }
   /**
    * Resolves a complete URL from a FetchRequest.
@@ -54,8 +54,8 @@ class g {
    * @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);
   }
   /**
    * Replaces placeholders in the URL with path parameters.
@@ -84,60 +84,122 @@ class g {
    * }
    * ```
    */
-  interpolateUrl(e, t) {
-    return t ? e.replace(/{([^}]+)}/g, (s, n) => {
-      const i = t[n];
+  interpolateUrl(t, e) {
+    return e ? t.replace(/{([^}]+)}/g, (s, o) => {
+      const i = e[o];
       if (i === void 0)
-        throw new Error(`Missing required path parameter: ${n}`);
+        throw new Error(`Missing required path parameter: ${o}`);
       return String(i);
-    }) : e;
+    }) : t;
   }
 }
-function w(r, e) {
-  return typeof r < "u" ? r : e;
+class a 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(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, a.prototype);
+  }
+}
+class m extends a {
+  /**
+   * Creates a new FetchError instance.
+   *
+   * @param exchange - The FetchExchange object containing request/response/error information.
+   * @param errorMsg - Optional custom error message. If not provided, will use the exchange's error message.
+   */
+  constructor(t, e) {
+    const s = e || t.error?.message || `Request to ${t.request.url} failed with no response`;
+    super(s, t.error), this.exchange = t, this.name = "FetchError", Object.setPrototypeOf(this, m.prototype);
+  }
 }
-class p extends Error {
+class T extends a {
   /**
    * 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, p.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, T.prototype);
   }
 }
-async function P(r) {
-  const e = r.url, t = r.timeout, s = r;
-  if (!t)
-    return fetch(e, s);
-  const n = new AbortController(), i = {
+function S(r, t) {
+  return typeof r < "u" ? r : t;
+}
+async function _(r) {
+  const t = r.url, e = r.timeout, s = r;
+  if (!e)
+    return fetch(t, s);
+  const o = new AbortController(), i = {
     ...s,
-    signal: n.signal
+    signal: o.signal
   };
-  let o = null;
-  const u = new Promise((L, E) => {
-    o = setTimeout(() => {
-      o && clearTimeout(o);
-      const y = new p(r);
-      n.abort(y), E(y);
-    }, t);
+  let n = null;
+  const u = new Promise((z, P) => {
+    n = setTimeout(() => {
+      n && clearTimeout(n);
+      const I = new T(r);
+      o.abort(I), P(I);
+    }, e);
   });
   try {
-    return await Promise.race([fetch(e, i), u]);
+    return await Promise.race([fetch(t, i), u]);
   } finally {
-    o && clearTimeout(o);
+    n && clearTimeout(n);
   }
 }
-function a(r, e) {
-  return e ? r.filter(e).sort((t, s) => t.order - s.order) : [...r].sort((t, s) => t.order - s.order);
+class N {
+  constructor(t, e, s, o) {
+    this.attributes = {}, this.fetcher = t, this.request = e, this.response = s, this.error = o;
+  }
+  /**
+   * Checks if the exchange has an error.
+   *
+   * @returns true if an error is present, false otherwise
+   */
+  hasError() {
+    return !!this.error;
+  }
+  /**
+   * Checks if the exchange has a response.
+   *
+   * @returns true if a response is present, false otherwise
+   */
+  hasResponse() {
+    return !!this.response;
+  }
 }
 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 v = "Content-Type";
+const Q = "Content-Type";
 var f = /* @__PURE__ */ ((r) => (r.APPLICATION_JSON = "application/json", r.TEXT_EVENT_STREAM = "text/event-stream", r))(f || {});
-class R {
+function l(r, t) {
+  if (!(r === void 0 && t === void 0))
+    return t === void 0 ? r : r === void 0 ? t : { ...r, ...t };
+}
+const F = "UrlResolveInterceptor", O = Number.MIN_SAFE_INTEGER + 1e3;
+class q {
   constructor() {
-    this.name = "RequestBodyInterceptor", this.order = Number.MIN_SAFE_INTEGER + 200;
+    this.name = F, this.order = O;
+  }
+  /**
+   * Resolves the final URL by combining the base URL, path parameters, and query parameters.
+   *
+   * @param exchange - The fetch exchange containing the request information
+   */
+  intercept(t) {
+    const e = t.request;
+    e.url = t.fetcher.urlBuilder.resolveRequestUrl(e);
+  }
+}
+const U = "RequestBodyInterceptor", C = O + 1e3;
+class L {
+  constructor() {
+    this.name = U, this.order = C;
   }
   /**
    * Attempts to convert request body to a valid fetch API body type.
@@ -176,20 +238,21 @@ class R {
    * // 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;
-    const s = { ...t };
-    s.body = JSON.stringify(t.body), s.headers || (s.headers = {});
-    const n = s.headers;
-    n["Content-Type"] || (n["Content-Type"] = f.APPLICATION_JSON), e.request = s;
+    const s = { ...e };
+    s.body = JSON.stringify(e.body), s.headers || (s.headers = {});
+    const o = s.headers;
+    o["Content-Type"] || (o["Content-Type"] = f.APPLICATION_JSON), t.request = s;
   }
 }
-class F {
+const D = "FetchInterceptor", v = Number.MAX_SAFE_INTEGER - 1e3;
+class M {
   constructor() {
-    this.name = "FetchInterceptor", this.order = Number.MAX_SAFE_INTEGER - 100;
+    this.name = D, this.order = v;
   }
   /**
    * Intercept and process HTTP requests.
@@ -216,27 +279,16 @@ class F {
    * await fetchInterceptor.intercept(exchange);
    * console.log(exchange.response); // HTTP response object
    */
-  async intercept(e) {
-    e.response = await P(e.request);
+  async intercept(t) {
+    t.response = await _(t.request);
   }
 }
-class A {
-  constructor() {
-    this.name = "UrlResolveInterceptor", this.order = Number.MIN_SAFE_INTEGER + 100;
-  }
-  /**
-   * 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);
-  }
+function h(r, t) {
+  return t ? r.filter(t).sort((e, s) => e.order - s.order) : [...r].sort((e, s) => e.order - s.order);
 }
-class h {
+class d {
   /**
-   * Initializes a new InterceptorManager instance.
+   * Initializes a new InterceptorRegistry instance.
    *
    * @param interceptors - Initial array of interceptors to manage
    *
@@ -244,11 +296,11 @@ class h {
    * The provided interceptors will be sorted by their order property immediately
    * upon construction.
    */
-  constructor(e = []) {
-    this.sortedInterceptors = [], this.sortedInterceptors = a(e);
+  constructor(t = []) {
+    this.sortedInterceptors = [], this.sortedInterceptors = h(t);
   }
   /**
-   * Gets the name of this interceptor manager.
+   * Gets the name of this interceptor registry.
    *
    * @returns The constructor name of this class
    */
@@ -256,15 +308,21 @@ class h {
     return this.constructor.name;
   }
   /**
-   * Gets the order of this interceptor manager.
+   * Gets the order of this interceptor registry.
    *
-   * @returns Number.MIN_SAFE_INTEGER, indicating this manager should execute early
+   * @returns Number.MIN_SAFE_INTEGER, indicating this registry should execute early
    */
   get order() {
     return Number.MIN_SAFE_INTEGER;
   }
   /**
-   * Adds an interceptor to this manager.
+   * Returns an array of all interceptors in the registry.
+   */
+  get interceptors() {
+    return [...this.sortedInterceptors];
+  }
+  /**
+   * Adds an interceptor to this registry.
    *
    * @param interceptor - The interceptor to add
    * @returns True if the interceptor was added, false if an interceptor with the
@@ -272,14 +330,14 @@ class h {
    *
    * @remarks
    * Interceptors are uniquely identified by their name property. Attempting to add
-   * an interceptor with a name that already exists in the manager will fail.
+   * an interceptor with a name that already exists in the registry will fail.
    *
    * After adding, interceptors are automatically sorted by their order property.
    */
-  use(e) {
-    return this.sortedInterceptors.some((t) => t.name === e.name) ? !1 : (this.sortedInterceptors = a([
+  use(t) {
+    return this.sortedInterceptors.some((e) => e.name === t.name) ? !1 : (this.sortedInterceptors = h([
       ...this.sortedInterceptors,
-      e
+      t
     ]), !0);
   }
   /**
@@ -289,15 +347,15 @@ class h {
    * @returns True if an interceptor was removed, false if no interceptor with the
    *          given name was found
    */
-  eject(e) {
-    const t = this.sortedInterceptors;
-    return this.sortedInterceptors = a(
-      t,
-      (s) => s.name !== e
-    ), t.length !== this.sortedInterceptors.length;
+  eject(t) {
+    const e = this.sortedInterceptors;
+    return this.sortedInterceptors = h(
+      e,
+      (s) => s.name !== t
+    ), e.length !== this.sortedInterceptors.length;
   }
   /**
-   * Removes all interceptors from this manager.
+   * Removes all interceptors from this registry.
    */
   clear() {
     this.sortedInterceptors = [];
@@ -316,52 +374,189 @@ class h {
    * 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 N {
-  constructor() {
-    this.request = new h([
-      new A(),
-      new R(),
-      new F()
-    ]), this.response = new h(), this.error = new h();
+class R extends a {
+  constructor(t) {
+    super(
+      `Request failed with status code ${t.response?.status} for ${t.request.url}`
+    ), this.exchange = t, this.name = "HttpStatusValidationError", Object.setPrototypeOf(this, R.prototype);
   }
 }
-class S {
-  constructor(e, t, s, n) {
-    this.attributes = {}, this.fetcher = e, this.request = t, this.response = s, this.error = n;
+const $ = (r) => r >= 200 && r < 300, j = "ValidateStatusInterceptor", B = Number.MAX_SAFE_INTEGER - 1e3;
+class G {
+  /**
+   * Creates a new ValidateStatusInterceptor instance.
+   *
+   * @param validateStatus - Function that determines if a status code is valid
+   */
+  constructor(t = $) {
+    this.validateStatus = t;
   }
   /**
-   * Checks if the exchange has an error.
+   * Gets the name of this interceptor.
    *
-   * @returns true if an error is present, false otherwise
+   * @returns The name of this interceptor
    */
-  hasError() {
-    return !!this.error;
+  get name() {
+    return j;
   }
   /**
-   * Checks if the exchange has a response.
+   * Gets the order of this interceptor.
    *
-   * @returns true if a response is present, false otherwise
+   * @returns VALIDATE_STATUS_INTERCEPTOR_ORDER, indicating this interceptor should execute early
    */
-  hasResponse() {
-    return !!this.response;
+  get order() {
+    return B;
+  }
+  /**
+   * Validates the response status code.
+   *
+   * @param exchange - The exchange containing the response to validate
+   * @throws HttpStatusValidationError if the status code is not valid
+   *
+   * @remarks
+   * This method runs at the beginning of the response interceptor chain to ensure
+   * status validation happens before any other response processing. Invalid responses
+   * are caught and converted to HttpStatusValidationError early in the pipeline,
+   * preventing other response handlers from attempting to process them. Valid responses
+   * proceed through the rest of the response interceptor chain normally.
+   */
+  intercept(t) {
+    if (!t.response)
+      return;
+    const e = t.response.status;
+    if (!this.validateStatus(e))
+      throw new R(t);
+  }
+}
+class y extends a {
+  /**
+   * Creates a new ExchangeError instance.
+   *
+   * @param exchange - The FetchExchange object containing request/response/error information.
+   */
+  constructor(t) {
+    const e = t.error?.message || t.response?.statusText || `Request to ${t.request.url} failed during exchange`;
+    super(e, t.error), this.exchange = t, this.name = "ExchangeError", Object.setPrototypeOf(this, y.prototype);
   }
 }
-function d(r, e) {
-  if (!(r === void 0 && e === void 0))
-    return e === void 0 ? r : r === void 0 ? e : { ...r, ...e };
+class V {
+  constructor() {
+    this.request = new d([
+      new q(),
+      new L(),
+      new M()
+    ]), this.response = new d([
+      new G()
+    ]), this.error = new d();
+  }
+  /**
+   * Processes a FetchExchange through the interceptor pipeline.
+   *
+   * This method is the core of the Fetcher's interceptor system. It executes the three
+   * phases of interceptors in sequence:
+   * 1. Request interceptors - Process the request before sending
+   * 2. Response interceptors - Process the response after receiving
+   * 3. Error interceptors - Handle any errors that occurred during the process
+   *
+   * The interceptor pipeline follows the Chain of Responsibility pattern, where each
+   * interceptor can modify the exchange object and decide whether to continue or
+   * terminate the chain.
+   *
+   * @param fetchExchange - The exchange object containing request, response, and error information
+   * @returns Promise that resolves to the processed FetchExchange
+   * @throws ExchangeError if an unhandled error occurs during processing
+   *
+   * @remarks
+   * The method handles three distinct phases:
+   *
+   * 1. Request Phase: Executes request interceptors which can modify headers, URL, body, etc.
+   *    Built-in interceptors handle URL resolution, body serialization, and actual HTTP execution.
+   *
+   * 2. Response Phase: Executes response interceptors which can transform or validate responses.
+   *    These interceptors only run if the request phase completed without throwing.
+   *
+   * 3. Error Phase: Executes error interceptors when any phase throws an error. Error interceptors
+   *    can handle errors by clearing the error property. If error interceptors clear the error,
+   *    the exchange is returned successfully.
+   *
+   * Error Handling:
+   * - If any interceptor throws an error, the error phase is triggered
+   * - Error interceptors can "fix" errors by clearing the error property on the exchange
+   * - If errors remain after error interceptors run, they are wrapped in ExchangeError
+   *
+   * Order of Execution:
+   * 1. Request interceptors (sorted by order property, ascending)
+   * 2. Response interceptors (sorted by order property, ascending) - only if no error in request phase
+   * 3. Error interceptors (sorted by order property, ascending) - only if an error occurred
+   *
+   * @example
+   * ```typescript
+   * // Create a fetcher with custom interceptors
+   * const fetcher = new Fetcher();
+   *
+   * // Add a request interceptor
+   * fetcher.interceptors.request.use({
+   *   name: 'AuthInterceptor',
+   *   order: 100,
+   *   async intercept(exchange: FetchExchange) {
+   *     exchange.request.headers = {
+   *       ...exchange.request.headers,
+   *       'Authorization': 'Bearer ' + getToken()
+   *     };
+   *   }
+   * });
+   *
+   * // Add a response interceptor
+   * fetcher.interceptors.response.use({
+   *   name: 'ResponseLogger',
+   *   order: 100,
+   *   async intercept(exchange: FetchExchange) {
+   *     console.log(`Response status: ${exchange.response?.status}`);
+   *   }
+   * });
+   *
+   * // Add an error interceptor
+   * fetcher.interceptors.error.use({
+   *   name: 'ErrorLogger',
+   *   order: 100,
+   *   async intercept(exchange: FetchExchange) {
+   *     console.error(`Request to ${exchange.request.url} failed:`, exchange.error);
+   *     // Clear the error to indicate it's been handled
+   *     exchange.error = undefined;
+   *   }
+   * });
+   *
+   * // Create and process an exchange
+   * const request: FetchRequest = {
+   *   url: '/api/users',
+   *   method: HttpMethod.GET
+   * };
+   * const exchange = new FetchExchange(fetcher, request);
+   * const result = await fetcher.exchange(exchange);
+   * ```
+   */
+  async exchange(t) {
+    try {
+      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 y(t);
+    }
+  }
 }
-const l = {
+const p = {
   "Content-Type": f.APPLICATION_JSON
-}, T = {
+}, A = {
   baseURL: "",
-  headers: l
+  headers: p
 };
-class q {
+class H {
   /**
    * Initializes a new Fetcher instance with optional configuration.
    *
@@ -370,8 +565,8 @@ class q {
    *
    * @param options - Configuration options for the Fetcher instance
    */
-  constructor(e = T) {
-    this.headers = l, this.urlBuilder = new g(e.baseURL), this.headers = e.headers ?? l, this.timeout = e.timeout, this.interceptors = e.interceptors ?? new N();
+  constructor(t = A) {
+    this.headers = p, this.urlBuilder = new w(t.baseURL), this.headers = t.headers ?? p, this.timeout = t.timeout, this.interceptors = t.interceptors ?? new V();
   }
   /**
    * Executes an HTTP request with the specified URL and options.
@@ -382,15 +577,18 @@ class q {
    * @param url - The URL path for the request (relative to baseURL if set)
    * @param request - Request configuration including headers, body, parameters, etc.
    * @returns Promise that resolves to the HTTP response
-   * @throws Error if the request fails and no response is generated
+   * @throws FetchError if the request fails and no response is generated
    */
-  async fetch(e, t = {}) {
-    const s = t;
-    s.url = e;
-    const n = await this.request(s);
-    if (!n.response)
-      throw new Error(`Request to ${s.url} failed with no response`);
-    return n.response;
+  async fetch(t, e = {}) {
+    const s = e;
+    s.url = t;
+    const o = await this.request(s);
+    if (!o.response)
+      throw new m(
+        o,
+        `Request to ${s.url} failed with no response`
+      );
+    return o.response;
   }
   /**
    * Processes an HTTP request through the Fetcher's internal workflow.
@@ -403,38 +601,13 @@ class q {
    * @returns Promise that resolves to a FetchExchange containing request/response data
    * @throws Error if an unhandled error occurs during request processing
    */
-  async request(e) {
-    const t = d(e.headers, this.headers), s = {
-      ...e,
-      headers: t,
-      timeout: w(e.timeout, this.timeout)
-    }, n = new S(this, s);
-    return this.exchange(n);
-  }
-  /**
-   * Processes a FetchExchange through the interceptor chain.
-   *
-   * Orchestrates the complete request lifecycle by applying interceptors in sequence:
-   * 1. Request interceptors - Modify the outgoing request
-   * 2. Response interceptors - Process the incoming response
-   *
-   * Error handling follows this flow:
-   * - If an error occurs, error interceptors are invoked
-   * - If an error interceptor produces a response, it's returned
-   * - Otherwise, the original error is re-thrown
-   *
-   * @param fetchExchange - The exchange object containing request and response data
-   * @returns Promise resolving to the processed exchange
-   * @throws Error if an unhandled error occurs during processing
-   */
-  async exchange(e) {
-    try {
-      return await this.interceptors.request.intercept(e), await this.interceptors.response.intercept(e), e;
-    } catch (t) {
-      if (e.error = t, await this.interceptors.error.intercept(e), e.hasResponse())
-        return e;
-      throw e.error;
-    }
+  async request(t) {
+    const e = l(t.headers, this.headers), s = {
+      ...t,
+      headers: e,
+      timeout: S(t.timeout, this.timeout)
+    }, o = new N(this, s);
+    return this.interceptors.exchange(o);
   }
   /**
    * Internal helper method for making HTTP requests with a specific method.
@@ -447,10 +620,10 @@ class q {
    * @param request - Additional request options
    * @returns Promise that resolves to the HTTP response
    */
-  async methodFetch(e, t, s = {}) {
-    return this.fetch(t, {
+  async methodFetch(t, e, s = {}) {
+    return this.fetch(e, {
       ...s,
-      method: e
+      method: t
     });
   }
   /**
@@ -463,8 +636,8 @@ class q {
    * @param request - Request options excluding method and body
    * @returns Promise that resolves to the HTTP response
    */
-  async get(e, t = {}) {
-    return this.methodFetch(c.GET, e, t);
+  async get(t, e = {}) {
+    return this.methodFetch(c.GET, t, e);
   }
   /**
    * Makes a POST HTTP request.
@@ -475,8 +648,8 @@ class q {
    * @param request - Request options including body and other parameters
    * @returns Promise that resolves to the HTTP response
    */
-  async post(e, t = {}) {
-    return this.methodFetch(c.POST, e, t);
+  async post(t, e = {}) {
+    return this.methodFetch(c.POST, t, e);
   }
   /**
    * Makes a PUT HTTP request.
@@ -487,8 +660,8 @@ class q {
    * @param request - Request options including body and other parameters
    * @returns Promise that resolves to the HTTP response
    */
-  async put(e, t = {}) {
-    return this.methodFetch(c.PUT, e, t);
+  async put(t, e = {}) {
+    return this.methodFetch(c.PUT, t, e);
   }
   /**
    * Makes a DELETE HTTP request.
@@ -499,8 +672,8 @@ class q {
    * @param request - Request options excluding method and body
    * @returns Promise that resolves to the HTTP response
    */
-  async delete(e, t = {}) {
-    return this.methodFetch(c.DELETE, e, t);
+  async delete(t, e = {}) {
+    return this.methodFetch(c.DELETE, t, e);
   }
   /**
    * Makes a PATCH HTTP request.
@@ -511,8 +684,8 @@ class q {
    * @param request - Request options including body and other parameters
    * @returns Promise that resolves to the HTTP response
    */
-  async patch(e, t = {}) {
-    return this.methodFetch(c.PATCH, e, t);
+  async patch(t, e = {}) {
+    return this.methodFetch(c.PATCH, t, e);
   }
   /**
    * Makes a HEAD HTTP request.
@@ -524,8 +697,8 @@ class q {
    * @param request - Request options excluding method and body
    * @returns Promise that resolves to the HTTP response
    */
-  async head(e, t = {}) {
-    return this.methodFetch(c.HEAD, e, t);
+  async head(t, e = {}) {
+    return this.methodFetch(c.HEAD, t, e);
   }
   /**
    * Makes an OPTIONS HTTP request.
@@ -537,12 +710,12 @@ class q {
    * @param request - Request options excluding method and body
    * @returns Promise that resolves to the HTTP response
    */
-  async options(e, t = {}) {
-    return this.methodFetch(c.OPTIONS, e, t);
+  async options(t, e = {}) {
+    return this.methodFetch(c.OPTIONS, t, e);
   }
 }
-const m = "default";
-class O {
+const E = "default";
+class k {
   constructor() {
     this.registrar = /* @__PURE__ */ new Map();
   }
@@ -555,8 +728,8 @@ class O {
    * 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
@@ -569,8 +742,8 @@ class O {
    *   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
@@ -583,8 +756,8 @@ class O {
    *   // 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
@@ -600,11 +773,11 @@ class O {
    *   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
@@ -615,7 +788,7 @@ class O {
    * const defaultFetcher = fetcherRegistrar.default;
    */
   get default() {
-    return this.requiredGet(m);
+    return this.requiredGet(E);
   }
   /**
    * Set the default Fetcher instance
@@ -625,8 +798,8 @@ class O {
    * const fetcher = new Fetcher({ baseURL: 'https://api.example.com' });
    * fetcherRegistrar.default = fetcher;
    */
-  set default(e) {
-    this.register(m, e);
+  set default(t) {
+    this.register(E, t);
   }
   /**
    * Get a copy of all registered fetchers
@@ -642,31 +815,31 @@ class O {
     return new Map(this.registrar);
   }
 }
-const U = new O();
-function C(r, e) {
+const J = new k();
+function Y(r, t) {
   if (Object.keys(r).length === 0)
-    return e;
-  if (Object.keys(e).length === 0)
+    return t;
+  if (Object.keys(t).length === 0)
     return r;
-  const t = {
-    path: d(r.urlParams?.path, e.urlParams?.path),
-    query: d(r.urlParams?.query, e.urlParams?.query)
+  const e = {
+    path: l(r.urlParams?.path, t.urlParams?.path),
+    query: l(r.urlParams?.query, t.urlParams?.query)
   }, s = {
     ...r.headers,
-    ...e.headers
-  }, n = e.method ?? r.method, i = e.body ?? r.body, o = e.timeout ?? r.timeout, u = e.signal ?? r.signal;
+    ...t.headers
+  }, o = t.method ?? r.method, i = t.body ?? r.body, n = t.timeout ?? r.timeout, u = t.signal ?? r.signal;
   return {
     ...r,
-    ...e,
-    method: n,
-    urlParams: t,
+    ...t,
+    method: o,
+    urlParams: e,
     headers: s,
     body: i,
-    timeout: o,
+    timeout: n,
     signal: u
   };
 }
-class _ extends q {
+class X extends H {
   /**
    * Create a NamedFetcher instance and automatically register it with the global fetcherRegistrar
    *
@@ -684,35 +857,48 @@ class _ extends q {
    *   headers: { 'Authorization': 'Bearer token' }
    * });
    */
-  constructor(e, t = T) {
-    super(t), this.name = e, U.register(e, this);
+  constructor(t, e = A) {
+    super(e), this.name = t, J.register(t, this);
   }
 }
-const D = new _(m);
+const K = new X(E);
 export {
-  v as ContentTypeHeader,
+  Q as ContentTypeHeader,
   f as ContentTypeValues,
-  m as DEFAULT_FETCHER_NAME,
-  T as DEFAULT_OPTIONS,
-  S as FetchExchange,
-  F as FetchInterceptor,
-  p as FetchTimeoutError,
-  q as Fetcher,
-  N as FetcherInterceptors,
-  O as FetcherRegistrar,
+  E as DEFAULT_FETCHER_NAME,
+  A as DEFAULT_OPTIONS,
+  y as ExchangeError,
+  D as FETCH_INTERCEPTOR_NAME,
+  v as FETCH_INTERCEPTOR_ORDER,
+  m as FetchError,
+  N as FetchExchange,
+  M as FetchInterceptor,
+  T as FetchTimeoutError,
+  H as Fetcher,
+  a as FetcherError,
+  k as FetcherRegistrar,
   c as HttpMethod,
-  h as InterceptorManager,
-  _ as NamedFetcher,
-  R as RequestBodyInterceptor,
-  g as UrlBuilder,
-  A as UrlResolveInterceptor,
-  b as combineURLs,
-  D as fetcher,
-  U as fetcherRegistrar,
-  I as isAbsoluteURL,
-  d as mergeRecords,
-  C as mergeRequest,
-  w as resolveTimeout,
-  P as timeoutFetch,
-  a as toSorted
+  R as HttpStatusValidationError,
+  V as InterceptorManager,
+  d as InterceptorRegistry,
+  X as NamedFetcher,
+  U as REQUEST_BODY_INTERCEPTOR_NAME,
+  C as REQUEST_BODY_INTERCEPTOR_ORDER,
+  L as RequestBodyInterceptor,
+  F as URL_RESOLVE_INTERCEPTOR_NAME,
+  O as URL_RESOLVE_INTERCEPTOR_ORDER,
+  w as UrlBuilder,
+  q as UrlResolveInterceptor,
+  j as VALIDATE_STATUS_INTERCEPTOR_NAME,
+  B as VALIDATE_STATUS_INTERCEPTOR_ORDER,
+  G as ValidateStatusInterceptor,
+  g as combineURLs,
+  K as fetcher,
+  J as fetcherRegistrar,
+  b as isAbsoluteURL,
+  l as mergeRecords,
+  Y as mergeRequest,
+  S as resolveTimeout,
+  _ as timeoutFetch,
+  h as toSorted
 };