mediasfu-shared 1.0.1 → 1.0.2

package/src/methods/utils/initialValuesState.ts

@@ -0,0 +1,405 @@
+export const initialValuesState = {
+  // The following are the initial values
+
+  roomName: '',
+  member: '',
+  adminPasscode: '',
+  islevel: '1',
+  coHost: 'No coHost',
+  coHostResponsibility: [
+    { name: 'participants', value: false, dedicated: false },
+    { name: 'media', value: false, dedicated: false },
+    { name: 'waiting', value: false, dedicated: false },
+    { name: 'chat', value: false, dedicated: false },
+  ],
+  youAreCoHost: false,
+  youAreHost: false,
+  confirmedToRecord: false,
+  meetingDisplayType: 'media',
+  meetingVideoOptimized: false,
+  eventType: 'webinar',
+  participants: [],
+  filteredParticipants: [],
+  participantsCounter: 0,
+  participantsFilter: '',
+
+  validated: false,
+  localUIMode: false,
+  socket: {},
+  localSocket: undefined,
+  roomData: null,
+  device: null,
+  apiKey: '',
+  apiUserName: '',
+  apiToken: '',
+  link: '',
+
+  consume_sockets: [],
+  rtpCapabilities: null,
+  roomRecvIPs: [],
+  meetingRoomParams: null,
+  itemPageLimit: 4,
+  audioOnlyRoom: false,
+  addForBasic: false,
+  screenPageLimit: 4,
+  shareScreenStarted: false,
+  shared: false,
+  targetOrientation: 'landscape',
+  targetResolution: 'sd',
+  targetResolutionHost: 'sd',
+  vidCons: { width: 640, height: 360 },
+  frameRate: 10,
+  hParams: {},
+  vParams: {},
+  screenParams: {},
+  aParams: {},
+
+  // Initial Values for New Recording Fields
+  recordingAudioPausesLimit: 0,
+  recordingAudioPausesCount: 0,
+  recordingAudioSupport: false,
+  recordingAudioPeopleLimit: 0,
+  recordingAudioParticipantsTimeLimit: 0,
+  recordingVideoPausesCount: 0,
+  recordingVideoPausesLimit: 0,
+  recordingVideoSupport: false,
+  recordingVideoPeopleLimit: 0,
+  recordingVideoParticipantsTimeLimit: 0,
+  recordingAllParticipantsSupport: false,
+  recordingVideoParticipantsSupport: false,
+  recordingAllParticipantsFullRoomSupport: false,
+  recordingVideoParticipantsFullRoomSupport: false,
+  recordingPreferredOrientation: 'landscape',
+  recordingSupportForOtherOrientation: false,
+  recordingMultiFormatsSupport: false,
+
+  userRecordingParams: {
+    mainSpecs: {
+      mediaOptions: 'video',
+      audioOptions: 'all',
+      videoOptions: 'all',
+      videoType: 'fullDisplay',
+      videoOptimized: false,
+      recordingDisplayType: 'media',
+      addHLS: false,
+    },
+    dispSpecs: {
+      nameTags: true,
+      backgroundColor: '#000000',
+      nameTagsColor: '#ffffff',
+      orientationVideo: 'portrait',
+    },
+  },
+
+  canRecord: false,
+  startReport: false,
+  endReport: false,
+  recordTimerInterval: null,
+  recordStartTime: 0,
+  recordElapsedTime: 0,
+  isTimerRunning: false,
+  canPauseResume: false,
+  recordChangeSeconds: 15000,
+  pauseLimit: 0,
+  pauseRecordCount: 0,
+  canLaunchRecord: true,
+  stopLaunchRecord: false,
+
+  // Room properties
+  participantsAll: [],
+  firstAll: false,
+  updateMainWindow: false,
+  first_round: false,
+  landScaped: false,
+  lock_screen: false,
+  screenId: '',
+  allVideoStreams: [],
+  newLimitedStreams: [],
+  newLimitedStreamsIDs: [],
+  activeSounds: [],
+  screenShareIDStream: '',
+  screenShareNameStream: '',
+  adminIDStream: '',
+  adminNameStream: '',
+  youYouStream: [],
+  youYouStreamIDs: [],
+  localStream: null,
+  recordStarted: false,
+  recordResumed: false,
+  recordPaused: false,
+  recordStopped: false,
+  adminRestrictSetting: false,
+  videoRequestState: null,
+  videoRequestTime: 0,
+  videoAction: false,
+  localStreamVideo: null,
+  userDefaultVideoInputDevice: '',
+  currentFacingMode: 'user',
+  prevFacingMode: 'user',
+  defVideoID: '',
+  allowed: false,
+  dispActiveNames: [],
+  activeNames: [],
+  prevActiveNames: [],
+  p_activeNames: [],
+  p_dispActiveNames: [],
+  membersReceived: false,
+  deferScreenReceived: false,
+  hostFirstSwitch: false,
+  micAction: false,
+  screenAction: false,
+  chatAction: false,
+  audioRequestState: null,
+  screenRequestState: null,
+  chatRequestState: null,
+  audioRequestTime: 0,
+  screenRequestTime: 0,
+  chatRequestTime: 0,
+  updateRequestIntervalSeconds: 240,
+  oldSoundIds: [],
+  hostLabel: 'Host',
+  mainScreenFilled: false,
+  localStreamScreen: null,
+  screenAlreadyOn: false,
+  chatAlreadyOn: false,
+  redirectURL: '',
+  oldAllStreams: [],
+  adminVidID: '',
+  streamNames: [],
+  non_alVideoStreams: [],
+  sortAudioLoudness: false,
+  audioDecibels: [],
+  mixed_alVideoStreams: [],
+  non_alVideoStreams_muted: [],
+  paginatedStreams: [],
+  localStreamAudio: null,
+  defAudioID: '',
+  userDefaultAudioInputDevice: '',
+  userDefaultAudioOutputDevice: '',
+  prevAudioInputDevice: '',
+  prevVideoInputDevice: '',
+  audioPaused: false,
+  mainScreenPerson: '',
+  adminOnMainScreen: false,
+  screenStates: [{
+    mainScreenPerson: '',
+    mainScreenProducerId: '',
+    mainScreenFilled: false,
+    adminOnMainScreen: false,
+  }],
+  prevScreenStates: [{
+    mainScreenPerson: '',
+    mainScreenProducerId: '',
+    mainScreenFilled: false,
+    adminOnMainScreen: false,
+  }],
+  updateDateState: null,
+  lastUpdate: null,
+  nForReadjustRecord: 0,
+  fixedPageLimit: 4,
+  removeAltGrid: false,
+  nForReadjust: 0,
+  reorderInterval: 30000,
+  fastReorderInterval: 10000,
+  lastReorderTime: 0,
+  audStreamNames: [],
+  currentUserPage: 0,
+  mainHeightWidth: 0,
+  prevMainHeightWidth: 0,
+  prevDoPaginate: false,
+  doPaginate: false,
+  shareEnded: false,
+  lStreams: [],
+  chatRefStreams: [],
+  controlHeight: 0,
+  isWideScreen: false,
+  isMediumScreen: false,
+  isSmallScreen: false,
+  addGrid: false,
+  addAltGrid: false,
+  gridRows: 0,
+  gridCols: 0,
+  altGridRows: 0,
+  altGridCols: 0,
+  numberPages: 0,
+  currentStreams: [],
+  showMiniView: false,
+  nStream: null,
+  defer_receive: false,
+  allAudioStreams: [],
+  remoteScreenStream: [],
+  screenProducer: null,
+  localScreenProducer: null,
+  gotAllVids: false,
+  paginationHeightWidth: 40,
+  paginationDirection: 'horizontal',
+  gridSizes: {
+    gridWidth: 0, gridHeight: 0, altGridWidth: 0, altGridHeight: 0,
+  },
+  screenForceFullDisplay: false,
+  mainGridStream: [],
+  otherGridStreams: [[], []],
+  audioOnlyStreams: [],
+  videoInputs: [],
+  audioInputs: [],
+  meetingProgressTime: '00:00:00',
+  meetingElapsedTime: 0,
+  ref_participants: [],
+
+  // Messaging, event, modals, and other UI states
+  messages: [],
+  startDirectMessage: false,
+  directMessageDetails: null,
+  showMessagesBadge: false,
+  audioSetting: 'allow',
+  videoSetting: 'allow',
+  screenshareSetting: 'allow',
+  chatSetting: 'allow',
+  displayOption: 'media',
+  autoWave: true,
+  forceFullDisplay: true,
+  prevForceFullDisplay: false,
+  prevMeetingDisplayType: 'video',
+  waitingRoomFilter: '',
+  waitingRoomList: [],
+  waitingRoomCounter: 0,
+  filteredWaitingRoomList: [],
+  requestFilter: '',
+  requestList: [],
+  requestCounter: 0,
+  filteredRequestList: [],
+  totalReqWait: 0,
+  alertVisible: false,
+  alertMessage: '',
+  alertType: 'success',
+  alertDuration: 3000,
+  progressTimerVisible: true,
+  progressTimerValue: 0,
+  isMenuModalVisible: false,
+  isRecordingModalVisible: false,
+  isSettingsModalVisible: false,
+  isRequestsModalVisible: false,
+  isWaitingModalVisible: false,
+  isCoHostModalVisible: false,
+  isMediaSettingsModalVisible: false,
+  isDisplaySettingsModalVisible: false,
+  isParticipantsModalVisible: false,
+  isMessagesModalVisible: false,
+  isConfirmExitModalVisible: false,
+  isConfirmHereModalVisible: false,
+  isShareEventModalVisible: false,
+  isLoadingModalVisible: false,
+
+  recordingMediaOptions: 'video',
+  recordingAudioOptions: 'all',
+  recordingVideoOptions: 'all',
+  recordingVideoType: 'fullDisplay',
+  recordingVideoOptimized: false,
+  recordingDisplayType: 'video',
+  recordingAddHLS: true,
+  recordingNameTags: true,
+  recordingBackgroundColor: '#83c0e9',
+  recordingNameTagsColor: '#ffffff',
+  recordingAddText: false,
+  recordingCustomText: 'Add Text',
+  recordingCustomTextPosition: 'top',
+  recordingCustomTextColor: '#ffffff',
+  recordingOrientationVideo: 'landscape',
+  clearedToResume: true,
+  clearedToRecord: true,
+  recordState: 'green',
+  showRecordButtons: false,
+  recordingProgressTime: '00:00:00',
+  audioSwitching: false,
+  videoSwitching: false,
+  videoAlreadyOn: false,
+  audioAlreadyOn: false,
+  componentSizes: {
+    mainHeight: 0, otherHeight: 0, mainWidth: 0, otherWidth: 0,
+  },
+  hasCameraPermission: false,
+  hasAudioPermission: false,
+  transportCreated: false,
+  localTransportCreated: false,
+  transportCreatedVideo: false,
+  transportCreatedAudio: false,
+  transportCreatedScreen: false,
+  producerTransport: null,
+  localProducerTransport: null,
+  videoProducer: null,
+  localVideoProducer: null,
+  params: {},
+  videoParams: {},
+  audioParams: {},
+  audioProducer: null,
+  localAudioProducer: null,
+  consumerTransports: [],
+  consumingTransports: [],
+
+  // Polls
+  polls: [],
+  poll: null,
+  isPollModalVisible: false,
+
+  // Background
+  customImage: '',
+  selectedImage: '',
+  segmentVideo: null,
+  selfieSegmentation: null,
+  pauseSegmentation: false,
+  processedStream: null,
+  keepBackground: false,
+  backgroundHasChanged: false,
+  virtualStream: null,
+  mainCanvas: null,
+  prevKeepBackground: false,
+  appliedBackground: false,
+  isBackgroundModalVisible: false,
+  autoClickBackground: false,
+
+  // Breakout Rooms
+  breakoutRooms: [],
+  currentRoomIndex: 0,
+  canStartBreakout: false,
+  breakOutRoomStarted: false,
+  breakOutRoomEnded: false,
+  hostNewRoom: -1,
+  limitedBreakRoom: [],
+  mainRoomsLength: 0,
+  memberRoom: -1,
+  isBreakoutRoomsModalVisible: false,
+
+  // Whiteboard
+  whiteboardUsers: [],
+  currentWhiteboardIndex: 0,
+  canStartWhiteboard: false,
+  whiteboardStarted: false,
+  whiteboardEnded: false,
+  whiteboardLimit: 4,
+  isWhiteboardModalVisible: false,
+  isConfigureWhiteboardModalVisible: false,
+  shapes: [],
+  useImageBackground: true,
+  redoStack: [],
+  undoStack: [],
+  canvasStream: null,
+  canvasWhiteboard: null,
+
+  // Screenboard
+  canvasScreenboard: null,
+  processedScreenStream: null,
+  annotateScreenStream: false,
+  mainScreenCanvas: null,
+  isScreenboardModalVisible: false,
+
+  // Control Buttons
+  micActive: false,
+  videoActive: false,
+  screenShareActive: false,
+  endCallActive: false,
+  participantsActive: false,
+  menuActive: false,
+  commentsActive: false,
+};
+
+export type InitialValuesStateType = typeof initialValuesState;

package/src/methods/utils/joinRoomOnMediaSFU.ts

@@ -0,0 +1,124 @@
+import type { CreateMediaSFURoomOptions, JoinMediaSFURoomOptions } from '../../types/types';
+import { resolveMediaSFURoomApi } from './resolveMediaSFURoomApi';
+
+export type CreateJoinRoomType = (options: {
+  payload: CreateMediaSFURoomOptions | JoinMediaSFURoomOptions;
+  apiUserName: string;
+  apiKey: string;
+  localLink?: string;
+}) => Promise<{
+  data: CreateJoinRoomResponse | CreateJoinRoomError | null;
+  success: boolean;
+}>;
+
+export interface CreateJoinRoomResponse {
+  message: string;
+  roomName: string;
+  secureCode?: string;
+  publicURL: string;
+  link: string;
+  secret: string;
+  success: boolean;
+}
+
+export interface CreateJoinRoomError {
+  error: string;
+  success?: boolean;
+}
+
+export type JoinRoomOnMediaSFUType = (options: {
+  payload: JoinMediaSFURoomOptions;
+  apiUserName: string;
+  apiKey: string;
+  localLink?: string;
+}) => Promise<{
+  data: CreateJoinRoomResponse | CreateJoinRoomError | null;
+  success: boolean;
+}>;
+
+const readResponseError = async (response: Response): Promise<string> => {
+  const fallbackMessage = `HTTP error! Status: ${response.status}`;
+
+  try {
+    const responseText = await response.text();
+
+    if (!responseText) {
+      return fallbackMessage;
+    }
+
+    const parsedResponse = JSON.parse(responseText) as { error?: string; message?: string };
+    return parsedResponse.error || parsedResponse.message || responseText;
+  } catch {
+    return fallbackMessage;
+  }
+};
+
+/**
+ * Calls the MediaSFU join-room API and returns a normalized success/error result.
+ *
+ * This helper supports both cloud and self-hosted deployments through the
+ * optional `localLink` override.
+ *
+ * @param options API request options including credentials and join payload.
+ * @returns A result object containing either parsed response data or an error payload.
+ *
+ * @example
+ * ```typescript
+ * const result = await joinRoomOnMediaSFU({
+ *   payload: { action: 'join', meetingID: 'room123', userName: 'Ada' },
+ *   apiUserName: 'sampleuser',
+ *   apiKey: '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef',
+ * });
+ *
+ * if (result.success) {
+ *   console.log(result.data?.roomName);
+ * }
+ * ```
+ */
+export const joinRoomOnMediaSFU: CreateJoinRoomType = async ({
+  payload,
+  apiUserName,
+  apiKey,
+  localLink = '',
+}) => {
+  try {
+    if (
+      !apiUserName ||
+      !apiKey ||
+      apiUserName === 'yourAPIUSERNAME' ||
+      apiKey === 'yourAPIKEY' ||
+      apiKey.length !== 64 ||
+      apiUserName.length < 6
+    ) {
+      return { data: { error: 'Invalid credentials' }, success: false };
+    }
+
+    const finalLink = resolveMediaSFURoomApi(localLink, 'joinRoom');
+
+    const response = await fetch(finalLink, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${apiUserName}:${apiKey}`,
+      },
+      body: JSON.stringify(payload),
+    });
+
+    if (!response.ok) {
+      throw new Error(await readResponseError(response));
+    }
+
+    const data = await response.json();
+    return { data, success: true };
+  } catch (error) {
+    const errorMessage = (
+      error as { reason?: string; message?: string }
+    ).reason || (
+      error as { reason?: string; message?: string }
+    ).message || 'unknown error';
+    return {
+      data: { error: `Unable to join room, ${errorMessage}` },
+      success: false,
+    };
+  }
+};

package/src/methods/utils/liveSubtitle.ts

@@ -0,0 +1,107 @@
+export interface TranslationTranscriptData {
+  speakerId: string;
+  speakerName?: string;
+  language: string;
+  originalText: string;
+  translatedText?: string;
+  timestamp?: number;
+  targetLanguage?: string;
+  isFinal?: boolean;
+  [key: string]: any;
+}
+
+export interface LiveSubtitle {
+  text: string;
+  language: string;
+  timestamp: number;
+  expiresAt: number;
+  speakerId: string;
+  speakerName?: string;
+}
+
+export interface UpdateLiveSubtitlesOptions {
+  currentSubtitles: Map<string, LiveSubtitle>;
+  transcript: TranslationTranscriptData;
+  now?: number;
+}
+
+export const createLiveSubtitle = (params: {
+  text: string;
+  language: string;
+  speakerId: string;
+  speakerName?: string;
+  timestamp?: number;
+}): LiveSubtitle => {
+  const timestamp = params.timestamp ?? Date.now();
+  const duration = Math.min(8000, Math.max(3000, 3000 + params.text.length * 50));
+
+  return {
+    text: params.text,
+    language: params.language,
+    timestamp,
+    expiresAt: timestamp + duration,
+    speakerId: params.speakerId,
+    speakerName: params.speakerName,
+  };
+};
+
+export const isSubtitleExpired = (subtitle: LiveSubtitle, now = Date.now()): boolean => {
+  return now >= subtitle.expiresAt;
+};
+
+export const pruneExpiredSubtitles = (
+  subtitles: Map<string, LiveSubtitle>,
+  now = Date.now(),
+): Map<string, LiveSubtitle> => {
+  const next = new Map(subtitles);
+
+  for (const [key, subtitle] of next.entries()) {
+    if (isSubtitleExpired(subtitle, now)) {
+      next.delete(key);
+    }
+  }
+
+  return next;
+};
+
+export const updateLiveSubtitlesFromTranscript = ({
+  currentSubtitles,
+  transcript,
+  now,
+}: UpdateLiveSubtitlesOptions): Map<string, LiveSubtitle> => {
+  const subtitle = createLiveSubtitle({
+    text: transcript.translatedText || transcript.originalText,
+    language: transcript.language,
+    speakerId: transcript.speakerId,
+    speakerName: transcript.speakerName,
+    timestamp: now ?? transcript.timestamp,
+  });
+
+  const next = pruneExpiredSubtitles(currentSubtitles, subtitle.timestamp);
+  next.set(transcript.speakerId, subtitle);
+
+  if (transcript.speakerName) {
+    next.set(transcript.speakerName, subtitle);
+  }
+
+  return next;
+};
+
+export const getSubtitleForSpeaker = (
+  subtitles: Map<string, LiveSubtitle>,
+  speakerId: string,
+  speakerName?: string,
+  now = Date.now(),
+): LiveSubtitle | null => {
+  const activeSubtitles = pruneExpiredSubtitles(subtitles, now);
+
+  if (speakerId && activeSubtitles.has(speakerId)) {
+    return activeSubtitles.get(speakerId) || null;
+  }
+
+  if (speakerName && activeSubtitles.has(speakerName)) {
+    return activeSubtitles.get(speakerName) || null;
+  }
+
+  return null;
+};

package/src/methods/utils/meetingTimeRemaining.ts

@@ -0,0 +1,33 @@
+import type { EventType, ShowAlert } from '../../types/types';
+
+export interface MeetingTimeRemainingOptions {
+  timeRemaining: number;
+  showAlert?: ShowAlert;
+  eventType: EventType;
+}
+
+export type MeetingTimeRemainingType = (options: MeetingTimeRemainingOptions) => Promise<void>;
+
+/**
+ * Shows a meeting countdown alert for non-chat event types.
+ *
+ * @param options Function options including the remaining time in milliseconds.
+ * @returns A promise that resolves after the alert has been evaluated and dispatched.
+ */
+export const meetingTimeRemaining = async ({
+  timeRemaining,
+  showAlert,
+  eventType,
+}: MeetingTimeRemainingOptions): Promise<void> => {
+  const minutes = Math.floor(timeRemaining / 60000);
+  const seconds = Math.floor((timeRemaining % 60000) / 1000);
+  const timeRemainingString = `${minutes}:${seconds < 10 ? '0' : ''}${seconds}`;
+
+  if (eventType !== 'chat') {
+    showAlert?.({
+      message: `The event will end in ${timeRemainingString} minutes.`,
+      type: 'success',
+      duration: 3000,
+    });
+  }
+};