@smartbit4all/ng-client 3.3.205 → 4.0.0

package/esm2022/lib/session/smart-header-maintainer.interceptor.mjs

@@ -0,0 +1,46 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./smart-session.service";
+export class SmartHeaderMaintainerInterceptor {
+    constructor(session) {
+        this.session = session;
+    }
+    intercept(request, next) {
+        // new request data
+        let url = request.urlWithParams.replace('http://localhost', this.session.getBasePath());
+        // TODO fix me
+        if (request.urlWithParams.includes('/kerb/sso')) {
+            request = request.clone({
+                url: url,
+            });
+            return next.handle(request);
+        }
+        let headers = {};
+        // copy current headers
+        request.headers.keys().map((key) => {
+            let value = request.headers.getAll(key);
+            if (value) {
+                headers[key] = value;
+            }
+        });
+        // add own headers
+        const hasHeaders = this.session.headerParams && this.session.headerParams.length;
+        if (hasHeaders) {
+            this.session.headerParams.map((headerParam) => {
+                headers[headerParam.headerName] = headerParam.value;
+            });
+        }
+        // create new request (necessary to rewrite url)
+        request = request.clone({
+            url: url,
+            setHeaders: headers,
+        });
+        return next.handle(request);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: SmartHeaderMaintainerInterceptor, deps: [{ token: i1.SmartSessionService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: SmartHeaderMaintainerInterceptor }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: SmartHeaderMaintainerInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.SmartSessionService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/lib/session/smart-session-handler.service.mjs

@@ -1,6 +1,6 @@
-export var SessionErrorBehaviour;
-(function (SessionErrorBehaviour) {
-    SessionErrorBehaviour[SessionErrorBehaviour["REFRESH"] = 0] = "REFRESH";
-    SessionErrorBehaviour[SessionErrorBehaviour["RESTART"] = 1] = "RESTART";
-})(SessionErrorBehaviour || (SessionErrorBehaviour = {}));
+export var SessionErrorBehaviour;
+(function (SessionErrorBehaviour) {
+    SessionErrorBehaviour[SessionErrorBehaviour["REFRESH"] = 0] = "REFRESH";
+    SessionErrorBehaviour[SessionErrorBehaviour["RESTART"] = 1] = "RESTART";
+})(SessionErrorBehaviour || (SessionErrorBehaviour = {}));
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnQtc2Vzc2lvbi1oYW5kbGVyLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zbWFydC1uZy1jbGllbnQvc3JjL2xpYi9zZXNzaW9uL3NtYXJ0LXNlc3Npb24taGFuZGxlci5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQVNBLE1BQU0sQ0FBTixJQUFZLHFCQUdYO0FBSEQsV0FBWSxxQkFBcUI7SUFDN0IsdUVBQU8sQ0FBQTtJQUNQLHVFQUFPLENBQUE7QUFDWCxDQUFDLEVBSFcscUJBQXFCLEtBQXJCLHFCQUFxQixRQUdoQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgU21hcnRTZXNzaW9uSGFuZGxlclNlcnZpY2Uge1xyXG4gICAgaGFuZGxlU2Vzc2lvbkVycm9yKHNlc3Npb25FcnJvcjogU2Vzc2lvbkVycm9yKTogUHJvbWlzZTx2b2lkPjtcclxufVxyXG5cclxuZXhwb3J0IGludGVyZmFjZSBTZXNzaW9uRXJyb3Ige1xyXG4gICAgY29kZTogc3RyaW5nO1xyXG4gICAgYmVoYXZpb3VyOiBTZXNzaW9uRXJyb3JCZWhhdmlvdXI7XHJcbn1cclxuXHJcbmV4cG9ydCBlbnVtIFNlc3Npb25FcnJvckJlaGF2aW91ciB7XHJcbiAgICBSRUZSRVNILFxyXG4gICAgUkVTVEFSVCxcclxufVxyXG4iXX0=

package/esm2022/lib/session/smart-session.module.mjs

@@ -0,0 +1,58 @@
+import { HTTP_INTERCEPTORS } from '@angular/common/http';
+import { CUSTOM_ELEMENTS_SCHEMA, NgModule } from '@angular/core';
+import { MatLegacyButtonModule as MatButtonModule } from '@angular/material/legacy-button';
+import { MatCommonModule } from '@angular/material/core';
+import { MatExpansionModule } from '@angular/material/expansion';
+import { BrowserModule } from '@angular/platform-browser';
+import { SmartdialogModule } from '../smart-dialog/projects';
+import { SmartIconModule } from '../smart-icon/projects';
+import { SmartCookieService } from './cookie-service/smart-cookie.service';
+import { SmartErrorCatchingInterceptor } from './smart-error-catching.interceptor';
+import { SmartHeaderMaintainerInterceptor } from './smart-header-maintainer.interceptor';
+import { SmartSessionService } from './smart-session.service';
+import { SmartSessionTimerComponent } from './smart-timer/smart-session-timer.component';
+import * as i0 from "@angular/core";
+export class SmartSessionModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: SmartSessionModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.2.4", ngImport: i0, type: SmartSessionModule, declarations: [SmartSessionTimerComponent], imports: [BrowserModule, MatCommonModule, MatExpansionModule, MatButtonModule, SmartIconModule], exports: [SmartSessionTimerComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: SmartSessionModule, providers: [
+            SmartCookieService,
+            SmartSessionService,
+            SmartdialogModule,
+            {
+                provide: HTTP_INTERCEPTORS,
+                useClass: SmartErrorCatchingInterceptor,
+                multi: true,
+            },
+            {
+                provide: HTTP_INTERCEPTORS,
+                useClass: SmartHeaderMaintainerInterceptor,
+                multi: true,
+            },
+        ], imports: [BrowserModule, MatCommonModule, MatExpansionModule, MatButtonModule, SmartIconModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: SmartSessionModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [SmartSessionTimerComponent],
+                    imports: [BrowserModule, MatCommonModule, MatExpansionModule, MatButtonModule, SmartIconModule],
+                    exports: [SmartSessionTimerComponent],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    providers: [
+                        SmartCookieService,
+                        SmartSessionService,
+                        SmartdialogModule,
+                        {
+                            provide: HTTP_INTERCEPTORS,
+                            useClass: SmartErrorCatchingInterceptor,
+                            multi: true,
+                        },
+                        {
+                            provide: HTTP_INTERCEPTORS,
+                            useClass: SmartHeaderMaintainerInterceptor,
+                            multi: true,
+                        },
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/session/smart-session.service.mjs

@@ -0,0 +1,225 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import { SmartSubject } from '../smart-subject/projects';
+import * as i0 from "@angular/core";
+import * as i1 from "./api";
+import * as i2 from "./cookie-service/smart-cookie.service";
+export class SmartSessionService {
+    get sessionInfoData() {
+        return this._sessionInfoData;
+    }
+    set sessionInfoData(sessionInfoData) {
+        let expiracyChanged = this.sessionInfoData?.expiration !== sessionInfoData?.expiration;
+        this._sessionInfoData = sessionInfoData;
+        if (expiracyChanged) {
+            this.sessionExpiracyChanged.next();
+        }
+    }
+    constructor(apiService, cookieService) {
+        this.apiService = apiService;
+        this.cookieService = cookieService;
+        this._destroy$ = new Subject();
+        this.isAuthenticated = false;
+        this.authenticationStateChanged = new SmartSubject(this._destroy$);
+        this.headerParams = new Array();
+        this.headersUpdated = new SmartSubject(this._destroy$);
+        // Locale
+        this.localStorageLocaleName = 'locale';
+        this.localeChanged = new SmartSubject(this._destroy$);
+        this.sessionExpiracyChanged = new SmartSubject(this._destroy$);
+    }
+    ngOnDestroy() {
+        this._destroy$.next();
+        this._destroy$.complete();
+    }
+    setSessionHandlerService(smartSessionHandlerService) {
+        this.sessionHandlerService = smartSessionHandlerService;
+    }
+    async handleSessionError(sessionError) {
+        if (this.sessionHandlerService) {
+            await this.sessionHandlerService.handleSessionError(sessionError);
+        }
+        throw new Error(`sessionHandlerService was not initialized. Error: ${sessionError.code}`);
+    }
+    addHeaderParam(headerParam) {
+        if (this.headerParams.find((h) => h.headerName === headerParam.headerName)) {
+            let index = this.headerParams.findIndex((h) => h.headerName === headerParam.headerName);
+            this.headerParams[index].value = headerParam.value;
+        }
+        else {
+            this.headerParams.push(headerParam);
+        }
+        this.headersUpdated.next();
+    }
+    setUpTokenForSessionService() {
+        this.addHeaderParam({
+            headerName: 'Authorization',
+            value: `Bearer ${this.token}`,
+        });
+    }
+    setUrl(url) {
+        this.basePath = url;
+    }
+    getBasePath() {
+        if (!this.basePath) {
+            throw new Error('BasePath has not been set in SmartSessionService!');
+        }
+        return this.basePath;
+    }
+    setCookieName(name) {
+        this.cookieName = name;
+    }
+    saveTokenToLocalStorage() {
+        if (this.sessionInfoData && this.cookieName) {
+            localStorage.setItem('token', this.sessionInfoData.sid);
+            if (this.sessionInfoData.refreshToken &&
+                this.sessionInfoData.refreshToken !== localStorage.getItem('refreshToken')) {
+                localStorage.setItem('refreshToken', this.sessionInfoData.refreshToken);
+            }
+            this.cookieService.set(this.cookieName, this.token);
+        }
+    }
+    setAuthenticationStatus() {
+        if (this.sessionInfoData && this.sessionInfoData.authentications) {
+            this.isAuthenticated = this.sessionInfoData.authentications.length > 0;
+        }
+        this.authenticationStateChanged.next(this.isAuthenticated);
+    }
+    checkStatements() {
+        if (!this.basePath) {
+            throw new Error('The url of the backend api has not been set!');
+        }
+        else if (!this.cookieName) {
+            throw new Error('The name of the cookie required by the backend has not been set!');
+        }
+    }
+    async initialize() {
+        if (this.initializeRunning) {
+            return this.initializeRunning.toPromise();
+        }
+        else {
+            this.initializeRunning = new SmartSubject(this._destroy$);
+            try {
+                this.checkStatements();
+                let tokenFromLocalStorage = localStorage.getItem('token');
+                let tokenFromCookies = this.cookieService.get(this.cookieName);
+                if (tokenFromLocalStorage &&
+                    tokenFromCookies &&
+                    tokenFromLocalStorage === tokenFromCookies) {
+                    this.token = tokenFromLocalStorage;
+                    this.setUpTokenForSessionService();
+                    try {
+                        await this.getSession();
+                    }
+                    catch (err) {
+                        await this.startSession();
+                    }
+                }
+                else {
+                    await this.clearAndStartNewSession();
+                }
+                if (this.sessionInfoData && this.sessionInfoData.locale) {
+                    localStorage.setItem(this.localStorageLocaleName, this.sessionInfoData.locale);
+                    this.localeChanged.next();
+                }
+            }
+            finally {
+                this.initializeRunning.complete();
+                this.initializeRunning = undefined;
+            }
+        }
+    }
+    async startSession() {
+        let sessionInfo = await this.apiService.startSession().toPromise();
+        if (sessionInfo) {
+            this.sessionInfoData = sessionInfo;
+            this.token = sessionInfo.sid;
+            this.saveTokenToLocalStorage();
+            this.setAuthenticationStatus();
+            this.setUpTokenForSessionService();
+        }
+        return this.sessionInfoData;
+    }
+    async getSession() {
+        let sessionInfo = await this.apiService.getSession().toPromise();
+        if (sessionInfo) {
+            this.sessionInfoData = sessionInfo;
+            this.token = sessionInfo.sid;
+            this.saveTokenToLocalStorage();
+            this.setAuthenticationStatus();
+        }
+        return this.sessionInfoData;
+    }
+    async refreshSession() {
+        let refreshToken = localStorage.getItem('refreshToken');
+        if (!refreshToken) {
+            return await this.startSession();
+        }
+        let sessionInfo = await this.apiService
+            .refreshSession({
+            refreshToken,
+        })
+            .toPromise()
+            .catch(async (error) => {
+            if (error.error &&
+                error.error.code &&
+                error.error.code === 'session.refreshtoken.invalid') {
+                await this.startSession();
+            }
+        });
+        if (sessionInfo) {
+            this.sessionInfoData = sessionInfo;
+            this.token = sessionInfo.sid;
+            this.saveTokenToLocalStorage();
+            this.setAuthenticationStatus();
+            this.setUpTokenForSessionService();
+        }
+        return this.sessionInfoData;
+    }
+    async getAuthenticationProviders() {
+        let providers = await this.apiService
+            .getAuthenticationProviders()
+            .toPromise();
+        this.providers = providers?.authenticationProviders;
+        return this.providers;
+    }
+    async getIsAuthenticated() {
+        if (this.sessionInfoData) {
+            return this.isAuthenticated;
+        }
+        await this.getSession();
+        return this.isAuthenticated;
+    }
+    async clearAndStartNewSession() {
+        sessionStorage.clear();
+        localStorage.clear();
+        this.headerParams = [];
+        this.cookieService.delete(this.cookieName);
+        await this.startSession();
+    }
+    getLocale() {
+        if (this.sessionInfoData && this.sessionInfoData.locale) {
+            if (localStorage.getItem(this.localStorageLocaleName) !== this.sessionInfoData.locale) {
+                localStorage.setItem(this.localStorageLocaleName, this.sessionInfoData.locale);
+            }
+            return this.sessionInfoData.locale;
+        }
+        throw new Error('There is no SessionInfoData or locale is undefined.');
+    }
+    async changeLocale(locale) {
+        this.sessionInfoData = await this.apiService.setLocale(locale).toPromise();
+        if (this.sessionInfoData && this.sessionInfoData.locale) {
+            localStorage.setItem(this.localStorageLocaleName, this.sessionInfoData.locale);
+            this.localeChanged.next();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: SmartSessionService, deps: [{ token: i1.SessionService }, { token: i2.SmartCookieService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: SmartSessionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: SmartSessionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.SessionService }, { type: i2.SmartCookieService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smart-session.service.js","sourceRoot":"","sources":["../../../../../projects/smart-ng-client/src/lib/session/smart-session.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpErrorResponse } from '@angular/common/http';\r\nimport { Injectable, OnDestroy } from '@angular/core';\r\nimport { Subject } from 'rxjs';\r\nimport {\r\n  ApiError,\r\n  AuthenticationProviderData,\r\n  GetAuthenticationProvidersResponse,\r\n  SessionInfoData,\r\n  SessionService,\r\n} from './api';\r\nimport { SmartCookieService } from './cookie-service/smart-cookie.service';\r\nimport { SessionError, SmartSessionHandlerService } from './smart-session-handler.service';\r\nimport { SmartSubject } from '../smart-subject/projects';\r\n\r\nexport interface HeaderParam {\r\n  headerName: string;\r\n  value: string;\r\n}\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class SmartSessionService implements OnDestroy {\r\n  private basePath?: string;\r\n  private token?: string;\r\n  private _sessionInfoData?: SessionInfoData;\r\n  private _destroy$: Subject<void> = new Subject();\r\n\r\n  public get sessionInfoData(): SessionInfoData | undefined {\r\n    return this._sessionInfoData;\r\n  }\r\n  private set sessionInfoData(sessionInfoData: SessionInfoData | undefined) {\r\n    let expiracyChanged = this.sessionInfoData?.expiration !== sessionInfoData?.expiration;\r\n\r\n    this._sessionInfoData = sessionInfoData;\r\n\r\n    if (expiracyChanged) {\r\n      this.sessionExpiracyChanged.next();\r\n    }\r\n  }\r\n\r\n  private providers?: Array<AuthenticationProviderData>;\r\n  private cookieName?: string;\r\n  public isAuthenticated: boolean = false;\r\n\r\n  public authenticationStateChanged: Subject<boolean> = new SmartSubject(this._destroy$);\r\n\r\n  public headerParams: Array<HeaderParam> = new Array();\r\n  public headersUpdated: Subject<void> = new SmartSubject(this._destroy$);\r\n\r\n  // Locale\r\n  private localStorageLocaleName: string = 'locale';\r\n  public localeChanged: Subject<void> = new SmartSubject(this._destroy$);\r\n  private initializeRunning: Subject<void> | undefined;\r\n\r\n  public sessionExpiracyChanged: Subject<void> = new SmartSubject(this._destroy$);\r\n\r\n  private sessionHandlerService?: SmartSessionHandlerService;\r\n\r\n  constructor(private apiService: SessionService, private cookieService: SmartCookieService) {}\r\n\r\n  ngOnDestroy(): void {\r\n    this._destroy$.next();\r\n    this._destroy$.complete();\r\n  }\r\n\r\n  public setSessionHandlerService(smartSessionHandlerService: SmartSessionHandlerService): void {\r\n    this.sessionHandlerService = smartSessionHandlerService;\r\n  }\r\n\r\n  public async handleSessionError(sessionError: SessionError): Promise<void> {\r\n    if (this.sessionHandlerService) {\r\n      await this.sessionHandlerService.handleSessionError(sessionError);\r\n    }\r\n    throw new Error(`sessionHandlerService was not initialized. Error: ${sessionError.code}`);\r\n  }\r\n\r\n  public addHeaderParam(headerParam: HeaderParam): void {\r\n    if (this.headerParams.find((h: HeaderParam) => h.headerName === headerParam.headerName)) {\r\n      let index = this.headerParams.findIndex(\r\n        (h: HeaderParam) => h.headerName === headerParam.headerName\r\n      );\r\n      this.headerParams[index!].value = headerParam.value;\r\n    } else {\r\n      this.headerParams.push(headerParam);\r\n    }\r\n    this.headersUpdated.next();\r\n  }\r\n\r\n  private setUpTokenForSessionService(): void {\r\n    this.addHeaderParam({\r\n      headerName: 'Authorization',\r\n      value: `Bearer ${this.token!}`,\r\n    });\r\n  }\r\n\r\n  public setUrl(url: string): void {\r\n    this.basePath = url;\r\n  }\r\n  public getBasePath(): string {\r\n    if (!this.basePath) {\r\n      throw new Error('BasePath has not been set in SmartSessionService!');\r\n    }\r\n    return this.basePath;\r\n  }\r\n\r\n  public setCookieName(name: string): void {\r\n    this.cookieName = name;\r\n  }\r\n\r\n  private saveTokenToLocalStorage(): void {\r\n    if (this.sessionInfoData && this.cookieName) {\r\n      localStorage.setItem('token', this.sessionInfoData.sid);\r\n      if (\r\n        this.sessionInfoData.refreshToken &&\r\n        this.sessionInfoData.refreshToken !== localStorage.getItem('refreshToken')\r\n      ) {\r\n        localStorage.setItem('refreshToken', this.sessionInfoData.refreshToken);\r\n      }\r\n      this.cookieService.set(this.cookieName, this.token!);\r\n    }\r\n  }\r\n\r\n  private setAuthenticationStatus(): void {\r\n    if (this.sessionInfoData && this.sessionInfoData.authentications) {\r\n      this.isAuthenticated = this.sessionInfoData.authentications.length > 0;\r\n    }\r\n    this.authenticationStateChanged.next(this.isAuthenticated);\r\n  }\r\n\r\n  private checkStatements(): void {\r\n    if (!this.basePath) {\r\n      throw new Error('The url of the backend api has not been set!');\r\n    } else if (!this.cookieName) {\r\n      throw new Error('The name of the cookie required by the backend has not been set!');\r\n    }\r\n  }\r\n\r\n  public async initialize(): Promise<void> {\r\n    if (this.initializeRunning) {\r\n      return this.initializeRunning.toPromise();\r\n    } else {\r\n      this.initializeRunning = new SmartSubject(this._destroy$);\r\n      try {\r\n        this.checkStatements();\r\n\r\n        let tokenFromLocalStorage = localStorage.getItem('token');\r\n        let tokenFromCookies = this.cookieService.get(this.cookieName!);\r\n\r\n        if (\r\n          tokenFromLocalStorage &&\r\n          tokenFromCookies &&\r\n          tokenFromLocalStorage === tokenFromCookies\r\n        ) {\r\n          this.token = tokenFromLocalStorage;\r\n          this.setUpTokenForSessionService();\r\n          try {\r\n            await this.getSession();\r\n          } catch (err) {\r\n            await this.startSession();\r\n          }\r\n        } else {\r\n          await this.clearAndStartNewSession();\r\n        }\r\n        if (this.sessionInfoData && this.sessionInfoData.locale) {\r\n          localStorage.setItem(this.localStorageLocaleName, this.sessionInfoData.locale);\r\n          this.localeChanged.next();\r\n        }\r\n      } finally {\r\n        this.initializeRunning.complete();\r\n        this.initializeRunning = undefined;\r\n      }\r\n    }\r\n  }\r\n\r\n  private async startSession(): Promise<SessionInfoData> {\r\n    let sessionInfo = await this.apiService.startSession().toPromise();\r\n    if (sessionInfo) {\r\n      this.sessionInfoData = sessionInfo;\r\n      this.token = sessionInfo.sid;\r\n      this.saveTokenToLocalStorage();\r\n      this.setAuthenticationStatus();\r\n      this.setUpTokenForSessionService();\r\n    }\r\n\r\n    return this.sessionInfoData!;\r\n  }\r\n\r\n  public async getSession(): Promise<SessionInfoData> {\r\n    let sessionInfo = await this.apiService.getSession().toPromise();\r\n    if (sessionInfo) {\r\n      this.sessionInfoData = sessionInfo;\r\n      this.token = sessionInfo.sid;\r\n      this.saveTokenToLocalStorage();\r\n      this.setAuthenticationStatus();\r\n    }\r\n\r\n    return this.sessionInfoData!;\r\n  }\r\n\r\n  public async refreshSession(): Promise<SessionInfoData> {\r\n    let refreshToken = localStorage.getItem('refreshToken');\r\n    if (!refreshToken) {\r\n      return await this.startSession();\r\n    }\r\n\r\n    let sessionInfo = await this.apiService\r\n      .refreshSession({\r\n        refreshToken,\r\n      })\r\n      .toPromise()\r\n      .catch(async (error: HttpErrorResponse) => {\r\n        if (\r\n          error.error &&\r\n          (error.error as ApiError).code &&\r\n          (error.error as ApiError).code === 'session.refreshtoken.invalid'\r\n        ) {\r\n          await this.startSession();\r\n        }\r\n      });\r\n\r\n    if (sessionInfo) {\r\n      this.sessionInfoData = sessionInfo;\r\n      this.token = sessionInfo.sid;\r\n      this.saveTokenToLocalStorage();\r\n      this.setAuthenticationStatus();\r\n      this.setUpTokenForSessionService();\r\n    }\r\n\r\n    return this.sessionInfoData!;\r\n  }\r\n\r\n  public async getAuthenticationProviders(): Promise<Array<AuthenticationProviderData>> {\r\n    let providers: GetAuthenticationProvidersResponse | undefined = await this.apiService\r\n      .getAuthenticationProviders()\r\n      .toPromise();\r\n\r\n    this.providers = providers?.authenticationProviders;\r\n\r\n    return this.providers!;\r\n  }\r\n\r\n  public async getIsAuthenticated(): Promise<boolean> {\r\n    if (this.sessionInfoData) {\r\n      return this.isAuthenticated;\r\n    }\r\n    await this.getSession();\r\n    return this.isAuthenticated;\r\n  }\r\n\r\n  public async clearAndStartNewSession(): Promise<void> {\r\n    sessionStorage.clear();\r\n    localStorage.clear();\r\n    this.headerParams = [];\r\n    this.cookieService.delete(this.cookieName!);\r\n\r\n    await this.startSession();\r\n  }\r\n\r\n  public getLocale(): string {\r\n    if (this.sessionInfoData && this.sessionInfoData.locale) {\r\n      if (localStorage.getItem(this.localStorageLocaleName) !== this.sessionInfoData.locale) {\r\n        localStorage.setItem(this.localStorageLocaleName, this.sessionInfoData.locale);\r\n      }\r\n      return this.sessionInfoData.locale;\r\n    }\r\n    throw new Error('There is no SessionInfoData or locale is undefined.');\r\n  }\r\n\r\n  public async changeLocale(locale: string): Promise<void> {\r\n    this.sessionInfoData = await this.apiService.setLocale(locale).toPromise();\r\n    if (this.sessionInfoData && this.sessionInfoData.locale) {\r\n      localStorage.setItem(this.localStorageLocaleName, this.sessionInfoData.locale);\r\n      this.localeChanged.next();\r\n    }\r\n  }\r\n}\r\n"]}

package/{esm2020 → esm2022}/lib/session/smart-timer/smart-session-timer.component.mjs

@@ -1,35 +1,35 @@
-import { Component } from '@angular/core';
-import { Subject, takeUntil } from 'rxjs';
-import { SmartSessionTimerService } from './smart-session-timer.service';
-import * as i0 from "@angular/core";
-import * as i1 from "./smart-session-timer.service";
-import * as i2 from "@angular/common";
-export class SmartSessionTimerComponent {
-    constructor(service) {
-        this.service = service;
-        this._destroy$ = new Subject();
-    }
-    ngOnInit() {
-        this.service.startTimer();
-        this.timeInSeconds = this.service.timeLeftInSeconds;
-        this.service.timeChanged.pipe(takeUntil(this._destroy$)).subscribe(() => {
-            this.timeInSeconds = this.service.timeLeftInSeconds;
-        });
-    }
-    ngOnDestroy() {
-        this._destroy$.next();
-        this._destroy$.complete();
-    }
-    formatTime(seconds) {
-        let minutes = Math.floor(seconds / 60);
-        let remainingSeconds = seconds % 60;
-        return `${minutes}:${remainingSeconds < 10 ? '0' : ''}${remainingSeconds}`;
-    }
-}
-SmartSessionTimerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: SmartSessionTimerComponent, deps: [{ token: i1.SmartSessionTimerService }], target: i0.ɵɵFactoryTarget.Component });
-SmartSessionTimerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.4.0", type: SmartSessionTimerComponent, selector: "smart-session-timer", providers: [SmartSessionTimerService], ngImport: i0, template: "<div class=\"smart-session-timer-container\">\r\n    <span class=\"smart-session-timer\" *ngIf=\"timeInSeconds\">\r\n        {{ formatTime(timeInSeconds!) }}\r\n    </span>\r\n</div>\r\n", styles: [""], directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: SmartSessionTimerComponent, decorators: [{
-            type: Component,
-            args: [{ selector: 'smart-session-timer', providers: [SmartSessionTimerService], template: "<div class=\"smart-session-timer-container\">\r\n    <span class=\"smart-session-timer\" *ngIf=\"timeInSeconds\">\r\n        {{ formatTime(timeInSeconds!) }}\r\n    </span>\r\n</div>\r\n", styles: [""] }]
-        }], ctorParameters: function () { return [{ type: i1.SmartSessionTimerService }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+import { Component } from '@angular/core';
+import { Subject, takeUntil } from 'rxjs';
+import { SmartSessionTimerService } from './smart-session-timer.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./smart-session-timer.service";
+import * as i2 from "@angular/common";
+export class SmartSessionTimerComponent {
+    constructor(service) {
+        this.service = service;
+        this._destroy$ = new Subject();
+    }
+    ngOnInit() {
+        this.service.startTimer();
+        this.timeInSeconds = this.service.timeLeftInSeconds;
+        this.service.timeChanged.pipe(takeUntil(this._destroy$)).subscribe(() => {
+            this.timeInSeconds = this.service.timeLeftInSeconds;
+        });
+    }
+    ngOnDestroy() {
+        this._destroy$.next();
+        this._destroy$.complete();
+    }
+    formatTime(seconds) {
+        let minutes = Math.floor(seconds / 60);
+        let remainingSeconds = seconds % 60;
+        return `${minutes}:${remainingSeconds < 10 ? '0' : ''}${remainingSeconds}`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: SmartSessionTimerComponent, deps: [{ token: i1.SmartSessionTimerService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.2.4", type: SmartSessionTimerComponent, selector: "smart-session-timer", providers: [SmartSessionTimerService], ngImport: i0, template: "<div class=\"smart-session-timer-container\">\r\n    <span class=\"smart-session-timer\" *ngIf=\"timeInSeconds\">\r\n        {{ formatTime(timeInSeconds!) }}\r\n    </span>\r\n</div>\r\n", styles: [""], dependencies: [{ kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: SmartSessionTimerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'smart-session-timer', providers: [SmartSessionTimerService], template: "<div class=\"smart-session-timer-container\">\r\n    <span class=\"smart-session-timer\" *ngIf=\"timeInSeconds\">\r\n        {{ formatTime(timeInSeconds!) }}\r\n    </span>\r\n</div>\r\n" }]
+        }], ctorParameters: () => [{ type: i1.SmartSessionTimerService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/session/smart-timer/smart-session-timer.service.mjs

@@ -0,0 +1,58 @@
+import { Injectable } from '@angular/core';
+import { Subject, takeUntil } from 'rxjs';
+import { SmartSubject } from '../../smart-subject/projects';
+import * as i0 from "@angular/core";
+import * as i1 from "../smart-session.service";
+export class SmartSessionTimerService {
+    constructor(session) {
+        this.session = session;
+        this._destroy$ = new Subject();
+        this.totalTimeInMinutes = 30;
+        this.sessionExpiration = 'sessionExpiracy';
+        this.timeChanged = new SmartSubject(this._destroy$);
+        this.onTimerExpired = new SmartSubject(this._destroy$);
+        this.session.sessionExpiracyChanged.pipe(takeUntil(this._destroy$)).subscribe(() => {
+            this.restart();
+        });
+    }
+    ngOnDestroy() {
+        this._destroy$.next();
+        this._destroy$.complete();
+    }
+    startTimer() {
+        const sessionInfoData = this.session.sessionInfoData;
+        const lifetimeSeconds = sessionInfoData?.duration;
+        if (lifetimeSeconds && lifetimeSeconds !== 0) {
+            this.timeLeftInSeconds = lifetimeSeconds;
+        }
+        else {
+            const expiration = new Date(sessionInfoData.expiration);
+            const now = new Date();
+            this.timeLeftInSeconds = Math.floor((expiration.getTime() - now.getTime()) / 1000);
+        }
+        this.timer = setInterval(() => {
+            this.timeLeftInSeconds--;
+            if (this.timeLeftInSeconds === 0) {
+                this.timeout();
+            }
+            this.timeChanged.next();
+        }, 1000);
+    }
+    restart() {
+        clearInterval(this.timer);
+        this.startTimer();
+    }
+    timeout() {
+        clearInterval(this.timer);
+        this.onTimerExpired.next();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: SmartSessionTimerService, deps: [{ token: i1.SmartSessionService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: SmartSessionTimerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: SmartSessionTimerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.SmartSessionService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/lib/shared/projects.mjs

@@ -1,4 +1,4 @@
-export * from './shared.module';
-export * from './smart-tooltip.directive';
-export * from './smarttable.date-pipe';
+export * from './shared.module';
+export * from './smart-tooltip.directive';
+export * from './smarttable.date-pipe';
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvamVjdHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zbWFydC1uZy1jbGllbnQvc3JjL2xpYi9zaGFyZWQvcHJvamVjdHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsd0JBQXdCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3NoYXJlZC5tb2R1bGUnO1xyXG5leHBvcnQgKiBmcm9tICcuL3NtYXJ0LXRvb2x0aXAuZGlyZWN0aXZlJztcclxuZXhwb3J0ICogZnJvbSAnLi9zbWFydHRhYmxlLmRhdGUtcGlwZSc7XHJcbiJdfQ==

package/esm2022/lib/shared/shared.module.mjs

@@ -0,0 +1,19 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { SmartTooltipDirective } from './smart-tooltip.directive';
+import { SmartDatePipe, SmartDateTimePipe, SmartTimePipe } from './smarttable.date-pipe';
+import * as i0 from "@angular/core";
+export class SharedModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: SharedModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.2.4", ngImport: i0, type: SharedModule, declarations: [SmartTooltipDirective, SmartDateTimePipe, SmartDatePipe, SmartTimePipe], imports: [CommonModule], exports: [SmartTooltipDirective, SmartDateTimePipe, SmartDatePipe, SmartTimePipe] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: SharedModule, imports: [CommonModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: SharedModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [SmartTooltipDirective, SmartDateTimePipe, SmartDatePipe, SmartTimePipe],
+                    imports: [CommonModule],
+                    exports: [SmartTooltipDirective, SmartDateTimePipe, SmartDatePipe, SmartTimePipe],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2hhcmVkLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3NtYXJ0LW5nLWNsaWVudC9zcmMvbGliL3NoYXJlZC9zaGFyZWQubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBQ2xFLE9BQU8sRUFBRSxhQUFhLEVBQUUsaUJBQWlCLEVBQUUsYUFBYSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7O0FBT3pGLE1BQU0sT0FBTyxZQUFZOzhHQUFaLFlBQVk7K0dBQVosWUFBWSxpQkFKUixxQkFBcUIsRUFBRSxpQkFBaUIsRUFBRSxhQUFhLEVBQUUsYUFBYSxhQUMzRSxZQUFZLGFBQ1oscUJBQXFCLEVBQUUsaUJBQWlCLEVBQUUsYUFBYSxFQUFFLGFBQWE7K0dBRXJFLFlBQVksWUFIYixZQUFZOzsyRkFHWCxZQUFZO2tCQUx4QixRQUFRO21CQUFDO29CQUNSLFlBQVksRUFBRSxDQUFDLHFCQUFxQixFQUFFLGlCQUFpQixFQUFFLGFBQWEsRUFBRSxhQUFhLENBQUM7b0JBQ3RGLE9BQU8sRUFBRSxDQUFDLFlBQVksQ0FBQztvQkFDdkIsT0FBTyxFQUFFLENBQUMscUJBQXFCLEVBQUUsaUJBQWlCLEVBQUUsYUFBYSxFQUFFLGFBQWEsQ0FBQztpQkFDbEYiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xyXG5pbXBvcnQgeyBTbWFydFRvb2x0aXBEaXJlY3RpdmUgfSBmcm9tICcuL3NtYXJ0LXRvb2x0aXAuZGlyZWN0aXZlJztcclxuaW1wb3J0IHsgU21hcnREYXRlUGlwZSwgU21hcnREYXRlVGltZVBpcGUsIFNtYXJ0VGltZVBpcGUgfSBmcm9tICcuL3NtYXJ0dGFibGUuZGF0ZS1waXBlJztcclxuXHJcbkBOZ01vZHVsZSh7XHJcbiAgZGVjbGFyYXRpb25zOiBbU21hcnRUb29sdGlwRGlyZWN0aXZlLCBTbWFydERhdGVUaW1lUGlwZSwgU21hcnREYXRlUGlwZSwgU21hcnRUaW1lUGlwZV0sXHJcbiAgaW1wb3J0czogW0NvbW1vbk1vZHVsZV0sXHJcbiAgZXhwb3J0czogW1NtYXJ0VG9vbHRpcERpcmVjdGl2ZSwgU21hcnREYXRlVGltZVBpcGUsIFNtYXJ0RGF0ZVBpcGUsIFNtYXJ0VGltZVBpcGVdLFxyXG59KVxyXG5leHBvcnQgY2xhc3MgU2hhcmVkTW9kdWxlIHt9XHJcbiJdfQ==