mediasfu-angular 1.0.0 → 1.0.2

package/dist/esm2022/lib/consumers/prepopulate-user-media.service.mjs

@@ -3,6 +3,105 @@ import { MiniCard } from '../components/display-components/mini-card/mini-card.c
 import { VideoCard } from '../components/display-components/video-card/video-card.component';
 import { AudioCard } from '../components/display-components/audio-card/audio-card.component';
 import * as i0 from "@angular/core";
+/**
+ * Prepopulates the user media based on the provided options.
+ *
+ * This method prepares the UI components for the user's media based on the event type and participant information.
+ * It manages the display of video and audio cards, mini cards, and handles screen sharing scenarios.
+ *
+ * @param {PrepopulateUserMediaOptions} options - The options for prepopulating user media.
+ * @param {string} options.name - The name of the user.
+ * @param {PrepopulateUserMediaParameters} options.parameters - The parameters for prepopulating user media.
+ * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+ * @param {Array<Participant>} options.parameters.participants - List of participants.
+ * @param {Array<Stream>} options.parameters.allVideoStreams - List of all video streams.
+ * @param {string} options.parameters.islevel - The level of the user.
+ * @param {string} options.parameters.member - The member name.
+ * @param {boolean} options.parameters.shared - Indicates if the screen is shared.
+ * @param {boolean} options.parameters.shareScreenStarted - Indicates if screen sharing has started.
+ * @param {string} options.parameters.eventType - The type of event (e.g., "broadcast", "chat", "conference").
+ * @param {string} options.parameters.screenId - The ID of the screen.
+ * @param {boolean} options.parameters.forceFullDisplay - Indicates if full display is forced.
+ * @param {Function} options.parameters.updateMainWindow - Function to update the main window.
+ * @param {boolean} options.parameters.mainScreenFilled - Indicates if the main screen is filled.
+ * @param {boolean} options.parameters.adminOnMainScreen - Indicates if admin is on the main screen.
+ * @param {string} options.parameters.mainScreenPerson - The person on the main screen.
+ * @param {boolean} options.parameters.videoAlreadyOn - Indicates if the video is already on.
+ * @param {boolean} options.parameters.audioAlreadyOn - Indicates if the audio is already on.
+ * @param {Array<Stream>} options.parameters.oldAllStreams - List of old all streams.
+ * @param {Function} options.parameters.checkOrientation - Function to check orientation.
+ * @param {boolean} options.parameters.screenForceFullDisplay - Indicates if screen force full display is enabled.
+ * @param {Stream} options.parameters.localStreamScreen - The local screen stream.
+ * @param {Array<Stream>} options.parameters.remoteScreenStream - List of remote screen streams.
+ * @param {Stream} options.parameters.localStreamVideo - The local video stream.
+ * @param {number} options.parameters.mainHeightWidth - The main height and width.
+ * @param {boolean} options.parameters.isWideScreen - Indicates if the screen is wide.
+ * @param {boolean} options.parameters.localUIMode - Indicates if local UI mode is enabled.
+ * @param {boolean} options.parameters.whiteboardStarted - Indicates if whiteboard has started.
+ * @param {boolean} options.parameters.whiteboardEnded - Indicates if whiteboard has ended.
+ * @param {Stream} options.parameters.virtualStream - The virtual stream.
+ * @param {boolean} options.parameters.keepBackground - Indicates if background should be kept.
+ * @param {Stream} options.parameters.annotateScreenStream - The annotate screen stream.
+ * @param {Function} options.parameters.updateMainScreenPerson - Function to update the main screen person.
+ * @param {Function} options.parameters.updateMainScreenFilled - Function to update if the main screen is filled.
+ * @param {Function} options.parameters.updateAdminOnMainScreen - Function to update if admin is on the main screen.
+ * @param {Function} options.parameters.updateMainHeightWidth - Function to update the main height and width.
+ * @param {Function} options.parameters.updateScreenForceFullDisplay - Function to update screen force full display.
+ * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window update status.
+ * @param {Function} options.parameters.updateMainGridStream - Function to update the main grid stream.
+ *
+ * @returns {Promise<{ component: any; inputs: any }[] | void>} A promise that resolves with the components and inputs or void.
+ *
+ * @throws {Error} Throws an error if there is an issue preparing and populating the main screen.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   name: 'John Doe',
+ *   parameters: {
+ *     getUpdatedAllParams: () => { },
+ *     participants: [],
+ *     allVideoStreams: [],
+ *     islevel: '1',
+ *     member: 'John',
+ *     shared: false,
+ *     shareScreenStarted: false,
+ *     eventType: 'conference',
+ *     screenId: 'screen123',
+ *     forceFullDisplay: false,
+ *     updateMainWindow: false,
+ *     mainScreenFilled: false,
+ *     adminOnMainScreen: false,
+ *     mainScreenPerson: '',
+ *     videoAlreadyOn: false,
+ *     audioAlreadyOn: false,
+ *     oldAllStreams: [],
+ *     checkOrientation: () => 'landscape',
+ *     screenForceFullDisplay: false,
+ *     localStreamScreen: null,
+ *     remoteScreenStream: [],
+ *     localStreamVideo: null,
+ *     mainHeightWidth: 100,
+ *     isWideScreen: true,
+ *     localUIMode: false,
+ *     whiteboardStarted: false,
+ *     whiteboardEnded: false,
+ *     virtualStream: null,
+ *     keepBackground: false,
+ *     annotateScreenStream: false,
+ *     updateMainScreenPerson: (person) => { console.log(updated) },
+ *     updateMainScreenFilled: (filled) => { console.log(updated) },
+ *     updateAdminOnMainScreen: (admin) => { console.log(updated) },
+ *     updateMainHeightWidth: (heightWidth) => { console.log(updated) },
+ *     updateScreenForceFullDisplay: (force) => { console.log(updated) },
+ *     updateUpdateMainWindow: (update) => { console.log(updated) },
+ *     updateMainGridStream: (components) => { console.log(updated) },
+ *   },
+ * };
+ *
+ * await prepopulateUserMedia(options);
+ * ```
+ */
 export class PrepopulateUserMedia {
     /**
      * Prepopulates the user media based on the provided options.
@@ -439,4 +538,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"prepopulate-user-media.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/prepopulate-user-media.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { MiniCard } from '../components/display-components/mini-card/mini-card.component';\nimport { VideoCard } from '../components/display-components/video-card/video-card.component';\nimport { AudioCard } from '../components/display-components/audio-card/audio-card.component';\nimport {\n  Participant,\n  Stream,\n  AudioCardParameters,\n  EventType,\n  CustomMediaComponent,\n} from '../@types/types';\n\nexport interface PrepopulateUserMediaParameters extends AudioCardParameters {\n  participants: Participant[];\n  allVideoStreams: (Stream | Participant)[];\n  islevel: string;\n  member: string;\n  shared: boolean;\n  shareScreenStarted: boolean;\n  eventType: EventType;\n  screenId?: string;\n  forceFullDisplay: boolean;\n  updateMainWindow: boolean;\n  mainScreenFilled: boolean;\n  adminOnMainScreen: boolean;\n  mainScreenPerson: string;\n  videoAlreadyOn: boolean;\n  audioAlreadyOn: boolean;\n  oldAllStreams: (Stream | Participant)[];\n  checkOrientation: () => string;\n  screenForceFullDisplay: boolean;\n  localStreamScreen: MediaStream | null;\n  remoteScreenStream: Stream[];\n  localStreamVideo: MediaStream | null;\n  mainHeightWidth: number;\n  isWideScreen: boolean;\n  localUIMode: boolean;\n  whiteboardStarted: boolean;\n  whiteboardEnded: boolean;\n  virtualStream: MediaStream | null;\n  keepBackground: boolean;\n  annotateScreenStream: boolean;\n  updateMainScreenPerson: (person: string) => void;\n  updateMainScreenFilled: (filled: boolean) => void;\n  updateAdminOnMainScreen: (admin: boolean) => void;\n  updateMainHeightWidth: (heightWidth: number) => void;\n  updateScreenForceFullDisplay: (force: boolean) => void;\n  updateUpdateMainWindow: (update: boolean) => void;\n  updateMainGridStream: (components: CustomMediaComponent[]) => void;\n\n  // mediasfu functions\n  getUpdatedAllParams: () => PrepopulateUserMediaParameters;\n  [key: string]: any;\n}\n\nexport interface PrepopulateUserMediaOptions {\n  name: string;\n  parameters: PrepopulateUserMediaParameters;\n}\n\n// Export the type definition for the function\nexport type PrepopulateUserMediaType = (options: {\n  name: string;\n  parameters: any;\n}) => Promise<{ component: any; inputs: any }[] | void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class PrepopulateUserMedia {\n  /**\n   * Prepopulates the user media based on the provided options.\n   *\n   * @param {PrepopulateUserMediaOptions} options - The options for prepopulating user media.\n   * @param {string} options.name - The name of the user.\n   * @param {Parameters} options.parameters - The parameters for prepopulating user media.\n   * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.\n   * @param {Array<Participant>} options.parameters.participants - List of participants.\n   * @param {Array<Stream>} options.parameters.allVideoStreams - List of all video streams.\n   * @param {string} options.parameters.islevel - The level of the user.\n   * @param {string} options.parameters.member - The member name.\n   * @param {boolean} options.parameters.shared - Indicates if the screen is shared.\n   * @param {boolean} options.parameters.shareScreenStarted - Indicates if screen sharing has started.\n   * @param {string} options.parameters.eventType - The type of event.\n   * @param {string} options.parameters.screenId - The screen ID.\n   * @param {boolean} options.parameters.forceFullDisplay - Indicates if full display is forced.\n   * @param {Function} options.parameters.updateMainWindow - Function to update the main window.\n   * @param {boolean} options.parameters.mainScreenFilled - Indicates if the main screen is filled.\n   * @param {boolean} options.parameters.adminOnMainScreen - Indicates if admin is on the main screen.\n   * @param {string} options.parameters.mainScreenPerson - The person on the main screen.\n   * @param {boolean} options.parameters.videoAlreadyOn - Indicates if the video is already on.\n   * @param {boolean} options.parameters.audioAlreadyOn - Indicates if the audio is already on.\n   * @param {Array<Stream>} options.parameters.oldAllStreams - List of old all streams.\n   * @param {Function} options.parameters.checkOrientation - Function to check orientation.\n   * @param {boolean} options.parameters.screenForceFullDisplay - Indicates if screen force full display is enabled.\n   * @param {Stream} options.parameters.localStreamScreen - The local screen stream.\n   * @param {Array<Stream>} options.parameters.remoteScreenStream - List of remote screen streams.\n   * @param {Stream} options.parameters.localStreamVideo - The local video stream.\n   * @param {number} options.parameters.mainHeightWidth - The main height and width.\n   * @param {boolean} options.parameters.isWideScreen - Indicates if the screen is wide.\n   * @param {boolean} options.parameters.localUIMode - Indicates if local UI mode is enabled.\n   * @param {boolean} options.parameters.whiteboardStarted - Indicates if whiteboard has started.\n   * @param {boolean} options.parameters.whiteboardEnded - Indicates if whiteboard has ended.\n   * @param {Stream} options.parameters.virtualStream - The virtual stream.\n   * @param {boolean} options.parameters.keepBackground - Indicates if background should be kept.\n   * @param {Stream} options.parameters.annotateScreenStream - The annotate screen stream.\n   * @param {Function} options.parameters.updateMainScreenPerson - Function to update the main screen person.\n   * @param {Function} options.parameters.updateMainScreenFilled - Function to update if the main screen is filled.\n   * @param {Function} options.parameters.updateAdminOnMainScreen - Function to update if admin is on the main screen.\n   * @param {Function} options.parameters.updateMainHeightWidth - Function to update the main height and width.\n   * @param {Function} options.parameters.updateScreenForceFullDisplay - Function to update screen force full display.\n   * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window update status.\n   * @param {Function} options.parameters.updateMainGridStream - Function to update the main grid stream.\n   *\n   * @returns {Promise<{ component: any, inputs: any }[] | void>} A promise that resolves with the components and inputs or void.\n   */\n  prepopulateUserMedia = async ({\n    name,\n    parameters,\n  }: PrepopulateUserMediaOptions): Promise<{ component: any; inputs: any }[] | void> => {\n    try {\n      // Destructure parameters\n\n      let { getUpdatedAllParams } = parameters;\n      parameters = getUpdatedAllParams();\n\n      let {\n        participants,\n        allVideoStreams,\n        islevel,\n        member,\n        shared,\n        shareScreenStarted,\n        eventType,\n        screenId,\n        forceFullDisplay,\n        updateMainWindow,\n        mainScreenFilled,\n        adminOnMainScreen,\n        mainScreenPerson,\n        videoAlreadyOn,\n        audioAlreadyOn,\n        oldAllStreams,\n        checkOrientation,\n        screenForceFullDisplay,\n\n        localStreamScreen,\n        remoteScreenStream,\n        localStreamVideo,\n        mainHeightWidth,\n        isWideScreen,\n        localUIMode,\n        whiteboardStarted,\n        whiteboardEnded,\n\n        virtualStream,\n        keepBackground,\n        annotateScreenStream,\n\n        updateMainScreenPerson,\n        updateMainScreenFilled,\n        updateAdminOnMainScreen,\n        updateMainHeightWidth,\n        updateScreenForceFullDisplay,\n        updateUpdateMainWindow,\n        updateMainGridStream,\n      } = parameters;\n\n      // If the event type is 'chat', return early\n      if (eventType == 'chat') {\n        return;\n      }\n\n      // Initialize variables\n      let host: Participant | null;\n      let hostStream: any;\n      let newComponents: { component: any; inputs: any }[] = [];\n\n      // Check if screen sharing is started or shared\n      if (shareScreenStarted || shared) {\n        // Handle main grid visibility based on the event type\n        if (eventType == 'conference') {\n          if (shared || shareScreenStarted) {\n            if (mainHeightWidth == 0) {\n              // Add the main grid if not present\n              updateMainHeightWidth(84);\n            }\n          } else {\n            // Remove the main grid if not shared or started\n            updateMainHeightWidth(0);\n          }\n        }\n\n        // Switch display to optimize for screen share\n        screenForceFullDisplay = forceFullDisplay;\n\n        updateScreenForceFullDisplay(screenForceFullDisplay);\n\n        // Get the orientation and adjust forceFullDisplay\n        let orientation = checkOrientation();\n        if (orientation == 'portrait' || !isWideScreen) {\n          if (shareScreenStarted || shared) {\n            screenForceFullDisplay = false;\n            updateScreenForceFullDisplay(screenForceFullDisplay);\n          }\n        }\n\n        // Check if the user is sharing the screen\n        if (shared) {\n          // User is sharing\n          host = { name: member, audioID: '', videoID: '' };\n          hostStream = localStreamScreen;\n\n          // Update admin on the main screen\n          adminOnMainScreen = islevel == '2';\n          updateAdminOnMainScreen(adminOnMainScreen);\n\n          // Update main screen person\n          mainScreenPerson = host.name || '';\n          updateMainScreenPerson(mainScreenPerson);\n        } else {\n          //someone else is sharing\n          host =\n            participants.find(\n              (participant: Participant) =>\n                participant.ScreenID == screenId && participant.ScreenOn == true,\n            ) ?? null;\n\n          if (whiteboardStarted && !whiteboardEnded) {\n            host = { name: 'WhiteboardActive', islevel: '2', audioID: '', videoID: '' };\n            hostStream = { producerId: 'WhiteboardActive' };\n          }\n\n          if (host == null) {\n            // remoteScreenStream\n            host =\n              participants.find((participant: Participant) => participant.ScreenOn == true) ?? null;\n          }\n\n          // check remoteScreenStream\n          if (host != null && !host?.name?.includes('WhiteboardActive')) {\n            if (remoteScreenStream.length == 0) {\n              hostStream =\n                allVideoStreams.find(\n                  (stream: Stream | Participant) => stream.producerId == host?.ScreenID,\n                ) ?? null;\n            } else {\n              hostStream = remoteScreenStream[0];\n            }\n          }\n\n          // Update admin on the main screen\n          adminOnMainScreen = (host && host.islevel == '2') ?? false;\n          updateAdminOnMainScreen(adminOnMainScreen);\n\n          // Update main screen person\n          mainScreenPerson = host?.name ?? '';\n          updateMainScreenPerson(mainScreenPerson);\n        }\n      } else {\n        // Screen share not started\n        if (eventType == 'conference') {\n          // No main grid for conferences\n          return;\n        }\n\n        // Find the host with level '2'\n        host = participants.find((participant: Participant) => participant.islevel == '2') ?? null;\n\n        // Update main screen person\n        mainScreenPerson = host?.name ?? '';\n        updateMainScreenPerson(mainScreenPerson);\n      }\n\n      // If host is not null, check if host videoIsOn\n      if (host) {\n        // Populate the main screen with the host video\n        if (shareScreenStarted || shared) {\n          forceFullDisplay = screenForceFullDisplay;\n          if (whiteboardStarted && !whiteboardEnded) {\n            // Whiteboard is active\n          } else {\n            newComponents.push({\n              component: VideoCard,\n              inputs: {\n                videoStream: shared ? hostStream : hostStream.stream,\n                remoteProducerId: host.ScreenID,\n                eventType,\n                forceFullDisplay: annotateScreenStream && shared ? false : forceFullDisplay,\n                customStyle: {\n                  border: eventType !== 'broadcast' ? '2px solid black' : '0px solid black',\n                },\n                participant: host,\n                backgroundColor: 'rgba(217, 227, 234, 0.99)',\n                showControls: false,\n                showInfo: true,\n                name: host.name,\n                doMirror: false,\n                parameters,\n              },\n            });\n          }\n\n          updateMainGridStream(newComponents);\n\n          mainScreenFilled = true;\n          updateMainScreenFilled(mainScreenFilled);\n          adminOnMainScreen = host.islevel == '2';\n          updateAdminOnMainScreen(adminOnMainScreen);\n          mainScreenPerson = host.name ?? '';\n          updateMainScreenPerson(mainScreenPerson);\n\n          return newComponents;\n        }\n\n        // Check if video is already on or not\n        if (\n          (islevel != '2' && !host['videoOn']) ||\n          (islevel == '2' && (!host['videoOn'] || !videoAlreadyOn)) ||\n          localUIMode == true\n        ) {\n          // Video is off\n          if (islevel == '2' && videoAlreadyOn) {\n            // Admin's video is on\n            newComponents.push({\n              component: VideoCard,\n              inputs: {\n                videoStream: keepBackground && virtualStream ? virtualStream : localStreamVideo,\n                remoteProducerId: host.videoID,\n                eventType,\n                forceFullDisplay,\n                customStyle: {\n                  border: eventType !== 'broadcast' ? '2px solid black' : '0px solid black',\n                },\n                participant: host,\n                backgroundColor: 'rgba(217, 227, 234, 0.99)',\n                showControls: false,\n                showInfo: true,\n                name: host.name,\n                doMirror: true,\n                parameters,\n              },\n            });\n            updateMainGridStream(newComponents);\n\n            mainScreenFilled = true;\n            updateMainScreenFilled(mainScreenFilled);\n            adminOnMainScreen = true;\n            updateAdminOnMainScreen(adminOnMainScreen);\n            mainScreenPerson = host.name ?? '';\n            updateMainScreenPerson(mainScreenPerson);\n          } else {\n            // Video is off and not admin\n            let audOn;\n\n            if (islevel == '2' && audioAlreadyOn) {\n              audOn = true;\n            } else {\n              if (host != null && islevel != '2') {\n                audOn = host['muted'] == false;\n              }\n            }\n\n            if (audOn) {\n              // Audio is on\n              try {\n                newComponents.push({\n                  component: AudioCard,\n                  inputs: {\n                    name: host.name,\n                    barColor: 'red',\n                    textColor: 'white',\n                    customStyle: {\n                      backgroundColor: 'transparent',\n                      border: eventType !== 'broadcast' ? '2px solid black' : '0px solid black',\n                    },\n                    controlsPosition: 'topLeft',\n                    infoPosition: 'topRight',\n                    showWaveform: true,\n                    roundedImage: true,\n                    parameters: parameters,\n                    showControls: false,\n                    backgroundColor: 'transparent',\n                  },\n                });\n\n                updateMainGridStream(newComponents);\n              } catch (error) {\n                // Handle audio card creation error\n              }\n\n              mainScreenFilled = true;\n              updateMainScreenFilled(mainScreenFilled);\n              adminOnMainScreen = islevel == '2';\n              updateAdminOnMainScreen(adminOnMainScreen);\n              mainScreenPerson = host.name ?? '';\n              updateMainScreenPerson(mainScreenPerson);\n            } else {\n              // Audio is off\n              try {\n                newComponents.push({\n                  component: MiniCard,\n                  inputs: {\n                    initials: name,\n                    fontSize: 20,\n                    customStyle: {\n                      backgroundColor: 'transparent',\n                      border: eventType !== 'broadcast' ? '2px solid black' : '0px solid black',\n                    },\n                  },\n                });\n                updateMainGridStream(newComponents);\n              } catch (error) {\n                // Handle mini card creation error\n              }\n\n              mainScreenFilled = false;\n              updateMainScreenFilled(mainScreenFilled);\n              adminOnMainScreen = islevel == '2';\n              updateAdminOnMainScreen(adminOnMainScreen);\n              mainScreenPerson = host.name ?? '';\n              updateMainScreenPerson(mainScreenPerson);\n            }\n          }\n        } else {\n          // Video is on\n          if (shareScreenStarted || shared) {\n            // Screen share is on\n            if (whiteboardStarted && !whiteboardEnded) {\n              // Whiteboard is active\n            } else {\n              try {\n                newComponents.push({\n                  component: VideoCard,\n                  inputs: {\n                    videoStream: shared ? hostStream : hostStream.stream,\n                    remoteProducerId: host.ScreenID,\n                    eventType,\n                    forceFullDisplay,\n                    customStyle: {\n                      border: eventType !== 'broadcast' ? '2px solid black' : '0px solid black',\n                    },\n                    participant: host,\n                    backgroundColor: 'rgba(217, 227, 234, 0.99)',\n                    showControls: false,\n                    showInfo: true,\n                    name: host.name,\n                    doMirror: false,\n                    parameters,\n                  },\n                });\n\n                updateMainGridStream(newComponents);\n\n                mainScreenFilled = true;\n                updateMainScreenFilled(mainScreenFilled);\n                adminOnMainScreen = host.islevel == '2';\n                updateAdminOnMainScreen(adminOnMainScreen);\n                mainScreenPerson = host.name ?? '';\n                updateMainScreenPerson(mainScreenPerson);\n              } catch (error) {\n                // Handle video card creation error\n              }\n            }\n          } else {\n            // Screen share is off\n            let streame;\n            if (islevel == '2') {\n              host['stream'] = keepBackground && virtualStream ? virtualStream : localStreamVideo;\n            } else {\n              streame = oldAllStreams.find(\n                (streame: Stream | Participant) => streame.producerId == host.videoID,\n              );\n              host['stream'] = streame && streame.stream;\n            }\n\n            try {\n              if (host['stream']) {\n                newComponents.push({\n                  component: VideoCard,\n                  inputs: {\n                    videoStream: host['stream'],\n                    remoteProducerId: host.videoID,\n                    eventType,\n                    forceFullDisplay,\n                    customStyle: {\n                      border: eventType !== 'broadcast' ? '2px solid black' : '0px solid black',\n                    },\n                    participant: host,\n                    backgroundColor: 'rgba(217, 227, 234, 0.99)',\n                    showControls: false,\n                    showInfo: true,\n                    name: host.name,\n                    doMirror: member == host.name,\n                    parameters,\n                  },\n                });\n\n                updateMainGridStream(newComponents);\n\n                mainScreenFilled = true;\n                adminOnMainScreen = host.islevel == '2';\n                mainScreenPerson = host.name ?? '';\n              } else {\n                newComponents.push({\n                  component: MiniCard,\n                  inputs: {\n                    initials: name,\n                    fontSize: 20,\n                    customStyle: {\n                      backgroundColor: 'transparent',\n                      border: eventType !== 'broadcast' ? '2px solid black' : '0px solid black',\n                    },\n                  },\n                });\n\n                updateMainGridStream(newComponents);\n                mainScreenFilled = false;\n                adminOnMainScreen = islevel == '2';\n                mainScreenPerson = host.name ?? '';\n              }\n\n              updateMainScreenFilled(mainScreenFilled);\n\n              updateAdminOnMainScreen(adminOnMainScreen);\n\n              updateMainScreenPerson(mainScreenPerson);\n            } catch (error) {\n              // Handle video card creation error\n            }\n          }\n        }\n      } else {\n        // Host is null, add a mini card\n        try {\n          newComponents.push({\n            component: MiniCard,\n            inputs: {\n              initials: name,\n              fontSize: 20,\n              customStyle: {\n                backgroundColor: 'transparent',\n                border: eventType !== 'broadcast' ? '2px solid black' : '0px solid black',\n              },\n            },\n          });\n\n          updateMainGridStream(newComponents);\n\n          mainScreenFilled = false;\n          adminOnMainScreen = false;\n          mainScreenPerson = '';\n          updateMainScreenFilled(mainScreenFilled);\n          updateAdminOnMainScreen(adminOnMainScreen);\n          updateMainScreenPerson(mainScreenPerson);\n        } catch (error) {\n          // Handle mini card creation error\n        }\n      }\n\n      updateMainWindow = false;\n      updateUpdateMainWindow(updateMainWindow);\n\n      return newComponents;\n    } catch (error: any) {\n      // Handle errors during the process of preparing and populating the main screen\n      console.log('Error preparing and populating the main screen:', error.message);\n      return [];\n    }\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"prepopulate-user-media.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/prepopulate-user-media.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,QAAQ,EAAE,MAAM,gEAAgE,CAAC;AAC1F,OAAO,EAAE,SAAS,EAAE,MAAM,kEAAkE,CAAC;AAC7F,OAAO,EAAE,SAAS,EAAE,MAAM,kEAAkE,CAAC;;AA+D7F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkGG;AAKH,MAAM,OAAO,oBAAoB;IAC/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6CG;IACH,oBAAoB,GAAG,KAAK,EAAE,EAC5B,IAAI,EACJ,UAAU,GACkB,EAAqD,EAAE;QACnF,IAAI,CAAC;YACH,yBAAyB;YAEzB,IAAI,EAAE,mBAAmB,EAAE,GAAG,UAAU,CAAC;YACzC,UAAU,GAAG,mBAAmB,EAAE,CAAC;YAEnC,IAAI,EACF,YAAY,EACZ,eAAe,EACf,OAAO,EACP,MAAM,EACN,MAAM,EACN,kBAAkB,EAClB,SAAS,EACT,QAAQ,EACR,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,EAChB,cAAc,EACd,cAAc,EACd,aAAa,EACb,gBAAgB,EAChB,sBAAsB,EAEtB,iBAAiB,EACjB,kBAAkB,EAClB,gBAAgB,EAChB,eAAe,EACf,YAAY,EACZ,WAAW,EACX,iBAAiB,EACjB,eAAe,EAEf,aAAa,EACb,cAAc,EACd,oBAAoB,EAEpB,sBAAsB,EACtB,sBAAsB,EACtB,uBAAuB,EACvB,qBAAqB,EACrB,4BAA4B,EAC5B,sBAAsB,EACtB,oBAAoB,GACrB,GAAG,UAAU,CAAC;YAEf,4CAA4C;YAC5C,IAAI,SAAS,IAAI,MAAM,EAAE,CAAC;gBACxB,OAAO;YACT,CAAC;YAED,uBAAuB;YACvB,IAAI,IAAwB,CAAC;YAC7B,IAAI,UAAe,CAAC;YACpB,IAAI,aAAa,GAAsC,EAAE,CAAC;YAE1D,+CAA+C;YAC/C,IAAI,kBAAkB,IAAI,MAAM,EAAE,CAAC;gBACjC,sDAAsD;gBACtD,IAAI,SAAS,IAAI,YAAY,EAAE,CAAC;oBAC9B,IAAI,MAAM,IAAI,kBAAkB,EAAE,CAAC;wBACjC,IAAI,eAAe,IAAI,CAAC,EAAE,CAAC;4BACzB,mCAAmC;4BACnC,qBAAqB,CAAC,EAAE,CAAC,CAAC;wBAC5B,CAAC;oBACH,CAAC;yBAAM,CAAC;wBACN,gDAAgD;wBAChD,qBAAqB,CAAC,CAAC,CAAC,CAAC;oBAC3B,CAAC;gBACH,CAAC;gBAED,8CAA8C;gBAC9C,sBAAsB,GAAG,gBAAgB,CAAC;gBAE1C,4BAA4B,CAAC,sBAAsB,CAAC,CAAC;gBAErD,kDAAkD;gBAClD,IAAI,WAAW,GAAG,gBAAgB,EAAE,CAAC;gBACrC,IAAI,WAAW,IAAI,UAAU,IAAI,CAAC,YAAY,EAAE,CAAC;oBAC/C,IAAI,kBAAkB,IAAI,MAAM,EAAE,CAAC;wBACjC,sBAAsB,GAAG,KAAK,CAAC;wBAC/B,4BAA4B,CAAC,sBAAsB,CAAC,CAAC;oBACvD,CAAC;gBACH,CAAC;gBAED,0CAA0C;gBAC1C,IAAI,MAAM,EAAE,CAAC;oBACX,kBAAkB;oBAClB,IAAI,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC;oBAClD,UAAU,GAAG,iBAAiB,CAAC;oBAE/B,kCAAkC;oBAClC,iBAAiB,GAAG,OAAO,IAAI,GAAG,CAAC;oBACnC,uBAAuB,CAAC,iBAAiB,CAAC,CAAC;oBAE3C,4BAA4B;oBAC5B,gBAAgB,GAAG,IAAI,CAAC,IAAI,IAAI,EAAE,CAAC;oBACnC,sBAAsB,CAAC,gBAAgB,CAAC,CAAC;gBAC3C,CAAC;qBAAM,CAAC;oBACN,yBAAyB;oBACzB,IAAI;wBACF,YAAY,CAAC,IAAI,CACf,CAAC,WAAwB,EAAE,EAAE,CAC3B,WAAW,CAAC,QAAQ,IAAI,QAAQ,IAAI,WAAW,CAAC,QAAQ,IAAI,IAAI,CACnE,IAAI,IAAI,CAAC;oBAEZ,IAAI,iBAAiB,IAAI,CAAC,eAAe,EAAE,CAAC;wBAC1C,IAAI,GAAG,EAAE,IAAI,EAAE,kBAAkB,EAAE,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC;wBAC5E,UAAU,GAAG,EAAE,UAAU,EAAE,kBAAkB,EAAE,CAAC;oBAClD,CAAC;oBAED,IAAI,IAAI,IAAI,IAAI,EAAE,CAAC;wBACjB,qBAAqB;wBACrB,IAAI;4BACF,YAAY,CAAC,IAAI,CAAC,CAAC,WAAwB,EAAE,EAAE,CAAC,WAAW,CAAC,QAAQ,IAAI,IAAI,CAAC,IAAI,IAAI,CAAC;oBAC1F,CAAC;oBAED,2BAA2B;oBAC3B,IAAI,IAAI,IAAI,IAAI,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,CAAC,kBAAkB,CAAC,EAAE,CAAC;wBAC9D,IAAI,kBAAkB,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;4BACnC,UAAU;gCACR,eAAe,CAAC,IAAI,CAClB,CAAC,MAA4B,EAAE,EAAE,CAAC,MAAM,CAAC,UAAU,IAAI,IAAI,EAAE,QAAQ,CACtE,IAAI,IAAI,CAAC;wBACd,CAAC;6BAAM,CAAC;4BACN,UAAU,GAAG,kBAAkB,CAAC,CAAC,CAAC,CAAC;wBACrC,CAAC;oBACH,CAAC;oBAED,kCAAkC;oBAClC,iBAAiB,GAAG,CAAC,IAAI,IAAI,IAAI,CAAC,OAAO,IAAI,GAAG,CAAC,IAAI,KAAK,CAAC;oBAC3D,uBAAuB,CAAC,iBAAiB,CAAC,CAAC;oBAE3C,4BAA4B;oBAC5B,gBAAgB,GAAG,IAAI,EAAE,IAAI,IAAI,EAAE,CAAC;oBACpC,sBAAsB,CAAC,gBAAgB,CAAC,CAAC;gBAC3C,CAAC;YACH,CAAC;iBAAM,CAAC;gBACN,2BAA2B;gBAC3B,IAAI,SAAS,IAAI,YAAY,EAAE,CAAC;oBAC9B,+BAA+B;oBAC/B,OAAO;gBACT,CAAC;gBAED,+BAA+B;gBAC/B,IAAI,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC,WAAwB,EAAE,EAAE,CAAC,WAAW,CAAC,OAAO,IAAI,GAAG,CAAC,IAAI,IAAI,CAAC;gBAE3F,4BAA4B;gBAC5B,gBAAgB,GAAG,IAAI,EAAE,IAAI,IAAI,EAAE,CAAC;gBACpC,sBAAsB,CAAC,gBAAgB,CAAC,CAAC;YAC3C,CAAC;YAED,+CAA+C;YAC/C,IAAI,IAAI,EAAE,CAAC;gBACT,+CAA+C;gBAC/C,IAAI,kBAAkB,IAAI,MAAM,EAAE,CAAC;oBACjC,gBAAgB,GAAG,sBAAsB,CAAC;oBAC1C,IAAI,iBAAiB,IAAI,CAAC,eAAe,EAAE,CAAC;wBAC1C,uBAAuB;oBACzB,CAAC;yBAAM,CAAC;wBACN,aAAa,CAAC,IAAI,CAAC;4BACjB,SAAS,EAAE,SAAS;4BACpB,MAAM,EAAE;gCACN,WAAW,EAAE,MAAM,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,MAAM;gCACpD,gBAAgB,EAAE,IAAI,CAAC,QAAQ;gCAC/B,SAAS;gCACT,gBAAgB,EAAE,oBAAoB,IAAI,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,gBAAgB;gCAC3E,WAAW,EAAE;oCACX,MAAM,EAAE,SAAS,KAAK,WAAW,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,iBAAiB;iCAC1E;gCACD,WAAW,EAAE,IAAI;gCACjB,eAAe,EAAE,2BAA2B;gCAC5C,YAAY,EAAE,KAAK;gCACnB,QAAQ,EAAE,IAAI;gCACd,IAAI,EAAE,IAAI,CAAC,IAAI;gCACf,QAAQ,EAAE,KAAK;gCACf,UAAU;6BACX;yBACF,CAAC,CAAC;oBACL,CAAC;oBAED,oBAAoB,CAAC,aAAa,CAAC,CAAC;oBAEpC,gBAAgB,GAAG,IAAI,CAAC;oBACxB,sBAAsB,CAAC,gBAAgB,CAAC,CAAC;oBACzC,iBAAiB,GAAG,IAAI,CAAC,OAAO,IAAI,GAAG,CAAC;oBACxC,uBAAuB,CAAC,iBAAiB,CAAC,CAAC;oBAC3C,gBAAgB,GAAG,IAAI,CAAC,IAAI,IAAI,EAAE,CAAC;oBACnC,sBAAsB,CAAC,gBAAgB,CAAC,CAAC;oBAEzC,OAAO,aAAa,CAAC;gBACvB,CAAC;gBAED,sCAAsC;gBACtC,IACE,CAAC,OAAO,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;oBACpC,CAAC,OAAO,IAAI,GAAG,IAAI,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;oBACzD,WAAW,IAAI,IAAI,EACnB,CAAC;oBACD,eAAe;oBACf,IAAI,OAAO,IAAI,GAAG,IAAI,cAAc,EAAE,CAAC;wBACrC,sBAAsB;wBACtB,aAAa,CAAC,IAAI,CAAC;4BACjB,SAAS,EAAE,SAAS;4BACpB,MAAM,EAAE;gCACN,WAAW,EAAE,cAAc,IAAI,aAAa,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,gBAAgB;gCAC/E,gBAAgB,EAAE,IAAI,CAAC,OAAO;gCAC9B,SAAS;gCACT,gBAAgB;gCAChB,WAAW,EAAE;oCACX,MAAM,EAAE,SAAS,KAAK,WAAW,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,iBAAiB;iCAC1E;gCACD,WAAW,EAAE,IAAI;gCACjB,eAAe,EAAE,2BAA2B;gCAC5C,YAAY,EAAE,KAAK;gCACnB,QAAQ,EAAE,IAAI;gCACd,IAAI,EAAE,IAAI,CAAC,IAAI;gCACf,QAAQ,EAAE,IAAI;gCACd,UAAU;6BACX;yBACF,CAAC,CAAC;wBACH,oBAAoB,CAAC,aAAa,CAAC,CAAC;wBAEpC,gBAAgB,GAAG,IAAI,CAAC;wBACxB,sBAAsB,CAAC,gBAAgB,CAAC,CAAC;wBACzC,iBAAiB,GAAG,IAAI,CAAC;wBACzB,uBAAuB,CAAC,iBAAiB,CAAC,CAAC;wBAC3C,gBAAgB,GAAG,IAAI,CAAC,IAAI,IAAI,EAAE,CAAC;wBACnC,sBAAsB,CAAC,gBAAgB,CAAC,CAAC;oBAC3C,CAAC;yBAAM,CAAC;wBACN,6BAA6B;wBAC7B,IAAI,KAAK,CAAC;wBAEV,IAAI,OAAO,IAAI,GAAG,IAAI,cAAc,EAAE,CAAC;4BACrC,KAAK,GAAG,IAAI,CAAC;wBACf,CAAC;6BAAM,CAAC;4BACN,IAAI,IAAI,IAAI,IAAI,IAAI,OAAO,IAAI,GAAG,EAAE,CAAC;gCACnC,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,KAAK,CAAC;4BACjC,CAAC;wBACH,CAAC;wBAED,IAAI,KAAK,EAAE,CAAC;4BACV,cAAc;4BACd,IAAI,CAAC;gCACH,aAAa,CAAC,IAAI,CAAC;oCACjB,SAAS,EAAE,SAAS;oCACpB,MAAM,EAAE;wCACN,IAAI,EAAE,IAAI,CAAC,IAAI;wCACf,QAAQ,EAAE,KAAK;wCACf,SAAS,EAAE,OAAO;wCAClB,WAAW,EAAE;4CACX,eAAe,EAAE,aAAa;4CAC9B,MAAM,EAAE,SAAS,KAAK,WAAW,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,iBAAiB;yCAC1E;wCACD,gBAAgB,EAAE,SAAS;wCAC3B,YAAY,EAAE,UAAU;wCACxB,YAAY,EAAE,IAAI;wCAClB,YAAY,EAAE,IAAI;wCAClB,UAAU,EAAE,UAAU;wCACtB,YAAY,EAAE,KAAK;wCACnB,eAAe,EAAE,aAAa;qCAC/B;iCACF,CAAC,CAAC;gCAEH,oBAAoB,CAAC,aAAa,CAAC,CAAC;4BACtC,CAAC;4BAAC,OAAO,KAAK,EAAE,CAAC;gCACf,mCAAmC;4BACrC,CAAC;4BAED,gBAAgB,GAAG,IAAI,CAAC;4BACxB,sBAAsB,CAAC,gBAAgB,CAAC,CAAC;4BACzC,iBAAiB,GAAG,OAAO,IAAI,GAAG,CAAC;4BACnC,uBAAuB,CAAC,iBAAiB,CAAC,CAAC;4BAC3C,gBAAgB,GAAG,IAAI,CAAC,IAAI,IAAI,EAAE,CAAC;4BACnC,sBAAsB,CAAC,gBAAgB,CAAC,CAAC;wBAC3C,CAAC;6BAAM,CAAC;4BACN,eAAe;4BACf,IAAI,CAAC;gCACH,aAAa,CAAC,IAAI,CAAC;oCACjB,SAAS,EAAE,QAAQ;oCACnB,MAAM,EAAE;wCACN,QAAQ,EAAE,IAAI;wCACd,QAAQ,EAAE,EAAE;wCACZ,WAAW,EAAE;4CACX,eAAe,EAAE,aAAa;4CAC9B,MAAM,EAAE,SAAS,KAAK,WAAW,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,iBAAiB;yCAC1E;qCACF;iCACF,CAAC,CAAC;gCACH,oBAAoB,CAAC,aAAa,CAAC,CAAC;4BACtC,CAAC;4BAAC,OAAO,KAAK,EAAE,CAAC;gCACf,kCAAkC;4BACpC,CAAC;4BAED,gBAAgB,GAAG,KAAK,CAAC;4BACzB,sBAAsB,CAAC,gBAAgB,CAAC,CAAC;4BACzC,iBAAiB,GAAG,OAAO,IAAI,GAAG,CAAC;4BACnC,uBAAuB,CAAC,iBAAiB,CAAC,CAAC;4BAC3C,gBAAgB,GAAG,IAAI,CAAC,IAAI,IAAI,EAAE,CAAC;4BACnC,sBAAsB,CAAC,gBAAgB,CAAC,CAAC;wBAC3C,CAAC;oBACH,CAAC;gBACH,CAAC;qBAAM,CAAC;oBACN,cAAc;oBACd,IAAI,kBAAkB,IAAI,MAAM,EAAE,CAAC;wBACjC,qBAAqB;wBACrB,IAAI,iBAAiB,IAAI,CAAC,eAAe,EAAE,CAAC;4BAC1C,uBAAuB;wBACzB,CAAC;6BAAM,CAAC;4BACN,IAAI,CAAC;gCACH,aAAa,CAAC,IAAI,CAAC;oCACjB,SAAS,EAAE,SAAS;oCACpB,MAAM,EAAE;wCACN,WAAW,EAAE,MAAM,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,MAAM;wCACpD,gBAAgB,EAAE,IAAI,CAAC,QAAQ;wCAC/B,SAAS;wCACT,gBAAgB;wCAChB,WAAW,EAAE;4CACX,MAAM,EAAE,SAAS,KAAK,WAAW,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,iBAAiB;yCAC1E;wCACD,WAAW,EAAE,IAAI;wCACjB,eAAe,EAAE,2BAA2B;wCAC5C,YAAY,EAAE,KAAK;wCACnB,QAAQ,EAAE,IAAI;wCACd,IAAI,EAAE,IAAI,CAAC,IAAI;wCACf,QAAQ,EAAE,KAAK;wCACf,UAAU;qCACX;iCACF,CAAC,CAAC;gCAEH,oBAAoB,CAAC,aAAa,CAAC,CAAC;gCAEpC,gBAAgB,GAAG,IAAI,CAAC;gCACxB,sBAAsB,CAAC,gBAAgB,CAAC,CAAC;gCACzC,iBAAiB,GAAG,IAAI,CAAC,OAAO,IAAI,GAAG,CAAC;gCACxC,uBAAuB,CAAC,iBAAiB,CAAC,CAAC;gCAC3C,gBAAgB,GAAG,IAAI,CAAC,IAAI,IAAI,EAAE,CAAC;gCACnC,sBAAsB,CAAC,gBAAgB,CAAC,CAAC;4BAC3C,CAAC;4BAAC,OAAO,KAAK,EAAE,CAAC;gCACf,mCAAmC;4BACrC,CAAC;wBACH,CAAC;oBACH,CAAC;yBAAM,CAAC;wBACN,sBAAsB;wBACtB,IAAI,OAAO,CAAC;wBACZ,IAAI,OAAO,IAAI,GAAG,EAAE,CAAC;4BACnB,IAAI,CAAC,QAAQ,CAAC,GAAG,cAAc,IAAI,aAAa,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,gBAAgB,CAAC;wBACtF,CAAC;6BAAM,CAAC;4BACN,OAAO,GAAG,aAAa,CAAC,IAAI,CAC1B,CAAC,OAA6B,EAAE,EAAE,CAAC,OAAO,CAAC,UAAU,IAAI,IAAI,CAAC,OAAO,CACtE,CAAC;4BACF,IAAI,CAAC,QAAQ,CAAC,GAAG,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC;wBAC7C,CAAC;wBAED,IAAI,CAAC;4BACH,IAAI,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;gCACnB,aAAa,CAAC,IAAI,CAAC;oCACjB,SAAS,EAAE,SAAS;oCACpB,MAAM,EAAE;wCACN,WAAW,EAAE,IAAI,CAAC,QAAQ,CAAC;wCAC3B,gBAAgB,EAAE,IAAI,CAAC,OAAO;wCAC9B,SAAS;wCACT,gBAAgB;wCAChB,WAAW,EAAE;4CACX,MAAM,EAAE,SAAS,KAAK,WAAW,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,iBAAiB;yCAC1E;wCACD,WAAW,EAAE,IAAI;wCACjB,eAAe,EAAE,2BAA2B;wCAC5C,YAAY,EAAE,KAAK;wCACnB,QAAQ,EAAE,IAAI;wCACd,IAAI,EAAE,IAAI,CAAC,IAAI;wCACf,QAAQ,EAAE,MAAM,IAAI,IAAI,CAAC,IAAI;wCAC7B,UAAU;qCACX;iCACF,CAAC,CAAC;gCAEH,oBAAoB,CAAC,aAAa,CAAC,CAAC;gCAEpC,gBAAgB,GAAG,IAAI,CAAC;gCACxB,iBAAiB,GAAG,IAAI,CAAC,OAAO,IAAI,GAAG,CAAC;gCACxC,gBAAgB,GAAG,IAAI,CAAC,IAAI,IAAI,EAAE,CAAC;4BACrC,CAAC;iCAAM,CAAC;gCACN,aAAa,CAAC,IAAI,CAAC;oCACjB,SAAS,EAAE,QAAQ;oCACnB,MAAM,EAAE;wCACN,QAAQ,EAAE,IAAI;wCACd,QAAQ,EAAE,EAAE;wCACZ,WAAW,EAAE;4CACX,eAAe,EAAE,aAAa;4CAC9B,MAAM,EAAE,SAAS,KAAK,WAAW,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,iBAAiB;yCAC1E;qCACF;iCACF,CAAC,CAAC;gCAEH,oBAAoB,CAAC,aAAa,CAAC,CAAC;gCACpC,gBAAgB,GAAG,KAAK,CAAC;gCACzB,iBAAiB,GAAG,OAAO,IAAI,GAAG,CAAC;gCACnC,gBAAgB,GAAG,IAAI,CAAC,IAAI,IAAI,EAAE,CAAC;4BACrC,CAAC;4BAED,sBAAsB,CAAC,gBAAgB,CAAC,CAAC;4BAEzC,uBAAuB,CAAC,iBAAiB,CAAC,CAAC;4BAE3C,sBAAsB,CAAC,gBAAgB,CAAC,CAAC;wBAC3C,CAAC;wBAAC,OAAO,KAAK,EAAE,CAAC;4BACf,mCAAmC;wBACrC,CAAC;oBACH,CAAC;gBACH,CAAC;YACH,CAAC;iBAAM,CAAC;gBACN,gCAAgC;gBAChC,IAAI,CAAC;oBACH,aAAa,CAAC,IAAI,CAAC;wBACjB,SAAS,EAAE,QAAQ;wBACnB,MAAM,EAAE;4BACN,QAAQ,EAAE,IAAI;4BACd,QAAQ,EAAE,EAAE;4BACZ,WAAW,EAAE;gCACX,eAAe,EAAE,aAAa;gCAC9B,MAAM,EAAE,SAAS,KAAK,WAAW,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,iBAAiB;6BAC1E;yBACF;qBACF,CAAC,CAAC;oBAEH,oBAAoB,CAAC,aAAa,CAAC,CAAC;oBAEpC,gBAAgB,GAAG,KAAK,CAAC;oBACzB,iBAAiB,GAAG,KAAK,CAAC;oBAC1B,gBAAgB,GAAG,EAAE,CAAC;oBACtB,sBAAsB,CAAC,gBAAgB,CAAC,CAAC;oBACzC,uBAAuB,CAAC,iBAAiB,CAAC,CAAC;oBAC3C,sBAAsB,CAAC,gBAAgB,CAAC,CAAC;gBAC3C,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,kCAAkC;gBACpC,CAAC;YACH,CAAC;YAED,gBAAgB,GAAG,KAAK,CAAC;YACzB,sBAAsB,CAAC,gBAAgB,CAAC,CAAC;YAEzC,OAAO,aAAa,CAAC;QACvB,CAAC;QAAC,OAAO,KAAU,EAAE,CAAC;YACpB,+EAA+E;YAC/E,OAAO,CAAC,GAAG,CAAC,iDAAiD,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;YAC9E,OAAO,EAAE,CAAC;QACZ,CAAC;IACH,CAAC,CAAC;uGApfS,oBAAoB;2GAApB,oBAAoB,cAFnB,MAAM;;2FAEP,oBAAoB;kBAHhC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { MiniCard } from '../components/display-components/mini-card/mini-card.component';\nimport { VideoCard } from '../components/display-components/video-card/video-card.component';\nimport { AudioCard } from '../components/display-components/audio-card/audio-card.component';\nimport {\n  Participant,\n  Stream,\n  AudioCardParameters,\n  EventType,\n  CustomMediaComponent,\n} from '../@types/types';\n\nexport interface PrepopulateUserMediaParameters extends AudioCardParameters {\n  participants: Participant[];\n  allVideoStreams: (Stream | Participant)[];\n  islevel: string;\n  member: string;\n  shared: boolean;\n  shareScreenStarted: boolean;\n  eventType: EventType;\n  screenId?: string;\n  forceFullDisplay: boolean;\n  updateMainWindow: boolean;\n  mainScreenFilled: boolean;\n  adminOnMainScreen: boolean;\n  mainScreenPerson: string;\n  videoAlreadyOn: boolean;\n  audioAlreadyOn: boolean;\n  oldAllStreams: (Stream | Participant)[];\n  checkOrientation: () => string;\n  screenForceFullDisplay: boolean;\n  localStreamScreen: MediaStream | null;\n  remoteScreenStream: Stream[];\n  localStreamVideo: MediaStream | null;\n  mainHeightWidth: number;\n  isWideScreen: boolean;\n  localUIMode: boolean;\n  whiteboardStarted: boolean;\n  whiteboardEnded: boolean;\n  virtualStream: MediaStream | null;\n  keepBackground: boolean;\n  annotateScreenStream: boolean;\n  updateMainScreenPerson: (person: string) => void;\n  updateMainScreenFilled: (filled: boolean) => void;\n  updateAdminOnMainScreen: (admin: boolean) => void;\n  updateMainHeightWidth: (heightWidth: number) => void;\n  updateScreenForceFullDisplay: (force: boolean) => void;\n  updateUpdateMainWindow: (update: boolean) => void;\n  updateMainGridStream: (components: CustomMediaComponent[]) => void;\n\n  // mediasfu functions\n  getUpdatedAllParams: () => PrepopulateUserMediaParameters;\n  [key: string]: any;\n}\n\nexport interface PrepopulateUserMediaOptions {\n  name: string;\n  parameters: PrepopulateUserMediaParameters;\n}\n\n// Export the type definition for the function\nexport type PrepopulateUserMediaType = (options: {\n  name: string;\n  parameters: any;\n}) => Promise<{ component: any; inputs: any }[] | void>;\n\n/**\n * Prepopulates the user media based on the provided options.\n *\n * This method prepares the UI components for the user's media based on the event type and participant information.\n * It manages the display of video and audio cards, mini cards, and handles screen sharing scenarios.\n *\n * @param {PrepopulateUserMediaOptions} options - The options for prepopulating user media.\n * @param {string} options.name - The name of the user.\n * @param {PrepopulateUserMediaParameters} options.parameters - The parameters for prepopulating user media.\n * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.\n * @param {Array<Participant>} options.parameters.participants - List of participants.\n * @param {Array<Stream>} options.parameters.allVideoStreams - List of all video streams.\n * @param {string} options.parameters.islevel - The level of the user.\n * @param {string} options.parameters.member - The member name.\n * @param {boolean} options.parameters.shared - Indicates if the screen is shared.\n * @param {boolean} options.parameters.shareScreenStarted - Indicates if screen sharing has started.\n * @param {string} options.parameters.eventType - The type of event (e.g., \"broadcast\", \"chat\", \"conference\").\n * @param {string} options.parameters.screenId - The ID of the screen.\n * @param {boolean} options.parameters.forceFullDisplay - Indicates if full display is forced.\n * @param {Function} options.parameters.updateMainWindow - Function to update the main window.\n * @param {boolean} options.parameters.mainScreenFilled - Indicates if the main screen is filled.\n * @param {boolean} options.parameters.adminOnMainScreen - Indicates if admin is on the main screen.\n * @param {string} options.parameters.mainScreenPerson - The person on the main screen.\n * @param {boolean} options.parameters.videoAlreadyOn - Indicates if the video is already on.\n * @param {boolean} options.parameters.audioAlreadyOn - Indicates if the audio is already on.\n * @param {Array<Stream>} options.parameters.oldAllStreams - List of old all streams.\n * @param {Function} options.parameters.checkOrientation - Function to check orientation.\n * @param {boolean} options.parameters.screenForceFullDisplay - Indicates if screen force full display is enabled.\n * @param {Stream} options.parameters.localStreamScreen - The local screen stream.\n * @param {Array<Stream>} options.parameters.remoteScreenStream - List of remote screen streams.\n * @param {Stream} options.parameters.localStreamVideo - The local video stream.\n * @param {number} options.parameters.mainHeightWidth - The main height and width.\n * @param {boolean} options.parameters.isWideScreen - Indicates if the screen is wide.\n * @param {boolean} options.parameters.localUIMode - Indicates if local UI mode is enabled.\n * @param {boolean} options.parameters.whiteboardStarted - Indicates if whiteboard has started.\n * @param {boolean} options.parameters.whiteboardEnded - Indicates if whiteboard has ended.\n * @param {Stream} options.parameters.virtualStream - The virtual stream.\n * @param {boolean} options.parameters.keepBackground - Indicates if background should be kept.\n * @param {Stream} options.parameters.annotateScreenStream - The annotate screen stream.\n * @param {Function} options.parameters.updateMainScreenPerson - Function to update the main screen person.\n * @param {Function} options.parameters.updateMainScreenFilled - Function to update if the main screen is filled.\n * @param {Function} options.parameters.updateAdminOnMainScreen - Function to update if admin is on the main screen.\n * @param {Function} options.parameters.updateMainHeightWidth - Function to update the main height and width.\n * @param {Function} options.parameters.updateScreenForceFullDisplay - Function to update screen force full display.\n * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window update status.\n * @param {Function} options.parameters.updateMainGridStream - Function to update the main grid stream.\n *\n * @returns {Promise<{ component: any; inputs: any }[] | void>} A promise that resolves with the components and inputs or void.\n *\n * @throws {Error} Throws an error if there is an issue preparing and populating the main screen.\n *\n * @example\n * ```typescript\n * const options = {\n *   name: 'John Doe',\n *   parameters: {\n *     getUpdatedAllParams: () => { },\n *     participants: [],\n *     allVideoStreams: [],\n *     islevel: '1',\n *     member: 'John',\n *     shared: false,\n *     shareScreenStarted: false,\n *     eventType: 'conference',\n *     screenId: 'screen123',\n *     forceFullDisplay: false,\n *     updateMainWindow: false,\n *     mainScreenFilled: false,\n *     adminOnMainScreen: false,\n *     mainScreenPerson: '',\n *     videoAlreadyOn: false,\n *     audioAlreadyOn: false,\n *     oldAllStreams: [],\n *     checkOrientation: () => 'landscape',\n *     screenForceFullDisplay: false,\n *     localStreamScreen: null,\n *     remoteScreenStream: [],\n *     localStreamVideo: null,\n *     mainHeightWidth: 100,\n *     isWideScreen: true,\n *     localUIMode: false,\n *     whiteboardStarted: false,\n *     whiteboardEnded: false,\n *     virtualStream: null,\n *     keepBackground: false,\n *     annotateScreenStream: false,\n *     updateMainScreenPerson: (person) => { console.log(updated) },\n *     updateMainScreenFilled: (filled) => { console.log(updated) },\n *     updateAdminOnMainScreen: (admin) => { console.log(updated) },\n *     updateMainHeightWidth: (heightWidth) => { console.log(updated) },\n *     updateScreenForceFullDisplay: (force) => { console.log(updated) },\n *     updateUpdateMainWindow: (update) => { console.log(updated) },\n *     updateMainGridStream: (components) => { console.log(updated) },\n *   },\n * };\n *\n * await prepopulateUserMedia(options);\n * ```\n */\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class PrepopulateUserMedia {\n  /**\n   * Prepopulates the user media based on the provided options.\n   *\n   * @param {PrepopulateUserMediaOptions} options - The options for prepopulating user media.\n   * @param {string} options.name - The name of the user.\n   * @param {Parameters} options.parameters - The parameters for prepopulating user media.\n   * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.\n   * @param {Array<Participant>} options.parameters.participants - List of participants.\n   * @param {Array<Stream>} options.parameters.allVideoStreams - List of all video streams.\n   * @param {string} options.parameters.islevel - The level of the user.\n   * @param {string} options.parameters.member - The member name.\n   * @param {boolean} options.parameters.shared - Indicates if the screen is shared.\n   * @param {boolean} options.parameters.shareScreenStarted - Indicates if screen sharing has started.\n   * @param {string} options.parameters.eventType - The type of event.\n   * @param {string} options.parameters.screenId - The screen ID.\n   * @param {boolean} options.parameters.forceFullDisplay - Indicates if full display is forced.\n   * @param {Function} options.parameters.updateMainWindow - Function to update the main window.\n   * @param {boolean} options.parameters.mainScreenFilled - Indicates if the main screen is filled.\n   * @param {boolean} options.parameters.adminOnMainScreen - Indicates if admin is on the main screen.\n   * @param {string} options.parameters.mainScreenPerson - The person on the main screen.\n   * @param {boolean} options.parameters.videoAlreadyOn - Indicates if the video is already on.\n   * @param {boolean} options.parameters.audioAlreadyOn - Indicates if the audio is already on.\n   * @param {Array<Stream>} options.parameters.oldAllStreams - List of old all streams.\n   * @param {Function} options.parameters.checkOrientation - Function to check orientation.\n   * @param {boolean} options.parameters.screenForceFullDisplay - Indicates if screen force full display is enabled.\n   * @param {Stream} options.parameters.localStreamScreen - The local screen stream.\n   * @param {Array<Stream>} options.parameters.remoteScreenStream - List of remote screen streams.\n   * @param {Stream} options.parameters.localStreamVideo - The local video stream.\n   * @param {number} options.parameters.mainHeightWidth - The main height and width.\n   * @param {boolean} options.parameters.isWideScreen - Indicates if the screen is wide.\n   * @param {boolean} options.parameters.localUIMode - Indicates if local UI mode is enabled.\n   * @param {boolean} options.parameters.whiteboardStarted - Indicates if whiteboard has started.\n   * @param {boolean} options.parameters.whiteboardEnded - Indicates if whiteboard has ended.\n   * @param {Stream} options.parameters.virtualStream - The virtual stream.\n   * @param {boolean} options.parameters.keepBackground - Indicates if background should be kept.\n   * @param {Stream} options.parameters.annotateScreenStream - The annotate screen stream.\n   * @param {Function} options.parameters.updateMainScreenPerson - Function to update the main screen person.\n   * @param {Function} options.parameters.updateMainScreenFilled - Function to update if the main screen is filled.\n   * @param {Function} options.parameters.updateAdminOnMainScreen - Function to update if admin is on the main screen.\n   * @param {Function} options.parameters.updateMainHeightWidth - Function to update the main height and width.\n   * @param {Function} options.parameters.updateScreenForceFullDisplay - Function to update screen force full display.\n   * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window update status.\n   * @param {Function} options.parameters.updateMainGridStream - Function to update the main grid stream.\n   *\n   * @returns {Promise<{ component: any, inputs: any }[] | void>} A promise that resolves with the components and inputs or void.\n   */\n  prepopulateUserMedia = async ({\n    name,\n    parameters,\n  }: PrepopulateUserMediaOptions): Promise<{ component: any; inputs: any }[] | void> => {\n    try {\n      // Destructure parameters\n\n      let { getUpdatedAllParams } = parameters;\n      parameters = getUpdatedAllParams();\n\n      let {\n        participants,\n        allVideoStreams,\n        islevel,\n        member,\n        shared,\n        shareScreenStarted,\n        eventType,\n        screenId,\n        forceFullDisplay,\n        updateMainWindow,\n        mainScreenFilled,\n        adminOnMainScreen,\n        mainScreenPerson,\n        videoAlreadyOn,\n        audioAlreadyOn,\n        oldAllStreams,\n        checkOrientation,\n        screenForceFullDisplay,\n\n        localStreamScreen,\n        remoteScreenStream,\n        localStreamVideo,\n        mainHeightWidth,\n        isWideScreen,\n        localUIMode,\n        whiteboardStarted,\n        whiteboardEnded,\n\n        virtualStream,\n        keepBackground,\n        annotateScreenStream,\n\n        updateMainScreenPerson,\n        updateMainScreenFilled,\n        updateAdminOnMainScreen,\n        updateMainHeightWidth,\n        updateScreenForceFullDisplay,\n        updateUpdateMainWindow,\n        updateMainGridStream,\n      } = parameters;\n\n      // If the event type is 'chat', return early\n      if (eventType == 'chat') {\n        return;\n      }\n\n      // Initialize variables\n      let host: Participant | null;\n      let hostStream: any;\n      let newComponents: { component: any; inputs: any }[] = [];\n\n      // Check if screen sharing is started or shared\n      if (shareScreenStarted || shared) {\n        // Handle main grid visibility based on the event type\n        if (eventType == 'conference') {\n          if (shared || shareScreenStarted) {\n            if (mainHeightWidth == 0) {\n              // Add the main grid if not present\n              updateMainHeightWidth(84);\n            }\n          } else {\n            // Remove the main grid if not shared or started\n            updateMainHeightWidth(0);\n          }\n        }\n\n        // Switch display to optimize for screen share\n        screenForceFullDisplay = forceFullDisplay;\n\n        updateScreenForceFullDisplay(screenForceFullDisplay);\n\n        // Get the orientation and adjust forceFullDisplay\n        let orientation = checkOrientation();\n        if (orientation == 'portrait' || !isWideScreen) {\n          if (shareScreenStarted || shared) {\n            screenForceFullDisplay = false;\n            updateScreenForceFullDisplay(screenForceFullDisplay);\n          }\n        }\n\n        // Check if the user is sharing the screen\n        if (shared) {\n          // User is sharing\n          host = { name: member, audioID: '', videoID: '' };\n          hostStream = localStreamScreen;\n\n          // Update admin on the main screen\n          adminOnMainScreen = islevel == '2';\n          updateAdminOnMainScreen(adminOnMainScreen);\n\n          // Update main screen person\n          mainScreenPerson = host.name || '';\n          updateMainScreenPerson(mainScreenPerson);\n        } else {\n          //someone else is sharing\n          host =\n            participants.find(\n              (participant: Participant) =>\n                participant.ScreenID == screenId && participant.ScreenOn == true,\n            ) ?? null;\n\n          if (whiteboardStarted && !whiteboardEnded) {\n            host = { name: 'WhiteboardActive', islevel: '2', audioID: '', videoID: '' };\n            hostStream = { producerId: 'WhiteboardActive' };\n          }\n\n          if (host == null) {\n            // remoteScreenStream\n            host =\n              participants.find((participant: Participant) => participant.ScreenOn == true) ?? null;\n          }\n\n          // check remoteScreenStream\n          if (host != null && !host?.name?.includes('WhiteboardActive')) {\n            if (remoteScreenStream.length == 0) {\n              hostStream =\n                allVideoStreams.find(\n                  (stream: Stream | Participant) => stream.producerId == host?.ScreenID,\n                ) ?? null;\n            } else {\n              hostStream = remoteScreenStream[0];\n            }\n          }\n\n          // Update admin on the main screen\n          adminOnMainScreen = (host && host.islevel == '2') ?? false;\n          updateAdminOnMainScreen(adminOnMainScreen);\n\n          // Update main screen person\n          mainScreenPerson = host?.name ?? '';\n          updateMainScreenPerson(mainScreenPerson);\n        }\n      } else {\n        // Screen share not started\n        if (eventType == 'conference') {\n          // No main grid for conferences\n          return;\n        }\n\n        // Find the host with level '2'\n        host = participants.find((participant: Participant) => participant.islevel == '2') ?? null;\n\n        // Update main screen person\n        mainScreenPerson = host?.name ?? '';\n        updateMainScreenPerson(mainScreenPerson);\n      }\n\n      // If host is not null, check if host videoIsOn\n      if (host) {\n        // Populate the main screen with the host video\n        if (shareScreenStarted || shared) {\n          forceFullDisplay = screenForceFullDisplay;\n          if (whiteboardStarted && !whiteboardEnded) {\n            // Whiteboard is active\n          } else {\n            newComponents.push({\n              component: VideoCard,\n              inputs: {\n                videoStream: shared ? hostStream : hostStream.stream,\n                remoteProducerId: host.ScreenID,\n                eventType,\n                forceFullDisplay: annotateScreenStream && shared ? false : forceFullDisplay,\n                customStyle: {\n                  border: eventType !== 'broadcast' ? '2px solid black' : '0px solid black',\n                },\n                participant: host,\n                backgroundColor: 'rgba(217, 227, 234, 0.99)',\n                showControls: false,\n                showInfo: true,\n                name: host.name,\n                doMirror: false,\n                parameters,\n              },\n            });\n          }\n\n          updateMainGridStream(newComponents);\n\n          mainScreenFilled = true;\n          updateMainScreenFilled(mainScreenFilled);\n          adminOnMainScreen = host.islevel == '2';\n          updateAdminOnMainScreen(adminOnMainScreen);\n          mainScreenPerson = host.name ?? '';\n          updateMainScreenPerson(mainScreenPerson);\n\n          return newComponents;\n        }\n\n        // Check if video is already on or not\n        if (\n          (islevel != '2' && !host['videoOn']) ||\n          (islevel == '2' && (!host['videoOn'] || !videoAlreadyOn)) ||\n          localUIMode == true\n        ) {\n          // Video is off\n          if (islevel == '2' && videoAlreadyOn) {\n            // Admin's video is on\n            newComponents.push({\n              component: VideoCard,\n              inputs: {\n                videoStream: keepBackground && virtualStream ? virtualStream : localStreamVideo,\n                remoteProducerId: host.videoID,\n                eventType,\n                forceFullDisplay,\n                customStyle: {\n                  border: eventType !== 'broadcast' ? '2px solid black' : '0px solid black',\n                },\n                participant: host,\n                backgroundColor: 'rgba(217, 227, 234, 0.99)',\n                showControls: false,\n                showInfo: true,\n                name: host.name,\n                doMirror: true,\n                parameters,\n              },\n            });\n            updateMainGridStream(newComponents);\n\n            mainScreenFilled = true;\n            updateMainScreenFilled(mainScreenFilled);\n            adminOnMainScreen = true;\n            updateAdminOnMainScreen(adminOnMainScreen);\n            mainScreenPerson = host.name ?? '';\n            updateMainScreenPerson(mainScreenPerson);\n          } else {\n            // Video is off and not admin\n            let audOn;\n\n            if (islevel == '2' && audioAlreadyOn) {\n              audOn = true;\n            } else {\n              if (host != null && islevel != '2') {\n                audOn = host['muted'] == false;\n              }\n            }\n\n            if (audOn) {\n              // Audio is on\n              try {\n                newComponents.push({\n                  component: AudioCard,\n                  inputs: {\n                    name: host.name,\n                    barColor: 'red',\n                    textColor: 'white',\n                    customStyle: {\n                      backgroundColor: 'transparent',\n                      border: eventType !== 'broadcast' ? '2px solid black' : '0px solid black',\n                    },\n                    controlsPosition: 'topLeft',\n                    infoPosition: 'topRight',\n                    showWaveform: true,\n                    roundedImage: true,\n                    parameters: parameters,\n                    showControls: false,\n                    backgroundColor: 'transparent',\n                  },\n                });\n\n                updateMainGridStream(newComponents);\n              } catch (error) {\n                // Handle audio card creation error\n              }\n\n              mainScreenFilled = true;\n              updateMainScreenFilled(mainScreenFilled);\n              adminOnMainScreen = islevel == '2';\n              updateAdminOnMainScreen(adminOnMainScreen);\n              mainScreenPerson = host.name ?? '';\n              updateMainScreenPerson(mainScreenPerson);\n            } else {\n              // Audio is off\n              try {\n                newComponents.push({\n                  component: MiniCard,\n                  inputs: {\n                    initials: name,\n                    fontSize: 20,\n                    customStyle: {\n                      backgroundColor: 'transparent',\n                      border: eventType !== 'broadcast' ? '2px solid black' : '0px solid black',\n                    },\n                  },\n                });\n                updateMainGridStream(newComponents);\n              } catch (error) {\n                // Handle mini card creation error\n              }\n\n              mainScreenFilled = false;\n              updateMainScreenFilled(mainScreenFilled);\n              adminOnMainScreen = islevel == '2';\n              updateAdminOnMainScreen(adminOnMainScreen);\n              mainScreenPerson = host.name ?? '';\n              updateMainScreenPerson(mainScreenPerson);\n            }\n          }\n        } else {\n          // Video is on\n          if (shareScreenStarted || shared) {\n            // Screen share is on\n            if (whiteboardStarted && !whiteboardEnded) {\n              // Whiteboard is active\n            } else {\n              try {\n                newComponents.push({\n                  component: VideoCard,\n                  inputs: {\n                    videoStream: shared ? hostStream : hostStream.stream,\n                    remoteProducerId: host.ScreenID,\n                    eventType,\n                    forceFullDisplay,\n                    customStyle: {\n                      border: eventType !== 'broadcast' ? '2px solid black' : '0px solid black',\n                    },\n                    participant: host,\n                    backgroundColor: 'rgba(217, 227, 234, 0.99)',\n                    showControls: false,\n                    showInfo: true,\n                    name: host.name,\n                    doMirror: false,\n                    parameters,\n                  },\n                });\n\n                updateMainGridStream(newComponents);\n\n                mainScreenFilled = true;\n                updateMainScreenFilled(mainScreenFilled);\n                adminOnMainScreen = host.islevel == '2';\n                updateAdminOnMainScreen(adminOnMainScreen);\n                mainScreenPerson = host.name ?? '';\n                updateMainScreenPerson(mainScreenPerson);\n              } catch (error) {\n                // Handle video card creation error\n              }\n            }\n          } else {\n            // Screen share is off\n            let streame;\n            if (islevel == '2') {\n              host['stream'] = keepBackground && virtualStream ? virtualStream : localStreamVideo;\n            } else {\n              streame = oldAllStreams.find(\n                (streame: Stream | Participant) => streame.producerId == host.videoID,\n              );\n              host['stream'] = streame && streame.stream;\n            }\n\n            try {\n              if (host['stream']) {\n                newComponents.push({\n                  component: VideoCard,\n                  inputs: {\n                    videoStream: host['stream'],\n                    remoteProducerId: host.videoID,\n                    eventType,\n                    forceFullDisplay,\n                    customStyle: {\n                      border: eventType !== 'broadcast' ? '2px solid black' : '0px solid black',\n                    },\n                    participant: host,\n                    backgroundColor: 'rgba(217, 227, 234, 0.99)',\n                    showControls: false,\n                    showInfo: true,\n                    name: host.name,\n                    doMirror: member == host.name,\n                    parameters,\n                  },\n                });\n\n                updateMainGridStream(newComponents);\n\n                mainScreenFilled = true;\n                adminOnMainScreen = host.islevel == '2';\n                mainScreenPerson = host.name ?? '';\n              } else {\n                newComponents.push({\n                  component: MiniCard,\n                  inputs: {\n                    initials: name,\n                    fontSize: 20,\n                    customStyle: {\n                      backgroundColor: 'transparent',\n                      border: eventType !== 'broadcast' ? '2px solid black' : '0px solid black',\n                    },\n                  },\n                });\n\n                updateMainGridStream(newComponents);\n                mainScreenFilled = false;\n                adminOnMainScreen = islevel == '2';\n                mainScreenPerson = host.name ?? '';\n              }\n\n              updateMainScreenFilled(mainScreenFilled);\n\n              updateAdminOnMainScreen(adminOnMainScreen);\n\n              updateMainScreenPerson(mainScreenPerson);\n            } catch (error) {\n              // Handle video card creation error\n            }\n          }\n        }\n      } else {\n        // Host is null, add a mini card\n        try {\n          newComponents.push({\n            component: MiniCard,\n            inputs: {\n              initials: name,\n              fontSize: 20,\n              customStyle: {\n                backgroundColor: 'transparent',\n                border: eventType !== 'broadcast' ? '2px solid black' : '0px solid black',\n              },\n            },\n          });\n\n          updateMainGridStream(newComponents);\n\n          mainScreenFilled = false;\n          adminOnMainScreen = false;\n          mainScreenPerson = '';\n          updateMainScreenFilled(mainScreenFilled);\n          updateAdminOnMainScreen(adminOnMainScreen);\n          updateMainScreenPerson(mainScreenPerson);\n        } catch (error) {\n          // Handle mini card creation error\n        }\n      }\n\n      updateMainWindow = false;\n      updateUpdateMainWindow(updateMainWindow);\n\n      return newComponents;\n    } catch (error: any) {\n      // Handle errors during the process of preparing and populating the main screen\n      console.log('Error preparing and populating the main screen:', error.message);\n      return [];\n    }\n  };\n}\n"]}

package/dist/esm2022/lib/consumers/process-consumer-transports-audio.service.mjs

@@ -1,5 +1,34 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Processes consumer transports for audio streams by pausing and resuming them based on their current state and the provided streams.
+ *
+ * This method checks the state of each audio consumer transport and either pauses or resumes it depending on the presence of its producer ID in the provided list of streams.
+ * It uses a sleep function to introduce a delay between the pause and resume operations to ensure smooth transitions.
+ *
+ * @param {ProcessConsumerTransportsAudioOptions} options - The options for processing consumer transports.
+ * @param {Array<Transport>} options.consumerTransports - The list of consumer transports to process.
+ * @param {Array<(Stream | Participant)>} options.lStreams - The list of local streams to check against.
+ * @param {ProcessConsumerTransportsAudioParameters} options.parameters - Additional parameters for processing.
+ * @param {Function} options.parameters.sleep - A function to pause execution for a specified duration.
+ *
+ * @returns {Promise<void>} A promise that resolves when the processing is complete.
+ *
+ * @throws {Error} Will throw an error if there is an issue processing the consumer transports.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   consumerTransports: [,
+ *   lStreams: [],
+ *   parameters: {
+ *     sleep: async ({ ms }) => new Promise(resolve => setTimeout(resolve, ms)),
+ *   },
+ * };
+ *
+ * await processConsumerTransportsAudio(options);
+ * ```
+ */
 export class ProcessConsumerTransportsAudio {
     /**
      * Processes consumer transports for audio streams by pausing and resuming them based on their current state and the provided streams.
@@ -69,4 +98,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"process-consumer-transports-audio.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/process-consumer-transports-audio.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Stream, Transport, Participant, SleepType } from '../@types/types';\n\nexport interface ProcessConsumerTransportsAudioParameters {\n  // mediasfu functions\n  sleep: SleepType;\n  [key: string]: any;\n}\n\nexport interface ProcessConsumerTransportsAudioOptions {\n  consumerTransports: Transport[];\n  lStreams: (Stream | Participant)[];\n  parameters: ProcessConsumerTransportsAudioParameters;\n}\n\n// Export the type definition for the function\nexport type ProcessConsumerTransportsAudioType = (\n  options: ProcessConsumerTransportsAudioOptions,\n) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ProcessConsumerTransportsAudio {\n  /**\n   * Processes consumer transports for audio streams by pausing and resuming them based on their current state and the provided streams.\n   *\n   * @param {Object} options - The options for processing consumer transports.\n   * @param {Array} options.consumerTransports - The list of consumer transports to process.\n   * @param {Array} options.lStreams - The list of local streams to check against.\n   * @param {Object} options.parameters - Additional parameters for processing.\n   * @param {Function} options.parameters.sleep - A function to pause execution for a specified duration.\n   *\n   * @returns {Promise<void>} A promise that resolves when the processing is complete.\n   *\n   * @throws Will throw an error if there is an issue processing the consumer transports.\n   */\n  processConsumerTransportsAudio = async ({\n    consumerTransports,\n    lStreams,\n    parameters,\n  }: ProcessConsumerTransportsAudioOptions): Promise<void> => {\n    try {\n      const { sleep } = parameters;\n\n      // Function to check if the producerId is valid\n      const isValidProducerId = (\n        producerId: string,\n        ...streamArrays: (Stream | Participant)[][]\n      ): boolean => {\n        return (\n          producerId !== null &&\n          producerId !== '' &&\n          streamArrays.some((streamArray) => {\n            return (\n              streamArray.length > 0 &&\n              streamArray.some((stream) => stream?.producerId === producerId)\n            );\n          })\n        );\n      };\n\n      // Get paused consumer transports that are audio\n      const consumerTransportsToResume = consumerTransports.filter(\n        (transport) =>\n          isValidProducerId(transport.producerId, lStreams) &&\n          transport.consumer?.paused === true &&\n          transport.consumer.kind === 'audio',\n      );\n\n      // Get unpaused consumer transports that are audio\n      const consumerTransportsToPause = consumerTransports.filter(\n        (transport) =>\n          transport.producerId &&\n          transport.producerId !== null &&\n          transport.producerId !== '' &&\n          !lStreams.some((stream) => stream.producerId === transport.producerId) &&\n          transport.consumer &&\n          transport.consumer.kind &&\n          transport.consumer.paused !== true &&\n          transport.consumer.kind === 'audio',\n      );\n\n      await sleep({ ms: 100 });\n\n      // Emit consumer.pause() for each transport to pause\n      for (const transport of consumerTransportsToPause) {\n        transport.consumer.pause();\n        transport.socket_.emit(\n          'consumer-pause',\n          { serverConsumerId: transport.serverConsumerTransportId },\n          async () => {\n            // Do something after the consumer is paused\n          },\n        );\n      }\n\n      // Emit consumer.resume() for each transport to resume\n      for (const transport of consumerTransportsToResume) {\n        transport.socket_.emit(\n          'consumer-resume',\n          { serverConsumerId: transport.serverConsumerTransportId },\n          async ({ resumed }: { resumed: boolean }) => {\n            if (resumed) {\n              transport.consumer.resume();\n            }\n          },\n        );\n      }\n    } catch (error: any) {\n      console.log(`Error in processConsumerTransportsAudio: ${error.message}`);\n    }\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"process-consumer-transports-audio.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/process-consumer-transports-audio.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Stream, Transport, Participant, SleepType } from '../@types/types';\n\nexport interface ProcessConsumerTransportsAudioParameters {\n  // mediasfu functions\n  sleep: SleepType;\n  [key: string]: any;\n}\n\nexport interface ProcessConsumerTransportsAudioOptions {\n  consumerTransports: Transport[];\n  lStreams: (Stream | Participant)[];\n  parameters: ProcessConsumerTransportsAudioParameters;\n}\n\n// Export the type definition for the function\nexport type ProcessConsumerTransportsAudioType = (\n  options: ProcessConsumerTransportsAudioOptions,\n) => Promise<void>;\n\n/**\n * Processes consumer transports for audio streams by pausing and resuming them based on their current state and the provided streams.\n *\n * This method checks the state of each audio consumer transport and either pauses or resumes it depending on the presence of its producer ID in the provided list of streams.\n * It uses a sleep function to introduce a delay between the pause and resume operations to ensure smooth transitions.\n *\n * @param {ProcessConsumerTransportsAudioOptions} options - The options for processing consumer transports.\n * @param {Array<Transport>} options.consumerTransports - The list of consumer transports to process.\n * @param {Array<(Stream | Participant)>} options.lStreams - The list of local streams to check against.\n * @param {ProcessConsumerTransportsAudioParameters} options.parameters - Additional parameters for processing.\n * @param {Function} options.parameters.sleep - A function to pause execution for a specified duration.\n *\n * @returns {Promise<void>} A promise that resolves when the processing is complete.\n *\n * @throws {Error} Will throw an error if there is an issue processing the consumer transports.\n *\n * @example\n * ```typescript\n * const options = {\n *   consumerTransports: [,\n *   lStreams: [],\n *   parameters: {\n *     sleep: async ({ ms }) => new Promise(resolve => setTimeout(resolve, ms)),\n *   },\n * };\n *\n * await processConsumerTransportsAudio(options);\n * ```\n */\n\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ProcessConsumerTransportsAudio {\n  /**\n   * Processes consumer transports for audio streams by pausing and resuming them based on their current state and the provided streams.\n   *\n   * @param {Object} options - The options for processing consumer transports.\n   * @param {Array} options.consumerTransports - The list of consumer transports to process.\n   * @param {Array} options.lStreams - The list of local streams to check against.\n   * @param {Object} options.parameters - Additional parameters for processing.\n   * @param {Function} options.parameters.sleep - A function to pause execution for a specified duration.\n   *\n   * @returns {Promise<void>} A promise that resolves when the processing is complete.\n   *\n   * @throws Will throw an error if there is an issue processing the consumer transports.\n   */\n  processConsumerTransportsAudio = async ({\n    consumerTransports,\n    lStreams,\n    parameters,\n  }: ProcessConsumerTransportsAudioOptions): Promise<void> => {\n    try {\n      const { sleep } = parameters;\n\n      // Function to check if the producerId is valid\n      const isValidProducerId = (\n        producerId: string,\n        ...streamArrays: (Stream | Participant)[][]\n      ): boolean => {\n        return (\n          producerId !== null &&\n          producerId !== '' &&\n          streamArrays.some((streamArray) => {\n            return (\n              streamArray.length > 0 &&\n              streamArray.some((stream) => stream?.producerId === producerId)\n            );\n          })\n        );\n      };\n\n      // Get paused consumer transports that are audio\n      const consumerTransportsToResume = consumerTransports.filter(\n        (transport) =>\n          isValidProducerId(transport.producerId, lStreams) &&\n          transport.consumer?.paused === true &&\n          transport.consumer.kind === 'audio',\n      );\n\n      // Get unpaused consumer transports that are audio\n      const consumerTransportsToPause = consumerTransports.filter(\n        (transport) =>\n          transport.producerId &&\n          transport.producerId !== null &&\n          transport.producerId !== '' &&\n          !lStreams.some((stream) => stream.producerId === transport.producerId) &&\n          transport.consumer &&\n          transport.consumer.kind &&\n          transport.consumer.paused !== true &&\n          transport.consumer.kind === 'audio',\n      );\n\n      await sleep({ ms: 100 });\n\n      // Emit consumer.pause() for each transport to pause\n      for (const transport of consumerTransportsToPause) {\n        transport.consumer.pause();\n        transport.socket_.emit(\n          'consumer-pause',\n          { serverConsumerId: transport.serverConsumerTransportId },\n          async () => {\n            // Do something after the consumer is paused\n          },\n        );\n      }\n\n      // Emit consumer.resume() for each transport to resume\n      for (const transport of consumerTransportsToResume) {\n        transport.socket_.emit(\n          'consumer-resume',\n          { serverConsumerId: transport.serverConsumerTransportId },\n          async ({ resumed }: { resumed: boolean }) => {\n            if (resumed) {\n              transport.consumer.resume();\n            }\n          },\n        );\n      }\n    } catch (error: any) {\n      console.log(`Error in processConsumerTransportsAudio: ${error.message}`);\n    }\n  };\n}\n"]}

package/dist/esm2022/lib/consumers/process-consumer-transports.service.mjs

@@ -1,5 +1,42 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Processes consumer transports by pausing and resuming them based on certain conditions.
+ *
+ * This method checks the state of each consumer transport and determines whether to pause or resume
+ * based on the validity of the producer ID in relation to the provided streams.
+ * It utilizes a sleep function to introduce a delay before pausing the transports.
+ *
+ * @param {ProcessConsumerTransportsOptions} options - The options for processing consumer transports.
+ * @param {Array<Transport>} options.consumerTransports - The list of consumer transports to process.
+ * @param {Array<Stream | Participant>} options.lStreams_ - The list of local streams.
+ * @param {ProcessConsumerTransportsParameters} options.parameters - The parameters for processing, including:
+ *   - {Array<Stream>} options.parameters.remoteScreenStream - The list of remote screen streams.
+ *   - {Array<Stream | Participant>} options.parameters.oldAllStreams - The list of old streams.
+ *   - {Array<Stream | Participant>} options.parameters.newLimitedStreams - The list of new limited streams.
+ *   - {Function} options.parameters.sleep - A function to pause execution for a specified duration.
+ *   - {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+ *
+ * @returns {Promise<void>} A promise that resolves when the processing is complete.
+ *
+ * @throws {Error} Will throw an error if there is an issue processing consumer transports.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   consumerTransports: [],
+ *   lStreams_: [],
+ *   parameters: {
+ *     remoteScreenStream: [],
+ *     oldAllStreams: [],
+ *     newLimitedStreams: [],
+ *     sleep: async ({ ms }) => new Promise(resolve => setTimeout(resolve, ms)),
+ *   },
+ * };
+ *
+ * await processConsumerTransports(options);
+ * ```
+ */
 export class ProcessConsumerTransports {
     /**
      * Processes consumer transports by pausing and resuming them based on certain conditions.
@@ -88,4 +125,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"process-consumer-transports.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/process-consumer-transports.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Stream, Participant, Transport, SleepType } from '../@types/types';\n\nexport interface ProcessConsumerTransportsParameters {\n  remoteScreenStream: Stream[];\n  oldAllStreams: (Stream | Participant)[];\n  newLimitedStreams: (Stream | Participant)[];\n\n  // mediasfu functions\n  sleep: SleepType;\n  getUpdatedAllParams: () => ProcessConsumerTransportsParameters;\n  [key: string]: any;\n}\n\nexport interface ProcessConsumerTransportsOptions {\n  consumerTransports: Transport[];\n  lStreams_: (Stream | Participant)[];\n  parameters: ProcessConsumerTransportsParameters;\n}\n\n// Export the type definition for the function\nexport type ProcessConsumerTransportsType = (\n  options: ProcessConsumerTransportsOptions,\n) => Promise<void>;\n@Injectable({\n  providedIn: 'root',\n})\nexport class ProcessConsumerTransports {\n  /**\n   * Processes consumer transports by pausing and resuming them based on certain conditions.\n   *\n   * @param {Object} options - The options for processing consumer transports.\n   * @param {Array} options.consumerTransports - The list of consumer transports to process.\n   * @param {Array} options.lStreams_ - The list of local streams.\n   * @param {Object} options.parameters - The parameters object containing various stream arrays and utility functions.\n   *\n   * @returns {Promise<void>} - A promise that resolves when the processing is complete.\n   *\n   * @throws {Error} - Throws an error if there is an issue processing consumer transports.\n   *\n   * The function performs the following steps:\n   * 1. Destructures and updates the parameters.\n   * 2. Defines a helper function to check if a producerId is valid in given stream arrays.\n   * 3. Filters consumer transports to resume based on certain conditions.\n   * 4. Filters consumer transports to pause based on certain conditions.\n   * 5. Pauses consumer transports after a short delay.\n   * 6. Emits `consumer-pause` event for each filtered transport (not audio).\n   * 7. Emits `consumer-resume` event for each filtered transport (not audio).\n   */\n  processConsumerTransports = async ({\n    consumerTransports,\n    lStreams_,\n    parameters,\n  }: ProcessConsumerTransportsOptions): Promise<void> => {\n    try {\n      // Destructure parameters\n      let { getUpdatedAllParams } = parameters;\n      parameters = getUpdatedAllParams();\n\n      const {\n        remoteScreenStream,\n        oldAllStreams,\n        newLimitedStreams,\n        // mediasfu functions\n        sleep,\n      } = parameters;\n\n      // Function to check if the producerId is valid in the given stream arrays\n      const isValidProducerId = (\n        producerId: string,\n        ...streamArrays: (Stream | Participant)[][]\n      ): boolean => {\n        return (\n          producerId !== null &&\n          producerId !== '' &&\n          streamArrays.some((streamArray) => {\n            return (\n              streamArray.length > 0 &&\n              streamArray.some((stream) => stream?.producerId === producerId)\n            );\n          })\n        );\n      };\n\n      // Get paused consumer transports that are not audio\n      const consumerTransportsToResume = consumerTransports.filter(\n        (transport) =>\n          isValidProducerId(\n            transport.producerId,\n            lStreams_,\n            remoteScreenStream,\n            oldAllStreams,\n            newLimitedStreams,\n          ) &&\n          transport.consumer?.paused === true &&\n          transport.consumer.kind !== 'audio',\n      );\n\n      // Get unpaused consumer transports that are not audio\n      const consumerTransportsToPause = consumerTransports.filter(\n        (transport) =>\n          transport.producerId &&\n          transport.producerId !== null &&\n          transport.producerId !== '' &&\n          !lStreams_.some((stream) => stream.producerId === transport.producerId) &&\n          transport.consumer &&\n          transport.consumer.kind &&\n          transport.consumer.paused !== true &&\n          transport.consumer.kind !== 'audio' &&\n          !remoteScreenStream.some((stream: any) => stream.producerId === transport.producerId) &&\n          !oldAllStreams.some((stream: any) => stream.producerId === transport.producerId) &&\n          !newLimitedStreams.some((stream: any) => stream.producerId === transport.producerId),\n      );\n\n      // Pause consumer transports after a short delay\n      await sleep({ ms: 100 });\n\n      // Emit consumer.pause() for each filtered transport (not audio)\n      for (const transport of consumerTransportsToPause) {\n        transport.consumer.pause();\n        transport.socket_.emit(\n          'consumer-pause',\n          { serverConsumerId: transport.serverConsumerTransportId },\n          async () => {\n            // Handle the response if needed\n          },\n        );\n      }\n\n      // Emit consumer.resume() for each filtered transport (not audio)\n      for (const transport of consumerTransportsToResume) {\n        transport.socket_.emit(\n          'consumer-resume',\n          { serverConsumerId: transport.serverConsumerTransportId },\n          async ({ resumed }: { resumed: boolean }) => {\n            if (resumed) {\n              transport.consumer.resume();\n            }\n          },\n        );\n      }\n    } catch (error: any) {\n      // Handle errors during the process of pausing or resuming consumer transports\n      console.log(`Error processing consumer transports: ${error.message}`);\n      // throw new Error(`Error processing consumer transports: ${error.message}`);\n    }\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"process-consumer-transports.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/process-consumer-transports.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Stream, Participant, Transport, SleepType } from '../@types/types';\n\nexport interface ProcessConsumerTransportsParameters {\n  remoteScreenStream: Stream[];\n  oldAllStreams: (Stream | Participant)[];\n  newLimitedStreams: (Stream | Participant)[];\n\n  // mediasfu functions\n  sleep: SleepType;\n  getUpdatedAllParams: () => ProcessConsumerTransportsParameters;\n  [key: string]: any;\n}\n\nexport interface ProcessConsumerTransportsOptions {\n  consumerTransports: Transport[];\n  lStreams_: (Stream | Participant)[];\n  parameters: ProcessConsumerTransportsParameters;\n}\n\n// Export the type definition for the function\nexport type ProcessConsumerTransportsType = (\n  options: ProcessConsumerTransportsOptions,\n) => Promise<void>;\n\n/**\n * Processes consumer transports by pausing and resuming them based on certain conditions.\n *\n * This method checks the state of each consumer transport and determines whether to pause or resume\n * based on the validity of the producer ID in relation to the provided streams.\n * It utilizes a sleep function to introduce a delay before pausing the transports.\n *\n * @param {ProcessConsumerTransportsOptions} options - The options for processing consumer transports.\n * @param {Array<Transport>} options.consumerTransports - The list of consumer transports to process.\n * @param {Array<Stream | Participant>} options.lStreams_ - The list of local streams.\n * @param {ProcessConsumerTransportsParameters} options.parameters - The parameters for processing, including:\n *   - {Array<Stream>} options.parameters.remoteScreenStream - The list of remote screen streams.\n *   - {Array<Stream | Participant>} options.parameters.oldAllStreams - The list of old streams.\n *   - {Array<Stream | Participant>} options.parameters.newLimitedStreams - The list of new limited streams.\n *   - {Function} options.parameters.sleep - A function to pause execution for a specified duration.\n *   - {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.\n *\n * @returns {Promise<void>} A promise that resolves when the processing is complete.\n *\n * @throws {Error} Will throw an error if there is an issue processing consumer transports.\n *\n * @example\n * ```typescript\n * const options = {\n *   consumerTransports: [],\n *   lStreams_: [],\n *   parameters: {\n *     remoteScreenStream: [],\n *     oldAllStreams: [],\n *     newLimitedStreams: [],\n *     sleep: async ({ ms }) => new Promise(resolve => setTimeout(resolve, ms)),\n *   },\n * };\n *\n * await processConsumerTransports(options);\n * ```\n */\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ProcessConsumerTransports {\n  /**\n   * Processes consumer transports by pausing and resuming them based on certain conditions.\n   *\n   * @param {Object} options - The options for processing consumer transports.\n   * @param {Array} options.consumerTransports - The list of consumer transports to process.\n   * @param {Array} options.lStreams_ - The list of local streams.\n   * @param {Object} options.parameters - The parameters object containing various stream arrays and utility functions.\n   *\n   * @returns {Promise<void>} - A promise that resolves when the processing is complete.\n   *\n   * @throws {Error} - Throws an error if there is an issue processing consumer transports.\n   *\n   * The function performs the following steps:\n   * 1. Destructures and updates the parameters.\n   * 2. Defines a helper function to check if a producerId is valid in given stream arrays.\n   * 3. Filters consumer transports to resume based on certain conditions.\n   * 4. Filters consumer transports to pause based on certain conditions.\n   * 5. Pauses consumer transports after a short delay.\n   * 6. Emits `consumer-pause` event for each filtered transport (not audio).\n   * 7. Emits `consumer-resume` event for each filtered transport (not audio).\n   */\n  processConsumerTransports = async ({\n    consumerTransports,\n    lStreams_,\n    parameters,\n  }: ProcessConsumerTransportsOptions): Promise<void> => {\n    try {\n      // Destructure parameters\n      let { getUpdatedAllParams } = parameters;\n      parameters = getUpdatedAllParams();\n\n      const {\n        remoteScreenStream,\n        oldAllStreams,\n        newLimitedStreams,\n        // mediasfu functions\n        sleep,\n      } = parameters;\n\n      // Function to check if the producerId is valid in the given stream arrays\n      const isValidProducerId = (\n        producerId: string,\n        ...streamArrays: (Stream | Participant)[][]\n      ): boolean => {\n        return (\n          producerId !== null &&\n          producerId !== '' &&\n          streamArrays.some((streamArray) => {\n            return (\n              streamArray.length > 0 &&\n              streamArray.some((stream) => stream?.producerId === producerId)\n            );\n          })\n        );\n      };\n\n      // Get paused consumer transports that are not audio\n      const consumerTransportsToResume = consumerTransports.filter(\n        (transport) =>\n          isValidProducerId(\n            transport.producerId,\n            lStreams_,\n            remoteScreenStream,\n            oldAllStreams,\n            newLimitedStreams,\n          ) &&\n          transport.consumer?.paused === true &&\n          transport.consumer.kind !== 'audio',\n      );\n\n      // Get unpaused consumer transports that are not audio\n      const consumerTransportsToPause = consumerTransports.filter(\n        (transport) =>\n          transport.producerId &&\n          transport.producerId !== null &&\n          transport.producerId !== '' &&\n          !lStreams_.some((stream) => stream.producerId === transport.producerId) &&\n          transport.consumer &&\n          transport.consumer.kind &&\n          transport.consumer.paused !== true &&\n          transport.consumer.kind !== 'audio' &&\n          !remoteScreenStream.some((stream: any) => stream.producerId === transport.producerId) &&\n          !oldAllStreams.some((stream: any) => stream.producerId === transport.producerId) &&\n          !newLimitedStreams.some((stream: any) => stream.producerId === transport.producerId),\n      );\n\n      // Pause consumer transports after a short delay\n      await sleep({ ms: 100 });\n\n      // Emit consumer.pause() for each filtered transport (not audio)\n      for (const transport of consumerTransportsToPause) {\n        transport.consumer.pause();\n        transport.socket_.emit(\n          'consumer-pause',\n          { serverConsumerId: transport.serverConsumerTransportId },\n          async () => {\n            // Handle the response if needed\n          },\n        );\n      }\n\n      // Emit consumer.resume() for each filtered transport (not audio)\n      for (const transport of consumerTransportsToResume) {\n        transport.socket_.emit(\n          'consumer-resume',\n          { serverConsumerId: transport.serverConsumerTransportId },\n          async ({ resumed }: { resumed: boolean }) => {\n            if (resumed) {\n              transport.consumer.resume();\n            }\n          },\n        );\n      }\n    } catch (error: any) {\n      // Handle errors during the process of pausing or resuming consumer transports\n      console.log(`Error processing consumer transports: ${error.message}`);\n      // throw new Error(`Error processing consumer transports: ${error.message}`);\n    }\n  };\n}\n"]}