ngx-techlify-core 11.5.2 → 14.2.1

package/esm2020/lib/core/credentials.service.mjs

@@ -0,0 +1,79 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./config.service";
+/**
+ * Provides storage for authentication credentials.
+ * The Credentials interface should be replaced with proper implementation.
+ */
+export class CredentialsService {
+    constructor(configService) {
+        this.configService = configService;
+        this._credentials = null;
+    }
+    /**
+     * Checks is the user is authenticated.
+     * @return True if the user is authenticated.
+     */
+    get isAuthenticated() {
+        return !!this.credentials;
+    }
+    /**
+     * Gets the user credentials.
+     * @return The user credentials or null if the user is not authenticated.
+     */
+    get credentials() {
+        if (!this._credentials) {
+            this._credentials = JSON.parse(sessionStorage.getItem(this.configService.getCredentialsKey()) || localStorage.getItem(this.configService.getCredentialsKey()));
+        }
+        return this._credentials;
+    }
+    /**
+     * Sets the user credentials.
+     * The credentials may be persisted across sessions by setting the `remember` parameter to true.
+     * Otherwise, the credentials are only persisted for the current session.
+     * @param credentials The user credentials.
+     * @param remember True to remember credentials across sessions.
+     */
+    setCredentials(credentials, remember) {
+        this._credentials = credentials || null;
+        if (credentials) {
+            (remember ? localStorage : sessionStorage).setItem(this.configService.getCredentialsKey(), JSON.stringify(credentials));
+        }
+        else {
+            sessionStorage.clear();
+            localStorage.clear();
+            this._credentials = null;
+        }
+    }
+    getAccessToken() {
+        const expiration = this.credentials?.token?.expires_in || '';
+        const token = this.credentials?.token?.access_token || '';
+        if (!token || !expiration) {
+            return null;
+        }
+        if (Date.now() > parseInt(expiration)) {
+            this.setCredentials();
+            return null;
+        }
+        return token;
+    }
+    getExpiration() {
+        return this.credentials?.token?.expires_in || '';
+    }
+    getRefreshToken() {
+        return this.credentials?.token?.refresh_token || '';
+    }
+    refresh() {
+        this._credentials = null;
+        return this;
+    }
+}
+CredentialsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: CredentialsService, deps: [{ token: i1.ConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
+CredentialsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: CredentialsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: CredentialsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ConfigService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,119 @@
+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 {
+    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();
+    }
+}
+DataManager.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: DataManager, deps: [{ token: i1.HttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+DataManager.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: DataManager, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", 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/esm2020/lib/core/error-handler.interceptor.mjs

@@ -0,0 +1,48 @@
+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 {
+    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);
+    }
+}
+ErrorHandlerInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ErrorHandlerInterceptor, deps: [{ token: i1.ConfigService }, { token: i2.ErrorHandlerService }], target: i0.ɵɵFactoryTarget.Injectable });
+ErrorHandlerInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ErrorHandlerInterceptor, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", 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/esm2020/lib/core/error-handler.service.mjs

@@ -0,0 +1,55 @@
+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 {
+    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();
+        }
+    }
+}
+ErrorHandlerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ErrorHandlerService, deps: [{ token: i1.AlertService }, { token: i2.TechlifyConfig }], target: i0.ɵɵFactoryTarget.Injectable });
+ErrorHandlerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ErrorHandlerService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", 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/esm2020/lib/core/filter.service.mjs

@@ -0,0 +1,37 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+export class FilterService {
+    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;
+    }
+}
+FilterService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: FilterService, deps: [{ token: i1.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+FilterService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: FilterService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: FilterService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Router }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsdGVyLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtdGVjaGxpZnktY29yZS9zcmMvbGliL2NvcmUvZmlsdGVyLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7O0FBTTNDLE1BQU0sT0FBTyxhQUFhO0lBSXhCLFlBQW9CLE1BQWM7UUFBZCxXQUFNLEdBQU4sTUFBTSxDQUFRO0lBQUksQ0FBQztJQUV2QyxrQkFBa0IsQ0FBQyxHQUFHLEVBQUUsTUFBTTtRQUM1QixJQUFJLENBQUMsTUFBTSxDQUFDLFFBQVEsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxFQUMzQjtZQUNFLFVBQVUsRUFBRSxHQUFHO1lBQ2YsVUFBVSxFQUFFLElBQUk7U0FDakIsQ0FDRixDQUFBO0lBQ0gsQ0FBQztJQUVELG1CQUFtQixDQUFDLEdBQUcsRUFBRSxlQUFlO1FBQ3RDLEdBQUcsQ0FBQyxNQUFNLENBQUMsU0FBUyxDQUNsQixNQUFNLENBQUMsRUFBRTtZQUNQLEtBQUssSUFBSSxNQUFNLElBQUksTUFBTSxFQUFFO2dCQUN6QixJQUFJLE1BQU0sQ0FBQyxNQUFNLENBQUMsRUFBRTtvQkFFbEIsS0FBSyxJQUFJLENBQUMsR0FBRyxFQUFFLEtBQUssQ0FBQyxJQUFJLE1BQU0sQ0FBQyxPQUFPLENBQUMsZUFBZSxDQUFDLEVBQUU7d0JBQ3hELElBQUksR0FBRyxLQUFLLE1BQU0sRUFBRTs0QkFDbEIsZUFBZSxDQUFDLEdBQUcsQ0FBQyxHQUFHLE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQzt5QkFDdkM7cUJBQ0Y7aUJBRUY7YUFFRjtRQUNILENBQUMsQ0FDRixDQUFDO1FBQ0YsT0FBTyxlQUFlLENBQUM7SUFDekIsQ0FBQzs7MEdBakNVLGFBQWE7OEdBQWIsYUFBYSxjQUZaLE1BQU07MkZBRVAsYUFBYTtrQkFIekIsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IEFjdGl2YXRlZFJvdXRlLCBSb3V0ZXIgfSBmcm9tICdAYW5ndWxhci9yb3V0ZXInO1xyXG5cclxuQEluamVjdGFibGUoe1xyXG4gIHByb3ZpZGVkSW46ICdyb290J1xyXG59KVxyXG5leHBvcnQgY2xhc3MgRmlsdGVyU2VydmljZSB7XHJcblxyXG4gIGZpbHRlcnM6IGFueTtcclxuXHJcbiAgY29uc3RydWN0b3IocHJpdmF0ZSByb3V0ZXI6IFJvdXRlcikgeyB9XHJcblxyXG4gIGFwcGx5RmlsdGVyVG9Sb3V0ZSh1cmwsIGZpbHRlcikge1xyXG4gICAgdGhpcy5yb3V0ZXIubmF2aWdhdGUoW2ZpbHRlcl0sXHJcbiAgICAgIHtcclxuICAgICAgICByZWxhdGl2ZVRvOiB1cmwsXHJcbiAgICAgICAgcmVwbGFjZVVybDogdHJ1ZVxyXG4gICAgICB9XHJcbiAgICApXHJcbiAgfVxyXG5cclxuICBnZXRGaWx0ZXJzRnJvbVJvdXRlKHVybCwgZmlsdGVyRm9ybUdyb3VwKSB7XHJcbiAgICB1cmwucGFyYW1zLnN1YnNjcmliZShcclxuICAgICAgcGFyYW1zID0+IHtcclxuICAgICAgICBmb3IgKHZhciBmaWx0ZXIgaW4gcGFyYW1zKSB7XHJcbiAgICAgICAgICBpZiAocGFyYW1zW2ZpbHRlcl0pIHtcclxuXHJcbiAgICAgICAgICAgIGZvciAobGV0IFtrZXksIHZhbHVlXSBvZiBPYmplY3QuZW50cmllcyhmaWx0ZXJGb3JtR3JvdXApKSB7XHJcbiAgICAgICAgICAgICAgaWYgKGtleSA9PT0gZmlsdGVyKSB7XHJcbiAgICAgICAgICAgICAgICBmaWx0ZXJGb3JtR3JvdXBba2V5XSA9IHBhcmFtc1tmaWx0ZXJdO1xyXG4gICAgICAgICAgICAgIH1cclxuICAgICAgICAgICAgfVxyXG5cclxuICAgICAgICAgIH1cclxuXHJcbiAgICAgICAgfVxyXG4gICAgICB9XHJcbiAgICApO1xyXG4gICAgcmV0dXJuIGZpbHRlckZvcm1Hcm91cDtcclxuICB9XHJcblxyXG59XHJcbiJdfQ==

package/esm2020/lib/core/form-validator.service.mjs

@@ -0,0 +1,24 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class FormValidatorService {
+    constructor() { }
+    /**Method to evaluate form fields*/
+    isFieldValid(field, formGroup, firstAttempt) {
+        return (!formGroup.get(field).valid && formGroup.get(field).touched) ||
+            (!formGroup.get(field).valid && formGroup.get(field).untouched && firstAttempt);
+    }
+    /**Method to find error in form fields*/
+    getErrorMessage(field, formGroup, errorMessages, errorField) {
+        const error = Object.keys(formGroup.get(field).errors);
+        return (error.length > 0) ? (errorMessages[errorField || field][error[0]] ? errorMessages[errorField || field][error[0]] : '') : '';
+    }
+}
+FormValidatorService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: FormValidatorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+FormValidatorService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: FormValidatorService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: FormValidatorService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/core/header.interceptor.mjs

@@ -0,0 +1,24 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Prefixes all requests not starting with `http[s]` with `environment.serverUrl`.
+ */
+export class HeaderInterceptor {
+    intercept(request, next) {
+        request = request.clone({
+            setHeaders: {
+                'Content-Type': request.headers.get('Content-Type') || 'application/json',
+            }
+        });
+        return next.handle(request);
+    }
+}
+HeaderInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: HeaderInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+HeaderInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: HeaderInterceptor, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: HeaderInterceptor, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGVhZGVyLmludGVyY2VwdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LXRlY2hsaWZ5LWNvcmUvc3JjL2xpYi9jb3JlL2hlYWRlci5pbnRlcmNlcHRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUszQzs7R0FFRztBQUlILE1BQU0sT0FBTyxpQkFBaUI7SUFFNUIsU0FBUyxDQUFDLE9BQXlCLEVBQUUsSUFBaUI7UUFDcEQsT0FBTyxHQUFHLE9BQU8sQ0FBQyxLQUFLLENBQUM7WUFDdEIsVUFBVSxFQUFFO2dCQUNWLGNBQWMsRUFBRSxPQUFPLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxjQUFjLENBQUMsSUFBSSxrQkFBa0I7YUFDMUU7U0FDRixDQUFDLENBQUM7UUFDSCxPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDOUIsQ0FBQzs7OEdBVFUsaUJBQWlCO2tIQUFqQixpQkFBaUIsY0FGaEIsTUFBTTsyRkFFUCxpQkFBaUI7a0JBSDdCLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBIdHRwRXZlbnQsIEh0dHBJbnRlcmNlcHRvciwgSHR0cEhhbmRsZXIsIEh0dHBSZXF1ZXN0IH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uL2h0dHAnO1xyXG5pbXBvcnQgeyBPYnNlcnZhYmxlIH0gZnJvbSAncnhqcyc7XHJcblxyXG5cclxuLyoqXHJcbiAqIFByZWZpeGVzIGFsbCByZXF1ZXN0cyBub3Qgc3RhcnRpbmcgd2l0aCBgaHR0cFtzXWAgd2l0aCBgZW52aXJvbm1lbnQuc2VydmVyVXJsYC5cclxuICovXHJcbkBJbmplY3RhYmxlKHtcclxuICBwcm92aWRlZEluOiAncm9vdCdcclxufSlcclxuZXhwb3J0IGNsYXNzIEhlYWRlckludGVyY2VwdG9yIGltcGxlbWVudHMgSHR0cEludGVyY2VwdG9yIHtcclxuXHJcbiAgaW50ZXJjZXB0KHJlcXVlc3Q6IEh0dHBSZXF1ZXN0PGFueT4sIG5leHQ6IEh0dHBIYW5kbGVyKTogT2JzZXJ2YWJsZTxIdHRwRXZlbnQ8YW55Pj4ge1xyXG4gICAgcmVxdWVzdCA9IHJlcXVlc3QuY2xvbmUoe1xyXG4gICAgICBzZXRIZWFkZXJzOiB7XHJcbiAgICAgICAgJ0NvbnRlbnQtVHlwZSc6IHJlcXVlc3QuaGVhZGVycy5nZXQoJ0NvbnRlbnQtVHlwZScpIHx8ICdhcHBsaWNhdGlvbi9qc29uJyxcclxuICAgICAgfVxyXG4gICAgfSk7XHJcbiAgICByZXR1cm4gbmV4dC5oYW5kbGUocmVxdWVzdCk7XHJcbiAgfVxyXG59XHJcbiJdfQ==

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

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