ngx-techlify-core 15.0.2 → 16.0.1

package/esm2022/lib/core/dataManager.service.mjs

@@ -0,0 +1,120 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./http.service";
+/**
+ * Service that provides a wrapper for retrieving data from the server
+ * @deprecated use HttpService Instead
+ * @author Joshua Kissoon
+ * @since 20170709
+ */
+export class DataManager {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * Callback wrapper for the HTTP GET Call
+     *
+     * @param urlq The query part of the URL to be sent to the server
+     *
+     * @author Joshua Kissoon
+     * @since 20160826
+     * @updated 20170711 to add parameters
+     */
+    GET(urlq, params = {}) {
+        return this.http
+            .get(urlq, { params: params })
+            .toPromise();
+    }
+    /**
+     * Callback wrapper for the HTTP POST Call
+     *
+     * @param urlq The query part of the URL to be sent to the server
+     * @param object The object containing the POST data to be sent
+     *
+     * @author Joshua Kissoon
+     * @since 20160826
+     */
+    POST(urlq, object) {
+        if (null == object) {
+            object = { "blank": "blank" };
+        }
+        return this.http
+            .post(urlq, object)
+            .toPromise();
+    }
+    /**
+     * Callback wrapper for the HTTP POST Call
+     *
+     * @param urlq The query part of the URL to be sent to the server
+     * @param object The object containing the POST data to be sent
+     *
+     * @author Joshua Kissoon
+     * @since 20160826
+     */
+    POSTRAW(urlq, object) {
+        if (null == object) {
+            object = { "blank": "blank" };
+        }
+        return this.http
+            .skipHeader()
+            .post(urlq, object)
+            .toPromise();
+    }
+    /**
+     * Callback wrapper for the HTTP PUT Call
+     *
+     * @param urlq The query part of the URL to be sent to the server
+     * @param object The object containing the PUT data to be sent
+     *
+     * @author Joshua Kissoon
+     * @since 20160826
+     */
+    PUT(urlq, object) {
+        if (null == object) {
+            object = { "blank": "blank" };
+        }
+        return this.http
+            .put(urlq, object)
+            .toPromise();
+    }
+    /**
+     * Callback wrapper for the HTTP PATCH Call
+     *
+     * @param urlq The query part of the URL to be sent to the server
+     * @param object The object containing the PUT data to be sent
+     *
+     * @author Joshua Kissoon
+     * @since 20161107
+     */
+    PATCH(urlq, object) {
+        if (null == object) {
+            object = { "blank": "blank" };
+        }
+        return this.http
+            .patch(urlq, object)
+            .toPromise();
+    }
+    /**
+     * Callback wrapper for the HTTP DELETE Call
+     *
+     * @param urlq The query part of the URL to be sent to the server
+     *
+     * @author Joshua Kissoon
+     * @since 20160826
+     */
+    DELETE(urlq) {
+        return this.http
+            .delete(urlq)
+            .toPromise();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DataManager, deps: [{ token: i1.HttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DataManager, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DataManager, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/error-handler.interceptor.mjs

@@ -0,0 +1,50 @@
+import { Injectable } from '@angular/core';
+import { throwError } from 'rxjs';
+import { catchError } from 'rxjs/operators';
+import { Logger } from './logger.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./config.service";
+import * as i2 from "./error-handler.service";
+const log = new Logger('ErrorHandlerInterceptor');
+/**
+ * Adds a default error handler to all requests.
+ */
+export class ErrorHandlerInterceptor {
+    configService;
+    errorHandler;
+    constructor(configService, errorHandler) {
+        this.configService = configService;
+        this.errorHandler = errorHandler;
+    }
+    intercept(request, next) {
+        return next.handle(request).pipe(catchError(error => this.handleError(error)));
+    }
+    // Customize the default error handler here if needed
+    handleError(error) {
+        let errorMessage = '';
+        if (error.error instanceof ErrorEvent) {
+            // client-side error
+            errorMessage = `Client Error: ${this.configService?.getProjectKey()}: ${error.error.message}`;
+        }
+        else {
+            // server-side error
+            errorMessage = `Server Error: ${this.configService?.getProjectKey()}`;
+            try {
+                this.errorHandler.handleError(error, 'Unexpected Server Error, try later or contact service team');
+            }
+            catch (e) {
+                console.log("Unable to handle server error", e);
+            }
+        }
+        return throwError(error);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ErrorHandlerInterceptor, deps: [{ token: i1.ConfigService }, { token: i2.ErrorHandlerService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ErrorHandlerInterceptor, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ErrorHandlerInterceptor, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ConfigService }, { type: i2.ErrorHandlerService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/error-handler.service.mjs

@@ -0,0 +1,57 @@
+import { Injectable } from "@angular/core";
+import * as i0 from "@angular/core";
+import * as i1 from "./alert.service";
+import * as i2 from "./techlify-config.model";
+/**
+ * Service used to handle errors from the request
+ *
+ * @author Joshua Kissoon
+ * @since 20171202
+ */
+export class ErrorHandlerService {
+    alerter;
+    config;
+    constructor(alerter, config) {
+        this.alerter = alerter;
+        this.config = config;
+    }
+    handleError(errorResponse, msg = '') {
+        // 1 - Create empty array to store errors
+        const errors = [];
+        // 2 - check if the error object is present in the response
+        if (errorResponse?.error) {
+            // 3 - Check for Laravel form validation error messages object
+            if (errorResponse?.error?.errors) {
+                // 4 - For each error property (which is a form field)
+                for (const property in errorResponse.error.errors) {
+                    if (errorResponse.error.errors?.hasOwnProperty(property)) {
+                        // 5 - Extract it's array of errors
+                        const propertyErrors = errorResponse?.error?.errors[property];
+                        // 6 - Push all errors in the array to the errors array
+                        propertyErrors.forEach(error => errors.push(error));
+                    }
+                }
+            }
+            if (errors.length === 0) {
+                // 7 - Push the main error message to the array of errors if there is no validation error
+                errors.push(errorResponse.error.message ? errorResponse.error.message : errorResponse.error?.error);
+            }
+        }
+        var errMessage = errors.length ? errors[0] : msg;
+        this.alerter.addAlert("Error: " + errMessage, "warning");
+        if (errorResponse.status == 403 && this.config.isLogoutWhileApiGetsFailed) {
+            sessionStorage.clear();
+            localStorage.clear();
+            location.reload();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ErrorHandlerService, deps: [{ token: i1.AlertService }, { token: i2.TechlifyConfig }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ErrorHandlerService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ErrorHandlerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.AlertService }, { type: i2.TechlifyConfig }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/filter.service.mjs

@@ -0,0 +1,39 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+export class FilterService {
+    router;
+    filters;
+    constructor(router) {
+        this.router = router;
+    }
+    applyFilterToRoute(url, filter) {
+        this.router.navigate([filter], {
+            relativeTo: url,
+            replaceUrl: true
+        });
+    }
+    getFiltersFromRoute(url, filterFormGroup) {
+        url.params.subscribe(params => {
+            for (var filter in params) {
+                if (params[filter]) {
+                    for (let [key, value] of Object.entries(filterFormGroup)) {
+                        if (key === filter) {
+                            filterFormGroup[key] = params[filter];
+                        }
+                    }
+                }
+            }
+        });
+        return filterFormGroup;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FilterService, deps: [{ token: i1.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FilterService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FilterService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Router }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/lib/core/form-validator.service.mjs

@@ -12,13 +12,13 @@ export class FormValidatorService {
         const error = Object.keys(formGroup.get(field).errors);
         return (error.length > 0) ? (errorMessages[errorField || field][error[0]] ? errorMessages[errorField || field][error[0]] : '') : '';
     }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FormValidatorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FormValidatorService, providedIn: 'root' });
 }
-FormValidatorService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: FormValidatorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-FormValidatorService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: FormValidatorService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: FormValidatorService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FormValidatorService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
                 }]
         }], ctorParameters: function () { return []; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/lib/core/header.interceptor.mjs

@@ -12,13 +12,13 @@ export class HeaderInterceptor {
         });
         return next.handle(request);
     }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HeaderInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HeaderInterceptor, providedIn: 'root' });
 }
-HeaderInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: HeaderInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-HeaderInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: HeaderInterceptor, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: HeaderInterceptor, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HeaderInterceptor, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGVhZGVyLmludGVyY2VwdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LXRlY2hsaWZ5LWNvcmUvc3JjL2xpYi9jb3JlL2hlYWRlci5pbnRlcmNlcHRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUszQzs7R0FFRztBQUlILE1BQU0sT0FBTyxpQkFBaUI7SUFFNUIsU0FBUyxDQUFDLE9BQXlCLEVBQUUsSUFBaUI7UUFDcEQsT0FBTyxHQUFHLE9BQU8sQ0FBQyxLQUFLLENBQUM7WUFDdEIsVUFBVSxFQUFFO2dCQUNWLGNBQWMsRUFBRSxPQUFPLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxjQUFjLENBQUMsSUFBSSxrQkFBa0I7YUFDMUU7U0FDRixDQUFDLENBQUM7UUFDSCxPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDOUIsQ0FBQzs7K0dBVFUsaUJBQWlCO21IQUFqQixpQkFBaUIsY0FGaEIsTUFBTTs0RkFFUCxpQkFBaUI7a0JBSDdCLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgSHR0cEV2ZW50LCBIdHRwSW50ZXJjZXB0b3IsIEh0dHBIYW5kbGVyLCBIdHRwUmVxdWVzdCB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbi9odHRwJztcbmltcG9ydCB7IE9ic2VydmFibGUgfSBmcm9tICdyeGpzJztcblxuXG4vKipcbiAqIFByZWZpeGVzIGFsbCByZXF1ZXN0cyBub3Qgc3RhcnRpbmcgd2l0aCBgaHR0cFtzXWAgd2l0aCBgZW52aXJvbm1lbnQuc2VydmVyVXJsYC5cbiAqL1xuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCdcbn0pXG5leHBvcnQgY2xhc3MgSGVhZGVySW50ZXJjZXB0b3IgaW1wbGVtZW50cyBIdHRwSW50ZXJjZXB0b3Ige1xuXG4gIGludGVyY2VwdChyZXF1ZXN0OiBIdHRwUmVxdWVzdDxhbnk+LCBuZXh0OiBIdHRwSGFuZGxlcik6IE9ic2VydmFibGU8SHR0cEV2ZW50PGFueT4+IHtcbiAgICByZXF1ZXN0ID0gcmVxdWVzdC5jbG9uZSh7XG4gICAgICBzZXRIZWFkZXJzOiB7XG4gICAgICAgICdDb250ZW50LVR5cGUnOiByZXF1ZXN0LmhlYWRlcnMuZ2V0KCdDb250ZW50LVR5cGUnKSB8fCAnYXBwbGljYXRpb24vanNvbicsXG4gICAgICB9XG4gICAgfSk7XG4gICAgcmV0dXJuIG5leHQuaGFuZGxlKHJlcXVlc3QpO1xuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGVhZGVyLmludGVyY2VwdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LXRlY2hsaWZ5LWNvcmUvc3JjL2xpYi9jb3JlL2hlYWRlci5pbnRlcmNlcHRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUszQzs7R0FFRztBQUlILE1BQU0sT0FBTyxpQkFBaUI7SUFFNUIsU0FBUyxDQUFDLE9BQXlCLEVBQUUsSUFBaUI7UUFDcEQsT0FBTyxHQUFHLE9BQU8sQ0FBQyxLQUFLLENBQUM7WUFDdEIsVUFBVSxFQUFFO2dCQUNWLGNBQWMsRUFBRSxPQUFPLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxjQUFjLENBQUMsSUFBSSxrQkFBa0I7YUFDMUU7U0FDRixDQUFDLENBQUM7UUFDSCxPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDOUIsQ0FBQzt3R0FUVSxpQkFBaUI7NEdBQWpCLGlCQUFpQixjQUZoQixNQUFNOzs0RkFFUCxpQkFBaUI7a0JBSDdCLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgSHR0cEV2ZW50LCBIdHRwSW50ZXJjZXB0b3IsIEh0dHBIYW5kbGVyLCBIdHRwUmVxdWVzdCB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbi9odHRwJztcbmltcG9ydCB7IE9ic2VydmFibGUgfSBmcm9tICdyeGpzJztcblxuXG4vKipcbiAqIFByZWZpeGVzIGFsbCByZXF1ZXN0cyBub3Qgc3RhcnRpbmcgd2l0aCBgaHR0cFtzXWAgd2l0aCBgZW52aXJvbm1lbnQuc2VydmVyVXJsYC5cbiAqL1xuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCdcbn0pXG5leHBvcnQgY2xhc3MgSGVhZGVySW50ZXJjZXB0b3IgaW1wbGVtZW50cyBIdHRwSW50ZXJjZXB0b3Ige1xuXG4gIGludGVyY2VwdChyZXF1ZXN0OiBIdHRwUmVxdWVzdDxhbnk+LCBuZXh0OiBIdHRwSGFuZGxlcik6IE9ic2VydmFibGU8SHR0cEV2ZW50PGFueT4+IHtcbiAgICByZXF1ZXN0ID0gcmVxdWVzdC5jbG9uZSh7XG4gICAgICBzZXRIZWFkZXJzOiB7XG4gICAgICAgICdDb250ZW50LVR5cGUnOiByZXF1ZXN0LmhlYWRlcnMuZ2V0KCdDb250ZW50LVR5cGUnKSB8fCAnYXBwbGljYXRpb24vanNvbicsXG4gICAgICB9XG4gICAgfSk7XG4gICAgcmV0dXJuIG5leHQuaGFuZGxlKHJlcXVlc3QpO1xuICB9XG59XG4iXX0=

package/esm2022/lib/core/http-cache.service.mjs

@@ -0,0 +1,110 @@
+import { Injectable } from '@angular/core';
+import { Logger } from './logger.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./config.service";
+const log = new Logger('HttpCacheService');
+/**
+ * Provides a cache facility for HTTP requests with configurable persistence policy.
+ */
+export class HttpCacheService {
+    configService;
+    cachedData = {};
+    storage;
+    cachePersistenceKey;
+    constructor(configService) {
+        this.configService = configService;
+        this.storage = this.configService.getStorage();
+        this.cachePersistenceKey = this.configService.getProjectKey() + '_HTTP_CACHE';
+        this.loadCacheData();
+    }
+    /**
+     * Sets the cache data for the specified request.
+     * @param {!string} url The request URL.
+     * @param {ResponseOptions} data The received data.
+     * @param {Date=} lastUpdated The cache last update, current date is used if not specified.
+     */
+    setCacheData(url, data, lastUpdated) {
+        this.cachedData[url] = {
+            lastUpdated: lastUpdated || new Date(),
+            data: data
+        };
+        log.debug(`Cache set for key: "${url}"`);
+        this.saveCacheData();
+    }
+    /**
+     * Gets the cached data for the specified request.
+     * @param {!string} url The request URL.
+     * @return {?ResponseOptions} The cached data or null if no cached data exists for this request.
+     */
+    getCacheData(url) {
+        const cacheEntry = this.cachedData[url];
+        if (cacheEntry) {
+            log.debug(`Cache hit for key: "${url}"`);
+            return cacheEntry.data;
+        }
+        return null;
+    }
+    /**
+     * Gets the cached entry for the specified request.
+     * @param {!string} url The request URL.
+     * @return {?HttpCacheEntry} The cache entry or null if no cache entry exists for this request.
+     */
+    getHttpCacheEntry(url) {
+        return this.cachedData[url] || null;
+    }
+    /**
+     * Clears the cached entry (if exists) for the specified request.
+     * @param {!string} url The request URL.
+     */
+    clearCache(url) {
+        delete this.cachedData[url];
+        log.debug(`Cache cleared for key: "${url}"`);
+        this.saveCacheData();
+    }
+    /**
+     * Cleans cache entries older than the specified date.
+     * @param {date=} expirationDate The cache expiration date. If no date is specified, all cache is cleared.
+     */
+    cleanCache(expirationDate) {
+        if (expirationDate) {
+            Object(this.cachedData).keys.forEach((key) => {
+                if (expirationDate >= this.cachedData[key]?.lastUpdated) {
+                    delete this.cachedData[key];
+                }
+            });
+        }
+        else {
+            this.cachedData = {};
+        }
+        this.saveCacheData();
+    }
+    /**
+     * Sets the cache persistence policy.
+     * Note that changing the cache persistence will also clear the cache from its previous storage.
+     * @param {'local'|'session'=} persistence How the cache should be persisted, it can be either local or session
+     *   storage, or if no value is provided it will be only in-memory (default).
+     */
+    setPersistence(persistence) {
+        this.cleanCache();
+        this.storage = persistence === 'local' ? localStorage : persistence === 'session' ? sessionStorage : null;
+        this.loadCacheData();
+    }
+    saveCacheData() {
+        if (this.storage) {
+            this.storage[this.cachePersistenceKey] = JSON.stringify(this.cachedData);
+        }
+    }
+    loadCacheData() {
+        const data = this.storage ? this.storage[this.cachePersistenceKey] : null;
+        this.cachedData = data ? JSON.parse(data) : {};
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HttpCacheService, deps: [{ token: i1.ConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HttpCacheService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HttpCacheService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ConfigService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http-cache.service.js","sourceRoot":"","sources":["../../../../../projects/ngx-techlify-core/src/lib/core/http-cache.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { HttpResponse } from '@angular/common/http';\nimport { ConfigService } from './config.service';\nimport { Logger } from './logger.service';\n\nconst log = new Logger('HttpCacheService');\n\n\nexport interface HttpCacheEntry {\n  lastUpdated: Date;\n  data: HttpResponse<any>;\n}\n\n/**\n * Provides a cache facility for HTTP requests with configurable persistence policy.\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class HttpCacheService {\n\n  private cachedData: { [key: string]: HttpCacheEntry; } = {};\n  private storage: Storage | any | null;\n  private cachePersistenceKey: String | any;\n\n  constructor(private configService: ConfigService) {\n    this.storage = this.configService.getStorage();\n    this.cachePersistenceKey = this.configService.getProjectKey() + '_HTTP_CACHE';\n    this.loadCacheData();\n  }\n\n  /**\n   * Sets the cache data for the specified request.\n   * @param {!string} url The request URL.\n   * @param {ResponseOptions} data The received data.\n   * @param {Date=} lastUpdated The cache last update, current date is used if not specified.\n   */\n  setCacheData(url: string, data: HttpResponse<any>, lastUpdated?: Date) {\n    this.cachedData[url] = {\n      lastUpdated: lastUpdated || new Date(),\n      data: data\n    };\n    log.debug(`Cache set for key: \"${url}\"`);\n    this.saveCacheData();\n  }\n\n  /**\n   * Gets the cached data for the specified request.\n   * @param {!string} url The request URL.\n   * @return {?ResponseOptions} The cached data or null if no cached data exists for this request.\n   */\n  getCacheData(url: string): HttpResponse<any> | null {\n    const cacheEntry = this.cachedData[url];\n\n    if (cacheEntry) {\n      log.debug(`Cache hit for key: \"${url}\"`);\n      return cacheEntry.data;\n    }\n\n    return null;\n  }\n\n  /**\n   * Gets the cached entry for the specified request.\n   * @param {!string} url The request URL.\n   * @return {?HttpCacheEntry} The cache entry or null if no cache entry exists for this request.\n   */\n  getHttpCacheEntry(url: string): HttpCacheEntry | null {\n    return this.cachedData[url] || null;\n  }\n\n  /**\n   * Clears the cached entry (if exists) for the specified request.\n   * @param {!string} url The request URL.\n   */\n  clearCache(url: string): void {\n    delete this.cachedData[url];\n    log.debug(`Cache cleared for key: \"${url}\"`);\n    this.saveCacheData();\n  }\n\n  /**\n   * Cleans cache entries older than the specified date.\n   * @param {date=} expirationDate The cache expiration date. If no date is specified, all cache is cleared.\n   */\n  cleanCache(expirationDate?: Date) {\n    if (expirationDate) {\n      Object(this.cachedData).keys.forEach((key: string) => {\n        if (expirationDate >= this.cachedData[key]?.lastUpdated) {\n          delete this.cachedData[key];\n        }\n      });\n    } else {\n      this.cachedData = {};\n    }\n    this.saveCacheData();\n  }\n\n  /**\n   * Sets the cache persistence policy.\n   * Note that changing the cache persistence will also clear the cache from its previous storage.\n   * @param {'local'|'session'=} persistence How the cache should be persisted, it can be either local or session\n   *   storage, or if no value is provided it will be only in-memory (default).\n   */\n  setPersistence(persistence?: 'local' | 'session') {\n    this.cleanCache();\n    this.storage = persistence === 'local' ? localStorage : persistence === 'session' ? sessionStorage : null;\n    this.loadCacheData();\n  }\n\n  private saveCacheData() {\n    if (this.storage) {\n      this.storage[this.cachePersistenceKey] = JSON.stringify(this.cachedData);\n    }\n  }\n\n  private loadCacheData() {\n    const data = this.storage ? this.storage[this.cachePersistenceKey] : null;\n    this.cachedData = data ? JSON.parse(data) : {};\n  }\n\n}\n"]}

package/esm2022/lib/core/http.service.mjs

@@ -0,0 +1,89 @@
+import { Inject, Injectable, InjectionToken, Optional } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { ErrorHandlerInterceptor } from './error-handler.interceptor';
+import { CacheInterceptor } from './cache.interceptor';
+import { ApiPrefixInterceptor } from './api-prefix.interceptor';
+import { TokenInterceptor } from './token.interceptor';
+import { HeaderInterceptor } from './header.interceptor';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+// From @angular/common/http/src/interceptor: allows to chain interceptors
+class HttpInterceptorHandler {
+    next;
+    interceptor;
+    constructor(next, interceptor) {
+        this.next = next;
+        this.interceptor = interceptor;
+    }
+    handle(request) {
+        return this.interceptor.intercept(request, this.next);
+    }
+}
+/**
+ * Allows to override default dynamic interceptors that can be disabled with the HttpService extension.
+ * Except for very specific needs, you should better configure these interceptors directly in the constructor below
+ * for better readability.
+ *
+ * For static interceptors that should always be enabled (like ApiPrefixInterceptor), use the standard
+ * HTTP_INTERCEPTORS token.
+ */
+export const HTTP_DYNAMIC_INTERCEPTORS = new InjectionToken('HTTP_DYNAMIC_INTERCEPTORS');
+/**
+ * Extends HttpClient with per request configuration using dynamic interceptors.
+ */
+export class HttpService extends HttpClient {
+    httpHandler;
+    injector;
+    interceptors;
+    constructor(httpHandler, injector, interceptors = []) {
+        super(httpHandler);
+        this.httpHandler = httpHandler;
+        this.injector = injector;
+        this.interceptors = interceptors;
+        if (!this.interceptors) {
+            // Configure default interceptors that can be disabled here
+            this.interceptors = [this.injector.get(ApiPrefixInterceptor), this.injector.get(HeaderInterceptor), this.injector.get(TokenInterceptor), this.injector.get(ErrorHandlerInterceptor)];
+        }
+    }
+    cache(forceUpdate) {
+        const cacheInterceptor = this.injector.get(CacheInterceptor).configure({ update: forceUpdate });
+        return this.addInterceptor(cacheInterceptor);
+    }
+    skipErrorHandler() {
+        return this.removeInterceptor(ErrorHandlerInterceptor);
+    }
+    skipApiPrefix() {
+        return this.removeInterceptor(ApiPrefixInterceptor);
+    }
+    skipToken() {
+        return this.removeInterceptor(TokenInterceptor);
+    }
+    skipHeader() {
+        return this.removeInterceptor(HeaderInterceptor);
+    }
+    // Override the original method to wire interceptors when triggering the request.
+    request(method, url, options) {
+        const handler = this.interceptors.reduceRight((next, interceptor) => new HttpInterceptorHandler(next, interceptor), this.httpHandler);
+        return new HttpClient(handler).request(method, url, options);
+    }
+    removeInterceptor(interceptorType) {
+        return new HttpService(this.httpHandler, this.injector, this.interceptors.filter(i => !(i instanceof interceptorType)));
+    }
+    addInterceptor(interceptor) {
+        return new HttpService(this.httpHandler, this.injector, this.interceptors.concat([interceptor]));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HttpService, deps: [{ token: i1.HttpHandler }, { token: i0.Injector }, { token: HTTP_DYNAMIC_INTERCEPTORS, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HttpService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HttpService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpHandler }, { type: i0.Injector }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [HTTP_DYNAMIC_INTERCEPTORS]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http.service.js","sourceRoot":"","sources":["../../../../../projects/ngx-techlify-core/src/lib/core/http.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, InjectionToken, Injector, Optional } from '@angular/core';\nimport { HttpClient, HttpEvent, HttpInterceptor, HttpHandler, HttpRequest } from '@angular/common/http';\n\nimport { Observable } from 'rxjs';\nimport { ErrorHandlerInterceptor } from './error-handler.interceptor';\nimport { CacheInterceptor } from './cache.interceptor';\nimport { ApiPrefixInterceptor } from './api-prefix.interceptor';\nimport { TokenInterceptor } from './token.interceptor';\nimport { HeaderInterceptor } from './header.interceptor';\n\n\n// Augment HttpClient with the added configuration methods from HttpService, to allow in-place replacement of\n// HttpClient with HttpService using dependency injection\nexport interface HttpCustomClient {\n\n  /**\n   * Enables caching for this request.\n   * @param {boolean} forceUpdate Forces request to be made and updates cache entry.\n   * @return {HttpCustomClient} The new instance.\n   */\n  cache(forceUpdate?: boolean): HttpCustomClient;\n\n  /**\n   * Skips default error handler for this request.\n   * @return {HttpCustomClient} The new instance.\n   */\n  skipErrorHandler(): HttpCustomClient;\n\n  /**\n  * Skips default API Prefix for this request.\n  * @return {HttpCustomClient} The new instance.\n  */\n  skipApiPrefix(): HttpCustomClient;\n\n\n  /**\n * Skips default Token Interceptor for this request.\n * @return {HttpCustomClient} The new instance.\n */\n  skipToken(): HttpCustomClient;\n\n  /**\n* Skips default Header Interceptor for this request.\n* @return {HttpCustomClient} The new instance.\n*/\n  skipHeader(): HttpCustomClient;\n\n}\n\n\n// From @angular/common/http/src/interceptor: allows to chain interceptors\nclass HttpInterceptorHandler implements HttpHandler {\n\n  constructor(private next: HttpHandler, private interceptor: HttpInterceptor) { }\n\n  handle(request: HttpRequest<any>): Observable<HttpEvent<any>> {\n    return this.interceptor.intercept(request, this.next);\n  }\n\n}\n\n/**\n * Allows to override default dynamic interceptors that can be disabled with the HttpService extension.\n * Except for very specific needs, you should better configure these interceptors directly in the constructor below\n * for better readability.\n *\n * For static interceptors that should always be enabled (like ApiPrefixInterceptor), use the standard\n * HTTP_INTERCEPTORS token.\n */\nexport const HTTP_DYNAMIC_INTERCEPTORS = new InjectionToken<HttpInterceptor>('HTTP_DYNAMIC_INTERCEPTORS');\n\n/**\n * Extends HttpClient with per request configuration using dynamic interceptors.\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class HttpService extends HttpClient implements HttpCustomClient {\n\n  constructor(private httpHandler: HttpHandler,\n    private injector: Injector,\n    @Optional() @Inject(HTTP_DYNAMIC_INTERCEPTORS) private interceptors: HttpInterceptor[] = []) {\n    super(httpHandler);\n\n    if (!this.interceptors) {\n      // Configure default interceptors that can be disabled here\n      this.interceptors = [this.injector.get(ApiPrefixInterceptor), this.injector.get(HeaderInterceptor), this.injector.get(TokenInterceptor), this.injector.get(ErrorHandlerInterceptor)];\n    }\n  }\n\n  cache(forceUpdate?: boolean): HttpService {\n    const cacheInterceptor = this.injector.get(CacheInterceptor).configure({ update: forceUpdate });\n    return this.addInterceptor(cacheInterceptor);\n  }\n\n  skipErrorHandler(): HttpService {\n    return this.removeInterceptor(ErrorHandlerInterceptor);\n  }\n\n  skipApiPrefix(): HttpService {\n    return this.removeInterceptor(ApiPrefixInterceptor);\n  }\n\n  skipToken(): HttpService {\n    return this.removeInterceptor(TokenInterceptor);\n  }\n\n  skipHeader(): HttpService {\n    return this.removeInterceptor(HeaderInterceptor);\n  }\n\n  // Override the original method to wire interceptors when triggering the request.\n  request(method?: any, url?: any, options?: any): any {\n    const handler = this.interceptors.reduceRight(\n      (next, interceptor) => new HttpInterceptorHandler(next, interceptor),\n      this.httpHandler\n    );\n    return new HttpClient(handler).request(method, url, options);\n  }\n\n  private removeInterceptor(interceptorType: Function): HttpService {\n    return new HttpService(\n      this.httpHandler,\n      this.injector,\n      this.interceptors.filter(i => !(i instanceof interceptorType))\n    );\n  }\n\n  private addInterceptor(interceptor: HttpInterceptor): HttpService {\n    return new HttpService(\n      this.httpHandler,\n      this.injector,\n      this.interceptors.concat([interceptor])\n    );\n  }\n\n}\n"]}