ngx-techlify-core 11.2.4

package/esm2015/lib/core/core.module.js

@@ -0,0 +1,42 @@
+import { NgModule, Optional, SkipSelf } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { HttpClientModule, HttpClient } from '@angular/common/http';
+import { RouteReuseStrategy, RouterModule } from '@angular/router';
+import { RouteReusableStrategy } from './route-reusable-strategy';
+import { HttpService } from './http.service';
+import { SnackModule } from './snack/snack.module';
+export class CoreModule {
+    constructor(parentModule) {
+        // Import guard
+        if (parentModule) {
+            throw new Error(`${parentModule} has already been loaded. Import Core module in the root module only.`);
+        }
+    }
+}
+CoreModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    CommonModule,
+                    HttpClientModule,
+                    RouterModule,
+                    SnackModule
+                ],
+                providers: [
+                    {
+                        provide: HttpClient,
+                        useClass: HttpService
+                    },
+                    {
+                        provide: RouteReuseStrategy,
+                        useClass: RouteReusableStrategy
+                    }
+                ],
+                exports: [
+                    SnackModule
+                ]
+            },] }
+];
+CoreModule.ctorParameters = () => [
+    { type: CoreModule, decorators: [{ type: Optional }, { type: SkipSelf }] }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/core/credentials.service.js

@@ -0,0 +1,84 @@
+import { Injectable } from '@angular/core';
+import { ConfigService } from './config.service';
+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() {
+        var _a, _b, _c, _d;
+        const expiration = ((_b = (_a = this.credentials) === null || _a === void 0 ? void 0 : _a.token) === null || _b === void 0 ? void 0 : _b.expires_in) || '';
+        const token = ((_d = (_c = this.credentials) === null || _c === void 0 ? void 0 : _c.token) === null || _d === void 0 ? void 0 : _d.access_token) || '';
+        if (!token || !expiration) {
+            return null;
+        }
+        if (Date.now() > parseInt(expiration)) {
+            this.setCredentials();
+            return null;
+        }
+        return token;
+    }
+    getExpiration() {
+        var _a, _b;
+        return ((_b = (_a = this.credentials) === null || _a === void 0 ? void 0 : _a.token) === null || _b === void 0 ? void 0 : _b.expires_in) || '';
+    }
+    getRefreshToken() {
+        var _a, _b;
+        return ((_b = (_a = this.credentials) === null || _a === void 0 ? void 0 : _a.token) === null || _b === void 0 ? void 0 : _b.refresh_token) || '';
+    }
+    refresh() {
+        this._credentials = null;
+        return this;
+    }
+}
+CredentialsService.ɵprov = i0.ɵɵdefineInjectable({ factory: function CredentialsService_Factory() { return new CredentialsService(i0.ɵɵinject(i1.ConfigService)); }, token: CredentialsService, providedIn: "root" });
+CredentialsService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+CredentialsService.ctorParameters = () => [
+    { type: ConfigService }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/core/dataManager.service.js

@@ -0,0 +1,121 @@
+import { Injectable } from '@angular/core';
+import { HttpService } from './http.service';
+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.ɵprov = i0.ɵɵdefineInjectable({ factory: function DataManager_Factory() { return new DataManager(i0.ɵɵinject(i1.HttpService)); }, token: DataManager, providedIn: "root" });
+DataManager.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+DataManager.ctorParameters = () => [
+    { type: HttpService }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/core/error-handler.interceptor.js

@@ -0,0 +1,53 @@
+import { Injectable } from '@angular/core';
+import { throwError } from 'rxjs';
+import { catchError } from 'rxjs/operators';
+import { Logger } from './logger.service';
+import { ConfigService } from './config.service';
+import { ErrorHandlerService } from './error-handler.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) {
+        var _a, _b;
+        let errorMessage = '';
+        if (error.error instanceof ErrorEvent) {
+            // client-side error
+            errorMessage = `Client Error: ${(_a = this.configService) === null || _a === void 0 ? void 0 : _a.getProjectKey()}: ${error.error.message}`;
+        }
+        else {
+            // server-side error
+            errorMessage = `Server Error: ${(_b = this.configService) === null || _b === void 0 ? void 0 : _b.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.ɵprov = i0.ɵɵdefineInjectable({ factory: function ErrorHandlerInterceptor_Factory() { return new ErrorHandlerInterceptor(i0.ɵɵinject(i1.ConfigService), i0.ɵɵinject(i2.ErrorHandlerService)); }, token: ErrorHandlerInterceptor, providedIn: "root" });
+ErrorHandlerInterceptor.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+ErrorHandlerInterceptor.ctorParameters = () => [
+    { type: ConfigService },
+    { type: ErrorHandlerService }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/core/error-handler.service.js

@@ -0,0 +1,49 @@
+import { Injectable } from "@angular/core";
+import { AlertService } from "./alert.service";
+import * as i0 from "@angular/core";
+import * as i1 from "./alert.service";
+/**
+ * Service used to handle errors from the request
+ *
+ * @author Joshua Kissoon
+ * @since 20171202
+ */
+export class ErrorHandlerService {
+    constructor(alerter) {
+        this.alerter = alerter;
+    }
+    handleError(errorResponse, msg = '') {
+        var _a;
+        // 1 - Create empty array to store errors
+        const errors = [];
+        // 2 - check if the error object is present in the response
+        if (errorResponse.error) {
+            // 3 - Push the main error message to the array of errors
+            errors.push(errorResponse.error.message ? errorResponse.error.message : (_a = errorResponse.error) === null || _a === void 0 ? void 0 : _a.error);
+            // 4 - Check for Laravel form validation error messages object
+            if (errorResponse.error.errors) {
+                // 5 - For each error property (which is a form field)
+                for (const property in errorResponse.error.errors) {
+                    if (errorResponse.error.errors.hasOwnProperty(property)) {
+                        // 6 - Extract it's array of errors
+                        const propertyErrors = errorResponse.error.errors[property];
+                        // 7 - Push all errors in the array to the errors array
+                        propertyErrors.forEach(error => errors.push(error));
+                    }
+                }
+            }
+        }
+        var errMessage = errors.length ? errors[0] : msg;
+        this.alerter.addAlert("Error: " + errMessage, "warning");
+    }
+}
+ErrorHandlerService.ɵprov = i0.ɵɵdefineInjectable({ factory: function ErrorHandlerService_Factory() { return new ErrorHandlerService(i0.ɵɵinject(i1.AlertService)); }, token: ErrorHandlerService, providedIn: "root" });
+ErrorHandlerService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+ErrorHandlerService.ctorParameters = () => [
+    { type: AlertService }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/core/form-validator.service.js

@@ -0,0 +1,23 @@
+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.ɵprov = i0.ɵɵdefineInjectable({ factory: function FormValidatorService_Factory() { return new FormValidatorService(); }, token: FormValidatorService, providedIn: "root" });
+FormValidatorService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+FormValidatorService.ctorParameters = () => [];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/core/header.interceptor.js

@@ -0,0 +1,22 @@
+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.ɵprov = i0.ɵɵdefineInjectable({ factory: function HeaderInterceptor_Factory() { return new HeaderInterceptor(); }, token: HeaderInterceptor, providedIn: "root" });
+HeaderInterceptor.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGVhZGVyLmludGVyY2VwdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LXRlY2hsaWZ5LWNvcmUvc3JjL2xpYi9jb3JlL2hlYWRlci5pbnRlcmNlcHRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUszQzs7R0FFRztBQUlILE1BQU0sT0FBTyxpQkFBaUI7SUFFNUIsU0FBUyxDQUFDLE9BQXlCLEVBQUUsSUFBaUI7UUFDcEQsT0FBTyxHQUFHLE9BQU8sQ0FBQyxLQUFLLENBQUM7WUFDdEIsVUFBVSxFQUFFO2dCQUNWLGNBQWMsRUFBRSxPQUFPLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxjQUFjLENBQUMsSUFBSSxrQkFBa0I7YUFDMUU7U0FDRixDQUFDLENBQUM7UUFDSCxPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDOUIsQ0FBQzs7OztZQVpGLFVBQVUsU0FBQztnQkFDVixVQUFVLEVBQUUsTUFBTTthQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEh0dHBFdmVudCwgSHR0cEludGVyY2VwdG9yLCBIdHRwSGFuZGxlciwgSHR0cFJlcXVlc3QgfSBmcm9tICdAYW5ndWxhci9jb21tb24vaHR0cCc7XG5pbXBvcnQgeyBPYnNlcnZhYmxlIH0gZnJvbSAncnhqcyc7XG5cblxuLyoqXG4gKiBQcmVmaXhlcyBhbGwgcmVxdWVzdHMgbm90IHN0YXJ0aW5nIHdpdGggYGh0dHBbc11gIHdpdGggYGVudmlyb25tZW50LnNlcnZlclVybGAuXG4gKi9cbkBJbmplY3RhYmxlKHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnXG59KVxuZXhwb3J0IGNsYXNzIEhlYWRlckludGVyY2VwdG9yIGltcGxlbWVudHMgSHR0cEludGVyY2VwdG9yIHtcblxuICBpbnRlcmNlcHQocmVxdWVzdDogSHR0cFJlcXVlc3Q8YW55PiwgbmV4dDogSHR0cEhhbmRsZXIpOiBPYnNlcnZhYmxlPEh0dHBFdmVudDxhbnk+PiB7XG4gICAgcmVxdWVzdCA9IHJlcXVlc3QuY2xvbmUoe1xuICAgICAgc2V0SGVhZGVyczoge1xuICAgICAgICAnQ29udGVudC1UeXBlJzogcmVxdWVzdC5oZWFkZXJzLmdldCgnQ29udGVudC1UeXBlJykgfHwgJ2FwcGxpY2F0aW9uL2pzb24nLFxuICAgICAgfVxuICAgIH0pO1xuICAgIHJldHVybiBuZXh0LmhhbmRsZShyZXF1ZXN0KTtcbiAgfVxufVxuIl19

package/esm2015/lib/core/http-cache.service.js

@@ -0,0 +1,110 @@
+import { Injectable } from '@angular/core';
+import { ConfigService } from './config.service';
+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) => {
+                var _a;
+                if (expirationDate >= ((_a = this.cachedData[key]) === null || _a === void 0 ? void 0 : _a.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.ɵprov = i0.ɵɵdefineInjectable({ factory: function HttpCacheService_Factory() { return new HttpCacheService(i0.ɵɵinject(i1.ConfigService)); }, token: HttpCacheService, providedIn: "root" });
+HttpCacheService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+HttpCacheService.ctorParameters = () => [
+    { type: 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"]}