@ahoo-wang/fetcher-storage 2.8.6 → 2.9.0

package/dist/index.es.js

@@ -1,9 +1,6 @@
-function a() {
-  return typeof window < "u";
-}
-class n {
+class z {
   constructor() {
-    this.store = /* @__PURE__ */ new Map(), this.listeners = /* @__PURE__ */ new Set();
+    this.store = /* @__PURE__ */ new Map();
   }
   /**
    * Gets the number of items stored in the storage.
@@ -39,12 +36,7 @@ class n {
    * @param key - The key of the item to remove
    */
   removeItem(e) {
-    const t = this.getItem(e);
-    this.store.has(e) && (this.store.delete(e), this.notifyListeners({
-      key: e,
-      oldValue: t,
-      newValue: null
-    }));
+    this.store.delete(e);
   }
   /**
    * Sets an item in the storage.
@@ -52,219 +44,1405 @@ class n {
    * @param value - The value to set
    */
   setItem(e, t) {
-    const r = this.getItem(e);
-    this.store.set(e, t), this.notifyListeners({ key: e, oldValue: r, newValue: t });
+    this.store.set(e, t);
   }
+}
+function M() {
+  return typeof window < "u";
+}
+const $ = () => M() ? window.localStorage : new z();
+class B {
   /**
-   * Adds a listener for storage changes.
-   * @param listener - The listener function to be called when storage changes
-   * @returns A function that can be called to remove the listener
+   * Serializes a value to a JSON string
+   * @param value The value to serialize
+   * @returns The JSON string representation of the value
    */
-  addListener(e) {
-    return this.listeners.add(e), () => this.listeners.delete(e);
+  serialize(e) {
+    return JSON.stringify(e);
   }
   /**
-   * Notifies all listeners of a storage change by creating and dispatching a StorageEvent.
-   * @param eventInit - The initialization object for the StorageEvent
+   * Deserializes a JSON string to a value
+   * @param value The JSON string to deserialize
+   * @returns The deserialized value
    */
-  notifyListeners(e) {
-    a() && window.location && (e.url = e.url || window.location.href), e.storageArea = this, this.listeners.forEach((t) => {
-      try {
-        t(e);
-      } catch (r) {
-        console.error("Error in storage change listener:", r);
-      }
-    });
+  deserialize(e) {
+    return JSON.parse(e);
   }
 }
-class o {
+class V {
   /**
-   * Creates a new BrowserListenableStorage instance.
-   * @param storage - The native Storage object to wrap (e.g., localStorage or sessionStorage)
+   * Returns the value as-is without serialization
+   * @param value The value to pass through
+   * @returns The same value that was passed in
+   */
+  serialize(e) {
+    return e;
+  }
+  /**
+   * Returns the value as-is without deserialization
+   * @param value The value to pass through
+   * @returns The same value that was passed in
+   */
+  deserialize(e) {
+    return e;
+  }
+}
+const qe = new B(), k = new V();
+function G() {
+  return k;
+}
+function U(r) {
+  return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(r);
+}
+function L(r, e) {
+  return U(e) ? e : e ? r.replace(/\/?\/$/, "") + "/" + e.replace(/^\/+/, "") : r;
+}
+function j(r) {
+  return r === 1 ? K : D;
+}
+function S(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 I(r, e) {
+  const t = [];
+  let s;
+  for (; (s = e.exec(r)) !== null; )
+    t.push(s[1]);
+  return t;
+}
+const b = class f {
+  /**
+   * 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 I(
+      e,
+      f.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 S(
+      e,
+      f.PATH_PARAM_REGEX,
+      t
+    );
+  }
+};
+b.PATH_PARAM_REGEX = /{([^}]+)}/g;
+let X = b;
+const D = new X(), H = class y {
+  /**
+   * 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 I(
+      e,
+      y.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 S(
+      e,
+      y.PATH_PARAM_REGEX,
+      t
+    );
+  }
+};
+H.PATH_PARAM_REGEX = /:([^/]+)/g;
+let J = H;
+const K = new J();
+class Q {
+  /**
+   * 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 = j(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 = L(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);
+  }
+}
+class d 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);
+  }
+}
+class l extends d {
+  /**
+   * 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, l.prototype);
+  }
+}
+class R extends d {
+  /**
+   * Creates a new FetchTimeoutError instance.
+   *
+   * @param request - The request options that timed out
    */
   constructor(e) {
-    this.storage = 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, R.prototype);
+  }
+}
+function Y(r, e) {
+  return typeof r < "u" ? r : e;
+}
+async function W(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, F) => {
+    a = setTimeout(() => {
+      a && clearTimeout(a);
+      const A = new R(r);
+      n.abort(A), F(A);
+    }, t);
+  });
+  try {
+    return await Promise.race([fetch(e, s), i]);
+  } finally {
+    a && clearTimeout(a);
   }
+}
+const Z = (r) => r, ee = (r) => r.requiredResponse, T = {
   /**
-   * Gets the number of items stored in the storage.
+   * Returns the original FetchExchange object
    */
-  get length() {
-    return this.storage.length;
+  Exchange: Z,
+  /**
+   * Extracts the raw Response object
+   */
+  Response: ee
+};
+function te(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 re {
+  constructor(e) {
+    this.fetcher = e.fetcher, this.request = e.request, this.resultExtractor = e.resultExtractor ?? T.Exchange, this.attributes = te(e.attributes), this._response = e.response, this.error = e.error;
   }
   /**
-   * Adds a listener for storage changes.
-   * @param listener - The listener function to be called when storage changes
-   * @returns A function that can be called to remove the listener
+   * 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
    */
-  addListener(e) {
-    const t = (r) => {
-      r.storageArea === this.storage && e(r);
-    };
-    return window.addEventListener(i, t), () => window.removeEventListener(i, t);
+  ensureRequestHeaders() {
+    return this.request.headers || (this.request.headers = {}), this.request.headers;
   }
   /**
-   * Clears all items from the storage.
+   * 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 l(
+        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", E = class {
+};
+E.APPLICATION_JSON = "application/json", E.TEXT_EVENT_STREAM = "text/event-stream";
+let O = E;
+const se = "UrlResolveInterceptor", C = Number.MIN_SAFE_INTEGER + 1e3;
+class ne {
+  constructor() {
+    this.name = se, this.order = C;
+  }
+  /**
+   * 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 ae = "RequestBodyInterceptor", oe = C + 1e3;
+class ie {
+  constructor() {
+    this.name = ae, this.order = oe;
+  }
+  /**
+   * 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] = O.APPLICATION_JSON));
+  }
+}
+const ue = "FetchInterceptor", ce = Number.MAX_SAFE_INTEGER - 1e3;
+class he {
+  constructor() {
+    this.name = ue, this.order = ce;
+  }
+  /**
+   * 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 W(e.request);
+  }
+}
+const q = 0;
+function x(r, e) {
+  return (r.order ?? q) - (e.order ?? q);
+}
+function u(r, e) {
+  return e ? r.filter(e).sort(x) : [...r].sort(x);
+}
+let p = class {
+  /**
+   * 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.storage.clear();
+    this.sortedInterceptors = [];
   }
   /**
-   * Gets an item from the storage.
-   * @param key - The key of the item to retrieve
-   * @returns The value of the item, or null if the item does not exist
+   * 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.
    */
-  getItem(e) {
-    return this.storage.getItem(e);
+  async intercept(e) {
+    for (const t of this.sortedInterceptors)
+      await t.intercept(e);
+  }
+};
+class P extends l {
+  constructor(e) {
+    super(
+      e,
+      `Request failed with status code ${e.response?.status} for ${e.request.url}`
+    ), this.name = "HttpStatusValidationError", Object.setPrototypeOf(this, P.prototype);
   }
+}
+const le = (r) => r >= 200 && r < 300, de = "ValidateStatusInterceptor", pe = Number.MAX_SAFE_INTEGER - 1e3;
+class me {
   /**
-   * Gets the key at the specified index.
-   * @param index - The index of the key to retrieve
-   * @returns The key at the specified index, or null if the index is out of bounds
+   * Creates a new ValidateStatusInterceptor instance.
+   *
+   * @param validateStatus - Function that determines if a status code is valid
    */
-  key(e) {
-    return this.storage.key(e);
+  constructor(e = le) {
+    this.validateStatus = e;
   }
   /**
-   * Removes an item from the storage.
-   * @param key - The key of the item to remove
+   * Gets the name of this interceptor.
+   *
+   * @returns The name of this interceptor
    */
-  removeItem(e) {
-    this.storage.removeItem(e);
+  get name() {
+    return de;
   }
   /**
-   * Sets an item in the storage.
-   * @param key - The key of the item to set
-   * @param value - The value to set
+   * Gets the order of this interceptor.
+   *
+   * @returns VALIDATE_STATUS_INTERCEPTOR_ORDER, indicating this interceptor should execute early
    */
-  setItem(e, t) {
-    this.storage.setItem(e, t);
+  get order() {
+    return pe;
+  }
+  /**
+   * 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 P(e);
   }
 }
-const i = "storage", h = () => a() ? new o(window.localStorage) : new n();
-class l {
+class fe {
+  constructor() {
+    this.request = new p([
+      new ne(),
+      new ie(),
+      new he()
+    ]), this.response = new p([
+      new me()
+    ]), this.error = new p();
+  }
   /**
-   * Serializes a value to a JSON string
-   * @param value The value to serialize
-   * @returns The JSON string representation of the value
+   * 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 l(e);
+    }
+  }
+}
+function m(r, e) {
+  return e && e.resultExtractor && e.attributes ? e : {
+    resultExtractor: e?.resultExtractor ?? r?.resultExtractor ?? _.resultExtractor,
+    attributes: e?.attributes ?? r?.attributes
+  };
+}
+const g = {
+  [h]: O.APPLICATION_JSON
+}, N = {
+  baseURL: "",
+  headers: g
+}, _ = {
+  resultExtractor: T.Exchange
+}, v = {
+  resultExtractor: T.Response
+};
+class ye {
   /**
-   * Serializes a value to a JSON string
-   * @param value The value to serialize
-   * @returns The JSON string representation of the value
+   * 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.
    */
-  serialize(e) {
-    return JSON.stringify(e);
+  constructor(e = N) {
+    this.headers = g, this.urlBuilder = new Q(e.baseURL, e.urlTemplateStyle), this.headers = e.headers ?? g, this.timeout = e.timeout, this.interceptors = e.interceptors ?? new fe();
   }
   /**
-   * Deserializes a JSON string to a value
-   * @template V The type of the deserialized value
-   * @param value The JSON string to deserialize
-   * @returns The deserialized value
+   * 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: Y(e.timeout, this.timeout)
+    }, { resultExtractor: a, attributes: i } = m(
+      _,
+      t
+    ), c = new re({
+      fetcher: this,
+      request: n,
+      resultExtractor: a,
+      attributes: i
+    });
+    return await this.interceptors.exchange(c);
+  }
   /**
-   * Deserializes a JSON string to a value
-   * @param value The JSON string to deserialize
-   * @returns The deserialized value
+   * 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
    */
-  deserialize(e) {
-    return JSON.parse(e);
+  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,
+      m(v, 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,
+      m(v, 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);
   }
 }
-class c {
+const w = "default";
+class Ee {
+  constructor() {
+    this.registrar = /* @__PURE__ */ new Map();
+  }
   /**
-   * Returns the value as-is without serialization
-   * @param value The value to pass through
-   * @returns The same value that was passed in
+   * 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);
+  }
   /**
-   * Returns the value as-is without serialization
-   * @param value The value to pass through
-   * @returns The same value that was passed in
+   * 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');
+   * }
    */
-  serialize(e) {
-    return e;
+  unregister(e) {
+    return this.registrar.delete(e);
   }
   /**
-   * Returns the value as-is without deserialization
-   * @template Deserialized The type of the deserialized value
-   * @param value The value to pass through
-   * @returns The same value that was passed in, cast to the target type
+   * 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);
+  }
   /**
-   * Returns the value as-is without deserialization
-   * @param value The value to pass through
-   * @returns The same value that was passed in
+   * 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);
+   * }
    */
-  deserialize(e) {
-    return e;
+  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(w);
+  }
+  /**
+   * 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(w, 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 ge = new Ee();
+class we extends ye {
+  /**
+   * 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 = N) {
+    super(t), this.name = e, ge.register(e, this);
   }
 }
-const d = new l(), u = new c();
-function g() {
-  return u;
+new we(w);
+class Re {
+  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 w {
+class Te extends Re {
   /**
-   * Creates a new KeyStorage instance
-   * @param options Configuration options for the storage
+   * Creates an in-memory typed event bus
+   *
+   * @param type - The event type identifier for this bus
    */
   constructor(e) {
-    this.cacheValue = null, this.refreshCacheListener = (t) => {
-      this.cacheValue = null, t.newValue && this.refreshCache(t.newValue);
-    }, this.key = e.key, this.serializer = e.serializer ?? g(), this.storage = e.storage ?? h(), this.addListener(this.refreshCacheListener);
+    super(), this.type = e;
   }
   /**
-   * Refreshes the cached value by deserializing the provided string
-   * @param value The serialized value to deserialize and cache
+   * 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
    */
-  refreshCache(e) {
-    this.cacheValue = this.serializer.deserialize(e);
+  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))
+    ));
   }
-  addListener(e) {
-    const t = (r) => {
-      r.key === this.key && e(r);
-    };
-    return this.storage.addListener(t);
+  /**
+   * 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 Pe {
+  constructor() {
+    this.namingCounter = 0;
   }
   /**
-   * Gets the value associated with the key from storage
-   * Uses cached value if available, otherwise retrieves from storage and caches it
-   * @returns The deserialized value or null if no value is found
+   * 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 Ae = new Pe();
+class Se {
+  /**
+   * Creates a new KeyStorage instance
+   * @param options Configuration options for the storage
+   */
+  constructor(e) {
+    this.cacheValue = null, this.keyStorageHandler = {
+      name: Ae.generate("KeyStorage"),
+      handle: (t) => {
+        this.cacheValue = t.newValue ?? null;
+      }
+    }, this.key = e.key, this.serializer = e.serializer ?? G(), this.storage = e.storage ?? $(), this.eventBus = e.eventBus ?? new Te(
+      `KeyStorage:${this.key}`
+    ), this.eventBus.on(this.keyStorageHandler);
+  }
+  addListener(e) {
+    return this.eventBus.on(e), () => this.eventBus.off(e.name);
+  }
   get() {
     if (this.cacheValue)
       return this.cacheValue;
     const e = this.storage.getItem(this.key);
-    return e ? (this.refreshCache(e), this.cacheValue) : null;
+    return e ? (this.cacheValue = this.serializer.deserialize(e), this.cacheValue) : null;
   }
-  /**
-   * Sets the value associated with the key in storage
-   * Also updates the cached value
-   * @param value The value to serialize and store
-   */
   set(e) {
-    const t = this.serializer.serialize(e);
-    this.storage.setItem(this.key, t), this.cacheValue = e;
+    const t = this.get(), s = this.serializer.serialize(e);
+    this.storage.setItem(this.key, s), this.cacheValue = e, this.eventBus.emit({
+      newValue: e,
+      oldValue: t
+    });
   }
-  /**
-   * Removes the value associated with the key from storage
-   * Also clears the cached value
-   */
   remove() {
-    this.storage.removeItem(this.key), this.cacheValue = null;
+    const e = this.get();
+    this.storage.removeItem(this.key), this.cacheValue = null, this.eventBus.emit({
+      oldValue: e,
+      newValue: null
+    });
+  }
+  destroy() {
+    this.eventBus.off(this.keyStorageHandler.name);
   }
 }
 export {
-  o as BrowserListenableStorage,
-  c as IdentitySerializer,
-  n as InMemoryListenableStorage,
-  l as JsonSerializer,
-  w as KeyStorage,
-  i as STORAGE_EVENT_TYPE,
-  h as createListenableStorage,
-  u as identitySerializer,
-  a as isBrowser,
-  d as jsonSerializer,
-  g as typedIdentitySerializer
+  V as IdentitySerializer,
+  z as InMemoryStorage,
+  B as JsonSerializer,
+  Se as KeyStorage,
+  $ as getStorage,
+  k as identitySerializer,
+  M as isBrowser,
+  qe as jsonSerializer,
+  G as typedIdentitySerializer
 };
 //# sourceMappingURL=index.es.js.map