@ipcom/asterisk-ari 0.0.25 → 0.0.27

package/dist/esm/index.js

@@ -572,6 +572,7 @@ var require_backoff = __commonJS({
 
 // src/ari-client/ariClient.ts
 var import_exponential_backoff = __toESM(require_backoff(), 1);
+import { EventEmitter as EventEmitter4 } from "events";
 
 // src/ari-client/baseClient.ts
 import axios from "axios";
@@ -835,16 +836,66 @@ var Bridges = class {
 };
 
 // src/ari-client/resources/channels.ts
+import { EventEmitter } from "events";
 function toQueryParams2(options) {
   return new URLSearchParams(
     Object.entries(options).filter(([, value]) => value !== void 0).map(([key, value]) => [key, value])
     // Garante que value é string
   ).toString();
 }
-var Channels = class {
+var Channels = class extends EventEmitter {
   constructor(client) {
+    super();
     this.client = client;
   }
+  /**
+   * Emits a specific channel-related event.
+   *
+   * This method is called by the WebSocket client to notify about channel-related events.
+   * It will emit events like "ChannelDtmfReceived" to registered listeners.
+   *
+   * @param eventType - The type of WebSocket event to emit.
+   * @param data - The data associated with the event.
+   */
+  emitChannelEvent(eventType, data) {
+    if ("channel" in data) {
+      const channelId = data.channel?.id;
+      if (channelId) {
+        this.emit(`${eventType}:${channelId}`, data);
+      }
+    }
+    this.emit(eventType, data);
+  }
+  /**
+   * Registers a listener for a specific channel-related event.
+   *
+   * @param eventType - The type of WebSocket event to listen for.
+   * @param channelId - The ID of the channel to listen for.
+   * @param callback - The callback function to execute when the event occurs.
+   */
+  registerChannelListener(eventType, channelId, callback) {
+    this.on(`${eventType}:${channelId}`, callback);
+  }
+  /**
+   * Unregisters a listener for a specific channel-related event.
+   *
+   * @param eventType - The type of WebSocket event to stop listening for.
+   * @param channelId - The ID of the channel to stop listening for.
+   * @param callback - The callback function to remove.
+   */
+  unregisterChannelListener(eventType, channelId, callback) {
+    this.off(`${eventType}:${channelId}`, callback);
+  }
+  /**
+   * Checks if a listener is already registered for a specific channel event.
+   *
+   * @param eventType - The type of event to check.
+   * @param channelId - The channel ID associated with the listener.
+   * @returns True if a listener is already registered, false otherwise.
+   */
+  isChannelListenerRegistered(eventType, channelId) {
+    return this.listenerCount(`${eventType}:${channelId}`) > 0;
+  }
   /**
    * Lists all active channels.
    */
@@ -1181,8 +1232,10 @@ var Endpoints = class {
 };
 
 // src/ari-client/resources/playbacks.ts
-var Playbacks = class {
+import { EventEmitter as EventEmitter2 } from "events";
+var Playbacks = class extends EventEmitter2 {
   constructor(client) {
+    super();
     this.client = client;
   }
   /**
@@ -1221,6 +1274,50 @@ var Playbacks = class {
   async stop(playbackId) {
     await this.client.post(`/playbacks/${playbackId}/stop`);
   }
+  /**
+   * Registers a listener for playback events.
+   * The listener is triggered for events such as "PlaybackFinished".
+   *
+   * @param eventType - The type of event to listen for.
+   * @param playbackId - The ID of the playback to associate with this listener.
+   * @param callback - The callback function to execute when the event occurs.
+   */
+  registerListener(eventType, playbackId, callback) {
+    this.on(`${eventType}:${playbackId}`, callback);
+  }
+  /**
+   * Unregisters a listener for playback events.
+   *
+   * @param eventType - The type of event to stop listening for.
+   * @param playbackId - The ID of the playback associated with the listener.
+   * @param callback - The callback function to remove.
+   */
+  unregisterListener(eventType, playbackId, callback) {
+    this.off(`${eventType}:${playbackId}`, callback);
+  }
+  /**
+   * Checks if a listener is already registered for a specific event and playback.
+   *
+   * @param eventType - The type of event to check.
+   * @param playbackId - The playback ID associated with the listener.
+   * @returns True if a listener is already registered, false otherwise.
+   */
+  isListenerRegistered(eventType, playbackId) {
+    return this.listenerCount(`${eventType}:${playbackId}`) > 0;
+  }
+  /**
+   * Emits playback events received via WebSocket.
+   * This method should be called by the WebSocket client when playback events occur.
+   *
+   * @param eventType - The type of the WebSocket event.
+   * @param data - The data associated with the event.
+   */
+  emitPlaybackEvent(eventType, data) {
+    if ("playbackId" in data) {
+      this.emit(`${eventType}:${data.playbackId}`, data);
+    }
+    this.emit(eventType, data);
+  }
 };
 
 // src/ari-client/resources/sounds.ts
@@ -1255,16 +1352,25 @@ var Sounds = class {
 };
 
 // src/ari-client/websocketClient.ts
+import { EventEmitter as EventEmitter3 } from "events";
 import WebSocket from "ws";
-var WebSocketClient = class {
-  // Para evitar reconexões paralelas
+var WebSocketClient = class extends EventEmitter3 {
+  /**
+   * Creates a new WebSocketClient instance.
+   * @param url - The WebSocket server URL to connect to.
+   */
   constructor(url) {
+    super();
     this.url = url;
   }
   ws = null;
   isClosedManually = false;
-  // Para evitar reconexões automáticas quando fechado manualmente
   isReconnecting = false;
+  /**
+   * Establishes a connection to the WebSocket server.
+   * @returns A Promise that resolves when the connection is established, or rejects if an error occurs.
+   * @throws Will throw an error if the connection fails.
+   */
   async connect() {
     if (this.isReconnecting) return;
     return new Promise((resolve, reject) => {
@@ -1282,47 +1388,70 @@ var WebSocketClient = class {
       this.ws.on("close", (code, reason) => {
         console.warn(`WebSocket desconectado: ${code} - ${reason}`);
         this.isReconnecting = false;
+        this.emit("close", { code, reason });
+      });
+      this.ws.on("message", (rawData) => {
+        this.handleMessage(rawData);
       });
     });
   }
-  async reconnect() {
-    if (this.isClosedManually || this.isReconnecting) return;
-    console.log("Tentando reconectar ao WebSocket...");
-    this.isReconnecting = true;
-    try {
-      await this.connect();
-      console.log("Reconex\xE3o bem-sucedida.");
-    } catch (err) {
-      console.error("Erro ao tentar reconectar:", err);
-    } finally {
-      this.isReconnecting = false;
-    }
-  }
+  /**
+   * Checks if the WebSocket connection is currently open.
+   * @returns True if the connection is open, false otherwise.
+   */
   isConnected() {
     return this.ws?.readyState === WebSocket.OPEN;
   }
+  /**
+   * Adds a listener for WebSocket events.
+   * @param event - The event type to listen for.
+   * @param callback - The function to call when the event occurs.
+   * @returns The WebSocketClient instance for chaining.
+   */
   on(event, callback) {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-      throw new Error("WebSocket n\xE3o est\xE1 conectado.");
-    }
-    if (event === "message") {
-      this.ws.on(event, (rawData) => {
-        try {
-          const decodedData = JSON.parse(rawData.toString());
-          if (decodedData?.type) {
-            const matchedEvent = decodedData;
-            callback(matchedEvent);
-          } else {
-            console.warn("Mensagem sem tipo:", decodedData);
-          }
-        } catch (err) {
-          console.error("Erro ao decodificar mensagem do WebSocket:", err);
-        }
-      });
-    } else {
-      this.ws.on(event, callback);
+    super.on(event, callback);
+    return this;
+  }
+  /**
+   * Removes a specific listener from a WebSocket event.
+   * @param event - The event type to remove the listener from.
+   * @param callback - The function to remove from the event listeners.
+   * @returns The WebSocketClient instance for chaining.
+   */
+  off(event, callback) {
+    super.off(event, callback);
+    return this;
+  }
+  /**
+   * Removes all listeners for a specific event, or all events if no event is specified.
+   * @param event - Optional. The event to remove all listeners from.
+   * @returns The WebSocketClient instance for chaining.
+   */
+  removeAllListeners(event) {
+    super.removeAllListeners(event);
+    return this;
+  }
+  /**
+   * Handles incoming WebSocket messages.
+   * @param rawData - The raw data received from the WebSocket.
+   */
+  handleMessage(rawData) {
+    try {
+      const decodedData = JSON.parse(rawData.toString());
+      if (decodedData?.type) {
+        this.emit(decodedData.type, decodedData);
+      } else {
+        console.warn("Mensagem recebida sem tipo:", decodedData);
+      }
+    } catch (err) {
+      console.error("Erro ao decodificar mensagem do WebSocket:", err);
     }
   }
+  /**
+   * Sends data through the WebSocket connection.
+   * @param data - The data to send.
+   * @throws Will throw an error if the WebSocket is not connected.
+   */
   send(data) {
     if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
       throw new Error("WebSocket n\xE3o est\xE1 conectado.");
@@ -1333,6 +1462,9 @@ var WebSocketClient = class {
       }
     });
   }
+  /**
+   * Closes the WebSocket connection manually.
+   */
   close() {
     if (this.ws) {
       this.isClosedManually = true;
@@ -1361,6 +1493,7 @@ var AriClient = class {
   wsClient = null;
   baseClient;
   isReconnecting = false;
+  eventEmitter = new EventEmitter4();
   channels;
   endpoints;
   applications;
@@ -1370,10 +1503,14 @@ var AriClient = class {
   bridges;
   /**
    * Connects to the ARI WebSocket for a specific application.
+   * This function establishes a WebSocket connection to the Asterisk ARI, sets up event listeners,
+   * and ensures the application is registered. It uses an exponential backoff strategy for connection attempts.
    *
-   * @param app - The application name to connect to.
-   * @param subscribedEvents
-   * @returns {Promise<void>} Resolves when the WebSocket connects successfully.
+   * @param app - The name of the application to connect to. This is required and used to identify the application in ARI.
+   * @param subscribedEvents - Optional array of WebSocketEventType to subscribe to specific events.
+   *                           If not provided or empty, it subscribes to all events.
+   * @returns A Promise that resolves when the WebSocket connection is successfully established and the application is registered.
+   * @throws Error if the 'app' parameter is not provided, or if connection attempts fail after multiple retries.
    */
   async connectWebSocket(app, subscribedEvents) {
     if (!app) {
@@ -1401,6 +1538,11 @@ var AriClient = class {
         return !this.wsClient?.isConnected();
       }
     };
+    if (this.wsClient?.isConnected()) {
+      console.log("WebSocket j\xE1 conectado. Removendo listeners antigos...");
+      this.wsClient.removeAllListeners();
+      this.wsClient.close();
+    }
     this.wsClient = new WebSocketClient(wsUrl);
     try {
       await (0, import_exponential_backoff.backOff)(async () => {
@@ -1408,6 +1550,7 @@ var AriClient = class {
           throw new Error("WebSocketClient instance is null.");
         }
         await this.wsClient.connect();
+        this.integrateWebSocketEvents();
         console.log(`WebSocket conectado para o app: ${app}`);
         await this.ensureAppRegistered(app);
       }, backoffOptions);
@@ -1421,6 +1564,104 @@ var AriClient = class {
       this.isReconnecting = false;
     }
   }
+  /**
+   * Integrates WebSocket events with playback listeners.
+   */
+  integrateWebSocketEvents() {
+    if (!this.wsClient) {
+      throw new Error("WebSocket client n\xE3o est\xE1 conectado.");
+    }
+    const eventHandlers = {
+      PlaybackFinished: (data) => {
+        if ("playbackId" in data) {
+          this.playbacks.emitPlaybackEvent("PlaybackFinished", data);
+        }
+        this.emitGlobalEvent(data);
+      },
+      ChannelStateChange: (data) => {
+        if ("channel" in data) {
+          console.log("Estado do canal alterado:", data.channel);
+        }
+        this.emitGlobalEvent(data);
+      },
+      BridgeDestroyed: (data) => {
+        if ("bridge" in data) {
+          console.log("Bridge destru\xEDda:", data.bridge);
+        }
+        this.emitGlobalEvent(data);
+      },
+      // Adicione mais eventos conforme necessário
+      // Exemplo:
+      ChannelDtmfReceived: (data) => {
+        if ("channel" in data) {
+          console.log("DTMF recebido no canal:", data.channel);
+          this.channels.emitChannelEvent("ChannelDtmfReceived", data);
+        }
+        this.emitGlobalEvent(data);
+      }
+    };
+    for (const [eventType, handler] of Object.entries(eventHandlers)) {
+      if (handler) {
+        this.wsClient.on(eventType, handler);
+      }
+    }
+    console.log("Todos os eventos do WebSocket foram registrados.");
+  }
+  /**
+   * Registra um listener para eventos globais.
+   * @param callback - A função a ser executada quando um evento global for recebido.
+   */
+  onGlobalEvent(callback) {
+    this.eventEmitter.on("globalEvent", callback);
+  }
+  /**
+   * Remove um listener para eventos globais.
+   * @param callback - A função a ser removida dos eventos globais.
+   */
+  offGlobalEvent(callback) {
+    this.eventEmitter.off("globalEvent", callback);
+  }
+  /**
+   * Emite um evento global.
+   * @param data - Os dados do evento a serem emitidos.
+   */
+  emitGlobalEvent(data) {
+    this.eventEmitter.emit("globalEvent", data);
+  }
+  /**
+   * Unregisters a listener for playback events.
+   *
+   * This method removes a specific listener registered for a playback event type,
+   * ensuring that no further notifications are sent to the callback function.
+   *
+   * @param eventType - The type of event to stop listening for.
+   * @param playbackId - The unique ID of the playback associated with the listener.
+   * @param callback - The callback function to remove from the listener.
+   */
+  unregisterPlaybackListener(eventType, playbackId, callback) {
+    this.playbacks.unregisterListener(eventType, playbackId, callback);
+  }
+  /**
+   * Registers a listener for playback events.
+   * The listener is triggered for events such as "PlaybackFinished".
+   *
+   * @param eventType - The type of event to listen for.
+   * @param playbackId - The ID of the playback to associate with this listener.
+   * @param callback - The callback function to execute when the event occurs.
+   */
+  registerPlaybackListener(eventType, playbackId, callback) {
+    this.playbacks.registerListener(eventType, playbackId, callback);
+  }
+  /**
+   * Checks if a listener is already registered for a specific event and playback.
+   *
+   * @param eventType - The type of event to check.
+   * @param playbackId - The playback ID associated with the listener.
+   * @returns True if a listener is already registered, false otherwise.
+   */
+  isPlaybackListenerRegistered(eventType, playbackId) {
+    return this.playbacks.isListenerRegistered(eventType, playbackId);
+  }
   /**
    * Ensures the ARI application is registered.
    *
@@ -1452,23 +1693,72 @@ var AriClient = class {
     return this.wsClient ? this.wsClient.isConnected() : false;
   }
   /**
-   * Registers a callback function for WebSocket events.
-   * This method allows you to listen for and respond to WebSocket messages
-   * and process specific event types.
+   * Registers a listener for WebSocket events.
+   *
+   * This function allows you to attach a callback function to a specific WebSocket event type.
+   * The callback will be executed whenever an event of the specified type is received.
+   *
+   * @template T - The type of WebSocket event, extending WebSocketEvent["type"].
+   * @param {T} event - The type of WebSocket event to listen for.
+   * @param {(data: Extract<WebSocketEvent, { type: T }>) => void} callback - The function to be called when the event is received.
+   *        The callback receives the event data as its parameter.
+   * @throws {Error} Throws an error if the WebSocket client is not connected when this method is called.
+   * @returns {void} This function doesn't return a value.
+   */
+  onWebSocketEvent(event, callback) {
+    if (!this.wsClient) {
+      throw new Error("WebSocket n\xE3o est\xE1 conectado.");
+    }
+    this.wsClient.on(event, callback);
+  }
+  /**
+   * Removes a specific listener for WebSocket events.
+   *
+   * This function unregisters a previously registered callback function for a specific WebSocket event type.
+   * It's useful for removing event handlers when they are no longer needed or for cleaning up resources.
+   *
+   * @template T - The type of WebSocket event, extending WebSocketEvent["type"].
+   * @param {T} event - The type of WebSocket event to remove the listener from.
+   * @param {(data: Extract<WebSocketEvent, { type: T }>) => void} callback - The callback function to be removed.
+   *        This should be the same function reference that was used when adding the event listener.
+   * @throws {Error} Throws an error if the WebSocket client is not connected when this method is called.
+   * @returns {void} This function doesn't return a value.
+   */
+  offWebSocketEvent(event, callback) {
+    if (!this.wsClient) {
+      throw new Error("WebSocket n\xE3o est\xE1 conectado.");
+    }
+    this.wsClient.off(event, callback);
+  }
+  /**
+   * Removes all listeners for a specific WebSocket event type.
+   *
+   * This function removes all event listeners that have been registered for a particular
+   * WebSocket event type. It's useful for cleaning up event listeners when they are no
+   * longer needed or before re-registering new listeners.
+   *
+   * @param event - The type of WebSocket event for which all listeners should be removed.
+   *                This should be a string identifying the event type (e.g., 'message', 'close', etc.).
+   *
+   * @throws {Error} Throws an error if the WebSocket client is not connected when this method is called.
    *
-   * @param callback - The callback function to execute when a WebSocket message is received.
-   *                   The function will receive the parsed event data as its parameter.
-   * @throws {Error} Throws an error if the WebSocket is not connected when trying to register the event.
-   * @returns {void}
+   * @returns {void} This function doesn't return a value.
    */
-  onWebSocketEvent(callback) {
+  removeAllWebSocketListeners(event) {
     if (!this.wsClient) {
-      throw new Error("WebSocket is not connected.");
+      throw new Error("WebSocket n\xE3o est\xE1 conectado.");
     }
-    this.wsClient.on("message", callback);
+    this.wsClient.removeAllListeners(event);
   }
   /**
-   * Closes the WebSocket connection.
+   * Closes the WebSocket connection and removes all associated listeners.
+   *
+   * This function terminates the active WebSocket connection if one exists,
+   * and cleans up by removing all event listeners attached to it. After calling
+   * this function, the WebSocket client will be set to null, effectively
+   * ending the connection and preparing for potential future connections.
+   *
+   * @returns {void} This function doesn't return a value.
    */
   closeWebSocket() {
     if (this.wsClient) {
@@ -1879,20 +2169,20 @@ var AriClient = class {
     return this.playbacks.getDetails(playbackId);
   }
   /**
-  * Controls a specific playback in the Asterisk server.
-  * This function allows manipulation of an ongoing playback, such as pausing, resuming, or skipping.
-  *
-  * @param playbackId - The unique identifier of the playback to control.
-  *                     This should be a string that uniquely identifies the playback in the Asterisk system.
-  * @param controlRequest - An object containing the control operation details.
-  *                         This object should conform to the PlaybackControlRequest interface,
-  *                         which includes an 'operation' property specifying the control action to perform.
-  * @returns A Promise that resolves when the control operation is successfully executed.
-  *          The promise resolves to void, indicating no specific return value.
-  *          If an error occurs during the operation, the promise will be rejected with an error object.
-  * @throws Will throw an error if the playback control operation fails, e.g., if the playback doesn't exist
-  *         or the requested operation is invalid.
-  */
+   * Controls a specific playback in the Asterisk server.
+   * This function allows manipulation of an ongoing playback, such as pausing, resuming, or skipping.
+   *
+   * @param playbackId - The unique identifier of the playback to control.
+   *                     This should be a string that uniquely identifies the playback in the Asterisk system.
+   * @param controlRequest - An object containing the control operation details.
+   *                         This object should conform to the PlaybackControlRequest interface,
+   *                         which includes an 'operation' property specifying the control action to perform.
+   * @returns A Promise that resolves when the control operation is successfully executed.
+   *          The promise resolves to void, indicating no specific return value.
+   *          If an error occurs during the operation, the promise will be rejected with an error object.
+   * @throws Will throw an error if the playback control operation fails, e.g., if the playback doesn't exist
+   *         or the requested operation is invalid.
+   */
   async controlPlayback(playbackId, controlRequest) {
     const { operation } = controlRequest;
     return this.playbacks.control(playbackId, operation);