mediasfu-angular 1.0.0

package/dist/esm2022/lib/producers/socket-receive-methods/all-members.service.mjs

@@ -0,0 +1,147 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class AllMembers {
+    /**
+     * allMembers - A method for handling various tasks related to participant management and UI updates.
+     * @param {Object} params - The parameters passed to the allMembers method.
+     * @param {Array} params.members - The array of participant members.
+     * @param {Array} params.requestss - The array of requests.
+     * @param {boolean} params.coHoste - The co-host state.
+     * @param {boolean} params.coHostRes - The co-host responsibility state.
+     * @param {Object} params.parameters - The object containing parameters for the allMembers method.
+     * @param {Array} params.consume_sockets - The array of consume sockets.
+     * @param {string} params.apiUserName - The API username.
+     * @param {string} params.apiKey - The API key.
+     * @param {string} params.apiToken - The API token.
+     * @returns {void} - No return value.
+     */
+    allMembers = async ({ members, requestss, coHoste, coHostRes, parameters, consume_sockets, apiUserName, apiKey, apiToken, }) => {
+        let { participantsAll, participants, dispActiveNames, requestList, coHost, coHostResponsibility, lock_screen, firstAll, membersReceived, roomRecvIPs, deferScreenReceived, screenId, shareScreenStarted, meetingDisplayType, hostFirstSwitch, waitingRoomList, islevel, updateParticipantsAll, updateParticipants, updateRequestList, updateCoHost, updateCoHostResponsibility, updateFirstAll, updateMembersReceived, updateDeferScreenReceived, updateShareScreenStarted, updateHostFirstSwitch, updateConsume_sockets, updateRoomRecvIPs, updateIsLoadingModalVisible, updateTotalReqWait, onScreenChanges, connectIps, reorderStreams, sleep, } = parameters;
+        // Filter out the participant that isBanned == true or isSuspended == true
+        participantsAll = members.map((participant) => ({
+            isBanned: participant.isBanned,
+            isSuspended: participant.isSuspended,
+            name: participant.name,
+            audioID: participant.audioID,
+            videoID: participant.videoID,
+        }));
+        updateParticipantsAll(participantsAll);
+        participants = members.filter((participant) => !participant.isBanned && !participant.isSuspended);
+        updateParticipants(participants);
+        // Check if dispActiveNames is not empty and contains the name of the participant that is not in the participants array
+        if (dispActiveNames.length > 0) {
+            let dispActiveNames_ = dispActiveNames.filter((name) => !participants.map((participant) => participant.name).includes(name));
+            if (dispActiveNames_.length > 0) {
+                await reorderStreams({ add: false, screenChanged: true, parameters });
+            }
+        }
+        // Operations to update the UI; make sure we are connected to the server before updating the UI
+        if (!membersReceived) {
+            if (roomRecvIPs.length < 1) {
+                // Keep checking every 0.01s
+                let checkIPs = setInterval(async () => {
+                    if (roomRecvIPs.length > 0) {
+                        clearInterval(checkIPs);
+                        if (deferScreenReceived && screenId != null) {
+                            shareScreenStarted = true;
+                            updateShareScreenStarted(shareScreenStarted);
+                        }
+                        const [sockets_, ips_] = await connectIps({
+                            consume_sockets,
+                            remIP: roomRecvIPs,
+                            parameters,
+                            apiUserName,
+                            apiKey,
+                            apiToken,
+                        });
+                        if (sockets_ && ips_) {
+                            updateConsume_sockets(sockets_);
+                            updateRoomRecvIPs(ips_);
+                        }
+                        membersReceived = true;
+                        updateMembersReceived(membersReceived);
+                        await sleep({ ms: 250 });
+                        updateIsLoadingModalVisible(false);
+                        deferScreenReceived = false;
+                        updateDeferScreenReceived(deferScreenReceived);
+                    }
+                }, 10);
+            }
+            else {
+                const [sockets_, ips_] = await connectIps({
+                    consume_sockets,
+                    remIP: roomRecvIPs,
+                    parameters,
+                    apiUserName,
+                    apiKey,
+                    apiToken,
+                });
+                if (sockets_ && ips_) {
+                    updateConsume_sockets(sockets_);
+                    updateRoomRecvIPs(ips_);
+                }
+                membersReceived = true;
+                updateMembersReceived(membersReceived);
+                if (deferScreenReceived && screenId != null) {
+                    shareScreenStarted = true;
+                    updateShareScreenStarted(shareScreenStarted);
+                }
+                await sleep({ ms: 250 });
+                updateIsLoadingModalVisible(false);
+                deferScreenReceived = false;
+                updateDeferScreenReceived(deferScreenReceived);
+            }
+        }
+        else {
+            if (screenId != null) {
+                let host = participants.find((participant) => participant.ScreenID == screenId && participant.ScreenOn == true);
+                if (deferScreenReceived && screenId != null && host) {
+                    shareScreenStarted = true;
+                    updateShareScreenStarted(shareScreenStarted);
+                }
+            }
+        }
+        // Return requests for only ids that are in the participants array and update the count badge
+        requestList = requestss.filter((request) => participants.some((participant) => participant.id == request.id));
+        updateRequestList(requestList);
+        updateTotalReqWait(requestList.length + waitingRoomList.length);
+        if (coHoste !== undefined && coHoste !== null) {
+            coHost = coHoste;
+        }
+        updateCoHost(coHost);
+        if (coHostRes) {
+            coHostResponsibility = coHostRes;
+        }
+        updateCoHostResponsibility(coHostResponsibility);
+        try {
+            if (!lock_screen && !firstAll) {
+                await onScreenChanges({ parameters });
+                if (meetingDisplayType != 'all') {
+                    firstAll = true;
+                    updateFirstAll(firstAll);
+                }
+            }
+            else {
+                if (islevel == '2') {
+                    if (!hostFirstSwitch) {
+                        await onScreenChanges({ parameters });
+                        hostFirstSwitch = true; // Get self display
+                        updateHostFirstSwitch(hostFirstSwitch);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.log('allMembers OnScreen', error);
+        }
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: AllMembers, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: AllMembers, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: AllMembers, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"all-members.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/producers/socket-receive-methods/all-members.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAiF3C,MAAM,OAAO,UAAU;IACrB;;;;;;;;;;;;;OAaG;IAEH,UAAU,GAAG,KAAK,EAAE,EAClB,OAAO,EACP,SAAS,EACT,OAAO,EACP,SAAS,EACT,UAAU,EACV,eAAe,EACf,WAAW,EACX,MAAM,EACN,QAAQ,GACU,EAAiB,EAAE;QACrC,IAAI,EACF,eAAe,EACf,YAAY,EACZ,eAAe,EACf,WAAW,EACX,MAAM,EACN,oBAAoB,EACpB,WAAW,EACX,QAAQ,EACR,eAAe,EACf,WAAW,EACX,mBAAmB,EACnB,QAAQ,EACR,kBAAkB,EAClB,kBAAkB,EAClB,eAAe,EACf,eAAe,EACf,OAAO,EACP,qBAAqB,EACrB,kBAAkB,EAClB,iBAAiB,EACjB,YAAY,EACZ,0BAA0B,EAC1B,cAAc,EACd,qBAAqB,EACrB,yBAAyB,EACzB,wBAAwB,EACxB,qBAAqB,EACrB,qBAAqB,EACrB,iBAAiB,EACjB,2BAA2B,EAC3B,kBAAkB,EAElB,eAAe,EACf,UAAU,EACV,cAAc,EACd,KAAK,GACN,GAAG,UAAU,CAAC;QAEf,0EAA0E;QAC1E,eAAe,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC;YAC9C,QAAQ,EAAE,WAAW,CAAC,QAAQ;YAC9B,WAAW,EAAE,WAAW,CAAC,WAAW;YACpC,IAAI,EAAE,WAAW,CAAC,IAAI;YACtB,OAAO,EAAE,WAAW,CAAC,OAAO;YAC5B,OAAO,EAAE,WAAW,CAAC,OAAO;SAC7B,CAAC,CAAC,CAAC;QACJ,qBAAqB,CAAC,eAAe,CAAC,CAAC;QAEvC,YAAY,GAAG,OAAO,CAAC,MAAM,CAC3B,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC,WAAW,CAAC,QAAQ,IAAI,CAAC,WAAW,CAAC,WAAW,CACnE,CAAC;QACF,kBAAkB,CAAC,YAAY,CAAC,CAAC;QAEjC,uHAAuH;QACvH,IAAI,eAAe,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC/B,IAAI,gBAAgB,GAAG,eAAe,CAAC,MAAM,CAC3C,CAAC,IAAY,EAAE,EAAE,CAAC,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,WAAgB,EAAE,EAAE,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAC3F,CAAC;YACF,IAAI,gBAAgB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAChC,MAAM,cAAc,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC,CAAC;YACxE,CAAC;QACH,CAAC;QAED,+FAA+F;QAC/F,IAAI,CAAC,eAAe,EAAE,CAAC;YACrB,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAC3B,4BAA4B;gBAC5B,IAAI,QAAQ,GAAG,WAAW,CAAC,KAAK,IAAI,EAAE;oBACpC,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;wBAC3B,aAAa,CAAC,QAAQ,CAAC,CAAC;wBAExB,IAAI,mBAAmB,IAAI,QAAQ,IAAI,IAAI,EAAE,CAAC;4BAC5C,kBAAkB,GAAG,IAAI,CAAC;4BAC1B,wBAAwB,CAAC,kBAAkB,CAAC,CAAC;wBAC/C,CAAC;wBAED,MAAM,CAAC,QAAQ,EAAE,IAAI,CAAC,GAAG,MAAM,UAAU,CAAC;4BACxC,eAAe;4BACf,KAAK,EAAE,WAAW;4BAClB,UAAU;4BACV,WAAW;4BACX,MAAM;4BACN,QAAQ;yBACT,CAAC,CAAC;wBAEH,IAAI,QAAQ,IAAI,IAAI,EAAE,CAAC;4BACrB,qBAAqB,CAAC,QAAQ,CAAC,CAAC;4BAChC,iBAAiB,CAAC,IAAI,CAAC,CAAC;wBAC1B,CAAC;wBAED,eAAe,GAAG,IAAI,CAAC;wBACvB,qBAAqB,CAAC,eAAe,CAAC,CAAC;wBAEvC,MAAM,KAAK,CAAC,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC;wBACzB,2BAA2B,CAAC,KAAK,CAAC,CAAC;wBACnC,mBAAmB,GAAG,KAAK,CAAC;wBAC5B,yBAAyB,CAAC,mBAAmB,CAAC,CAAC;oBACjD,CAAC;gBACH,CAAC,EAAE,EAAE,CAAC,CAAC;YACT,CAAC;iBAAM,CAAC;gBACN,MAAM,CAAC,QAAQ,EAAE,IAAI,CAAC,GAAG,MAAM,UAAU,CAAC;oBACxC,eAAe;oBACf,KAAK,EAAE,WAAW;oBAClB,UAAU;oBACV,WAAW;oBACX,MAAM;oBACN,QAAQ;iBACT,CAAC,CAAC;gBAEH,IAAI,QAAQ,IAAI,IAAI,EAAE,CAAC;oBACrB,qBAAqB,CAAC,QAAQ,CAAC,CAAC;oBAChC,iBAAiB,CAAC,IAAI,CAAC,CAAC;gBAC1B,CAAC;gBACD,eAAe,GAAG,IAAI,CAAC;gBACvB,qBAAqB,CAAC,eAAe,CAAC,CAAC;gBAEvC,IAAI,mBAAmB,IAAI,QAAQ,IAAI,IAAI,EAAE,CAAC;oBAC5C,kBAAkB,GAAG,IAAI,CAAC;oBAC1B,wBAAwB,CAAC,kBAAkB,CAAC,CAAC;gBAC/C,CAAC;gBAED,MAAM,KAAK,CAAC,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC;gBACzB,2BAA2B,CAAC,KAAK,CAAC,CAAC;gBACnC,mBAAmB,GAAG,KAAK,CAAC;gBAC5B,yBAAyB,CAAC,mBAAmB,CAAC,CAAC;YACjD,CAAC;QACH,CAAC;aAAM,CAAC;YACN,IAAI,QAAQ,IAAI,IAAI,EAAE,CAAC;gBACrB,IAAI,IAAI,GAAG,YAAY,CAAC,IAAI,CAC1B,CAAC,WAAgB,EAAE,EAAE,CAAC,WAAW,CAAC,QAAQ,IAAI,QAAQ,IAAI,WAAW,CAAC,QAAQ,IAAI,IAAI,CACvF,CAAC;gBACF,IAAI,mBAAmB,IAAI,QAAQ,IAAI,IAAI,IAAI,IAAI,EAAE,CAAC;oBACpD,kBAAkB,GAAG,IAAI,CAAC;oBAC1B,wBAAwB,CAAC,kBAAkB,CAAC,CAAC;gBAC/C,CAAC;YACH,CAAC;QACH,CAAC;QAED,6FAA6F;QAC7F,WAAW,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC,OAAO,EAAE,EAAE,CACzC,YAAY,CAAC,IAAI,CAAC,CAAC,WAAgB,EAAE,EAAE,CAAC,WAAW,CAAC,EAAE,IAAI,OAAO,CAAC,EAAE,CAAC,CACtE,CAAC;QACF,iBAAiB,CAAC,WAAW,CAAC,CAAC;QAE/B,kBAAkB,CAAC,WAAW,CAAC,MAAM,GAAG,eAAe,CAAC,MAAM,CAAC,CAAC;QAEhE,IAAI,OAAO,KAAK,SAAS,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;YAC9C,MAAM,GAAG,OAAO,CAAC;QACnB,CAAC;QACD,YAAY,CAAC,MAAM,CAAC,CAAC;QACrB,IAAI,SAAS,EAAE,CAAC;YACd,oBAAoB,GAAG,SAAS,CAAC;QACnC,CAAC;QACD,0BAA0B,CAAC,oBAAoB,CAAC,CAAC;QAEjD,IAAI,CAAC;YACH,IAAI,CAAC,WAAW,IAAI,CAAC,QAAQ,EAAE,CAAC;gBAC9B,MAAM,eAAe,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC;gBAEtC,IAAI,kBAAkB,IAAI,KAAK,EAAE,CAAC;oBAChC,QAAQ,GAAG,IAAI,CAAC;oBAChB,cAAc,CAAC,QAAQ,CAAC,CAAC;gBAC3B,CAAC;YACH,CAAC;iBAAM,CAAC;gBACN,IAAI,OAAO,IAAI,GAAG,EAAE,CAAC;oBACnB,IAAI,CAAC,eAAe,EAAE,CAAC;wBACrB,MAAM,eAAe,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC;wBACtC,eAAe,GAAG,IAAI,CAAC,CAAC,mBAAmB;wBAC3C,qBAAqB,CAAC,eAAe,CAAC,CAAC;oBACzC,CAAC;gBACH,CAAC;YACH,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,GAAG,CAAC,qBAAqB,EAAE,KAAK,CAAC,CAAC;QAC5C,CAAC;IACH,CAAC,CAAC;uGA3MS,UAAU;2GAAV,UAAU,cAFT,MAAM;;2FAEP,UAAU;kBAHtB,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  Participant,\n  Request,\n  ReorderStreamsType,\n  ReorderStreamsParameters,\n  SleepType,\n  ConnectIpsParameters,\n  OnScreenChangesParameters,\n  OnScreenChangesType,\n  ConnectIpsType,\n  ConsumeSocket,\n  CoHostResponsibility,\n  WaitingRoomParticipant,\n} from '../../@types/types';\n\nexport interface AllMembersParameters\n  extends ReorderStreamsParameters,\n    ConnectIpsParameters,\n    OnScreenChangesParameters {\n  participantsAll: Participant[];\n  participants: Participant[];\n  dispActiveNames: string[];\n  requestList: Request[];\n  coHost: string;\n  coHostResponsibility: CoHostResponsibility[];\n  lock_screen: boolean;\n  firstAll: boolean;\n  membersReceived: boolean;\n  roomRecvIPs: string[];\n  deferScreenReceived: boolean;\n  screenId?: string;\n  shareScreenStarted: boolean;\n  meetingDisplayType: string;\n  hostFirstSwitch: boolean;\n  waitingRoomList: WaitingRoomParticipant[];\n  islevel: string;\n\n  updateParticipantsAll: (participantsAll: Participant[]) => void;\n  updateParticipants: (participants: Participant[]) => void;\n  updateRequestList: (requestList: Request[]) => void;\n  updateCoHost: (coHost: string) => void;\n  updateCoHostResponsibility: (coHostRes: CoHostResponsibility[]) => void;\n  updateFirstAll: (firstAll: boolean) => void;\n  updateMembersReceived: (membersReceived: boolean) => void;\n  updateDeferScreenReceived: (deferScreenReceived: boolean) => void;\n  updateShareScreenStarted: (shareScreenStarted: boolean) => void;\n  updateHostFirstSwitch: (hostFirstSwitch: boolean) => void;\n  updateConsume_sockets: (sockets: ConsumeSocket[]) => void;\n  updateRoomRecvIPs: (ips: string[]) => void;\n  updateIsLoadingModalVisible: (visible: boolean) => void;\n  updateTotalReqWait: (total: number) => void;\n\n  // mediasfu functions\n  onScreenChanges: OnScreenChangesType;\n  connectIps: ConnectIpsType;\n  sleep: SleepType;\n  reorderStreams: ReorderStreamsType;\n\n  getUpdatedAllParams: () => AllMembersParameters;\n  [key: string]: any;\n}\n\nexport interface AllMembersOptions {\n  members: Participant[];\n  requestss: Request[];\n  coHoste: string;\n  coHostRes: CoHostResponsibility[];\n  parameters: AllMembersParameters;\n  consume_sockets: ConsumeSocket[];\n  apiUserName: string;\n  apiKey: string;\n  apiToken: string;\n}\n\n// Export the type definition for the function\nexport type AllMembersType = (options: AllMembersOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class AllMembers {\n  /**\n   * allMembers - A method for handling various tasks related to participant management and UI updates.\n   * @param {Object} params - The parameters passed to the allMembers method.\n   * @param {Array} params.members - The array of participant members.\n   * @param {Array} params.requestss - The array of requests.\n   * @param {boolean} params.coHoste - The co-host state.\n   * @param {boolean} params.coHostRes - The co-host responsibility state.\n   * @param {Object} params.parameters - The object containing parameters for the allMembers method.\n   * @param {Array} params.consume_sockets - The array of consume sockets.\n   * @param {string} params.apiUserName - The API username.\n   * @param {string} params.apiKey - The API key.\n   * @param {string} params.apiToken - The API token.\n   * @returns {void} - No return value.\n   */\n\n  allMembers = async ({\n    members,\n    requestss,\n    coHoste,\n    coHostRes,\n    parameters,\n    consume_sockets,\n    apiUserName,\n    apiKey,\n    apiToken,\n  }: AllMembersOptions): Promise<void> => {\n    let {\n      participantsAll,\n      participants,\n      dispActiveNames,\n      requestList,\n      coHost,\n      coHostResponsibility,\n      lock_screen,\n      firstAll,\n      membersReceived,\n      roomRecvIPs,\n      deferScreenReceived,\n      screenId,\n      shareScreenStarted,\n      meetingDisplayType,\n      hostFirstSwitch,\n      waitingRoomList,\n      islevel,\n      updateParticipantsAll,\n      updateParticipants,\n      updateRequestList,\n      updateCoHost,\n      updateCoHostResponsibility,\n      updateFirstAll,\n      updateMembersReceived,\n      updateDeferScreenReceived,\n      updateShareScreenStarted,\n      updateHostFirstSwitch,\n      updateConsume_sockets,\n      updateRoomRecvIPs,\n      updateIsLoadingModalVisible,\n      updateTotalReqWait,\n\n      onScreenChanges,\n      connectIps,\n      reorderStreams,\n      sleep,\n    } = parameters;\n\n    // Filter out the participant that isBanned == true or isSuspended == true\n    participantsAll = members.map((participant) => ({\n      isBanned: participant.isBanned,\n      isSuspended: participant.isSuspended,\n      name: participant.name,\n      audioID: participant.audioID,\n      videoID: participant.videoID,\n    }));\n    updateParticipantsAll(participantsAll);\n\n    participants = members.filter(\n      (participant) => !participant.isBanned && !participant.isSuspended,\n    );\n    updateParticipants(participants);\n\n    // Check if dispActiveNames is not empty and contains the name of the participant that is not in the participants array\n    if (dispActiveNames.length > 0) {\n      let dispActiveNames_ = dispActiveNames.filter(\n        (name: string) => !participants.map((participant: any) => participant.name).includes(name),\n      );\n      if (dispActiveNames_.length > 0) {\n        await reorderStreams({ add: false, screenChanged: true, parameters });\n      }\n    }\n\n    // Operations to update the UI; make sure we are connected to the server before updating the UI\n    if (!membersReceived) {\n      if (roomRecvIPs.length < 1) {\n        // Keep checking every 0.01s\n        let checkIPs = setInterval(async () => {\n          if (roomRecvIPs.length > 0) {\n            clearInterval(checkIPs);\n\n            if (deferScreenReceived && screenId != null) {\n              shareScreenStarted = true;\n              updateShareScreenStarted(shareScreenStarted);\n            }\n\n            const [sockets_, ips_] = await connectIps({\n              consume_sockets,\n              remIP: roomRecvIPs,\n              parameters,\n              apiUserName,\n              apiKey,\n              apiToken,\n            });\n\n            if (sockets_ && ips_) {\n              updateConsume_sockets(sockets_);\n              updateRoomRecvIPs(ips_);\n            }\n\n            membersReceived = true;\n            updateMembersReceived(membersReceived);\n\n            await sleep({ ms: 250 });\n            updateIsLoadingModalVisible(false);\n            deferScreenReceived = false;\n            updateDeferScreenReceived(deferScreenReceived);\n          }\n        }, 10);\n      } else {\n        const [sockets_, ips_] = await connectIps({\n          consume_sockets,\n          remIP: roomRecvIPs,\n          parameters,\n          apiUserName,\n          apiKey,\n          apiToken,\n        });\n\n        if (sockets_ && ips_) {\n          updateConsume_sockets(sockets_);\n          updateRoomRecvIPs(ips_);\n        }\n        membersReceived = true;\n        updateMembersReceived(membersReceived);\n\n        if (deferScreenReceived && screenId != null) {\n          shareScreenStarted = true;\n          updateShareScreenStarted(shareScreenStarted);\n        }\n\n        await sleep({ ms: 250 });\n        updateIsLoadingModalVisible(false);\n        deferScreenReceived = false;\n        updateDeferScreenReceived(deferScreenReceived);\n      }\n    } else {\n      if (screenId != null) {\n        let host = participants.find(\n          (participant: any) => participant.ScreenID == screenId && participant.ScreenOn == true,\n        );\n        if (deferScreenReceived && screenId != null && host) {\n          shareScreenStarted = true;\n          updateShareScreenStarted(shareScreenStarted);\n        }\n      }\n    }\n\n    // Return requests for only ids that are in the participants array and update the count badge\n    requestList = requestss.filter((request) =>\n      participants.some((participant: any) => participant.id == request.id),\n    );\n    updateRequestList(requestList);\n\n    updateTotalReqWait(requestList.length + waitingRoomList.length);\n\n    if (coHoste !== undefined && coHoste !== null) {\n      coHost = coHoste;\n    }\n    updateCoHost(coHost);\n    if (coHostRes) {\n      coHostResponsibility = coHostRes;\n    }\n    updateCoHostResponsibility(coHostResponsibility);\n\n    try {\n      if (!lock_screen && !firstAll) {\n        await onScreenChanges({ parameters });\n\n        if (meetingDisplayType != 'all') {\n          firstAll = true;\n          updateFirstAll(firstAll);\n        }\n      } else {\n        if (islevel == '2') {\n          if (!hostFirstSwitch) {\n            await onScreenChanges({ parameters });\n            hostFirstSwitch = true; // Get self display\n            updateHostFirstSwitch(hostFirstSwitch);\n          }\n        }\n      }\n    } catch (error) {\n      console.log('allMembers OnScreen', error);\n    }\n  };\n}\n"]}

package/dist/esm2022/lib/producers/socket-receive-methods/all-waiting-room-members.service.mjs

@@ -0,0 +1,30 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class AllWaitingRoomMembers {
+    /**
+     * Updates the waiting room participants list and the total count of waiting room participants.
+     *
+     * @param {Object} options - The options object.
+     * @param {Array} options.waitingParticipants - An array of participants currently in the waiting room.
+     * @param {Function} options.updateWaitingRoomList - A function to update the waiting room participants list.
+     * @param {Function} options.updateTotalReqWait - A function to update the total count of waiting room participants.
+     * @returns {Promise<void>} A promise that resolves when the updates are complete.
+     */
+    allWaitingRoomMembers = async ({ waitingParticipants, updateWaitingRoomList, updateTotalReqWait, }) => {
+        // Calculate the total number of waiting room participants
+        const totalReqs = waitingParticipants.length;
+        // Update the waiting room participants list
+        updateWaitingRoomList(waitingParticipants);
+        // Update the total count of waiting room participants
+        updateTotalReqWait(totalReqs);
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: AllWaitingRoomMembers, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: AllWaitingRoomMembers, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: AllWaitingRoomMembers, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/producers/socket-receive-methods/ban-participant.service.mjs

@@ -0,0 +1,40 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class BanParticipant {
+    /**
+     * Bans a participant from the session by removing them from the active and display names arrays,
+     * updating the participants list, and reordering the streams.
+     *
+     * @param {BanParticipantOptions} options - The options for banning a participant.
+     * @param {string} options.name - The name of the participant to be banned.
+     * @param {Object} options.parameters - The parameters required for banning the participant.
+     * @param {string[]} options.parameters.activeNames - The array of active participant names.
+     * @param {string[]} options.parameters.dispActiveNames - The array of display participant names.
+     * @param {Object[]} options.parameters.participants - The array of participant objects.
+     * @param {Function} options.parameters.updateParticipants - The function to update the participants array.
+     * @param {Function} options.parameters.reorderStreams - The function to reorder the streams.
+     *
+     * @returns {Promise<void>} A promise that resolves when the participant has been banned and streams reordered.
+     */
+    banParticipant = async ({ name, parameters }) => {
+        const { activeNames, dispActiveNames, participants, updateParticipants, reorderStreams } = parameters;
+        // Check if the participant is in the active or display names array
+        if (activeNames.includes(name) || dispActiveNames.includes(name)) {
+            // Filter out the banned participant from the participants array
+            const updatedParticipants = participants.filter((participant) => participant.name !== name);
+            // Update the participants array
+            updateParticipants(updatedParticipants);
+            // Reorder streams after participant removal
+            await reorderStreams({ add: false, screenChanged: true, parameters });
+        }
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: BanParticipant, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: BanParticipant, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: BanParticipant, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/producers/socket-receive-methods/control-media-host.service.mjs

@@ -0,0 +1,146 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ControlMediaHost {
+    /**
+     * Controls the media (audio, video, screenshare, chat) of a participant as a host.
+     *
+     * @param {object} options - The function parameters.
+     * @param {string} options.type - The type of media to control ('audio', 'video', 'screenshare', 'chat', 'all').
+     * @param {object} options.parameters - Additional parameters needed for the function.
+     * @param {boolean} options.parameters.adminRestrictSetting - The setting to restrict host control.
+     * @param {function} options.parameters.updateAdminRestrictSetting - Function to update the adminRestrictSetting.
+     * @param {MediaStream} options.parameters.localStream - The local audio and video stream.
+     * @param {function} options.parameters.updateLocalStream - Function to update the local audio and video stream.
+     * @param {boolean} options.parameters.audioAlreadyOn - Indicates whether audio is currently on.
+     * @param {function} options.parameters.updateAudioAlreadyOn - Function to update the audioAlreadyOn status.
+     * @param {MediaStream} options.parameters.localStreamScreen - The local screenshare stream.
+     * @param {function} options.parameters.updateLocalStreamScreen - Function to update the local screenshare stream.
+     * @param {MediaStream} options.parameters.localStreamVideo - The local video stream.
+     * @param {function} options.parameters.updateLocalStreamVideo - Function to update the local video stream.
+     * @param {boolean} options.parameters.screenAlreadyOn - Indicates whether screenshare is currently on.
+     * @param {function} options.parameters.updateScreenAlreadyOn - Function to update the screenAlreadyOn status.
+     * @param {boolean} options.parameters.videoAlreadyOn - Indicates whether video is currently on.
+     * @param {function} options.parameters.updateVideoAlreadyOn - Function to update the videoAlreadyOn status.
+     * @param {boolean} options.parameters.chatAlreadyOn - Indicates whether chat is currently on.
+     * @param {function} options.parameters.updateChatAlreadyOn - Function to update the chatAlreadyOn status.
+     * @param {function} options.parameters.onScreenChanges - Function to handle changes in screen status.
+     * @param {function} options.parameters.stopShareScreen - Function to stop sharing the screen.
+     * @param {function} options.parameters.disconnectSendTransportVideo - Function to disconnect video send transport.
+     * @param {function} options.parameters.disconnectSendTransportAudio - Function to disconnect audio send transport.
+     * @param {function} options.parameters.disconnectSendTransportScreen - Function to disconnect screenshare send transport.
+     */
+    controlMediaHost = async ({ type, parameters }) => {
+        let { updateAdminRestrictSetting, updateLocalStream, updateAudioAlreadyOn, updateLocalStreamScreen, updateLocalStreamVideo, updateScreenAlreadyOn, updateVideoAlreadyOn, updateChatAlreadyOn, onScreenChanges, stopShareScreen, disconnectSendTransportVideo, disconnectSendTransportAudio, disconnectSendTransportScreen, } = parameters;
+        let { localStream, localStreamScreen, localStreamVideo } = parameters.getUpdatedAllParams();
+        try {
+            updateAdminRestrictSetting(true);
+            if (type === 'audio') {
+                if (localStream) {
+                    localStream.getAudioTracks()[0].enabled = false;
+                }
+                updateLocalStream(localStream);
+                await disconnectSendTransportAudio({ parameters });
+                updateAudioAlreadyOn(false);
+            }
+            else if (type === 'video') {
+                try {
+                    if (localStream) {
+                        localStream.getVideoTracks()[0].enabled = false;
+                    }
+                    updateLocalStream(localStream);
+                    await disconnectSendTransportVideo({ parameters });
+                    await onScreenChanges({ changed: true, parameters });
+                    updateVideoAlreadyOn(false);
+                }
+                catch {
+                    /* handle error */
+                }
+                try {
+                    if (localStreamVideo) {
+                        localStreamVideo.getVideoTracks()[0].enabled = false;
+                        updateLocalStreamVideo(localStreamVideo);
+                        await disconnectSendTransportVideo({ parameters });
+                        await onScreenChanges({ changed: true, parameters });
+                        updateVideoAlreadyOn(false);
+                    }
+                }
+                catch (error) {
+                    onScreenChanges({ changed: true, parameters });
+                }
+            }
+            else if (type === 'screenshare') {
+                if (localStreamScreen) {
+                    localStreamScreen.getVideoTracks()[0].enabled = false;
+                }
+                updateLocalStreamScreen(localStreamScreen);
+                await disconnectSendTransportScreen({ parameters });
+                await stopShareScreen({ parameters });
+                updateScreenAlreadyOn(false);
+            }
+            else if (type === 'chat') {
+                updateChatAlreadyOn(false);
+            }
+            else if (type === 'all') {
+                try {
+                    if (localStream) {
+                        localStream.getAudioTracks()[0].enabled = false;
+                    }
+                    updateLocalStream(localStream);
+                    await disconnectSendTransportAudio({ parameters });
+                    updateAudioAlreadyOn(false);
+                }
+                catch {
+                    /* handle error */
+                }
+                try {
+                    if (localStreamScreen) {
+                        localStreamScreen.getVideoTracks()[0].enabled = false;
+                    }
+                    updateLocalStreamScreen(localStreamScreen);
+                    await disconnectSendTransportScreen({ parameters });
+                    await stopShareScreen({ parameters });
+                    updateScreenAlreadyOn(false);
+                }
+                catch {
+                    /* handle error */
+                }
+                try {
+                    if (localStream) {
+                        localStream.getVideoTracks()[0].enabled = false;
+                    }
+                    updateLocalStream(localStream);
+                    await disconnectSendTransportVideo({ parameters });
+                    await onScreenChanges({ changed: true, parameters });
+                    updateVideoAlreadyOn(false);
+                }
+                catch {
+                    /* handle error */
+                }
+                try {
+                    if (localStreamVideo) {
+                        localStreamVideo.getVideoTracks()[0].enabled = false;
+                    }
+                    updateLocalStreamVideo(localStreamVideo);
+                    await disconnectSendTransportVideo({ parameters });
+                    await onScreenChanges({ changed: true, parameters });
+                    updateVideoAlreadyOn(false);
+                }
+                catch (error) {
+                    onScreenChanges({ changed: true, parameters });
+                }
+            }
+        }
+        catch (error) {
+            console.error('Error in controlMediaHost:', error);
+        }
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ControlMediaHost, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ControlMediaHost, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ControlMediaHost, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"control-media-host.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/producers/socket-receive-methods/control-media-host.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  OnScreenChangesType,\n  StopShareScreenType,\n  DisconnectSendTransportVideoType,\n  DisconnectSendTransportAudioType,\n  DisconnectSendTransportScreenType,\n  OnScreenChangesParameters,\n  StopShareScreenParameters,\n  DisconnectSendTransportVideoParameters,\n  DisconnectSendTransportAudioParameters,\n  DisconnectSendTransportScreenParameters,\n} from '../../@types/types';\nexport interface ControlMediaHostParameters\n  extends OnScreenChangesParameters,\n    StopShareScreenParameters,\n    DisconnectSendTransportVideoParameters,\n    DisconnectSendTransportAudioParameters,\n    DisconnectSendTransportScreenParameters {\n  updateAdminRestrictSetting: (value: boolean) => void;\n  localStream: MediaStream | null;\n  updateLocalStream: (stream: MediaStream | null) => void;\n  updateAudioAlreadyOn: (value: boolean) => void;\n  localStreamScreen: MediaStream | null;\n  updateLocalStreamScreen: (stream: MediaStream | null) => void;\n  localStreamVideo: MediaStream | null;\n  updateLocalStreamVideo: (stream: MediaStream | null) => void;\n\n  updateScreenAlreadyOn: (value: boolean) => void;\n  updateVideoAlreadyOn: (value: boolean) => void;\n  updateChatAlreadyOn: (value: boolean) => void;\n\n  // mediasfu functions\n  onScreenChanges: OnScreenChangesType;\n  stopShareScreen: StopShareScreenType;\n  disconnectSendTransportVideo: DisconnectSendTransportVideoType;\n  disconnectSendTransportAudio: DisconnectSendTransportAudioType;\n  disconnectSendTransportScreen: DisconnectSendTransportScreenType;\n\n  getUpdatedAllParams: () => ControlMediaHostParameters;\n  [key: string]: any;\n}\n\nexport interface ControlMediaHostOptions {\n  type: 'audio' | 'video' | 'screenshare' | 'chat' | 'all';\n  parameters: ControlMediaHostParameters;\n}\n\n// Export the type definition for the function\nexport type ControlMediaHostType = (options: ControlMediaHostOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ControlMediaHost {\n  /**\n   * Controls the media (audio, video, screenshare, chat) of a participant as a host.\n   *\n   * @param {object} options - The function parameters.\n   * @param {string} options.type - The type of media to control ('audio', 'video', 'screenshare', 'chat', 'all').\n   * @param {object} options.parameters - Additional parameters needed for the function.\n   * @param {boolean} options.parameters.adminRestrictSetting - The setting to restrict host control.\n   * @param {function} options.parameters.updateAdminRestrictSetting - Function to update the adminRestrictSetting.\n   * @param {MediaStream} options.parameters.localStream - The local audio and video stream.\n   * @param {function} options.parameters.updateLocalStream - Function to update the local audio and video stream.\n   * @param {boolean} options.parameters.audioAlreadyOn - Indicates whether audio is currently on.\n   * @param {function} options.parameters.updateAudioAlreadyOn - Function to update the audioAlreadyOn status.\n   * @param {MediaStream} options.parameters.localStreamScreen - The local screenshare stream.\n   * @param {function} options.parameters.updateLocalStreamScreen - Function to update the local screenshare stream.\n   * @param {MediaStream} options.parameters.localStreamVideo - The local video stream.\n   * @param {function} options.parameters.updateLocalStreamVideo - Function to update the local video stream.\n   * @param {boolean} options.parameters.screenAlreadyOn - Indicates whether screenshare is currently on.\n   * @param {function} options.parameters.updateScreenAlreadyOn - Function to update the screenAlreadyOn status.\n   * @param {boolean} options.parameters.videoAlreadyOn - Indicates whether video is currently on.\n   * @param {function} options.parameters.updateVideoAlreadyOn - Function to update the videoAlreadyOn status.\n   * @param {boolean} options.parameters.chatAlreadyOn - Indicates whether chat is currently on.\n   * @param {function} options.parameters.updateChatAlreadyOn - Function to update the chatAlreadyOn status.\n   * @param {function} options.parameters.onScreenChanges - Function to handle changes in screen status.\n   * @param {function} options.parameters.stopShareScreen - Function to stop sharing the screen.\n   * @param {function} options.parameters.disconnectSendTransportVideo - Function to disconnect video send transport.\n   * @param {function} options.parameters.disconnectSendTransportAudio - Function to disconnect audio send transport.\n   * @param {function} options.parameters.disconnectSendTransportScreen - Function to disconnect screenshare send transport.\n   */\n  controlMediaHost = async ({ type, parameters }: ControlMediaHostOptions): Promise<void> => {\n    let {\n      updateAdminRestrictSetting,\n      updateLocalStream,\n      updateAudioAlreadyOn,\n      updateLocalStreamScreen,\n      updateLocalStreamVideo,\n      updateScreenAlreadyOn,\n      updateVideoAlreadyOn,\n      updateChatAlreadyOn,\n      onScreenChanges,\n      stopShareScreen,\n      disconnectSendTransportVideo,\n      disconnectSendTransportAudio,\n      disconnectSendTransportScreen,\n    } = parameters;\n\n    let { localStream, localStreamScreen, localStreamVideo } = parameters.getUpdatedAllParams();\n\n    try {\n      updateAdminRestrictSetting(true);\n\n      if (type === 'audio') {\n        if (localStream) {\n          localStream.getAudioTracks()[0].enabled = false;\n        }\n        updateLocalStream(localStream);\n        await disconnectSendTransportAudio({ parameters });\n        updateAudioAlreadyOn(false);\n      } else if (type === 'video') {\n        try {\n          if (localStream) {\n            localStream.getVideoTracks()[0].enabled = false;\n          }\n          updateLocalStream(localStream);\n          await disconnectSendTransportVideo({ parameters });\n          await onScreenChanges({ changed: true, parameters });\n          updateVideoAlreadyOn(false);\n        } catch {\n          /* handle error */\n        }\n        try {\n          if (localStreamVideo) {\n            localStreamVideo.getVideoTracks()[0].enabled = false;\n            updateLocalStreamVideo(localStreamVideo);\n            await disconnectSendTransportVideo({ parameters });\n            await onScreenChanges({ changed: true, parameters });\n            updateVideoAlreadyOn(false);\n          }\n        } catch (error) {\n          onScreenChanges({ changed: true, parameters });\n        }\n      } else if (type === 'screenshare') {\n        if (localStreamScreen) {\n          localStreamScreen.getVideoTracks()[0].enabled = false;\n        }\n        updateLocalStreamScreen(localStreamScreen);\n        await disconnectSendTransportScreen({ parameters });\n        await stopShareScreen({ parameters });\n        updateScreenAlreadyOn(false);\n      } else if (type === 'chat') {\n        updateChatAlreadyOn(false);\n      } else if (type === 'all') {\n        try {\n          if (localStream) {\n            localStream.getAudioTracks()[0].enabled = false;\n          }\n          updateLocalStream(localStream);\n          await disconnectSendTransportAudio({ parameters });\n          updateAudioAlreadyOn(false);\n        } catch {\n          /* handle error */\n        }\n\n        try {\n          if (localStreamScreen) {\n            localStreamScreen.getVideoTracks()[0].enabled = false;\n          }\n          updateLocalStreamScreen(localStreamScreen);\n          await disconnectSendTransportScreen({ parameters });\n          await stopShareScreen({ parameters });\n          updateScreenAlreadyOn(false);\n        } catch {\n          /* handle error */\n        }\n\n        try {\n          if (localStream) {\n            localStream.getVideoTracks()[0].enabled = false;\n          }\n          updateLocalStream(localStream);\n          await disconnectSendTransportVideo({ parameters });\n          await onScreenChanges({ changed: true, parameters });\n          updateVideoAlreadyOn(false);\n        } catch {\n          /* handle error */\n        }\n        try {\n          if (localStreamVideo) {\n            localStreamVideo.getVideoTracks()[0].enabled = false;\n          }\n          updateLocalStreamVideo(localStreamVideo);\n          await disconnectSendTransportVideo({ parameters });\n          await onScreenChanges({ changed: true, parameters });\n          updateVideoAlreadyOn(false);\n        } catch (error) {\n          onScreenChanges({ changed: true, parameters });\n        }\n      }\n    } catch (error) {\n      console.error('Error in controlMediaHost:', error);\n    }\n  };\n}\n"]}

package/dist/esm2022/lib/producers/socket-receive-methods/disconnect-user-self.service.mjs

@@ -0,0 +1,26 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class DisconnectUserSelf {
+    /**
+     * Disconnects the user from the specified room and bans them.
+     *
+     * @param {DisconnectUserSelfOptions} options - The options for disconnecting the user.
+     * @param {Object} options.member - The member object representing the user to disconnect.
+     * @param {string} options.roomName - The name of the room from which the user will be disconnected.
+     * @param {Socket} options.socket - The socket instance used to emit the disconnection request.
+     * @returns {Promise<void>} A promise that resolves when the disconnection request has been emitted.
+     */
+    disconnectUserSelf = async ({ member, roomName, socket, }) => {
+        // Update that the user needs to be disconnected; this is initiated by the host when banning a user
+        socket.emit('disconnectUser', { member, roomName, ban: true });
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: DisconnectUserSelf, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: DisconnectUserSelf, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: DisconnectUserSelf, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/producers/socket-receive-methods/disconnect.service.mjs

@@ -0,0 +1,38 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class Disconnect {
+    /**
+     * Handles the disconnection logic by either redirecting to a specified URL or showing an alert.
+     *
+     * @param {DisconnectOptions} options - The options for handling disconnection.
+     * @param {Function} options.showAlert - Function to display an alert message.
+     * @param {string} options.redirectURL - URL to redirect to if on the web.
+     * @param {boolean} options.onWeb - Flag indicating if the operation is on the web.
+     * @returns {Promise<void>} A promise that resolves when the disconnection handling is complete.
+     */
+    disconnect = async ({ showAlert, redirectURL, onWeb }) => {
+        // Redirect to the specified URL on the web
+        if (onWeb && redirectURL) {
+            window.location.href = redirectURL;
+        }
+        else {
+            // Display an alert and update the validated state
+            if (showAlert) {
+                showAlert({
+                    message: 'You have been disconnected from the session.',
+                    type: 'danger',
+                    duration: 2000,
+                });
+            }
+        }
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: Disconnect, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: Disconnect, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: Disconnect, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/producers/socket-receive-methods/get-domains.service.mjs

@@ -0,0 +1,63 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Service to handle domain-related operations.
+ *
+ * @class
+ * @name GetDomains
+ * @description This service provides a method to retrieve and process domains.
+ *
+ * @method
+ * @name getDomains
+ * @async
+ * @param {Object} options - The options for retrieving domains.
+ * @param {string[]} options.domains - The list of domains to process.
+ * @param {Object} options.alt_domains - An object mapping domains to alternative domains.
+ * @param {string} options.apiUserName - The API username for authentication.
+ * @param {string} options.apiKey - The API key for authentication.
+ * @param {string} options.apiToken - The API token for authentication.
+ * @param {Object} options.parameters - Additional parameters for the operation.
+ * @param {string[]} options.parameters.roomRecvIPs - The list of IPs currently in the room.
+ * @param {Function} options.parameters.getUpdatedAllParams - A function to get updated parameters.
+ * @param {Function} options.parameters.connectIps - A function to connect IPs.
+ * @returns {Promise<void>} A promise that resolves when the operation is complete.
+ * @throws {Error} Throws an error if the domain retrieval fails.
+ */
+export class GetDomains {
+    getDomains = async ({ domains, alt_domains, apiUserName, apiKey, apiToken, parameters, }) => {
+        const { roomRecvIPs, connectIps } = parameters;
+        const ipsToConnect = [];
+        let updatedConsumeSockets = parameters.getUpdatedAllParams().consume_sockets;
+        try {
+            for (const domain of domains) {
+                const ipToCheck = alt_domains[domain] || domain;
+                // Check if the IP is already in roomRecvIPs
+                if (!roomRecvIPs.includes(ipToCheck)) {
+                    ipsToConnect.push(ipToCheck);
+                }
+            }
+            const [,] = await connectIps({
+                consume_sockets: updatedConsumeSockets,
+                remIP: ipsToConnect,
+                parameters,
+                apiUserName,
+                apiKey,
+                apiToken,
+            });
+            // Handle sockets_ and ips_ if needed
+        }
+        catch (error) {
+            console.error('Error in getDomains: ', error);
+            throw new Error('Failed to retrieve domains.');
+        }
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: GetDomains, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: GetDomains, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: GetDomains, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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