ngx-techlify-core 11.4.6 → 11.4.7

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

@@ -1,110 +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"]}
+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';\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"]}

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

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

package/esm2015/lib/core/index.js

@@ -1,21 +1,21 @@
-export * from './snack/snack.component';
-export * from './snack/snack.module';
-export * from './alert.service';
-export * from './api-prefix.interceptor';
-export * from './authentication.guard';
-export * from './authentication.service';
-export * from './cache.interceptor';
-export * from './config.service';
-export * from './credentials.service';
-export * from './error-handler.interceptor';
-export * from './error-handler.service';
-export * from './form-validator.service';
-export * from './http-cache.service';
-export * from './http.service';
-export * from './logger.service';
-export * from './route-reusable-strategy';
-export * from './storage.service';
-export * from './techlify-config.model';
-export * from './token.interceptor';
-export * from './dataManager.service';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtdGVjaGxpZnktY29yZS9zcmMvbGliL2NvcmUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLHNCQUFzQixDQUFDO0FBRXJDLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLHVCQUF1QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9zbmFjay9zbmFjay5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9zbmFjay9zbmFjay5tb2R1bGUnO1xuXG5leHBvcnQgKiBmcm9tICcuL2FsZXJ0LnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9hcGktcHJlZml4LmludGVyY2VwdG9yJztcbmV4cG9ydCAqIGZyb20gJy4vYXV0aGVudGljYXRpb24uZ3VhcmQnO1xuZXhwb3J0ICogZnJvbSAnLi9hdXRoZW50aWNhdGlvbi5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vY2FjaGUuaW50ZXJjZXB0b3InO1xuZXhwb3J0ICogZnJvbSAnLi9jb25maWcuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2NyZWRlbnRpYWxzLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9lcnJvci1oYW5kbGVyLmludGVyY2VwdG9yJztcbmV4cG9ydCAqIGZyb20gJy4vZXJyb3ItaGFuZGxlci5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vZm9ybS12YWxpZGF0b3Iuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2h0dHAtY2FjaGUuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2h0dHAuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2xvZ2dlci5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vcm91dGUtcmV1c2FibGUtc3RyYXRlZ3knO1xuZXhwb3J0ICogZnJvbSAnLi9zdG9yYWdlLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi90ZWNobGlmeS1jb25maWcubW9kZWwnO1xuZXhwb3J0ICogZnJvbSAnLi90b2tlbi5pbnRlcmNlcHRvcic7XG5leHBvcnQgKiBmcm9tICcuL2RhdGFNYW5hZ2VyLnNlcnZpY2UnO1xuIl19
+export * from './snack/snack.component';
+export * from './snack/snack.module';
+export * from './alert.service';
+export * from './api-prefix.interceptor';
+export * from './authentication.guard';
+export * from './authentication.service';
+export * from './cache.interceptor';
+export * from './config.service';
+export * from './credentials.service';
+export * from './error-handler.interceptor';
+export * from './error-handler.service';
+export * from './form-validator.service';
+export * from './http-cache.service';
+export * from './http.service';
+export * from './logger.service';
+export * from './route-reusable-strategy';
+export * from './storage.service';
+export * from './techlify-config.model';
+export * from './token.interceptor';
+export * from './dataManager.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtdGVjaGxpZnktY29yZS9zcmMvbGliL2NvcmUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLHNCQUFzQixDQUFDO0FBRXJDLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLHVCQUF1QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9zbmFjay9zbmFjay5jb21wb25lbnQnO1xyXG5leHBvcnQgKiBmcm9tICcuL3NuYWNrL3NuYWNrLm1vZHVsZSc7XHJcblxyXG5leHBvcnQgKiBmcm9tICcuL2FsZXJ0LnNlcnZpY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL2FwaS1wcmVmaXguaW50ZXJjZXB0b3InO1xyXG5leHBvcnQgKiBmcm9tICcuL2F1dGhlbnRpY2F0aW9uLmd1YXJkJztcclxuZXhwb3J0ICogZnJvbSAnLi9hdXRoZW50aWNhdGlvbi5zZXJ2aWNlJztcclxuZXhwb3J0ICogZnJvbSAnLi9jYWNoZS5pbnRlcmNlcHRvcic7XHJcbmV4cG9ydCAqIGZyb20gJy4vY29uZmlnLnNlcnZpY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL2NyZWRlbnRpYWxzLnNlcnZpY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL2Vycm9yLWhhbmRsZXIuaW50ZXJjZXB0b3InO1xyXG5leHBvcnQgKiBmcm9tICcuL2Vycm9yLWhhbmRsZXIuc2VydmljZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vZm9ybS12YWxpZGF0b3Iuc2VydmljZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vaHR0cC1jYWNoZS5zZXJ2aWNlJztcclxuZXhwb3J0ICogZnJvbSAnLi9odHRwLnNlcnZpY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xvZ2dlci5zZXJ2aWNlJztcclxuZXhwb3J0ICogZnJvbSAnLi9yb3V0ZS1yZXVzYWJsZS1zdHJhdGVneSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vc3RvcmFnZS5zZXJ2aWNlJztcclxuZXhwb3J0ICogZnJvbSAnLi90ZWNobGlmeS1jb25maWcubW9kZWwnO1xyXG5leHBvcnQgKiBmcm9tICcuL3Rva2VuLmludGVyY2VwdG9yJztcclxuZXhwb3J0ICogZnJvbSAnLi9kYXRhTWFuYWdlci5zZXJ2aWNlJztcclxuIl19