mediasfu-shared 1.0.0

package/src/methods/participants/messageParticipants.ts

@@ -0,0 +1,78 @@
+import type { Participant, CoHostResponsibility, ShowAlert } from "../../types/types";
+
+export interface MessageParticipantsOptions {
+  coHostResponsibility?: CoHostResponsibility[];
+  participant: Participant;
+  member: string;
+  islevel: string;
+  showAlert?: ShowAlert;
+  coHost: string;
+  updateIsMessagesModalVisible: (isVisible: boolean) => void;
+  updateDirectMessageDetails: (participant: Participant | null) => void;
+  updateStartDirectMessage: (start: boolean) => void;
+}
+
+/**
+ * Sends a direct message to a participant if the current member has the necessary permissions.
+ *
+ * @param {MessageParticipantsOptions} options - The options for messaging participants.
+ * @param {CoHostResponsibility[]} options.coHostResponsibility - Array of responsibilities assigned to the co-host.
+ * @param {Participant} options.participant - The participant to whom the message is to be sent.
+ * @param {string} options.member - The current member attempting to send the message.
+ * @param {string} options.islevel - The level of the current member.
+ * @param {ShowAlert} [options.showAlert] - Function to show an alert message.
+ * @param {string} options.coHost - The co-host member.
+ * @param {Function} options.updateIsMessagesModalVisible - Function to update the visibility of the messages modal.
+ * @param {Function} options.updateDirectMessageDetails - Function to update the details of the direct message.
+ * @param {Function} options.updateStartDirectMessage - Function to start the direct message.
+ *
+ * @example
+ * ```typescript
+ * messageParticipants({
+ *   coHostResponsibility: [{ name: "chat", value: true }],
+ *   participant: { name: "John Doe", islevel: "1" },
+ *   member: "currentMember",
+ *   islevel: "2",
+ *   showAlert: (alert) => console.log(alert.message),
+ *   coHost: "coHostMember",
+ *   updateIsMessagesModalVisible: (isVisible) => setMessagesModalVisible(isVisible),
+ *   updateDirectMessageDetails: (participant) => setDirectMessageDetails(participant),
+ *   updateStartDirectMessage: (start) => setStartDirectMessage(start),
+ * });
+ * ```
+ */
+
+export const messageParticipants = ({
+  coHostResponsibility = [],
+  participant,
+  member,
+  islevel,
+  showAlert,
+  coHost,
+  updateIsMessagesModalVisible,
+  updateDirectMessageDetails,
+  updateStartDirectMessage,
+}: MessageParticipantsOptions): void => {
+  let chatValue = false;
+
+  try {
+    chatValue = coHostResponsibility.find((item) => item.name === "chat")?.value ?? false;
+  } catch (error) {
+    console.error(error);
+  }
+
+  if (islevel === "2" || (coHost === member && chatValue === true)) {
+    if (participant.islevel !== "2") {
+      updateDirectMessageDetails(participant);
+      updateStartDirectMessage(true);
+      updateIsMessagesModalVisible(true);
+    }
+  } else {
+    showAlert?.({
+      message: "You are not allowed to send this message",
+      type: "danger",
+      duration: 3000,
+    });
+    return;
+  }
+};

package/src/methods/participants/muteParticipants.ts

@@ -0,0 +1,79 @@
+import { Socket } from "socket.io-client";
+import type { Participant, CoHostResponsibility, ShowAlert } from "../../types/types";
+
+export interface MuteParticipantsOptions {
+  socket: Socket;
+  coHostResponsibility?: CoHostResponsibility[];
+  participant: Participant;
+  member: string;
+  islevel: string;
+  showAlert?: ShowAlert;
+  coHost: string;
+  roomName: string;
+}
+
+/**
+ * Mutes a participant in a media session if the current member has the necessary permissions.
+ *
+ * @param {MuteParticipantsOptions} options - The options for muting participants.
+ * @param {Socket} options.socket - The socket instance for communication.
+ * @param {CoHostResponsibility[]} options.coHostResponsibility - List of co-host responsibilities.
+ * @param {Participant} options.participant - The participant to be muted.
+ * @param {string} options.member - The current member attempting to mute.
+ * @param {string} options.islevel - The level of the current member.
+ * @param {ShowAlert} [options.showAlert] - Optional function to show alerts.
+ * @param {string} options.coHost - The co-host information.
+ * @param {string} options.roomName - The name of the room.
+ *
+ * @example
+ * ```typescript
+ * muteParticipants({
+ *   socket,
+ *   coHostResponsibility: [{ name: "media", value: true }],
+ *   participant: { id: "123", name: "John Doe", muted: false, islevel: "1" },
+ *   member: "currentMember",
+ *   islevel: "2",
+ *   showAlert: (alert) => console.log(alert.message),
+ *   coHost: "coHostMember",
+ *   roomName: "room1",
+ * });
+ * ```
+ */
+
+export const muteParticipants = async ({
+  socket,
+  coHostResponsibility = [],
+  participant,
+  member,
+  islevel,
+  showAlert,
+  coHost,
+  roomName,
+}: MuteParticipantsOptions): Promise<void> => {
+  let mediaValue = false;
+
+  try {
+    mediaValue =
+      coHostResponsibility.find((item) => item.name === "media")?.value ?? false;
+  } catch (error) {
+    console.error(error);
+  }
+
+  if (islevel === "2" || (coHost === member && mediaValue)) {
+    if (!participant.muted && participant.islevel !== "2") {
+      const participantId = participant.id;
+      socket.emit("controlMedia", {
+        participantId,
+        participantName: participant.name,
+        type: "all",
+        roomName,
+      });
+    }
+  } else {
+    showAlert?.({
+      message: "You are not allowed to mute other participants",
+      type: "danger",
+      duration: 3000,
+    });
+  }
+};

package/src/methods/participants/removeParticipants.ts

@@ -0,0 +1,97 @@
+import { Socket } from 'socket.io-client';
+import type { CoHostResponsibility, Participant, ShowAlert } from '../../types/types';
+
+export interface RemoveParticipantsOptions {
+  coHostResponsibility: CoHostResponsibility[];
+  participant: Participant;
+  member: string;
+  islevel: string;
+  showAlert?: ShowAlert;
+  coHost: string;
+  participants: Participant[];
+  socket: Socket;
+  roomName: string;
+  updateParticipants: (participants: Participant[]) => void;
+}
+
+/**
+ * Removes a participant from the room if the user has the necessary permissions.
+ *
+ * @param {RemoveParticipantsOptions} options - The options for removing a participant.
+ * @param {CoHostResponsibility[]} options.coHostResponsibility - The responsibilities assigned to the co-host.
+ * @param {Participant} options.participant - The participant to be removed from the room.
+ * @param {string} options.member - The current member attempting to remove the participant.
+ * @param {string} options.islevel - The level of the current member.
+ * @param {ShowAlert} [options.showAlert] - Optional function to display an alert.
+ * @param {string} options.coHost - The co-host identifier.
+ * @param {Participant[]} options.participants - List of current participants.
+ * @param {Socket} options.socket - The socket instance for communication.
+ * @param {string} options.roomName - The name of the room.
+ * @param {Function} options.updateParticipants - Function to update the participants list.
+ *
+ * @example
+ * ```typescript
+ * removeParticipants({
+ *   coHostResponsibility: [{ name: "participants", value: true }],
+ *   participant: { id: "123", name: "John Doe", islevel: "1" },
+ *   member: "currentMember",
+ *   islevel: "2",
+ *   showAlert: (alert) => console.log(alert.message),
+ *   coHost: "coHostMember",
+ *   participants: [{ id: "123", name: "John Doe", islevel: "1" }],
+ *   socket,
+ *   roomName: "room1",
+ *   updateParticipants: (updatedParticipants) => console.log(updatedParticipants),
+ * });
+ * ```
+ */
+
+export const removeParticipants = async ({
+  coHostResponsibility,
+  participant,
+  member,
+  islevel,
+  showAlert,
+  coHost,
+  participants,
+  socket,
+  roomName,
+  updateParticipants
+}: RemoveParticipantsOptions): Promise<void> => {
+  let participantsValue = false;
+
+  try {
+    participantsValue =
+      coHostResponsibility.find((item) => item.name === 'participants')?.value ?? false;
+  } catch {
+    participantsValue = false;
+  }
+
+  if (islevel === '2' || (coHost === member && participantsValue === true)) {
+    if (participant.islevel !== '2') {
+      const participantId = participant.id;
+
+      // Emit a socket event to disconnect the user
+      socket.emit('disconnectUserInitiate', {
+        member: participant.name,
+        roomName,
+        id: participantId,
+      });
+
+      // Remove the participant from the local array
+      const index = participants.findIndex((obj) => obj.name === participant.name);
+      if (index !== -1) {
+        participants.splice(index, 1);
+      }
+
+      // Update the participants array
+      updateParticipants(participants);
+    }
+  } else {
+    showAlert?.({
+      message: 'You are not allowed to remove other participants',
+      type: 'danger',
+      duration: 3000,
+    });
+  }
+};

package/src/methods/polls/handleCreatePoll.ts

@@ -0,0 +1,66 @@
+import { Socket } from "socket.io-client";
+import type { ShowAlert } from "../../types/types";
+
+interface NewPoll {
+  question: string;
+  type: string;
+  options: string[];
+}
+
+export interface HandleCreatePollOptions {
+  poll: NewPoll;
+  socket: Socket;
+  roomName: string;
+  showAlert?: ShowAlert;
+  updateIsPollModalVisible: (visible: boolean) => void;
+}
+
+// Export the type definition for the function
+export type HandleCreatePollType = (options: HandleCreatePollOptions) => Promise<void>;
+
+/**
+ * Handles the creation of a poll by emitting a "createPoll" event with the provided details.
+ *
+ * @param {HandleCreatePollOptions} options - The options for creating the poll.
+ * @param {NewPoll} options.poll - The poll object containing the poll question, type, and options.
+ * @param {Socket} options.socket - The socket instance used to communicate with the server.
+ * @param {string} options.roomName - The name of the room where the poll is created.
+ * @param {Function} [options.showAlert] - Optional function to show alert messages.
+ * @param {Function} options.updateIsPollModalVisible - Function to toggle the poll modal visibility.
+ *
+ * @example
+ * ```typescript
+ * handleCreatePoll({
+ *   poll: { question: "Favorite color?", type: "singleChoice", options: ["Red", "Blue", "Green"] },
+ *   socket: socketInstance,
+ *   roomName: "roomA",
+ *   showAlert: (message) => console.log(message),
+ *   updateIsPollModalVisible: (isVisible) => setIsPollModalVisible(isVisible),
+ * });
+ * ```
+ */
+
+export const handleCreatePoll = async ({
+  poll,
+  socket,
+  roomName,
+  showAlert,
+  updateIsPollModalVisible,
+}: HandleCreatePollOptions): Promise<void> => {
+  try {
+    socket.emit(
+      "createPoll",
+      { roomName, poll },
+      (response: { success: boolean; reason?: string }) => {
+        if (response.success) {
+          showAlert?.({ message: "Poll created successfully", type: "success" });
+          updateIsPollModalVisible(false);
+        } else {
+          showAlert?.({ message: response.reason || "Failed to create poll", type: "danger" });
+        }
+      }
+    );
+  } catch (error) {
+    console.error("Error creating poll:", error);
+  }
+};

package/src/methods/polls/handleEndPoll.ts

@@ -0,0 +1,64 @@
+import { Socket } from "socket.io-client";
+import type { ShowAlert } from "../../types/types";
+
+export interface HandleEndPollOptions {
+  pollId: string;
+  socket: Socket;
+  showAlert?: ShowAlert;
+  roomName: string;
+  updateIsPollModalVisible: (isVisible: boolean) => void;
+}
+
+// Export the type definition for the function
+export type HandleEndPollType = (options: HandleEndPollOptions) => Promise<void>;
+
+/**
+ * Handles the end of a poll by emitting an "endPoll" event through the provided socket.
+ * Displays an alert based on the success or failure of the operation.
+ *
+ * @param {HandleEndPollOptions} options - The options for ending the poll.
+ * @param {string} options.pollId - The ID of the poll to end.
+ * @param {Socket} options.socket - The socket instance to emit the event.
+ * @param {Function} [options.showAlert] - Optional function to display alerts.
+ * @param {string} options.roomName - The name of the room where the poll is being conducted.
+ * @param {Function} options.updateIsPollModalVisible - Function to update the poll modal visibility.
+ *
+ * @example
+ * ```typescript
+ * handleEndPoll({
+ *   pollId: "poll123",
+ *   socket: socketInstance,
+ *   showAlert: (message) => console.log(message),
+ *   roomName: "roomA",
+ *   updateIsPollModalVisible: (isVisible) => setIsPollModalVisible(isVisible),
+ * });
+ * ```
+ */
+
+export const handleEndPoll = async ({
+  pollId,
+  socket,
+  showAlert,
+  roomName,
+  updateIsPollModalVisible,
+}: HandleEndPollOptions): Promise<void> => {
+  try {
+    socket.emit(
+      "endPoll",
+      { roomName, poll_id: pollId },
+      (response: { success: boolean; reason?: string }) => {
+        if (response.success) {
+          showAlert?.({
+            message: "Poll ended successfully",
+            type: "success",
+          });
+          updateIsPollModalVisible(false);
+        } else {
+          showAlert?.({ message: response.reason || "Failed to end poll", type: "danger" });
+        }
+      }
+    );
+  } catch (error) {
+    console.error("Error ending poll:", error);
+  }
+};

package/src/methods/polls/handleVotePoll.ts

@@ -0,0 +1,76 @@
+import { Socket } from "socket.io-client";
+import type { ShowAlert } from "../../types/types";
+
+export interface HandleVotePollOptions {
+  pollId: string;
+  optionIndex: number;
+  socket: Socket;
+  showAlert?: ShowAlert;
+  member: string;
+  roomName: string;
+  updateIsPollModalVisible: (isVisible: boolean) => void;
+}
+
+// Export the type definition for the function
+export type HandleVotePollType = (options: HandleVotePollOptions) => Promise<void>;
+
+/**
+ * Handles the voting process for a poll.
+ *
+ * @param {HandleVotePollOptions} options - The options for handling the vote.
+ * @param {string} options.pollId - The ID of the poll.
+ * @param {number} options.optionIndex - The index of the selected option.
+ * @param {Socket} options.socket - The socket instance for communication.
+ * @param {Function} [options.showAlert] - Optional function to show alerts.
+ * @param {string} options.member - The member who is voting.
+ * @param {string} options.roomName - The name of the room where the poll is conducted.
+ * @param {Function} options.updateIsPollModalVisible - Function to update the visibility of the poll modal.
+ *
+ * @example
+ * ```typescript
+ * handleVotePoll({
+ *   pollId: "poll123",
+ *   optionIndex: 1,
+ *   socket: socketInstance,
+ *   showAlert: (message) => console.log(message),
+ *   member: "user1",
+ *   roomName: "roomA",
+ *   updateIsPollModalVisible: (isVisible) => setIsPollModalVisible(isVisible),
+ * });
+ * ```
+ */
+
+export const handleVotePoll = async ({
+  pollId,
+  optionIndex,
+  socket,
+  showAlert,
+  member,
+  roomName,
+  updateIsPollModalVisible,
+}: HandleVotePollOptions): Promise<void> => {
+  try {
+    socket.emit(
+      "votePoll",
+      {
+        roomName,
+        poll_id: pollId,
+        member,
+        choice: optionIndex,
+      },
+      (response: { success: boolean; reason?: string }) => {
+        if (response.success) {
+          showAlert?.({
+            message: "Vote submitted successfully",
+            type: "success",
+          });
+          updateIsPollModalVisible(false);
+        } else {
+          showAlert?.({ message: response.reason || "Failed to submit vote", type: "danger" });
+        }
+      }
+    );
+  } catch (error) {
+    console.error("Error submitting vote:", error);
+  }
+};

package/src/methods/polls/index.ts

@@ -0,0 +1,3 @@
+export { handleCreatePoll, type HandleCreatePollType, type HandleCreatePollOptions } from './handleCreatePoll';
+export { handleEndPoll, type HandleEndPollType, type HandleEndPollOptions } from './handleEndPoll';
+export { handleVotePoll, type HandleVotePollType, type HandleVotePollOptions } from './handleVotePoll';

package/src/methods/polls/launchPoll.ts

@@ -0,0 +1,25 @@
+export interface LaunchPollOptions {
+  updateIsPollModalVisible: (isVisible: boolean) => void
+  isPollModalVisible: boolean
+}
+
+export type LaunchPollType = (options: LaunchPollOptions) => void
+
+/**
+ * Toggles the visibility of the poll modal.
+ *
+ * @param {LaunchPollOptions} options - The options for toggling the poll modal visibility.
+ * @param {Function} options.updateIsPollModalVisible - Function to update the visibility state of the poll modal.
+ * @param {boolean} options.isPollModalVisible - Current visibility state of the poll modal.
+ *
+ * @example
+ * ```typescript
+ * launchPoll({
+ *   updateIsPollModalVisible: (visible) => setIsPollModalVisible(visible),
+ *   isPollModalVisible: false,
+ * })
+ * ```
+ */
+export const launchPoll: LaunchPollType = ({ updateIsPollModalVisible, isPollModalVisible }) => {
+  updateIsPollModalVisible(!isPollModalVisible)
+}