mediasfu-angular 1.0.0

package/dist/esm2022/lib/consumers/receive-room-messages.service.mjs

@@ -0,0 +1,42 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ReceiveRoomMessages {
+    /**
+     * Asynchronously retrieves and updates messages for a specified room from the server.
+     *
+     * @param {object} options - The function parameters.
+     * @param {object} options.parameters - Additional parameters needed for the function.
+     * @param {string} options.parameters.roomName - The name of the room to retrieve messages for.
+     * @param {function} options.parameters.updateMessages - Function to update the messages array.
+     */
+    async receiveRoomMessages({ socket, roomName, updateMessages, }) {
+        try {
+            // Retrieve messages from the server
+            await new Promise((resolve, reject) => {
+                socket.emit('getMessage', { roomName }, async ({ messages_ }) => {
+                    try {
+                        const updatedMessages = messages_;
+                        updateMessages(updatedMessages);
+                        resolve();
+                    }
+                    catch (err) {
+                        reject(err);
+                    }
+                });
+            });
+        }
+        catch (error) {
+            // Handle errors if any
+            console.log('Error tuning messages:', error.message);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ReceiveRoomMessages, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ReceiveRoomMessages, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ReceiveRoomMessages, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,181 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ReorderStreams {
+    /**
+     * Reorders the video streams based on the provided options and updates the UI accordingly.
+     *
+     * @param {Object} options - The options for reordering streams.
+     * @param {boolean} [options.add=false] - Whether to add new streams or not.
+     * @param {boolean} [options.screenChanged=false] - Whether the screen has changed or not.
+     * @param {ReorderStreamsOptions} options.parameters - The parameters required for reordering streams.
+     *
+     * @returns {Promise<void>} A promise that resolves when the reordering is complete.
+     *
+     * @typedef {Object} ReorderStreamsOptions
+     * @property {Function} getUpdatedAllParams - Function to get updated parameters.
+     * @property {Array} allVideoStreams - Array of all video streams.
+     * @property {Array} participants - Array of participants.
+     * @property {Array} oldAllStreams - Array of old streams.
+     * @property {string} screenId - ID of the screen.
+     * @property {string} adminVidID - ID of the admin video.
+     * @property {Array} newLimitedStreams - Array of new limited streams.
+     * @property {Array} newLimitedStreamsIDs - Array of new limited stream IDs.
+     * @property {Array} activeSounds - Array of active sounds.
+     * @property {string} screenShareIDStream - ID of the screen share stream.
+     * @property {string} screenShareNameStream - Name of the screen share stream.
+     * @property {string} adminIDStream - ID of the admin stream.
+     * @property {string} adminNameStream - Name of the admin stream.
+     * @property {Function} updateNewLimitedStreams - Function to update new limited streams.
+     * @property {Function} updateNewLimitedStreamsIDs - Function to update new limited stream IDs.
+     * @property {Function} updateActiveSounds - Function to update active sounds.
+     * @property {Function} updateScreenShareIDStream - Function to update screen share ID stream.
+     * @property {Function} updateScreenShareNameStream - Function to update screen share name stream.
+     * @property {Function} updateAdminIDStream - Function to update admin ID stream.
+     * @property {Function} updateAdminNameStream - Function to update admin name stream.
+     * @property {Function} updateYouYouStream - Function to update YouYou stream.
+     * @property {Function} changeVids - Function to reflect changes on the UI.
+     */
+    reorderStreams = async ({ add = false, screenChanged = false, parameters, }) => {
+        let { getUpdatedAllParams } = parameters;
+        parameters = getUpdatedAllParams();
+        let { allVideoStreams, participants, oldAllStreams, screenId, adminVidID, newLimitedStreams, newLimitedStreamsIDs, activeSounds, screenShareIDStream, screenShareNameStream, adminIDStream, adminNameStream, updateNewLimitedStreams, updateNewLimitedStreamsIDs, updateActiveSounds, updateScreenShareIDStream, updateScreenShareNameStream, updateAdminIDStream, updateAdminNameStream, updateYouYouStream, 
+        //mediasfu functions
+        changeVids, } = parameters;
+        // function to reorder streams on the ui
+        if (!add) {
+            newLimitedStreams = [];
+            newLimitedStreamsIDs = [];
+            activeSounds = [];
+        }
+        const youyou = allVideoStreams.filter((stream) => stream.producerId === 'youyou');
+        const admin = participants.filter((participant) => participant.islevel === '2');
+        if (admin.length > 0) {
+            adminVidID = admin[0].videoID;
+        }
+        else {
+            adminVidID = '';
+        }
+        if (adminVidID) {
+            const adminStream = allVideoStreams.find((stream) => stream.producerId === adminVidID);
+            if (!add) {
+                newLimitedStreams = [...newLimitedStreams, ...youyou];
+                newLimitedStreamsIDs = [
+                    ...newLimitedStreamsIDs,
+                    ...youyou.map((stream) => stream.producerId),
+                ];
+            }
+            else {
+                const youyouStream = newLimitedStreams.find((stream) => stream.producerId === 'youyou');
+                if (!youyouStream) {
+                    newLimitedStreams = [...newLimitedStreams, ...youyou];
+                    newLimitedStreamsIDs = [
+                        ...newLimitedStreamsIDs,
+                        ...youyou.map((stream) => stream.producerId),
+                    ];
+                }
+            }
+            if (adminStream) {
+                adminIDStream = adminVidID;
+                if (!add) {
+                    newLimitedStreams = [...newLimitedStreams, adminStream];
+                    newLimitedStreamsIDs = [...newLimitedStreamsIDs, adminStream.producerId];
+                }
+                else {
+                    const adminStreamer = newLimitedStreams.find((stream) => stream.producerId === adminVidID);
+                    if (!adminStreamer) {
+                        newLimitedStreams = [...newLimitedStreams, adminStream];
+                        newLimitedStreamsIDs = [...newLimitedStreamsIDs, adminStream.producerId];
+                    }
+                }
+            }
+            else {
+                const oldAdminStream = oldAllStreams.find((stream) => stream.producerId === adminVidID);
+                if (oldAdminStream) {
+                    //add it to the allVideoStream
+                    adminIDStream = adminVidID;
+                    adminNameStream = admin[0].name;
+                    if (!add) {
+                        newLimitedStreams = [...newLimitedStreams, oldAdminStream];
+                        newLimitedStreamsIDs = [...newLimitedStreamsIDs, oldAdminStream.producerId];
+                    }
+                    else {
+                        const adminStreamer = newLimitedStreams.find((stream) => stream.producerId === adminVidID);
+                        if (!adminStreamer) {
+                            newLimitedStreams = [...newLimitedStreams, oldAdminStream];
+                            newLimitedStreamsIDs = [...newLimitedStreamsIDs, oldAdminStream.producerId];
+                        }
+                    }
+                }
+            }
+            const screenParticipant = participants.filter((participant) => participant.ScreenID === screenId);
+            if (screenParticipant.length > 0) {
+                const screenParticipantVidID = screenParticipant[0].videoID;
+                const screenParticipantVidID_ = newLimitedStreams.filter((stream) => stream.producerId === screenParticipantVidID);
+                if (screenParticipantVidID_?.length < 1 && screenParticipantVidID) {
+                    screenShareIDStream = screenParticipantVidID;
+                    screenShareNameStream = screenParticipant[0].name;
+                    const screenParticipantVidID__ = allVideoStreams.filter((stream) => stream.producerId === screenParticipantVidID);
+                    newLimitedStreams = [...newLimitedStreams, ...screenParticipantVidID__];
+                    newLimitedStreamsIDs = [
+                        ...newLimitedStreamsIDs,
+                        ...screenParticipantVidID__.map((stream) => stream.producerId),
+                    ];
+                }
+            }
+        }
+        else {
+            if (!add) {
+                newLimitedStreams = [...newLimitedStreams, ...youyou];
+                newLimitedStreamsIDs = [
+                    ...newLimitedStreamsIDs,
+                    ...youyou.map((stream) => stream.producerId),
+                ];
+            }
+            else {
+                const youyouStream = newLimitedStreams.find((stream) => stream.producerId === 'youyou');
+                if (!youyouStream) {
+                    newLimitedStreams = [...newLimitedStreams, ...youyou];
+                    newLimitedStreamsIDs = [
+                        ...newLimitedStreamsIDs,
+                        ...youyou.map((stream) => stream.producerId),
+                    ];
+                }
+            }
+            const screenParticipant = participants.filter((participant) => participant.ScreenID === screenId);
+            if (screenParticipant.length > 0) {
+                const screenParticipantVidID = screenParticipant[0].videoID;
+                const screenParticipantVidID_ = newLimitedStreams.filter((stream) => stream.producerId === screenParticipantVidID);
+                if (screenParticipantVidID_?.length < 1 && screenParticipantVidID) {
+                    screenShareIDStream = screenParticipantVidID;
+                    screenShareNameStream = screenParticipant[0].name;
+                    const screenParticipantVidID__ = allVideoStreams.filter((stream) => stream.producerId === screenParticipantVidID);
+                    newLimitedStreams = [...newLimitedStreams, ...screenParticipantVidID__];
+                    newLimitedStreamsIDs = [
+                        ...newLimitedStreamsIDs,
+                        ...screenParticipantVidID__.map((stream) => stream.producerId),
+                    ];
+                }
+            }
+        }
+        updateNewLimitedStreams(newLimitedStreams);
+        updateNewLimitedStreamsIDs(newLimitedStreamsIDs);
+        updateActiveSounds(activeSounds);
+        updateScreenShareIDStream(screenShareIDStream);
+        updateScreenShareNameStream(screenShareNameStream);
+        updateAdminIDStream(adminIDStream);
+        updateAdminNameStream(adminNameStream);
+        updateYouYouStream(youyou);
+        //reflect the changes on the ui
+        await changeVids({ screenChanged, parameters });
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ReorderStreams, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ReorderStreams, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ReorderStreams, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"reorder-streams.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/reorder-streams.service.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-non-null-assertion */\nimport { Injectable } from '@angular/core';\nimport { Participant, Stream, ChangeVidsParameters, ChangeVidsType } from '../@types/types';\n\nexport interface ReorderStreamsParameters extends ChangeVidsParameters {\n  allVideoStreams: (Stream | Participant)[];\n  participants: Participant[];\n  oldAllStreams: (Stream | Participant)[];\n  screenId?: string;\n  adminVidID?: string;\n  newLimitedStreams: (Stream | Participant)[];\n  newLimitedStreamsIDs: string[];\n  activeSounds: string[];\n  screenShareIDStream?: string;\n  screenShareNameStream?: string;\n  adminIDStream?: string;\n  adminNameStream?: string;\n  updateNewLimitedStreams: (streams: (Stream | Participant)[]) => void;\n  updateNewLimitedStreamsIDs: (ids: string[]) => void;\n  updateActiveSounds: (sounds: string[]) => void;\n  updateScreenShareIDStream: (id: string) => void;\n  updateScreenShareNameStream: (name: string) => void;\n  updateAdminIDStream: (id: string) => void;\n  updateAdminNameStream: (name: string) => void;\n  updateYouYouStream: (streams: (Stream | Participant)[]) => void;\n\n  // mediasfu functions\n  changeVids: ChangeVidsType;\n  getUpdatedAllParams: () => ReorderStreamsParameters;\n  [key: string]: any;\n}\n\nexport interface ReorderStreamsOptions {\n  add?: boolean;\n  screenChanged?: boolean;\n  parameters: ReorderStreamsParameters;\n}\n\nexport type ReorderStreamsType = (options: ReorderStreamsOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ReorderStreams {\n  /**\n   * Reorders the video streams based on the provided options and updates the UI accordingly.\n   *\n   * @param {Object} options - The options for reordering streams.\n   * @param {boolean} [options.add=false] - Whether to add new streams or not.\n   * @param {boolean} [options.screenChanged=false] - Whether the screen has changed or not.\n   * @param {ReorderStreamsOptions} options.parameters - The parameters required for reordering streams.\n   *\n   * @returns {Promise<void>} A promise that resolves when the reordering is complete.\n   *\n   * @typedef {Object} ReorderStreamsOptions\n   * @property {Function} getUpdatedAllParams - Function to get updated parameters.\n   * @property {Array} allVideoStreams - Array of all video streams.\n   * @property {Array} participants - Array of participants.\n   * @property {Array} oldAllStreams - Array of old streams.\n   * @property {string} screenId - ID of the screen.\n   * @property {string} adminVidID - ID of the admin video.\n   * @property {Array} newLimitedStreams - Array of new limited streams.\n   * @property {Array} newLimitedStreamsIDs - Array of new limited stream IDs.\n   * @property {Array} activeSounds - Array of active sounds.\n   * @property {string} screenShareIDStream - ID of the screen share stream.\n   * @property {string} screenShareNameStream - Name of the screen share stream.\n   * @property {string} adminIDStream - ID of the admin stream.\n   * @property {string} adminNameStream - Name of the admin stream.\n   * @property {Function} updateNewLimitedStreams - Function to update new limited streams.\n   * @property {Function} updateNewLimitedStreamsIDs - Function to update new limited stream IDs.\n   * @property {Function} updateActiveSounds - Function to update active sounds.\n   * @property {Function} updateScreenShareIDStream - Function to update screen share ID stream.\n   * @property {Function} updateScreenShareNameStream - Function to update screen share name stream.\n   * @property {Function} updateAdminIDStream - Function to update admin ID stream.\n   * @property {Function} updateAdminNameStream - Function to update admin name stream.\n   * @property {Function} updateYouYouStream - Function to update YouYou stream.\n   * @property {Function} changeVids - Function to reflect changes on the UI.\n   */\n\n  reorderStreams = async ({\n    add = false,\n    screenChanged = false,\n    parameters,\n  }: ReorderStreamsOptions): Promise<void> => {\n    let { getUpdatedAllParams } = parameters;\n    parameters = getUpdatedAllParams();\n\n    let {\n      allVideoStreams,\n      participants,\n      oldAllStreams,\n      screenId,\n      adminVidID,\n      newLimitedStreams,\n      newLimitedStreamsIDs,\n      activeSounds,\n      screenShareIDStream,\n      screenShareNameStream,\n      adminIDStream,\n      adminNameStream,\n      updateNewLimitedStreams,\n      updateNewLimitedStreamsIDs,\n      updateActiveSounds,\n      updateScreenShareIDStream,\n      updateScreenShareNameStream,\n      updateAdminIDStream,\n      updateAdminNameStream,\n      updateYouYouStream,\n\n      //mediasfu functions\n      changeVids,\n    } = parameters;\n\n    // function to reorder streams on the ui\n    if (!add) {\n      newLimitedStreams = [];\n      newLimitedStreamsIDs = [];\n      activeSounds = [];\n    }\n\n    const youyou = allVideoStreams.filter((stream) => stream.producerId === 'youyou');\n    const admin = participants.filter((participant) => participant.islevel === '2');\n\n    if (admin.length > 0) {\n      adminVidID = admin[0].videoID;\n    } else {\n      adminVidID = '';\n    }\n\n    if (adminVidID) {\n      const adminStream = allVideoStreams.find((stream) => stream.producerId === adminVidID);\n\n      if (!add) {\n        newLimitedStreams = [...newLimitedStreams, ...youyou];\n        newLimitedStreamsIDs = [\n          ...newLimitedStreamsIDs,\n          ...youyou.map((stream) => stream.producerId),\n        ];\n      } else {\n        const youyouStream = newLimitedStreams.find((stream) => stream.producerId === 'youyou');\n\n        if (!youyouStream) {\n          newLimitedStreams = [...newLimitedStreams, ...youyou];\n          newLimitedStreamsIDs = [\n            ...newLimitedStreamsIDs,\n            ...youyou.map((stream) => stream.producerId),\n          ];\n        }\n      }\n\n      if (adminStream) {\n        adminIDStream = adminVidID;\n\n        if (!add) {\n          newLimitedStreams = [...newLimitedStreams, adminStream];\n          newLimitedStreamsIDs = [...newLimitedStreamsIDs, adminStream.producerId];\n        } else {\n          const adminStreamer = newLimitedStreams.find(\n            (stream) => stream.producerId === adminVidID,\n          );\n\n          if (!adminStreamer) {\n            newLimitedStreams = [...newLimitedStreams, adminStream];\n            newLimitedStreamsIDs = [...newLimitedStreamsIDs, adminStream.producerId];\n          }\n        }\n      } else {\n        const oldAdminStream = oldAllStreams.find((stream) => stream.producerId === adminVidID);\n\n        if (oldAdminStream) {\n          //add it to the allVideoStream\n\n          adminIDStream = adminVidID;\n          adminNameStream = admin[0].name;\n\n          if (!add) {\n            newLimitedStreams = [...newLimitedStreams, oldAdminStream];\n            newLimitedStreamsIDs = [...newLimitedStreamsIDs, oldAdminStream.producerId];\n          } else {\n            const adminStreamer = newLimitedStreams.find(\n              (stream) => stream.producerId === adminVidID,\n            );\n\n            if (!adminStreamer) {\n              newLimitedStreams = [...newLimitedStreams, oldAdminStream];\n              newLimitedStreamsIDs = [...newLimitedStreamsIDs, oldAdminStream.producerId];\n            }\n          }\n        }\n      }\n\n      const screenParticipant = participants.filter(\n        (participant) => participant.ScreenID === screenId,\n      );\n\n      if (screenParticipant.length > 0) {\n        const screenParticipantVidID = screenParticipant[0].videoID;\n        const screenParticipantVidID_ = newLimitedStreams.filter(\n          (stream) => stream.producerId === screenParticipantVidID,\n        );\n\n        if (screenParticipantVidID_?.length < 1 && screenParticipantVidID) {\n          screenShareIDStream = screenParticipantVidID;\n          screenShareNameStream = screenParticipant[0].name;\n          const screenParticipantVidID__ = allVideoStreams.filter(\n            (stream) => stream.producerId === screenParticipantVidID,\n          );\n          newLimitedStreams = [...newLimitedStreams, ...screenParticipantVidID__];\n          newLimitedStreamsIDs = [\n            ...newLimitedStreamsIDs,\n            ...screenParticipantVidID__.map((stream) => stream.producerId),\n          ];\n        }\n      }\n    } else {\n      if (!add) {\n        newLimitedStreams = [...newLimitedStreams, ...youyou];\n        newLimitedStreamsIDs = [\n          ...newLimitedStreamsIDs,\n          ...youyou.map((stream) => stream.producerId),\n        ];\n      } else {\n        const youyouStream = newLimitedStreams.find((stream) => stream.producerId === 'youyou');\n\n        if (!youyouStream) {\n          newLimitedStreams = [...newLimitedStreams, ...youyou];\n          newLimitedStreamsIDs = [\n            ...newLimitedStreamsIDs,\n            ...youyou.map((stream) => stream.producerId),\n          ];\n        }\n      }\n\n      const screenParticipant = participants.filter(\n        (participant) => participant.ScreenID === screenId,\n      );\n\n      if (screenParticipant.length > 0) {\n        const screenParticipantVidID = screenParticipant[0].videoID;\n        const screenParticipantVidID_ = newLimitedStreams.filter(\n          (stream) => stream.producerId === screenParticipantVidID,\n        );\n\n        if (screenParticipantVidID_?.length < 1 && screenParticipantVidID) {\n          screenShareIDStream = screenParticipantVidID;\n          screenShareNameStream = screenParticipant[0].name;\n          const screenParticipantVidID__ = allVideoStreams.filter(\n            (stream) => stream.producerId === screenParticipantVidID,\n          );\n          newLimitedStreams = [...newLimitedStreams, ...screenParticipantVidID__];\n          newLimitedStreamsIDs = [\n            ...newLimitedStreamsIDs,\n            ...screenParticipantVidID__.map((stream) => stream.producerId),\n          ];\n        }\n      }\n    }\n\n    updateNewLimitedStreams(newLimitedStreams);\n    updateNewLimitedStreamsIDs(newLimitedStreamsIDs);\n    updateActiveSounds(activeSounds);\n    updateScreenShareIDStream(screenShareIDStream!);\n    updateScreenShareNameStream(screenShareNameStream!);\n    updateAdminIDStream(adminIDStream!);\n    updateAdminNameStream(adminNameStream!);\n    updateYouYouStream(youyou);\n\n    //reflect the changes on the ui\n    await changeVids({ screenChanged, parameters });\n  };\n}\n"]}

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

@@ -0,0 +1,67 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class RequestScreenShare {
+    /**
+     * Requests to start screen sharing.
+     *
+     * @param {RequestScreenShareOptions} options - The options for requesting screen share.
+     * @param {Object} options.parameters - The parameters for the screen share request.
+     * @param {Socket} options.parameters.socket - The socket instance to communicate with the server.
+     * @param {Function} [options.parameters.showAlert] - Optional function to show alerts to the user.
+     * @param {boolean} options.parameters.localUIMode - Indicates if the user is in local UI mode.
+     * @param {string} [options.parameters.targetResolution] - The target resolution for screen sharing.
+     * @param {string} [options.parameters.targetResolutionHost] - The target resolution for the host screen.
+     * @param {Function} options.parameters.startShareScreen - Function to start screen sharing.
+     *
+     * @returns {Promise<void>} A promise that resolves when the screen share request is processed.
+     *
+     * @throws {Error} Throws an error if there is an issue during the screen share request process.
+     */
+    requestScreenShare = async ({ parameters }) => {
+        try {
+            // Destructure parameters
+            const { showAlert, localUIMode, startShareScreen, socket, targetResolution = 'hd', targetResolutionHost = 'hd', } = parameters;
+            // Check if the user is in local UI mode
+            if (localUIMode === true) {
+                await startShareScreen({ parameters });
+                return;
+            }
+            let targetWidth = 1280;
+            let targetHeight = 720;
+            if (targetResolution == 'qhd' || targetResolutionHost == 'qhd') {
+                targetWidth = 2560;
+                targetHeight = 1440;
+            }
+            else if (targetResolution == 'fhd' || targetResolutionHost == 'fhd') {
+                targetWidth = 1920;
+                targetHeight = 1080;
+            }
+            socket.emit('requestScreenShare', async ({ allowScreenShare }) => {
+                if (!allowScreenShare) {
+                    // Send an alert to the user
+                    showAlert?.({
+                        message: 'You are not allowed to share screen',
+                        type: 'danger',
+                        duration: 3000,
+                    });
+                }
+                else {
+                    await startShareScreen({ parameters: { ...parameters, targetWidth, targetHeight } });
+                }
+            });
+        }
+        catch (error) {
+            // Handle errors during the process of requesting screen share
+            console.error('Error during requesting screen share: ', error);
+        }
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: RequestScreenShare, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: RequestScreenShare, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: RequestScreenShare, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/consumers/resume-pause-audio-streams.service.mjs

@@ -0,0 +1,99 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ResumePauseAudioStreams {
+    /**
+     * Resumes or pauses audio streams based on the provided options.
+     *
+     * @param {ResumePauseAudioStreamsOptions} options - The options for resuming or pausing audio streams.
+     * @param {number} [options.breakRoom=-1] - The ID of the break room.
+     * @param {boolean} [options.inBreakRoom=false] - Indicates if the participant is in a break room.
+     * @param {Parameters} options.parameters - The parameters required for processing audio streams.
+     *
+     * @returns {Promise<void>} A promise that resolves when the audio streams have been processed.
+     *
+     * @throws Will log an error message if there is an issue processing the audio streams.
+     */
+    resumePauseAudioStreams = async ({ breakRoom = -1, inBreakRoom = false, parameters, }) => {
+        let { getUpdatedAllParams } = parameters;
+        parameters = getUpdatedAllParams();
+        let { breakoutRooms, ref_participants, allAudioStreams, participants, islevel, eventType, consumerTransports, hostNewRoom, member, updateLimitedBreakRoom, processConsumerTransportsAudio, } = parameters;
+        let room = [];
+        let currentStreams = [];
+        // Determine the room based on breakout status
+        if (inBreakRoom && breakRoom !== -1) {
+            room = breakoutRooms[breakRoom];
+        }
+        else {
+            room = ref_participants.filter((participant) => !breakoutRooms
+                .flat()
+                .map((obj) => obj.name)
+                .includes(participant.name));
+        }
+        updateLimitedBreakRoom(room);
+        try {
+            let addHostAudio = false;
+            if (islevel !== '2' && eventType === 'conference') {
+                const roomMember = breakoutRooms.find((r) => r.find((p) => p.name === member));
+                let memberBreakRoom = -1;
+                if (roomMember) {
+                    memberBreakRoom = breakoutRooms.indexOf(roomMember);
+                }
+                if ((inBreakRoom && breakRoom !== hostNewRoom) ||
+                    (!inBreakRoom && hostNewRoom !== -1 && hostNewRoom !== memberBreakRoom)) {
+                    const host = participants.find((obj) => obj.islevel === '2');
+                    // Remove the host from the room
+                    room = room.filter((participant) => participant.name !== host?.name);
+                }
+                else {
+                    if ((inBreakRoom && breakRoom === hostNewRoom) ||
+                        (!inBreakRoom && hostNewRoom === -1) ||
+                        (!inBreakRoom && hostNewRoom === memberBreakRoom && memberBreakRoom !== -1)) {
+                        addHostAudio = true;
+                    }
+                }
+            }
+            for (let participant of room) {
+                let streams = allAudioStreams.filter((stream) => {
+                    if ((Object.prototype.hasOwnProperty.call(stream, 'producerId') && stream.producerId) ||
+                        (Object.prototype.hasOwnProperty.call(stream, 'audioID') && stream.audioID)) {
+                        let producerId = stream.producerId || stream.audioID;
+                        let matchingParticipant = ref_participants.find((obj) => obj.audioID == producerId);
+                        return matchingParticipant && matchingParticipant.name == participant.name;
+                    }
+                    // Return false if the stream doesn't meet the criteria
+                    return false;
+                });
+                currentStreams.push(...streams);
+            }
+            // If webinar, add the host audio stream if it is not in the currentStreams
+            if (islevel !== '2' && (eventType === 'webinar' || addHostAudio)) {
+                const host = participants.find((obj) => obj.islevel === '2');
+                const hostStream = allAudioStreams.find((obj) => obj.producerId === host?.audioID);
+                if (hostStream && !currentStreams.includes(hostStream)) {
+                    currentStreams.push(hostStream);
+                    if (host?.name && !room.map((obj) => obj.name).includes(host.name)) {
+                        room.push({ name: host?.name || '', breakRoom: -1 });
+                    }
+                    updateLimitedBreakRoom(room);
+                }
+            }
+            await processConsumerTransportsAudio({
+                consumerTransports,
+                lStreams: currentStreams,
+                parameters,
+            });
+        }
+        catch (error) {
+            console.log('Error in resumePauseAudioStreams:', error);
+        }
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ResumePauseAudioStreams, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ResumePauseAudioStreams, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ResumePauseAudioStreams, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resume-pause-audio-streams.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/resume-pause-audio-streams.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  Participant,\n  Stream,\n  ProcessConsumerTransportsAudioType,\n  ProcessConsumerTransportsAudioParameters,\n  Transport,\n  BreakoutParticipant,\n  EventType,\n} from '../@types/types';\n\nexport interface ResumePauseAudioStreamsParameters\n  extends ProcessConsumerTransportsAudioParameters {\n  breakoutRooms: BreakoutParticipant[][];\n  ref_participants: Participant[];\n  allAudioStreams: (Stream | Participant)[];\n  participants: Participant[];\n  islevel: string;\n  eventType: EventType;\n  consumerTransports: Transport[];\n  limitedBreakRoom: BreakoutParticipant[];\n  hostNewRoom: number;\n  member: string;\n  updateLimitedBreakRoom: (limitedBreakRoom: BreakoutParticipant[]) => void;\n\n  // mediasfu functions\n  processConsumerTransportsAudio: ProcessConsumerTransportsAudioType;\n  getUpdatedAllParams: () => ResumePauseAudioStreamsParameters;\n  [key: string]: any;\n}\n\nexport interface ResumePauseAudioStreamsOptions {\n  breakRoom?: number;\n  inBreakRoom?: boolean;\n  parameters: ResumePauseAudioStreamsParameters;\n}\n\n// Export the type definition for the function\nexport type ResumePauseAudioStreamsType = (\n  options: ResumePauseAudioStreamsOptions,\n) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ResumePauseAudioStreams {\n  /**\n   * Resumes or pauses audio streams based on the provided options.\n   *\n   * @param {ResumePauseAudioStreamsOptions} options - The options for resuming or pausing audio streams.\n   * @param {number} [options.breakRoom=-1] - The ID of the break room.\n   * @param {boolean} [options.inBreakRoom=false] - Indicates if the participant is in a break room.\n   * @param {Parameters} options.parameters - The parameters required for processing audio streams.\n   *\n   * @returns {Promise<void>} A promise that resolves when the audio streams have been processed.\n   *\n   * @throws Will log an error message if there is an issue processing the audio streams.\n   */\n\n  resumePauseAudioStreams = async ({\n    breakRoom = -1,\n    inBreakRoom = false,\n    parameters,\n  }: ResumePauseAudioStreamsOptions): Promise<void> => {\n    let { getUpdatedAllParams } = parameters;\n    parameters = getUpdatedAllParams();\n\n    let {\n      breakoutRooms,\n      ref_participants,\n      allAudioStreams,\n      participants,\n      islevel,\n      eventType,\n      consumerTransports,\n      hostNewRoom,\n      member,\n\n      updateLimitedBreakRoom,\n      processConsumerTransportsAudio,\n    } = parameters;\n\n    let room: BreakoutParticipant[] = [];\n    let currentStreams: (Stream | Participant)[] = [];\n    // Determine the room based on breakout status\n    if (inBreakRoom && breakRoom !== -1) {\n      room = breakoutRooms[breakRoom];\n    } else {\n      room = ref_participants.filter(\n        (participant) =>\n          !breakoutRooms\n            .flat()\n            .map((obj) => obj.name)\n            .includes(participant.name),\n      );\n    }\n\n    updateLimitedBreakRoom(room);\n\n    try {\n      let addHostAudio = false;\n\n      if (islevel !== '2' && eventType === 'conference') {\n        const roomMember = breakoutRooms.find((r) => r.find((p) => p.name === member));\n        let memberBreakRoom = -1;\n        if (roomMember) {\n          memberBreakRoom = breakoutRooms.indexOf(roomMember);\n        }\n\n        if (\n          (inBreakRoom && breakRoom !== hostNewRoom) ||\n          (!inBreakRoom && hostNewRoom !== -1 && hostNewRoom !== memberBreakRoom)\n        ) {\n          const host = participants.find((obj) => obj.islevel === '2');\n          // Remove the host from the room\n          room = room.filter((participant) => participant.name !== host?.name);\n        } else {\n          if (\n            (inBreakRoom && breakRoom === hostNewRoom) ||\n            (!inBreakRoom && hostNewRoom === -1) ||\n            (!inBreakRoom && hostNewRoom === memberBreakRoom && memberBreakRoom !== -1)\n          ) {\n            addHostAudio = true;\n          }\n        }\n      }\n\n      for (let participant of room) {\n        let streams = allAudioStreams.filter((stream) => {\n          if (\n            (Object.prototype.hasOwnProperty.call(stream, 'producerId') && stream.producerId) ||\n            (Object.prototype.hasOwnProperty.call(stream, 'audioID') && stream.audioID)\n          ) {\n            let producerId = stream.producerId || stream.audioID;\n            let matchingParticipant = ref_participants.find((obj) => obj.audioID == producerId);\n            return matchingParticipant && matchingParticipant.name == participant.name;\n          }\n          // Return false if the stream doesn't meet the criteria\n          return false;\n        });\n\n        currentStreams.push(...streams);\n      }\n\n      // If webinar, add the host audio stream if it is not in the currentStreams\n      if (islevel !== '2' && (eventType === 'webinar' || addHostAudio)) {\n        const host = participants.find((obj) => obj.islevel === '2');\n        const hostStream = allAudioStreams.find((obj) => obj.producerId === host?.audioID);\n        if (hostStream && !currentStreams.includes(hostStream)) {\n          currentStreams.push(hostStream);\n          if (host?.name && !room.map((obj) => obj.name).includes(host.name)) {\n            room.push({ name: host?.name || '', breakRoom: -1 });\n          }\n          updateLimitedBreakRoom(room);\n        }\n      }\n\n      await processConsumerTransportsAudio({\n        consumerTransports,\n        lStreams: currentStreams,\n        parameters,\n      });\n    } catch (error) {\n      console.log('Error in resumePauseAudioStreams:', error);\n    }\n  };\n}\n"]}

package/dist/esm2022/lib/consumers/resume-pause-streams.service.mjs

@@ -0,0 +1,70 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ResumePauseStreams {
+    /**
+     * Resumes or pauses streams based on the provided parameters.
+     *
+     * @param {ResumePauseStreamsOptions} options - The options for resuming or pausing streams.
+     * @param {Object} options.parameters - The parameters for the function.
+     * @param {Array} options.parameters.participants - The list of participants.
+     * @param {Array} options.parameters.dispActiveNames - The list of active display names.
+     * @param {Array} options.parameters.consumerTransports - The list of consumer transports.
+     * @param {string} options.parameters.screenId - The screen producer ID.
+     * @param {string} options.parameters.islevel - The level of the user.
+     *
+     * @returns {Promise<void>} A promise that resolves when the streams have been resumed or paused.
+     *
+     * @throws Will throw an error if there is an issue during the process of resuming or pausing streams.
+     */
+    resumePauseStreams = async ({ parameters }) => {
+        try {
+            // Destructure parameters
+            parameters = parameters.getUpdatedAllParams();
+            let { participants, dispActiveNames, consumerTransports, screenId, islevel } = parameters;
+            // Get the videoID of the host (islevel=2)
+            let host = participants.find((obj) => obj.islevel === '2');
+            let hostVideoID = host ? host.videoID : null;
+            // Get videoIDs of participants in dispActiveNames and screenproducerId
+            let videosIDs = dispActiveNames.map((name) => {
+                let participant = participants.find((obj) => obj.name === name);
+                return participant ? participant.videoID : null;
+            });
+            // Add screenproducerId to allVideoIDs if it's not null or empty
+            if (screenId) {
+                videosIDs.push(screenId);
+            }
+            // Add hostVideoID to allVideoIDs if it's not null or empty (only if the user is not the host)
+            if (islevel !== '2' && hostVideoID) {
+                videosIDs.push(hostVideoID);
+            }
+            // Remove null or empty videoIDs
+            let allVideoIDs = videosIDs.filter((videoID) => videoID !== null && videoID !== '');
+            if (allVideoIDs.length > 0) {
+                // Get consumer transports with producerId in allVideoIDs
+                const consumerTransportsToResume = consumerTransports.filter((transport) => allVideoIDs.includes(transport.producerId) && transport.consumer.kind !== 'audio');
+                // Resume all consumerTransportsToResume
+                for (const transport of consumerTransportsToResume) {
+                    transport.socket_.emit('consumer-resume', { serverConsumerId: transport.serverConsumerTransportId }, async ({ resumed }) => {
+                        if (resumed) {
+                            transport.consumer.resume();
+                        }
+                    });
+                }
+            }
+        }
+        catch (error) {
+            console.log('Error during resuming or pausing streams: ', error);
+            // Handle errors during the process of resuming or pausing streams
+            // throw new Error(`Error during resuming or pausing streams: ${error.message}`);
+        }
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ResumePauseStreams, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ResumePauseStreams, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ResumePauseStreams, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resume-pause-streams.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/resume-pause-streams.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AA0B3C,MAAM,OAAO,kBAAkB;IAC7B;;;;;;;;;;;;;;OAcG;IACH,kBAAkB,GAAG,KAAK,EAAE,EAAE,UAAU,EAA6B,EAAiB,EAAE;QACtF,IAAI,CAAC;YACH,yBAAyB;YACzB,UAAU,GAAG,UAAU,CAAC,mBAAmB,EAAE,CAAC;YAC9C,IAAI,EAAE,YAAY,EAAE,eAAe,EAAE,kBAAkB,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,UAAU,CAAC;YAE1F,0CAA0C;YAC1C,IAAI,IAAI,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC,GAAQ,EAAE,EAAE,CAAC,GAAG,CAAC,OAAO,KAAK,GAAG,CAAC,CAAC;YAChE,IAAI,WAAW,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC;YAE7C,uEAAuE;YACvE,IAAI,SAAS,GAAG,eAAe,CAAC,GAAG,CAAC,CAAC,IAAS,EAAE,EAAE;gBAChD,IAAI,WAAW,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC,GAAQ,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;gBACrE,OAAO,WAAW,CAAC,CAAC,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC;YAClD,CAAC,CAAC,CAAC;YAEH,gEAAgE;YAChE,IAAI,QAAQ,EAAE,CAAC;gBACb,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YAC3B,CAAC;YAED,8FAA8F;YAC9F,IAAI,OAAO,KAAK,GAAG,IAAI,WAAW,EAAE,CAAC;gBACnC,SAAS,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YAC9B,CAAC;YAED,gCAAgC;YAChC,IAAI,WAAW,GAAG,SAAS,CAAC,MAAM,CAChC,CAAC,OAAsB,EAAE,EAAE,CAAC,OAAO,KAAK,IAAI,IAAI,OAAO,KAAK,EAAE,CAC/D,CAAC;YAEF,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAC3B,yDAAyD;gBACzD,MAAM,0BAA0B,GAAG,kBAAkB,CAAC,MAAM,CAC1D,CAAC,SAAc,EAAE,EAAE,CACjB,WAAW,CAAC,QAAQ,CAAC,SAAS,CAAC,UAAU,CAAC,IAAI,SAAS,CAAC,QAAQ,CAAC,IAAI,KAAK,OAAO,CACpF,CAAC;gBAEF,wCAAwC;gBACxC,KAAK,MAAM,SAAS,IAAI,0BAA0B,EAAE,CAAC;oBACnD,SAAS,CAAC,OAAO,CAAC,IAAI,CACpB,iBAAiB,EACjB,EAAE,gBAAgB,EAAE,SAAS,CAAC,yBAAyB,EAAE,EACzD,KAAK,EAAE,EAAE,OAAO,EAAwB,EAAE,EAAE;wBAC1C,IAAI,OAAO,EAAE,CAAC;4BACZ,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;wBAC9B,CAAC;oBACH,CAAC,CACF,CAAC;gBACJ,CAAC;YACH,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,GAAG,CAAC,4CAA4C,EAAE,KAAK,CAAC,CAAC;YACjE,kEAAkE;YAClE,iFAAiF;QACnF,CAAC;IACH,CAAC,CAAC;uGAxES,kBAAkB;2GAAlB,kBAAkB,cAFjB,MAAM;;2FAEP,kBAAkB;kBAH9B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Participant, Transport, Stream } from '../@types/types';\n\nexport interface ResumePauseStreamsParameters {\n  participants: Participant[];\n  dispActiveNames: string[];\n  remoteScreenStream: Stream[];\n  consumerTransports: Transport[];\n  screenId?: string;\n  islevel: string;\n\n  // mediasfu functions\n  getUpdatedAllParams: () => ResumePauseStreamsParameters;\n  [key: string]: any;\n}\n\nexport interface ResumePauseStreamsOptions {\n  parameters: ResumePauseStreamsParameters;\n}\n\n// Export the type definition for the function\nexport type ResumePauseStreamsType = (options: ResumePauseStreamsOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ResumePauseStreams {\n  /**\n   * Resumes or pauses streams based on the provided parameters.\n   *\n   * @param {ResumePauseStreamsOptions} options - The options for resuming or pausing streams.\n   * @param {Object} options.parameters - The parameters for the function.\n   * @param {Array} options.parameters.participants - The list of participants.\n   * @param {Array} options.parameters.dispActiveNames - The list of active display names.\n   * @param {Array} options.parameters.consumerTransports - The list of consumer transports.\n   * @param {string} options.parameters.screenId - The screen producer ID.\n   * @param {string} options.parameters.islevel - The level of the user.\n   *\n   * @returns {Promise<void>} A promise that resolves when the streams have been resumed or paused.\n   *\n   * @throws Will throw an error if there is an issue during the process of resuming or pausing streams.\n   */\n  resumePauseStreams = async ({ parameters }: ResumePauseStreamsOptions): Promise<void> => {\n    try {\n      // Destructure parameters\n      parameters = parameters.getUpdatedAllParams();\n      let { participants, dispActiveNames, consumerTransports, screenId, islevel } = parameters;\n\n      // Get the videoID of the host (islevel=2)\n      let host = participants.find((obj: any) => obj.islevel === '2');\n      let hostVideoID = host ? host.videoID : null;\n\n      // Get videoIDs of participants in dispActiveNames and screenproducerId\n      let videosIDs = dispActiveNames.map((name: any) => {\n        let participant = participants.find((obj: any) => obj.name === name);\n        return participant ? participant.videoID : null;\n      });\n\n      // Add screenproducerId to allVideoIDs if it's not null or empty\n      if (screenId) {\n        videosIDs.push(screenId);\n      }\n\n      // Add hostVideoID to allVideoIDs if it's not null or empty (only if the user is not the host)\n      if (islevel !== '2' && hostVideoID) {\n        videosIDs.push(hostVideoID);\n      }\n\n      // Remove null or empty videoIDs\n      let allVideoIDs = videosIDs.filter(\n        (videoID: string | null) => videoID !== null && videoID !== '',\n      );\n\n      if (allVideoIDs.length > 0) {\n        // Get consumer transports with producerId in allVideoIDs\n        const consumerTransportsToResume = consumerTransports.filter(\n          (transport: any) =>\n            allVideoIDs.includes(transport.producerId) && transport.consumer.kind !== 'audio',\n        );\n\n        // Resume all consumerTransportsToResume\n        for (const transport of consumerTransportsToResume) {\n          transport.socket_.emit(\n            'consumer-resume',\n            { serverConsumerId: transport.serverConsumerTransportId },\n            async ({ resumed }: { resumed: boolean }) => {\n              if (resumed) {\n                transport.consumer.resume();\n              }\n            },\n          );\n        }\n      }\n    } catch (error) {\n      console.log('Error during resuming or pausing streams: ', error);\n      // Handle errors during the process of resuming or pausing streams\n      // throw new Error(`Error during resuming or pausing streams: ${error.message}`);\n    }\n  };\n}\n"]}