mediasfu-shared 1.0.1 → 1.0.2

package/src/methods/displaySettings/modifyDisplaySettings.ts

@@ -6,6 +6,7 @@ export interface ModifyDisplaySettingsParameters extends OnScreenChangesParamete
   meetingDisplayType: string
   autoWave: boolean
   forceFullDisplay: boolean
+  showSubtitlesOnCards?: boolean
   meetingVideoOptimized: boolean
   islevel: string
   recordStarted: boolean
@@ -19,6 +20,7 @@ export interface ModifyDisplaySettingsParameters extends OnScreenChangesParamete
   updateMeetingDisplayType: (displayType: string) => void
   updateAutoWave: (autoWave: boolean) => void
   updateForceFullDisplay: (forceFullDisplay: boolean) => void
+  updateShowSubtitlesOnCards?: (showSubtitlesOnCards: boolean) => void
   updateMeetingVideoOptimized: (optimized: boolean) => void
   updatePrevForceFullDisplay: (forceFullDisplay: boolean) => void
   updatePrevMeetingDisplayType: (displayType: string) => void
@@ -121,6 +123,7 @@ export const modifyDisplaySettings = async ({
     meetingDisplayType,
     autoWave,
     forceFullDisplay,
+    showSubtitlesOnCards = true,
     meetingVideoOptimized,
     islevel,
     recordStarted,
@@ -134,6 +137,7 @@ export const modifyDisplaySettings = async ({
     updateMeetingDisplayType,
     updateAutoWave,
     updateForceFullDisplay,
+    updateShowSubtitlesOnCards,
     updateMeetingVideoOptimized,
     updatePrevForceFullDisplay,
     updatePrevMeetingDisplayType,
@@ -148,6 +152,7 @@ export const modifyDisplaySettings = async ({
   // Update previous states
   updateAutoWave(autoWave)
   updateForceFullDisplay(forceFullDisplay)
+  updateShowSubtitlesOnCards?.(showSubtitlesOnCards)
 
   if (
     islevel === '2' &&

package/src/methods/index.ts

@@ -3,3 +3,69 @@
 export * from './prejoin';
 // Welcome methods
 export * from './welcome';
+// Panelists methods
+export * from './panelists';
+// Permissions methods
+export * from './permissions';
+// Shared utility methods
+export * from './utils/liveSubtitle';
+export * from './utils/translationLanguages';
+export * from './utils/SoundPlayer';
+export * from './utils/getOverlayPosition';
+export * from './utils/sleep';
+export * from './utils/formatNumber';
+export * from './utils/generateRandomMessages';
+export * from './utils/generateRandomParticipants';
+export * from './utils/generateRandomPolls';
+export * from './utils/generateRandomRequestList';
+export * from './utils/generateRandomWaitingRoomList';
+export * from './utils/initialValuesState';
+export * from './utils/webrtc';
+export * from './utils/checkLimitsAndMakeRequest';
+export * from './utils/createResponseJoinRoom';
+export * from './utils/joinRoomOnMediaSFU';
+export * from './utils/createRoomOnMediaSFU';
+export * from './utils/meetingTimer/startMeetingProgressTimer';
+export * from './utils/meetingTimeRemaining';
+export * from './utils/producer/aParams';
+export * from './utils/producer/hParams';
+export * from './utils/producer/vParams';
+export * from './utils/producer/screenParams';
+export * from './utils/producer/videoCaptureConstraints';
+export * from './utils/validateAlphanumeric';
+export * from './polls/pollUpdated';
+export * from './requests/hostRequestResponse';
+export * from './stream/clickAudio';
+export * from './stream/clickChat';
+export * from './stream/clickScreenShare';
+export * from './whiteboard/captureCanvasStream';
+export * from './recording/timeLeftRecording';
+export * from './socketReceive/allWaitingRoomMembers';
+export * from './socketReceive/allMembers';
+export * from './socketReceive/allMembersRest';
+export * from './socketReceive/banParticipant';
+export * from './socketReceive/controlMediaHost';
+export * from './socketReceive/disconnect';
+export * from './socketReceive/disconnectUserSelf';
+export * from './socketReceive/getDomains';
+export * from './socketReceive/meetingEnded';
+export * from './socketReceive/meetingStillThere';
+export * from './socketReceive/panelistReceiveMethods';
+export * from './socketReceive/participantRequested';
+export * from './socketReceive/permissionReceiveMethods';
+export * from './socketReceive/personJoined';
+export * from './socketReceive/producerMediaClosed';
+export * from './socketReceive/producerMediaPaused';
+export * from './socketReceive/producerMediaResumed';
+export * from './socketReceive/receiveMessage';
+export * from './socketReceive/recordingNotice';
+export * from './socketReceive/reInitiateRecording';
+export * from './socketReceive/roomRecordParams';
+export * from './socketReceive/screenProducerId';
+export * from './socketReceive/startRecords';
+export * from './socketReceive/stoppedRecording';
+export * from './socketReceive/translationReceiveMethods';
+export * from './socketReceive/updateMediaSettings';
+export * from './socketReceive/updateConsumingDomains';
+export * from './socketReceive/updatedCoHost';
+export * from './socketReceive/userWaiting';

package/src/methods/message/sendMessage.ts

@@ -77,7 +77,6 @@ export const sendMessage = async ({
   member,
   sender,
   islevel,
-  eventType,
   showAlert,
   coHostResponsibility,
   coHost,
@@ -87,34 +86,18 @@ export const sendMessage = async ({
 }: 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 message count limit based on room type prefix
+  if (
+    (messagesLength > 100 && roomName.startsWith("d")) ||
+    (messagesLength > 500 && roomName.startsWith("s")) ||
+    (messagesLength > 100000 && roomName.startsWith("p"))
+  ) {
+    showAlert?.({
+      message: "You have reached the maximum number of messages allowed.",
+      type: "danger",
+      duration: 3000,
+    });
+    return;
   }
 
   // Check if message is valid

package/src/methods/panelists/focusPanelists.ts

@@ -0,0 +1,83 @@
+import { Socket } from 'socket.io-client';
+import type { ShowAlert } from '../../types/types';
+
+export interface FocusPanelistsOptions {
+  socket: Socket;
+  roomName: string;
+  member: string;
+  islevel: string;
+  focusEnabled: boolean;
+  muteOthersMic?: boolean;
+  muteOthersCamera?: boolean;
+  showAlert?: ShowAlert;
+}
+
+export interface UnfocusPanelistsOptions {
+  socket: Socket;
+  roomName: string;
+  member: string;
+  islevel: string;
+  showAlert?: ShowAlert;
+}
+
+export type FocusPanelistsType = (options: FocusPanelistsOptions) => Promise<void>;
+export type UnfocusPanelistsType = (options: UnfocusPanelistsOptions) => Promise<void>;
+
+export const focusPanelists = async ({
+  socket,
+  roomName,
+  member: _member,
+  islevel,
+  focusEnabled,
+  muteOthersMic = false,
+  muteOthersCamera = false,
+  showAlert,
+}: FocusPanelistsOptions): Promise<void> => {
+  if (islevel !== '2') {
+    showAlert?.({ message: 'Only the host can focus panelists', type: 'danger', duration: 3000 });
+    return;
+  }
+
+  socket.emit(
+    'focusPanelists',
+    {
+      roomName,
+      focusEnabled,
+      muteOthersMic,
+      muteOthersCamera,
+    },
+    (response: { success: boolean; reason?: string }) => {
+      if (!response?.success) {
+        showAlert?.({ message: response?.reason || 'Failed to focus panelists', type: 'danger', duration: 3000 });
+      }
+    }
+  );
+};
+
+export const unfocusPanelists = async ({
+  socket,
+  roomName,
+  member: _member,
+  islevel,
+  showAlert,
+}: UnfocusPanelistsOptions): Promise<void> => {
+  if (islevel !== '2') {
+    showAlert?.({ message: 'Only the host can unfocus panelists', type: 'danger', duration: 3000 });
+    return;
+  }
+
+  socket.emit(
+    'focusPanelists',
+    {
+      roomName,
+      focusEnabled: false,
+      muteOthersMic: false,
+      muteOthersCamera: false,
+    },
+    (response: { success: boolean; reason?: string }) => {
+      if (!response?.success) {
+        showAlert?.({ message: response?.reason || 'Failed to unfocus panelists', type: 'danger', duration: 3000 });
+      }
+    }
+  );
+};

package/src/methods/panelists/index.ts

@@ -0,0 +1,3 @@
+export * from './launchPanelists';
+export * from './updatePanelists';
+export * from './focusPanelists';

package/src/methods/panelists/launchPanelists.ts

@@ -0,0 +1,13 @@
+export interface LaunchPanelistsOptions {
+  updateIsPanelistsModalVisible: (visible: boolean) => void;
+  isPanelistsModalVisible: boolean;
+}
+
+export type LaunchPanelistsType = (options: LaunchPanelistsOptions) => void;
+
+export const launchPanelists = ({
+  updateIsPanelistsModalVisible,
+  isPanelistsModalVisible,
+}: LaunchPanelistsOptions): void => {
+  updateIsPanelistsModalVisible(!isPanelistsModalVisible);
+};

package/src/methods/panelists/updatePanelists.ts

@@ -0,0 +1,135 @@
+import { Socket } from 'socket.io-client';
+import type { Participant, ShowAlert } from '../../types/types';
+
+export interface UpdatePanelistsOptions {
+  socket: Socket;
+  panelists: Participant[];
+  roomName: string;
+  member: string;
+  islevel: string;
+  showAlert?: ShowAlert;
+}
+
+export interface AddPanelistOptions {
+  socket: Socket;
+  participant: Participant;
+  currentPanelists: Participant[];
+  maxPanelists: number;
+  roomName: string;
+  member: string;
+  islevel: string;
+  showAlert?: ShowAlert;
+}
+
+export interface RemovePanelistOptions {
+  socket: Socket;
+  participant: Participant;
+  roomName: string;
+  member: string;
+  islevel: string;
+  showAlert?: ShowAlert;
+}
+
+export type UpdatePanelistsType = (options: UpdatePanelistsOptions) => Promise<void>;
+export type AddPanelistType = (options: AddPanelistOptions) => Promise<boolean>;
+export type RemovePanelistType = (options: RemovePanelistOptions) => Promise<void>;
+
+export const updatePanelists = async ({
+  socket,
+  panelists,
+  roomName,
+  member: _member,
+  islevel,
+  showAlert,
+}: UpdatePanelistsOptions): Promise<void> => {
+  if (islevel !== '2') {
+    showAlert?.({ message: 'Only the host can update panelists', type: 'danger', duration: 3000 });
+    return;
+  }
+
+  socket.emit(
+    'updatePanelists',
+    {
+      panelists: panelists.map((p) => ({ id: p.id, name: p.name })),
+      roomName,
+    },
+    (response: { success: boolean; reason?: string }) => {
+      if (!response?.success) {
+        showAlert?.({ message: response?.reason || 'Failed to update panelists', type: 'danger', duration: 3000 });
+      }
+    }
+  );
+};
+
+export const addPanelist = async ({
+  socket,
+  participant,
+  currentPanelists,
+  maxPanelists,
+  roomName,
+  member: _member,
+  islevel,
+  showAlert,
+}: AddPanelistOptions): Promise<boolean> => {
+  if (islevel !== '2') {
+    showAlert?.({ message: 'Only the host can add panelists', type: 'danger', duration: 3000 });
+    return false;
+  }
+
+  if (currentPanelists.some((p) => p.id === participant.id)) {
+    showAlert?.({ message: `${participant.name} is already a panelist`, type: 'success', duration: 3000 });
+    return false;
+  }
+
+  if (currentPanelists.length >= maxPanelists) {
+    showAlert?.({ message: `Maximum panelist limit (${maxPanelists}) reached`, type: 'danger', duration: 3000 });
+    return false;
+  }
+
+  return new Promise((resolve) => {
+    socket.emit(
+      'addPanelist',
+      {
+        participantId: participant.id,
+        participantName: participant.name,
+        roomName,
+      },
+      (response: { success: boolean; reason?: string }) => {
+        if (!response?.success) {
+          showAlert?.({ message: response?.reason || 'Failed to add panelist', type: 'danger', duration: 3000 });
+          resolve(false);
+        } else {
+          resolve(true);
+        }
+      }
+    );
+  });
+};
+
+export const removePanelist = async ({
+  socket,
+  participant,
+  roomName,
+  member: _member,
+  islevel,
+  showAlert,
+}: RemovePanelistOptions): Promise<void> => {
+  if (islevel !== '2') {
+    showAlert?.({ message: 'Only the host can remove panelists', type: 'danger', duration: 3000 });
+    return;
+  }
+
+  socket.emit(
+    'removePanelist',
+    {
+      participantId: participant.id,
+      participantName: participant.name,
+      roomName,
+    },
+    (response: { success: boolean; reason?: string }) => {
+      if (!response?.success) {
+        showAlert?.({ message: response?.reason || 'Failed to remove panelist', type: 'danger', duration: 3000 });
+      }
+    }
+  );
+};

package/src/methods/permissions/index.ts

@@ -0,0 +1,3 @@
+export * from './launchPermissions';
+export * from './updateParticipantPermission';
+export * from './updatePermissionConfig';

package/src/methods/permissions/launchPermissions.ts

@@ -0,0 +1,13 @@
+export interface LaunchPermissionsOptions {
+  updateIsPermissionsModalVisible: (visible: boolean) => void;
+  isPermissionsModalVisible: boolean;
+}
+
+export type LaunchPermissionsType = (options: LaunchPermissionsOptions) => void;
+
+export const launchPermissions = ({
+  updateIsPermissionsModalVisible,
+  isPermissionsModalVisible,
+}: LaunchPermissionsOptions): void => {
+  updateIsPermissionsModalVisible(!isPermissionsModalVisible);
+};

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 {
+  }
+};