mediasfu-shared 1.0.1 → 1.0.3

package/src/methods/permissions/updateParticipantPermission.ts

@@ -0,0 +1,127 @@
+import { Socket } from 'socket.io-client';
+import type { Participant, ShowAlert } from '../../types/types';
+
+export type PermissionLevel = '0' | '1' | '2';
+
+export interface UpdateParticipantPermissionOptions {
+  socket: Socket;
+  participant: Participant;
+  newLevel: PermissionLevel;
+  member: string;
+  islevel: string;
+  roomName: string;
+  showAlert?: ShowAlert;
+}
+
+export interface BulkUpdateParticipantPermissionsOptions {
+  socket: Socket;
+  participants: Participant[];
+  newLevel: PermissionLevel;
+  member: string;
+  islevel: string;
+  roomName: string;
+  showAlert?: ShowAlert;
+  maxBatchSize?: number;
+}
+
+export const updateParticipantPermission = async ({
+  socket,
+  participant,
+  newLevel,
+  member: _member,
+  islevel,
+  roomName,
+  showAlert,
+}: UpdateParticipantPermissionOptions): Promise<void> => {
+  if (islevel !== '2') {
+    showAlert?.({ message: 'Only the host can update participant permissions', type: 'danger', duration: 3000 });
+    return;
+  }
+
+  if (participant.islevel === '2') {
+    showAlert?.({ message: "Cannot change the host's permission level", type: 'danger', duration: 3000 });
+    return;
+  }
+
+  if (participant.islevel === newLevel) return;
+
+  return new Promise<void>((resolve) => {
+    socket.emit(
+      'updateParticipantPermission',
+      {
+        participantId: participant.id,
+        participantName: participant.name,
+        newLevel,
+        roomName,
+      },
+      (response: { success: boolean; reason?: string }) => {
+        if (!response?.success) {
+          showAlert?.({ message: response?.reason || 'Failed to update permission', type: 'danger', duration: 3000 });
+        }
+        resolve();
+      }
+    );
+  });
+};
+
+export const bulkUpdateParticipantPermissions = async ({
+  socket,
+  participants,
+  newLevel,
+  member: _member,
+  islevel,
+  roomName,
+  showAlert,
+  maxBatchSize = 50,
+}: BulkUpdateParticipantPermissionsOptions): Promise<void> => {
+  if (islevel !== '2') {
+    showAlert?.({ message: 'Only the host can update participant permissions', type: 'danger', duration: 3000 });
+    return;
+  }
+
+  const eligibleParticipants = participants.filter(
+    (p) => p.islevel !== '2' && p.islevel !== newLevel
+  );
+
+  if (eligibleParticipants.length === 0) {
+    showAlert?.({
+      message: 'No participants to update',
+      type: 'info',
+      duration: 3000,
+    });
+    return;
+  }
+
+  const batch = eligibleParticipants.slice(0, maxBatchSize);
+
+  return new Promise<void>((resolve) => {
+    socket.emit(
+      'bulkUpdateParticipantPermissions',
+      {
+        updates: batch.map((p) => ({
+          participantId: p.id,
+          participantName: p.name,
+          newLevel,
+        })),
+        roomName,
+      },
+      (response: { success: boolean; reason?: string }) => {
+        if (!response?.success) {
+          showAlert?.({
+            message: response?.reason || 'Failed to update permissions',
+            type: 'danger',
+            duration: 3000,
+          });
+        } else if (eligibleParticipants.length > maxBatchSize) {
+          showAlert?.({
+            message: `Updated ${batch.length} participants. ${eligibleParticipants.length - maxBatchSize} remaining.`,
+            type: 'info',
+            duration: 3000,
+          });
+        }
+
+        resolve();
+      }
+    );
+  });
+};

package/src/methods/permissions/updatePermissionConfig.ts

@@ -0,0 +1,52 @@
+import { Socket } from 'socket.io-client';
+import type { ShowAlert } from '../../types/types';
+
+export interface PermissionCapabilities {
+  useMic: 'allow' | 'approval' | 'disallow';
+  useCamera: 'allow' | 'approval' | 'disallow';
+  useScreen: 'allow' | 'approval' | 'disallow';
+  useChat: 'allow' | 'disallow';
+}
+
+export interface PermissionConfig {
+  level0: PermissionCapabilities;
+  level1: PermissionCapabilities;
+}
+
+export interface UpdatePermissionConfigOptions {
+  socket: Socket;
+  config: PermissionConfig;
+  member: string;
+  islevel: string;
+  roomName: string;
+  showAlert?: ShowAlert;
+}
+
+export const updatePermissionConfig = async ({
+  socket,
+  config,
+  islevel,
+  roomName,
+  showAlert,
+}: UpdatePermissionConfigOptions): Promise<void> => {
+  if (islevel !== '2') {
+    showAlert?.({ message: 'Only the host can update permission configuration', type: 'danger', duration: 3000 });
+    return;
+  }
+
+  return new Promise<void>((resolve) => {
+    socket.emit(
+      'updatePermissionConfig',
+      {
+        config,
+        roomName,
+      },
+      (response: { success: boolean; reason?: string }) => {
+        if (!response?.success) {
+          showAlert?.({ message: response?.reason || 'Failed to update permission config', type: 'danger', duration: 3000 });
+        }
+        resolve();
+      }
+    );
+  });
+};

package/src/methods/polls/pollUpdated.ts

@@ -0,0 +1,88 @@
+import type { Poll, PollUpdatedData, ShowAlert } from '../../types/types';
+
+export interface PollUpdatedOptions {
+  data: PollUpdatedData;
+  polls: Poll[];
+  poll: Poll;
+  member: string;
+  islevel: string;
+  showAlert?: ShowAlert;
+  updatePolls: (polls: Poll[]) => void;
+  updatePoll: (poll: Poll) => void;
+  updateIsPollModalVisible: (isVisible: boolean) => void;
+}
+
+export type PollUpdatedType = (options: PollUpdatedOptions) => Promise<void>;
+
+/**
+ * Reconciles poll update payloads with current poll state.
+ *
+ * This helper updates the poll collection, manages active poll visibility, and
+ * emits user-facing alerts when a new poll starts or an active poll ends.
+ *
+ * @param options Poll update handling options.
+ * @returns A promise that resolves after local poll state has been synchronized.
+ *
+ * @example
+ * ```typescript
+ * await pollUpdated({
+ *   data,
+ *   polls,
+ *   poll,
+ *   member: 'Ada',
+ *   islevel: '1',
+ *   updatePolls: setPolls,
+ *   updatePoll: setCurrentPoll,
+ *   updateIsPollModalVisible: setPollModalVisible,
+ * });
+ * ```
+ */
+export const pollUpdated = async ({
+  data,
+  polls,
+  poll,
+  member,
+  islevel,
+  showAlert,
+  updatePolls,
+  updatePoll,
+  updateIsPollModalVisible,
+}: PollUpdatedOptions): Promise<void> => {
+  try {
+    if (data.polls) {
+      polls = data.polls;
+      updatePolls(data.polls);
+    } else {
+      polls = [data.poll];
+      updatePolls(polls);
+    }
+
+    let tempPoll: Poll | { id: string } = { id: '' };
+
+    if (poll) {
+      tempPoll = { ...poll };
+    }
+
+    if (data.status !== 'ended') {
+      poll = data.poll;
+      updatePoll(data.poll);
+    }
+
+    if (data.status === 'started' && islevel !== '2') {
+      if (!poll.voters || (poll.voters && !poll.voters[member])) {
+        showAlert?.({
+          message: 'New poll started',
+          type: 'success',
+          duration: 3000,
+        });
+        updateIsPollModalVisible(true);
+      }
+    } else if (data.status === 'ended') {
+      if (tempPoll.id === data.poll.id) {
+        showAlert?.({ message: 'Poll ended', type: 'danger', duration: 3000 });
+        updatePoll(data.poll);
+      }
+    }
+  } catch {
+  }
+};

package/src/methods/recording/confirmRecording.ts

@@ -50,6 +50,10 @@ export interface ConfirmRecordingOptions {
 
 export type ConfirmRecordingType = (options: ConfirmRecordingOptions) => Promise<void>
 
+const ALERT_DURATION = 6000
+const FULL_PARTICIPANT_RECORDING_ALERT_MESSAGE =
+  'You are not allowed to record videos of all participants while the meeting display is set to All. Switch the meeting display to Media and try again.'
+
 /**
  * Confirms the recording settings based on the provided parameters and updates the recording state.
  */
@@ -100,10 +104,9 @@ export const confirmRecording: ConfirmRecordingType = async ({
   ) {
     if (meetingDisplayType === 'all' && !(breakOutRoomStarted && !breakOutRoomEnded)) {
       showAlert?.({
-        message:
-          'You are not allowed to record videos of all participants; change the meeting display type to video or video optimized.',
+        message: FULL_PARTICIPANT_RECORDING_ALERT_MESSAGE,
         type: 'danger',
-        duration: 3000,
+        duration: ALERT_DURATION,
       })
       return
     }
@@ -113,7 +116,7 @@ export const confirmRecording: ConfirmRecordingType = async ({
     showAlert?.({
       message: 'You are only allowed to record yourself.',
       type: 'danger',
-      duration: 3000,
+      duration: ALERT_DURATION,
     })
     return
   }
@@ -122,7 +125,7 @@ export const confirmRecording: ConfirmRecordingType = async ({
     showAlert?.({
       message: 'You are not allowed to record other video participants.',
       type: 'danger',
-      duration: 3000,
+      duration: ALERT_DURATION,
     })
     return
   }
@@ -131,7 +134,7 @@ export const confirmRecording: ConfirmRecordingType = async ({
     showAlert?.({
       message: 'You are not allowed to record all orientations.',
       type: 'danger',
-      duration: 3000,
+      duration: ALERT_DURATION,
     })
     return
   }
@@ -144,7 +147,7 @@ export const confirmRecording: ConfirmRecordingType = async ({
       showAlert?.({
         message: 'You are not allowed to record this orientation.',
         type: 'danger',
-        duration: 3000,
+        duration: ALERT_DURATION,
       })
       return
     }
@@ -154,7 +157,7 @@ export const confirmRecording: ConfirmRecordingType = async ({
     showAlert?.({
       message: 'You are not allowed to record all formats.',
       type: 'danger',
-      duration: 3000,
+      duration: ALERT_DURATION,
     })
     return
   }
@@ -166,7 +169,7 @@ export const confirmRecording: ConfirmRecordingType = async ({
           message:
             'Recording display type can be either video, video optimized, or media when meeting display type is media.',
           type: 'danger',
-          duration: 3000,
+          duration: ALERT_DURATION,
         })
         updateRecordingDisplayType(meetingDisplayType as 'video' | 'media' | 'all')
         return
@@ -178,7 +181,7 @@ export const confirmRecording: ConfirmRecordingType = async ({
             message:
               'Recording display type can be either video or video optimized when meeting display type is video.',
             type: 'danger',
-            duration: 3000,
+            duration: ALERT_DURATION,
           })
           updateRecordingDisplayType(meetingDisplayType as 'video' | 'media' | 'all')
           return
@@ -189,7 +192,7 @@ export const confirmRecording: ConfirmRecordingType = async ({
             message:
               'Recording display type can only be video optimized when meeting display type is video optimized.',
             type: 'danger',
-            duration: 3000,
+            duration: ALERT_DURATION,
           })
           updateRecordingVideoOptimized(meetingVideoOptimized)
           return
@@ -205,7 +208,7 @@ export const confirmRecording: ConfirmRecordingType = async ({
     showAlert?.({
       message: 'You can only record all participants with media.',
       type: 'danger',
-      duration: 3000,
+      duration: ALERT_DURATION,
     })
     return
   }

package/src/methods/recording/recordResumeTimer.ts

@@ -6,13 +6,13 @@ export interface RecordResumeTimerParameters {
   canPauseResume: boolean
   recordElapsedTime: number
   recordStartTime: number
-  recordTimerInterval?: NodeJS.Timeout | null
+  recordTimerInterval?: ReturnType<typeof setInterval> | null
   showAlert?: ShowAlert
   recordPaused: boolean
   recordStopped: boolean
   roomName: string | null
   updateRecordStartTime: (time: number) => void
-  updateRecordTimerInterval: (interval: NodeJS.Timeout | null) => void
+  updateRecordTimerInterval: (interval: ReturnType<typeof setInterval> | null) => void
   updateIsTimerRunning: (isRunning: boolean) => void
   updateCanPauseResume: (canPause: boolean) => void
   updateRecordElapsedTime: (elapsed: number) => void

package/src/methods/recording/recordStartTimer.ts

@@ -2,7 +2,7 @@ import { recordUpdateTimer } from './recordUpdateTimer'
 
 export interface RecordStartTimerParameters {
   recordStartTime: number
-  recordTimerInterval?: NodeJS.Timeout | null
+  recordTimerInterval?: ReturnType<typeof setInterval> | null
   isTimerRunning: boolean
   canPauseResume: boolean
   recordChangeSeconds: number
@@ -10,7 +10,7 @@ export interface RecordStartTimerParameters {
   recordStopped: boolean
   roomName: string | null
   updateRecordStartTime: (time: number) => void
-  updateRecordTimerInterval: (interval: NodeJS.Timeout | null) => void
+  updateRecordTimerInterval: (interval: ReturnType<typeof setInterval> | null) => void
   updateIsTimerRunning: (isRunning: boolean) => void
   updateCanPauseResume: (canPause: boolean) => void
   recordElapsedTime: number

package/src/methods/recording/timeLeftRecording.ts

@@ -0,0 +1,25 @@
+import type { ShowAlert } from '../../types/types';
+
+export interface TimeLeftRecordingOptions {
+  timeLeft: number;
+  showAlert?: ShowAlert;
+}
+
+export type TimeLeftRecordingType = (options: TimeLeftRecordingOptions) => void;
+
+/**
+ * Shows a short warning that the current recording session is about to end.
+ *
+ * @param options Function options including the remaining recording time in seconds.
+ */
+export const timeLeftRecording = ({ timeLeft, showAlert }: TimeLeftRecordingOptions): void => {
+  try {
+    showAlert?.({
+      message: `The recording will stop in less than ${timeLeft} seconds.`,
+      duration: 3000,
+      type: 'danger',
+    });
+  } catch (error) {
+    console.log('Error in timeLeftRecording: ', error);
+  }
+};

package/src/methods/requests/hostRequestResponse.ts

@@ -0,0 +1,158 @@
+import type { Request, RequestResponse, ShowAlert } from '../../types/types';
+
+export interface HostRequestResponseOptions {
+  requestResponse: RequestResponse;
+  showAlert?: ShowAlert;
+  requestList: Request[];
+  updateRequestList: (requestList: Request[]) => void;
+  updateMicAction: (action: boolean) => void;
+  updateVideoAction: (action: boolean) => void;
+  updateScreenAction: (action: boolean) => void;
+  updateChatAction: (action: boolean) => void;
+  updateAudioRequestState: (state: string | null) => void;
+  updateVideoRequestState: (state: string | null) => void;
+  updateScreenRequestState: (state: string | null) => void;
+  updateChatRequestState: (state: string | null) => void;
+  updateAudioRequestTime: (time: number) => void;
+  updateVideoRequestTime: (time: number) => void;
+  updateScreenRequestTime: (time: number) => void;
+  updateChatRequestTime: (time: number) => void;
+  updateRequestIntervalSeconds: number;
+}
+
+export type HostRequestResponseType = (options: HostRequestResponseOptions) => Promise<void>;
+
+/**
+ * Applies a host's response to a pending participant request.
+ *
+ * This helper removes the resolved request from the pending list, updates the
+ * caller's relevant request state, and triggers acceptance or rejection alerts
+ * with the correct retry cooldown timestamps.
+ *
+ * @param options Function options for processing the host response.
+ * @returns A promise that resolves after request state has been updated.
+ */
+export const hostRequestResponse = async ({
+  requestResponse,
+  showAlert,
+  requestList,
+  updateRequestList,
+  updateMicAction,
+  updateVideoAction,
+  updateScreenAction,
+  updateChatAction,
+  updateAudioRequestState,
+  updateVideoRequestState,
+  updateScreenRequestState,
+  updateChatRequestState,
+  updateAudioRequestTime,
+  updateVideoRequestTime,
+  updateScreenRequestTime,
+  updateChatRequestTime,
+  updateRequestIntervalSeconds,
+}: HostRequestResponseOptions): Promise<void> => {
+  const requestType = requestResponse.type ?? requestResponse.icon;
+
+  // Remove only the specific request that received a host response.
+  const filteredRequests = requestList.filter(
+    (request) => {
+      const matchesId = request.id === requestResponse.id;
+      const matchesType = requestType == null || request.icon === requestType;
+      const matchesName = requestResponse.name == null || request.name === requestResponse.name;
+      const matchesUsername =
+        requestResponse.username == null || request.username === requestResponse.username;
+
+      return !(matchesId && matchesType && matchesName && matchesUsername);
+    }
+  );
+  updateRequestList(filteredRequests);
+
+  if (requestResponse.action === 'accepted') {
+    switch (requestType) {
+      case 'fa-microphone':
+        showAlert?.({
+          message: 'Unmute request was accepted; click the mic button again to begin.',
+          type: 'success',
+          duration: 10000,
+        });
+        updateMicAction(true);
+        updateAudioRequestState('accepted');
+        break;
+      case 'fa-video':
+        showAlert?.({
+          message: 'Video request was accepted; click the video button again to begin.',
+          type: 'success',
+          duration: 10000,
+        });
+        updateVideoAction(true);
+        updateVideoRequestState('accepted');
+        break;
+      case 'fa-desktop':
+        showAlert?.({
+          message: 'Screenshare request was accepted; click the screen button again to begin.',
+          type: 'success',
+          duration: 10000,
+        });
+        updateScreenAction(true);
+        updateScreenRequestState('accepted');
+        break;
+      case 'fa-comments':
+        showAlert?.({
+          message: 'Chat request was accepted; click the chat button again to begin.',
+          type: 'success',
+          duration: 10000,
+        });
+        updateChatAction(true);
+        updateChatRequestState('accepted');
+        break;
+    }
+  } else {
+    let timerDate: Date;
+    switch (requestType) {
+      case 'fa-microphone':
+        showAlert?.({
+          message: 'Unmute request was not accepted',
+          type: 'danger',
+          duration: 10000,
+        });
+        updateAudioRequestState('rejected');
+        timerDate = new Date();
+        timerDate.setSeconds(timerDate.getSeconds() + updateRequestIntervalSeconds);
+        updateAudioRequestTime(timerDate.getTime());
+        break;
+      case 'fa-video':
+        showAlert?.({
+          message: 'Video request was not accepted',
+          type: 'danger',
+          duration: 10000,
+        });
+        updateVideoRequestState('rejected');
+        timerDate = new Date();
+        timerDate.setSeconds(timerDate.getSeconds() + updateRequestIntervalSeconds);
+        updateVideoRequestTime(timerDate.getTime());
+        break;
+      case 'fa-desktop':
+        showAlert?.({
+          message: 'Screenshare request was not accepted',
+          type: 'danger',
+          duration: 10000,
+        });
+        updateScreenRequestState('rejected');
+        timerDate = new Date();
+        timerDate.setSeconds(timerDate.getSeconds() + updateRequestIntervalSeconds);
+        updateScreenRequestTime(timerDate.getTime());
+        break;
+      case 'fa-comments':
+        showAlert?.({
+          message: 'Chat request was not accepted',
+          type: 'danger',
+          duration: 10000,
+        });
+        updateChatRequestState('rejected');
+        timerDate = new Date();
+        timerDate.setSeconds(timerDate.getSeconds() + updateRequestIntervalSeconds);
+        updateChatRequestTime(timerDate.getTime());
+        break;
+    }
+  }
+};

package/src/methods/settings/modifySettings.ts

@@ -46,7 +46,7 @@ export type ModifySettingsType = (options: ModifySettingsOptions) => Promise<voi
  * ```
  */
 export async function modifySettings({
-  showAlert,
+  // showAlert,
   roomName,
   audioSet,
   videoSet,
@@ -59,23 +59,23 @@ export async function modifySettings({
   updateChatSetting,
   updateIsSettingsModalVisible,
 }: ModifySettingsOptions): Promise<void> {
-  if (roomName.toLowerCase().startsWith('d')) {
-    // none should be approval
-    if (
-      audioSet === 'approval' ||
-      videoSet === 'approval' ||
-      screenshareSet === 'approval' ||
-      chatSet === 'approval'
-    ) {
-      showAlert?.({
-        message: 'You cannot set approval for demo mode.',
-        type: 'danger',
-        duration: 3000,
-      });
+  // if (roomName.toLowerCase().startsWith('d')) {
+  //   // none should be approval
+  //   if (
+  //     audioSet === 'approval' ||
+  //     videoSet === 'approval' ||
+  //     screenshareSet === 'approval' ||
+  //     chatSet === 'approval'
+  //   ) {
+  //     showAlert?.({
+  //       message: 'You cannot set approval for demo mode.',
+  //       type: 'danger',
+  //       duration: 3000,
+  //     });
 
-      return;
-    }
-  }
+  //     return;
+  //   }
+  // }
 
   // Check and update state variables based on the provided logic
   if (audioSet) {