mediasfu-angular 1.0.0 → 1.0.2

package/dist/esm2022/lib/consumers/connect-ips.service.mjs

@@ -4,6 +4,48 @@ import * as i1 from "../sockets/socket-manager.service";
 import * as i2 from "./socket-receive-methods/new-pipe-producer.service";
 import * as i3 from "./socket-receive-methods/producer-closed.service";
 import * as i4 from "./socket-receive-methods/join-consume-room.service";
+/**
+ * Connects to remote IPs and manages socket connections.
+ *
+ * This method establishes connections to remote IPs for media streaming, handles new pipe producer events,
+ * and manages producer closure events. It updates the necessary state in the application to reflect
+ * the current connections and stream configurations.
+ *
+ * @param {ConnectIpsOptions} options - The options for connecting IPs.
+ * @param {Record<string, any>[]} options.consume_sockets - The array of current socket connections.
+ * @param {string[]} options.remIP - The list of remote IPs to connect to.
+ * @param {string} options.apiUserName - The API username for authentication.
+ * @param {string} [options.apiKey] - The API key for authentication.
+ * @param {string} [options.apiToken] - The API token for authentication.
+ * @param {Function} [options.newProducerMethod] - The method to handle new pipe producer events (default: newPipeProducer).
+ * @param {Function} [options.closedProducerMethod] - The method to handle producer closed events (default: producerClosed).
+ * @param {Function} [options.joinConsumeRoomMethod] - The method to handle joining a consuming room (default: joinConsumeRoom).
+ * @param {ConnectIpsParameters} options.parameters - Additional parameters for the operation.
+ * @param {string[]} options.parameters.roomRecvIPs - The list of IPs that have been received in the room.
+ * @param {Function} options.parameters.updateRoomRecvIPs - Function to update the room received IPs.
+ * @param {Function} options.parameters.updateConsume_sockets - Function to update the consume sockets.
+ *
+ * @returns {Promise<[Record<string, any>[], string[]]>} A promise that resolves to an array containing the updated consume sockets and room received IPs.
+ *
+ * @throws Will throw an error if required parameters are missing or if there is an issue connecting to a remote IP.
+ *
+ * @example
+ * ```typescript
+ * const result = await connectIps({
+ *   consume_sockets: currentSockets,
+ *   remIP: ['192.168.1.1', '192.168.1.2'],
+ *   apiUserName: 'username',
+ *   apiKey: 'your-api-key',
+ *   apiToken: 'your-api-token',
+ *   parameters: {
+ *     roomRecvIPs: [],
+ *     updateRoomRecvIPs: (ips) => { },
+ *     updateConsume_sockets: (sockets) => { },
+ *     // ...other parameters
+ *   },
+ * });
+ * ```
+ */
 export class ConnectIps {
     socketManagerService;
     newPipeProducerService;
@@ -109,4 +151,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }], ctorParameters: () => [{ type: i1.SocketManager }, { type: i2.NewPipeProducer }, { type: i3.ProducerClosed }, { type: i4.JoinConsumeRoom }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"connect-ips.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/connect-ips.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { SocketManager } from '../sockets/socket-manager.service';\nimport { NewPipeProducer } from './socket-receive-methods/new-pipe-producer.service';\nimport { ProducerClosed } from './socket-receive-methods/producer-closed.service';\nimport { JoinConsumeRoom } from './socket-receive-methods/join-consume-room.service';\nimport { Device } from 'mediasoup-client/lib/types';\nimport {\n  ReorderStreamsParameters,\n  ReorderStreamsType,\n  NewPipeProducerParameters,\n  NewPipeProducerType,\n  ProducerClosedType,\n  ProducerClosedParameters,\n  JoinConsumeRoomType,\n  JoinConsumeRoomParameters,\n  ConsumeSocket,\n} from '../@types/types';\n\nexport interface ConnectIpsParameters\n  extends ReorderStreamsParameters,\n    JoinConsumeRoomParameters,\n    ProducerClosedParameters,\n    NewPipeProducerParameters {\n  device: Device | null;\n  roomRecvIPs: string[];\n  updateRoomRecvIPs: (roomRecvIPs: string[]) => void;\n  updateConsume_sockets: (consume_sockets: ConsumeSocket[]) => void;\n\n  // mediasfu functions\n  reorderStreams: ReorderStreamsType;\n  getUpdatedAllParams: () => ConnectIpsParameters;\n  [key: string]: any;\n}\n\nexport interface ConnectIpsOptions {\n  consume_sockets: ConsumeSocket[];\n  remIP: string[];\n  apiUserName: string;\n  apiKey?: string;\n  apiToken: string;\n  newProducerMethod?: NewPipeProducerType;\n  closedProducerMethod?: ProducerClosedType;\n  joinConsumeRoomMethod?: JoinConsumeRoomType;\n  parameters: ConnectIpsParameters;\n}\n\n// Export the type definition for the function\nexport type ConnectIpsType = (\n  options: ConnectIpsOptions,\n) => Promise<[Record<string, any>[], string[]]>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ConnectIps {\n  constructor(\n    private socketManagerService: SocketManager,\n    private newPipeProducerService: NewPipeProducer,\n    private producerClosedService: ProducerClosed,\n    private joinConsumeRoomService: JoinConsumeRoom,\n  ) {}\n\n  /**\n   * Connects to remote IPs and manages socket connections.\n   *\n   * @param {Object} options - The options for connecting IPs.\n   * @param {Record<string, any>[]} options.consume_sockets - The array of current socket connections.\n   * @param {string[]} options.remIP - The list of remote IPs to connect to.\n   * @param {string} options.apiUserName - The API username for authentication.\n   * @param {string} [options.apiKey] - The API key for authentication.\n   * @param {string} [options.apiToken] - The API token for authentication.\n   * @param {Function} [options.newProducerMethod=newPipeProducer] - The method to handle new pipe producer events.\n   * @param {Function} [options.closedProducerMethod=producerClosed] - The method to handle producer closed events.\n   * @param {Function} [options.joinConsumeRoomMethod=joinConsumeRoom] - The method to handle joining a consuming room.\n   * @param {Object} options.parameters - Additional parameters.\n   * @param {string[]} options.parameters.roomRecvIPs - The list of IPs that have been received in the room.\n   * @param {Function} options.parameters.updateRoomRecvIPs - The function to update the room received IPs.\n   * @param {Function} options.parameters.updateConsume_sockets - The function to update the consume sockets.\n   *\n   * @returns {Promise<[Record<string, any>[], string[]]>} A promise that resolves to an array containing the updated consume sockets and room received IPs.\n   *\n   * @throws Will throw an error if required parameters are missing or if there is an issue connecting to a remote IP.\n   */\n  connectIps = async ({\n    consume_sockets,\n    remIP,\n    apiUserName,\n    apiKey = '',\n    apiToken = '',\n    newProducerMethod = this.newPipeProducerService.newPipeProducer,\n    closedProducerMethod = this.producerClosedService.producerClosed,\n    joinConsumeRoomMethod = this.joinConsumeRoomService.joinConsumeRoom,\n    parameters,\n  }: ConnectIpsOptions): Promise<any> => {\n    try {\n      const { roomRecvIPs, updateRoomRecvIPs, updateConsume_sockets } = parameters;\n\n      if (!consume_sockets || !remIP || !apiUserName || (!apiKey && !apiToken)) {\n        console.log(\n          'Missing required parameters - consume_sockets, remIP, apiUserName, apiKey, apiToken',\n        );\n        return [consume_sockets, roomRecvIPs];\n      }\n\n      await Promise.all(\n        remIP.map(async (ip) => {\n          try {\n            // Check if the IP is already connected\n            const matching = consume_sockets.find(\n              (socketObj: any) => Object.keys(socketObj)[0] == ip,\n            );\n\n            if (matching || !ip || ip === '' || ip === null || ip === undefined) {\n              // Skip if the IP is already connected\n              return;\n            }\n\n            // Connect to the remote socket using socket.io-client\n            const remote_sock = await this.socketManagerService.connectSocket({\n              apiUserName,\n              apiKey,\n              apiToken,\n              link: `https://${ip}.mediasfu.com`,\n            });\n\n            // Handle successful connection to the remote socket\n            if (remote_sock.id) {\n              // Check if the IP is in the roomRecvIPs, if not, add it\n              if (!roomRecvIPs.includes(ip)) {\n                roomRecvIPs.push(ip);\n                updateRoomRecvIPs(roomRecvIPs);\n              }\n\n              // Handle new pipe producer event\n              remote_sock.on(\n                'new-pipe-producer',\n                async ({ producerId, islevel }: { producerId: string; islevel: string }) => {\n                  await newProducerMethod({ producerId, islevel, nsock: remote_sock, parameters });\n                },\n              );\n\n              // Handle producer closed event\n              remote_sock.on(\n                'producer-closed',\n                async ({ remoteProducerId }: { remoteProducerId: string }) => {\n                  await closedProducerMethod({ remoteProducerId, parameters });\n                },\n              );\n\n              // Handle new consuming room by joining the room\n              const data = await joinConsumeRoomMethod({\n                remote_sock,\n                apiToken,\n                apiUserName,\n                parameters,\n              });\n              if (!data.rtpCapabilities) {\n                return;\n              }\n\n              // Add the remote socket to the consume_sockets array\n              consume_sockets.push({ [ip]: remote_sock });\n              updateConsume_sockets(consume_sockets);\n            }\n          } catch (error) {\n            // Handle the error\n            console.log('connectIps error', error);\n          }\n        }),\n      );\n\n      return [consume_sockets, roomRecvIPs];\n    } catch (error) {\n      // Handle the error\n      console.log('connectIps error', error);\n    }\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"connect-ips.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/connect-ips.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { SocketManager } from '../sockets/socket-manager.service';\nimport { NewPipeProducer } from './socket-receive-methods/new-pipe-producer.service';\nimport { ProducerClosed } from './socket-receive-methods/producer-closed.service';\nimport { JoinConsumeRoom } from './socket-receive-methods/join-consume-room.service';\nimport { Device } from 'mediasoup-client/lib/types';\nimport {\n  ReorderStreamsParameters,\n  ReorderStreamsType,\n  NewPipeProducerParameters,\n  NewPipeProducerType,\n  ProducerClosedType,\n  ProducerClosedParameters,\n  JoinConsumeRoomType,\n  JoinConsumeRoomParameters,\n  ConsumeSocket,\n} from '../@types/types';\n\nexport interface ConnectIpsParameters\n  extends ReorderStreamsParameters,\n    JoinConsumeRoomParameters,\n    ProducerClosedParameters,\n    NewPipeProducerParameters {\n  device: Device | null;\n  roomRecvIPs: string[];\n  updateRoomRecvIPs: (roomRecvIPs: string[]) => void;\n  updateConsume_sockets: (consume_sockets: ConsumeSocket[]) => void;\n\n  // mediasfu functions\n  reorderStreams: ReorderStreamsType;\n  getUpdatedAllParams: () => ConnectIpsParameters;\n  [key: string]: any;\n}\n\nexport interface ConnectIpsOptions {\n  consume_sockets: ConsumeSocket[];\n  remIP: string[];\n  apiUserName: string;\n  apiKey?: string;\n  apiToken: string;\n  newProducerMethod?: NewPipeProducerType;\n  closedProducerMethod?: ProducerClosedType;\n  joinConsumeRoomMethod?: JoinConsumeRoomType;\n  parameters: ConnectIpsParameters;\n}\n\n// Export the type definition for the function\nexport type ConnectIpsType = (\n  options: ConnectIpsOptions,\n) => Promise<[Record<string, any>[], string[]]>;\n\n/**\n * Connects to remote IPs and manages socket connections.\n *\n * This method establishes connections to remote IPs for media streaming, handles new pipe producer events,\n * and manages producer closure events. It updates the necessary state in the application to reflect\n * the current connections and stream configurations.\n *\n * @param {ConnectIpsOptions} options - The options for connecting IPs.\n * @param {Record<string, any>[]} options.consume_sockets - The array of current socket connections.\n * @param {string[]} options.remIP - The list of remote IPs to connect to.\n * @param {string} options.apiUserName - The API username for authentication.\n * @param {string} [options.apiKey] - The API key for authentication.\n * @param {string} [options.apiToken] - The API token for authentication.\n * @param {Function} [options.newProducerMethod] - The method to handle new pipe producer events (default: newPipeProducer).\n * @param {Function} [options.closedProducerMethod] - The method to handle producer closed events (default: producerClosed).\n * @param {Function} [options.joinConsumeRoomMethod] - The method to handle joining a consuming room (default: joinConsumeRoom).\n * @param {ConnectIpsParameters} options.parameters - Additional parameters for the operation.\n * @param {string[]} options.parameters.roomRecvIPs - The list of IPs that have been received in the room.\n * @param {Function} options.parameters.updateRoomRecvIPs - Function to update the room received IPs.\n * @param {Function} options.parameters.updateConsume_sockets - Function to update the consume sockets.\n *\n * @returns {Promise<[Record<string, any>[], string[]]>} A promise that resolves to an array containing the updated consume sockets and room received IPs.\n *\n * @throws Will throw an error if required parameters are missing or if there is an issue connecting to a remote IP.\n *\n * @example\n * ```typescript\n * const result = await connectIps({\n *   consume_sockets: currentSockets,\n *   remIP: ['192.168.1.1', '192.168.1.2'],\n *   apiUserName: 'username',\n *   apiKey: 'your-api-key',\n *   apiToken: 'your-api-token',\n *   parameters: {\n *     roomRecvIPs: [],\n *     updateRoomRecvIPs: (ips) => { },\n *     updateConsume_sockets: (sockets) => { },\n *     // ...other parameters\n *   },\n * });\n * ```\n */\n\n\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ConnectIps {\n  constructor(\n    private socketManagerService: SocketManager,\n    private newPipeProducerService: NewPipeProducer,\n    private producerClosedService: ProducerClosed,\n    private joinConsumeRoomService: JoinConsumeRoom,\n  ) {}\n\n  /**\n   * Connects to remote IPs and manages socket connections.\n   *\n   * @param {Object} options - The options for connecting IPs.\n   * @param {Record<string, any>[]} options.consume_sockets - The array of current socket connections.\n   * @param {string[]} options.remIP - The list of remote IPs to connect to.\n   * @param {string} options.apiUserName - The API username for authentication.\n   * @param {string} [options.apiKey] - The API key for authentication.\n   * @param {string} [options.apiToken] - The API token for authentication.\n   * @param {Function} [options.newProducerMethod=newPipeProducer] - The method to handle new pipe producer events.\n   * @param {Function} [options.closedProducerMethod=producerClosed] - The method to handle producer closed events.\n   * @param {Function} [options.joinConsumeRoomMethod=joinConsumeRoom] - The method to handle joining a consuming room.\n   * @param {Object} options.parameters - Additional parameters.\n   * @param {string[]} options.parameters.roomRecvIPs - The list of IPs that have been received in the room.\n   * @param {Function} options.parameters.updateRoomRecvIPs - The function to update the room received IPs.\n   * @param {Function} options.parameters.updateConsume_sockets - The function to update the consume sockets.\n   *\n   * @returns {Promise<[Record<string, any>[], string[]]>} A promise that resolves to an array containing the updated consume sockets and room received IPs.\n   *\n   * @throws Will throw an error if required parameters are missing or if there is an issue connecting to a remote IP.\n   */\n  connectIps = async ({\n    consume_sockets,\n    remIP,\n    apiUserName,\n    apiKey = '',\n    apiToken = '',\n    newProducerMethod = this.newPipeProducerService.newPipeProducer,\n    closedProducerMethod = this.producerClosedService.producerClosed,\n    joinConsumeRoomMethod = this.joinConsumeRoomService.joinConsumeRoom,\n    parameters,\n  }: ConnectIpsOptions): Promise<any> => {\n    try {\n      const { roomRecvIPs, updateRoomRecvIPs, updateConsume_sockets } = parameters;\n\n      if (!consume_sockets || !remIP || !apiUserName || (!apiKey && !apiToken)) {\n        console.log(\n          'Missing required parameters - consume_sockets, remIP, apiUserName, apiKey, apiToken',\n        );\n        return [consume_sockets, roomRecvIPs];\n      }\n\n      await Promise.all(\n        remIP.map(async (ip) => {\n          try {\n            // Check if the IP is already connected\n            const matching = consume_sockets.find(\n              (socketObj: any) => Object.keys(socketObj)[0] == ip,\n            );\n\n            if (matching || !ip || ip === '' || ip === null || ip === undefined) {\n              // Skip if the IP is already connected\n              return;\n            }\n\n            // Connect to the remote socket using socket.io-client\n            const remote_sock = await this.socketManagerService.connectSocket({\n              apiUserName,\n              apiKey,\n              apiToken,\n              link: `https://${ip}.mediasfu.com`,\n            });\n\n            // Handle successful connection to the remote socket\n            if (remote_sock.id) {\n              // Check if the IP is in the roomRecvIPs, if not, add it\n              if (!roomRecvIPs.includes(ip)) {\n                roomRecvIPs.push(ip);\n                updateRoomRecvIPs(roomRecvIPs);\n              }\n\n              // Handle new pipe producer event\n              remote_sock.on(\n                'new-pipe-producer',\n                async ({ producerId, islevel }: { producerId: string; islevel: string }) => {\n                  await newProducerMethod({ producerId, islevel, nsock: remote_sock, parameters });\n                },\n              );\n\n              // Handle producer closed event\n              remote_sock.on(\n                'producer-closed',\n                async ({ remoteProducerId }: { remoteProducerId: string }) => {\n                  await closedProducerMethod({ remoteProducerId, parameters });\n                },\n              );\n\n              // Handle new consuming room by joining the room\n              const data = await joinConsumeRoomMethod({\n                remote_sock,\n                apiToken,\n                apiUserName,\n                parameters,\n              });\n              if (!data.rtpCapabilities) {\n                return;\n              }\n\n              // Add the remote socket to the consume_sockets array\n              consume_sockets.push({ [ip]: remote_sock });\n              updateConsume_sockets(consume_sockets);\n            }\n          } catch (error) {\n            // Handle the error\n            console.log('connectIps error', error);\n          }\n        }),\n      );\n\n      return [consume_sockets, roomRecvIPs];\n    } catch (error) {\n      // Handle the error\n      console.log('connectIps error', error);\n    }\n  };\n}\n"]}

package/dist/esm2022/lib/consumers/connect-recv-transport.service.mjs

@@ -1,5 +1,38 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Connects the receiving transport to consume media from a remote producer.
+ *
+ * @param {ConnectRecvTransportOptions} options - The options for connecting the receiving transport.
+ * @param {Transport} options.consumerTransport - The transport used for consuming media.
+ * @param {string} options.remoteProducerId - The ID of the remote producer.
+ * @param {string} options.serverConsumerTransportId - The ID of the server consumer transport.
+ * @param {Socket} options.nsock - The socket used for communication.
+ * @param {ConnectRecvTransportParameters} options.parameters - The parameters for the connection.
+ *
+ * @returns {Promise<void>} A promise that resolves when the connection is established.
+ *
+ * @throws Will throw an error if the connection or consumption fails.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   consumerTransport,
+ *   remoteProducerId: 'producer-id',
+ *   serverConsumerTransportId: 'transport-id',
+ *   nsock: socket,
+ *   parameters: connectRecvTransportOptions,
+ * };
+ *
+ * connectRecvTransport(options)
+ *   .then(() => {
+ *     console.log('Transport connected and consuming media');
+ *   })
+ *   .catch((error) => {
+ *     console.error('Error connecting transport:', error);
+ *   });
+ * ```
+ */
 export class ConnectRecvTransport {
     /**
      * Connects the receiving transport to consume media from a remote producer.
@@ -110,4 +143,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"connect-recv-transport.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/connect-recv-transport.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAyC3C,MAAM,OAAO,oBAAoB;IAC/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IAEH,oBAAoB,GAAG,KAAK,EAAE,EAC5B,iBAAiB,EACjB,gBAAgB,EAChB,yBAAyB,EACzB,KAAK,EACL,UAAU,GACkB,EAAiB,EAAE;QAC/C,IAAI,CAAC;YACH,UAAU,GAAG,UAAU,CAAC,mBAAmB,EAAE,CAAC;YAC9C,MAAM,EAAE,MAAM,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,cAAc,EAAE,GAAG,UAAU,CAAC;YAE5F,wDAAwD;YACxD,KAAK,CAAC,IAAI,CACR,SAAS,EACT;gBACE,eAAe,EAAE,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC,CAAC,IAAI;gBACvD,gBAAgB;gBAChB,yBAAyB;aAC1B,EACD,KAAK,EAAE,EAAE,MAAM,EAAsB,EAAE,EAAE;gBACvC,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;oBACjB,eAAe;oBACf,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;oBAC3C,OAAO;gBACT,CAAC;gBAED,IAAI,CAAC;oBACH,0CAA0C;oBAC1C,MAAM,QAAQ,GAAa,MAAM,iBAAiB,CAAC,OAAO,CAAC;wBACzD,EAAE,EAAE,MAAM,CAAC,EAAE;wBACb,UAAU,EAAE,MAAM,CAAC,UAAU;wBAC7B,IAAI,EAAE,MAAM,CAAC,IAAyB;wBACtC,aAAa,EAAE,MAAM,CAAC,aAAa;qBACpC,CAAC,CAAC;oBAEH,wDAAwD;oBACxD,kBAAkB,CAAC,IAAI,CAAC;wBACtB,iBAAiB;wBACjB,yBAAyB,EAAE,MAAM,CAAC,EAAE;wBACpC,UAAU,EAAE,gBAAgB;wBAC5B,QAAQ;wBACR,OAAO,EAAE,KAAK;qBACf,CAAC,CAAC;oBAEH,wBAAwB,CAAC,kBAAkB,CAAC,CAAC;oBAE7C,kCAAkC;oBAClC,MAAM,EAAE,KAAK,EAAE,GAAG,QAAQ,CAAC;oBAE3B,6DAA6D;oBAC7D,KAAK,CAAC,IAAI,CACR,iBAAiB,EACjB,EAAE,gBAAgB,EAAE,MAAM,CAAC,gBAAgB,EAAE,EAC7C,KAAK,EAAE,EAAE,OAAO,EAAO,EAAE,EAAE;wBACzB,IAAI,OAAO,EAAE,CAAC;4BACZ,wCAAwC;4BACxC,IAAI,CAAC;gCACH,MAAM,cAAc,CAAC;oCACnB,KAAK;oCACL,IAAI,EAAE,MAAM,CAAC,IAAI;oCACjB,gBAAgB;oCAChB,MAAM;oCACN,UAAU;oCACV,KAAK;iCACN,CAAC,CAAC;4BACL,CAAC;4BAAC,OAAO,KAAK,EAAE,CAAC;gCACf,eAAe;gCACf,OAAO,CAAC,GAAG,CAAC,sBAAsB,EAAE,KAAK,CAAC,CAAC;4BAC7C,CAAC;wBACH,CAAC;oBACH,CAAC,CACF,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,eAAe;oBACf,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE,KAAK,CAAC,CAAC;oBACpC,OAAO;gBACT,CAAC;YACH,CAAC,CACF,CAAC;QACJ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,eAAe;YACf,OAAO,CAAC,GAAG,CAAC,4BAA4B,EAAE,KAAK,CAAC,CAAC;QACnD,CAAC;IACH,CAAC,CAAC;uGAtHS,oBAAoB;2GAApB,oBAAoB,cAFnB,MAAM;;2FAEP,oBAAoB;kBAHhC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Socket } from 'socket.io-client';\nimport {\n  ConsumerResumeType,\n  ConsumerResumeParameters,\n  Transport as TransportType,\n} from '../@types/types';\nimport { Consumer, Device, Transport } from 'mediasoup-client/lib/types';\ninterface Params {\n  id: string;\n  producerId: string;\n  kind: string;\n  rtpParameters: any;\n  serverConsumerId: string;\n  error?: string;\n}\n\nexport interface ConnectRecvTransportParameters extends ConsumerResumeParameters {\n  device: Device | null;\n  consumerTransports: TransportType[];\n  updateConsumerTransports: (transports: TransportType[]) => void;\n\n  // mediasfu functions\n  consumerResume: ConsumerResumeType;\n  getUpdatedAllParams: () => ConnectRecvTransportParameters;\n  [key: string]: any; // Extendable for additional parameters\n}\nexport interface ConnectRecvTransportOptions {\n  consumerTransport: Transport;\n  remoteProducerId: string;\n  serverConsumerTransportId: string;\n  nsock: Socket;\n  parameters: ConnectRecvTransportParameters;\n}\n\n// Export the type definition for the function\nexport type ConnectRecvTransportType = (options: ConnectRecvTransportOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ConnectRecvTransport {\n  /**\n   * Connects the receiving transport to consume media from a remote producer.\n   *\n   * @param {Object} options - The options for connecting the receiving transport.\n   * @param {Transport} options.consumerTransport - The transport used for consuming media.\n   * @param {string} options.remoteProducerId - The ID of the remote producer.\n   * @param {string} options.serverConsumerTransportId - The ID of the server consumer transport.\n   * @param {Socket} options.nsock - The socket used for communication.\n   * @param {ConnectRecvTransportOptions} options.parameters - The parameters for the connection.\n   *\n   * @returns {Promise<void>} A promise that resolves when the connection is established.\n   *\n   * @throws Will throw an error if the connection or consumption fails.\n   *\n   * @example\n   * ```typescript\n   * const options = {\n   *   consumerTransport,\n   *   remoteProducerId: 'producer-id',\n   *   serverConsumerTransportId: 'transport-id',\n   *   nsock: socket,\n   *   parameters: connectRecvTransportOptions,\n   * };\n   *\n   * connectRecvTransport(options)\n   *   .then(() => {\n   *     console.log('Transport connected and consuming media');\n   *   })\n   *   .catch((error) => {\n   *     console.error('Error connecting transport:', error);\n   *   });\n   * ```\n   */\n\n  connectRecvTransport = async ({\n    consumerTransport,\n    remoteProducerId,\n    serverConsumerTransportId,\n    nsock,\n    parameters,\n  }: ConnectRecvTransportOptions): Promise<void> => {\n    try {\n      parameters = parameters.getUpdatedAllParams();\n      const { device, consumerTransports, updateConsumerTransports, consumerResume } = parameters;\n\n      // Emit 'consume' event to signal consumption initiation\n      nsock.emit(\n        'consume',\n        {\n          rtpCapabilities: device ? device.rtpCapabilities : null,\n          remoteProducerId,\n          serverConsumerTransportId,\n        },\n        async ({ params }: { params: Params }) => {\n          if (params.error) {\n            // Handle error\n            console.log('consume error', params.error);\n            return;\n          }\n\n          try {\n            // Consume media using received parameters\n            const consumer: Consumer = await consumerTransport.consume({\n              id: params.id,\n              producerId: params.producerId,\n              kind: params.kind as 'audio' | 'video',\n              rtpParameters: params.rtpParameters,\n            });\n\n            // Update consumerTransports array with the new consumer\n            consumerTransports.push({\n              consumerTransport,\n              serverConsumerTransportId: params.id,\n              producerId: remoteProducerId,\n              consumer,\n              socket_: nsock,\n            });\n\n            updateConsumerTransports(consumerTransports);\n\n            // Extract track from the consumer\n            const { track } = consumer;\n\n            // Emit 'consumer-resume' event to signal consumer resumption\n            nsock.emit(\n              'consumer-resume',\n              { serverConsumerId: params.serverConsumerId },\n              async ({ resumed }: any) => {\n                if (resumed) {\n                  // Consumer resumed and ready to be used\n                  try {\n                    await consumerResume({\n                      track,\n                      kind: params.kind,\n                      remoteProducerId,\n                      params,\n                      parameters,\n                      nsock,\n                    });\n                  } catch (error) {\n                    // Handle error\n                    console.log('consumerResume error', error);\n                  }\n                }\n              },\n            );\n          } catch (error) {\n            // Handle error\n            console.log('consume error', error);\n            return;\n          }\n        },\n      );\n    } catch (error) {\n      // Handle error\n      console.log('connectRecvTransport error', error);\n    }\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"connect-recv-transport.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/connect-recv-transport.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAsCzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAML,MAAM,OAAO,oBAAoB;IAC/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IAEH,oBAAoB,GAAG,KAAK,EAAE,EAC5B,iBAAiB,EACjB,gBAAgB,EAChB,yBAAyB,EACzB,KAAK,EACL,UAAU,GACkB,EAAiB,EAAE;QAC/C,IAAI,CAAC;YACH,UAAU,GAAG,UAAU,CAAC,mBAAmB,EAAE,CAAC;YAC9C,MAAM,EAAE,MAAM,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,cAAc,EAAE,GAAG,UAAU,CAAC;YAE5F,wDAAwD;YACxD,KAAK,CAAC,IAAI,CACR,SAAS,EACT;gBACE,eAAe,EAAE,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC,CAAC,IAAI;gBACvD,gBAAgB;gBAChB,yBAAyB;aAC1B,EACD,KAAK,EAAE,EAAE,MAAM,EAAsB,EAAE,EAAE;gBACvC,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;oBACjB,eAAe;oBACf,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;oBAC3C,OAAO;gBACT,CAAC;gBAED,IAAI,CAAC;oBACH,0CAA0C;oBAC1C,MAAM,QAAQ,GAAa,MAAM,iBAAiB,CAAC,OAAO,CAAC;wBACzD,EAAE,EAAE,MAAM,CAAC,EAAE;wBACb,UAAU,EAAE,MAAM,CAAC,UAAU;wBAC7B,IAAI,EAAE,MAAM,CAAC,IAAyB;wBACtC,aAAa,EAAE,MAAM,CAAC,aAAa;qBACpC,CAAC,CAAC;oBAEH,wDAAwD;oBACxD,kBAAkB,CAAC,IAAI,CAAC;wBACtB,iBAAiB;wBACjB,yBAAyB,EAAE,MAAM,CAAC,EAAE;wBACpC,UAAU,EAAE,gBAAgB;wBAC5B,QAAQ;wBACR,OAAO,EAAE,KAAK;qBACf,CAAC,CAAC;oBAEH,wBAAwB,CAAC,kBAAkB,CAAC,CAAC;oBAE7C,kCAAkC;oBAClC,MAAM,EAAE,KAAK,EAAE,GAAG,QAAQ,CAAC;oBAE3B,6DAA6D;oBAC7D,KAAK,CAAC,IAAI,CACR,iBAAiB,EACjB,EAAE,gBAAgB,EAAE,MAAM,CAAC,gBAAgB,EAAE,EAC7C,KAAK,EAAE,EAAE,OAAO,EAAO,EAAE,EAAE;wBACzB,IAAI,OAAO,EAAE,CAAC;4BACZ,wCAAwC;4BACxC,IAAI,CAAC;gCACH,MAAM,cAAc,CAAC;oCACnB,KAAK;oCACL,IAAI,EAAE,MAAM,CAAC,IAAI;oCACjB,gBAAgB;oCAChB,MAAM;oCACN,UAAU;oCACV,KAAK;iCACN,CAAC,CAAC;4BACL,CAAC;4BAAC,OAAO,KAAK,EAAE,CAAC;gCACf,eAAe;gCACf,OAAO,CAAC,GAAG,CAAC,sBAAsB,EAAE,KAAK,CAAC,CAAC;4BAC7C,CAAC;wBACH,CAAC;oBACH,CAAC,CACF,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,eAAe;oBACf,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE,KAAK,CAAC,CAAC;oBACpC,OAAO;gBACT,CAAC;YACH,CAAC,CACF,CAAC;QACJ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,eAAe;YACf,OAAO,CAAC,GAAG,CAAC,4BAA4B,EAAE,KAAK,CAAC,CAAC;QACnD,CAAC;IACH,CAAC,CAAC;uGAtHS,oBAAoB;2GAApB,oBAAoB,cAFnB,MAAM;;2FAEP,oBAAoB;kBAHhC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Socket } from 'socket.io-client';\nimport {\n  ConsumerResumeType,\n  ConsumerResumeParameters,\n  Transport as TransportType,\n} from '../@types/types';\nimport { Consumer, Device, Transport } from 'mediasoup-client/lib/types';\ninterface Params {\n  id: string;\n  producerId: string;\n  kind: string;\n  rtpParameters: any;\n  serverConsumerId: string;\n  error?: string;\n}\n\nexport interface ConnectRecvTransportParameters extends ConsumerResumeParameters {\n  device: Device | null;\n  consumerTransports: TransportType[];\n  updateConsumerTransports: (transports: TransportType[]) => void;\n\n  // mediasfu functions\n  consumerResume: ConsumerResumeType;\n  getUpdatedAllParams: () => ConnectRecvTransportParameters;\n  [key: string]: any; // Extendable for additional parameters\n}\nexport interface ConnectRecvTransportOptions {\n  consumerTransport: Transport;\n  remoteProducerId: string;\n  serverConsumerTransportId: string;\n  nsock: Socket;\n  parameters: ConnectRecvTransportParameters;\n}\n\n// Export the type definition for the function\nexport type ConnectRecvTransportType = (options: ConnectRecvTransportOptions) => Promise<void>;\n\n  /**\n   * Connects the receiving transport to consume media from a remote producer.\n   *\n   * @param {ConnectRecvTransportOptions} options - The options for connecting the receiving transport.\n   * @param {Transport} options.consumerTransport - The transport used for consuming media.\n   * @param {string} options.remoteProducerId - The ID of the remote producer.\n   * @param {string} options.serverConsumerTransportId - The ID of the server consumer transport.\n   * @param {Socket} options.nsock - The socket used for communication.\n   * @param {ConnectRecvTransportParameters} options.parameters - The parameters for the connection.\n   *\n   * @returns {Promise<void>} A promise that resolves when the connection is established.\n   *\n   * @throws Will throw an error if the connection or consumption fails.\n   *\n   * @example\n   * ```typescript\n   * const options = {\n   *   consumerTransport,\n   *   remoteProducerId: 'producer-id',\n   *   serverConsumerTransportId: 'transport-id',\n   *   nsock: socket,\n   *   parameters: connectRecvTransportOptions,\n   * };\n   *\n   * connectRecvTransport(options)\n   *   .then(() => {\n   *     console.log('Transport connected and consuming media');\n   *   })\n   *   .catch((error) => {\n   *     console.error('Error connecting transport:', error);\n   *   });\n   * ```\n   */\n\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ConnectRecvTransport {\n  /**\n   * Connects the receiving transport to consume media from a remote producer.\n   *\n   * @param {Object} options - The options for connecting the receiving transport.\n   * @param {Transport} options.consumerTransport - The transport used for consuming media.\n   * @param {string} options.remoteProducerId - The ID of the remote producer.\n   * @param {string} options.serverConsumerTransportId - The ID of the server consumer transport.\n   * @param {Socket} options.nsock - The socket used for communication.\n   * @param {ConnectRecvTransportOptions} options.parameters - The parameters for the connection.\n   *\n   * @returns {Promise<void>} A promise that resolves when the connection is established.\n   *\n   * @throws Will throw an error if the connection or consumption fails.\n   *\n   * @example\n   * ```typescript\n   * const options = {\n   *   consumerTransport,\n   *   remoteProducerId: 'producer-id',\n   *   serverConsumerTransportId: 'transport-id',\n   *   nsock: socket,\n   *   parameters: connectRecvTransportOptions,\n   * };\n   *\n   * connectRecvTransport(options)\n   *   .then(() => {\n   *     console.log('Transport connected and consuming media');\n   *   })\n   *   .catch((error) => {\n   *     console.error('Error connecting transport:', error);\n   *   });\n   * ```\n   */\n\n  connectRecvTransport = async ({\n    consumerTransport,\n    remoteProducerId,\n    serverConsumerTransportId,\n    nsock,\n    parameters,\n  }: ConnectRecvTransportOptions): Promise<void> => {\n    try {\n      parameters = parameters.getUpdatedAllParams();\n      const { device, consumerTransports, updateConsumerTransports, consumerResume } = parameters;\n\n      // Emit 'consume' event to signal consumption initiation\n      nsock.emit(\n        'consume',\n        {\n          rtpCapabilities: device ? device.rtpCapabilities : null,\n          remoteProducerId,\n          serverConsumerTransportId,\n        },\n        async ({ params }: { params: Params }) => {\n          if (params.error) {\n            // Handle error\n            console.log('consume error', params.error);\n            return;\n          }\n\n          try {\n            // Consume media using received parameters\n            const consumer: Consumer = await consumerTransport.consume({\n              id: params.id,\n              producerId: params.producerId,\n              kind: params.kind as 'audio' | 'video',\n              rtpParameters: params.rtpParameters,\n            });\n\n            // Update consumerTransports array with the new consumer\n            consumerTransports.push({\n              consumerTransport,\n              serverConsumerTransportId: params.id,\n              producerId: remoteProducerId,\n              consumer,\n              socket_: nsock,\n            });\n\n            updateConsumerTransports(consumerTransports);\n\n            // Extract track from the consumer\n            const { track } = consumer;\n\n            // Emit 'consumer-resume' event to signal consumer resumption\n            nsock.emit(\n              'consumer-resume',\n              { serverConsumerId: params.serverConsumerId },\n              async ({ resumed }: any) => {\n                if (resumed) {\n                  // Consumer resumed and ready to be used\n                  try {\n                    await consumerResume({\n                      track,\n                      kind: params.kind,\n                      remoteProducerId,\n                      params,\n                      parameters,\n                      nsock,\n                    });\n                  } catch (error) {\n                    // Handle error\n                    console.log('consumerResume error', error);\n                  }\n                }\n              },\n            );\n          } catch (error) {\n            // Handle error\n            console.log('consume error', error);\n            return;\n          }\n        },\n      );\n    } catch (error) {\n      // Handle error\n      console.log('connectRecvTransport error', error);\n    }\n  };\n}\n"]}

package/dist/esm2022/lib/consumers/connect-send-transport-audio.service.mjs

@@ -1,5 +1,43 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Connects the send transport for audio by producing audio data and updating the audio producer and producer transport objects.
+ *
+ * @param {ConnectSendTransportAudioOptions} options - The parameters for connecting the send transport.
+ * @param {ProducerOptions} options.audioParams - The options for the audio producer.
+ * @param {ConnectSendTransportAudioParameters} options.parameters - The parameters containing the audio producer, producer transport, and update functions.
+ * @param {Producer} options.parameters.audioProducer - The current audio producer.
+ * @param {Transport} options.parameters.producerTransport - The transport used to produce audio data.
+ * @param {Function} options.parameters.updateAudioProducer - Function to update the audio producer.
+ * @param {Function} options.parameters.updateProducerTransport - Function to update the producer transport.
+ *
+ * @returns {Promise<void>} A promise that resolves when the audio transport is successfully connected.
+ *
+ * @throws Will throw an error if the connection fails.
+ *
+ * @example
+ * ```typescript
+ * const audioParams: ProducerOptions = {
+ *   codec: 'opus',
+ *   // other options
+ * };
+ *
+ * const parameters = {
+ *   audioProducer: null,
+ *   producerTransport: transport,
+ *   updateAudioProducer: (producer) => { console.log(updated) },
+  *   updateProducerTransport: (transport) => { console.log(updated) },
+  * };
+  *
+  * connectSendTransportAudio({ audioParams, parameters })
+  *   .then(() => {
+  *     console.log('Audio transport connected successfully');
+  *   })
+  *   .catch((error) => {
+  *     console.error('Error connecting audio transport:', error);
+  *   });
+  * ```
+  */
 export class ConnectSendTransportAudio {
     /**
      * Connects the send transport for audio by producing audio data and updating the audio producer and producer transport objects.
@@ -43,4 +81,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/consumers/connect-send-transport-screen.service.mjs

@@ -1,5 +1,45 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Connects and sets up the screen sharing transport for sending video streams.
+ *
+ * @param {ConnectSendTransportScreenOptions} options - The options for connecting the screen transport.
+ * @param {MediaStream} options.stream - The media stream containing the screen video track.
+ * @param {ConnectSendTransportScreenParameters} options.parameters - The parameters required for setting up the transport.
+ * @param {Producer} options.parameters.screenProducer - The screen producer object.
+ * @param {Device} options.parameters.device - The device object containing RTP capabilities.
+ * @param {ProducerOptions} options.parameters.screenParams - The parameters for producing the screen share.
+ * @param {Transport} options.parameters.producerTransport - The transport object used for producing the screen share.
+ * @param {Function} options.parameters.updateScreenProducer - Function to update the screen producer object.
+ * @param {Function} options.parameters.updateProducerTransport - Function to update the producer transport object.
+ * @param {Function} options.parameters.getUpdatedAllParams - Function to fetch updated device information.
+ *
+ * @returns {Promise<void>} A promise that resolves when the screen transport is successfully connected and set up.
+ *
+ * @throws Will throw an error if the connection or setup process fails.
+ *
+ * @example
+ * ```typescript
+ * const stream = await navigator.mediaDevices.getDisplayMedia({ video: true });
+ * const parameters = {
+ *   screenProducer: null,
+ *   device: device, // Assume 'device' is initialized and ready
+ *   screenParams: { codec: 'vp9' },
+ *   producerTransport: transport, // Assume 'transport' is initialized
+ *   updateScreenProducer: (producer) => { console.log(updated) },
+ *   updateProducerTransport: (transport) => { console.log(updated) },
+ *   getUpdatedAllParams: () => {  },
+ * };
+ *
+ * connectSendTransportScreen({ stream, parameters })
+ *   .then(() => {
+ *     console.log('Screen transport connected successfully');
+ *   })
+ *   .catch((error) => {
+ *     console.error('Error connecting screen transport:', error);
+ *   });
+ * ```
+ */
 export class ConnectSendTransportScreen {
     /**
      * Connects and sets up the screen sharing transport for sending video streams.
@@ -59,4 +99,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"connect-send-transport-screen.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/connect-send-transport-screen.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAyBzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAKL,MAAM,OAAO,0BAA0B;IACrC;;;;;;;;;;;;;;;;;;OAkBG;IACH,KAAK,CAAC,0BAA0B,CAAC,EAC/B,MAAM,EACN,UAAU,GACwB;QAClC,IAAI,CAAC;YACH,IAAI,EACF,cAAc,EACd,MAAM,EACN,YAAY,EACZ,iBAAiB,EACjB,MAAM,EACN,oBAAoB,EACpB,uBAAuB,GACxB,GAAG,UAAU,CAAC;YAEf,MAAM,GAAG,UAAU,CAAC,mBAAmB,EAAE,CAAC,MAAM,CAAC;YACjD,6EAA6E;YAC7E,MAAM,GAAG,YAAY,CAAC;YAEtB,kCAAkC;YAClC,IAAI,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,eAAe,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,MAAM,EAAE,CAAC;gBACzE,MAAM,IAAI,KAAK,CAAC,mDAAmD,CAAC,CAAC;YACvE,CAAC;YAED,IAAI,KAAK,GAAG,MAAM,CAAC,eAAe,CAAC,MAAM,CAAC,IAAI,CAC5C,CAAC,KAAU,EAAE,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,WAAW,EAAE,KAAK,WAAW,IAAI,KAAK,CAAC,IAAI,KAAK,OAAO,CACvF,CAAC;YAEF,yDAAyD;YACzD,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBACvB,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;YAC1D,CAAC;YAED,cAAc,GAAG,MAAM,iBAAiB,CAAC,OAAO,CAAC;gBAC/C,KAAK,EAAE,MAAM,EAAE,cAAc,EAAE,CAAC,CAAC,CAAC;gBAClC,GAAG,MAAM;gBACT,KAAK,EAAE,KAAK;gBACZ,OAAO,EAAE,EAAE,QAAQ,EAAE,cAAc,EAAE;aACtC,CAAC,CAAC;YAEH,4DAA4D;YAC5D,oBAAoB,CAAC,cAAc,CAAC,CAAC;YACrC,uBAAuB,CAAC,iBAAiB,CAAC,CAAC;QAC7C,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,GAAG,CAAC,kCAAkC,EAAE,KAAK,CAAC,CAAC;YACvD,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;uGAnEU,0BAA0B;2GAA1B,0BAA0B,cAFzB,MAAM;;2FAEP,0BAA0B;kBAHtC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Transport, Producer, Device, ProducerOptions } from 'mediasoup-client/lib/types';\nexport interface ConnectSendTransportScreenParameters {\n  screenProducer: Producer | null;\n  device: Device | null;\n  screenParams: ProducerOptions;\n  producerTransport: Transport | null;\n  params: ProducerOptions;\n  updateScreenProducer: (producer: Producer | null) => void;\n  updateProducerTransport: (transport: Transport | null) => void;\n\n  getUpdatedAllParams: () => ConnectSendTransportScreenParameters;\n  [key: string]: any; // Extendable for additional parameters\n}\n\nexport interface ConnectSendTransportScreenOptions {\n  stream: MediaStream | null;\n  parameters: ConnectSendTransportScreenParameters;\n}\n\n// Export the type definition for the function\nexport type ConnectSendTransportScreenType = (\n  options: ConnectSendTransportScreenOptions,\n) => Promise<void>;\n\n  /**\n   * Connects and sets up the screen sharing transport for sending video streams.\n   *\n   * @param {ConnectSendTransportScreenOptions} options - The options for connecting the screen transport.\n   * @param {MediaStream} options.stream - The media stream containing the screen video track.\n   * @param {ConnectSendTransportScreenParameters} options.parameters - The parameters required for setting up the transport.\n   * @param {Producer} options.parameters.screenProducer - The screen producer object.\n   * @param {Device} options.parameters.device - The device object containing RTP capabilities.\n   * @param {ProducerOptions} options.parameters.screenParams - The parameters for producing the screen share.\n   * @param {Transport} options.parameters.producerTransport - The transport object used for producing the screen share.\n   * @param {Function} options.parameters.updateScreenProducer - Function to update the screen producer object.\n   * @param {Function} options.parameters.updateProducerTransport - Function to update the producer transport object.\n   * @param {Function} options.parameters.getUpdatedAllParams - Function to fetch updated device information.\n   *\n   * @returns {Promise<void>} A promise that resolves when the screen transport is successfully connected and set up.\n   *\n   * @throws Will throw an error if the connection or setup process fails.\n   *\n   * @example\n   * ```typescript\n   * const stream = await navigator.mediaDevices.getDisplayMedia({ video: true });\n   * const parameters = {\n   *   screenProducer: null,\n   *   device: device, // Assume 'device' is initialized and ready\n   *   screenParams: { codec: 'vp9' },\n   *   producerTransport: transport, // Assume 'transport' is initialized\n   *   updateScreenProducer: (producer) => { console.log(updated) },\n   *   updateProducerTransport: (transport) => { console.log(updated) },\n   *   getUpdatedAllParams: () => {  },\n   * };\n   *\n   * connectSendTransportScreen({ stream, parameters })\n   *   .then(() => {\n   *     console.log('Screen transport connected successfully');\n   *   })\n   *   .catch((error) => {\n   *     console.error('Error connecting screen transport:', error);\n   *   });\n   * ```\n   */\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ConnectSendTransportScreen {\n  /**\n   * Connects and sets up the screen sharing transport for sending video streams.\n   *\n   * @param {Object} options - The options for connecting the screen transport.\n   * @param {MediaStream} options.stream - The media stream containing the screen video track.\n   * @param {ConnectSendTransportScreenOptions} options.parameters - The parameters required for setting up the transport.\n   * @param {Producer} options.parameters.screenProducer - The screen producer object.\n   * @param {Device} options.parameters.device - The device object containing RTP capabilities.\n   * @param {Promise<ScreenParams>} options.parameters.screenParams - A promise resolving to screen share parameters.\n   * @param {Transport} options.parameters.producerTransport - The transport object used for producing the screen share.\n   * @param {Params} options.parameters.params - The parameters for producing the screen share.\n   * @param {Function} options.parameters.updateScreenProducer - Function to update the screen producer object.\n   * @param {Function} options.parameters.updateProducerTransport - Function to update the producer transport object.\n   * @param {Function} options.parameters.getUpdatedAllParams - Function to fetch updated device information.\n   *\n   * @returns {Promise<void>} A promise that resolves when the screen transport is successfully connected and set up.\n   *\n   * @throws Will throw an error if the connection or setup process fails.\n   */\n  async connectSendTransportScreen({\n    stream,\n    parameters,\n  }: ConnectSendTransportScreenOptions): Promise<void> {\n    try {\n      let {\n        screenProducer,\n        device,\n        screenParams,\n        producerTransport,\n        params,\n        updateScreenProducer,\n        updateProducerTransport,\n      } = parameters;\n\n      device = parameters.getUpdatedAllParams().device;\n      // Connect the send transport for screen share by producing screen video data\n      params = screenParams;\n\n      // Find VP9 codec for screen share\n      if (!device || !device.rtpCapabilities || !device.rtpCapabilities.codecs) {\n        throw new Error('Device or its RTP capabilities are not available.');\n      }\n\n      let codec = device.rtpCapabilities.codecs.find(\n        (codec: any) => codec.mimeType.toLowerCase() === 'video/vp9' && codec.kind === 'video',\n      );\n\n      // Produce screen share data using the producer transport\n      if (!producerTransport) {\n        throw new Error('Producer transport is not available.');\n      }\n\n      screenProducer = await producerTransport.produce({\n        track: stream?.getVideoTracks()[0],\n        ...params,\n        codec: codec,\n        appData: { mediaTag: 'screen-video' },\n      });\n\n      // Update the screen producer and producer transport objects\n      updateScreenProducer(screenProducer);\n      updateProducerTransport(producerTransport);\n    } catch (error) {\n      console.log('connectSendTransportScreen error', error);\n      throw error;\n    }\n  }\n}\n"]}

package/dist/esm2022/lib/consumers/connect-send-transport-video.service.mjs

@@ -1,5 +1,49 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Connects the send transport for video by producing video data and updates the relevant states.
+ *
+ * @param {ConnectSendTransportVideoOptions} options - The options for connecting the send transport for video.
+ * @param {ProducerOptions} options.videoParams - The parameters for producing video data.
+ * @param {ConnectSendTransportVideoParameters} options.parameters - The parameters for updating the state.
+ * @param {Producer} options.parameters.videoProducer - The video producer instance.
+ * @param {Transport} options.parameters.producerTransport - The transport instance used for producing video.
+ * @param {string} options.parameters.islevel - The connection level.
+ * @param {boolean} options.parameters.updateMainWindow - The state of the main window update.
+ * @param {Function} options.parameters.updateVideoProducer - Function to update the video producer.
+ * @param {Function} options.parameters.updateProducerTransport - Function to update the producer transport.
+ * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window state.
+ *
+ * @returns {Promise<void>} A promise that resolves when the send transport for video is connected.
+ *
+ * @throws Will throw an error if the connection fails.
+ *
+ * @example
+ * ```typescript
+ * const videoParams = {
+ *   codec: 'vp8',
+ *   // Other producer options...
+ * };
+ *
+ * const parameters = {
+ *   videoProducer: null,
+ *   producerTransport: transport, // Assume 'transport' is initialized and ready
+ *   islevel: '1',
+ *   updateMainWindow: false,
+ *   updateVideoProducer: (producer) => { console.log(updated) },
+ *   updateProducerTransport: (transport) => { console.log(updated) },
+ *   updateUpdateMainWindow: (state) => { console.log(updated) },
+ * };
+ *
+ * connectSendTransportVideo({ videoParams, parameters })
+ *   .then(() => {
+ *     console.log('Video transport connected successfully');
+ *   })
+ *   .catch((error) => {
+ *     console.error('Error connecting video transport:', error);
+ *   });
+ * ```
+ */
 export class ConnectSendTransportVideo {
     /**
      * Connects the send transport for video by producing video data and updates the relevant states.
@@ -52,4 +96,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"connect-send-transport-video.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/connect-send-transport-video.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAwBzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAKL,MAAM,OAAO,yBAAyB;IACpC;;;;;;;;;;;;;;;;;OAiBG;IACH,yBAAyB,GAAG,KAAK,EAAE,EACjC,WAAW,EACX,UAAU,GACuB,EAAiB,EAAE;QACpD,IAAI,CAAC;YACH,IAAI,EACF,aAAa,EACb,iBAAiB,EACjB,OAAO,EACP,gBAAgB,EAChB,mBAAmB,EACnB,uBAAuB,EACvB,sBAAsB,GACvB,GAAG,UAAU,CAAC;YAEf,+DAA+D;YAC/D,IAAI,iBAAiB,EAAE,CAAC;gBACtB,aAAa,GAAG,MAAM,iBAAiB,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;YAC/D,CAAC;iBAAM,CAAC;gBACN,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC;YAChD,CAAC;YAED,+DAA+D;YAC/D,IAAI,OAAO,KAAK,GAAG,EAAE,CAAC;gBACpB,gBAAgB,GAAG,IAAI,CAAC;YAC1B,CAAC;YAED,2DAA2D;YAC3D,mBAAmB,CAAC,aAAa,CAAC,CAAC;YACnC,uBAAuB,CAAC,iBAAiB,CAAC,CAAC;YAC3C,sBAAsB,CAAC,gBAAgB,CAAC,CAAC;QAC3C,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,GAAG,CAAC,iCAAiC,EAAE,KAAK,CAAC,CAAC;YACtD,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC,CAAC;uGAtDS,yBAAyB;2GAAzB,yBAAyB,cAFxB,MAAM;;2FAEP,yBAAyB;kBAHrC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Device, Producer, ProducerOptions, Transport } from 'mediasoup-client/lib/types';\nexport interface ConnectSendTransportVideoParameters {\n  videoProducer: Producer | null;\n  device: Device | null;\n  producerTransport: Transport | null;\n  islevel: string;\n  updateMainWindow: boolean;\n  updateVideoProducer: (producer: Producer | null) => void;\n  updateProducerTransport: (transport: Transport | null) => void;\n  updateUpdateMainWindow: (state: boolean) => void;\n  [key: string]: any; // Extendable for additional parameters\n}\n\nexport interface ConnectSendTransportVideoOptions {\n  videoParams: ProducerOptions;\n  parameters: ConnectSendTransportVideoParameters;\n}\n\n// Export the type definition for the function\nexport type ConnectSendTransportVideoType = (\n  options: ConnectSendTransportVideoOptions,\n) => Promise<void>;\n\n  /**\n   * Connects the send transport for video by producing video data and updates the relevant states.\n   *\n   * @param {ConnectSendTransportVideoOptions} options - The options for connecting the send transport for video.\n   * @param {ProducerOptions} options.videoParams - The parameters for producing video data.\n   * @param {ConnectSendTransportVideoParameters} options.parameters - The parameters for updating the state.\n   * @param {Producer} options.parameters.videoProducer - The video producer instance.\n   * @param {Transport} options.parameters.producerTransport - The transport instance used for producing video.\n   * @param {string} options.parameters.islevel - The connection level.\n   * @param {boolean} options.parameters.updateMainWindow - The state of the main window update.\n   * @param {Function} options.parameters.updateVideoProducer - Function to update the video producer.\n   * @param {Function} options.parameters.updateProducerTransport - Function to update the producer transport.\n   * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window state.\n   *\n   * @returns {Promise<void>} A promise that resolves when the send transport for video is connected.\n   *\n   * @throws Will throw an error if the connection fails.\n   *\n   * @example\n   * ```typescript\n   * const videoParams = {\n   *   codec: 'vp8',\n   *   // Other producer options...\n   * };\n   *\n   * const parameters = {\n   *   videoProducer: null,\n   *   producerTransport: transport, // Assume 'transport' is initialized and ready\n   *   islevel: '1',\n   *   updateMainWindow: false,\n   *   updateVideoProducer: (producer) => { console.log(updated) },\n   *   updateProducerTransport: (transport) => { console.log(updated) },\n   *   updateUpdateMainWindow: (state) => { console.log(updated) },\n   * };\n   *\n   * connectSendTransportVideo({ videoParams, parameters })\n   *   .then(() => {\n   *     console.log('Video transport connected successfully');\n   *   })\n   *   .catch((error) => {\n   *     console.error('Error connecting video transport:', error);\n   *   });\n   * ```\n   */\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ConnectSendTransportVideo {\n  /**\n   * Connects the send transport for video by producing video data and updates the relevant states.\n   *\n   * @param {ConnectSendTransportVideoOptions} options - The options for connecting the send transport for video.\n   * @param {Object} options.videoParams - The parameters for producing video data.\n   * @param {Object} options.parameters - The parameters for updating the state.\n   * @param {Producer} options.parameters.videoProducer - The video producer instance.\n   * @param {Transport} options.parameters.producerTransport - The transport instance used for producing video.\n   * @param {string} options.parameters.islevel - The connection level.\n   * @param {boolean} options.parameters.updateMainWindow - The state of the main window update.\n   * @param {Function} options.parameters.updateVideoProducer - Function to update the video producer.\n   * @param {Function} options.parameters.updateProducerTransport - Function to update the producer transport.\n   * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window state.\n   *\n   * @returns {Promise<void>} A promise that resolves when the send transport for video is connected.\n   *\n   * @throws Will throw an error if the connection fails.\n   */\n  connectSendTransportVideo = async ({\n    videoParams,\n    parameters,\n  }: ConnectSendTransportVideoOptions): Promise<void> => {\n    try {\n      let {\n        videoProducer,\n        producerTransport,\n        islevel,\n        updateMainWindow,\n        updateVideoProducer,\n        updateProducerTransport,\n        updateUpdateMainWindow,\n      } = parameters;\n\n      // Connect the send transport for video by producing video data\n      if (producerTransport) {\n        videoProducer = await producerTransport.produce(videoParams);\n      } else {\n        throw new Error('Producer transport is null');\n      }\n\n      // Update main window state based on the video connection level\n      if (islevel === '2') {\n        updateMainWindow = true;\n      }\n\n      // Update the video producer and producer transport objects\n      updateVideoProducer(videoProducer);\n      updateProducerTransport(producerTransport);\n      updateUpdateMainWindow(updateMainWindow);\n    } catch (error) {\n      console.log('connectSendTransportVideo error', error);\n      throw error;\n    }\n  };\n}\n"]}

package/dist/esm2022/lib/consumers/connect-send-transport.service.mjs

@@ -1,5 +1,59 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Connects the send transport based on the specified option.
+ *
+ * @param {ConnectSendTransportOptions} options - The options for connecting the send transport.
+ * @param {string} options.option - The type of transport to connect ("audio", "video", "screen", or "all").
+ * @param {ConnectSendTransportParameters} options.parameters - The parameters required for connecting the transport.
+ * @param {ProducerOptions} options.parameters.audioParams - The audio parameters.
+ * @param {ProducerOptions} options.parameters.videoParams - The video parameters.
+ * @param {MediaStream} options.parameters.localStreamScreen - The local screen stream.
+ * @param {MediaStream} options.parameters.canvasStream - The canvas stream.
+ * @param {boolean} options.parameters.whiteboardStarted - Indicates if the whiteboard has started.
+ * @param {boolean} options.parameters.whiteboardEnded - Indicates if the whiteboard has ended.
+ * @param {boolean} options.parameters.shared - Indicates if the screen is shared.
+ * @param {string} options.parameters.islevel - The level of the screen sharing.
+ * @param {Function} options.parameters.connectSendTransportAudio - Function to connect the audio send transport.
+ * @param {Function} options.parameters.connectSendTransportVideo - Function to connect the video send transport.
+ * @param {Function} options.parameters.connectSendTransportScreen - Function to connect the screen send transport.
+ *
+ * @returns {Promise<void>} A promise that resolves when the transport is connected.
+ *
+ * @throws Will throw an error if the connection fails.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   option: 'audio', // Can be 'audio', 'video', 'screen', or 'all'
+ *   parameters: {
+ *     audioParams: { codec: 'opus' },
+ *     videoParams: { codec: 'vp8' },
+ *     localStreamScreen: null, // Set to your local screen stream
+ *     canvasStream: null, // Set to your canvas stream if using
+ *     whiteboardStarted: false,
+ *     whiteboardEnded: true,
+ *     shared: false,
+ *     islevel: '1',
+ *     connectSendTransportAudio: connectSendTransportAudioFunction,
+ *     connectSendTransportVideo: connectSendTransportVideoFunction,
+ *     connectSendTransportScreen: connectSendTransportScreenFunction,
+ *     updateVideoProducer: () => {},
+ *     updateProducerTransport: () => {},
+ *     updateScreenProducer: () => {},
+ *     updateMainWindow: false,
+ *   },
+ * };
+ *
+ * connectSendTransport(options)
+ *   .then(() => {
+ *     console.log('Transport connected successfully');
+ *   })
+ *   .catch((error) => {
+ *     console.error('Error connecting transport:', error);
+ *   });
+ * ```
+ */
 export class ConnectSendTransport {
     /**
      * Connects the send transport based on the specified option.
@@ -83,4 +137,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"connect-send-transport.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/connect-send-transport.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AA0C3C,MAAM,OAAO,oBAAoB;IAC/B;;;;;;;;;;;;;;;;;;;;;OAqBG;IAEH,KAAK,CAAC,oBAAoB,CAAC,EAAE,MAAM,EAAE,UAAU,EAA+B;QAC5E,IAAI,CAAC;YACH,MAAM,EACJ,WAAW,EACX,WAAW,EACX,iBAAiB,EACjB,YAAY,EACZ,iBAAiB,EACjB,eAAe,EACf,MAAM,EACN,OAAO,EACP,yBAAyB,EACzB,yBAAyB,EACzB,0BAA0B,GAC3B,GAAG,UAAU,CAAC;YAEf,uDAAuD;YACvD,IAAI,MAAM,KAAK,OAAO,EAAE,CAAC;gBACvB,MAAM,yBAAyB,CAAC;oBAC9B,WAAW;oBACX,UAAU;iBACX,CAAC,CAAC;YACL,CAAC;iBAAM,IAAI,MAAM,KAAK,OAAO,EAAE,CAAC;gBAC9B,MAAM,yBAAyB,CAAC;oBAC9B,WAAW;oBACX,UAAU;iBACX,CAAC,CAAC;YACL,CAAC;iBAAM,IAAI,MAAM,KAAK,QAAQ,EAAE,CAAC;gBAC/B,IAAI,iBAAiB,IAAI,CAAC,eAAe,IAAI,YAAY,IAAI,OAAO,KAAK,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;oBACxF,MAAM,0BAA0B,CAAC;wBAC/B,MAAM,EAAE,YAAY;wBACpB,UAAU;qBACX,CAAC,CAAC;gBACL,CAAC;qBAAM,CAAC;oBACN,IAAI,iBAAiB,EAAE,CAAC;wBACtB,MAAM,0BAA0B,CAAC;4BAC/B,MAAM,EAAE,iBAAiB;4BACzB,UAAU;yBACX,CAAC,CAAC;oBACL,CAAC;yBAAM,CAAC;wBACN,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;oBAC5D,CAAC;gBACH,CAAC;YACH,CAAC;iBAAM,CAAC;gBACN,+CAA+C;gBAC/C,MAAM,yBAAyB,CAAC;oBAC9B,WAAW;oBACX,UAAU;iBACX,CAAC,CAAC;gBACH,MAAM,yBAAyB,CAAC;oBAC9B,WAAW;oBACX,UAAU;iBACX,CAAC,CAAC;YACL,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,GAAG,CAAC,4BAA4B,EAAE,KAAK,CAAC,CAAC;QACnD,CAAC;IACH,CAAC;uGAjFU,oBAAoB;2GAApB,oBAAoB,cAFnB,MAAM;;2FAEP,oBAAoB;kBAHhC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\n\nimport { ProducerOptions } from 'mediasoup-client/lib/types';\nimport {\n  ConnectSendTransportAudioType,\n  ConnectSendTransportVideoType,\n  ConnectSendTransportScreenType,\n  ConnectSendTransportAudioParameters,\n  ConnectSendTransportVideoParameters,\n  ConnectSendTransportScreenParameters,\n} from '../@types/types';\nexport interface ConnectSendTransportParameters\n  extends ConnectSendTransportAudioParameters,\n    ConnectSendTransportVideoParameters,\n    ConnectSendTransportScreenParameters {\n  audioParams: ProducerOptions;\n  videoParams: ProducerOptions;\n  localStreamScreen: MediaStream | null;\n  canvasStream: MediaStream | null;\n  whiteboardStarted: boolean;\n  whiteboardEnded: boolean;\n  shared: boolean;\n  islevel: string;\n\n  //mediasfu functions\n  connectSendTransportAudio: ConnectSendTransportAudioType;\n  connectSendTransportVideo: ConnectSendTransportVideoType;\n  connectSendTransportScreen: ConnectSendTransportScreenType;\n  [key: string]: any;\n}\n\nexport interface ConnectSendTransportOptions {\n  option: 'audio' | 'video' | 'screen' | 'all';\n  parameters: ConnectSendTransportParameters;\n}\n\n// Export the type definition for the function\nexport type ConnectSendTransportType = (options: ConnectSendTransportOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ConnectSendTransport {\n  /**\n   * Connects the send transport based on the specified option.\n   *\n   * @param {ConnectSendTransportOptions} options - The options for connecting the send transport.\n   * @param {string} options.option - The type of transport to connect (\"audio\", \"video\", \"screen\", or both).\n   * @param {Object} options.parameters - The parameters required for connecting the transport.\n   * @param {Object} options.parameters.audioParams - The audio parameters.\n   * @param {Object} options.parameters.videoParams - The video parameters.\n   * @param {MediaStream} options.parameters.localStreamScreen - The local screen stream.\n   * @param {MediaStream} options.parameters.canvasStream - The canvas stream.\n   * @param {boolean} options.parameters.whiteboardStarted - Indicates if the whiteboard has started.\n   * @param {boolean} options.parameters.whiteboardEnded - Indicates if the whiteboard has ended.\n   * @param {boolean} options.parameters.shared - Indicates if the screen is shared.\n   * @param {string} options.parameters.islevel - The level of the screen sharing.\n   * @param {Function} options.parameters.connectSendTransportAudio - Function to connect the audio send transport.\n   * @param {Function} options.parameters.connectSendTransportVideo - Function to connect the video send transport.\n   * @param {Function} options.parameters.connectSendTransportScreen - Function to connect the screen send transport.\n   *\n   * @returns {Promise<void>} A promise that resolves when the transport is connected.\n   *\n   * @throws Will throw an error if the connection fails.\n   */\n\n  async connectSendTransport({ option, parameters }: ConnectSendTransportOptions): Promise<void> {\n    try {\n      const {\n        audioParams,\n        videoParams,\n        localStreamScreen,\n        canvasStream,\n        whiteboardStarted,\n        whiteboardEnded,\n        shared,\n        islevel,\n        connectSendTransportAudio,\n        connectSendTransportVideo,\n        connectSendTransportScreen,\n      } = parameters;\n\n      // Connect send transport based on the specified option\n      if (option === 'audio') {\n        await connectSendTransportAudio({\n          audioParams,\n          parameters,\n        });\n      } else if (option === 'video') {\n        await connectSendTransportVideo({\n          videoParams,\n          parameters,\n        });\n      } else if (option === 'screen') {\n        if (whiteboardStarted && !whiteboardEnded && canvasStream && islevel === '2' && !shared) {\n          await connectSendTransportScreen({\n            stream: canvasStream,\n            parameters,\n          });\n        } else {\n          if (localStreamScreen) {\n            await connectSendTransportScreen({\n              stream: localStreamScreen,\n              parameters,\n            });\n          } else {\n            throw new Error('localStreamScreen is null or undefined');\n          }\n        }\n      } else {\n        // Connect both audio and video send transports\n        await connectSendTransportAudio({\n          audioParams,\n          parameters,\n        });\n        await connectSendTransportVideo({\n          videoParams,\n          parameters,\n        });\n      }\n    } catch (error) {\n      console.log('connectSendTransport error', error);\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"connect-send-transport.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/connect-send-transport.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAuCzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AAML,MAAM,OAAO,oBAAoB;IAC/B;;;;;;;;;;;;;;;;;;;;;OAqBG;IAEH,KAAK,CAAC,oBAAoB,CAAC,EAAE,MAAM,EAAE,UAAU,EAA+B;QAC5E,IAAI,CAAC;YACH,MAAM,EACJ,WAAW,EACX,WAAW,EACX,iBAAiB,EACjB,YAAY,EACZ,iBAAiB,EACjB,eAAe,EACf,MAAM,EACN,OAAO,EACP,yBAAyB,EACzB,yBAAyB,EACzB,0BAA0B,GAC3B,GAAG,UAAU,CAAC;YAEf,uDAAuD;YACvD,IAAI,MAAM,KAAK,OAAO,EAAE,CAAC;gBACvB,MAAM,yBAAyB,CAAC;oBAC9B,WAAW;oBACX,UAAU;iBACX,CAAC,CAAC;YACL,CAAC;iBAAM,IAAI,MAAM,KAAK,OAAO,EAAE,CAAC;gBAC9B,MAAM,yBAAyB,CAAC;oBAC9B,WAAW;oBACX,UAAU;iBACX,CAAC,CAAC;YACL,CAAC;iBAAM,IAAI,MAAM,KAAK,QAAQ,EAAE,CAAC;gBAC/B,IAAI,iBAAiB,IAAI,CAAC,eAAe,IAAI,YAAY,IAAI,OAAO,KAAK,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;oBACxF,MAAM,0BAA0B,CAAC;wBAC/B,MAAM,EAAE,YAAY;wBACpB,UAAU;qBACX,CAAC,CAAC;gBACL,CAAC;qBAAM,CAAC;oBACN,IAAI,iBAAiB,EAAE,CAAC;wBACtB,MAAM,0BAA0B,CAAC;4BAC/B,MAAM,EAAE,iBAAiB;4BACzB,UAAU;yBACX,CAAC,CAAC;oBACL,CAAC;yBAAM,CAAC;wBACN,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;oBAC5D,CAAC;gBACH,CAAC;YACH,CAAC;iBAAM,CAAC;gBACN,+CAA+C;gBAC/C,MAAM,yBAAyB,CAAC;oBAC9B,WAAW;oBACX,UAAU;iBACX,CAAC,CAAC;gBACH,MAAM,yBAAyB,CAAC;oBAC9B,WAAW;oBACX,UAAU;iBACX,CAAC,CAAC;YACL,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,GAAG,CAAC,4BAA4B,EAAE,KAAK,CAAC,CAAC;QACnD,CAAC;IACH,CAAC;uGAjFU,oBAAoB;2GAApB,oBAAoB,cAFnB,MAAM;;2FAEP,oBAAoB;kBAHhC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\n\nimport { ProducerOptions } from 'mediasoup-client/lib/types';\nimport {\n  ConnectSendTransportAudioType,\n  ConnectSendTransportVideoType,\n  ConnectSendTransportScreenType,\n  ConnectSendTransportAudioParameters,\n  ConnectSendTransportVideoParameters,\n  ConnectSendTransportScreenParameters,\n} from '../@types/types';\nexport interface ConnectSendTransportParameters\n  extends ConnectSendTransportAudioParameters,\n    ConnectSendTransportVideoParameters,\n    ConnectSendTransportScreenParameters {\n  audioParams: ProducerOptions;\n  videoParams: ProducerOptions;\n  localStreamScreen: MediaStream | null;\n  canvasStream: MediaStream | null;\n  whiteboardStarted: boolean;\n  whiteboardEnded: boolean;\n  shared: boolean;\n  islevel: string;\n\n  //mediasfu functions\n  connectSendTransportAudio: ConnectSendTransportAudioType;\n  connectSendTransportVideo: ConnectSendTransportVideoType;\n  connectSendTransportScreen: ConnectSendTransportScreenType;\n  [key: string]: any;\n}\n\nexport interface ConnectSendTransportOptions {\n  option: 'audio' | 'video' | 'screen' | 'all';\n  parameters: ConnectSendTransportParameters;\n}\n\n// Export the type definition for the function\nexport type ConnectSendTransportType = (options: ConnectSendTransportOptions) => Promise<void>;\n\n  /**\n   * Connects the send transport based on the specified option.\n   *\n   * @param {ConnectSendTransportOptions} options - The options for connecting the send transport.\n   * @param {string} options.option - The type of transport to connect (\"audio\", \"video\", \"screen\", or \"all\").\n   * @param {ConnectSendTransportParameters} options.parameters - The parameters required for connecting the transport.\n   * @param {ProducerOptions} options.parameters.audioParams - The audio parameters.\n   * @param {ProducerOptions} options.parameters.videoParams - The video parameters.\n   * @param {MediaStream} options.parameters.localStreamScreen - The local screen stream.\n   * @param {MediaStream} options.parameters.canvasStream - The canvas stream.\n   * @param {boolean} options.parameters.whiteboardStarted - Indicates if the whiteboard has started.\n   * @param {boolean} options.parameters.whiteboardEnded - Indicates if the whiteboard has ended.\n   * @param {boolean} options.parameters.shared - Indicates if the screen is shared.\n   * @param {string} options.parameters.islevel - The level of the screen sharing.\n   * @param {Function} options.parameters.connectSendTransportAudio - Function to connect the audio send transport.\n   * @param {Function} options.parameters.connectSendTransportVideo - Function to connect the video send transport.\n   * @param {Function} options.parameters.connectSendTransportScreen - Function to connect the screen send transport.\n   *\n   * @returns {Promise<void>} A promise that resolves when the transport is connected.\n   *\n   * @throws Will throw an error if the connection fails.\n   *\n   * @example\n   * ```typescript\n   * const options = {\n   *   option: 'audio', // Can be 'audio', 'video', 'screen', or 'all'\n   *   parameters: {\n   *     audioParams: { codec: 'opus' },\n   *     videoParams: { codec: 'vp8' },\n   *     localStreamScreen: null, // Set to your local screen stream\n   *     canvasStream: null, // Set to your canvas stream if using\n   *     whiteboardStarted: false,\n   *     whiteboardEnded: true,\n   *     shared: false,\n   *     islevel: '1',\n   *     connectSendTransportAudio: connectSendTransportAudioFunction,\n   *     connectSendTransportVideo: connectSendTransportVideoFunction,\n   *     connectSendTransportScreen: connectSendTransportScreenFunction,\n   *     updateVideoProducer: () => {},\n   *     updateProducerTransport: () => {},\n   *     updateScreenProducer: () => {},\n   *     updateMainWindow: false,\n   *   },\n   * };\n   *\n   * connectSendTransport(options)\n   *   .then(() => {\n   *     console.log('Transport connected successfully');\n   *   })\n   *   .catch((error) => {\n   *     console.error('Error connecting transport:', error);\n   *   });\n   * ```\n   */\n\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ConnectSendTransport {\n  /**\n   * Connects the send transport based on the specified option.\n   *\n   * @param {ConnectSendTransportOptions} options - The options for connecting the send transport.\n   * @param {string} options.option - The type of transport to connect (\"audio\", \"video\", \"screen\", or both).\n   * @param {Object} options.parameters - The parameters required for connecting the transport.\n   * @param {Object} options.parameters.audioParams - The audio parameters.\n   * @param {Object} options.parameters.videoParams - The video parameters.\n   * @param {MediaStream} options.parameters.localStreamScreen - The local screen stream.\n   * @param {MediaStream} options.parameters.canvasStream - The canvas stream.\n   * @param {boolean} options.parameters.whiteboardStarted - Indicates if the whiteboard has started.\n   * @param {boolean} options.parameters.whiteboardEnded - Indicates if the whiteboard has ended.\n   * @param {boolean} options.parameters.shared - Indicates if the screen is shared.\n   * @param {string} options.parameters.islevel - The level of the screen sharing.\n   * @param {Function} options.parameters.connectSendTransportAudio - Function to connect the audio send transport.\n   * @param {Function} options.parameters.connectSendTransportVideo - Function to connect the video send transport.\n   * @param {Function} options.parameters.connectSendTransportScreen - Function to connect the screen send transport.\n   *\n   * @returns {Promise<void>} A promise that resolves when the transport is connected.\n   *\n   * @throws Will throw an error if the connection fails.\n   */\n\n  async connectSendTransport({ option, parameters }: ConnectSendTransportOptions): Promise<void> {\n    try {\n      const {\n        audioParams,\n        videoParams,\n        localStreamScreen,\n        canvasStream,\n        whiteboardStarted,\n        whiteboardEnded,\n        shared,\n        islevel,\n        connectSendTransportAudio,\n        connectSendTransportVideo,\n        connectSendTransportScreen,\n      } = parameters;\n\n      // Connect send transport based on the specified option\n      if (option === 'audio') {\n        await connectSendTransportAudio({\n          audioParams,\n          parameters,\n        });\n      } else if (option === 'video') {\n        await connectSendTransportVideo({\n          videoParams,\n          parameters,\n        });\n      } else if (option === 'screen') {\n        if (whiteboardStarted && !whiteboardEnded && canvasStream && islevel === '2' && !shared) {\n          await connectSendTransportScreen({\n            stream: canvasStream,\n            parameters,\n          });\n        } else {\n          if (localStreamScreen) {\n            await connectSendTransportScreen({\n              stream: localStreamScreen,\n              parameters,\n            });\n          } else {\n            throw new Error('localStreamScreen is null or undefined');\n          }\n        }\n      } else {\n        // Connect both audio and video send transports\n        await connectSendTransportAudio({\n          audioParams,\n          parameters,\n        });\n        await connectSendTransportVideo({\n          videoParams,\n          parameters,\n        });\n      }\n    } catch (error) {\n      console.log('connectSendTransport error', error);\n    }\n  }\n}\n"]}