mediasfu-shared 1.0.1 → 1.0.2

package/src/methods/socketReceive/controlMediaHost.ts

@@ -0,0 +1,280 @@
+export interface ControlMediaHostNestedOptions<TParameters = unknown> {
+  parameters: TParameters;
+}
+
+export interface ControlMediaHostTrackLike {
+  enabled: boolean;
+  kind?: string;
+}
+
+export interface ControlMediaHostMediaStreamLike {
+  getAudioTracks?: () => ControlMediaHostTrackLike[];
+  getVideoTracks?: () => ControlMediaHostTrackLike[];
+  tracks?: ControlMediaHostTrackLike[];
+  [key: string]: any;
+}
+
+export interface ControlMediaHostOnScreenChangesOptions<TParameters = unknown>
+  extends ControlMediaHostNestedOptions<TParameters> {
+  changed?: boolean;
+}
+
+export type ControlMediaHostOnScreenChangesType<TParameters = unknown> = (
+  options: ControlMediaHostOnScreenChangesOptions<TParameters>,
+) => Promise<void>;
+
+export type ControlMediaHostStopShareScreenType<TParameters = unknown> = (
+  options: ControlMediaHostNestedOptions<TParameters>,
+) => Promise<void>;
+
+export type ControlMediaHostDisconnectSendTransportVideoType<
+  TParameters = unknown,
+> = (options: ControlMediaHostNestedOptions<TParameters>) => Promise<void>;
+
+export type ControlMediaHostDisconnectSendTransportAudioType<
+  TParameters = unknown,
+> = (options: ControlMediaHostNestedOptions<TParameters>) => Promise<void>;
+
+export type ControlMediaHostDisconnectSendTransportScreenType<
+  TParameters = unknown,
+> = (options: ControlMediaHostNestedOptions<TParameters>) => Promise<void>;
+
+export interface ControlMediaHostParameters<
+  TOnScreenChangesParameters = unknown,
+  TStopShareScreenParameters = unknown,
+  TDisconnectSendTransportVideoParameters = unknown,
+  TDisconnectSendTransportAudioParameters = unknown,
+  TDisconnectSendTransportScreenParameters = unknown,
+  TAllParameters extends TOnScreenChangesParameters &
+    TStopShareScreenParameters &
+    TDisconnectSendTransportVideoParameters &
+    TDisconnectSendTransportAudioParameters &
+    TDisconnectSendTransportScreenParameters = TOnScreenChangesParameters &
+    TStopShareScreenParameters &
+    TDisconnectSendTransportVideoParameters &
+    TDisconnectSendTransportAudioParameters &
+    TDisconnectSendTransportScreenParameters,
+  TMediaStream extends ControlMediaHostMediaStreamLike = MediaStream,
+> {
+  updateAdminRestrictSetting: (value: boolean) => void;
+  localStream: TMediaStream | null;
+  updateLocalStream: (stream: TMediaStream | null) => void;
+  updateAudioAlreadyOn: (value: boolean) => void;
+  localStreamScreen: TMediaStream | null;
+  updateLocalStreamScreen: (stream: TMediaStream | null) => void;
+  localStreamVideo: TMediaStream | null;
+  updateLocalStreamVideo: (stream: TMediaStream | null) => void;
+  updateScreenAlreadyOn: (value: boolean) => void;
+  updateVideoAlreadyOn: (value: boolean) => void;
+  updateChatAlreadyOn: (value: boolean) => void;
+  onScreenChanges: ControlMediaHostOnScreenChangesType<TOnScreenChangesParameters>;
+  stopShareScreen: ControlMediaHostStopShareScreenType<TStopShareScreenParameters>;
+  disconnectSendTransportVideo: ControlMediaHostDisconnectSendTransportVideoType<TDisconnectSendTransportVideoParameters>;
+  disconnectSendTransportAudio: ControlMediaHostDisconnectSendTransportAudioType<TDisconnectSendTransportAudioParameters>;
+  disconnectSendTransportScreen: ControlMediaHostDisconnectSendTransportScreenType<TDisconnectSendTransportScreenParameters>;
+  getUpdatedAllParams: () =>
+    ControlMediaHostParameters<
+      TOnScreenChangesParameters,
+      TStopShareScreenParameters,
+      TDisconnectSendTransportVideoParameters,
+      TDisconnectSendTransportAudioParameters,
+      TDisconnectSendTransportScreenParameters,
+      TAllParameters,
+      TMediaStream
+    > & TAllParameters;
+  [key: string]: any;
+}
+
+export interface ControlMediaHostOptions<
+  TOnScreenChangesParameters = unknown,
+  TStopShareScreenParameters = unknown,
+  TDisconnectSendTransportVideoParameters = unknown,
+  TDisconnectSendTransportAudioParameters = unknown,
+  TDisconnectSendTransportScreenParameters = unknown,
+  TAllParameters extends TOnScreenChangesParameters &
+    TStopShareScreenParameters &
+    TDisconnectSendTransportVideoParameters &
+    TDisconnectSendTransportAudioParameters &
+    TDisconnectSendTransportScreenParameters = TOnScreenChangesParameters &
+    TStopShareScreenParameters &
+    TDisconnectSendTransportVideoParameters &
+    TDisconnectSendTransportAudioParameters &
+    TDisconnectSendTransportScreenParameters,
+  TMediaStream extends ControlMediaHostMediaStreamLike = MediaStream,
+> {
+  type: 'audio' | 'video' | 'screenshare' | 'chat' | 'all';
+  parameters:
+    ControlMediaHostParameters<
+      TOnScreenChangesParameters,
+      TStopShareScreenParameters,
+      TDisconnectSendTransportVideoParameters,
+      TDisconnectSendTransportAudioParameters,
+      TDisconnectSendTransportScreenParameters,
+      TAllParameters,
+      TMediaStream
+    > & TAllParameters;
+}
+
+export type ControlMediaHostType<
+  TOnScreenChangesParameters = unknown,
+  TStopShareScreenParameters = unknown,
+  TDisconnectSendTransportVideoParameters = unknown,
+  TDisconnectSendTransportAudioParameters = unknown,
+  TDisconnectSendTransportScreenParameters = unknown,
+  TAllParameters extends TOnScreenChangesParameters &
+    TStopShareScreenParameters &
+    TDisconnectSendTransportVideoParameters &
+    TDisconnectSendTransportAudioParameters &
+    TDisconnectSendTransportScreenParameters = TOnScreenChangesParameters &
+    TStopShareScreenParameters &
+    TDisconnectSendTransportVideoParameters &
+    TDisconnectSendTransportAudioParameters &
+    TDisconnectSendTransportScreenParameters,
+  TMediaStream extends ControlMediaHostMediaStreamLike = MediaStream,
+> = (
+  options: ControlMediaHostOptions<
+    TOnScreenChangesParameters,
+    TStopShareScreenParameters,
+    TDisconnectSendTransportVideoParameters,
+    TDisconnectSendTransportAudioParameters,
+    TDisconnectSendTransportScreenParameters,
+    TAllParameters,
+    TMediaStream
+  >,
+) => Promise<void>;
+
+/**
+ * Applies host-enforced media restrictions across local audio, video, screenshare, and chat state.
+ *
+ * @param {ControlMediaHostOptions} options - Restriction type and shared transport/screen callbacks.
+ * @returns {Promise<void>} Resolves once the requested host restriction is applied.
+ *
+ * @example
+ * ```typescript
+ * await controlMediaHost({
+ *   type: 'video',
+ *   parameters,
+ * });
+ * ```
+ */
+export const controlMediaHost = async <
+  TOnScreenChangesParameters = unknown,
+  TStopShareScreenParameters = unknown,
+  TDisconnectSendTransportVideoParameters = unknown,
+  TDisconnectSendTransportAudioParameters = unknown,
+  TDisconnectSendTransportScreenParameters = unknown,
+  TAllParameters extends TOnScreenChangesParameters &
+    TStopShareScreenParameters &
+    TDisconnectSendTransportVideoParameters &
+    TDisconnectSendTransportAudioParameters &
+    TDisconnectSendTransportScreenParameters = TOnScreenChangesParameters &
+    TStopShareScreenParameters &
+    TDisconnectSendTransportVideoParameters &
+    TDisconnectSendTransportAudioParameters &
+    TDisconnectSendTransportScreenParameters,
+  TMediaStream extends ControlMediaHostMediaStreamLike = MediaStream,
+>({
+  type,
+  parameters,
+}: ControlMediaHostOptions<
+  TOnScreenChangesParameters,
+  TStopShareScreenParameters,
+  TDisconnectSendTransportVideoParameters,
+  TDisconnectSendTransportAudioParameters,
+  TDisconnectSendTransportScreenParameters,
+  TAllParameters,
+  TMediaStream
+>): Promise<void> => {
+  const {
+    updateAdminRestrictSetting,
+    updateLocalStream,
+    updateAudioAlreadyOn,
+    updateLocalStreamScreen,
+    updateLocalStreamVideo,
+    updateScreenAlreadyOn,
+    updateVideoAlreadyOn,
+    updateChatAlreadyOn,
+    onScreenChanges,
+    stopShareScreen,
+    disconnectSendTransportVideo,
+    disconnectSendTransportAudio,
+    disconnectSendTransportScreen,
+  } = parameters;
+
+  const { localStream, localStreamScreen, localStreamVideo } =
+    parameters.getUpdatedAllParams();
+
+  const disableTrack = (
+    stream: TMediaStream | null,
+    kind: 'audio' | 'video',
+  ): boolean => {
+    const getTracks =
+      kind === 'audio' ? stream?.getAudioTracks : stream?.getVideoTracks;
+    const tracks =
+      typeof getTracks === 'function'
+        ? getTracks.call(stream)
+        : stream?.tracks?.filter((track) => track.kind === kind) ?? [];
+    const track = tracks && tracks[0];
+    if (track) {
+      track.enabled = false;
+      return true;
+    }
+    return false;
+  };
+
+  try {
+    updateAdminRestrictSetting(true);
+
+    if (type === 'audio') {
+      disableTrack(localStream, 'audio');
+      updateLocalStream(localStream ?? null);
+      await disconnectSendTransportAudio({ parameters });
+      updateAudioAlreadyOn(false);
+    } else if (type === 'video') {
+      disableTrack(localStream, 'video');
+      updateLocalStream(localStream ?? null);
+      await disconnectSendTransportVideo({ parameters });
+      await onScreenChanges({ changed: true, parameters });
+
+      disableTrack(localStreamVideo, 'video');
+      updateLocalStreamVideo(localStreamVideo ?? null);
+      await disconnectSendTransportVideo({ parameters });
+      await onScreenChanges({ changed: true, parameters });
+
+      updateVideoAlreadyOn(false);
+    } else if (type === 'screenshare') {
+      disableTrack(localStreamScreen, 'video');
+      updateLocalStreamScreen(localStreamScreen ?? null);
+      await disconnectSendTransportScreen({ parameters });
+      await stopShareScreen({ parameters });
+      updateScreenAlreadyOn(false);
+    } else if (type === 'chat') {
+      updateChatAlreadyOn(false);
+    } else if (type === 'all') {
+      disableTrack(localStream, 'audio');
+      updateLocalStream(localStream ?? null);
+      await disconnectSendTransportAudio({ parameters });
+      updateAudioAlreadyOn(false);
+
+      disableTrack(localStreamScreen, 'video');
+      updateLocalStreamScreen(localStreamScreen ?? null);
+      await disconnectSendTransportScreen({ parameters });
+      await stopShareScreen({ parameters });
+      updateScreenAlreadyOn(false);
+
+      disableTrack(localStream, 'video');
+      updateLocalStream(localStream ?? null);
+      await disconnectSendTransportVideo({ parameters });
+      await onScreenChanges({ changed: true, parameters });
+
+      disableTrack(localStreamVideo, 'video');
+      updateLocalStreamVideo(localStreamVideo ?? null);
+      await disconnectSendTransportVideo({ parameters });
+      await onScreenChanges({ changed: true, parameters });
+
+      updateVideoAlreadyOn(false);
+    }
+  } catch (error) {
+    console.error('Error in controlMediaHost:', error);
+  }
+};

package/src/methods/socketReceive/disconnect.ts

@@ -0,0 +1,40 @@
+import type { ShowAlert } from '../../types/types';
+
+export interface DisconnectOptions {
+  showAlert?: ShowAlert;
+  redirectURL?: string;
+  onWeb: boolean;
+  updateValidated?: (isValidated: boolean) => void;
+}
+
+export type DisconnectType = (options: DisconnectOptions) => Promise<void>;
+
+/**
+ * Handles a forced session disconnect by redirecting web users or showing a local alert fallback.
+ *
+ * @param {DisconnectOptions} options - Redirect and alert handlers for the disconnect flow.
+ * @returns {Promise<void>} Resolves after the redirect or alert side effect is applied.
+ *
+ * @example
+ * ```typescript
+ * await disconnect({
+ *   onWeb: true,
+ *   redirectURL: 'https://example.com/exit',
+ * });
+ * ```
+ */
+export const disconnect = async ({
+  showAlert,
+  redirectURL,
+  onWeb,
+}: DisconnectOptions): Promise<void> => {
+  if (onWeb && redirectURL && typeof window !== 'undefined') {
+    window.location.href = redirectURL;
+  } else {
+    showAlert?.({
+      message: 'You have been disconnected from the session.',
+      type: 'danger',
+      duration: 2000,
+    });
+  }
+};

package/src/methods/socketReceive/disconnectUserSelf.ts

@@ -0,0 +1,56 @@
+export interface DisconnectUserSelfSocketLike {
+  id?: string;
+  emit: (event: string, ...args: any[]) => void;
+}
+
+export interface DisconnectUserSelfOptions {
+  member: string;
+  roomName: string;
+  socket: DisconnectUserSelfSocketLike;
+  localSocket?: DisconnectUserSelfSocketLike;
+}
+
+export type DisconnectUserSelfType = (
+  options: DisconnectUserSelfOptions,
+) => Promise<void>;
+
+/**
+ * Emits a self-disconnect request, including the optional mirrored local socket.
+ *
+ * @param {DisconnectUserSelfOptions} options - Socket targets and participant identity.
+ * @returns {Promise<void>} Resolves after the disconnect events are emitted.
+ *
+ * @example
+ * ```typescript
+ * await disconnectUserSelf({
+ *   member: 'user123',
+ *   roomName: 'main-room',
+ *   socket,
+ *   localSocket,
+ * });
+ * ```
+ */
+export async function disconnectUserSelf({
+  member,
+  roomName,
+  socket,
+  localSocket,
+}: DisconnectUserSelfOptions): Promise<void> {
+  socket.emit('disconnectUser', {
+    member,
+    roomName,
+    ban: true,
+  });
+
+  try {
+    if (localSocket?.id) {
+      localSocket.emit('disconnectUser', {
+        member,
+        roomName,
+        ban: true,
+      });
+    }
+  } catch {
+    // no-op
+  }
+}

package/src/methods/socketReceive/getDomains.ts

@@ -0,0 +1,112 @@
+import type { RtpCapabilities } from 'mediasoup-client/lib/types';
+import type {
+  AltDomains,
+  ConsumeSocket,
+} from '../../types/types';
+
+export interface ConnectIpsLikeOptions<
+  TParameters = unknown,
+  TConsumeSocket = ConsumeSocket,
+> {
+  consume_sockets: TConsumeSocket[];
+  remIP: string[];
+  apiUserName: string;
+  apiKey?: string;
+  apiToken: string;
+  parameters: TParameters;
+}
+
+export type ConnectIpsLikeType<
+  TParameters = unknown,
+  TConsumeSocket = ConsumeSocket,
+> = (
+  options: ConnectIpsLikeOptions<TParameters, TConsumeSocket>,
+) => Promise<[unknown[], string[]]>;
+
+export interface GetDomainsParameters<
+  TParameters = unknown,
+  TConsumeSocket = ConsumeSocket,
+  TRtpCapabilities = RtpCapabilities,
+> {
+  roomRecvIPs: string[];
+  rtpCapabilities: TRtpCapabilities | null;
+  consume_sockets: TConsumeSocket[];
+  connectIps: ConnectIpsLikeType<TParameters, TConsumeSocket>;
+  getUpdatedAllParams: () => GetDomainsParameters<TParameters, TConsumeSocket, TRtpCapabilities> & TParameters;
+  [key: string]: any;
+}
+
+export interface GetDomainsOptions<
+  TParameters = unknown,
+  TConsumeSocket = ConsumeSocket,
+  TRtpCapabilities = RtpCapabilities,
+> {
+  domains: string[];
+  alt_domains: AltDomains;
+  apiUserName: string;
+  apiKey: string;
+  apiToken: string;
+  parameters: GetDomainsParameters<TParameters, TConsumeSocket, TRtpCapabilities> & TParameters;
+}
+
+export type GetDomainsType<
+  TParameters = unknown,
+  TConsumeSocket = ConsumeSocket,
+  TRtpCapabilities = RtpCapabilities,
+> = (options: GetDomainsOptions<TParameters, TConsumeSocket, TRtpCapabilities>) => Promise<void>;
+
+/**
+ * Resolves newly announced consuming domains to connection targets and connects missing ones.
+ *
+ * @param {GetDomainsOptions} options - Domain payload and shared consume-socket connection helpers.
+ * @returns {Promise<void>} Resolves after any missing consume domains are connected.
+ *
+ * @example
+ * ```typescript
+ * await getDomains({
+ *   domains: ['recv-1', 'recv-2'],
+ *   alt_domains,
+ *   apiUserName: 'api-user',
+ *   apiKey: 'api-key',
+ *   apiToken: 'api-token',
+ *   parameters,
+ * });
+ * ```
+ */
+export const getDomains = async <
+  TParameters = unknown,
+  TConsumeSocket = ConsumeSocket,
+  TRtpCapabilities = RtpCapabilities,
+>({
+  domains,
+  alt_domains,
+  apiUserName,
+  apiKey,
+  apiToken,
+  parameters,
+}: GetDomainsOptions<TParameters, TConsumeSocket, TRtpCapabilities>): Promise<void> => {
+  let { roomRecvIPs, consume_sockets, connectIps } = parameters;
+  const ipsToConnect: string[] = [];
+
+  try {
+    consume_sockets = parameters.getUpdatedAllParams().consume_sockets;
+
+    for (const domain of domains) {
+      const ipToCheck = alt_domains[domain] || domain;
+      if (!roomRecvIPs.includes(ipToCheck)) {
+        ipsToConnect.push(ipToCheck);
+      }
+    }
+
+    await connectIps({
+      consume_sockets,
+      remIP: ipsToConnect,
+      parameters,
+      apiUserName,
+      apiKey,
+      apiToken,
+    });
+  } catch (error) {
+    console.error('Error in getDomains: ', error);
+  }
+};

package/src/methods/socketReceive/meetingEnded.ts

@@ -0,0 +1,49 @@
+import type { EventType, ShowAlert } from '../../types/types';
+
+export interface MeetingEndedOptions {
+  showAlert?: ShowAlert;
+  redirectURL?: string;
+  onWeb: boolean;
+  eventType: EventType;
+  updateValidated?: (isValid: boolean) => void;
+}
+
+export type MeetingEndedType = (options: MeetingEndedOptions) => Promise<void>;
+
+/**
+ * Announces that the current event has ended and optionally redirects on web.
+ *
+ * @param {MeetingEndedOptions} options - Event-end behavior settings.
+ * @returns {Promise<void>} Resolves after alerts and redirect scheduling are configured.
+ *
+ * @example
+ * ```typescript
+ * await meetingEnded({
+ *   onWeb: true,
+ *   eventType: 'conference',
+ *   redirectURL: 'https://example.com',
+ *   showAlert,
+ * });
+ * ```
+ */
+export const meetingEnded = async ({
+  showAlert,
+  redirectURL,
+  onWeb,
+  eventType,
+}: MeetingEndedOptions): Promise<void> => {
+  if (eventType !== 'chat') {
+    showAlert?.({
+      message:
+        'The event has ended. You will be redirected to the home page in 2 seconds.',
+      type: 'danger',
+      duration: 2000,
+    });
+  }
+
+  if (onWeb && redirectURL) {
+    setTimeout(() => {
+      window.location.href = redirectURL;
+    }, 2000);
+  }
+};

package/src/methods/socketReceive/meetingStillThere.ts

@@ -0,0 +1,26 @@
+export interface MeetingStillThereOptions {
+  updateIsConfirmHereModalVisible: (isVisible: boolean) => void;
+}
+
+export type MeetingStillThereType = (
+  options: MeetingStillThereOptions,
+) => Promise<void>;
+
+/**
+ * Shows the "still there" confirmation modal.
+ *
+ * @param {MeetingStillThereOptions} options - Visibility setter for the confirmation modal.
+ * @returns {Promise<void>} Resolves after the modal is shown.
+ *
+ * @example
+ * ```typescript
+ * await meetingStillThere({
+ *   updateIsConfirmHereModalVisible: setIsConfirmHereModalVisible,
+ * });
+ * ```
+ */
+export const meetingStillThere = async ({
+  updateIsConfirmHereModalVisible,
+}: MeetingStillThereOptions): Promise<void> => {
+  updateIsConfirmHereModalVisible(true);
+};