mediasfu-shared 1.0.0

package/src/methods/displaySettings/modifyDisplaySettings.ts

@@ -0,0 +1,242 @@
+import type { ShowAlert, OnScreenChangesParameters, OnScreenChangesType  } from '../../types/types'
+
+
+export interface ModifyDisplaySettingsParameters extends OnScreenChangesParameters {
+  showAlert?: ShowAlert
+  meetingDisplayType: string
+  autoWave: boolean
+  forceFullDisplay: boolean
+  meetingVideoOptimized: boolean
+  islevel: string
+  recordStarted: boolean
+  recordResumed: boolean
+  recordStopped: boolean
+  recordPaused: boolean
+  recordingDisplayType: 'video' | 'media' | 'all'
+  recordingVideoOptimized: boolean
+  prevForceFullDisplay: boolean
+  prevMeetingDisplayType: string
+  updateMeetingDisplayType: (displayType: string) => void
+  updateAutoWave: (autoWave: boolean) => void
+  updateForceFullDisplay: (forceFullDisplay: boolean) => void
+  updateMeetingVideoOptimized: (optimized: boolean) => void
+  updatePrevForceFullDisplay: (forceFullDisplay: boolean) => void
+  updatePrevMeetingDisplayType: (displayType: string) => void
+  updateIsDisplaySettingsModalVisible: (isVisible: boolean) => void
+  updateFirstAll: (firstAll: boolean) => void
+  updateUpdateMainWindow: (update: boolean) => void
+  breakOutRoomStarted: boolean
+  breakOutRoomEnded: boolean
+
+  // mediasfu functions
+  onScreenChanges: OnScreenChangesType
+
+  [key: string]: any
+}
+
+export interface ModifyDisplaySettingsOptions {
+  parameters: ModifyDisplaySettingsParameters
+}
+
+// Export the type definition for the function
+export type ModifyDisplaySettingsType = (
+  options: ModifyDisplaySettingsOptions
+) => Promise<void>
+
+/**
+ * Modifies the display settings based on the provided parameters.
+ *
+ * @param {ModifyDisplaySettingsOptions} options - The options containing the parameters to modify the display settings.
+ * @param {Object} options.parameters - The parameters for modifying the display settings.
+ * @param {Function} options.parameters.showAlert - Function to show alert messages.
+ * @param {string} options.parameters.meetingDisplayType - The current meeting display type.
+ * @param {boolean} options.parameters.autoWave - Flag indicating if auto wave is enabled.
+ * @param {boolean} options.parameters.forceFullDisplay - Flag indicating if full display is forced.
+ * @param {boolean} options.parameters.meetingVideoOptimized - Flag indicating if the meeting video is optimized.
+ * @param {string} options.parameters.islevel - The current level of the meeting.
+ * @param {boolean} options.parameters.recordStarted - Flag indicating if recording has started.
+ * @param {boolean} options.parameters.recordResumed - Flag indicating if recording has resumed.
+ * @param {boolean} options.parameters.recordStopped - Flag indicating if recording has stopped.
+ * @param {boolean} options.parameters.recordPaused - Flag indicating if recording is paused.
+ * @param {string} options.parameters.recordingDisplayType - The current recording display type.
+ * @param {boolean} options.parameters.recordingVideoOptimized - Flag indicating if the recording video is optimized.
+ * @param {string} options.parameters.prevForceFullDisplay - The previous force full display value.
+ * @param {string} options.parameters.prevMeetingDisplayType - The previous meeting display type.
+ * @param {Function} options.parameters.updateMeetingDisplayType - Function to update the meeting display type.
+ * @param {Function} options.parameters.updateAutoWave - Function to update the auto wave setting.
+ * @param {Function} options.parameters.updateForceFullDisplay - Function to update the force full display setting.
+ * @param {Function} options.parameters.updateMeetingVideoOptimized - Function to update the meeting video optimization setting.
+ * @param {Function} options.parameters.updatePrevForceFullDisplay - Function to update the previous force full display setting.
+ * @param {Function} options.parameters.updatePrevMeetingDisplayType - Function to update the previous meeting display type.
+ * @param {Function} options.parameters.updateIsDisplaySettingsModalVisible - Function to update the visibility of the display settings modal.
+ * @param {Function} options.parameters.updateFirstAll - Function to update the first all setting.
+ * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window.
+ * @param {boolean} options.parameters.breakOutRoomStarted - Flag indicating if a breakout room has started.
+ * @param {boolean} options.parameters.breakOutRoomEnded - Flag indicating if a breakout room has ended.
+ * @param {Function} options.parameters.onScreenChanges - Function to handle screen changes.
+ *
+ * @example
+ * ```typescript
+ * const options: ModifyDisplaySettingsOptions = {
+ *   parameters: {
+ *     showAlert: showAlertFunction,
+ *     meetingDisplayType: "video",
+ *     autoWave: true,
+ *     forceFullDisplay: false,
+ *     meetingVideoOptimized: true,
+ *     islevel: "2",
+ *     recordStarted: true,
+ *     recordResumed: false,
+ *     recordStopped: false,
+ *     recordPaused: false,
+ *     recordingDisplayType: "video",
+ *     recordingVideoOptimized: true,
+ *     prevForceFullDisplay: false,
+ *     prevMeetingDisplayType: "media",
+ *     updateMeetingDisplayType: updateDisplayTypeFunction,
+ *     updateAutoWave: updateAutoWaveFunction,
+ *     updateForceFullDisplay: updateForceFullDisplayFunction,
+ *     updateMeetingVideoOptimized: updateVideoOptimizedFunction,
+ *     updatePrevForceFullDisplay: updatePrevForceFullFunction,
+ *     updatePrevMeetingDisplayType: updatePrevDisplayTypeFunction,
+ *     updateIsDisplaySettingsModalVisible: setModalVisibilityFunction,
+ *     updateFirstAll: setFirstAllFunction,
+ *     updateUpdateMainWindow: setMainWindowUpdateFunction,
+ *     breakOutRoomStarted: false,
+ *     breakOutRoomEnded: true,
+ *     onScreenChanges: onScreenChangesFunction
+ *   }
+ * };
+ *
+ * await modifyDisplaySettings(options);
+ * ```
+ */
+
+export const modifyDisplaySettings = async ({
+  parameters
+}: ModifyDisplaySettingsOptions): Promise<void> => {
+  // Destructure the parameters
+  let {
+    showAlert,
+    meetingDisplayType,
+    autoWave,
+    forceFullDisplay,
+    meetingVideoOptimized,
+    islevel,
+    recordStarted,
+    recordResumed,
+    recordStopped,
+    recordPaused,
+    recordingDisplayType,
+    recordingVideoOptimized,
+    prevForceFullDisplay,
+    prevMeetingDisplayType,
+    updateMeetingDisplayType,
+    updateAutoWave,
+    updateForceFullDisplay,
+    updateMeetingVideoOptimized,
+    updatePrevForceFullDisplay,
+    updatePrevMeetingDisplayType,
+    updateIsDisplaySettingsModalVisible,
+    updateFirstAll,
+    updateUpdateMainWindow,
+    breakOutRoomStarted,
+    breakOutRoomEnded,
+    onScreenChanges
+  } = parameters
+
+  // Update previous states
+  updateAutoWave(autoWave)
+  updateForceFullDisplay(forceFullDisplay)
+
+  if (
+    islevel === '2' &&
+    (recordStarted || recordResumed) &&
+    !recordStopped &&
+    !recordPaused
+  ) {
+    if (
+      recordingDisplayType === 'video' &&
+      meetingDisplayType === 'video' &&
+      meetingVideoOptimized &&
+      !recordingVideoOptimized
+    ) {
+      showAlert?.({
+        message:
+          'Meeting display type can be either video, media, or all when recording display type is non-optimized video.',
+        type: 'danger',
+        duration: 3000
+      })
+      // Reset to previous values or handle as needed
+      meetingDisplayType = recordingDisplayType
+      updateMeetingDisplayType(meetingDisplayType)
+      meetingVideoOptimized = recordingVideoOptimized
+      updateMeetingVideoOptimized(meetingVideoOptimized)
+      return
+    } else if (
+      recordingDisplayType === 'media' &&
+      meetingDisplayType === 'video'
+    ) {
+      showAlert?.({
+        message:
+          'Meeting display type can be either media or all when recording display type is media.',
+        type: 'danger',
+        duration: 3000
+      })
+
+      // Reset to previous values or handle as needed
+      meetingDisplayType = recordingDisplayType
+      updateMeetingDisplayType(meetingDisplayType)
+      return
+    } else if (
+      recordingDisplayType === 'all' &&
+      (meetingDisplayType === 'video' || meetingDisplayType === 'media')
+    ) {
+      showAlert?.({
+        message:
+          'Meeting display type can be only all when recording display type is all.',
+        type: 'danger',
+        duration: 3000
+      })
+      // Reset to previous values or handle as needed
+      meetingDisplayType = recordingDisplayType
+      updateMeetingDisplayType(meetingDisplayType)
+      return
+    }
+  }
+
+  updateMeetingDisplayType(meetingDisplayType)
+  updateMeetingVideoOptimized(meetingVideoOptimized)
+
+  // Close the modal or perform additional actions
+  updateIsDisplaySettingsModalVisible(false)
+
+  if (
+    prevMeetingDisplayType !== meetingDisplayType ||
+    prevForceFullDisplay !== forceFullDisplay
+  ) {
+    if (
+      breakOutRoomStarted &&
+      !breakOutRoomEnded &&
+      meetingDisplayType !== 'all'
+    ) {
+      showAlert?.({
+        message:
+          'Breakout room is active. Display type can only be all.',
+        type: 'danger'
+      })
+      meetingDisplayType = prevMeetingDisplayType
+      updateMeetingDisplayType(prevMeetingDisplayType)
+      return
+    }
+
+    updateFirstAll(meetingDisplayType !== 'all' ? true : false)
+    updateUpdateMainWindow(true)
+    await onScreenChanges({
+      changed: true,
+      parameters: { ...parameters, meetingDisplayType, forceFullDisplay }
+    })
+    updatePrevForceFullDisplay(forceFullDisplay)
+    updatePrevMeetingDisplayType(meetingDisplayType)
+  }
+}

package/src/methods/exit/confirmExit.ts

@@ -0,0 +1,60 @@
+import type { Socket } from 'socket.io-client'
+
+export interface ConfirmExitOptions {
+  socket: Socket
+  localSocket?: Socket
+  member: string
+  roomName: string
+  ban?: boolean
+}
+
+// Export the type definition for the function
+export type ConfirmExitType = (options: ConfirmExitOptions) => Promise<void>
+
+/**
+ * Confirms the exit of a member from a room and optionally bans them.
+ *
+ * @param {ConfirmExitOptions} options - The options for confirming the exit.
+ * @param {Socket} options.socket - The socket instance to emit the event.
+ * @param {Socket} [options.localSocket] - The local socket instance to emit the event.
+ * @param {string} options.member - The member who is exiting.
+ * @param {string} options.roomName - The name of the room the member is exiting from.
+ * @param {boolean} [options.ban=false] - Whether to ban the member from the room.
+ * @returns {Promise<void>} A promise that resolves when the exit is confirmed.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   socket: socketInstance,
+ *   localSocket: localSocketInstance,
+ *   member: "JohnDoe",
+ *   roomName: "Room123",
+ *   ban: true,
+ * };
+ * await confirmExit(options);
+ * ```
+ */
+
+export const confirmExit = async ({
+  socket,
+  localSocket,
+  member,
+  roomName,
+  ban = false
+}: ConfirmExitOptions): Promise<void> => {
+  // Emit a socket event to disconnect the user from the room
+  socket.emit('disconnectUser', {
+    member: member,
+    roomName: roomName,
+    ban: ban
+  })
+
+  if (localSocket && localSocket.id) {
+    // Emit a local socket event to disconnect the user from the room
+    localSocket.emit('disconnectUser', {
+      member: member,
+      roomName: roomName,
+      ban: ban
+    })
+  }
+}

package/src/methods/exit/index.ts

@@ -0,0 +1,2 @@
+export * from './confirmExit'
+export * from './launchConfirmExit'

package/src/methods/exit/launchConfirmExit.ts

@@ -0,0 +1,29 @@
+export interface LaunchConfirmExitOptions {
+  updateIsConfirmExitModalVisible: (isVisible: boolean) => void
+  isConfirmExitModalVisible: boolean
+}
+
+export type LaunchConfirmExitType = (options: LaunchConfirmExitOptions) => void
+
+/**
+ * Toggles the visibility of the confirmation exit modal.
+ *
+ * @param {LaunchConfirmExitOptions} options - The options for launching the confirmation exit modal.
+ * @param {Function} options.updateIsConfirmExitModalVisible - Function to update the visibility state of the confirmation exit modal.
+ * @param {boolean} options.isConfirmExitModalVisible - Current visibility state of the confirmation exit modal.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   updateIsConfirmExitModalVisible: setIsConfirmExitModalVisible,
+ *   isConfirmExitModalVisible: false,
+ * }
+ * launchConfirmExit(options)
+ * ```
+ */
+export const launchConfirmExit: LaunchConfirmExitType = ({
+  updateIsConfirmExitModalVisible,
+  isConfirmExitModalVisible,
+}) => {
+  updateIsConfirmExitModalVisible(!isConfirmExitModalVisible)
+}

package/src/methods/index.ts

@@ -0,0 +1,5 @@
+// Export all shared methods
+// Prejoin methods
+export * from './prejoin';
+// Welcome methods
+export * from './welcome';

package/src/methods/mediaSettings/launchMediaSettings.ts

@@ -0,0 +1,61 @@
+export interface LaunchMediaSettingsOptions {
+  updateIsMediaSettingsModalVisible: (isVisible: boolean) => void
+  isMediaSettingsModalVisible: boolean
+  mediaDevices: MediaDevices
+  audioInputs: MediaDeviceInfo[]
+  videoInputs: MediaDeviceInfo[]
+  updateAudioInputs: (inputs: MediaDeviceInfo[]) => void
+  updateVideoInputs: (inputs: MediaDeviceInfo[]) => void
+}
+
+export type LaunchMediaSettingsType = (options: LaunchMediaSettingsOptions) => Promise<void>
+
+/**
+ * Launches the media settings modal and updates the available audio and video input devices.
+ *
+ * @param {LaunchMediaSettingsOptions} options - The options for launching media settings.
+ * @param {Function} options.updateIsMediaSettingsModalVisible - Function to update the visibility state of the media settings modal.
+ * @param {boolean} options.isMediaSettingsModalVisible - Current visibility state of the media settings modal.
+ * @param {MediaDevices} options.mediaDevices - MediaDevices interface to enumerate media devices.
+ * @param {MediaDeviceInfo[]} options.audioInputs - Array to store available audio input devices.
+ * @param {MediaDeviceInfo[]} options.videoInputs - Array to store available video input devices.
+ * @param {Function} options.updateAudioInputs - Function to update the available audio input devices.
+ * @param {Function} options.updateVideoInputs - Function to update the available video input devices.
+ * @returns {Promise<void>} A promise that resolves when the media settings have been updated.
+ *
+ * @example
+ * ```typescript
+ * launchMediaSettings({
+ *   updateIsMediaSettingsModalVisible: (isVisible) => console.log('Modal visible:', isVisible),
+ *   isMediaSettingsModalVisible: false,
+ *   mediaDevices: navigator.mediaDevices,
+ *   audioInputs: [],
+ *   videoInputs: [],
+ *   updateAudioInputs: (inputs) => console.log('Audio Inputs:', inputs),
+ *   updateVideoInputs: (inputs) => console.log('Video Inputs:', inputs),
+ * })
+ * ```
+ */
+export const launchMediaSettings: LaunchMediaSettingsType = async ({
+  updateIsMediaSettingsModalVisible,
+  isMediaSettingsModalVisible,
+  mediaDevices,
+  audioInputs,
+  videoInputs,
+  updateAudioInputs,
+  updateVideoInputs,
+}) => {
+  if (!isMediaSettingsModalVisible) {
+    try {
+      const devices = await mediaDevices.enumerateDevices()
+      videoInputs = devices.filter((device) => device.kind === 'videoinput')
+      audioInputs = devices.filter((device) => device.kind === 'audioinput')
+      updateVideoInputs(videoInputs)
+      updateAudioInputs(audioInputs)
+    } catch (error) {
+      console.log('Error getting media devices', error)
+    }
+  }
+
+  updateIsMediaSettingsModalVisible(!isMediaSettingsModalVisible)
+}

package/src/methods/menu/launchMenuModal.ts

@@ -0,0 +1,28 @@
+export interface LaunchMenuModalOptions {
+  updateIsMenuModalVisible: (isVisible: boolean) => void
+  isMenuModalVisible: boolean
+}
+
+export type LaunchMenuModalType = (options: LaunchMenuModalOptions) => void
+
+/**
+ * Toggles the visibility of the menu modal.
+ *
+ * @param {LaunchMenuModalOptions} options - The options for launching the menu modal.
+ * @param {Function} options.updateIsMenuModalVisible - Function to update the visibility state of the menu modal.
+ * @param {boolean} options.isMenuModalVisible - Current visibility state of the menu modal.
+ *
+ * @example
+ * ```typescript
+ * launchMenuModal({
+ *   updateIsMenuModalVisible: (isVisible) => console.log("Menu modal visibility:", isVisible),
+ *   isMenuModalVisible: false,
+ * });
+ * ```
+ */
+export const launchMenuModal: LaunchMenuModalType = ({
+  updateIsMenuModalVisible,
+  isMenuModalVisible,
+}) => {
+  updateIsMenuModalVisible(!isMenuModalVisible)
+}

package/src/methods/message/index.ts

@@ -0,0 +1 @@
+export { sendMessage, type SendMessageType, type SendMessageOptions } from './sendMessage';

package/src/methods/message/launchMessages.ts

@@ -0,0 +1,27 @@
+export interface LaunchMessagesOptions {
+  updateIsMessagesModalVisible: (visible: boolean) => void
+  isMessagesModalVisible: boolean
+}
+
+export type LaunchMessagesType = (options: LaunchMessagesOptions) => void
+
+/**
+ * Toggles the visibility state of the messages modal.
+ *
+ * @param {LaunchMessagesOptions} options - The options object.
+ * @param {Function} options.updateIsMessagesModalVisible - Function to update the visibility state of the messages modal.
+ * @param {boolean} options.isMessagesModalVisible - Current visibility state of the messages modal.
+ *
+ * @example
+ * ```typescript
+ * const options: LaunchMessagesOptions = {
+ *   updateIsMessagesModalVisible: setModalVisibilityFunction,
+ *   isMessagesModalVisible: false,
+ * }
+ *
+ * launchMessages(options)
+ * ```
+ */
+export const launchMessages: LaunchMessagesType = ({ updateIsMessagesModalVisible, isMessagesModalVisible }) => {
+  updateIsMessagesModalVisible(!isMessagesModalVisible)
+}

package/src/methods/message/sendMessage.ts

@@ -0,0 +1,175 @@
+import { Socket } from "socket.io-client";
+import type {
+  CoHostResponsibility,
+  EventType,
+  Message,
+  ShowAlert,
+} from "../../types/types";
+
+export interface SendMessageOptions {
+  message: string;
+  receivers: string[];
+  group: boolean;
+  messagesLength: number;
+  member: string;
+  sender: string;
+  islevel: string;
+  eventType?: EventType;
+  showAlert?: ShowAlert;
+  coHostResponsibility: CoHostResponsibility[];
+  coHost: string;
+  roomName: string;
+  socket: Socket;
+  chatSetting: string;
+}
+
+// Export the type
+export type SendMessageType = (options: SendMessageOptions) => Promise<void>;
+
+/**
+ * Sends a message to the server.
+ *
+ * @param {SendMessageOptions} options - The options for sending a message.
+ * @param {string} options.message - The message content to be sent.
+ * @param {string[]} options.receivers - The list of receivers for the message.
+ * @param {boolean} options.group - Indicates if the message is for a group.
+ * @param {number} options.messagesLength - The current number of messages.
+ * @param {string} options.member - The member sending the message.
+ * @param {string} options.sender - The sender of the message.
+ * @param {string} options.islevel - The level of the sender (e.g., "2" for admin).
+ * @param {EventType} [options.eventType] - The type of event (e.g., "broadcast", "chat", "conference").
+ * @param {ShowAlert} [options.showAlert] - Function to show alerts to the user.
+ * @param {CoHostResponsibility[]} options.coHostResponsibility - Array of co-host responsibilities.
+ * @param {string} options.coHost - The co-host member name.
+ * @param {string} options.roomName - The name of the room.
+ * @param {Socket} options.socket - The socket instance for communication.
+ * @param {string} options.chatSetting - The chat setting for the event room.
+ * @returns {Promise<void>} A promise that resolves when the message is sent.
+ *
+ * @throws Will show an alert if the message count exceeds the limit, if the message is invalid, or if the user is not allowed to send a message.
+ *
+ * @example
+ * ```typescript
+ * await sendMessage({
+ *   message: "Hello, World!",
+ *   receivers: ["user1", "user2"],
+ *   group: true,
+ *   messagesLength: 50,
+ *   member: "user3",
+ *   sender: "user3",
+ *   islevel: "2",
+ *   eventType: "chat",
+ *   showAlert: ({ message, type }) => console.log(message, type),
+ *   coHostResponsibility: [{ name: "chat", value: true }],
+ *   coHost: "coHostUser",
+ *   roomName: "mainRoom",
+ *   socket: socketInstance,
+ *   chatSetting: "allow",
+ * });
+ * ```
+ */
+
+export const sendMessage = async ({
+  message,
+  receivers,
+  group,
+  messagesLength,
+  member,
+  sender,
+  islevel,
+  eventType,
+  showAlert,
+  coHostResponsibility,
+  coHost,
+  roomName,
+  socket,
+  chatSetting,
+}: SendMessageOptions): Promise<void> => {
+  let chatValue = false;
+
+  // Check if messages count exceeds the limit
+  if (eventType === "broadcast") {
+    if (messagesLength >= 100) {
+      showAlert?.({
+        message: "You have reached the maximum number of messages",
+        type: "danger",
+        duration: 3000,
+      });
+      return;
+    }
+  } else if (eventType === "chat") {
+    if (messagesLength >= 500) {
+      showAlert?.({
+        message: "You have reached the maximum number of messages",
+        type: "danger",
+        duration: 3000,
+      });
+      return;
+    }
+  } else {
+    if (messagesLength >= 100000) {
+      showAlert?.({
+        message: "You have reached the maximum number of messages",
+        type: "danger",
+        duration: 3000,
+      });
+      return;
+    }
+  }
+
+  // Check if message is valid
+  if (!message || message === "") {
+    showAlert?.({
+      message: "Message is not valid.",
+      type: "danger",
+      duration: 3000,
+    });
+    return;
+  }
+
+  // Check if receivers is valid
+  if (receivers.length < 1 && group === false) {
+    showAlert?.({
+      message: "Please select a message to reply to",
+      type: "danger",
+      duration: 3000,
+    });
+    return;
+  }
+
+  // Create message object
+  const messageObject: Message = {
+    sender: sender ? sender : member,
+    receivers: receivers,
+    message: message,
+    timestamp: new Date().toLocaleTimeString(),
+    group: group !== undefined && group !== null ? group : false,
+  };
+
+  try {
+    // Check co-host responsibility for chat
+    chatValue = coHostResponsibility.find((item) => item.name === "chat")?.value ?? false;
+  } catch (error) {
+    console.error(error);
+  }
+
+  if (islevel === "2" || (coHost === member && chatValue === true)) {
+    // Allow sending message
+  } else {
+    // Check if user is allowed to send a message in the event room
+    if (!chatSetting) {
+      showAlert?.({
+        message: "You are not allowed to send a message in this event room",
+        type: "danger",
+        duration: 3000,
+      });
+      return;
+    }
+  }
+
+  // Send the message to the server
+  socket.emit("sendMessage", {
+    messageObject: messageObject,
+    roomName: roomName,
+  });
+};

package/src/methods/participants/index.ts

@@ -0,0 +1,3 @@
+export { muteParticipants, type MuteParticipantsOptions } from './muteParticipants';
+export { messageParticipants, type MessageParticipantsOptions } from './messageParticipants';
+export { removeParticipants, type RemoveParticipantsOptions } from './removeParticipants';

package/src/methods/participants/launchParticipants.ts

@@ -0,0 +1,25 @@
+export interface LaunchParticipantsOptions {
+  updateIsParticipantsModalVisible: (isVisible: boolean) => void
+  isParticipantsModalVisible: boolean
+}
+
+export type LaunchParticipantsType = (options: LaunchParticipantsOptions) => void
+
+/**
+ * Toggles the visibility of the participants modal.
+ *
+ * @param {LaunchParticipantsOptions} options - The options for toggling the participants modal.
+ * @param {Function} options.updateIsParticipantsModalVisible - Function to update the visibility state of the participants modal.
+ * @param {boolean} options.isParticipantsModalVisible - Current visibility state of the participants modal.
+ *
+ * @example
+ * ```typescript
+ * launchParticipants({
+ *   updateIsParticipantsModalVisible: (isVisible) => setParticipantsModalVisible(isVisible),
+ *   isParticipantsModalVisible: true,
+ * })
+ * ```
+ */
+export const launchParticipants: LaunchParticipantsType = ({ updateIsParticipantsModalVisible, isParticipantsModalVisible }) => {
+  updateIsParticipantsModalVisible(!isParticipantsModalVisible)
+}