@smartbit4all/ng-client 6.0.7 → 6.0.9

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';
@@ -139,6 +139,13 @@ import { MatToolbarModule } from '@angular/material/toolbar';
 import { MatBadgeModule } from '@angular/material/badge';
 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();
@@ -1040,31 +1047,60 @@ class SmartSessionService {
     }
     async doRefreshSession() {
         try {
-            let refreshToken = localStorage.getItem('refreshToken');
+            const refreshToken = localStorage.getItem('refreshToken');
             if (!refreshToken) {
-                return await this.startSession();
+                // 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();
             }
-            try {
-                const sessionInfo = await lastValueFrom(this.apiService.refreshSession({ refreshToken }));
-                if (sessionInfo) {
-                    this.updateSessionInfo(sessionInfo);
-                    return sessionInfo;
-                }
+            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();
             }
-            catch (error) {
-                if (this.isInvalidRefreshTokenError(error)) {
-                    await this.clearAndStartNewSession();
-                    // still throw the error, so the error can be handled in the caller
-                }
-                throw error;
-            }
-            // 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;
@@ -1078,11 +1114,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()
@@ -13400,71 +13431,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
@@ -13675,172 +13641,6 @@ 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;
-        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\">\n    <span class=\"smart-session-timer\" *ngIf=\"timeInSeconds\">\n        {{ formatTime(timeInSeconds!) }}\n    </span>\n</div>\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\">\n    <span class=\"smart-session-timer\" *ngIf=\"timeInSeconds\">\n        {{ formatTime(timeInSeconds!) }}\n    </span>\n</div>\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;
@@ -13984,6 +13784,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\">\n    <span class=\"smart-session-timer\" *ngIf=\"timeInSeconds\">\n        {{ formatTime(timeInSeconds!) }}\n    </span>\n</div>\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\">\n    <span class=\"smart-session-timer\" *ngIf=\"timeInSeconds\">\n        {{ formatTime(timeInSeconds!) }}\n    </span>\n</div>\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] }); }
@@ -21571,7 +21461,7 @@ class SmartComponentLayoutComponent {
             const form = this.formRef();
             if (this.smartForm && form && this.parentSmartComponent) {
                 this.parentSmartComponent.handleDataChangeSubscriptions(form);
-                this.parentSmartComponent.handleLayoutUploadCallback(form);
+                this.parentSmartComponent.handleUploadCallback(form);
                 form.markAllWidgetsForChangeDetection();
             }
         });
@@ -24237,6 +24127,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 }); }