@ipcom/asterisk-ari 0.0.151 → 0.0.153

package/dist/cjs/index.cjs

@@ -1202,73 +1202,24 @@ var ChannelInstance = class {
    * Plays media on the channel
    */
   async play(options, playbackId) {
-    return new Promise(async (resolve, reject) => {
-      try {
-        if (!options.media) {
-          throw new Error("Media URL is required");
-        }
-        if (!this.channelData) {
-          this.channelData = await this.getDetails();
-        }
-        const playback = this.client.Playback(playbackId || v4_default());
-        let playbackStarted = false;
-        const failureListener = (event) => {
-          if ("playback" in event && event.playback) {
-            if (event.playback.state === "failed") {
-              console.error("Playback falhou:", {
-                playbackId: playback.id,
-                channelId: this.id,
-                state: event.playback.state
-              });
-              if (!playbackStarted) {
-                reject(
-                  new Error(
-                    `Playback failed to start: ${event.playback.state}`
-                  )
-                );
-              }
-            }
-          }
-        };
-        const startListener = (event) => {
-          if ("playback" in event && event.playback) {
-            console.log("Playback come\xE7ou:", {
-              playbackId: playback.id,
-              channelId: this.id,
-              state: event.playback.state
-            });
-            playbackStarted = true;
-            setTimeout(async () => {
-              try {
-                const status = await playback.get();
-                if (status.state === "playing") {
-                  resolve(playback);
-                } else {
-                  reject(
-                    new Error(`Playback started but state is ${status.state}`)
-                  );
-                }
-              } catch (_err) {
-                reject(new Error("Failed to verify playback status"));
-              }
-            }, 500);
-          }
-        };
-        playback.once("PlaybackStarted", startListener);
-        playback.once("PlaybackFinished", failureListener);
-        await this.baseClient.post(
-          `/channels/${this.id}/play/${playback.id}`,
-          options
-        );
-        setTimeout(() => {
-          if (!playbackStarted) {
-            reject(new Error("Playback timeout - n\xE3o iniciou"));
-          }
-        }, 5e3);
-      } catch (error) {
-        reject(error);
+    if (!options.media) {
+      throw new Error("Media URL is required");
+    }
+    try {
+      if (!this.channelData) {
+        this.channelData = await this.getDetails();
       }
-    });
+      const playback = this.client.Playback(playbackId || v4_default());
+      await this.baseClient.post(
+        `/channels/${this.id}/play/${playback.id}`,
+        options
+      );
+      return playback;
+    } catch (error) {
+      const message = getErrorMessage(error);
+      console.error(`Error playing media on channel ${this.id}:`, message);
+      throw new Error(`Failed to play media: ${message}`);
+    }
   }
   /**
    * Gets the current channel details
@@ -2389,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.
-   *
-   * This constructor initializes a WebSocketClient with the necessary dependencies and configuration.
-   * It ensures that at least one application name is provided.
+   * Creates a new WebSocket client instance.
    *
-   * @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();
@@ -2414,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,
@@ -2432,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();
@@ -2454,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 () => {
@@ -2480,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();
           });
@@ -2497,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);
           });
@@ -2514,16 +2438,9 @@ var WebSocketClient = class extends import_events3.EventEmitter {
     }, this.backOffOptions);
   }
   /**
-   * Handles incoming WebSocket messages by parsing and processing events.
+   * Processes incoming WebSocket messages.
    *
-   * 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.
-   *
-   * @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 {
@@ -2551,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);
@@ -2579,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 {
@@ -2602,30 +2504,17 @@ var WebSocketClient = class extends import_events3.EventEmitter {
     }
   }
   /**
-   * Checks if the WebSocket connection is currently open and active.
+   * Checks if the WebSocket is currently connected.
    *
-   * This method examines the readyState of the WebSocket instance to determine
-   * if the connection is established and ready for communication.
-   *
-   * @returns {boolean} True if the WebSocket connection is open and ready,
-   *                    false otherwise.
+   * @returns {boolean} True if connected, false otherwise
    */
   isConnected() {
     return this.ws?.readyState === import_ws.default.OPEN;
   }
   /**
-   * Retrieves the current state of the WebSocket connection.
-   *
-   * This method returns the readyState of the WebSocket instance, which
-   * indicates the current state of the connection. If no WebSocket instance
-   * exists, it returns the CLOSED state.
+   * Gets the current connection state.
    *
-   * @returns {number} The current state of the WebSocket connection.
-   *                   Possible values are:
-   *                   - WebSocket.CONNECTING (0): The connection is not yet open.
-   *                   - WebSocket.OPEN (1): The connection is open and ready to communicate.
-   *                   - WebSocket.CLOSING (2): The connection is in the process of closing.
-   *                   - WebSocket.CLOSED (3): The connection is closed or couldn't be opened.
+   * @returns {number} The WebSocket ready state
    */
   getState() {
     return this.ws?.readyState ?? import_ws.default.CLOSED;