http-request-manager 18.7.2 → 18.7.4

package/README.md

@@ -468,21 +468,45 @@ this.wsService.getUsersInChannel('PUB-my-channel');
 
 #### Channel Naming Conventions
 
-The WebSocket service supports channel prefixes for organizing communication:
+The WebSocket service and state manager use a **channel type system** to organize communication. Channel prefixes are managed automatically by the state service.
 
-| Prefix | Description | Visibility |
-| :--- | :--- | :--- |
-| `PUB-` | Public channels for user messaging | Visible to users |
-| `SYS-` | System channels for internal communication | Hidden from users |
+##### Channel Types (`ChannelType` Enum)
+
+```typescript
+import { ChannelType, createChannelName } from 'http-request-manager';
+
+export enum ChannelType {
+  STATE = 'SYS',        // Private state synchronization channels
+  MESSAGE = 'MES',      // Messaging/communication channels (persisted notifications)
+  NOTIFICATION = 'PUB'  // Public notification/broadcast channels
+}
+
+// Utility function to create prefixed channel name
+createChannelName(ChannelType.STATE, 'USERS123');  // Returns 'SYS-USERS123'
+createChannelName(ChannelType.MESSAGE, 'alerts');   // Returns 'MES-alerts'
+createChannelName(ChannelType.NOTIFICATION, 'chat'); // Returns 'PUB-chat'
+```
+
+| Channel Type | Prefix | Description | Visibility | Persistence |
+| :--- | :--- | :--- | :--- | :--- |
+| `STATE` | `SYS-` | Private channels for state synchronization (CRUD operations) | Hidden from users | In-memory only |
+| `MESSAGE` | `MES-` | Messaging channels for notifications (persisted to database) | Visible to users | Database persisted |
+| `NOTIFICATION` | `PUB-` | Public channels for real-time messaging/chat | Visible to users | In-memory only |
+
+**Important:** When using `HTTPManagerStateService`, channel prefixes are automatically managed. You only need to provide the base channel name.
 
 **Example:**
 
 ```typescript
-// Create a public channel (visible in UI)
-this.wsService.createChannel('PUB-general-chat');
+// State service automatically adds SYS- prefix for state channels
+// User provides: 'USERS123'
+// State service uses: 'SYS-USERS123'
 
-// Create a system channel (hidden from UI)
-this.wsService.createChannel('SYS-internal-notifications');
+// For messaging channels, use subscribeToMessageChannel()
+stateService.subscribeToMessageChannel('alerts');  // Uses 'MES-alerts'
+
+// For notification channels, use subscribeToNotificationChannel()
+stateService.subscribeToNotificationChannel('announcements');  // Uses 'PUB-announcements'
 ```
 
 #### WebSocket Message Types
@@ -543,6 +567,326 @@ export class UsersStore extends HTTPManagerStateService<User> {
 }
 ```
 
+---
+
+## Real-Time Features
+
+The `http-request-manager` library provides two distinct real-time communication features:
+
+1. **Messaging (PUB- channels)** - Real-time chat/messaging between users
+2. **Notifications (MES- channels)** - Persistent notifications stored in database
+
+Both features integrate seamlessly with `HTTPManagerStateService` and automatically manage channel prefixes.
+
+### Messaging Feature (PUB- Channels)
+
+**Purpose:** Real-time messaging/chat functionality for communication between users.
+
+**Characteristics:**
+
+- Messages are broadcast in real-time to subscribed users
+- Messages are stored in-memory only (not persisted to database)
+- Uses `PUB-` prefix (automatically added)
+- Ideal for chat applications, live collaboration, etc.
+
+#### Messaging Observables
+
+| Observable | Type | Description |
+| :--- | :--- | :--- |
+| `channels$` | `Observable<string[]>` | List of all available channels |
+| `communicationMessages$` | `Observable<any[]>` | All received messages |
+| `latestCommunicationMessages$` | `Observable<any>` | Most recent message received |
+| `connectionStatus$` | `Observable<boolean>` | WebSocket connection status |
+| `user$` | `Observable<WSUser>` | Current user information |
+
+#### Messaging Methods
+
+```typescript
+// Create a new messaging channel
+stateService.createChannel('general-chat');  // Creates PUB-general-chat
+
+// Subscribe to a channel to receive messages
+stateService.subscribeToChannel('general-chat');  // Subscribes to PUB-general-chat
+
+// Unsubscribe from a channel
+stateService.unsubscribeFromChannel('general-chat');
+
+// Get all available channels
+stateService.getAllChannels();
+
+// Send a message to specific channels
+stateService.wsMessaging(
+  ChannelMessage.adapt({
+    sessionId: currentUser,
+    content: { message: 'Hello everyone!' }
+  }),
+  ['general-chat', 'team-updates']  // Channels (PUB- prefix added automatically)
+);
+```
+
+#### Demo Component: `WsMessagingComponent`
+
+The library includes a demo component showcasing messaging functionality:
+
+```html
+<app-ws-messaging
+  [server]="'http://localhost:8080'"
+  [wsServer]="'ws://localhost:8080'"
+  [jwtToken]="'your-jwt-token'"
+  [user]="{ ldap: 'jdoe', name: 'John Doe', email: 'jdoe@example.com' }">
+</app-ws-messaging>
+```
+
+**Features demonstrated:**
+
+- Create public channels
+- Subscribe/unsubscribe to channels
+- Send messages to multiple channels
+- View real-time message stream
+- Toast notifications for incoming messages
+
+---
+
+### Notifications Feature (MES- Channels)
+
+**Purpose:** Persistent notifications that are stored in the database and can be retrieved with date filters.
+
+**Characteristics:**
+
+- Notifications are persisted to the server database
+- Supports date-range queries (startEpoch, endEpoch)
+- Uses `MES-` prefix (automatically added)
+- Retrieves historical notifications on subscription
+- Ideal for announcements, alerts, audit logs, etc.
+
+#### Notification Observables
+
+| Observable | Type | Description |
+| :--- | :--- | :--- |
+| `notificationChannels$` | `Observable<string[]>` | In-memory notification channels from server |
+| `todaysNotificationChannels$` | `Observable<string[]>` | Channels with notifications posted today (from DB) |
+| `notificationMessages$` | `Observable<any[]>` | All notification messages |
+| `latestNotification$` | `Observable<any>` | Most recent notification received |
+
+#### Notification Methods
+
+```typescript
+// Create a notification channel
+stateService.createNotificationChannel('alerts');  // Creates MES-alerts
+
+// Get all notification channels (in-memory)
+stateService.getNotificationChannels();
+
+// Get today's notification channels (from database)
+stateService.getTodaysNotificationChannels();
+
+// Subscribe to notifications with optional date filter
+stateService.subscribeToNotificationChannel('alerts', {
+  startEpoch: Math.floor(Date.now() / 1000) - 86400,  // Last 24 hours
+  endEpoch: Math.floor(Date.now() / 1000)
+});
+
+// Unsubscribe from notifications
+stateService.unsubscribeFromNotificationChannel('alerts');
+
+// Send a notification (persisted to database)
+stateService.sendNotification('alerts', {
+  title: 'System Alert',
+  message: 'Scheduled maintenance at midnight',
+  priority: 'high'
+});
+```
+
+#### Notification Message Structure
+
+```typescript
+interface NotificationMessage {
+  id: number;
+  channel: string;      // e.g., 'MES-alerts'
+  created: number;      // epoch seconds
+  user_name: string;    // sender's name
+  sessionId: any;       // sender's session info
+  content: any;         // notification payload
+}
+```
+
+#### Demo Component: `WsNotificationsComponent`
+
+The library includes a demo component showcasing notification functionality:
+
+```html
+<app-ws-notifications
+  [server]="'http://localhost:8080'"
+  [wsServer]="'ws://localhost:8080'"
+  [jwtToken]="'your-jwt-token'"
+  [user]="{ ldap: 'jdoe', name: 'John Doe', email: 'jdoe@example.com' }">
+</app-ws-notifications>
+```
+
+**Features demonstrated:**
+
+- Create notification channels
+- View today's notification channels (from database)
+- Subscribe with date range filters
+- Connect/disconnect from channels
+- Send notifications (persisted)
+- View historical notifications in a table
+
+---
+
+### Creating a Custom State Service with Messaging & Notifications
+
+Here's a complete example of a state service that utilizes all real-time features:
+
+```typescript
+import { Injectable } from '@angular/core';
+import { HTTPManagerStateService, ChannelType, createChannelName } from 'http-request-manager';
+import { ApiRequest, DataType, DatabaseStorage } from 'http-request-manager';
+
+export interface User {
+  id: number;
+  name: string;
+  email: string;
+}
+
+@Injectable({
+  providedIn: 'root'
+})
+export class UserStateService extends HTTPManagerStateService<User> {
+
+  constructor() {
+    super(
+      ApiRequest.adapt({
+        server: 'http://localhost:8080',
+        path: ['api', 'users'],
+        adapter: (data: any) => data as User,
+        ws: {
+          id: 'USERS123',  // Base name - automatically becomes SYS-USERS123
+          wsServer: 'ws://localhost:8080',
+          jwtToken: '',
+          retry: { times: 3, delay: 5 }
+        }
+      }),
+      DataType.ARRAY,
+      DatabaseStorage.adapt({ table: 'users-cache', expiresIn: '1d' })
+    );
+  }
+
+  // Initialize connection with user info
+  initializeConnection(wsServer: string, jwtToken: string, user: any) {
+    this.setApiRequestOptions(
+      ApiRequest.adapt({
+        ...this.ApiRequestOptions,
+        ws: {
+          ...this.ApiRequestOptions.ws,
+          wsServer,
+          jwtToken,
+          user
+        }
+      })
+    );
+  }
+
+  // === MESSAGING (PUB- channels) ===
+
+  createChatRoom(roomName: string) {
+    this.createChannel(roomName);  // Creates PUB-{roomName}
+  }
+
+  joinChatRoom(roomName: string) {
+    this.subscribeToChannel(roomName);
+  }
+
+  leaveChatRoom(roomName: string) {
+    this.unsubscribeFromChannel(roomName);
+  }
+
+  sendChatMessage(content: string, rooms: string[]) {
+    this.wsMessaging(
+      { content: { message: content } },
+      rooms
+    );
+  }
+
+  // === NOTIFICATIONS (MES- channels) ===
+
+  createNotificationStream(streamName: string) {
+    this.createNotificationChannel(streamName);  // Creates MES-{streamName}
+  }
+
+  subscribeToAlerts(streamName: string, lastHours: number = 24) {
+    const now = Math.floor(Date.now() / 1000);
+    const startEpoch = now - (lastHours * 3600);
+
+    this.subscribeToNotificationChannel(streamName, {
+      startEpoch,
+      endEpoch: now
+    });
+  }
+
+  sendAlert(streamName: string, alert: { title: string; message: string; priority: string }) {
+    this.sendNotification(streamName, alert);
+  }
+}
+```
+
+**Usage in Component:**
+
+```typescript
+@Component({
+  selector: 'app-dashboard',
+  template: `
+    <div *ngIf="connectionStatus$ | async">
+      <!-- Chat Messages -->
+      <div *ngFor="let msg of chatMessages$ | async">
+        {{ msg.content.message }}
+      </div>
+
+      <!-- Notifications -->
+      <div *ngFor="let notification of notifications$ | async">
+        {{ notification.content.title }}: {{ notification.content.message }}
+      </div>
+    </div>
+  `
+})
+export class DashboardComponent implements OnInit {
+  userState = inject(UserStateService);
+
+  connectionStatus$ = this.userState.connectionStatus$;
+  chatMessages$ = this.userState.communicationMessages$;
+  notifications$ = this.userState.notificationMessages$;
+
+  ngOnInit() {
+    // Initialize WebSocket connection
+    this.userState.initializeConnection(
+      'ws://localhost:8080',
+      'jwt-token',
+      { ldap: 'jdoe', name: 'John Doe' }
+    );
+
+    // Join a chat room
+    this.userState.joinChatRoom('general');
+
+    // Subscribe to alerts from last 24 hours
+    this.userState.subscribeToAlerts('system-alerts', 24);
+  }
+
+  sendMessage(text: string) {
+    this.userState.sendChatMessage(text, ['general']);
+  }
+
+  sendAlert() {
+    this.userState.sendAlert('system-alerts', {
+      title: 'Update Available',
+      message: 'A new version is available',
+      priority: 'medium'
+    });
+  }
+}
+```
+
+---
+
 ### 8. Database Manager Service (`DatabaseManagerService`)
 
 **Path:** `database-manager-service/database.manager.service.ts`

package/fesm2022/http-request-manager.mjs

@@ -829,6 +829,8 @@ class WebsocketService {
             }
         }
         this.isSubscribed = false;
+        // Clear tracked subscriptions for new connection
+        this.subscribedChannels.next(new Set());
         const sessionId = this.getSessionId();
         const URL = (jwtToken) ? `${options.wsServer}?token=${jwtToken}&sessionId=${sessionId}` : `${options.wsServer}?sessionId=${sessionId}`;
         this.socket = new WebSocket(URL);
@@ -2998,6 +3000,27 @@ class ChannelMessage {
 }
 
 const API_OPTS = new InjectionToken('API_OPTS');
+/**
+ * Channel type enum for different communication purposes
+ * - STATE: Private channels for state synchronization
+ * - MESSAGE: Messaging/communication channels
+ * - NOTIFICATION: Notification/broadcast channels
+ */
+var ChannelType;
+(function (ChannelType) {
+    ChannelType["STATE"] = "SYS";
+    ChannelType["MESSAGE"] = "MES";
+    ChannelType["NOTIFICATION"] = "PUB";
+})(ChannelType || (ChannelType = {}));
+/**
+ * Utility function to create prefixed channel name
+ * @param channelType - The type of channel
+ * @param channelName - The base channel name
+ * @returns Prefixed channel name (e.g., 'SYS-USERS123')
+ */
+function createChannelName(channelType, channelName) {
+    return `${channelType}-${channelName}`;
+}
 const defaultState = {
     data: [],
     dataObject: null,
@@ -3499,6 +3522,36 @@ class HTTPManagerStateService extends ComponentStore {
             this.initDBStorage();
         }
     }
+    /**
+     * Add appropriate prefix to a channel name if not already present
+     */
+    prefixChannel(channel, type) {
+        const prefix = `${type}-`;
+        if (channel.startsWith(prefix)) {
+            return channel;
+        }
+        // Remove any other known prefix before adding the correct one
+        const cleanChannel = this.stripChannelPrefix(channel);
+        return `${type}-${cleanChannel}`;
+    }
+    /**
+     * Remove any known prefix from a channel name
+     */
+    stripChannelPrefix(channel) {
+        for (const type of Object.values(ChannelType)) {
+            const prefix = `${type}-`;
+            if (channel.startsWith(prefix)) {
+                return channel.slice(prefix.length);
+            }
+        }
+        return channel;
+    }
+    /**
+     * Get the base channel name without prefix (for display/user reference)
+     */
+    getBaseChannelName(channel) {
+        return this.stripChannelPrefix(channel);
+    }
     setApiRequestOptions(apiOptions, dataType, database) {
         this.apiOptions = ApiRequest.adapt(apiOptions);
         this.dataType = (dataType) ? dataType : DataType.ARRAY;
@@ -3508,6 +3561,10 @@ class HTTPManagerStateService extends ComponentStore {
             this.databaseOptions = (this.hasDatabase) ? DatabaseStorage.adapt(database) : undefined;
         }
         if (this.apiOptions.ws && this.apiOptions.ws.id !== '') {
+            // Auto-prefix channel ID for private state manager channels
+            // This ensures state manager channels are separate from user-defined channels
+            this.apiOptions.ws.id = this.prefixChannel(this.apiOptions.ws.id, ChannelType.STATE);
+            console.log(`🔒 Private state channel: ${this.apiOptions.ws.id}`);
             // Update WebSocket retry settings when options change
             if (this.apiOptions.ws?.retry) {
                 this.maxRetries = this.apiOptions.ws.retry.times || 3;
@@ -3657,12 +3714,19 @@ class HTTPManagerStateService extends ComponentStore {
             this.httpManagerService.sendMessageInChannel(wsServer, { method, path, user: this.apiOptions.ws.user });
         }
     }
+    /**
+     * Send a message to channel(s)
+     * @param message - The message content
+     * @param channels - Optional array of channel names (passed as-is, caller should include prefix)
+     *                   Use 'allChannels' to broadcast to all
+     */
     wsMessaging(message, channels) {
         const user = this.user.value;
         const messageInfo = ChannelMessage.adapt({ ...message, fromUser: user });
         console.log('📤 wsMessaging called with channels:', channels);
         if (this.wsConnection && this.apiOptions.ws) {
             // If specific channels provided, send to each channel
+            // Channels are passed as-is - caller is responsible for including the correct prefix
             if (channels && channels.length > 0) {
                 console.log(`📤 Sending to ${channels.length} channel(s):`, channels);
                 channels.forEach(channel => {
@@ -3675,17 +3739,46 @@ class HTTPManagerStateService extends ComponentStore {
                 });
             }
             else {
-                // Fallback to the primary WS channel
+                // Fallback to the primary WS channel (already prefixed with SYS-)
                 const wsChannel = this.apiOptions.ws.id;
-                console.log(`📤 Sending to fallback channel:`, wsChannel);
+                console.log(`📤 Sending to state channel:`, wsChannel);
                 this.httpManagerService.sendChannelMessage(wsChannel, messageInfo);
             }
         }
     }
+    /**
+     * Subscribe to a messaging channel
+     * @param channel - Base channel name (MES- prefix added automatically)
+     */
+    subscribeToMessageChannel(channel) {
+        if (this.wsConnection) {
+            const prefixedChannel = this.prefixChannel(channel, ChannelType.MESSAGE);
+            this.httpManagerService.subscribeToChannel(prefixedChannel);
+            console.log(`💬 Subscribed to message channel: ${prefixedChannel}`);
+        }
+        else {
+            console.warn('Cannot subscribe to message channel: WebSocket not connected.');
+        }
+    }
+    /**
+     * Unsubscribe from a messaging channel
+     * @param channel - Base channel name (MES- prefix added automatically)
+     */
+    unsubscribeFromMessageChannel(channel) {
+        if (this.wsConnection) {
+            const prefixedChannel = this.prefixChannel(channel, ChannelType.MESSAGE);
+            this.httpManagerService.unsubscribeFromChannel(prefixedChannel);
+            console.log(`💬 Unsubscribed from message channel: ${prefixedChannel}`);
+        }
+        else {
+            console.warn('Cannot unsubscribe from message channel: WebSocket not connected.');
+        }
+    }
     // --------------------------------------------------------------------------------------------------
-    // CHANNEL MANAGEMENT
+    // CHANNEL MANAGEMENT (Raw channels - no automatic prefix)
     /**
-     * Subscribe to a single channel
+     * Subscribe to a single channel (no automatic prefix)
+     * Use subscribeToMessageChannel() for MES- prefixed channels
      */
     subscribeToChannel(channel) {
         if (this.wsConnection) {
@@ -3774,13 +3867,16 @@ class HTTPManagerStateService extends ComponentStore {
         }
     }
     // --------------------------------------------------------------------------------------------------
-    // NOTIFICATION CHANNELS (MES- prefix)
+    // NOTIFICATION CHANNELS (PUB- prefix - managed automatically)
     /**
      * Create a notification channel on the server
+     * @param channel - Base channel name (PUB- prefix added automatically)
      */
     createNotificationChannel(channel) {
         if (this.wsConnection) {
-            this.httpManagerService.createNotificationChannel(channel);
+            const prefixedChannel = this.prefixChannel(channel, ChannelType.NOTIFICATION);
+            this.httpManagerService.createNotificationChannel(prefixedChannel);
+            console.log(`📢 Creating notification channel: ${prefixedChannel}`);
         }
         else {
             console.warn('Cannot create notification channel: WebSocket not connected.');
@@ -3811,10 +3907,13 @@ class HTTPManagerStateService extends ComponentStore {
     }
     /**
      * Subscribe to a notification channel with optional date filters
+     * @param channel - Base channel name (PUB- prefix added automatically)
      */
     subscribeToNotificationChannel(channel, options, user) {
         if (this.wsConnection) {
-            this.httpManagerService.subscribeToNotificationChannel(channel, options, user);
+            const prefixedChannel = this.prefixChannel(channel, ChannelType.NOTIFICATION);
+            this.httpManagerService.subscribeToNotificationChannel(prefixedChannel, options, user);
+            console.log(`📢 Subscribing to notification channel: ${prefixedChannel}`);
         }
         else {
             console.warn('Cannot subscribe to notification channel: WebSocket not connected.');
@@ -3822,10 +3921,13 @@ class HTTPManagerStateService extends ComponentStore {
     }
     /**
      * Unsubscribe from a notification channel
+     * @param channel - Base channel name (PUB- prefix added automatically)
      */
     unsubscribeFromNotificationChannel(channel) {
         if (this.wsConnection) {
-            this.httpManagerService.unsubscribeFromNotificationChannel(channel);
+            const prefixedChannel = this.prefixChannel(channel, ChannelType.NOTIFICATION);
+            this.httpManagerService.unsubscribeFromNotificationChannel(prefixedChannel);
+            console.log(`📢 Unsubscribing from notification channel: ${prefixedChannel}`);
         }
         else {
             console.warn('Cannot unsubscribe from notification channel: WebSocket not connected.');
@@ -3833,10 +3935,13 @@ class HTTPManagerStateService extends ComponentStore {
     }
     /**
      * Send a notification to a channel
+     * @param channel - Base channel name (PUB- prefix added automatically)
      */
     sendNotification(channel, content) {
         if (this.wsConnection) {
-            this.httpManagerService.sendNotification(channel, content);
+            const prefixedChannel = this.prefixChannel(channel, ChannelType.NOTIFICATION);
+            this.httpManagerService.sendNotification(prefixedChannel, content);
+            console.log(`📢 Sending notification to channel: ${prefixedChannel}`);
         }
         else {
             console.warn('Cannot send notification: WebSocket not connected.');
@@ -4530,7 +4635,7 @@ class StateServiceDemo extends HTTPManagerStateService {
             }),
             adapter: OIDCClient.adapt,
             ws: {
-                id: 'SYS-USERS123',
+                id: 'USERS123',
                 wsServer,
                 jwtToken,
                 user,
@@ -6994,5 +7099,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
  * Generated bundle index. Do not edit.
  */
 
-export { ApiRequest, AppService, AsymmetricalEncryptionService, CONFIG_SETTINGS_TOKEN, ChannelInfo, CommunicationType, ConfigHTTPOptions, ConfigOptions, DataType, DatabaseDataDemoComponent, DatabaseManagerService, DatabaseStorage, DbService, ErrorDisplaySettings, GlobalStoreOptions, HTTPManagerService, HTTPManagerSignalsService, HTTPManagerStateService, HeadersService, HttpRequestManagerModule, HttpRequestServicesDemoComponent, LocalStorageDemoComponent, LocalStorageManagerService, LocalStorageOptions, LocalStorageSignalsManagerService, PathQueryService, Random, RandomNumber, RandomNumbers, RandomNumbersUnique, RandomSignature, RandomStr, RequestErrorInterceptor, RequestHeadersInterceptor, RequestManagerDemoComponent, RequestManagerStateDemoComponent, RequestOptions, RequestService, RequestSignalsService, RetryOptions, SettingOptions, StateStorageOptions, StorageData, StorageOption, StorageType, StoreStateManagerService, SymmetricalEncryptionService, TableSchemaDef, UUID, UUID_STR, UtilsService, WSOptions, WSUser, WebsocketService, WithCredentialsInterceptor, countdown, delayedRetry, requestPolling, requestStreaming };
+export { ApiRequest, AppService, AsymmetricalEncryptionService, CONFIG_SETTINGS_TOKEN, ChannelInfo, ChannelType, CommunicationType, ConfigHTTPOptions, ConfigOptions, DataType, DatabaseDataDemoComponent, DatabaseManagerService, DatabaseStorage, DbService, ErrorDisplaySettings, GlobalStoreOptions, HTTPManagerService, HTTPManagerSignalsService, HTTPManagerStateService, HeadersService, HttpRequestManagerModule, HttpRequestServicesDemoComponent, LocalStorageDemoComponent, LocalStorageManagerService, LocalStorageOptions, LocalStorageSignalsManagerService, PathQueryService, Random, RandomNumber, RandomNumbers, RandomNumbersUnique, RandomSignature, RandomStr, RequestErrorInterceptor, RequestHeadersInterceptor, RequestManagerDemoComponent, RequestManagerStateDemoComponent, RequestOptions, RequestService, RequestSignalsService, RetryOptions, SettingOptions, StateStorageOptions, StorageData, StorageOption, StorageType, StoreStateManagerService, SymmetricalEncryptionService, TableSchemaDef, UUID, UUID_STR, UtilsService, WSOptions, WSUser, WebsocketService, WithCredentialsInterceptor, countdown, createChannelName, delayedRetry, requestPolling, requestStreaming };
 //# sourceMappingURL=http-request-manager.mjs.map