mediasfu-shared 1.0.1 → 1.0.2

package/src/consumers/socketReceiveMethods/newPipeProducer.ts

@@ -2,6 +2,14 @@ import { Socket } from 'socket.io-client';
 import { signalNewConsumerTransport } from '../signalNewConsumerTransport';
 import { ReorderStreamsParameters, ReorderStreamsType, SignalNewConsumerTransportParameters, ConnectRecvTransportParameters, ConnectRecvTransportType, ShowAlert } from '../../types/types';
 import type { Device } from 'mediasoup-client/lib/types';
+
+export interface TranslationMeta {
+  speakerId: string;
+  speakerName: string;
+  language: string;
+  originalProducerId?: string;
+  isSpeakerControlled?: boolean;
+}
 export interface NewPipeProducerParameters extends ReorderStreamsParameters, SignalNewConsumerTransportParameters, ConnectRecvTransportParameters {
 
   first_round: boolean;
@@ -21,6 +29,15 @@ export interface NewPipeProducerParameters extends ReorderStreamsParameters, Sig
   connectRecvTransport: ConnectRecvTransportType;
   reorderStreams: ReorderStreamsType;
   getUpdatedAllParams: () => NewPipeProducerParameters;
+
+  startConsumingTranslation?: (producerId: string, speakerId: string, language: string, originalProducerId?: string, nsock?: Socket) => Promise<void>;
+  translationSubscriptions?: Map<string, { speakerId: string; language: string }>;
+  speakerTranslationStates?: Map<string, { speakerId: string; speakerName: string; inputLanguage: string; outputLanguage: string; originalProducerId: string; enabled: boolean }>;
+  listenerTranslationOverrides?: Map<string, { speakerId: string; wantOriginal: boolean; preferredLanguage?: string }>;
+  listenerTranslationPreferences?: {
+    perSpeaker: Map<string, { speakerId: string; language: string | null; wantOriginal: boolean }>;
+    globalLanguage: string | null;
+  };
   [key: string]: any;
 
 }
@@ -30,6 +47,8 @@ export interface NewPipeProducerOptions {
   islevel: string;
   nsock: Socket;
   parameters: NewPipeProducerParameters;
+  isTranslation?: boolean;
+  translationMeta?: TranslationMeta;
 }
 
 // Export the type definition for the function
@@ -96,7 +115,102 @@ export const newPipeProducer = async ({
   islevel,
   nsock,
   parameters,
+  isTranslation,
+  translationMeta,
 }: NewPipeProducerOptions): Promise<void> => {
+  if (isTranslation && translationMeta) {
+    const freshParams = parameters.getUpdatedAllParams ? parameters.getUpdatedAllParams() : parameters;
+
+    const {
+      startConsumingTranslation,
+      translationSubscriptions,
+      speakerTranslationStates,
+      listenerTranslationOverrides,
+      listenerTranslationPreferences,
+    } = freshParams;
+
+    const normalizedLang = translationMeta.language?.toLowerCase();
+    const isSpeakerControlledFromMeta = translationMeta.isSpeakerControlled === true;
+    const speakerState = speakerTranslationStates?.get(translationMeta.speakerId);
+    const isSpeakerControlledFromState = speakerState?.enabled
+      && speakerState?.outputLanguage?.toLowerCase() === normalizedLang;
+    const shouldSkipBecauseWrongLanguage = isSpeakerControlledFromMeta
+      && speakerState?.enabled
+      && speakerState?.outputLanguage?.toLowerCase() !== normalizedLang;
+
+    const subscriptionKey = `${translationMeta.speakerId}_${normalizedLang}`;
+    const isListenerSubscribed = translationSubscriptions?.has(subscriptionKey)
+      || translationSubscriptions?.has(translationMeta.speakerId);
+
+    let overrideBlocksConsumption = false;
+    let shouldConsumeForOverride = false;
+    let shouldConsumeForGlobal = false;
+
+    const perSpeakerPref = listenerTranslationPreferences?.perSpeaker?.get(translationMeta.speakerId);
+    const globalPref = listenerTranslationPreferences?.globalLanguage;
+    const listenerOverride = listenerTranslationOverrides?.get(translationMeta.speakerId);
+
+    if (perSpeakerPref) {
+      if (perSpeakerPref.wantOriginal) {
+        overrideBlocksConsumption = true;
+      } else if (perSpeakerPref.language) {
+        if (perSpeakerPref.language === normalizedLang) {
+          shouldConsumeForOverride = true;
+        } else {
+          overrideBlocksConsumption = true;
+        }
+      }
+    } else if (globalPref) {
+      if (globalPref === normalizedLang) {
+        shouldConsumeForGlobal = true;
+      } else {
+        overrideBlocksConsumption = true;
+      }
+    } else if (listenerOverride) {
+      if (listenerOverride.wantOriginal) {
+        overrideBlocksConsumption = true;
+      } else if (listenerOverride.preferredLanguage) {
+        if (listenerOverride.preferredLanguage.toLowerCase() === normalizedLang) {
+          shouldConsumeForOverride = true;
+        } else {
+          overrideBlocksConsumption = true;
+        }
+      }
+    }
+
+    const shouldConsumeForSpeakerControlled =
+      isSpeakerControlledFromMeta
+      && (!speakerState?.enabled || speakerState?.outputLanguage?.toLowerCase() === normalizedLang);
+    const hasNoPreference = !perSpeakerPref && !globalPref && !listenerOverride;
+    const isListenerInitiated = !isSpeakerControlledFromMeta && !isSpeakerControlledFromState;
+    const blockBecauseNotRelevant = hasNoPreference && isListenerInitiated && !isListenerSubscribed;
+
+    const shouldConsume =
+      !overrideBlocksConsumption
+      && !shouldSkipBecauseWrongLanguage
+      && !blockBecauseNotRelevant
+      && (shouldConsumeForOverride
+        || shouldConsumeForGlobal
+        || shouldConsumeForSpeakerControlled
+        || isSpeakerControlledFromState
+        || isListenerSubscribed);
+
+    if (shouldConsume && startConsumingTranslation) {
+      try {
+        await startConsumingTranslation(
+          producerId,
+          translationMeta.speakerId,
+          translationMeta.language,
+          translationMeta.originalProducerId,
+          nsock,
+        );
+      } catch {
+      }
+    }
+
+    return;
+  }
+
   const {
     shareScreenStarted,
     shared,

package/src/consumers/socketReceiveMethods/producerClosed.ts

@@ -63,6 +63,19 @@ export const producerClosed = async ({
 }: ProducerClosedOptions): Promise<void> => {
   let { consumerTransports, closeAndResize, screenId, updateConsumerTransports } = parameters;
 
+  const activeTranslationProducerIds = parameters.activeTranslationProducerIds;
+  const isTranslationProducer = activeTranslationProducerIds?.has?.(remoteProducerId);
+
+  if (isTranslationProducer) {
+    activeTranslationProducerIds?.delete?.(remoteProducerId);
+
+    const removeTranslationStream = parameters.removeTranslationStream as ((producerId: string) => void) | undefined;
+
+    if (removeTranslationStream) {
+      removeTranslationStream(remoteProducerId);
+    }
+  }
+
   // Handle producer closed
   const producerToClose = consumerTransports.find(
     (transportData: any) => transportData.producerId === remoteProducerId

package/src/consumers/streamSuccessScreen.ts

@@ -3,11 +3,11 @@
 import { Socket } from "socket.io-client";
 import {
   SleepType, CreateSendTransportType, ConnectSendTransportScreenType, DisconnectSendTransportScreenType, StopShareScreenType, ReorderStreamsType, PrepopulateUserMediaType, RePortType,
-  ShowAlert, CreateSendTransportParameters, ConnectSendTransportScreenParameters, DisconnectSendTransportScreenParameters, StopShareScreenParameters, ReorderStreamsParameters, PrepopulateUserMediaParameters,
+  ShowAlert, CreateSendTransportParameters, ConnectSendTransportScreenParameters, DisconnectSendTransportScreenParameters, StopShareScreenParameters, ReorderStreamsParameters, PrepopulateUserMediaParameters, RePortParameters,
   EventType
 } from "../types/types";
 
-export interface StreamSuccessScreenParameters extends CreateSendTransportParameters, ConnectSendTransportScreenParameters, DisconnectSendTransportScreenParameters, StopShareScreenParameters, ReorderStreamsParameters, PrepopulateUserMediaParameters {
+export interface StreamSuccessScreenParameters extends CreateSendTransportParameters, ConnectSendTransportScreenParameters, DisconnectSendTransportScreenParameters, StopShareScreenParameters, ReorderStreamsParameters, PrepopulateUserMediaParameters, RePortParameters {
   socket: Socket;
   transportCreated: boolean;
   localStreamScreen: MediaStream | null;

package/src/consumers/streamSuccessVideo.ts

@@ -30,6 +30,7 @@ export interface StreamSuccessVideoParameters extends CreateSendTransportParamet
   keepBackground: boolean;
   appliedBackground: boolean;
   videoProducer: Producer | null;
+  removeSingleVideoEncoding?: boolean;
 
   // Update functions
   updateTransportCreatedVideo: (created: boolean) => void;
@@ -275,6 +276,10 @@ export const streamSuccessVideo = async ({
         (codec: RtpCodecCapability) => codec.mimeType.toLowerCase() !== "video/vp9" && codec.kind === "video"
       ) || [];
 
+      if (parameters.removeSingleVideoEncoding && videoParamse.encodings && videoParamse.encodings.length <= 1) {
+        delete videoParamse.encodings;
+      }
+
       videoParams = {
         track: localStream.getVideoTracks()[0],
         ...videoParamse,

package/src/consumers/translationConsumerSwitch.ts

@@ -0,0 +1,299 @@
+import { BreakoutParticipant, EventType, Participant, Transport } from '../types/types';
+
+export interface TranslationConsumerSwitchParameters {
+  consumerTransports: Transport[];
+  roomName: string;
+  member: string;
+  updateConsumerTransports: (transports: Transport[]) => void;
+  breakOutRoomStarted?: boolean;
+  breakOutRoomEnded?: boolean;
+  breakoutRooms?: BreakoutParticipant[][];
+  limitedBreakRoom?: BreakoutParticipant[];
+  participants?: Participant[];
+  ref_participants?: Participant[];
+  islevel?: string;
+  eventType?: EventType;
+  hostNewRoom?: number;
+  [key: string]: any;
+}
+
+export interface PauseOriginalProducerOptions {
+  originalProducerId: string;
+  speakerId?: string;
+  parameters: TranslationConsumerSwitchParameters;
+}
+
+export interface ResumeOriginalProducerOptions {
+  originalProducerId: string;
+  speakerId?: string;
+  parameters: TranslationConsumerSwitchParameters;
+}
+
+export type PauseOriginalProducerType = (options: PauseOriginalProducerOptions) => Promise<void>;
+export type ResumeOriginalProducerType = (options: ResumeOriginalProducerOptions) => Promise<void>;
+
+export interface StopConsumingTranslationOptions {
+  speakerId?: string;
+  language: string;
+  translationProducerMap: Record<string, Record<string, string>>;
+  parameters: TranslationConsumerSwitchParameters;
+}
+
+export type StopConsumingTranslationType = (options: StopConsumingTranslationOptions) => Promise<string | null>;
+
+export const isSpeakerInMyBreakoutRoom = (
+  speakerName: string,
+  parameters: TranslationConsumerSwitchParameters
+): boolean => {
+  const {
+    breakOutRoomStarted = false,
+    breakOutRoomEnded = false,
+    limitedBreakRoom = [],
+    participants = [],
+    islevel = '1',
+    eventType = 'conference',
+    hostNewRoom = -1,
+    breakoutRooms = [],
+    member = '',
+  } = parameters;
+
+  if (!breakOutRoomStarted || breakOutRoomEnded) {
+    return true;
+  }
+
+  const host = participants.find((p) => p.islevel === '2');
+  const speakerIsHost = host?.name === speakerName;
+
+  if (islevel !== '2') {
+    if (eventType === 'webinar' && speakerIsHost) {
+      return true;
+    }
+
+    if (eventType === 'conference' && speakerIsHost) {
+      const roomMember = breakoutRooms.find((r) =>
+        r.find((p) => p.name === member)
+      );
+      const memberBreakRoom = roomMember ? breakoutRooms.indexOf(roomMember) : -1;
+      const inBreakRoom = memberBreakRoom !== -1;
+
+      if (inBreakRoom) {
+        return memberBreakRoom === hostNewRoom;
+      }
+
+      if (hostNewRoom === -1) {
+        return true;
+      }
+
+      return hostNewRoom === memberBreakRoom && memberBreakRoom !== -1;
+    }
+  }
+
+  return limitedBreakRoom.some((p) => p.name === speakerName);
+};
+
+export const pauseOriginalProducer = async ({
+  originalProducerId,
+  speakerId,
+  parameters,
+}: PauseOriginalProducerOptions): Promise<void> => {
+  try {
+    const { consumerTransports } = parameters;
+
+    if (speakerId && !isSpeakerInMyBreakoutRoom(speakerId, parameters)) {
+      return;
+    }
+
+    const transport = consumerTransports.find(
+      (t) => t.producerId === originalProducerId && t.consumer?.kind === 'audio'
+    );
+
+    if (transport && transport.consumer && !transport.consumer.paused) {
+      transport.consumer.pause();
+
+      transport.socket_?.emit(
+        'consumer-pause',
+        { serverConsumerId: transport.serverConsumerTransportId },
+        async () => {}
+      );
+    }
+  } catch (error) {
+    console.error('[TranslationSwitch] Error pausing original producer:', error);
+  }
+};
+
+export const resumeOriginalProducer = async ({
+  originalProducerId,
+  speakerId,
+  parameters,
+}: ResumeOriginalProducerOptions): Promise<void> => {
+  try {
+    const { consumerTransports } = parameters;
+
+    if (speakerId && !isSpeakerInMyBreakoutRoom(speakerId, parameters)) {
+      return;
+    }
+
+    const transport = consumerTransports.find(
+      (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();
+          }
+        }
+      );
+    }
+  } catch (error) {
+    console.error('[TranslationSwitch] Error resuming original producer:', error);
+  }
+};
+
+export const isConsumingTranslationForSpeaker = (
+  speakerId: string,
+  consumerTransports: Transport[],
+  translationProducerMap: Map<string, { translationProducerId: string; originalProducerId: string; language: string }>
+): { consuming: boolean; language?: string; translationProducerId?: string; originalProducerId?: string } => {
+  const translationInfo = translationProducerMap.get(speakerId);
+
+  if (translationInfo) {
+    const hasConsumer = consumerTransports.some(
+      (t) => t.producerId === translationInfo.translationProducerId
+    );
+
+    if (hasConsumer) {
+      return {
+        consuming: true,
+        language: translationInfo.language,
+        translationProducerId: translationInfo.translationProducerId,
+        originalProducerId: translationInfo.originalProducerId,
+      };
+    }
+  }
+
+  return { consuming: false };
+};
+
+export const getActiveTranslationConsumers = (
+  translationProducerMap: Map<string, { translationProducerId: string; originalProducerId: string; language: string }>,
+  consumerTransports: Transport[]
+): Array<{ speakerId: string; translationProducerId: string; originalProducerId: string; language: string }> => {
+  const results: Array<{ speakerId: string; translationProducerId: string; originalProducerId: string; language: string }> = [];
+
+  translationProducerMap.forEach((info, speakerId) => {
+    const hasConsumer = consumerTransports.some(
+      (t) => t.producerId === info.translationProducerId
+    );
+
+    if (hasConsumer) {
+      results.push({
+        speakerId,
+        ...info,
+      });
+    }
+  });
+
+  return results;
+};
+
+export const findOriginalProducerForSpeaker = (
+  speakerId: string,
+  allAudioStreams: Array<{ producerId: string; name?: string; [key: string]: any }>
+): string | null => {
+  const stream = allAudioStreams.find(
+    (s) => s.name === speakerId || s.producerId?.includes(speakerId)
+  );
+  return stream?.producerId || null;
+};
+
+export const stopConsumingTranslation = async (options: StopConsumingTranslationOptions): Promise<string | null> => {
+  const { language, translationProducerMap, parameters } = options;
+  try {
+    const { consumerTransports, updateConsumerTransports } = parameters;
+
+    let originalProducerId: string | null = null;
+    let translationProducerId: string | null = null;
+
+    for (const [origId, langMap] of Object.entries(translationProducerMap)) {
+      if (langMap && langMap[language]) {
+        translationProducerId = langMap[language];
+        originalProducerId = origId;
+        break;
+      }
+    }
+
+    if (!translationProducerId) {
+      return originalProducerId;
+    }
+
+    const transportIndex = consumerTransports.findIndex(
+      (t) => t.producerId === translationProducerId
+    );
+
+    if (transportIndex === -1) {
+      return originalProducerId;
+    }
+
+    const transport = consumerTransports[transportIndex];
+
+    if (transport.socket_ && transport.consumer) {
+      transport.socket_.emit(
+        'consumer-close',
+        { serverConsumerId: transport.serverConsumerTransportId },
+        () => {}
+      );
+    }
+
+    if (transport.consumer) {
+      transport.consumer.close();
+    }
+
+    const updatedTransports = consumerTransports.filter((_, i) => i !== transportIndex);
+    updateConsumerTransports(updatedTransports);
+
+    return originalProducerId;
+  } catch (error) {
+    console.error('[TranslationSwitch] Error stopping translation consumer:', error);
+    return null;
+  }
+};
+
+export const syncTranslationStateAfterBreakoutChange = async (
+  translationProducerMap: Record<string, Record<string, string>>,
+  speakerIdByProducerId: Record<string, string>,
+  parameters: TranslationConsumerSwitchParameters
+): Promise<void> => {
+  try {
+    const { consumerTransports } = parameters;
+
+    for (const [originalProducerId, langMap] of Object.entries(translationProducerMap)) {
+      const speakerId = speakerIdByProducerId[originalProducerId];
+      if (!speakerId) continue;
+
+      const inMyRoom = isSpeakerInMyBreakoutRoom(speakerId, parameters);
+      const hasTranslation = Object.keys(langMap).length > 0;
+
+      const originalConsumer = consumerTransports.find(
+        (t) => t.producerId === originalProducerId && t.consumer?.kind === 'audio'
+      );
+
+      if (!originalConsumer) continue;
+
+      if (inMyRoom && hasTranslation) {
+        if (!originalConsumer.consumer.paused) {
+          await pauseOriginalProducer({
+            originalProducerId,
+            speakerId,
+            parameters,
+          });
+        }
+      }
+    }
+  } catch (error) {
+    console.error('[TranslationSwitch] Error syncing translation state:', error);
+  }
+};

package/src/index.ts

@@ -11,11 +11,14 @@ export * from './consumers/checkScreenShare';
 export * from './consumers/closeAndResize';
 export * from './consumers/compareActiveNames';
 export * from './consumers/compareScreenStates';
+export * from './consumers/gridLayout/addVideosGrid.engine';
+export * from './consumers/gridLayout/prepopulateUserMedia.engine';
 export * from './consumers/connectIps';
 export * from './consumers/connectLocalIps';
 export * from './consumers/connectRecvTransport';
 export * from './consumers/connectSendTransport';
 export * from './consumers/connectSendTransportAudio';
+export * from './consumers/consumerResume';
 export * from './consumers/connectSendTransportScreen';
 export * from './consumers/connectSendTransportVideo';
 export * from './consumers/controlMedia';
@@ -56,6 +59,7 @@ export * from './consumers/streamSuccessVideo';
 export * from './consumers/switchUserAudio';
 export * from './consumers/switchUserVideo';
 export * from './consumers/switchUserVideoAlt';
+export * from './consumers/translationConsumerSwitch';
 export * from './consumers/trigger';
 export * from './consumers/updateMiniCardsGrid';
 export * from './consumers/updateParticipantAudioDecibels';
@@ -79,10 +83,17 @@ export * from './methods/participants/launchParticipants';
 export * from './methods/participants/messageParticipants';
 export * from './methods/participants/muteParticipants';
 export * from './methods/participants/removeParticipants';
+export * from './methods/panelists/launchPanelists';
+export * from './methods/panelists/updatePanelists';
+export * from './methods/panelists/focusPanelists';
+export * from './methods/permissions/launchPermissions';
+export * from './methods/permissions/updateParticipantPermission';
+export * from './methods/permissions/updatePermissionConfig';
 export * from './methods/polls/handleCreatePoll';
 export * from './methods/polls/handleEndPoll';
 export * from './methods/polls/handleVotePoll';
 export * from './methods/polls/launchPoll';
+export * from './methods/polls/pollUpdated';
 export * from './methods/prejoin/handleCreateRoom';
 export * from './methods/prejoin/handleJoinRoom';
 export * from './methods/recording/checkPauseState';
@@ -95,24 +106,97 @@ export * from './methods/recording/recordStartTimer';
 export * from './methods/recording/recordUpdateTimer';
 export * from './methods/recording/startRecording';
 export * from './methods/recording/stopRecording';
+export * from './methods/recording/timeLeftRecording';
 export * from './methods/recording/updateRecording';
 export * from './methods/requests/launchRequests';
+export * from './methods/requests/hostRequestResponse';
 export * from './methods/requests/respondToRequests';
 export * from './methods/settings/launchSettings';
 export * from './methods/settings/modifySettings';
 export * from './methods/stream/switchAudio';
 export * from './methods/stream/switchVideo';
 export * from './methods/stream/switchVideoAlt';
+export * from './methods/stream/clickAudio';
+export * from './methods/stream/clickChat';
+export * from './methods/stream/clickScreenShare';
+export * from './methods/utils/liveSubtitle';
+export * from './methods/utils/translationLanguages';
+export * from './methods/utils/SoundPlayer';
+export * from './methods/utils/getOverlayPosition';
+export * from './methods/utils/getModalPosition';
+export * from './methods/utils/sleep';
+export * from './methods/utils/formatNumber';
+export * from './methods/utils/generateRandomMessages';
+export * from './methods/utils/generateRandomParticipants';
+export * from './methods/utils/generateRandomPolls';
+export * from './methods/utils/generateRandomRequestList';
+export * from './methods/utils/generateRandomWaitingRoomList';
+export * from './methods/utils/initialValuesState';
+export * from './methods/utils/webrtc';
+export * from './methods/utils/checkLimitsAndMakeRequest';
+export * from './methods/utils/createResponseJoinRoom';
+export * from './methods/utils/joinRoomOnMediaSFU';
+export * from './methods/utils/createRoomOnMediaSFU';
+export * from './methods/utils/meetingTimer/startMeetingProgressTimer';
+export * from './methods/utils/meetingTimeRemaining';
+export * from './methods/utils/producer/aParams';
+export * from './methods/utils/producer/hParams';
+export * from './methods/utils/producer/vParams';
+export * from './methods/utils/producer/screenParams';
+export * from './methods/utils/producer/videoCaptureConstraints';
+export * from './methods/utils/validateAlphanumeric';
+export * from './methods/socketReceive/allWaitingRoomMembers';
+export * from './methods/socketReceive/allMembers';
+export * from './methods/socketReceive/allMembersRest';
+export * from './methods/socketReceive/banParticipant';
+export * from './methods/socketReceive/controlMediaHost';
+export * from './methods/socketReceive/disconnect';
+export * from './methods/socketReceive/disconnectUserSelf';
+export * from './methods/socketReceive/getDomains';
+export * from './methods/socketReceive/meetingEnded';
+export * from './methods/socketReceive/meetingStillThere';
+export * from './methods/socketReceive/panelistReceiveMethods';
+export * from './methods/socketReceive/participantRequested';
+export * from './methods/socketReceive/permissionReceiveMethods';
+export * from './methods/socketReceive/personJoined';
+export * from './methods/socketReceive/producerMediaClosed';
+export * from './methods/socketReceive/producerMediaPaused';
+export * from './methods/socketReceive/producerMediaResumed';
+export * from './methods/socketReceive/receiveMessage';
+export * from './methods/socketReceive/recordingNotice';
+export * from './methods/socketReceive/reInitiateRecording';
+export * from './methods/socketReceive/roomRecordParams';
+export * from './methods/socketReceive/screenProducerId';
+export * from './methods/socketReceive/startRecords';
+export * from './methods/socketReceive/stoppedRecording';
+export * from './methods/socketReceive/translationReceiveMethods';
+export * from './methods/socketReceive/updateMediaSettings';
+export * from './methods/socketReceive/updateConsumingDomains';
+export * from './methods/socketReceive/updatedCoHost';
+export * from './methods/socketReceive/userWaiting';
 export * from './methods/waiting/launchWaiting';
 export * from './methods/waiting/respondToWaiting';
-export * from './methods/welcome/handleWelcomeRequest';
+export {
+	handleWelcomeRequest,
+	validateAlphanumeric as validateWelcomeAlphanumeric,
+	validateWelcomeInputs,
+} from './methods/welcome/handleWelcomeRequest';
+export type {
+	HandleWelcomeRequestOptions,
+	ValidateWelcomeInputsOptions,
+} from './methods/welcome/handleWelcomeRequest';
 export * from './methods/whiteboard/handleStartWhiteboard';
 export * from './methods/whiteboard/handleStopWhiteboard';
 export * from './methods/whiteboard/launchConfigureWhiteboard';
+export * from './methods/whiteboard/captureCanvasStream';
 // ProducerClient exports
 export * from './ProducerClient/producerClientEmits/createDeviceClient';
+export * from './ProducerClient/producerClientEmits/joinRoomClient';
+export * from './ProducerClient/producerClientEmits/updateRoomParametersClient';
 // Producers exports
 export * from './producers/producerEmits/joinConRoom';
+export * from './producers/producerEmits/joinLocalRoom';
+export * from './producers/producerEmits/joinRoom';
 // Socket exports
 export * from './sockets/SocketManager';
 // Stream method exports (clickVideo)

package/src/methods/coHostMethods/modifyCoHostSettings.ts

@@ -51,7 +51,7 @@ export type ModifyCoHostSettingsType = (options: ModifyCoHostSettingsOptions) =>
  */
 export const modifyCoHostSettings = async ({
   roomName,
-  showAlert,
+  // showAlert,
   selectedParticipant,
   coHost,
   coHostResponsibility,
@@ -61,15 +61,15 @@ export const modifyCoHostSettings = async ({
   socket,
 }: ModifyCoHostSettingsOptions): Promise<void> => {
   // Check if the chat room is in demo mode
-  if (roomName.toLowerCase().startsWith('d')) {
-    showAlert?.({
-      message: 'You cannot add co-host in demo mode.',
-      type: 'danger',
-      duration: 3000,
-    });
+  // if (roomName.toLowerCase().startsWith('d')) {
+  //   showAlert?.({
+  //     message: 'You cannot add co-host in demo mode.',
+  //     type: 'danger',
+  //     duration: 3000,
+  //   });
 
-    return;
-  }
+  //   return;
+  // }
 
   let newCoHost = coHost;