ngx-techlify-core 11.2.4

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

@@ -0,0 +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"]}

package/esm2015/lib/core/index.js

@@ -0,0 +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

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

@@ -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/esm2015/lib/core/route-reusable-strategy.js

@@ -0,0 +1,35 @@
+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) {
+        var _a, _b, _c;
+        // 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(((_a = future.routeConfig) === null || _a === void 0 ? void 0 : _a.component) &&
+                ((_b = future.routeConfig) === null || _b === void 0 ? void 0 : _b.component) === ((_c = curr.routeConfig) === null || _c === void 0 ? void 0 : _c.component));
+    }
+}
+RouteReusableStrategy.ɵprov = i0.ɵɵdefineInjectable({ factory: function RouteReusableStrategy_Factory() { return new RouteReusableStrategy(); }, token: RouteReusableStrategy, providedIn: "root" });
+RouteReusableStrategy.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/core/snack/snack.component.js

@@ -0,0 +1,33 @@
+import { Component, Inject } from '@angular/core';
+import { MAT_SNACK_BAR_DATA } from '@angular/material/snack-bar';
+export class SuccessSnackComponent {
+    constructor(data) {
+        this.data = data;
+    }
+}
+SuccessSnackComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'snack-bar-component-example-snack',
+                template: "<div class=\"row-container\">\n    <span class=\"icon-column\">\n        <mat-icon class=\"success\"> check_circle_outline</mat-icon>\n    </span>\n    <span class=\"text-column\">\n        {{ data }}\n    </span>\n</div>",
+                styles: [".error{color:#dc3545}.success{color:#28a745}.row-container{display:flex}.icon-column{flex:5%;padding-right:5px}.text-column{color:#fff;flex:95%;text-align:center}"]
+            },] }
+];
+SuccessSnackComponent.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [MAT_SNACK_BAR_DATA,] }] }
+];
+export class ErrorSnackComponent {
+    constructor(data) {
+        this.data = data;
+    }
+}
+ErrorSnackComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'snack-bar-component-example-snack',
+                template: "<div class=\"row-container\">\n    <span class=\"icon-column\">\n        <mat-icon class=\"error\"> cancel</mat-icon>\n    </span>\n    <span class=\"text-column\">\n        {{ data }}\n    </span>\n</div>",
+                styles: [".error{color:#dc3545}.success{color:#28a745}.row-container{display:flex}.icon-column{flex:5%;padding-right:5px}.text-column{color:#fff;flex:95%;text-align:center}"]
+            },] }
+];
+ErrorSnackComponent.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [MAT_SNACK_BAR_DATA,] }] }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic25hY2suY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LXRlY2hsaWZ5LWNvcmUvc3JjL2xpYi9jb3JlL3NuYWNrL3NuYWNrLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUNsRCxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQU9qRSxNQUFNLE9BQU8scUJBQXFCO0lBQ2hDLFlBQStDLElBQVM7UUFBVCxTQUFJLEdBQUosSUFBSSxDQUFLO0lBQUksQ0FBQzs7O1lBTjlELFNBQVMsU0FBQztnQkFDVCxRQUFRLEVBQUUsbUNBQW1DO2dCQUM3Qyx5T0FBaUM7O2FBRWxDOzs7NENBRWMsTUFBTSxTQUFDLGtCQUFrQjs7QUFPeEMsTUFBTSxPQUFPLG1CQUFtQjtJQUM5QixZQUErQyxJQUFTO1FBQVQsU0FBSSxHQUFKLElBQUksQ0FBSztJQUFJLENBQUM7OztZQU45RCxTQUFTLFNBQUM7Z0JBQ1QsUUFBUSxFQUFFLG1DQUFtQztnQkFDN0MseU5BQStCOzthQUVoQzs7OzRDQUVjLE1BQU0sU0FBQyxrQkFBa0IiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnQsIEluamVjdCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgTUFUX1NOQUNLX0JBUl9EQVRBIH0gZnJvbSAnQGFuZ3VsYXIvbWF0ZXJpYWwvc25hY2stYmFyJztcblxuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAnc25hY2stYmFyLWNvbXBvbmVudC1leGFtcGxlLXNuYWNrJyxcbiAgdGVtcGxhdGVVcmw6ICdzdWNjZXNzLXNuYWNrLmh0bWwnLFxuICBzdHlsZVVybHM6IFsnLi9zbmFjay5zY3NzJ10sXG59KVxuZXhwb3J0IGNsYXNzIFN1Y2Nlc3NTbmFja0NvbXBvbmVudCB7XG4gIGNvbnN0cnVjdG9yKEBJbmplY3QoTUFUX1NOQUNLX0JBUl9EQVRBKSBwdWJsaWMgZGF0YTogYW55KSB7IH1cbn1cbkBDb21wb25lbnQoe1xuICBzZWxlY3RvcjogJ3NuYWNrLWJhci1jb21wb25lbnQtZXhhbXBsZS1zbmFjaycsXG4gIHRlbXBsYXRlVXJsOiAnZXJyb3Itc25hY2suaHRtbCcsXG4gIHN0eWxlVXJsczogWycuL3NuYWNrLnNjc3MnXSxcbn0pXG5leHBvcnQgY2xhc3MgRXJyb3JTbmFja0NvbXBvbmVudCB7XG4gIGNvbnN0cnVjdG9yKEBJbmplY3QoTUFUX1NOQUNLX0JBUl9EQVRBKSBwdWJsaWMgZGF0YTogYW55KSB7IH1cbn1cbiJdfQ==

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

@@ -0,0 +1,25 @@
+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';
+export class SnackModule {
+}
+SnackModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [
+                    SuccessSnackComponent,
+                    ErrorSnackComponent
+                ],
+                imports: [
+                    CommonModule,
+                    MatSnackBarModule,
+                    MatIconModule
+                ],
+                exports: [
+                    SuccessSnackComponent,
+                    ErrorSnackComponent,
+                ]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic25hY2subW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LXRlY2hsaWZ5LWNvcmUvc3JjL2xpYi9jb3JlL3NuYWNrL3NuYWNrLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxtQkFBbUIsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQy9FLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUNoRSxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFpQnZELE1BQU0sT0FBTyxXQUFXOzs7WUFmdkIsUUFBUSxTQUFDO2dCQUNSLFlBQVksRUFBRTtvQkFDWixxQkFBcUI7b0JBQ3JCLG1CQUFtQjtpQkFDcEI7Z0JBQ0QsT0FBTyxFQUFFO29CQUNQLFlBQVk7b0JBQ1osaUJBQWlCO29CQUNqQixhQUFhO2lCQUNkO2dCQUNELE9BQU8sRUFBRTtvQkFDUCxxQkFBcUI7b0JBQ3JCLG1CQUFtQjtpQkFDcEI7YUFDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBTdWNjZXNzU25hY2tDb21wb25lbnQsIEVycm9yU25hY2tDb21wb25lbnQgfSBmcm9tICcuL3NuYWNrLmNvbXBvbmVudCc7XG5pbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgTWF0U25hY2tCYXJNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC9zbmFjay1iYXInO1xuaW1wb3J0IHsgTWF0SWNvbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL21hdGVyaWFsL2ljb24nO1xuXG5ATmdNb2R1bGUoe1xuICBkZWNsYXJhdGlvbnM6IFtcbiAgICBTdWNjZXNzU25hY2tDb21wb25lbnQsXG4gICAgRXJyb3JTbmFja0NvbXBvbmVudFxuICBdLFxuICBpbXBvcnRzOiBbXG4gICAgQ29tbW9uTW9kdWxlLFxuICAgIE1hdFNuYWNrQmFyTW9kdWxlLFxuICAgIE1hdEljb25Nb2R1bGVcbiAgXSxcbiAgZXhwb3J0czogW1xuICAgIFN1Y2Nlc3NTbmFja0NvbXBvbmVudCxcbiAgICBFcnJvclNuYWNrQ29tcG9uZW50LFxuICBdXG59KVxuZXhwb3J0IGNsYXNzIFNuYWNrTW9kdWxlIHsgfVxuIl19

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

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

package/esm2015/lib/core/techlify-config.model.js

@@ -0,0 +1,26 @@
+/**
+ * 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.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 === null || data === void 0 ? void 0 : data.storage;
+        this.rawConfigs = data;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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