mediasfu-shared 1.0.1 → 1.0.2

package/src/consumers/getPipedProducersAlt.ts

@@ -1,11 +1,37 @@
 import { Socket } from "socket.io-client";
 import { SignalNewConsumerTransportParameters, SignalNewConsumerTransportType } from '../types/types';
 
-export interface GetPipedProducersAltParameters extends SignalNewConsumerTransportParameters {
+interface TranslationMeta {
+  speakerId: string;
+  speakerName: string;
+  language: string;
+  originalProducerId?: string;
+  isSpeakerControlled?: boolean;
+}
+
+interface ProducerInfo {
+  id: string;
+  translationMeta?: TranslationMeta | null;
+}
+
+export interface GetPipedProducersAltParameters extends Omit<SignalNewConsumerTransportParameters, 'getUpdatedAllParams'> {
   member: string;
 
+  listenerTranslationPreferences?: {
+    perSpeaker: Map<string, { speakerId: string; language: string | null; wantOriginal: boolean }>;
+    globalLanguage: string | null;
+  };
+
   // mediasfu functions
   signalNewConsumerTransport: SignalNewConsumerTransportType;
+  startConsumingTranslation?: (
+    producerId: string,
+    speakerId: string,
+    language: string,
+    originalProducerId?: string,
+    nsock?: Socket
+  ) => Promise<void>;
+  getUpdatedAllParams?: () => GetPipedProducersAltParameters;
   [key: string]: any;
 }
 
@@ -19,6 +45,41 @@ export interface GetPipedProducersAltOptions {
 // Export the type definition for the function
 export type GetPipedProducersAltType = (options: GetPipedProducersAltOptions) => Promise<void>;
 
+const shouldConsumeTranslationProducer = (
+  translationMeta: TranslationMeta,
+  listenerTranslationPreferences?: {
+    perSpeaker: Map<string, { speakerId: string; language: string | null; wantOriginal: boolean }>;
+    globalLanguage: string | null;
+  }
+): boolean => {
+  const normalizedLang = translationMeta.language?.toLowerCase();
+  const speakerId = translationMeta.speakerId;
+  const isSpeakerControlled = translationMeta.isSpeakerControlled === true;
+
+  if (listenerTranslationPreferences) {
+    const perSpeakerPref = listenerTranslationPreferences.perSpeaker?.get(speakerId);
+    if (perSpeakerPref) {
+      if (perSpeakerPref.wantOriginal) {
+        return false;
+      }
+      if (perSpeakerPref.language) {
+        return perSpeakerPref.language.toLowerCase() === normalizedLang;
+      }
+    }
+
+    const globalPref = listenerTranslationPreferences.globalLanguage;
+    if (globalPref) {
+      return globalPref.toLowerCase() === normalizedLang;
+    }
+  }
+
+  if (isSpeakerControlled) {
+    return true;
+  }
+
+  return false;
+};
+
 /**
  * Retrieves piped producers and signals new consumer transport for each retrieved producer.
  *
@@ -63,8 +124,14 @@ export const getPipedProducersAlt = async ({
   parameters,
 }: GetPipedProducersAltOptions): Promise<void> => {
   try {
-    // Destructure parameters
-    const { member, signalNewConsumerTransport } = parameters;
+    const freshParams = parameters.getUpdatedAllParams ? parameters.getUpdatedAllParams() : parameters;
+
+    const {
+      member,
+      signalNewConsumerTransport,
+      startConsumingTranslation,
+      listenerTranslationPreferences,
+    } = freshParams;
 
     const emitName = community ? "getProducersAlt" : "getProducersPipedAlt";
 
@@ -72,20 +139,49 @@ export const getPipedProducersAlt = async ({
     await nsock.emit(
       emitName,
       { islevel, member },
-      async (producerIds: string[]) => {
+      async (producers: (string | ProducerInfo)[]) => {
         // 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,
-              })
-            )
-          );
+        if (producers.length > 0) {
+          for (const producer of producers) {
+            let producerId: string;
+            let translationMeta: TranslationMeta | null = null;
+
+            if (typeof producer === 'string') {
+              producerId = producer;
+            } else {
+              producerId = producer.id;
+              translationMeta = producer.translationMeta || null;
+            }
+
+            if (translationMeta) {
+              const shouldConsume = shouldConsumeTranslationProducer(
+                translationMeta,
+                listenerTranslationPreferences,
+              );
+
+              if (!shouldConsume) {
+                continue;
+              }
+
+              if (startConsumingTranslation) {
+                await startConsumingTranslation(
+                  producerId,
+                  translationMeta.speakerId,
+                  translationMeta.language,
+                  translationMeta.originalProducerId,
+                  nsock,
+                );
+                continue;
+              }
+            }
+
+            await signalNewConsumerTransport({
+              nsock,
+              remoteProducerId: producerId,
+              islevel,
+              parameters: freshParams as unknown as SignalNewConsumerTransportParameters,
+            });
+          }
         }
       }
     );

package/src/consumers/gridLayout/addVideosGrid.engine.ts

@@ -0,0 +1,42 @@
+export interface GridPlanEntry<T> {
+  stream: T;
+  index: number;
+}
+
+export interface BuildAddVideosGridPlanOptions<T> {
+  mainGridStreams: T[];
+  altGridStreams: T[];
+  numToAdd?: number;
+}
+
+export interface AddVideosGridPlan<T> {
+  mainEntries: GridPlanEntry<T>[];
+  altEntries: GridPlanEntry<T>[];
+}
+
+/**
+ * Pure planning engine for addVideosGrid.
+ * Produces deterministic main/alt stream iteration plans without rendering concerns.
+ */
+export function buildAddVideosGridPlan<T>({
+  mainGridStreams,
+  altGridStreams,
+  numToAdd,
+}: BuildAddVideosGridPlanOptions<T>): AddVideosGridPlan<T> {
+  const safeMain = Array.isArray(mainGridStreams) ? mainGridStreams : [];
+  const safeAlt = Array.isArray(altGridStreams) ? altGridStreams : [];
+
+  const bounded = Math.max(0, Math.min(numToAdd ?? safeMain.length, safeMain.length));
+
+  const mainEntries = safeMain.slice(0, bounded).map((stream, index) => ({
+    stream,
+    index,
+  }));
+
+  const altEntries = safeAlt.map((stream, index) => ({
+    stream,
+    index,
+  }));
+
+  return { mainEntries, altEntries };
+}

package/src/consumers/gridLayout/prepopulateUserMedia.engine.ts

@@ -0,0 +1,444 @@
+export interface PrepopulateParticipantLike {
+  name?: string;
+  islevel?: string;
+  ScreenID?: string;
+  ScreenOn?: boolean;
+  [key: string]: any;
+}
+
+export interface PrepopulateStreamLike {
+  producerId?: string;
+  stream?: any;
+  [key: string]: any;
+}
+
+export interface BuildPrepopulateUserMediaPlanOptions<
+  P extends PrepopulateParticipantLike,
+  S extends PrepopulateStreamLike,
+> {
+  participants: P[];
+  allVideoStreams: S[];
+  member: string;
+  islevel: string;
+  shared: boolean;
+  shareScreenStarted: boolean;
+  eventType: string;
+  screenId?: string;
+  whiteboardStarted: boolean;
+  whiteboardEnded: boolean;
+  remoteScreenStream: S[];
+  localStreamScreen: any;
+  checkOrientation: () => string;
+  isWideScreen: boolean;
+  forceFullDisplay: boolean;
+  includeWhiteboardAsScreenFlow?: boolean;
+}
+
+export interface PrepopulateUserMediaPlan<P extends PrepopulateParticipantLike> {
+  screenFlowActive: boolean;
+  shouldReturnEarly: boolean;
+  shouldUpdateAdminOnMainScreen: boolean;
+  screenForceFullDisplay: boolean;
+  host: P | null;
+  hostStream: any;
+  adminOnMainScreen: boolean;
+  mainScreenPerson: string;
+}
+
+export interface ResolveMainHostRenderModeOptions {
+  islevel: string;
+  localUIMode: boolean;
+  videoAlreadyOn: boolean;
+  audioAlreadyOn: boolean;
+  hostVideoOn: boolean;
+  hostMuted?: boolean;
+}
+
+export type MainHostRenderMode = 'adminVideo' | 'audio' | 'mini' | 'video';
+
+export interface ResolveHostVideoStreamOptions<TStreamLike = PrepopulateStreamLike> {
+  islevel: string;
+  keepBackground: boolean;
+  virtualStream: any;
+  localStreamVideo: any;
+  oldAllStreams: TStreamLike[];
+  hostVideoID?: string;
+}
+
+export interface BuildMainScreenStateOptions {
+  filled: boolean;
+  adminOnMainScreen: boolean;
+  mainScreenPerson: string;
+}
+
+export interface MainScreenState {
+  filled: boolean;
+  adminOnMainScreen: boolean;
+  mainScreenPerson: string;
+}
+
+export interface BuildMainHostCardPlanOptions<TStreamLike = PrepopulateStreamLike> {
+  islevel: string;
+  localUIMode: boolean;
+  videoAlreadyOn: boolean;
+  audioAlreadyOn: boolean;
+  hostVideoOn: boolean;
+  hostMuted?: boolean;
+  hostIsAdmin: boolean;
+  hostName: string;
+  hostVideoID?: string;
+  fallbackName: string;
+  member: string;
+  keepBackground: boolean;
+  virtualStream: any;
+  localStreamVideo: any;
+  oldAllStreams: TStreamLike[];
+}
+
+export interface MainHostCardPlan {
+  kind: 'video' | 'audio' | 'mini';
+  key: string;
+  name: string;
+  initials?: string;
+  remoteProducerId?: string;
+  videoStream?: any;
+  doMirror?: boolean;
+  state: MainScreenState;
+}
+
+export interface BuildScreenShareHostCardPlanOptions {
+  hostName: string;
+  hostScreenID?: string;
+  hostIsAdmin: boolean;
+  shared: boolean;
+  hostStream: any;
+  screenForceFullDisplay: boolean;
+  annotateScreenStream: boolean;
+}
+
+export interface ScreenShareHostCardPlan {
+  key: string;
+  name: string;
+  remoteProducerId: string;
+  videoStream: any;
+  forceFullDisplay: boolean;
+  doMirror: false;
+  state: MainScreenState;
+}
+
+/**
+ * Pure helper for resolving which non-screen-share host card mode should render.
+ */
+export function resolveMainHostRenderMode({
+  islevel,
+  localUIMode,
+  videoAlreadyOn,
+  audioAlreadyOn,
+  hostVideoOn,
+  hostMuted,
+}: ResolveMainHostRenderModeOptions): MainHostRenderMode {
+  const hostVideoOffPath =
+    (islevel !== '2' && !hostVideoOn)
+    || (islevel === '2' && (!hostVideoOn || !videoAlreadyOn))
+    || localUIMode === true;
+
+  if (!hostVideoOffPath) {
+    return 'video';
+  }
+
+  if (islevel === '2' && videoAlreadyOn) {
+    return 'adminVideo';
+  }
+
+  const audOn =
+    (islevel === '2' && audioAlreadyOn)
+    || (islevel !== '2' && hostMuted === false);
+
+  return audOn ? 'audio' : 'mini';
+}
+
+/**
+ * Resolves the correct host video stream source for non-screen-share rendering.
+ */
+export function resolveHostVideoStream<TStreamLike extends PrepopulateStreamLike = PrepopulateStreamLike>({
+  islevel,
+  keepBackground,
+  virtualStream,
+  localStreamVideo,
+  oldAllStreams,
+  hostVideoID,
+}: ResolveHostVideoStreamOptions<TStreamLike>): any {
+  if (islevel === '2') {
+    return keepBackground && virtualStream ? virtualStream : localStreamVideo;
+  }
+
+  const safeOldStreams = Array.isArray(oldAllStreams) ? oldAllStreams : [];
+  const matched = safeOldStreams.find((stream) => stream.producerId === hostVideoID);
+  return matched?.stream ?? null;
+}
+
+/**
+ * Pure helper for normalizing main-screen state updates.
+ */
+export function buildMainScreenState({
+  filled,
+  adminOnMainScreen,
+  mainScreenPerson,
+}: BuildMainScreenStateOptions): MainScreenState {
+  return {
+    filled,
+    adminOnMainScreen,
+    mainScreenPerson,
+  };
+}
+
+/**
+ * Pure helper for resolving the non-screen-share host card to render on the main screen.
+ */
+export function buildMainHostCardPlan<TStreamLike extends PrepopulateStreamLike = PrepopulateStreamLike>({
+  islevel,
+  localUIMode,
+  videoAlreadyOn,
+  audioAlreadyOn,
+  hostVideoOn,
+  hostMuted,
+  hostIsAdmin,
+  hostName,
+  hostVideoID,
+  fallbackName,
+  member,
+  keepBackground,
+  virtualStream,
+  localStreamVideo,
+  oldAllStreams,
+}: BuildMainHostCardPlanOptions<TStreamLike>): MainHostCardPlan {
+  const mode = resolveMainHostRenderMode({
+    islevel,
+    localUIMode,
+    videoAlreadyOn,
+    audioAlreadyOn,
+    hostVideoOn,
+    hostMuted,
+  });
+
+  if (mode === 'adminVideo') {
+    return {
+      kind: 'video',
+      key: hostVideoID || hostName || 'host-video',
+      name: hostName,
+      remoteProducerId: hostVideoID || '',
+      videoStream: keepBackground && virtualStream ? virtualStream : localStreamVideo,
+      doMirror: true,
+      state: buildMainScreenState({
+        filled: true,
+        adminOnMainScreen: true,
+        mainScreenPerson: hostName,
+      }),
+    };
+  }
+
+  if (mode === 'audio') {
+    return {
+      kind: 'audio',
+      key: hostName || fallbackName,
+      name: hostName,
+      state: buildMainScreenState({
+        filled: true,
+        adminOnMainScreen: islevel === '2',
+        mainScreenPerson: hostName,
+      }),
+    };
+  }
+
+  if (mode === 'mini') {
+    return {
+      kind: 'mini',
+      key: fallbackName,
+      name: hostName,
+      initials: fallbackName,
+      state: buildMainScreenState({
+        filled: false,
+        adminOnMainScreen: islevel === '2',
+        mainScreenPerson: hostName,
+      }),
+    };
+  }
+
+  const hostStream = resolveHostVideoStream({
+    islevel,
+    keepBackground,
+    virtualStream,
+    localStreamVideo,
+    oldAllStreams,
+    hostVideoID,
+  });
+
+  if (!hostStream) {
+    return {
+      kind: 'mini',
+      key: fallbackName,
+      name: hostName,
+      initials: fallbackName,
+      state: buildMainScreenState({
+        filled: false,
+        adminOnMainScreen: islevel === '2',
+        mainScreenPerson: hostName,
+      }),
+    };
+  }
+
+  return {
+    kind: 'video',
+    key: hostVideoID || hostName || 'host-video',
+    name: hostName,
+    remoteProducerId: hostVideoID || '',
+    videoStream: hostStream,
+    doMirror: member === hostName,
+    state: buildMainScreenState({
+      filled: true,
+      adminOnMainScreen: hostIsAdmin,
+      mainScreenPerson: hostName,
+    }),
+  };
+}
+
+/**
+ * Pure helper for resolving the screen-share host card to render on the main screen.
+ */
+export function buildScreenShareHostCardPlan({
+  hostName,
+  hostScreenID,
+  hostIsAdmin,
+  shared,
+  hostStream,
+  screenForceFullDisplay,
+  annotateScreenStream,
+}: BuildScreenShareHostCardPlanOptions): ScreenShareHostCardPlan {
+  return {
+    key: hostScreenID || hostName || 'host-screen',
+    name: hostName,
+    remoteProducerId: hostScreenID || '',
+    videoStream: shared ? hostStream : hostStream?.stream ?? null,
+    forceFullDisplay: annotateScreenStream && shared ? false : screenForceFullDisplay,
+    doMirror: false,
+    state: buildMainScreenState({
+      filled: true,
+      adminOnMainScreen: hostIsAdmin,
+      mainScreenPerson: hostName,
+    }),
+  };
+}
+
+/**
+ * Pure planning engine for prepopulateUserMedia host/screen-flow resolution.
+ * Returns deterministic state decisions without rendering concerns.
+ */
+export function buildPrepopulateUserMediaPlan<
+  P extends PrepopulateParticipantLike,
+  S extends PrepopulateStreamLike,
+>({
+  participants,
+  allVideoStreams,
+  member,
+  shared,
+  shareScreenStarted,
+  eventType,
+  screenId,
+  whiteboardStarted,
+  whiteboardEnded,
+  remoteScreenStream,
+  localStreamScreen,
+  checkOrientation,
+  isWideScreen,
+  forceFullDisplay,
+  includeWhiteboardAsScreenFlow = false,
+}: BuildPrepopulateUserMediaPlanOptions<P, S>): PrepopulateUserMediaPlan<P> {
+  const safeParticipants = Array.isArray(participants) ? participants : [];
+  const safeVideoStreams = Array.isArray(allVideoStreams) ? allVideoStreams : [];
+  const safeRemoteScreenStreams = Array.isArray(remoteScreenStream) ? remoteScreenStream : [];
+
+  const whiteboardActive = whiteboardStarted && !whiteboardEnded;
+  const screenFlowActive =
+    shareScreenStarted || shared || (includeWhiteboardAsScreenFlow && whiteboardActive);
+
+  let screenForceFullDisplay = forceFullDisplay;
+  const orientation = checkOrientation();
+  if ((orientation === 'portrait' || !isWideScreen) && (shareScreenStarted || shared)) {
+    screenForceFullDisplay = false;
+  }
+
+  if (!screenFlowActive) {
+    if (eventType === 'conference') {
+      return {
+        screenFlowActive,
+        shouldReturnEarly: true,
+        shouldUpdateAdminOnMainScreen: false,
+        screenForceFullDisplay,
+        host: null,
+        hostStream: null,
+        adminOnMainScreen: false,
+        mainScreenPerson: '',
+      };
+    }
+
+    const host = safeParticipants.find((participant) => participant.islevel === '2') ?? null;
+
+    return {
+      screenFlowActive,
+      shouldReturnEarly: false,
+      shouldUpdateAdminOnMainScreen: false,
+      screenForceFullDisplay,
+      host,
+      hostStream: null,
+      adminOnMainScreen: false,
+      mainScreenPerson: host?.name ?? '',
+    };
+  }
+
+  let host: P | null = null;
+  let hostStream: any = null;
+
+  if (shared) {
+    host = { name: member, audioID: '', videoID: '' } as unknown as P;
+    hostStream = localStreamScreen;
+  } else {
+    host =
+      safeParticipants.find(
+        (participant) => participant.ScreenID === screenId && participant.ScreenOn === true,
+      ) ?? null;
+
+    if (whiteboardActive) {
+      host = {
+        name: 'WhiteboardActive',
+        islevel: '2',
+        audioID: '',
+        videoID: '',
+      } as unknown as P;
+      hostStream = { producerId: 'WhiteboardActive' };
+    }
+
+    if (host === null) {
+      host = safeParticipants.find((participant) => participant.ScreenOn === true) ?? null;
+    }
+
+    if (host && !String(host.name ?? '').includes('WhiteboardActive')) {
+      if (safeRemoteScreenStreams.length === 0) {
+        hostStream =
+          safeVideoStreams.find((stream) => stream.producerId === host?.ScreenID) ?? null;
+      } else {
+        hostStream = safeRemoteScreenStreams[0];
+      }
+    }
+  }
+
+  return {
+    screenFlowActive,
+    shouldReturnEarly: false,
+    shouldUpdateAdminOnMainScreen: true,
+    screenForceFullDisplay,
+    host,
+    hostStream,
+    adminOnMainScreen: (host && host.islevel === '2') ?? false,
+    mainScreenPerson: host?.name ?? '',
+  };
+}