mediasfu-shared 1.0.0

package/src/consumers/generatePageContent.ts

@@ -0,0 +1,118 @@
+import { Participant, Stream, DispStreamsType, DispStreamsParameters } from '../types/types';
+
+export interface GeneratePageContentParameters extends DispStreamsParameters {
+  paginatedStreams: (Participant | Stream)[][];
+  currentUserPage: number;
+  updateMainWindow: boolean;
+  updateCurrentUserPage: (page: number) => void;
+  updateUpdateMainWindow: (flag: boolean) => void;
+
+  // mediasfu functions
+  dispStreams: DispStreamsType;
+  getUpdatedAllParams: () => GeneratePageContentParameters;
+  [key: string]: any;
+}
+
+export interface GeneratePageContentOptions {
+  page: number | string;
+  parameters: GeneratePageContentParameters;
+  breakRoom?: number;
+  inBreakRoom?: boolean;
+}
+
+// Export the type definition for the function
+export type GeneratePageContentType = (options: GeneratePageContentOptions) => Promise<void>;
+
+/**
+ * Generates the content for a specific page.
+ *
+ * @param {GeneratePageContentOptions} options - The options for generating page content.
+ * @param {number | string} options.page - The page number to generate content for.
+ * @param {GeneratePageContentParameters} options.parameters - The parameters required for generating content.
+ * @param {Array} options.parameters.paginatedStreams - The streams to be paginated.
+ * @param {number} options.parameters.currentUserPage - The current page of the user.
+ * @param {Function} options.parameters.updateMainWindow - Function to update the main window flag.
+ * @param {Function} options.parameters.updateCurrentUserPage - Function to update the current user page.
+ * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window update flag.
+ * @param {Function} options.parameters.dispStreams - Function to display streams for the specified page.
+ * @param {number} [options.breakRoom=-1] - The break room identifier.
+ * @param {boolean} [options.inBreakRoom=false] - Flag indicating if the user is in a break room.
+ * 
+ * @returns {Promise<void>} A promise that resolves when the content generation is complete.
+ * 
+ * @throws {Error} Throws an error if content generation fails.
+ * 
+ * @example
+ * const options = {
+ *   page: 1,
+ *   parameters: {
+ *     paginatedStreams: [[stream1, stream2], [stream3, stream4]], // Example paginated streams
+ *     currentUserPage: 0,
+ *     updateMainWindow: true,
+ *     updateCurrentUserPage: (page) => console.log('Current user page updated to:', page),
+ *     updateUpdateMainWindow: (flag) => console.log('Main window update flag:', flag),
+ *     dispStreams: async ({ lStreams, ind }) => {
+ *       console.log(`Displaying streams for page ${ind}:`, lStreams);
+ *     },
+ *   },
+ *   breakRoom: 1,
+ *   inBreakRoom: false,
+ * };
+ * 
+ * generatePageContent(options)
+ *   .then(() => {
+ *     console.log('Page content generated successfully');
+ *   })
+ *   .catch((error) => {
+ *     console.error('Error generating page content:', error);
+ *   });
+ */
+
+export async function generatePageContent({
+  page,
+  parameters,
+  breakRoom = -1,
+  inBreakRoom = false,
+}: GeneratePageContentOptions): Promise<void> {
+  try {
+    // Destructure parameters
+    let {
+      paginatedStreams,
+      currentUserPage,
+      updateMainWindow,
+
+      updateCurrentUserPage,
+      updateUpdateMainWindow,
+
+      //mediasfu functions
+      dispStreams,
+    } = parameters;
+
+    // Convert page to an integer
+    page = typeof page === "string" ? parseInt(page) : page;
+
+    // Update current user page
+    currentUserPage = page;
+    updateCurrentUserPage(currentUserPage);
+
+    // Update main window flag
+    updateMainWindow = true;
+    updateUpdateMainWindow(updateMainWindow);
+
+    // Display streams for the specified page
+    await dispStreams({
+      lStreams: paginatedStreams[page],
+      ind: page,
+      parameters,
+      breakRoom,
+      inBreakRoom,
+    });
+  } catch (error) {
+    // Handle errors during content generation
+    if (error instanceof Error) {
+      console.log("Error generating page content:", error.message);
+    } else {
+      console.log("Error generating page content:", error);
+    }
+  }
+}

package/src/consumers/getEstimate.ts

@@ -0,0 +1,124 @@
+import { CalculateRowsAndColumnsType, EventType } from "../types/types";
+
+export interface GetEstimateParameters {
+  fixedPageLimit: number;
+  screenPageLimit: number;
+  shareScreenStarted: boolean;
+  shared?: boolean;
+  eventType: EventType;
+  removeAltGrid: boolean;
+  isWideScreen: boolean;
+  isMediumScreen: boolean;
+  updateRemoveAltGrid: (value: boolean) => void;
+
+  // mediaSfu functions
+  calculateRowsAndColumns: CalculateRowsAndColumnsType;
+
+  [key: string]: any;
+}
+
+export interface GetEstimateOptions {
+  n: number;
+  parameters: GetEstimateParameters;
+}
+
+// Export the type definition for the function
+export type GetEstimateType = (options: GetEstimateOptions) => [number, number, number];
+
+/**
+ * Estimates the number of rows and columns for a given set of parameters.
+ *
+ * @param {GetEstimateOptions} options - The options for the estimation.
+ * @param {number} options.n - The number of items to estimate for.
+ * @param {GetEstimateParameters} options.parameters - The parameters for the estimation.
+ * @param {number} options.parameters.fixedPageLimit - The fixed page limit.
+ * @param {number} options.parameters.screenPageLimit - The screen page limit.
+ * @param {boolean} options.parameters.shareScreenStarted - Indicates if screen sharing has started.
+ * @param {boolean} [options.parameters.shared] - Indicates if sharing is active.
+ * @param {string} options.parameters.eventType - The type of event (e.g., "chat", "conference").
+ * @param {boolean} options.parameters.removeAltGrid - Indicates if the alternate grid should be removed.
+ * @param {boolean} options.parameters.isWideScreen - Indicates if the screen is wide.
+ * @param {boolean} options.parameters.isMediumScreen - Indicates if the screen is medium-sized.
+ * @param {Function} options.parameters.updateRemoveAltGrid - Function to update the removeAltGrid parameter.
+ * @param {Function} options.parameters.calculateRowsAndColumns - Function to calculate rows and columns.
+ *
+ * @returns {[number, number, number]} An array containing the estimated number of items, rows, and columns.
+ *
+ * @throws Will log an error message if an error occurs during estimation.
+ *
+ * @example
+ * const options = {
+ *   n: 10,
+ *   parameters: {
+ *     fixedPageLimit: 5,
+ *     screenPageLimit: 8,
+ *     shareScreenStarted: false,
+ *     shared: false,
+ *     eventType: 'conference',
+ *     removeAltGrid: false,
+ *     isWideScreen: true,
+ *     isMediumScreen: false,
+ *     updateRemoveAltGrid: (value) => console.log('Remove Alt Grid:', value),
+ *     calculateRowsAndColumns: ({ n }) => [3, 4], // Example implementation
+ *   },
+ * };
+ * 
+ * const estimate = getEstimate(options);
+ * console.log('Estimated:', estimate); // Output: Estimated: [10, 3, 4]
+ */
+
+export function getEstimate({ n, parameters }: GetEstimateOptions): [number, number, number] {
+  try {
+    // Destructure parameters
+    let {
+      fixedPageLimit,
+      screenPageLimit,
+      shareScreenStarted,
+      shared,
+      eventType,
+      removeAltGrid,
+      isWideScreen,
+      isMediumScreen,
+      updateRemoveAltGrid,
+
+      //mediaSfu functions
+      calculateRowsAndColumns,
+    } = parameters;
+
+    // Calculate rows and columns
+    const [rows, cols] = calculateRowsAndColumns({ n });
+
+    // Check conditions for removing alt grid
+    if (
+      n < fixedPageLimit ||
+      ((shareScreenStarted || shared) && n < screenPageLimit + 1)
+    ) {
+      removeAltGrid = true;
+      updateRemoveAltGrid(removeAltGrid);
+
+      // Return estimated values based on screen width
+      if (!(isMediumScreen || isWideScreen)) {
+        return eventType === "chat" ||
+          (eventType === "conference" && !(shareScreenStarted || shared))
+          ? [n, n, 1]
+          : [n, 1, n];
+      } else {
+        return eventType === "chat" ||
+          (eventType === "conference" && !(shareScreenStarted || shared))
+          ? [n, 1, n]
+          : [n, n, 1];
+      }
+    }
+
+    return [rows * cols, rows, cols];
+  } catch (error) {
+    // Handle errors during estimation
+    if (error instanceof Error) {
+      console.log("Error estimating rows and columns:", error.message);
+    } else {
+      console.log("Error estimating rows and columns:", error);
+    }
+    return [0, 0, 0];
+    // throw error;
+  }
+}

package/src/consumers/getPipedProducersAlt.ts

@@ -0,0 +1,96 @@
+import { Socket } from "socket.io-client";
+import { SignalNewConsumerTransportParameters, SignalNewConsumerTransportType } from '../types/types';
+
+export interface GetPipedProducersAltParameters extends SignalNewConsumerTransportParameters {
+  member: string;
+
+  // mediasfu functions
+  signalNewConsumerTransport: SignalNewConsumerTransportType;
+  [key: string]: any;
+}
+
+export interface GetPipedProducersAltOptions {
+  community?: boolean;
+  nsock: Socket;
+  islevel: string;
+  parameters: GetPipedProducersAltParameters;
+}
+
+// Export the type definition for the function
+export type GetPipedProducersAltType = (options: GetPipedProducersAltOptions) => Promise<void>;
+
+/**
+ * Retrieves piped producers and signals new consumer transport for each retrieved producer.
+ *
+ * @param {GetPipedProducersAltOptions} options - The options for retrieving piped producers.
+ * @param {boolean} options.community - A flag indicating if the room is a community edition room.
+ * @param {Socket} options.nsock - The WebSocket instance used for communication.
+ * @param {string} options.islevel - A flag indicating the level of the request.
+ * @param {GetPipedProducersAltParameters} options.parameters - Additional parameters for the request.
+ * @param {string} options.parameters.member - The member identifier.
+ * @param {Function} options.parameters.signalNewConsumerTransport - A function to signal new consumer transport.
+ *
+ * @returns {Promise<void>} A promise that resolves when the operation is complete.
+ *
+ * @throws {Error} If an error occurs during the process of retrieving producers.
+ *
+ * @example
+ * const options = {
+ *   community: false,
+ *   nsock: socketInstance,
+ *   islevel: '1',
+ *   parameters: {
+ *     member: 'memberId',
+ *     signalNewConsumerTransport: async ({ nsock, remoteProducerId, islevel, parameters }) => {
+ *       // Implementation for signaling new consumer transport
+ *     },
+ *   },
+ * };
+ *
+ * getPipedProducersAlt(options)
+ *   .then(() => {
+ *     console.log('Successfully retrieved piped producers');
+ *   })
+ *   .catch((error) => {
+ *     console.error('Error retrieving piped producers:', error);
+ *   });
+ */
+
+export const getPipedProducersAlt = async ({
+  community = false,
+  nsock,
+  islevel,
+  parameters,
+}: GetPipedProducersAltOptions): Promise<void> => {
+  try {
+    // Destructure parameters
+    const { member, signalNewConsumerTransport } = parameters;
+
+    const emitName = community ? "getProducersAlt" : "getProducersPipedAlt";
+
+    // Emit request to get piped producers using WebSocket
+    await nsock.emit(
+      emitName,
+      { islevel, member },
+      async (producerIds: string[]) => {
+        // Check if producers are retrieved
+        if (producerIds.length > 0) {
+          // Signal new consumer transport for each retrieved producer
+          await Promise.all(
+            producerIds.map((id) =>
+              signalNewConsumerTransport({
+                nsock,
+                remoteProducerId: id,
+                islevel,
+                parameters,
+              })
+            )
+          );
+        }
+      }
+    );
+  } catch (error) {
+    // Handle errors during the process of retrieving producers
+    console.log("Error getting piped producers:", (error as Error).message);
+  }
+};

package/src/consumers/getProducersPiped.ts

@@ -0,0 +1,89 @@
+import { Socket } from "socket.io-client";
+import { SignalNewConsumerTransportParameters, SignalNewConsumerTransportType } from "../types/types";
+export interface GetProducersPipedParameters extends SignalNewConsumerTransportParameters {
+  member: string;
+
+  // mediasfu functions
+  signalNewConsumerTransport: SignalNewConsumerTransportType,
+  [key: string]: any;
+}
+
+export interface GetProducersPipedOptions {
+  nsock: Socket;
+  islevel: string;
+  parameters: GetProducersPipedParameters;
+}
+
+// Export the type definition for the function
+export type GetProducersPipedType = (options: GetProducersPipedOptions) => Promise<void>;
+
+/**
+ * Retrieves piped producers and signals new consumer transport for each retrieved producer.
+ *
+ * @param {GetProducersPipedOptions} options - The options for getting piped producers.
+ * @param {Socket} options.nsock - The WebSocket instance used for communication.
+ * @param {string} options.islevel - A flag indicating the level of the operation.
+ * @param {GetProducersPipedParameters} options.parameters - Additional parameters for the operation.
+ * @param {string} options.parameters.member - The member identifier.
+ * @param {Function} options.parameters.signalNewConsumerTransport - The function to signal new consumer transport.
+ *
+ * @returns {Promise<void>} A promise that resolves when the operation is complete.
+ *
+ * @throws {Error} If an error occurs during the process of retrieving producers.
+ *
+ * @example
+ * const options = {
+ *   nsock: socketInstance,
+ *   islevel: '1',
+ *   parameters: {
+ *     member: 'memberId',
+ *     signalNewConsumerTransport: async ({ remoteProducerId, islevel, nsock, parameters }) => {
+ *       // Implementation for signaling new consumer transport
+ *     },
+ *   },
+ * };
+ *
+ * getProducersPiped(options)
+ *   .then(() => {
+ *     console.log('Successfully retrieved piped producers');
+ *   })
+ *   .catch((error) => {
+ *     console.error('Error retrieving piped producers:', error);
+ *   });
+ */
+
+export const getProducersPiped = async ({
+  nsock,
+  islevel,
+  parameters,
+}: GetProducersPipedOptions): Promise<void> => {
+  try {
+    // Destructure parameters
+    const { member, signalNewConsumerTransport } = parameters;
+
+    // Emit request to get piped producers using WebSocket
+    await nsock.emit(
+      "getProducersPipedAlt",
+      { islevel, member },
+      async (producerIds: string[]) => {
+        // Check if producers are retrieved
+        if (producerIds.length > 0) {
+          // Signal new consumer transport for each retrieved producer
+          await Promise.all(
+            producerIds.map((id) =>
+              signalNewConsumerTransport({
+                remoteProducerId: id,
+                islevel,
+                nsock,
+                parameters,
+              })
+            )
+          );
+        }
+      }
+    );
+  } catch (error) {
+    // Handle errors during the process of retrieving producers
+    console.log("Error getting piped producers:", (error as Error).message);
+  }
+};

package/src/consumers/getVideos.ts

@@ -0,0 +1,107 @@
+import { Stream, Participant } from "../types/types";
+export interface GetVideosOptions {
+  participants: Participant[];
+  allVideoStreams: (Stream | Participant)[];
+  oldAllStreams: (Stream | Participant)[];
+  adminVidID?: string;
+  updateAllVideoStreams: (streams: (Stream | Participant)[]) => void;
+  updateOldAllStreams: (streams: (Stream | Participant)[]) => void;
+}
+
+// Export the type definition for the function
+export type GetVideosType = (options: GetVideosOptions) => Promise<void>;
+
+
+/**
+ * Asynchronously processes and updates video streams by filtering out the admin's video stream.
+ *
+ * @param {GetVideosOptions} options - The options for getting videos.
+ * @param {Participant[]} options.participants - The list of participants.
+ * @param {(Stream | Participant)[]} options.allVideoStreams - The list of all video streams.
+ * @param {(Stream | Participant)[]} options.oldAllStreams - The list of old video streams.
+ * @param {string} [options.adminVidID] - The ID of the admin's video stream.
+ * @param {Function} options.updateAllVideoStreams - Function to update the state variable for all video streams.
+ * @param {Function} options.updateOldAllStreams - Function to update the state variable for old video streams.
+ *
+ * @returns {Promise<void>} A promise that resolves when the video streams have been processed and updated.
+ *
+ * @throws {Error} Throws an error if an issue occurs while processing the streams.
+ *
+ * @example
+ * const options = {
+ *   participants: participantList,
+ *   allVideoStreams: allStreams,
+ *   oldAllStreams: oldStreams,
+ *   adminVidID: 'admin-video-id',
+ *   updateAllVideoStreams: (streams) => {
+ *     console.log('All video streams updated:', streams);
+ *   },
+ *   updateOldAllStreams: (streams) => {
+ *     console.log('Old video streams updated:', streams);
+ *   },
+ * };
+ *
+ * getVideos(options)
+ *   .then(() => {
+ *     console.log('Video streams processed successfully');
+ *   })
+ *   .catch((error) => {
+ *     console.error('Error processing video streams:', error);
+ *   });
+ */
+
+export async function getVideos({
+  participants,
+  allVideoStreams,
+  oldAllStreams,
+  adminVidID,
+  updateAllVideoStreams,
+  updateOldAllStreams,
+}: GetVideosOptions): Promise<void> {
+
+  try {
+
+    // Filter out the admin's video stream and update state variables
+    let admin = participants.filter(
+      (participant) => participant.islevel === "2"
+    );
+
+    if (admin.length > 0) {
+      adminVidID = admin[0].videoID;
+
+      if (adminVidID != null && adminVidID !== "") {
+        let oldAllStreams_: (Stream | Participant)[] = [];
+
+        // Check if the length of oldAllStreams is greater than 0
+        if (oldAllStreams.length > 0) {
+          oldAllStreams_ = oldAllStreams;
+        }
+
+        // Filter out admin's video stream from oldAllStreams
+        oldAllStreams = allVideoStreams.filter(
+          (streame) => streame.producerId === adminVidID
+        );
+
+        // If no admin's video stream found, revert to the previous state
+        if (oldAllStreams.length < 1) {
+          oldAllStreams = oldAllStreams_;
+        }
+
+        // Update the state variable for old video streams
+        updateOldAllStreams(oldAllStreams);
+
+        // Filter out admin's video stream from allVideoStreams
+        allVideoStreams = allVideoStreams.filter(
+          (streame) => streame.producerId !== adminVidID
+        );
+
+        // Update the state variable for all video streams
+        updateAllVideoStreams(allVideoStreams);
+      }
+    }
+  } catch (error) {
+    // Handle errors during the process of updating video streams
+    console.log("Error updating video streams:", (error as Error).message);
+    // throw error;
+  }
+}

package/src/consumers/mixStreams.ts

@@ -0,0 +1,97 @@
+import { Stream, Participant } from "../types/types";
+
+export interface MixStreamsOptions {
+  alVideoStreams: (Stream | Participant)[];
+  non_alVideoStreams: Participant[];
+  ref_participants: (Stream | Participant)[];
+}
+
+// Export the type definition for the function
+export type MixStreamsType = (options: MixStreamsOptions) => Promise<(Stream | Participant)[]>;
+
+/**
+ * Mixes video and audio streams and participants based on specified parameters.
+ *
+ * @param {MixStreamsOptions} options - The options for mixing streams.
+ * @param {Array} options.alVideoStreams - The list of audio and video streams to mix.
+ * @param {Array} options.non_alVideoStreams - The list of non-audio and video streams to mix.
+ * @param {Array} options.ref_participants - The list of reference participants to mix.
+ * @returns {Promise<Array>} A promise that resolves with the mixed streams.
+ * @throws Will throw an error if there is an issue mixing the streams.
+ * @example
+ * ```typescript
+ * const mixedStreams = await mixStreams({
+ *   alVideoStreams: [stream1, stream2],
+ *   non_alVideoStreams: [participant1, participant2],
+ *   ref_participants: [participant1, participant2],
+ * });
+ * console.log('Mixed streams:', mixedStreams);
+ * ```
+ */
+
+
+export async function mixStreams({
+  alVideoStreams,
+  non_alVideoStreams,
+  ref_participants,
+}: MixStreamsOptions): Promise<(Stream | Participant)[]> {
+  try {
+
+    const mixedStreams: (Stream | Participant)[] = [];
+
+    // Find "youyou" or "youyouyou" stream
+    const youyouStream = alVideoStreams.find(
+      (obj) => obj.producerId === "youyou" || obj.producerId === "youyouyou"
+    );
+
+    let remainingAlVideoStreams = alVideoStreams.filter(
+      (obj) => obj.producerId !== "youyou" && obj.producerId !== "youyouyou"
+    );
+
+    // Separate unmuted and muted streams
+    const unmutedAlVideoStreams = remainingAlVideoStreams.filter((obj) => {
+      const participant = ref_participants.find(
+        (p) => p.videoID === obj.producerId
+      );
+      return !obj.muted && participant && participant.muted === false;
+    });
+
+    const mutedAlVideoStreams = remainingAlVideoStreams.filter((obj) => {
+      const participant = ref_participants.find(
+        (p) => p.videoID === obj.producerId
+      );
+      return obj.muted || (participant && participant.muted === true);
+    });
+
+    const nonAlVideoStreams = [...non_alVideoStreams]; // Create a copy of non_alVideoStreams
+
+    // Add unmutedAlVideoStreams to mixedStreams
+    mixedStreams.push(...unmutedAlVideoStreams);
+
+    // Interleave the mutedAlVideoStreams and nonAlVideoStreams
+    let nonAlIndex = 0;
+    for (let i = 0; i < mutedAlVideoStreams.length; i++) {
+      if (nonAlIndex < nonAlVideoStreams.length) {
+        mixedStreams.push(nonAlVideoStreams[nonAlIndex]);
+        nonAlIndex++;
+      }
+      mixedStreams.push(mutedAlVideoStreams[i]);
+    }
+
+    // Handle remaining nonAlVideoStreams (if any)
+    for (let i = nonAlIndex; i < nonAlVideoStreams.length; i++) {
+      mixedStreams.push(nonAlVideoStreams[i]);
+    }
+
+    // Unshift 'youyou' or 'youyouyou' stream to mixedStreams
+    if (youyouStream) {
+      mixedStreams.unshift(youyouStream);
+    }
+
+    return mixedStreams;
+  } catch (error) {
+    // Handle errors during the process of mixing streams
+    console.log("Error mixing streams:", (error as Error).message);
+    throw error;
+  }
+}