@smartbit4all/ng-client 4.5.32 → 4.5.34

package/fesm2022/smartbit4all-ng-client.mjs

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, Injectable, Optional, Inject, PLATFORM_ID, NgModule, SkipSelf, RendererStyleFlags2, Directive, Input, HostBinding, HostListener, Component, EventEmitter, Output, ViewChildren, ViewChild, ElementRef, forwardRef, Pipe, ViewContainerRef, ViewEncapsulation, ChangeDetectionStrategy, CUSTOM_ELEMENTS_SCHEMA, NO_ERRORS_SCHEMA, inject, input, computed, effect, signal, ApplicationRef, viewChild, ChangeDetectorRef } from '@angular/core';
+import { InjectionToken, Injectable, Optional, Inject, PLATFORM_ID, NgModule, SkipSelf, RendererStyleFlags2, Directive, Input, HostBinding, HostListener, Component, EventEmitter, Output, ViewChildren, ViewChild, ElementRef, forwardRef, Pipe, ViewContainerRef, ViewEncapsulation, ChangeDetectionStrategy, CUSTOM_ELEMENTS_SCHEMA, NO_ERRORS_SCHEMA, input, computed, effect, signal, inject, ApplicationRef, viewChild, ChangeDetectorRef } from '@angular/core';
 import * as i1 from '@angular/common/http';
 import { HttpHeaders, HttpContext, HttpErrorResponse, HttpParams, HttpClientModule, HTTP_INTERCEPTORS } from '@angular/common/http';
 import { Subject, lastValueFrom, take, takeUntil, interval, startWith, map, distinctUntilChanged, catchError, throwError, from } from 'rxjs';
@@ -140,6 +140,13 @@ import { MatBadgeModule } from '@angular/material/badge';
 import * as i4$5 from '@angular/material/tabs';
 import { MatTabsModule } from '@angular/material/tabs';
 
+var SessionErrorBehaviour;
+(function (SessionErrorBehaviour) {
+    SessionErrorBehaviour[SessionErrorBehaviour["REFRESH"] = 0] = "REFRESH";
+    SessionErrorBehaviour[SessionErrorBehaviour["RESTART"] = 1] = "RESTART";
+    SessionErrorBehaviour[SessionErrorBehaviour["RESTART_VIEWCONTEXT"] = 2] = "RESTART_VIEWCONTEXT";
+})(SessionErrorBehaviour || (SessionErrorBehaviour = {}));
+
 class SmartSubject extends Subject {
     constructor(unsubscribe$) {
         super();
@@ -1041,31 +1048,60 @@ class SmartSessionService {
     }
     async doRefreshSession() {
         try {
-            let refreshToken = localStorage.getItem('refreshToken');
+            const refreshToken = localStorage.getItem('refreshToken');
             if (!refreshToken) {
-                return await this.startSession();
-            }
-            try {
-                const sessionInfo = await lastValueFrom(this.apiService.refreshSession({ refreshToken }));
-                if (sessionInfo) {
-                    this.updateSessionInfo(sessionInfo);
-                    return sessionInfo;
-                }
+                // No refresh token at all: there is no HTTP refresh round-trip that the
+                // interceptor could classify as an error, so run the session-restart
+                // handling here instead of silently starting a new session.
+                return await this.failRefresh();
             }
-            catch (error) {
-                if (this.isInvalidRefreshTokenError(error)) {
-                    await this.clearAndStartNewSession();
-                    // still throw the error, so the error can be handled in the caller
-                }
-                throw error;
+            const sessionInfo = await lastValueFrom(this.apiService.refreshSession({ refreshToken }));
+            if (!sessionInfo) {
+                // The refresh round-trip completed (HTTP 200) but yielded no session, so
+                // the interceptor never saw an error response — handle it here as well.
+                return await this.failRefresh();
             }
-            // no sessionInfo returned
-            throw new Error('Unable to refresh session');
+            this.updateSessionInfo(sessionInfo);
+            return sessionInfo;
+            // If the refresh call itself FAILS with a session error, the
+            // SmartErrorCatchingInterceptor already runs handleSessionError for that
+            // (nested) HTTP error response. We let that error propagate unchanged and
+            // must NOT handle it again here — that would invoke handleSessionError twice.
         }
         finally {
             this.runningRefresh = undefined;
         }
     }
+    /**
+     * Runs the standard session-restart handling for a refresh that finished
+     * without an error HTTP response (no refresh token, or an empty refresh
+     * result), then throws a failure shaped like the backend's rejected refresh.
+     *
+     * Only the paths that do NOT produce an error HTTP response come here: a
+     * refresh call that fails with a session error is already handled by the
+     * SmartErrorCatchingInterceptor, so routing it through here too would invoke
+     * handleSessionError a second time.
+     */
+    async failRefresh() {
+        await this.handleSessionError({
+            code: 'session.refreshtoken.invalid',
+            behaviour: SessionErrorBehaviour.RESTART,
+        });
+        throw this.createRefreshFailedError();
+    }
+    /**
+     * Builds a failure shaped exactly like the backend's rejected-refresh
+     * response (HTTP 400 + ApiError.code === 'session.refreshtoken.invalid'), so a
+     * failed/impossible refresh surfaces like any other invalid refresh token
+     * instead of producing a fresh session as a refresh side effect.
+     */
+    createRefreshFailedError() {
+        const error = {
+            code: 'session.refreshtoken.invalid',
+            message: 'Unable to refresh session',
+        };
+        return new HttpErrorResponse({ status: 400, error });
+    }
     updateSessionInfo(sessionInfo) {
         this.sessionInfoData = sessionInfo;
         this.token = sessionInfo.sid;
@@ -1079,11 +1115,6 @@ class SmartSessionService {
         this.setUpTokenForSessionService();
         this.setAuthenticationStatus();
     }
-    isInvalidRefreshTokenError(error) {
-        return (error instanceof HttpErrorResponse &&
-            error.error &&
-            error.error.code === 'session.refreshtoken.invalid');
-    }
     async getAuthenticationProviders() {
         let providers = await this.apiService
             .getAuthenticationProviders()
@@ -1584,6 +1615,51 @@ class ViewService {
             reportProgress: reportProgress
         });
     }
+    getPublishedViewData(channel, uuid, observe = 'body', reportProgress = false, options) {
+        if (channel === null || channel === undefined) {
+            throw new Error('Required parameter channel was null or undefined when calling getPublishedViewData.');
+        }
+        if (uuid === null || uuid === undefined) {
+            throw new Error('Required parameter uuid was null or undefined when calling getPublishedViewData.');
+        }
+        let localVarHeaders = this.defaultHeaders;
+        let localVarHttpHeaderAcceptSelected = options && options.httpHeaderAccept;
+        if (localVarHttpHeaderAcceptSelected === undefined) {
+            // to determine the Accept header
+            const httpHeaderAccepts = [
+                'application/json'
+            ];
+            localVarHttpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
+        }
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+        let localVarHttpContext = options && options.context;
+        if (localVarHttpContext === undefined) {
+            localVarHttpContext = new HttpContext();
+        }
+        let responseType_ = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            }
+            else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            }
+            else {
+                responseType_ = 'blob';
+            }
+        }
+        let localVarPath = `/smartlink/${this.configuration.encodeParam({ name: "channel", value: channel, in: "path", style: "simple", explode: false, dataType: "string", dataFormat: undefined })}/${this.configuration.encodeParam({ name: "uuid", value: uuid, in: "path", style: "simple", explode: false, dataType: "string", dataFormat: undefined })}`;
+        return this.httpClient.request('get', `${this.configuration.basePath}${localVarPath}`, {
+            context: localVarHttpContext,
+            responseType: responseType_,
+            withCredentials: this.configuration.withCredentials,
+            headers: localVarHeaders,
+            observe: observe,
+            reportProgress: reportProgress
+        });
+    }
     getViewConstraint(uuid, observe = 'body', reportProgress = false, options) {
         if (uuid === null || uuid === undefined) {
             throw new Error('Required parameter uuid was null or undefined when calling getViewConstraint.');
@@ -2387,6 +2463,18 @@ var NamedValidatorOperationEnum;
 })(NamedValidatorOperationEnum || (NamedValidatorOperationEnum = {}));
 ;
 
+/**
+ * View API
+ * View API
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * Contact: info@it4all.hu
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
 /**
  * View API
  * View API
@@ -13190,71 +13278,6 @@ var SmartActionType;
  * Public API Surface of smartdialog
  */
 
-var SessionErrorBehaviour;
-(function (SessionErrorBehaviour) {
-    SessionErrorBehaviour[SessionErrorBehaviour["REFRESH"] = 0] = "REFRESH";
-    SessionErrorBehaviour[SessionErrorBehaviour["RESTART"] = 1] = "RESTART";
-    SessionErrorBehaviour[SessionErrorBehaviour["RESTART_VIEWCONTEXT"] = 2] = "RESTART_VIEWCONTEXT";
-})(SessionErrorBehaviour || (SessionErrorBehaviour = {}));
-
-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() {
-        if (this.timer) {
-            clearInterval(this.timer);
-        }
-        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.timer = undefined;
-        this.startTimer();
-    }
-    timeout() {
-        clearInterval(this.timer);
-        this.timer = undefined;
-        this.onTimerExpired.next();
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartSessionTimerService, deps: [{ token: SmartSessionService }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartSessionTimerService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartSessionTimerService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: SmartSessionService }] });
-
 /**
  * Thrown by `whenReady()` when the viewcontext was rebuilt between the
  * caller's entry into `whenReady()` and the gate releasing. Any uuid the
@@ -13465,269 +13488,103 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImpo
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [{ type: SmartSessionService }, { type: SmartViewContextService }] });
 
-class SmartSessionTimerComponent {
-    constructor(service, bootstrap) {
-        this.service = service;
+class SmartErrorCatchingInterceptor {
+    constructor(session, bootstrap) {
+        this.session = session;
         this.bootstrap = bootstrap;
-        this._destroy$ = new Subject();
+        this.sessionErrorCodes = [
+            {
+                code: 'session.expired',
+                behaviour: SessionErrorBehaviour.REFRESH,
+            },
+            {
+                code: 'session.refreshtoken.invalid',
+                behaviour: SessionErrorBehaviour.RESTART,
+            },
+            {
+                code: 'session.badrequest.missingtoken',
+                behaviour: SessionErrorBehaviour.RESTART,
+            },
+            {
+                code: 'session.security.nocontext',
+                behaviour: SessionErrorBehaviour.RESTART,
+            },
+            {
+                code: 'session.invalidsessionuri',
+                behaviour: SessionErrorBehaviour.RESTART,
+            },
+            {
+                code: 'session.notinitialized',
+                behaviour: SessionErrorBehaviour.RESTART,
+            },
+            {
+                code: 'session.viewcontext.missing',
+                behaviour: SessionErrorBehaviour.RESTART_VIEWCONTEXT,
+            },
+        ];
     }
-    ngOnInit() {
-        this.bootstrap.whenReady().then(() => {
-            this.service.startTimer();
-            this.timeInSeconds = this.service.timeLeftInSeconds;
-            this.service.timeChanged.pipe(takeUntil(this._destroy$)).subscribe(() => {
-                this.timeInSeconds = this.service.timeLeftInSeconds;
+    intercept(request, next) {
+        return next
+            .handle(request)
+            .pipe(catchError$1((error) => this.handleError(error, request, next)));
+    }
+    handleError(error, request, next) {
+        if (this.isSessionError(error)) {
+            const sessionError = this.getSessionError(error);
+            if (sessionError) {
+                return this.resolveError(sessionError).pipe(switchMap((resolved) => {
+                    if (resolved && sessionError.behaviour === SessionErrorBehaviour.REFRESH) {
+                        return next.handle(this.updateRequestHeaders(request));
+                    }
+                    return throwError(() => error);
+                }), catchError$1((resolveError) => {
+                    // when the resolveError throws a restart error (in the refreshSession), rethrow the original error
+                    if (this.isSessionError(resolveError)) {
+                        const resolveSessionError = this.getSessionError(resolveError);
+                        if (resolveSessionError?.behaviour === SessionErrorBehaviour.RESTART) {
+                            return throwError(() => error);
+                        }
+                    }
+                    return throwError(() => resolveError);
+                }));
+            }
+        }
+        if (this.isTransportError(error)) {
+            // Fire-and-forget; the request still rejects so callers can react per-call.
+            this.bootstrap.handleTransportError(error).catch((err) => {
+                console.error('handleTransportError hook threw', err);
             });
-        });
+        }
+        return throwError(() => error);
     }
-    ngOnDestroy() {
-        this._destroy$.next();
-        this._destroy$.complete();
+    isSessionError(error) {
+        return error.status === 400 && error.error.code != null;
     }
-    formatTime(seconds) {
-        let minutes = Math.floor(seconds / 60);
-        let remainingSeconds = seconds % 60;
-        return `${minutes}:${remainingSeconds < 10 ? '0' : ''}${remainingSeconds}`;
+    isTransportError(error) {
+        return error.status === 0 || error.status >= 500;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartSessionTimerComponent, deps: [{ token: SmartSessionTimerService }, { token: SmartBackendBootstrapService }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.11", 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: i1$2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", 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: SmartSessionTimerService }, { type: SmartBackendBootstrapService }] });
-
-const STRINGS_HU = {
-    startErrorMessage: 'A szerver nem elérhető.',
-    startErrorRetry: 'Újrapróbálás',
-    transportErrorMessage: 'A szerver nem elérhető.',
-    transportErrorReload: 'Újratöltés',
-    sessionErrorMessage: 'A munkamenet lejárt, kérjük jelentkezzen be újra.',
-    sessionErrorAction: 'Bejelentkezés',
-};
-const STRINGS_EN = {
-    startErrorMessage: 'The server is unavailable.',
-    startErrorRetry: 'Retry',
-    transportErrorMessage: 'The server is unavailable.',
-    transportErrorReload: 'Reload',
-    sessionErrorMessage: 'Your session has expired. Please log in again.',
-    sessionErrorAction: 'Log in',
-};
-/**
- * Opt-in default UX for `SmartBackendBootstrapService` error hooks.
- *
- * Spread the result of `hooks(options)` into `bootstrap.configure()` to get a
- * MatSnackBar-based "error + retry" UI without writing the host glue:
- *
- * ```ts
- * bootstrap.configure({
- *   ...minimalConfig,
- *   ...defaultErrorUi.hooks({ language: 'hu' }),
- * });
- * ```
- *
- * Hosts that want custom logic can omit this service and write their own
- * `onStartError` / `onTransportError` callbacks directly.
- */
-class SmartDefaultErrorUiService {
-    constructor() {
-        this.snackBar = inject(MatSnackBar);
-        this.session = inject(SmartSessionService);
-    }
-    /** Returns a hooks bundle ready to spread into `bootstrap.configure()`. */
-    hooks(options = {}) {
-        return {
-            onStartError: (err) => this.showStartError(err, options),
-            onTransportError: (err) => this.showTransportError(err, options),
-            onSessionError: (err) => this.showSessionError(err, options),
-        };
-    }
-    showStartError(_err, options = {}) {
-        const s = this.resolveStrings(options);
-        const ref = this.snackBar.open(s.startErrorMessage, s.startErrorRetry, {
-            duration: 0, // sticky — app is not usable until retry succeeds
-        });
-        // Full reload, not bootstrap.start(). A bootstrap.start() retry only re-runs
-        // the init sequence; any components that already mounted during the failed
-        // attempt have rejected `whenReady()` Promises and won't re-trigger their
-        // run() when bootstrap eventually succeeds. Reload guarantees a clean mount.
-        ref.onAction().subscribe(() => this.verifyServerAndReload());
-    }
-    showTransportError(_err, options = {}) {
-        const s = this.resolveStrings(options);
-        const ref = this.snackBar.open(s.transportErrorMessage, s.transportErrorReload, {
-            duration: options.transportErrorDuration ?? 0,
-        });
-        ref.onAction().subscribe(() => this.verifyServerAndReload());
-    }
-    showSessionError(_err, options = {}) {
-        const s = this.resolveStrings(options);
-        const ref = this.snackBar.open(s.sessionErrorMessage, s.sessionErrorAction, {
-            duration: 0, // sticky — session is invalid until the user takes action
-        });
-        ref.onAction().subscribe(() => this.recoverSession());
-    }
-    /**
-     * Clears the dead session and reloads. Unlike `verifyServerAndReload`, this
-     * does NOT pre-check via `getSession()` — the SID is known to be invalid,
-     * so the check would fail. We best-effort `clearAndStartNewSession()`
-     * (creates a fresh anonymous session); reload happens regardless so the
-     * user is not stuck if the clear fails (e.g., server flapping).
-     *
-     * Overridable in tests.
-     */
-    async recoverSession() {
-        try {
-            await this.session.clearAndStartNewSession();
-        }
-        catch {
-            // Server may also be down; reload anyway and let bootstrap.start() retry.
-        }
-        this.reloadPage();
-    }
-    /**
-     * Pings `getSession()` before reloading: if the server is still down, the
-     * reload would just re-trigger the broken-screen state. The failed check
-     * goes through `SmartErrorCatchingInterceptor` and re-fires `onTransportError`,
-     * so the user sees a fresh snackbar — they get visible feedback that the
-     * server is still unreachable, without paying the cost of a full bundle
-     * reload that lands on the same broken state.
-     *
-     * Overridable in tests.
-     */
-    async verifyServerAndReload() {
-        try {
-            await this.session.getSession();
-        }
-        catch {
-            return; // server still unreachable — interceptor re-opens the snackbar
-        }
-        this.reloadPage();
-    }
-    /** Overridable in tests. */
-    reloadPage() {
-        window.location.reload();
-    }
-    resolveStrings(options) {
-        const lang = this.resolveLanguage(options.language);
-        const base = lang === 'hu' ? STRINGS_HU : STRINGS_EN;
-        return { ...base, ...(options.strings ?? {}) };
-    }
-    resolveLanguage(lang) {
-        if (lang === 'hu' || lang === 'en') {
-            return lang;
-        }
-        return navigator.language?.toLowerCase().startsWith('hu') ? 'hu' : 'en';
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartDefaultErrorUiService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartDefaultErrorUiService, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartDefaultErrorUiService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-
-/*
- * Public API Surface of smart-session
- */
-
-class SmartErrorCatchingInterceptor {
-    constructor(session, bootstrap) {
-        this.session = session;
-        this.bootstrap = bootstrap;
-        this.sessionErrorCodes = [
-            {
-                code: 'session.expired',
-                behaviour: SessionErrorBehaviour.REFRESH,
-            },
-            {
-                code: 'session.refreshtoken.invalid',
-                behaviour: SessionErrorBehaviour.RESTART,
-            },
-            {
-                code: 'session.badrequest.missingtoken',
-                behaviour: SessionErrorBehaviour.RESTART,
-            },
-            {
-                code: 'session.security.nocontext',
-                behaviour: SessionErrorBehaviour.RESTART,
-            },
-            {
-                code: 'session.invalidsessionuri',
-                behaviour: SessionErrorBehaviour.RESTART,
-            },
-            {
-                code: 'session.notinitialized',
-                behaviour: SessionErrorBehaviour.RESTART,
-            },
-            {
-                code: 'session.viewcontext.missing',
-                behaviour: SessionErrorBehaviour.RESTART_VIEWCONTEXT,
-            },
-        ];
-    }
-    intercept(request, next) {
-        return next
-            .handle(request)
-            .pipe(catchError$1((error) => this.handleError(error, request, next)));
-    }
-    handleError(error, request, next) {
-        if (this.isSessionError(error)) {
-            const sessionError = this.getSessionError(error);
-            if (sessionError) {
-                return this.resolveError(sessionError).pipe(switchMap((resolved) => {
-                    if (resolved && sessionError.behaviour === SessionErrorBehaviour.REFRESH) {
-                        return next.handle(this.updateRequestHeaders(request));
-                    }
-                    return throwError(() => error);
-                }), catchError$1((resolveError) => {
-                    // when the resolveError throws a restart error (in the refreshSession), rethrow the original error
-                    if (this.isSessionError(resolveError)) {
-                        const resolveSessionError = this.getSessionError(resolveError);
-                        if (resolveSessionError?.behaviour === SessionErrorBehaviour.RESTART) {
-                            return throwError(() => error);
-                        }
-                    }
-                    return throwError(() => resolveError);
-                }));
-            }
-        }
-        if (this.isTransportError(error)) {
-            // Fire-and-forget; the request still rejects so callers can react per-call.
-            this.bootstrap.handleTransportError(error).catch((err) => {
-                console.error('handleTransportError hook threw', err);
-            });
-        }
-        return throwError(() => error);
-    }
-    isSessionError(error) {
-        return error.status === 400 && error.error.code != null;
-    }
-    isTransportError(error) {
-        return error.status === 0 || error.status >= 500;
-    }
-    getSessionError(error) {
-        return this.sessionErrorCodes.find((sessionError) => sessionError.code === error.error.code);
-    }
-    resolveError(sessionError) {
-        if (sessionError.behaviour === SessionErrorBehaviour.RESTART) {
-            return from(this.session.handleSessionError(sessionError));
-        }
-        if (sessionError.behaviour === SessionErrorBehaviour.RESTART_VIEWCONTEXT) {
-            return from(this.bootstrap.handleViewContextLost(sessionError));
-        }
-        return from(this.session.refreshSession());
-    }
-    updateRequestHeaders(request) {
-        this.session.headerParams.forEach((headerParam) => {
-            request = request.clone({
-                headers: request.headers.set(headerParam.headerName, headerParam.value),
-            });
-        });
-        return request;
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartErrorCatchingInterceptor, deps: [{ token: SmartSessionService }, { token: SmartBackendBootstrapService }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartErrorCatchingInterceptor }); }
+    getSessionError(error) {
+        return this.sessionErrorCodes.find((sessionError) => sessionError.code === error.error.code);
+    }
+    resolveError(sessionError) {
+        if (sessionError.behaviour === SessionErrorBehaviour.RESTART) {
+            return from(this.session.handleSessionError(sessionError));
+        }
+        if (sessionError.behaviour === SessionErrorBehaviour.RESTART_VIEWCONTEXT) {
+            return from(this.bootstrap.handleViewContextLost(sessionError));
+        }
+        return from(this.session.refreshSession());
+    }
+    updateRequestHeaders(request) {
+        this.session.headerParams.forEach((headerParam) => {
+            request = request.clone({
+                headers: request.headers.set(headerParam.headerName, headerParam.value),
+            });
+        });
+        return request;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartErrorCatchingInterceptor, deps: [{ token: SmartSessionService }, { token: SmartBackendBootstrapService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartErrorCatchingInterceptor }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartErrorCatchingInterceptor, decorators: [{
             type: Injectable
@@ -13774,6 +13631,96 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImpo
             type: Injectable
         }], ctorParameters: () => [{ type: SmartSessionService }] });
 
+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() {
+        if (this.timer) {
+            clearInterval(this.timer);
+        }
+        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.timer = undefined;
+        this.startTimer();
+    }
+    timeout() {
+        clearInterval(this.timer);
+        this.timer = undefined;
+        this.onTimerExpired.next();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartSessionTimerService, deps: [{ token: SmartSessionService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartSessionTimerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartSessionTimerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: SmartSessionService }] });
+
+class SmartSessionTimerComponent {
+    constructor(service, bootstrap) {
+        this.service = service;
+        this.bootstrap = bootstrap;
+        this._destroy$ = new Subject();
+    }
+    ngOnInit() {
+        this.bootstrap.whenReady().then(() => {
+            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.3.11", ngImport: i0, type: SmartSessionTimerComponent, deps: [{ token: SmartSessionTimerService }, { token: SmartBackendBootstrapService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.11", 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: i1$2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", 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: SmartSessionTimerService }, { type: SmartBackendBootstrapService }] });
+
 class SmartSessionModule {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartSessionModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
     static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.11", ngImport: i0, type: SmartSessionModule, declarations: [SmartSessionTimerComponent], imports: [BrowserModule, MatCommonModule, MatExpansionModule, MatButtonModule, SmartIconModule], exports: [SmartSessionTimerComponent] }); }
@@ -24128,6 +24075,140 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImpo
                 args: [UiActionToolbarComponent]
             }] } });
 
+const STRINGS_HU = {
+    startErrorMessage: 'A szerver nem elérhető.',
+    startErrorRetry: 'Újrapróbálás',
+    transportErrorMessage: 'A szerver nem elérhető.',
+    transportErrorReload: 'Újratöltés',
+    sessionErrorMessage: 'A munkamenet lejárt, kérjük jelentkezzen be újra.',
+    sessionErrorAction: 'Bejelentkezés',
+};
+const STRINGS_EN = {
+    startErrorMessage: 'The server is unavailable.',
+    startErrorRetry: 'Retry',
+    transportErrorMessage: 'The server is unavailable.',
+    transportErrorReload: 'Reload',
+    sessionErrorMessage: 'Your session has expired. Please log in again.',
+    sessionErrorAction: 'Log in',
+};
+/**
+ * Opt-in default UX for `SmartBackendBootstrapService` error hooks.
+ *
+ * Spread the result of `hooks(options)` into `bootstrap.configure()` to get a
+ * MatSnackBar-based "error + retry" UI without writing the host glue:
+ *
+ * ```ts
+ * bootstrap.configure({
+ *   ...minimalConfig,
+ *   ...defaultErrorUi.hooks({ language: 'hu' }),
+ * });
+ * ```
+ *
+ * Hosts that want custom logic can omit this service and write their own
+ * `onStartError` / `onTransportError` callbacks directly.
+ */
+class SmartDefaultErrorUiService {
+    constructor() {
+        this.snackBar = inject(MatSnackBar);
+        this.session = inject(SmartSessionService);
+    }
+    /** Returns a hooks bundle ready to spread into `bootstrap.configure()`. */
+    hooks(options = {}) {
+        return {
+            onStartError: (err) => this.showStartError(err, options),
+            onTransportError: (err) => this.showTransportError(err, options),
+            onSessionError: (err) => this.showSessionError(err, options),
+        };
+    }
+    showStartError(_err, options = {}) {
+        const s = this.resolveStrings(options);
+        const ref = this.snackBar.open(s.startErrorMessage, s.startErrorRetry, {
+            duration: 0, // sticky — app is not usable until retry succeeds
+        });
+        // Full reload, not bootstrap.start(). A bootstrap.start() retry only re-runs
+        // the init sequence; any components that already mounted during the failed
+        // attempt have rejected `whenReady()` Promises and won't re-trigger their
+        // run() when bootstrap eventually succeeds. Reload guarantees a clean mount.
+        ref.onAction().subscribe(() => this.verifyServerAndReload());
+    }
+    showTransportError(_err, options = {}) {
+        const s = this.resolveStrings(options);
+        const ref = this.snackBar.open(s.transportErrorMessage, s.transportErrorReload, {
+            duration: options.transportErrorDuration ?? 0,
+        });
+        ref.onAction().subscribe(() => this.verifyServerAndReload());
+    }
+    showSessionError(_err, options = {}) {
+        const s = this.resolveStrings(options);
+        const ref = this.snackBar.open(s.sessionErrorMessage, s.sessionErrorAction, {
+            duration: 0, // sticky — session is invalid until the user takes action
+        });
+        ref.onAction().subscribe(() => this.recoverSession());
+    }
+    /**
+     * Clears the dead session and reloads. Unlike `verifyServerAndReload`, this
+     * does NOT pre-check via `getSession()` — the SID is known to be invalid,
+     * so the check would fail. We best-effort `clearAndStartNewSession()`
+     * (creates a fresh anonymous session); reload happens regardless so the
+     * user is not stuck if the clear fails (e.g., server flapping).
+     *
+     * Overridable in tests.
+     */
+    async recoverSession() {
+        try {
+            await this.session.clearAndStartNewSession();
+        }
+        catch {
+            // Server may also be down; reload anyway and let bootstrap.start() retry.
+        }
+        this.reloadPage();
+    }
+    /**
+     * Pings `getSession()` before reloading: if the server is still down, the
+     * reload would just re-trigger the broken-screen state. The failed check
+     * goes through `SmartErrorCatchingInterceptor` and re-fires `onTransportError`,
+     * so the user sees a fresh snackbar — they get visible feedback that the
+     * server is still unreachable, without paying the cost of a full bundle
+     * reload that lands on the same broken state.
+     *
+     * Overridable in tests.
+     */
+    async verifyServerAndReload() {
+        try {
+            await this.session.getSession();
+        }
+        catch {
+            return; // server still unreachable — interceptor re-opens the snackbar
+        }
+        this.reloadPage();
+    }
+    /** Overridable in tests. */
+    reloadPage() {
+        window.location.reload();
+    }
+    resolveStrings(options) {
+        const lang = this.resolveLanguage(options.language);
+        const base = lang === 'hu' ? STRINGS_HU : STRINGS_EN;
+        return { ...base, ...(options.strings ?? {}) };
+    }
+    resolveLanguage(lang) {
+        if (lang === 'hu' || lang === 'en') {
+            return lang;
+        }
+        return navigator.language?.toLowerCase().startsWith('hu') ? 'hu' : 'en';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartDefaultErrorUiService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartDefaultErrorUiService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartDefaultErrorUiService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/*
+ * Public API Surface of smart-session
+ */
+
 class SmartNavbarService {
     constructor() { }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartNavbarService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }