@enegalan/request-manager 1.0.10 → 1.1.1

package/dist/request-manager.umd.js

@@ -1,604 +1,707 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
-    typeof define === 'function' && define.amd ? define(factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.RequestManager = factory());
+  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+  typeof define === 'function' && define.amd ? define(factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.RequestManager = factory());
 })(this, (function () { 'use strict';
 
-    /**
-     * RequestManager - A library for managing and regulating HTTP requests efficiently.
-     * @license MIT
-     * @author Eneko Galan <enekogalanelorza@gmail.com>
-     * This library allows you to manage HTTP requests from any library (ajax, Ext.Ajax, axios, fetch, etc.)
-     * by accepting Promises as parameters. When a request is repeated with the same identifier,
-     * the previous request is automatically cancelled and the new one is executed, giving priority to the most recent requests.
-     */
-    class RequestManager {
-        constructor(options = {}) {
-            /**
-             * Map to store active requests by their unique identifier.
-             * @type {Map<string, import('./index.d.ts').ActiveRequest>}
-             */
-            this.activeRequests = new Map();
-            /**
-             * @type {import('./index.d.ts').Options}
-             */
-            this.options = options;
-            /**
-             * One-shot AbortController for getSignal()/getAbortController() handoff.
-             * Consumed by the next request that does not pass options.abortController.
-             * @type {AbortController|null}
-             */
-            this.abortController = null;
-        }
-
-        /**
-         * Gets the manager options
-         * @returns {import('./index.d.ts').Options} Manager options
-         */
-        getOptions() {
-            return this.options;
-        }
-
-        /**
-         * Sets the manager options
-         * @param {import('./index.d.ts').Options} options - The options to set
-         */
-        setOptions(options) {
-            this.options = options;
-        }
-
-        /**
-         * Creates a new AbortController and returns its signal for the next request()
-         * (one getSignal → one request). Do not use for parallel requests; use fetch(),
-         * axios(), or request(url, ({ options }) => ...) instead — they create their own signal.
-         * @returns {AbortSignal} The signal from a new AbortController
-         * @example
-         * const signal = requestManager.getSignal();
-         * requestManager.request('/api/users', fetch('/api/users', { signal }));
-         */
-        getSignal() {
-            return this.getAbortController().signal;
-        }
-
-        /**
-         * Creates a new AbortController for the next request handoff.
-         * Always returns a fresh controller (never reuses one from another in-flight request).
-         * @returns {AbortController} A new AbortController instance
-         */
-        getAbortController() {
-            this.abortController = new AbortController();
-            return this.abortController;
-        }
-
-        /**
-         * Checks if a request with the given identifier is currently active.
-         * @param {string} requestId - The unique identifier to check
-         * @returns {boolean} True if the request is active, false otherwise
-         */
-        isActive(requestId) {
-            return this.activeRequests.has(requestId);
-        }
-
-        /**
-         * Gets the number of active requests.
-         * @returns {number} The number of currently active requests
-         */
-        getActiveCount() {
-            return this.activeRequests.size;
+  function _arrayLikeToArray(r, a) {
+    (null == a || a > r.length) && (a = r.length);
+    for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+    return n;
+  }
+  function _arrayWithHoles(r) {
+    if (Array.isArray(r)) return r;
+  }
+  function _assertClassBrand(e, t, n) {
+    if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
+    throw new TypeError("Private element is not present on this object");
+  }
+  function _checkPrivateRedeclaration(e, t) {
+    if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+  }
+  function _classPrivateMethodInitSpec(e, a) {
+    _checkPrivateRedeclaration(e, a), a.add(e);
+  }
+  function _defineProperty(e, r, t) {
+    return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+      value: t,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    }) : e[r] = t, e;
+  }
+  function _iterableToArrayLimit(r, l) {
+    var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+    if (null != t) {
+      var e,
+        n,
+        i,
+        u,
+        a = [],
+        f = true,
+        o = false;
+      try {
+        if (i = (t = t.call(r)).next, 0 === l) ; else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+      } catch (r) {
+        o = true, n = r;
+      } finally {
+        try {
+          if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
+        } finally {
+          if (o) throw n;
         }
+      }
+      return a;
+    }
+  }
+  function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  function ownKeys(e, r) {
+    var t = Object.keys(e);
+    if (Object.getOwnPropertySymbols) {
+      var o = Object.getOwnPropertySymbols(e);
+      r && (o = o.filter(function (r) {
+        return Object.getOwnPropertyDescriptor(e, r).enumerable;
+      })), t.push.apply(t, o);
+    }
+    return t;
+  }
+  function _objectSpread2(e) {
+    for (var r = 1; r < arguments.length; r++) {
+      var t = null != arguments[r] ? arguments[r] : {};
+      r % 2 ? ownKeys(Object(t), true).forEach(function (r) {
+        _defineProperty(e, r, t[r]);
+      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
+        Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+      });
+    }
+    return e;
+  }
+  function _slicedToArray(r, e) {
+    return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
+  }
+  function _toPrimitive(t, r) {
+    if ("object" != typeof t || !t) return t;
+    var e = t[Symbol.toPrimitive];
+    if (void 0 !== e) {
+      var i = e.call(t, r);
+      if ("object" != typeof i) return i;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return ("string" === r ? String : Number)(t);
+  }
+  function _toPropertyKey(t) {
+    var i = _toPrimitive(t, "string");
+    return "symbol" == typeof i ? i : i + "";
+  }
+  function _unsupportedIterableToArray(r, a) {
+    if (r) {
+      if ("string" == typeof r) return _arrayLikeToArray(r, a);
+      var t = {}.toString.call(r).slice(8, -1);
+      return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+    }
+  }
+
+  var _RequestManager_brand = /*#__PURE__*/new WeakSet();
+  /**
+   * RequestManager - A library for managing and regulating HTTP requests efficiently.
+   * @license MIT
+   * @author Eneko Galan <enekogalanelorza@gmail.com>
+   * This library allows you to manage HTTP requests from any library (ajax, Ext.Ajax, axios, fetch, etc.)
+   * by accepting Promises as parameters. When a request is repeated with the same identifier,
+   * the previous request is automatically cancelled and the new one is executed, giving priority to the most recent requests.
+   */
+  class RequestManager {
+    constructor() {
+      var _options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      /**
+       * Resolves the AbortController for a request: explicit option, pending handoff, or new.
+       * Clears the pending handoff so concurrent requests do not share it.
+       * @param {AbortController|undefined} provided - Optional AbortController from options
+       * @returns {AbortController}
+       * @private
+       */
+      _classPrivateMethodInitSpec(this, _RequestManager_brand);
+      /**
+       * @type {Map<string, import('./index.d.ts').ActiveRequest>}
+       */
+      this.activeRequests = new Map();
+      /**
+       * @type {import('./index.d.ts').Options}
+       */
+      this.options = _options;
+      /**
+       * One-shot AbortController for getSignal()/getAbortController() handoff.
+       * Consumed by the next request that does not pass options.abortController.
+       * @type {AbortController|null}
+       */
+      this.abortController = null;
+    }
 
-        /**
-         * Clears all active requests without cancelling them.
-         * Use with caution - this will not cancel the underlying HTTP requests.
-         */
-        clear() {
-            this.activeRequests.clear();
-        }
+    /**
+     * Gets the manager options
+     * @returns {import('./index.d.ts').Options} Manager options
+     */
+    getOptions() {
+      return this.options;
+    }
 
-        /**
-         * Executes an HTTP request, cancelling any previous request with the same identifier.
-         * @param {string} url - The URL to request
-         * @param {Promise|import('./index.d.ts').RequestFunction|string} requestPromise - The request promise or function that returns a promise
-         * @param {import('./index.d.ts').RequestOptions} options - Optional configuration
-         * @returns {Promise} A Promise that resolves/rejects based on the most recent request
-         * @example
-         * // Request with Promise
-         * requestManager.request('/api/users', axios.get('/api/users', { cancelToken: axios.CancelToken.source().token }));
-         * @example
-         * // Request with Function
-         * requestManager.request('/api/users', ({ options }) => fetch('/api/users', { signal: options.signal, ...options }));
-         * @example
-         * // Request with Promise and custom cancellation grouping with requestKey
-         * const options = {
-         *   requestKey: 'get-users',
-         *   cancelToken: axios.CancelToken.source().cancel
-         * }
-         * requestManager.request('/api/users', axios.get('/api/users', options), options);
-         */
-        request(url, requestPromise, options = {}) {
-            return this.#_request(this.getRequestId(url, options), requestPromise, options);
-        }
+    /**
+     * Sets the manager options
+     * @param {import('./index.d.ts').Options} options - The options to set
+     */
+    setOptions(options) {
+      this.options = options;
+    }
 
-        /**
-         * Executes an HTTP request using fetch, cancelling any previous request with the same identifier.
-         * @param {string} url - The URL to fetch
-         * @param {import('./index.d.ts').FetchOptions} options - Optional configuration
-         * @returns {Promise} A Promise that resolves/rejects based on the most recent request
-         * @example
-         * // Simple GET request
-         * requestManager.fetch('/api/users');
-         * @example
-         * // POST request with options
-         * requestManager.fetch('/api/users', {
-         *   method: 'POST',
-         *   headers: { 'Content-Type': 'application/json' },
-         *   body: JSON.stringify({ name: 'John' })
-         * });
-         * @example
-         * // Request with requestKey for custom cancellation grouping with requestKey
-         * requestManager.fetch('/api/users', {
-         *   requestKey: 'get-users'
-         * });
-         */
-        fetch(url, options = {}) {
-            return this.#_request(this.getRequestId(url, options), url, options);
-        }
+    /**
+     * Creates a new AbortController and returns its signal for the next request()
+     * (one getSignal → one request). Do not use for parallel requests; use fetch(),
+     * axios(), or request(url, ({ options }) => ...) instead — they create their own signal.
+     * @returns {AbortSignal} The signal from a new AbortController
+     * @example
+     * const signal = requestManager.getSignal();
+     * requestManager.request('/api/users', fetch('/api/users', { signal }));
+     */
+    getSignal() {
+      return this.getAbortController().signal;
+    }
 
-        /**
-         * Executes an HTTP request using axios, cancelling any previous request with the same identifier.
-         * @param {string} url - The URL to request
-         * @param {import('./index.d.ts').AxiosRequestOptions} options - Optional configuration
-         * @param {import('./index.d.ts').AxiosInstance|import('./index.d.ts').AxiosStatic|null} axiosInstance - Optional axios instance to use. If not provided, uses global axios.
-         * @returns {Promise} A Promise that resolves/rejects based on the most recent request
-         * @example
-         * // Simple GET request (uses global axios)
-         * requestManager.axios('/api/users');
-         * @example
-         * // With custom axios instance
-         * const myAxios = axios.create({ baseURL: 'https://api.example.com' });
-         * requestManager.axios('/users', {}, myAxios);
-         * @example
-         * // POST request with options
-         * requestManager.axios('/api/users', {
-         *   method: 'POST',
-         *   headers: { 'Content-Type': 'application/json' },
-         *   body: JSON.stringify({ name: 'John' })
-         * });
-         * @example
-         * // Request with requestKey for custom cancellation grouping with requestKey
-         * requestManager.axios('/api/users', {
-         *   requestKey: 'get-users'
-         * });
-         */
-        axios(url, options = {}, axiosInstance = null) {
-            const axiosLib = axiosInstance || axios;
-            const cancelToken = axiosLib.CancelToken.source();
-            const requestId = this.getRequestId(url, options);
-            return this.#_request(requestId, axiosLib({ url, cancelToken: cancelToken.token, ...options }), {
-                cancelToken: cancelToken,
-                ...options,
-            });
-        }
+    /**
+     * Creates a new AbortController for the next request handoff.
+     * Always returns a fresh controller (never reuses one from another in-flight request).
+     * @returns {AbortController} A new AbortController instance
+     */
+    getAbortController() {
+      this.abortController = new AbortController();
+      return this.abortController;
+    }
 
-        /**
-         * Executes an HTTP request using jQuery.ajax, cancelling any previous request with the same identifier.
-         * @param {import('./index.d.ts').AjaxFunction} ajaxFunction - A function that receives { url, ...options } and returns a Promise
-         * @param {string} url - The URL to request
-         * @param {import('./index.d.ts').BaseRequestOptions & Record<string, any>} options - Optional configuration
-         * @returns {Promise} A Promise that resolves/rejects based on the most recent request
-         * @example
-         * // Simple GET request
-         * requestManager.ajax(ajaxFunction, '/api/users');
-         * @example
-         * // POST request with options
-         * requestManager.ajax(ajaxFunction, '/api/users', {
-         *   method: 'POST',
-         *   headers: { 'Content-Type': 'application/json' },
-         *   body: JSON.stringify({ name: 'John' })
-         * });
-         * @example
-         * // Request with requestKey for custom cancellation grouping with requestKey
-         * requestManager.ajax(ajaxFunction, '/api/users', {
-         *   requestKey: 'get-users'
-         * });
-         */
-        ajax(ajaxFunction, url, options = {}) {
-            if (typeof ajaxFunction !== 'function') throw new Error('ajaxFunction parameter must be a function');
-            return this.#_request(
-                this.getRequestId(url, options),
-                ({ options: requestOptions }) => ajaxFunction({ url, ...requestOptions }),
-                options
-            );
-        }
+    /**
+     * Checks if a request with the given identifier is currently active.
+     * @param {string} requestId - The unique identifier to check
+     * @returns {boolean} True if the request is active, false otherwise
+     */
+    isActive(requestId) {
+      return this.activeRequests.has(requestId);
+    }
 
-        /**
-         * Executes an HTTP request using XMLHttpRequest, cancelling any previous request with the same identifier.
-         * @param {string} url - The URL to request
-         * @param {import('./index.d.ts').XhrOptions} options - Optional configuration
-         * @returns {Promise<import('./index.d.ts').XhrResponse>} A Promise that resolves/rejects based on the most recent request
-         * @example
-         * // Simple GET request
-         * requestManager.xhr('/api/users');
-         * @example
-         * // POST request with options
-         * requestManager.xhr('/api/users', {
-         *   method: 'POST',
-         *   headers: { 'Content-Type': 'application/json' },
-         *   body: JSON.stringify({ name: 'John' })
-         * });
-         * @example
-         * // Request with requestKey for custom cancellation grouping
-         * requestManager.xhr('/api/users', {
-         *   requestKey: 'get-users'
-         * });
-         */
-        xhr(url, options = {}) {
-            const requestId = this.getRequestId(url, options);
-            /** @type {import('./index.d.ts').RequestFunction<import('./index.d.ts').XhrResponse>} */
-            const xhrFunction = ({ options: fetchOptions }) => {
-                // Create XMLHttpRequest
-                const xhr = new XMLHttpRequest();
-                const method = (options.method || 'GET').toUpperCase();
-                // Create a promise that wraps the XHR request
-                const xhrPromise = new Promise((resolve, reject) => {
-                    xhr.onload = function () {
-                        if (xhr.status >= 200 && xhr.status < 300) {
-                            let response = xhr.response;
-                            if (
-                                options.responseType === 'json' ||
-                                (xhr.getResponseHeader('Content-Type') &&
-                                    xhr.getResponseHeader('Content-Type').includes('application/json'))
-                            ) {
-                                try {
-                                    response = JSON.parse(xhr.responseText);
-                                } catch {
-                                    response = xhr.responseText;
-                                }
-                            }
-                            resolve({
-                                data: response,
-                                status: xhr.status,
-                                statusText: xhr.statusText,
-                                headers: xhr.getAllResponseHeaders(),
-                                xhr: xhr,
-                            });
-                        } else {
-                            reject({
-                                message: `Request failed with status ${xhr.status}`,
-                                status: xhr.status,
-                                statusText: xhr.statusText,
-                                xhr: xhr,
-                            });
-                        }
-                    };
-                    xhr.onerror = function () {
-                        reject({
-                            message: 'Network error',
-                            xhr: xhr,
-                        });
-                    };
-                    xhr.ontimeout = function () {
-                        reject({
-                            message: 'Request timeout',
-                            xhr: xhr,
-                        });
-                    };
-
-                    // Open the request
-                    xhr.open(method, url, true);
-
-                    // Set response type
-                    if (options.responseType) xhr.responseType = options.responseType;
-                    // Set withCredentials
-                    if (options.withCredentials !== undefined) xhr.withCredentials = options.withCredentials;
-                    // Set timeout
-                    if (options.timeout !== undefined) xhr.timeout = options.timeout;
-                    // Set headers
-                    if (options.headers)
-                        Object.keys(options.headers).forEach((key) => {
-                            xhr.setRequestHeader(key, options.headers[key]);
-                        });
-
-                    // Connect abort signal to xhr.abort()
-                    if (fetchOptions.signal) fetchOptions.signal.addEventListener('abort', () => xhr.abort());
-
-                    // Send the request
-                    xhr.send(options.body || null);
-                });
-                return xhrPromise;
-            };
-            return this.#_request(requestId, xhrFunction, options);
-        }
+    /**
+     * Gets the number of active requests.
+     * @returns {number} The number of currently active requests
+     */
+    getActiveCount() {
+      return this.activeRequests.size;
+    }
 
-        /**
-         * Returns the request identifier for a URL and options.
-         * @param {string} url - The URL used when starting the request
-         * @param {import('./index.d.ts').BaseRequestOptions} options - Same options used for the request
-         * @returns {string} The request identifier
-         * @example
-         * requestManager.fetch('/api/users');
-         * const id = requestManager.getRequestId('/api/users');
-         * requestManager.cancel(id);
-         */
-        getRequestId(url, options = {}) {
-            let requestKey = options.requestKey;
-
-            const prefix = 'request_';
-
-            // Generate a unique identifier to prevent cancellation for non cancelable requests
-            if (options.noCancel) {
-                return `${prefix}${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
-            }
+    /**
+     * Clears all active requests without cancelling them.
+     * Use with caution - this will not cancel the underlying HTTP requests.
+     */
+    clear() {
+      this.activeRequests.clear();
+    }
 
-            // Handle function requestKey
-            if (typeof requestKey === 'function') {
-                try {
-                    requestKey = requestKey();
-                } catch {
-                    requestKey = null;
-                }
-            }
-            if (requestKey !== null && requestKey !== undefined) return `${prefix}${String(requestKey)}`;
-
-            // Use cleaned URL as key as fallback
-            let cleanedUrl = url || '';
-            if (cleanedUrl.includes('://')) cleanedUrl = cleanedUrl.split('://')[1];
-            if (cleanedUrl.includes('#')) cleanedUrl = cleanedUrl.split('#')[0];
-            if (!options.includeQuery && cleanedUrl.includes('?')) cleanedUrl = cleanedUrl.split('?')[0];
-            return `${prefix}${cleanedUrl}`;
-        }
+    /**
+     * Executes an HTTP request, cancelling any previous request with the same identifier.
+     * @param {string} url - The URL to request
+     * @param {Promise|import('./index.d.ts').RequestFunction|string} requestPromise - The request promise or function that returns a promise
+     * @param {import('./index.d.ts').RequestOptions} options - Optional configuration
+     * @returns {Promise} A Promise that resolves/rejects based on the most recent request
+     * @example
+     * // Request with Promise
+     * requestManager.request('/api/users', axios.get('/api/users'));
+     * @example
+     * // Request with Function
+     * requestManager.request('/api/users', ({ options }) => fetch('/api/users', { signal: options.signal, ...options }));
+     * @example
+     * // Request with Promise and custom cancellation grouping with requestKey
+     * const options = {
+     *   requestKey: 'get-users'
+     * }
+     * requestManager.request('/api/users', axios.get('/api/users', options), options);
+     */
+    request(url, requestPromise) {
+      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      return _assertClassBrand(_RequestManager_brand, this, _request).call(this, this.getRequestId(url, options), requestPromise, options);
+    }
 
-        /**
-         * Cancels a specific request by its identifier.
-         * @param {string} requestId - The unique identifier of the request to cancel
-         * @returns {boolean} True if the request was found and cancelled, false otherwise
-         */
-        cancel(requestId) {
-            /** @type {import('./index.d.ts').ActiveRequest|undefined} */
-            const requestInfo = this.activeRequests.get(requestId);
-            if (!requestInfo) return false;
+    /**
+     * Executes an HTTP request using fetch, cancelling any previous request with the same identifier.
+     * @param {string} url - The URL to fetch
+     * @param {import('./index.d.ts').FetchOptions} options - Optional configuration
+     * @returns {Promise} A Promise that resolves/rejects based on the most recent request
+     * @example
+     * // Simple GET request
+     * requestManager.fetch('/api/users');
+     * @example
+     * // POST request with options
+     * requestManager.fetch('/api/users', {
+     *   method: 'POST',
+     *   headers: { 'Content-Type': 'application/json' },
+     *   body: JSON.stringify({ name: 'John' })
+     * });
+     * @example
+     * // Request with requestKey for custom cancellation grouping with requestKey
+     * requestManager.fetch('/api/users', {
+     *   requestKey: 'get-users'
+     * });
+     */
+    fetch(url) {
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      return _assertClassBrand(_RequestManager_brand, this, _request).call(this, this.getRequestId(url, options), url, options);
+    }
 
-            requestInfo.isCancelled = true; // Mark as cancelled
+    /**
+     * Executes an HTTP request using axios, cancelling any previous request with the same identifier.
+     * @param {string} url - The URL to request
+     * @param {import('./index.d.ts').AxiosRequestOptions} options - Optional configuration
+     * @param {import('./index.d.ts').AxiosInstance|import('./index.d.ts').AxiosStatic|null} axiosInstance - Optional axios instance to use. If not provided, uses global axios.
+     * @returns {Promise} A Promise that resolves/rejects based on the most recent request
+     * @example
+     * // Simple GET request (uses global axios)
+     * requestManager.axios('/api/users');
+     * @example
+     * // With custom axios instance
+     * const myAxios = axios.create({ baseURL: 'https://api.example.com' });
+     * requestManager.axios('/users', {}, myAxios);
+     * @example
+     * // POST request with options
+     * requestManager.axios('/api/users', {
+     *   method: 'POST',
+     *   headers: { 'Content-Type': 'application/json' },
+     *   body: JSON.stringify({ name: 'John' })
+     * });
+     * @example
+     * // Request with requestKey for custom cancellation grouping with requestKey
+     * requestManager.axios('/api/users', {
+     *   requestKey: 'get-users'
+     * });
+     */
+    axios(url) {
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var axiosInstance = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+      var axiosLib = axiosInstance || axios;
+      _assertClassBrand(_RequestManager_brand, this, _checkAxiosVersion).call(this, axiosLib);
+      return _assertClassBrand(_RequestManager_brand, this, _request).call(this, this.getRequestId(url, options), _ref => {
+        var requestOptions = _ref.options;
+        return axiosLib(_objectSpread2({
+          url
+        }, requestOptions));
+      }, options);
+    }
 
-            // Try to abort using AbortController (for fetch)
-            if (requestInfo.abortController && !requestInfo.abortController.signal.aborted) {
-                try {
-                    requestInfo.abortController.abort('Request was cancelled');
-                } catch (error) {}
-            }
+    /**
+     * Executes an HTTP request using jQuery.ajax, cancelling any previous request with the same identifier.
+     * @param {import('./index.d.ts').AjaxFunction} ajaxFunction - A function that receives { url, ...options } and returns a Promise
+     * @param {string} url - The URL to request
+     * @param {import('./index.d.ts').BaseRequestOptions & Record<string, any>} options - Optional configuration
+     * @returns {Promise} A Promise that resolves/rejects based on the most recent request
+     * @example
+     * // Simple GET request
+     * requestManager.ajax(ajaxFunction, '/api/users');
+     * @example
+     * // POST request with options
+     * requestManager.ajax(ajaxFunction, '/api/users', {
+     *   method: 'POST',
+     *   headers: { 'Content-Type': 'application/json' },
+     *   body: JSON.stringify({ name: 'John' })
+     * });
+     * @example
+     * // Request with requestKey for custom cancellation grouping with requestKey
+     * requestManager.ajax(ajaxFunction, '/api/users', {
+     *   requestKey: 'get-users'
+     * });
+     */
+    ajax(ajaxFunction, url) {
+      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      if (typeof ajaxFunction !== 'function') throw new Error('ajaxFunction parameter must be a function');
+      return _assertClassBrand(_RequestManager_brand, this, _request).call(this, this.getRequestId(url, options), _ref2 => {
+        var requestOptions = _ref2.options;
+        return ajaxFunction(_objectSpread2({
+          url
+        }, requestOptions));
+      }, options);
+    }
 
-            // Try to cancel using cancel token/function (for axios and others)
-            if (requestInfo.cancelToken) {
+    /**
+     * Executes an HTTP request using XMLHttpRequest, cancelling any previous request with the same identifier.
+     * @param {string} url - The URL to request
+     * @param {import('./index.d.ts').XhrOptions} options - Optional configuration
+     * @returns {Promise<import('./index.d.ts').XhrResponse>} A Promise that resolves/rejects based on the most recent request
+     * @example
+     * // Simple GET request
+     * requestManager.xhr('/api/users');
+     * @example
+     * // POST request with options
+     * requestManager.xhr('/api/users', {
+     *   method: 'POST',
+     *   headers: { 'Content-Type': 'application/json' },
+     *   body: JSON.stringify({ name: 'John' })
+     * });
+     * @example
+     * // Request with requestKey for custom cancellation grouping
+     * requestManager.xhr('/api/users', {
+     *   requestKey: 'get-users'
+     * });
+     */
+    xhr(url) {
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var requestId = this.getRequestId(url, options);
+      /** @type {import('./index.d.ts').RequestFunction<import('./index.d.ts').XhrResponse>} */
+      var xhrFunction = _ref3 => {
+        var fetchOptions = _ref3.options;
+        // Create XMLHttpRequest
+        var xhr = new XMLHttpRequest();
+        var method = (options.method || 'GET').toUpperCase();
+        // Create a promise that wraps the XHR request
+        var xhrPromise = new Promise((resolve, reject) => {
+          xhr.onload = function () {
+            if (xhr.status >= 200 && xhr.status < 300) {
+              var _xhr$getResponseHeade;
+              var response = xhr.response;
+              if (options.responseType === 'json' || (!options.responseType || options.responseType === 'text') && (_xhr$getResponseHeade = xhr.getResponseHeader('Content-Type')) !== null && _xhr$getResponseHeade !== void 0 && _xhr$getResponseHeade.includes('application/json') && typeof response === 'string') {
                 try {
-                    if (typeof requestInfo.cancelToken === 'function') requestInfo.cancelToken();
-                    else if (requestInfo.cancelToken.cancel) requestInfo.cancelToken.cancel();
-                } catch (error) {}
+                  response = JSON.parse(response);
+                } catch (_unused) {}
+              }
+              resolve({
+                data: response,
+                status: xhr.status,
+                statusText: xhr.statusText,
+                headers: xhr.getAllResponseHeaders(),
+                xhr: xhr
+              });
+            } else {
+              reject({
+                message: "Request failed with status ".concat(xhr.status),
+                status: xhr.status,
+                statusText: xhr.statusText,
+                xhr: xhr
+              });
             }
-
-            // Reject the wrapper promise
-            this.#_deleteRequest(
-                requestId,
-                requestInfo.rejectWrapper,
-                this.getOptions().verbose ? new Error(`Request ${requestId} was cancelled`) : null
-            );
-            return true;
-        }
-
-        /**
-         * Link abort signal with HTTP client abort method.
-         * Useful for custom HTTP clients that only support the abort method to cancel requests.
-         * @param {Function} abortMethod - The abort method to call when the signal is aborted
-         * @param {AbortSignal} signal - The signal to listen to
-         */
-        addAbortListener(abortMethod, signal) {
-            if (!abortMethod || !signal) return;
-            signal.addEventListener('abort', () => {
-                if (typeof abortMethod === 'function') {
-                    try {
-                        abortMethod();
-                    } catch (error) {}
-                }
+          };
+          xhr.onerror = function () {
+            reject({
+              message: 'Network error',
+              xhr: xhr
             });
-        }
-
-        /**
-         * Cancels all active requests.
-         * @returns {number} The number of requests that were cancelled
-         */
-        cancelAll() {
-            const requestIds = Array.from(this.activeRequests.keys());
-            let cancelledCount = 0;
-            requestIds.forEach((requestId) => {
-                if (this.cancel(requestId)) cancelledCount++;
+          };
+          xhr.ontimeout = function () {
+            reject({
+              message: 'Request timeout',
+              xhr: xhr
             });
-            return cancelledCount;
-        }
-
-        /**
-         * Resolves the AbortController for a request: explicit option, pending handoff, or new.
-         * Clears the pending handoff so concurrent requests do not share it.
-         * @param {AbortController|undefined} provided - Optional AbortController from options
-         * @returns {AbortController}
-         * @private
-         */
-        #_resolveAbortController(provided) {
-            const abortController = provided || this.abortController || new AbortController();
-            this.abortController = null;
-            return abortController;
-        }
-
-        /**
-         * Picks the best abort callback for a client request object.
-         * @param {Object} req - The request object
-         * @returns {Function|null}
-         * @private
-         */
-        #_resolveAbortMethod(req) {
-            if (!req) return null;
-            if (typeof req.abort === 'function') return () => req.abort();
-            const ExtAjax =
-                typeof globalThis !== 'undefined' && globalThis.Ext && globalThis.Ext.Ajax ? globalThis.Ext.Ajax : null;
-            if (req.xhr && ExtAjax && typeof ExtAjax.abort === 'function') {
-                return () => ExtAjax.abort(req);
-            }
-            if (req.xhr && typeof req.xhr.abort === 'function') return () => req.xhr.abort();
-            return null;
-        }
+          };
+
+          // Open the request
+          xhr.open(method, url, true);
+
+          // Set response type
+          if (options.responseType) xhr.responseType = options.responseType;
+          // Set withCredentials
+          if (options.withCredentials !== undefined) xhr.withCredentials = options.withCredentials;
+          // Set timeout
+          if (options.timeout !== undefined) xhr.timeout = options.timeout;
+          // Set headers
+          if (options.headers) Object.keys(options.headers).forEach(key => {
+            xhr.setRequestHeader(key, options.headers[key]);
+          });
+
+          // Connect abort signal to xhr.abort()
+          if (fetchOptions.signal) fetchOptions.signal.addEventListener('abort', () => xhr.abort());
+
+          // Send the request
+          xhr.send(options.body || null);
+        });
+        return xhrPromise;
+      };
+      return _assertClassBrand(_RequestManager_brand, this, _request).call(this, requestId, xhrFunction, options);
+    }
 
-        /**
-         * Prepares request options by merging options and removing custom properties
-         * @param {import('./index.d.ts').RequestOptions} options - Configuration options
-         * @param {AbortSignal} signal - Abort signal to add to request options
-         * @returns {Object} Prepared request options
-         * @private
-         */
-        #_prepareRequestOptions(options, signal) {
-            const requestOptions = {};
-            const customOptions = ['abortController', 'cancelToken', 'requestKey', 'noCancel', 'includeQuery'];
-            Object.keys(options).forEach((key) => {
-                if (customOptions.includes(key)) return;
-                requestOptions[key] = options[key];
-            });
-            requestOptions.signal = signal;
-            return requestOptions;
+    /**
+     * Returns the request identifier for a URL and options.
+     * @param {string} url - The URL used when starting the request
+     * @param {import('./index.d.ts').BaseRequestOptions} options - Same options used for the request
+     * @returns {string} The request identifier
+     * @example
+     * requestManager.fetch('/api/users');
+     * const id = requestManager.getRequestId('/api/users');
+     * requestManager.cancel(id);
+     */
+    getRequestId(url) {
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var requestKey = options.requestKey;
+      var prefix = 'request_';
+
+      // Generate a unique identifier to prevent cancellation for non cancelable requests
+      if (options.noCancel) {
+        return "".concat(prefix).concat(Date.now(), "_").concat(Math.random().toString(36).slice(2, 11));
+      }
+
+      // Handle function requestKey
+      if (typeof requestKey === 'function') {
+        try {
+          requestKey = requestKey();
+        } catch (_unused2) {
+          requestKey = null;
         }
+      }
+      if (requestKey !== null && requestKey !== undefined) return "".concat(prefix).concat(String(requestKey));
+
+      // Use cleaned URL as key as fallback
+      var cleanedUrl = url || '';
+      if (cleanedUrl.includes('://')) cleanedUrl = cleanedUrl.split('://')[1];
+      if (cleanedUrl.includes('#')) cleanedUrl = cleanedUrl.split('#')[0];
+      if (!options.includeQuery && cleanedUrl.includes('?')) cleanedUrl = cleanedUrl.split('?')[0];
+      var methodPrefix = options.includeMethod === false ? '' : "".concat((options.method || options.type || 'GET').toUpperCase(), "_");
+      return "".concat(prefix).concat(methodPrefix).concat(cleanedUrl);
+    }
 
-        /**
-         * Deletes a request from the active requests map and rejects the wrapper promise
-         * @param {string} requestId - The unique identifier of the request
-         * @param {Function} rejectWrapper - The function to reject the wrapper promise
-         * @param {*} error - The error to reject the wrapper promise with; the wrapper is not rejected if null/undefined
-         * @private
-         */
-        #_deleteRequest(requestId, rejectWrapper, error) {
-            this.activeRequests.delete(requestId);
-            if (error !== null && error !== undefined) {
-                rejectWrapper(error);
-            }
-        }
+    /**
+     * Cancels a specific request by its identifier.
+     * @param {string} requestId - The unique identifier of the request to cancel
+     * @returns {boolean} True if the request was found and cancelled, false otherwise
+     */
+    cancel(requestId) {
+      /** @type {import('./index.d.ts').ActiveRequest|undefined} */
+      var requestInfo = this.activeRequests.get(requestId);
+      if (!requestInfo) return false;
+      requestInfo.isCancelled = true; // Mark as cancelled
+
+      // Try to abort using AbortController (for fetch)
+      if (requestInfo.abortController && !requestInfo.abortController.signal.aborted) {
+        try {
+          requestInfo.abortController.abort('Request was cancelled');
+        } catch (error) {}
+      }
+
+      // Try to cancel using cancel token/function (for axios and others)
+      if (requestInfo.cancelToken) {
+        try {
+          if (typeof requestInfo.cancelToken === 'function') requestInfo.cancelToken();else if (requestInfo.cancelToken.cancel) requestInfo.cancelToken.cancel();
+        } catch (error) {}
+      }
+
+      // Reject the wrapper promise
+      _assertClassBrand(_RequestManager_brand, this, _deleteRequest).call(this, requestId, requestInfo.rejectWrapper, this.getOptions().verbose ? new Error("Request ".concat(requestId, " was cancelled")) : null);
+      return true;
+    }
 
-        /**
-         * Completes a request by deleting it from the active requests map and resolving the wrapper promise
-         * @param {string} requestId - The unique identifier of the request
-         * @param {Function} resolveWrapper - The function to resolve the wrapper promise
-         * @param {Promise} requestPromise - The request promise
-         * @param {boolean} isCancelled - Whether the request was cancelled
-         * @private
-         */
-        #_completeRequest(requestId, resolveWrapper, requestPromise, isCancelled) {
-            this.activeRequests.delete(requestId);
-            if (!isCancelled) {
-                resolveWrapper(requestPromise);
-            }
+    /**
+     * Link abort signal with HTTP client abort method.
+     * Useful for custom HTTP clients that only support the abort method to cancel requests.
+     * @param {Function} abortMethod - The abort method to call when the signal is aborted
+     * @param {AbortSignal} signal - The signal to listen to
+     */
+    addAbortListener(abortMethod, signal) {
+      if (!abortMethod || !signal) return;
+      signal.addEventListener('abort', () => {
+        if (typeof abortMethod === 'function') {
+          try {
+            abortMethod();
+          } catch (error) {}
         }
+      });
+    }
 
-        /**
-         * Internal method that handles the core request logic.
-         * @param {string} requestId - Unique identifier for the request
-         * @param {Promise|import('./index.d.ts').RequestFunction|string} requestPromise - The request promise, function, or URL string
-         * @param {import('./index.d.ts').BaseRequestOptions} options - Configuration options
-         * @returns {Promise} A Promise that resolves/rejects based on the most recent request
-         * @private
-         */
-        #_request(requestId, requestPromise, options = {}) {
-            const abortController = this.#_resolveAbortController(options.abortController);
-
-            // Handle different types of requestPromise inputs
-            // Priority: Function (Custom logic) > String (URL) > Promise (axios, fetch, etc.)
-            if (typeof requestPromise === 'function') {
-                // Function: custom logic for any library (axios, ajax, etc.)
-                try {
-                    requestPromise = requestPromise({
-                        options: this.#_prepareRequestOptions(options, abortController.signal),
-                    });
-                } catch (error) {
-                    return Promise.reject(error);
-                }
-            } else if (typeof requestPromise === 'string') {
-                // String (URL): make fetch internally
-                try {
-                    requestPromise = fetch(requestPromise, this.#_prepareRequestOptions(options, abortController.signal));
-                } catch (error) {
-                    return Promise.reject(error);
-                }
-            }
+    /**
+     * Cancels all active requests.
+     * @returns {number} The number of requests that were cancelled
+     */
+    cancelAll() {
+      var requestIds = Array.from(this.activeRequests.keys());
+      var cancelledCount = 0;
+      requestIds.forEach(requestId => {
+        if (this.cancel(requestId)) cancelledCount++;
+      });
+      return cancelledCount;
+    }
+  }
+  function _resolveAbortController(provided) {
+    var abortController = provided || this.abortController || new AbortController();
+    this.abortController = null;
+    return abortController;
+  }
+  /**
+   * Picks the best abort callback for a client request object.
+   * @param {Object} req - The request object
+   * @returns {Function|null}
+   * @private
+   */
+  function _resolveAbortMethod(req) {
+    if (!req) return null;
+    if (typeof req.abort === 'function') return () => req.abort();
+    var ExtAjax = typeof globalThis !== 'undefined' && globalThis.Ext && globalThis.Ext.Ajax ? globalThis.Ext.Ajax : null;
+    if (req.xhr && ExtAjax && typeof ExtAjax.abort === 'function') {
+      return () => ExtAjax.abort(req);
+    }
+    if (req.xhr && typeof req.xhr.abort === 'function') return () => req.xhr.abort();
+    return null;
+  }
+  /**
+   * Prepares request options by merging options and removing custom properties
+   * @param {import('./index.d.ts').RequestOptions} options - Configuration options
+   * @param {AbortSignal} signal - Abort signal to add to request options
+   * @returns {Object} Prepared request options
+   * @private
+   */
+  function _prepareRequestOptions(options, signal) {
+    var requestOptions = {};
+    var customOptions = ['abortController', 'cancelToken', 'requestKey', 'noCancel', 'includeQuery'];
+    Object.keys(options).forEach(key => {
+      if (customOptions.includes(key)) return;
+      requestOptions[key] = options[key];
+    });
+    requestOptions.signal = signal;
+    return requestOptions;
+  }
+  /**
+   * Warns when the provided axios instance predates 0.22.0, the first version
+   * supporting AbortSignal cancellation. Older instances silently ignore
+   * options.signal, so duplicate requests would not be cancelled.
+   * @param {object} axiosLib - The axios instance about to be used
+   * @private
+   */
+  function _checkAxiosVersion(axiosLib) {
+    var version = typeof (axiosLib === null || axiosLib === void 0 ? void 0 : axiosLib.VERSION) === 'string' ? axiosLib.VERSION : null;
+    if (!version) return;
+    var _version$split$map = version.split('.').map(Number),
+      _version$split$map2 = _slicedToArray(_version$split$map, 2),
+      major = _version$split$map2[0],
+      minor = _version$split$map2[1];
+    if (major === 0 && minor < 22) {
+      console.warn("[request-manager] axios >= 0.22.0 is required: axios ".concat(version, " ignores the AbortSignal used for automatic cancellation. Please upgrade axios."));
+    }
+  }
+  /**
+   * Deletes a request from the active requests map and rejects the wrapper promise
+   * @param {string} requestId - The unique identifier of the request
+   * @param {Function} rejectWrapper - The function to reject the wrapper promise
+   * @param {*} error - The error to reject the wrapper promise with; the wrapper is not rejected if null/undefined
+   * @private
+   */
+  function _deleteRequest(requestId, rejectWrapper, error) {
+    this.activeRequests.delete(requestId);
+    if (error !== null && error !== undefined) {
+      rejectWrapper(error);
+    }
+  }
+  /**
+   * Completes a request by deleting it from the active requests map and resolving the wrapper promise
+   * @param {string} requestId - The unique identifier of the request
+   * @param {Function} resolveWrapper - The function to resolve the wrapper promise
+   * @param {Promise} requestPromise - The request promise
+   * @param {boolean} isCancelled - Whether the request was cancelled
+   * @private
+   */
+  function _completeRequest(requestId, resolveWrapper, requestPromise, isCancelled) {
+    this.activeRequests.delete(requestId);
+    if (!isCancelled) {
+      resolveWrapper(requestPromise);
+    }
+  }
+  /**
+   * Internal method that handles the core request logic.
+   * @param {string} requestId - Unique identifier for the request
+   * @param {Promise|import('./index.d.ts').RequestFunction|string} requestPromise - The request promise, function, or URL string
+   * @param {import('./index.d.ts').BaseRequestOptions} options - Configuration options
+   * @returns {Promise} A Promise that resolves/rejects based on the most recent request
+   * @private
+   */
+  function _request(requestId, requestPromise) {
+    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    var abortController = _assertClassBrand(_RequestManager_brand, this, _resolveAbortController).call(this, options.abortController);
+
+    // Handle different types of requestPromise inputs
+    // Priority: Function (Custom logic) > String (URL) > Promise (axios, fetch, etc.)
+    if (typeof requestPromise === 'function') {
+      // Function: custom logic for any library (axios, ajax, etc.)
+      try {
+        requestPromise = requestPromise({
+          options: _assertClassBrand(_RequestManager_brand, this, _prepareRequestOptions).call(this, options, abortController.signal)
+        });
+      } catch (error) {
+        return Promise.reject(error);
+      }
+    } else if (typeof requestPromise === 'string') {
+      // String (URL): make fetch internally
+      try {
+        requestPromise = fetch(requestPromise, _assertClassBrand(_RequestManager_brand, this, _prepareRequestOptions).call(this, options, abortController.signal));
+      } catch (error) {
+        return Promise.reject(error);
+      }
+    }
 
-            // Link the request object's abort method (Ext.Ajax, XHR, etc.) to the cancellation signal
-            this.addAbortListener(this.#_resolveAbortMethod(requestPromise), abortController.signal);
+    // Link the request object's abort method (Ext.Ajax, XHR, etc.) to the cancellation signal
+    this.addAbortListener(_assertClassBrand(_RequestManager_brand, this, _resolveAbortMethod).call(this, requestPromise), abortController.signal);
 
-            // Cancel previous request with the same identifier if it exists
-            if (!options.noCancel) this.cancel(requestId);
+    // Cancel previous request with the same identifier if it exists
+    if (!options.noCancel) this.cancel(requestId);
 
-            // Create a wrapper promise that will be resolved/rejected based on the request
-            let resolveWrapper, rejectWrapper;
-            const wrapperPromise = new Promise((resolve, reject) => {
-                resolveWrapper = resolve;
-                rejectWrapper = reject;
-            });
+    // Create a wrapper promise that will be resolved/rejected based on the request
+    var resolveWrapper, rejectWrapper;
+    var wrapperPromise = new Promise((resolve, reject) => {
+      resolveWrapper = resolve;
+      rejectWrapper = reject;
+    });
 
-            /**
-             * @type {import('./index.d.ts').ActiveRequest}
-             */
-            const requestInfo = {
-                promise: requestPromise,
-                abortController: abortController,
-                cancelToken: options.cancelToken || null,
-                resolveWrapper: resolveWrapper,
-                rejectWrapper: rejectWrapper,
-                isCancelled: false,
-            };
-
-            this.activeRequests.set(requestId, requestInfo);
-
-            // Handle request promise completion
-            if (requestPromise && typeof requestPromise.then === 'function') {
-                try {
-                    let req = requestPromise.then((result) => {
-                        if (this.activeRequests.get(requestId) !== requestInfo) return;
-                        this.#_completeRequest(requestId, resolveWrapper, result, requestInfo.isCancelled);
-                    });
-                    if (req.catch)
-                        req.catch((error) => {
-                            onError(this, error);
-                        });
-                } catch (error) {
-                    onError(this, error);
-                }
-                function onError(scope, error) {
-                    // Check if this requestInfo is still the active one, or if it was cancelled
-                    if (scope.activeRequests.get(requestId) !== requestInfo) return;
-                    if (requestInfo.isCancelled) {
-                        // Already cancelled: let cancel() handle cleanup and reject the wrapper promise
-                        scope.cancel(requestId);
-                        return;
-                    }
-                    // Only delete if this is still the active request
-                    scope.#_deleteRequest(requestId, rejectWrapper, error);
-                }
-            } else {
-                // Non-promise (Ext.Ajax request object, raw XHR, etc.). Keep tracked until the
-                // underlying XHR finishes so a later duplicate can still cancel it.
-                const xhr =
-                    requestPromise &&
-                    (requestPromise.xhr ||
-                        (typeof XMLHttpRequest !== 'undefined' && requestPromise instanceof XMLHttpRequest
-                            ? requestPromise
-                            : null));
-                const finish = () => {
-                    if (this.activeRequests.get(requestId) !== requestInfo) return;
-                    this.#_completeRequest(requestId, resolveWrapper, requestPromise, requestInfo.isCancelled);
-                };
-                if (xhr && typeof xhr.addEventListener === 'function') {
-                    xhr.addEventListener('loadend', finish);
-                } else {
-                    setTimeout(finish, 0);
-                }
-            }
-            return wrapperPromise;
+    /**
+     * @type {import('./index.d.ts').ActiveRequest}
+     */
+    var requestInfo = {
+      promise: requestPromise,
+      abortController: abortController,
+      cancelToken: options.cancelToken || null,
+      resolveWrapper: resolveWrapper,
+      rejectWrapper: rejectWrapper,
+      isCancelled: false
+    };
+    this.activeRequests.set(requestId, requestInfo);
+
+    // Handle request promise completion
+    if (requestPromise && typeof requestPromise.then === 'function') {
+      try {
+        var req = requestPromise.then(result => {
+          if (this.activeRequests.get(requestId) !== requestInfo) return;
+          _assertClassBrand(_RequestManager_brand, this, _completeRequest).call(this, requestId, resolveWrapper, result, requestInfo.isCancelled);
+        });
+        if (req.catch) req.catch(error => {
+          onError(this, error);
+        });
+      } catch (error) {
+        onError(this, error);
+      }
+      function onError(scope, error) {
+        // Check if this requestInfo is still the active one, or if it was cancelled
+        if (scope.activeRequests.get(requestId) !== requestInfo) return;
+        if (requestInfo.isCancelled) {
+          // Already cancelled: let cancel() handle cleanup and reject the wrapper promise
+          scope.cancel(requestId);
+          return;
         }
+        // Only delete if this is still the active request
+        _assertClassBrand(_RequestManager_brand, scope, _deleteRequest).call(scope, requestId, rejectWrapper, error);
+      }
+    } else {
+      // Non-promise (Ext.Ajax request object, raw XHR, etc.). Keep tracked until the
+      // underlying XHR finishes so a later duplicate can still cancel it.
+      var xhr = requestPromise && (requestPromise.xhr || (typeof XMLHttpRequest !== 'undefined' && requestPromise instanceof XMLHttpRequest ? requestPromise : null));
+      var finish = () => {
+        if (this.activeRequests.get(requestId) !== requestInfo) return;
+        _assertClassBrand(_RequestManager_brand, this, _completeRequest).call(this, requestId, resolveWrapper, requestPromise, requestInfo.isCancelled);
+      };
+      if (xhr && typeof xhr.addEventListener === 'function') {
+        xhr.addEventListener('loadend', finish);
+      } else {
+        setTimeout(finish, 0);
+      }
     }
+    return wrapperPromise;
+  }
 
-    return RequestManager;
+  return RequestManager;
 
 }));
 //# sourceMappingURL=request-manager.umd.js.map