mediasfu-shared 1.0.2 → 1.0.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mediasfu-shared",
-  "version": "1.0.2",
-  "description": "Framework-agnostic MediaSFU runtime for room creation/join, mediasoup signaling, and shared browser state",
+  "version": "1.0.3",
+  "description": "Framework-agnostic MediaSFU WebRTC runtime for room creation, joining, mediasoup signaling, sockets, media state, translation, and reusable SDK types",
   "main": "dist/index.cjs",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -44,16 +44,27 @@
   "keywords": [
     "mediasfu",
     "webrtc",
+    "webRTC",
     "mediasoup",
-    "socket.io",
+    "sfu",
     "video-conferencing",
+    "video-call",
+    "audio-call",
+    "socket.io",
     "real-time-communication",
+    "real-time-media",
     "room-management",
     "screen-sharing",
     "recording",
+    "live-streaming",
+    "webinar",
+    "broadcasting",
+    "whiteboard",
+    "live-subtitles",
     "translation",
     "framework-agnostic",
-    "typescript"
+    "typescript",
+    "mediasfu-shared"
   ],
   "author": "MediaSFU",
   "license": "MIT",

package/src/consumers/connectIps.ts

@@ -125,13 +125,15 @@ export const connectIps = async ({
           }
 
           // Handle new pipe producer event
-          remote_sock.on("new-pipe-producer", async ({ producerId, islevel }: { producerId: string; islevel: string }) => {
+          remote_sock.on("new-pipe-producer", async ({ producerId, islevel, isTranslation, translationMeta }: { producerId: string; islevel: string; isTranslation?: boolean; translationMeta?: { speakerId: string; speakerName: string; language: string; originalProducerId?: string; isSpeakerControlled?: boolean } }) => {
             if (newProducerMethod) {
               await newProducerMethod({
                 producerId,
                 islevel,
                 nsock: remote_sock,
                 parameters,
+                isTranslation,
+                translationMeta,
               });
             }
           });

package/src/consumers/connectLocalIps.ts

@@ -76,13 +76,15 @@ export const connectLocalIps = async ({
 
     // Connect to the remote socket using socket.io-client
     // Handle new pipe producer event
-    socket.on("new-producer", async ({ producerId, islevel }: { producerId: string; islevel: string }) => {
+    socket.on("new-producer", async ({ producerId, islevel, isTranslation, translationMeta }: { producerId: string; islevel: string; isTranslation?: boolean; translationMeta?: { speakerId: string; speakerName: string; language: string; originalProducerId?: string } }) => {
       if (newProducerMethod) {
         await newProducerMethod({
           producerId,
           islevel,
           nsock: socket,
           parameters,
+          isTranslation,
+          translationMeta,
         });
       }
     });

package/src/consumers/connectRecvTransport.ts

@@ -11,6 +11,74 @@ interface SpeakerTranslationState {
   enabled: boolean;
 }
 
+const getSpeakerNameForProducerId = (
+  producerId: string,
+  parameters: Record<string, any>,
+): string | undefined => {
+  const participants = parameters.participants as Participant[] | 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,
+  parameters: Record<string, any>,
+): boolean => {
+  const activeTranslationProducerIds = parameters.activeTranslationProducerIds as Set<string> | undefined;
+  if (activeTranslationProducerIds?.has(producerId)) {
+    return false;
+  }
+
+  const speakerTranslationStates = parameters.speakerTranslationStates as
+    | Map<string, SpeakerTranslationState>
+    | 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
+    );
+  });
+};
+
 interface Params {
   id: string;
   producerId: string;
@@ -152,28 +220,14 @@ export const connectRecvTransport = async ({
                   if (params.kind === 'audio') {
                     try {
                       const updatedParams = parameters.getUpdatedAllParams();
-                      const speakerTranslationStates = updatedParams.speakerTranslationStates as
-                        | Map<string, SpeakerTranslationState>
-                        | undefined;
-                      const participants = updatedParams.participants as Participant[] | undefined;
-
-                      if (speakerTranslationStates && speakerTranslationStates.size > 0 && participants?.length) {
-                        const participant = participants.find(
-                          (candidate) => candidate.audioID === remoteProducerId,
+                      if (isOriginalAudioSuppressedByTranslation(remoteProducerId, updatedParams)) {
+                        consumer.pause();
+                        nsock.emit(
+                          'consumer-pause',
+                          { serverConsumerId: params.serverConsumerId },
+                          () => {},
                         );
-
-                        if (participant?.name) {
-                          const speakerState = speakerTranslationStates.get(participant.name);
-
-                          if (speakerState?.enabled && speakerState.originalProducerId === remoteProducerId) {
-                            consumer.pause();
-                            nsock.emit(
-                              'consumer-pause',
-                              { serverConsumerId: params.serverConsumerId },
-                              () => {},
-                            );
-                          }
-                        }
+                        return;
                       }
                     } catch {
                     }

package/src/consumers/processConsumerTransportsAudio.ts

@@ -4,6 +4,18 @@ 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;
 };
@@ -30,6 +42,78 @@ interface TransportLike {
   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
@@ -106,6 +190,7 @@ 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"
     );
@@ -116,8 +201,11 @@ export const processConsumerTransportsAudio = async <
         transport.producerId &&
         transport.producerId !== null &&
         transport.producerId !== "" &&
-        !lStreams.some(
-          (stream) => getProducerId(stream) === transport.producerId
+        (
+          isOriginalAudioSuppressedByTranslation(transport.producerId, parameters) ||
+          !lStreams.some(
+            (stream) => getProducerId(stream) === transport.producerId
+          )
         ) &&
         transport.consumer &&
         transport.consumer?.kind &&
@@ -141,6 +229,10 @@ 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 },

package/src/consumers/translationConsumerSwitch.ts

@@ -107,15 +107,25 @@ export const pauseOriginalProducer = async ({
       (t) => t.producerId === originalProducerId && t.consumer?.kind === 'audio'
     );
 
-    if (transport && transport.consumer && !transport.consumer.paused) {
-      transport.consumer.pause();
+    if (!transport?.consumer) {
+      return;
+    }
 
-      transport.socket_?.emit(
-        'consumer-pause',
-        { serverConsumerId: transport.serverConsumerTransportId },
-        async () => {}
-      );
+    if (transport.consumer.track) {
+      transport.consumer.track.enabled = false;
     }
+
+    if (transport.consumer.paused) {
+      return;
+    }
+
+    transport.consumer.pause();
+
+    transport.socket_?.emit(
+      'consumer-pause',
+      { serverConsumerId: transport.serverConsumerTransportId },
+      async () => {}
+    );
   } catch (error) {
     console.error('[TranslationSwitch] Error pausing original producer:', error);
   }
@@ -137,17 +147,29 @@ export const resumeOriginalProducer = async ({
       (t) => t.producerId === originalProducerId && t.consumer?.kind === 'audio'
     );
 
-    if (transport && transport.consumer && transport.consumer.paused) {
-      transport.socket_?.emit(
-        'consumer-resume',
-        { serverConsumerId: transport.serverConsumerTransportId },
-        async ({ resumed }: { resumed: boolean }) => {
-          if (resumed) {
-            transport.consumer.resume();
+    if (!transport?.consumer) {
+      return;
+    }
+
+    if (!transport.consumer.paused) {
+      if (transport.consumer.track) {
+        transport.consumer.track.enabled = true;
+      }
+      return;
+    }
+
+    transport.socket_?.emit(
+      'consumer-resume',
+      { serverConsumerId: transport.serverConsumerTransportId },
+      async ({ resumed }: { resumed: boolean }) => {
+        if (resumed) {
+          if (transport.consumer.track) {
+            transport.consumer.track.enabled = true;
           }
+          transport.consumer.resume();
         }
-      );
-    }
+      }
+    );
   } catch (error) {
     console.error('[TranslationSwitch] Error resuming original producer:', error);
   }

package/src/methods/requests/hostRequestResponse.ts

@@ -51,17 +51,22 @@ export const hostRequestResponse = async ({
   updateChatRequestTime,
   updateRequestIntervalSeconds,
 }: HostRequestResponseOptions): Promise<void> => {
+  const requestType = requestResponse.type ?? requestResponse.icon;
+
+  // Remove only the specific request that received a host response.
   const filteredRequests = requestList.filter(
-    (request) =>
-      request.id !== requestResponse.id &&
-      request.icon !== requestResponse.type &&
-      request.name !== requestResponse.name &&
-      request.username !== requestResponse.username,
+    (request) => {
+      const matchesId = request.id === requestResponse.id;
+      const matchesType = requestType == null || request.icon === requestType;
+      const matchesName = requestResponse.name == null || request.name === requestResponse.name;
+      const matchesUsername =
+        requestResponse.username == null || request.username === requestResponse.username;
+
+      return !(matchesId && matchesType && matchesName && matchesUsername);
+    }
   );
   updateRequestList(filteredRequests);
 
-  const requestType = requestResponse.type;
-
   if (requestResponse.action === 'accepted') {
     switch (requestType) {
       case 'fa-microphone':

package/src/methods/socketReceive/translationReceiveMethods.ts

@@ -164,7 +164,7 @@ export interface TranslationSubscribedOptions {
   data: TranslationSubscribedData;
   updateListenPreferences?: (updater: (prev: Map<string, string>) => Map<string, string>) => void;
   updateTranslationProducerMap?: (updater: (prev: TranslationProducerMap) => TranslationProducerMap) => void;
-  startConsumingTranslation?: (producerId: string, speakerId: string, language: string) => Promise<void>;
+  startConsumingTranslation?: (producerId: string, speakerId: string, language: string, originalProducerId?: string) => Promise<void>;
   showAlert?: ShowAlert;
 }
 
@@ -323,7 +323,7 @@ export const translationSubscribed: TranslationSubscribedType = async ({
     }
 
     if (producerId && startConsumingTranslation) {
-      await startConsumingTranslation(producerId, speakerId, language);
+      await startConsumingTranslation(producerId, speakerId, language, originalProducerId);
     }
 
     if (showAlert && channelCreated) {

package/src/methods/stream/clickVideo.ts

@@ -208,7 +208,12 @@ export const clickVideo = async ({ parameters }: ClickVideoOptions): Promise<voi
     if (!videoAction && islevel !== "2" && !youAreCoHost) {
       response = await checkPermission({
         permissionType: "videoSetting",
-        audioSetting, videoSetting, screenshareSetting, chatSetting,
+        audioSetting,
+        videoSetting,
+        screenshareSetting,
+        chatSetting,
+        permissionConfig: parameters.permissionConfig,
+        participantLevel: islevel,
       });
     } else {
       response = 0;

package/src/methods/utils/resolveMediaSFURoomApi.ts

@@ -2,15 +2,27 @@ const DEFAULT_MEDIA_SFU_ROOM_API_URL = 'https://mediasfu.com/v1/rooms/';
 
 type MediaSFURoomApiAction = 'createRoom' | 'joinRoom';
 
+const normalizeManagedRoomApi = (normalizedLink: string): string => {
+  if (normalizedLink.includes('/v1/rooms')) {
+    return `${normalizedLink.replace(/\/$/, '')}/`;
+  }
+
+  return `${normalizedLink.replace(/\/$/, '')}/v1/rooms/`;
+};
+
 export const resolveMediaSFURoomApi = (
   localLink: string | undefined,
   action: MediaSFURoomApiAction,
 ): string => {
   const normalizedLink = localLink?.trim();
 
-  if (!normalizedLink || normalizedLink.includes('mediasfu.com')) {
+  if (!normalizedLink) {
     return DEFAULT_MEDIA_SFU_ROOM_API_URL;
   }
 
+  if (normalizedLink.includes('mediasfu.com')) {
+    return normalizeManagedRoomApi(normalizedLink);
+  }
+
   return `${normalizedLink.replace(/\/$/, '')}/${action}`;
 };