mediasfu-shared 1.0.1 → 1.0.2

package/src/methods/stream/clickScreenShare.ts

@@ -0,0 +1,173 @@
+import { Socket } from 'socket.io-client';
+import type {
+  CheckPermissionType,
+  CheckScreenShareParameters,
+  CheckScreenShareType,
+  ShowAlert,
+  StopShareScreenParameters,
+  StopShareScreenType,
+} from '../../types/types';
+import type { PermissionConfig } from '../permissions/updatePermissionConfig';
+
+export interface ClickScreenShareParameters
+  extends CheckScreenShareParameters,
+    StopShareScreenParameters {
+  showAlert?: ShowAlert;
+  roomName: string;
+  member: string;
+  socket: Socket;
+  islevel: string;
+  youAreCoHost: boolean;
+  adminRestrictSetting: boolean;
+  audioSetting: string;
+  videoSetting: string;
+  screenshareSetting: string;
+  chatSetting: string;
+  permissionConfig?: PermissionConfig | null;
+  screenAction: boolean;
+  screenAlreadyOn: boolean;
+  screenRequestState: string | null;
+  screenRequestTime: number;
+  audioOnlyRoom: boolean;
+  updateRequestIntervalSeconds: number;
+  updateScreenRequestState: (state: string | null) => void;
+  updateScreenAlreadyOn: (status: boolean) => void;
+
+  checkPermission: CheckPermissionType;
+  checkScreenShare: CheckScreenShareType;
+  stopShareScreen: StopShareScreenType;
+
+  getUpdatedAllParams: () => ClickScreenShareParameters;
+  [key: string]: any;
+}
+
+export interface ClickScreenShareOptions {
+  parameters: ClickScreenShareParameters;
+}
+
+export type ClickScreenShareType = (options: ClickScreenShareOptions) => Promise<void>;
+
+/**
+ * Handles screen-share toggle flow for a participant.
+ *
+ * This helper checks room restrictions, host permission policies, request
+ * cooldowns, and then delegates to the supplied start/stop share helpers.
+ *
+ * @param options Function options containing the full runtime parameter bag.
+ * @returns A promise that resolves after the screen-share action has been processed.
+ */
+export const clickScreenShare = async ({ parameters }: ClickScreenShareOptions): Promise<void> => {
+  let {
+    showAlert,
+    roomName,
+    member,
+    socket,
+    islevel,
+    youAreCoHost,
+    adminRestrictSetting,
+    audioSetting,
+    videoSetting,
+    screenshareSetting,
+    chatSetting,
+    screenAction,
+    screenAlreadyOn,
+    screenRequestState,
+    screenRequestTime,
+    audioOnlyRoom,
+    updateRequestIntervalSeconds,
+    updateScreenRequestState,
+    updateScreenAlreadyOn,
+    checkPermission,
+    checkScreenShare,
+    stopShareScreen,
+  } = parameters;
+
+  if (audioOnlyRoom) {
+    showAlert?.({
+      message: 'You cannot turn on your camera in an audio-only event.',
+      type: 'danger',
+      duration: 3000,
+    });
+    return;
+  }
+
+  if (screenAlreadyOn) {
+    screenAlreadyOn = false;
+    updateScreenAlreadyOn(screenAlreadyOn);
+    await stopShareScreen({ parameters });
+  } else {
+    if (adminRestrictSetting) {
+      showAlert?.({
+        message: 'You cannot start screen share. Access denied by host.',
+        type: 'danger',
+        duration: 3000,
+      });
+      return;
+    }
+
+    let response = 2;
+    if (!screenAction && islevel !== '2' && !youAreCoHost) {
+      response = await checkPermission({
+        permissionType: 'screenshareSetting',
+        audioSetting,
+        videoSetting,
+        screenshareSetting,
+        chatSetting,
+        permissionConfig: parameters.permissionConfig,
+        participantLevel: islevel,
+      });
+    } else {
+      response = 0;
+    }
+
+    switch (response) {
+      case 0:
+        checkScreenShare({ parameters });
+        break;
+      case 1: {
+        if (screenRequestState === 'pending') {
+          showAlert?.({
+            message: 'A request is already pending. Please wait for the host to respond.',
+            type: 'danger',
+            duration: 3000,
+          });
+          return;
+        }
+
+        if (
+          screenRequestState === 'rejected' &&
+          Date.now() - screenRequestTime < updateRequestIntervalSeconds
+        ) {
+          showAlert?.({
+            message: 'You cannot send another request at this time.',
+            type: 'danger',
+            duration: 3000,
+          });
+          return;
+        }
+
+        showAlert?.({
+          message: 'Your request has been sent to the host.',
+          type: 'success',
+          duration: 3000,
+        });
+
+        screenRequestState = 'pending';
+        updateScreenRequestState(screenRequestState);
+
+        const userRequest = { id: socket.id, name: member, icon: 'fa-desktop' };
+        socket.emit('participantRequest', { userRequest, roomName });
+        break;
+      }
+      case 2:
+        showAlert?.({
+          message: 'You are not allowed to start screen share.',
+          type: 'danger',
+          duration: 3000,
+        });
+        break;
+      default:
+        break;
+    }
+  }
+};

package/src/methods/stream/clickVideo.ts

@@ -148,6 +148,21 @@ export const clickVideo = async ({ parameters }: ClickVideoOptions): Promise<voi
     checkPermission,
   } = parameters;
 
+  const resolvedMediaDevices =
+    typeof mediaDevices?.getUserMedia === "function"
+      ? mediaDevices
+      : globalThis.navigator?.mediaDevices;
+
+  if (typeof resolvedMediaDevices?.getUserMedia !== "function") {
+    showAlert?.({
+      message:
+        "Camera access is unavailable in this browser session. Please refresh and try again.",
+      type: "danger",
+      duration: 3000,
+    });
+    return;
+  }
+
   if (audioOnlyRoom) {
     showAlert?.({
       message: "You cannot turn on your camera in an audio-only event.",
@@ -173,8 +188,10 @@ export const clickVideo = async ({ parameters }: ClickVideoOptions): Promise<voi
 
     videoAlreadyOn = false;
     updateVideoAlreadyOn(videoAlreadyOn);
-    localStream!.getVideoTracks()[0].enabled = false;
-    updateLocalStream(localStream);
+    if (localStream && localStream.getVideoTracks().length > 0) {
+      localStream.getVideoTracks()[0].enabled = false;
+      updateLocalStream(localStream);
+    }
     await disconnectSendTransportVideo({ parameters });
   } else {
     if (adminRestrictSetting) {
@@ -299,13 +316,13 @@ export const clickVideo = async ({ parameters }: ClickVideoOptions): Promise<voi
         }
       }
 
-      await mediaDevices
+      await resolvedMediaDevices
         .getUserMedia(mediaConstraints)
         .then(async (stream) => {
           await streamSuccessVideo({ stream, parameters });
         })
         .catch(async () => {
-          await mediaDevices
+          await resolvedMediaDevices
             .getUserMedia(altMediaConstraints)
             .then(async (stream) => {
               await streamSuccessVideo({ stream, parameters });
@@ -316,7 +333,7 @@ export const clickVideo = async ({ parameters }: ClickVideoOptions): Promise<voi
                 video: { ...vidCons },
                 audio: false,
               };
-              await mediaDevices
+              await resolvedMediaDevices
               .getUserMedia(altMediaConstraints)
               .then(async (stream) => {
                 await streamSuccessVideo({ stream, parameters });

package/src/methods/stream/index.ts

@@ -1,3 +1,4 @@
 export * from './switchAudio'
 export * from './switchVideo'
 export * from './switchVideoAlt'
+export * from './clickChat'

package/src/methods/utils/SoundPlayer.ts

@@ -0,0 +1,31 @@
+export interface SoundPlayerOptions {
+  soundUrl: string;
+}
+
+export type SoundPlayerType = (options: SoundPlayerOptions) => void | Promise<void>;
+
+/**
+ * Attempts to play a remote sound asset when the runtime supports browser audio playback.
+ *
+ * @param {SoundPlayerOptions} options - The sound asset URL to play.
+ * @returns {void | Promise<void>} Completes after playback attempt starts/completes or is skipped.
+ *
+ * @example
+ * ```typescript
+ * await SoundPlayer({
+ *   soundUrl: 'https://www.mediasfu.com/sounds/record-progress.mp3',
+ * });
+ * ```
+ */
+export const SoundPlayer = async ({ soundUrl }: SoundPlayerOptions): Promise<void> => {
+  if (!soundUrl || typeof Audio === 'undefined') {
+    return;
+  }
+
+  try {
+    const audio = new Audio(soundUrl);
+    await audio.play();
+  } catch (error) {
+    console.error('Error playing sound:', error);
+  }
+};

package/src/methods/utils/checkLimitsAndMakeRequest.ts

@@ -1,5 +1,5 @@
 import { PreJoinPageParameters } from "../../types/types";
-import { Socket } from "socket.io-client";
+import type { Socket } from "socket.io-client";
 import Cookies from "universal-cookie";
 
 
@@ -7,6 +7,160 @@ const cookies = new Cookies();
 const MAX_ATTEMPTS = 10; // Maximum number of unsuccessful attempts before rate limiting
 const RATE_LIMIT_DURATION = 3 * 60 * 60 * 1000; // 3 hours in milliseconds
 
+export interface CheckLimitsStorageAdapter {
+  getItem: (key: string) => Promise<string | null | undefined> | string | null | undefined;
+  setItem: (key: string, value: string) => Promise<void> | void;
+}
+
+export interface CheckLimitsAndMakeRequestWithStorageOptions {
+  apiUserName: string;
+  apiToken: string;
+  link: string;
+  apiKey?: string;
+  userName: string;
+  parameters: PreJoinPageParameters;
+  validate?: boolean;
+  storageAdapter: CheckLimitsStorageAdapter;
+}
+
+export type CheckLimitsAndMakeRequestWithStorageType = (
+  options: CheckLimitsAndMakeRequestWithStorageOptions,
+) => Promise<void>;
+
+const readStoredNumber = async (
+  adapter: CheckLimitsStorageAdapter,
+  key: string,
+): Promise<number> => {
+  const value = await adapter.getItem(key);
+  const parsed = parseInt((value ?? '0').toString(), 10);
+  return Number.isNaN(parsed) ? 0 : parsed;
+};
+
+const writeStoredNumber = async (
+  adapter: CheckLimitsStorageAdapter,
+  key: string,
+  value: number,
+): Promise<void> => {
+  await adapter.setItem(key, value.toString());
+};
+
+const hasConnectedSocketId = (socket: unknown): socket is Socket & { id: string } => {
+  if (!socket || typeof socket !== 'object') {
+    return false;
+  }
+
+  const candidate = socket as { id?: unknown };
+  return typeof candidate.id === 'string' && candidate.id.length > 0;
+};
+
+/**
+ * Mobile/storage-adapter variant used by RN/Expo wrappers to share one canonical implementation.
+ */
+export const checkLimitsAndMakeRequestWithStorage: CheckLimitsAndMakeRequestWithStorageType = async ({
+  apiUserName,
+  apiToken,
+  link,
+  apiKey = '',
+  userName,
+  parameters,
+  validate = true,
+  storageAdapter,
+}) => {
+  const TIMEOUT_DURATION = 10000; // 10 seconds
+
+  try {
+    let unsuccessfulAttempts = await readStoredNumber(storageAdapter, 'unsuccessfulAttempts');
+    const lastRequestTimestamp = await readStoredNumber(storageAdapter, 'lastRequestTimestamp');
+
+    if (
+      unsuccessfulAttempts >= MAX_ATTEMPTS
+      && Date.now() - lastRequestTimestamp < RATE_LIMIT_DURATION
+    ) {
+      parameters.showAlert?.({
+        message: 'Too many unsuccessful attempts. Please try again later.',
+        type: 'danger',
+        duration: 3000,
+      });
+      await writeStoredNumber(storageAdapter, 'lastRequestTimestamp', Date.now());
+      return;
+    }
+
+    if (unsuccessfulAttempts >= MAX_ATTEMPTS) {
+      unsuccessfulAttempts = 0;
+      await writeStoredNumber(storageAdapter, 'unsuccessfulAttempts', unsuccessfulAttempts);
+      await writeStoredNumber(storageAdapter, 'lastRequestTimestamp', Date.now());
+    }
+
+    parameters.updateIsLoadingModalVisible(true);
+
+    const socketPromise = parameters.connectSocket({
+      apiUserName,
+      apiKey,
+      apiToken,
+      link,
+    });
+    const timeoutPromise = new Promise<never>((_, reject) => setTimeout(
+      () => reject(new Error('Request timed out')),
+      TIMEOUT_DURATION,
+    ));
+
+    const socket = await Promise.race([socketPromise, timeoutPromise]);
+
+    if (hasConnectedSocketId(socket)) {
+      unsuccessfulAttempts = 0;
+      await writeStoredNumber(storageAdapter, 'unsuccessfulAttempts', unsuccessfulAttempts);
+      await writeStoredNumber(storageAdapter, 'lastRequestTimestamp', Date.now());
+
+      if (validate) {
+        parameters.updateSocket(socket);
+      } else {
+        parameters.updateLocalSocket?.(socket);
+      }
+
+      parameters.updateApiUserName(apiUserName);
+      parameters.updateApiToken(apiToken);
+      parameters.updateLink(link);
+      parameters.updateRoomName(apiUserName);
+      parameters.updateMember(userName);
+      if (validate) {
+        parameters.updateValidated(true);
+      }
+    } else {
+      unsuccessfulAttempts += 1;
+      await writeStoredNumber(storageAdapter, 'unsuccessfulAttempts', unsuccessfulAttempts);
+      await writeStoredNumber(storageAdapter, 'lastRequestTimestamp', Date.now());
+      parameters.updateIsLoadingModalVisible(false);
+
+      if (unsuccessfulAttempts >= MAX_ATTEMPTS) {
+        parameters.showAlert?.({
+          message: 'Too many unsuccessful attempts. Please try again later.',
+          type: 'danger',
+          duration: 3000,
+        });
+      } else {
+        parameters.showAlert?.({
+          message: 'Invalid credentials.',
+          type: 'danger',
+          duration: 3000,
+        });
+      }
+    }
+  } catch (error) {
+    console.error('Error connecting to socket:', error);
+    parameters.showAlert?.({
+      message: 'Unable to connect. Check your credentials and try again.',
+      type: 'danger',
+      duration: 3000,
+    });
+
+    let unsuccessfulAttempts = await readStoredNumber(storageAdapter, 'unsuccessfulAttempts');
+    unsuccessfulAttempts += 1;
+    await writeStoredNumber(storageAdapter, 'unsuccessfulAttempts', unsuccessfulAttempts);
+    await writeStoredNumber(storageAdapter, 'lastRequestTimestamp', Date.now());
+    parameters.updateIsLoadingModalVisible(false);
+  }
+};
+
 
 export const checkLimitsAndMakeRequest = async ({
     apiUserName,
@@ -63,7 +217,7 @@ export const checkLimitsAndMakeRequest = async ({
       );
   
       const socket = await Promise.race([socketPromise, timeoutPromise]);
-      if (socket && socket instanceof Socket && socket.id) {
+      if (hasConnectedSocketId(socket)) {
         unsuccessfulAttempts = 0;
         cookies.set("unsuccessfulAttempts", unsuccessfulAttempts.toString());
         cookies.set("lastRequestTimestamp", Date.now().toString());

package/src/methods/utils/createResponseJoinRoom.ts

@@ -0,0 +1,47 @@
+import type { ResponseJoinLocalRoom, ResponseJoinRoom } from '../../types/types';
+
+export interface CreateResponseJoinRoomOptions {
+  localRoom: ResponseJoinLocalRoom;
+}
+
+export type CreateResponseJoinRoomType = (options: CreateResponseJoinRoomOptions) => Promise<ResponseJoinRoom>;
+
+/**
+ * Converts a local-room join response into the broader MediaSFU join response shape.
+ *
+ * This helper is useful when local/demo or self-hosted room flows need to be
+ * normalized to the same response contract consumed by the main runtime.
+ *
+ * @param options Response conversion options.
+ * @returns A normalized `ResponseJoinRoom` object.
+ *
+ * @example
+ * ```typescript
+ * const normalized = await createResponseJoinRoom({ localRoom });
+ * if (normalized.success) {
+ *   console.log(normalized.meetingRoomParams);
+ * }
+ * ```
+ */
+export const createResponseJoinRoom: CreateResponseJoinRoomType = async ({
+  localRoom,
+}: CreateResponseJoinRoomOptions): Promise<ResponseJoinRoom> => {
+  return {
+    rtpCapabilities: localRoom.rtpCapabilities ?? null,
+    success: localRoom.rtpCapabilities !== null,
+    roomRecvIPs: [],
+    meetingRoomParams: localRoom.eventRoomParams,
+    recordingParams: localRoom.recordingParams,
+    secureCode: localRoom.secureCode,
+    recordOnly: false,
+    isHost: localRoom.isHost,
+    safeRoom: false,
+    autoStartSafeRoom: false,
+    safeRoomStarted: false,
+    safeRoomEnded: false,
+    reason: localRoom.isBanned ? 'User is banned from the room.' : undefined,
+    banned: localRoom.isBanned,
+    suspended: false,
+    noAdmin: localRoom.hostNotJoined,
+  };
+};

package/src/methods/utils/createRoomOnMediaSFU.ts

@@ -0,0 +1,160 @@
+import type {
+  CreateRoomOnMediaSFUOptions,
+  CreateRoomOnMediaSFUType,
+  PendingRequestStorage,
+} from '../../types/types';
+import type { CreateJoinRoomError, CreateJoinRoomResponse } from './joinRoomOnMediaSFU';
+import { resolveMediaSFURoomApi } from './resolveMediaSFURoomApi';
+
+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;
+  }
+};
+
+const createBrowserPendingRequestStorage = (): PendingRequestStorage | undefined => {
+  if (typeof localStorage === 'undefined') {
+    return undefined;
+  }
+
+  return {
+    getItem: async (key: string) => localStorage.getItem(key),
+    setItem: async (key: string, value: string) => {
+      localStorage.setItem(key, value);
+    },
+    removeItem: async (key: string) => {
+      localStorage.removeItem(key);
+    },
+  };
+};
+
+/**
+ * Calls the MediaSFU create-room API and guards against duplicate in-flight room requests.
+ *
+ * A short-lived `localStorage` marker is used to prevent accidental duplicate
+ * submissions while a room create request is still pending.
+ *
+ * @param options API request options including credentials and create payload.
+ * @returns A result object containing either parsed response data or an error payload.
+ *
+ * @example
+ * ```typescript
+ * const created = await createRoomOnMediaSFU({
+ *   payload: {
+ *     action: 'create',
+ *     userName: 'Ada',
+ *     duration: 60,
+ *     capacity: 10,
+ *   } as CreateMediaSFURoomOptions,
+ *   apiUserName: 'sampleuser',
+ *   apiKey: '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef',
+ * });
+ *
+ * console.log(created.success);
+ * ```
+ */
+export const createRoomOnMediaSFU: CreateRoomOnMediaSFUType = async ({
+  payload,
+  apiUserName,
+  apiKey,
+  localLink = '',
+  pendingRequestStorage,
+}: CreateRoomOnMediaSFUOptions): Promise<{
+  data: CreateJoinRoomResponse | CreateJoinRoomError | null;
+  success: boolean;
+}> => {
+  const storage = pendingRequestStorage ?? createBrowserPendingRequestStorage();
+  const roomIdentifier = `create_${payload.userName}_${payload.duration}_${payload.capacity}`;
+
+  const pendingKey = `mediasfu_pending_${roomIdentifier}`;
+  const pendingTimeout = 30 * 1000;
+
+  try {
+    const pendingRequest = storage ? await storage.getItem(pendingKey) : null;
+    if (storage && pendingRequest) {
+      const pendingData = JSON.parse(pendingRequest) as { timestamp: number };
+      const timeSincePending = Date.now() - pendingData.timestamp;
+
+      if (timeSincePending < pendingTimeout) {
+        return {
+          data: { error: 'Room creation already in progress' },
+          success: false,
+        };
+      }
+
+      await storage.removeItem(pendingKey);
+    }
+
+    if (
+      !apiUserName ||
+      !apiKey ||
+      apiUserName === 'yourAPIUSERNAME' ||
+      apiKey === 'yourAPIKEY' ||
+      apiKey.length !== 64 ||
+      apiUserName.length < 6
+    ) {
+      return { data: { error: 'Invalid credentials' }, success: false };
+    }
+
+    const finalLink = resolveMediaSFURoomApi(localLink, 'createRoom');
+
+    if (storage) {
+      await storage.setItem(pendingKey, JSON.stringify({
+        timestamp: Date.now(),
+        payload: {
+          action: payload.action,
+          userName: payload.userName,
+          meetingID: 'create',
+        },
+      }));
+
+      setTimeout(() => {
+        storage.removeItem(pendingKey).catch(() => {
+        });
+      }, pendingTimeout);
+    }
+
+    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: CreateJoinRoomResponse = await response.json();
+    if (storage) {
+      await storage.removeItem(pendingKey);
+    }
+    return { data, success: true };
+  } catch (error) {
+    if (storage) {
+      try {
+        await storage.removeItem(pendingKey);
+      } catch {
+      }
+    }
+
+    const errorMessage = (error as Error).message || 'unknown error';
+    return {
+      data: { error: `Unable to create room, ${errorMessage}` },
+      success: false,
+    };
+  }
+};

package/src/methods/utils/formatNumber.ts

@@ -0,0 +1,42 @@
+export interface FormatNumberOptions {
+  number: number;
+}
+
+export type FormatNumberType = (options: FormatNumberOptions) => Promise<string | undefined>;
+
+/**
+ * Formats large numbers into compact display strings.
+ *
+ * Values are converted to `K`, `M`, or `B` suffixes for UI-friendly display.
+ * Falsy values return `undefined` to match existing MediaSFU display behavior.
+ *
+ * @param options Number formatting options.
+ * @returns A compact string such as `1.2K` or `3.4M`, or `undefined` for empty input.
+ *
+ * @example
+ * ```typescript
+ * const viewers = await formatNumber({ number: 1530 });
+ * // viewers === '1.5K'
+ * ```
+ */
+export const formatNumber = async ({ number }: FormatNumberOptions): Promise<string | undefined> => {
+  if (number) {
+    if (number < 1e3) {
+      return number.toString();
+    }
+
+    if (number < 1e6) {
+      return `${(number / 1e3).toFixed(1)}K`;
+    }
+
+    if (number < 1e9) {
+      return `${(number / 1e6).toFixed(1)}M`;
+    }
+
+    if (number < 1e12) {
+      return `${(number / 1e9).toFixed(1)}B`;
+    }
+  }
+
+  return undefined;
+};