mediasfu-shared 1.0.0

package/src/methods/breakoutRooms/breakoutRoomUpdated.ts

@@ -0,0 +1,161 @@
+import type {
+  BreakoutParticipant,
+  BreakoutRoomUpdatedData,
+  OnScreenChangesParameters,
+  OnScreenChangesType,
+  Participant,
+  RePortParameters,
+  RePortType,
+} from '../../types/types'
+
+export interface BreakoutRoomUpdatedParameters extends OnScreenChangesParameters, RePortParameters {
+  breakOutRoomStarted: boolean
+  breakOutRoomEnded: boolean
+  breakoutRooms: BreakoutParticipant[][]
+  hostNewRoom: number
+  islevel: string
+  participantsAll: Participant[]
+  participants: Participant[]
+  meetingDisplayType: string
+  prevMeetingDisplayType: string
+  updateBreakoutRooms: (rooms: BreakoutParticipant[][]) => void
+  updateBreakOutRoomStarted: (started: boolean) => void
+  updateBreakOutRoomEnded: (ended: boolean) => void
+  updateHostNewRoom: (room: number) => void
+  updateMeetingDisplayType: (type: string) => void
+  updateParticipantsAll: (participants: Participant[]) => void
+  updateParticipants: (participants: Participant[]) => void
+  onScreenChanges: OnScreenChangesType
+  rePort: RePortType
+  getUpdatedAllParams: () => BreakoutRoomUpdatedParameters
+  [key: string]: any
+}
+
+export interface BreakoutRoomUpdatedOptions {
+  data: BreakoutRoomUpdatedData
+  parameters: BreakoutRoomUpdatedParameters
+}
+
+export type BreakoutRoomUpdatedType = (options: BreakoutRoomUpdatedOptions) => Promise<void>
+
+/**
+ * Updates the state of breakout rooms based on the provided data and parameters.
+ *
+ * @param {BreakoutRoomUpdatedOptions} options - The options object.
+ * @param {BreakoutRoomUpdatedData} options.data - The data object containing information about the breakout rooms.
+ * @param {BreakoutRoomUpdatedParameters} options.parameters - The parameters object containing various state update functions and other parameters.
+ *
+ * @example
+ * ```typescript
+ * const breakoutOptions: BreakoutRoomUpdatedOptions = {
+ *   data: breakoutData,
+ *   parameters: {
+ *     breakOutRoomStarted: false,
+ *     breakOutRoomEnded: false,
+ *     breakoutRooms: [[]],
+ *     hostNewRoom: 1,
+ *     islevel: '2',
+ *     participantsAll: allParticipants,
+ *     participants: activeParticipants,
+ *     meetingDisplayType: 'all',
+ *     prevMeetingDisplayType: 'video',
+ *     updateBreakoutRooms: setBreakoutRooms,
+ *     updateBreakOutRoomStarted: setBreakOutRoomStarted,
+ *     updateBreakOutRoomEnded: setBreakOutRoomEnded,
+ *     updateHostNewRoom: setHostNewRoom,
+ *     updateMeetingDisplayType: setMeetingDisplayType,
+ *     updateParticipantsAll: setAllParticipants,
+ *     updateParticipants: setActiveParticipants,
+ *     onScreenChanges: handleScreenChanges,
+ *     rePort: reportFunction,
+ *     getUpdatedAllParams: () => breakoutOptions.parameters,
+ *   },
+ * }
+ *
+ * await breakoutRoomUpdated(breakoutOptions)
+ * ```
+ */
+export const breakoutRoomUpdated: BreakoutRoomUpdatedType = async ({ data, parameters }) => {
+  try {
+    let {
+      breakOutRoomStarted,
+      breakOutRoomEnded,
+      breakoutRooms,
+      hostNewRoom,
+      islevel,
+      participantsAll,
+      participants,
+      meetingDisplayType,
+      prevMeetingDisplayType,
+      updateBreakoutRooms,
+      updateBreakOutRoomStarted,
+      updateBreakOutRoomEnded,
+      updateHostNewRoom,
+      updateMeetingDisplayType,
+      updateParticipantsAll,
+      updateParticipants,
+      onScreenChanges,
+      rePort,
+    } = parameters
+
+    if (data.forHost) {
+      hostNewRoom = data.newRoom!
+      updateHostNewRoom(hostNewRoom!)
+      await onScreenChanges({ changed: true, parameters })
+      return
+    }
+
+    if (islevel === '2' && data.members) {
+      participantsAll = data.members.map((participant) => ({
+        isBanned: participant.isBanned,
+        name: participant.name,
+        audioID: participant.audioID,
+        videoID: participant.videoID,
+      }))
+      updateParticipantsAll(participantsAll)
+
+      participants = data.members.filter((participant) => !participant.isBanned)
+      updateParticipants(participants)
+    }
+
+    breakoutRooms = data.breakoutRooms || []
+    updateBreakoutRooms(breakoutRooms)
+
+    if (data.status === 'started' && (!breakOutRoomStarted || breakOutRoomEnded)) {
+      breakOutRoomStarted = true
+      breakOutRoomEnded = false
+      updateBreakOutRoomStarted(true)
+      updateBreakOutRoomEnded(false)
+      prevMeetingDisplayType = meetingDisplayType
+      if (meetingDisplayType !== 'all') {
+        meetingDisplayType = 'all'
+        updateMeetingDisplayType('all')
+      }
+      await onScreenChanges({ changed: true, parameters })
+      if (islevel === '2') {
+        await rePort({ restart: true, parameters })
+      }
+    } else if (data.status === 'ended') {
+      breakOutRoomEnded = true
+      updateBreakOutRoomEnded(true)
+      if (meetingDisplayType !== prevMeetingDisplayType) {
+        updateMeetingDisplayType(prevMeetingDisplayType)
+      }
+      await onScreenChanges({ changed: true, parameters })
+      if (islevel === '2') {
+        await rePort({ restart: true, parameters })
+      }
+    } else if (data.status === 'started' && breakOutRoomStarted) {
+      breakOutRoomStarted = true
+      breakOutRoomEnded = false
+      updateBreakOutRoomStarted(true)
+      updateBreakOutRoomEnded(false)
+      await onScreenChanges({ changed: true, parameters })
+      if (islevel === '2') {
+        await rePort({ restart: true, parameters })
+      }
+    }
+  } catch {
+    // Handle error
+  }
+}

package/src/methods/breakoutRooms/handleStartBreakout.ts

@@ -0,0 +1,96 @@
+import { Socket } from 'socket.io-client';
+import type { ShowAlert } from '../../types/types';
+
+
+
+export interface HandleStartBreakoutOptions {
+  socket: Socket;
+  localSocket?: Socket;
+  breakoutRooms: Array<Array<{ name: string; breakRoom?: number | null }>>;
+  newParticipantAction: string;
+  roomName: string;
+  breakOutRoomStarted: boolean;
+  breakOutRoomEnded: boolean;
+  showAlert?: ShowAlert;
+  updateBreakOutRoomStarted: (started: boolean) => void;
+  updateBreakOutRoomEnded: (ended: boolean) => void;
+  onBreakoutRoomsClose: () => void;
+  meetingDisplayType: string;
+  updateMeetingDisplayType: (displayType: string) => void;
+}
+
+export type HandleStartBreakoutType = (options: HandleStartBreakoutOptions) => void;
+
+/**
+ * Handles the start of breakout rooms.
+ * @function
+ * @param {HandleStartBreakoutOptions} options - The options for starting breakout rooms.
+ * @param {Socket} options.socket - The main socket instance.
+ * @param {Socket} [options.localSocket] - The local socket instance (optional).
+ * @param {Array<Array<{name: string, breakRoom: number | null}>>} options.breakoutRooms - The array of breakout rooms with participant data.
+ * @param {string} options.newParticipantAction - The action to take for new participants.
+ * @param {string} options.roomName - The name of the main room.
+ * @param {boolean} options.breakOutRoomStarted - Whether breakout rooms have already started.
+ * @param {boolean} options.breakOutRoomEnded - Whether breakout rooms have ended.
+ * @param {ShowAlert} [options.showAlert] - Function to show alerts.
+ * @param {Function} options.updateBreakOutRoomStarted - Function to update breakout room started state.
+ * @param {Function} options.updateBreakOutRoomEnded - Function to update breakout room ended state.
+ * @param {Function} options.onBreakoutRoomsClose - Function to close breakout rooms modal.
+ * @param {string} options.meetingDisplayType - Current meeting display type.
+ * @param {Function} options.updateMeetingDisplayType - Function to update meeting display type.
+ * @returns {void}
+ */
+export const handleStartBreakout = ({
+  socket,
+  localSocket,
+  breakoutRooms,
+  newParticipantAction,
+  roomName,
+  breakOutRoomStarted,
+  breakOutRoomEnded,
+  showAlert,
+  updateBreakOutRoomStarted,
+  updateBreakOutRoomEnded,
+  onBreakoutRoomsClose,
+  meetingDisplayType,
+  updateMeetingDisplayType,
+}: HandleStartBreakoutOptions): void => {
+  const emitName = breakOutRoomStarted && !breakOutRoomEnded ? 'updateBreakout' : 'startBreakout';
+  const filteredBreakoutRooms = breakoutRooms.map((room) =>
+    room.map(({ name, breakRoom }) => ({ name, breakRoom }))
+  );
+
+  socket.emit(
+    emitName,
+    { breakoutRooms: filteredBreakoutRooms, newParticipantAction, roomName },
+    (response: { success: boolean; reason: string }) => {
+      if (response.success) {
+        showAlert?.({ message: 'Breakout rooms active', type: 'success' });
+        updateBreakOutRoomStarted(true);
+        updateBreakOutRoomEnded(false);
+        onBreakoutRoomsClose();
+        if (meetingDisplayType !== 'all') {
+          updateMeetingDisplayType('all');
+        }
+      } else {
+        showAlert?.({ message: response.reason, type: 'danger' });
+      }
+    }
+  );
+
+  if (localSocket && localSocket.id) {
+    try {
+      localSocket.emit(
+        emitName,
+        { breakoutRooms: filteredBreakoutRooms, newParticipantAction, roomName },
+        (response: { success: boolean; reason: string }) => {
+          if (response.success) {
+            // do nothing
+          }
+        }
+      );
+    } catch {
+      console.log('Error starting local breakout rooms:');
+    }
+  }
+};

package/src/methods/breakoutRooms/handleStopBreakout.ts

@@ -0,0 +1,72 @@
+import { Socket } from 'socket.io-client';
+import type { ShowAlert } from '../../types/types';
+
+export interface HandleStopBreakoutOptions {
+  socket: Socket;
+  localSocket?: Socket;
+  roomName: string;
+  showAlert?: ShowAlert;
+  updateBreakOutRoomStarted: (started: boolean) => void;
+  updateBreakOutRoomEnded: (ended: boolean) => void;
+  onBreakoutRoomsClose: () => void;
+  meetingDisplayType: string;
+  prevMeetingDisplayType: string;
+  updateMeetingDisplayType: (displayType: string) => void;
+}
+
+export type HandleStopBreakoutType = (options: HandleStopBreakoutOptions) => void;
+
+/**
+ * Handles stopping breakout rooms.
+ * @function
+ * @param {HandleStopBreakoutOptions} options - The options for stopping breakout rooms.
+ * @param {Socket} options.socket - The main socket instance.
+ * @param {Socket} [options.localSocket] - The local socket instance (optional).
+ * @param {string} options.roomName - The name of the main room.
+ * @param {ShowAlert} [options.showAlert] - Function to show alerts.
+ * @param {Function} options.updateBreakOutRoomStarted - Function to update breakout room started state.
+ * @param {Function} options.updateBreakOutRoomEnded - Function to update breakout room ended state.
+ * @param {Function} options.onBreakoutRoomsClose - Function to close breakout rooms modal.
+ * @param {string} options.meetingDisplayType - Current meeting display type.
+ * @param {string} options.prevMeetingDisplayType - Previous meeting display type.
+ * @param {Function} options.updateMeetingDisplayType - Function to update meeting display type.
+ * @returns {void}
+ */
+export const handleStopBreakout = ({
+  socket,
+  localSocket,
+  roomName,
+  showAlert,
+  updateBreakOutRoomStarted,
+  updateBreakOutRoomEnded,
+  onBreakoutRoomsClose,
+  meetingDisplayType,
+  prevMeetingDisplayType,
+  updateMeetingDisplayType,
+}: HandleStopBreakoutOptions): void => {
+  socket.emit('stopBreakout', { roomName }, (response: { success: boolean; reason: string }) => {
+    if (response.success) {
+      showAlert?.({ message: 'Breakout rooms stopped', type: 'success' });
+      updateBreakOutRoomStarted(false);
+      updateBreakOutRoomEnded(true);
+      onBreakoutRoomsClose();
+      if (meetingDisplayType !== prevMeetingDisplayType) {
+        updateMeetingDisplayType(prevMeetingDisplayType);
+      }
+    } else {
+      showAlert?.({ message: response.reason, type: 'danger' });
+    }
+  });
+
+  if (localSocket && localSocket.id) {
+    try {
+      localSocket.emit('stopBreakout', { roomName }, (response: { success: boolean; reason: string }) => {
+        if (response.success) {
+          // do nothing
+        }
+      });
+    } catch {
+      console.log('Error stopping local breakout rooms:');
+    }
+  }
+};

package/src/methods/breakoutRooms/index.ts

@@ -0,0 +1,4 @@
+export { handleStartBreakout } from './handleStartBreakout';
+export type { HandleStartBreakoutOptions, HandleStartBreakoutType } from './handleStartBreakout';
+export { handleStopBreakout } from './handleStopBreakout';
+export type { HandleStopBreakoutOptions, HandleStopBreakoutType } from './handleStopBreakout';

package/src/methods/breakoutRooms/launchBreakoutRooms.ts

@@ -0,0 +1,31 @@
+export interface LaunchBreakoutRoomsOptions {
+  updateIsBreakoutRoomsModalVisible: (isVisible: boolean) => void
+  isBreakoutRoomsModalVisible: boolean
+}
+
+export type LaunchBreakoutRoomsType = (options: LaunchBreakoutRoomsOptions) => void
+
+/**
+ * Launches the breakout rooms by toggling the visibility of the breakout rooms modal.
+ *
+ * @param {LaunchBreakoutRoomsOptions} options - The options object.
+ * @param {Function} options.updateIsBreakoutRoomsModalVisible - Function to update the visibility state of the breakout rooms modal.
+ * @param {boolean} options.isBreakoutRoomsModalVisible - Current visibility state of the breakout rooms modal.
+ *
+ * @example
+ * ```typescript
+ * const options: LaunchBreakoutRoomsOptions = {
+ *   updateIsBreakoutRoomsModalVisible: setModalVisible,
+ *   isBreakoutRoomsModalVisible: false,
+ * }
+ *
+ * launchBreakoutRooms(options)
+ * // Toggles the breakout rooms modal to visible.
+ * ```
+ */
+export const launchBreakoutRooms: LaunchBreakoutRoomsType = ({
+  updateIsBreakoutRoomsModalVisible,
+  isBreakoutRoomsModalVisible,
+}) => {
+  updateIsBreakoutRoomsModalVisible(!isBreakoutRoomsModalVisible)
+}

package/src/methods/coHost/launchCoHost.ts

@@ -0,0 +1,28 @@
+export interface LaunchCoHostOptions {
+  updateIsCoHostModalVisible: (isVisible: boolean) => void
+  isCoHostModalVisible: boolean
+}
+
+export type LaunchCoHostType = (options: LaunchCoHostOptions) => void
+
+/**
+ * Toggles the visibility of the co-host modal.
+ *
+ * @param {LaunchCoHostOptions} options - The options object.
+ * @param {Function} options.updateIsCoHostModalVisible - Function to update the visibility state of the co-host modal.
+ * @param {boolean} options.isCoHostModalVisible - Current visibility state of the co-host modal.
+ *
+ * @example
+ * ```typescript
+ * const options: LaunchCoHostOptions = {
+ *   updateIsCoHostModalVisible: setModalVisible,
+ *   isCoHostModalVisible: false,
+ * }
+ *
+ * launchCoHost(options)
+ * // Toggles the co-host modal to visible.
+ * ```
+ */
+export const launchCoHost: LaunchCoHostType = ({ updateIsCoHostModalVisible, isCoHostModalVisible }) => {
+  updateIsCoHostModalVisible(!isCoHostModalVisible)
+}

package/src/methods/coHostMethods/index.ts

@@ -0,0 +1,2 @@
+export { modifyCoHostSettings } from './modifyCoHostSettings';
+export type { ModifyCoHostSettingsOptions, ModifyCoHostSettingsType } from './modifyCoHostSettings';

package/src/methods/coHostMethods/modifyCoHostSettings.ts

@@ -0,0 +1,94 @@
+import type { Socket } from 'socket.io-client';
+import type { ShowAlert, CoHostResponsibility } from '../../types/types';
+
+
+export interface ModifyCoHostSettingsOptions {
+  roomName: string;
+  showAlert?: ShowAlert;
+  selectedParticipant: string;
+  coHost: string;
+  coHostResponsibility: CoHostResponsibility[];
+  updateIsCoHostModalVisible: (isVisible: boolean) => void;
+  updateCoHostResponsibility: (coHostResponsibility: CoHostResponsibility[]) => void;
+  updateCoHost: (coHost: string) => void;
+  socket: Socket;
+}
+
+export type ModifyCoHostSettingsType = (options: ModifyCoHostSettingsOptions) => Promise<void>;
+
+/**
+ * Modifies the co-host settings for a given room.
+ * @function
+ * @param {ModifyCoHostSettingsOptions} options - The options for modifying co-host settings.
+ * @param {string} options.roomName - The name of the room.
+ * @param {ShowAlert} [options.showAlert] - Function to show an alert message.
+ * @param {string} options.selectedParticipant - The participant selected to be co-host.
+ * @param {string} options.coHost - The current co-host.
+ * @param {CoHostResponsibility[]} options.coHostResponsibility - The responsibilities assigned to the co-host.
+ * @param {Function} options.updateIsCoHostModalVisible - Function to update the visibility of the co-host modal.
+ * @param {Function} options.updateCoHostResponsibility - Function to update the co-host responsibility.
+ * @param {Function} options.updateCoHost - Function to update the co-host.
+ * @param {Socket} options.socket - The socket instance for emitting events.
+ * @returns {Promise<void>} A promise that resolves when the co-host settings have been modified.
+ *
+ * @example
+ * ```typescript
+ * const options: ModifyCoHostSettingsOptions = {
+ *   roomName: "mainRoom",
+ *   showAlert: (alert) => console.log(alert.message),
+ *   selectedParticipant: "User123",
+ *   coHost: "No coHost",
+ *   coHostResponsibility: [{ name: "media", value: true, dedicated: false }],
+ *   updateIsCoHostModalVisible: setModalVisible,
+ *   updateCoHostResponsibility: setCoHostResponsibility,
+ *   updateCoHost: setCoHost,
+ *   socket: socketInstance,
+ * };
+ *
+ * modifyCoHostSettings(options);
+ * // Sets User123 as the new co-host with specific responsibilities and emits the update event.
+ * ```
+ */
+export const modifyCoHostSettings = async ({
+  roomName,
+  showAlert,
+  selectedParticipant,
+  coHost,
+  coHostResponsibility,
+  updateIsCoHostModalVisible,
+  updateCoHostResponsibility,
+  updateCoHost,
+  socket,
+}: ModifyCoHostSettingsOptions): Promise<void> => {
+  // Check if the chat room is in demo mode
+  if (roomName.toLowerCase().startsWith('d')) {
+    showAlert?.({
+      message: 'You cannot add co-host in demo mode.',
+      type: 'danger',
+      duration: 3000,
+    });
+
+    return;
+  }
+
+  let newCoHost = coHost;
+
+  if (coHost !== 'No coHost' || (selectedParticipant && selectedParticipant !== 'Select a participant')) {
+    if (selectedParticipant && selectedParticipant !== 'Select a participant') {
+      newCoHost = selectedParticipant;
+      updateCoHost(newCoHost);
+    }
+
+    updateCoHostResponsibility(coHostResponsibility);
+
+    // Emit a socket event to update co-host information
+    socket.emit('updateCoHost', {
+      roomName,
+      coHost: newCoHost,
+      coHostResponsibility,
+    });
+  }
+
+  // Close the co-host modal
+  updateIsCoHostModalVisible(false);
+};

package/src/methods/displaySettings/index.ts

@@ -0,0 +1 @@
+export * from './modifyDisplaySettings'

package/src/methods/displaySettings/launchDisplaySettings.ts

@@ -0,0 +1,31 @@
+export interface LaunchDisplaySettingsOptions {
+  updateIsDisplaySettingsModalVisible: (isVisible: boolean) => void
+  isDisplaySettingsModalVisible: boolean
+}
+
+export type LaunchDisplaySettingsType = (options: LaunchDisplaySettingsOptions) => void
+
+/**
+ * Toggles the visibility of the display settings modal.
+ *
+ * @param {LaunchDisplaySettingsOptions} options - The options object.
+ * @param {Function} options.updateIsDisplaySettingsModalVisible - Function to update the visibility state of the display settings modal.
+ * @param {boolean} options.isDisplaySettingsModalVisible - Current visibility state of the display settings modal.
+ *
+ * @example
+ * ```typescript
+ * const options: LaunchDisplaySettingsOptions = {
+ *   updateIsDisplaySettingsModalVisible: setModalVisibilityFunction,
+ *   isDisplaySettingsModalVisible: false,
+ * }
+ *
+ * launchDisplaySettings(options)
+ * // This will open the display settings modal if it's currently closed, or close it if it's open.
+ * ```
+ */
+export const launchDisplaySettings: LaunchDisplaySettingsType = ({
+  updateIsDisplaySettingsModalVisible,
+  isDisplaySettingsModalVisible,
+}) => {
+  updateIsDisplaySettingsModalVisible(!isDisplaySettingsModalVisible)
+}