@ipcom/asterisk-ari 0.0.152 → 0.0.153

package/dist/cjs/index.cjs

@@ -2340,17 +2340,12 @@ var DEFAULT_STARTING_DELAY = 500;
 var DEFAULT_MAX_DELAY = 1e4;
 var WebSocketClient = class extends import_events3.EventEmitter {
   /**
-   * Creates a new WebSocketClient instance.
+   * Creates a new WebSocket client instance.
    *
-   * This constructor initializes a WebSocketClient with the necessary dependencies and configuration.
-   * It ensures that at least one application name is provided.
-   *
-   * @param baseClient - The BaseClient instance used for basic ARI operations and authentication.
-   * @param apps - An array of application names to connect to via the WebSocket.
-   * @param subscribedEvents - Optional. An array of WebSocketEventTypes to subscribe to. If not provided, all events will be subscribed.
-   * @param ariClient - Optional. The AriClient instance, used for creating Channel and Playback instances when processing events.
-   *
-   * @throws {Error} Throws an error if the apps array is empty.
+   * @param {BaseClient} baseClient - The base client containing connection details
+   * @param {string[]} apps - List of applications to connect to
+   * @param {WebSocketEventType[]} [subscribedEvents] - Optional list of events to subscribe to
+   * @param {AriClient} [ariClient] - Optional ARI client for handling channel and playback events
    */
   constructor(baseClient, apps, subscribedEvents, ariClient) {
     super();
@@ -2365,8 +2360,6 @@ var WebSocketClient = class extends import_events3.EventEmitter {
   ws;
   isReconnecting = false;
   maxReconnectAttempts = DEFAULT_MAX_RECONNECT_ATTEMPTS;
-  reconnectionAttempts = 0;
-  lastWsUrl = "";
   backOffOptions = {
     numOfAttempts: DEFAULT_MAX_RECONNECT_ATTEMPTS,
     startingDelay: DEFAULT_STARTING_DELAY,
@@ -2383,14 +2376,10 @@ var WebSocketClient = class extends import_events3.EventEmitter {
     }
   };
   /**
-   * Establishes a WebSocket connection to the Asterisk server.
-   *
-   * This method constructs the WebSocket URL using the base URL, credentials,
-   * application names, and subscribed events. It then initiates the connection
-   * using the constructed URL.
+   * Establishes a WebSocket connection.
    *
-   * @returns A Promise that resolves when the WebSocket connection is successfully established.
-   * @throws Will throw an error if the connection cannot be established.
+   * @returns {Promise<void>} Resolves when connection is established
+   * @throws {Error} If connection fails
    */
   async connect() {
     const { baseUrl, username, password } = this.baseClient.getCredentials();
@@ -2405,24 +2394,15 @@ var WebSocketClient = class extends import_events3.EventEmitter {
     } else {
       queryParams.append("subscribeAll", "true");
     }
-    this.lastWsUrl = `${protocol}://${encodeURIComponent(username)}:${encodeURIComponent(password)}@${normalizedHost}/ari/events?${queryParams.toString()}`;
+    const wsUrl = `${protocol}://${encodeURIComponent(username)}:${encodeURIComponent(password)}@${normalizedHost}/ari/events?${queryParams.toString()}`;
     console.log("Connecting to WebSocket...");
-    return this.initializeWebSocket(this.lastWsUrl);
+    return this.initializeWebSocket(wsUrl);
   }
   /**
-   * Initializes a WebSocket connection with exponential backoff retry mechanism.
-   *
-   * This method attempts to establish a WebSocket connection to the specified URL.
-   * It sets up event listeners for the WebSocket's 'open', 'message', 'close', and 'error' events.
-   * If the connection is successful, it emits a 'connected' event. If it's a reconnection,
-   * it also emits a 'reconnected' event with the current apps and subscribed events.
-   * In case of connection failure, it uses an exponential backoff strategy to retry.
+   * Initializes WebSocket connection with reconnection logic.
    *
-   * @param wsUrl - The WebSocket URL to connect to.
-   * @returns A Promise that resolves when the connection is successfully established,
-   *          or rejects if an error occurs during the connection process.
-   * @throws Will throw an error if the WebSocket connection cannot be established
-   *         after the maximum number of retry attempts.
+   * @param {string} wsUrl - The WebSocket URL to connect to
+   * @returns {Promise<void>} Resolves when connection is established
    */
   async initializeWebSocket(wsUrl) {
     return (0, import_exponential_backoff.backOff)(async () => {
@@ -2431,14 +2411,7 @@ var WebSocketClient = class extends import_events3.EventEmitter {
           this.ws = new import_ws.default(wsUrl);
           this.ws.on("open", () => {
             console.log("WebSocket connection established successfully");
-            if (this.isReconnecting) {
-              this.emit("reconnected", {
-                apps: this.apps,
-                subscribedEvents: this.subscribedEvents
-              });
-            }
             this.isReconnecting = false;
-            this.reconnectionAttempts = 0;
             this.emit("connected");
             resolve();
           });
@@ -2448,13 +2421,13 @@ var WebSocketClient = class extends import_events3.EventEmitter {
               `WebSocket disconnected with code ${code}. Attempting to reconnect...`
             );
             if (!this.isReconnecting) {
-              this.reconnect(this.lastWsUrl);
+              this.reconnect(wsUrl);
             }
           });
           this.ws.on("error", (err) => {
             console.error("WebSocket error:", err.message);
             if (!this.isReconnecting) {
-              this.reconnect(this.lastWsUrl);
+              this.reconnect(wsUrl);
             }
             reject(err);
           });
@@ -2465,16 +2438,9 @@ var WebSocketClient = class extends import_events3.EventEmitter {
     }, this.backOffOptions);
   }
   /**
-   * Handles incoming WebSocket messages by parsing and processing events.
-   *
-   * This method parses the raw message into a WebSocketEvent, filters it based on
-   * subscribed events (if any), processes channel and playback events, and emits
-   * the event to listeners. It also handles any errors that occur during processing.
+   * Processes incoming WebSocket messages.
    *
-   * @param rawMessage - The raw message string received from the WebSocket connection.
-   * @returns void This method doesn't return a value but emits events.
-   *
-   * @throws Will emit an 'error' event if the message cannot be parsed or processed.
+   * @param {string} rawMessage - The raw message received from WebSocket
    */
   handleMessage(rawMessage) {
     try {
@@ -2502,27 +2468,18 @@ var WebSocketClient = class extends import_events3.EventEmitter {
     }
   }
   /**
-   * Attempts to reconnect to the WebSocket server using an exponential backoff strategy.
-   *
-   * This method is called when the WebSocket connection is closed unexpectedly.
-   * It increments the reconnection attempt counter, logs the attempt, and uses
-   * the backOff utility to retry the connection with exponential delays between attempts.
+   * Attempts to reconnect to the WebSocket.
    *
-   * @param wsUrl - The WebSocket URL to reconnect to.
-   * @returns void - This method doesn't return a value.
-   *
-   * @emits reconnectFailed - Emitted if all reconnection attempts fail.
+   * @param {string} wsUrl - The WebSocket URL to reconnect to
    */
   reconnect(wsUrl) {
     this.isReconnecting = true;
-    this.reconnectionAttempts++;
-    console.log(
-      `Initiating reconnection attempt #${this.reconnectionAttempts}...`
-    );
+    console.log("Initiating reconnection attempt...");
+    this.removeAllListeners();
     (0, import_exponential_backoff.backOff)(() => this.initializeWebSocket(wsUrl), this.backOffOptions).catch(
       (error) => {
         console.error(
-          `Failed to reconnect after ${this.reconnectionAttempts} attempts:`,
+          "Failed to reconnect after multiple attempts:",
           error instanceof Error ? error.message : "Unknown error"
         );
         this.emit("reconnectFailed", error);
@@ -2530,13 +2487,7 @@ var WebSocketClient = class extends import_events3.EventEmitter {
     );
   }
   /**
-   * Closes the WebSocket connection if it exists.
-   *
-   * This method attempts to gracefully close the WebSocket connection
-   * and sets the WebSocket instance to undefined. If an error occurs
-   * during the closing process, it will be caught and logged.
-   *
-   * @throws {Error} Logs an error message if closing the WebSocket fails.
+   * Manually closes the WebSocket connection.
    */
   close() {
     try {
@@ -2552,9 +2503,19 @@ var WebSocketClient = class extends import_events3.EventEmitter {
       );
     }
   }
+  /**
+   * Checks if the WebSocket is currently connected.
+   *
+   * @returns {boolean} True if connected, false otherwise
+   */
   isConnected() {
     return this.ws?.readyState === import_ws.default.OPEN;
   }
+  /**
+   * Gets the current connection state.
+   *
+   * @returns {number} The WebSocket ready state
+   */
   getState() {
     return this.ws?.readyState ?? import_ws.default.CLOSED;
   }