@ahoo-wang/fetcher-storage 2.9.1 → 2.9.3

package/dist/index.es.js

@@ -1,4 +1,5 @@
-class $ {
+import { nameGenerator as i, SerialTypedEventBus as n } from "@ahoo-wang/fetcher-eventbus";
+class a {
   constructor() {
     this.store = /* @__PURE__ */ new Map();
   }
@@ -47,11 +48,11 @@ class $ {
     this.store.set(e, t);
   }
 }
-function B() {
+function l() {
   return typeof window < "u";
 }
-const V = () => B() ? window.localStorage : new $();
-class k {
+const o = () => l() ? window.localStorage : new a();
+class h {
   /**
    * Serializes a value to a JSON string
    * @param value The value to serialize
@@ -69,7 +70,7 @@ class k {
     return JSON.parse(e);
   }
 }
-class G {
+class u {
   /**
    * Returns the value as-is without serialization
    * @param value The value to pass through
@@ -87,1322 +88,22 @@ class G {
     return e;
   }
 }
-const ve = new k(), U = new G();
-function L() {
-  return U;
+const d = new h(), c = new u();
+function y() {
+  return c;
 }
-function j(r) {
-  return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(r);
-}
-function X(r, e) {
-  return j(e) ? e : e ? r.replace(/\/?\/$/, "") + "/" + e.replace(/^\/+/, "") : r;
-}
-function D(r) {
-  return r === 1 ? Y : K;
-}
-function x(r, e, t) {
-  return t ? r.replace(e, (s, n) => {
-    const a = t[n];
-    if (a === void 0)
-      throw new Error(`Missing required path parameter: ${n}`);
-    return encodeURIComponent(a);
-  }) : r;
-}
-function b(r, e) {
-  const t = [];
-  let s;
-  for (; (s = e.exec(r)) !== null; )
-    t.push(s[1]);
-  return t;
-}
-const v = class p {
-  /**
-   * Extracts path parameters from a URL string.
-   *
-   * @param urlTemplate - The URL string to extract path parameters from
-   * @returns An array of path parameter names without the curly braces, or an empty array if no matches found
-   *
-   * @example
-   * ```typescript
-   * const resolver = uriTemplateResolver;
-   *
-   * // Extract multiple parameters
-   * const params = resolver.extractPathParams('/users/{id}/posts/{postId}');
-   * // params = ['id', 'postId']
-   *
-   * // Extract parameters from full URLs
-   * const urlParams = resolver.extractPathParams('https://api.example.com/{resource}/{id}');
-   * // urlParams = ['resource', 'id']
-   *
-   * // No parameters
-   * const noParams = resolver.extractPathParams('/users/profile');
-   * // noParams = []
-   * ```
-   */
-  extractPathParams(e) {
-    return b(
-      e,
-      p.PATH_PARAM_REGEX
-    );
-  }
-  /**
-   * Replaces placeholders in the URL with path parameters.
-   *
-   * @param urlTemplate - Path string containing placeholders, e.g., "http://localhost/users/{id}/posts/{postId}"
-   * @param pathParams - Path parameter object used to replace placeholders in the URL
-   * @returns Path string with placeholders replaced
-   * @throws Error when required path parameters are missing
-   *
-   * @example
-   * ```typescript
-   * const resolver = uriTemplateResolver;
-   *
-   * // Replace parameters
-   * const url = resolver.resolve('/users/{id}/posts/{postId}', { id: 123, postId: 456 });
-   * // url = '/users/123/posts/456'
-   *
-   * // Handle string parameter values
-   * const stringUrl = resolver.resolve('/users/{username}', { username: 'john_doe' });
-   * // stringUrl = '/users/john_doe'
-   *
-   * // URL encode parameter values
-   * const encodedUrl = resolver.resolve('/search/{query}', { query: 'hello world' });
-   * // encodedUrl = '/search/hello%20world'
-   * ```
-   *
-   * @example
-   * ```typescript
-   * // Missing required parameter throws an error
-   * const resolver = uriTemplateResolver;
-   * try {
-   *   resolver.resolve('/users/{id}', { name: 'John' });
-   * } catch (error) {
-   *   console.error(error.message); // "Missing required path parameter: id"
-   * }
-   * ```
-   */
-  resolve(e, t) {
-    return x(
-      e,
-      p.PATH_PARAM_REGEX,
-      t
-    );
-  }
-};
-v.PATH_PARAM_REGEX = /{([^}]+)}/g;
-let J = v;
-const K = new J(), S = class m {
-  /**
-   * Extracts path parameters from an Express-style URL string.
-   *
-   * @param urlTemplate - The URL string with Express-style parameter placeholders
-   * @returns An array of parameter names extracted from the URL template
-   *
-   * @example
-   * ```typescript
-   * const resolver = new expressUrlTemplateResolver;
-   *
-   * // Extract multiple parameters
-   * const params = resolver.extractPathParams('/users/:id/posts/:postId');
-   * // params = ['id', 'postId']
-   *
-   * // No parameters
-   * const noParams = resolver.extractPathParams('/users/profile');
-   * // noParams = []
-   * ```
-   */
-  extractPathParams(e) {
-    return b(
-      e,
-      m.PATH_PARAM_REGEX
-    );
-  }
-  /**
-   * Replaces Express-style placeholders in the URL with path parameters.
-   *
-   * @param urlTemplate - Path string containing Express-style placeholders
-   * @param pathParams - Object containing parameter values to replace placeholders
-   * @returns Path string with placeholders replaced
-   * @throws Error when required path parameters are missing
-   *
-   * @example
-   * ```typescript
-   * const resolver = expressUrlTemplateResolver;
-   *
-   * // Replace parameters
-   * const url = resolver.resolve('/users/:id/posts/:postId', { id: 123, postId: 456 });
-   * // url = '/users/123/posts/456'
-   *
-   * // Handle string parameter values
-   * const stringUrl = resolver.resolve('/users/:username', { username: 'john_doe' });
-   * // stringUrl = '/users/john_doe'
-   * ```
-   *
-   * @example
-   * ```typescript
-   * // Missing required parameter throws an error
-   * const resolver = expressUrlTemplateResolver;
-   * try {
-   *   resolver.resolve('/users/:id', { name: 'John' });
-   * } catch (error) {
-   *   console.error(error.message); // "Missing required path parameter: id"
-   * }
-   * ```
-   */
-  resolve(e, t) {
-    return x(
-      e,
-      m.PATH_PARAM_REGEX,
-      t
-    );
-  }
-};
-S.PATH_PARAM_REGEX = /:([^/]+)/g;
-let Q = S;
-const Y = new Q();
-class W {
-  /**
-   * Initializes a new UrlBuilder instance.
-   *
-   * @param baseURL - Base URL that all constructed URLs will be based on
-   * @param urlTemplateStyle - Optional style configuration for URL template resolution.
-   *                           Determines how path parameters are parsed and resolved.
-   *                           Defaults to UriTemplate style if not specified.
-   *
-   * @example
-   * ```typescript
-   * // Create a URL builder with default URI template style
-   * const urlBuilder = new UrlBuilder('https://api.example.com');
-   *
-   * // Create a URL builder with Express-style template resolution
-   * const expressUrlBuilder = new UrlBuilder('https://api.example.com', UrlTemplateStyle.Express);
-   * ```
-   */
-  constructor(e, t) {
-    this.baseURL = e, this.urlTemplateResolver = D(t);
-  }
-  /**
-   * Builds a complete URL, including path parameter replacement and query parameter addition.
-   *
-   * @param url - URL path to build (e.g., '/users/{id}/posts')
-   * @param params - URL parameters including path and query parameters
-   * @returns Complete URL string with base URL, path parameters interpolated, and query string appended
-   * @throws Error when required path parameters are missing
-   *
-   * @example
-   * ```typescript
-   * const urlBuilder = new UrlBuilder('https://api.example.com');
-   * const url = urlBuilder.build('/users/{id}/posts/{postId}', {
-   *   path: { id: 123, postId: 456 },
-   *   query: { filter: 'active', limit: 10 }
-   * });
-   * // Result: https://api.example.com/users/123/posts/456?filter=active&limit=10
-   * ```
-   */
-  build(e, t) {
-    const s = t?.path, n = t?.query, a = X(this.baseURL, e);
-    let i = this.urlTemplateResolver.resolve(a, s);
-    if (n) {
-      const c = new URLSearchParams(n).toString();
-      c && (i += "?" + c);
-    }
-    return i;
-  }
-  /**
-   * Resolves a complete URL from a FetchRequest.
-   *
-   * Used internally by the Fetcher to build the final URL for a request
-   * by combining the request URL with its URL parameters using this UrlBuilder.
-   *
-   * @param request - The FetchRequest containing URL and URL parameters
-   * @returns Complete resolved URL string
-   */
-  resolveRequestUrl(e) {
-    return this.build(e.url, e.urlParams);
-  }
-}
-let I = class H 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, H.prototype);
-  }
-}, g = class O extends I {
-  /**
-   * 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, O.prototype);
-  }
-};
-class w extends I {
-  /**
-   * 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, w.prototype);
-  }
-}
-function Z(r, e) {
-  return typeof r < "u" ? r : e;
-}
-async function ee(r) {
-  const e = r.url, t = r.timeout, s = r;
-  if (r.signal)
-    return await fetch(e, s);
-  if (!t)
-    return r.abortController && (s.signal = r.abortController.signal), await fetch(e, s);
-  const n = r.abortController ?? new AbortController();
-  r.abortController = n, s.signal = n.signal;
-  let a = null;
-  const i = new Promise((c, M) => {
-    a = setTimeout(() => {
-      a && clearTimeout(a);
-      const T = new w(r);
-      n.abort(T), M(T);
-    }, t);
-  });
-  try {
-    return await Promise.race([fetch(e, s), i]);
-  } finally {
-    a && clearTimeout(a);
-  }
-}
-const te = (r) => r, re = (r) => r.requiredResponse, R = {
-  /**
-   * Returns the original FetchExchange object
-   */
-  Exchange: te,
-  /**
-   * Extracts the raw Response object
-   */
-  Response: re
-};
-function se(r, e) {
-  if (e ??= /* @__PURE__ */ new Map(), !r)
-    return e;
-  if (r instanceof Map) {
-    for (const [t, s] of r)
-      e.set(t, s);
-    return e;
-  }
-  for (const [t, s] of Object.entries(r))
-    e.set(t, s);
-  return e;
-}
-class ne {
-  constructor(e) {
-    this.fetcher = e.fetcher, this.request = e.request, this.resultExtractor = e.resultExtractor ?? R.Exchange, this.attributes = se(e.attributes), this._response = e.response, this.error = e.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(e) {
-    this._response = e, 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 g(
-        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 o = /* @__PURE__ */ ((r) => (r.GET = "GET", r.POST = "POST", r.PUT = "PUT", r.DELETE = "DELETE", r.PATCH = "PATCH", r.HEAD = "HEAD", r.OPTIONS = "OPTIONS", r.TRACE = "TRACE", r))(o || {});
-const h = "Content-Type", f = class {
-};
-f.APPLICATION_JSON = "application/json", f.TEXT_EVENT_STREAM = "text/event-stream";
-let C = f;
-const ae = "UrlResolveInterceptor", N = Number.MIN_SAFE_INTEGER + 1e3;
-class oe {
-  constructor() {
-    this.name = ae, this.order = N;
-  }
-  /**
-   * 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);
-  }
-}
-const ie = "RequestBodyInterceptor", ue = N + 1e3;
-class ce {
-  constructor() {
-    this.name = ie, this.order = ue;
-  }
-  /**
-   * Checks if the provided body is of a supported complex type that doesn't require JSON serialization.
-   *
-   * @param body - The request body to check
-   * @returns True if the body is an ArrayBuffer, TypedArray, DataView or ReadableStream, false otherwise
-   */
-  isSupportedComplexBodyType(e) {
-    return e instanceof ArrayBuffer || ArrayBuffer.isView(e) || e instanceof ReadableStream;
-  }
-  /**
-   * Checks if the provided body is of a type that automatically appends Content-Type header.
-   *
-   * @param body - The request body to check
-   * @returns True if the body is a Blob, File, FormData or URLSearchParams, false otherwise
-   */
-  isAutoAppendContentType(e) {
-    return e instanceof Blob || e instanceof File || e instanceof FormData || e instanceof URLSearchParams;
-  }
-  /**
-   * Attempts to convert request body to a valid fetch API body type.
-   *
-   * This method follows a specific processing order to handle different types of request bodies:
-   * 1. Check if the body is null or undefined and return early if so
-   * 2. Check if the body is a non-object type and return early if so
-   * 3. Check if the body is a type that automatically appends Content-Type header
-   * 4. Check if the body is a supported complex type that doesn't require JSON serialization
-   * 5. For plain objects, convert to JSON string and set Content-Type header to application/json
-   *
-   * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch#setting_a_body}
-   *
-   * Supported types:
-   *   - a string
-   *   - ArrayBuffer
-   *   - TypedArray
-   *   - DataView
-   *   - Blob
-   *   - File
-   *   - URLSearchParams
-   *   - FormData
-   *   - ReadableStream
-   *
-   * For unsupported object types (like plain objects), they will be automatically
-   * converted to JSON strings.
-   *
-   * @param exchange - The exchange object containing the request to process
-   *
-   * @example
-   * // Plain object body will be converted to JSON
-   * const fetcher = new Fetcher();
-   * const exchange = new FetchExchange(
-   *   fetcher,
-   *   {
-   *     body: { name: 'John', age: 30 }
-   *   }
-   * );
-   * interceptor.intercept(exchange);
-   * // 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")
-      return;
-    const s = e.ensureRequestHeaders();
-    if (this.isAutoAppendContentType(t.body)) {
-      s[h] && delete s[h];
-      return;
-    }
-    this.isSupportedComplexBodyType(t.body) || (e.request.body = JSON.stringify(t.body), s[h] || (s[h] = C.APPLICATION_JSON));
-  }
-}
-const he = "FetchInterceptor", le = Number.MAX_SAFE_INTEGER - 1e3;
-class de {
-  constructor() {
-    this.name = he, this.order = le;
-  }
-  /**
-   * Intercept and process HTTP requests.
-   *
-   * Executes the actual HTTP request and applies timeout control. This is the final
-   * step in the request processing chain, responsible for calling the timeoutFetch
-   * function to send the network request.
-   *
-   * @param exchange - Exchange object containing request information
-   *
-   * @throws {FetchTimeoutError} Throws timeout exception when request times out
-   *
-   * @example
-   * // Usually called internally by Fetcher
-   * const fetcher = new Fetcher();
-   * const exchange = new FetchExchange(
-   *   fetcher,
-   *   {
-   *     url: 'https://api.example.com/users',
-   *     method: 'GET',
-   *     timeout: 5000
-   *   }
-   * );
-   * await fetchInterceptor.intercept(exchange);
-   * console.log(exchange.response); // HTTP response object
-   */
-  async intercept(e) {
-    e.response = await ee(e.request);
-  }
-}
-const P = 0;
-function A(r, e) {
-  return (r.order ?? P) - (e.order ?? P);
-}
-function u(r, e) {
-  return e ? r.filter(e).sort(A) : [...r].sort(A);
-}
-class l {
-  /**
-   * Initializes a new InterceptorRegistry instance.
-   *
-   * @param interceptors - Initial array of interceptors to manage
-   *
-   * @remarks
-   * The provided interceptors will be sorted by their order property immediately
-   * upon construction.
-   */
-  constructor(e = []) {
-    this.sortedInterceptors = [], this.sortedInterceptors = u(e);
-  }
-  /**
-   * Gets the name of this interceptor registry.
-   *
-   * @returns The constructor name of this class
-   */
-  get name() {
-    return this.constructor.name;
-  }
-  /**
-   * Gets the order of this interceptor registry.
-   *
-   * @returns Number.MIN_SAFE_INTEGER, indicating this registry should execute early
-   */
-  get order() {
-    return Number.MIN_SAFE_INTEGER;
-  }
-  /**
-   * 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
-   *          same name already exists
-   *
-   * @remarks
-   * Interceptors are uniquely identified by their name property. Attempting to add
-   * 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 = u([
-      ...this.sortedInterceptors,
-      e
-    ]), !0);
-  }
-  /**
-   * Removes an interceptor by name.
-   *
-   * @param name - The name of the interceptor to remove
-   * @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 = u(
-      t,
-      (s) => s.name !== e
-    ), t.length !== this.sortedInterceptors.length;
-  }
-  /**
-   * Removes all interceptors from this registry.
-   */
-  clear() {
-    this.sortedInterceptors = [];
-  }
-  /**
-   * Executes all managed interceptors on the given exchange object.
-   *
-   * @param exchange - The exchange object to process
-   * @returns A promise that resolves when all interceptors have been executed
-   *
-   * @remarks
-   * Interceptors are executed in order, with each interceptor receiving the result
-   * of the previous interceptor. The first interceptor receives the original
-   * exchange object.
-   *
-   * 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);
-  }
-}
-let pe = class _ extends g {
-  constructor(e) {
-    super(
-      e,
-      `Request failed with status code ${e.response?.status} for ${e.request.url}`
-    ), this.name = "HttpStatusValidationError", Object.setPrototypeOf(this, _.prototype);
-  }
-};
-const me = (r) => r >= 200 && r < 300, fe = "ValidateStatusInterceptor", ye = Number.MAX_SAFE_INTEGER - 1e3;
-class Ee {
-  /**
-   * Creates a new ValidateStatusInterceptor instance.
-   *
-   * @param validateStatus - Function that determines if a status code is valid
-   */
-  constructor(e = me) {
-    this.validateStatus = e;
-  }
-  /**
-   * Gets the name of this interceptor.
-   *
-   * @returns The name of this interceptor
-   */
-  get name() {
-    return fe;
-  }
-  /**
-   * Gets the order of this interceptor.
-   *
-   * @returns VALIDATE_STATUS_INTERCEPTOR_ORDER, indicating this interceptor should execute early
-   */
-  get order() {
-    return ye;
-  }
-  /**
-   * 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(e) {
-    if (!e.response)
-      return;
-    const t = e.response.status;
-    if (!this.validateStatus(t))
-      throw new pe(e);
-  }
-}
-class ge {
-  constructor() {
-    this.request = new l([
-      new oe(),
-      new ce(),
-      new de()
-    ]), this.response = new l([
-      new Ee()
-    ]), this.error = new l();
-  }
-  /**
-   * 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(e) {
-    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 g(e);
-    }
-  }
-}
-function d(r, e) {
-  return e && e.resultExtractor && e.attributes ? e : {
-    resultExtractor: e?.resultExtractor ?? r?.resultExtractor ?? z.resultExtractor,
-    attributes: e?.attributes ?? r?.attributes
-  };
-}
-const y = {
-  [h]: C.APPLICATION_JSON
-}, F = {
-  baseURL: "",
-  headers: y
-}, z = {
-  resultExtractor: R.Exchange
-}, q = {
-  resultExtractor: R.Response
-};
-class we {
-  /**
-   * Initializes a new Fetcher instance with optional configuration.
-   *
-   * Creates a Fetcher with default settings that can be overridden through the options parameter.
-   * 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 = F) {
-    this.headers = y, this.urlBuilder = new W(e.baseURL, e.urlTemplateStyle), this.headers = e.headers ?? y, this.timeout = e.timeout, this.interceptors = e.interceptors ?? new ge();
-  }
-  /**
-   * Processes an HTTP request through the Fetcher's internal workflow.
-   *
-   * This method creates a FetchExchange object and passes it through the interceptor chain.
-   * It handles header merging, timeout resolution, and result extractor configuration.
-   *
-   * @param request - The HTTP request configuration to process
-   * @param options - Optional request options including result extractor and attributes
-   * @returns Promise that resolves to the processed FetchExchange object
-   */
-  async exchange(e, t) {
-    const s = {
-      ...this.headers,
-      ...e.headers
-    }, n = {
-      ...e,
-      headers: s,
-      timeout: Z(e.timeout, this.timeout)
-    }, { resultExtractor: a, attributes: i } = d(
-      z,
-      t
-    ), c = new ne({
-      fetcher: this,
-      request: n,
-      resultExtractor: a,
-      attributes: i
-    });
-    return await this.interceptors.exchange(c);
-  }
-  /**
-   * Processes an HTTP request through the Fetcher's internal workflow.
-   *
-   * This method prepares the request by merging headers and timeout settings,
-   * 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 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) {
-    return await (await this.exchange(e, t)).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.
-   *
-   * @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(e, t = {}, s) {
-    const n = {
-      ...t,
-      url: e
-    };
-    return await this.request(
-      n,
-      d(q, s)
-    );
-  }
-  /**
-   * Internal helper method for making HTTP requests with a specific method.
-   *
-   * 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 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 = {}, n) {
-    const a = {
-      ...s,
-      url: t,
-      method: e
-    };
-    return await this.request(
-      a,
-      d(q, n)
-    );
-  }
-  /**
-   * Makes a GET HTTP request.
-   *
-   * 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 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) {
-    return await this.methodFetch(o.GET, e, t, s);
-  }
-  /**
-   * Makes a PUT HTTP request.
-   *
-   * 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 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) {
-    return await this.methodFetch(o.PUT, e, t, s);
-  }
-  /**
-   * Makes a POST HTTP request.
-   *
-   * 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 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) {
-    return await this.methodFetch(o.POST, e, t, s);
-  }
-  /**
-   * Makes a PATCH HTTP request.
-   *
-   * 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 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 patch(e, t = {}, s) {
-    return await this.methodFetch(o.PATCH, e, t, s);
-  }
-  /**
-   * Makes a DELETE HTTP request.
-   *
-   * 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 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 delete(e, t = {}, s) {
-    return await this.methodFetch(o.DELETE, e, t, s);
-  }
-  /**
-   * Makes a HEAD HTTP request.
-   *
-   * 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 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) {
-    return await this.methodFetch(o.HEAD, e, t, s);
-  }
-  /**
-   * Makes an OPTIONS HTTP request.
-   *
-   * 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 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) {
-    return await this.methodFetch(o.OPTIONS, e, t, s);
-  }
-  /**
-   * Sends an HTTP TRACE request to the specified URL and returns the response.
-   *
-   * The TRACE method is used to echo the received request for debugging purposes.
-   * This method automatically sets the HTTP method to TRACE and omits the request body
-   * since TRACE requests must not have a body according to the HTTP specification.
-   *
-   * @param url - The target URL for the TRACE request. Must be a valid absolute or relative URL.
-   * @param request - Request configuration options excluding 'method' and 'body' properties.
-   *                  Defaults to an empty object. Common properties include headers, cache settings, etc.
-   * @param options - Optional additional request parameters for extended functionality.
-   *                  May include custom handling logic or metadata for the request pipeline.
-   * @returns A Promise resolving to the response object of type R (defaults to Response).
-   *          The response contains status, headers, and body data from the TRACE request.
-   */
-  async trace(e, t = {}, s) {
-    return await this.methodFetch(o.TRACE, e, t, s);
-  }
-}
-const E = "default";
-class Re {
-  constructor() {
-    this.registrar = /* @__PURE__ */ new Map();
-  }
-  /**
-   * Register a Fetcher instance with a given name
-   *
-   * @param name - The name to register the fetcher under
-   * @param fetcher - The Fetcher instance to register
-   * @example
-   * const fetcher = new Fetcher({ baseURL: 'https://api.example.com' });
-   * fetcherRegistrar.register('api', fetcher);
-   */
-  register(e, t) {
-    this.registrar.set(e, t);
-  }
-  /**
-   * Unregister a Fetcher instance by name
-   *
-   * @param name - The name of the fetcher to unregister
-   * @returns boolean - True if the fetcher was successfully unregistered, false otherwise
-   * @example
-   * const success = fetcherRegistrar.unregister('api');
-   * if (success) {
-   *   console.log('Fetcher unregistered successfully');
-   * }
-   */
-  unregister(e) {
-    return this.registrar.delete(e);
-  }
-  /**
-   * Get a Fetcher instance by name
-   *
-   * @param name - The name of the fetcher to retrieve
-   * @returns Fetcher | undefined - The Fetcher instance if found, undefined otherwise
-   * @example
-   * const fetcher = fetcherRegistrar.get('api');
-   * if (fetcher) {
-   *   // Use the fetcher
-   * }
-   */
-  get(e) {
-    return this.registrar.get(e);
-  }
-  /**
-   * Get a Fetcher instance by name, throwing an error if not found
-   *
-   * @param name - The name of the fetcher to retrieve
-   * @returns Fetcher - The Fetcher instance
-   * @throws Error - If no fetcher is registered with the given name
-   * @example
-   * try {
-   *   const fetcher = fetcherRegistrar.requiredGet('api');
-   *   // Use the fetcher
-   * } catch (error) {
-   *   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;
-  }
-  /**
-   * Get the default Fetcher instance
-   *
-   * @returns Fetcher - The default Fetcher instance
-   * @throws Error - If no default fetcher is registered
-   * @example
-   * const defaultFetcher = fetcherRegistrar.default;
-   */
-  get default() {
-    return this.requiredGet(E);
-  }
-  /**
-   * Set the default Fetcher instance
-   *
-   * @param fetcher - The Fetcher instance to set as default
-   * @example
-   * const fetcher = new Fetcher({ baseURL: 'https://api.example.com' });
-   * fetcherRegistrar.default = fetcher;
-   */
-  set default(e) {
-    this.register(E, e);
-  }
-  /**
-   * Get a copy of all registered fetchers
-   *
-   * @returns Map<string, Fetcher> - A copy of the internal registrar map
-   * @example
-   * const allFetchers = fetcherRegistrar.fetchers;
-   * for (const [name, fetcher] of allFetchers) {
-   *   console.log(`Fetcher ${name}:`, fetcher);
-   * }
-   */
-  get fetchers() {
-    return new Map(this.registrar);
-  }
-}
-const Te = new Re();
-class Pe extends we {
-  /**
-   * Create a NamedFetcher instance and automatically register it with the global fetcherRegistrar
-   *
-   * @param name - The name to register this fetcher under
-   * @param options - Fetcher configuration options (same as Fetcher constructor)
-   *
-   * @example
-   * // Create with default options
-   * const fetcher1 = new NamedFetcher('default');
-   *
-   * // Create with custom options
-   * const fetcher2 = new NamedFetcher('api', {
-   *   baseURL: 'https://api.example.com',
-   *   timeout: 5000,
-   *   headers: { 'Authorization': 'Bearer token' }
-   * });
-   */
-  constructor(e, t = F) {
-    super(t), this.name = e, Te.register(e, this);
-  }
-}
-new Pe(E);
-class Ae {
-  constructor() {
-    this.eventHandlers = [];
-  }
-  /**
-   * Gets a copy of all registered event handlers, sorted by order
-   */
-  get handlers() {
-    return [...this.eventHandlers];
-  }
-  destroy() {
-    this.eventHandlers = [];
-  }
-  async handleEvent(e, t) {
-    try {
-      e.handle(t);
-    } catch (s) {
-      console.warn(`Event handler error for ${e.name}:`, s);
-    }
-  }
-}
-class qe extends Ae {
-  /**
-   * Creates an in-memory typed event bus
-   *
-   * @param type - The event type identifier for this bus
-   */
-  constructor(e) {
-    super(), this.type = e;
-  }
-  /**
-   * Emits an event to all registered handlers serially
-   *
-   * Handlers are executed in order of their priority. Once-only handlers are removed after execution.
-   * Errors in individual handlers are logged but do not stop other handlers.
-   *
-   * @param event - The event to emit
-   */
-  async emit(e) {
-    const t = [];
-    for (const s of this.eventHandlers)
-      await this.handleEvent(s, e), s.once && t.push(s);
-    t.length > 0 && (this.eventHandlers = u(
-      this.eventHandlers.filter((s) => !t.includes(s))
-    ));
-  }
-  /**
-   * Removes an event handler by name
-   *
-   * @param name - The name of the handler to remove
-   * @returns true if a handler was removed, false otherwise
-   */
-  off(e) {
-    const t = this.eventHandlers;
-    return t.some((s) => s.name === e) ? (this.eventHandlers = u(t, (s) => s.name !== e), !0) : !1;
-  }
-  /**
-   * Adds an event handler if not already present
-   *
-   * Handlers are sorted by their order property after addition.
-   *
-   * @param handler - The event handler to add
-   * @returns true if the handler was added, false if a handler with the same name already exists
-   */
-  on(e) {
-    const t = this.eventHandlers;
-    return t.some((s) => s.name === e.name) ? !1 : (this.eventHandlers = u([...t, e]), !0);
-  }
-}
-class xe {
-  constructor() {
-    this.namingCounter = 0;
-  }
-  /**
-   * Generates a unique name by appending an incrementing counter to the prefix
-   * @param prefix - The prefix for the generated name
-   * @returns The generated unique name
-   */
-  generate(e) {
-    return this.namingCounter++, `${e}_${this.namingCounter}`;
-  }
-}
-const be = new xe();
-class Ie {
+class m {
   /**
    * Creates a new KeyStorage instance
    * @param options Configuration options for the storage
    */
   constructor(e) {
     this.cacheValue = null, this.keyStorageHandler = {
-      name: be.generate("KeyStorage"),
+      name: i.generate("KeyStorage"),
       handle: (t) => {
         this.cacheValue = t.newValue ?? null;
       }
-    }, this.key = e.key, this.serializer = e.serializer ?? L(), this.storage = e.storage ?? V(), this.eventBus = e.eventBus ?? new qe(
+    }, this.key = e.key, this.serializer = e.serializer ?? y(), this.storage = e.storage ?? o(), this.eventBus = e.eventBus ?? new n(
       `KeyStorage:${this.key}`
     ), this.eventBus.on(this.keyStorageHandler);
   }
@@ -1434,14 +135,14 @@ class Ie {
   }
 }
 export {
-  G as IdentitySerializer,
-  $ as InMemoryStorage,
-  k as JsonSerializer,
-  Ie as KeyStorage,
-  V as getStorage,
-  U as identitySerializer,
-  B as isBrowser,
-  ve as jsonSerializer,
-  L as typedIdentitySerializer
+  u as IdentitySerializer,
+  a as InMemoryStorage,
+  h as JsonSerializer,
+  m as KeyStorage,
+  o as getStorage,
+  c as identitySerializer,
+  l as isBrowser,
+  d as jsonSerializer,
+  y as typedIdentitySerializer
 };
 //# sourceMappingURL=index.es.js.map