@messaia/cdk 12.3.5-rc21 → 13.0.0-rc02

package/esm2020/lib/base/interceptors/base.interceptor.mjs

@@ -0,0 +1,138 @@
+import { HttpResponse } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { MatSnackBar } from '@angular/material/snack-bar';
+import { tap } from 'rxjs/operators';
+import { AppSetting } from '../../common/models/app-setting';
+import * as i0 from "@angular/core";
+import * as i1 from "../../common/models/app-setting";
+import * as i2 from "@angular/material/snack-bar";
+/**
+ * Pass untouched request through to the next request handler.
+ */
+export class BaseInterceptor {
+    /**
+     * Constructor
+     */
+    constructor(appSetting, snackBar) {
+        this.appSetting = appSetting;
+        this.snackBar = snackBar;
+    }
+    /**
+     * Intercept an outgoing `HttpRequest` and optionally transform it or the
+     * response.
+     *
+     * Typically an interceptor will transform the outgoing request before returning
+     * `next.handle(transformedReq)`. An interceptor may choose to transform the
+     * response event stream as well, by applying additional Rx operators on the stream
+     * returned by `next.handle()`.
+     *
+     * More rarely, an interceptor may choose to completely handle the request itself,
+     * and compose a new event stream instead of invoking `next.handle()`. This is
+     * acceptable behavior, but keep in mind further interceptors will be skipped entirely.
+     *
+     * It is also rare but valid for an interceptor to return multiple responses on the
+     * event stream for a single request.
+     */
+    intercept(req, next) {
+        /* Clone the request and set the base url */
+        const authReq = req.clone({
+            url: req.url.startsWith('http') || req.url.startsWith('./assets') ? req.url : `${this.appSetting.apiUrl}${req.url}`,
+            headers: req.method == 'GET' ? req.headers.set('CheckIn', 'Yes') : req.headers
+        });
+        /* Send cloned request with header to the next handler */
+        return next.handle(authReq).pipe(tap(
+        /* Succeeds when there is a response; ignore other events */
+        event => {
+            if (event instanceof HttpResponse) {
+                if (req.headers.get('Show-Message')) {
+                    /* Show a success message for POST requests */
+                    if (req.method == 'POST') {
+                        this.snackBar.open($localize `:@@snackbar.create.success:Data saved successfully.`, null, {
+                            duration: 3000,
+                            panelClass: ['primary']
+                        });
+                    }
+                    /* Show a success message for PUT or PATCH requests */
+                    if (['PUT', 'PATCH'].indexOf(req.method) >= 0) {
+                        this.snackBar.open($localize `:@@snackbar.update.success:Changes saved successfully.`, null, {
+                            duration: 3000,
+                            panelClass: ['primary']
+                        });
+                    }
+                    /* Show a success message for PUT or PATCH requests */
+                    if (['DELETE'].indexOf(req.method) >= 0) {
+                        this.snackBar.open($localize `:@@snackbar.delete.success:Record(s) deleted successfully.`, null, {
+                            duration: 3000,
+                            panelClass: ['primary']
+                        });
+                    }
+                    /* Show warnings from headers, if any */
+                    var warning = event.headers.get("Warning");
+                    if (warning) {
+                        this.snackBar.open(warning, "OK", { duration: 6000, panelClass: ['warn'] });
+                    }
+                }
+            }
+        }, 
+        /* Operation failed; error is an HttpErrorResponse */
+        error => {
+            /* Status: 400 - Bad Request (i.e. validation errors) */
+            if (error.status == 400) {
+                let message = this.parseErrors(error.error);
+                if (message) {
+                    this.snackBar.open(message, "OK", { duration: 8000, panelClass: ['error'] });
+                }
+            }
+            /* Status: 403 -  Not permitted */
+            if (error.status == 403) {
+                this.snackBar.open($localize `:@@snackbar.error.not-allowed:You are not allowed to perform this request.`, null, {
+                    duration: 6000,
+                    panelClass: ['error']
+                });
+            }
+            /* Status: 404 -  Bad request, show some error messages */
+            if (error.status == 404) {
+                this.snackBar.open($localize `:@@snackbar.error.not-found:The resource could not be found.`, null, {
+                    duration: 6000,
+                    panelClass: ['error']
+                });
+            }
+            /* Custom error message */
+            if (error.status == 452) {
+                this.snackBar.open(error.text(), null, { duration: 6000, panelClass: ['error'] });
+            }
+            /* Internal server error */
+            if (error.status == 500) {
+                this.snackBar.open(error.text(), null, { duration: 6000, panelClass: ['error'] });
+            }
+        }));
+    }
+    /**
+     * Parses http response errors
+     * @param error
+     */
+    parseErrors(error) {
+        let errors = [];
+        if (error) {
+            Object.keys(error).forEach(el => {
+                let err = error[el];
+                if (Array.isArray(err)) {
+                    err.forEach(err => {
+                        errors.push(err);
+                    });
+                }
+                else if (typeof err === "string") {
+                    errors.push(err);
+                }
+            });
+        }
+        return errors.join('\n');
+    }
+}
+/** @nocollapse */ /** @nocollapse */ BaseInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: BaseInterceptor, deps: [{ token: i1.AppSetting }, { token: i2.MatSnackBar }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ BaseInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: BaseInterceptor, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: BaseInterceptor, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.AppSetting }, { type: i2.MatSnackBar }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base.interceptor.js","sourceRoot":"","sources":["../../../../../../projects/cdk/src/lib/base/interceptors/base.interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpEvent, HttpHandler, HttpInterceptor, HttpRequest, HttpResponse } from '@angular/common/http';\r\nimport { Injectable } from '@angular/core';\r\nimport { MatSnackBar } from '@angular/material/snack-bar';\r\nimport { Observable } from 'rxjs';\r\nimport { tap } from 'rxjs/operators';\r\nimport { AppSetting } from '../../common/models/app-setting';\r\n\r\n/**\r\n * Pass untouched request through to the next request handler.\r\n */\r\n@Injectable({ providedIn: 'root' })\r\nexport class BaseInterceptor implements HttpInterceptor {\r\n\r\n\t/**\r\n\t * Constructor\r\n\t */\r\n\tconstructor(private appSetting: AppSetting, private snackBar: MatSnackBar) { }\r\n\r\n\t/**\r\n\t * Intercept an outgoing `HttpRequest` and optionally transform it or the\r\n\t * response.\r\n\t *\r\n\t * Typically an interceptor will transform the outgoing request before returning\r\n\t * `next.handle(transformedReq)`. An interceptor may choose to transform the\r\n\t * response event stream as well, by applying additional Rx operators on the stream\r\n\t * returned by `next.handle()`.\r\n\t *\r\n\t * More rarely, an interceptor may choose to completely handle the request itself,\r\n\t * and compose a new event stream instead of invoking `next.handle()`. This is\r\n\t * acceptable behavior, but keep in mind further interceptors will be skipped entirely.\r\n\t *\r\n\t * It is also rare but valid for an interceptor to return multiple responses on the\r\n\t * event stream for a single request.\r\n\t */\r\n\tintercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {\r\n\r\n\t\t/* Clone the request and set the base url */\r\n\t\tconst authReq = req.clone({\r\n\t\t\turl: req.url.startsWith('http') || req.url.startsWith('./assets') ? req.url : `${this.appSetting.apiUrl}${req.url}`,\r\n\t\t\theaders: req.method == 'GET' ? req.headers.set('CheckIn', 'Yes') : req.headers\r\n\t\t});\r\n\r\n\t\t/* Send cloned request with header to the next handler */\r\n\t\treturn next.handle(authReq).pipe(\r\n\t\t\ttap(\r\n\t\t\t\t/* Succeeds when there is a response; ignore other events */\r\n\t\t\t\tevent => {\r\n\t\t\t\t\tif (event instanceof HttpResponse) {\r\n\t\t\t\t\t\tif (req.headers.get('Show-Message')) {\r\n\t\t\t\t\t\t\t/* Show a success message for POST requests */\r\n\t\t\t\t\t\t\tif (req.method == 'POST') {\r\n\t\t\t\t\t\t\t\tthis.snackBar.open($localize`:@@snackbar.create.success:Data saved successfully.`, null, {\r\n\t\t\t\t\t\t\t\t\tduration: 3000,\r\n\t\t\t\t\t\t\t\t\tpanelClass: ['primary']\r\n\t\t\t\t\t\t\t\t});\r\n\t\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\t\t/* Show a success message for PUT or PATCH requests */\r\n\t\t\t\t\t\t\tif (['PUT', 'PATCH'].indexOf(req.method) >= 0) {\r\n\t\t\t\t\t\t\t\tthis.snackBar.open($localize`:@@snackbar.update.success:Changes saved successfully.`, null, {\r\n\t\t\t\t\t\t\t\t\tduration: 3000,\r\n\t\t\t\t\t\t\t\t\tpanelClass: ['primary']\r\n\t\t\t\t\t\t\t\t});\r\n\t\t\t\t\t\t\t}\r\n\r\n\r\n\t\t\t\t\t\t\t/* Show a success message for PUT or PATCH requests */\r\n\t\t\t\t\t\t\tif (['DELETE'].indexOf(req.method) >= 0) {\r\n\t\t\t\t\t\t\t\tthis.snackBar.open($localize`:@@snackbar.delete.success:Record(s) deleted successfully.`, null, {\r\n\t\t\t\t\t\t\t\t\tduration: 3000,\r\n\t\t\t\t\t\t\t\t\tpanelClass: ['primary']\r\n\t\t\t\t\t\t\t\t});\r\n\t\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\t\t/* Show warnings from headers, if any */\r\n\t\t\t\t\t\t\tvar warning = event.headers.get(\"Warning\");\r\n\t\t\t\t\t\t\tif (warning) {\r\n\t\t\t\t\t\t\t\tthis.snackBar.open(warning, \"OK\", { duration: 6000, panelClass: ['warn'] });\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t},\r\n\t\t\t\t/* Operation failed; error is an HttpErrorResponse */\r\n\t\t\t\terror => {\r\n\t\t\t\t\t/* Status: 400 - Bad Request (i.e. validation errors) */\r\n\t\t\t\t\tif (error.status == 400) {\r\n\t\t\t\t\t\tlet message = this.parseErrors(error.error);\r\n\t\t\t\t\t\tif (message) {\r\n\t\t\t\t\t\t\tthis.snackBar.open(message, \"OK\", { duration: 8000, panelClass: ['error'] })\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\t/* Status: 403 -  Not permitted */\r\n\t\t\t\t\tif (error.status == 403) {\r\n\t\t\t\t\t\tthis.snackBar.open($localize`:@@snackbar.error.not-allowed:You are not allowed to perform this request.`, null, {\r\n\t\t\t\t\t\t\tduration: 6000,\r\n\t\t\t\t\t\t\tpanelClass: ['error']\r\n\t\t\t\t\t\t});\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\t/* Status: 404 -  Bad request, show some error messages */\r\n\t\t\t\t\tif (error.status == 404) {\r\n\t\t\t\t\t\tthis.snackBar.open($localize`:@@snackbar.error.not-found:The resource could not be found.`, null, {\r\n\t\t\t\t\t\t\tduration: 6000,\r\n\t\t\t\t\t\t\tpanelClass: ['error']\r\n\t\t\t\t\t\t});\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\t/* Custom error message */\r\n\t\t\t\t\tif (error.status == 452) {\r\n\t\t\t\t\t\tthis.snackBar.open(error.text(), null, { duration: 6000, panelClass: ['error'] });\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\t/* Internal server error */\r\n\t\t\t\t\tif (error.status == 500) {\r\n\t\t\t\t\t\tthis.snackBar.open(error.text(), null, { duration: 6000, panelClass: ['error'] });\r\n\t\t\t\t\t}\r\n\t\t\t\t})\r\n\t\t);\r\n\t}\r\n\r\n\t/**\r\n\t * Parses http response errors\r\n\t * @param error \r\n\t */\r\n\tprotected parseErrors(error: Object): string {\r\n\t\tlet errors: string[] = [];\r\n\t\tif (error) {\r\n\t\t\tObject.keys(error).forEach(el => {\r\n\t\t\t\tlet err = error[el];\r\n\t\t\t\tif (Array.isArray(err)) {\r\n\t\t\t\t\terr.forEach(err => {\r\n\t\t\t\t\t\terrors.push(err);\r\n\t\t\t\t\t});\r\n\t\t\t\t} else if (typeof err === \"string\") {\r\n\t\t\t\t\terrors.push(err);\r\n\t\t\t\t}\r\n\t\t\t});\r\n\t\t}\r\n\r\n\t\treturn errors.join('\\n');\r\n\t}\r\n}"]}

package/esm2020/lib/base/interceptors/caching-interceptor.mjs

@@ -0,0 +1,68 @@
+import { HttpResponse } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { of } from 'rxjs';
+import { tap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+/**
+ * Pass untouched request through to the next request handler.
+ */
+export class CachingInterceptor {
+    /**
+     * Constructor
+     */
+    constructor() {
+        /**
+         * Cache container
+         */
+        this.cache = new Map();
+    }
+    /**
+     * Intercept an outgoing `HttpRequest` and optionally transform it or the
+     * response.
+     *
+     * Typically an interceptor will transform the outgoing request before returning
+     * `next.handle(transformedReq)`. An interceptor may choose to transform the
+     * response event stream as well, by applying additional Rx operators on the stream
+     * returned by `next.handle()`.
+     *
+     * More rarely, an interceptor may choose to completely handle the request itself,
+     * and compose a new event stream instead of invoking `next.handle()`. This is
+     * acceptable behavior, but keep in mind further interceptors will be skipped entirely.
+     *
+     * It is also rare but valid for an interceptor to return multiple responses on the
+     * event stream for a single request.
+     */
+    intercept(req, next) {
+        /* Before doing anything, it's important to only cache GET requests. */
+        if (req.method !== 'GET' || req.responseType.toLowerCase() === 'arraybuffer') {
+            this.cache.clear();
+            return next.handle(req);
+        }
+        /* First, check the cache to see if this request exists. */
+        const cachedResponse = this.cache.get(req.urlWithParams);
+        if (cachedResponse && req.headers.get('Client-Cache')) {
+            /*
+            A cached response exists. Serve it instead of forwarding
+            the request to the next handler.
+            */
+            return of(cachedResponse.clone());
+        }
+        /* No cached response exists. Go to the network, and cache the response when it arrives. */
+        return next.handle(req).pipe(tap(
+        /* Succeeds when there is a response; ignore other events */
+        event => {
+            /* Remember, there may be other events besides just the response. */
+            if (event instanceof HttpResponse && req.headers.get('Client-Cache')) {
+                /* Update the cache. */
+                this.cache.set(req.urlWithParams, event.clone());
+            }
+        }));
+    }
+}
+/** @nocollapse */ /** @nocollapse */ CachingInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: CachingInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ CachingInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: CachingInterceptor, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: CachingInterceptor, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/base/interceptors/loading.interceptor.mjs

@@ -0,0 +1,63 @@
+import { Injectable } from "@angular/core";
+import { finalize } from "rxjs/operators";
+import { LoadingScreenService } from "../services/loading-screen.service";
+import * as i0 from "@angular/core";
+import * as i1 from "../services/loading-screen.service";
+export class LoadingScreenInterceptor {
+    /**
+     * Constructor
+     * @param loadingScreenService
+     */
+    constructor(loadingScreenService) {
+        this.loadingScreenService = loadingScreenService;
+        /**
+         * activeRequests: number
+         */
+        this.activeRequests = 0;
+        /**
+         * URLs for which the loading screen should not be enabled
+         */
+        this.skippUrls = ['/authrefresh'];
+    }
+    /**
+    * Identifies and handles a given HTTP request.
+    * @param req The outgoing request object to handle.
+    * @param next The next interceptor in the chain, or the backend
+    * if no interceptors remain in the chain.
+    * @returns An observable of the event stream.
+    */
+    intercept(request, next) {
+        let displayLoadingScreen = true;
+        /* Skip loading screen for folowed urls */
+        for (const skippUrl of this.skippUrls) {
+            if (new RegExp(skippUrl).test(request.url)) {
+                displayLoadingScreen = false;
+                break;
+            }
+        }
+        if (displayLoadingScreen) {
+            if (this.activeRequests === 0) {
+                this.loadingScreenService.startLoading();
+            }
+            /* Count the active requests */
+            this.activeRequests++;
+            /* handle the request */
+            return next.handle(request).pipe(finalize(() => {
+                this.activeRequests--;
+                if (this.activeRequests === 0) {
+                    this.loadingScreenService.stopLoading();
+                }
+            }));
+        }
+        else {
+            return next.handle(request);
+        }
+    }
+    ;
+}
+/** @nocollapse */ /** @nocollapse */ LoadingScreenInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: LoadingScreenInterceptor, deps: [{ token: i1.LoadingScreenService }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ LoadingScreenInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: LoadingScreenInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: LoadingScreenInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.LoadingScreenService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/base/services/file.service.mjs

@@ -0,0 +1,18 @@
+import { Injectable } from '@angular/core';
+import { GenericService } from '../../http/services/generic.service';
+import * as i0 from "@angular/core";
+export class FileService extends GenericService {
+    /**
+     * Constructor
+     */
+    constructor() {
+        super('file');
+    }
+}
+/** @nocollapse */ /** @nocollapse */ FileService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: FileService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ FileService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: FileService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: FileService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY2RrL3NyYy9saWIvYmFzZS9zZXJ2aWNlcy9maWxlLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzQyxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0scUNBQXFDLENBQUM7O0FBR3JFLE1BQU0sT0FBTyxXQUFZLFNBQVEsY0FBbUI7SUFFbkQ7O09BRUc7SUFDSDtRQUNDLEtBQUssQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUNmLENBQUM7OzhJQVBXLFdBQVc7a0pBQVgsV0FBVyxjQURFLE1BQU07MkZBQ25CLFdBQVc7a0JBRHZCLFVBQVU7bUJBQUMsRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFFIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBHZW5lcmljU2VydmljZSB9IGZyb20gJy4uLy4uL2h0dHAvc2VydmljZXMvZ2VuZXJpYy5zZXJ2aWNlJztcclxuXHJcbkBJbmplY3RhYmxlKHsgcHJvdmlkZWRJbjogJ3Jvb3QnIH0pXHJcbmV4cG9ydCBjbGFzcyBGaWxlU2VydmljZSBleHRlbmRzIEdlbmVyaWNTZXJ2aWNlPGFueT4ge1xyXG5cclxuXHQvKipcclxuXHQgKiBDb25zdHJ1Y3RvclxyXG5cdCAqL1xyXG5cdGNvbnN0cnVjdG9yKCkge1xyXG5cdFx0c3VwZXIoJ2ZpbGUnKTtcclxuXHR9XHJcbn0iXX0=

package/esm2020/lib/base/services/loading-screen.service.mjs

@@ -0,0 +1,47 @@
+import { Injectable } from '@angular/core';
+import { Subject } from "rxjs";
+import * as i0 from "@angular/core";
+export class LoadingScreenService {
+    constructor() {
+        /**
+         * _loading: boolean
+         */
+        this._loading = false;
+        /**
+         * loadingStatus: Subject<any>
+         */
+        this.loadingStatus = new Subject();
+    }
+    /**
+     * Gets the loading
+     */
+    get loading() {
+        return this._loading;
+    }
+    /**
+     * Sets the loading
+     */
+    set loading(value) {
+        this._loading = value;
+        this.loadingStatus.next(value);
+    }
+    /**
+     * Starts the loding
+     */
+    startLoading() {
+        this.loading = true;
+    }
+    /**
+     * Stops the loading
+     */
+    stopLoading() {
+        this.loading = false;
+    }
+}
+/** @nocollapse */ /** @nocollapse */ LoadingScreenService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: LoadingScreenService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ LoadingScreenService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: LoadingScreenService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: LoadingScreenService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/base/services/print.service.mjs

@@ -0,0 +1,40 @@
+import { Injectable } from '@angular/core';
+import { Router } from '@angular/router';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+export class PrintService {
+    /**
+     * Constructor
+     * @param router
+     */
+    constructor(router) {
+        this.router = router;
+        this.isPrinting = false;
+    }
+    /**
+     * Print document
+     * @param documentName
+     * @param documentData
+     */
+    printDocument(documentName, documentData) {
+        this.isPrinting = true;
+        this.router.navigate(['/', { outlets: { 'print': ['print', documentName, documentData.join()] } }]);
+    }
+    /**
+     * On data ready
+     */
+    onDataReady() {
+        setTimeout(() => {
+            window.print();
+            this.isPrinting = false;
+            this.router.navigate([{ outlets: { print: null } }]);
+        });
+    }
+}
+/** @nocollapse */ /** @nocollapse */ PrintService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: PrintService, deps: [{ token: i1.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ PrintService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: PrintService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: PrintService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.Router }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/chips/chips.module.mjs

@@ -0,0 +1,63 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { MatAutocompleteModule } from '@angular/material/autocomplete';
+import { MatChipsModule } from '@angular/material/chips';
+import { MatIconModule } from '@angular/material/icon';
+import { MatInputModule } from '@angular/material/input';
+import { MatProgressSpinnerModule } from '@angular/material/progress-spinner';
+import { MatSelectModule } from '@angular/material/select';
+import { VdAutocompleteOptionDirective, VdChipDirective, VdChipsComponent } from './components/chips.component';
+import * as i0 from "@angular/core";
+const DECLARATIONS = [
+    VdChipsComponent,
+    VdAutocompleteOptionDirective,
+    VdChipDirective
+];
+const MATRIAL_DECLARATIONS = [
+    MatChipsModule,
+    MatIconModule,
+    MatInputModule,
+    MatSelectModule,
+    MatAutocompleteModule,
+    MatProgressSpinnerModule
+];
+export class VdChipsModule {
+}
+/** @nocollapse */ /** @nocollapse */ VdChipsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: VdChipsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ /** @nocollapse */ VdChipsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: VdChipsModule, declarations: [VdChipsComponent,
+        VdAutocompleteOptionDirective,
+        VdChipDirective], imports: [CommonModule,
+        FormsModule,
+        ReactiveFormsModule, MatChipsModule,
+        MatIconModule,
+        MatInputModule,
+        MatSelectModule,
+        MatAutocompleteModule,
+        MatProgressSpinnerModule], exports: [VdChipsComponent,
+        VdAutocompleteOptionDirective,
+        VdChipDirective] });
+/** @nocollapse */ /** @nocollapse */ VdChipsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: VdChipsModule, imports: [[
+            CommonModule,
+            FormsModule,
+            ReactiveFormsModule,
+            MATRIAL_DECLARATIONS
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.3", ngImport: i0, type: VdChipsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        FormsModule,
+                        ReactiveFormsModule,
+                        MATRIAL_DECLARATIONS
+                    ],
+                    declarations: [
+                        DECLARATIONS
+                    ],
+                    exports: [
+                        DECLARATIONS
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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