@smartbit4all/ng-client 4.5.11 → 4.5.12

package/lib/session/projects.d.ts

@@ -6,3 +6,4 @@ export * from './smart-timer/smart-session-timer.component';
 export * from './smart-timer/smart-session-timer.service';
 export * from './smart-backend-bootstrap.service';
 export * from './smart-backend-bootstrap.config';
+export * from './smart-default-error-ui.service';

package/lib/session/smart-backend-bootstrap.config.d.ts

@@ -1,3 +1,4 @@
+import { HttpErrorResponse } from '@angular/common/http';
 import { UiActionDescriptor } from '../view-context/api';
 import { SmartViewHandlerModel } from '../view-context/smart-view-context.model';
 import { SessionError } from './smart-session-handler.service';
@@ -23,7 +24,11 @@ export interface SmartBackendBootstrapCredentials {
 export interface SmartBackendBootstrapConfig {
     url: string;
     cookieName: string;
-    messageDialogName: string;
+    /**
+     * View name the backend uses for generic message dialogs. Defaults to
+     * `'message-dialog'` (the platform convention) when omitted.
+     */
+    messageDialogName?: string;
     viewHandlers: SmartViewHandlerModel[];
     actionDescriptors: Map<string, UiActionDescriptor>;
     /** Optional override for the default `handleSessionError` flow. */
@@ -32,6 +37,17 @@ export interface SmartBackendBootstrapConfig {
     onSmartLink?: (channel: string) => Promise<void> | void;
     /** Hook for host UX when `start()` rejects (snackbar + retry). */
     onStartError?: (err: unknown) => Promise<void> | void;
+    /**
+     * Hook called when a BFF call fails at the transport level — server
+     * unreachable (status 0), gateway/service-unavailable (502/503/504), or
+     * generic server-error (500). Default: a console.warn line; the request
+     * still rejects with the original error, allowing per-call handling.
+     *
+     * Fire-and-forget: every failed request invokes the hook (no dedup); the
+     * host is responsible for own UI deduplication if needed (e.g. snackbar
+     * with a "this message is already showing" guard).
+     */
+    onTransportError?: (err: HttpErrorResponse) => Promise<void> | void;
     /**
      * Hook called when the backend reports the current viewContext is gone
      * (logout, session expiry, backend restart) — i.e. when the

package/lib/session/smart-backend-bootstrap.service.d.ts

@@ -1,3 +1,4 @@
+import { HttpErrorResponse } from '@angular/common/http';
 import { SmartSessionService } from './smart-session.service';
 import { SmartViewContextService } from '../view-context/smart-view-context.service';
 import { SessionError, SmartSessionHandlerService } from './smart-session-handler.service';
@@ -26,6 +27,12 @@ export declare class SmartBackendBootstrapService implements SmartSessionHandler
      */
     handleViewContextLost(err: SessionError): Promise<void>;
     private runViewContextLost;
+    /**
+     * 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.
+     */
+    handleTransportError(err: HttpErrorResponse): Promise<void>;
     private runInit;
     private runBootstrapWith;
     private handleInitFailure;

package/lib/session/smart-default-error-ui.service.d.ts

@@ -0,0 +1,90 @@
+import { HttpErrorResponse } from '@angular/common/http';
+import { SessionError } from './smart-session-handler.service';
+import * as i0 from "@angular/core";
+export type DefaultErrorUiLanguage = 'hu' | 'en' | 'auto';
+export interface DefaultErrorUiStrings {
+    startErrorMessage: string;
+    startErrorRetry: string;
+    transportErrorMessage: string;
+    transportErrorReload: string;
+    sessionErrorMessage: string;
+    sessionErrorAction: string;
+}
+export interface DefaultErrorUiOptions {
+    /** 'auto' (default) picks 'hu' if navigator.language starts with 'hu', else 'en'. */
+    language?: DefaultErrorUiLanguage;
+    /** Override individual strings; missing keys fall back to the language default. */
+    strings?: Partial<DefaultErrorUiStrings>;
+    /**
+     * Snackbar auto-dismiss in ms for transportError. Default: 0 (sticky).
+     *
+     * Sticky default rationale: a transport error commonly leaves the screen in
+     * an inconsistent state (failed component loads, stuck spinners) that does
+     * NOT self-recover when the server returns. An auto-dismissing snackbar
+     * would hide the notification before the user can act, leaving them with a
+     * broken UI and no way back. Sticky forces the Reload action.
+     *
+     * Set a positive number to opt into auto-dismiss (e.g. mobile-shell flows
+     * where the shell tears down the webview on transport error anyway).
+     *
+     * `startError` is always sticky regardless — the app is unusable until the
+     * user retries.
+     */
+    transportErrorDuration?: number;
+}
+/**
+ * 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 declare class SmartDefaultErrorUiService {
+    private snackBar;
+    private session;
+    /** Returns a hooks bundle ready to spread into `bootstrap.configure()`. */
+    hooks(options?: DefaultErrorUiOptions): {
+        onStartError: (err: unknown) => void;
+        onTransportError: (err: HttpErrorResponse) => void;
+        onSessionError: (err: SessionError) => void;
+    };
+    showStartError(_err: unknown, options?: DefaultErrorUiOptions): void;
+    showTransportError(_err: HttpErrorResponse, options?: DefaultErrorUiOptions): void;
+    showSessionError(_err: SessionError, options?: DefaultErrorUiOptions): void;
+    /**
+     * 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.
+     */
+    protected recoverSession(): Promise<void>;
+    /**
+     * 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.
+     */
+    protected verifyServerAndReload(): Promise<void>;
+    /** Overridable in tests. */
+    protected reloadPage(): void;
+    private resolveStrings;
+    private resolveLanguage;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SmartDefaultErrorUiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SmartDefaultErrorUiService>;
+}

package/lib/session/smart-error-catching.interceptor.d.ts

@@ -11,6 +11,7 @@ export declare class SmartErrorCatchingInterceptor implements HttpInterceptor {
     intercept(request: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>>;
     private handleError;
     private isSessionError;
+    private isTransportError;
     private getSessionError;
     private resolveError;
     private updateRequestHeaders;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smartbit4all/ng-client",
-  "version": "4.5.11",
+  "version": "4.5.12",
   "peerDependencies": {
     "@angular/animations": "^13.0.0 || ^14.0.0 || ^15.0.0 || ^16.0.0 || ^17.0.0",
     "@angular/common": "^13.0.0 || ^14.0.0 || ^15.0.0 || ^16.0.0 || ^17.0.0",