mediasfu-shared 1.0.1 → 1.0.3

package/src/methods/socketReceive/updateMediaSettings.ts

@@ -0,0 +1,45 @@
+import type { Settings } from '../../types/types';
+
+export interface UpdateMediaSettingsOptions {
+  settings: Settings;
+  updateAudioSetting: (value: string) => void;
+  updateVideoSetting: (value: string) => void;
+  updateScreenshareSetting: (value: string) => void;
+  updateChatSetting: (value: string) => void;
+}
+
+export type UpdateMediaSettingsType = (
+  options: UpdateMediaSettingsOptions,
+) => void;
+
+/**
+ * Expands the shared `Settings` tuple into individual media setting updaters.
+ *
+ * @param {UpdateMediaSettingsOptions} options - Settings tuple and update callbacks.
+ * @returns {void} Updates state synchronously.
+ *
+ * @example
+ * ```typescript
+ * updateMediaSettings({
+ *   settings: ['allow', 'allow', 'deny', 'allow'],
+ *   updateAudioSetting: setAudioSetting,
+ *   updateVideoSetting: setVideoSetting,
+ *   updateScreenshareSetting: setScreenshareSetting,
+ *   updateChatSetting: setChatSetting,
+ * });
+ * ```
+ */
+export const updateMediaSettings = ({
+  settings,
+  updateAudioSetting,
+  updateVideoSetting,
+  updateScreenshareSetting,
+  updateChatSetting,
+}: UpdateMediaSettingsOptions): void => {
+  const [audioSetting, videoSetting, screenshareSetting, chatSetting] = settings;
+
+  updateAudioSetting(audioSetting);
+  updateVideoSetting(videoSetting);
+  updateScreenshareSetting(screenshareSetting);
+  updateChatSetting(chatSetting);
+};

package/src/methods/socketReceive/updatedCoHost.ts

@@ -0,0 +1,75 @@
+import type {
+  CoHostResponsibility,
+  EventType,
+  ShowAlert,
+} from '../../types/types';
+
+export interface UpdatedCoHostOptions {
+  coHost: string;
+  coHostResponsibility: CoHostResponsibility[];
+  showAlert?: ShowAlert;
+  eventType: EventType;
+  islevel: string;
+  member: string;
+  youAreCoHost: boolean;
+  updateCoHost: (coHost: string) => void;
+  updateCoHostResponsibility: (responsibility: CoHostResponsibility[]) => void;
+  updateYouAreCoHost: (youAreCoHost: boolean) => void;
+}
+
+export type UpdatedCoHostType = (options: UpdatedCoHostOptions) => Promise<void>;
+
+/**
+ * Synchronizes co-host assignment state and optionally alerts the newly assigned co-host.
+ *
+ * @param {UpdatedCoHostOptions} options - Co-host payload and state setters.
+ * @returns {Promise<void>} Resolves after co-host state is synchronized.
+ *
+ * @example
+ * ```typescript
+ * await updatedCoHost({
+ *   coHost: 'user123',
+ *   coHostResponsibility: responsibilities,
+ *   eventType: 'conference',
+ *   islevel: '1',
+ *   member: 'user123',
+ *   youAreCoHost: false,
+ *   updateCoHost: setCoHost,
+ *   updateCoHostResponsibility: setCoHostResponsibility,
+ *   updateYouAreCoHost: setYouAreCoHost,
+ *   showAlert,
+ * });
+ * ```
+ */
+export const updatedCoHost = async ({
+  coHost,
+  coHostResponsibility,
+  showAlert,
+  eventType,
+  islevel,
+  member,
+  youAreCoHost,
+  updateCoHost,
+  updateCoHostResponsibility,
+  updateYouAreCoHost,
+}: UpdatedCoHostOptions): Promise<void> => {
+  if (eventType !== 'broadcast' && eventType !== 'chat') {
+    updateCoHost(coHost);
+    updateCoHostResponsibility(coHostResponsibility);
+
+    if (member === coHost) {
+      if (!youAreCoHost) {
+        updateYouAreCoHost(true);
+        showAlert?.({
+          message: 'You are now a co-host.',
+          type: 'success',
+          duration: 3000,
+        });
+      }
+    } else {
+      updateYouAreCoHost(false);
+    }
+  } else if (islevel !== '2') {
+    updateYouAreCoHost(true);
+  }
+};

package/src/methods/socketReceive/userWaiting.ts

@@ -0,0 +1,45 @@
+import type { ShowAlert } from '../../types/types';
+
+export interface UserWaitingOptions {
+  name: string;
+  showAlert?: ShowAlert;
+  totalReqWait: number;
+  updateTotalReqWait: (total: number) => void;
+}
+
+export type UserWaitingType = (options: UserWaitingOptions) => Promise<void>;
+
+/**
+ * Handles a participant joining the waiting room by notifying the UI and bumping the pending total.
+ *
+ * @param {UserWaitingOptions} options - Waiting-room notification settings.
+ * @param {string} options.name - Participant name shown in the alert.
+ * @param {ShowAlert} [options.showAlert] - Optional alert presenter.
+ * @param {number} options.totalReqWait - Current combined waiting/request count.
+ * @param {(total: number) => void} options.updateTotalReqWait - Updates the combined waiting/request count.
+ * @returns {Promise<void>} Resolves after state updates complete.
+ *
+ * @example
+ * ```typescript
+ * await userWaiting({
+ *   name: 'Ada',
+ *   totalReqWait: 2,
+ *   updateTotalReqWait: setTotalReqWait,
+ *   showAlert: ({ message }) => console.log(message),
+ * });
+ * ```
+ */
+export const userWaiting = async ({
+  name,
+  showAlert,
+  totalReqWait,
+  updateTotalReqWait,
+}: UserWaitingOptions): Promise<void> => {
+  showAlert?.({
+    message: `${name} joined the waiting room.`,
+    type: 'success',
+    duration: 3000,
+  });
+
+  updateTotalReqWait(totalReqWait + 1);
+};

package/src/methods/stream/clickAudio.ts

@@ -0,0 +1,380 @@
+import { Socket } from 'socket.io-client';
+import {
+  CheckPermissionType,
+  DisconnectSendTransportAudioParameters,
+  DisconnectSendTransportAudioType,
+  Participant,
+  RequestPermissionAudioType,
+  ResumeSendTransportAudioParameters,
+  ResumeSendTransportAudioType,
+  ShowAlert,
+  StreamSuccessAudioParameters,
+  StreamSuccessAudioType,
+} from '../../types/types';
+import type { PermissionConfig } from '../permissions/updatePermissionConfig';
+
+export interface ClickAudioParameters
+  extends DisconnectSendTransportAudioParameters,
+    ResumeSendTransportAudioParameters,
+    StreamSuccessAudioParameters {
+  checkMediaPermission: boolean;
+  hasAudioPermission: boolean;
+  audioPaused: boolean;
+  audioAlreadyOn: boolean;
+  audioOnlyRoom: boolean;
+  recordStarted: boolean;
+  recordResumed: boolean;
+  recordPaused: boolean;
+  recordStopped: boolean;
+  recordingMediaOptions: string;
+  islevel: string;
+  youAreCoHost: boolean;
+  adminRestrictSetting: boolean;
+  audioRequestState: string | null;
+  audioRequestTime: number;
+  member: string;
+  socket: Socket;
+  localSocket?: Socket;
+  roomName: string;
+  userDefaultAudioInputDevice: string;
+  micAction: boolean;
+  localStream: MediaStream | null;
+  audioSetting: string;
+  videoSetting: string;
+  screenshareSetting: string;
+  chatSetting: string;
+  permissionConfig?: PermissionConfig | null;
+  updateRequestIntervalSeconds: number;
+  participants: Participant[];
+  mediaDevices: MediaDevices;
+  transportCreated: boolean;
+  transportCreatedAudio: boolean;
+  supportFlexRoom?: boolean;
+  supportMaxRoom?: boolean;
+
+  updateAudioAlreadyOn: (status: boolean) => void;
+  updateAudioRequestState: (state: string | null) => void;
+  updateAudioPaused: (status: boolean) => void;
+  updateLocalStream: (stream: MediaStream | null) => void;
+  updateParticipants: (participants: Participant[]) => void;
+  updateTransportCreated: (status: boolean) => void;
+  updateTransportCreatedAudio: (status: boolean) => void;
+  updateMicAction: (action: boolean) => void;
+  showAlert?: ShowAlert;
+
+  checkPermission: CheckPermissionType;
+  streamSuccessAudio: StreamSuccessAudioType;
+  disconnectSendTransportAudio: DisconnectSendTransportAudioType;
+  requestPermissionAudio: RequestPermissionAudioType;
+  resumeSendTransportAudio: ResumeSendTransportAudioType;
+
+  getUpdatedAllParams: () => ClickAudioParameters;
+  [key: string]: any;
+}
+
+export interface ClickAudioOptions {
+  parameters: ClickAudioParameters;
+}
+
+export type ClickAudioType = (options: ClickAudioOptions) => Promise<void>;
+
+/**
+ * Handles microphone toggle flow for a participant.
+ *
+ * This helper enforces host permission rules, request cooldowns, recording
+ * constraints, and transport resume/disconnect behavior before updating the
+ * caller's local media state.
+ *
+ * @param options Function options containing the full runtime parameter bag.
+ * @returns A promise that resolves after the microphone action has been processed.
+ */
+export const clickAudio = async ({ parameters }: ClickAudioOptions): Promise<void> => {
+  let {
+    checkMediaPermission,
+    hasAudioPermission,
+    audioPaused,
+    audioAlreadyOn,
+    audioOnlyRoom,
+    recordStarted,
+    recordResumed,
+    recordPaused,
+    recordStopped,
+    recordingMediaOptions,
+    islevel,
+    youAreCoHost,
+    adminRestrictSetting,
+    audioRequestState,
+    audioRequestTime,
+    member,
+    socket,
+    localSocket,
+    roomName,
+    userDefaultAudioInputDevice,
+    micAction,
+    localStream,
+    audioSetting,
+    videoSetting,
+    screenshareSetting,
+    chatSetting,
+    updateRequestIntervalSeconds,
+    participants,
+    mediaDevices,
+    showAlert,
+    transportCreated,
+    transportCreatedAudio,
+
+    updateAudioAlreadyOn,
+    updateAudioRequestState,
+    updateAudioPaused,
+    updateLocalStream,
+    updateParticipants,
+    updateTransportCreated,
+    updateTransportCreatedAudio,
+    updateMicAction,
+
+    checkPermission,
+    streamSuccessAudio,
+    requestPermissionAudio,
+    resumeSendTransportAudio,
+    disconnectSendTransportAudio,
+  } = parameters;
+
+  if (audioOnlyRoom) {
+    showAlert?.({
+      message: 'You cannot turn on your camera in an audio-only event.',
+      type: 'danger',
+      duration: 3000,
+    });
+    return;
+  }
+
+  if (audioAlreadyOn) {
+    if (islevel === '2' && (recordStarted || recordResumed)) {
+      if (!(recordPaused || recordStopped)) {
+        if (recordingMediaOptions === 'audio') {
+          showAlert?.({
+            message: 'You cannot turn off your audio while recording, please pause or stop recording first.',
+            type: 'danger',
+            duration: 3000,
+          });
+          return;
+        }
+      }
+    }
+
+    audioAlreadyOn = false;
+    updateAudioAlreadyOn(audioAlreadyOn);
+    if (localStream && localStream.getAudioTracks().length > 0) {
+      localStream.getAudioTracks()[0].enabled = false;
+      updateLocalStream(localStream);
+    }
+    await disconnectSendTransportAudio({ parameters });
+    audioPaused = true;
+    updateAudioPaused(audioPaused);
+  } else {
+    if (adminRestrictSetting) {
+      showAlert?.({
+        message: 'You cannot turn on your microphone. Access denied by host.',
+        type: 'danger',
+        duration: 3000,
+      });
+      return;
+    }
+
+    const supportMaxRoom = parameters.supportMaxRoom;
+    const supportFlexRoom = parameters.supportFlexRoom;
+    if ((supportMaxRoom || supportFlexRoom) && islevel !== '2') {
+      try {
+        const checkResult = await new Promise<{
+          allowed: boolean;
+          reason?: string;
+          producingCount?: number;
+          producerLimit?: number;
+        }>((resolve) => {
+          socket.emit(
+            'checkProduce',
+            { kind: 'audio' },
+            (response: {
+              allowed: boolean;
+              reason?: string;
+              producingCount?: number;
+              producerLimit?: number;
+            }) => {
+              resolve(response || { allowed: false, reason: 'No response from server' });
+            },
+          );
+
+          setTimeout(() => resolve({ allowed: true }), 5000);
+        });
+
+        if (!checkResult.allowed) {
+          showAlert?.({
+            message:
+              checkResult.reason ||
+              `Audio producer limit reached (${checkResult.producingCount}/${checkResult.producerLimit}).`,
+            type: 'danger',
+            duration: 3000,
+          });
+          return;
+        }
+      } catch (error) {
+        console.warn('Failed to check producer limit:', error);
+      }
+    }
+
+    const panelistsFocused = parameters.panelistsFocused;
+    const muteOthersMic = parameters.muteOthersMic;
+    const panelists = parameters.panelists;
+
+    if (panelistsFocused && muteOthersMic && islevel !== '2') {
+      const isPanelist =
+        panelists?.some((panelist: { name: string }) => panelist.name === member) || false;
+
+      if (!isPanelist) {
+        showAlert?.({
+          message:
+            'You cannot turn on your microphone. Only panelists can unmute while focus mode is active.',
+          type: 'danger',
+          duration: 3000,
+        });
+        return;
+      }
+    }
+
+    let response = 2;
+    if (!micAction && islevel !== '2' && !youAreCoHost) {
+      response = await checkPermission({
+        permissionType: 'audioSetting',
+        audioSetting,
+        videoSetting,
+        screenshareSetting,
+        chatSetting,
+        permissionConfig: parameters.permissionConfig,
+        participantLevel: islevel,
+      });
+    } else {
+      response = 0;
+    }
+
+    switch (response) {
+      case 1: {
+        if (audioRequestState === 'pending') {
+          showAlert?.({
+            message: 'A request is pending. Please wait for the host to respond.',
+            type: 'danger',
+            duration: 3000,
+          });
+          return;
+        }
+
+        if (
+          audioRequestState === 'rejected' &&
+          Date.now() - audioRequestTime < updateRequestIntervalSeconds * 1000
+        ) {
+          showAlert?.({
+            message: `A request was rejected. Please wait for ${updateRequestIntervalSeconds} seconds before sending another request.`,
+            type: 'danger',
+            duration: 3000,
+          });
+          return;
+        }
+
+        showAlert?.({
+          message: 'Request sent to host.',
+          type: 'success',
+          duration: 3000,
+        });
+
+        audioRequestState = 'pending';
+        updateAudioRequestState(audioRequestState);
+
+        const userRequest = {
+          id: socket.id,
+          name: member,
+          icon: 'fa-microphone',
+        };
+        socket.emit('participantRequest', { userRequest, roomName });
+        break;
+      }
+
+      case 2:
+        showAlert?.({
+          message: 'You cannot turn on your microphone. Access denied by host.',
+          type: 'danger',
+          duration: 3000,
+        });
+        break;
+
+      case 0:
+        if (audioPaused) {
+          if (localStream && localStream.getAudioTracks().length > 0) {
+            localStream.getAudioTracks()[0].enabled = true;
+          }
+          updateAudioAlreadyOn(true);
+          await resumeSendTransportAudio({ parameters });
+          socket.emit('resumeProducerAudio', { mediaTag: 'audio', roomName });
+
+          try {
+            if (localSocket && localSocket.id) {
+              localSocket.emit('resumeProducerAudio', { mediaTag: 'audio', roomName });
+            }
+          } catch (error) {
+            console.log('Error in resumeProducerAudio', error);
+          }
+
+          updateLocalStream(localStream);
+
+          if (micAction === true) {
+            micAction = false;
+            updateMicAction(micAction);
+          }
+
+          participants.forEach((participant) => {
+            if (participant.socketId === socket.id && participant.name === member) {
+              participant.muted = false;
+            }
+          });
+          updateParticipants(participants);
+
+          transportCreated = true;
+          updateTransportCreated(transportCreated);
+
+          transportCreatedAudio = true;
+          updateTransportCreatedAudio(transportCreatedAudio);
+        } else {
+          if (!hasAudioPermission && checkMediaPermission) {
+            const statusMic = await requestPermissionAudio();
+            if (statusMic !== 'granted') {
+              showAlert?.({
+                message:
+                  'Allow access to your microphone or check if your microphone is not being used by another application.',
+                type: 'danger',
+                duration: 3000,
+              });
+              return;
+            }
+          }
+
+          const mediaConstraints = userDefaultAudioInputDevice
+            ? { audio: { deviceId: userDefaultAudioInputDevice }, video: false }
+            : { audio: true, video: false };
+
+          try {
+            const stream = await mediaDevices.getUserMedia(mediaConstraints);
+            await streamSuccessAudio({ stream, parameters });
+          } catch (error) {
+            console.error(error);
+            showAlert?.({
+              message:
+                'Allow access to your microphone or check if your microphone is not being used by another application.',
+              type: 'danger',
+              duration: 3000,
+            });
+          }
+        }
+        break;
+
+      default:
+    }
+  }
+};

package/src/methods/stream/clickChat.ts

@@ -0,0 +1,36 @@
+import type { ShowAlert } from '../../types/types';
+
+export interface ClickChatOptions {
+  isMessagesModalVisible: boolean;
+  updateIsMessagesModalVisible: (isVisible: boolean) => void;
+  chatSetting: string;
+  islevel: string;
+  showAlert?: ShowAlert;
+}
+
+export type ClickChatType = (options: ClickChatOptions) => Promise<void>;
+
+export const clickChat = async ({
+  isMessagesModalVisible,
+  updateIsMessagesModalVisible,
+  chatSetting,
+  islevel,
+  showAlert,
+}: ClickChatOptions): Promise<void> => {
+  if (isMessagesModalVisible) {
+    updateIsMessagesModalVisible(false);
+    return;
+  }
+
+  if (chatSetting !== 'allow' && islevel !== '2') {
+    updateIsMessagesModalVisible(false);
+    showAlert?.({
+      message: 'Chat is disabled for this event.',
+      type: 'danger',
+      duration: 3000,
+    });
+    return;
+  }
+
+  updateIsMessagesModalVisible(true);
+};