@noatgnu/cupcake-core 1.2.17 → 1.3.1

package/fesm2022/noatgnu-cupcake-core.mjs

@@ -2,9 +2,9 @@ import * as i0 from '@angular/core';
 import { inject, InjectionToken, Injectable, signal, computed, Component, effect, ChangeDetectorRef, NgModule } from '@angular/core';
 import * as i1 from '@angular/common/http';
 import { HttpClient, HttpParams, provideHttpClient, withInterceptors, HttpClientModule } from '@angular/common/http';
-import { BehaviorSubject, catchError, throwError, switchMap, filter, take, map, tap, Subject, interval, timer, EMPTY, debounceTime, distinctUntilChanged } from 'rxjs';
+import { BehaviorSubject, catchError, throwError, switchMap, filter, take, map, tap, Subject, timer, EMPTY, interval, debounceTime, distinctUntilChanged } from 'rxjs';
 import { Router, ActivatedRoute, RouterModule } from '@angular/router';
-import { map as map$1, tap as tap$1, takeUntil, switchMap as switchMap$1 } from 'rxjs/operators';
+import { map as map$1, takeUntil, tap as tap$1, switchMap as switchMap$1, filter as filter$1 } from 'rxjs/operators';
 import * as i1$1 from '@angular/forms';
 import { FormBuilder, Validators, ReactiveFormsModule, FormsModule, NonNullableFormBuilder } from '@angular/forms';
 import * as i2 from '@angular/common';
@@ -89,6 +89,56 @@ var AnnotationType;
     AnnotationType["Booking"] = "booking";
 })(AnnotationType || (AnnotationType = {}));
 
+var TaskStatus;
+(function (TaskStatus) {
+    TaskStatus["QUEUED"] = "QUEUED";
+    TaskStatus["STARTED"] = "STARTED";
+    TaskStatus["SUCCESS"] = "SUCCESS";
+    TaskStatus["FAILURE"] = "FAILURE";
+    TaskStatus["CANCELLED"] = "CANCELLED";
+})(TaskStatus || (TaskStatus = {}));
+var TaskType;
+(function (TaskType) {
+    TaskType["EXPORT_EXCEL"] = "EXPORT_EXCEL";
+    TaskType["EXPORT_SDRF"] = "EXPORT_SDRF";
+    TaskType["IMPORT_SDRF"] = "IMPORT_SDRF";
+    TaskType["IMPORT_EXCEL"] = "IMPORT_EXCEL";
+    TaskType["EXPORT_MULTIPLE_SDRF"] = "EXPORT_MULTIPLE_SDRF";
+    TaskType["EXPORT_MULTIPLE_EXCEL"] = "EXPORT_MULTIPLE_EXCEL";
+    TaskType["VALIDATE_TABLE"] = "VALIDATE_TABLE";
+    TaskType["REORDER_TABLE_COLUMNS"] = "REORDER_TABLE_COLUMNS";
+    TaskType["REORDER_TEMPLATE_COLUMNS"] = "REORDER_TEMPLATE_COLUMNS";
+    TaskType["TRANSCRIBE_AUDIO"] = "TRANSCRIBE_AUDIO";
+    TaskType["TRANSCRIBE_VIDEO"] = "TRANSCRIBE_VIDEO";
+})(TaskType || (TaskType = {}));
+const TASK_TYPE_LABELS = {
+    [TaskType.EXPORT_EXCEL]: 'Export Excel Template',
+    [TaskType.EXPORT_SDRF]: 'Export SDRF File',
+    [TaskType.IMPORT_SDRF]: 'Import SDRF File',
+    [TaskType.IMPORT_EXCEL]: 'Import Excel File',
+    [TaskType.EXPORT_MULTIPLE_SDRF]: 'Export Multiple SDRF Files',
+    [TaskType.EXPORT_MULTIPLE_EXCEL]: 'Export Multiple Excel Templates',
+    [TaskType.VALIDATE_TABLE]: 'Validate Metadata Table',
+    [TaskType.REORDER_TABLE_COLUMNS]: 'Reorder Table Columns',
+    [TaskType.REORDER_TEMPLATE_COLUMNS]: 'Reorder Template Columns',
+    [TaskType.TRANSCRIBE_AUDIO]: 'Transcribe Audio',
+    [TaskType.TRANSCRIBE_VIDEO]: 'Transcribe Video',
+};
+const TASK_STATUS_LABELS = {
+    [TaskStatus.QUEUED]: 'Queued',
+    [TaskStatus.STARTED]: 'In Progress',
+    [TaskStatus.SUCCESS]: 'Completed',
+    [TaskStatus.FAILURE]: 'Failed',
+    [TaskStatus.CANCELLED]: 'Cancelled',
+};
+const TASK_STATUS_COLORS = {
+    [TaskStatus.QUEUED]: 'secondary',
+    [TaskStatus.STARTED]: 'primary',
+    [TaskStatus.SUCCESS]: 'success',
+    [TaskStatus.FAILURE]: 'danger',
+    [TaskStatus.CANCELLED]: 'warning',
+};
+
 /**
  * CUPCAKE Core (CCC) - Models barrel export
  * User management, lab groups, and core functionality interfaces
@@ -1114,86 +1164,484 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.7", ngImpor
                 }]
         }] });
 
-class ToastService {
-    toastsSignal = signal([], ...(ngDevMode ? [{ debugName: "toastsSignal" }] : []));
-    toasts = this.toastsSignal.asReadonly();
-    show(message, type = 'info', duration = 5000) {
-        const id = this.generateId();
-        const toast = {
-            id,
-            message,
-            type,
-            duration,
-            dismissible: true
+const WEBSOCKET_ENDPOINT = new InjectionToken('WEBSOCKET_ENDPOINT', {
+    providedIn: 'root',
+    factory: () => 'notifications'
+});
+class WebSocketService {
+    authService;
+    ws = null;
+    config;
+    destroy$ = new Subject();
+    reconnectAttempts = 0;
+    isConnecting = false;
+    connectionState = signal('disconnected', ...(ngDevMode ? [{ debugName: "connectionState" }] : []));
+    lastError = signal(null, ...(ngDevMode ? [{ debugName: "lastError" }] : []));
+    messageSubject = new Subject();
+    connectionSubject = new BehaviorSubject(false);
+    messages$ = this.messageSubject.asObservable();
+    isConnected$ = this.connectionSubject.asObservable();
+    connectionState$ = computed(() => this.connectionState(), ...(ngDevMode ? [{ debugName: "connectionState$" }] : []));
+    lastError$ = computed(() => this.lastError(), ...(ngDevMode ? [{ debugName: "lastError$" }] : []));
+    config_token = inject(CUPCAKE_CORE_CONFIG);
+    endpoint = inject(WEBSOCKET_ENDPOINT, { optional: true }) || 'notifications';
+    constructor(authService) {
+        this.authService = authService;
+        this.config = {
+            url: this.getWebSocketUrl(),
+            endpoint: this.endpoint,
+            reconnectInterval: this.getAdaptiveReconnectInterval(),
+            maxReconnectAttempts: 3
         };
-        this.toastsSignal.update(toasts => [...toasts, toast]);
-        if (duration > 0) {
-            setTimeout(() => {
-                this.remove(id);
-            }, duration);
+        this.authService.isAuthenticated$.subscribe(isAuthenticated => {
+            if (!isAuthenticated && this.ws) {
+                console.log('User logged out - disconnecting WebSocket');
+                this.disconnect();
+            }
+        });
+        this.setupBrowserResourceHandling();
+    }
+    getWebSocketUrl() {
+        const apiUrl = this.config_token.apiUrl;
+        try {
+            const url = new URL(apiUrl);
+            const protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
+            const host = url.host;
+            const endpoint = this.config?.endpoint || 'notifications';
+            return `${protocol}//${host}/ws/${endpoint}/`;
+        }
+        catch (error) {
+            console.error('Invalid API URL in cupcake config:', apiUrl);
+            const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+            const host = window.location.host;
+            const endpoint = this.config?.endpoint || 'notifications';
+            return `${protocol}//${host}/ws/${endpoint}/`;
         }
     }
-    success(message, duration = 5000) {
-        this.show(message, 'success', duration);
+    connect() {
+        console.log('🔌 WebSocket connect() called');
+        console.log('🔌 Current connection state:', this.connectionState());
+        console.log('🔌 WebSocket URL:', this.config.url);
+        if (this.isConnecting) {
+            console.log('WebSocket connection already in progress');
+            return;
+        }
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            console.log('WebSocket already connected');
+            return;
+        }
+        if (this.ws && this.ws.readyState !== WebSocket.CLOSED) {
+            console.log('Closing existing WebSocket connection');
+            this.ws.close();
+            this.ws = null;
+        }
+        const token = this.authService.getAccessToken();
+        if (!token) {
+            console.error('❌ Cannot connect WebSocket - no authentication token');
+            this.lastError.set('Authentication required');
+            this.connectionState.set('error');
+            return;
+        }
+        this.isConnecting = true;
+        this.connectionState.set('connecting');
+        this.lastError.set(null);
+        try {
+            const wsUrl = `${this.config.url}?token=${encodeURIComponent(token)}`;
+            console.log('Connecting to WebSocket:', wsUrl.replace(token, '[TOKEN_HIDDEN]'));
+            this.ws = new WebSocket(wsUrl);
+            this.ws.onopen = this.onOpen.bind(this);
+            this.ws.onmessage = this.onMessage.bind(this);
+            this.ws.onerror = this.onError.bind(this);
+            this.ws.onclose = this.onClose.bind(this);
+            const connectionTimeout = setTimeout(() => {
+                if (this.ws?.readyState === WebSocket.CONNECTING) {
+                    console.warn('WebSocket connection timeout - closing');
+                    this.ws.close();
+                    this.lastError.set('Connection timeout');
+                    this.connectionState.set('error');
+                    this.isConnecting = false;
+                }
+            }, 10000);
+            this.ws.onopen = (event) => {
+                clearTimeout(connectionTimeout);
+                this.onOpen(event);
+            };
+        }
+        catch (error) {
+            console.error('WebSocket connection error:', error);
+            this.connectionState.set('error');
+            this.lastError.set('Connection failed');
+            this.isConnecting = false;
+        }
     }
-    error(message, duration = 8000) {
-        this.show(message, 'error', duration);
+    disconnect() {
+        this.destroy$.next();
+        this.isConnecting = false;
+        if (this.ws) {
+            this.ws.close(1000, 'User disconnected');
+            this.ws = null;
+        }
+        this.connectionState.set('disconnected');
+        this.connectionSubject.next(false);
+        this.reconnectAttempts = 0;
     }
-    warning(message, duration = 6000) {
-        this.show(message, 'warning', duration);
+    send(message) {
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify(message));
+        }
+        else {
+            console.warn('WebSocket not connected, cannot send message:', message);
+        }
     }
-    info(message, duration = 5000) {
-        this.show(message, 'info', duration);
+    subscribe(subscriptionType, options = {}) {
+        this.send({
+            type: 'subscribe',
+            subscription_type: subscriptionType,
+            ...options
+        });
     }
-    remove(id) {
-        this.toastsSignal.update(toasts => toasts.filter(toast => toast.id !== id));
+    onOpen(event) {
+        console.log('WebSocket connected');
+        this.isConnecting = false;
+        this.connectionState.set('connected');
+        this.connectionSubject.next(true);
+        this.reconnectAttempts = 0;
+        this.lastError.set(null);
     }
-    clear() {
-        this.toastsSignal.set([]);
+    onMessage(event) {
+        try {
+            const data = JSON.parse(event.data);
+            console.log('WebSocket message received:', data);
+            this.messageSubject.next(data);
+        }
+        catch (error) {
+            console.error('Error parsing WebSocket message:', error);
+        }
     }
-    generateId() {
-        return Math.random().toString(36).substring(2) + Date.now().toString(36);
+    onError(event) {
+        console.error('WebSocket error:', event);
+        this.isConnecting = false;
+        this.connectionState.set('error');
+        this.lastError.set('Connection error occurred');
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: ToastService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: ToastService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: ToastService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }] });
-
-class NotificationService {
-    toastService;
-    notifications = signal([], ...(ngDevMode ? [{ debugName: "notifications" }] : []));
-    notificationSubject = new Subject();
-    allNotifications = computed(() => this.notifications(), ...(ngDevMode ? [{ debugName: "allNotifications" }] : []));
-    unreadNotifications = computed(() => this.notifications().filter(n => !n.read), ...(ngDevMode ? [{ debugName: "unreadNotifications" }] : []));
-    unreadCount = computed(() => this.unreadNotifications().length, ...(ngDevMode ? [{ debugName: "unreadCount" }] : []));
-    notification$ = this.notificationSubject.asObservable();
-    constructor(toastService) {
-        this.toastService = toastService;
+    onClose(event) {
+        console.log(`WebSocket closed: ${event.code} ${event.reason}`);
+        this.isConnecting = false;
+        this.connectionState.set('disconnected');
+        this.connectionSubject.next(false);
+        if (event.code === 4001) {
+            this.lastError.set('Authentication failed');
+            console.error('WebSocket authentication failed');
+            return;
+        }
+        else if (event.code === 4003) {
+            this.lastError.set('Insufficient permissions');
+            console.error('WebSocket permission denied');
+            return;
+        }
+        if (event.code !== 1000 && this.reconnectAttempts < (this.config.maxReconnectAttempts || 5)) {
+            this.attemptReconnection();
+        }
     }
-    addNotification(notification) {
-        this.notifications.update(notifications => {
-            const updated = [notification, ...notifications];
-            return updated.slice(0, 100);
-        });
-        this.notificationSubject.next(notification);
-        console.log('Notification added:', notification);
+    attemptReconnection() {
+        this.reconnectAttempts++;
+        const delay = this.config.reconnectInterval || 5000;
+        console.log(`WebSocket reconnection attempt ${this.reconnectAttempts} in ${delay}ms`);
+        timer(delay).pipe(takeUntil(this.destroy$), tap$1(() => {
+            if (this.reconnectAttempts <= (this.config.maxReconnectAttempts || 5)) {
+                this.connect();
+            }
+            else {
+                console.error('Max WebSocket reconnection attempts reached');
+                this.lastError.set('Connection failed - max attempts reached');
+            }
+        })).subscribe();
     }
-    generateNotificationId() {
-        return `notification_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    filterMessages(type) {
+        return this.messages$.pipe(tap$1(msg => console.log('Filtering message:', msg.type, 'looking for:', type)), switchMap$1(message => message.type === type ? [message] : EMPTY));
     }
-    markAsRead(notificationId) {
-        this.notifications.update(notifications => notifications.map(n => n.id === notificationId ? { ...n, read: true } : n));
+    getNotifications() {
+        return this.filterMessages('notification');
     }
-    markAllAsRead() {
-        this.notifications.update(notifications => notifications.map(n => ({ ...n, read: true })));
+    getSystemNotifications() {
+        return this.filterMessages('system.notification');
     }
-    removeNotification(notificationId) {
-        this.notifications.update(notifications => notifications.filter(n => n.id !== notificationId));
+    reconnectWithNewToken() {
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            console.log('Reconnecting WebSocket with new token');
+            this.disconnect();
+            setTimeout(() => this.connect(), 100);
+        }
+    }
+    shouldConnect() {
+        return this.authService.isAuthenticated() && !!this.authService.getAccessToken();
+    }
+    updateConfig() {
+        this.config.url = this.getWebSocketUrl();
+        console.log('WebSocket URL updated to:', this.config.url);
+    }
+    ngOnDestroy() {
+        this.disconnect();
+    }
+    getAdaptiveReconnectInterval() {
+        const baseInterval = 5000;
+        const tabCount = this.estimateTabCount();
+        if (tabCount > 20) {
+            return baseInterval * 3;
+        }
+        else if (tabCount > 10) {
+            return baseInterval * 2;
+        }
+        return baseInterval;
+    }
+    estimateTabCount() {
+        try {
+            if ('memory' in performance) {
+                const memory = performance.memory;
+                const usedMB = memory.usedJSHeapSize / (1024 * 1024);
+                if (usedMB > 500)
+                    return 25;
+                if (usedMB > 300)
+                    return 15;
+                if (usedMB > 150)
+                    return 10;
+                return 5;
+            }
+            return 10;
+        }
+        catch (error) {
+            return 10;
+        }
+    }
+    canConnectSafely() {
+        try {
+            if ('memory' in performance) {
+                const memory = performance.memory;
+                const usedMB = memory.usedJSHeapSize / (1024 * 1024);
+                const totalMB = memory.totalJSHeapSize / (1024 * 1024);
+                const memoryUsageRatio = usedMB / totalMB;
+                if (memoryUsageRatio > 0.9) {
+                    console.warn('High memory usage detected, delaying WebSocket connection');
+                    return false;
+                }
+            }
+            const tabCount = this.estimateTabCount();
+            if (tabCount > 30) {
+                console.warn('Too many tabs detected, may affect WebSocket reliability');
+                return false;
+            }
+            return true;
+        }
+        catch (error) {
+            return true;
+        }
+    }
+    setupBrowserResourceHandling() {
+        document.addEventListener('visibilitychange', () => {
+            if (document.visibilityState === 'visible') {
+                if (this.shouldConnect() && this.connectionState() === 'disconnected') {
+                    console.log('Tab became active - attempting WebSocket reconnection');
+                    setTimeout(() => this.connect(), 1000);
+                }
+            }
+            else {
+                const tabCount = this.estimateTabCount();
+                if (tabCount > 15 && this.ws?.readyState === WebSocket.OPEN) {
+                    console.log('Tab inactive with high tab count - maintaining connection with reduced activity');
+                }
+            }
+        });
+        window.addEventListener('beforeunload', () => {
+            if (this.ws) {
+                this.ws.close(1000, 'Page unloading');
+            }
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: WebSocketService, deps: [{ token: AuthService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: WebSocketService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: WebSocketService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: AuthService }] });
+
+class AsyncTaskMonitorService extends BaseApiService {
+    destroy$ = new Subject();
+    tasksSubject = new BehaviorSubject([]);
+    isSubscribed = false;
+    websocket = inject(WebSocketService);
+    tasks$ = this.tasksSubject.asObservable();
+    activeTasks$ = this.tasks$.pipe(map$1(tasks => {
+        const taskArray = Array.isArray(tasks) ? tasks : [];
+        const active = taskArray.filter(task => task.status === TaskStatus.QUEUED || task.status === TaskStatus.STARTED);
+        console.log('AsyncTaskMonitorService: activeTasks$ emitting:', active.length, 'active tasks out of', taskArray.length, 'total');
+        return active;
+    }));
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+    startRealtimeUpdates() {
+        if (this.isSubscribed) {
+            console.log('AsyncTaskMonitorService: Already subscribed to real-time updates');
+            return;
+        }
+        console.log('AsyncTaskMonitorService: Starting real-time updates');
+        this.isSubscribed = true;
+        if (!this.websocket.connectionState$() || this.websocket.connectionState$() === 'disconnected') {
+            console.log('AsyncTaskMonitorService: WebSocket not connected, connecting now...');
+            this.websocket.connect();
+        }
+        else {
+            console.log('AsyncTaskMonitorService: WebSocket already connected');
+        }
+        this.websocket.isConnected$.pipe(takeUntil(this.destroy$), filter$1(connected => connected)).subscribe(() => {
+            console.log('AsyncTaskMonitorService: WebSocket connected, subscribing to async_task_updates');
+            this.websocket.subscribe('async_task_updates');
+        });
+        this.websocket.filterMessages('async_task.update').pipe(takeUntil(this.destroy$)).subscribe((message) => {
+            console.log('AsyncTaskMonitorService: Received async_task.update message:', message);
+            this.handleTaskUpdate(message);
+        });
+        this.loadAllTasks();
+    }
+    stopRealtimeUpdates() {
+        console.log('AsyncTaskMonitorService: Stopping real-time updates');
+        this.isSubscribed = false;
+        this.destroy$.next();
+    }
+    loadAllTasks() {
+        const httpParams = this.buildHttpParams({ limit: 100 });
+        this.get(`${this.apiUrl}/async-tasks/`, { params: httpParams }).subscribe({
+            next: (response) => {
+                const taskArray = Array.isArray(response.results) ? response.results : [];
+                console.log('AsyncTaskMonitorService: Loaded tasks from server:', taskArray.length);
+                this.tasksSubject.next(taskArray);
+            },
+            error: (error) => {
+                console.error('AsyncTaskMonitorService: Error loading tasks:', error);
+            }
+        });
+    }
+    handleTaskUpdate(message) {
+        console.log('AsyncTaskMonitorService: handleTaskUpdate called with message:', message);
+        const taskId = message.task_id;
+        const currentTasks = this.tasksSubject.value;
+        console.log('AsyncTaskMonitorService: Current tasks in subject:', currentTasks.length);
+        const existingTaskIndex = currentTasks.findIndex(t => t.id === taskId);
+        console.log('AsyncTaskMonitorService: Existing task index:', existingTaskIndex);
+        if (existingTaskIndex >= 0) {
+            const existingTask = currentTasks[existingTaskIndex];
+            const updatedTask = {
+                ...existingTask,
+                status: message.status,
+                progressPercentage: message.progress_percentage || existingTask.progressPercentage,
+                progressDescription: message.progress_description || existingTask.progressDescription,
+                errorMessage: message.error_message || existingTask.errorMessage,
+                result: message.result || existingTask.result,
+            };
+            const updatedTasks = [...currentTasks];
+            updatedTasks[existingTaskIndex] = updatedTask;
+            console.log('AsyncTaskMonitorService: Emitting updated tasks:', updatedTasks.length, 'active tasks:', updatedTasks.filter(t => t.status === TaskStatus.QUEUED || t.status === TaskStatus.STARTED).length);
+            this.tasksSubject.next(updatedTasks);
+        }
+        else {
+            console.log('AsyncTaskMonitorService: Task not found in current list, fetching all tasks');
+            this.loadAllTasks();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: AsyncTaskMonitorService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: AsyncTaskMonitorService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: AsyncTaskMonitorService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class ToastService {
+    toastsSignal = signal([], ...(ngDevMode ? [{ debugName: "toastsSignal" }] : []));
+    toasts = this.toastsSignal.asReadonly();
+    show(message, type = 'info', duration = 5000) {
+        const id = this.generateId();
+        const toast = {
+            id,
+            message,
+            type,
+            duration,
+            dismissible: true
+        };
+        this.toastsSignal.update(toasts => [...toasts, toast]);
+        if (duration > 0) {
+            setTimeout(() => {
+                this.remove(id);
+            }, duration);
+        }
+    }
+    success(message, duration = 5000) {
+        this.show(message, 'success', duration);
+    }
+    error(message, duration = 8000) {
+        this.show(message, 'error', duration);
+    }
+    warning(message, duration = 6000) {
+        this.show(message, 'warning', duration);
+    }
+    info(message, duration = 5000) {
+        this.show(message, 'info', duration);
+    }
+    remove(id) {
+        this.toastsSignal.update(toasts => toasts.filter(toast => toast.id !== id));
+    }
+    clear() {
+        this.toastsSignal.set([]);
+    }
+    generateId() {
+        return Math.random().toString(36).substring(2) + Date.now().toString(36);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: ToastService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: ToastService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: ToastService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class NotificationService {
+    toastService;
+    notifications = signal([], ...(ngDevMode ? [{ debugName: "notifications" }] : []));
+    notificationSubject = new Subject();
+    allNotifications = computed(() => this.notifications(), ...(ngDevMode ? [{ debugName: "allNotifications" }] : []));
+    unreadNotifications = computed(() => this.notifications().filter(n => !n.read), ...(ngDevMode ? [{ debugName: "unreadNotifications" }] : []));
+    unreadCount = computed(() => this.unreadNotifications().length, ...(ngDevMode ? [{ debugName: "unreadCount" }] : []));
+    notification$ = this.notificationSubject.asObservable();
+    constructor(toastService) {
+        this.toastService = toastService;
+    }
+    addNotification(notification) {
+        this.notifications.update(notifications => {
+            const updated = [notification, ...notifications];
+            return updated.slice(0, 100);
+        });
+        this.notificationSubject.next(notification);
+        console.log('Notification added:', notification);
+    }
+    generateNotificationId() {
+        return `notification_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    markAsRead(notificationId) {
+        this.notifications.update(notifications => notifications.map(n => n.id === notificationId ? { ...n, read: true } : n));
+    }
+    markAllAsRead() {
+        this.notifications.update(notifications => notifications.map(n => ({ ...n, read: true })));
+    }
+    removeNotification(notificationId) {
+        this.notifications.update(notifications => notifications.filter(n => n.id !== notificationId));
     }
     clearAll() {
         this.notifications.set([]);
@@ -1486,318 +1934,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.7", ngImpor
                 }]
         }], ctorParameters: () => [] });
 
-const WEBSOCKET_ENDPOINT = new InjectionToken('WEBSOCKET_ENDPOINT', {
-    providedIn: 'root',
-    factory: () => 'notifications'
-});
-class WebSocketService {
-    authService;
-    ws = null;
-    config;
-    destroy$ = new Subject();
-    reconnectAttempts = 0;
-    isConnecting = false;
-    connectionState = signal('disconnected', ...(ngDevMode ? [{ debugName: "connectionState" }] : []));
-    lastError = signal(null, ...(ngDevMode ? [{ debugName: "lastError" }] : []));
-    messageSubject = new Subject();
-    connectionSubject = new BehaviorSubject(false);
-    messages$ = this.messageSubject.asObservable();
-    isConnected$ = this.connectionSubject.asObservable();
-    connectionState$ = computed(() => this.connectionState(), ...(ngDevMode ? [{ debugName: "connectionState$" }] : []));
-    lastError$ = computed(() => this.lastError(), ...(ngDevMode ? [{ debugName: "lastError$" }] : []));
-    config_token = inject(CUPCAKE_CORE_CONFIG);
-    endpoint = inject(WEBSOCKET_ENDPOINT, { optional: true }) || 'notifications';
-    constructor(authService) {
-        this.authService = authService;
-        this.config = {
-            url: this.getWebSocketUrl(),
-            endpoint: this.endpoint,
-            reconnectInterval: this.getAdaptiveReconnectInterval(),
-            maxReconnectAttempts: 3
-        };
-        this.authService.isAuthenticated$.subscribe(isAuthenticated => {
-            if (!isAuthenticated && this.ws) {
-                console.log('User logged out - disconnecting WebSocket');
-                this.disconnect();
-            }
-        });
-        this.setupBrowserResourceHandling();
-    }
-    getWebSocketUrl() {
-        const apiUrl = this.config_token.apiUrl;
-        try {
-            const url = new URL(apiUrl);
-            const protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
-            const host = url.host;
-            const endpoint = this.config?.endpoint || 'notifications';
-            return `${protocol}//${host}/ws/${endpoint}/`;
-        }
-        catch (error) {
-            console.error('Invalid API URL in cupcake config:', apiUrl);
-            const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
-            const host = window.location.host;
-            const endpoint = this.config?.endpoint || 'notifications';
-            return `${protocol}//${host}/ws/${endpoint}/`;
-        }
-    }
-    connect() {
-        console.log('🔌 WebSocket connect() called');
-        console.log('🔌 Current connection state:', this.connectionState());
-        console.log('🔌 WebSocket URL:', this.config.url);
-        if (this.isConnecting) {
-            console.log('WebSocket connection already in progress');
-            return;
-        }
-        if (this.ws?.readyState === WebSocket.OPEN) {
-            console.log('WebSocket already connected');
-            return;
-        }
-        if (this.ws && this.ws.readyState !== WebSocket.CLOSED) {
-            console.log('Closing existing WebSocket connection');
-            this.ws.close();
-            this.ws = null;
-        }
-        const token = this.authService.getAccessToken();
-        if (!token) {
-            console.error('❌ Cannot connect WebSocket - no authentication token');
-            this.lastError.set('Authentication required');
-            this.connectionState.set('error');
-            return;
-        }
-        this.isConnecting = true;
-        this.connectionState.set('connecting');
-        this.lastError.set(null);
-        try {
-            const wsUrl = `${this.config.url}?token=${encodeURIComponent(token)}`;
-            console.log('Connecting to WebSocket:', wsUrl.replace(token, '[TOKEN_HIDDEN]'));
-            this.ws = new WebSocket(wsUrl);
-            this.ws.onopen = this.onOpen.bind(this);
-            this.ws.onmessage = this.onMessage.bind(this);
-            this.ws.onerror = this.onError.bind(this);
-            this.ws.onclose = this.onClose.bind(this);
-            const connectionTimeout = setTimeout(() => {
-                if (this.ws?.readyState === WebSocket.CONNECTING) {
-                    console.warn('WebSocket connection timeout - closing');
-                    this.ws.close();
-                    this.lastError.set('Connection timeout');
-                    this.connectionState.set('error');
-                    this.isConnecting = false;
-                }
-            }, 10000);
-            this.ws.onopen = (event) => {
-                clearTimeout(connectionTimeout);
-                this.onOpen(event);
-            };
-        }
-        catch (error) {
-            console.error('WebSocket connection error:', error);
-            this.connectionState.set('error');
-            this.lastError.set('Connection failed');
-            this.isConnecting = false;
-        }
-    }
-    disconnect() {
-        this.destroy$.next();
-        this.isConnecting = false;
-        if (this.ws) {
-            this.ws.close(1000, 'User disconnected');
-            this.ws = null;
-        }
-        this.connectionState.set('disconnected');
-        this.connectionSubject.next(false);
-        this.reconnectAttempts = 0;
-    }
-    send(message) {
-        if (this.ws?.readyState === WebSocket.OPEN) {
-            this.ws.send(JSON.stringify(message));
-        }
-        else {
-            console.warn('WebSocket not connected, cannot send message:', message);
-        }
-    }
-    subscribe(subscriptionType, options = {}) {
-        this.send({
-            type: 'subscribe',
-            subscription_type: subscriptionType,
-            ...options
-        });
-    }
-    onOpen(event) {
-        console.log('WebSocket connected');
-        this.isConnecting = false;
-        this.connectionState.set('connected');
-        this.connectionSubject.next(true);
-        this.reconnectAttempts = 0;
-        this.lastError.set(null);
-    }
-    onMessage(event) {
-        try {
-            const data = JSON.parse(event.data);
-            console.log('WebSocket message received:', data);
-            this.messageSubject.next(data);
-        }
-        catch (error) {
-            console.error('Error parsing WebSocket message:', error);
-        }
-    }
-    onError(event) {
-        console.error('WebSocket error:', event);
-        this.isConnecting = false;
-        this.connectionState.set('error');
-        this.lastError.set('Connection error occurred');
-    }
-    onClose(event) {
-        console.log(`WebSocket closed: ${event.code} ${event.reason}`);
-        this.isConnecting = false;
-        this.connectionState.set('disconnected');
-        this.connectionSubject.next(false);
-        if (event.code === 4001) {
-            this.lastError.set('Authentication failed');
-            console.error('WebSocket authentication failed');
-            return;
-        }
-        else if (event.code === 4003) {
-            this.lastError.set('Insufficient permissions');
-            console.error('WebSocket permission denied');
-            return;
-        }
-        if (event.code !== 1000 && this.reconnectAttempts < (this.config.maxReconnectAttempts || 5)) {
-            this.attemptReconnection();
-        }
-    }
-    attemptReconnection() {
-        this.reconnectAttempts++;
-        const delay = this.config.reconnectInterval || 5000;
-        console.log(`WebSocket reconnection attempt ${this.reconnectAttempts} in ${delay}ms`);
-        timer(delay).pipe(takeUntil(this.destroy$), tap$1(() => {
-            if (this.reconnectAttempts <= (this.config.maxReconnectAttempts || 5)) {
-                this.connect();
-            }
-            else {
-                console.error('Max WebSocket reconnection attempts reached');
-                this.lastError.set('Connection failed - max attempts reached');
-            }
-        })).subscribe();
-    }
-    filterMessages(type) {
-        return this.messages$.pipe(tap$1(msg => console.log('Filtering message:', msg.type, 'looking for:', type)), switchMap$1(message => message.type === type ? [message] : EMPTY));
-    }
-    getNotifications() {
-        return this.filterMessages('notification');
-    }
-    getSystemNotifications() {
-        return this.filterMessages('system.notification');
-    }
-    reconnectWithNewToken() {
-        if (this.ws?.readyState === WebSocket.OPEN) {
-            console.log('Reconnecting WebSocket with new token');
-            this.disconnect();
-            setTimeout(() => this.connect(), 100);
-        }
-    }
-    shouldConnect() {
-        return this.authService.isAuthenticated() && !!this.authService.getAccessToken();
-    }
-    updateConfig() {
-        this.config.url = this.getWebSocketUrl();
-        console.log('WebSocket URL updated to:', this.config.url);
-    }
-    ngOnDestroy() {
-        this.disconnect();
-    }
-    getAdaptiveReconnectInterval() {
-        const baseInterval = 5000;
-        const tabCount = this.estimateTabCount();
-        if (tabCount > 20) {
-            return baseInterval * 3;
-        }
-        else if (tabCount > 10) {
-            return baseInterval * 2;
-        }
-        return baseInterval;
-    }
-    estimateTabCount() {
-        try {
-            if ('memory' in performance) {
-                const memory = performance.memory;
-                const usedMB = memory.usedJSHeapSize / (1024 * 1024);
-                if (usedMB > 500)
-                    return 25;
-                if (usedMB > 300)
-                    return 15;
-                if (usedMB > 150)
-                    return 10;
-                return 5;
-            }
-            return 10;
-        }
-        catch (error) {
-            return 10;
-        }
-    }
-    canConnectSafely() {
-        try {
-            if ('memory' in performance) {
-                const memory = performance.memory;
-                const usedMB = memory.usedJSHeapSize / (1024 * 1024);
-                const totalMB = memory.totalJSHeapSize / (1024 * 1024);
-                const memoryUsageRatio = usedMB / totalMB;
-                if (memoryUsageRatio > 0.9) {
-                    console.warn('High memory usage detected, delaying WebSocket connection');
-                    return false;
-                }
-            }
-            const tabCount = this.estimateTabCount();
-            if (tabCount > 30) {
-                console.warn('Too many tabs detected, may affect WebSocket reliability');
-                return false;
-            }
-            return true;
-        }
-        catch (error) {
-            return true;
-        }
-    }
-    setupBrowserResourceHandling() {
-        document.addEventListener('visibilitychange', () => {
-            if (document.visibilityState === 'visible') {
-                if (this.shouldConnect() && this.connectionState() === 'disconnected') {
-                    console.log('Tab became active - attempting WebSocket reconnection');
-                    setTimeout(() => this.connect(), 1000);
-                }
-            }
-            else {
-                const tabCount = this.estimateTabCount();
-                if (tabCount > 15 && this.ws?.readyState === WebSocket.OPEN) {
-                    console.log('Tab inactive with high tab count - maintaining connection with reduced activity');
-                }
-            }
-        });
-        window.addEventListener('beforeunload', () => {
-            if (this.ws) {
-                this.ws.close(1000, 'Page unloading');
-            }
-        });
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: WebSocketService, deps: [{ token: AuthService }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: WebSocketService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: WebSocketService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: () => [{ type: AuthService }] });
-
 const WEBSOCKET_ENDPOINTS = new InjectionToken('WEBSOCKET_ENDPOINTS');
 class WebSocketEndpoints {
     static CORE_NOTIFICATIONS = 'notifications';
     static CORE_ADMIN = 'admin';
-    static CCV_NOTIFICATIONS = 'ccv/notifications';
-    static CCV_ADMIN = 'ccv/admin';
-    static CCM_NOTIFICATIONS = 'ccm/notifications';
-    static CCRV_NOTIFICATIONS = 'ccrv/notifications';
-    static CCSC_NOTIFICATIONS = 'ccsc/notifications';
 }
 class WebSocketConfigService {
     endpoints = new Map();
@@ -1815,31 +1955,6 @@ class WebSocketConfigService {
             endpoint: WebSocketEndpoints.CORE_ADMIN,
             description: 'Core admin notification endpoint'
         });
-        this.registerEndpoint({
-            app: 'ccv',
-            endpoint: WebSocketEndpoints.CCV_NOTIFICATIONS,
-            description: 'CCV notification endpoint'
-        });
-        this.registerEndpoint({
-            app: 'ccv',
-            endpoint: WebSocketEndpoints.CCV_ADMIN,
-            description: 'CCV admin notification endpoint'
-        });
-        this.registerEndpoint({
-            app: 'ccm',
-            endpoint: WebSocketEndpoints.CCM_NOTIFICATIONS,
-            description: 'CCM notification endpoint'
-        });
-        this.registerEndpoint({
-            app: 'ccrv',
-            endpoint: WebSocketEndpoints.CCRV_NOTIFICATIONS,
-            description: 'CCRV notification endpoint'
-        });
-        this.registerEndpoint({
-            app: 'ccsc',
-            endpoint: WebSocketEndpoints.CCSC_NOTIFICATIONS,
-            description: 'CCSC notification endpoint'
-        });
     }
     registerEndpoint(config) {
         this.endpoints.set(config.endpoint, config);
@@ -3483,5 +3598,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.7", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { AnnotationType, ApiService, AuthService, BaseApiService, CUPCAKE_CORE_CONFIG, CupcakeCoreModule, InvitationStatus, InvitationStatusLabels, LabGroupService, LabGroupsComponent, LoginComponent, NotificationService, PoweredByFooterComponent, RegisterComponent, ResourceRole, ResourceRoleLabels, ResourceService, ResourceType, ResourceTypeLabels, ResourceVisibility, ResourceVisibilityLabels, SiteConfigComponent, SiteConfigService, ThemeService, ToastContainerComponent, ToastService, UserManagementComponent, UserManagementService, UserProfileComponent, WEBSOCKET_ENDPOINT, WEBSOCKET_ENDPOINTS, WebSocketConfigService, WebSocketEndpoints, WebSocketService, adminGuard, authGuard, authInterceptor, resetRefreshState };
+export { AnnotationType, ApiService, AsyncTaskMonitorService, AuthService, BaseApiService, CUPCAKE_CORE_CONFIG, CupcakeCoreModule, InvitationStatus, InvitationStatusLabels, LabGroupService, LabGroupsComponent, LoginComponent, NotificationService, PoweredByFooterComponent, RegisterComponent, ResourceRole, ResourceRoleLabels, ResourceService, ResourceType, ResourceTypeLabels, ResourceVisibility, ResourceVisibilityLabels, SiteConfigComponent, SiteConfigService, TASK_STATUS_COLORS, TASK_STATUS_LABELS, TASK_TYPE_LABELS, TaskStatus, TaskType, ThemeService, ToastContainerComponent, ToastService, UserManagementComponent, UserManagementService, UserProfileComponent, WEBSOCKET_ENDPOINT, WEBSOCKET_ENDPOINTS, WebSocketConfigService, WebSocketEndpoints, WebSocketService, adminGuard, authGuard, authInterceptor, resetRefreshState };
 //# sourceMappingURL=noatgnu-cupcake-core.mjs.map