ngx-techlify-core 11.5.0 → 14.2.0

package/esm2020/lib/audit-log/audit-logs-view-model/audit-logs-view-model.module.mjs

@@ -0,0 +1,32 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { AuditLogsViewModelRoutingModule } from './audit-logs-view-model-routing.module';
+import { AuditLogsViewModelComponent } from './audit-logs-view-model.component';
+import { AuditLogListModule } from '../audit-log-list/audit-log-list.module';
+import { FlexLayoutModule } from '@angular/flex-layout';
+import * as i0 from "@angular/core";
+export class AuditLogsViewModelModule {
+}
+AuditLogsViewModelModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: AuditLogsViewModelModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AuditLogsViewModelModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.2.7", ngImport: i0, type: AuditLogsViewModelModule, declarations: [AuditLogsViewModelComponent], imports: [CommonModule,
+        AuditLogsViewModelRoutingModule,
+        FlexLayoutModule,
+        AuditLogListModule], exports: [AuditLogsViewModelComponent] });
+AuditLogsViewModelModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: AuditLogsViewModelModule, imports: [CommonModule,
+        AuditLogsViewModelRoutingModule,
+        FlexLayoutModule,
+        AuditLogListModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: AuditLogsViewModelModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [AuditLogsViewModelComponent],
+                    imports: [
+                        CommonModule,
+                        AuditLogsViewModelRoutingModule,
+                        FlexLayoutModule,
+                        AuditLogListModule
+                    ],
+                    exports: [AuditLogsViewModelComponent]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2015/lib/base-model/index.js → esm2020/lib/base-model/index.mjs}

@@ -1,4 +1,4 @@
-export * from './techlify-form-component.class';
-export * from './techlify-listing-component.class';
-export * from './techlify-service.class';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtdGVjaGxpZnktY29yZS9zcmMvbGliL2Jhc2UtbW9kZWwvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxpQ0FBaUMsQ0FBQTtBQUMvQyxjQUFjLG9DQUFvQyxDQUFBO0FBQ2xELGNBQWMsMEJBQTBCLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3RlY2hsaWZ5LWZvcm0tY29tcG9uZW50LmNsYXNzJ1xuZXhwb3J0ICogZnJvbSAnLi90ZWNobGlmeS1saXN0aW5nLWNvbXBvbmVudC5jbGFzcydcbmV4cG9ydCAqIGZyb20gJy4vdGVjaGxpZnktc2VydmljZS5jbGFzcydcbiJdfQ==
+export * from './techlify-form-component.class';
+export * from './techlify-listing-component.class';
+export * from './techlify-service.class';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtdGVjaGxpZnktY29yZS9zcmMvbGliL2Jhc2UtbW9kZWwvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxpQ0FBaUMsQ0FBQTtBQUMvQyxjQUFjLG9DQUFvQyxDQUFBO0FBQ2xELGNBQWMsMEJBQTBCLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3RlY2hsaWZ5LWZvcm0tY29tcG9uZW50LmNsYXNzJ1xyXG5leHBvcnQgKiBmcm9tICcuL3RlY2hsaWZ5LWxpc3RpbmctY29tcG9uZW50LmNsYXNzJ1xyXG5leHBvcnQgKiBmcm9tICcuL3RlY2hsaWZ5LXNlcnZpY2UuY2xhc3MnXHJcbiJdfQ==

package/esm2020/lib/base-model/techlify-form-component.class.mjs

@@ -0,0 +1,49 @@
+/**
+ * Interface used to ensure we have a consistent structure across our form components
+ *
+ * It also provides some abstraction of repeated code to reduce our codebase size
+ *
+ * @todo This should be moved to ngx-techlify-core
+ *
+ * Advantages of this abstract class
+ * - Less code, less maintenance, less bugs
+ * - more consistent code
+ * - comments on more code
+ * - save time, save energy
+ */
+export class TechlifyFormComponentInterface {
+    constructor(formValidatorService) {
+        this.formValidatorService = formValidatorService;
+    }
+    /**
+     * Resets the value of a field in the HTML form
+     *
+     * @param event
+     * @param field
+     */
+    resetFieldValue(event, field) {
+        this.form?.get(field)?.setValue('');
+    }
+    /**
+     * Retrieves the value of a field from the HTML form
+     *
+     * @param field
+     * @returns
+     */
+    getFieldValue(field) {
+        return this.form?.get(field)?.value;
+    }
+    /**
+     * Method to evaluate form fields
+     * */
+    isFieldValid(field) {
+        return this.formValidatorService.isFieldValid(field, this.form, true);
+    }
+    /**
+     * Method to find error in form fields
+     * */
+    getErrorMessage(field) {
+        return this.formValidatorService.getErrorMessage(field, this.form, this.errorMessages);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/base-model/techlify-listing-component.class.mjs

@@ -0,0 +1,41 @@
+/**
+ * Interface used to ensure we have a consistent structure across our listing pages
+ *
+ * @todo This should be moved to ngx-techlify-core
+ *
+ * Advantages of this abstract class
+ * - Less code, less maintenance, less bugs
+ * - more consistent code
+ * - comments on more code
+ * - save time, save energy
+ */
+export class TechlifyListingControllerInterface {
+    constructor() {
+        this.models = [];
+        this.page = 1;
+        this.perPage = 25;
+        this.lastPage = 500;
+        this.isWorking = false;
+    }
+    /**
+     * Reload all data from page 1
+     */
+    reload() {
+        this.models = [];
+        this.page = 1;
+        if (!this.isWorking) {
+            this.loadData();
+        }
+    }
+    /**
+     * Can be called when the user is scrolling,
+     * to trigger loading a new page of data
+     */
+    onScroll() {
+        if (!this.isWorking && this.page < this.lastPage) {
+            this.page += 1;
+            this.loadData();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/base-model/techlify-service.class.mjs

@@ -0,0 +1,64 @@
+/**
+ * Interface used to ensure we have a consistent structure across our listing pages
+ *
+ * @todo This should be moved to ngx-techlify-core
+ *
+ * Advantages of this abstract class
+ * - Less code, less maintenance, less bugs
+ * - more consistent code
+ * - comments on more code
+ * - save time, save energy
+ */
+export class TechlifyServiceBaseClass {
+    constructor(http, baseUrl) {
+        this.http = http;
+        this.baseUrl = "you-forgot-to-set-a-base-url";
+        this.baseUrl = baseUrl;
+    }
+    /**
+     * Loads a set of the model this service is for
+     *
+     * @param filters Restrictors to filter the set of models
+     * @returns
+     */
+    index(filters) {
+        return this.http.get(`api/${this.baseUrl}`, { params: { ...filters } }).toPromise();
+    }
+    /**
+     * Add a new record to the database
+     *
+     * @param model The data of the model to add
+     * @returns
+     */
+    store(model) {
+        return this.http.post(`api/${this.baseUrl}`, model).toPromise();
+    }
+    /**
+     * Load a single model record, often with all relations and related data
+     *
+     * @param modelId ID of the model to load
+     * @returns
+     */
+    show(modelId) {
+        return this.http.get(`api/${this.baseUrl}/${modelId}`).toPromise();
+    }
+    /**
+     * Update fields of a single existing model
+     *
+     * @param model Model to update
+     * @returns
+     */
+    update(model) {
+        return this.http.put(`api/${this.baseUrl}/${model.id}`, model).toPromise();
+    }
+    /**
+     * Delete a single model
+     *
+     * @param model Model to delete
+     * @returns
+     */
+    delete(model) {
+        return this.http.delete(`api/${this.baseUrl}/${model.id}`).toPromise();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,38 @@
+import { Injectable } from '@angular/core';
+import { ErrorSnackComponent, SuccessSnackComponent } from './snack/snack.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/snack-bar";
+/**
+ * Service used to manage alerts in the entire system frontend
+ *
+ * @author Gokula Prasanna
+ * @since 20210131
+ */
+export class AlertService {
+    constructor(snackBar) {
+        this.snackBar = snackBar;
+    }
+    addAlert(message, alertType, duration = 3) {
+        if (alertType == "success") {
+            this.snackBar.openFromComponent(SuccessSnackComponent, {
+                duration: 1000 * duration,
+                data: message
+            });
+        }
+        else {
+            this.snackBar.openFromComponent(ErrorSnackComponent, {
+                duration: 1000 * duration,
+                data: message
+            });
+        }
+    }
+}
+AlertService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: AlertService, deps: [{ token: i1.MatSnackBar }], target: i0.ɵɵFactoryTarget.Injectable });
+AlertService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: AlertService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: AlertService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MatSnackBar }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/core/api-prefix.interceptor.mjs

@@ -0,0 +1,26 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./config.service";
+/**
+ * Prefixes all requests not starting with `http[s]` with `environment.serverUrl`.
+ */
+export class ApiPrefixInterceptor {
+    constructor(configService) {
+        this.configService = configService;
+    }
+    intercept(request, next) {
+        if (!/^(http|https):/i.test(request.url)) {
+            request = request.clone({ url: this.configService.getApiUrl() + request.url });
+        }
+        return next.handle(request);
+    }
+}
+ApiPrefixInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ApiPrefixInterceptor, deps: [{ token: i1.ConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
+ApiPrefixInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ApiPrefixInterceptor, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ApiPrefixInterceptor, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ConfigService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/core/authentication.guard.mjs

@@ -0,0 +1,35 @@
+import { Injectable } from '@angular/core';
+import { Logger } from './logger.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "./credentials.service";
+const log = new Logger('AuthenticationGuard');
+export class AuthenticationGuard {
+    constructor(router, credentialsService) {
+        this.router = router;
+        this.credentialsService = credentialsService;
+    }
+    canActivate(route, state) {
+        return this.isUserAuthenticated(route, state);
+    }
+    canLoad(route, state) {
+        return this.isUserAuthenticated(route, state);
+    }
+    isUserAuthenticated(route, state) {
+        if (this.credentialsService.isAuthenticated) {
+            return true;
+        }
+        log.debug('Not authenticated, redirecting and adding redirect url...');
+        this.router.navigate(['/login'], { queryParams: { redirect: state.url }, replaceUrl: true });
+        return false;
+    }
+}
+AuthenticationGuard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: AuthenticationGuard, deps: [{ token: i1.Router }, { token: i2.CredentialsService }], target: i0.ɵɵFactoryTarget.Injectable });
+AuthenticationGuard.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: AuthenticationGuard, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: AuthenticationGuard, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: i2.CredentialsService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,54 @@
+import { Injectable } from '@angular/core';
+import { of } from 'rxjs';
+import { concatMap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "./credentials.service";
+import * as i2 from "./http.service";
+/**
+ * Provides a base for authentication workflow.
+ * The login/logout methods should be replaced with proper implementation.
+ */
+export class AuthenticationService {
+    constructor(credentialsService, http) {
+        this.credentialsService = credentialsService;
+        this.http = http;
+    }
+    /**
+     * Authenticates the user.
+     * @param context The login parameters.
+     * @return The user credentials.
+     */
+    login(context) {
+        const data = {};
+        return this.http
+            .skipToken()
+            .post('oauth/token', context)
+            .pipe(concatMap(async (tokenInfo) => {
+            tokenInfo.expires_in = Date.now() + (tokenInfo.expires_in * 1000);
+            data.token = tokenInfo;
+            data.user = {};
+            this.credentialsService.setCredentials(data, context.remember);
+            const userInfo = await this.http.get('api/user/current').toPromise();
+            data.user = userInfo?.user;
+            this.credentialsService.setCredentials(data, context.remember);
+            return data;
+        }));
+    }
+    /**
+     * Logs out the user and clear credentials.
+     * @return True if the user was logged out successfully.
+     */
+    logout() {
+        this.credentialsService.setCredentials();
+        return of(true);
+    }
+}
+AuthenticationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: AuthenticationService, deps: [{ token: i1.CredentialsService }, { token: i2.HttpService }], target: i0.ɵɵFactoryTarget.Injectable });
+AuthenticationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: AuthenticationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: AuthenticationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.CredentialsService }, { type: i2.HttpService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,58 @@
+import { Injectable } from '@angular/core';
+import { HttpResponse } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "./http-cache.service";
+/**
+ * Caches HTTP requests.
+ * Use ExtendedHttpClient fluent API to configure caching for each request.
+ */
+export class CacheInterceptor {
+    constructor(httpCacheService) {
+        this.httpCacheService = httpCacheService;
+        this.forceUpdate = false;
+    }
+    /**
+     * Configures interceptor options
+     * @param {{update: boolean}} options If update option is enabled, forces request to be made and updates cache entry.
+     * @return {CacheInterceptor} The configured instance.
+     */
+    configure(options) {
+        const instance = new CacheInterceptor(this.httpCacheService);
+        if (options && options.update) {
+            instance.forceUpdate = true;
+        }
+        return instance;
+    }
+    intercept(request, next) {
+        if (request.method !== 'GET') {
+            return next.handle(request);
+        }
+        return new Observable((subscriber) => {
+            const cachedData = this.forceUpdate ? null : this.httpCacheService.getCacheData(request.urlWithParams);
+            if (cachedData !== null) {
+                // Create new response to avoid side-effects
+                subscriber.next(new HttpResponse(cachedData));
+                subscriber.complete();
+            }
+            else {
+                next.handle(request)
+                    .subscribe(event => {
+                    if (event instanceof HttpResponse) {
+                        this.httpCacheService.setCacheData(request.urlWithParams, event);
+                    }
+                    subscriber.next(event);
+                }, error => subscriber.error(error), () => subscriber.complete());
+            }
+        });
+    }
+}
+CacheInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: CacheInterceptor, deps: [{ token: i1.HttpCacheService }], target: i0.ɵɵFactoryTarget.Injectable });
+CacheInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: CacheInterceptor, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: CacheInterceptor, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpCacheService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,45 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./techlify-config.model";
+/**
+ * Service that provides settings for all other services
+ *
+ * @author Joshua Kissoon
+ * @since 20170709
+ */
+export class ConfigService {
+    constructor(config) {
+        this.config = config;
+    }
+    getConfigsRaw() {
+        return this.config.rawConfigs;
+    }
+    getProjectKey() {
+        return this.config.projectKey;
+    }
+    getApiUrl() {
+        return this.config.apiUrl;
+    }
+    getAuthClientSecret() {
+        return this.config.authClientSecret;
+    }
+    getStorage() {
+        return this.config.storage ? this.config.storage : localStorage;
+    }
+    getAuthGrantType() {
+        return this.config.authGrantType;
+    }
+    getCredentialsKey() {
+        return this.config.projectKey + "_" + ConfigService.BASE_CREDENTIALS;
+    }
+}
+ConfigService.BASE_CREDENTIALS = "credentials";
+ConfigService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ConfigService, deps: [{ token: i1.TechlifyConfig }], target: i0.ɵɵFactoryTarget.Injectable });
+ConfigService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ConfigService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ConfigService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TechlifyConfig }]; } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,63 @@
+import { NgModule, Optional, SkipSelf } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { HttpClientModule, HttpClient } from '@angular/common/http';
+import { RouteReuseStrategy, RouterModule } from '@angular/router';
+import { RouteReusableStrategy } from './route-reusable-strategy';
+import { HttpService } from './http.service';
+import { SnackModule } from './snack/snack.module';
+import * as i0 from "@angular/core";
+export class CoreModule {
+    constructor(parentModule) {
+        // Import guard
+        if (parentModule) {
+            throw new Error(`${parentModule} has already been loaded. Import Core module in the root module only.`);
+        }
+    }
+}
+CoreModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: CoreModule, deps: [{ token: CoreModule, optional: true, skipSelf: true }], target: i0.ɵɵFactoryTarget.NgModule });
+CoreModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.2.7", ngImport: i0, type: CoreModule, imports: [CommonModule,
+        HttpClientModule,
+        RouterModule,
+        SnackModule], exports: [SnackModule] });
+CoreModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: CoreModule, providers: [
+        {
+            provide: HttpClient,
+            useClass: HttpService
+        },
+        {
+            provide: RouteReuseStrategy,
+            useClass: RouteReusableStrategy
+        }
+    ], imports: [CommonModule,
+        HttpClientModule,
+        RouterModule,
+        SnackModule, SnackModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: CoreModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        HttpClientModule,
+                        RouterModule,
+                        SnackModule
+                    ],
+                    providers: [
+                        {
+                            provide: HttpClient,
+                            useClass: HttpService
+                        },
+                        {
+                            provide: RouteReuseStrategy,
+                            useClass: RouteReusableStrategy
+                        }
+                    ],
+                    exports: [
+                        SnackModule
+                    ]
+                }]
+        }], ctorParameters: function () { return [{ type: CoreModule, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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