ngx-techlify-core 11.5.2 → 14.2.0

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

@@ -0,0 +1,84 @@
+import { Inject, Injectable, InjectionToken, Optional } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { ErrorHandlerInterceptor } from './error-handler.interceptor';
+import { CacheInterceptor } from './cache.interceptor';
+import { ApiPrefixInterceptor } from './api-prefix.interceptor';
+import { TokenInterceptor } from './token.interceptor';
+import { HeaderInterceptor } from './header.interceptor';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+// From @angular/common/http/src/interceptor: allows to chain interceptors
+class HttpInterceptorHandler {
+    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.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: HttpService, deps: [{ token: i1.HttpHandler }, { token: i0.Injector }, { token: HTTP_DYNAMIC_INTERCEPTORS, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+HttpService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: HttpService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: HttpService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpHandler }, { type: i0.Injector }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [HTTP_DYNAMIC_INTERCEPTORS]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http.service.js","sourceRoot":"","sources":["../../../../../projects/ngx-techlify-core/src/lib/core/http.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, InjectionToken, Injector, Optional } from '@angular/core';\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/esm2020/lib/core/index.mjs

@@ -0,0 +1,22 @@
+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';
+export * from './filter.service';
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,100 @@
+/**
+ * Simple logger system with the possibility of registering custom outputs.
+ *
+ * 4 different log levels are provided, with corresponding methods:
+ * - debug   : for debug information
+ * - info    : for informative status of the application (success, ...)
+ * - warning : for non-critical errors that do not prevent normal application behavior
+ * - error   : for critical errors that prevent normal application behavior
+ *
+ * Example usage:
+ * ```
+ * import { Logger } from 'app/core/logger.service';
+ *
+ * const log = new Logger('myFile');
+ * ...
+ * log.debug('something happened');
+ * ```
+ *
+ * To disable debug and info logs in production, add this snippet to your root component:
+ * ```
+ * export class AppComponent implements OnInit {
+ *   ngOnInit() {
+ *     if (environment.production) {
+ *       Logger.enableProductionMode();
+ *     }
+ *     ...
+ *   }
+ * }
+ *
+ * If you want to process logs through other outputs than console, you can add LogOutput functions to Logger.outputs.
+ */
+/**
+ * The possible log levels.
+ * LogLevel.Off is never emitted and only used with Logger.level property to disable logs.
+ */
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["Off"] = 0] = "Off";
+    LogLevel[LogLevel["Error"] = 1] = "Error";
+    LogLevel[LogLevel["Warning"] = 2] = "Warning";
+    LogLevel[LogLevel["Info"] = 3] = "Info";
+    LogLevel[LogLevel["Debug"] = 4] = "Debug";
+})(LogLevel || (LogLevel = {}));
+export class Logger {
+    constructor(source) {
+        this.source = source;
+    }
+    /**
+     * Enables production mode.
+     * Sets logging level to LogLevel.Warning.
+     */
+    static enableProductionMode() {
+        Logger.level = LogLevel.Warning;
+    }
+    /**
+     * Logs messages or objects  with the debug level.
+     * Works the same as console.log().
+     */
+    debug(...objects) {
+        this.log(console.log, LogLevel.Debug, objects);
+    }
+    /**
+     * Logs messages or objects  with the info level.
+     * Works the same as console.log().
+     */
+    info(...objects) {
+        this.log(console.info, LogLevel.Info, objects);
+    }
+    /**
+     * Logs messages or objects  with the warning level.
+     * Works the same as console.log().
+     */
+    warn(...objects) {
+        this.log(console.warn, LogLevel.Warning, objects);
+    }
+    /**
+     * Logs messages or objects  with the error level.
+     * Works the same as console.log().
+     */
+    error(...objects) {
+        this.log(console.error, LogLevel.Error, objects);
+    }
+    log(func, level, objects) {
+        if (level <= Logger.level) {
+            const log = this.source ? ['[' + this.source + ']'].concat(objects) : objects;
+            func.apply(console, log);
+            Logger.outputs.forEach(output => output.apply(output, [this.source, level, ...objects]));
+        }
+    }
+}
+/**
+ * Current logging level.
+ * Set it to LogLevel.Off to disable logs completely.
+ */
+Logger.level = LogLevel.Debug;
+/**
+ * Additional log outputs.
+ */
+Logger.outputs = [];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/core/route-reusable-strategy.mjs

@@ -0,0 +1,36 @@
+import { RouteReuseStrategy } from '@angular/router';
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * A route strategy allowing for explicit route reuse.
+ * Used as a workaround for https://github.com/angular/angular/issues/18374
+ * To reuse a given route, add `data: { reuse: true }` to the route definition.
+ */
+export class RouteReusableStrategy extends RouteReuseStrategy {
+    shouldDetach(route) {
+        return false;
+    }
+    store(route, detachedTree) { }
+    shouldAttach(route) {
+        return false;
+    }
+    retrieve(route) {
+        return null;
+    }
+    shouldReuseRoute(future, curr) {
+        // Reuse the route if the RouteConfig is the same, or if both routes use the
+        // same component, because the latter can have different RouteConfigs.
+        return future.routeConfig === curr.routeConfig ||
+            Boolean(future.routeConfig?.component &&
+                future.routeConfig?.component === curr.routeConfig?.component);
+    }
+}
+RouteReusableStrategy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: RouteReusableStrategy, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+RouteReusableStrategy.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: RouteReusableStrategy, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: RouteReusableStrategy, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/core/snack/snack.component.mjs

@@ -0,0 +1,33 @@
+import { Component, Inject } from '@angular/core';
+import { MAT_SNACK_BAR_DATA } from '@angular/material/snack-bar';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/icon";
+export class SuccessSnackComponent {
+    constructor(data) {
+        this.data = data;
+    }
+}
+SuccessSnackComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: SuccessSnackComponent, deps: [{ token: MAT_SNACK_BAR_DATA }], target: i0.ɵɵFactoryTarget.Component });
+SuccessSnackComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.7", type: SuccessSnackComponent, selector: "snack-bar-component-example-snack", ngImport: i0, template: "<div class=\"row-container\">\r\n    <span class=\"icon-column\">\r\n        <mat-icon class=\"success\"> check_circle_outline</mat-icon>\r\n    </span>\r\n    <span class=\"text-column\">\r\n        {{ data }}\r\n    </span>\r\n</div>", styles: [".error{color:#dc3545}.success{color:#28a745}.row-container{display:flex}.icon-column{flex:5%;padding-right:5px}.text-column{flex:95%;text-align:center;color:#fff}\n"], dependencies: [{ kind: "component", type: i1.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: SuccessSnackComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'snack-bar-component-example-snack', template: "<div class=\"row-container\">\r\n    <span class=\"icon-column\">\r\n        <mat-icon class=\"success\"> check_circle_outline</mat-icon>\r\n    </span>\r\n    <span class=\"text-column\">\r\n        {{ data }}\r\n    </span>\r\n</div>", styles: [".error{color:#dc3545}.success{color:#28a745}.row-container{display:flex}.icon-column{flex:5%;padding-right:5px}.text-column{flex:95%;text-align:center;color:#fff}\n"] }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MAT_SNACK_BAR_DATA]
+                }] }]; } });
+export class ErrorSnackComponent {
+    constructor(data) {
+        this.data = data;
+    }
+}
+ErrorSnackComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ErrorSnackComponent, deps: [{ token: MAT_SNACK_BAR_DATA }], target: i0.ɵɵFactoryTarget.Component });
+ErrorSnackComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.7", type: ErrorSnackComponent, selector: "snack-bar-component-example-snack", ngImport: i0, template: "<div class=\"row-container\">\r\n    <span class=\"icon-column\">\r\n        <mat-icon class=\"error\"> cancel</mat-icon>\r\n    </span>\r\n    <span class=\"text-column\">\r\n        {{ data }}\r\n    </span>\r\n</div>", styles: [".error{color:#dc3545}.success{color:#28a745}.row-container{display:flex}.icon-column{flex:5%;padding-right:5px}.text-column{flex:95%;text-align:center;color:#fff}\n"], dependencies: [{ kind: "component", type: i1.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ErrorSnackComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'snack-bar-component-example-snack', template: "<div class=\"row-container\">\r\n    <span class=\"icon-column\">\r\n        <mat-icon class=\"error\"> cancel</mat-icon>\r\n    </span>\r\n    <span class=\"text-column\">\r\n        {{ data }}\r\n    </span>\r\n</div>", styles: [".error{color:#dc3545}.success{color:#28a745}.row-container{display:flex}.icon-column{flex:5%;padding-right:5px}.text-column{flex:95%;text-align:center;color:#fff}\n"] }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MAT_SNACK_BAR_DATA]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/core/snack/snack.module.mjs

@@ -0,0 +1,36 @@
+import { NgModule } from '@angular/core';
+import { SuccessSnackComponent, ErrorSnackComponent } from './snack.component';
+import { CommonModule } from '@angular/common';
+import { MatSnackBarModule } from '@angular/material/snack-bar';
+import { MatIconModule } from '@angular/material/icon';
+import * as i0 from "@angular/core";
+export class SnackModule {
+}
+SnackModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: SnackModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+SnackModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.2.7", ngImport: i0, type: SnackModule, declarations: [SuccessSnackComponent,
+        ErrorSnackComponent], imports: [CommonModule,
+        MatSnackBarModule,
+        MatIconModule], exports: [SuccessSnackComponent,
+        ErrorSnackComponent] });
+SnackModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: SnackModule, imports: [CommonModule,
+        MatSnackBarModule,
+        MatIconModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: SnackModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        SuccessSnackComponent,
+                        ErrorSnackComponent
+                    ],
+                    imports: [
+                        CommonModule,
+                        MatSnackBarModule,
+                        MatIconModule
+                    ],
+                    exports: [
+                        SuccessSnackComponent,
+                        ErrorSnackComponent,
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic25hY2subW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LXRlY2hsaWZ5LWNvcmUvc3JjL2xpYi9jb3JlL3NuYWNrL3NuYWNrLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxtQkFBbUIsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQy9FLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUNoRSxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7O0FBaUJ2RCxNQUFNLE9BQU8sV0FBVzs7d0dBQVgsV0FBVzt5R0FBWCxXQUFXLGlCQWJwQixxQkFBcUI7UUFDckIsbUJBQW1CLGFBR25CLFlBQVk7UUFDWixpQkFBaUI7UUFDakIsYUFBYSxhQUdiLHFCQUFxQjtRQUNyQixtQkFBbUI7eUdBR1YsV0FBVyxZQVRwQixZQUFZO1FBQ1osaUJBQWlCO1FBQ2pCLGFBQWE7MkZBT0osV0FBVztrQkFmdkIsUUFBUTttQkFBQztvQkFDUixZQUFZLEVBQUU7d0JBQ1oscUJBQXFCO3dCQUNyQixtQkFBbUI7cUJBQ3BCO29CQUNELE9BQU8sRUFBRTt3QkFDUCxZQUFZO3dCQUNaLGlCQUFpQjt3QkFDakIsYUFBYTtxQkFDZDtvQkFDRCxPQUFPLEVBQUU7d0JBQ1AscUJBQXFCO3dCQUNyQixtQkFBbUI7cUJBQ3BCO2lCQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgU3VjY2Vzc1NuYWNrQ29tcG9uZW50LCBFcnJvclNuYWNrQ29tcG9uZW50IH0gZnJvbSAnLi9zbmFjay5jb21wb25lbnQnO1xyXG5pbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xyXG5pbXBvcnQgeyBNYXRTbmFja0Jhck1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL21hdGVyaWFsL3NuYWNrLWJhcic7XHJcbmltcG9ydCB7IE1hdEljb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC9pY29uJztcclxuXHJcbkBOZ01vZHVsZSh7XHJcbiAgZGVjbGFyYXRpb25zOiBbXHJcbiAgICBTdWNjZXNzU25hY2tDb21wb25lbnQsXHJcbiAgICBFcnJvclNuYWNrQ29tcG9uZW50XHJcbiAgXSxcclxuICBpbXBvcnRzOiBbXHJcbiAgICBDb21tb25Nb2R1bGUsXHJcbiAgICBNYXRTbmFja0Jhck1vZHVsZSxcclxuICAgIE1hdEljb25Nb2R1bGVcclxuICBdLFxyXG4gIGV4cG9ydHM6IFtcclxuICAgIFN1Y2Nlc3NTbmFja0NvbXBvbmVudCxcclxuICAgIEVycm9yU25hY2tDb21wb25lbnQsXHJcbiAgXVxyXG59KVxyXG5leHBvcnQgY2xhc3MgU25hY2tNb2R1bGUgeyB9XHJcbiJdfQ==

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

@@ -0,0 +1,38 @@
+import { Injectable } from "@angular/core";
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Service used to manage Local Storage
+ *
+ * @author Joshua Kissoon
+ * @since 20190623
+ */
+export class StorageService {
+    constructor() {
+        this.storageSub = new Subject();
+    }
+    watch() {
+        return this.storageSub.asObservable();
+    }
+    setItem(key, data) {
+        localStorage.setItem(key, data);
+        this.storageSub.next({ key: key, value: data });
+    }
+    getItem(key) {
+        return localStorage.getItem(key);
+    }
+    removeItem(key) {
+        const data = this.getItem(key);
+        localStorage.removeItem(key);
+        this.storageSub.next({ key: key, value: data });
+    }
+}
+StorageService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: StorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+StorageService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: StorageService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: StorageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/core/techlify-config.model.mjs

@@ -0,0 +1,28 @@
+/**
+ * Class that stores the configuration data
+ *
+ * @author Joshua Kissoon
+ * @since 20180724
+ */
+export class TechlifyConfig {
+    constructor(data) {
+        this.projectKey = '';
+        this.environment = '';
+        this.authClientSecret = '';
+        this.authGrantType = '';
+        this.apiUrl = '';
+        this.isLogoutWhileApiGetsFailed = false;
+        this.loadFromMap(data);
+    }
+    loadFromMap(data) {
+        this.projectKey = data.projectKey;
+        this.environment = data.environment;
+        this.authClientSecret = data.authClientSecret;
+        this.authGrantType = data.authGrantType;
+        this.apiUrl = data.apiUrl;
+        this.storage = data?.storage;
+        this.rawConfigs = data;
+        this.isLogoutWhileApiGetsFailed = data?.isLogoutWhileApiGetsFailed;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,28 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./credentials.service";
+/**
+ * Prefixes all requests not starting with `http[s]` with `environment.serverUrl`.
+ */
+export class TokenInterceptor {
+    constructor(credentials) {
+        this.credentials = credentials;
+    }
+    intercept(request, next) {
+        request = request.clone({
+            setHeaders: {
+                Authorization: `Bearer ${this.credentials.getAccessToken() || ''}`
+            }
+        });
+        return next.handle(request);
+    }
+}
+TokenInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: TokenInterceptor, deps: [{ token: i1.CredentialsService }], target: i0.ɵɵFactoryTarget.Injectable });
+TokenInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: TokenInterceptor, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: TokenInterceptor, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.CredentialsService }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9rZW4uaW50ZXJjZXB0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtdGVjaGxpZnktY29yZS9zcmMvbGliL2NvcmUvdG9rZW4uaW50ZXJjZXB0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7O0FBTTNDOztHQUVHO0FBSUgsTUFBTSxPQUFPLGdCQUFnQjtJQUUzQixZQUFvQixXQUErQjtRQUEvQixnQkFBVyxHQUFYLFdBQVcsQ0FBb0I7SUFBSSxDQUFDO0lBRXhELFNBQVMsQ0FBQyxPQUF5QixFQUFFLElBQWlCO1FBQ3BELE9BQU8sR0FBRyxPQUFPLENBQUMsS0FBSyxDQUFDO1lBQ3RCLFVBQVUsRUFBRTtnQkFDVixhQUFhLEVBQUUsVUFBVSxJQUFJLENBQUMsV0FBVyxDQUFDLGNBQWMsRUFBRSxJQUFJLEVBQUUsRUFBRTthQUNuRTtTQUNGLENBQUMsQ0FBQztRQUNILE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUM5QixDQUFDOzs2R0FYVSxnQkFBZ0I7aUhBQWhCLGdCQUFnQixjQUZmLE1BQU07MkZBRVAsZ0JBQWdCO2tCQUg1QixVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgSHR0cEV2ZW50LCBIdHRwSW50ZXJjZXB0b3IsIEh0dHBIYW5kbGVyLCBIdHRwUmVxdWVzdCB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbi9odHRwJztcclxuaW1wb3J0IHsgT2JzZXJ2YWJsZSB9IGZyb20gJ3J4anMnO1xyXG5pbXBvcnQgeyBDcmVkZW50aWFsc1NlcnZpY2UgfSBmcm9tICcuL2NyZWRlbnRpYWxzLnNlcnZpY2UnO1xyXG5cclxuXHJcbi8qKlxyXG4gKiBQcmVmaXhlcyBhbGwgcmVxdWVzdHMgbm90IHN0YXJ0aW5nIHdpdGggYGh0dHBbc11gIHdpdGggYGVudmlyb25tZW50LnNlcnZlclVybGAuXHJcbiAqL1xyXG5ASW5qZWN0YWJsZSh7XHJcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBUb2tlbkludGVyY2VwdG9yIGltcGxlbWVudHMgSHR0cEludGVyY2VwdG9yIHtcclxuXHJcbiAgY29uc3RydWN0b3IocHJpdmF0ZSBjcmVkZW50aWFsczogQ3JlZGVudGlhbHNTZXJ2aWNlKSB7IH1cclxuXHJcbiAgaW50ZXJjZXB0KHJlcXVlc3Q6IEh0dHBSZXF1ZXN0PGFueT4sIG5leHQ6IEh0dHBIYW5kbGVyKTogT2JzZXJ2YWJsZTxIdHRwRXZlbnQ8YW55Pj4ge1xyXG4gICAgcmVxdWVzdCA9IHJlcXVlc3QuY2xvbmUoe1xyXG4gICAgICBzZXRIZWFkZXJzOiB7XHJcbiAgICAgICAgQXV0aG9yaXphdGlvbjogYEJlYXJlciAke3RoaXMuY3JlZGVudGlhbHMuZ2V0QWNjZXNzVG9rZW4oKSB8fCAnJ31gXHJcbiAgICAgIH1cclxuICAgIH0pO1xyXG4gICAgcmV0dXJuIG5leHQuaGFuZGxlKHJlcXVlc3QpO1xyXG4gIH1cclxufVxyXG4iXX0=