mediasfu-angular 1.0.1 → 1.0.2

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

@@ -1,5 +1,78 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Manages participant settings and UI updates, including connecting IPs, reordering streams,
+ * updating settings, and handling participant display based on various session parameters.
+ *
+ * @async
+ * @param {AllMembersRestOptions} options - Parameters for managing members.
+ * @param {Participant[]} options.members - The array of participant objects.
+ * @param {Settings} options.settings - The session settings for audio, video, screenshare, and chat.
+ * @param {string} [options.coHoste] - The current co-host name.
+ * @param {CoHostResponsibility[]} [options.coHostRes] - The responsibilities assigned to the co-host.
+ * @param {AllMembersRestParameters} options.parameters - Additional parameters for managing members and UI updates.
+ * @param {ConsumeSocket[]} options.consume_sockets - Array of sockets for participant communication.
+ * @param {string} options.apiUserName - API username for authentication.
+ * @param {string} options.apiKey - API key for authentication.
+ * @param {string} options.apiToken - API token for authentication.
+ *
+ * @returns {Promise<void>} A promise that resolves when updates and changes for members are completed.
+ *
+ * @example
+ * ```typescript
+ * const allMembersRestService = new AllMembersRest();
+ * await allMembersRestService.allMembersRest({
+ *   members: [{ name: 'John', isBanned: false, isSuspended: false, audioID: '123', videoID: '456' }],
+ *   settings: ['enabled', 'HD', 'allowed', 'public'],
+ *   coHoste: 'Jane',
+ *   coHostRes: ['manage-chat'],
+ *   parameters: {
+ *     participantsAll: [],
+ *     participants: [],
+ *     dispActiveNames: ['John'],
+ *     requestList: [],
+ *     coHost: '',
+ *     coHostResponsibility: [],
+ *     lock_screen: false,
+ *     firstAll: false,
+ *     membersReceived: false,
+ *     roomRecvIPs: [],
+ *     deferScreenReceived: false,
+ *     screenId: null,
+ *     shareScreenStarted: false,
+ *     meetingDisplayType: 'grid',
+ *     audioSetting: '',
+ *     videoSetting: '',
+ *     screenshareSetting: '',
+ *     chatSetting: '',
+ *     updateParticipantsAll: (participantsAll) => console.log(participantsAll),
+ *     updateParticipants: (participants) => console.log(participants),
+ *     updateRequestList: (requestList) => console.log(requestList),
+ *     updateCoHost: (coHost) => console.log(coHost),
+ *     updateCoHostResponsibility: (coHostRes) => console.log(coHostRes),
+ *     updateFirstAll: (firstAll) => console.log(firstAll),
+ *     updateMembersReceived: (membersReceived) => console.log(membersReceived),
+ *     updateDeferScreenReceived: (deferScreenReceived) => console.log(deferScreenReceived),
+ *     updateShareScreenStarted: (shareScreenStarted) => console.log(shareScreenStarted),
+ *     updateAudioSetting: (audioSetting) => console.log(audioSetting),
+ *     updateVideoSetting: (videoSetting) => console.log(videoSetting),
+ *     updateScreenshareSetting: (screenshareSetting) => console.log(screenshareSetting),
+ *     updateChatSetting: (chatSetting) => console.log(chatSetting),
+ *     updateConsume_sockets: (sockets) => console.log(sockets),
+ *     updateRoomRecvIPs: (ips) => console.log(ips),
+ *     updateIsLoadingModalVisible: (visible) => console.log(visible),
+ *     onScreenChanges: (params) => console.log('onScreenChanges called with', params),
+ *     connectIps: async (params) => [['socket1'], ['ip1']],
+ *     sleep: async ({ ms }) => new Promise((resolve) => setTimeout(resolve, ms)),
+ *     reorderStreams: async (params) => console.log('reorderStreams called with', params),
+ *   },
+ *   consume_sockets: [{ socketId: 'abc123' }],
+ *   apiUserName: 'testUser',
+ *   apiKey: 'apiKeyExample',
+ *   apiToken: 'apiTokenExample',
+ * });
+ * ```
+ */
 export class AllMembersRest {
     /**
      * Handles various tasks related to participant management and UI updates.
@@ -152,4 +225,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"all-members-rest.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/producers/socket-receive-methods/all-members-rest.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\n\nimport {\n  Participant,\n  CoHostResponsibility,\n  OnScreenChangesType,\n  OnScreenChangesParameters,\n  Request,\n  ConnectIpsParameters,\n  ReorderStreamsParameters,\n  ConnectIpsType,\n  SleepType,\n  ReorderStreamsType,\n  Settings,\n  ConsumeSocket,\n} from '../../@types/types';\nexport interface AllMembersRestParameters\n  extends OnScreenChangesParameters,\n    ConnectIpsParameters,\n    ReorderStreamsParameters {\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  audioSetting: string;\n  videoSetting: string;\n  screenshareSetting: string;\n  chatSetting: string;\n\n  updateParticipantsAll: (participantsAll: Participant[]) => void;\n  updateParticipants: (participants: Participant[]) => void;\n  updateRequestList: (requestList: Request[]) => void;\n  updateCoHost: (coHost: string) => void;\n  updateCoHostResponsibility: (coHostResponsibility: CoHostResponsibility[]) => void;\n  updateFirstAll: (firstAll: boolean) => void;\n  updateMembersReceived: (membersReceived: boolean) => void;\n  updateDeferScreenReceived: (deferScreenReceived: boolean) => void;\n  updateShareScreenStarted: (shareScreenStarted: boolean) => void;\n  updateAudioSetting: (audioSetting: string) => void;\n  updateVideoSetting: (videoSetting: string) => void;\n  updateScreenshareSetting: (screenshareSetting: string) => void;\n  updateChatSetting: (chatSetting: string) => void;\n  updateConsume_sockets: (consume_sockets: ConsumeSocket[]) => void;\n  updateRoomRecvIPs: (ips: string[]) => void;\n  updateIsLoadingModalVisible: (visible: boolean) => void;\n\n  // mediasfu functions\n  onScreenChanges: OnScreenChangesType;\n  connectIps: ConnectIpsType;\n  sleep: SleepType;\n  reorderStreams: ReorderStreamsType;\n\n  getUpdatedAllParams: () => AllMembersRestParameters;\n  [key: string]: any;\n}\n\nexport interface AllMembersRestOptions {\n  members: Participant[];\n  settings: Settings;\n  coHoste?: string;\n  coHostRes?: CoHostResponsibility[];\n  parameters: AllMembersRestParameters;\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 AllMembersRestType = (options: AllMembersRestOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class AllMembersRest {\n  /**\n   * Handles various tasks related to participant management and UI updates.\n   * @param {Object} params - The parameters passed to the allMembersRest method.\n   * @param {Array} params.members - The array of participant members.\n   * @param {Array} params.settings - The array of settings.\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 allMembersRest 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  async allMembersRest({\n    members,\n    settings,\n    coHoste,\n    coHostRes,\n    parameters,\n    consume_sockets,\n    apiUserName,\n    apiKey,\n    apiToken,\n  }: AllMembersRestOptions): 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      audioSetting,\n      videoSetting,\n      screenshareSetting,\n      chatSetting,\n      updateParticipantsAll,\n      updateParticipants,\n      updateRequestList,\n      updateCoHost,\n      updateCoHostResponsibility,\n      updateFirstAll,\n      updateMembersReceived,\n      updateDeferScreenReceived,\n      updateShareScreenStarted,\n      updateAudioSetting,\n      updateVideoSetting,\n      updateScreenshareSetting,\n      updateChatSetting,\n      updateConsume_sockets,\n      updateRoomRecvIPs,\n      updateIsLoadingModalVisible,\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 && membersReceived) {\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    let requests = requestList;\n    requestList = requests.filter((request: any) =>\n      participants.some((participant: any) => participant.id == request.id),\n    );\n    updateRequestList(requestList);\n\n    if (coHoste !== undefined && coHoste !== null) {\n      coHost = coHoste;\n    }\n    if (coHost !== undefined && coHost !== null) {\n      updateCoHost(coHost);\n    }\n    if (coHostRes !== undefined && coHostRes !== null) {\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      }\n    } catch (error) {\n      console.log('allMembersRest OnScreen', error);\n    }\n\n    try {\n      if (membersReceived) {\n        audioSetting = settings[0];\n        videoSetting = settings[1];\n        screenshareSetting = settings[2];\n        chatSetting = settings[3];\n\n        updateAudioSetting(audioSetting);\n        updateVideoSetting(videoSetting);\n        updateScreenshareSetting(screenshareSetting);\n        updateChatSetting(chatSetting);\n      }\n    } catch (error) {\n      console.log('allMembersRest Settings', error);\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"all-members-rest.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/producers/socket-receive-methods/all-members-rest.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\n\nimport {\n  Participant,\n  CoHostResponsibility,\n  OnScreenChangesType,\n  OnScreenChangesParameters,\n  Request,\n  ConnectIpsParameters,\n  ReorderStreamsParameters,\n  ConnectIpsType,\n  SleepType,\n  ReorderStreamsType,\n  Settings,\n  ConsumeSocket,\n} from '../../@types/types';\nexport interface AllMembersRestParameters\n  extends OnScreenChangesParameters,\n    ConnectIpsParameters,\n    ReorderStreamsParameters {\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  audioSetting: string;\n  videoSetting: string;\n  screenshareSetting: string;\n  chatSetting: string;\n\n  updateParticipantsAll: (participantsAll: Participant[]) => void;\n  updateParticipants: (participants: Participant[]) => void;\n  updateRequestList: (requestList: Request[]) => void;\n  updateCoHost: (coHost: string) => void;\n  updateCoHostResponsibility: (coHostResponsibility: CoHostResponsibility[]) => void;\n  updateFirstAll: (firstAll: boolean) => void;\n  updateMembersReceived: (membersReceived: boolean) => void;\n  updateDeferScreenReceived: (deferScreenReceived: boolean) => void;\n  updateShareScreenStarted: (shareScreenStarted: boolean) => void;\n  updateAudioSetting: (audioSetting: string) => void;\n  updateVideoSetting: (videoSetting: string) => void;\n  updateScreenshareSetting: (screenshareSetting: string) => void;\n  updateChatSetting: (chatSetting: string) => void;\n  updateConsume_sockets: (consume_sockets: ConsumeSocket[]) => void;\n  updateRoomRecvIPs: (ips: string[]) => void;\n  updateIsLoadingModalVisible: (visible: boolean) => void;\n\n  // mediasfu functions\n  onScreenChanges: OnScreenChangesType;\n  connectIps: ConnectIpsType;\n  sleep: SleepType;\n  reorderStreams: ReorderStreamsType;\n\n  getUpdatedAllParams: () => AllMembersRestParameters;\n  [key: string]: any;\n}\n\nexport interface AllMembersRestOptions {\n  members: Participant[];\n  settings: Settings;\n  coHoste?: string;\n  coHostRes?: CoHostResponsibility[];\n  parameters: AllMembersRestParameters;\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 AllMembersRestType = (options: AllMembersRestOptions) => Promise<void>;\n\n/**\n * Manages participant settings and UI updates, including connecting IPs, reordering streams,\n * updating settings, and handling participant display based on various session parameters.\n *\n * @async\n * @param {AllMembersRestOptions} options - Parameters for managing members.\n * @param {Participant[]} options.members - The array of participant objects.\n * @param {Settings} options.settings - The session settings for audio, video, screenshare, and chat.\n * @param {string} [options.coHoste] - The current co-host name.\n * @param {CoHostResponsibility[]} [options.coHostRes] - The responsibilities assigned to the co-host.\n * @param {AllMembersRestParameters} options.parameters - Additional parameters for managing members and UI updates.\n * @param {ConsumeSocket[]} options.consume_sockets - Array of sockets for participant communication.\n * @param {string} options.apiUserName - API username for authentication.\n * @param {string} options.apiKey - API key for authentication.\n * @param {string} options.apiToken - API token for authentication.\n *\n * @returns {Promise<void>} A promise that resolves when updates and changes for members are completed.\n *\n * @example\n * ```typescript\n * const allMembersRestService = new AllMembersRest();\n * await allMembersRestService.allMembersRest({\n *   members: [{ name: 'John', isBanned: false, isSuspended: false, audioID: '123', videoID: '456' }],\n *   settings: ['enabled', 'HD', 'allowed', 'public'],\n *   coHoste: 'Jane',\n *   coHostRes: ['manage-chat'],\n *   parameters: {\n *     participantsAll: [],\n *     participants: [],\n *     dispActiveNames: ['John'],\n *     requestList: [],\n *     coHost: '',\n *     coHostResponsibility: [],\n *     lock_screen: false,\n *     firstAll: false,\n *     membersReceived: false,\n *     roomRecvIPs: [],\n *     deferScreenReceived: false,\n *     screenId: null,\n *     shareScreenStarted: false,\n *     meetingDisplayType: 'grid',\n *     audioSetting: '',\n *     videoSetting: '',\n *     screenshareSetting: '',\n *     chatSetting: '',\n *     updateParticipantsAll: (participantsAll) => console.log(participantsAll),\n *     updateParticipants: (participants) => console.log(participants),\n *     updateRequestList: (requestList) => console.log(requestList),\n *     updateCoHost: (coHost) => console.log(coHost),\n *     updateCoHostResponsibility: (coHostRes) => console.log(coHostRes),\n *     updateFirstAll: (firstAll) => console.log(firstAll),\n *     updateMembersReceived: (membersReceived) => console.log(membersReceived),\n *     updateDeferScreenReceived: (deferScreenReceived) => console.log(deferScreenReceived),\n *     updateShareScreenStarted: (shareScreenStarted) => console.log(shareScreenStarted),\n *     updateAudioSetting: (audioSetting) => console.log(audioSetting),\n *     updateVideoSetting: (videoSetting) => console.log(videoSetting),\n *     updateScreenshareSetting: (screenshareSetting) => console.log(screenshareSetting),\n *     updateChatSetting: (chatSetting) => console.log(chatSetting),\n *     updateConsume_sockets: (sockets) => console.log(sockets),\n *     updateRoomRecvIPs: (ips) => console.log(ips),\n *     updateIsLoadingModalVisible: (visible) => console.log(visible),\n *     onScreenChanges: (params) => console.log('onScreenChanges called with', params),\n *     connectIps: async (params) => [['socket1'], ['ip1']],\n *     sleep: async ({ ms }) => new Promise((resolve) => setTimeout(resolve, ms)),\n *     reorderStreams: async (params) => console.log('reorderStreams called with', params),\n *   },\n *   consume_sockets: [{ socketId: 'abc123' }],\n *   apiUserName: 'testUser',\n *   apiKey: 'apiKeyExample',\n *   apiToken: 'apiTokenExample',\n * });\n * ```\n */\n\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class AllMembersRest {\n  /**\n   * Handles various tasks related to participant management and UI updates.\n   * @param {Object} params - The parameters passed to the allMembersRest method.\n   * @param {Array} params.members - The array of participant members.\n   * @param {Array} params.settings - The array of settings.\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 allMembersRest 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  async allMembersRest({\n    members,\n    settings,\n    coHoste,\n    coHostRes,\n    parameters,\n    consume_sockets,\n    apiUserName,\n    apiKey,\n    apiToken,\n  }: AllMembersRestOptions): 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      audioSetting,\n      videoSetting,\n      screenshareSetting,\n      chatSetting,\n      updateParticipantsAll,\n      updateParticipants,\n      updateRequestList,\n      updateCoHost,\n      updateCoHostResponsibility,\n      updateFirstAll,\n      updateMembersReceived,\n      updateDeferScreenReceived,\n      updateShareScreenStarted,\n      updateAudioSetting,\n      updateVideoSetting,\n      updateScreenshareSetting,\n      updateChatSetting,\n      updateConsume_sockets,\n      updateRoomRecvIPs,\n      updateIsLoadingModalVisible,\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 && membersReceived) {\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    let requests = requestList;\n    requestList = requests.filter((request: any) =>\n      participants.some((participant: any) => participant.id == request.id),\n    );\n    updateRequestList(requestList);\n\n    if (coHoste !== undefined && coHoste !== null) {\n      coHost = coHoste;\n    }\n    if (coHost !== undefined && coHost !== null) {\n      updateCoHost(coHost);\n    }\n    if (coHostRes !== undefined && coHostRes !== null) {\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      }\n    } catch (error) {\n      console.log('allMembersRest OnScreen', error);\n    }\n\n    try {\n      if (membersReceived) {\n        audioSetting = settings[0];\n        videoSetting = settings[1];\n        screenshareSetting = settings[2];\n        chatSetting = settings[3];\n\n        updateAudioSetting(audioSetting);\n        updateVideoSetting(videoSetting);\n        updateScreenshareSetting(screenshareSetting);\n        updateChatSetting(chatSetting);\n      }\n    } catch (error) {\n      console.log('allMembersRest Settings', error);\n    }\n  }\n}\n"]}

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

@@ -1,5 +1,76 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Manages participant-related operations, including updates for participant lists, requests, co-host settings,
+ * and other session details. This method filters out banned and suspended participants, reorders streams,
+ * connects IPs, and updates the UI.
+ *
+ * @async
+ * @param {AllMembersOptions} options - Parameters for managing all members.
+ * @param {Participant[]} options.members - The array of participant objects.
+ * @param {Request[]} options.requestss - The list of requests from participants.
+ * @param {string} options.coHoste - The current co-host name.
+ * @param {CoHostResponsibility[]} options.coHostRes - The responsibilities assigned to the co-host.
+ * @param {AllMembersParameters} options.parameters - Additional parameters for member management and UI updates.
+ * @param {ConsumeSocket[]} options.consume_sockets - Array of sockets for participant communication.
+ * @param {string} options.apiUserName - API username for authentication.
+ * @param {string} options.apiKey - API key for authentication.
+ * @param {string} options.apiToken - API token for authentication.
+ *
+ * @returns {Promise<void>} A promise that resolves when all members have been processed and updates are complete.
+ *
+ * @example
+ * ```typescript
+ * const allMembersService = new AllMembers();
+ * await allMembersService.allMembers({
+ *   members: [{ name: 'John', isBanned: false, isSuspended: false, audioID: '123', videoID: '456' }],
+ *   requestss: [{ id: '1', name: 'Jane', type: 'fa-microphone' }],
+ *   coHoste: 'Jane',
+ *   coHostRes: ['manage-chat'],
+ *   parameters: {
+ *     participantsAll: [],
+ *     participants: [],
+ *     dispActiveNames: ['John'],
+ *     requestList: [],
+ *     coHost: '',
+ *     coHostResponsibility: [],
+ *     lock_screen: false,
+ *     firstAll: false,
+ *     membersReceived: false,
+ *     roomRecvIPs: [],
+ *     deferScreenReceived: false,
+ *     screenId: null,
+ *     shareScreenStarted: false,
+ *     meetingDisplayType: 'grid',
+ *     hostFirstSwitch: false,
+ *     waitingRoomList: [],
+ *     islevel: '1',
+ *     updateParticipantsAll: (participantsAll) => console.log(participantsAll),
+ *     updateParticipants: (participants) => console.log(participants),
+ *     updateRequestList: (requestList) => console.log(requestList),
+ *     updateCoHost: (coHost) => console.log(coHost),
+ *     updateCoHostResponsibility: (coHostRes) => console.log(coHostRes),
+ *     updateFirstAll: (firstAll) => console.log(firstAll),
+ *     updateMembersReceived: (membersReceived) => console.log(membersReceived),
+ *     updateDeferScreenReceived: (deferScreenReceived) => console.log(deferScreenReceived),
+ *     updateShareScreenStarted: (shareScreenStarted) => console.log(shareScreenStarted),
+ *     updateHostFirstSwitch: (hostFirstSwitch) => console.log(hostFirstSwitch),
+ *     updateConsume_sockets: (sockets) => console.log(sockets),
+ *     updateRoomRecvIPs: (ips) => console.log(ips),
+ *     updateIsLoadingModalVisible: (visible) => console.log(visible),
+ *     updateTotalReqWait: (total) => console.log(total),
+ *     onScreenChanges: (params) => console.log('onScreenChanges called with', params),
+ *     connectIps: async (params) => [['socket1'], ['ip1']],
+ *     sleep: async ({ ms }) => new Promise((resolve) => setTimeout(resolve, ms)),
+ *     reorderStreams: async (params) => console.log('reorderStreams called with', params),
+ *   },
+ *   consume_sockets: [{ socketId: 'abc123' }],
+ *   apiUserName: 'testUser',
+ *   apiKey: 'apiKeyExample',
+ *   apiToken: 'apiTokenExample',
+ * });
+ * ```
+ */
 export class AllMembers {
     /**
      * allMembers - A method for handling various tasks related to participant management and UI updates.
@@ -144,4 +215,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     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":"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","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"]}
+//# 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":"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","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/**\n * Manages participant-related operations, including updates for participant lists, requests, co-host settings,\n * and other session details. This method filters out banned and suspended participants, reorders streams,\n * connects IPs, and updates the UI.\n *\n * @async\n * @param {AllMembersOptions} options - Parameters for managing all members.\n * @param {Participant[]} options.members - The array of participant objects.\n * @param {Request[]} options.requestss - The list of requests from participants.\n * @param {string} options.coHoste - The current co-host name.\n * @param {CoHostResponsibility[]} options.coHostRes - The responsibilities assigned to the co-host.\n * @param {AllMembersParameters} options.parameters - Additional parameters for member management and UI updates.\n * @param {ConsumeSocket[]} options.consume_sockets - Array of sockets for participant communication.\n * @param {string} options.apiUserName - API username for authentication.\n * @param {string} options.apiKey - API key for authentication.\n * @param {string} options.apiToken - API token for authentication.\n *\n * @returns {Promise<void>} A promise that resolves when all members have been processed and updates are complete.\n *\n * @example\n * ```typescript\n * const allMembersService = new AllMembers();\n * await allMembersService.allMembers({\n *   members: [{ name: 'John', isBanned: false, isSuspended: false, audioID: '123', videoID: '456' }],\n *   requestss: [{ id: '1', name: 'Jane', type: 'fa-microphone' }],\n *   coHoste: 'Jane',\n *   coHostRes: ['manage-chat'],\n *   parameters: {\n *     participantsAll: [],\n *     participants: [],\n *     dispActiveNames: ['John'],\n *     requestList: [],\n *     coHost: '',\n *     coHostResponsibility: [],\n *     lock_screen: false,\n *     firstAll: false,\n *     membersReceived: false,\n *     roomRecvIPs: [],\n *     deferScreenReceived: false,\n *     screenId: null,\n *     shareScreenStarted: false,\n *     meetingDisplayType: 'grid',\n *     hostFirstSwitch: false,\n *     waitingRoomList: [],\n *     islevel: '1',\n *     updateParticipantsAll: (participantsAll) => console.log(participantsAll),\n *     updateParticipants: (participants) => console.log(participants),\n *     updateRequestList: (requestList) => console.log(requestList),\n *     updateCoHost: (coHost) => console.log(coHost),\n *     updateCoHostResponsibility: (coHostRes) => console.log(coHostRes),\n *     updateFirstAll: (firstAll) => console.log(firstAll),\n *     updateMembersReceived: (membersReceived) => console.log(membersReceived),\n *     updateDeferScreenReceived: (deferScreenReceived) => console.log(deferScreenReceived),\n *     updateShareScreenStarted: (shareScreenStarted) => console.log(shareScreenStarted),\n *     updateHostFirstSwitch: (hostFirstSwitch) => console.log(hostFirstSwitch),\n *     updateConsume_sockets: (sockets) => console.log(sockets),\n *     updateRoomRecvIPs: (ips) => console.log(ips),\n *     updateIsLoadingModalVisible: (visible) => console.log(visible),\n *     updateTotalReqWait: (total) => console.log(total),\n *     onScreenChanges: (params) => console.log('onScreenChanges called with', params),\n *     connectIps: async (params) => [['socket1'], ['ip1']],\n *     sleep: async ({ ms }) => new Promise((resolve) => setTimeout(resolve, ms)),\n *     reorderStreams: async (params) => console.log('reorderStreams called with', params),\n *   },\n *   consume_sockets: [{ socketId: 'abc123' }],\n *   apiUserName: 'testUser',\n *   apiKey: 'apiKeyExample',\n *   apiToken: 'apiTokenExample',\n * });\n * ```\n */\n\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

@@ -1,5 +1,32 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Service to handle updating the list and count of waiting room participants.
+ *
+ * @class
+ * @name AllWaitingRoomMembers
+ * @description This service updates the waiting room participants list and the total count of participants waiting to join.
+ *
+ * @method
+ * @async
+ * @name allWaitingRoomMembers
+ * @param {AllWaitingRoomMembersOptions} options - The options for updating the waiting room data.
+ * @param {WaitingRoomParticipant[]} options.waitingParticipants - An array of participants currently in the waiting room.
+ * @param {Function} options.updateWaitingRoomList - Function to update the waiting room participants list.
+ * @param {Function} options.updateTotalReqWait - Function to update the total count of waiting room participants.
+ *
+ * @returns {Promise<void>} A promise that resolves when the updates to the waiting room data are complete.
+ *
+ * @example
+ * ```typescript
+ * const allWaitingRoomMembersService = new AllWaitingRoomMembers();
+ * await allWaitingRoomMembersService.allWaitingRoomMembers({
+ *   waitingParticipants: [{ name: 'John Doe', isApproved: false }],
+ *   updateWaitingRoomList: (participants) => console.log(participants),
+ *   updateTotalReqWait: (total) => console.log(`Total requests: ${total}`)
+ * });
+ * ```
+ */
 export class AllWaitingRoomMembers {
     /**
      * Updates the waiting room participants list and the total count of waiting room participants.
@@ -27,4 +54,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,5 +1,41 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Service to handle banning a participant from the session.
+ *
+ * @class
+ * @name BanParticipant
+ * @description This service provides a method to remove a participant from active lists and update the session's participant array, followed by reordering the streams.
+ *
+ * @method
+ * banParticipant
+ * @async
+ * @param {BanParticipantOptions} options - The options for banning a participant.
+ * @param {string} options.name - The name of the participant to be banned.
+ * @param {BanParticipantParameters} options.parameters - Parameters required for the banning operation.
+ * @param {string[]} options.parameters.activeNames - Array of active participant names.
+ * @param {string[]} options.parameters.dispActiveNames - Array of display participant names.
+ * @param {Participant[]} options.parameters.participants - Array of current session participants.
+ * @param {Function} options.parameters.updateParticipants - Function to update the participants array.
+ * @param {Function} options.parameters.reorderStreams - Function to reorder the streams after removing the participant.
+ *
+ * @returns {Promise<void>} A promise that resolves when the participant has been banned and streams reordered.
+ *
+ * @example
+ * ```typescript
+ * const banParticipantService = new BanParticipant();
+ * await banParticipantService.banParticipant({
+ *   name: 'John Doe',
+ *   parameters: {
+ *     activeNames: ['John Doe', 'Jane Smith'],
+ *     dispActiveNames: ['John Doe', 'Jane Smith'],
+ *     participants: [{ name: 'John Doe', isBanned: false }, { name: 'Jane Smith', isBanned: false }],
+ *     updateParticipants: (updated) => console.log(updated),
+ *     reorderStreams: async () => { }
+ *   }
+ * });
+ * ```
+ */
 export class BanParticipant {
     /**
      * Bans a participant from the session by removing them from the active and display names arrays,
@@ -37,4 +73,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,5 +1,42 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Service for controlling participant media in a session, with options to manage audio, video, screenshare, and chat functionalities.
+ *
+ * @class
+ * @name ControlMediaHost
+ * @description This service provides the host with control over a participant's media (audio, video, screenshare, chat), with options to enable or disable these functionalities individually or all at once.
+ *
+ * @method
+ * controlMediaHost
+ * @async
+ * @param {ControlMediaHostOptions} options - Options to specify which media type to control and provide necessary parameters.
+ * @param {string} options.type - The media type to control ('audio', 'video', 'screenshare', 'chat', 'all').
+ * @param {ControlMediaHostParameters} options.parameters - Additional parameters, functions, and media streams necessary to perform the media control operations.
+ *
+ * @returns {Promise<void>} - A promise that resolves when the media control operation is complete.
+ *
+ * @example
+ * ```typescript
+ * const controlMediaHostService = new ControlMediaHost();
+ * await controlMediaHostService.controlMediaHost({
+ *   type: 'audio',
+ *   parameters: {
+ *     updateAdminRestrictSetting: (value) => console.log(value),
+ *     localStream: myLocalStream,
+ *     updateLocalStream: (stream) => console.log(stream),
+ *     updateAudioAlreadyOn: (value) => console.log(value),
+ *     onScreenChanges: async () => { },
+ *     disconnectSendTransportAudio: async () => { },
+ *     getUpdatedAllParams: () => ({ }),
+ *   }
+ * });
+ * ```
+ *
+ * @remarks
+ * - This function handles the control of audio, video, screenshare, or chat for a participant based on the specified type.
+ * - For `all` type, it sequentially controls each media type to ensure all are turned off.
+ */
 export class ControlMediaHost {
     /**
      * Controls the media (audio, video, screenshare, chat) of a participant as a host.
@@ -143,4 +180,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     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"]}
+//# 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/**\n * Service for controlling participant media in a session, with options to manage audio, video, screenshare, and chat functionalities.\n *\n * @class\n * @name ControlMediaHost\n * @description This service provides the host with control over a participant's media (audio, video, screenshare, chat), with options to enable or disable these functionalities individually or all at once.\n *\n * @method\n * controlMediaHost\n * @async\n * @param {ControlMediaHostOptions} options - Options to specify which media type to control and provide necessary parameters.\n * @param {string} options.type - The media type to control ('audio', 'video', 'screenshare', 'chat', 'all').\n * @param {ControlMediaHostParameters} options.parameters - Additional parameters, functions, and media streams necessary to perform the media control operations.\n *\n * @returns {Promise<void>} - A promise that resolves when the media control operation is complete.\n *\n * @example\n * ```typescript\n * const controlMediaHostService = new ControlMediaHost();\n * await controlMediaHostService.controlMediaHost({\n *   type: 'audio',\n *   parameters: {\n *     updateAdminRestrictSetting: (value) => console.log(value),\n *     localStream: myLocalStream,\n *     updateLocalStream: (stream) => console.log(stream),\n *     updateAudioAlreadyOn: (value) => console.log(value),\n *     onScreenChanges: async () => { },\n *     disconnectSendTransportAudio: async () => { },\n *     getUpdatedAllParams: () => ({ }),\n *   }\n * });\n * ```\n *\n * @remarks\n * - This function handles the control of audio, video, screenshare, or chat for a participant based on the specified type.\n * - For `all` type, it sequentially controls each media type to ensure all are turned off.\n */\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"]}