mediasfu-angular 1.0.0 → 1.0.2

package/dist/esm2022/lib/consumers/get-piped-producers-alt.service.mjs

@@ -1,6 +1,39 @@
 // piped-producers.service.ts
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Retrieves piped producers and signals new consumer transport for each retrieved producer.
+ *
+ * @param {GetPipedProducersAltOptions} options - The options for retrieving piped producers.
+ * @param {Socket} options.nsock - The WebSocket instance used for communication.
+ * @param {string} options.islevel - A flag indicating the level of the request.
+ * @param {GetPipedProducersAltParameters} options.parameters - Additional parameters for the request.
+ * @param {string} options.parameters.member - The member identifier.
+ * @param {SignalNewConsumerTransportType} options.parameters.signalNewConsumerTransport - A function to signal new consumer transport.
+ *
+ * @returns {Promise<void>} A promise that resolves when the operation is complete.
+ *
+ * @throws {Error} If an error occurs during the process of retrieving producers.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   nsock: socketInstance,
+ *   islevel: '2',
+ *   parameters: {
+ *     member: 'user123',
+ *     signalNewConsumerTransport: async ({ nsock, remoteProducerId, islevel, parameters }) => {
+ *       // Implementation to signal new consumer transport
+ *       console.log(`Signaling new consumer transport for producer: ${remoteProducerId}`);
+ *     },
+ *   },
+ * };
+ *
+ * const getPipedProducersService = new GetPipedProducersAlt();
+ * await getPipedProducersService.getPipedProducersAlt(options);
+ * console.log('Piped producers retrieved successfully.');
+ * ```
+ */
 export class GetPipedProducersAlt {
     /**
      * Retrieves piped producers and signals new consumer transport for each retrieved producer.
@@ -46,4 +79,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/get-producers-piped.service.mjs

@@ -1,5 +1,38 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Retrieves piped producers and signals new consumer transport for each retrieved producer.
+ *
+ * @param {GetProducersPipedOptions} options - The options for getting piped producers.
+ * @param {Socket} options.nsock - The WebSocket instance used for communication.
+ * @param {string} options.islevel - A flag indicating the level of the operation.
+ * @param {GetProducersPipedParameters} options.parameters - Additional parameters for the operation.
+ * @param {string} options.parameters.member - The member identifier.
+ * @param {SignalNewConsumerTransportType} options.parameters.signalNewConsumerTransport - The function to signal new consumer transport.
+ *
+ * @returns {Promise<void>} A promise that resolves when the operation is complete.
+ *
+ * @throws {Error} If an error occurs during the process of retrieving producers.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   nsock: socketInstance,
+ *   islevel: '2',
+ *   parameters: {
+ *     member: 'user123',
+ *     signalNewConsumerTransport: async ({ remoteProducerId, islevel, nsock, parameters }) => {
+ *       // Implementation to signal new consumer transport
+ *       console.log(`Signaling new consumer transport for producer: ${remoteProducerId}`);
+ *     },
+ *   },
+ * };
+ *
+ * const getProducersPipedService = new GetProducersPiped();
+ * await getProducersPipedService.getProducersPiped(options);
+ * console.log('Piped producers retrieved successfully.');
+ * ```
+ */
 export class GetProducersPiped {
     /**
      * Retrieves piped producers and signals new consumer transport for each retrieved producer.
@@ -43,4 +76,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/get-videos.service.mjs

@@ -1,5 +1,38 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Asynchronously processes and updates video streams by filtering out the admin's video stream.
+ *
+ * @param {GetVideosOptions} options - The options for getting videos.
+ * @param {Participant[]} options.participants - The list of participants.
+ * @param {Stream[]} options.allVideoStreams - The list of all video streams.
+ * @param {(Stream | Participant)[]} options.oldAllStreams - The list of old video streams.
+ * @param {string} [options.adminVidID] - The ID of the admin's video stream.
+ * @param {Function} options.updateAllVideoStreams - Function to update the state variable for all video streams.
+ * @param {Function} options.updateOldAllStreams - Function to update the state variable for old video streams.
+ * @returns {Promise<void>} A promise that resolves when the video streams have been processed and updated.
+ *
+ * @throws {Error} If an error occurs during the process of updating video streams.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   participants: participantList,
+ *   allVideoStreams: currentVideoStreams,
+ *   oldAllStreams: previousVideoStreams,
+ *   updateAllVideoStreams: (streams) => {
+ *     console.log('Updated all video streams:', streams);
+ *   },
+ *   updateOldAllStreams: (streams) => {
+ *     console.log('Updated old video streams:', streams);
+ *   },
+ * };
+ *
+ * const getVideosService = new GetVideos();
+ * await getVideosService.getVideos(options);
+ * console.log('Video streams processed successfully.');
+ * ```
+ */
 export class GetVideos {
     /**
      * Asynchronously processes and updates video streams by filtering out the admin's video stream.
@@ -55,4 +88,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":"get-videos.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/get-videos.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAc3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAMH,MAAM,OAAO,SAAS;IACpB;;;;;;;;;;;OAWG;IAEH,KAAK,CAAC,SAAS,CAAC,EACd,YAAY,EACZ,eAAe,EACf,aAAa,EACb,UAAU,EACV,qBAAqB,EACrB,mBAAmB,GACF;QACjB,IAAI,CAAC;YACH,iEAAiE;YACjE,IAAI,KAAK,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC,WAAgB,EAAE,EAAE,CAAC,WAAW,CAAC,OAAO,KAAK,GAAG,CAAC,CAAC;YAEnF,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACrB,UAAU,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;gBAE9B,IAAI,UAAU,IAAI,IAAI,IAAI,UAAU,KAAK,EAAE,EAAE,CAAC;oBAC5C,IAAI,cAAc,GAAU,EAAE,CAAC;oBAE/B,yDAAyD;oBACzD,IAAI,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;wBAC7B,cAAc,GAAG,aAAa,CAAC;oBACjC,CAAC;oBAED,qDAAqD;oBACrD,aAAa,GAAG,eAAe,CAAC,MAAM,CACpC,CAAC,OAAY,EAAE,EAAE,CAAC,OAAO,CAAC,UAAU,KAAK,UAAU,CACpD,CAAC;oBAEF,iEAAiE;oBACjE,IAAI,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;wBAC7B,aAAa,GAAG,cAAc,CAAC;oBACjC,CAAC;oBAED,kDAAkD;oBAClD,mBAAmB,CAAC,aAAa,CAAC,CAAC;oBAEnC,uDAAuD;oBACvD,eAAe,GAAG,eAAe,CAAC,MAAM,CACtC,CAAC,OAAY,EAAE,EAAE,CAAC,OAAO,CAAC,UAAU,KAAK,UAAU,CACpD,CAAC;oBAEF,kDAAkD;oBAClD,qBAAqB,CAAC,eAAe,CAAC,CAAC;gBACzC,CAAC;YACH,CAAC;QACH,CAAC;QAAC,OAAO,KAAU,EAAE,CAAC;YACpB,6DAA6D;YAC7D,OAAO,CAAC,GAAG,CAAC,+BAA+B,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;YAC5D,eAAe;QACjB,CAAC;IACH,CAAC;uGAhEU,SAAS;2GAAT,SAAS,cAFR,MAAM;;2FAEP,SAAS;kBAHrB,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Stream, Participant } from '../@types/types';\nexport interface GetVideosOptions {\n  participants: Participant[];\n  allVideoStreams: (Stream | Participant)[];\n  oldAllStreams: (Stream | Participant)[];\n  adminVidID?: string;\n  updateAllVideoStreams: (streams: (Stream | Participant)[]) => void;\n  updateOldAllStreams: (streams: (Stream | Participant)[]) => void;\n}\n\n// Export the type definition for the function\nexport type GetVideosType = (options: GetVideosOptions) => Promise<void>;\n\n/**\n * Asynchronously processes and updates video streams by filtering out the admin's video stream.\n *\n * @param {GetVideosOptions} options - The options for getting videos.\n * @param {Participant[]} options.participants - The list of participants.\n * @param {Stream[]} options.allVideoStreams - The list of all video streams.\n * @param {(Stream | Participant)[]} options.oldAllStreams - The list of old video streams.\n * @param {string} [options.adminVidID] - The ID of the admin's video stream.\n * @param {Function} options.updateAllVideoStreams - Function to update the state variable for all video streams.\n * @param {Function} options.updateOldAllStreams - Function to update the state variable for old video streams.\n * @returns {Promise<void>} A promise that resolves when the video streams have been processed and updated.\n *\n * @throws {Error} If an error occurs during the process of updating video streams.\n *\n * @example\n * ```typescript\n * const options = {\n *   participants: participantList,\n *   allVideoStreams: currentVideoStreams,\n *   oldAllStreams: previousVideoStreams,\n *   updateAllVideoStreams: (streams) => {\n *     console.log('Updated all video streams:', streams);\n *   },\n *   updateOldAllStreams: (streams) => {\n *     console.log('Updated old video streams:', streams);\n *   },\n * };\n *\n * const getVideosService = new GetVideos();\n * await getVideosService.getVideos(options);\n * console.log('Video streams processed successfully.');\n * ```\n */\n\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class GetVideos {\n  /**\n   * Asynchronously processes and updates video streams by filtering out the admin's video stream.\n   *\n   * @param {GetVideosOptions} options - The options for getting videos.\n   * @param {Participant[]} options.participants - The list of participants.\n   * @param {Stream[]} options.allVideoStreams - The list of all video streams.\n   * @param {(Stream | Participant)[]} options.oldAllStreams - The list of old video streams.\n   * @param {string} options.adminVidID - The ID of the admin's video stream.\n   * @param {Function} options.updateAllVideoStreams - Function to update the state variable for all video streams.\n   * @param {Function} options.updateOldAllStreams - Function to update the state variable for old video streams.\n   * @returns {Promise<void>} A promise that resolves when the video streams have been processed and updated.\n   */\n\n  async getVideos({\n    participants,\n    allVideoStreams,\n    oldAllStreams,\n    adminVidID,\n    updateAllVideoStreams,\n    updateOldAllStreams,\n  }: GetVideosOptions): Promise<void> {\n    try {\n      // Filter out the admin's video stream and update state variables\n      let admin = participants.filter((participant: any) => participant.islevel === '2');\n\n      if (admin.length > 0) {\n        adminVidID = admin[0].videoID;\n\n        if (adminVidID != null && adminVidID !== '') {\n          let oldAllStreams_: any[] = [];\n\n          // Check if the length of oldAllStreams is greater than 0\n          if (oldAllStreams.length > 0) {\n            oldAllStreams_ = oldAllStreams;\n          }\n\n          // Filter out admin's video stream from oldAllStreams\n          oldAllStreams = allVideoStreams.filter(\n            (streame: any) => streame.producerId === adminVidID,\n          );\n\n          // If no admin's video stream found, revert to the previous state\n          if (oldAllStreams.length < 1) {\n            oldAllStreams = oldAllStreams_;\n          }\n\n          // Update the state variable for old video streams\n          updateOldAllStreams(oldAllStreams);\n\n          // Filter out admin's video stream from allVideoStreams\n          allVideoStreams = allVideoStreams.filter(\n            (streame: any) => streame.producerId !== adminVidID,\n          );\n\n          // Update the state variable for all video streams\n          updateAllVideoStreams(allVideoStreams);\n        }\n      }\n    } catch (error: any) {\n      // Handle errors during the process of updating video streams\n      console.log('Error updating video streams:', error.message);\n      // throw error;\n    }\n  }\n}\n"]}

package/dist/esm2022/lib/consumers/mix-streams.service.mjs

@@ -1,5 +1,27 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Mixes video and audio streams and participants based on specified parameters.
+ *
+ * @param {MixStreamsOptions} options - The options for mixing streams.
+ * @param {Array<Stream | Participant>} options.alVideoStreams - The list of audio and video streams to mix.
+ * @param {Array<Participant>} options.non_alVideoStreams - The list of non-audio and video streams to mix.
+ * @param {Array<Stream | Participant>} options.ref_participants - The list of reference participants to mix.
+ * @returns {Promise<Array<Stream | Participant>>} A promise that resolves with the mixed streams.
+ *
+ * @throws Will throw an error if there is an issue mixing the streams.
+ *
+ * @example
+ * ```typescript
+ * const mixedStreams = await mixStreams({
+ *   alVideoStreams: [stream1, stream2],
+ *   non_alVideoStreams: [participant1, participant2],
+ *   ref_participants: [participant1, participant2],
+ * });
+ *
+ * console.log('Mixed streams:', mixedStreams);
+ * ```
+ */
 export class MixStreams {
     /**
      * Mixes video and audio streams and participants based on specified parameters.
@@ -70,4 +92,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":"mix-streams.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/mix-streams.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAY3C;;;;;;;;;;;;;;;;;;;;;GAqBG;AAMH,MAAM,OAAO,UAAU;IACrB;;;;;;;;;;;;;;;;;;OAkBG;IAEH,KAAK,CAAC,UAAU,CAAC,EACf,cAAc,EACd,kBAAkB,EAClB,gBAAgB,GACE;QAClB,IAAI,CAAC;YACH,MAAM,YAAY,GAAU,EAAE,CAAC;YAC/B,MAAM,YAAY,GAAG,cAAc,CAAC,IAAI,CACtC,CAAC,GAAQ,EAAE,EAAE,CAAC,GAAG,CAAC,UAAU,KAAK,QAAQ,IAAI,GAAG,CAAC,UAAU,KAAK,WAAW,CAC5E,CAAC;YACF,cAAc,GAAG,cAAc,CAAC,MAAM,CACpC,CAAC,GAAQ,EAAE,EAAE,CAAC,GAAG,CAAC,UAAU,KAAK,QAAQ,IAAI,GAAG,CAAC,UAAU,KAAK,WAAW,CAC5E,CAAC;YAEF,MAAM,qBAAqB,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC,GAAQ,EAAE,EAAE;gBAC/D,MAAM,WAAW,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,GAAG,CAAC,UAAU,CAAC,CAAC;gBACpF,OAAO,CAAC,GAAG,CAAC,KAAK,IAAI,WAAW,IAAI,WAAW,CAAC,KAAK,KAAK,KAAK,CAAC;YAClE,CAAC,CAAC,CAAC;YAEH,MAAM,mBAAmB,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC,GAAQ,EAAE,EAAE;gBAC7D,MAAM,WAAW,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,GAAG,CAAC,UAAU,CAAC,CAAC;gBACpF,OAAO,GAAG,CAAC,KAAK,IAAI,CAAC,WAAW,IAAI,WAAW,CAAC,KAAK,KAAK,IAAI,CAAC,CAAC;YAClE,CAAC,CAAC,CAAC;YAEH,MAAM,iBAAiB,GAAG,kBAAkB,CAAC,KAAK,EAAE,CAAC,CAAC,sCAAsC;YAE5F,4CAA4C;YAC5C,YAAY,CAAC,IAAI,CAAC,GAAG,qBAAqB,CAAC,CAAC;YAE5C,2DAA2D;YAC3D,IAAI,UAAU,GAAG,CAAC,CAAC;YACnB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,mBAAmB,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gBACpD,IAAI,UAAU,GAAG,iBAAiB,CAAC,MAAM,EAAE,CAAC;oBAC1C,YAAY,CAAC,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAC,CAAC;oBACjD,UAAU,EAAE,CAAC;gBACf,CAAC;gBACD,YAAY,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAAC;YAC5C,CAAC;YAED,8CAA8C;YAC9C,KAAK,IAAI,CAAC,GAAG,UAAU,EAAE,CAAC,GAAG,iBAAiB,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC3D,YAAY,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC;YAC1C,CAAC;YAED,yDAAyD;YACzD,IAAI,YAAY,EAAE,CAAC;gBACjB,YAAY,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;YACrC,CAAC;YAED,OAAO,YAAY,CAAC;QACtB,CAAC;QAAC,OAAO,KAAU,EAAE,CAAC;YACpB,qDAAqD;YACrD,OAAO,CAAC,GAAG,CAAC,uBAAuB,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;YACpD,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;uGA5EU,UAAU;2GAAV,UAAU,cAFT,MAAM;;2FAEP,UAAU;kBAHtB,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Stream, Participant } from '../@types/types';\n\nexport interface MixStreamsOptions {\n  alVideoStreams: (Stream | Participant)[];\n  non_alVideoStreams: Participant[];\n  ref_participants: (Stream | Participant)[];\n}\n\n// Export the type definition for the function\nexport type MixStreamsType = (options: MixStreamsOptions) => Promise<(Stream | Participant)[]>;\n\n/**\n * Mixes video and audio streams and participants based on specified parameters.\n *\n * @param {MixStreamsOptions} options - The options for mixing streams.\n * @param {Array<Stream | Participant>} options.alVideoStreams - The list of audio and video streams to mix.\n * @param {Array<Participant>} options.non_alVideoStreams - The list of non-audio and video streams to mix.\n * @param {Array<Stream | Participant>} options.ref_participants - The list of reference participants to mix.\n * @returns {Promise<Array<Stream | Participant>>} A promise that resolves with the mixed streams.\n *\n * @throws Will throw an error if there is an issue mixing the streams.\n *\n * @example\n * ```typescript\n * const mixedStreams = await mixStreams({\n *   alVideoStreams: [stream1, stream2],\n *   non_alVideoStreams: [participant1, participant2],\n *   ref_participants: [participant1, participant2],\n * });\n *\n * console.log('Mixed streams:', mixedStreams);\n * ```\n */\n\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class MixStreams {\n  /**\n   * Mixes video and audio streams and participants based on specified parameters.\n   *\n   * @param {Object} options - The options for mixing streams.\n   * @param {Array} options.alVideoStreams - The list of audio and video streams to mix.\n   * @param {Array} options.non_alVideoStreams - The list of non-audio and video streams to mix.\n   * @param {Array} options.ref_participants - The list of reference participants to mix.\n   * @returns {Promise<Array>} A promise that resolves with the mixed streams.\n   * @throws Will throw an error if there is an issue mixing the streams.\n   * @example\n   * ```typescript\n   * mixStreams({\n   *   alVideoStreams: [stream1, stream2],\n   *  non_alVideoStreams: [participant1, participant2],\n   * ref_participants: [participant1, participant2]\n   * });\n   *\n   * ```\n   */\n\n  async mixStreams({\n    alVideoStreams,\n    non_alVideoStreams,\n    ref_participants,\n  }: MixStreamsOptions): Promise<(Stream | Participant)[]> {\n    try {\n      const mixedStreams: any[] = [];\n      const youyouStream = alVideoStreams.find(\n        (obj: any) => obj.producerId === 'youyou' || obj.producerId === 'youyouyou',\n      );\n      alVideoStreams = alVideoStreams.filter(\n        (obj: any) => obj.producerId !== 'youyou' && obj.producerId !== 'youyouyou',\n      );\n\n      const unmutedAlVideoStreams = alVideoStreams.filter((obj: any) => {\n        const participant = ref_participants.find((p: any) => p.videoID === obj.producerId);\n        return !obj.muted && participant && participant.muted === false;\n      });\n\n      const mutedAlVideoStreams = alVideoStreams.filter((obj: any) => {\n        const participant = ref_participants.find((p: any) => p.videoID === obj.producerId);\n        return obj.muted || (participant && participant.muted === true);\n      });\n\n      const nonAlVideoStreams = non_alVideoStreams.slice(); // Create a copy of non_alVideoStreams\n\n      // Add unmutedAlVideoStreams to mixedStreams\n      mixedStreams.push(...unmutedAlVideoStreams);\n\n      // Interleave the mutedAlVideoStreams and nonAlVideoStreams\n      let nonAlIndex = 0;\n      for (let i = 0; i < mutedAlVideoStreams.length; i++) {\n        if (nonAlIndex < nonAlVideoStreams.length) {\n          mixedStreams.push(nonAlVideoStreams[nonAlIndex]);\n          nonAlIndex++;\n        }\n        mixedStreams.push(mutedAlVideoStreams[i]);\n      }\n\n      // Handle remaining nonAlVideoStreams (if any)\n      for (let i = nonAlIndex; i < nonAlVideoStreams.length; i++) {\n        mixedStreams.push(nonAlVideoStreams[i]);\n      }\n\n      // Unshift 'youyou' or 'youyouyou' stream to mixedStreams\n      if (youyouStream) {\n        mixedStreams.unshift(youyouStream);\n      }\n\n      return mixedStreams;\n    } catch (error: any) {\n      // Handle errors during the process of mixing streams\n      console.log('Error mixing streams:', error.message);\n      throw error;\n    }\n  }\n}\n"]}

package/dist/esm2022/lib/consumers/on-screen-changes.service.mjs

@@ -1,5 +1,45 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Handles changes in screen events such as broadcast, chat, and conference.
+ *
+ * @param {OnScreenChangesOptions} options - The options for handling screen changes.
+ * @param {boolean} [options.changed=false] - Indicates if the screen has changed.
+ * @param {OnScreenChangesParameters} options.parameters - The parameters for handling screen changes.
+ * @param {string} options.parameters.eventType - The type of event (e.g., "broadcast", "chat", "conference").
+ * @param {boolean} options.parameters.shareScreenStarted - Indicates if screen sharing has started.
+ * @param {boolean} options.parameters.shared - Indicates if the screen is shared.
+ * @param {boolean} options.parameters.addForBasic - Flag to add basic controls.
+ * @param {Function} options.parameters.updateMainHeightWidth - Function to update the main height and width.
+ * @param {Function} options.parameters.updateAddForBasic - Function to update the addForBasic flag.
+ * @param {number} options.parameters.itemPageLimit - The limit for item pages.
+ * @param {Function} options.parameters.updateItemPageLimit - Function to update the item page limit.
+ * @param {Function} options.parameters.reorderStreams - Function to reorder streams.
+ *
+ * @returns {Promise<void>} A promise that resolves when the screen changes have been handled.
+ *
+ * @throws {Error} Throws an error if there is an issue handling screen changes.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   changed: true,
+ *   parameters: {
+ *     eventType: 'broadcast',
+ *     shareScreenStarted: false,
+ *     shared: false,
+ *     addForBasic: false,
+ *     updateMainHeightWidth: (value) => { console.log(updated) },
+ *     updateAddForBasic: (value) => { console.log(updated) },
+ *     itemPageLimit: 1,
+ *     updateItemPageLimit: (value) => { console.log(updated) },
+ *     reorderStreams: async (params) => { },
+ *   },
+ * };
+ *
+ * await onScreenChanges(options);
+ * ```
+ */
 export class OnScreenChanges {
     /**
      * Handles changes in screen events such as broadcast, chat, and conference.
@@ -60,4 +100,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":"on-screen-changes.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/on-screen-changes.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAyB3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAMH,MAAM,OAAO,eAAe;IAC1B;;;;;;;;;;;;;;;;;;;OAmBG;IACH,eAAe,GAAG,KAAK,EAAE,EACvB,OAAO,GAAG,KAAK,EACf,UAAU,GACa,EAAiB,EAAE;QAC1C,IAAI,CAAC;YACH,yBAAyB;YACzB,IAAI,EACF,SAAS,EACT,kBAAkB,EAClB,MAAM,EACN,WAAW,EACX,qBAAqB,EACrB,iBAAiB,EACjB,aAAa,EACb,mBAAmB;YAEnB,qBAAqB;YACrB,cAAc,GACf,GAAG,UAAU,CAAC;YAEf,0CAA0C;YAC1C,WAAW,GAAG,KAAK,CAAC;YACpB,iBAAiB,CAAC,WAAW,CAAC,CAAC;YAE/B,IAAI,SAAS,IAAI,WAAW,IAAI,SAAS,IAAI,MAAM,EAAE,CAAC;gBACpD,WAAW,GAAG,IAAI,CAAC;gBACnB,iBAAiB,CAAC,WAAW,CAAC,CAAC;gBAE/B,aAAa,GAAG,SAAS,IAAI,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBACjD,mBAAmB,CAAC,aAAa,CAAC,CAAC;gBACnC,qBAAqB,CAAC,SAAS,IAAI,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAC5D,CAAC;iBAAM,CAAC;gBACN,IAAI,SAAS,IAAI,YAAY,IAAI,CAAC,CAAC,kBAAkB,IAAI,MAAM,CAAC,EAAE,CAAC;oBACjE,qBAAqB,CAAC,CAAC,CAAC,CAAC;gBAC3B,CAAC;YACH,CAAC;YAED,6BAA6B;YAC7B,MAAM,cAAc,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC,CAAC;QAC3E,CAAC;QAAC,OAAO,KAAU,EAAE,CAAC;YACpB,8DAA8D;YAC9D,OAAO,CAAC,GAAG,CAAC,gCAAgC,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;YAC7D,eAAe;QACjB,CAAC;IACH,CAAC,CAAC;uGAjES,eAAe;2GAAf,eAAe,cAFd,MAAM;;2FAEP,eAAe;kBAH3B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { ReorderStreamsType, ReorderStreamsParameters, EventType } from '../@types/types';\nexport interface OnScreenChangesParameters extends ReorderStreamsParameters {\n  eventType: EventType;\n  shareScreenStarted: boolean;\n  shared: boolean;\n  addForBasic: boolean;\n  updateAddForBasic: (value: boolean) => void;\n  itemPageLimit: number;\n  updateItemPageLimit: (value: number) => void;\n  updateMainHeightWidth: (value: number) => void;\n\n  //mediasfu functions\n  reorderStreams: ReorderStreamsType;\n  [key: string]: any;\n}\n\nexport interface OnScreenChangesOptions {\n  changed?: boolean;\n  parameters: OnScreenChangesParameters;\n}\n\n// Export the type definition for the function\nexport type OnScreenChangesType = (options: OnScreenChangesOptions) => Promise<void>;\n\n/**\n * Handles changes in screen events such as broadcast, chat, and conference.\n *\n * @param {OnScreenChangesOptions} options - The options for handling screen changes.\n * @param {boolean} [options.changed=false] - Indicates if the screen has changed.\n * @param {OnScreenChangesParameters} options.parameters - The parameters for handling screen changes.\n * @param {string} options.parameters.eventType - The type of event (e.g., \"broadcast\", \"chat\", \"conference\").\n * @param {boolean} options.parameters.shareScreenStarted - Indicates if screen sharing has started.\n * @param {boolean} options.parameters.shared - Indicates if the screen is shared.\n * @param {boolean} options.parameters.addForBasic - Flag to add basic controls.\n * @param {Function} options.parameters.updateMainHeightWidth - Function to update the main height and width.\n * @param {Function} options.parameters.updateAddForBasic - Function to update the addForBasic flag.\n * @param {number} options.parameters.itemPageLimit - The limit for item pages.\n * @param {Function} options.parameters.updateItemPageLimit - Function to update the item page limit.\n * @param {Function} options.parameters.reorderStreams - Function to reorder streams.\n *\n * @returns {Promise<void>} A promise that resolves when the screen changes have been handled.\n *\n * @throws {Error} Throws an error if there is an issue handling screen changes.\n *\n * @example\n * ```typescript\n * const options = {\n *   changed: true,\n *   parameters: {\n *     eventType: 'broadcast',\n *     shareScreenStarted: false,\n *     shared: false,\n *     addForBasic: false,\n *     updateMainHeightWidth: (value) => { console.log(updated) },\n *     updateAddForBasic: (value) => { console.log(updated) },\n *     itemPageLimit: 1,\n *     updateItemPageLimit: (value) => { console.log(updated) },\n *     reorderStreams: async (params) => { },\n *   },\n * };\n *\n * await onScreenChanges(options);\n * ```\n */\n\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class OnScreenChanges {\n  /**\n   * Handles changes in screen events such as broadcast, chat, and conference.\n   *\n   * @param {OnScreenChangesOptions} options - The options for handling screen changes.\n   * @param {boolean} options.changed - Indicates if the screen has changed.\n   * @param {object} options.parameters - The parameters for handling screen changes.\n   * @param {string} options.parameters.eventType - The type of event (e.g., \"broadcast\", \"chat\", \"conference\").\n   * @param {boolean} options.parameters.shareScreenStarted - Indicates if screen sharing has started.\n   * @param {boolean} options.parameters.shared - Indicates if the screen is shared.\n   * @param {boolean} options.parameters.addForBasic - Flag to add basic controls.\n   * @param {function} options.parameters.updateMainHeightWidth - Function to update the main height and width.\n   * @param {function} options.parameters.updateAddForBasic - Function to update the addForBasic flag.\n   * @param {number} options.parameters.itemPageLimit - The limit for item pages.\n   * @param {function} options.parameters.updateItemPageLimit - Function to update the item page limit.\n   * @param {function} options.parameters.reorderStreams - Function to reorder streams.\n   *\n   * @returns {Promise<void>} A promise that resolves when the screen changes have been handled.\n   *\n   * @throws {Error} Throws an error if there is an issue handling screen changes.\n   */\n  onScreenChanges = async ({\n    changed = false,\n    parameters,\n  }: OnScreenChangesOptions): Promise<void> => {\n    try {\n      // Destructure parameters\n      let {\n        eventType,\n        shareScreenStarted,\n        shared,\n        addForBasic,\n        updateMainHeightWidth,\n        updateAddForBasic,\n        itemPageLimit,\n        updateItemPageLimit,\n\n        // mediasfu functions\n        reorderStreams,\n      } = parameters;\n\n      // Remove element with id 'controlButtons'\n      addForBasic = false;\n      updateAddForBasic(addForBasic);\n\n      if (eventType == 'broadcast' || eventType == 'chat') {\n        addForBasic = true;\n        updateAddForBasic(addForBasic);\n\n        itemPageLimit = eventType == 'broadcast' ? 1 : 2;\n        updateItemPageLimit(itemPageLimit);\n        updateMainHeightWidth(eventType == 'broadcast' ? 100 : 0);\n      } else {\n        if (eventType == 'conference' && !(shareScreenStarted || shared)) {\n          updateMainHeightWidth(0);\n        }\n      }\n\n      // Update the mini cards grid\n      await reorderStreams({ add: false, screenChanged: changed, parameters });\n    } catch (error: any) {\n      // Handle errors during the process of handling screen changes\n      console.log('Error handling screen changes:', error.message);\n      // throw error;\n    }\n  };\n}\n"]}