@enegalan/request-manager 1.0.0

package/dist/request-manager.umd.js

@@ -0,0 +1,673 @@
+/**
+ * RequestManager - A library for managing and regulating HTTP requests efficiently.
+ * @license MIT
+ */
+(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());
+})(this, (function () { 'use strict';
+
+    /**
+     * RequestManager - A library for managing and regulating HTTP requests efficiently.
+     * @license MIT
+     * 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 = {}) {
+            /**
+             * 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
+             */
+            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}
+             */
+            this.options = {};
+            /**
+             * AbortController instance for the current request: will be flushed after the request is completed
+             * @type {AbortController}
+             */
+            this.abortController = null;
+        }
+
+        /**
+         * Flushes the options for the current request
+         * @private
+         */
+        #_flushRequestOptions() {
+            this.options = {};
+        }
+
+        /**
+         * Gets the manager options
+         * @returns {Object} Manager options
+         */
+        getOptions() {
+            return this.managerOptions;
+        }
+
+        /**
+         * Sets the manager options
+         * @param {Object} 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.
+         * 
+         * @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;
+        }
+
+        /**
+         * 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
+         */
+        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();
+            }
+            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
+         */
+        #_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}`;
+        }
+
+        /**
+         * 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
+         */
+        #_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;
+        }
+
+        /**
+         * 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
+         */
+        #_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;
+        }
+
+        /**
+         * 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.)
+         * @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);
+         * 
+         * @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);
+        }
+
+        /**
+         * 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.)
+         * @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'
+         * });
+         * 
+         * @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);
+        }
+
+        /**
+         * 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.
+         * @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'
+         * });
+         * 
+         * @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
+            });
+        }
+
+        /**
+         * Executes an HTTP request using jQuery.ajax, cancelling any previous request with the same identifier.
+         * 
+         * @param {Function} ajaxMethod - 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
+         * @returns {Promise} A Promise that resolves/rejects based on the most recent request
+         * 
+         * @example
+         * // Simple GET request
+         * requestManager.ajax(ajaxMethod, '/api/users');
+         * 
+         * @example
+         * // POST request with options
+         * requestManager.ajax(ajaxMethod, '/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(ajaxMethod, '/api/users', {
+         *   requestKey: 'get-users'
+         * });
+         */
+        ajax(ajaxMethod, url, options = {}) {
+            if (typeof ajaxMethod !== 'function') throw new Error('ajaxMethod must be a function');
+            const requestOptions = options || {};
+            const requestId = this.#_generateRequestId(url, requestOptions.requestKey, requestOptions.noCancel);
+            try {
+                const req = ajaxMethod({ url, ...requestOptions });
+                this.addAbortListener(req.abort, this.getSignal());
+                return this.#_request(requestId, req, requestOptions);
+            } catch (error) {
+                return Promise.reject(error);
+            }
+        }
+
+        /**
+         * 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
+         * 
+         * @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'
+         * });
+         * 
+         * @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 xhrFunction = ({ options: fetchOptions }) => {
+                // Create XMLHttpRequest
+                const xhr = new XMLHttpRequest();
+                const method = (requestOptions.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 (requestOptions.responseType === 'json' ||
+                                (xhr.getResponseHeader('Content-Type') && xhr.getResponseHeader('Content-Type').includes('application/json'))) {
+                                try {
+                                    response = JSON.parse(xhr.responseText);
+                                } catch (e) {
+                                    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 (requestOptions.responseType) xhr.responseType = requestOptions.responseType;
+                    // Set withCredentials
+                    if (requestOptions.withCredentials !== undefined) xhr.withCredentials = requestOptions.withCredentials;
+                    // Set timeout
+                    if (requestOptions.timeout !== undefined) xhr.timeout = requestOptions.timeout;
+                    // Set headers
+                    if (requestOptions.headers) Object.keys(requestOptions.headers).forEach(key => {
+                        xhr.setRequestHeader(key, requestOptions.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);
+                });
+                return xhrPromise;
+            };
+            return this.#_request(requestId, xhrFunction, requestOptions);
+        }
+
+        /**
+         * 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) {
+            const 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
+            if (requestInfo.rejectWrapper && this.verbose) {
+                requestInfo.rejectWrapper(new Error('Request was cancelled'));
+            }
+            this.activeRequests.delete(requestId); // Remove from active requests
+            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 (!signal) return;
+            signal.addEventListener("abort", () => {
+                if (typeof abortMethod === 'function') {
+                    try {
+                        abortMethod();
+                    } catch (error) {}
+                }
+            });
+        }
+
+        /**
+         * 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++;
+            });
+            return cancelledCount;
+        }
+
+        /**
+         * 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;
+        }
+
+        /**
+         * Clears all active requests without cancelling them.
+         * Use with caution - this will not cancel the underlying HTTP requests.
+         */
+        clear() {
+            this.activeRequests.clear();
+        }
+    }
+
+    return RequestManager;
+
+}));
+//# sourceMappingURL=request-manager.umd.js.map