@smartbit4all/ng-client 4.5.11 → 4.5.12

package/esm2022/lib/session/projects.mjs

@@ -9,4 +9,5 @@ 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';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvamVjdHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zbWFydC1uZy1jbGllbnQvc3JjL2xpYi9zZXNzaW9uL3Byb2plY3RzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsaUNBQWlDLENBQUM7QUFDaEQsY0FBYyw2Q0FBNkMsQ0FBQztBQUM1RCxjQUFjLDJDQUEyQyxDQUFDO0FBQzFELGNBQWMsbUNBQW1DLENBQUM7QUFDbEQsY0FBYyxrQ0FBa0MsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBQdWJsaWMgQVBJIFN1cmZhY2Ugb2Ygc21hcnQtc2Vzc2lvblxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vc21hcnQtc2Vzc2lvbi5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vYXBpL2luZGV4JztcbmV4cG9ydCAqIGZyb20gJy4vc21hcnQtc2Vzc2lvbi5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9zbWFydC1zZXNzaW9uLWhhbmRsZXIuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NtYXJ0LXRpbWVyL3NtYXJ0LXNlc3Npb24tdGltZXIuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vc21hcnQtdGltZXIvc21hcnQtc2Vzc2lvbi10aW1lci5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vc21hcnQtYmFja2VuZC1ib290c3RyYXAuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3NtYXJ0LWJhY2tlbmQtYm9vdHN0cmFwLmNvbmZpZyc7XG4iXX0=
+export * from './smart-default-error-ui.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvamVjdHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zbWFydC1uZy1jbGllbnQvc3JjL2xpYi9zZXNzaW9uL3Byb2plY3RzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsaUNBQWlDLENBQUM7QUFDaEQsY0FBYyw2Q0FBNkMsQ0FBQztBQUM1RCxjQUFjLDJDQUEyQyxDQUFDO0FBQzFELGNBQWMsbUNBQW1DLENBQUM7QUFDbEQsY0FBYyxrQ0FBa0MsQ0FBQztBQUNqRCxjQUFjLGtDQUFrQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBzbWFydC1zZXNzaW9uXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9zbWFydC1zZXNzaW9uLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9hcGkvaW5kZXgnO1xuZXhwb3J0ICogZnJvbSAnLi9zbWFydC1zZXNzaW9uLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL3NtYXJ0LXNlc3Npb24taGFuZGxlci5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vc21hcnQtdGltZXIvc21hcnQtc2Vzc2lvbi10aW1lci5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9zbWFydC10aW1lci9zbWFydC1zZXNzaW9uLXRpbWVyLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9zbWFydC1iYWNrZW5kLWJvb3RzdHJhcC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vc21hcnQtYmFja2VuZC1ib290c3RyYXAuY29uZmlnJztcbmV4cG9ydCAqIGZyb20gJy4vc21hcnQtZGVmYXVsdC1lcnJvci11aS5zZXJ2aWNlJztcbiJdfQ==

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

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnQtYmFja2VuZC1ib290c3RyYXAuY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvc21hcnQtbmctY2xpZW50L3NyYy9saWIvc2Vzc2lvbi9zbWFydC1iYWNrZW5kLWJvb3RzdHJhcC5jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEh0dHBFcnJvclJlc3BvbnNlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uL2h0dHAnO1xuaW1wb3J0IHsgVWlBY3Rpb25EZXNjcmlwdG9yIH0gZnJvbSAnLi4vdmlldy1jb250ZXh0L2FwaSc7XG5pbXBvcnQgeyBTbWFydFZpZXdIYW5kbGVyTW9kZWwgfSBmcm9tICcuLi92aWV3LWNvbnRleHQvc21hcnQtdmlldy1jb250ZXh0Lm1vZGVsJztcbmltcG9ydCB7IFNlc3Npb25FcnJvciB9IGZyb20gJy4vc21hcnQtc2Vzc2lvbi1oYW5kbGVyLnNlcnZpY2UnO1xuXG4vKipcbiAqIEV4dGVybmFsbHkgcHJvdmlkZWQgc2Vzc2lvbiArIHZpZXdDb250ZXh0IHRvIGh5ZHJhdGUgdGhlIGJvb3RzdHJhcCB3aXRoLFxuICogYnlwYXNzaW5nIHRoZSByZWd1bGFyIGBzdGFydCgpYCBmbG93LiBUeXBpY2FsIHVzZSBjYXNlOiBhIG5hdGl2ZSBtb2JpbGVcbiAqIHNoZWxsIHRoYXQgcGVyZm9ybWVkIGF1dGhlbnRpY2F0aW9uIGl0c2VsZiBhbmQgaGFuZHMgb2ZmIHRoZSByZXN1bHQgdG8gYVxuICogd2Vidmlldy1ob3N0ZWQgQW5ndWxhciBhcHAgdmlhIFVSTCBmcmFnbWVudC5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBTbWFydEJhY2tlbmRCb290c3RyYXBDcmVkZW50aWFscyB7XG4gIC8qKiBTSUQgaXNzdWVkIGJ5IHRoZSBiYWNrZW5kOyB3aWxsIGJlIHNlbnQgYXMgYEF1dGhvcml6YXRpb246IEJlYXJlciA8c2Vzc2lvblRva2VuPmAuICovXG4gIHNlc3Npb25Ub2tlbjogc3RyaW5nO1xuICAvKiogVVVJRCBvZiBhbiBhbHJlYWR5LWV4aXN0aW5nIHZpZXdDb250ZXh0IG9uIHRoZSBiYWNrZW5kLiAqL1xuICB2aWV3Q29udGV4dFV1aWQ6IHN0cmluZztcbiAgLyoqXG4gICAqIE9wdGlvbmFsIGxvbmctbGl2ZWQgcmVmcmVzaCB0b2tlbiBwYWlyZWQgd2l0aCB0aGUgU0lELiBJZiBwcm92aWRlZCwgaXQgaXNcbiAgICogcGVyc2lzdGVkIHRvIGxvY2FsU3RvcmFnZSBzbyB0aGUgYXV0b25vbW91cyBgU21hcnRFcnJvckNhdGNoaW5nSW50ZXJjZXB0b3JgXG4gICAqIFJFRlJFU0ggZmxvdyBjYW4gcmVjb3ZlciBmcm9tIGBzZXNzaW9uLmV4cGlyZWRgIGVycm9ycyB3aXRob3V0IGRyb3BwaW5nXG4gICAqIHRoZSB1c2VyIGJhY2sgdG8gYSBmcmVzaCBhbm9ueW1vdXMgc2Vzc2lvbi5cbiAgICovXG4gIHJlZnJlc2hUb2tlbj86IHN0cmluZztcbn1cblxuZXhwb3J0IGludGVyZmFjZSBTbWFydEJhY2tlbmRCb290c3RyYXBDb25maWcge1xuICB1cmw6IHN0cmluZztcbiAgY29va2llTmFtZTogc3RyaW5nO1xuICAvKipcbiAgICogVmlldyBuYW1lIHRoZSBiYWNrZW5kIHVzZXMgZm9yIGdlbmVyaWMgbWVzc2FnZSBkaWFsb2dzLiBEZWZhdWx0cyB0b1xuICAgKiBgJ21lc3NhZ2UtZGlhbG9nJ2AgKHRoZSBwbGF0Zm9ybSBjb252ZW50aW9uKSB3aGVuIG9taXR0ZWQuXG4gICAqL1xuICBtZXNzYWdlRGlhbG9nTmFtZT86IHN0cmluZztcbiAgdmlld0hhbmRsZXJzOiBTbWFydFZpZXdIYW5kbGVyTW9kZWxbXTtcbiAgYWN0aW9uRGVzY3JpcHRvcnM6IE1hcDxzdHJpbmcsIFVpQWN0aW9uRGVzY3JpcHRvcj47XG5cbiAgLyoqIE9wdGlvbmFsIG92ZXJyaWRlIGZvciB0aGUgZGVmYXVsdCBgaGFuZGxlU2Vzc2lvbkVycm9yYCBmbG93LiAqL1xuICBvblNlc3Npb25FcnJvcj86IChlcnI6IFNlc3Npb25FcnJvcikgPT4gUHJvbWlzZTx2b2lkPiB8IHZvaWQ7XG5cbiAgLyoqIE9wdGlvbmFsIG92ZXJyaWRlIGZvciB0aGUgZGVmYXVsdCBgb3BlblNtYXJ0TGlua2AgaGFuZGxlci4gKi9cbiAgb25TbWFydExpbms/OiAoY2hhbm5lbDogc3RyaW5nKSA9PiBQcm9taXNlPHZvaWQ+IHwgdm9pZDtcblxuICAvKiogSG9vayBmb3IgaG9zdCBVWCB3aGVuIGBzdGFydCgpYCByZWplY3RzIChzbmFja2JhciArIHJldHJ5KS4gKi9cbiAgb25TdGFydEVycm9yPzogKGVycjogdW5rbm93bikgPT4gUHJvbWlzZTx2b2lkPiB8IHZvaWQ7XG5cbiAgLyoqXG4gICAqIEhvb2sgY2FsbGVkIHdoZW4gYSBCRkYgY2FsbCBmYWlscyBhdCB0aGUgdHJhbnNwb3J0IGxldmVsIOKAlCBzZXJ2ZXJcbiAgICogdW5yZWFjaGFibGUgKHN0YXR1cyAwKSwgZ2F0ZXdheS9zZXJ2aWNlLXVuYXZhaWxhYmxlICg1MDIvNTAzLzUwNCksIG9yXG4gICAqIGdlbmVyaWMgc2VydmVyLWVycm9yICg1MDApLiBEZWZhdWx0OiBhIGNvbnNvbGUud2FybiBsaW5lOyB0aGUgcmVxdWVzdFxuICAgKiBzdGlsbCByZWplY3RzIHdpdGggdGhlIG9yaWdpbmFsIGVycm9yLCBhbGxvd2luZyBwZXItY2FsbCBoYW5kbGluZy5cbiAgICpcbiAgICogRmlyZS1hbmQtZm9yZ2V0OiBldmVyeSBmYWlsZWQgcmVxdWVzdCBpbnZva2VzIHRoZSBob29rIChubyBkZWR1cCk7IHRoZVxuICAgKiBob3N0IGlzIHJlc3BvbnNpYmxlIGZvciBvd24gVUkgZGVkdXBsaWNhdGlvbiBpZiBuZWVkZWQgKGUuZy4gc25hY2tiYXJcbiAgICogd2l0aCBhIFwidGhpcyBtZXNzYWdlIGlzIGFscmVhZHkgc2hvd2luZ1wiIGd1YXJkKS5cbiAgICovXG4gIG9uVHJhbnNwb3J0RXJyb3I/OiAoZXJyOiBIdHRwRXJyb3JSZXNwb25zZSkgPT4gUHJvbWlzZTx2b2lkPiB8IHZvaWQ7XG5cbiAgLyoqXG4gICAqIEhvb2sgY2FsbGVkIHdoZW4gdGhlIGJhY2tlbmQgcmVwb3J0cyB0aGUgY3VycmVudCB2aWV3Q29udGV4dCBpcyBnb25lXG4gICAqIChsb2dvdXQsIHNlc3Npb24gZXhwaXJ5LCBiYWNrZW5kIHJlc3RhcnQpIOKAlCBpLmUuIHdoZW4gdGhlXG4gICAqIGBTbWFydEVycm9yQ2F0Y2hpbmdJbnRlcmNlcHRvcmAgd291bGQgaGlzdG9yaWNhbGx5IGF1dG8tdHJpZ2dlclxuICAgKiBgUkVTVEFSVF9WSUVXQ09OVEVYVGAuXG4gICAqXG4gICAqIERlZmF1bHQ6IHJlYnVpbGRzIGEgZnJlc2ggYW5vbnltb3VzIHZpZXdDb250ZXh0IHZpYVxuICAgKiBgdmlld0NvbnRleHQuaW5pdE5ld1ZpZXdDb250ZXh0KClgICh0aGUgaGlzdG9yaWNhbCB3ZWIgZmxvdykuXG4gICAqXG4gICAqIE1vYmlsZS9lbWJlZGRlZCBob3N0cyBvdmVycmlkZSB0aGlzIHRvIGZ1bGx5IGRlbGVnYXRlIHRvIHRoZSBzaGVsbCDigJRcbiAgICogdHlwaWNhbGx5IGJ5IGNhbGxpbmcgYSBKUyBicmlkZ2UgdGhhdCBzaWduYWxzIHRoZSBuYXRpdmUgc2lkZSB0b1xuICAgKiB0ZWFyIGRvd24gdGhlIHdlYnZpZXcgYW5kIHJldHVybiB0byB0aGUgbmF0aXZlIGxvZ2luIHBhZ2UuXG4gICAqL1xuICBvblZpZXdDb250ZXh0TG9zdD86IChlcnI6IFNlc3Npb25FcnJvcikgPT4gUHJvbWlzZTx2b2lkPiB8IHZvaWQ7XG59XG4iXX0=

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

@@ -18,7 +18,7 @@ export class SmartBackendBootstrapService {
         this.session.setCookieName(config.cookieName);
         this.session.setSessionHandlerService(this);
         this.viewContext.setViewHandlers(config.viewHandlers);
-        this.viewContext.setMessageDialogName(config.messageDialogName);
+        this.viewContext.setMessageDialogName(config.messageDialogName ?? 'message-dialog');
         this.viewContext.setActionDescriptors(config.actionDescriptors);
         this.viewContext.openSmartLink.subscribe((channel) => {
             this.handleSmartLink(channel);
@@ -101,6 +101,21 @@ export class SmartBackendBootstrapService {
         }
         await this.viewContext.initNewViewContext();
     }
+    /**
+     * 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();
@@ -148,4 +163,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImpo
             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 { 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@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\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);\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  whenReady(): Promise<void> {\n    if (!this.runningInit) {\n      return Promise.reject(new Error('BootstrapNotStarted'));\n    }\n    return this.runningInit;\n  }\n\n  async reset(): Promise<void> {\n    this.runningInit = undefined;\n    this.lastInitFailed = false;\n    this.mode = undefined;\n    this.runningViewContextLost = 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    if (this.config?.onViewContextLost) {\n      await this.config.onViewContextLost(err);\n      return;\n    }\n    await this.viewContext.initNewViewContext();\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  async handleSessionError(err: SessionError): Promise<void> {\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  }\n}\n"]}
+//# 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@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\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  whenReady(): Promise<void> {\n    if (!this.runningInit) {\n      return Promise.reject(new Error('BootstrapNotStarted'));\n    }\n    return this.runningInit;\n  }\n\n  async reset(): Promise<void> {\n    this.runningInit = undefined;\n    this.lastInitFailed = false;\n    this.mode = undefined;\n    this.runningViewContextLost = 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    if (this.config?.onViewContextLost) {\n      await this.config.onViewContextLost(err);\n      return;\n    }\n    await this.viewContext.initNewViewContext();\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  async handleSessionError(err: SessionError): Promise<void> {\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  }\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

@@ -66,11 +66,20 @@ export class SmartErrorCatchingInterceptor {
                 }));
             }
         }
+        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);
     }
@@ -97,4 +106,4 @@ export class 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    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 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"]}
+//# 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/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, input, computed, effect, signal, 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, inject, input, computed, effect, signal, 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';
@@ -33,7 +33,7 @@ import { ENTER, COMMA } from '@angular/cdk/keycodes';
 import { deepEqual } from 'fast-equals';
 import moment from 'moment';
 import * as i1$4 from '@angular/material/snack-bar';
-import { MAT_SNACK_BAR_DATA, MatSnackBarModule } from '@angular/material/snack-bar';
+import { MAT_SNACK_BAR_DATA, MatSnackBarModule, MatSnackBar } from '@angular/material/snack-bar';
 import { TemplatePortal } from '@angular/cdk/portal';
 import * as i2$2 from '@angular/cdk/overlay';
 import * as i11 from '@angular/material/form-field';
@@ -13212,7 +13212,7 @@ class SmartBackendBootstrapService {
         this.session.setCookieName(config.cookieName);
         this.session.setSessionHandlerService(this);
         this.viewContext.setViewHandlers(config.viewHandlers);
-        this.viewContext.setMessageDialogName(config.messageDialogName);
+        this.viewContext.setMessageDialogName(config.messageDialogName ?? 'message-dialog');
         this.viewContext.setActionDescriptors(config.actionDescriptors);
         this.viewContext.openSmartLink.subscribe((channel) => {
             this.handleSmartLink(channel);
@@ -13295,6 +13295,21 @@ class SmartBackendBootstrapService {
         }
         await this.viewContext.initNewViewContext();
     }
+    /**
+     * 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();
@@ -13343,6 +13358,136 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImpo
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [{ type: SmartSessionService }, { type: SmartViewContextService }] });
 
+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
  */
@@ -13408,11 +13553,20 @@ class SmartErrorCatchingInterceptor {
                 }));
             }
         }
+        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);
     }
@@ -23861,5 +24015,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImpo
  * Generated bundle index. Do not edit.
  */
 
-export { APIS$5 as APIS, AbstractMap, ApiModule$5 as ApiModule, ApiQueueService, BASE_PATH$7 as BASE_PATH, COLLECTION_FORMATS$7 as COLLECTION_FORMATS, COMPONENT_LIBRARY, CUSTOM_DIAGRAM_OPTIONS, CloseResult, ComparableDropdownDirective, ComparableMultiselectDirective, ComponentFactoryService, ComponentFactoryServiceModule, ComponentLibrary, ComponentType, ComponentWidgetType, Configuration$7 as Configuration, DIALOG_DISABLE_CLOSE, DataChangeKind, DefaultChartOptionsProvider, DefaultUiActionCode_CLOSE, DrawTime, EMPTY_PARAMS, ExpandableSectionButtonIconPosition, ExpandableSectionButtonType, ExpandableSectionComponent, FilterExpressionBoolOperator$1 as FilterExpressionBoolOperator, FilterExpressionBuilderGroupBuilderGroupKindEnum, FilterExpressionDataType, FilterExpressionFieldWidgetType, FilterExpressionOperation, FilterExpressionOrderByOrderEnum, GeoMapDataLoadingMode, GeoMapDataSourceType, GeoMapItemKind, GeoMapOperationMode, GeoMapSelectionMode, GeoMapTextType, GoogleMap, GridColumnContentType, GridDataAccessConfigKindEnum, GridSelectionMode, GridSelectionType, GridUiActionType, GridViewDescriptorKindEnum, HighlightPipe, IS_ASYNC_PARAM_NAME, IconPosition, ImageResourceKindEnum, LayoutDirection, LeafletMap, LinkTargetEnum, MAP_ENGINE, MapEngine, MenuComponent, MessageOptionType, MessageTextType, MessageType, NAMED_VALIDATOR, NamedValidatorOperationEnum, NamedValidatorService, PhotoCaptureWidgetComponent, RecordingUploaderPropertiesOpenDirectionEnum, SelectionDefinitionTypeEnum, SelectionDefinitionValueSetValueTypeEnum, ServerRequestType, SessionAPIS, SessionErrorBehaviour, SessionService, SharedModule, SimplifiedTabGroupComponent, SmartActionType, SmartBackendBootstrapService, SmartComponent, SmartComponentApiClient, SmartComponentLayoutComponent, SmartComponentLayoutModule, SmartComponentLayoutUtility, SmartDatePipe, SmartDateTimePipe, SmartDiagramComponent, SmartDiagramModule, SmartDialog, SmartEmbeddedSlotDirective, SmartExpandableSectionModule, SmartExpandableSectionService, SmartFileEditorComponent, SmartFileUploaderComponent, SmartFilterComponent, SmartFilterEditorContentComponent, SmartFilterEditorModule, SmartFilterEditorService, SmartFilterExpressionItemComponent, SmartFilterExpressionItemsComponent, SmartFilterModule, SmartFilterParamComponent, SmartFilterParamsComponent, SmartFilterPosition, SmartFilterType, SmartFormInputMode, SmartFormTextFieldButtonIconPosition, SmartFormWidgetDirection, SmartFormWidgetType, SmartFormWidgetWidth, SmartGridButtonType, SmartGridComponent, SmartGridDataLayout, SmartGridModule, SmartGridService, SmartGridType, SmartIconComponent, SmartIconModule, SmartIconService, SmartLayoutDef, SmartLinkChannelVariableInPath, SmartLinkMigrationStatusStatusEnum, SmartLinkUuidVariableInPath, SmartMapComponent, SmartMapModule, SmartMultiFileEditorComponent, SmartNavbarComponent, SmartNavbarModule, SmartNavbarService, SmartNavigationModule, SmartNavigationService, SmartNgClientModule, SmartNgClientService, SmartService, SmartSessionModule, SmartSessionService, SmartSessionTimerComponent, SmartSessionTimerService, SmartSubject, SmartTabGroupModule, SmartTabGroupService, SmartTable, SmartTableButtonType, SmartTableHeaderPropertyType, SmartTableInterfaceTypeEnum, SmartTableOptionButtonDirection, SmartTableOrder, SmartTableType, SmartTimePipe, SmartTooltipDirective, SmartTreeComponent, SmartTreeNodeButtonType, SmartUserSettinsIconPosition, SmartValidationModule, SmartValidatorName, SmartViewContextErrorDialogButtonLabel, SmartViewContextErrorDialogMessage, SmartViewContextErrorDialogTitle, SmartViewContextModule, SmartViewContextService, SmartViewRedirect, SmartVoiceRecorderComponent, SmartWidgetHintPosition, SmartWidgetHintPositionEnum, SmartWidgetSettings, SmartdialogModule, SmartdialogService, SmartfileuploaderComponent, SmartformComponent, SmartformLayoutDefinitionService, SmartformwidgetComponent, SmarttableComponent, SmarttableModule, SmarttableService, SmarttreeGenericService, SmarttreeModule, SmarttreeService, TabGroupComponent, ToggleLabelPosition, ToolbarDirection, UiActionButtonComponent, UiActionButtonType, UiActionConfirmDialogComponent, UiActionConfirmDialogService, UiActionDescriptorService, UiActionDialogButtonComponent, UiActionDialogType, UiActionFeedbackType, UiActionInputDialogComponent, UiActionInputDialogService, UiActionInputType, UiActionService, UiActionToolbarComponent, UiActionTooltipTooltipPositionEnum, UiBadgeComponent, UiBadgeDirective, UploadWidgetComponent, UploadWidgetType, ValueChangeMode, ViewEventHandlerViewEventTypeEnum, ViewService, ViewState, ViewType, VoiceRecordWidgetComponent, barChart, bubbleChart, createBasicOptions, doughnutChart, horizontalBarChart, horizontalStackedBarChart, multiAxisLineChart, pieChart, polarAreaChart, radarChart, scatterChart, stackedBarChart, transformDataToBarLikeDataSet, transformDataToBasicDataSets, transformDataToBubble, transformDataToScatter };
+export { APIS$5 as APIS, AbstractMap, ApiModule$5 as ApiModule, ApiQueueService, BASE_PATH$7 as BASE_PATH, COLLECTION_FORMATS$7 as COLLECTION_FORMATS, COMPONENT_LIBRARY, CUSTOM_DIAGRAM_OPTIONS, CloseResult, ComparableDropdownDirective, ComparableMultiselectDirective, ComponentFactoryService, ComponentFactoryServiceModule, ComponentLibrary, ComponentType, ComponentWidgetType, Configuration$7 as Configuration, DIALOG_DISABLE_CLOSE, DataChangeKind, DefaultChartOptionsProvider, DefaultUiActionCode_CLOSE, DrawTime, EMPTY_PARAMS, ExpandableSectionButtonIconPosition, ExpandableSectionButtonType, ExpandableSectionComponent, FilterExpressionBoolOperator$1 as FilterExpressionBoolOperator, FilterExpressionBuilderGroupBuilderGroupKindEnum, FilterExpressionDataType, FilterExpressionFieldWidgetType, FilterExpressionOperation, FilterExpressionOrderByOrderEnum, GeoMapDataLoadingMode, GeoMapDataSourceType, GeoMapItemKind, GeoMapOperationMode, GeoMapSelectionMode, GeoMapTextType, GoogleMap, GridColumnContentType, GridDataAccessConfigKindEnum, GridSelectionMode, GridSelectionType, GridUiActionType, GridViewDescriptorKindEnum, HighlightPipe, IS_ASYNC_PARAM_NAME, IconPosition, ImageResourceKindEnum, LayoutDirection, LeafletMap, LinkTargetEnum, MAP_ENGINE, MapEngine, MenuComponent, MessageOptionType, MessageTextType, MessageType, NAMED_VALIDATOR, NamedValidatorOperationEnum, NamedValidatorService, PhotoCaptureWidgetComponent, RecordingUploaderPropertiesOpenDirectionEnum, SelectionDefinitionTypeEnum, SelectionDefinitionValueSetValueTypeEnum, ServerRequestType, SessionAPIS, SessionErrorBehaviour, SessionService, SharedModule, SimplifiedTabGroupComponent, SmartActionType, SmartBackendBootstrapService, SmartComponent, SmartComponentApiClient, SmartComponentLayoutComponent, SmartComponentLayoutModule, SmartComponentLayoutUtility, SmartDatePipe, SmartDateTimePipe, SmartDefaultErrorUiService, SmartDiagramComponent, SmartDiagramModule, SmartDialog, SmartEmbeddedSlotDirective, SmartExpandableSectionModule, SmartExpandableSectionService, SmartFileEditorComponent, SmartFileUploaderComponent, SmartFilterComponent, SmartFilterEditorContentComponent, SmartFilterEditorModule, SmartFilterEditorService, SmartFilterExpressionItemComponent, SmartFilterExpressionItemsComponent, SmartFilterModule, SmartFilterParamComponent, SmartFilterParamsComponent, SmartFilterPosition, SmartFilterType, SmartFormInputMode, SmartFormTextFieldButtonIconPosition, SmartFormWidgetDirection, SmartFormWidgetType, SmartFormWidgetWidth, SmartGridButtonType, SmartGridComponent, SmartGridDataLayout, SmartGridModule, SmartGridService, SmartGridType, SmartIconComponent, SmartIconModule, SmartIconService, SmartLayoutDef, SmartLinkChannelVariableInPath, SmartLinkMigrationStatusStatusEnum, SmartLinkUuidVariableInPath, SmartMapComponent, SmartMapModule, SmartMultiFileEditorComponent, SmartNavbarComponent, SmartNavbarModule, SmartNavbarService, SmartNavigationModule, SmartNavigationService, SmartNgClientModule, SmartNgClientService, SmartService, SmartSessionModule, SmartSessionService, SmartSessionTimerComponent, SmartSessionTimerService, SmartSubject, SmartTabGroupModule, SmartTabGroupService, SmartTable, SmartTableButtonType, SmartTableHeaderPropertyType, SmartTableInterfaceTypeEnum, SmartTableOptionButtonDirection, SmartTableOrder, SmartTableType, SmartTimePipe, SmartTooltipDirective, SmartTreeComponent, SmartTreeNodeButtonType, SmartUserSettinsIconPosition, SmartValidationModule, SmartValidatorName, SmartViewContextErrorDialogButtonLabel, SmartViewContextErrorDialogMessage, SmartViewContextErrorDialogTitle, SmartViewContextModule, SmartViewContextService, SmartViewRedirect, SmartVoiceRecorderComponent, SmartWidgetHintPosition, SmartWidgetHintPositionEnum, SmartWidgetSettings, SmartdialogModule, SmartdialogService, SmartfileuploaderComponent, SmartformComponent, SmartformLayoutDefinitionService, SmartformwidgetComponent, SmarttableComponent, SmarttableModule, SmarttableService, SmarttreeGenericService, SmarttreeModule, SmarttreeService, TabGroupComponent, ToggleLabelPosition, ToolbarDirection, UiActionButtonComponent, UiActionButtonType, UiActionConfirmDialogComponent, UiActionConfirmDialogService, UiActionDescriptorService, UiActionDialogButtonComponent, UiActionDialogType, UiActionFeedbackType, UiActionInputDialogComponent, UiActionInputDialogService, UiActionInputType, UiActionService, UiActionToolbarComponent, UiActionTooltipTooltipPositionEnum, UiBadgeComponent, UiBadgeDirective, UploadWidgetComponent, UploadWidgetType, ValueChangeMode, ViewEventHandlerViewEventTypeEnum, ViewService, ViewState, ViewType, VoiceRecordWidgetComponent, barChart, bubbleChart, createBasicOptions, doughnutChart, horizontalBarChart, horizontalStackedBarChart, multiAxisLineChart, pieChart, polarAreaChart, radarChart, scatterChart, stackedBarChart, transformDataToBarLikeDataSet, transformDataToBasicDataSets, transformDataToBubble, transformDataToScatter };
 //# sourceMappingURL=smartbit4all-ng-client.mjs.map