mediasfu-shared 1.0.0

package/src/methods/stream/switchVideo.ts

@@ -0,0 +1,148 @@
+import type { ShowAlert, SwitchUserVideoType, SwitchUserVideoParameters } from '../../types/types'
+
+
+export interface SwitchVideoParameters extends SwitchUserVideoParameters {
+  recordStarted: boolean
+  recordResumed: boolean
+  recordStopped: boolean
+  recordPaused: boolean
+  recordingMediaOptions: string
+  videoAlreadyOn: boolean
+  userDefaultVideoInputDevice: string
+  defVideoID: string
+  allowed: boolean
+  updateDefVideoID: (deviceId: string) => void
+  updatePrevVideoInputDevice: (deviceId: string) => void
+  updateUserDefaultVideoInputDevice: (deviceId: string) => void
+  updateIsMediaSettingsModalVisible: (isVisible: boolean) => void
+  showAlert?: ShowAlert
+
+  // Mediasfu functions
+  switchUserVideo: SwitchUserVideoType
+
+  [key: string]: any
+}
+
+export interface SwitchVideoOptions {
+  videoPreference: string
+  parameters: SwitchVideoParameters
+}
+
+// Export the type definition for the function
+export type SwitchVideoType = (options: SwitchVideoOptions) => Promise<void>
+
+/**
+ * Switches the user's video device based on the provided video preference.
+ *
+ * @param {SwitchVideoOptions} options - The function parameters.
+ * @returns {Promise<void>}
+ *
+ * @example
+ * ```typescript
+ * switchVideo({
+ *   videoPreference: "newVideoDeviceID",
+ *   parameters: {
+ *     recordStarted: true,
+ *     recordResumed: false,
+ *     recordStopped: false,
+ *     recordPaused: false,
+ *     recordingMediaOptions: "video",
+ *     videoAlreadyOn: true,
+ *     userDefaultVideoInputDevice: "currentVideoDeviceID",
+ *     defVideoID: "defaultVideoDeviceID",
+ *     allowed: true,
+ *     updateDefVideoID: (deviceId) => setDefVideoID(deviceId),
+ *     updatePrevVideoInputDevice: (deviceId) => setPrevVideoDevice(deviceId),
+ *     updateUserDefaultVideoInputDevice: (deviceId) => setUserDefaultVideo(deviceId),
+ *     updateIsMediaSettingsModalVisible: (isVisible) => setMediaSettingsModal(isVisible),
+ *     showAlert: (alertOptions) => showAlert(alertOptions),
+ *     switchUserVideo: switchUserVideoFunction,
+ *   }
+ * });
+ * ```
+ */
+
+export const switchVideo = async ({
+  videoPreference,
+  parameters
+}: SwitchVideoOptions): Promise<void> => {
+  let {
+    recordStarted,
+    recordResumed,
+    recordStopped,
+    recordPaused,
+    recordingMediaOptions,
+    videoAlreadyOn,
+    userDefaultVideoInputDevice,
+    defVideoID,
+    allowed,
+    updateDefVideoID,
+    updatePrevVideoInputDevice,
+    updateUserDefaultVideoInputDevice,
+    updateIsMediaSettingsModalVisible,
+
+    //mediasfu functions
+    showAlert,
+    switchUserVideo
+  } = parameters
+
+  // Check if recording is in progress and whether the selected video device is the default one
+  let checkoff = false
+  if ((recordStarted || recordResumed) && !recordStopped && !recordPaused) {
+    if (recordingMediaOptions === 'video') {
+      checkoff = true
+    }
+  }
+
+  // Check camera access permission
+  if (!allowed) {
+    showAlert?.({
+      message:
+        'Allow access to your camera by starting it for the first time.',
+      type: 'danger',
+      duration: 3000
+    })
+    return
+  }
+
+  // Check video state and display appropriate alert messages
+  if (checkoff) {
+    if (videoAlreadyOn) {
+      showAlert?.({
+        message: 'Please turn off your video before switching.',
+        type: 'danger',
+        duration: 3000
+      })
+      return
+    }
+  } else {
+    if (!videoAlreadyOn) {
+      showAlert?.({
+        message: 'Please turn on your video before switching.',
+        type: 'danger',
+        duration: 3000
+      })
+      return
+    }
+  }
+
+  // Set default video ID if not already set
+  if (!defVideoID) {
+    defVideoID = userDefaultVideoInputDevice ?? 'default'
+    updateDefVideoID(defVideoID)
+  }
+
+  // Switch video only if the selected video device is different from the default
+  if (videoPreference !== defVideoID) {
+    const prevVideoInputDevice = userDefaultVideoInputDevice
+    updatePrevVideoInputDevice(prevVideoInputDevice)
+
+    userDefaultVideoInputDevice = videoPreference
+    updateUserDefaultVideoInputDevice(userDefaultVideoInputDevice)
+
+    if (defVideoID) {
+      updateIsMediaSettingsModalVisible(false)
+      await switchUserVideo({ videoPreference, checkoff, parameters })
+    }
+  }
+}

package/src/methods/stream/switchVideoAlt.ts

@@ -0,0 +1,152 @@
+import type { ShowAlert, SwitchUserVideoAltParameters, SwitchUserVideoAltType } from '../../types/types'
+
+
+export interface SwitchVideoAltParameters extends SwitchUserVideoAltParameters {
+  recordStarted: boolean
+  recordResumed: boolean
+  recordStopped: boolean
+  recordPaused: boolean
+  recordingMediaOptions: string
+  videoAlreadyOn: boolean
+  currentFacingMode: string
+  prevFacingMode: string
+  allowed: boolean
+  audioOnlyRoom: boolean
+  updateCurrentFacingMode: (mode: string) => void
+  updatePrevFacingMode: (mode: string) => void
+  updateIsMediaSettingsModalVisible: (isVisible: boolean) => void
+  showAlert?: ShowAlert
+
+  // mediasfu functions
+  switchUserVideoAlt: SwitchUserVideoAltType
+
+  getUpdatedAllParams: () => SwitchVideoAltParameters
+  [key: string]: any
+}
+
+export interface SwitchVideoAltOptions {
+  parameters: SwitchVideoAltParameters
+}
+
+// Export the type definition for the function
+export type SwitchVideoAltType = (
+  options: SwitchVideoAltOptions
+) => Promise<void>
+
+/**
+ * Switches the user's video device with alternate logic, taking into account recording state and camera access permissions.
+ *
+ * @param {SwitchVideoAltOptions} options - The parameters object containing necessary variables.
+ * @returns {Promise<void>}
+ *
+ * @example
+ * ```typescript
+ * switchVideoAlt({
+ *   parameters: {
+ *     recordStarted: true,
+ *     recordResumed: false,
+ *     recordStopped: false,
+ *     recordPaused: false,
+ *     recordingMediaOptions: 'video',
+ *     videoAlreadyOn: true,
+ *     currentFacingMode: 'user',
+ *     prevFacingMode: 'environment',
+ *     allowed: true,
+ *     audioOnlyRoom: false,
+ *     updateCurrentFacingMode: (mode) => setCurrentFacingMode(mode),
+ *     updatePrevFacingMode: (mode) => setPrevFacingMode(mode),
+ *     updateIsMediaSettingsModalVisible: (isVisible) => setMediaSettingsModal(isVisible),
+ *     showAlert: (alertOptions) => showAlert(alertOptions),
+ *     switchUserVideoAlt: switchUserVideoAltFunction,
+ *   }
+ * });
+ * ```
+ */
+
+export const switchVideoAlt = async ({
+  parameters
+}: SwitchVideoAltOptions): Promise<void> => {
+  let {
+    recordStarted,
+    recordResumed,
+    recordStopped,
+    recordPaused,
+    recordingMediaOptions,
+    videoAlreadyOn,
+    currentFacingMode,
+    prevFacingMode,
+    allowed,
+    audioOnlyRoom,
+    updateCurrentFacingMode,
+    updateIsMediaSettingsModalVisible,
+    updatePrevFacingMode,
+
+    showAlert,
+
+    //media functions
+    switchUserVideoAlt
+  } = parameters
+
+  if (audioOnlyRoom) {
+    showAlert?.({
+      message: 'You cannot turn on your camera in an audio-only event.',
+      type: 'danger',
+      duration: 3000
+    })
+    return
+  }
+
+  let checkoff = false
+  if (
+    (recordStarted || recordResumed) &&
+    !recordStopped &&
+    !recordPaused &&
+    recordingMediaOptions === 'video'
+  ) {
+    checkoff = true
+  }
+
+  if (!allowed) {
+    showAlert?.({
+      message:
+        'Allow access to your camera by starting it for the first time.',
+      type: 'danger',
+      duration: 3000
+    })
+    return
+  }
+
+  if (checkoff) {
+    if (videoAlreadyOn) {
+      showAlert?.({
+        message: 'Please turn off your video before switching.',
+        type: 'danger',
+        duration: 3000
+      })
+      return
+    }
+  } else {
+    if (!videoAlreadyOn) {
+      showAlert?.({
+        message: 'Please turn on your video before switching.',
+        type: 'danger',
+        duration: 3000
+      })
+      return
+    }
+  }
+
+  // Camera switching logic
+  prevFacingMode = currentFacingMode
+  updatePrevFacingMode(prevFacingMode)
+
+  currentFacingMode = currentFacingMode === 'environment' ? 'user' : 'environment'
+  updateCurrentFacingMode(currentFacingMode)
+
+  updateIsMediaSettingsModalVisible(false)
+  await switchUserVideoAlt({
+    videoPreference: currentFacingMode,
+    checkoff,
+    parameters
+  })
+}

package/src/methods/utils/checkLimitsAndMakeRequest.ts

@@ -0,0 +1,103 @@
+import { PreJoinPageParameters } from "../../types/types";
+import { Socket } from "socket.io-client";
+import Cookies from "universal-cookie";
+
+
+const cookies = new Cookies();
+const MAX_ATTEMPTS = 10; // Maximum number of unsuccessful attempts before rate limiting
+const RATE_LIMIT_DURATION = 3 * 60 * 60 * 1000; // 3 hours in milliseconds
+
+
+export const checkLimitsAndMakeRequest = async ({
+    apiUserName,
+    apiToken,
+    link,
+    apiKey = "",
+    userName,
+    parameters,
+    validate = true,
+  }: {
+    apiUserName: string;
+    apiToken: string;
+    link: string;
+    apiKey?: string;
+    userName: string;
+    parameters: PreJoinPageParameters;
+    validate?: boolean;
+  }) => {
+    const TIMEOUT_DURATION = 10000; // 10 seconds
+    let unsuccessfulAttempts =
+      parseInt(cookies.get("unsuccessfulAttempts")) || 0;
+    let lastRequestTimestamp =
+      parseInt(cookies.get("lastRequestTimestamp")) || 0;
+  
+    if (
+      unsuccessfulAttempts >= MAX_ATTEMPTS &&
+      Date.now() - lastRequestTimestamp < RATE_LIMIT_DURATION
+    ) {
+      parameters.showAlert?.({
+        message: "Too many unsuccessful attempts. Please try again later.",
+        type: "danger",
+        duration: 3000,
+      });
+      return;
+    } else {
+      unsuccessfulAttempts = 0;
+      cookies.set("unsuccessfulAttempts", unsuccessfulAttempts.toString());
+      cookies.set("lastRequestTimestamp", Date.now().toString());
+    }
+  
+    try {
+      parameters.updateIsLoadingModalVisible(true);
+      const socketPromise = await parameters.connectSocket({
+        apiUserName,
+        apiKey,
+        apiToken,
+        link,
+      });
+      const timeoutPromise = new Promise<null>((_, reject) =>
+        setTimeout(
+          () => reject(new Error("Request timed out")),
+          TIMEOUT_DURATION
+        )
+      );
+  
+      const socket = await Promise.race([socketPromise, timeoutPromise]);
+      if (socket && socket instanceof Socket && socket.id) {
+        unsuccessfulAttempts = 0;
+        cookies.set("unsuccessfulAttempts", unsuccessfulAttempts.toString());
+        cookies.set("lastRequestTimestamp", Date.now().toString());
+        if (validate){
+          // only one connection is established, no local socket
+          parameters.updateSocket(socket);
+        }else{
+          // local socket is also established, mediaSFU connection is now the local socket
+          parameters.updateLocalSocket?.(socket);
+        }
+        parameters.updateApiUserName(apiUserName);
+        parameters.updateApiToken(apiToken);
+        parameters.updateLink(link);
+        parameters.updateRoomName(apiUserName);
+        parameters.updateMember(userName);
+        if (validate) parameters.updateValidated(true);
+      } else {
+        unsuccessfulAttempts += 1;
+        cookies.set("unsuccessfulAttempts", unsuccessfulAttempts.toString());
+        parameters.updateIsLoadingModalVisible(false);
+        parameters.showAlert?.({
+          message: "Invalid credentials.",
+          type: "danger",
+          duration: 3000,
+        });
+      }
+    } catch {
+      parameters.showAlert?.({
+        message: "Unable to connect. Check your credentials and try again.",
+        type: "danger",
+        duration: 3000,
+      });
+      unsuccessfulAttempts += 1;
+      cookies.set("unsuccessfulAttempts", unsuccessfulAttempts.toString());
+      parameters.updateIsLoadingModalVisible(false);
+    }
+  };

package/src/methods/utils/validateAlphanumeric.ts

@@ -0,0 +1,41 @@
+
+export interface ValidateAlphanumericOptions {
+  str: string;
+}
+
+// Export the type definition for the function
+export type ValidateAlphanumericType = (options: ValidateAlphanumericOptions) => Promise<boolean>;
+
+/**
+ * Validates if the given string contains only alphanumeric characters.
+ *
+ * @param {ValidateAlphanumericOptions} options - The options containing the string to validate.
+ * @param {string} options.str - The string to be validated.
+ * @returns {Promise<boolean>} - A promise that resolves to `true` if the string is alphanumeric, otherwise `false`.
+ * 
+ * @example
+ * ```typescript 
+ * const isValid = await validateAlphanumeric({ str: "abc123" });
+ * console.log(isValid);
+ * // Output: true
+ * ```
+ */
+
+
+const validateAlphanumeric = async ({ str }: ValidateAlphanumericOptions): Promise<boolean> => {
+  let code: number, i: number, len: number;
+
+  for (i = 0, len = str.length; i < len; i++) {
+    code = str.charCodeAt(i);
+    if (
+      !(code > 47 && code < 58) && // numeric (0-9)
+      !(code > 64 && code < 91) && // upper alpha (A-Z)
+      !(code > 96 && code < 123)   // lower alpha (a-z)
+    ) {
+      return false;
+    }
+  }
+  return true;
+};
+
+export { validateAlphanumeric };

package/src/methods/waiting/index.ts

@@ -0,0 +1 @@
+export { respondToWaiting, type RespondToWaitingType, type RespondToWaitingOptions } from './respondToWaiting';

package/src/methods/waiting/launchWaiting.ts

@@ -0,0 +1,26 @@
+export interface LaunchWaitingOptions {
+  updateIsWaitingModalVisible: (visible: boolean) => void
+  isWaitingModalVisible: boolean
+}
+
+export type LaunchWaitingType = (options: LaunchWaitingOptions) => void
+
+/**
+ * Toggles the visibility of the waiting modal.
+ *
+ * @param {LaunchWaitingOptions} options - The options for toggling the waiting modal visibility.
+ * @param {Function} options.updateIsWaitingModalVisible - Function to update the visibility state of the waiting modal.
+ * @param {boolean} options.isWaitingModalVisible - Current visibility state of the waiting modal.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   updateIsWaitingModalVisible: (visible: boolean) => console.log('Waiting modal visibility updated:', visible),
+ *   isWaitingModalVisible: true,
+ * }
+ * launchWaiting(options)
+ * ```
+ */
+export const launchWaiting: LaunchWaitingType = ({ updateIsWaitingModalVisible, isWaitingModalVisible }) => {
+  updateIsWaitingModalVisible(!isWaitingModalVisible)
+}

package/src/methods/waiting/respondToWaiting.ts

@@ -0,0 +1,82 @@
+import { Socket } from "socket.io-client";
+import type { WaitingRoomParticipant } from "../../types/types";
+
+export interface RespondToWaitingOptions {
+  participantId: string;
+  participantName: string;
+  updateWaitingList: (waitingList: WaitingRoomParticipant[]) => void;
+  waitingList?: WaitingRoomParticipant[];
+  type: string | boolean;
+  roomName: string;
+  socket: Socket;
+}
+
+// Export the type definition for the function
+export type RespondToWaitingType = (options: RespondToWaitingOptions) => Promise<void>;
+
+/**
+ * Responds to a participant waiting to join a room by either allowing or denying their entry.
+ *
+ * @param {RespondToWaitingOptions} options - The options for responding to the waiting participant.
+ * @param {string} options.participantId - The ID of the participant.
+ * @param {string} options.participantName - The name of the participant.
+ * @param {Function} options.updateWaitingList - The function to update the waiting list.
+ * @param {WaitingRoomParticipant[]} options.waitingList - The current waiting list of participants.
+ * @param {boolean | string} options.type - The type of response, either "true" or "false".
+ * @param {string} options.roomName - The name of the room.
+ * @param {Socket} options.socket - The socket instance to emit events.
+ * 
+ * @example
+ * ```typescript
+ * const options = {
+ *   participantId: "12345",
+ *   participantName: "John Doe",
+ *   updateWaitingList: (list) => console.log("Updated Waiting List:", list),
+ *   waitingList: [{ id: "12345", name: "John Doe" }],
+ *   type: true,
+ *   roomName: "room1",
+ *   socket: socketInstance,
+ * };
+ * respondToWaiting(options);
+ * ```
+ */
+
+export const respondToWaiting = async ({
+  participantId,
+  participantName,
+  updateWaitingList,
+  waitingList = [],
+  type,
+  roomName,
+  socket,
+}: RespondToWaitingOptions): Promise<void> => {
+  if (!participantId || !participantName) {
+    return;
+  }
+
+  if (!updateWaitingList) {
+    console.warn('[respondToWaiting] Missing updateWaitingList handler; aborting emit.');
+    return;
+  }
+
+  if (!socket || typeof (socket as Socket).emit !== 'function') {
+    console.warn('[respondToWaiting] Socket is not ready; skipping emit.');
+    return;
+  }
+
+  // Filter out the participant from the waiting list
+  const newWaitingList = waitingList.filter((item) => item.name !== participantName);
+
+  // Update the waiting list
+  updateWaitingList(newWaitingList);
+
+  const responseType = type === "true" || type === true ? "true" : "false";
+
+  // Emit an event to allow or deny the participant based on the response type
+  socket.emit("allowUserIn", {
+    participantId,
+    participantName,
+    type: responseType,
+    roomName,
+  });
+};