mediasfu-angular 1.0.0 → 1.0.2

package/dist/esm2022/lib/consumers/signal-new-consumer-transport.service.mjs

@@ -1,43 +1,43 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+   * Signals the creation of a new consumer transport.
+   *
+   * @param {Object} options - The options for signaling a new consumer transport.
+   * @param {string} options.remoteProducerId - The ID of the remote producer.
+   * @param {boolean} options.islevel - Indicates the level of the consumer.
+   * @param {any} options.nsock - The socket instance for communication.
+   * @param {SignalNewConsumerTransportOptions} options.parameters - The parameters for the transport.
+   *
+   * @returns {Promise<string[] | void>} A promise that resolves to an array of consuming transports or void.
+   *
+   * @throws Will throw an error if the signaling process fails.
+   *
+   * @example
+   * const options = {
+   *   remoteProducerId: 'producer-id',
+   *   islevel: true,
+   *   nsock: socketInstance,
+   *   parameters: {
+   *     device: mediaDevice,
+   *     consumingTransports: [],
+   *     lock_screen: false,
+   *     updateConsumingTransports: updateFunction,
+   *     connectRecvTransport: connectFunction,
+   *     reorderStreams: reorderFunction,
+   *     getUpdatedAllParams: getUpdatedParamsFunction,
+   *   },
+   * };
+   *
+   * signalNewConsumerTransport(options)
+   *   .then(consumingTransports => {
+   *     console.log('Consuming Transports:', consumingTransports);
+   *   })
+   *   .catch(error => {
+   *     console.error('Error signaling new consumer transport:', error);
+   *   });
+   */
 export class SignalNewConsumerTransport {
-    /**
-     * Signals the creation of a new consumer transport.
-     *
-     * @param {Object} options - The options for signaling a new consumer transport.
-     * @param {string} options.remoteProducerId - The ID of the remote producer.
-     * @param {boolean} options.islevel - Indicates the level of the consumer.
-     * @param {any} options.nsock - The socket instance for communication.
-     * @param {SignalNewConsumerTransportOptions} options.parameters - The parameters for the transport.
-     *
-     * @returns {Promise<string[] | void>} A promise that resolves to an array of consuming transports or void.
-     *
-     * @throws Will throw an error if the signaling process fails.
-     *
-     * @example
-     * const options = {
-     *   remoteProducerId: 'producer-id',
-     *   islevel: true,
-     *   nsock: socketInstance,
-     *   parameters: {
-     *     device: mediaDevice,
-     *     consumingTransports: [],
-     *     lock_screen: false,
-     *     updateConsumingTransports: updateFunction,
-     *     connectRecvTransport: connectFunction,
-     *     reorderStreams: reorderFunction,
-     *     getUpdatedAllParams: getUpdatedParamsFunction,
-     *   },
-     * };
-     *
-     * signalNewConsumerTransport(options)
-     *   .then(consumingTransports => {
-     *     console.log('Consuming Transports:', consumingTransports);
-     *   })
-     *   .catch(error => {
-     *     console.error('Error signaling new consumer transport:', error);
-     *   });
-     */
     signalNewConsumerTransport = async ({ remoteProducerId, islevel, nsock, parameters, }) => {
         try {
             let { device, consumingTransports, lock_screen, updateConsumingTransports, connectRecvTransport, reorderStreams, } = parameters;
@@ -133,4 +133,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signal-new-consumer-transport.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/signal-new-consumer-transport.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Socket } from 'socket.io-client';\nimport {\n  ReorderStreamsParameters,\n  ReorderStreamsType,\n  ConnectRecvTransportType,\n  ConnectRecvTransportParameters,\n  CreateWebRTCTransportResponse,\n} from '../@types/types';\nimport { Device, DtlsParameters } from 'mediasoup-client/lib/types';\n\nexport interface SignalNewConsumerTransportParameters\n  extends ReorderStreamsParameters,\n    ConnectRecvTransportParameters {\n  device: Device | null;\n  consumingTransports: string[];\n  lock_screen: boolean;\n  updateConsumingTransports: (transports: string[]) => void;\n  connectRecvTransport: ConnectRecvTransportType;\n  reorderStreams: ReorderStreamsType;\n  getUpdatedAllParams: () => SignalNewConsumerTransportParameters;\n  [key: string]: any;\n}\n\nexport interface SignalNewConsumerTransportOptions {\n  remoteProducerId: string;\n  islevel: string;\n  nsock: Socket;\n  parameters: SignalNewConsumerTransportParameters;\n}\n\n// Export the type definition for the function\nexport type SignalNewConsumerTransportType = (\n  options: SignalNewConsumerTransportOptions,\n) => Promise<string[] | void>;\n@Injectable({\n  providedIn: 'root',\n})\nexport class SignalNewConsumerTransport {\n  /**\n   * Signals the creation of a new consumer transport.\n   *\n   * @param {Object} options - The options for signaling a new consumer transport.\n   * @param {string} options.remoteProducerId - The ID of the remote producer.\n   * @param {boolean} options.islevel - Indicates the level of the consumer.\n   * @param {any} options.nsock - The socket instance for communication.\n   * @param {SignalNewConsumerTransportOptions} options.parameters - The parameters for the transport.\n   *\n   * @returns {Promise<string[] | void>} A promise that resolves to an array of consuming transports or void.\n   *\n   * @throws Will throw an error if the signaling process fails.\n   *\n   * @example\n   * const options = {\n   *   remoteProducerId: 'producer-id',\n   *   islevel: true,\n   *   nsock: socketInstance,\n   *   parameters: {\n   *     device: mediaDevice,\n   *     consumingTransports: [],\n   *     lock_screen: false,\n   *     updateConsumingTransports: updateFunction,\n   *     connectRecvTransport: connectFunction,\n   *     reorderStreams: reorderFunction,\n   *     getUpdatedAllParams: getUpdatedParamsFunction,\n   *   },\n   * };\n   *\n   * signalNewConsumerTransport(options)\n   *   .then(consumingTransports => {\n   *     console.log('Consuming Transports:', consumingTransports);\n   *   })\n   *   .catch(error => {\n   *     console.error('Error signaling new consumer transport:', error);\n   *   });\n   */\n  signalNewConsumerTransport = async ({\n    remoteProducerId,\n    islevel,\n    nsock,\n    parameters,\n  }: SignalNewConsumerTransportOptions): Promise<string[] | void> => {\n    try {\n      let {\n        device,\n        consumingTransports,\n        lock_screen,\n        updateConsumingTransports,\n        connectRecvTransport,\n        reorderStreams,\n      } = parameters;\n\n      // Get updated parameters\n      const updatedParams = parameters.getUpdatedAllParams();\n      device = updatedParams.device;\n      consumingTransports = updatedParams.consumingTransports;\n\n      // Check if already consuming\n      if (consumingTransports.includes(remoteProducerId)) {\n        return consumingTransports;\n      }\n\n      // Add remote producer ID to consumingTransports array\n      consumingTransports.push(remoteProducerId);\n      updateConsumingTransports(consumingTransports);\n\n      // Emit createWebRtcTransport event to signal a new consumer\n      nsock.emit(\n        'createWebRtcTransport',\n        { consumer: true, islevel },\n        async ({ params }: { params: CreateWebRTCTransportResponse }) => {\n          if (params.error) {\n            // Handle error\n            return;\n          }\n\n          try {\n            // Create a new receiving transport using the received parameters\n            if (!device) {\n              throw new Error('Device is not initialized');\n            }\n            const consumerTransport = device.createRecvTransport({ ...params });\n\n            // Handle 'connect' event for the consumer transport\n            consumerTransport.on(\n              'connect',\n              async (\n                { dtlsParameters }: { dtlsParameters: DtlsParameters },\n                callback: () => void,\n                errback: (error: any) => void,\n              ) => {\n                try {\n                  // Emit transport-recv-connect event to signal connection\n                  nsock.emit('transport-recv-connect', {\n                    dtlsParameters,\n                    serverConsumerTransportId: params.id,\n                  });\n                  callback();\n                } catch (error) {\n                  errback(error);\n                }\n              },\n            );\n\n            // Listen for connection state change\n            consumerTransport.on('connectionstatechange', async (state: string) => {\n              switch (state) {\n                case 'connecting':\n                  // Handle connecting state\n                  break;\n\n                case 'connected':\n                  // Handle connected state\n                  break;\n\n                case 'failed':\n                  // Handle failed state\n                  consumerTransport.close();\n\n                  // Reorder streams based on conditions\n                  if (lock_screen) {\n                    await reorderStreams({ add: true, parameters });\n                  } else {\n                    await reorderStreams({ add: false, parameters });\n                  }\n                  break;\n\n                default:\n                  break;\n              }\n            });\n\n            // Connect the receiving transport\n            await connectRecvTransport({\n              consumerTransport,\n              remoteProducerId,\n              serverConsumerTransportId: params.id,\n              nsock,\n              parameters,\n            });\n          } catch (error) {\n            console.log(error, 'createRecvTransport error');\n            // Handle error\n            return;\n          }\n        },\n      );\n    } catch (error) {\n      console.log(error, 'signalNewConsumerTransport error');\n      // Handle error\n      return;\n    }\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signal-new-consumer-transport.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/signal-new-consumer-transport.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Socket } from 'socket.io-client';\nimport {\n  ReorderStreamsParameters,\n  ReorderStreamsType,\n  ConnectRecvTransportType,\n  ConnectRecvTransportParameters,\n  CreateWebRTCTransportResponse,\n} from '../@types/types';\nimport { Device, DtlsParameters } from 'mediasoup-client/lib/types';\n\nexport interface SignalNewConsumerTransportParameters\n  extends ReorderStreamsParameters,\n    ConnectRecvTransportParameters {\n  device: Device | null;\n  consumingTransports: string[];\n  lock_screen: boolean;\n  updateConsumingTransports: (transports: string[]) => void;\n  connectRecvTransport: ConnectRecvTransportType;\n  reorderStreams: ReorderStreamsType;\n  getUpdatedAllParams: () => SignalNewConsumerTransportParameters;\n  [key: string]: any;\n}\n\nexport interface SignalNewConsumerTransportOptions {\n  remoteProducerId: string;\n  islevel: string;\n  nsock: Socket;\n  parameters: SignalNewConsumerTransportParameters;\n}\n\n// Export the type definition for the function\nexport type SignalNewConsumerTransportType = (\n  options: SignalNewConsumerTransportOptions,\n) => Promise<string[] | void>;\n\n/**\n   * Signals the creation of a new consumer transport.\n   *\n   * @param {Object} options - The options for signaling a new consumer transport.\n   * @param {string} options.remoteProducerId - The ID of the remote producer.\n   * @param {boolean} options.islevel - Indicates the level of the consumer.\n   * @param {any} options.nsock - The socket instance for communication.\n   * @param {SignalNewConsumerTransportOptions} options.parameters - The parameters for the transport.\n   *\n   * @returns {Promise<string[] | void>} A promise that resolves to an array of consuming transports or void.\n   *\n   * @throws Will throw an error if the signaling process fails.\n   *\n   * @example\n   * const options = {\n   *   remoteProducerId: 'producer-id',\n   *   islevel: true,\n   *   nsock: socketInstance,\n   *   parameters: {\n   *     device: mediaDevice,\n   *     consumingTransports: [],\n   *     lock_screen: false,\n   *     updateConsumingTransports: updateFunction,\n   *     connectRecvTransport: connectFunction,\n   *     reorderStreams: reorderFunction,\n   *     getUpdatedAllParams: getUpdatedParamsFunction,\n   *   },\n   * };\n   *\n   * signalNewConsumerTransport(options)\n   *   .then(consumingTransports => {\n   *     console.log('Consuming Transports:', consumingTransports);\n   *   })\n   *   .catch(error => {\n   *     console.error('Error signaling new consumer transport:', error);\n   *   });\n   */\n@Injectable({\n  providedIn: 'root',\n})\nexport class SignalNewConsumerTransport {\n\n  signalNewConsumerTransport = async ({\n    remoteProducerId,\n    islevel,\n    nsock,\n    parameters,\n  }: SignalNewConsumerTransportOptions): Promise<string[] | void> => {\n    try {\n      let {\n        device,\n        consumingTransports,\n        lock_screen,\n        updateConsumingTransports,\n        connectRecvTransport,\n        reorderStreams,\n      } = parameters;\n\n      // Get updated parameters\n      const updatedParams = parameters.getUpdatedAllParams();\n      device = updatedParams.device;\n      consumingTransports = updatedParams.consumingTransports;\n\n      // Check if already consuming\n      if (consumingTransports.includes(remoteProducerId)) {\n        return consumingTransports;\n      }\n\n      // Add remote producer ID to consumingTransports array\n      consumingTransports.push(remoteProducerId);\n      updateConsumingTransports(consumingTransports);\n\n      // Emit createWebRtcTransport event to signal a new consumer\n      nsock.emit(\n        'createWebRtcTransport',\n        { consumer: true, islevel },\n        async ({ params }: { params: CreateWebRTCTransportResponse }) => {\n          if (params.error) {\n            // Handle error\n            return;\n          }\n\n          try {\n            // Create a new receiving transport using the received parameters\n            if (!device) {\n              throw new Error('Device is not initialized');\n            }\n            const consumerTransport = device.createRecvTransport({ ...params });\n\n            // Handle 'connect' event for the consumer transport\n            consumerTransport.on(\n              'connect',\n              async (\n                { dtlsParameters }: { dtlsParameters: DtlsParameters },\n                callback: () => void,\n                errback: (error: any) => void,\n              ) => {\n                try {\n                  // Emit transport-recv-connect event to signal connection\n                  nsock.emit('transport-recv-connect', {\n                    dtlsParameters,\n                    serverConsumerTransportId: params.id,\n                  });\n                  callback();\n                } catch (error) {\n                  errback(error);\n                }\n              },\n            );\n\n            // Listen for connection state change\n            consumerTransport.on('connectionstatechange', async (state: string) => {\n              switch (state) {\n                case 'connecting':\n                  // Handle connecting state\n                  break;\n\n                case 'connected':\n                  // Handle connected state\n                  break;\n\n                case 'failed':\n                  // Handle failed state\n                  consumerTransport.close();\n\n                  // Reorder streams based on conditions\n                  if (lock_screen) {\n                    await reorderStreams({ add: true, parameters });\n                  } else {\n                    await reorderStreams({ add: false, parameters });\n                  }\n                  break;\n\n                default:\n                  break;\n              }\n            });\n\n            // Connect the receiving transport\n            await connectRecvTransport({\n              consumerTransport,\n              remoteProducerId,\n              serverConsumerTransportId: params.id,\n              nsock,\n              parameters,\n            });\n          } catch (error) {\n            console.log(error, 'createRecvTransport error');\n            // Handle error\n            return;\n          }\n        },\n      );\n    } catch (error) {\n      console.log(error, 'signalNewConsumerTransport error');\n      // Handle error\n      return;\n    }\n  };\n}\n"]}

package/dist/esm2022/lib/consumers/socket-receive-methods/join-consume-room.service.mjs

@@ -1,6 +1,39 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
 import * as i1 from "../../producers/producer-emits/join-con-room.service";
+/**
+ * @service JoinConsumeRoom
+ * @description Service to join a media consumption room, setup device, and manage piped transports.
+ *
+ * @method joinConsumeRoom
+ * Joins a consumption room by sending a request to the server and performing necessary device and transport setup.
+ *
+ * @param {JoinConsumeRoomOptions} options - Options for joining the consumption room.
+ * @param {Socket} options.remote_sock - The remote socket used for joining the room.
+ * @param {string} options.apiToken - API token for authentication.
+ * @param {string} options.apiUserName - API username for authentication.
+ * @param {JoinConsumeRoomParameters} options.parameters - Parameters required for the function.
+ *
+ * @returns {Promise<JoinConsumeRoomResponse>} A promise that resolves with the result of the join request.
+ *
+ * @example
+ * ```typescript
+ * const joinConsumeRoomResponse = await joinConsumeRoomService.joinConsumeRoom({
+ *   remote_sock: mySocket,
+ *   apiToken: 'apiToken123',
+ *   apiUserName: 'myUser',
+ *   parameters: {
+ *     roomName: 'room1',
+ *     islevel: '2',
+ *     member: 'JohnDoe',
+ *     device: null,
+ *     updateDevice: updateDeviceFunction,
+ *     receiveAllPipedTransports: receiveAllPipedTransportsFunction,
+ *     createDeviceClient: createDeviceClientFunction,
+ *   }
+ * });
+ * ```
+ */
 export class JoinConsumeRoom {
     JoinConRoomService;
     constructor(JoinConRoomService) {
@@ -60,4 +93,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }], ctorParameters: () => [{ type: i1.JoinConRoom }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"join-consume-room.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/consumers/socket-receive-methods/join-consume-room.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;;AAwC3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAKH,MAAM,OAAO,eAAe;IACN;IAApB,YAAoB,kBAA+B;QAA/B,uBAAkB,GAAlB,kBAAkB,CAAa;IAAG,CAAC;IAEvD;;;;;;;;OAQG;IACH,eAAe,GAAG,KAAK,EAAE,EACvB,WAAW,EACX,QAAQ,EACR,WAAW,EACX,UAAU,GACa,EAAoC,EAAE;QAC7D,IAAI,EACF,QAAQ,EACR,OAAO,EACP,MAAM,EACN,MAAM,EACN,YAAY;QAEZ,oBAAoB;QACpB,yBAAyB,EACzB,kBAAkB,GACnB,GAAG,UAAU,CAAC;QAEf,IAAI,CAAC;YACH,4BAA4B;YAC5B,MAAM,IAAI,GAAQ,MAAM,IAAI,CAAC,kBAAkB,CAAC,WAAW,CAAC;gBAC1D,MAAM,EAAE,WAAW;gBACnB,QAAQ;gBACR,OAAO;gBACP,MAAM;gBACN,GAAG,EAAE,QAAQ;gBACb,WAAW;aACZ,CAAC,CAAC;YAEH,IAAI,IAAI,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;gBACzB,wCAAwC;gBACxC,IAAI,CAAC,MAAM,EAAE,CAAC;oBACZ,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;wBACzB,MAAM,OAAO,GAAG,MAAM,kBAAkB,CAAC;4BACvC,eAAe,EAAE,IAAI,CAAC,eAAe;yBACtC,CAAC,CAAC;wBAEH,IAAI,OAAO,EAAE,CAAC;4BACZ,YAAY,CAAC,OAAO,CAAC,CAAC;wBACxB,CAAC;oBACH,CAAC;gBACH,CAAC;gBAED,+BAA+B;gBAC/B,MAAM,yBAAyB,CAAC,EAAE,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,CAAC,CAAC;YACtE,CAAC;YAED,OAAO,IAAI,CAAC;QACd,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,GAAG,CAAC,2BAA2B,EAAE,KAAK,CAAC,CAAC;YAChD,MAAM,IAAI,KAAK,CAAC,qEAAqE,CAAC,CAAC;QACzF,CAAC;IACH,CAAC,CAAC;uGAhES,eAAe;2GAAf,eAAe,cAFd,MAAM;;2FAEP,eAAe;kBAH3B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { JoinConRoom } from '../../producers/producer-emits/join-con-room.service';\nimport { Socket } from 'socket.io-client';\nimport {\n  ReceiveAllPipedTransportsType,\n  ReceiveAllPipedTransportsParameters,\n  CreateDeviceClientType,\n} from '../../@types/types';\nimport { Device, RtpCapabilities } from 'mediasoup-client/lib/types';\n\nexport interface JoinConsumeRoomParameters extends ReceiveAllPipedTransportsParameters {\n  roomName: string;\n  islevel: string;\n  member: string;\n  device: Device | null;\n  updateDevice: (device: Device | null) => void;\n  receiveAllPipedTransports: ReceiveAllPipedTransportsType;\n  createDeviceClient: CreateDeviceClientType;\n\n  // mediasfu functions\n  [key: string]: any;\n}\nexport interface JoinConsumeRoomOptions {\n  remote_sock: Socket;\n  apiToken: string;\n  apiUserName: string;\n  parameters: JoinConsumeRoomParameters;\n}\n\ninterface JoinConsumeRoomResponse {\n  success: boolean;\n  rtpCapabilities?: RtpCapabilities;\n}\n\n// Export the type definition for the function\nexport type JoinConsumeRoomType = (\n  options: JoinConsumeRoomOptions,\n) => Promise<JoinConsumeRoomResponse>;\n\n\n/**\n * @service JoinConsumeRoom\n * @description Service to join a media consumption room, setup device, and manage piped transports.\n *\n * @method joinConsumeRoom\n * Joins a consumption room by sending a request to the server and performing necessary device and transport setup.\n *\n * @param {JoinConsumeRoomOptions} options - Options for joining the consumption room.\n * @param {Socket} options.remote_sock - The remote socket used for joining the room.\n * @param {string} options.apiToken - API token for authentication.\n * @param {string} options.apiUserName - API username for authentication.\n * @param {JoinConsumeRoomParameters} options.parameters - Parameters required for the function.\n *\n * @returns {Promise<JoinConsumeRoomResponse>} A promise that resolves with the result of the join request.\n *\n * @example\n * ```typescript\n * const joinConsumeRoomResponse = await joinConsumeRoomService.joinConsumeRoom({\n *   remote_sock: mySocket,\n *   apiToken: 'apiToken123',\n *   apiUserName: 'myUser',\n *   parameters: {\n *     roomName: 'room1',\n *     islevel: '2',\n *     member: 'JohnDoe',\n *     device: null,\n *     updateDevice: updateDeviceFunction,\n *     receiveAllPipedTransports: receiveAllPipedTransportsFunction,\n *     createDeviceClient: createDeviceClientFunction,\n *   }\n * });\n * ```\n */\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class JoinConsumeRoom {\n  constructor(private JoinConRoomService: JoinConRoom) {}\n\n  /**\n   * Joins a consumption room by sending a request to the server and handles the necessary setup.\n   * @param {Object} options - The options object containing necessary variables.\n   * @param {any} options.remote_sock - The remote socket information.\n   * @param {string} options.apiToken - The API token for authentication.\n   * @param {string} options.apiUserName - The API username for authentication.\n   * @param {any} options.parameters - Additional parameters required for the function.\n   * @returns {Promise<any>} - A promise that resolves with data related to the success of joining the room.\n   */\n  joinConsumeRoom = async ({\n    remote_sock,\n    apiToken,\n    apiUserName,\n    parameters,\n  }: JoinConsumeRoomOptions): Promise<JoinConsumeRoomResponse> => {\n    let {\n      roomName,\n      islevel,\n      member,\n      device,\n      updateDevice,\n\n      //Mediasfu functions\n      receiveAllPipedTransports,\n      createDeviceClient,\n    } = parameters;\n\n    try {\n      // Join the consumption room\n      const data: any = await this.JoinConRoomService.joinConRoom({\n        socket: remote_sock,\n        roomName,\n        islevel,\n        member,\n        sec: apiToken,\n        apiUserName,\n      });\n\n      if (data && data.success) {\n        // Setup media device if not already set\n        if (!device) {\n          if (data.rtpCapabilities) {\n            const device_ = await createDeviceClient({\n              rtpCapabilities: data.rtpCapabilities,\n            });\n\n            if (device_) {\n              updateDevice(device_);\n            }\n          }\n        }\n\n        // Receive all piped transports\n        await receiveAllPipedTransports({ nsock: remote_sock, parameters });\n      }\n\n      return data;\n    } catch (error) {\n      console.log('Error in joinConsumeRoom:', error);\n      throw new Error('Failed to join the consumption room or set up necessary components.');\n    }\n  };\n}\n"]}

package/dist/esm2022/lib/consumers/socket-receive-methods/new-pipe-producer.service.mjs

@@ -1,6 +1,45 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
 import * as i1 from "../signal-new-consumer-transport.service";
+/**
+ * @service NewPipeProducer
+ * @description Service to manage new pipe producer events, update state, and handle screen orientation for optimal experience.
+ *
+ * @method newPipeProducer
+ * Handles the setup of a new pipe producer and manages user notifications or orientation changes as needed.
+ *
+ * @param {NewPipeProducerOptions} options - Options for setting up a new pipe producer.
+ * @param {string} options.producerId - Unique ID for the new producer.
+ * @param {string} options.islevel - Level designation for the producer.
+ * @param {Socket} options.nsock - The socket used for communication.
+ * @param {NewPipeProducerParameters} options.parameters - Parameters to configure the new pipe producer.
+ *
+ * @returns {Promise<void>} A promise that completes when the new pipe producer is set up.
+ *
+ * @example
+ * ```typescript
+ * await newPipeProducerService.newPipeProducer({
+ *   producerId: 'producer123',
+ *   islevel: '2',
+ *   nsock: mySocket,
+ *   parameters: {
+ *     first_round: true,
+ *     shareScreenStarted: false,
+ *     shared: false,
+ *     landScaped: false,
+ *     showAlert: alertFunction,
+ *     isWideScreen: true,
+ *     updateFirst_round: updateFirstRoundFunction,
+ *     updateLandScaped: updateLandScapedFunction,
+ *     device: myDevice,
+ *     consumingTransports: [],
+ *     connectRecvTransport: connectRecvTransportFunction,
+ *     reorderStreams: reorderStreamsFunction,
+ *     getUpdatedAllParams: getUpdatedParamsFunction,
+ *   }
+ * });
+ * ```
+ */
 export class NewPipeProducer {
     signalNewConsumerTransportService;
     constructor(signalNewConsumerTransportService) {
@@ -58,4 +97,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }], ctorParameters: () => [{ type: i1.SignalNewConsumerTransport }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"new-pipe-producer.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/consumers/socket-receive-methods/new-pipe-producer.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;;AA+C3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAKH,MAAM,OAAO,eAAe;IACN;IAApB,YAAoB,iCAA6D;QAA7D,sCAAiC,GAAjC,iCAAiC,CAA4B;IAAG,CAAC;IAErF;;;;;;;;OAQG;IACH,eAAe,GAAG,KAAK,EAAE,EACvB,UAAU,EACV,OAAO,EACP,KAAK,EACL,UAAU,GACa,EAAiB,EAAE;QAC1C,IAAI,EACF,WAAW,EACX,kBAAkB,EAClB,MAAM,EACN,UAAU,EACV,SAAS,EACT,YAAY,EACZ,iBAAiB,EACjB,gBAAgB,GACjB,GAAG,UAAU,CAAC;QAEf,IAAI,CAAC;YACH,+CAA+C;YAC/C,MAAM,IAAI,CAAC,iCAAiC,CAAC,0BAA0B,CAAC;gBACtE,gBAAgB,EAAE,UAAU;gBAC5B,OAAO,EAAE,OAAO;gBAChB,KAAK,EAAE,KAAK;gBACZ,UAAU,EAAE,UAAU;aACvB,CAAC,CAAC;YAEH,WAAW,GAAG,KAAK,CAAC;YACpB,IAAI,kBAAkB,IAAI,MAAM,EAAE,CAAC;gBACjC,IAAI,CAAC,YAAY,EAAE,CAAC;oBAClB,IAAI,CAAC,UAAU,EAAE,CAAC;wBAChB,IAAI,SAAS,EAAE,CAAC;4BACd,SAAS,CAAC;gCACR,OAAO,EAAE,mEAAmE;gCAC5E,IAAI,EAAE,SAAS;gCACf,QAAQ,EAAE,IAAI;6BACf,CAAC,CAAC;wBACL,CAAC;wBACD,UAAU,GAAG,IAAI,CAAC;wBAClB,gBAAgB,CAAC,UAAU,CAAC,CAAC;oBAC/B,CAAC;gBACH,CAAC;gBAED,WAAW,GAAG,IAAI,CAAC;gBACnB,iBAAiB,CAAC,WAAW,CAAC,CAAC;YACjC,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,2BAA2B,EAAE,KAAK,CAAC,CAAC;YAClD,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;QAC/D,CAAC;IACH,CAAC,CAAC;uGA7DS,eAAe;2GAAf,eAAe,cAFd,MAAM;;2FAEP,eAAe;kBAH3B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { SignalNewConsumerTransport } from '../signal-new-consumer-transport.service';\nimport { Socket } from 'socket.io-client';\nimport {\n  ReorderStreamsParameters,\n  ReorderStreamsType,\n  SignalNewConsumerTransportParameters,\n  ConnectRecvTransportParameters,\n  ConnectRecvTransportType,\n  ShowAlert,\n} from '../../@types/types';\nimport { Device } from 'mediasoup-client/lib/types';\n\nexport interface NewPipeProducerParameters\n  extends ReorderStreamsParameters,\n    SignalNewConsumerTransportParameters,\n    ConnectRecvTransportParameters {\n  first_round: boolean;\n  shareScreenStarted: boolean;\n  shared: boolean;\n  landScaped: boolean;\n  showAlert?: ShowAlert;\n  isWideScreen: boolean;\n  updateFirst_round: (firstRound: boolean) => void;\n  updateLandScaped: (landScaped: boolean) => void;\n  device: Device | null;\n  consumingTransports: string[];\n  lock_screen: boolean;\n  updateConsumingTransports: (transports: string[]) => void;\n\n  // mediasfu functions\n  connectRecvTransport: ConnectRecvTransportType;\n  reorderStreams: ReorderStreamsType;\n  getUpdatedAllParams: () => NewPipeProducerParameters;\n  [key: string]: any;\n}\n\nexport interface NewPipeProducerOptions {\n  producerId: string;\n  islevel: string;\n  nsock: Socket;\n  parameters: NewPipeProducerParameters;\n}\n\n// Export the type definition for the function\nexport type NewPipeProducerType = (options: NewPipeProducerOptions) => Promise<void>;\n\n/**\n * @service NewPipeProducer\n * @description Service to manage new pipe producer events, update state, and handle screen orientation for optimal experience.\n *\n * @method newPipeProducer\n * Handles the setup of a new pipe producer and manages user notifications or orientation changes as needed.\n *\n * @param {NewPipeProducerOptions} options - Options for setting up a new pipe producer.\n * @param {string} options.producerId - Unique ID for the new producer.\n * @param {string} options.islevel - Level designation for the producer.\n * @param {Socket} options.nsock - The socket used for communication.\n * @param {NewPipeProducerParameters} options.parameters - Parameters to configure the new pipe producer.\n *\n * @returns {Promise<void>} A promise that completes when the new pipe producer is set up.\n *\n * @example\n * ```typescript\n * await newPipeProducerService.newPipeProducer({\n *   producerId: 'producer123',\n *   islevel: '2',\n *   nsock: mySocket,\n *   parameters: {\n *     first_round: true,\n *     shareScreenStarted: false,\n *     shared: false,\n *     landScaped: false,\n *     showAlert: alertFunction,\n *     isWideScreen: true,\n *     updateFirst_round: updateFirstRoundFunction,\n *     updateLandScaped: updateLandScapedFunction,\n *     device: myDevice,\n *     consumingTransports: [],\n *     connectRecvTransport: connectRecvTransportFunction,\n *     reorderStreams: reorderStreamsFunction,\n *     getUpdatedAllParams: getUpdatedParamsFunction,\n *   }\n * });\n * ```\n */\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class NewPipeProducer {\n  constructor(private signalNewConsumerTransportService: SignalNewConsumerTransport) {}\n\n  /**\n   * Handles new pipe producer events and updates relevant states.\n   * @param {Object} options - The options object containing necessary variables.\n   * @param {string} options.producerId - The ID of the producer.\n   * @param {string} options.islevel - The level of the producer.\n   * @param {any} options.nsock - The socket object.\n   * @param {any} options.parameters - Additional parameters required for the function.\n   * @returns {Promise<void>}\n   */\n  newPipeProducer = async ({\n    producerId,\n    islevel,\n    nsock,\n    parameters,\n  }: NewPipeProducerOptions): Promise<void> => {\n    let {\n      first_round,\n      shareScreenStarted,\n      shared,\n      landScaped,\n      showAlert,\n      isWideScreen,\n      updateFirst_round,\n      updateLandScaped,\n    } = parameters;\n\n    try {\n      // Perform signaling for new consumer transport\n      await this.signalNewConsumerTransportService.signalNewConsumerTransport({\n        remoteProducerId: producerId,\n        islevel: islevel,\n        nsock: nsock,\n        parameters: parameters,\n      });\n\n      first_round = false;\n      if (shareScreenStarted || shared) {\n        if (!isWideScreen) {\n          if (!landScaped) {\n            if (showAlert) {\n              showAlert({\n                message: 'Please rotate your device to landscape mode for better experience',\n                type: 'success',\n                duration: 3000,\n              });\n            }\n            landScaped = true;\n            updateLandScaped(landScaped);\n          }\n        }\n\n        first_round = true;\n        updateFirst_round(first_round);\n      }\n    } catch (error) {\n      console.error('Error in newPipeProducer:', error);\n      throw new Error('Failed to handle new pipe producer event.');\n    }\n  };\n}\n"]}

package/dist/esm2022/lib/consumers/socket-receive-methods/producer-closed.service.mjs

@@ -1,5 +1,32 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * @service ProducerClosed
+ * @description Service to manage the closing of a producer, including resizing video elements and updating consumer transports.
+ *
+ * @method producerClosed
+ * Closes a specific producer by its ID, adjusts any associated video elements, and updates the list of consumer transports.
+ *
+ * @param {ProducerClosedOptions} options - Options for closing the specified producer.
+ * @param {string} options.remoteProducerId - Unique ID for the producer to close.
+ * @param {ProducerClosedParameters} options.parameters - Parameters to configure the producer closure and related updates.
+ *
+ * @returns {Promise<void>} A promise that resolves when the producer has been closed and relevant updates have been made.
+ *
+ * @example
+ * ```typescript
+ * await producerClosedService.producerClosed({
+ *   remoteProducerId: 'producer123',
+ *   parameters: {
+ *     consumerTransports: currentTransports,
+ *     screenId: 'screen123',
+ *     updateConsumerTransports: updateTransportList,
+ *     closeAndResize: closeAndResizeFunction,
+ *     getUpdatedAllParams: getUpdatedParamsFunction,
+ *   }
+ * });
+ * ```
+ */
 export class ProducerClosed {
     /**
      * Handles the closing of a producer and resizes video elements.
@@ -48,4 +75,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvZHVjZXItY2xvc2VkLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tZWRpYXNmdS1hbmd1bGFyL3NyYy9saWIvY29uc3VtZXJzL3NvY2tldC1yZWNlaXZlLW1ldGhvZHMvcHJvZHVjZXItY2xvc2VkLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUF5QjNDLE1BQU0sT0FBTyxjQUFjO0lBQ3pCOzs7Ozs7T0FNRztJQUNILGNBQWMsR0FBRyxLQUFLLEVBQUUsRUFDdEIsZ0JBQWdCLEVBQ2hCLFVBQVUsR0FDWSxFQUFpQixFQUFFO1FBQ3pDLElBQUksRUFDRixrQkFBa0IsRUFDbEIsUUFBUSxFQUNSLHdCQUF3QjtRQUV4QixxQkFBcUI7UUFDckIsY0FBYyxHQUNmLEdBQUcsVUFBVSxDQUFDO1FBRWYseUJBQXlCO1FBQ3pCLE1BQU0sZUFBZSxHQUFHLGtCQUFrQixDQUFDLElBQUksQ0FDN0MsQ0FBQyxhQUFrQixFQUFFLEVBQUUsQ0FBQyxhQUFhLENBQUMsVUFBVSxLQUFLLGdCQUFnQixDQUN0RSxDQUFDO1FBRUYsSUFBSSxDQUFDLGVBQWUsRUFBRSxDQUFDO1lBQ3JCLE9BQU87UUFDVCxDQUFDO1FBRUQsMERBQTBEO1FBQzFELElBQUksSUFBSSxHQUFXLGVBQWUsQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDO1FBRWpELElBQUksZUFBZSxDQUFDLFVBQVUsSUFBSSxRQUFRLEVBQUUsQ0FBQztZQUMzQyxJQUFJLEdBQUcsYUFBYSxDQUFDO1FBQ3ZCLENBQUM7UUFDRCxJQUFJLENBQUM7WUFDSCxNQUFNLGVBQWUsQ0FBQyxtQkFBbUIsQ0FBQyxDQUFDLEtBQUssRUFBRSxDQUFDO1FBQ3JELENBQUM7UUFBQyxPQUFPLEtBQUssRUFBRSxDQUFDO1lBQ2YsT0FBTyxDQUFDLEtBQUssQ0FBQyxrQ0FBa0MsRUFBRSxLQUFLLENBQUMsQ0FBQztRQUMzRCxDQUFDO1FBRUQsSUFBSSxDQUFDO1lBQ0gsZUFBZSxDQUFDLFFBQVEsQ0FBQyxLQUFLLEVBQUUsQ0FBQztRQUNuQyxDQUFDO1FBQUMsT0FBTyxLQUFLLEVBQUUsQ0FBQztZQUNmLE9BQU8sQ0FBQyxLQUFLLENBQUMseUJBQXlCLEVBQUUsS0FBSyxDQUFDLENBQUM7UUFDbEQsQ0FBQztRQUVELGtCQUFrQixHQUFHLGtCQUFrQixDQUFDLE1BQU0sQ0FDNUMsQ0FBQyxhQUFrQixFQUFFLEVBQUUsQ0FBQyxhQUFhLENBQUMsVUFBVSxLQUFLLGdCQUFnQixDQUN0RSxDQUFDO1FBQ0Ysd0JBQXdCLENBQUMsa0JBQWtCLENBQUMsQ0FBQztRQUU3Qyw4QkFBOEI7UUFDOUIsTUFBTSxjQUFjLENBQUMsRUFBRSxVQUFVLEVBQUUsZ0JBQWdCLEVBQUUsSUFBSSxFQUFFLElBQUksRUFBRSxVQUFVLEVBQUUsVUFBVSxFQUFFLENBQUMsQ0FBQztJQUM3RixDQUFDLENBQUM7dUdBdkRTLGNBQWM7MkdBQWQsY0FBYyxjQUZiLE1BQU07OzJGQUVQLGNBQWM7a0JBSDFCLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgVHJhbnNwb3J0LCBDbG9zZUFuZFJlc2l6ZVBhcmFtZXRlcnMsIENsb3NlQW5kUmVzaXplVHlwZSB9IGZyb20gJy4uLy4uL0B0eXBlcy90eXBlcyc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgUHJvZHVjZXJDbG9zZWRQYXJhbWV0ZXJzIGV4dGVuZHMgQ2xvc2VBbmRSZXNpemVQYXJhbWV0ZXJzIHtcbiAgY29uc3VtZXJUcmFuc3BvcnRzOiBUcmFuc3BvcnRbXTtcbiAgc2NyZWVuSWQ/OiBzdHJpbmc7XG4gIHVwZGF0ZUNvbnN1bWVyVHJhbnNwb3J0czogKHRyYW5zcG9ydHM6IFRyYW5zcG9ydFtdKSA9PiB2b2lkO1xuXG4gIC8vIG1lZGlhc2Z1IGZ1bmN0aW9uc1xuICBjbG9zZUFuZFJlc2l6ZTogQ2xvc2VBbmRSZXNpemVUeXBlO1xuICBnZXRVcGRhdGVkQWxsUGFyYW1zOiAoKSA9PiBQcm9kdWNlckNsb3NlZFBhcmFtZXRlcnM7XG4gIFtrZXk6IHN0cmluZ106IGFueTtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBQcm9kdWNlckNsb3NlZE9wdGlvbnMge1xuICByZW1vdGVQcm9kdWNlcklkOiBzdHJpbmc7XG4gIHBhcmFtZXRlcnM6IFByb2R1Y2VyQ2xvc2VkUGFyYW1ldGVycztcbn1cblxuLy8gRXhwb3J0IHRoZSB0eXBlIGRlZmluaXRpb24gZm9yIHRoZSBmdW5jdGlvblxuZXhwb3J0IHR5cGUgUHJvZHVjZXJDbG9zZWRUeXBlID0gKG9wdGlvbnM6IFByb2R1Y2VyQ2xvc2VkT3B0aW9ucykgPT4gUHJvbWlzZTx2b2lkPjtcblxuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCcsXG59KVxuZXhwb3J0IGNsYXNzIFByb2R1Y2VyQ2xvc2VkIHtcbiAgLyoqXG4gICAqIEhhbmRsZXMgdGhlIGNsb3Npbmcgb2YgYSBwcm9kdWNlciBhbmQgcmVzaXplcyB2aWRlbyBlbGVtZW50cy5cbiAgICogQHBhcmFtIHtPYmplY3R9IG9wdGlvbnMgLSBUaGUgb3B0aW9ucyBvYmplY3QgY29udGFpbmluZyBuZWNlc3NhcnkgdmFyaWFibGVzLlxuICAgKiBAcGFyYW0ge3N0cmluZ30gb3B0aW9ucy5yZW1vdGVQcm9kdWNlcklkIC0gVGhlIElEIG9mIHRoZSByZW1vdGUgcHJvZHVjZXIuXG4gICAqIEBwYXJhbSB7YW55fSBvcHRpb25zLnBhcmFtZXRlcnMgLSBBZGRpdGlvbmFsIHBhcmFtZXRlcnMgcmVxdWlyZWQgZm9yIHRoZSBmdW5jdGlvbi5cbiAgICogQHJldHVybnMge1Byb21pc2U8dm9pZD59XG4gICAqL1xuICBwcm9kdWNlckNsb3NlZCA9IGFzeW5jICh7XG4gICAgcmVtb3RlUHJvZHVjZXJJZCxcbiAgICBwYXJhbWV0ZXJzLFxuICB9OiBQcm9kdWNlckNsb3NlZE9wdGlvbnMpOiBQcm9taXNlPHZvaWQ+ID0+IHtcbiAgICBsZXQge1xuICAgICAgY29uc3VtZXJUcmFuc3BvcnRzLFxuICAgICAgc2NyZWVuSWQsXG4gICAgICB1cGRhdGVDb25zdW1lclRyYW5zcG9ydHMsXG5cbiAgICAgIC8vIG1lZGlhc2Z1IGZ1bmN0aW9uc1xuICAgICAgY2xvc2VBbmRSZXNpemUsXG4gICAgfSA9IHBhcmFtZXRlcnM7XG5cbiAgICAvLyBIYW5kbGUgcHJvZHVjZXIgY2xvc2VkXG4gICAgY29uc3QgcHJvZHVjZXJUb0Nsb3NlID0gY29uc3VtZXJUcmFuc3BvcnRzLmZpbmQoXG4gICAgICAodHJhbnNwb3J0RGF0YTogYW55KSA9PiB0cmFuc3BvcnREYXRhLnByb2R1Y2VySWQgPT09IHJlbW90ZVByb2R1Y2VySWQsXG4gICAgKTtcblxuICAgIGlmICghcHJvZHVjZXJUb0Nsb3NlKSB7XG4gICAgICByZXR1cm47XG4gICAgfVxuXG4gICAgLy8gQ2hlY2sgaWYgdGhlIElEIG9mIHRoZSBwcm9kdWNlciB0byBjbG9zZSBpcyA9PSBzY3JlZW5JZFxuICAgIGxldCBraW5kOiBzdHJpbmcgPSBwcm9kdWNlclRvQ2xvc2UuY29uc3VtZXIua2luZDtcblxuICAgIGlmIChwcm9kdWNlclRvQ2xvc2UucHJvZHVjZXJJZCA9PSBzY3JlZW5JZCkge1xuICAgICAga2luZCA9ICdzY3JlZW5zaGFyZSc7XG4gICAgfVxuICAgIHRyeSB7XG4gICAgICBhd2FpdCBwcm9kdWNlclRvQ2xvc2VbJ2NvbnN1bWVyVHJhbnNwb3J0J10uY2xvc2UoKTtcbiAgICB9IGNhdGNoIChlcnJvcikge1xuICAgICAgY29uc29sZS5lcnJvcignRXJyb3IgY2xvc2luZyBjb25zdW1lclRyYW5zcG9ydDonLCBlcnJvcik7XG4gICAgfVxuXG4gICAgdHJ5IHtcbiAgICAgIHByb2R1Y2VyVG9DbG9zZS5jb25zdW1lci5jbG9zZSgpO1xuICAgIH0gY2F0Y2ggKGVycm9yKSB7XG4gICAgICBjb25zb2xlLmVycm9yKCdFcnJvciBjbG9zaW5nIGNvbnN1bWVyOicsIGVycm9yKTtcbiAgICB9XG5cbiAgICBjb25zdW1lclRyYW5zcG9ydHMgPSBjb25zdW1lclRyYW5zcG9ydHMuZmlsdGVyKFxuICAgICAgKHRyYW5zcG9ydERhdGE6IGFueSkgPT4gdHJhbnNwb3J0RGF0YS5wcm9kdWNlcklkICE9PSByZW1vdGVQcm9kdWNlcklkLFxuICAgICk7XG4gICAgdXBkYXRlQ29uc3VtZXJUcmFuc3BvcnRzKGNvbnN1bWVyVHJhbnNwb3J0cyk7XG5cbiAgICAvLyBDbG9zZSBhbmQgcmVzaXplIHRoZSB2aWRlb3NcbiAgICBhd2FpdCBjbG9zZUFuZFJlc2l6ZSh7IHByb2R1Y2VySWQ6IHJlbW90ZVByb2R1Y2VySWQsIGtpbmQ6IGtpbmQsIHBhcmFtZXRlcnM6IHBhcmFtZXRlcnMgfSk7XG4gIH07XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/consumers/start-share-screen.service.mjs

@@ -1,5 +1,45 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * StartShareScreen - Service to initiate screen sharing with configurable options for different environments.
+ *
+ * This service initiates the screen sharing process, handling both successful and failed attempts
+ * and updating the shared state accordingly.
+ *
+ * @class
+ * @name StartShareScreen
+ * @example
+ * ```typescript
+ * const startShareScreenService = new StartShareScreen();
+ * await startShareScreenService.startShareScreen({
+ *   parameters: {
+ *     shared: false,
+ *     showAlert: (alert) => console.log(alert.message),
+ *     updateShared: (shared) => console.log('Shared state:', shared),
+ *     onWeb: true,
+ *     targetWidth: 1920,
+ *     targetHeight: 1080,
+ *     streamSuccessScreen: async ({ stream }) => {
+ *       // Handle the successful stream here
+ *       console.log('Stream started:', stream);
+ *     },
+ *   },
+ * });
+ * ```
+ *
+ * @param {StartShareScreenOptions} options - The options for starting screen sharing.
+ * @param {Object} options.parameters - The parameters controlling screen sharing behavior.
+ * @param {boolean} options.parameters.shared - Indicates if the screen is currently shared.
+ * @param {Function} options.parameters.showAlert - Function to display alerts.
+ * @param {Function} options.parameters.updateShared - Function to update the shared state.
+ * @param {boolean} options.parameters.onWeb - Indicates if the app is running in a web environment.
+ * @param {number} [options.parameters.targetWidth=1280] - Optional width setting for shared screen resolution.
+ * @param {number} [options.parameters.targetHeight=720] - Optional height setting for shared screen resolution.
+ * @param {Function} options.parameters.streamSuccessScreen - Function to handle successful screen sharing.
+ *
+ * @method startShareScreen - Initiates the screen sharing process based on the provided parameters.
+ * @returns {Promise<void>} Resolves when the screen sharing process is complete or fails.
+ */
 export class StartShareScreen {
     /**
      * Starts the screen sharing process.
@@ -77,4 +117,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":"start-share-screen.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/start-share-screen.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAqB3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAMH,MAAM,OAAO,gBAAgB;IAC3B;;;;;;;;;;;;;;;;OAgBG;IACH,gBAAgB,GAAG,KAAK,EAAE,EAAE,UAAU,EAA2B,EAAiB,EAAE;QAClF,8BAA8B;QAC9B,8DAA8D;QAE9D,IAAI,EACF,MAAM,EACN,SAAS,EACT,YAAY,EACZ,KAAK,EACL,WAAW,GAAG,IAAI,EAClB,YAAY,GAAG,GAAG,EAClB,mBAAmB,GACpB,GAAG,UAAU,CAAC;QAEf,IAAI,CAAC;YACH,IAAI,CAAC,KAAK,EAAE,CAAC;gBACX,SAAS,EAAE,CAAC;oBACV,OAAO,EAAE,yCAAyC;oBAClD,IAAI,EAAE,QAAQ;oBACd,QAAQ,EAAE,IAAI;iBACf,CAAC,CAAC;gBACH,OAAO;YACT,CAAC;YAED,IAAI,SAAS,CAAC,YAAY,IAAI,SAAS,CAAC,YAAY,CAAC,eAAe,EAAE,CAAC;gBACrE,MAAM,GAAG,IAAI,CAAC;gBACd,MAAM,SAAS,CAAC,YAAY;qBACzB,eAAe,CAAC;oBACf,KAAK,EAAE;wBACL,KAAK,EAAE,WAAW;wBAClB,MAAM,EAAE,YAAY;wBACpB,SAAS,EAAE,EAAE;qBACd;oBACD,KAAK,EAAE,KAAK;iBACb,CAAC;qBACD,IAAI,CAAC,KAAK,EAAE,MAAmB,EAAE,EAAE;oBAClC,MAAM,mBAAmB,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC,CAAC;gBACpD,CAAC,CAAC;qBACD,KAAK,CAAC,KAAK,IAAI,EAAE;oBAChB,MAAM,GAAG,KAAK,CAAC;oBACf,SAAS,EAAE,CAAC;wBACV,OAAO,EAAE,yCAAyC;wBAClD,IAAI,EAAE,QAAQ;wBACd,QAAQ,EAAE,IAAI;qBACf,CAAC,CAAC;gBACL,CAAC,CAAC,CAAC;YACP,CAAC;iBAAM,CAAC;gBACN,SAAS,EAAE,CAAC;oBACV,OAAO,EAAE,yCAAyC;oBAClD,IAAI,EAAE,QAAQ;oBACd,QAAQ,EAAE,IAAI;iBACf,CAAC,CAAC;YACL,CAAC;YAED,6BAA6B;YAC7B,YAAY,CAAC,MAAM,CAAC,CAAC;QACvB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,GAAG,CAAC,6BAA6B,EAAE,KAAK,CAAC,CAAC;QACpD,CAAC;IACH,CAAC,CAAC;uGA7ES,gBAAgB;2GAAhB,gBAAgB,cAFf,MAAM;;2FAEP,gBAAgB;kBAH5B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { StreamSuccessScreenType, StreamSuccessScreenParameters, ShowAlert } from '../@types/types';\nexport interface StartShareScreenParameters extends StreamSuccessScreenParameters {\n  shared: boolean;\n  showAlert?: ShowAlert;\n  updateShared: (shared: boolean) => void;\n  onWeb: boolean;\n  targetWidth?: number;\n  targetHeight?: number;\n\n  // mediasfu functions\n  streamSuccessScreen: StreamSuccessScreenType;\n  [key: string]: any;\n}\n\nexport interface StartShareScreenOptions {\n  parameters: StartShareScreenParameters;\n}\n\n// Export the type definition for the function\nexport type StartShareScreenType = (options: StartShareScreenOptions) => Promise<void>;\n/**\n * StartShareScreen - Service to initiate screen sharing with configurable options for different environments.\n *\n * This service initiates the screen sharing process, handling both successful and failed attempts\n * and updating the shared state accordingly.\n *\n * @class\n * @name StartShareScreen\n * @example\n * ```typescript\n * const startShareScreenService = new StartShareScreen();\n * await startShareScreenService.startShareScreen({\n *   parameters: {\n *     shared: false,\n *     showAlert: (alert) => console.log(alert.message),\n *     updateShared: (shared) => console.log('Shared state:', shared),\n *     onWeb: true,\n *     targetWidth: 1920,\n *     targetHeight: 1080,\n *     streamSuccessScreen: async ({ stream }) => {\n *       // Handle the successful stream here\n *       console.log('Stream started:', stream);\n *     },\n *   },\n * });\n * ```\n *\n * @param {StartShareScreenOptions} options - The options for starting screen sharing.\n * @param {Object} options.parameters - The parameters controlling screen sharing behavior.\n * @param {boolean} options.parameters.shared - Indicates if the screen is currently shared.\n * @param {Function} options.parameters.showAlert - Function to display alerts.\n * @param {Function} options.parameters.updateShared - Function to update the shared state.\n * @param {boolean} options.parameters.onWeb - Indicates if the app is running in a web environment.\n * @param {number} [options.parameters.targetWidth=1280] - Optional width setting for shared screen resolution.\n * @param {number} [options.parameters.targetHeight=720] - Optional height setting for shared screen resolution.\n * @param {Function} options.parameters.streamSuccessScreen - Function to handle successful screen sharing.\n *\n * @method startShareScreen - Initiates the screen sharing process based on the provided parameters.\n * @returns {Promise<void>} Resolves when the screen sharing process is complete or fails.\n */\n\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class StartShareScreen {\n  /**\n   * Starts the screen sharing process.\n   *\n   * @param {StartShareScreenOptions} options - The options for starting screen sharing.\n   * @param {Object} options.parameters - The parameters for screen sharing.\n   * @param {boolean} options.parameters.shared - Indicates if the screen is currently being shared.\n   * @param {Function} options.parameters.showAlert - Function to show alert messages.\n   * @param {Function} options.parameters.updateShared - Function to update the shared state.\n   * @param {boolean} options.parameters.onWeb - Indicates if the application is running on a web platform.\n   * @param {number} [options.parameters.targetWidth] - The target width for screen sharing.\n   * @param {number} [options.parameters.targetHeight] - The target height for screen sharing.\n   * @param {Function} options.parameters.streamSuccessScreen - Function to handle successful screen sharing.\n   *\n   * @returns {Promise<void>} A promise that resolves when the screen sharing process is complete.\n   *\n   * @throws Will log an error message if there is an issue starting the screen share.\n   */\n  startShareScreen = async ({ parameters }: StartShareScreenOptions): Promise<void> => {\n    // start screen share function\n    // attempt to start screen share and return true if successful\n\n    let {\n      shared,\n      showAlert,\n      updateShared,\n      onWeb,\n      targetWidth = 1280,\n      targetHeight = 720,\n      streamSuccessScreen,\n    } = parameters;\n\n    try {\n      if (!onWeb) {\n        showAlert?.({\n          message: 'You cannot share screen while on mobile',\n          type: 'danger',\n          duration: 3000,\n        });\n        return;\n      }\n\n      if (navigator.mediaDevices && navigator.mediaDevices.getDisplayMedia) {\n        shared = true;\n        await navigator.mediaDevices\n          .getDisplayMedia({\n            video: {\n              width: targetWidth,\n              height: targetHeight,\n              frameRate: 30,\n            },\n            audio: false,\n          })\n          .then(async (stream: MediaStream) => {\n            await streamSuccessScreen({ stream, parameters });\n          })\n          .catch(async () => {\n            shared = false;\n            showAlert?.({\n              message: 'Could not share screen, check and retry',\n              type: 'danger',\n              duration: 3000,\n            });\n          });\n      } else {\n        showAlert?.({\n          message: 'Could not share screen, check and retry',\n          type: 'danger',\n          duration: 3000,\n        });\n      }\n\n      // update the shared variable\n      updateShared(shared);\n    } catch (error) {\n      console.log('Error starting screen share', error);\n    }\n  };\n}\n"]}

package/dist/esm2022/lib/consumers/stop-share-screen.service.mjs

@@ -1,5 +1,60 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Stops the screen sharing process and updates the relevant parameters and states.
+ *
+ * This method updates the internal state to reflect that screen sharing has ended,
+ * cleans up local media tracks, and reorders the streams in the application.
+ *
+ * @param {StopShareScreenOptions} options - The options for stopping the screen share.
+ * @param {Object} options.parameters - The parameters required for stopping the screen share.
+ * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+ * @param {boolean} options.parameters.shared - Indicates if the screen is currently shared.
+ * @param {boolean} options.parameters.shareScreenStarted - Indicates if the screen sharing has started.
+ * @param {boolean} options.parameters.shareEnded - Indicates if the screen sharing has ended.
+ * @param {boolean} options.parameters.updateMainWindow - Indicates if the main window needs to be updated.
+ * @param {boolean} options.parameters.defer_receive - Indicates if receiving is deferred.
+ * @param {string} options.parameters.hostLabel - The label of the host.
+ * @param {boolean} options.parameters.lock_screen - Indicates if the screen is locked.
+ * @param {boolean} options.parameters.forceFullDisplay - Indicates if full display is forced.
+ * @param {boolean} options.parameters.firstAll - Indicates if it is the first all.
+ * @param {boolean} options.parameters.first_round - Indicates if it is the first round.
+ * @param {MediaStream} options.parameters.localStreamScreen - The local screen stream.
+ * @param {string} options.parameters.eventType - The type of event (e.g., "conference").
+ * @param {boolean} options.parameters.prevForceFullDisplay - Indicates if full display was previously forced.
+ * @param {boolean} options.parameters.annotateScreenStream - Indicates if the screen stream is annotated.
+ * @param {Function} options.parameters.updateShared - Function to update the shared state.
+ * @param {Function} options.parameters.updateShareScreenStarted - Function to update the share screen started state.
+ * @param {Function} options.parameters.updateShareEnded - Function to update the share ended state.
+ * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window state.
+ * @param {Function} options.parameters.updateDefer_receive - Function to update the defer receive state.
+ * @param {Function} options.parameters.updateLock_screen - Function to update the lock screen state.
+ * @param {Function} options.parameters.updateForceFullDisplay - Function to update the force full display state.
+ * @param {Function} options.parameters.updateFirstAll - Function to update the first all state.
+ * @param {Function} options.parameters.updateFirst_round - Function to update the first round state.
+ * @param {Function} options.parameters.updateLocalStreamScreen - Function to update the local screen stream.
+ * @param {Function} options.parameters.updateMainHeightWidth - Function to update the main height and width.
+ * @param {Function} options.parameters.updateAnnotateScreenStream - Function to update the annotate screen stream state.
+ * @param {Function} options.parameters.updateIsScreenboardModalVisible - Function to update the screenboard modal visibility.
+ * @param {Function} options.parameters.disconnectSendTransportScreen - Function to disconnect the send transport screen.
+ * @param {Function} options.parameters.prepopulateUserMedia - Function to prepopulate user media.
+ * @param {Function} options.parameters.reorderStreams - Function to reorder streams.
+ * @param {Function} options.parameters.getVideos - Function to get videos.
+ *
+ * @returns {Promise<void>} A promise that resolves when the screen sharing process is stopped.
+ *
+ * @throws {Error} Throws an error if there is an issue during the screen share stopping process.
+ *
+ * @example
+ * await stopShareScreen({
+ *   parameters: {
+ *     socket: mySocket,
+ *     shared: true,
+ *     shareScreenStarted: true,
+ *     // other parameters...
+ *   },
+ * });
+ */
 export class StopShareScreen {
     /**
      * Stops the screen sharing process and updates the relevant parameters and states.
@@ -117,4 +172,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stop-share-screen.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/stop-share-screen.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  DisconnectSendTransportScreenType,\n  PrepopulateUserMediaType,\n  ReorderStreamsType,\n  GetVideosType,\n  DisconnectSendTransportScreenParameters,\n  PrepopulateUserMediaParameters,\n  ReorderStreamsParameters,\n  EventType,\n} from '../@types/types';\nexport interface StopShareScreenParameters\n  extends DisconnectSendTransportScreenParameters,\n    PrepopulateUserMediaParameters,\n    ReorderStreamsParameters {\n  shared: boolean;\n  shareScreenStarted: boolean;\n  shareEnded: boolean;\n  updateMainWindow: boolean;\n  defer_receive: boolean;\n  hostLabel: string;\n  lock_screen: boolean;\n  forceFullDisplay: boolean;\n  firstAll: boolean;\n  first_round: boolean;\n  localStreamScreen: MediaStream | null;\n  eventType: EventType;\n  prevForceFullDisplay: boolean;\n  annotateScreenStream: boolean;\n\n  updateShared: (shared: boolean) => void;\n  updateShareScreenStarted: (shareScreenStarted: boolean) => void;\n  updateShareEnded: (shareEnded: boolean) => void;\n  updateUpdateMainWindow: (updateMainWindow: boolean) => void;\n  updateDefer_receive: (defer_receive: boolean) => void;\n  updateLock_screen: (lock_screen: boolean) => void;\n  updateForceFullDisplay: (forceFullDisplay: boolean) => void;\n  updateFirstAll: (firstAll: boolean) => void;\n  updateFirst_round: (first_round: boolean) => void;\n  updateLocalStreamScreen: (localStreamScreen: MediaStream | null) => void;\n  updateMainHeightWidth: (mainHeightWidth: number) => void;\n  updateAnnotateScreenStream: (annotateScreenStream: boolean) => void;\n  updateIsScreenboardModalVisible: (isVisible: boolean) => void;\n\n  // mediasfu functions\n  disconnectSendTransportScreen: DisconnectSendTransportScreenType;\n  prepopulateUserMedia: PrepopulateUserMediaType;\n  reorderStreams: ReorderStreamsType;\n  getVideos: GetVideosType;\n\n  getUpdatedAllParams: () => StopShareScreenParameters;\n  [key: string]: any;\n}\n\nexport interface StopShareScreenOptions {\n  parameters: StopShareScreenParameters;\n}\n\n// Export the type definition for the function\nexport type StopShareScreenType = (options: StopShareScreenOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class StopShareScreen {\n  /**\n   * Stops the screen sharing process and updates the relevant parameters and states.\n   *\n   * @param {StopShareScreenOptions} options - The options for stopping the screen share.\n   * @param {Object} options.parameters - The parameters required for stopping the screen share.\n   * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.\n   * @param {boolean} options.parameters.shared - Indicates if the screen is currently shared.\n   * @param {boolean} options.parameters.shareScreenStarted - Indicates if the screen sharing has started.\n   * @param {boolean} options.parameters.shareEnded - Indicates if the screen sharing has ended.\n   * @param {boolean} options.parameters.updateMainWindow - Indicates if the main window needs to be updated.\n   * @param {boolean} options.parameters.defer_receive - Indicates if receiving is deferred.\n   * @param {string} options.parameters.hostLabel - The label of the host.\n   * @param {boolean} options.parameters.lock_screen - Indicates if the screen is locked.\n   * @param {boolean} options.parameters.forceFullDisplay - Indicates if full display is forced.\n   * @param {boolean} options.parameters.firstAll - Indicates if it is the first all.\n   * @param {boolean} options.parameters.first_round - Indicates if it is the first round.\n   * @param {MediaStream} options.parameters.localStreamScreen - The local screen stream.\n   * @param {string} options.parameters.eventType - The type of event.\n   * @param {boolean} options.parameters.prevForceFullDisplay - Indicates if full display was previously forced.\n   * @param {boolean} options.parameters.annotateScreenStream - Indicates if the screen stream is annotated.\n   * @param {Function} options.parameters.updateShared - Function to update the shared state.\n   * @param {Function} options.parameters.updateShareScreenStarted - Function to update the share screen started state.\n   * @param {Function} options.parameters.updateShareEnded - Function to update the share ended state.\n   * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window state.\n   * @param {Function} options.parameters.updateDefer_receive - Function to update the defer receive state.\n   * @param {Function} options.parameters.updateLock_screen - Function to update the lock screen state.\n   * @param {Function} options.parameters.updateForceFullDisplay - Function to update the force full display state.\n   * @param {Function} options.parameters.updateFirstAll - Function to update the first all state.\n   * @param {Function} options.parameters.updateFirst_round - Function to update the first round state.\n   * @param {Function} options.parameters.updateLocalStreamScreen - Function to update the local screen stream.\n   * @param {Function} options.parameters.updateMainHeightWidth - Function to update the main height and width.\n   * @param {Function} options.parameters.updateAnnotateScreenStream - Function to update the annotate screen stream state.\n   * @param {Function} options.parameters.updateIsScreenboardModalVisible - Function to update the screenboard modal visibility.\n   * @param {Function} options.parameters.disconnectSendTransportScreen - Function to disconnect the send transport screen.\n   * @param {Function} options.parameters.prepopulateUserMedia - Function to prepopulate user media.\n   * @param {Function} options.parameters.reorderStreams - Function to reorder streams.\n   * @param {Function} options.parameters.getVideos - Function to get videos.\n   *\n   * @returns {Promise<void>} A promise that resolves when the screen sharing process is stopped.\n   */\n  stopShareScreen = async ({ parameters }: StopShareScreenOptions): Promise<void> => {\n    let { getUpdatedAllParams } = parameters;\n    parameters = getUpdatedAllParams();\n\n    let {\n      shared,\n      shareScreenStarted,\n      shareEnded,\n      updateMainWindow,\n      defer_receive,\n      hostLabel,\n      lock_screen,\n      forceFullDisplay,\n      firstAll,\n      first_round,\n      localStreamScreen,\n      eventType,\n      prevForceFullDisplay,\n      annotateScreenStream,\n\n      // updates for the above\n      updateShared,\n      updateShareScreenStarted,\n      updateShareEnded,\n      updateUpdateMainWindow,\n      updateDefer_receive,\n      updateLock_screen,\n      updateForceFullDisplay,\n      updateFirstAll,\n      updateFirst_round,\n      updateLocalStreamScreen,\n      updateMainHeightWidth,\n      updateAnnotateScreenStream,\n      updateIsScreenboardModalVisible,\n\n      // mediasfu functions\n      disconnectSendTransportScreen,\n      prepopulateUserMedia,\n      reorderStreams,\n      getVideos,\n    } = parameters;\n\n    shared = false;\n    updateShared(shared);\n    shareScreenStarted = false;\n    updateShareScreenStarted(shareScreenStarted);\n    shareEnded = true;\n    updateShareEnded(shareEnded);\n    updateMainWindow = true;\n    updateUpdateMainWindow(updateMainWindow);\n\n    if (defer_receive) {\n      defer_receive = false;\n      updateDefer_receive(defer_receive);\n      await getVideos({\n        participants: parameters.participants,\n        allVideoStreams: parameters.allVideoStreams,\n        oldAllStreams: parameters.oldAllStreams,\n        adminVidID: parameters.adminVidID,\n        updateAllVideoStreams: parameters['updateAllVideoStreams'],\n        updateOldAllStreams: parameters['updateOldAllStreams'],\n      });\n    }\n\n    localStreamScreen?.getTracks().forEach((track: MediaStreamTrack) => track.stop());\n    updateLocalStreamScreen(localStreamScreen);\n    await disconnectSendTransportScreen({ parameters });\n\n    try {\n      if (annotateScreenStream) {\n        annotateScreenStream = false;\n        updateAnnotateScreenStream(annotateScreenStream);\n        updateIsScreenboardModalVisible(true);\n        await new Promise((resolve) => setTimeout(resolve, 500));\n        updateIsScreenboardModalVisible(false);\n      }\n    } catch (error) {\n      console.log('Error handling screen annotation:', error);\n    }\n\n    if (eventType == 'conference') {\n      updateMainHeightWidth(0);\n    }\n\n    try {\n      await prepopulateUserMedia({ name: hostLabel, parameters });\n    } catch (error) {\n      console.log('Error in prepopulateUserMedia:', error);\n    }\n\n    try {\n      await reorderStreams({ add: false, screenChanged: true, parameters });\n    } catch (error) {\n      console.log('Error in reorderStreams:', error);\n    }\n\n    lock_screen = false;\n    updateLock_screen(lock_screen);\n    forceFullDisplay = prevForceFullDisplay;\n    updateForceFullDisplay(forceFullDisplay);\n    firstAll = false;\n    updateFirstAll(firstAll);\n    first_round = false;\n    updateFirst_round(first_round);\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stop-share-screen.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/stop-share-screen.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  DisconnectSendTransportScreenType,\n  PrepopulateUserMediaType,\n  ReorderStreamsType,\n  GetVideosType,\n  DisconnectSendTransportScreenParameters,\n  PrepopulateUserMediaParameters,\n  ReorderStreamsParameters,\n  EventType,\n} from '../@types/types';\nexport interface StopShareScreenParameters\n  extends DisconnectSendTransportScreenParameters,\n    PrepopulateUserMediaParameters,\n    ReorderStreamsParameters {\n  shared: boolean;\n  shareScreenStarted: boolean;\n  shareEnded: boolean;\n  updateMainWindow: boolean;\n  defer_receive: boolean;\n  hostLabel: string;\n  lock_screen: boolean;\n  forceFullDisplay: boolean;\n  firstAll: boolean;\n  first_round: boolean;\n  localStreamScreen: MediaStream | null;\n  eventType: EventType;\n  prevForceFullDisplay: boolean;\n  annotateScreenStream: boolean;\n\n  updateShared: (shared: boolean) => void;\n  updateShareScreenStarted: (shareScreenStarted: boolean) => void;\n  updateShareEnded: (shareEnded: boolean) => void;\n  updateUpdateMainWindow: (updateMainWindow: boolean) => void;\n  updateDefer_receive: (defer_receive: boolean) => void;\n  updateLock_screen: (lock_screen: boolean) => void;\n  updateForceFullDisplay: (forceFullDisplay: boolean) => void;\n  updateFirstAll: (firstAll: boolean) => void;\n  updateFirst_round: (first_round: boolean) => void;\n  updateLocalStreamScreen: (localStreamScreen: MediaStream | null) => void;\n  updateMainHeightWidth: (mainHeightWidth: number) => void;\n  updateAnnotateScreenStream: (annotateScreenStream: boolean) => void;\n  updateIsScreenboardModalVisible: (isVisible: boolean) => void;\n\n  // mediasfu functions\n  disconnectSendTransportScreen: DisconnectSendTransportScreenType;\n  prepopulateUserMedia: PrepopulateUserMediaType;\n  reorderStreams: ReorderStreamsType;\n  getVideos: GetVideosType;\n\n  getUpdatedAllParams: () => StopShareScreenParameters;\n  [key: string]: any;\n}\n\nexport interface StopShareScreenOptions {\n  parameters: StopShareScreenParameters;\n}\n\n// Export the type definition for the function\nexport type StopShareScreenType = (options: StopShareScreenOptions) => Promise<void>;\n\n/**\n * Stops the screen sharing process and updates the relevant parameters and states.\n *\n * This method updates the internal state to reflect that screen sharing has ended,\n * cleans up local media tracks, and reorders the streams in the application.\n *\n * @param {StopShareScreenOptions} options - The options for stopping the screen share.\n * @param {Object} options.parameters - The parameters required for stopping the screen share.\n * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.\n * @param {boolean} options.parameters.shared - Indicates if the screen is currently shared.\n * @param {boolean} options.parameters.shareScreenStarted - Indicates if the screen sharing has started.\n * @param {boolean} options.parameters.shareEnded - Indicates if the screen sharing has ended.\n * @param {boolean} options.parameters.updateMainWindow - Indicates if the main window needs to be updated.\n * @param {boolean} options.parameters.defer_receive - Indicates if receiving is deferred.\n * @param {string} options.parameters.hostLabel - The label of the host.\n * @param {boolean} options.parameters.lock_screen - Indicates if the screen is locked.\n * @param {boolean} options.parameters.forceFullDisplay - Indicates if full display is forced.\n * @param {boolean} options.parameters.firstAll - Indicates if it is the first all.\n * @param {boolean} options.parameters.first_round - Indicates if it is the first round.\n * @param {MediaStream} options.parameters.localStreamScreen - The local screen stream.\n * @param {string} options.parameters.eventType - The type of event (e.g., \"conference\").\n * @param {boolean} options.parameters.prevForceFullDisplay - Indicates if full display was previously forced.\n * @param {boolean} options.parameters.annotateScreenStream - Indicates if the screen stream is annotated.\n * @param {Function} options.parameters.updateShared - Function to update the shared state.\n * @param {Function} options.parameters.updateShareScreenStarted - Function to update the share screen started state.\n * @param {Function} options.parameters.updateShareEnded - Function to update the share ended state.\n * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window state.\n * @param {Function} options.parameters.updateDefer_receive - Function to update the defer receive state.\n * @param {Function} options.parameters.updateLock_screen - Function to update the lock screen state.\n * @param {Function} options.parameters.updateForceFullDisplay - Function to update the force full display state.\n * @param {Function} options.parameters.updateFirstAll - Function to update the first all state.\n * @param {Function} options.parameters.updateFirst_round - Function to update the first round state.\n * @param {Function} options.parameters.updateLocalStreamScreen - Function to update the local screen stream.\n * @param {Function} options.parameters.updateMainHeightWidth - Function to update the main height and width.\n * @param {Function} options.parameters.updateAnnotateScreenStream - Function to update the annotate screen stream state.\n * @param {Function} options.parameters.updateIsScreenboardModalVisible - Function to update the screenboard modal visibility.\n * @param {Function} options.parameters.disconnectSendTransportScreen - Function to disconnect the send transport screen.\n * @param {Function} options.parameters.prepopulateUserMedia - Function to prepopulate user media.\n * @param {Function} options.parameters.reorderStreams - Function to reorder streams.\n * @param {Function} options.parameters.getVideos - Function to get videos.\n *\n * @returns {Promise<void>} A promise that resolves when the screen sharing process is stopped.\n *\n * @throws {Error} Throws an error if there is an issue during the screen share stopping process.\n *\n * @example\n * await stopShareScreen({\n *   parameters: {\n *     socket: mySocket,\n *     shared: true,\n *     shareScreenStarted: true,\n *     // other parameters...\n *   },\n * });\n */\n\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class StopShareScreen {\n  /**\n   * Stops the screen sharing process and updates the relevant parameters and states.\n   *\n   * @param {StopShareScreenOptions} options - The options for stopping the screen share.\n   * @param {Object} options.parameters - The parameters required for stopping the screen share.\n   * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.\n   * @param {boolean} options.parameters.shared - Indicates if the screen is currently shared.\n   * @param {boolean} options.parameters.shareScreenStarted - Indicates if the screen sharing has started.\n   * @param {boolean} options.parameters.shareEnded - Indicates if the screen sharing has ended.\n   * @param {boolean} options.parameters.updateMainWindow - Indicates if the main window needs to be updated.\n   * @param {boolean} options.parameters.defer_receive - Indicates if receiving is deferred.\n   * @param {string} options.parameters.hostLabel - The label of the host.\n   * @param {boolean} options.parameters.lock_screen - Indicates if the screen is locked.\n   * @param {boolean} options.parameters.forceFullDisplay - Indicates if full display is forced.\n   * @param {boolean} options.parameters.firstAll - Indicates if it is the first all.\n   * @param {boolean} options.parameters.first_round - Indicates if it is the first round.\n   * @param {MediaStream} options.parameters.localStreamScreen - The local screen stream.\n   * @param {string} options.parameters.eventType - The type of event.\n   * @param {boolean} options.parameters.prevForceFullDisplay - Indicates if full display was previously forced.\n   * @param {boolean} options.parameters.annotateScreenStream - Indicates if the screen stream is annotated.\n   * @param {Function} options.parameters.updateShared - Function to update the shared state.\n   * @param {Function} options.parameters.updateShareScreenStarted - Function to update the share screen started state.\n   * @param {Function} options.parameters.updateShareEnded - Function to update the share ended state.\n   * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window state.\n   * @param {Function} options.parameters.updateDefer_receive - Function to update the defer receive state.\n   * @param {Function} options.parameters.updateLock_screen - Function to update the lock screen state.\n   * @param {Function} options.parameters.updateForceFullDisplay - Function to update the force full display state.\n   * @param {Function} options.parameters.updateFirstAll - Function to update the first all state.\n   * @param {Function} options.parameters.updateFirst_round - Function to update the first round state.\n   * @param {Function} options.parameters.updateLocalStreamScreen - Function to update the local screen stream.\n   * @param {Function} options.parameters.updateMainHeightWidth - Function to update the main height and width.\n   * @param {Function} options.parameters.updateAnnotateScreenStream - Function to update the annotate screen stream state.\n   * @param {Function} options.parameters.updateIsScreenboardModalVisible - Function to update the screenboard modal visibility.\n   * @param {Function} options.parameters.disconnectSendTransportScreen - Function to disconnect the send transport screen.\n   * @param {Function} options.parameters.prepopulateUserMedia - Function to prepopulate user media.\n   * @param {Function} options.parameters.reorderStreams - Function to reorder streams.\n   * @param {Function} options.parameters.getVideos - Function to get videos.\n   *\n   * @returns {Promise<void>} A promise that resolves when the screen sharing process is stopped.\n   */\n  stopShareScreen = async ({ parameters }: StopShareScreenOptions): Promise<void> => {\n    let { getUpdatedAllParams } = parameters;\n    parameters = getUpdatedAllParams();\n\n    let {\n      shared,\n      shareScreenStarted,\n      shareEnded,\n      updateMainWindow,\n      defer_receive,\n      hostLabel,\n      lock_screen,\n      forceFullDisplay,\n      firstAll,\n      first_round,\n      localStreamScreen,\n      eventType,\n      prevForceFullDisplay,\n      annotateScreenStream,\n\n      // updates for the above\n      updateShared,\n      updateShareScreenStarted,\n      updateShareEnded,\n      updateUpdateMainWindow,\n      updateDefer_receive,\n      updateLock_screen,\n      updateForceFullDisplay,\n      updateFirstAll,\n      updateFirst_round,\n      updateLocalStreamScreen,\n      updateMainHeightWidth,\n      updateAnnotateScreenStream,\n      updateIsScreenboardModalVisible,\n\n      // mediasfu functions\n      disconnectSendTransportScreen,\n      prepopulateUserMedia,\n      reorderStreams,\n      getVideos,\n    } = parameters;\n\n    shared = false;\n    updateShared(shared);\n    shareScreenStarted = false;\n    updateShareScreenStarted(shareScreenStarted);\n    shareEnded = true;\n    updateShareEnded(shareEnded);\n    updateMainWindow = true;\n    updateUpdateMainWindow(updateMainWindow);\n\n    if (defer_receive) {\n      defer_receive = false;\n      updateDefer_receive(defer_receive);\n      await getVideos({\n        participants: parameters.participants,\n        allVideoStreams: parameters.allVideoStreams,\n        oldAllStreams: parameters.oldAllStreams,\n        adminVidID: parameters.adminVidID,\n        updateAllVideoStreams: parameters['updateAllVideoStreams'],\n        updateOldAllStreams: parameters['updateOldAllStreams'],\n      });\n    }\n\n    localStreamScreen?.getTracks().forEach((track: MediaStreamTrack) => track.stop());\n    updateLocalStreamScreen(localStreamScreen);\n    await disconnectSendTransportScreen({ parameters });\n\n    try {\n      if (annotateScreenStream) {\n        annotateScreenStream = false;\n        updateAnnotateScreenStream(annotateScreenStream);\n        updateIsScreenboardModalVisible(true);\n        await new Promise((resolve) => setTimeout(resolve, 500));\n        updateIsScreenboardModalVisible(false);\n      }\n    } catch (error) {\n      console.log('Error handling screen annotation:', error);\n    }\n\n    if (eventType == 'conference') {\n      updateMainHeightWidth(0);\n    }\n\n    try {\n      await prepopulateUserMedia({ name: hostLabel, parameters });\n    } catch (error) {\n      console.log('Error in prepopulateUserMedia:', error);\n    }\n\n    try {\n      await reorderStreams({ add: false, screenChanged: true, parameters });\n    } catch (error) {\n      console.log('Error in reorderStreams:', error);\n    }\n\n    lock_screen = false;\n    updateLock_screen(lock_screen);\n    forceFullDisplay = prevForceFullDisplay;\n    updateForceFullDisplay(forceFullDisplay);\n    firstAll = false;\n    updateFirstAll(firstAll);\n    first_round = false;\n    updateFirst_round(first_round);\n  };\n}\n"]}