http-request-manager 18.1.1 → 18.2.0

package/esm2022/lib/services/request-manager-services/http-manager-signals.service.mjs

@@ -0,0 +1,199 @@
+import { Inject, inject, Injectable, Injector, Optional, signal } from '@angular/core';
+import { HttpErrorResponse } from '@angular/common/http';
+import { Subject, throwError } from 'rxjs';
+import { tap, map, finalize, catchError } from 'rxjs/operators';
+import { ApiRequest } from '../request-manager-state-service/models/api-request.model';
+import { RequestSignalsService } from './request-signals.service'; // 👈 updated
+import { requestPolling, countdown, delayedRetry } from './rxjs-operators';
+import { ToastColors, ToastDisplay, ToastMessageDisplayService } from 'toast-message-display';
+import { CONFIG_SETTINGS_TOKEN } from '../../models/config-token.model';
+import { ObjectMergerService } from '../utils/object-merger.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../models";
+export class HTTPManagerSignalsService extends RequestSignalsService {
+    constructor(configOptions) {
+        super();
+        this.configOptions = configOptions;
+        this.toastMessage = inject(ToastMessageDisplayService);
+        this.ng_injector = inject(Injector);
+        this.objectMergerService = inject(ObjectMergerService);
+        // ✅ Replaced BehaviorSubjects with Angular signals
+        this.countdown = signal(0);
+        this.error = signal(false);
+        this.data = signal(null);
+        this.polling$ = new Subject();
+        this.config = ApiRequest.adapt();
+        this.config = configOptions
+            ? ApiRequest.adapt(configOptions.httpRequestOptions)
+            : this.config;
+    }
+    // REQUESTS
+    getRequest(options, params) {
+        this.isPending.set(true);
+        this.data.set(null);
+        const updatedOptions = this.defineReqOptions(options, params);
+        const func = this.getRecordRequest;
+        const requests = this.createRequest(func, updatedOptions);
+        return this.createObservable(updatedOptions, requests, func.name).pipe(tap(data => this.data.set(data)), finalize(() => this.isPending.set(false)), catchError((err) => {
+            if (updatedOptions.displayError)
+                this.handleErrorWithSnackBar(err);
+            this.isPending.set(false);
+            return this.handleError(err);
+        }));
+    }
+    postRequest(data, options, params) {
+        this.isPending.set(true);
+        this.data.set(null);
+        const updatedOptions = this.defineReqOptions(options, params);
+        const func = this.createRecordRequest;
+        const requests = this.createRequest(func, updatedOptions, data);
+        return this.createObservable(updatedOptions, requests, func.name).pipe(tap(data => this.data.set(data)), finalize(() => this.isPending.set(false)), catchError((err) => {
+            if (updatedOptions.displayError)
+                this.handleErrorWithSnackBar(err);
+            this.isPending.set(false);
+            return this.handleError(err);
+        }));
+    }
+    putRequest(data, options, params) {
+        this.isPending.set(true);
+        this.data.set(null);
+        const updatedOptions = this.defineReqOptions(options, params);
+        const func = this.updateRecordRequest;
+        const requests = this.createRequest(func, updatedOptions, data);
+        return this.createObservable(updatedOptions, requests, func.name).pipe(tap(data => this.data.set(data)), finalize(() => this.isPending.set(false)), catchError((err) => {
+            if (updatedOptions.displayError)
+                this.handleErrorWithSnackBar(err);
+            this.isPending.set(false);
+            return this.handleError(err);
+        }));
+    }
+    deleteRequest(options, params) {
+        this.isPending.set(true);
+        this.data.set(null);
+        const updatedOptions = this.defineReqOptions(options, params);
+        const func = this.deleteRecordRequest;
+        const requests = this.createRequest(func, updatedOptions);
+        return this.createObservable(updatedOptions, requests, func.name).pipe(tap(data => this.data.set(data)), finalize(() => this.isPending.set(false)), catchError((err) => {
+            if (updatedOptions.displayError)
+                this.handleErrorWithSnackBar(err);
+            this.isPending.set(false);
+            return this.handleError(err);
+        }));
+    }
+    downloadRequest(options, params, saveAs) {
+        this.isPending.set(true);
+        const updatedOptions = this.defineReqOptions(options, params);
+        const func = this.downloadFileRequest;
+        const requests = this.createRequest(func, updatedOptions);
+        return this.createObservable(updatedOptions, requests, func.name).pipe(catchError((err) => {
+            this.error.set(true);
+            this.isPending.set(false);
+            return this.handleError(err);
+        }));
+    }
+    // --- private helpers ---
+    createObservable(options, request$, funcName) {
+        const polling = options.polling ? (options.polling > 0 ? true : false) : false;
+        const isPolling = polling &&
+            !(funcName === 'deleteRecordRequest' ||
+                funcName === 'updateRecordRequest' ||
+                funcName === 'createRecordRequest');
+        this.polling$.next();
+        const polling$ = (isPolling && options.polling) || 0 >= 3
+            ? request$.pipe(requestPolling((options.polling || 0) + 1, this.polling$, this.isPending), tap(() => this.countdown.set(0)), tap(() => {
+                if (!options.polling)
+                    return;
+                const count = options.polling ? options.polling : 0;
+                countdown(count)
+                    .pipe(map((x) => {
+                    const pollingInSec = options.polling || 0;
+                    const percentageCompleted = ((pollingInSec - x) / pollingInSec) * 100;
+                    return Math.round(percentageCompleted);
+                }))
+                    .subscribe((countDownValue) => {
+                    this.countdown.set(countDownValue);
+                });
+            }))
+            : request$.pipe(catchError((err) => {
+                if (err instanceof HttpErrorResponse) {
+                    this.error.set(true);
+                    return this.handleError(err);
+                }
+                return throwError(() => err);
+            }));
+        return polling$.pipe(catchError((err, caught) => {
+            if (err instanceof HttpErrorResponse) {
+                this.error.set(true);
+                if (isPolling)
+                    this.stopPolling();
+                return this.handleError(err);
+            }
+            return throwError(() => err);
+        }), options?.retry && options.retry.times > 0
+            ? delayedRetry((options.retry.delay || 3) * 1000, (options.retry.times || 0) - 1)
+            : (source) => source);
+    }
+    createRequest(func, options, data) {
+        const dataItem = this.prepareRequestData(options, data, func.name);
+        return func.bind(this)(dataItem.options, dataItem.data);
+    }
+    prepareRequestData(options, data, funcName) {
+        if ((options.mapper && funcName === 'updateRecordRequest') || funcName === 'createRecordRequest') {
+            if (options?.mapper) {
+                data = options.mapper
+                    ? Array.isArray(data)
+                        ? map((item) => options.mapper(item))
+                        : options.mapper(data)
+                    : data;
+            }
+        }
+        else {
+            if (options?.adapter) {
+                data = Array.isArray(data)
+                    ? map((item) => options.adapter(item))
+                    : options.adapter(data);
+            }
+        }
+        return { options: options, data: data };
+    }
+    handleError(error) {
+        this.error.set(error.message || `${error.status} - ${error.statusText}`);
+        return throwError(() => error);
+    }
+    handleErrorWithSnackBar(error) {
+        const displayError = ToastDisplay.adapt({
+            message: error.message || `${error.status} - ${error.statusText}`,
+            action: 'OK',
+            color: ToastColors.ERROR,
+            icon: 'error',
+            duration: 5 * 1000,
+        });
+        this.toastMessage.toastMessage(displayError);
+    }
+    stopPolling() {
+        this.isPending.set(false);
+        this.polling$.next();
+    }
+    defineReqOptions(options, params) {
+        const req = ApiRequest.adapt(options);
+        if (req?.path)
+            req.path = params ? [...req.path, ...params] : req.path;
+        const optionsReq = req ? req : ApiRequest.adapt();
+        const updatedOptions = this.objectMergerService.mergeOptions(optionsReq);
+        return updatedOptions;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: HTTPManagerSignalsService, deps: [{ token: CONFIG_SETTINGS_TOKEN, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: HTTPManagerSignalsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: HTTPManagerSignalsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.ConfigOptions, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [CONFIG_SETTINGS_TOKEN]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http-manager-signals.service.js","sourceRoot":"","sources":["../../../../../../projects/http-request-manager/src/lib/services/request-manager-services/http-manager-signals.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, inject, Injectable, Injector, Optional, signal } from '@angular/core';\nimport { HttpErrorResponse } from '@angular/common/http';\nimport { Observable, Subject, throwError } from 'rxjs';\nimport { tap, map, finalize, catchError } from 'rxjs/operators';\n\nimport { ApiRequest } from '../request-manager-state-service/models/api-request.model';\nimport { RequestSignalsService } from './request-signals.service';   // 👈 updated\nimport { requestPolling, countdown, delayedRetry } from './rxjs-operators';\n\nimport { ToastColors, ToastDisplay, ToastMessageDisplayService } from 'toast-message-display';\nimport { CONFIG_SETTINGS_TOKEN } from '../../models/config-token.model';\nimport { ConfigOptions } from '../../models';\nimport { ObjectMergerService } from '../utils/object-merger.service';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class HTTPManagerSignalsService<T> extends RequestSignalsService {   // 👈 use signals service\n\n  toastMessage = inject(ToastMessageDisplayService);\n  ng_injector = inject(Injector);\n  objectMergerService = inject(ObjectMergerService);\n\n  // ✅ Replaced BehaviorSubjects with Angular signals\n  countdown = signal<number>(0);\n  error = signal<string | boolean>(false);\n  data = signal<any>(null);\n\n  private polling$ = new Subject<void>();\n\n  config = ApiRequest.adapt();\n\n  constructor(@Optional() @Inject(CONFIG_SETTINGS_TOKEN) private configOptions?: ConfigOptions) {\n    super();\n    this.config = configOptions\n      ? ApiRequest.adapt(configOptions.httpRequestOptions)\n      : this.config;\n  }\n\n  // REQUESTS\n  getRequest<T>(options?: ApiRequest, params?: any[]) {\n    this.isPending.set(true);\n    this.data.set(null);\n\n    const updatedOptions = this.defineReqOptions(options, params);\n    const func = this.getRecordRequest;\n    const requests = this.createRequest(func, updatedOptions);\n\n    return this.createObservable<T>(updatedOptions, requests, func.name).pipe(\n      tap(data => this.data.set(data)),\n      finalize(() => this.isPending.set(false)),\n      catchError((err) => {\n        if (updatedOptions.displayError) this.handleErrorWithSnackBar(err);\n        this.isPending.set(false);\n        return this.handleError(err);\n      })\n    );\n  }\n\n  postRequest<T extends { id?: number|string }>(data: T, options: ApiRequest, params?: any[]) {\n    this.isPending.set(true);\n    this.data.set(null);\n\n    const updatedOptions = this.defineReqOptions(options, params);\n    const func = this.createRecordRequest;\n    const requests = this.createRequest(func, updatedOptions, data);\n\n    return this.createObservable<T>(updatedOptions, requests, func.name).pipe(\n      tap(data => this.data.set(data)),\n      finalize(() => this.isPending.set(false)),\n      catchError((err) => {\n        if (updatedOptions.displayError) this.handleErrorWithSnackBar(err);\n        this.isPending.set(false);\n        return this.handleError(err);\n      })\n    );\n  }\n\n  putRequest<T extends { id?: number|string }>(data: T, options: ApiRequest, params?: any[]) {\n    this.isPending.set(true);\n    this.data.set(null);\n\n    const updatedOptions = this.defineReqOptions(options, params);\n    const func = this.updateRecordRequest;\n    const requests = this.createRequest(func, updatedOptions, data);\n\n    return this.createObservable<T>(updatedOptions, requests, func.name).pipe(\n      tap(data => this.data.set(data)),\n      finalize(() => this.isPending.set(false)),\n      catchError((err) => {\n        if (updatedOptions.displayError) this.handleErrorWithSnackBar(err);\n        this.isPending.set(false);\n        return this.handleError(err);\n      })\n    );\n  }\n\n  deleteRequest<T>(options: ApiRequest, params?: any[]) {\n    this.isPending.set(true);\n    this.data.set(null);\n\n    const updatedOptions = this.defineReqOptions(options, params);\n    const func = this.deleteRecordRequest;\n    const requests = this.createRequest(func, updatedOptions);\n\n    return this.createObservable<T>(updatedOptions, requests, func.name).pipe(\n      tap(data => this.data.set(data)),\n      finalize(() => this.isPending.set(false)),\n      catchError((err) => {\n        if (updatedOptions.displayError) this.handleErrorWithSnackBar(err);\n        this.isPending.set(false);\n        return this.handleError(err);\n      })\n    );\n  }\n\n  downloadRequest<T>(options: ApiRequest, params?: any[], saveAs?: string) {\n    this.isPending.set(true);\n\n    const updatedOptions = this.defineReqOptions(options, params);\n    const func = this.downloadFileRequest;\n    const requests = this.createRequest(func, updatedOptions);\n\n    return this.createObservable<T>(updatedOptions, requests, func.name).pipe(\n      catchError((err) => {\n        this.error.set(true);\n        this.isPending.set(false);\n        return this.handleError(err);\n      })\n    );\n  }\n\n  // --- private helpers ---\n  private createObservable<T>(options: ApiRequest, request$: Observable<T>, funcName: string) {\n    const polling =\n      options.polling ? (options.polling > 0 ? true : false) : false;\n\n    const isPolling =\n      polling &&\n      !(funcName === 'deleteRecordRequest' ||\n        funcName === 'updateRecordRequest' ||\n        funcName === 'createRecordRequest');\n\n    this.polling$.next();\n\n    const polling$ =\n      (isPolling && options.polling) || 0 >= 3\n        ? request$.pipe(\n            requestPolling((options.polling || 0) + 1, this.polling$, this.isPending),\n            tap(() => this.countdown.set(0)),\n            tap(() => {\n              if (!options.polling) return;\n              const count = options.polling ? options.polling : 0;\n              countdown(count)\n                .pipe(\n                  map((x: number) => {\n                    const pollingInSec = options.polling || 0;\n                    const percentageCompleted = ((pollingInSec - x) / pollingInSec) * 100;\n                    return Math.round(percentageCompleted);\n                  })\n                )\n                .subscribe((countDownValue: number) => {\n                  this.countdown.set(countDownValue);\n                });\n            }),\n          )\n        : request$.pipe(\n            catchError((err: any) => {\n              if (err instanceof HttpErrorResponse) {\n                this.error.set(true);\n                return this.handleError(err);\n              }\n              return throwError(() => err);\n            })\n          );\n\n    return polling$.pipe(\n      catchError((err: any, caught: Observable<T>) => {\n        if (err instanceof HttpErrorResponse) {\n          this.error.set(true);\n          if (isPolling) this.stopPolling();\n          return this.handleError(err);\n        }\n        return throwError(() => err);\n      }),\n      options?.retry && options.retry.times > 0\n        ? delayedRetry((options.retry.delay || 3) * 1000, (options.retry.times || 0) - 1)\n        : (source: Observable<T>) => source\n    );\n  }\n\n  private createRequest(func: Function, options: ApiRequest, data?: any | any[]) {\n    const dataItem = this.prepareRequestData(options, data, func.name);\n    return func.bind(this)(dataItem.options, dataItem.data);\n  }\n\n  private prepareRequestData(options: ApiRequest, data: any, funcName: string) {\n    if ((options.mapper && funcName === 'updateRecordRequest') || funcName === 'createRecordRequest') {\n      if (options?.mapper) {\n        data = options.mapper\n          ? Array.isArray(data)\n            ? map((item) => options.mapper(item))\n            : options.mapper(data)\n          : data;\n      }\n    } else {\n      if (options?.adapter) {\n        data = Array.isArray(data)\n          ? map((item) => options.adapter(item))\n          : options.adapter(data);\n      }\n    }\n    return { options: options, data: data };\n  }\n\n  private handleError(error: Response | any) {\n    this.error.set(error.message || `${error.status} - ${error.statusText}`);\n    return throwError(() => error);\n  }\n\n  private handleErrorWithSnackBar(error: Response | any) {\n    const displayError = ToastDisplay.adapt({\n      message: error.message || `${error.status} - ${error.statusText}`,\n      action: 'OK',\n      color: ToastColors.ERROR,\n      icon: 'error',\n      duration: 5 * 1000,\n    });\n    this.toastMessage.toastMessage(displayError);\n  }\n\n  private stopPolling() {\n    this.isPending.set(false);\n    this.polling$.next();\n  }\n\n  private defineReqOptions(options: any, params?: any[]) {\n    const req = ApiRequest.adapt(options);\n    if (req?.path) req.path = params ? [...req.path, ...params] : req.path;\n\n    const optionsReq = req ? req : ApiRequest.adapt();\n    const updatedOptions = this.objectMergerService.mergeOptions(optionsReq);\n\n    return updatedOptions;\n  }\n}\n"]}

package/esm2022/lib/services/request-manager-services/index.mjs

@@ -1,5 +1,6 @@
 export * from "./http-manager.service";
+export * from "./http-manager-signals.service";
 // export * from './request.service';
 export * from "../../models/index";
 export * from "./rxjs-operators/index";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9odHRwLXJlcXVlc3QtbWFuYWdlci9zcmMvbGliL3NlcnZpY2VzL3JlcXVlc3QtbWFuYWdlci1zZXJ2aWNlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLHFDQUFxQztBQUVyQyxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsd0JBQXdCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9odHRwLW1hbmFnZXIuc2VydmljZVwiO1xuLy8gZXhwb3J0ICogZnJvbSAnLi9yZXF1ZXN0LnNlcnZpY2UnO1xuXG5leHBvcnQgKiBmcm9tIFwiLi4vLi4vbW9kZWxzL2luZGV4XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9yeGpzLW9wZXJhdG9ycy9pbmRleFwiO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9odHRwLXJlcXVlc3QtbWFuYWdlci9zcmMvbGliL3NlcnZpY2VzL3JlcXVlc3QtbWFuYWdlci1zZXJ2aWNlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsZ0NBQWdDLENBQUM7QUFDL0MscUNBQXFDO0FBRXJDLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyx3QkFBd0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2h0dHAtbWFuYWdlci5zZXJ2aWNlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9odHRwLW1hbmFnZXItc2lnbmFscy5zZXJ2aWNlXCI7XG4vLyBleHBvcnQgKiBmcm9tICcuL3JlcXVlc3Quc2VydmljZSc7XG5cbmV4cG9ydCAqIGZyb20gXCIuLi8uLi9tb2RlbHMvaW5kZXhcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3J4anMtb3BlcmF0b3JzL2luZGV4XCI7XG4iXX0=

package/esm2022/lib/services/request-manager-services/request-signals.service.mjs

@@ -0,0 +1,170 @@
+import { HttpClient, HttpEventType, HttpHeaderResponse } from '@angular/common/http';
+import { Injectable, inject, signal, computed } from '@angular/core';
+import { throwError } from 'rxjs';
+import { catchError, finalize, map } from 'rxjs/operators';
+import { PathQueryService, HeadersService } from '../utils';
+import { requestStreaming } from './rxjs-operators/request-streaming';
+import * as i0 from "@angular/core";
+export class RequestSignalsService {
+    constructor() {
+        this.http = inject(HttpClient);
+        this.pathQueryService = inject(PathQueryService);
+        this.headersService = inject(HeadersService);
+        this.isPending = signal(false);
+        this.progress = signal(0);
+        this.isIdle = computed(() => !this.isPending());
+    }
+    getRecordRequest(options) {
+        const urlPath = this.buildUrlPath(options);
+        const headers = this.buildCombinedHeaders(options);
+        this.isPending.set(true);
+        return (options.stream)
+            ? this.http.get(urlPath, headers).pipe(requestStreaming(), this.handleFinalize())
+            : this.http.get(urlPath, headers).pipe(this.request(options), this.handleFinalize());
+    }
+    createRecordRequest(options, data) {
+        const urlPath = this.buildUrlPath(options);
+        const headers = this.buildCombinedHeaders(options);
+        this.isPending.set(true);
+        return (options.stream)
+            ? this.http.post(urlPath, data, headers).pipe(requestStreaming(), this.handleFinalize())
+            : this.http.post(urlPath, data, headers).pipe(this.request(options), this.handleFinalize());
+    }
+    updateRecordRequest(options, data) {
+        const urlPath = this.buildUrlPath(options);
+        const headers = this.buildHeaders(options);
+        this.isPending.set(true);
+        return this.http.put(urlPath, data, headers).pipe(this.request(options), this.handleFinalize());
+    }
+    deleteRecordRequest(options) {
+        const urlPath = this.buildUrlPath(options);
+        const headers = this.buildHeaders(options);
+        this.isPending.set(true);
+        return this.http.delete(urlPath, headers).pipe(this.request(options), this.handleFinalize());
+    }
+    buildUrlPath(options) {
+        return this.pathQueryService.buildAPIPath(options.server, options.path);
+    }
+    buildHeaders(options) {
+        return this.headersService.generateHeaders(options.headers);
+    }
+    buildCombinedHeaders(options) {
+        const headers = this.headersService.generateHeaders(options.headers);
+        return this.combineHeaders(headers, options.stream || false);
+    }
+    request(options) {
+        return (source$) => {
+            return source$.pipe(map(data => {
+                if (options?.adapter) {
+                    return Array.isArray(data)
+                        ? data.map((item) => options.adapter(item))
+                        : options.adapter(data);
+                }
+                return data;
+            }));
+        };
+    }
+    downloadFileRequest(options) {
+        this.isPending.set(true);
+        const urlPath = this.buildUrlPath(options);
+        return this.http.get(urlPath, { responseType: 'blob', observe: 'events', reportProgress: true })
+            .pipe(map((event) => {
+            this.isPending.set(true);
+            if (event instanceof HttpHeaderResponse) {
+                if (event.status !== 200) {
+                    this.isPending.set(false);
+                    throw new Error('Download failed');
+                }
+            }
+            switch (event.type) {
+                case HttpEventType.DownloadProgress:
+                    const status = (event.total) ? Math.round(event.loaded / (event.total || 1) * 100) : 100;
+                    this.progress.set(status);
+                    return status;
+                case HttpEventType.Response:
+                    try {
+                        const fileNamePath = (options?.saveAs) ? options.saveAs : (options.path) ? options.path[options.path.length - 1] : [];
+                        const header_content = event.headers.get('Content-Disposition') || '';
+                        const file = (header_content) ? header_content.split('=')[1].substring(0, header_content.split('=')[1].length) : '';
+                        const fileName = (fileNamePath !== '') ? fileNamePath : file;
+                        if (fileName === '') {
+                            this.isPending.set(false);
+                            throw new Error('Save File: (file name and extension) not found in Headers or Path');
+                        }
+                        this.downloadFile(fileName, event.body);
+                        this.isPending.set(false);
+                        return 100;
+                    }
+                    catch (error) {
+                        throw new Error('Download failed');
+                    }
+                default:
+                    this.isPending.set(false);
+                    return 0;
+            }
+        }), catchError(err => {
+            return throwError(() => err);
+        }));
+    }
+    handleFinalize() {
+        return finalize(() => this.isPending.set(false));
+    }
+    downloadFile(file, fileData) {
+        const navigatorAny = window.navigator;
+        const extension = file.split('.')[1]?.toLowerCase();
+        const newBlob = new Blob([fileData], { type: this.createFileType(extension) });
+        if (navigatorAny.msSaveOrOpenBlob) {
+            navigatorAny.msSaveOrOpenBlob(newBlob, file);
+        }
+        else {
+            const link = document.createElement('a');
+            const url = window.URL.createObjectURL(newBlob);
+            link.href = url;
+            link.download = file;
+            link.click();
+            window.URL.revokeObjectURL(url);
+        }
+    }
+    createFileType(ext) {
+        let fileType = "";
+        if (ext === 'pdf' || ext === 'csv')
+            fileType = `application/${ext}`;
+        else if (ext === 'jpeg' || ext === 'jpg' || ext === 'png')
+            fileType = `image/${ext}`;
+        else if (ext === 'txt')
+            fileType = 'text/plain';
+        else if (ext === 'ppt' || ext === 'pot' || ext === 'pps' || ext === 'ppa')
+            fileType = 'application/vnd.ms-powerpoint';
+        else if (ext === 'pptx')
+            fileType = 'application/vnd.openxmlformats-officedocument.presentationml.presentation';
+        else if (ext === 'doc' || ext === 'dot')
+            fileType = 'application/msword';
+        else if (ext === 'docx')
+            fileType = 'application/vnd.openxmlformats-officedocument.wordprocessingml.document';
+        else if (ext === 'xls' || ext === 'xlt' || ext === 'xla')
+            fileType = 'application/vnd.ms-excel';
+        else if (ext === 'xlsx')
+            fileType = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
+        return fileType;
+    }
+    combineHeaders(headers, isStreaming) {
+        return (isStreaming)
+            ? {
+                ...headers,
+                observe: 'events',
+                responseType: 'text',
+                reportProgress: true,
+                Accept: 'text/event-stream'
+            }
+            : headers;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RequestSignalsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RequestSignalsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RequestSignalsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"request-signals.service.js","sourceRoot":"","sources":["../../../../../../projects/http-request-manager/src/lib/services/request-manager-services/request-signals.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAa,aAAa,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAChG,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACrE,OAAO,EAAc,UAAU,EAAE,MAAM,MAAM,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAG3D,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;;AAKtE,MAAM,OAAO,qBAAqB;IAHlC;QAKU,SAAI,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;QAC1B,qBAAgB,GAAG,MAAM,CAAC,gBAAgB,CAAC,CAAC;QAC5C,mBAAc,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC;QAEhD,cAAS,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QAC1B,aAAQ,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QAErB,WAAM,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC;KAgM5C;IA9LC,gBAAgB,CAAI,OAAmB;QACrC,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QAC3C,MAAM,OAAO,GAAG,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC;QAEnD,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAEzB,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC;YACrB,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAM,OAAO,EAAE,OAAO,CAAC,CAAC,IAAI,CACvC,gBAAgB,EAAE,EAClB,IAAI,CAAC,cAAc,EAAE,CACtB;YACH,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAI,OAAO,EAAE,OAAO,CAAC,CAAC,IAAI,CACrC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,EACrB,IAAI,CAAC,cAAc,EAAE,CACtB,CAAC;IACR,CAAC;IAED,mBAAmB,CAAI,OAAmB,EAAE,IAAS;QACnD,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QAC3C,MAAM,OAAO,GAAG,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC;QAEnD,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAEzB,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC;YACrB,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAM,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC,IAAI,CAC9C,gBAAgB,EAAE,EAClB,IAAI,CAAC,cAAc,EAAE,CACtB;YACH,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAI,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC,IAAI,CAC5C,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,EACrB,IAAI,CAAC,cAAc,EAAE,CACtB,CAAC;IACR,CAAC;IAED,mBAAmB,CAAI,OAAmB,EAAE,IAAS;QACnD,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QAC3C,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QAE3C,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAEzB,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAM,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC,IAAI,CACpD,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,EACrB,IAAI,CAAC,cAAc,EAAE,CACtB,CAAC;IACJ,CAAC;IAED,mBAAmB,CAAI,OAAmB;QACxC,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QAC3C,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QAE3C,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAEzB,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAM,OAAO,EAAE,OAAO,CAAC,CAAC,IAAI,CACjD,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,EACrB,IAAI,CAAC,cAAc,EAAE,CACtB,CAAC;IACJ,CAAC;IAEO,YAAY,CAAC,OAAmB;QACtC,OAAO,IAAI,CAAC,gBAAgB,CAAC,YAAY,CAAC,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1E,CAAC;IAEO,YAAY,CAAC,OAAmB;QACtC,OAAO,IAAI,CAAC,cAAc,CAAC,eAAe,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IAC9D,CAAC;IAEO,oBAAoB,CAAC,OAAmB;QAC9C,MAAM,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,eAAe,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QACrE,OAAO,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,OAAO,CAAC,MAAM,IAAI,KAAK,CAAC,CAAC;IAC/D,CAAC;IAEO,OAAO,CAAI,OAAmB;QACpC,OAAO,CAAC,OAAwB,EAAiB,EAAE;YACjD,OAAO,OAAO,CAAC,IAAI,CACjB,GAAG,CAAC,IAAI,CAAC,EAAE;gBACT,IAAI,OAAO,EAAE,OAAO,EAAE,CAAC;oBACrB,OAAO,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC;wBACxB,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAS,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;wBAChD,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;gBAC5B,CAAC;gBACD,OAAO,IAAI,CAAC;YACd,CAAC,CAAC,CACH,CAAC;QACJ,CAAC,CAAC;IACJ,CAAC;IAED,mBAAmB,CAAC,OAAmB;QACrC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAEzB,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QAE3C,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,EAAE,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,IAAI,EAAE,CAAC;aAC7F,IAAI,CACH,GAAG,CAAC,CAAC,KAAqB,EAAE,EAAE;YAC5B,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YAEzB,IAAI,KAAK,YAAY,kBAAkB,EAAE,CAAC;gBACxC,IAAI,KAAK,CAAC,MAAM,KAAK,GAAG,EAAE,CAAC;oBACzB,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;oBAC1B,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAC;gBACrC,CAAC;YACH,CAAC;YAED,QAAQ,KAAK,CAAC,IAAI,EAAE,CAAC;gBACnB,KAAK,aAAa,CAAC,gBAAgB;oBACjC,MAAM,MAAM,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;oBACzF,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;oBAC1B,OAAO,MAAM,CAAC;gBAEhB,KAAK,aAAa,CAAC,QAAQ;oBACzB,IAAI,CAAC;wBACH,MAAM,YAAY,GAAG,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;wBACtH,MAAM,cAAc,GAAG,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,qBAAqB,CAAC,IAAI,EAAE,CAAC;wBACtE,MAAM,IAAI,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,cAAc,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;wBAEpH,MAAM,QAAQ,GAAG,CAAC,YAAY,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC;wBAE7D,IAAI,QAAQ,KAAK,EAAE,EAAE,CAAC;4BACpB,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;4BAC1B,MAAM,IAAI,KAAK,CAAC,mEAAmE,CAAC,CAAC;wBACvF,CAAC;wBAED,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;wBACxC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;wBAE1B,OAAO,GAAG,CAAC;oBAEb,CAAC;oBAAC,OAAO,KAAK,EAAE,CAAC;wBACf,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAC;oBACrC,CAAC;gBAEH;oBACE,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;oBAC1B,OAAO,CAAC,CAAC;YACb,CAAC;QACH,CAAC,CAAC,EACF,UAAU,CAAC,GAAG,CAAC,EAAE;YACf,OAAO,UAAU,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC;QAC/B,CAAC,CAAC,CACH,CAAC;IACN,CAAC;IAEO,cAAc;QACpB,OAAO,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;IACnD,CAAC;IAEO,YAAY,CAAC,IAAY,EAAE,QAAa;QAC9C,MAAM,YAAY,GAAG,MAAM,CAAC,SAAgB,CAAC;QAC7C,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC;QACpD,MAAM,OAAO,GAAG,IAAI,IAAI,CAAC,CAAC,QAAQ,CAAC,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;QAE/E,IAAI,YAAY,CAAC,gBAAgB,EAAE,CAAC;YAClC,YAAY,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;QAC/C,CAAC;aAAM,CAAC;YACN,MAAM,IAAI,GAAG,QAAQ,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;YACzC,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;YAChD,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC;YAChB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;YACrB,IAAI,CAAC,KAAK,EAAE,CAAC;YACb,MAAM,CAAC,GAAG,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC;QAClC,CAAC;IACH,CAAC;IAEO,cAAc,CAAC,GAAW;QAChC,IAAI,QAAQ,GAAG,EAAE,CAAC;QAElB,IAAI,GAAG,KAAK,KAAK,IAAI,GAAG,KAAK,KAAK;YAAE,QAAQ,GAAG,eAAe,GAAG,EAAE,CAAC;aAC/D,IAAI,GAAG,KAAK,MAAM,IAAI,GAAG,KAAK,KAAK,IAAI,GAAG,KAAK,KAAK;YAAE,QAAQ,GAAG,SAAS,GAAG,EAAE,CAAC;aAChF,IAAI,GAAG,KAAK,KAAK;YAAE,QAAQ,GAAG,YAAY,CAAC;aAC3C,IAAI,GAAG,KAAK,KAAK,IAAI,GAAG,KAAK,KAAK,IAAI,GAAG,KAAK,KAAK,IAAI,GAAG,KAAK,KAAK;YAAE,QAAQ,GAAG,+BAA+B,CAAC;aACjH,IAAI,GAAG,KAAK,MAAM;YAAE,QAAQ,GAAG,2EAA2E,CAAC;aAC3G,IAAI,GAAG,KAAK,KAAK,IAAI,GAAG,KAAK,KAAK;YAAE,QAAQ,GAAG,oBAAoB,CAAC;aACpE,IAAI,GAAG,KAAK,MAAM;YAAE,QAAQ,GAAG,yEAAyE,CAAC;aACzG,IAAI,GAAG,KAAK,KAAK,IAAI,GAAG,KAAK,KAAK,IAAI,GAAG,KAAK,KAAK;YAAE,QAAQ,GAAG,0BAA0B,CAAC;aAC3F,IAAI,GAAG,KAAK,MAAM;YAAE,QAAQ,GAAG,mEAAmE,CAAC;QAExG,OAAO,QAAQ,CAAC;IAClB,CAAC;IAEO,cAAc,CAAC,OAAY,EAAE,WAAoB;QACvD,OAAO,CAAC,WAAW,CAAC;YAClB,CAAC,CAAC;gBACE,GAAG,OAAO;gBACV,OAAO,EAAE,QAAQ;gBACjB,YAAY,EAAE,MAAM;gBACpB,cAAc,EAAE,IAAI;gBACpB,MAAM,EAAE,mBAAmB;aAC5B;YACH,CAAC,CAAC,OAAO,CAAC;IACd,CAAC;+GAxMU,qBAAqB;mHAArB,qBAAqB,cAFpB,MAAM;;4FAEP,qBAAqB;kBAHjC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { HttpClient, HttpEvent, HttpEventType, HttpHeaderResponse } from '@angular/common/http';\nimport { Injectable, inject, signal, computed } from '@angular/core';\nimport { Observable, throwError } from 'rxjs';\nimport { catchError, finalize, map } from 'rxjs/operators';\n\nimport { ApiRequest } from '../request-manager-state-service/models/api-request.model';\nimport { PathQueryService, HeadersService } from '../utils';\nimport { requestStreaming } from './rxjs-operators/request-streaming';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class RequestSignalsService {\n\n  private http = inject(HttpClient);\n  private pathQueryService = inject(PathQueryService);\n  private headersService = inject(HeadersService);\n\n  isPending = signal(false);\n  progress = signal(0);\n\n  isIdle = computed(() => !this.isPending());\n\n  getRecordRequest<T>(options: ApiRequest): Observable<T> {\n    const urlPath = this.buildUrlPath(options);\n    const headers = this.buildCombinedHeaders(options);\n\n    this.isPending.set(true);\n\n    return (options.stream)\n      ? this.http.get<any>(urlPath, headers).pipe(\n          requestStreaming(),\n          this.handleFinalize()\n        )\n      : this.http.get<T>(urlPath, headers).pipe(\n          this.request(options),\n          this.handleFinalize()\n        );\n  }\n\n  createRecordRequest<T>(options: ApiRequest, data: any): Observable<T> {\n    const urlPath = this.buildUrlPath(options);\n    const headers = this.buildCombinedHeaders(options);\n\n    this.isPending.set(true);\n\n    return (options.stream)\n      ? this.http.post<any>(urlPath, data, headers).pipe(\n          requestStreaming(),\n          this.handleFinalize()\n        )\n      : this.http.post<T>(urlPath, data, headers).pipe(\n          this.request(options),\n          this.handleFinalize()\n        );\n  }\n\n  updateRecordRequest<T>(options: ApiRequest, data: any): Observable<T> {\n    const urlPath = this.buildUrlPath(options);\n    const headers = this.buildHeaders(options);\n\n    this.isPending.set(true);\n\n    return this.http.put<any>(urlPath, data, headers).pipe(\n      this.request(options),\n      this.handleFinalize()\n    );\n  }\n\n  deleteRecordRequest<T>(options: ApiRequest): Observable<T> {\n    const urlPath = this.buildUrlPath(options);\n    const headers = this.buildHeaders(options);\n\n    this.isPending.set(true);\n\n    return this.http.delete<any>(urlPath, headers).pipe(\n      this.request(options),\n      this.handleFinalize()\n    );\n  }\n\n  private buildUrlPath(options: ApiRequest): string {\n    return this.pathQueryService.buildAPIPath(options.server, options.path);\n  }\n\n  private buildHeaders(options: ApiRequest): any {\n    return this.headersService.generateHeaders(options.headers);\n  }\n\n  private buildCombinedHeaders(options: ApiRequest): any {\n    const headers = this.headersService.generateHeaders(options.headers);\n    return this.combineHeaders(headers, options.stream || false);\n  }\n\n  private request<T>(options: ApiRequest): (source: Observable<any>) => Observable<T> {\n    return (source$: Observable<any>): Observable<T> => {\n      return source$.pipe(\n        map(data => {\n          if (options?.adapter) {\n            return Array.isArray(data)\n              ? data.map((item: any) => options.adapter(item))\n              : options.adapter(data);\n          }\n          return data;\n        })\n      );\n    };\n  }\n\n  downloadFileRequest(options: ApiRequest): Observable<any> {\n    this.isPending.set(true);\n\n    const urlPath = this.buildUrlPath(options);\n\n    return this.http.get(urlPath, { responseType: 'blob', observe: 'events', reportProgress: true })\n      .pipe(\n        map((event: HttpEvent<any>) => {\n          this.isPending.set(true);\n\n          if (event instanceof HttpHeaderResponse) {\n            if (event.status !== 200) {\n              this.isPending.set(false);\n              throw new Error('Download failed');\n            }\n          }\n\n          switch (event.type) {\n            case HttpEventType.DownloadProgress:\n              const status = (event.total) ? Math.round(event.loaded / (event.total || 1) * 100) : 100;\n              this.progress.set(status);\n              return status;\n\n            case HttpEventType.Response:\n              try {\n                const fileNamePath = (options?.saveAs) ? options.saveAs : (options.path) ? options.path[options.path.length - 1] : [];\n                const header_content = event.headers.get('Content-Disposition') || '';\n                const file = (header_content) ? header_content.split('=')[1].substring(0, header_content.split('=')[1].length) : '';\n\n                const fileName = (fileNamePath !== '') ? fileNamePath : file;\n\n                if (fileName === '') {\n                  this.isPending.set(false);\n                  throw new Error('Save File: (file name and extension) not found in Headers or Path');\n                }\n\n                this.downloadFile(fileName, event.body);\n                this.isPending.set(false);\n\n                return 100;\n\n              } catch (error) {\n                throw new Error('Download failed');\n              }\n\n            default:\n              this.isPending.set(false);\n              return 0;\n          }\n        }),\n        catchError(err => {\n          return throwError(() => err);\n        })\n      );\n  }\n\n  private handleFinalize(): (source: Observable<any>) => Observable<any> {\n    return finalize(() => this.isPending.set(false));\n  }\n\n  private downloadFile(file: string, fileData: any) {\n    const navigatorAny = window.navigator as any;\n    const extension = file.split('.')[1]?.toLowerCase();\n    const newBlob = new Blob([fileData], { type: this.createFileType(extension) });\n\n    if (navigatorAny.msSaveOrOpenBlob) {\n      navigatorAny.msSaveOrOpenBlob(newBlob, file);\n    } else {\n      const link = document.createElement('a');\n      const url = window.URL.createObjectURL(newBlob);\n      link.href = url;\n      link.download = file;\n      link.click();\n      window.URL.revokeObjectURL(url);\n    }\n  }\n\n  private createFileType(ext: string): string {\n    let fileType = \"\";\n\n    if (ext === 'pdf' || ext === 'csv') fileType = `application/${ext}`;\n    else if (ext === 'jpeg' || ext === 'jpg' || ext === 'png') fileType = `image/${ext}`;\n    else if (ext === 'txt') fileType = 'text/plain';\n    else if (ext === 'ppt' || ext === 'pot' || ext === 'pps' || ext === 'ppa') fileType = 'application/vnd.ms-powerpoint';\n    else if (ext === 'pptx') fileType = 'application/vnd.openxmlformats-officedocument.presentationml.presentation';\n    else if (ext === 'doc' || ext === 'dot') fileType = 'application/msword';\n    else if (ext === 'docx') fileType = 'application/vnd.openxmlformats-officedocument.wordprocessingml.document';\n    else if (ext === 'xls' || ext === 'xlt' || ext === 'xla') fileType = 'application/vnd.ms-excel';\n    else if (ext === 'xlsx') fileType = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';\n\n    return fileType;\n  }\n\n  private combineHeaders(headers: any, isStreaming: boolean) {\n    return (isStreaming)\n      ? {\n          ...headers,\n          observe: 'events',\n          responseType: 'text',\n          reportProgress: true,\n          Accept: 'text/event-stream'\n        }\n      : headers;\n  }\n}\n"]}