@eui/core 17.0.0-rc.7 → 17.0.0-rc.8

package/esm2022/lib/services/dynamic-menu/dynamic-menu.service.mjs

@@ -24,7 +24,7 @@ export class EuiDynamicMenuService {
     }
     filterEuiMenuItemsWithRights(links) {
         return links.filter((link) => {
-            if (link.hasChildren) {
+            if (link.children != null) {
                 link.children = this.filterEuiMenuItemsWithRights(link.children);
             }
             // First check if the user is denied access:
@@ -66,4 +66,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.2", ngImpor
                     providedIn: 'root',
                 }]
         }], ctorParameters: () => [{ type: i1.EuiPermissionService }, { type: i2.StoreService }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/queue/api-queue.service.mjs

@@ -1,5 +1,5 @@
 import { Injectable, Optional } from '@angular/core';
-import { of, forkJoin } from 'rxjs';
+import { of, forkJoin, from } from 'rxjs';
 import { tap, switchMap, take, map, catchError, concatMap } from 'rxjs/operators';
 import { getApiQueue, getApiQueueItem } from '@eui/base';
 import { AddApiQueueItemAction, RemoveApiQueueItemAction, EmptyApiQueueAction } from '../store';
@@ -7,6 +7,40 @@ import * as i0 from "@angular/core";
 import * as i1 from "../store";
 import * as i2 from "@angular/common/http";
 import * as i3 from "../log";
+/**
+ * Service class for managing and processing a queue of API requests.
+ *
+ * This service provides functionality to add, remove, process, and manage HTTP requests stored in a queue.
+ * It enables sequential or bulk processing of requests, ensuring controlled execution and handling of API calls.
+ * The service methods offer features like processing individual items, processing all items in the queue either
+ * sequentially or all at once, and removing items from the queue. Each method is designed to handle specific aspects
+ * of queue management and processing, with attention to details like order of execution and error handling.
+ *
+ * Usage of this service is ideal in scenarios where API requests need to be managed in a queue structure, allowing
+ * for controlled execution and monitoring of these requests.
+ *
+ * @example
+ * // Adding a new item to the queue
+ * apiQueueService.addQueueItem({ id: 'item124', method: 'POST', uri: '/api/data', payload: {...} });
+ *
+ * // Processing a single item from the queue
+ * apiQueueService.processQueueItem('item123').subscribe(result => {
+ *   console.log('Processed item 123 with result:', result);
+ * });
+ *
+ * // Processing all items in the queue in sequential order
+ * apiQueueService.processAllQueueItemsSequential(false).subscribe(results => {
+ *   console.log('Processed all items in descending order of their timestamp:', results);
+ * });
+ *
+ * // Removing an item from the queue
+ * apiQueueService.removeQueueItem('item123');
+ *
+ * // Processing all items in the queue and continuing on error
+ * apiQueueService.processAllQueueItems(true).subscribe(results => {
+ *   console.log('Processed all items in the queue with continuation on errors:', results);
+ * });
+ */
 export class ApiQueueService {
     constructor(store, http, logService) {
         this.store = store;
@@ -14,10 +48,26 @@ export class ApiQueueService {
         this.logService = logService;
     }
     /**
-     * Adds an item in the queue by dispatching an action to the store.
-     * @param id - The id of the item inside the queue.
-     * WARNING if matches any other queue item id will overwrite it.
-     * @param item - an item for Queue
+     * Adds an item to the queue by dispatching an action to the store.
+     * This function is specifically designed to enqueue API call requests represented by `ApiQueueItem` objects.
+     * Each item is identified by a unique `id`, which is used to manage the queue.
+     *
+     * @param {string} id - The unique identifier for the queue item. It's crucial to ensure that this ID is unique within the queue.
+     *                      If an item with the same ID already exists, the new item will overwrite the existing one.
+     *                      WARNING: Duplicate IDs will lead to overwriting of queue items.
+     *
+     * @param {ApiQueueItem} item - The item to be enqueued. This should be an object of type `ApiQueueItem`.
+     *                              The `method` property of the item must be one of the allowed methods ('post', 'put', 'get').
+     *                              If an unsupported method is provided, the function will throw an error.
+     *
+     * @throws {Error} Throws an error if the `method` property of the `item` is not one of the allowed methods.
+     *                 The error message is: `[ApiQueue] method "${item.method}" is not allowed`.
+     *
+     * @example
+     * // Example of adding an item to the API queue
+     * addQueueItem('12345', { method: 'post', url: '/api/data', payload: {...} });
+     *
+     * @returns {void} This function does not return a value. It adds the item to the queue via a dispatch action.
      */
     addQueueItem(id, item) {
         const allowedMethods = ['post', 'put', 'get'];
@@ -27,8 +77,25 @@ export class ApiQueueService {
         this.store.dispatch(new AddApiQueueItemAction({ id, item }));
     }
     /**
-     * Subscribes to the store to retrieve queue and then converts the queue object to an array of items.
-     * @return An Observable of array of all items inside the current queue (ApiQueueItem[])
+     * Retrieves the current state of the API queue and converts it into an array of Observables.
+     *
+     * This method subscribes to the store to access the API queue. It then maps the queue object,
+     * which is an associative array, into a linear array of ApiQueueItem instances. If the queue is empty,
+     * a warning is logged. This method is useful for tracking the state and contents of the API queue
+     * at a given moment.
+     *
+     * Note: This method takes a snapshot of the queue at the time of subscription. It does not provide
+     * a continuous stream of queue updates. To get real-time updates, consider subscribing directly
+     * to the store's observable.
+     *
+     * @returns {Observable<ApiQueueItem[]>} An Observable that emits an array of ApiQueueItem.
+     * The array represents all items currently in the queue. If the queue is empty, it emits an empty array.
+     *
+     * @example
+     * // Example usage
+     * this.getQueue().subscribe(queueItems => {
+     *   console.log('Current queue items:', queueItems);
+     * });
      */
     getQueue() {
         return this.store.select(getApiQueue).pipe(take(1), map((queue) => {
@@ -40,9 +107,29 @@ export class ApiQueueService {
         }));
     }
     /**
-     * Subscribes to the store to retrieve an item from the queue.
-     * @param id - id of the item inside the queue
-     * @return An Observable of ApiQueueItem type
+     * Retrieves a specific item from the API queue by its ID.
+     *
+     * This method subscribes to the store and selects a single item from the API queue based on the provided ID.
+     * It employs a pipeline to fetch the item: the `getApiQueueItem` selector is used to retrieve the item,
+     * and a `map` operator processes the result. If the item with the specified ID does not exist in the queue,
+     * a warning is logged, and `null` is returned.
+     *
+     * This method is ideal for accessing a specific queue item when its ID is known, allowing for targeted
+     * operations or checks on that particular item.
+     *
+     * @param {string} id - The unique identifier of the item within the queue.
+     * @returns {Observable<ApiQueueItem | null>} An Observable emitting the requested ApiQueueItem.
+     * If no item with the given ID exists in the queue, the Observable emits `null`.
+     *
+     * @example
+     * // Example usage
+     * this.getQueueItem('item123').subscribe(item => {
+     *   if (item) {
+     *     console.log('Found item:', item);
+     *   } else {
+     *     console.log('Item not found in the queue');
+     *   }
+     * });
      */
     getQueueItem(id) {
         return this.store.select(getApiQueueItem(id)).pipe(take(1), map((queue) => {
@@ -54,24 +141,65 @@ export class ApiQueueService {
         }));
     }
     /**
-     * Removes a given item from the queue.
-     * @param id - id of the item inside the queue
+     * Removes a specific item from the API queue using its ID.
+     *
+     * This method dispatches an action to remove an item from the queue, identified by the provided ID.
+     * It is essential for managing the queue by eliminating items that are no longer needed or have been processed.
+     * The function does not return any value, as it primarily triggers an action within the store.
+     *
+     * Note: This method assumes the existence of the item in the queue. It does not perform a check
+     * to confirm the presence of the item before attempting to remove it. Therefore, it's recommended
+     * to verify the item's existence in the queue if uncertainty exists.
+     *
+     * @param {string} id - The unique identifier of the item to be removed from the queue.
+     *
+     * @example
+     * // Example usage
+     * this.removeQueueItem('item123');
+     * // The item with ID 'item123' will be dispatched for removal from the queue.
      */
     removeQueueItem(id) {
         this.store.dispatch(new RemoveApiQueueItemAction(id));
     }
     /**
-     * Removes all items placed in the queue.
+     * Clears all items from the API queue.
+     *
+     * This method dispatches an action to empty the entire API queue, effectively removing all items that are currently queued.
+     * It is useful for scenarios where a complete reset of the queue is required, such as during initialization or after processing
+     * a batch of items. The function does not return any value, as its primary purpose is to trigger a state change in the store.
+     *
+     * Note: Use this method with caution as it will irreversibly clear all items in the queue. Ensure that this action does not
+     * disrupt any ongoing processes that rely on the queue's contents.
+     *
+     * @example
+     * // Example usage
+     * this.removeAllQueueItem();
+     * // This will dispatch an action to empty the entire API queue.
      */
     removeAllQueueItem() {
         this.store.dispatch(new EmptyApiQueueAction(null));
     }
     /**
-     * Process an item from the queue.
-     * @param id - id of the item inside the queue
-     * @return An Observable of type any
+     * Processes an item from the API queue identified by its ID.
+     *
+     * Retrieves the specified item from the queue and applies processing logic as defined in `buildHttpRequest`.
+     * If the item is not found, logs a warning and returns an Observable emitting `null`.
+     *
+     * @param {string} id - The unique identifier of the item within the queue to be processed.
+     * @returns {Observable<any>} An Observable that emits the result of processing the queue item.
+     * If the item does not exist, the Observable emits `null`.
+     *
+     * @example
+     * // Example usage
+     * this.processQueueItem('item123').subscribe(result => {
+     *   if (result) {
+     *     console.log('Processing result:', result);
+     *   } else {
+     *     console.log('Item not found in the queue');
+     *   }
+     * });
      */
-    // TODO: find the correct type or turn into a generic, https://www.typescriptlang.org/docs/handbook/2/generics.html
+    // TODO: Replace `any` with a more specific type or make the method generic, https://www.typescriptlang.org/docs/handbook/2/generics.html
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     processQueueItem(id) {
         return this.store.select(getApiQueueItem(id)).pipe(take(1), switchMap((queue) => {
@@ -83,11 +211,26 @@ export class ApiQueueService {
         }));
     }
     /**
-     * Process all the items inside the queue.
-     * @param [continueOnError=true] - in case of an item request fails continue with the rest in queue
-     * @return An Observable with an array which contains all responses from all items in queue.
+     * Processes all items in the API queue and collects their responses.
+     *
+     * Iterates over each item in the queue and processes them using `buildHttpRequest`. If a request fails,
+     * the method can either continue processing the remaining items or stop, based on the `continueOnError` parameter.
+     * It returns an Observable that emits an array containing the responses or errors from all the processed items.
+     *
+     * The function currently returns `Observable<any[]>` indicating an array of any type. Future improvements
+     * should aim to specify a more accurate return type or utilize generics for increased type safety.
+     *
+     * @param {boolean} [continueOnError=true] - Determines whether to continue with the next item in the queue
+     *                                           after a request failure. Defaults to `true`.
+     * @returns {Observable<any[]>} An Observable emitting an array of either responses or errors from the processed
+     *                              queue items.
+     *
+     * @example
+     * this.processAllQueueItems().subscribe(results => {
+     *   // Handle the array of responses or errors
+     * });
      */
-    // TODO: find the correct type or turn into a generic, https://www.typescriptlang.org/docs/handbook/2/generics.html
+    // TODO: Refine the return type to be more specific or implement generics, https://www.typescriptlang.org/docs/handbook/2/generics.html
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     processAllQueueItems(continueOnError = true) {
         return this.store.select(getApiQueue).pipe(map((queue) => Object.entries(queue).map(([key, value]) => this.buildHttpRequest(key, value).pipe(catchError((error) => {
@@ -96,40 +239,80 @@ export class ApiQueueService {
                 throw error;
             }
             return of(error);
-        })))), 
-        // TODO: find the correct type or turn into a generic, https://www.typescriptlang.org/docs/handbook/2/generics.html
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        switchMap((obsQueue) => forkJoin(Array.from(obsQueue))));
+        })))), switchMap((obsQueue) => forkJoin(Array.from(obsQueue))));
     }
     /**
-     * Process all items in queue after it order them based on their timestamp. Beware that order
-     * matter in execution of Http Request in queue. When a request completes only then next will begin. Emission
-     * or Http response follows order.
-     * @param [ascending=true] - sets the order of queue items based on timestamp
+     * Processes all items in the queue sequentially, based on their timestamp ordering.
+     *
+     * This method first orders the items in the API queue by their timestamp, either in ascending or descending
+     * order as specified by the `ascending` parameter. It then processes each item using `buildHttpRequest`, ensuring
+     * that each request is completed before the next begins. This sequential processing is crucial when the order of
+     * execution matters for HTTP requests in the queue. The method returns an Observable that emits the responses
+     * following the same order as the queue items were processed.
+     *
+     * The function currently returns `Observable<any>`, indicating a broad type. Future improvements should focus on
+     * specifying a more accurate return type or utilizing generics for increased type safety.
+     *
+     * @param {boolean} [ascending=true] - Determines whether the queue items are processed in ascending order of their
+     *                                     timestamp. Defaults to `true`.
+     * @returns {Observable<any>} An Observable emitting the responses of the HTTP requests in the order they were processed.
+     *
+     * @example
+     * this.processAllQueueItemsSequential().subscribe(response => {
+     *   // Handle each response in the order of queue processing
+     * });
      */
-    // TODO: find the correct type or turn into a generic, https://www.typescriptlang.org/docs/handbook/2/generics.html
+    // TODO: Refine the return type for more specific or implement generics, https://www.typescriptlang.org/docs/handbook/2/generics.html
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     processAllQueueItemsSequential(ascending = true) {
-        return this.store.select(getApiQueue).pipe(concatMap((queue) => Object.entries(queue)
+        return this.store.select(getApiQueue).pipe(switchMap((queue) => from(Object.entries(queue)
             .sort((a, b) => (ascending ? this.sortOnTimestamp(a, b) : this.sortOnTimestamp(b, a)))
-            .map(([id, item]) => this.buildHttpRequest(id, item))));
+            .map(([id, item]) => this.buildHttpRequest(id, item)))
+            .pipe(concatMap(x => x))));
     }
     /**
-     * Short dates ascending based on input
-     * @param a - Date one
-     * @param b - Date two
+     * Compares two queue items based on their timestamp and determines their order.
+     *
+     * This protected method is used to sort queue items. It takes two queue items as input, each represented
+     * as a tuple containing an item ID and the `ApiQueueItem` object. The method compares these items based on
+     * the `timestamp` property of the `ApiQueueItem` objects. It returns a number indicating the order in which
+     * these items should be sorted.
+     *
+     * A positive return value indicates that the first item should come after the second, a negative value
+     * indicates the opposite, and zero indicates that they are equal in terms of timestamp.
      *
+     * @param {[string, ApiQueueItem]} a - The first queue item tuple for comparison.
+     * @param {[string, ApiQueueItem]} b - The second queue item tuple for comparison.
+     * @returns {number} A number indicating the order of the items: negative if `a` is earlier than `b`,
+     *                  positive if `a` is later than `b`, and zero if they are equal.
      * @beta
      */
     sortOnTimestamp(a, b) {
         return +new Date(a[1].timestamp) - +new Date(b[1].timestamp);
     }
     /**
-     * build and HttpRequest Observable based on the given queue.
-     * After successful request completion removes the item from the queue.
-     * @param id - id of the item inside the queue
-     * @param item - the item of the queue that matches the id.
-     * @return An Observable of HttpClient Request
+     * Constructs and executes an HTTP request based on the provided queue item details.
+     *
+     * This private method takes an ID and an `ApiQueueItem` object to build and execute an HTTP request.
+     * It determines the HTTP method (like GET, POST, etc.) from the `method` property of the `ApiQueueItem`,
+     * and uses the `uri` and `payload` properties for the request's URL and body, respectively. After the
+     * request is executed, the corresponding queue item is removed from the queue.
+     *
+     * The method is generic, allowing the caller to specify the expected response type `T`. By default,
+     * it uses `any` type, but specifying a more concrete type enhances type safety and clarity in usage.
+     *
+     * @param {string} id - The ID of the queue item being processed.
+     * @param {ApiQueueItem} item - The queue item containing details for the HTTP request.
+     * @returns {Observable<T>} An Observable of type T, representing the response of the HTTP request.
+     *
+     * @example
+     * // Example usage for a specific response type
+     * this.buildHttpRequest<MyResponseType>('item123', queueItem)
+     *     .subscribe(response => {
+     *         // Handle the response
+     *     });
+     *
+     * @template T - The expected type of the HTTP response. Defaults to `any`.
      */
     // TODO: add type for T and deprecate old function
     // TODO: find the correct type or turn into a generic, https://www.typescriptlang.org/docs/handbook/2/generics.html
@@ -148,4 +331,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.2", ngImpor
         }], ctorParameters: () => [{ type: i1.StoreService }, { type: i2.HttpClient }, { type: i3.LogService, decorators: [{
                     type: Optional
                 }] }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-queue.service.js","sourceRoot":"","sources":["../../../../../src/lib/services/queue/api-queue.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Optional } from '@angular/core';\nimport { HttpClient } from '@angular/common/http';\nimport { Observable, of, forkJoin } from 'rxjs';\nimport { tap, switchMap, take, map, catchError, concatMap } from 'rxjs/operators';\nimport { getApiQueue, getApiQueueItem, ApiQueue, ApiQueueItem } from '@eui/base';\n\nimport { LogService } from '../log';\nimport { StoreService, AddApiQueueItemAction, RemoveApiQueueItemAction, EmptyApiQueueAction } from '../store';\n\n@Injectable({\n    providedIn: 'root',\n})\nexport class ApiQueueService {\n    constructor(\n        protected store: StoreService,\n        protected http: HttpClient,\n        @Optional() protected logService: LogService,\n    ) {}\n\n    /**\n     * Adds an item in the queue by dispatching an action to the store.\n     * @param id - The id of the item inside the queue.\n     * WARNING if matches any other queue item id will overwrite it.\n     * @param item - an item for Queue\n     */\n    addQueueItem(id: string, item: ApiQueueItem): void {\n        const allowedMethods = ['post', 'put', 'get'];\n\n        if (allowedMethods.indexOf(item.method) < 0) {\n            throw new Error(`[ApiQueue] method \"${item.method}\" is not allowed`);\n        }\n\n        this.store.dispatch(new AddApiQueueItemAction({ id, item }));\n    }\n\n    /**\n     * Subscribes to the store to retrieve queue and then converts the queue object to an array of items.\n     * @return An Observable of array of all items inside the current queue (ApiQueueItem[])\n     */\n    getQueue(): Observable<ApiQueueItem[]> {\n        return this.store.select(getApiQueue).pipe(\n            take(1),\n            map((queue: ApiQueue) => {\n                const queueArray = queue && Object.values<ApiQueueItem>(queue);\n                if (!queueArray || queueArray.length < 1) {\n                    this.logService?.warn('No items in the queue exist.');\n                }\n\n                return queueArray;\n            }),\n        );\n    }\n\n    /**\n     * Subscribes to the store to retrieve an item from the queue.\n     * @param id - id of the item inside the queue\n     * @return An Observable of ApiQueueItem type\n     */\n    getQueueItem(id: string): Observable<ApiQueueItem> {\n        return this.store.select(getApiQueueItem(id)).pipe(\n            take(1),\n            map((queue: ApiQueueItem) => {\n                if (!queue) {\n                    this.logService?.warn(`Queue item with id \"${id}\" does not exist`);\n                    return null;\n                }\n                return queue;\n            }),\n        );\n    }\n\n    /**\n     * Removes a given item from the queue.\n     * @param id - id of the item inside the queue\n     */\n    removeQueueItem(id: string): void {\n        this.store.dispatch(new RemoveApiQueueItemAction(id));\n    }\n\n    /**\n     * Removes all items placed in the queue.\n     */\n    removeAllQueueItem(): void {\n        this.store.dispatch(new EmptyApiQueueAction(null));\n    }\n\n    /**\n     * Process an item from the queue.\n     * @param id - id of the item inside the queue\n     * @return An Observable of type any\n     */\n    // TODO: find the correct type or turn into a generic, https://www.typescriptlang.org/docs/handbook/2/generics.html\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    processQueueItem(id: string): Observable<any> {\n        return this.store.select(getApiQueueItem(id)).pipe(\n            take(1),\n            switchMap((queue: ApiQueueItem) => {\n                if (!queue) {\n                    this.logService?.warn(`Queue item with id \"${id}\" does not exist`);\n                    return of(null);\n                }\n\n                return this.buildHttpRequest(id, queue);\n            }),\n        );\n    }\n\n    /**\n     * Process all the items inside the queue.\n     * @param [continueOnError=true] - in case of an item request fails continue with the rest in queue\n     * @return An Observable with an array which contains all responses from all items in queue.\n     */\n    // TODO: find the correct type or turn into a generic, https://www.typescriptlang.org/docs/handbook/2/generics.html\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    processAllQueueItems(continueOnError = true): Observable<any[]> {\n        return this.store.select(getApiQueue).pipe(\n            map((queue: ApiQueue) =>\n                Object.entries(queue).map(([key, value]) =>\n                    this.buildHttpRequest(key, value).pipe(\n                        catchError((error: Error) => {\n                            this.logService?.error(`Queue Item with id ${key} failed.`, error.message, error.stack);\n\n                            if (!continueOnError) {\n                                throw error;\n                            }\n\n                            return of(error);\n                        }),\n                    ),\n                ),\n            ),\n            // TODO: find the correct type or turn into a generic, https://www.typescriptlang.org/docs/handbook/2/generics.html\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            switchMap((obsQueue: Observable<any>[]) => forkJoin(Array.from(obsQueue))),\n        );\n    }\n\n    /**\n     * Process all items in queue after it order them based on their timestamp. Beware that order\n     * matter in execution of Http Request in queue. When a request completes only then next will begin. Emission\n     * or Http response follows order.\n     * @param [ascending=true] - sets the order of queue items based on timestamp\n     */\n    // TODO: find the correct type or turn into a generic, https://www.typescriptlang.org/docs/handbook/2/generics.html\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    processAllQueueItemsSequential(ascending = true): Observable<any> {\n        return this.store.select(getApiQueue).pipe(\n            concatMap((queue: ApiQueue) =>\n                Object.entries(queue)\n                    .sort((a, b) => (ascending ? this.sortOnTimestamp(a, b) : this.sortOnTimestamp(b, a)))\n                    .map(([id, item]) => this.buildHttpRequest(id, item)),\n            ),\n        );\n    }\n\n    /**\n     * Short dates ascending based on input\n     * @param a - Date one\n     * @param b - Date two\n     *\n     * @beta\n     */\n    protected sortOnTimestamp(a: [string, ApiQueueItem], b: [string, ApiQueueItem]): number {\n        return +new Date(a[1].timestamp) - +new Date(b[1].timestamp);\n    }\n\n    /**\n     * build and HttpRequest Observable based on the given queue.\n     * After successful request completion removes the item from the queue.\n     * @param id - id of the item inside the queue\n     * @param item - the item of the queue that matches the id.\n     * @return An Observable of HttpClient Request\n     */\n    // TODO: add type for T and deprecate old function\n    // TODO: find the correct type or turn into a generic, https://www.typescriptlang.org/docs/handbook/2/generics.html\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    private buildHttpRequest<T = any>(id: string, item: ApiQueueItem): Observable<T> {\n        return this.http[item.method.toLowerCase()](item.uri, item.payload).pipe(tap(() => this.removeQueueItem(id)));\n    }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-queue.service.js","sourceRoot":"","sources":["../../../../../src/lib/services/queue/api-queue.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Optional } from '@angular/core';\nimport { HttpClient } from '@angular/common/http';\nimport { Observable, of, forkJoin, from } from 'rxjs';\nimport { tap, switchMap, take, map, catchError, concatMap } from 'rxjs/operators';\nimport { getApiQueue, getApiQueueItem, ApiQueue, ApiQueueItem } from '@eui/base';\n\nimport { LogService } from '../log';\nimport { StoreService, AddApiQueueItemAction, RemoveApiQueueItemAction, EmptyApiQueueAction } from '../store';\n\n/**\n * Service class for managing and processing a queue of API requests.\n *\n * This service provides functionality to add, remove, process, and manage HTTP requests stored in a queue.\n * It enables sequential or bulk processing of requests, ensuring controlled execution and handling of API calls.\n * The service methods offer features like processing individual items, processing all items in the queue either\n * sequentially or all at once, and removing items from the queue. Each method is designed to handle specific aspects\n * of queue management and processing, with attention to details like order of execution and error handling.\n *\n * Usage of this service is ideal in scenarios where API requests need to be managed in a queue structure, allowing\n * for controlled execution and monitoring of these requests.\n *\n * @example\n * // Adding a new item to the queue\n * apiQueueService.addQueueItem({ id: 'item124', method: 'POST', uri: '/api/data', payload: {...} });\n *\n * // Processing a single item from the queue\n * apiQueueService.processQueueItem('item123').subscribe(result => {\n *   console.log('Processed item 123 with result:', result);\n * });\n *\n * // Processing all items in the queue in sequential order\n * apiQueueService.processAllQueueItemsSequential(false).subscribe(results => {\n *   console.log('Processed all items in descending order of their timestamp:', results);\n * });\n *\n * // Removing an item from the queue\n * apiQueueService.removeQueueItem('item123');\n *\n * // Processing all items in the queue and continuing on error\n * apiQueueService.processAllQueueItems(true).subscribe(results => {\n *   console.log('Processed all items in the queue with continuation on errors:', results);\n * });\n */\n@Injectable({\n    providedIn: 'root',\n})\nexport class ApiQueueService {\n    constructor(\n        protected store: StoreService,\n        protected http: HttpClient,\n        @Optional() protected logService: LogService,\n    ) {}\n\n    /**\n     * Adds an item to the queue by dispatching an action to the store.\n     * This function is specifically designed to enqueue API call requests represented by `ApiQueueItem` objects.\n     * Each item is identified by a unique `id`, which is used to manage the queue.\n     *\n     * @param {string} id - The unique identifier for the queue item. It's crucial to ensure that this ID is unique within the queue.\n     *                      If an item with the same ID already exists, the new item will overwrite the existing one.\n     *                      WARNING: Duplicate IDs will lead to overwriting of queue items.\n     *\n     * @param {ApiQueueItem} item - The item to be enqueued. This should be an object of type `ApiQueueItem`.\n     *                              The `method` property of the item must be one of the allowed methods ('post', 'put', 'get').\n     *                              If an unsupported method is provided, the function will throw an error.\n     *\n     * @throws {Error} Throws an error if the `method` property of the `item` is not one of the allowed methods.\n     *                 The error message is: `[ApiQueue] method \"${item.method}\" is not allowed`.\n     *\n     * @example\n     * // Example of adding an item to the API queue\n     * addQueueItem('12345', { method: 'post', url: '/api/data', payload: {...} });\n     *\n     * @returns {void} This function does not return a value. It adds the item to the queue via a dispatch action.\n     */\n    addQueueItem(id: string, item: ApiQueueItem): void {\n        const allowedMethods = ['post', 'put', 'get'];\n\n        if (allowedMethods.indexOf(item.method) < 0) {\n            throw new Error(`[ApiQueue] method \"${item.method}\" is not allowed`);\n        }\n\n        this.store.dispatch(new AddApiQueueItemAction({ id, item }));\n    }\n\n    /**\n     * Retrieves the current state of the API queue and converts it into an array of Observables.\n     *\n     * This method subscribes to the store to access the API queue. It then maps the queue object,\n     * which is an associative array, into a linear array of ApiQueueItem instances. If the queue is empty,\n     * a warning is logged. This method is useful for tracking the state and contents of the API queue\n     * at a given moment.\n     *\n     * Note: This method takes a snapshot of the queue at the time of subscription. It does not provide\n     * a continuous stream of queue updates. To get real-time updates, consider subscribing directly\n     * to the store's observable.\n     *\n     * @returns {Observable<ApiQueueItem[]>} An Observable that emits an array of ApiQueueItem.\n     * The array represents all items currently in the queue. If the queue is empty, it emits an empty array.\n     *\n     * @example\n     * // Example usage\n     * this.getQueue().subscribe(queueItems => {\n     *   console.log('Current queue items:', queueItems);\n     * });\n     */\n    getQueue(): Observable<ApiQueueItem[]> {\n        return this.store.select(getApiQueue).pipe(\n            take(1),\n            map((queue: ApiQueue) => {\n                const queueArray = queue && Object.values<ApiQueueItem>(queue);\n                if (!queueArray || queueArray.length < 1) {\n                    this.logService?.warn('No items in the queue exist.');\n                }\n\n                return queueArray;\n            }),\n        );\n    }\n\n    /**\n     * Retrieves a specific item from the API queue by its ID.\n     *\n     * This method subscribes to the store and selects a single item from the API queue based on the provided ID.\n     * It employs a pipeline to fetch the item: the `getApiQueueItem` selector is used to retrieve the item,\n     * and a `map` operator processes the result. If the item with the specified ID does not exist in the queue,\n     * a warning is logged, and `null` is returned.\n     *\n     * This method is ideal for accessing a specific queue item when its ID is known, allowing for targeted\n     * operations or checks on that particular item.\n     *\n     * @param {string} id - The unique identifier of the item within the queue.\n     * @returns {Observable<ApiQueueItem | null>} An Observable emitting the requested ApiQueueItem.\n     * If no item with the given ID exists in the queue, the Observable emits `null`.\n     *\n     * @example\n     * // Example usage\n     * this.getQueueItem('item123').subscribe(item => {\n     *   if (item) {\n     *     console.log('Found item:', item);\n     *   } else {\n     *     console.log('Item not found in the queue');\n     *   }\n     * });\n     */\n    getQueueItem(id: string): Observable<ApiQueueItem> {\n        return this.store.select(getApiQueueItem(id)).pipe(\n            take(1),\n            map((queue: ApiQueueItem) => {\n                if (!queue) {\n                    this.logService?.warn(`Queue item with id \"${id}\" does not exist`);\n                    return null;\n                }\n                return queue;\n            }),\n        );\n    }\n\n    /**\n     * Removes a specific item from the API queue using its ID.\n     *\n     * This method dispatches an action to remove an item from the queue, identified by the provided ID.\n     * It is essential for managing the queue by eliminating items that are no longer needed or have been processed.\n     * The function does not return any value, as it primarily triggers an action within the store.\n     *\n     * Note: This method assumes the existence of the item in the queue. It does not perform a check\n     * to confirm the presence of the item before attempting to remove it. Therefore, it's recommended\n     * to verify the item's existence in the queue if uncertainty exists.\n     *\n     * @param {string} id - The unique identifier of the item to be removed from the queue.\n     *\n     * @example\n     * // Example usage\n     * this.removeQueueItem('item123');\n     * // The item with ID 'item123' will be dispatched for removal from the queue.\n     */\n    removeQueueItem(id: string): void {\n        this.store.dispatch(new RemoveApiQueueItemAction(id));\n    }\n\n    /**\n     * Clears all items from the API queue.\n     *\n     * This method dispatches an action to empty the entire API queue, effectively removing all items that are currently queued.\n     * It is useful for scenarios where a complete reset of the queue is required, such as during initialization or after processing\n     * a batch of items. The function does not return any value, as its primary purpose is to trigger a state change in the store.\n     *\n     * Note: Use this method with caution as it will irreversibly clear all items in the queue. Ensure that this action does not\n     * disrupt any ongoing processes that rely on the queue's contents.\n     *\n     * @example\n     * // Example usage\n     * this.removeAllQueueItem();\n     * // This will dispatch an action to empty the entire API queue.\n     */\n    removeAllQueueItem(): void {\n        this.store.dispatch(new EmptyApiQueueAction(null));\n    }\n\n    /**\n     * Processes an item from the API queue identified by its ID.\n     *\n     * Retrieves the specified item from the queue and applies processing logic as defined in `buildHttpRequest`.\n     * If the item is not found, logs a warning and returns an Observable emitting `null`.\n     *\n     * @param {string} id - The unique identifier of the item within the queue to be processed.\n     * @returns {Observable<any>} An Observable that emits the result of processing the queue item.\n     * If the item does not exist, the Observable emits `null`.\n     *\n     * @example\n     * // Example usage\n     * this.processQueueItem('item123').subscribe(result => {\n     *   if (result) {\n     *     console.log('Processing result:', result);\n     *   } else {\n     *     console.log('Item not found in the queue');\n     *   }\n     * });\n     */\n    // TODO: Replace `any` with a more specific type or make the method generic, https://www.typescriptlang.org/docs/handbook/2/generics.html\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    processQueueItem(id: string): Observable<any> {\n        return this.store.select(getApiQueueItem(id)).pipe(\n            take(1),\n            switchMap((queue: ApiQueueItem) => {\n                if (!queue) {\n                    this.logService?.warn(`Queue item with id \"${id}\" does not exist`);\n                    return of(null);\n                }\n\n                return this.buildHttpRequest(id, queue);\n            }),\n        );\n    }\n\n    /**\n     * Processes all items in the API queue and collects their responses.\n     *\n     * Iterates over each item in the queue and processes them using `buildHttpRequest`. If a request fails,\n     * the method can either continue processing the remaining items or stop, based on the `continueOnError` parameter.\n     * It returns an Observable that emits an array containing the responses or errors from all the processed items.\n     *\n     * The function currently returns `Observable<any[]>` indicating an array of any type. Future improvements\n     * should aim to specify a more accurate return type or utilize generics for increased type safety.\n     *\n     * @param {boolean} [continueOnError=true] - Determines whether to continue with the next item in the queue\n     *                                           after a request failure. Defaults to `true`.\n     * @returns {Observable<any[]>} An Observable emitting an array of either responses or errors from the processed\n     *                              queue items.\n     *\n     * @example\n     * this.processAllQueueItems().subscribe(results => {\n     *   // Handle the array of responses or errors\n     * });\n     */\n    // TODO: Refine the return type to be more specific or implement generics, https://www.typescriptlang.org/docs/handbook/2/generics.html\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    processAllQueueItems<T = any>(continueOnError = true): Observable<T[]> {\n        return this.store.select(getApiQueue).pipe(\n            map((queue: ApiQueue) =>\n                Object.entries(queue).map(([key, value]) =>\n                    this.buildHttpRequest(key, value).pipe(\n                        catchError((error: Error) => {\n                            this.logService?.error(`Queue Item with id ${key} failed.`, error.message, error.stack);\n\n                            if (!continueOnError) {\n                                throw error;\n                            }\n\n                            return of(error);\n                        }),\n                    ),\n                ),\n            ),\n            switchMap((obsQueue: Observable<T>[]) => forkJoin(Array.from(obsQueue))),\n        );\n    }\n\n    /**\n     * Processes all items in the queue sequentially, based on their timestamp ordering.\n     *\n     * This method first orders the items in the API queue by their timestamp, either in ascending or descending\n     * order as specified by the `ascending` parameter. It then processes each item using `buildHttpRequest`, ensuring\n     * that each request is completed before the next begins. This sequential processing is crucial when the order of\n     * execution matters for HTTP requests in the queue. The method returns an Observable that emits the responses\n     * following the same order as the queue items were processed.\n     *\n     * The function currently returns `Observable<any>`, indicating a broad type. Future improvements should focus on\n     * specifying a more accurate return type or utilizing generics for increased type safety.\n     *\n     * @param {boolean} [ascending=true] - Determines whether the queue items are processed in ascending order of their\n     *                                     timestamp. Defaults to `true`.\n     * @returns {Observable<any>} An Observable emitting the responses of the HTTP requests in the order they were processed.\n     *\n     * @example\n     * this.processAllQueueItemsSequential().subscribe(response => {\n     *   // Handle each response in the order of queue processing\n     * });\n     */\n    // TODO: Refine the return type for more specific or implement generics, https://www.typescriptlang.org/docs/handbook/2/generics.html\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    processAllQueueItemsSequential(ascending = true): Observable<any> {\n        return this.store.select(getApiQueue).pipe(\n            switchMap((queue: ApiQueue) =>\n                from(Object.entries(queue)\n                    .sort((a, b) => (ascending ? this.sortOnTimestamp(a, b) : this.sortOnTimestamp(b, a)))\n                    .map(([id, item]) => this.buildHttpRequest(id, item)))\n                    .pipe(concatMap(x => x)),\n            ),\n        );\n    }\n\n    /**\n     * Compares two queue items based on their timestamp and determines their order.\n     *\n     * This protected method is used to sort queue items. It takes two queue items as input, each represented\n     * as a tuple containing an item ID and the `ApiQueueItem` object. The method compares these items based on\n     * the `timestamp` property of the `ApiQueueItem` objects. It returns a number indicating the order in which\n     * these items should be sorted.\n     *\n     * A positive return value indicates that the first item should come after the second, a negative value\n     * indicates the opposite, and zero indicates that they are equal in terms of timestamp.\n     *\n     * @param {[string, ApiQueueItem]} a - The first queue item tuple for comparison.\n     * @param {[string, ApiQueueItem]} b - The second queue item tuple for comparison.\n     * @returns {number} A number indicating the order of the items: negative if `a` is earlier than `b`,\n     *                  positive if `a` is later than `b`, and zero if they are equal.\n     * @beta\n     */\n    protected sortOnTimestamp(a: [string, ApiQueueItem], b: [string, ApiQueueItem]): number {\n        return +new Date(a[1].timestamp) - +new Date(b[1].timestamp);\n    }\n\n    /**\n     * Constructs and executes an HTTP request based on the provided queue item details.\n     *\n     * This private method takes an ID and an `ApiQueueItem` object to build and execute an HTTP request.\n     * It determines the HTTP method (like GET, POST, etc.) from the `method` property of the `ApiQueueItem`,\n     * and uses the `uri` and `payload` properties for the request's URL and body, respectively. After the\n     * request is executed, the corresponding queue item is removed from the queue.\n     *\n     * The method is generic, allowing the caller to specify the expected response type `T`. By default,\n     * it uses `any` type, but specifying a more concrete type enhances type safety and clarity in usage.\n     *\n     * @param {string} id - The ID of the queue item being processed.\n     * @param {ApiQueueItem} item - The queue item containing details for the HTTP request.\n     * @returns {Observable<T>} An Observable of type T, representing the response of the HTTP request.\n     *\n     * @example\n     * // Example usage for a specific response type\n     * this.buildHttpRequest<MyResponseType>('item123', queueItem)\n     *     .subscribe(response => {\n     *         // Handle the response\n     *     });\n     *\n     * @template T - The expected type of the HTTP response. Defaults to `any`.\n     */\n    // TODO: add type for T and deprecate old function\n    // TODO: find the correct type or turn into a generic, https://www.typescriptlang.org/docs/handbook/2/generics.html\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    private buildHttpRequest<T = any>(id: string, item: ApiQueueItem): Observable<T> {\n        return this.http[item.method.toLowerCase()]<T>(item.uri, item.payload).pipe(tap(() => this.removeQueueItem(id)));\n    }\n}\n"]}