mediasfu-shared 1.0.0

package/src/consumers/onScreenChanges.ts

@@ -0,0 +1,106 @@
+import { ReorderStreamsType, ReorderStreamsParameters, EventType } from "../types/types";
+
+export interface OnScreenChangesParameters extends ReorderStreamsParameters {
+  eventType: EventType;
+  shareScreenStarted: boolean;
+  shared: boolean;
+  addForBasic: boolean;
+  updateAddForBasic: (value: boolean) => void;
+  itemPageLimit: number;
+  updateItemPageLimit: (value: number) => void;
+  updateMainHeightWidth: (value: number) => void;
+
+  //mediasfu functions
+  reorderStreams: ReorderStreamsType;
+  [key: string]: any;
+}
+
+export interface OnScreenChangesOptions {
+  changed?: boolean;
+  parameters: OnScreenChangesParameters;
+}
+
+// Export the type definition for the function
+export type OnScreenChangesType = (options: OnScreenChangesOptions) => Promise<void>;
+
+/**
+ * Handles changes in screen events such as broadcast, chat, and conference.
+ * 
+ * @param {OnScreenChangesOptions} options - The options for handling screen changes.
+ * @param {boolean} options.changed - Indicates if the screen has changed.
+ * @param {object} options.parameters - The parameters for handling screen changes.
+ * @param {string} options.parameters.eventType - The type of event (e.g., "broadcast", "chat", "conference").
+ * @param {boolean} options.parameters.shareScreenStarted - Indicates if screen sharing has started.
+ * @param {boolean} options.parameters.shared - Indicates if the screen is shared.
+ * @param {boolean} options.parameters.addForBasic - Flag to add basic controls.
+ * @param {function} options.parameters.updateMainHeightWidth - Function to update the main height and width.
+ * @param {function} options.parameters.updateAddForBasic - Function to update the addForBasic flag.
+ * @param {number} options.parameters.itemPageLimit - The limit for item pages.
+ * @param {function} options.parameters.updateItemPageLimit - Function to update the item page limit.
+ * @param {function} options.parameters.reorderStreams - Function to reorder streams.
+ * 
+ * @returns {Promise<void>} A promise that resolves when the screen changes have been handled.
+ * 
+ * @throws {Error} Throws an error if there is an issue handling screen changes.
+ * 
+ * @example
+ * ```typescript
+ * await onScreenChanges({
+ *   changed: true,
+ *   parameters: {
+ *     eventType: 'conference',
+ *     shareScreenStarted: false,
+ *     shared: false,
+ *     addForBasic: false,
+ *     updateMainHeightWidth: (height) => console.log('Updated height:', height),
+ *     updateAddForBasic: (value) => console.log('Updated addForBasic:', value),
+ *     itemPageLimit: 2,
+ *     updateItemPageLimit: (limit) => console.log('Updated item page limit:', limit),
+ *     reorderStreams: async (options) => console.log('Reordered streams with options:', options),
+ *   },
+ * });
+ * ```
+ */ 
+
+export async function onScreenChanges({ changed, parameters }: OnScreenChangesOptions): Promise<void> {
+  try {
+    // Destructure parameters
+    let {
+      eventType,
+      shareScreenStarted,
+      shared,
+      addForBasic,
+      updateMainHeightWidth,
+      updateAddForBasic,
+      itemPageLimit,
+      updateItemPageLimit,
+
+      //mediasfu functions
+      reorderStreams,
+    } = parameters;
+
+    // Remove element with id 'controlButtons'
+    addForBasic = false;
+    updateAddForBasic(addForBasic);
+
+    if (eventType === "broadcast" || eventType === "chat") {
+      addForBasic = true;
+      updateAddForBasic(addForBasic);
+
+      itemPageLimit = eventType === "broadcast" ? 1 : 2;
+      updateItemPageLimit(itemPageLimit);
+      updateMainHeightWidth(eventType === "broadcast" ? 100 : 0);
+    } else {
+      if (eventType === "conference" && !(shareScreenStarted || shared)) {
+        updateMainHeightWidth(0);
+      }
+    }
+
+    // Update the mini cards grid
+    await reorderStreams({ add: false, screenChanged: changed, parameters });
+  } catch (error) {
+    // Handle errors during the process of handling screen changes
+    console.log("Error handling screen changes:", (error as Error).message);
+    // throw error;
+  }
+}

package/src/consumers/prepopulateUserMedia.ts

@@ -0,0 +1,18 @@
+// Stub export for prepopulateUserMedia
+// This is a React component in the original and not needed for the shared package
+
+export interface PrepopulateUserMediaParameters {
+  [key: string]: any;
+}
+
+export interface PrepopulateUserMediaOptions {
+  name: string;
+  parameters: PrepopulateUserMediaParameters;
+}
+
+export type PrepopulateUserMediaType = (options: PrepopulateUserMediaOptions) => Promise<void>;
+
+export const prepopulateUserMedia: PrepopulateUserMediaType = async () => {
+  // Stub implementation - actual logic handled in framework-specific packages
+  console.warn('prepopulateUserMedia called on shared package - should be implemented in framework package');
+};

package/src/consumers/processConsumerTransports.ts

@@ -0,0 +1,157 @@
+import { Stream, Participant, Transport, SleepType } from "../types/types";
+
+export interface ProcessConsumerTransportsParameters {
+  remoteScreenStream: Stream[];
+  oldAllStreams: (Stream | Participant)[];
+  newLimitedStreams: (Stream | Participant)[];
+
+  // mediasfu functions
+  sleep: SleepType;
+  getUpdatedAllParams: () => ProcessConsumerTransportsParameters;
+  [key: string]: any;
+}
+
+export interface ProcessConsumerTransportsOptions {
+  consumerTransports: Transport[];
+  lStreams_: (Stream | Participant)[];
+  parameters: ProcessConsumerTransportsParameters;
+}
+
+// Export the type definition for the function
+export type ProcessConsumerTransportsType = (options: ProcessConsumerTransportsOptions) => Promise<void>;
+
+/**
+ * Processes consumer transports by pausing and resuming them based on certain conditions.
+ *
+ * @param {Object} options - The options for processing consumer transports.
+ * @param {Array} options.consumerTransports - The list of consumer transports to process.
+ * @param {Array} options.lStreams_ - The list of local streams.
+ * @param {Object} options.parameters - The parameters object containing various stream arrays and utility functions.
+ *
+ * @returns {Promise<void>} - A promise that resolves when the processing is complete.
+ *
+ * @throws {Error} - Throws an error if there is an issue processing consumer transports.
+ *
+ * The function performs the following steps:
+ * 1. Destructures and updates the parameters.
+ * 2. Defines a helper function to check if a producerId is valid in given stream arrays.
+ * 3. Filters consumer transports to resume based on certain conditions.
+ * 4. Filters consumer transports to pause based on certain conditions.
+ * 5. Pauses consumer transports after a short delay.
+ * 6. Emits `consumer-pause` event for each filtered transport (not audio).
+ * 7. Emits `consumer-resume` event for each filtered transport (not audio).
+ *
+ * @example
+ * ```typescript
+ * await processConsumerTransports({
+ *   consumerTransports: [transport1, transport2],
+ *   lStreams_: [stream1, stream2],
+ *   parameters: {
+ *     remoteScreenStream: [],
+ *     oldAllStreams: [],
+ *     newLimitedStreams: [],
+ *     sleep: sleepFunction,
+ *     getUpdatedAllParams: () => parameters,
+ *   },
+ * });
+ * ```
+ */
+
+export async function processConsumerTransports({
+  consumerTransports,
+  lStreams_,
+  parameters,
+}: ProcessConsumerTransportsOptions): Promise<void> {
+  try {
+    // Destructure parameters and get updated values
+    parameters = parameters.getUpdatedAllParams();
+
+    const {
+      remoteScreenStream,
+      oldAllStreams,
+      newLimitedStreams,
+      sleep,
+    } = parameters;
+
+    // Function to check if the producerId is valid in the given stream arrays
+    function isValidProducerId(producerId: string, ...streamArrays: (Stream | Participant)[][]): boolean {
+      return (
+        producerId !== null &&
+        producerId !== "" &&
+        streamArrays.some((streamArray) => {
+          return (
+            streamArray.length > 0 &&
+            streamArray.some((stream) => stream?.producerId === producerId)
+          );
+        })
+      );
+    }
+
+    // Get paused consumer transports that are not audio
+    const consumerTransportsToResume = consumerTransports.filter(
+      (transport) =>
+        isValidProducerId(
+          transport.producerId,
+          lStreams_,
+          remoteScreenStream,
+          oldAllStreams,
+          newLimitedStreams
+        ) &&
+        transport.consumer?.paused === true &&
+        transport.consumer.kind !== "audio"
+    );
+
+    // Get unpaused consumer transports that are not audio
+    const consumerTransportsToPause = consumerTransports.filter(
+      (transport) =>
+        transport.producerId &&
+        transport.producerId !== null &&
+        transport.producerId !== "" &&
+        !lStreams_.some(
+          (stream) => stream.producerId === transport.producerId
+        ) &&
+        transport.consumer &&
+        transport.consumer.kind &&
+        transport.consumer.paused !== true &&
+        transport.consumer.kind !== "audio" &&
+        !remoteScreenStream.some((stream) => stream.producerId === transport.producerId) &&
+        !oldAllStreams.some((stream) => stream.producerId === transport.producerId) &&
+        !newLimitedStreams.some((stream) => stream.producerId === transport.producerId)
+    );
+
+    // Pause consumer transports after a short delay
+    await sleep({ ms: 100 });
+
+    // Emit consumer.pause() for each filtered transport (not audio)
+    for (const transport of consumerTransportsToPause) {
+     transport.consumer.pause();
+       transport.socket_.emit(
+        "consumer-pause",
+        { serverConsumerId: transport.serverConsumerTransportId },
+        async () => {
+          // Handle the response if needed
+        }
+      );
+    }
+
+    // Emit consumer.resume() for each filtered transport (not audio)
+    for (const transport of consumerTransportsToResume) {
+      transport.socket_.emit(
+        "consumer-resume",
+        { serverConsumerId: transport.serverConsumerTransportId },
+        async ({ resumed }: { resumed: boolean }) => {
+          if (resumed) {
+            transport.consumer.resume();
+          }
+        }
+      );
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(`Error processing consumer transports: ${error.message}`);
+    } else {
+      console.error('Error processing consumer transports:', error);
+    }
+    // throw new Error(`Error processing consumer transports: ${error.message}`);
+  }
+}

package/src/consumers/processConsumerTransportsAudio.ts

@@ -0,0 +1,121 @@
+import { Stream, Transport, Participant, SleepType } from "../types/types";
+
+export interface ProcessConsumerTransportsAudioParameters {
+
+  // mediasfu functions
+  sleep: SleepType;
+  [key: string]: any;
+}
+
+export interface ProcessConsumerTransportsAudioOptions {
+  consumerTransports: Transport[];
+  lStreams: (Stream | Participant)[];
+  parameters: ProcessConsumerTransportsAudioParameters;
+}
+
+// Export the type definition for the function
+export type ProcessConsumerTransportsAudioType = (
+  options: ProcessConsumerTransportsAudioOptions
+) => Promise<void>;
+
+/**
+ * Processes consumer transports for audio streams by pausing and resuming them based on their current state and the provided streams.
+ *
+ * @param {Object} options - The options for processing consumer transports.
+ * @param {Array} options.consumerTransports - The list of consumer transports to process.
+ * @param {Array} options.lStreams - The list of local streams to check against.
+ * @param {Object} options.parameters - Additional parameters for processing.
+ * @param {Function} options.parameters.sleep - A function to pause execution for a specified duration.
+ *
+ * @returns {Promise<void>} A promise that resolves when the processing is complete.
+ *
+ * @throws Will throw an error if there is an issue processing the consumer transports.
+ *
+ * @example
+ * ```typescript
+ * await processConsumerTransportsAudio({
+ *   consumerTransports: [transport1, transport2],
+ *   lStreams: [stream1, stream2],
+ *   parameters: {
+ *     sleep: sleepFunction,
+ *   },
+ * });
+ * ```
+ */
+
+export const processConsumerTransportsAudio = async ({
+  consumerTransports,
+  lStreams,
+  parameters,
+}: ProcessConsumerTransportsAudioOptions): Promise<void> => {
+  try {
+    const { sleep } = parameters;
+
+    // Function to check if the producerId is valid in the given stream arrays
+    const isValidProducerId = (producerId: string, ...streamArrays: (Stream | Participant)[][]): boolean => {
+      return (
+        producerId !== null &&
+        producerId !== "" &&
+        streamArrays.some((streamArray) => {
+          return (
+            streamArray.length > 0 &&
+          streamArray.some((stream) => stream?.producerId === producerId)
+          );
+        })
+      );
+    };
+
+    // Get paused consumer transports that are audio
+    const consumerTransportsToResume = consumerTransports.filter(
+      (transport) =>
+        isValidProducerId(transport.producerId, lStreams) &&
+        transport.consumer?.paused === true &&
+        transport.consumer.kind === "audio"
+    );
+
+    // Get unpaused consumer transports that are audio
+    const consumerTransportsToPause = consumerTransports.filter(
+      (transport) =>
+        transport.producerId &&
+        transport.producerId !== null &&
+        transport.producerId !== "" &&
+        !lStreams.some(
+          (stream) => stream.producerId === transport.producerId
+        ) &&
+        transport.consumer &&
+        transport.consumer.kind &&
+        transport.consumer.paused !== true &&
+        transport.consumer.kind === "audio"
+    );
+
+    await sleep({ms:100});
+
+    // Emit consumer.pause() for each transport to pause
+    for (const transport of consumerTransportsToPause) {
+      transport.consumer.pause();
+      transport.socket_.emit(
+        "consumer-pause",
+        { serverConsumerId: transport.serverConsumerTransportId },
+        async () => {
+          // Handle the response if needed
+        }
+      );
+    }
+
+    // Emit consumer.resume() for each transport to resume
+    for (const transport of consumerTransportsToResume) {
+      transport.socket_.emit(
+        "consumer-resume",
+        { serverConsumerId: transport.serverConsumerTransportId },
+        async ({ resumed }: { resumed: boolean }) => {
+          if (resumed) {
+            transport.consumer.resume();
+          }
+        }
+      );
+    }
+  } catch (error) {
+    console.error("Error in processConsumerTransportsAudio:", error);
+  }
+};
+

package/src/consumers/rePort.ts

@@ -0,0 +1,123 @@
+import { ScreenState, CompareScreenStatesParameters, CompareScreenStatesType, CompareActiveNamesParameters, CompareActiveNamesType } from '../types/types';
+
+
+export interface RePortParameters extends CompareScreenStatesParameters, CompareActiveNamesParameters {
+  islevel: string;
+  mainScreenPerson: string;
+  adminOnMainScreen: boolean;
+  mainScreenFilled: boolean;
+  recordStarted: boolean;
+  recordStopped: boolean;
+  recordPaused: boolean;
+  recordResumed: boolean;
+  screenStates: ScreenState[];
+  prevScreenStates: ScreenState[];
+  updateScreenStates: (states: ScreenState[]) => void;
+  updatePrevScreenStates: (states: ScreenState[]) => void;
+
+  // mediasfu functions
+  compareActiveNames: CompareActiveNamesType;
+  compareScreenStates: CompareScreenStatesType;
+
+  getUpdatedAllParams: () => RePortParameters;
+  [key: string]: any;
+}
+
+export interface RePortOptions {
+  restart?: boolean;
+  parameters: RePortParameters;
+}
+
+
+// Export the type definition for the function
+export type RePortType = (options: RePortOptions) => Promise<void>;
+
+/**
+ * RePort function that handles the reporting logic based on the provided parameters.
+ *
+ * @param {RePortOptions} options - The options for the rePort function.
+ * @param {boolean} [options.restart=false] - Flag indicating whether to restart the process.
+ * @param {Object} options.parameters - The parameters object containing various states and functions.
+ * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+ * @param {string} options.parameters.islevel - The current level of the process.
+ * @param {string} options.parameters.mainScreenPerson - The person on the main screen.
+ * @param {boolean} options.parameters.adminOnMainScreen - Flag indicating if admin is on the main screen.
+ * @param {boolean} options.parameters.mainScreenFilled - Flag indicating if the main screen is filled.
+ * @param {boolean} options.parameters.recordStarted - Flag indicating if recording has started.
+ * @param {boolean} options.parameters.recordStopped - Flag indicating if recording has stopped.
+ * @param {boolean} options.parameters.recordPaused - Flag indicating if recording is paused.
+ * @param {boolean} options.parameters.recordResumed - Flag indicating if recording has resumed.
+ * @param {Array} options.parameters.screenStates - Array of current screen states.
+ * @param {Function} options.parameters.updateScreenStates - Function to update the current screen states.
+ * @param {Function} options.parameters.updatePrevScreenStates - Function to update the previous screen states.
+ * @param {Function} options.parameters.compareActiveNames - Function to compare active names.
+ * @param {Function} options.parameters.compareScreenStates - Function to compare screen states.
+ *
+ * @returns {Promise<void>} A promise that resolves when the reporting process is complete.
+ *
+ * @throws {Error} Throws an error if there is an issue during the reporting process.
+ *
+ * @example
+ * ```typescript
+ * await rePort({
+ *   restart: false,
+ *   parameters: {
+ *     islevel: "2",
+ *     mainScreenPerson: "John Doe",
+ *     // other parameters...
+ *   },
+ * });
+ * ```
+ */
+
+export async function rePort({ restart = false, parameters }: RePortOptions): Promise<void> {
+  const { getUpdatedAllParams } = parameters;
+  parameters = getUpdatedAllParams();
+
+  try {
+    // Destructure parameters
+    const {
+      islevel,
+      mainScreenPerson,
+      adminOnMainScreen,
+      mainScreenFilled,
+      recordStarted,
+      recordStopped,
+      recordPaused,
+      recordResumed,
+      screenStates,
+      updateScreenStates,
+      updatePrevScreenStates,
+      compareActiveNames,
+      compareScreenStates,
+    } = parameters;
+
+    if (recordStarted || recordResumed) {
+      if (recordStopped || recordPaused) {
+        // Recording stopped or paused, do nothing
+      } else {
+        if (islevel === "2") {
+          const previousScreenStates = [...screenStates];
+          updatePrevScreenStates(previousScreenStates);
+
+          const currentScreenStates = [
+            { mainScreenPerson, adminOnMainScreen, mainScreenFilled },
+          ];
+          updateScreenStates(currentScreenStates);
+
+
+          if (restart) {
+            await compareActiveNames({ restart, parameters });
+            return;
+          }
+          await compareActiveNames({ restart, parameters });
+          await compareScreenStates({ restart, parameters });
+        }
+      }
+    }
+  } catch (error) {
+    console.log("Error during rePorting: ", error);
+    // throw new Error(`Error during rePorting: ${error.message}`);
+  }
+}
+