@smartbit4all/ng-client 5.0.21 → 6.0.1

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

@@ -0,0 +1,214 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./smart-session.service";
+import * as i2 from "../view-context/smart-view-context.service";
+/**
+ * Thrown by `whenReady()` when the viewcontext was rebuilt between the
+ * caller's entry into `whenReady()` and the gate releasing. Any uuid the
+ * caller resolved before entering is now stale; `SmartComponentApiClient.run()`
+ * catches this and skips the load — the component is expected to receive a
+ * fresh uuid through `uuidOfPageHasBeenChanged` (NORMAL views) or to be
+ * recreated by `openView` (EMBEDDED/DIALOG views).
+ */
+export class ViewContextRebuiltError extends Error {
+    constructor() {
+        super('ViewContextRebuilt');
+        this.name = 'ViewContextRebuiltError';
+    }
+}
+export class SmartBackendBootstrapService {
+    constructor(session, viewContext) {
+        this.session = session;
+        this.viewContext = viewContext;
+        this.lastInitFailed = false;
+    }
+    configure(config) {
+        if (this.config) {
+            console.warn('SmartBackendBootstrapService already configured; ignoring duplicate configure() call.');
+            return;
+        }
+        this.config = config;
+        this.session.setUrl(config.url);
+        this.session.setCookieName(config.cookieName);
+        this.session.setSessionHandlerService(this);
+        this.viewContext.setViewHandlers(config.viewHandlers);
+        this.viewContext.setMessageDialogName(config.messageDialogName ?? 'message-dialog');
+        this.viewContext.setActionDescriptors(config.actionDescriptors);
+        this.viewContext.openSmartLink.subscribe((channel) => {
+            this.handleSmartLink(channel);
+        });
+    }
+    async handleSmartLink(channel) {
+        if (this.config?.onSmartLink) {
+            await this.config.onSmartLink(channel);
+            return;
+        }
+        // Default: simply unblock showPublishedView's `await openSmartLink.toPromise()`.
+        // The viewContext is already initialized by start()/bootstrapWith() — calling
+        // initialize() here without a uuid would always trigger startViewContext(),
+        // creating a second viewcontext and producing duplicate UI (e.g. two login pages).
+        this.viewContext.openSmartLink.complete();
+    }
+    start() {
+        if (!this.config) {
+            return Promise.reject(new Error('SmartBackendBootstrapService.configure() must be called before start().'));
+        }
+        if (this.mode === 'bootstrapWith' && !this.lastInitFailed) {
+            return Promise.reject(new Error('SmartBackendBootstrapService.bootstrapWith() was already called; start() is mutually exclusive with it. Call reset() first to switch entry points.'));
+        }
+        if (this.runningInit && !this.lastInitFailed) {
+            return this.runningInit;
+        }
+        this.mode = 'start';
+        this.lastInitFailed = false;
+        this.runningInit = this.runInit();
+        return this.runningInit;
+    }
+    bootstrapWith(creds) {
+        if (!this.config) {
+            return Promise.reject(new Error('SmartBackendBootstrapService.configure() must be called before bootstrapWith().'));
+        }
+        if (this.mode === 'start' && !this.lastInitFailed) {
+            return Promise.reject(new Error('SmartBackendBootstrapService.start() was already called; bootstrapWith() is mutually exclusive with it. Call reset() first to switch entry points.'));
+        }
+        if (this.runningInit && !this.lastInitFailed) {
+            return this.runningInit;
+        }
+        this.mode = 'bootstrapWith';
+        this.lastInitFailed = false;
+        this.runningInit = this.runBootstrapWith(creds);
+        return this.runningInit;
+    }
+    async whenReady() {
+        if (!this.runningInit) {
+            throw new Error('BootstrapNotStarted');
+        }
+        await this.runningInit;
+        const generationBefore = this.viewContext.getGeneration();
+        // Gate on any in-flight session/viewcontext recovery so a component's
+        // BFF call cannot race against the session being torn down and rebuilt.
+        // The loop handles cascading recoveries (e.g. vc-lost surfaces during
+        // a session restart): each settle clears its own latch in finally, and
+        // the next iteration picks up whatever started in the meantime.
+        while (this.runningViewContextLost || this.runningSessionError) {
+            await this.runningViewContextLost;
+            await this.runningSessionError;
+        }
+        if (this.viewContext.getGeneration() !== generationBefore) {
+            throw new ViewContextRebuiltError();
+        }
+    }
+    async reset() {
+        this.runningInit = undefined;
+        this.lastInitFailed = false;
+        this.mode = undefined;
+        this.runningViewContextLost = undefined;
+        this.runningSessionError = undefined;
+        return this.start();
+    }
+    /**
+     * Called by `SmartErrorCatchingInterceptor` when the backend reports
+     * `session.viewcontext.missing`. Idempotent across concurrent and
+     * sequential calls until the next `reset()` — multiple racing BFF
+     * failures collapse into a single recovery attempt.
+     */
+    handleViewContextLost(err) {
+        if (!this.config) {
+            return Promise.reject(new Error('SmartBackendBootstrapService.configure() must be called before handleViewContextLost().'));
+        }
+        if (this.runningViewContextLost) {
+            return this.runningViewContextLost;
+        }
+        this.runningViewContextLost = this.runViewContextLost(err);
+        return this.runningViewContextLost;
+    }
+    async runViewContextLost(err) {
+        try {
+            if (this.config?.onViewContextLost) {
+                await this.config.onViewContextLost(err);
+                return;
+            }
+            await this.viewContext.initNewViewContext();
+        }
+        finally {
+            this.runningViewContextLost = undefined;
+        }
+    }
+    /**
+     * Called by `SmartErrorCatchingInterceptor` for transport-level failures
+     * (status 0, 5xx). Fire-and-forget; the request still rejects with the
+     * original error so callers can do per-call handling.
+     */
+    async handleTransportError(err) {
+        if (!this.config) {
+            return Promise.reject(new Error('SmartBackendBootstrapService.configure() must be called before handleTransportError().'));
+        }
+        if (this.config.onTransportError) {
+            await this.config.onTransportError(err);
+            return;
+        }
+        console.warn('Transport error — server unreachable or 5xx', err);
+    }
+    async runInit() {
+        try {
+            await this.session.initialize();
+            await this.viewContext.initViewContext();
+        }
+        catch (err) {
+            await this.handleInitFailure(err);
+            throw err;
+        }
+    }
+    async runBootstrapWith(creds) {
+        try {
+            this.session.setSessionToken(creds.sessionToken, creds.refreshToken);
+            await this.viewContext.initFromExistingViewContext(creds.viewContextUuid);
+        }
+        catch (err) {
+            await this.handleInitFailure(err);
+            throw err;
+        }
+    }
+    async handleInitFailure(err) {
+        this.lastInitFailed = true;
+        if (this.config?.onStartError) {
+            try {
+                await this.config.onStartError(err);
+            }
+            catch (callbackErr) {
+                console.error('SmartBackendBootstrapService.onStartError callback threw', callbackErr);
+            }
+        }
+    }
+    handleSessionError(err) {
+        if (!this.config) {
+            return Promise.reject(new Error('SmartBackendBootstrapService.configure() must be called before handleSessionError().'));
+        }
+        if (this.runningSessionError) {
+            return this.runningSessionError;
+        }
+        this.runningSessionError = this.runSessionError(err);
+        return this.runningSessionError;
+    }
+    async runSessionError(err) {
+        try {
+            if (this.config?.onSessionError) {
+                await this.config.onSessionError(err);
+                return;
+            }
+            // Default: clear the session and let the backend rebuild via RESTART_VIEWCONTEXT.
+            // No router navigation here — the new viewcontext drives navigation server-side.
+            await this.session.clearAndStartNewSession();
+        }
+        finally {
+            this.runningSessionError = undefined;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartBackendBootstrapService, deps: [{ token: i1.SmartSessionService }, { token: i2.SmartViewContextService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartBackendBootstrapService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartBackendBootstrapService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.SmartSessionService }, { type: i2.SmartViewContextService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smart-backend-bootstrap.service.js","sourceRoot":"","sources":["../../../../../projects/smart-ng-client/src/lib/session/smart-backend-bootstrap.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpErrorResponse } from '@angular/common/http';\nimport { Injectable } from '@angular/core';\nimport { SmartSessionService } from './smart-session.service';\nimport { SmartViewContextService } from '../view-context/smart-view-context.service';\nimport { SessionError, SmartSessionHandlerService } from './smart-session-handler.service';\nimport {\n  SmartBackendBootstrapConfig,\n  SmartBackendBootstrapCredentials,\n} from './smart-backend-bootstrap.config';\n\ntype BootstrapMode = 'start' | 'bootstrapWith';\n\n/**\n * Thrown by `whenReady()` when the viewcontext was rebuilt between the\n * caller's entry into `whenReady()` and the gate releasing. Any uuid the\n * caller resolved before entering is now stale; `SmartComponentApiClient.run()`\n * catches this and skips the load — the component is expected to receive a\n * fresh uuid through `uuidOfPageHasBeenChanged` (NORMAL views) or to be\n * recreated by `openView` (EMBEDDED/DIALOG views).\n */\nexport class ViewContextRebuiltError extends Error {\n  constructor() {\n    super('ViewContextRebuilt');\n    this.name = 'ViewContextRebuiltError';\n  }\n}\n\n@Injectable({ providedIn: 'root' })\nexport class SmartBackendBootstrapService implements SmartSessionHandlerService {\n  private config?: SmartBackendBootstrapConfig;\n  private runningInit?: Promise<void>;\n  private lastInitFailed = false;\n  private mode?: BootstrapMode;\n  private runningViewContextLost?: Promise<void>;\n  private runningSessionError?: Promise<void>;\n\n  constructor(\n    private session: SmartSessionService,\n    private viewContext: SmartViewContextService,\n  ) {}\n\n  configure(config: SmartBackendBootstrapConfig): void {\n    if (this.config) {\n      console.warn('SmartBackendBootstrapService already configured; ignoring duplicate configure() call.');\n      return;\n    }\n    this.config = config;\n\n    this.session.setUrl(config.url);\n    this.session.setCookieName(config.cookieName);\n    this.session.setSessionHandlerService(this);\n\n    this.viewContext.setViewHandlers(config.viewHandlers);\n    this.viewContext.setMessageDialogName(config.messageDialogName ?? 'message-dialog');\n    this.viewContext.setActionDescriptors(config.actionDescriptors);\n\n    this.viewContext.openSmartLink.subscribe((channel: string) => {\n      this.handleSmartLink(channel);\n    });\n  }\n\n  private async handleSmartLink(channel: string): Promise<void> {\n    if (this.config?.onSmartLink) {\n      await this.config.onSmartLink(channel);\n      return;\n    }\n    // Default: simply unblock showPublishedView's `await openSmartLink.toPromise()`.\n    // The viewContext is already initialized by start()/bootstrapWith() — calling\n    // initialize() here without a uuid would always trigger startViewContext(),\n    // creating a second viewcontext and producing duplicate UI (e.g. two login pages).\n    this.viewContext.openSmartLink.complete();\n  }\n\n  start(): Promise<void> {\n    if (!this.config) {\n      return Promise.reject(new Error('SmartBackendBootstrapService.configure() must be called before start().'));\n    }\n    if (this.mode === 'bootstrapWith' && !this.lastInitFailed) {\n      return Promise.reject(new Error(\n        'SmartBackendBootstrapService.bootstrapWith() was already called; start() is mutually exclusive with it. Call reset() first to switch entry points.',\n      ));\n    }\n    if (this.runningInit && !this.lastInitFailed) {\n      return this.runningInit;\n    }\n    this.mode = 'start';\n    this.lastInitFailed = false;\n    this.runningInit = this.runInit();\n    return this.runningInit;\n  }\n\n  bootstrapWith(creds: SmartBackendBootstrapCredentials): Promise<void> {\n    if (!this.config) {\n      return Promise.reject(new Error('SmartBackendBootstrapService.configure() must be called before bootstrapWith().'));\n    }\n    if (this.mode === 'start' && !this.lastInitFailed) {\n      return Promise.reject(new Error(\n        'SmartBackendBootstrapService.start() was already called; bootstrapWith() is mutually exclusive with it. Call reset() first to switch entry points.',\n      ));\n    }\n    if (this.runningInit && !this.lastInitFailed) {\n      return this.runningInit;\n    }\n    this.mode = 'bootstrapWith';\n    this.lastInitFailed = false;\n    this.runningInit = this.runBootstrapWith(creds);\n    return this.runningInit;\n  }\n\n  async whenReady(): Promise<void> {\n    if (!this.runningInit) {\n      throw new Error('BootstrapNotStarted');\n    }\n    await this.runningInit;\n    const generationBefore = this.viewContext.getGeneration();\n    // Gate on any in-flight session/viewcontext recovery so a component's\n    // BFF call cannot race against the session being torn down and rebuilt.\n    // The loop handles cascading recoveries (e.g. vc-lost surfaces during\n    // a session restart): each settle clears its own latch in finally, and\n    // the next iteration picks up whatever started in the meantime.\n    while (this.runningViewContextLost || this.runningSessionError) {\n      await this.runningViewContextLost;\n      await this.runningSessionError;\n    }\n    if (this.viewContext.getGeneration() !== generationBefore) {\n      throw new ViewContextRebuiltError();\n    }\n  }\n\n  async reset(): Promise<void> {\n    this.runningInit = undefined;\n    this.lastInitFailed = false;\n    this.mode = undefined;\n    this.runningViewContextLost = undefined;\n    this.runningSessionError = undefined;\n    return this.start();\n  }\n\n  /**\n   * Called by `SmartErrorCatchingInterceptor` when the backend reports\n   * `session.viewcontext.missing`. Idempotent across concurrent and\n   * sequential calls until the next `reset()` — multiple racing BFF\n   * failures collapse into a single recovery attempt.\n   */\n  handleViewContextLost(err: SessionError): Promise<void> {\n    if (!this.config) {\n      return Promise.reject(new Error(\n        'SmartBackendBootstrapService.configure() must be called before handleViewContextLost().',\n      ));\n    }\n    if (this.runningViewContextLost) {\n      return this.runningViewContextLost;\n    }\n    this.runningViewContextLost = this.runViewContextLost(err);\n    return this.runningViewContextLost;\n  }\n\n  private async runViewContextLost(err: SessionError): Promise<void> {\n    try {\n      if (this.config?.onViewContextLost) {\n        await this.config.onViewContextLost(err);\n        return;\n      }\n      await this.viewContext.initNewViewContext();\n    } finally {\n      this.runningViewContextLost = undefined;\n    }\n  }\n\n  /**\n   * Called by `SmartErrorCatchingInterceptor` for transport-level failures\n   * (status 0, 5xx). Fire-and-forget; the request still rejects with the\n   * original error so callers can do per-call handling.\n   */\n  async handleTransportError(err: HttpErrorResponse): Promise<void> {\n    if (!this.config) {\n      return Promise.reject(new Error(\n        'SmartBackendBootstrapService.configure() must be called before handleTransportError().',\n      ));\n    }\n    if (this.config.onTransportError) {\n      await this.config.onTransportError(err);\n      return;\n    }\n    console.warn('Transport error — server unreachable or 5xx', err);\n  }\n\n  private async runInit(): Promise<void> {\n    try {\n      await this.session.initialize();\n      await this.viewContext.initViewContext();\n    } catch (err) {\n      await this.handleInitFailure(err);\n      throw err;\n    }\n  }\n\n  private async runBootstrapWith(creds: SmartBackendBootstrapCredentials): Promise<void> {\n    try {\n      this.session.setSessionToken(creds.sessionToken, creds.refreshToken);\n      await this.viewContext.initFromExistingViewContext(creds.viewContextUuid);\n    } catch (err) {\n      await this.handleInitFailure(err);\n      throw err;\n    }\n  }\n\n  private async handleInitFailure(err: unknown): Promise<void> {\n    this.lastInitFailed = true;\n    if (this.config?.onStartError) {\n      try {\n        await this.config.onStartError(err);\n      } catch (callbackErr) {\n        console.error('SmartBackendBootstrapService.onStartError callback threw', callbackErr);\n      }\n    }\n  }\n\n  handleSessionError(err: SessionError): Promise<void> {\n    if (!this.config) {\n      return Promise.reject(new Error(\n        'SmartBackendBootstrapService.configure() must be called before handleSessionError().',\n      ));\n    }\n    if (this.runningSessionError) {\n      return this.runningSessionError;\n    }\n    this.runningSessionError = this.runSessionError(err);\n    return this.runningSessionError;\n  }\n\n  private async runSessionError(err: SessionError): Promise<void> {\n    try {\n      if (this.config?.onSessionError) {\n        await this.config.onSessionError(err);\n        return;\n      }\n      // Default: clear the session and let the backend rebuild via RESTART_VIEWCONTEXT.\n      // No router navigation here — the new viewcontext drives navigation server-side.\n      await this.session.clearAndStartNewSession();\n    } finally {\n      this.runningSessionError = undefined;\n    }\n  }\n}\n"]}

package/esm2022/lib/session/smart-default-error-ui.service.mjs

@@ -0,0 +1,134 @@
+import { Injectable, inject } from '@angular/core';
+import { MatSnackBar } from '@angular/material/snack-bar';
+import { SmartSessionService } from './smart-session.service';
+import * as i0 from "@angular/core";
+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.
+ */
+export 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' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smart-default-error-ui.service.js","sourceRoot":"","sources":["../../../../../projects/smart-ng-client/src/lib/session/smart-default-error-ui.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpErrorResponse } from '@angular/common/http';\nimport { Injectable, inject } from '@angular/core';\nimport { MatSnackBar } from '@angular/material/snack-bar';\nimport { SessionError } from './smart-session-handler.service';\nimport { SmartSessionService } from './smart-session.service';\n\nexport type DefaultErrorUiLanguage = 'hu' | 'en' | 'auto';\n\nexport interface DefaultErrorUiStrings {\n  startErrorMessage: string;\n  startErrorRetry: string;\n  transportErrorMessage: string;\n  transportErrorReload: string;\n  sessionErrorMessage: string;\n  sessionErrorAction: string;\n}\n\nexport interface DefaultErrorUiOptions {\n  /** 'auto' (default) picks 'hu' if navigator.language starts with 'hu', else 'en'. */\n  language?: DefaultErrorUiLanguage;\n  /** Override individual strings; missing keys fall back to the language default. */\n  strings?: Partial<DefaultErrorUiStrings>;\n  /**\n   * Snackbar auto-dismiss in ms for transportError. Default: 0 (sticky).\n   *\n   * Sticky default rationale: a transport error commonly leaves the screen in\n   * an inconsistent state (failed component loads, stuck spinners) that does\n   * NOT self-recover when the server returns. An auto-dismissing snackbar\n   * would hide the notification before the user can act, leaving them with a\n   * broken UI and no way back. Sticky forces the Reload action.\n   *\n   * Set a positive number to opt into auto-dismiss (e.g. mobile-shell flows\n   * where the shell tears down the webview on transport error anyway).\n   *\n   * `startError` is always sticky regardless — the app is unusable until the\n   * user retries.\n   */\n  transportErrorDuration?: number;\n}\n\nconst STRINGS_HU: DefaultErrorUiStrings = {\n  startErrorMessage: 'A szerver nem elérhető.',\n  startErrorRetry: 'Újrapróbálás',\n  transportErrorMessage: 'A szerver nem elérhető.',\n  transportErrorReload: 'Újratöltés',\n  sessionErrorMessage: 'A munkamenet lejárt, kérjük jelentkezzen be újra.',\n  sessionErrorAction: 'Bejelentkezés',\n};\n\nconst STRINGS_EN: DefaultErrorUiStrings = {\n  startErrorMessage: 'The server is unavailable.',\n  startErrorRetry: 'Retry',\n  transportErrorMessage: 'The server is unavailable.',\n  transportErrorReload: 'Reload',\n  sessionErrorMessage: 'Your session has expired. Please log in again.',\n  sessionErrorAction: 'Log in',\n};\n\n/**\n * Opt-in default UX for `SmartBackendBootstrapService` error hooks.\n *\n * Spread the result of `hooks(options)` into `bootstrap.configure()` to get a\n * MatSnackBar-based \"error + retry\" UI without writing the host glue:\n *\n * ```ts\n * bootstrap.configure({\n *   ...minimalConfig,\n *   ...defaultErrorUi.hooks({ language: 'hu' }),\n * });\n * ```\n *\n * Hosts that want custom logic can omit this service and write their own\n * `onStartError` / `onTransportError` callbacks directly.\n */\n@Injectable({ providedIn: 'root' })\nexport class SmartDefaultErrorUiService {\n  private snackBar = inject(MatSnackBar);\n  private session = inject(SmartSessionService);\n\n  /** Returns a hooks bundle ready to spread into `bootstrap.configure()`. */\n  hooks(options: DefaultErrorUiOptions = {}): {\n    onStartError: (err: unknown) => void;\n    onTransportError: (err: HttpErrorResponse) => void;\n    onSessionError: (err: SessionError) => void;\n  } {\n    return {\n      onStartError: (err: unknown) => this.showStartError(err, options),\n      onTransportError: (err: HttpErrorResponse) => this.showTransportError(err, options),\n      onSessionError: (err: SessionError) => this.showSessionError(err, options),\n    };\n  }\n\n  showStartError(_err: unknown, options: DefaultErrorUiOptions = {}): void {\n    const s = this.resolveStrings(options);\n    const ref = this.snackBar.open(s.startErrorMessage, s.startErrorRetry, {\n      duration: 0, // sticky — app is not usable until retry succeeds\n    });\n    // Full reload, not bootstrap.start(). A bootstrap.start() retry only re-runs\n    // the init sequence; any components that already mounted during the failed\n    // attempt have rejected `whenReady()` Promises and won't re-trigger their\n    // run() when bootstrap eventually succeeds. Reload guarantees a clean mount.\n    ref.onAction().subscribe(() => this.verifyServerAndReload());\n  }\n\n  showTransportError(_err: HttpErrorResponse, options: DefaultErrorUiOptions = {}): void {\n    const s = this.resolveStrings(options);\n    const ref = this.snackBar.open(s.transportErrorMessage, s.transportErrorReload, {\n      duration: options.transportErrorDuration ?? 0,\n    });\n    ref.onAction().subscribe(() => this.verifyServerAndReload());\n  }\n\n  showSessionError(_err: SessionError, options: DefaultErrorUiOptions = {}): void {\n    const s = this.resolveStrings(options);\n    const ref = this.snackBar.open(s.sessionErrorMessage, s.sessionErrorAction, {\n      duration: 0, // sticky — session is invalid until the user takes action\n    });\n    ref.onAction().subscribe(() => this.recoverSession());\n  }\n\n  /**\n   * Clears the dead session and reloads. Unlike `verifyServerAndReload`, this\n   * does NOT pre-check via `getSession()` — the SID is known to be invalid,\n   * so the check would fail. We best-effort `clearAndStartNewSession()`\n   * (creates a fresh anonymous session); reload happens regardless so the\n   * user is not stuck if the clear fails (e.g., server flapping).\n   *\n   * Overridable in tests.\n   */\n  protected async recoverSession(): Promise<void> {\n    try {\n      await this.session.clearAndStartNewSession();\n    } catch {\n      // Server may also be down; reload anyway and let bootstrap.start() retry.\n    }\n    this.reloadPage();\n  }\n\n  /**\n   * Pings `getSession()` before reloading: if the server is still down, the\n   * reload would just re-trigger the broken-screen state. The failed check\n   * goes through `SmartErrorCatchingInterceptor` and re-fires `onTransportError`,\n   * so the user sees a fresh snackbar — they get visible feedback that the\n   * server is still unreachable, without paying the cost of a full bundle\n   * reload that lands on the same broken state.\n   *\n   * Overridable in tests.\n   */\n  protected async verifyServerAndReload(): Promise<void> {\n    try {\n      await this.session.getSession();\n    } catch {\n      return; // server still unreachable — interceptor re-opens the snackbar\n    }\n    this.reloadPage();\n  }\n\n  /** Overridable in tests. */\n  protected reloadPage(): void {\n    window.location.reload();\n  }\n\n  private resolveStrings(options: DefaultErrorUiOptions): DefaultErrorUiStrings {\n    const lang = this.resolveLanguage(options.language);\n    const base = lang === 'hu' ? STRINGS_HU : STRINGS_EN;\n    return { ...base, ...(options.strings ?? {}) };\n  }\n\n  private resolveLanguage(lang?: DefaultErrorUiLanguage): 'hu' | 'en' {\n    if (lang === 'hu' || lang === 'en') {\n      return lang;\n    }\n    return navigator.language?.toLowerCase().startsWith('hu') ? 'hu' : 'en';\n  }\n}\n"]}

package/esm2022/lib/session/smart-error-catching.interceptor.mjs

@@ -0,0 +1,109 @@
+import { Injectable } from '@angular/core';
+import { from, throwError } from 'rxjs';
+import { catchError, switchMap } from 'rxjs/operators';
+import { SessionErrorBehaviour, } from './projects';
+import * as i0 from "@angular/core";
+import * as i1 from "./projects";
+import * as i2 from "./smart-backend-bootstrap.service";
+export 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((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((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: i1.SmartSessionService }, { token: i2.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
+        }], ctorParameters: () => [{ type: i1.SmartSessionService }, { type: i2.SmartBackendBootstrapService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smart-error-catching.interceptor.js","sourceRoot":"","sources":["../../../../../projects/smart-ng-client/src/lib/session/smart-error-catching.interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  HttpErrorResponse,\n  HttpEvent,\n  HttpHandler,\n  HttpInterceptor,\n  HttpRequest,\n} from '@angular/common/http';\nimport { Injectable } from '@angular/core';\nimport { from, Observable, throwError } from 'rxjs';\nimport { catchError, switchMap } from 'rxjs/operators';\nimport {\n  ApiError,\n  HeaderParam,\n  SessionError,\n  SessionErrorBehaviour,\n  SmartSessionService,\n} from './projects';\nimport { SmartBackendBootstrapService } from './smart-backend-bootstrap.service';\n\n@Injectable()\nexport class SmartErrorCatchingInterceptor implements HttpInterceptor {\n  sessionErrorCodes: SessionError[] = [\n    {\n      code: 'session.expired',\n      behaviour: SessionErrorBehaviour.REFRESH,\n    },\n    {\n      code: 'session.refreshtoken.invalid',\n      behaviour: SessionErrorBehaviour.RESTART,\n    },\n    {\n      code: 'session.badrequest.missingtoken',\n      behaviour: SessionErrorBehaviour.RESTART,\n    },\n    {\n      code: 'session.security.nocontext',\n      behaviour: SessionErrorBehaviour.RESTART,\n    },\n    {\n      code: 'session.invalidsessionuri',\n      behaviour: SessionErrorBehaviour.RESTART,\n    },\n    {\n      code: 'session.notinitialized',\n      behaviour: SessionErrorBehaviour.RESTART,\n    },\n    {\n      code: 'session.viewcontext.missing',\n      behaviour: SessionErrorBehaviour.RESTART_VIEWCONTEXT,\n    },\n  ];\n\n  constructor(\n    private session: SmartSessionService,\n    private bootstrap: SmartBackendBootstrapService,\n  ) {}\n\n  intercept(request: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>> {\n    return next\n      .handle(request)\n      .pipe(catchError((error: HttpErrorResponse) => this.handleError(error, request, next)));\n  }\n\n  private handleError(\n    error: HttpErrorResponse,\n    request: HttpRequest<unknown>,\n    next: HttpHandler\n  ): Observable<HttpEvent<unknown>> {\n    if (this.isSessionError(error)) {\n      const sessionError = this.getSessionError(error);\n      if (sessionError) {\n        return this.resolveError(sessionError).pipe(\n          switchMap((resolved) => {\n            if (resolved && sessionError.behaviour === SessionErrorBehaviour.REFRESH) {\n              return next.handle(this.updateRequestHeaders(request));\n            }\n            return throwError(() => error);\n          }),\n          catchError((resolveError) => {\n            // when the resolveError throws a restart error (in the refreshSession), rethrow the original error\n            if (this.isSessionError(resolveError)) {\n              const resolveSessionError = this.getSessionError(resolveError);\n              if (resolveSessionError?.behaviour === SessionErrorBehaviour.RESTART) {\n                return throwError(() => error);\n              }\n            }\n            return throwError(() => resolveError);\n          })\n        );\n      }\n    }\n    if (this.isTransportError(error)) {\n      // Fire-and-forget; the request still rejects so callers can react per-call.\n      this.bootstrap.handleTransportError(error).catch((err) => {\n        console.error('handleTransportError hook threw', err);\n      });\n    }\n    return throwError(() => error);\n  }\n\n  private isSessionError(error: HttpErrorResponse): boolean {\n    return error.status === 400 && (error.error as ApiError).code != null;\n  }\n\n  private isTransportError(error: HttpErrorResponse): boolean {\n    return error.status === 0 || error.status >= 500;\n  }\n\n  private getSessionError(error: HttpErrorResponse): SessionError | undefined {\n    return this.sessionErrorCodes.find(\n      (sessionError: SessionError) => sessionError.code === (error.error as ApiError).code\n    );\n  }\n\n  private resolveError(sessionError: SessionError): Observable<any> {\n    if (sessionError.behaviour === SessionErrorBehaviour.RESTART) {\n      return from(this.session.handleSessionError(sessionError));\n    }\n    if (sessionError.behaviour === SessionErrorBehaviour.RESTART_VIEWCONTEXT) {\n      return from(this.bootstrap.handleViewContextLost(sessionError));\n    }\n    return from(this.session.refreshSession());\n  }\n\n  private updateRequestHeaders(request: HttpRequest<unknown>): HttpRequest<unknown> {\n    this.session.headerParams.forEach((headerParam: HeaderParam) => {\n      request = request.clone({\n        headers: request.headers.set(headerParam.headerName, headerParam.value),\n      });\n    });\n    return request;\n  }\n}\n"]}

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

@@ -0,0 +1,44 @@
+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
+        // 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.3.11", ngImport: i0, type: SmartHeaderMaintainerInterceptor, deps: [{ token: i1.SmartSessionService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartHeaderMaintainerInterceptor }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartHeaderMaintainerInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.SmartSessionService }] });
+//# sourceMappingURL=data:application/json;base64,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

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

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