mediasfu-shared 1.0.1 → 1.0.3

package/src/consumers/mixStreams.ts

@@ -1,13 +1,41 @@
 import { Stream, Participant } from "../types/types";
 
-export interface MixStreamsOptions {
-  alVideoStreams: (Stream | Participant)[];
-  non_alVideoStreams: Participant[];
-  ref_participants: (Stream | Participant)[];
+interface MixStreamLike {
+  producerId?: string | null;
+  muted?: boolean | null;
+}
+
+interface MixParticipantLike {
+  videoID?: string | null;
+  muted?: boolean | null;
+}
+
+const getProducerId = (value: unknown): string | null | undefined => {
+  return (value as MixStreamLike | null | undefined)?.producerId;
+};
+
+const getVideoId = (value: unknown): string | null | undefined => {
+  return (value as MixParticipantLike | null | undefined)?.videoID;
+};
+
+const getMuted = (value: unknown): boolean | null | undefined => {
+  return (value as (MixStreamLike & MixParticipantLike) | null | undefined)?.muted;
+};
+
+export interface MixStreamsOptions<
+  TStream extends MixStreamLike = Stream,
+  TParticipant extends MixParticipantLike = Participant,
+> {
+  alVideoStreams: (TStream | TParticipant)[];
+  non_alVideoStreams: TParticipant[];
+  ref_participants: (TStream | TParticipant)[];
 }
 
 // Export the type definition for the function
-export type MixStreamsType = (options: MixStreamsOptions) => Promise<(Stream | Participant)[]>;
+export type MixStreamsType = <
+  TStream extends MixStreamLike = Stream,
+  TParticipant extends MixParticipantLike = Participant,
+>(options: MixStreamsOptions<TStream, TParticipant>) => Promise<(TStream | TParticipant)[]>;
 
 /**
  * Mixes video and audio streams and participants based on specified parameters.
@@ -30,37 +58,40 @@ export type MixStreamsType = (options: MixStreamsOptions) => Promise<(Stream | P
  */
 
 
-export async function mixStreams({
+export async function mixStreams<
+  TStream extends MixStreamLike = Stream,
+  TParticipant extends MixParticipantLike = Participant,
+>({
   alVideoStreams,
   non_alVideoStreams,
   ref_participants,
-}: MixStreamsOptions): Promise<(Stream | Participant)[]> {
+}: MixStreamsOptions<TStream, TParticipant>): Promise<(TStream | TParticipant)[]> {
   try {
 
-    const mixedStreams: (Stream | Participant)[] = [];
+    const mixedStreams: (TStream | TParticipant)[] = [];
 
     // Find "youyou" or "youyouyou" stream
     const youyouStream = alVideoStreams.find(
-      (obj) => obj.producerId === "youyou" || obj.producerId === "youyouyou"
+      (obj) => getProducerId(obj) === "youyou" || getProducerId(obj) === "youyouyou"
     );
 
     let remainingAlVideoStreams = alVideoStreams.filter(
-      (obj) => obj.producerId !== "youyou" && obj.producerId !== "youyouyou"
+      (obj) => getProducerId(obj) !== "youyou" && getProducerId(obj) !== "youyouyou"
     );
 
     // Separate unmuted and muted streams
     const unmutedAlVideoStreams = remainingAlVideoStreams.filter((obj) => {
       const participant = ref_participants.find(
-        (p) => p.videoID === obj.producerId
+        (p) => getVideoId(p) === getProducerId(obj)
       );
-      return !obj.muted && participant && participant.muted === false;
+      return !getMuted(obj) && participant && getMuted(participant) === false;
     });
 
     const mutedAlVideoStreams = remainingAlVideoStreams.filter((obj) => {
       const participant = ref_participants.find(
-        (p) => p.videoID === obj.producerId
+        (p) => getVideoId(p) === getProducerId(obj)
       );
-      return obj.muted || (participant && participant.muted === true);
+      return !!getMuted(obj) || (participant && getMuted(participant) === true);
     });
 
     const nonAlVideoStreams = [...non_alVideoStreams]; // Create a copy of non_alVideoStreams

package/src/consumers/onScreenChanges.ts

@@ -1,6 +1,10 @@
-import { ReorderStreamsType, ReorderStreamsParameters, EventType } from "../types/types";
+import { ReorderStreamsParameters, EventType } from "../types/types";
 
-export interface OnScreenChangesParameters extends ReorderStreamsParameters {
+type OpaqueReorderStreamsInvoker = {
+  bivarianceHack: (options: any) => Promise<void>;
+}["bivarianceHack"];
+
+export interface OnScreenChangesParameters extends ReorderStreamsParameters<any, any, any> {
   eventType: EventType;
   shareScreenStarted: boolean;
   shared: boolean;
@@ -10,18 +14,22 @@ export interface OnScreenChangesParameters extends ReorderStreamsParameters {
   updateItemPageLimit: (value: number) => void;
   updateMainHeightWidth: (value: number) => void;
 
-  //mediasfu functions
-  reorderStreams: ReorderStreamsType;
+  // mediasfu functions
+  reorderStreams: OpaqueReorderStreamsInvoker;
   [key: string]: any;
 }
 
-export interface OnScreenChangesOptions {
+export interface OnScreenChangesOptions<
+  TParameters extends OnScreenChangesParameters = OnScreenChangesParameters,
+> {
   changed?: boolean;
-  parameters: OnScreenChangesParameters;
+  parameters: TParameters;
 }
 
 // Export the type definition for the function
-export type OnScreenChangesType = (options: OnScreenChangesOptions) => Promise<void>;
+export type OnScreenChangesType = <
+  TParameters extends OnScreenChangesParameters = OnScreenChangesParameters,
+>(options: OnScreenChangesOptions<TParameters>) => Promise<void>;
 
 /**
  * Handles changes in screen events such as broadcast, chat, and conference.
@@ -62,13 +70,17 @@ export type OnScreenChangesType = (options: OnScreenChangesOptions) => Promise<v
  * ```
  */ 
 
-export async function onScreenChanges({ changed, parameters }: OnScreenChangesOptions): Promise<void> {
+export async function onScreenChanges<
+  TParameters extends OnScreenChangesParameters = OnScreenChangesParameters,
+>({ changed, parameters }: OnScreenChangesOptions<TParameters>): Promise<void> {
   try {
     // Destructure parameters
     let {
       eventType,
       shareScreenStarted,
       shared,
+      whiteboardStarted,
+      whiteboardEnded,
       addForBasic,
       updateMainHeightWidth,
       updateAddForBasic,
@@ -78,6 +90,7 @@ export async function onScreenChanges({ changed, parameters }: OnScreenChangesOp
       //mediasfu functions
       reorderStreams,
     } = parameters;
+    const screenFlowActive = shareScreenStarted || shared || (whiteboardStarted && !whiteboardEnded);
 
     // Remove element with id 'controlButtons'
     addForBasic = false;
@@ -89,9 +102,11 @@ export async function onScreenChanges({ changed, parameters }: OnScreenChangesOp
 
       itemPageLimit = eventType === "broadcast" ? 1 : 2;
       updateItemPageLimit(itemPageLimit);
-      updateMainHeightWidth(eventType === "broadcast" ? 100 : 0);
+      updateMainHeightWidth(screenFlowActive ? 84 : eventType === "broadcast" ? 100 : 0);
+    } else if (screenFlowActive) {
+      updateMainHeightWidth(84);
     } else {
-      if (eventType === "conference" && !(shareScreenStarted || shared)) {
+      if (eventType === "conference") {
         updateMainHeightWidth(0);
       }
     }

package/src/consumers/prepopulateUserMedia.ts

@@ -1,6 +1,8 @@
 // Stub export for prepopulateUserMedia
 // This is a React component in the original and not needed for the shared package
 
+import { createFrameworkConsumerContractError } from './frameworkConsumerContract';
+
 export interface PrepopulateUserMediaParameters {
   [key: string]: any;
 }
@@ -13,6 +15,5 @@ export interface PrepopulateUserMediaOptions {
 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');
+  throw createFrameworkConsumerContractError('prepopulateUserMedia');
 };

package/src/consumers/processConsumerTransports.ts

@@ -1,24 +1,65 @@
 import { Stream, Participant, Transport, SleepType } from "../types/types";
 
-export interface ProcessConsumerTransportsParameters {
-  remoteScreenStream: Stream[];
-  oldAllStreams: (Stream | Participant)[];
-  newLimitedStreams: (Stream | Participant)[];
+interface ProducerIdCarrier {
+  producerId?: string | null;
+}
+
+const getProducerId = (value: unknown): string | null | undefined => {
+  return (value as ProducerIdCarrier | null | undefined)?.producerId;
+};
+
+interface ConsumerLike {
+  paused?: boolean;
+  kind?: string;
+  pause: () => unknown;
+  resume: () => unknown;
+}
+
+interface SocketLike {
+  emit: (
+    event: string,
+    payload: { serverConsumerId: string },
+    callback?: ((payload?: { resumed: boolean }) => void | Promise<unknown>)
+  ) => void;
+}
+
+interface TransportLike {
+  producerId?: string | null;
+  consumer?: ConsumerLike;
+  socket_: SocketLike;
+  serverConsumerTransportId: string;
+}
+
+export interface ProcessConsumerTransportsParameters<
+  TStreamEntry = Stream,
+  TMediaEntry = Stream | Participant,
+> {
+  remoteScreenStream: TStreamEntry[];
+  oldAllStreams: TMediaEntry[];
+  newLimitedStreams: TMediaEntry[];
 
   // mediasfu functions
   sleep: SleepType;
-  getUpdatedAllParams: () => ProcessConsumerTransportsParameters;
+  getUpdatedAllParams: () => ProcessConsumerTransportsParameters<TStreamEntry, TMediaEntry>;
   [key: string]: any;
 }
 
-export interface ProcessConsumerTransportsOptions {
-  consumerTransports: Transport[];
-  lStreams_: (Stream | Participant)[];
-  parameters: ProcessConsumerTransportsParameters;
+export interface ProcessConsumerTransportsOptions<
+  TTransport extends TransportLike = Transport,
+  TStreamEntry = Stream,
+  TMediaEntry = Stream | Participant,
+> {
+  consumerTransports: TTransport[];
+  lStreams_: TMediaEntry[];
+  parameters: ProcessConsumerTransportsParameters<TStreamEntry, TMediaEntry>;
 }
 
 // Export the type definition for the function
-export type ProcessConsumerTransportsType = (options: ProcessConsumerTransportsOptions) => Promise<void>;
+export type ProcessConsumerTransportsType = <
+  TTransport extends TransportLike = Transport,
+  TStreamEntry = Stream,
+  TMediaEntry = Stream | Participant,
+>(options: ProcessConsumerTransportsOptions<TTransport, TStreamEntry, TMediaEntry>) => Promise<void>;
 
 /**
  * Processes consumer transports by pausing and resuming them based on certain conditions.
@@ -57,11 +98,15 @@ export type ProcessConsumerTransportsType = (options: ProcessConsumerTransportsO
  * ```
  */
 
-export async function processConsumerTransports({
+export async function processConsumerTransports<
+  TTransport extends TransportLike = Transport,
+  TStreamEntry = Stream,
+  TMediaEntry = Stream | Participant,
+>({
   consumerTransports,
   lStreams_,
   parameters,
-}: ProcessConsumerTransportsOptions): Promise<void> {
+}: ProcessConsumerTransportsOptions<TTransport, TStreamEntry, TMediaEntry>): Promise<void> {
   try {
     // Destructure parameters and get updated values
     parameters = parameters.getUpdatedAllParams();
@@ -74,14 +119,14 @@ export async function processConsumerTransports({
     } = parameters;
 
     // Function to check if the producerId is valid in the given stream arrays
-    function isValidProducerId(producerId: string, ...streamArrays: (Stream | Participant)[][]): boolean {
+    function isValidProducerId(producerId: string | null | undefined, ...streamArrays: unknown[][]): boolean {
       return (
         producerId !== null &&
         producerId !== "" &&
         streamArrays.some((streamArray) => {
           return (
             streamArray.length > 0 &&
-            streamArray.some((stream) => stream?.producerId === producerId)
+            streamArray.some((stream) => getProducerId(stream) === producerId)
           );
         })
       );
@@ -98,7 +143,7 @@ export async function processConsumerTransports({
           newLimitedStreams
         ) &&
         transport.consumer?.paused === true &&
-        transport.consumer.kind !== "audio"
+        transport.consumer?.kind !== "audio"
     );
 
     // Get unpaused consumer transports that are not audio
@@ -108,15 +153,15 @@ export async function processConsumerTransports({
         transport.producerId !== null &&
         transport.producerId !== "" &&
         !lStreams_.some(
-          (stream) => stream.producerId === transport.producerId
+          (stream) => getProducerId(stream) === transport.producerId
         ) &&
         transport.consumer &&
-        transport.consumer.kind &&
+        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)
+        !remoteScreenStream.some((stream) => getProducerId(stream) === transport.producerId) &&
+        !oldAllStreams.some((stream) => getProducerId(stream) === transport.producerId) &&
+        !newLimitedStreams.some((stream) => getProducerId(stream) === transport.producerId)
     );
 
     // Pause consumer transports after a short delay
@@ -124,7 +169,7 @@ export async function processConsumerTransports({
 
     // Emit consumer.pause() for each filtered transport (not audio)
     for (const transport of consumerTransportsToPause) {
-     transport.consumer.pause();
+     transport.consumer?.pause();
        transport.socket_.emit(
         "consumer-pause",
         { serverConsumerId: transport.serverConsumerTransportId },
@@ -139,9 +184,9 @@ export async function processConsumerTransports({
       transport.socket_.emit(
         "consumer-resume",
         { serverConsumerId: transport.serverConsumerTransportId },
-        async ({ resumed }: { resumed: boolean }) => {
+        async ({ resumed }: { resumed: boolean } = { resumed: false }) => {
           if (resumed) {
-            transport.consumer.resume();
+            transport.consumer?.resume();
           }
         }
       );

package/src/consumers/processConsumerTransportsAudio.ts

@@ -1,5 +1,119 @@
 import { Stream, Transport, Participant, SleepType } from "../types/types";
 
+interface ProducerIdCarrier {
+  producerId?: string | null;
+}
+
+interface SpeakerTranslationStateLike {
+  enabled?: boolean;
+  speakerId?: string;
+  speakerName?: string;
+  originalProducerId?: string;
+}
+
+interface ParticipantLike {
+  name?: string | null;
+  audioID?: string | null;
+}
+
+const getProducerId = (value: unknown): string | null | undefined => {
+  return (value as ProducerIdCarrier | null | undefined)?.producerId;
+};
+
+interface ConsumerLike {
+  paused?: boolean;
+  kind?: string;
+  pause: () => unknown;
+  resume: () => unknown;
+}
+
+interface SocketLike {
+  emit: (
+    event: string,
+    payload: { serverConsumerId: string },
+    callback?: ((payload?: { resumed: boolean }) => void | Promise<unknown>)
+  ) => void;
+}
+
+interface TransportLike {
+  producerId?: string | null;
+  consumer?: ConsumerLike;
+  socket_: SocketLike;
+  serverConsumerTransportId: string;
+}
+
+const getSpeakerNameForProducerId = (
+  producerId: string,
+  parameters: Record<string, any>,
+): string | undefined => {
+  const participants = parameters.participants as ParticipantLike[] | undefined;
+  const participant = participants?.find((candidate) => candidate.audioID === producerId);
+
+  if (participant?.name) {
+    return participant.name;
+  }
+
+  const audStreamName = (parameters.audStreamNames as Array<{ producerId?: string; name?: string }> | undefined)
+    ?.find((stream) => stream.producerId === producerId && typeof stream.name === 'string');
+  if (audStreamName?.name) {
+    return audStreamName.name;
+  }
+
+  return (parameters.allAudioStreams as Array<{ producerId?: string; name?: string }> | undefined)
+    ?.find((stream) => stream.producerId === producerId && typeof stream.name === 'string')
+    ?.name;
+};
+
+const isOriginalAudioSuppressedByTranslation = (
+  producerId: string | null | undefined,
+  parameters: Record<string, any>,
+): boolean => {
+  if (!producerId) {
+    return false;
+  }
+
+  const activeTranslationProducerIds = parameters.activeTranslationProducerIds as Set<string> | undefined;
+  if (activeTranslationProducerIds?.has(producerId)) {
+    return false;
+  }
+
+  const speakerTranslationStates = parameters.speakerTranslationStates as
+    | Map<string, SpeakerTranslationStateLike>
+    | undefined;
+
+  if (!speakerTranslationStates?.size) {
+    return false;
+  }
+
+  const speakerName = getSpeakerNameForProducerId(producerId, parameters);
+
+  if (speakerName) {
+    const speakerState = speakerTranslationStates.get(speakerName);
+    if (speakerState?.enabled) {
+      return true;
+    }
+  }
+
+  return Array.from(speakerTranslationStates.values()).some((speakerState) => {
+    if (!speakerState?.enabled) {
+      return false;
+    }
+
+    if (speakerState.originalProducerId === producerId) {
+      return true;
+    }
+
+    if (!speakerName) {
+      return false;
+    }
+
+    return (
+      speakerState.speakerId === speakerName ||
+      speakerState.speakerName === speakerName
+    );
+  });
+};
+
 export interface ProcessConsumerTransportsAudioParameters {
 
   // mediasfu functions
@@ -7,16 +121,20 @@ export interface ProcessConsumerTransportsAudioParameters {
   [key: string]: any;
 }
 
-export interface ProcessConsumerTransportsAudioOptions {
-  consumerTransports: Transport[];
-  lStreams: (Stream | Participant)[];
+export interface ProcessConsumerTransportsAudioOptions<
+  TTransport extends TransportLike = Transport,
+  TMediaEntry = Stream | Participant,
+> {
+  consumerTransports: TTransport[];
+  lStreams: TMediaEntry[];
   parameters: ProcessConsumerTransportsAudioParameters;
 }
 
 // Export the type definition for the function
-export type ProcessConsumerTransportsAudioType = (
-  options: ProcessConsumerTransportsAudioOptions
-) => Promise<void>;
+export type ProcessConsumerTransportsAudioType = <
+  TTransport extends TransportLike = Transport,
+  TMediaEntry = Stream | Participant,
+>(options: ProcessConsumerTransportsAudioOptions<TTransport, TMediaEntry>) => Promise<void>;
 
 /**
  * Processes consumer transports for audio streams by pausing and resuming them based on their current state and the provided streams.
@@ -43,23 +161,26 @@ export type ProcessConsumerTransportsAudioType = (
  * ```
  */
 
-export const processConsumerTransportsAudio = async ({
+export const processConsumerTransportsAudio = async <
+  TTransport extends TransportLike = Transport,
+  TMediaEntry = Stream | Participant,
+>({
   consumerTransports,
   lStreams,
   parameters,
-}: ProcessConsumerTransportsAudioOptions): Promise<void> => {
+}: ProcessConsumerTransportsAudioOptions<TTransport, TMediaEntry>): 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 => {
+    const isValidProducerId = (producerId: string | null | undefined, ...streamArrays: unknown[][]): boolean => {
       return (
         producerId !== null &&
         producerId !== "" &&
         streamArrays.some((streamArray) => {
           return (
             streamArray.length > 0 &&
-          streamArray.some((stream) => stream?.producerId === producerId)
+          streamArray.some((stream) => getProducerId(stream) === producerId)
           );
         })
       );
@@ -69,8 +190,9 @@ export const processConsumerTransportsAudio = async ({
     const consumerTransportsToResume = consumerTransports.filter(
       (transport) =>
         isValidProducerId(transport.producerId, lStreams) &&
+        !isOriginalAudioSuppressedByTranslation(transport.producerId, parameters) &&
         transport.consumer?.paused === true &&
-        transport.consumer.kind === "audio"
+        transport.consumer?.kind === "audio"
     );
 
     // Get unpaused consumer transports that are audio
@@ -79,11 +201,14 @@ export const processConsumerTransportsAudio = async ({
         transport.producerId &&
         transport.producerId !== null &&
         transport.producerId !== "" &&
-        !lStreams.some(
-          (stream) => stream.producerId === transport.producerId
+        (
+          isOriginalAudioSuppressedByTranslation(transport.producerId, parameters) ||
+          !lStreams.some(
+            (stream) => getProducerId(stream) === transport.producerId
+          )
         ) &&
         transport.consumer &&
-        transport.consumer.kind &&
+        transport.consumer?.kind &&
         transport.consumer.paused !== true &&
         transport.consumer.kind === "audio"
     );
@@ -92,7 +217,7 @@ export const processConsumerTransportsAudio = async ({
 
     // Emit consumer.pause() for each transport to pause
     for (const transport of consumerTransportsToPause) {
-      transport.consumer.pause();
+      transport.consumer?.pause();
       transport.socket_.emit(
         "consumer-pause",
         { serverConsumerId: transport.serverConsumerTransportId },
@@ -104,12 +229,16 @@ export const processConsumerTransportsAudio = async ({
 
     // Emit consumer.resume() for each transport to resume
     for (const transport of consumerTransportsToResume) {
+      if (isOriginalAudioSuppressedByTranslation(transport.producerId, parameters)) {
+        continue;
+      }
+
       transport.socket_.emit(
         "consumer-resume",
         { serverConsumerId: transport.serverConsumerTransportId },
-        async ({ resumed }: { resumed: boolean }) => {
+        async ({ resumed }: { resumed: boolean } = { resumed: false }) => {
           if (resumed) {
-            transport.consumer.resume();
+            transport.consumer?.resume();
           }
         }
       );