@techextensor/tab-core-utility 2.2.199 → 2.2.201

package/esm2022/lib/tab-core-utility/core/service/notification/notification-inbox.service.mjs

@@ -0,0 +1,299 @@
+import { inject, Injectable } from '@angular/core';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { NOTIFICATION_WS_CONFIG, WS_MESSAGE_TYPE, } from '../../../app/interfaces/notification.interface';
+import { NotificationWebSocketService } from './notification-websocket.service';
+import * as i0 from "@angular/core";
+/**
+ * Public notification inbox service.
+ *
+ * Pure — no storage / auth coupling. The caller (SDK facade) supplies all auth
+ * identifiers via `connect(params)`, and they're held for the lifetime of the
+ * connection (cleared on disconnect).
+ *
+ * Subscribes to the WebSocket transport, routes incoming messages by type into
+ * dedicated streams, and exposes high-level actions for the UI.
+ *
+ * Components/extensions consume this via the SDK facade (`TabSdk.notification.*`),
+ * not directly.
+ *
+ * Named `NotificationInboxService` to avoid collision with the existing toastr
+ * `NotificationService` in `core/service/notification.service.ts`.
+ */
+export class NotificationInboxService {
+    constructor() {
+        this.ws = inject(NotificationWebSocketService);
+        // Held between connect() and disconnect() — every outbound message includes it.
+        this.workspaceKey = null;
+        // ----------- streams -----------
+        this.latestNotifications$ = new Subject();
+        this.unreadCount$ = new BehaviorSubject(0);
+        this.markAsReadEvent$ = new Subject();
+        this.clearEvent$ = new Subject();
+        this.loading$ = new BehaviorSubject(false);
+        this.totalPages$ = new BehaviorSubject(1);
+        this.loadMoreTimer = null;
+        // Route inbound messages → streams
+        this.ws.messages$.subscribe((message) => this.handleMessage(message));
+    }
+    // ----------- lifecycle -----------
+    /**
+     * Connect to the notification WebSocket. Awaitable, idempotent.
+     *
+     * If a connection is already active for a *different* workspace (tenant/app/env
+     * switch without signOut), we tear it down first so the new connection uses
+     * the correct URL and workspaceKey. The underlying `ws.connect` is idempotent
+     * by connection state, so it would otherwise keep the stale URL.
+     *
+     * Once connected, an unread-count fetch is fired automatically so the badge populates.
+     */
+    async connect(params) {
+        if (this.workspaceKey && this.workspaceKey !== params.workspaceKey) {
+            await this.disconnect();
+        }
+        this.workspaceKey = params.workspaceKey;
+        await this.ws.connect({
+            userId: params.userId,
+            appId: params.appId,
+            tenantId: params.tenantId,
+        });
+        if (this.ws.isConnected()) {
+            this.requestUnreadCount();
+        }
+    }
+    /**
+     * Tear down the connection. Resets all stream state so the UI clears.
+     */
+    async disconnect() {
+        await this.ws.disconnect();
+        this.workspaceKey = null;
+        this.unreadCount$.next(0);
+        this.totalPages$.next(1);
+        this.loading$.next(false);
+        if (this.loadMoreTimer) {
+            clearTimeout(this.loadMoreTimer);
+            this.loadMoreTimer = null;
+        }
+    }
+    // ----------- actions -----------
+    /**
+     * Fetch a page of notifications. Server replies via GET_NOTIFICATIONS_RESPONSE.
+     *
+     * Skips entirely when the socket isn't connected — otherwise we'd set
+     * `loading$` true, send into a no-op, and the UI would spin forever.
+     *
+     * Adds a safety timeout so the spinner clears even if the BE accepts the
+     * connection but never replies (broken hub, dropped frame, etc.).
+     */
+    loadMore(pageNumber, pageSize = NOTIFICATION_WS_CONFIG.DEFAULT_PAGE_SIZE) {
+        if (!this.workspaceKey || !this.ws.isConnected())
+            return;
+        this.loading$.next(true);
+        this.ws.send({
+            type: WS_MESSAGE_TYPE.GET_NOTIFICATIONS,
+            workspaceKey: this.workspaceKey,
+            pageNumber,
+            pageSize,
+        });
+        if (this.loadMoreTimer)
+            clearTimeout(this.loadMoreTimer);
+        this.loadMoreTimer = setTimeout(() => {
+            this.loadMoreTimer = null;
+            if (this.loading$.value) {
+                this.loading$.next(false);
+            }
+        }, NOTIFICATION_WS_CONFIG.LOAD_TIMEOUT_MS);
+    }
+    /**
+     * Request unread count. Result arrives on `unreadCount$`.
+     */
+    requestUnreadCount() {
+        if (!this.workspaceKey)
+            return;
+        this.ws.send({
+            type: WS_MESSAGE_TYPE.GET_UNREAD_COUNT,
+            workspaceKey: this.workspaceKey,
+        });
+    }
+    markAsRead(notificationId) {
+        if (!this.workspaceKey)
+            return;
+        this.ws.send({
+            type: WS_MESSAGE_TYPE.MARK_NOTIFICATION_READ,
+            workspaceKey: this.workspaceKey,
+            notificationId,
+        });
+    }
+    markAllAsRead() {
+        if (!this.workspaceKey)
+            return;
+        this.ws.send({
+            type: WS_MESSAGE_TYPE.MARK_ALL_NOTIFICATION_READ,
+            workspaceKey: this.workspaceKey,
+        });
+    }
+    clearOne(notificationId) {
+        if (!this.workspaceKey)
+            return;
+        this.ws.send({
+            type: WS_MESSAGE_TYPE.CLEAR_NOTIFICATION,
+            workspaceKey: this.workspaceKey,
+            notificationId,
+        });
+    }
+    clearAll() {
+        if (!this.workspaceKey)
+            return;
+        this.ws.send({
+            type: WS_MESSAGE_TYPE.CLEAR_ALL_NOTIFICATIONS,
+            workspaceKey: this.workspaceKey,
+        });
+    }
+    // ----------- streams (read-only views) -----------
+    getLatestNotifications() {
+        return this.latestNotifications$.asObservable();
+    }
+    getUnreadCount() {
+        return this.unreadCount$.asObservable();
+    }
+    getMarkAsReadEvents() {
+        return this.markAsReadEvent$.asObservable();
+    }
+    getClearEvents() {
+        return this.clearEvent$.asObservable();
+    }
+    getLoadingState() {
+        return this.loading$.asObservable();
+    }
+    getTotalPages() {
+        return this.totalPages$.asObservable();
+    }
+    // ----------- internal -----------
+    handleMessage(message) {
+        if (!message?.type)
+            return;
+        switch (message.type) {
+            case WS_MESSAGE_TYPE.GET_NOTIFICATIONS_RESPONSE:
+                if (message.success) {
+                    const items = message.notifications ?? [];
+                    const ui = items.map((n) => this.parseInboxNotification(n));
+                    this.latestNotifications$.next(ui);
+                    this.totalPages$.next(message.totalPages ?? 1);
+                }
+                this.loading$.next(false);
+                if (this.loadMoreTimer) {
+                    clearTimeout(this.loadMoreTimer);
+                    this.loadMoreTimer = null;
+                }
+                break;
+            case WS_MESSAGE_TYPE.GET_UNREAD_COUNT_RESPONSE:
+                if (message.success) {
+                    this.unreadCount$.next(message.count ?? 0);
+                }
+                break;
+            case WS_MESSAGE_TYPE.NOTIFICATION: {
+                const ui = this.transformPushNotification(message);
+                this.latestNotifications$.next(ui);
+                this.requestUnreadCount();
+                break;
+            }
+            case WS_MESSAGE_TYPE.MARK_NOTIFICATION_READ_RESPONSE:
+                if (message.success) {
+                    this.markAsReadEvent$.next(message.notificationId ?? null);
+                    this.requestUnreadCount();
+                }
+                break;
+            case WS_MESSAGE_TYPE.NOTIFICATION_MARKED_READ:
+                // Broadcast from another session of same user. notificationId optional
+                // (absent ⇒ "all read").
+                this.markAsReadEvent$.next(message.notificationId ?? null);
+                this.requestUnreadCount();
+                break;
+            case WS_MESSAGE_TYPE.MARK_ALL_NOTIFICATION_READ_RESPONSE:
+                if (message.success) {
+                    this.markAsReadEvent$.next(null);
+                    this.requestUnreadCount();
+                }
+                break;
+            case WS_MESSAGE_TYPE.CLEAR_NOTIFICATION_RESPONSE:
+            case WS_MESSAGE_TYPE.NOTIFICATION_CLEARED:
+                if (Array.isArray(message.notificationIds) && message.notificationIds.length) {
+                    this.clearEvent$.next(message.notificationIds);
+                    this.requestUnreadCount();
+                }
+                break;
+            case WS_MESSAGE_TYPE.CLEAR_ALL_NOTIFICATIONS_RESPONSE:
+                if (message.success) {
+                    this.clearEvent$.next(null);
+                    this.requestUnreadCount();
+                }
+                break;
+            case WS_MESSAGE_TYPE.ALL_NOTIFICATIONS_CLEARED:
+                if (message.success) {
+                    this.clearEvent$.next(null);
+                    this.requestUnreadCount();
+                }
+                break;
+            case WS_MESSAGE_TYPE.CONNECTION_ESTABLISHED:
+                // Server confirms the connection is live. Fire the post-connect
+                // unread-count fetch here — works whether the resolver-time await
+                // saw the connection open or timed out early.
+                if (this.workspaceKey) {
+                    this.requestUnreadCount();
+                }
+                break;
+            // PONG, HEARTBEAT_ACK, ERROR are handled at the transport layer
+            // (or are no-ops). HEARTBEAT is intercepted by transport and never forwarded.
+        }
+    }
+    /**
+     * Parse an inbox notification's `data` JSON into a UI-shaped object.
+     *
+     * Read state is surfaced via `status === 'Read'` (confirmed by BE).
+     * Inbox response only contains `Delivered` (unread) + `Read` items;
+     * `Pending` / `Done` / `Failed` are filtered out server-side.
+     */
+    parseInboxNotification(item) {
+        let parsedPayload = {};
+        try {
+            parsedPayload = JSON.parse(item.data);
+        }
+        catch {
+            parsedPayload = {};
+        }
+        return {
+            id: item.id,
+            createdAt: item.createdAt,
+            status: item.status,
+            priority: item.priority,
+            parsedPayload,
+            isRead: item.status === 'Read',
+        };
+    }
+    /**
+     * Wrap a server-pushed live notification into the same UI shape as inbox items.
+     * The push event has fields flat at the top level (NOT inside `data`) — synthesize
+     * `parsedPayload` from those fields so the component sees a uniform shape.
+     */
+    transformPushNotification(push) {
+        return {
+            id: push.id,
+            createdAt: push.createdAt,
+            status: 'Delivered',
+            priority: push.priority,
+            parsedPayload: {
+                title: push.title,
+                body: push.body,
+                category: push.category,
+                priority: push.priority,
+            },
+            isRead: false,
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.21", ngImport: i0, type: NotificationInboxService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.21", ngImport: i0, type: NotificationInboxService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.21", ngImport: i0, type: NotificationInboxService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"notification-inbox.service.js","sourceRoot":"","sources":["../../../../../../../../../libs/data-access/src/lib/tab-core-utility/core/service/notification/notification-inbox.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable } from '@angular/core';\r\nimport { BehaviorSubject, Observable, Subject } from 'rxjs';\r\nimport {\r\n  NOTIFICATION_WS_CONFIG,\r\n  NotificationInboxConnectParams,\r\n  NotificationItem,\r\n  NotificationPushPayload,\r\n  ParsedNotificationPayload,\r\n  UiNotification,\r\n  WS_MESSAGE_TYPE,\r\n} from '../../../app/interfaces/notification.interface';\r\nimport { NotificationWebSocketService } from './notification-websocket.service';\r\n\r\n/**\r\n * Public notification inbox service.\r\n *\r\n * Pure — no storage / auth coupling. The caller (SDK facade) supplies all auth\r\n * identifiers via `connect(params)`, and they're held for the lifetime of the\r\n * connection (cleared on disconnect).\r\n *\r\n * Subscribes to the WebSocket transport, routes incoming messages by type into\r\n * dedicated streams, and exposes high-level actions for the UI.\r\n *\r\n * Components/extensions consume this via the SDK facade (`TabSdk.notification.*`),\r\n * not directly.\r\n *\r\n * Named `NotificationInboxService` to avoid collision with the existing toastr\r\n * `NotificationService` in `core/service/notification.service.ts`.\r\n */\r\n@Injectable({ providedIn: 'root' })\r\nexport class NotificationInboxService {\r\n  private readonly ws = inject(NotificationWebSocketService);\r\n\r\n  // Held between connect() and disconnect() — every outbound message includes it.\r\n  private workspaceKey: string | null = null;\r\n\r\n  // ----------- streams -----------\r\n\r\n  private readonly latestNotifications$ = new Subject<UiNotification | UiNotification[]>();\r\n  private readonly unreadCount$ = new BehaviorSubject<number>(0);\r\n  private readonly markAsReadEvent$ = new Subject<string | null>();\r\n  private readonly clearEvent$ = new Subject<string[] | null>();\r\n  private readonly loading$ = new BehaviorSubject<boolean>(false);\r\n  private readonly totalPages$ = new BehaviorSubject<number>(1);\r\n  private loadMoreTimer: ReturnType<typeof setTimeout> | null = null;\r\n\r\n  constructor() {\r\n    // Route inbound messages → streams\r\n    this.ws.messages$.subscribe((message) => this.handleMessage(message));\r\n  }\r\n\r\n  // ----------- lifecycle -----------\r\n\r\n  /**\r\n   * Connect to the notification WebSocket. Awaitable, idempotent.\r\n   *\r\n   * If a connection is already active for a *different* workspace (tenant/app/env\r\n   * switch without signOut), we tear it down first so the new connection uses\r\n   * the correct URL and workspaceKey. The underlying `ws.connect` is idempotent\r\n   * by connection state, so it would otherwise keep the stale URL.\r\n   *\r\n   * Once connected, an unread-count fetch is fired automatically so the badge populates.\r\n   */\r\n  async connect(params: NotificationInboxConnectParams): Promise<void> {\r\n    if (this.workspaceKey && this.workspaceKey !== params.workspaceKey) {\r\n      await this.disconnect();\r\n    }\r\n\r\n    this.workspaceKey = params.workspaceKey;\r\n\r\n    await this.ws.connect({\r\n      userId: params.userId,\r\n      appId: params.appId,\r\n      tenantId: params.tenantId,\r\n    });\r\n\r\n    if (this.ws.isConnected()) {\r\n      this.requestUnreadCount();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Tear down the connection. Resets all stream state so the UI clears.\r\n   */\r\n  async disconnect(): Promise<void> {\r\n    await this.ws.disconnect();\r\n    this.workspaceKey = null;\r\n    this.unreadCount$.next(0);\r\n    this.totalPages$.next(1);\r\n    this.loading$.next(false);\r\n    if (this.loadMoreTimer) {\r\n      clearTimeout(this.loadMoreTimer);\r\n      this.loadMoreTimer = null;\r\n    }\r\n  }\r\n\r\n  // ----------- actions -----------\r\n\r\n  /**\r\n   * Fetch a page of notifications. Server replies via GET_NOTIFICATIONS_RESPONSE.\r\n   *\r\n   * Skips entirely when the socket isn't connected — otherwise we'd set\r\n   * `loading$` true, send into a no-op, and the UI would spin forever.\r\n   *\r\n   * Adds a safety timeout so the spinner clears even if the BE accepts the\r\n   * connection but never replies (broken hub, dropped frame, etc.).\r\n   */\r\n  loadMore(pageNumber: number, pageSize: number = NOTIFICATION_WS_CONFIG.DEFAULT_PAGE_SIZE): void {\r\n    if (!this.workspaceKey || !this.ws.isConnected()) return;\r\n\r\n    this.loading$.next(true);\r\n    this.ws.send({\r\n      type: WS_MESSAGE_TYPE.GET_NOTIFICATIONS,\r\n      workspaceKey: this.workspaceKey,\r\n      pageNumber,\r\n      pageSize,\r\n    });\r\n\r\n    if (this.loadMoreTimer) clearTimeout(this.loadMoreTimer);\r\n    this.loadMoreTimer = setTimeout(() => {\r\n      this.loadMoreTimer = null;\r\n      if (this.loading$.value) {\r\n        this.loading$.next(false);\r\n      }\r\n    }, NOTIFICATION_WS_CONFIG.LOAD_TIMEOUT_MS);\r\n  }\r\n\r\n  /**\r\n   * Request unread count. Result arrives on `unreadCount$`.\r\n   */\r\n  requestUnreadCount(): void {\r\n    if (!this.workspaceKey) return;\r\n    this.ws.send({\r\n      type: WS_MESSAGE_TYPE.GET_UNREAD_COUNT,\r\n      workspaceKey: this.workspaceKey,\r\n    });\r\n  }\r\n\r\n  markAsRead(notificationId: string): void {\r\n    if (!this.workspaceKey) return;\r\n    this.ws.send({\r\n      type: WS_MESSAGE_TYPE.MARK_NOTIFICATION_READ,\r\n      workspaceKey: this.workspaceKey,\r\n      notificationId,\r\n    });\r\n  }\r\n\r\n  markAllAsRead(): void {\r\n    if (!this.workspaceKey) return;\r\n    this.ws.send({\r\n      type: WS_MESSAGE_TYPE.MARK_ALL_NOTIFICATION_READ,\r\n      workspaceKey: this.workspaceKey,\r\n    });\r\n  }\r\n\r\n  clearOne(notificationId: string): void {\r\n    if (!this.workspaceKey) return;\r\n    this.ws.send({\r\n      type: WS_MESSAGE_TYPE.CLEAR_NOTIFICATION,\r\n      workspaceKey: this.workspaceKey,\r\n      notificationId,\r\n    });\r\n  }\r\n\r\n  clearAll(): void {\r\n    if (!this.workspaceKey) return;\r\n    this.ws.send({\r\n      type: WS_MESSAGE_TYPE.CLEAR_ALL_NOTIFICATIONS,\r\n      workspaceKey: this.workspaceKey,\r\n    });\r\n  }\r\n\r\n  // ----------- streams (read-only views) -----------\r\n\r\n  getLatestNotifications(): Observable<UiNotification | UiNotification[]> {\r\n    return this.latestNotifications$.asObservable();\r\n  }\r\n\r\n  getUnreadCount(): Observable<number> {\r\n    return this.unreadCount$.asObservable();\r\n  }\r\n\r\n  getMarkAsReadEvents(): Observable<string | null> {\r\n    return this.markAsReadEvent$.asObservable();\r\n  }\r\n\r\n  getClearEvents(): Observable<string[] | null> {\r\n    return this.clearEvent$.asObservable();\r\n  }\r\n\r\n  getLoadingState(): Observable<boolean> {\r\n    return this.loading$.asObservable();\r\n  }\r\n\r\n  getTotalPages(): Observable<number> {\r\n    return this.totalPages$.asObservable();\r\n  }\r\n\r\n  // ----------- internal -----------\r\n\r\n  private handleMessage(message: any): void {\r\n    if (!message?.type) return;\r\n\r\n    switch (message.type) {\r\n      case WS_MESSAGE_TYPE.GET_NOTIFICATIONS_RESPONSE:\r\n        if (message.success) {\r\n          const items: NotificationItem[] = message.notifications ?? [];\r\n          const ui = items.map((n) => this.parseInboxNotification(n));\r\n          this.latestNotifications$.next(ui);\r\n          this.totalPages$.next(message.totalPages ?? 1);\r\n        }\r\n        this.loading$.next(false);\r\n        if (this.loadMoreTimer) {\r\n          clearTimeout(this.loadMoreTimer);\r\n          this.loadMoreTimer = null;\r\n        }\r\n        break;\r\n\r\n      case WS_MESSAGE_TYPE.GET_UNREAD_COUNT_RESPONSE:\r\n        if (message.success) {\r\n          this.unreadCount$.next(message.count ?? 0);\r\n        }\r\n        break;\r\n\r\n      case WS_MESSAGE_TYPE.NOTIFICATION: {\r\n        const ui = this.transformPushNotification(message);\r\n        this.latestNotifications$.next(ui);\r\n        this.requestUnreadCount();\r\n        break;\r\n      }\r\n\r\n      case WS_MESSAGE_TYPE.MARK_NOTIFICATION_READ_RESPONSE:\r\n        if (message.success) {\r\n          this.markAsReadEvent$.next(message.notificationId ?? null);\r\n          this.requestUnreadCount();\r\n        }\r\n        break;\r\n\r\n      case WS_MESSAGE_TYPE.NOTIFICATION_MARKED_READ:\r\n        // Broadcast from another session of same user. notificationId optional\r\n        // (absent ⇒ \"all read\").\r\n        this.markAsReadEvent$.next(message.notificationId ?? null);\r\n        this.requestUnreadCount();\r\n        break;\r\n\r\n      case WS_MESSAGE_TYPE.MARK_ALL_NOTIFICATION_READ_RESPONSE:\r\n        if (message.success) {\r\n          this.markAsReadEvent$.next(null);\r\n          this.requestUnreadCount();\r\n        }\r\n        break;\r\n\r\n      case WS_MESSAGE_TYPE.CLEAR_NOTIFICATION_RESPONSE:\r\n      case WS_MESSAGE_TYPE.NOTIFICATION_CLEARED:\r\n        if (Array.isArray(message.notificationIds) && message.notificationIds.length) {\r\n          this.clearEvent$.next(message.notificationIds);\r\n          this.requestUnreadCount();\r\n        }\r\n        break;\r\n\r\n      case WS_MESSAGE_TYPE.CLEAR_ALL_NOTIFICATIONS_RESPONSE:\r\n        if (message.success) {\r\n          this.clearEvent$.next(null);\r\n          this.requestUnreadCount();\r\n        }\r\n        break;\r\n\r\n      case WS_MESSAGE_TYPE.ALL_NOTIFICATIONS_CLEARED:\r\n        if (message.success) {\r\n          this.clearEvent$.next(null);\r\n          this.requestUnreadCount();\r\n        }\r\n        break;\r\n\r\n      case WS_MESSAGE_TYPE.CONNECTION_ESTABLISHED:\r\n        // Server confirms the connection is live. Fire the post-connect\r\n        // unread-count fetch here — works whether the resolver-time await\r\n        // saw the connection open or timed out early.\r\n        if (this.workspaceKey) {\r\n          this.requestUnreadCount();\r\n        }\r\n        break;\r\n\r\n      // PONG, HEARTBEAT_ACK, ERROR are handled at the transport layer\r\n      // (or are no-ops). HEARTBEAT is intercepted by transport and never forwarded.\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Parse an inbox notification's `data` JSON into a UI-shaped object.\r\n   *\r\n   * Read state is surfaced via `status === 'Read'` (confirmed by BE).\r\n   * Inbox response only contains `Delivered` (unread) + `Read` items;\r\n   * `Pending` / `Done` / `Failed` are filtered out server-side.\r\n   */\r\n  private parseInboxNotification(item: NotificationItem): UiNotification {\r\n    let parsedPayload: ParsedNotificationPayload = {};\r\n    try {\r\n      parsedPayload = JSON.parse(item.data) as ParsedNotificationPayload;\r\n    } catch {\r\n      parsedPayload = {};\r\n    }\r\n\r\n    return {\r\n      id: item.id,\r\n      createdAt: item.createdAt,\r\n      status: item.status,\r\n      priority: item.priority,\r\n      parsedPayload,\r\n      isRead: item.status === 'Read',\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Wrap a server-pushed live notification into the same UI shape as inbox items.\r\n   * The push event has fields flat at the top level (NOT inside `data`) — synthesize\r\n   * `parsedPayload` from those fields so the component sees a uniform shape.\r\n   */\r\n  private transformPushNotification(push: NotificationPushPayload): UiNotification {\r\n    return {\r\n      id: push.id,\r\n      createdAt: push.createdAt,\r\n      status: 'Delivered',\r\n      priority: push.priority,\r\n      parsedPayload: {\r\n        title: push.title,\r\n        body: push.body,\r\n        category: push.category,\r\n        priority: push.priority,\r\n      },\r\n      isRead: false,\r\n    };\r\n  }\r\n}\r\n"]}

package/esm2022/lib/tab-core-utility/core/service/notification/notification-websocket.service.mjs

@@ -0,0 +1,220 @@
+import { Injectable, signal } from '@angular/core';
+import { Subject } from 'rxjs';
+import { webSocket } from 'rxjs/webSocket';
+import { Common } from '../../../app/constants/common';
+import { NOTIFICATION_WS_CONFIG, WS_CONNECTION_STATE, WS_MESSAGE_TYPE, } from '../../../app/interfaces/notification.interface';
+import * as i0 from "@angular/core";
+/**
+ * Low-level Notification WebSocket transport.
+ *
+ * Pure — no storage / auth coupling. The caller (SDK facade or app layer)
+ * supplies all auth identifiers via `connect(params)`.
+ *
+ * Mirrors the SignalR infrastructure pattern:
+ *  - connect() is idempotent, dedupes concurrent calls, tears down stale sockets
+ *  - disconnect() flips an explicit-disconnected flag so retries don't revive
+ *  - state exposed as Angular signal
+ *  - inbound messages forwarded on `messages$` for higher-level service to route
+ *
+ * Internal use — consumers should use `NotificationInboxService` instead.
+ */
+export class NotificationWebSocketService {
+    constructor() {
+        this.socket = null;
+        this.socketSub = null;
+        // In-flight connect promise — used to dedupe concurrent connect() calls
+        this.connectingPromise = null;
+        // Set true on explicit disconnect() so scheduled retries don't resurrect the connection
+        this.explicitlyDisconnected = false;
+        // Last connect params — kept so reconnect can rebuild the URL without the caller
+        // re-supplying them. Cleared on disconnect().
+        this.lastParams = null;
+        // Reconnect attempt counter (resets on successful connect)
+        this.reconnectAttempt = 0;
+        this.reconnectTimer = null;
+        // Connection state as Angular signal — for UI indicators / route resolvers
+        this.connectionState = signal(WS_CONNECTION_STATE.DISCONNECTED);
+        // Inbound message stream — NotificationInboxService subscribes and routes per type
+        this.messages$ = new Subject();
+    }
+    // ----------- public API -----------
+    /**
+     * Establish the WebSocket connection.
+     *
+     * Idempotent — if already OPEN, resolves immediately.
+     * In-flight calls are de-duplicated.
+     * Any stale (non-OPEN) socket is torn down before rebuild.
+     */
+    async connect(params) {
+        this.explicitlyDisconnected = false;
+        this.lastParams = params;
+        if (this.connectionState() === WS_CONNECTION_STATE.CONNECTED) {
+            return;
+        }
+        // If a connect is already in flight, wait for it (capped) — don't start a second one.
+        if (this.connectingPromise) {
+            return this.raceWithTimeout(this.connectingPromise);
+        }
+        if (this.socket) {
+            try {
+                this.socket.complete();
+            }
+            catch { /* ignore */ }
+            this.socket = null;
+            this.socketSub?.unsubscribe();
+            this.socketSub = null;
+        }
+        this.connectingPromise = this.doConnect(params);
+        // Null connectingPromise once the underlying handshake actually settles
+        // (open / close / error). We do NOT null it on the timeout — the WS keeps
+        // trying in the background, and a concurrent connect() should join the
+        // same in-flight attempt instead of starting a new one.
+        this.connectingPromise.finally(() => {
+            this.connectingPromise = null;
+        });
+        // Block the caller for at most CONNECT_TIMEOUT_MS so the route resolver
+        // doesn't hang for ~21s on a TCP timeout when the BE is unreachable.
+        return this.raceWithTimeout(this.connectingPromise);
+    }
+    raceWithTimeout(p) {
+        return Promise.race([
+            p,
+            new Promise(resolve => setTimeout(resolve, NOTIFICATION_WS_CONFIG.CONNECT_TIMEOUT_MS)),
+        ]);
+    }
+    async doConnect(params) {
+        const baseUrl = Common.notificationWebSocketUrl;
+        if (!baseUrl) {
+            this.connectionState.set(WS_CONNECTION_STATE.DISCONNECTED);
+            return;
+        }
+        if (!params.userId) {
+            console.warn('[NotificationWS] No userId provided — skipping connect');
+            this.connectionState.set(WS_CONNECTION_STATE.FAILED);
+            return;
+        }
+        // BE doc: ws://host/ws?userId=...&appId=...&tenantId=...
+        const url = `${baseUrl}?userId=${encodeURIComponent(params.userId)}` +
+            (params.appId ? `&appId=${encodeURIComponent(params.appId)}` : '') +
+            (params.tenantId ? `&tenantId=${encodeURIComponent(params.tenantId)}` : '');
+        this.connectionState.set(WS_CONNECTION_STATE.CONNECTING);
+        return new Promise((resolve) => {
+            this.socket = webSocket({
+                url,
+                openObserver: {
+                    next: () => {
+                        this.connectionState.set(WS_CONNECTION_STATE.CONNECTED);
+                        this.reconnectAttempt = 0;
+                        resolve();
+                    },
+                },
+                closeObserver: {
+                    next: () => {
+                        if (this.connectionState() !== WS_CONNECTION_STATE.CLOSED) {
+                            this.connectionState.set(WS_CONNECTION_STATE.DISCONNECTED);
+                        }
+                        this.scheduleReconnect();
+                        resolve();
+                    },
+                },
+            });
+            this.socketSub = this.socket.subscribe({
+                next: (msg) => this.handleIncoming(msg),
+                error: (err) => {
+                    console.error('[NotificationWS] Socket error:', err);
+                    this.connectionState.set(WS_CONNECTION_STATE.FAILED);
+                    this.scheduleReconnect();
+                    resolve();
+                },
+            });
+        });
+    }
+    /**
+     * Send a message over the socket. Silently no-ops if not connected.
+     */
+    send(message) {
+        if (!this.socket || this.connectionState() !== WS_CONNECTION_STATE.CONNECTED) {
+            return;
+        }
+        try {
+            this.socket.next(message);
+        }
+        catch (error) {
+            console.error('[NotificationWS] Failed to send message:', error);
+        }
+    }
+    /**
+     * Tear down the socket.
+     *
+     * Sets explicitlyDisconnected so any pending retry timers become no-ops,
+     * then closes the socket and clears state.
+     */
+    async disconnect() {
+        this.explicitlyDisconnected = true;
+        this.connectingPromise = null;
+        this.lastParams = null;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.socket) {
+            try {
+                this.socket.complete();
+            }
+            catch { /* ignore */ }
+            this.socket = null;
+        }
+        this.socketSub?.unsubscribe();
+        this.socketSub = null;
+        this.reconnectAttempt = 0;
+        this.connectionState.set(WS_CONNECTION_STATE.CLOSED);
+    }
+    // ----------- internal -----------
+    handleIncoming(message) {
+        if (!message || typeof message !== 'object')
+            return;
+        // Heartbeat: server pings every ~30s; we MUST reply or BE will close the socket.
+        if (message.type === WS_MESSAGE_TYPE.HEARTBEAT) {
+            this.send({ type: WS_MESSAGE_TYPE.HEARTBEAT });
+            return;
+        }
+        if (message.type === WS_MESSAGE_TYPE.CONNECTION_ESTABLISHED) {
+            this.connectionState.set(WS_CONNECTION_STATE.CONNECTED);
+        }
+        if (message.type === WS_MESSAGE_TYPE.ERROR) {
+            console.warn('[NotificationWS] Server error:', message.error);
+        }
+        this.messages$.next(message);
+    }
+    scheduleReconnect() {
+        if (this.explicitlyDisconnected)
+            return;
+        if (this.reconnectTimer)
+            return;
+        if (!this.lastParams)
+            return; // can't reconnect without params
+        const delays = NOTIFICATION_WS_CONFIG.RECONNECT_DELAYS_MS;
+        const delay = delays[Math.min(this.reconnectAttempt, delays.length - 1)];
+        this.reconnectAttempt++;
+        this.connectionState.set(WS_CONNECTION_STATE.RECONNECTING);
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            if (!this.explicitlyDisconnected && this.lastParams) {
+                this.connect(this.lastParams);
+            }
+        }, delay);
+    }
+    /**
+     * Snapshot of current connection state — for debugging.
+     */
+    isConnected() {
+        return this.connectionState() === WS_CONNECTION_STATE.CONNECTED;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.21", ngImport: i0, type: NotificationWebSocketService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.21", ngImport: i0, type: NotificationWebSocketService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.21", ngImport: i0, type: NotificationWebSocketService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"notification-websocket.service.js","sourceRoot":"","sources":["../../../../../../../../../libs/data-access/src/lib/tab-core-utility/core/service/notification/notification-websocket.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,OAAO,EAAgB,MAAM,MAAM,CAAC;AAC7C,OAAO,EAAE,SAAS,EAAoB,MAAM,gBAAgB,CAAC;AAC7D,OAAO,EAAE,MAAM,EAAE,MAAM,+BAA+B,CAAC;AACvD,OAAO,EACL,sBAAsB,EAEtB,mBAAmB,EACnB,eAAe,GAEhB,MAAM,gDAAgD,CAAC;;AAExD;;;;;;;;;;;;;GAaG;AAEH,MAAM,OAAO,4BAA4B;IADzC;QAEU,WAAM,GAAiC,IAAI,CAAC;QAC5C,cAAS,GAAwB,IAAI,CAAC;QAE9C,wEAAwE;QAChE,sBAAiB,GAAyB,IAAI,CAAC;QAEvD,wFAAwF;QAChF,2BAAsB,GAAG,KAAK,CAAC;QAEvC,iFAAiF;QACjF,8CAA8C;QACtC,eAAU,GAA8C,IAAI,CAAC;QAErE,2DAA2D;QACnD,qBAAgB,GAAG,CAAC,CAAC;QACrB,mBAAc,GAAyC,IAAI,CAAC;QAEpE,2EAA2E;QAClE,oBAAe,GAAG,MAAM,CAAoB,mBAAmB,CAAC,YAAY,CAAC,CAAC;QAEvF,mFAAmF;QAC1E,cAAS,GAAG,IAAI,OAAO,EAAO,CAAC;KAoMzC;IAlMC,qCAAqC;IAErC;;;;;;OAMG;IACH,KAAK,CAAC,OAAO,CAAC,MAA0C;QACtD,IAAI,CAAC,sBAAsB,GAAG,KAAK,CAAC;QACpC,IAAI,CAAC,UAAU,GAAG,MAAM,CAAC;QAEzB,IAAI,IAAI,CAAC,eAAe,EAAE,KAAK,mBAAmB,CAAC,SAAS,EAAE,CAAC;YAC7D,OAAO;QACT,CAAC;QAED,sFAAsF;QACtF,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;YAC3B,OAAO,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;QACtD,CAAC;QAED,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChB,IAAI,CAAC;gBAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;YAAC,CAAC;YAAC,MAAM,CAAC,CAAC,YAAY,CAAC,CAAC;YACtD,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;YACnB,IAAI,CAAC,SAAS,EAAE,WAAW,EAAE,CAAC;YAC9B,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACxB,CAAC;QAED,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;QAChD,wEAAwE;QACxE,0EAA0E;QAC1E,uEAAuE;QACvE,wDAAwD;QACxD,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,GAAG,EAAE;YAClC,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;QAChC,CAAC,CAAC,CAAC;QAEH,wEAAwE;QACxE,qEAAqE;QACrE,OAAO,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;IACtD,CAAC;IAEO,eAAe,CAAC,CAAgB;QACtC,OAAO,OAAO,CAAC,IAAI,CAAC;YAClB,CAAC;YACD,IAAI,OAAO,CAAO,OAAO,CAAC,EAAE,CAC1B,UAAU,CAAC,OAAO,EAAE,sBAAsB,CAAC,kBAAkB,CAAC,CAC/D;SACF,CAAC,CAAC;IACL,CAAC;IAEO,KAAK,CAAC,SAAS,CAAC,MAA0C;QAChE,MAAM,OAAO,GAAG,MAAM,CAAC,wBAAwB,CAAC;QAChD,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,mBAAmB,CAAC,YAAY,CAAC,CAAC;YAC3D,OAAO;QACT,CAAC;QAED,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;YACnB,OAAO,CAAC,IAAI,CAAC,wDAAwD,CAAC,CAAC;YACvE,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC;YACrD,OAAO;QACT,CAAC;QAED,yDAAyD;QACzD,MAAM,GAAG,GAAG,GAAG,OAAO,WAAW,kBAAkB,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE;YAClE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,UAAU,kBAAkB,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YAClE,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,aAAa,kBAAkB,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QAE9E,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,mBAAmB,CAAC,UAAU,CAAC,CAAC;QAEzD,OAAO,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE;YACnC,IAAI,CAAC,MAAM,GAAG,SAAS,CAAM;gBAC3B,GAAG;gBACH,YAAY,EAAE;oBACZ,IAAI,EAAE,GAAG,EAAE;wBACT,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,mBAAmB,CAAC,SAAS,CAAC,CAAC;wBACxD,IAAI,CAAC,gBAAgB,GAAG,CAAC,CAAC;wBAC1B,OAAO,EAAE,CAAC;oBACZ,CAAC;iBACF;gBACD,aAAa,EAAE;oBACb,IAAI,EAAE,GAAG,EAAE;wBACT,IAAI,IAAI,CAAC,eAAe,EAAE,KAAK,mBAAmB,CAAC,MAAM,EAAE,CAAC;4BAC1D,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,mBAAmB,CAAC,YAAY,CAAC,CAAC;wBAC7D,CAAC;wBACD,IAAI,CAAC,iBAAiB,EAAE,CAAC;wBACzB,OAAO,EAAE,CAAC;oBACZ,CAAC;iBACF;aACF,CAAC,CAAC;YAEH,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC;gBACrC,IAAI,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC;gBACvC,KAAK,EAAE,CAAC,GAAG,EAAE,EAAE;oBACb,OAAO,CAAC,KAAK,CAAC,gCAAgC,EAAE,GAAG,CAAC,CAAC;oBACrD,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC;oBACrD,IAAI,CAAC,iBAAiB,EAAE,CAAC;oBACzB,OAAO,EAAE,CAAC;gBACZ,CAAC;aACF,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,IAAI,CAAC,OAA4B;QAC/B,IAAI,CAAC,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,eAAe,EAAE,KAAK,mBAAmB,CAAC,SAAS,EAAE,CAAC;YAC7E,OAAO;QACT,CAAC;QACD,IAAI,CAAC;YACH,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC5B,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,0CAA0C,EAAE,KAAK,CAAC,CAAC;QACnE,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,UAAU;QACd,IAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC;QACnC,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;QAC9B,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;QAEvB,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;YACxB,YAAY,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;YAClC,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;QAC7B,CAAC;QAED,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChB,IAAI,CAAC;gBAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;YAAC,CAAC;YAAC,MAAM,CAAC,CAAC,YAAY,CAAC,CAAC;YACtD,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;QACrB,CAAC;QAED,IAAI,CAAC,SAAS,EAAE,WAAW,EAAE,CAAC;QAC9B,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QAEtB,IAAI,CAAC,gBAAgB,GAAG,CAAC,CAAC;QAC1B,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC;IACvD,CAAC;IAED,mCAAmC;IAE3B,cAAc,CAAC,OAAY;QACjC,IAAI,CAAC,OAAO,IAAI,OAAO,OAAO,KAAK,QAAQ;YAAE,OAAO;QAEpD,iFAAiF;QACjF,IAAI,OAAO,CAAC,IAAI,KAAK,eAAe,CAAC,SAAS,EAAE,CAAC;YAC/C,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,eAAe,CAAC,SAAS,EAAE,CAAC,CAAC;YAC/C,OAAO;QACT,CAAC;QAED,IAAI,OAAO,CAAC,IAAI,KAAK,eAAe,CAAC,sBAAsB,EAAE,CAAC;YAC5D,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,mBAAmB,CAAC,SAAS,CAAC,CAAC;QAC1D,CAAC;QAED,IAAI,OAAO,CAAC,IAAI,KAAK,eAAe,CAAC,KAAK,EAAE,CAAC;YAC3C,OAAO,CAAC,IAAI,CAAC,gCAAgC,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;QAChE,CAAC;QAED,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC/B,CAAC;IAEO,iBAAiB;QACvB,IAAI,IAAI,CAAC,sBAAsB;YAAE,OAAO;QACxC,IAAI,IAAI,CAAC,cAAc;YAAE,OAAO;QAChC,IAAI,CAAC,IAAI,CAAC,UAAU;YAAE,OAAO,CAAC,iCAAiC;QAE/D,MAAM,MAAM,GAAG,sBAAsB,CAAC,mBAAmB,CAAC;QAC1D,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,gBAAgB,EAAE,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC;QACzE,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAExB,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,mBAAmB,CAAC,YAAY,CAAC,CAAC;QAE3D,IAAI,CAAC,cAAc,GAAG,UAAU,CAAC,GAAG,EAAE;YACpC,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;YAC3B,IAAI,CAAC,IAAI,CAAC,sBAAsB,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;gBACpD,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAChC,CAAC;QACH,CAAC,EAAE,KAAK,CAAC,CAAC;IACZ,CAAC;IAED;;OAEG;IACH,WAAW;QACT,OAAO,IAAI,CAAC,eAAe,EAAE,KAAK,mBAAmB,CAAC,SAAS,CAAC;IAClE,CAAC;+GAzNU,4BAA4B;mHAA5B,4BAA4B,cADf,MAAM;;4FACnB,4BAA4B;kBADxC,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE","sourcesContent":["import { Injectable, signal } from '@angular/core';\r\nimport { Subject, Subscription } from 'rxjs';\r\nimport { webSocket, WebSocketSubject } from 'rxjs/webSocket';\r\nimport { Common } from '../../../app/constants/common';\r\nimport {\r\n  NOTIFICATION_WS_CONFIG,\r\n  NotificationWebSocketConnectParams,\r\n  WS_CONNECTION_STATE,\r\n  WS_MESSAGE_TYPE,\r\n  WsConnectionState,\r\n} from '../../../app/interfaces/notification.interface';\r\n\r\n/**\r\n * Low-level Notification WebSocket transport.\r\n *\r\n * Pure — no storage / auth coupling. The caller (SDK facade or app layer)\r\n * supplies all auth identifiers via `connect(params)`.\r\n *\r\n * Mirrors the SignalR infrastructure pattern:\r\n *  - connect() is idempotent, dedupes concurrent calls, tears down stale sockets\r\n *  - disconnect() flips an explicit-disconnected flag so retries don't revive\r\n *  - state exposed as Angular signal\r\n *  - inbound messages forwarded on `messages$` for higher-level service to route\r\n *\r\n * Internal use — consumers should use `NotificationInboxService` instead.\r\n */\r\n@Injectable({ providedIn: 'root' })\r\nexport class NotificationWebSocketService {\r\n  private socket: WebSocketSubject<any> | null = null;\r\n  private socketSub: Subscription | null = null;\r\n\r\n  // In-flight connect promise — used to dedupe concurrent connect() calls\r\n  private connectingPromise: Promise<void> | null = null;\r\n\r\n  // Set true on explicit disconnect() so scheduled retries don't resurrect the connection\r\n  private explicitlyDisconnected = false;\r\n\r\n  // Last connect params — kept so reconnect can rebuild the URL without the caller\r\n  // re-supplying them. Cleared on disconnect().\r\n  private lastParams: NotificationWebSocketConnectParams | null = null;\r\n\r\n  // Reconnect attempt counter (resets on successful connect)\r\n  private reconnectAttempt = 0;\r\n  private reconnectTimer: ReturnType<typeof setTimeout> | null = null;\r\n\r\n  // Connection state as Angular signal — for UI indicators / route resolvers\r\n  readonly connectionState = signal<WsConnectionState>(WS_CONNECTION_STATE.DISCONNECTED);\r\n\r\n  // Inbound message stream — NotificationInboxService subscribes and routes per type\r\n  readonly messages$ = new Subject<any>();\r\n\r\n  // ----------- public API -----------\r\n\r\n  /**\r\n   * Establish the WebSocket connection.\r\n   *\r\n   * Idempotent — if already OPEN, resolves immediately.\r\n   * In-flight calls are de-duplicated.\r\n   * Any stale (non-OPEN) socket is torn down before rebuild.\r\n   */\r\n  async connect(params: NotificationWebSocketConnectParams): Promise<void> {\r\n    this.explicitlyDisconnected = false;\r\n    this.lastParams = params;\r\n\r\n    if (this.connectionState() === WS_CONNECTION_STATE.CONNECTED) {\r\n      return;\r\n    }\r\n\r\n    // If a connect is already in flight, wait for it (capped) — don't start a second one.\r\n    if (this.connectingPromise) {\r\n      return this.raceWithTimeout(this.connectingPromise);\r\n    }\r\n\r\n    if (this.socket) {\r\n      try { this.socket.complete(); } catch { /* ignore */ }\r\n      this.socket = null;\r\n      this.socketSub?.unsubscribe();\r\n      this.socketSub = null;\r\n    }\r\n\r\n    this.connectingPromise = this.doConnect(params);\r\n    // Null connectingPromise once the underlying handshake actually settles\r\n    // (open / close / error). We do NOT null it on the timeout — the WS keeps\r\n    // trying in the background, and a concurrent connect() should join the\r\n    // same in-flight attempt instead of starting a new one.\r\n    this.connectingPromise.finally(() => {\r\n      this.connectingPromise = null;\r\n    });\r\n\r\n    // Block the caller for at most CONNECT_TIMEOUT_MS so the route resolver\r\n    // doesn't hang for ~21s on a TCP timeout when the BE is unreachable.\r\n    return this.raceWithTimeout(this.connectingPromise);\r\n  }\r\n\r\n  private raceWithTimeout(p: Promise<void>): Promise<void> {\r\n    return Promise.race([\r\n      p,\r\n      new Promise<void>(resolve =>\r\n        setTimeout(resolve, NOTIFICATION_WS_CONFIG.CONNECT_TIMEOUT_MS)\r\n      ),\r\n    ]);\r\n  }\r\n\r\n  private async doConnect(params: NotificationWebSocketConnectParams): Promise<void> {\r\n    const baseUrl = Common.notificationWebSocketUrl;\r\n    if (!baseUrl) {\r\n      this.connectionState.set(WS_CONNECTION_STATE.DISCONNECTED);\r\n      return;\r\n    }\r\n\r\n    if (!params.userId) {\r\n      console.warn('[NotificationWS] No userId provided — skipping connect');\r\n      this.connectionState.set(WS_CONNECTION_STATE.FAILED);\r\n      return;\r\n    }\r\n\r\n    // BE doc: ws://host/ws?userId=...&appId=...&tenantId=...\r\n    const url = `${baseUrl}?userId=${encodeURIComponent(params.userId)}` +\r\n      (params.appId ? `&appId=${encodeURIComponent(params.appId)}` : '') +\r\n      (params.tenantId ? `&tenantId=${encodeURIComponent(params.tenantId)}` : '');\r\n\r\n    this.connectionState.set(WS_CONNECTION_STATE.CONNECTING);\r\n\r\n    return new Promise<void>((resolve) => {\r\n      this.socket = webSocket<any>({\r\n        url,\r\n        openObserver: {\r\n          next: () => {\r\n            this.connectionState.set(WS_CONNECTION_STATE.CONNECTED);\r\n            this.reconnectAttempt = 0;\r\n            resolve();\r\n          },\r\n        },\r\n        closeObserver: {\r\n          next: () => {\r\n            if (this.connectionState() !== WS_CONNECTION_STATE.CLOSED) {\r\n              this.connectionState.set(WS_CONNECTION_STATE.DISCONNECTED);\r\n            }\r\n            this.scheduleReconnect();\r\n            resolve();\r\n          },\r\n        },\r\n      });\r\n\r\n      this.socketSub = this.socket.subscribe({\r\n        next: (msg) => this.handleIncoming(msg),\r\n        error: (err) => {\r\n          console.error('[NotificationWS] Socket error:', err);\r\n          this.connectionState.set(WS_CONNECTION_STATE.FAILED);\r\n          this.scheduleReconnect();\r\n          resolve();\r\n        },\r\n      });\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Send a message over the socket. Silently no-ops if not connected.\r\n   */\r\n  send(message: Record<string, any>): void {\r\n    if (!this.socket || this.connectionState() !== WS_CONNECTION_STATE.CONNECTED) {\r\n      return;\r\n    }\r\n    try {\r\n      this.socket.next(message);\r\n    } catch (error) {\r\n      console.error('[NotificationWS] Failed to send message:', error);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Tear down the socket.\r\n   *\r\n   * Sets explicitlyDisconnected so any pending retry timers become no-ops,\r\n   * then closes the socket and clears state.\r\n   */\r\n  async disconnect(): Promise<void> {\r\n    this.explicitlyDisconnected = true;\r\n    this.connectingPromise = null;\r\n    this.lastParams = null;\r\n\r\n    if (this.reconnectTimer) {\r\n      clearTimeout(this.reconnectTimer);\r\n      this.reconnectTimer = null;\r\n    }\r\n\r\n    if (this.socket) {\r\n      try { this.socket.complete(); } catch { /* ignore */ }\r\n      this.socket = null;\r\n    }\r\n\r\n    this.socketSub?.unsubscribe();\r\n    this.socketSub = null;\r\n\r\n    this.reconnectAttempt = 0;\r\n    this.connectionState.set(WS_CONNECTION_STATE.CLOSED);\r\n  }\r\n\r\n  // ----------- internal -----------\r\n\r\n  private handleIncoming(message: any): void {\r\n    if (!message || typeof message !== 'object') return;\r\n\r\n    // Heartbeat: server pings every ~30s; we MUST reply or BE will close the socket.\r\n    if (message.type === WS_MESSAGE_TYPE.HEARTBEAT) {\r\n      this.send({ type: WS_MESSAGE_TYPE.HEARTBEAT });\r\n      return;\r\n    }\r\n\r\n    if (message.type === WS_MESSAGE_TYPE.CONNECTION_ESTABLISHED) {\r\n      this.connectionState.set(WS_CONNECTION_STATE.CONNECTED);\r\n    }\r\n\r\n    if (message.type === WS_MESSAGE_TYPE.ERROR) {\r\n      console.warn('[NotificationWS] Server error:', message.error);\r\n    }\r\n\r\n    this.messages$.next(message);\r\n  }\r\n\r\n  private scheduleReconnect(): void {\r\n    if (this.explicitlyDisconnected) return;\r\n    if (this.reconnectTimer) return;\r\n    if (!this.lastParams) return; // can't reconnect without params\r\n\r\n    const delays = NOTIFICATION_WS_CONFIG.RECONNECT_DELAYS_MS;\r\n    const delay = delays[Math.min(this.reconnectAttempt, delays.length - 1)];\r\n    this.reconnectAttempt++;\r\n\r\n    this.connectionState.set(WS_CONNECTION_STATE.RECONNECTING);\r\n\r\n    this.reconnectTimer = setTimeout(() => {\r\n      this.reconnectTimer = null;\r\n      if (!this.explicitlyDisconnected && this.lastParams) {\r\n        this.connect(this.lastParams);\r\n      }\r\n    }, delay);\r\n  }\r\n\r\n  /**\r\n   * Snapshot of current connection state — for debugging.\r\n   */\r\n  isConnected(): boolean {\r\n    return this.connectionState() === WS_CONNECTION_STATE.CONNECTED;\r\n  }\r\n}\r\n"]}