ngx-techlify-core 15.0.2 → 16.0.1

package/{esm2020 → esm2022}/lib/column-selector/column-selector.module.mjs

@@ -7,19 +7,19 @@ import { MatSelectModule } from '@angular/material/select';
 import { ReactiveFormsModule } from '@angular/forms';
 import * as i0 from "@angular/core";
 export class ColumnSelectorModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ColumnSelectorModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: ColumnSelectorModule, declarations: [ColumnSelectorComponent], imports: [CommonModule,
+            MatFormFieldModule,
+            MatOptionModule,
+            MatSelectModule,
+            ReactiveFormsModule], exports: [ColumnSelectorComponent] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ColumnSelectorModule, imports: [CommonModule,
+            MatFormFieldModule,
+            MatOptionModule,
+            MatSelectModule,
+            ReactiveFormsModule] });
 }
-ColumnSelectorModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ColumnSelectorModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-ColumnSelectorModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.10", ngImport: i0, type: ColumnSelectorModule, declarations: [ColumnSelectorComponent], imports: [CommonModule,
-        MatFormFieldModule,
-        MatOptionModule,
-        MatSelectModule,
-        ReactiveFormsModule], exports: [ColumnSelectorComponent] });
-ColumnSelectorModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ColumnSelectorModule, imports: [CommonModule,
-        MatFormFieldModule,
-        MatOptionModule,
-        MatSelectModule,
-        ReactiveFormsModule] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ColumnSelectorModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ColumnSelectorModule, decorators: [{
             type: NgModule,
             args: [{
                     declarations: [
@@ -37,4 +37,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
                     ]
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,39 @@
+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 {
+    snackBar;
+    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
+            });
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AlertService, deps: [{ token: i1.MatSnackBar }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AlertService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", 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/esm2022/lib/core/api-prefix.interceptor.mjs

@@ -0,0 +1,27 @@
+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 {
+    configService;
+    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);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ApiPrefixInterceptor, deps: [{ token: i1.ConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ApiPrefixInterceptor, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ApiPrefixInterceptor, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ConfigService }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBpLXByZWZpeC5pbnRlcmNlcHRvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC10ZWNobGlmeS1jb3JlL3NyYy9saWIvY29yZS9hcGktcHJlZml4LmludGVyY2VwdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7OztBQUszQzs7R0FFRztBQUlILE1BQU0sT0FBTyxvQkFBb0I7SUFFWDtJQUFwQixZQUFvQixhQUE0QjtRQUE1QixrQkFBYSxHQUFiLGFBQWEsQ0FBZTtJQUFJLENBQUM7SUFFckQsU0FBUyxDQUFDLE9BQXlCLEVBQUUsSUFBaUI7UUFDcEQsSUFBSSxDQUFDLGlCQUFpQixDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLEVBQUU7WUFDeEMsT0FBTyxHQUFHLE9BQU8sQ0FBQyxLQUFLLENBQUMsRUFBRSxHQUFHLEVBQUUsSUFBSSxDQUFDLGFBQWEsQ0FBQyxTQUFTLEVBQUUsR0FBRyxPQUFPLENBQUMsR0FBRyxFQUFFLENBQUMsQ0FBQztTQUNoRjtRQUNELE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUM5QixDQUFDO3dHQVRVLG9CQUFvQjs0R0FBcEIsb0JBQW9CLGNBRm5CLE1BQU07OzRGQUVQLG9CQUFvQjtrQkFIaEMsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBIdHRwRXZlbnQsIEh0dHBJbnRlcmNlcHRvciwgSHR0cEhhbmRsZXIsIEh0dHBSZXF1ZXN0IH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uL2h0dHAnO1xuaW1wb3J0IHsgT2JzZXJ2YWJsZSB9IGZyb20gJ3J4anMnO1xuaW1wb3J0IHsgQ29uZmlnU2VydmljZSB9IGZyb20gJy4vY29uZmlnLnNlcnZpY2UnO1xuXG4vKipcbiAqIFByZWZpeGVzIGFsbCByZXF1ZXN0cyBub3Qgc3RhcnRpbmcgd2l0aCBgaHR0cFtzXWAgd2l0aCBgZW52aXJvbm1lbnQuc2VydmVyVXJsYC5cbiAqL1xuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCdcbn0pXG5leHBvcnQgY2xhc3MgQXBpUHJlZml4SW50ZXJjZXB0b3IgaW1wbGVtZW50cyBIdHRwSW50ZXJjZXB0b3Ige1xuXG4gIGNvbnN0cnVjdG9yKHByaXZhdGUgY29uZmlnU2VydmljZTogQ29uZmlnU2VydmljZSkgeyB9XG5cbiAgaW50ZXJjZXB0KHJlcXVlc3Q6IEh0dHBSZXF1ZXN0PGFueT4sIG5leHQ6IEh0dHBIYW5kbGVyKTogT2JzZXJ2YWJsZTxIdHRwRXZlbnQ8YW55Pj4ge1xuICAgIGlmICghL14oaHR0cHxodHRwcyk6L2kudGVzdChyZXF1ZXN0LnVybCkpIHtcbiAgICAgIHJlcXVlc3QgPSByZXF1ZXN0LmNsb25lKHsgdXJsOiB0aGlzLmNvbmZpZ1NlcnZpY2UuZ2V0QXBpVXJsKCkgKyByZXF1ZXN0LnVybCB9KTtcbiAgICB9XG4gICAgcmV0dXJuIG5leHQuaGFuZGxlKHJlcXVlc3QpO1xuICB9XG59XG4iXX0=

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

@@ -0,0 +1,37 @@
+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 {
+    router;
+    credentialsService;
+    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;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AuthenticationGuard, deps: [{ token: i1.Router }, { token: i2.CredentialsService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AuthenticationGuard, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", 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/esm2022/lib/core/authentication.service.mjs

@@ -0,0 +1,65 @@
+import { Injectable } from '@angular/core';
+import { of } from 'rxjs';
+import { map, switchMap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "./credentials.service";
+import * as i2 from "./http.service";
+import * as i3 from "../user/current-user.service";
+/**
+ * Provides a base for authentication workflow.
+ * The login/logout methods should be replaced with proper implementation.
+ */
+export class AuthenticationService {
+    credentialsService;
+    http;
+    currentUserService;
+    constructor(credentialsService, http, currentUserService) {
+        this.credentialsService = credentialsService;
+        this.http = http;
+        this.currentUserService = currentUserService;
+    }
+    /**
+     * 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(switchMap((tokenInfo) => {
+            tokenInfo.expires_in = Date.now() + (tokenInfo.expires_in * 1000);
+            data.token = tokenInfo;
+            data.user = {};
+            this.credentialsService.setCredentials(data, context.remember);
+            // Update the auth status of the user.
+            this.currentUserService.updateAuthStatus(true);
+            return this.http.get('api/user/current')
+                .pipe(map((res) => {
+                data.user = res?.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() {
+        // Update the auth status of the user.
+        this.currentUserService.updateAuthStatus(false);
+        this.credentialsService.setCredentials();
+        return of(true);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AuthenticationService, deps: [{ token: i1.CredentialsService }, { token: i2.HttpService }, { token: i3.CurrentUserService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AuthenticationService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AuthenticationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.CredentialsService }, { type: i2.HttpService }, { type: i3.CurrentUserService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,59 @@
+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 {
+    httpCacheService;
+    forceUpdate = false;
+    constructor(httpCacheService) {
+        this.httpCacheService = httpCacheService;
+    }
+    /**
+     * 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());
+            }
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CacheInterceptor, deps: [{ token: i1.HttpCacheService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CacheInterceptor, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", 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/esm2022/lib/core/config.service.mjs

@@ -0,0 +1,46 @@
+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 {
+    static BASE_CREDENTIALS = "credentials";
+    config;
+    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;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ConfigService, deps: [{ token: i1.TechlifyConfig }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ConfigService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", 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/esm2022/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.`);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CoreModule, deps: [{ token: CoreModule, optional: true, skipSelf: true }], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: CoreModule, imports: [CommonModule,
+            HttpClientModule,
+            RouterModule,
+            SnackModule], exports: [SnackModule] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", 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: "16.2.12", 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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

package/esm2022/lib/core/credentials.service.mjs

@@ -0,0 +1,80 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./config.service";
+/**
+ * Provides storage for authentication credentials.
+ * The Credentials interface should be replaced with proper implementation.
+ */
+export class CredentialsService {
+    configService;
+    _credentials = null;
+    constructor(configService) {
+        this.configService = configService;
+    }
+    /**
+     * Checks is the user is authenticated.
+     * @return True if the user is authenticated.
+     */
+    get isAuthenticated() {
+        return !!this.credentials;
+    }
+    /**
+     * Gets the user credentials.
+     * @return The user credentials or null if the user is not authenticated.
+     */
+    get credentials() {
+        if (!this._credentials) {
+            this._credentials = JSON.parse(sessionStorage.getItem(this.configService.getCredentialsKey()) || localStorage.getItem(this.configService.getCredentialsKey()));
+        }
+        return this._credentials;
+    }
+    /**
+     * Sets the user credentials.
+     * The credentials may be persisted across sessions by setting the `remember` parameter to true.
+     * Otherwise, the credentials are only persisted for the current session.
+     * @param credentials The user credentials.
+     * @param remember True to remember credentials across sessions.
+     */
+    setCredentials(credentials, remember) {
+        this._credentials = credentials || null;
+        if (credentials) {
+            (remember ? localStorage : sessionStorage).setItem(this.configService.getCredentialsKey(), JSON.stringify(credentials));
+        }
+        else {
+            sessionStorage.clear();
+            localStorage.clear();
+            this._credentials = null;
+        }
+    }
+    getAccessToken() {
+        const expiration = this.credentials?.token?.expires_in || '';
+        const token = this.credentials?.token?.access_token || '';
+        if (!token || !expiration) {
+            return null;
+        }
+        if (Date.now() > parseInt(expiration)) {
+            this.setCredentials();
+            return null;
+        }
+        return token;
+    }
+    getExpiration() {
+        return this.credentials?.token?.expires_in || '';
+    }
+    getRefreshToken() {
+        return this.credentials?.token?.refresh_token || '';
+    }
+    refresh() {
+        this._credentials = null;
+        return this;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CredentialsService, deps: [{ token: i1.ConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CredentialsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: CredentialsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ConfigService }]; } });
+//# sourceMappingURL=data:application/json;base64,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