@enegalan/request-manager 1.0.3 → 1.1.0

package/dist/request-manager.js

@@ -4,94 +4,50 @@ var RequestManager = (function () {
     /**
      * 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.
-
-     * @param {Object} managerOptions - The options for the manager
-     * @param {boolean} managerOptions.verbose - If true, cancellation errors will include messages
-     * @returns {RequestManager} A new RequestManager instance
-    */
+     */
     class RequestManager {
-        constructor(managerOptions = {}) {
+        constructor(options = {}) {
             /**
-             * Map to store active requests by their unique identifier.
-             * Each entry contains:
-             * - promise: The original promise
-             * - abortController: AbortController instance (if available)
-             * - cancelToken: Cancel token (for axios compatibility)
-             * - wrapperPromise: The promise that wraps the request
-             * - resolveWrapper: The function to resolve the wrapper promise
-             * - rejectWrapper: The function to reject the wrapper promise
-             * - isCancelled: Whether the request has been cancelled
-             * - verbose: Whether to include verbose messages in the cancellation error
+             * @type {Map<string, import('./index.d.ts').ActiveRequest>}
              */
             this.activeRequests = new Map();
             /**
-             * Verbose mode: if true, cancellation errors will include messages
-             * @type {boolean}
-             */
-            this.verbose = managerOptions.verbose || false;
-            /**
-             * Manager options: the options that were passed to the constructor
-             * @type {Object}
-             */
-            this.managerOptions = managerOptions;
-            /**
-             * Options for the current request: will be flushed after the request is completed
-             * @type {Object}
+             * @type {import('./index.d.ts').Options}
              */
-            this.options = {};
+            this.options = options;
             /**
-             * AbortController instance for the current request: will be flushed after the request is completed
-             * @type {AbortController}
+             * One-shot AbortController for getSignal()/getAbortController() handoff.
+             * Consumed by the next request that does not pass options.abortController.
+             * @type {AbortController|null}
              */
             this.abortController = null;
         }
 
-        /**
-         * Flushes the options for the current request
-         * @private
-         */
-        #_flushRequestOptions() {
-            this.options = {};
-        }
-
         /**
          * Gets the manager options
-         * @returns {Object} Manager options
+         * @returns {import('./index.d.ts').Options} Manager options
          */
         getOptions() {
-            return this.managerOptions;
+            return this.options;
         }
 
         /**
          * Sets the manager options
-         * @param {Object} options - The options to set
+         * @param {import('./index.d.ts').Options} options - The options to set
          */
         setOptions(options) {
-            this.managerOptions = options;
-            if (options.verbose !== undefined) {
-                this.verbose = options.verbose;
-            }
-        }
-
-        /**
-         * Sets the options for the current request
-         * @param {Object} options - The options to set
-         * @private
-         */
-        #_setRequestOptions(options) {
             this.options = options;
         }
 
         /**
-         * Creates an AbortController and returns its signal.
-         * The AbortController is stored internally and will be used by the next request() call.
-         * This allows users to get the signal before creating the request.
-         * 
+         * 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 }));
@@ -101,235 +57,71 @@ var RequestManager = (function () {
         }
 
         /**
-         * Gets the current AbortController instance
-         * Creates a new AbortController if none exists or if the current one is aborted
-         * @returns {AbortController} The current AbortController instance
+         * 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() {
-            // Create a new AbortController if none exists or if the current one is aborted
-            if (!this.abortController || this.abortController.signal.aborted) {
-                this.abortController = new AbortController();
-            }
+            this.abortController = new AbortController();
             return this.abortController;
         }
 
         /**
-         * Clears the current AbortController
-         * @private
-         */
-        #_clearAbortController() {
-            this.abortController = null;
-        }
-
-        /**
-         * Generates a request identifier based on the requestKey or URL
-         * @param {string} url - The URL of the request
-         * @param {string|number|Function} requestKey - Optional key to generate a deterministic ID.
-         *                                              If provided, requests with the same key will share the same ID.
-         *                                              If null or undefined, the cleaned URL will be used as the key.
-         * @param {boolean} noCancel - If true, generates a unique ID to prevent cancellation
-         * @returns {string} A unique request identifier
-         * @private
+         * 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
          */
-        #_generateRequestId(url, requestKey = null, noCancel = false) {
-            if (noCancel) { // Generate a unique ID to prevent cancellation
-                return `request_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
-            }
-            if (requestKey !== null && requestKey !== undefined) {
-                if (typeof requestKey === 'function') {
-                    try {
-                        requestKey = requestKey();
-                    } catch (error) {
-                        requestKey = null;
-                    }
-                }
-                if (requestKey !== null && requestKey !== undefined) return `request_${String(requestKey)}`;
-            }
-            // Use cleaned URL as key when requestKey is null/undefined
-            let cleanedUrl = url || '';
-            let hasProtocol = cleanedUrl.includes('://');
-            if (hasProtocol) cleanedUrl = cleanedUrl.split('://')[1];
-            let hasParams = cleanedUrl.includes('?');
-            if (hasParams) cleanedUrl = cleanedUrl.split('?')[0];
-            let hasHash = cleanedUrl.includes('#');
-            if (hasHash) cleanedUrl = cleanedUrl.split('#')[0];
-            return `request_${cleanedUrl}`;
+        isActive(requestId) {
+            return this.activeRequests.has(requestId);
         }
 
         /**
-         * Prepares fetch options by merging options and removing custom properties
-         * @param {Object} options - Configuration options
-         * @param {AbortSignal} signal - Abort signal to add to fetch options
-         * @param {Object} additionalOptions - Additional options to merge
-         * @returns {Object} Prepared fetch options
-         * @private
+         * Gets the number of active requests.
+         * @returns {number} The number of currently active requests
          */
-        #_prepareFetchOptions(options, signal, additionalOptions = {}) {
-            const fetchOptions = Object.assign({}, additionalOptions);
-            const customOptions = ['abortController', 'cancelToken', 'requestKey', 'noCancel'];
-            Object.keys(options).forEach(key => {
-                if (customOptions.includes(key)) return;
-                fetchOptions[key] = options[key];
-            });
-            fetchOptions.signal = signal;
-            return fetchOptions;
+        getActiveCount() {
+            return this.activeRequests.size;
         }
 
         /**
-         * Internal method that handles the core request logic.
-         * 
-         * @param {string} requestId - Unique identifier for the request
-         * @param {Promise|Function|string} requestPromise - The request promise, function, or URL string
-         * @param {Object} options - Configuration options
-         * @param {AbortController} options.abortController - AbortController instance
-         * @param {Function} options.cancelToken - Cancel token or cancel function
-         * @param {boolean} options.noCancel - If true, this request will not cancel previous requests with the same ID
-         * @returns {Promise} A Promise that resolves/rejects based on the most recent request
-         * @private
+         * Clears all active requests without cancelling them.
+         * Use with caution - this will not cancel the underlying HTTP requests.
          */
-        #_request(requestId, requestPromise, options = {}) {
-            this.#_setRequestOptions(options);
-            if (!options.abortController) this.#_clearAbortController(); // Clear any existing abortController to ensure each request gets a fresh one
-            this.#_flushRequestOptions();
-            const abortController = options.abortController || this.getAbortController();
-
-            // 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.)
-                const fetchOptions = this.#_prepareFetchOptions(options, abortController.signal);
-                requestPromise = requestPromise({ options: fetchOptions });
-            } else if (typeof requestPromise === 'string') {
-                // String (URL): make fetch internally
-                const fetchOptions = this.#_prepareFetchOptions(options, abortController.signal);
-                requestPromise = fetch(requestPromise, fetchOptions);
-            }
-
-            // Cancel previous request with the same ID 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;
-            });
-
-            // Store the request information
-            const requestInfo = {
-                promise: requestPromise,
-                abortController: abortController,
-                cancelToken: options.cancelToken || null,
-                wrapperPromise: wrapperPromise,
-                resolveWrapper: resolveWrapper,
-                rejectWrapper: rejectWrapper,
-                isCancelled: false,
-                verbose: this.verbose
-            };
-
-            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 && !requestInfo.isCancelled) {
-                            this.activeRequests.delete(requestId);
-                            resolveWrapper(result);
-                        }
-                    });
-                    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
-                    const currentRequestInfo = scope.activeRequests.get(requestId);
-                    if (currentRequestInfo !== requestInfo) return;
-                    // Only delete if this is still the active request
-                    scope.activeRequests.delete(requestId);
-                    if (!requestInfo.isCancelled) rejectWrapper(error);
-                    else if (requestInfo.isCancelled && requestInfo.verbose) rejectWrapper(new Error('Request was cancelled'));
-                }
-            } else {
-                // If requestPromise is not a promise, we can't track its completion automatically
-                // This can happen with libraries like ExtJS that return request objects instead of promises
-                // In this case, the user should handle the request object themselves
-                // We'll resolve the wrapper promise immediately to prevent it from hanging
-                // The user can still use the request object returned by the library
-                setTimeout(() => {
-                    if (this.activeRequests.get(requestId) === requestInfo && !requestInfo.isCancelled) {
-                        this.activeRequests.delete(requestId);
-                        resolveWrapper(requestPromise); // Resolve with the request object so the user can use it
-                    }
-                }, 0);
-            }
-            return wrapperPromise;
+        clear() {
+            this.activeRequests.clear();
         }
 
         /**
          * Executes an HTTP request, cancelling any previous request with the same identifier.
-         * 
          * @param {string} url - The URL to request
-         * @param {Promise|Function} requestPromise - The request promise or function that returns a promise
-         * @param {Object} options - Optional configuration
-         * @param {string|number|Function} options.requestKey - Key to identify duplicate requests.
-         *                                                    If provided, requests with the same key will cancel previous ones.
-         *                                                    Can be a string, number, or function that returns a key.
-         * @param {AbortController} options.abortController - AbortController instance (created automatically if not provided)
-         * @param {Function} options.cancelToken - Cancel token or cancel function for other libraries
-         * @param {boolean} options.noCancel - If true, this request will not cancel previous requests with the same ID, allowing concurrent requests
-         *                                                    Any other properties are passed as fetch options (method, headers, body, etc.)
+         * @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 }));
-         * 
+         * 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',
-         *   cancelToken: axios.CancelToken.source().cancel
+         *   requestKey: 'get-users'
          * }
          * requestManager.request('/api/users', axios.get('/api/users', options), options);
-         * 
-         * @example
-         * // Request with noCancel to allow concurrent requests (e.g., lazy loading)
-         * requestManager.request('/api/lazy?load=1', fetch('/api/lazy?load=1'), { noCancel: true });
-         * requestManager.request('/api/lazy?load=2', fetch('/api/lazy?load=2'), { noCancel: true });
-         * // Both requests will execute concurrently without canceling each other
          */
         request(url, requestPromise, options = {}) {
-            const requestOptions = options || {};
-            const requestId = this.#_generateRequestId(url, requestOptions.requestKey, requestOptions.noCancel);
-            return this.#_request(requestId, requestPromise, requestOptions);
+            return this.#_request(this.getRequestId(url, options), requestPromise, options);
         }
 
         /**
          * Executes an HTTP request using fetch, cancelling any previous request with the same identifier.
-         * 
          * @param {string} url - The URL to fetch
-         * @param {Object} options - Optional configuration
-         * @param {string|number|Function} options.requestKey - Key to identify duplicate requests.
-         *                                                    If provided, requests with the same key will cancel previous ones.
-         *                                                    Can be a string, number, or function that returns a key.
-         * @param {AbortController} options.abortController - AbortController instance (created automatically if not provided)
-         * @param {Function} options.cancelToken - Cancel token or cancel function for other libraries
-         * @param {boolean} options.noCancel - If true, this request will not cancel previous requests with the same ID, allowing concurrent requests
-         *                                                    Any other properties are passed as fetch options (method, headers, body, etc.)
+         * @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', {
@@ -337,47 +129,29 @@ var RequestManager = (function () {
          *   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'
          * });
-         * 
-         * @example
-         * // Request with noCancel to allow concurrent requests (e.g., lazy loading)
-         * requestManager.fetch('/api/lazy?load=1', { noCancel: true });
-         * requestManager.fetch('/api/lazy?load=2', { noCancel: true });
-         * // Both requests will execute concurrently without canceling each other
          */
         fetch(url, options = {}) {
-            const requestOptions = options || {};
-            const requestId = this.#_generateRequestId(url, requestOptions.requestKey, requestOptions.noCancel);
-            return this.#_request(requestId, url, requestOptions);
+            return this.#_request(this.getRequestId(url, options), url, options);
         }
 
         /**
          * Executes an HTTP request using axios, cancelling any previous request with the same identifier.
-         * 
          * @param {string} url - The URL to request
-         * @param {Object} options - Optional configuration
-         * @param {string|number|Function} options.requestKey - Key to identify duplicate requests.
-         *                                                    If provided, requests with the same key will cancel previous ones.
-         *                                                    Can be a string, number, or function that returns a key.
-         * @param {boolean} options.noCancel - If true, this request will not cancel previous requests with the same ID, allowing concurrent requests
-         *                                                    Any other properties are passed as axios options (method, headers, params, data, etc.)
-         * @param {Object} axiosInstance - Optional axios instance to use. If not provided, uses global axios.
+         * @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', {
@@ -385,46 +159,30 @@ var RequestManager = (function () {
          *   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'
          * });
-         * 
-         * @example
-         * // Request with noCancel to allow concurrent requests
-         * requestManager.axios('/api/lazy?load=1', { noCancel: true });
-         * requestManager.axios('/api/lazy?load=2', { noCancel: true });
          */
         axios(url, options = {}, axiosInstance = null) {
-            const requestOptions = options || {};
             const axiosLib = axiosInstance || axios;
-            const cancelToken = axiosLib.CancelToken.source();
-            const requestId = this.#_generateRequestId(url, requestOptions.requestKey, requestOptions.noCancel);
-            return this.#_request(requestId, axiosLib.get(url, { cancelToken: cancelToken.token, ...requestOptions }), {
-                cancelToken: cancelToken,
-                ...requestOptions
-            });
+            return this.#_request(
+                this.getRequestId(url, options),
+                ({ options: requestOptions }) => axiosLib({ url, ...requestOptions }),
+                options
+            );
         }
 
         /**
          * Executes an HTTP request using jQuery.ajax, cancelling any previous request with the same identifier.
-         * 
-         * @param {Function} ajaxFunction - A function that receives { url, ...options } and returns a Promise
+         * @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 {Object} options - Optional configuration
-         * @param {string|number|Function} options.requestKey - Key to identify duplicate requests.
-         *                                                    If provided, requests with the same key will cancel previous ones.
-         *                                                    Can be a string, number, or function that returns a key.
-         * @param {boolean} options.noCancel - If true, this request will not cancel previous requests with the same ID, allowing concurrent requests
-         *                                                    Any other properties are passed to the ajax method function
+         * @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', {
@@ -432,7 +190,6 @@ var RequestManager = (function () {
          *   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', {
@@ -441,52 +198,21 @@ var RequestManager = (function () {
          */
         ajax(ajaxFunction, url, options = {}) {
             if (typeof ajaxFunction !== 'function') throw new Error('ajaxFunction parameter must be a function');
-            const requestOptions = options || {};
-            const requestId = this.#_generateRequestId(url, requestOptions.requestKey, requestOptions.noCancel);
-            try {
-                // AbortController is needed at this point, so we clear here any existing one.
-                // This is the same behavior as in the request method.
-                this.#_clearAbortController();
-                const abortController = options.abortController || this.getAbortController();
-                const req = ajaxFunction({ url, ...requestOptions });
-                // Determine abort method
-                let abortMethod = null;
-                if (req) {
-                    if (typeof req.abort === 'function') {
-                        abortMethod = req.abort.bind(req);
-                    } else if (req.xhr && typeof req.xhr.abort === 'function') {
-                        abortMethod = req.xhr.abort.bind(req.xhr);
-                    }
-                }
-                if (abortMethod) this.addAbortListener(abortMethod, abortController.signal);
-                // Pass the AbortController to avoid creating another one for this request
-                return this.#_request(requestId, req, { ...requestOptions, abortController: abortController });
-            } catch (error) {
-                return Promise.reject(error);
-            }
+            return this.#_request(
+                this.getRequestId(url, options),
+                ({ options: requestOptions }) => ajaxFunction({ url, ...requestOptions }),
+                options
+            );
         }
 
         /**
          * Executes an HTTP request using XMLHttpRequest, cancelling any previous request with the same identifier.
-         * 
          * @param {string} url - The URL to request
-         * @param {Object} options - Optional configuration
-         * @param {string} options.method - HTTP method (GET, POST, PUT, DELETE, etc.). Defaults to 'GET'.
-         * @param {Object} options.headers - Headers object to set on the request
-         * @param {string|FormData|Blob|ArrayBuffer} options.body - Request body
-         * @param {string} options.responseType - Response type ('text', 'json', 'blob', 'arraybuffer', 'document'). Defaults to 'text'.
-         * @param {boolean} options.withCredentials - Whether to send credentials with the request
-         * @param {number} options.timeout - Request timeout in milliseconds
-         * @param {string|number|Function} options.requestKey - Key to identify duplicate requests.
-         *                                                    If provided, requests with the same key will cancel previous ones.
-         *                                                    Can be a string, number, or function that returns a key.
-         * @param {boolean} options.noCancel - If true, this request will not cancel previous requests with the same ID, allowing concurrent requests
-         * @returns {Promise} A Promise that resolves/rejects based on the most recent 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', {
@@ -494,64 +220,60 @@ var RequestManager = (function () {
          *   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'
          * });
-         * 
-         * @example
-         * // Request with noCancel to allow concurrent requests
-         * requestManager.xhr('/api/lazy?load=1', { noCancel: true });
-         * requestManager.xhr('/api/lazy?load=2', { noCancel: true });
          */
         xhr(url, options = {}) {
-            const requestOptions = options || {};
-            const requestId = this.#_generateRequestId(url, requestOptions.requestKey, requestOptions.noCancel);
+            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 = (requestOptions.method || 'GET').toUpperCase();
+                const method = (options.method || 'GET').toUpperCase();
                 // Create a promise that wraps the XHR request
                 const xhrPromise = new Promise((resolve, reject) => {
-                    xhr.onload = function() {
+                    xhr.onload = function () {
                         if (xhr.status >= 200 && xhr.status < 300) {
                             let response = xhr.response;
-                            if (requestOptions.responseType === 'json' ||
-                                (xhr.getResponseHeader('Content-Type') && xhr.getResponseHeader('Content-Type').includes('application/json'))) {
+                            if (
+                                options.responseType === 'json' ||
+                                ((!options.responseType || options.responseType === 'text') &&
+                                    xhr.getResponseHeader('Content-Type')?.includes('application/json') &&
+                                    typeof response === 'string')
+                            ) {
                                 try {
-                                    response = JSON.parse(xhr.responseText);
-                                } catch (e) {
-                                    response = xhr.responseText;
-                                }
+                                    response = JSON.parse(response);
+                                } catch {}
                             }
                             resolve({
                                 data: response,
                                 status: xhr.status,
                                 statusText: xhr.statusText,
                                 headers: xhr.getAllResponseHeaders(),
-                                xhr: xhr
+                                xhr: xhr,
                             });
                         } else {
                             reject({
                                 message: `Request failed with status ${xhr.status}`,
                                 status: xhr.status,
                                 statusText: xhr.statusText,
-                                xhr: xhr
+                                xhr: xhr,
                             });
                         }
                     };
-                    xhr.onerror = function() {
+                    xhr.onerror = function () {
                         reject({
                             message: 'Network error',
-                            xhr: xhr
+                            xhr: xhr,
                         });
                     };
-                    xhr.ontimeout = function() {
+                    xhr.ontimeout = function () {
                         reject({
                             message: 'Request timeout',
-                            xhr: xhr
+                            xhr: xhr,
                         });
                     };
 
@@ -559,34 +281,73 @@ var RequestManager = (function () {
                     xhr.open(method, url, true);
 
                     // Set response type
-                    if (requestOptions.responseType) xhr.responseType = requestOptions.responseType;
+                    if (options.responseType) xhr.responseType = options.responseType;
                     // Set withCredentials
-                    if (requestOptions.withCredentials !== undefined) xhr.withCredentials = requestOptions.withCredentials;
+                    if (options.withCredentials !== undefined) xhr.withCredentials = options.withCredentials;
                     // Set timeout
-                    if (requestOptions.timeout !== undefined) xhr.timeout = requestOptions.timeout;
+                    if (options.timeout !== undefined) xhr.timeout = options.timeout;
                     // Set headers
-                    if (requestOptions.headers) Object.keys(requestOptions.headers).forEach(key => {
-                        xhr.setRequestHeader(key, requestOptions.headers[key]);
-                    });
+                    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(requestOptions.body || null);
+                    xhr.send(options.body || null);
                 });
                 return xhrPromise;
             };
-            return this.#_request(requestId, xhrFunction, requestOptions);
+            return this.#_request(requestId, xhrFunction, options);
+        }
+
+        /**
+         * 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)}`;
+            }
+
+            // 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}`;
         }
 
         /**
          * 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;
 
@@ -608,10 +369,11 @@ var RequestManager = (function () {
             }
 
             // Reject the wrapper promise
-            if (requestInfo.rejectWrapper && this.verbose) {
-                requestInfo.rejectWrapper(new Error(`Request ${requestId} was cancelled`));
-            }
-            this.activeRequests.delete(requestId); // Remove from active requests
+            this.#_deleteRequest(
+                requestId,
+                requestInfo.rejectWrapper,
+                this.getOptions().verbose ? new Error(`Request ${requestId} was cancelled`) : null
+            );
             return true;
         }
 
@@ -622,8 +384,8 @@ var RequestManager = (function () {
          * @param {AbortSignal} signal - The signal to listen to
          */
         addAbortListener(abortMethod, signal) {
-            if (!signal) return;
-            signal.addEventListener("abort", () => {
+            if (!abortMethod || !signal) return;
+            signal.addEventListener('abort', () => {
                 if (typeof abortMethod === 'function') {
                     try {
                         abortMethod();
@@ -634,7 +396,6 @@ var RequestManager = (function () {
 
         /**
          * Cancels all active requests.
-         * 
          * @returns {number} The number of requests that were cancelled
          */
         cancelAll() {
@@ -647,30 +408,186 @@ var RequestManager = (function () {
         }
 
         /**
-         * 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
+         * 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
          */
-        isActive(requestId) {
-            return this.activeRequests.has(requestId);
+        #_resolveAbortController(provided) {
+            const abortController = provided || this.abortController || new AbortController();
+            this.abortController = null;
+            return abortController;
         }
 
         /**
-         * Gets the number of active requests.
-         * 
-         * @returns {number} The number of currently active requests
+         * Picks the best abort callback for a client request object.
+         * @param {Object} req - The request object
+         * @returns {Function|null}
+         * @private
          */
-        getActiveCount() {
-            return this.activeRequests.size;
+        #_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;
         }
 
         /**
-         * Clears all active requests without cancelling them.
-         * Use with caution - this will not cancel the underlying HTTP requests.
+         * 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
          */
-        clear() {
-            this.activeRequests.clear();
+        #_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;
+        }
+
+        /**
+         * 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);
+            }
+        }
+
+        /**
+         * 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);
+            }
+        }
+
+        /**
+         * 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);
+                }
+            }
+
+            // Link the request object's abort method (Ext.Ajax, XHR, etc.) to the cancellation signal
+            this.addAbortListener(this.#_resolveAbortMethod(requestPromise), abortController.signal);
+
+            // 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;
+            });
+
+            /**
+             * @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;
         }
     }