mediasfu-shared 1.0.0

package/src/consumers/connectSendTransport.ts

@@ -0,0 +1,150 @@
+import type { ProducerOptions } from 'mediasoup-client/lib/types';
+import { ConnectSendTransportAudioType, ConnectSendTransportVideoType, ConnectSendTransportScreenType, ConnectSendTransportAudioParameters, ConnectSendTransportVideoParameters, ConnectSendTransportScreenParameters } from '../types/types';
+export interface ConnectSendTransportParameters extends ConnectSendTransportAudioParameters, ConnectSendTransportVideoParameters, ConnectSendTransportScreenParameters {
+  audioParams: ProducerOptions 
+  videoParams: ProducerOptions;
+  localStreamScreen: MediaStream | null;
+  canvasStream: MediaStream | null;
+  whiteboardStarted: boolean;
+  whiteboardEnded: boolean;
+  shared: boolean;
+  islevel: string;
+
+  //mediasfu functions
+  connectSendTransportAudio: ConnectSendTransportAudioType;
+  connectSendTransportVideo: ConnectSendTransportVideoType;
+  connectSendTransportScreen: ConnectSendTransportScreenType;
+
+  getUpdatedAllParams: () => ConnectSendTransportParameters;
+  [key: string]: any;
+}
+
+export interface ConnectSendTransportOptions {
+  option: 'audio' | 'video' | 'screen' | 'all';
+  targetOption?: 'local' | 'remote' | 'all';
+  parameters: ConnectSendTransportParameters;
+}
+
+// Export the type definition for the function
+export type ConnectSendTransportType = (options: ConnectSendTransportOptions) => Promise<void>;
+
+/**
+ * Connects the send transport based on the specified option.
+ *
+ * @param {ConnectSendTransportOptions} options - The options for connecting the send transport.
+ * @param {string} options.option - The type of transport to connect ("audio", "video", "screen", or "all").
+ * @param {boolean} options.targetOption - The target option to connect ("local", "remote", or "all").
+ * @param {ConnectSendTransportParameters} options.parameters - The parameters required for connecting the transport.
+ * @param {ProducerOptions} options.parameters.audioParams - The audio parameters.
+ * @param {ProducerOptions} options.parameters.videoParams - The video parameters.
+ * @param {MediaStream} options.parameters.localStreamScreen - The local screen stream.
+ * @param {MediaStream} options.parameters.canvasStream - The canvas stream.
+ * @param {boolean} options.parameters.whiteboardStarted - Indicates if the whiteboard has started.
+ * @param {boolean} options.parameters.whiteboardEnded - Indicates if the whiteboard has ended.
+ * @param {boolean} options.parameters.shared - Indicates if the screen is shared.
+ * @param {string} options.parameters.islevel - The level of the screen sharing.
+ * @param {Function} options.parameters.connectSendTransportAudio - Function to connect the audio send transport.
+ * @param {Function} options.parameters.connectSendTransportVideo - Function to connect the video send transport.
+ * @param {Function} options.parameters.connectSendTransportScreen - Function to connect the screen send transport.
+ *
+ * @returns {Promise<void>} A promise that resolves when the transport is connected.
+ *
+ * @throws Will throw an error if the connection fails.
+ *
+ * @example
+ * const options = {
+ *   option: 'audio',
+ *   targetOption: 'local',
+ *   parameters: {
+ *     audioParams: audioProducerOptions,
+ *     videoParams: videoProducerOptions,
+ *     localStreamScreen: localStream,
+ *     canvasStream: canvasStream,
+ *     whiteboardStarted: false,
+ *     whiteboardEnded: false,
+ *     shared: false,
+ *     islevel: '1',
+ *     connectSendTransportAudio: connectAudioFunction,
+ *     connectSendTransportVideo: connectVideoFunction,
+ *     connectSendTransportScreen: connectScreenFunction,
+ *   },
+ * };
+ * 
+ * connectSendTransport(options)
+ *   .then(() => {
+ *     console.log('Transport connected successfully');
+ *   })
+ *   .catch((error) => {
+ *     console.error('Error connecting transport:', error);
+ *   });
+ */
+
+export const connectSendTransport = async ({ option, targetOption = "all", parameters }: ConnectSendTransportOptions): Promise<void> => {
+  try {
+    let {
+      audioParams,
+      videoParams,
+      localStreamScreen,
+      canvasStream,
+      whiteboardStarted,
+      whiteboardEnded,
+      shared,
+      islevel,
+
+      //media functions
+      connectSendTransportAudio,
+      connectSendTransportVideo,
+      connectSendTransportScreen,
+    } = parameters;
+
+    // Connect send transport based on the specified option
+    if (option === "audio") {
+      await connectSendTransportAudio({
+        targetOption,
+        audioParams,
+        parameters,
+      });
+    } else if (option === "video") {
+      await connectSendTransportVideo({
+        targetOption,
+        videoParams,
+        parameters,
+      });
+    } else if (option === "screen") {
+      if (
+        whiteboardStarted &&
+        !whiteboardEnded &&
+        canvasStream &&
+        islevel === "2" &&
+        !shared
+      ) {
+        await connectSendTransportScreen({
+          targetOption,
+          stream: canvasStream,
+          parameters,
+        });
+      } else {
+        await connectSendTransportScreen({
+          targetOption,
+          stream: localStreamScreen!,
+          parameters,
+        });
+      }
+    } else {
+      // Connect both audio and video send transports
+      await connectSendTransportAudio({
+        targetOption,
+        audioParams,
+        parameters,
+      });
+      await connectSendTransportVideo({
+        targetOption,
+        videoParams,
+        parameters,
+      });
+    }
+  } catch (error) {
+    console.log("connectSendTransport error", error);
+    // throw error;
+  }
+};

package/src/consumers/connectSendTransportAudio.ts

@@ -0,0 +1,161 @@
+import type { Transport, Producer, ProducerOptions } from 'mediasoup-client/lib/types';
+
+export interface ConnectSendTransportAudioParameters {
+  audioProducer: Producer | null;
+  producerTransport: Transport | null;
+  localAudioProducer?: Producer | null;
+  localProducerTransport?: Transport | null;
+  updateAudioProducer: (producer: Producer | null) => void;
+  updateProducerTransport: (transport: Transport | null) => void;
+  updateLocalAudioProducer?: (localProducer: Producer | null) => void;
+  updateLocalProducerTransport?: (localTransport: Transport | null) => void;
+  updateAudioLevel: (level: number) => void;
+
+  // Function to get all parameters
+  getUpdatedAllParams: () => ConnectSendTransportAudioParameters;
+  [key: string]: any; // Extendable for additional parameters
+
+}
+
+export interface ConnectSendTransportAudioOptions {
+  audioParams: ProducerOptions;
+  parameters: ConnectSendTransportAudioParameters;
+  targetOption?: 'all' | 'local' | 'remote';
+}
+
+// Export the type definition for the function
+export type ConnectSendTransportAudioType = (options: ConnectSendTransportAudioOptions) => Promise<void>;
+
+const connectLocalSendTransportAudio = async ({
+  parameters,
+  audioParams
+}: ConnectSendTransportAudioOptions): Promise<void> => {
+  try {
+    let {
+      localAudioProducer,
+      localProducerTransport,
+      updateLocalAudioProducer,
+      updateLocalProducerTransport,
+    } = parameters;
+
+    if (localProducerTransport) {
+      localAudioProducer = await localProducerTransport.produce(audioParams);
+
+      updateLocalAudioProducer?.(localAudioProducer);
+      updateLocalProducerTransport?.(localProducerTransport);
+    }
+  } catch (error) {
+    console.error("Error connecting local audio transport:", error);
+    throw error; // Re-throw to let the parent handle it
+  }
+};
+
+export const updateMicLevel = async (audioProducer: Producer, updateAudioLevel: (level: number) => void) => {
+  try {
+    setInterval(() => {
+      const sender = audioProducer!.rtpSender;
+
+      sender?.getStats().then((stats) => {
+        stats.forEach((report) => {
+
+          if (report.type === "media-source" && report.kind === "audio" && report.audioLevel !== undefined) {
+            const newLevel = 127.5 + (report.audioLevel * 127.5);
+            updateAudioLevel(newLevel);
+          }
+
+        });
+      });
+    }, 1000);
+  } catch {
+    // Handle error
+  }
+}
+
+
+/**
+ * Connects the send transport for audio by producing audio data and updating the audio producer and producer transport objects.
+ *
+ * If the primary connection fails, it attempts to connect using the local transport via a separate function.
+ *
+ * @param {ConnectSendTransportAudioOptions} options - The options for connecting the send transport.
+ * @param {ProducerOptions} options.audioParams - The audio parameters.
+ * @param {ConnectSendTransportAudioParameters} options.parameters - The parameters required for connecting the transport.
+ * @param {Producer | null} options.parameters.audioProducer - The audio producer object.
+ * @param {Transport | null} options.parameters.producerTransport - The producer transport object.
+ * @param {Producer | null} [options.parameters.localAudioProducer] - The local audio producer object.
+ * @param {Transport | null} [options.parameters.localProducerTransport] - The local producer transport object.
+ * @param {(producer: Producer | null) => void} options.parameters.updateAudioProducer - The function to update the audio producer object.
+ * @param {(transport: Transport | null) => void} options.parameters.updateProducerTransport - The function to update the producer transport object.
+ * @param {(localProducer: Producer | null) => void} [options.parameters.updateLocalAudioProducer] - The function to update the local audio producer object.
+ * @param {(localTransport: Transport | null) => void} [options.parameters.updateLocalProducerTransport] - The function to update the local producer transport object.
+ * @param {(level: number) => void} [options.parameters.updateAudioLevel] - The function to update the audio level.
+ * @returns {Promise<void>} A promise that resolves when the connection is established.
+ *
+ * @example
+ * const options = {
+ *   audioParams: { codec: "opus", maxBitrate: 128000 },
+ *   parameters: {
+ *     audioProducer: null,
+ *     producerTransport: transport,
+ *     localAudioProducer: null,
+ *     localProducerTransport: localTransport,
+ *     updateAudioProducer: (producer) => console.log("Updated producer:", producer),
+ *     updateProducerTransport: (transport) => console.log("Updated transport:", transport),
+ *     updateLocalAudioProducer: (localProducer) => console.log("Updated local producer:", localProducer),
+ *     updateLocalProducerTransport: (localTransport) => console.log("Updated local transport:", localTransport),
+ *     updateAudioLevel: (level) => console.log("Updated audio level:", level),
+ *   },
+ * };
+ *
+ * connectSendTransportAudio(options)
+ *   .then(() => console.log("Audio transport connected successfully"))
+ *   .catch((error) => console.error("Error connecting audio transport:", error));
+ */
+
+export const connectSendTransportAudio: ConnectSendTransportAudioType = async ({
+  parameters,
+  audioParams,
+  targetOption = "all",
+}: ConnectSendTransportAudioOptions): Promise<void> => {
+  try {
+    let {
+      audioProducer,
+      producerTransport,
+      updateAudioProducer,
+      updateProducerTransport,
+    } = parameters;
+
+    // Attempt to connect the primary send transport
+    if (targetOption === "all" || targetOption === "remote") {
+      audioProducer = await producerTransport!.produce(audioParams);
+
+      // Update the audio level
+      updateMicLevel(audioProducer, parameters.updateAudioLevel);
+
+      // Update state with the new producer and transport
+      updateAudioProducer(audioProducer);
+      updateProducerTransport(producerTransport);
+    }
+
+    // Attempt to connect the local send transport
+    if (targetOption === "all" || targetOption === "local") {
+      try {
+        await connectLocalSendTransportAudio({ parameters, audioParams });
+
+        // Update the audio level
+        if (targetOption === "local" && parameters.updateAudioLevel) {
+          if (!parameters.localAudioProducer) {
+            parameters = parameters.getUpdatedAllParams();
+          }
+          updateMicLevel(parameters.localAudioProducer!, parameters.updateAudioLevel);
+        }
+      } catch (localError) {
+        console.error("Local audio transport connection failed:", localError);
+      }
+    }
+
+  } catch (primaryError) {
+    console.error("audio transport connection failed:", primaryError);
+    throw new Error("Failed to connect to audio transport.");
+  }
+};

package/src/consumers/connectSendTransportScreen.ts

@@ -0,0 +1,169 @@
+import type { Transport, Producer, Device, ProducerOptions } from 'mediasoup-client/lib/types';
+
+export interface ConnectSendTransportScreenParameters {
+  screenProducer: Producer | null;
+  localScreenProducer?: Producer | null;
+  device: Device | null;
+  screenParams: ProducerOptions;
+  producerTransport: Transport | null;
+  localProducerTransport?: Transport | null;
+  params: ProducerOptions;
+  updateScreenProducer: (producer: Producer | null) => void;
+  updateLocalScreenProducer?: (localProducer: Producer | null) => void;
+  updateProducerTransport: (transport: Transport | null) => void;
+  updateLocalProducerTransport?: (localTransport: Transport | null) => void;
+
+  getUpdatedAllParams: () => ConnectSendTransportScreenParameters;
+  [key: string]: any; // Extendable for additional parameters
+}
+
+export interface ConnectSendTransportScreenOptions {
+  stream: MediaStream;
+  parameters: ConnectSendTransportScreenParameters;
+  targetOption?: "all" | "local" | "remote";
+}
+
+// Export the type definition for the function
+export type ConnectSendTransportScreenType = (options: ConnectSendTransportScreenOptions) => Promise<void>;
+
+const connectLocalSendTransportScreen = async ({
+  stream,
+  parameters,
+}: ConnectSendTransportScreenOptions): Promise<void> => {
+  try {
+    let {
+      localScreenProducer,
+      localProducerTransport,
+      updateLocalScreenProducer,
+      updateLocalProducerTransport,
+      device,
+    } = parameters;
+
+    // Find VP9 codec for local screen share
+    const codec = device?.rtpCapabilities?.codecs?.find(
+      (codec: { mimeType: string }) =>
+        codec.mimeType.toLowerCase() === "video/vp9"
+    );
+
+    // Produce local screen share data
+    if (localProducerTransport) {
+      localScreenProducer = await localProducerTransport.produce({
+        track: stream.getVideoTracks()[0],
+        codec,
+        appData: { mediaTag: "screen-video" },
+      });
+
+      // Update the local producer and transport objects
+      updateLocalScreenProducer?.(localScreenProducer);
+      updateLocalProducerTransport?.(localProducerTransport);
+    } 
+  } catch (error) {
+    console.error("Error connecting local screen transport:", error);
+    throw error; // Re-throw to propagate the error
+  }
+};
+
+/**
+ * Sets up and connects a screen sharing transport for sending video streams.
+ *
+ * This function supports both a primary and a local screen producer, delegating local handling to a separate function.
+ *
+ * @param {ConnectSendTransportScreenOptions} options - The configuration options for setting up the screen transport.
+ * @param {"all" | "local" | "remote"} [options.targetOption] - The target option for connecting the transport.
+ * @param {MediaStream} options.stream - The screen stream to be shared.
+ * @param {ConnectSendTransportScreenParameters} options.parameters - The parameters required for setting up the screen transport.
+ * @param {Producer | null} options.parameters.screenProducer - The screen producer object to be updated.
+ * @param {Device | null} options.parameters.device - The device object for media capabilities.
+ * @param {ProducerOptions} options.parameters.screenParams - The parameters for the screen producer.
+ * @param {Transport | null} options.parameters.producerTransport - The producer transport object.
+ * @param {ProducerOptions} options.parameters.params - The parameters for the producer.
+ * @param {Function} options.parameters.updateScreenProducer - The function to update the screen producer object.
+ * @param {Function} options.parameters.updateProducerTransport - The function to update the producer transport object.
+ * @param {Function} [options.parameters.updateLocalScreenProducer] - The function to update the local screen producer object.
+ * @param {Function} [options.parameters.updateLocalProducerTransport] - The function to update the local producer transport object.
+ * @param {Function} options.parameters.getUpdatedAllParams - The function to get updated parameters.
+ * @param {Object} [options.parameters.*] - Additional parameters for future use.
+ * 
+ * @returns {Promise<void>} - A promise that resolves once the screen transport is successfully connected and set up.
+ *
+ * @throws Will throw an error if there is an issue with the connection or setup process.
+ *
+ * @example
+ * ```typescript
+ * await connectSendTransportScreen({
+ *   stream: screenStream,
+ *   targetOption: "all",
+ *   parameters: {
+ *     screenProducer: null,
+ *     localScreenProducer: null,
+ *     device: mediaDevice,
+ *     screenParams: { encodings: [{ maxBitrate: 1500000 }] },
+ *     producerTransport: sendTransport,
+ *     localProducerTransport: localSendTransport,
+ *     params: { track: screenStream.getVideoTracks()[0] },
+ *     updateScreenProducer: setScreenProducer,
+ *     updateLocalScreenProducer: setLocalScreenProducer,
+ *     updateProducerTransport: setProducerTransport,
+ *     updateLocalProducerTransport: setLocalProducerTransport,
+ *     getUpdatedAllParams: getParams,
+ *   },
+ * });
+ * ```
+ */
+
+export const connectSendTransportScreen: ConnectSendTransportScreenType = async ({
+  stream,
+  parameters,
+  targetOption = "all",
+}: ConnectSendTransportScreenOptions): Promise<void> => {
+  try {
+    let {
+      screenProducer,
+      device,
+      screenParams,
+      producerTransport,
+      params,
+      updateScreenProducer,
+      updateProducerTransport,
+    } = parameters;
+
+    // Fetch updated device information
+    device = parameters.getUpdatedAllParams().device;
+
+    // Retrieve screen share parameters
+    params = screenParams;
+
+    // Find VP9 codec for screen share
+    const codec = device?.rtpCapabilities?.codecs?.find(
+      (codec: { mimeType: string }) =>
+        codec.mimeType.toLowerCase() === "video/vp9"
+    );
+
+    // Produce screen share data using the producer transport
+    if (targetOption === "remote" || targetOption === "all") {
+      screenProducer = await producerTransport!.produce({
+        track: stream.getVideoTracks()[0],
+        ...params,
+        codec,
+        appData: { mediaTag: "screen-video" },
+      });
+
+      // Update the screen producer and producer transport objects
+      updateScreenProducer(screenProducer);
+      updateProducerTransport(producerTransport);
+    }
+
+    // Produce screen share data using the local producer transport
+    if (targetOption === "local" || targetOption === "all") {
+      try {
+        await connectLocalSendTransportScreen({ stream, parameters });
+      } catch (localError) {
+        console.log("Error connecting local screen transport:", localError);
+      }
+    }
+
+  } catch (error) {
+    console.log("connectSendTransportScreen error", error);
+    throw error;
+  }
+};

package/src/consumers/connectSendTransportVideo.ts

@@ -0,0 +1,149 @@
+import type { Device, Producer, ProducerOptions, Transport } from 'mediasoup-client/lib/types';
+
+export interface ConnectSendTransportVideoParameters {
+  videoProducer: Producer | null;
+  localVideoProducer?: Producer | null;
+  device: Device | null;
+  producerTransport: Transport | null;
+  localProducerTransport?: Transport | null;
+  islevel: string;
+  updateMainWindow: boolean;
+  updateVideoProducer: (producer: Producer | null) => void;
+  updateLocalVideoProducer?: (localProducer: Producer | null) => void;
+  updateProducerTransport: (transport: Transport | null) => void;
+  updateLocalProducerTransport?: (localTransport: Transport | null) => void;
+  updateUpdateMainWindow: (state: boolean) => void;
+  [key: string]: any; // Extendable for additional parameters
+}
+
+export interface ConnectSendTransportVideoOptions {
+  videoParams: ProducerOptions;
+  parameters: ConnectSendTransportVideoParameters;
+  targetOption?: "all" | "local" | "remote";
+}
+
+// Export the type definition for the function
+export type ConnectSendTransportVideoType = (options: ConnectSendTransportVideoOptions) => Promise<void>;
+
+const connectLocalSendTransportVideo = async ({
+  videoParams,
+  parameters,
+}: ConnectSendTransportVideoOptions): Promise<void> => {
+  try {
+    let {
+      localVideoProducer,
+      localProducerTransport,
+      updateLocalVideoProducer,
+      updateLocalProducerTransport,
+    } = parameters;
+
+    // Produce local video data if transport exists
+    if (localProducerTransport) {
+      localVideoProducer = await localProducerTransport.produce(videoParams);
+
+      // Update local producer and transport
+      updateLocalVideoProducer?.(localVideoProducer);
+      updateLocalProducerTransport?.(localProducerTransport);
+    }
+  } catch (error) {
+    console.error("Error connecting local video transport:", error);
+    throw error; // Re-throw to propagate the error
+  }
+};
+
+/**
+ * Connects the send transport for video by producing video data and updates the relevant states.
+ *
+ * This function supports both a primary and a local video producer, delegating local handling to a separate function.
+ *
+ * @param {ConnectSendTransportVideoOptions} options - The options for connecting the send transport for video.
+ * @param {ProducerOptions} options.videoParams - The parameters for the video producer.
+ * @param {"all" | "local" | "remote"} [options.targetOption] - The target option for the video transport connection.
+ * @param {ConnectSendTransportVideoParameters} options.parameters - The parameters for the video transport connection.
+ * @param {Producer | null} options.parameters.videoProducer - The primary video producer.
+ * @param {Producer | null} [options.parameters.localVideoProducer] - The local video producer.
+ * @param {Device | null} options.parameters.device - The device information.
+ * @param {Transport | null} options.parameters.producerTransport - The primary producer transport.
+ * @param {Transport | null} [options.parameters.localProducerTransport] - The local producer transport.
+ * @param {string} options.parameters.islevel - The connection level for the video transport.
+ * @param {boolean} options.parameters.updateMainWindow - The flag to update the main window state.
+ * @param {(producer: Producer | null) => void} options.parameters.updateVideoProducer - The function to update the video producer state.
+ * @param {(localProducer: Producer | null) => void} [options.parameters.updateLocalVideoProducer] - The function to update the local video producer state.
+ * @param {(transport: Transport | null) => void} options.parameters.updateProducerTransport - The function to update the producer transport state.
+ * @param {(localTransport: Transport | null) => void} [options.parameters.updateLocalProducerTransport] - The function to update the local producer transport state.
+ * @param {(state: boolean) => void} options.parameters.updateUpdateMainWindow - The function to update the main window state.
+ * @param {any} [options.parameters] - Additional parameters for future use.
+ * @returns {Promise<void>} A promise that resolves when the send transport for video is connected.
+ *
+ * @throws Will throw an error if the connection fails.
+ *
+ * @example
+ * const options = {
+ *   videoParams: {
+ *     // video producer options (e.g., codec, bitrate)
+ *   },
+ *   targetOption: "all",
+ *   parameters: {
+ *     videoProducer: null,
+ *     localVideoProducer: null,
+ *     producerTransport: transport,
+ *     localProducerTransport: localTransport,
+ *     islevel: '2',
+ *     updateMainWindow: false,
+ *     updateVideoProducer: (producer) => console.log("Updated producer"),
+ *     updateLocalVideoProducer: (localProducer) => console.log("Updated local producer"),
+ *     updateProducerTransport: (transport) => console.log("Updated transport"),
+ *     updateLocalProducerTransport: (localTransport) => console.log("Updated local transport"),
+ *     updateUpdateMainWindow: (state) => console.log("Updated main window:", state),
+ *   },
+ * };
+ *
+ * connectSendTransportVideo(options)
+ *   .then(() => console.log("Video transport connected successfully"))
+ *   .catch((error) => console.error("Error connecting video transport:", error));
+ */
+
+export const connectSendTransportVideo: ConnectSendTransportVideoType = async ({
+  videoParams,
+  parameters,
+  targetOption = "all",
+}: ConnectSendTransportVideoOptions): Promise<void> => {
+  try {
+    let {
+      videoProducer,
+      producerTransport,
+      islevel,
+      updateMainWindow,
+      updateVideoProducer,
+      updateProducerTransport,
+      updateUpdateMainWindow,
+    } = parameters;
+
+    // Produce video data using the primary transport
+    if (targetOption === "all" || targetOption === "remote"){
+      videoProducer = await producerTransport!.produce(videoParams);
+
+      // Update main window state based on the video connection level
+      if (islevel === "2") {
+        updateMainWindow = true;
+      }
+
+      // Update video producer, transport, and UI state
+      updateVideoProducer(videoProducer);
+      updateProducerTransport(producerTransport);
+      updateUpdateMainWindow(updateMainWindow);
+    }
+
+    // Handle local video transport regardless of primary success or 
+    if (targetOption === "all" || targetOption === "local") {
+      try {
+        await connectLocalSendTransportVideo({ videoParams, parameters });
+      } catch (localError) {
+        console.log("Error connecting local video transport:", localError);
+      }
+    }
+  } catch (error) {
+    console.log("connectSendTransportVideo error", error);
+    throw error;
+  }
+};

package/src/consumers/consumerResume.ts

@@ -0,0 +1,25 @@
+// Stub export for consumerResume
+// This is a React component in the original and not needed for the shared package
+
+import { Socket } from 'socket.io-client';
+
+export interface ConsumerResumeParameters {
+  [key: string]: any;
+}
+
+export interface ConsumerResumeOptions {
+  track: MediaStreamTrack;
+  kind: string;
+  remoteProducerId: string;
+  params: any;
+  parameters: ConsumerResumeParameters;
+  nsock: Socket;
+  consumer?: any; // mediasoup Consumer
+}
+
+export type ConsumerResumeType = (options: ConsumerResumeOptions) => Promise<void>;
+
+export const consumerResume: ConsumerResumeType = async () => {
+  // Stub implementation - actual logic handled in framework-specific packages
+  console.warn('consumerResume called on shared package - should be implemented in framework package');
+};