mediasfu-shared 1.0.1 → 1.0.2

package/src/methods/socketReceive/panelistReceiveMethods.ts

@@ -0,0 +1,195 @@
+import type { Participant, ShowAlert } from '../../types/types';
+
+export interface PanelistData {
+  id: string;
+  name: string;
+}
+
+export interface PanelistsUpdatedData {
+  panelists: PanelistData[];
+}
+
+export interface PanelistFocusChangedData {
+  focusEnabled: boolean;
+  panelists: PanelistData[];
+  muteOthersMic: boolean;
+  muteOthersCamera: boolean;
+}
+
+export interface ControlMediaData {
+  type: 'audio' | 'video';
+  action: 'mute' | 'unmute';
+  reason?: string;
+}
+
+export interface AddedAsPanelistData {
+  message: string;
+}
+
+export interface RemovedFromPanelistsData {
+  message: string;
+}
+
+export interface PanelistsUpdatedOptions {
+  data: PanelistsUpdatedData;
+  updatePanelists?: (panelists: Participant[]) => void;
+}
+
+export interface PanelistFocusChangedOptions {
+  data: PanelistFocusChangedData;
+  updatePanelistsFocused?: (focused: boolean) => void;
+  updateMuteOthersMic?: (mute: boolean) => void;
+  updateMuteOthersCamera?: (mute: boolean) => void;
+  updatePanelists?: (panelists: Participant[]) => void;
+  currentPanelistsFocused?: boolean;
+  currentPanelists?: Participant[];
+  onScreenChanges?: () => Promise<void>;
+}
+
+export interface ControlMediaOptions {
+  data: ControlMediaData;
+  showAlert?: ShowAlert;
+  clickAudio?: () => void;
+  clickVideo?: () => void;
+  audioAlreadyOn?: boolean;
+  videoAlreadyOn?: boolean;
+}
+
+export interface AddedAsPanelistOptions {
+  data: AddedAsPanelistData;
+  showAlert?: ShowAlert;
+}
+
+export interface RemovedFromPanelistsOptions {
+  data: RemovedFromPanelistsData;
+  showAlert?: ShowAlert;
+}
+
+export type PanelistsUpdatedType = (options: PanelistsUpdatedOptions) => Promise<void>;
+export type PanelistFocusChangedType = (options: PanelistFocusChangedOptions) => Promise<void>;
+export type ControlMediaType = (options: ControlMediaOptions) => Promise<void>;
+export type AddedAsPanelistType = (options: AddedAsPanelistOptions) => Promise<void>;
+export type RemovedFromPanelistsType = (options: RemovedFromPanelistsOptions) => Promise<void>;
+
+export const panelistsUpdated: PanelistsUpdatedType = async ({
+  data,
+  updatePanelists,
+}): Promise<void> => {
+  try {
+    const { panelists } = data;
+
+    if (updatePanelists) {
+      updatePanelists(
+        panelists.map((panelist) => ({
+          id: panelist.id,
+          name: panelist.name,
+          audioID: '',
+          videoID: '',
+        } as Participant)),
+      );
+    }
+  } catch (error) {
+    console.error('Error handling panelistsUpdated:', error);
+  }
+};
+
+export const panelistFocusChanged: PanelistFocusChangedType = async ({
+  data,
+  updatePanelistsFocused,
+  updateMuteOthersMic,
+  updateMuteOthersCamera,
+  updatePanelists,
+  currentPanelistsFocused,
+  currentPanelists,
+  onScreenChanges,
+}): Promise<void> => {
+  try {
+    const { focusEnabled, panelists, muteOthersMic, muteOthersCamera } = data;
+    const focusChanged = currentPanelistsFocused !== undefined && currentPanelistsFocused !== focusEnabled;
+    const currentPanelistIds = (currentPanelists || []).map((panelist) => panelist.id).sort().join(',');
+    const newPanelistIds = panelists.map((panelist) => panelist.id).sort().join(',');
+    const panelistsChanged = currentPanelistIds !== newPanelistIds;
+
+    updatePanelistsFocused?.(focusEnabled);
+    updateMuteOthersMic?.(muteOthersMic);
+    updateMuteOthersCamera?.(muteOthersCamera);
+
+    if (updatePanelists) {
+      updatePanelists(
+        panelists.map((panelist) => ({
+          id: panelist.id,
+          name: panelist.name,
+          audioID: '',
+          videoID: '',
+        } as Participant)),
+      );
+    }
+
+    if ((focusChanged || panelistsChanged) && onScreenChanges) {
+      await onScreenChanges();
+    }
+  } catch (error) {
+    console.error('Error handling panelistFocusChanged:', error);
+  }
+};
+
+export const panelistControlMedia: ControlMediaType = async ({
+  data,
+  showAlert,
+  clickAudio,
+  clickVideo,
+  audioAlreadyOn,
+  videoAlreadyOn,
+}: ControlMediaOptions): Promise<void> => {
+  try {
+    const { type, action, reason } = data;
+
+    if (action === 'mute') {
+      if (type === 'audio' && audioAlreadyOn && clickAudio) {
+        clickAudio();
+      } else if (type === 'video' && videoAlreadyOn && clickVideo) {
+        clickVideo();
+      }
+
+      if (showAlert && reason) {
+        showAlert({
+          message: `Your ${type === 'audio' ? 'microphone' : 'camera'} has been muted. ${reason}`,
+          type: 'info',
+          duration: 3000,
+        });
+      }
+    }
+  } catch (error) {
+    console.error('Error handling controlMedia:', error);
+  }
+};
+
+export const addedAsPanelist: AddedAsPanelistType = async ({
+  data,
+  showAlert,
+}: AddedAsPanelistOptions): Promise<void> => {
+  try {
+    showAlert?.({
+      message: data.message || 'You have been added as a panelist',
+      type: 'success',
+      duration: 3000,
+    });
+  } catch (error) {
+    console.error('Error handling addedAsPanelist:', error);
+  }
+};
+
+export const removedFromPanelists: RemovedFromPanelistsType = async ({
+  data,
+  showAlert,
+}: RemovedFromPanelistsOptions): Promise<void> => {
+  try {
+    showAlert?.({
+      message: data.message || 'You have been removed from panelists',
+      type: 'info',
+      duration: 3000,
+    });
+  } catch (error) {
+    console.error('Error handling removedFromPanelists:', error);
+  }
+};

package/src/methods/socketReceive/participantRequested.ts

@@ -0,0 +1,48 @@
+import type { Request, WaitingRoomParticipant } from '../../types/types';
+
+export interface ParticipantRequestedOptions {
+  userRequest: Request;
+  requestList: Request[];
+  waitingRoomList: WaitingRoomParticipant[];
+  updateTotalReqWait: (count: number) => void;
+  updateRequestList: (list: Request[]) => void;
+}
+
+export type ParticipantRequestedType = (
+  options: ParticipantRequestedOptions,
+) => Promise<void>;
+
+/**
+ * Appends a new participant request and refreshes the combined request/waiting count.
+ *
+ * @param {ParticipantRequestedOptions} options - Request payload and state setters.
+ * @returns {Promise<void>} Resolves after the request state is updated.
+ *
+ * @example
+ * ```typescript
+ * await participantRequested({
+ *   userRequest,
+ *   requestList,
+ *   waitingRoomList,
+ *   updateRequestList: setRequestList,
+ *   updateTotalReqWait: setTotalReqWait,
+ * });
+ * ```
+ */
+export const participantRequested = async ({
+  userRequest,
+  requestList,
+  waitingRoomList,
+  updateTotalReqWait,
+  updateRequestList,
+}: ParticipantRequestedOptions): Promise<void> => {
+  const hasMatchingRequest = requestList.some(
+    (request) => request.id === userRequest.id && request.icon === userRequest.icon,
+  );
+
+  const updatedRequestList = hasMatchingRequest
+    ? requestList
+    : [...requestList, userRequest];
+  updateRequestList(updatedRequestList);
+  updateTotalReqWait(updatedRequestList.length + waitingRoomList.length);
+};

package/src/methods/socketReceive/permissionReceiveMethods.ts

@@ -0,0 +1,59 @@
+import type { ShowAlert } from '../../types/types';
+import type {
+  PermissionConfig,
+} from '../permissions/updatePermissionConfig';
+
+export interface PermissionUpdatedData {
+  newLevel: string;
+  message?: string;
+}
+
+export interface PermissionConfigUpdatedData {
+  config: PermissionConfig;
+}
+
+export interface PermissionUpdatedOptions {
+  data: PermissionUpdatedData;
+  showAlert?: ShowAlert;
+  updateIslevel?: (level: string) => void;
+}
+
+export interface PermissionConfigUpdatedOptions {
+  data: PermissionConfigUpdatedData;
+  updatePermissionConfig?: (config: PermissionConfig) => void;
+}
+
+export type PermissionUpdatedType = (options: PermissionUpdatedOptions) => Promise<void>;
+export type PermissionConfigUpdatedType = (options: PermissionConfigUpdatedOptions) => Promise<void>;
+
+export const permissionUpdated: PermissionUpdatedType = async ({
+  data,
+  showAlert,
+  updateIslevel,
+}: PermissionUpdatedOptions): Promise<void> => {
+  try {
+    const { newLevel, message } = data;
+    updateIslevel?.(newLevel);
+
+    if (showAlert && message) {
+      showAlert({
+        message,
+        type: newLevel === '1' ? 'success' : 'info',
+        duration: 3000,
+      });
+    }
+  } catch (error) {
+    console.error('Error handling permissionUpdated:', error);
+  }
+};
+
+export const permissionConfigUpdated: PermissionConfigUpdatedType = async ({
+  data,
+  updatePermissionConfig,
+}: PermissionConfigUpdatedOptions): Promise<void> => {
+  try {
+    updatePermissionConfig?.(data.config);
+  } catch (error) {
+    console.error('Error handling permissionConfigUpdated:', error);
+  }
+};

package/src/methods/socketReceive/personJoined.ts

@@ -0,0 +1,35 @@
+import type { ShowAlert } from '../../types/types';
+
+export interface PersonJoinedOptions {
+  showAlert?: ShowAlert;
+  name: string;
+}
+
+export type PersonJoinedType = (options: PersonJoinedOptions) => Promise<void>;
+
+/**
+ * Announces that a participant has joined the event.
+ *
+ * @param {PersonJoinedOptions} options - Join alert settings.
+ * @param {string} options.name - Participant name to display.
+ * @param {ShowAlert} [options.showAlert] - Optional alert presenter.
+ * @returns {Promise<void>} Resolves after the alert is dispatched.
+ *
+ * @example
+ * ```typescript
+ * await personJoined({
+ *   name: 'Alice',
+ *   showAlert: ({ message }) => console.log(message),
+ * });
+ * ```
+ */
+export const personJoined = async ({
+  name,
+  showAlert,
+}: PersonJoinedOptions): Promise<void> => {
+  showAlert?.({
+    message: `${name} joined the event.`,
+    type: 'success',
+    duration: 3000,
+  });
+};

package/src/methods/socketReceive/producerMediaClosed.ts

@@ -0,0 +1,223 @@
+import type {
+  CloseAndResizeParameters,
+  PrepopulateUserMediaParameters,
+  ReorderStreamsParameters,
+} from '../../types/types';
+
+export interface ProducerMediaClosedCloseAndResizeOptions<TParameters = unknown> {
+  producerId: string;
+  kind: 'video' | 'screen' | 'audio' | 'screenshare';
+  parameters: TParameters;
+}
+
+export type ProducerMediaClosedCloseAndResizeType<TParameters = unknown> = (
+  options: ProducerMediaClosedCloseAndResizeOptions<TParameters>,
+) => Promise<unknown>;
+
+export interface ProducerMediaClosedPrepopulateUserMediaOptions<
+  TParameters = unknown,
+> {
+  name: string;
+  parameters: TParameters;
+}
+
+export type ProducerMediaClosedPrepopulateUserMediaType<
+  TParameters = unknown,
+> = (
+  options: ProducerMediaClosedPrepopulateUserMediaOptions<TParameters>,
+) => Promise<unknown>;
+
+export interface ProducerMediaClosedReorderStreamsOptions<
+  TParameters = unknown,
+> {
+  add: boolean;
+  screenChanged?: boolean;
+  parameters: TParameters;
+}
+
+export type ProducerMediaClosedReorderStreamsType<TParameters = unknown> = (
+  options: ProducerMediaClosedReorderStreamsOptions<TParameters>,
+) => Promise<unknown>;
+
+export interface ProducerMediaClosedTransportLike {
+  producerId: string;
+  consumerTransport?: {
+    close: () => Promise<void> | void;
+  };
+  consumer: {
+    close: () => Promise<void> | void;
+  };
+  [key: string]: any;
+}
+
+export interface ProducerMediaClosedParameters<
+  TTransport extends ProducerMediaClosedTransportLike = ProducerMediaClosedTransportLike,
+  TCloseAndResizeParameters = CloseAndResizeParameters,
+  TPrepopulateUserMediaParameters = PrepopulateUserMediaParameters,
+  TReorderStreamsParameters = ReorderStreamsParameters,
+  TAllParameters extends TCloseAndResizeParameters &
+    TPrepopulateUserMediaParameters &
+    TReorderStreamsParameters = TCloseAndResizeParameters &
+    TPrepopulateUserMediaParameters &
+    TReorderStreamsParameters,
+> {
+  consumerTransports: TTransport[];
+  updateConsumerTransports: (transports: TTransport[]) => void;
+  hostLabel: string;
+  shared: boolean;
+  updateShared: (shared: boolean) => void;
+  updateShareScreenStarted: (started: boolean) => void;
+  updateScreenId: (screenId: string) => void;
+  updateShareEnded: (ended: boolean) => void;
+  closeAndResize: ProducerMediaClosedCloseAndResizeType<TCloseAndResizeParameters>;
+  prepopulateUserMedia: ProducerMediaClosedPrepopulateUserMediaType<TPrepopulateUserMediaParameters>;
+  reorderStreams: ProducerMediaClosedReorderStreamsType<TReorderStreamsParameters>;
+  getUpdatedAllParams: () =>
+    ProducerMediaClosedParameters<
+      TTransport,
+      TCloseAndResizeParameters,
+      TPrepopulateUserMediaParameters,
+      TReorderStreamsParameters,
+      TAllParameters
+    > & TAllParameters;
+  [key: string]: any;
+}
+
+export interface ProducerMediaClosedOptions<
+  TTransport extends ProducerMediaClosedTransportLike = ProducerMediaClosedTransportLike,
+  TCloseAndResizeParameters = CloseAndResizeParameters,
+  TPrepopulateUserMediaParameters = PrepopulateUserMediaParameters,
+  TReorderStreamsParameters = ReorderStreamsParameters,
+  TAllParameters extends TCloseAndResizeParameters &
+    TPrepopulateUserMediaParameters &
+    TReorderStreamsParameters = TCloseAndResizeParameters &
+    TPrepopulateUserMediaParameters &
+    TReorderStreamsParameters,
+> {
+  producerId: string;
+  kind: 'video' | 'screen' | 'audio' | 'screenshare';
+  parameters:
+    ProducerMediaClosedParameters<
+      TTransport,
+      TCloseAndResizeParameters,
+      TPrepopulateUserMediaParameters,
+      TReorderStreamsParameters,
+      TAllParameters
+    > & TAllParameters;
+}
+
+export type ProducerMediaClosedType<
+  TTransport extends ProducerMediaClosedTransportLike = ProducerMediaClosedTransportLike,
+  TCloseAndResizeParameters = CloseAndResizeParameters,
+  TPrepopulateUserMediaParameters = PrepopulateUserMediaParameters,
+  TReorderStreamsParameters = ReorderStreamsParameters,
+  TAllParameters extends TCloseAndResizeParameters &
+    TPrepopulateUserMediaParameters &
+    TReorderStreamsParameters = TCloseAndResizeParameters &
+    TPrepopulateUserMediaParameters &
+    TReorderStreamsParameters,
+> = (
+  options: ProducerMediaClosedOptions<
+    TTransport,
+    TCloseAndResizeParameters,
+    TPrepopulateUserMediaParameters,
+    TReorderStreamsParameters,
+    TAllParameters
+  >,
+) => Promise<void>;
+
+/**
+ * Tears down a producer consumer transport and reconciles shared screen state when a producer closes.
+ *
+ * @param {ProducerMediaClosedOptions} options - Producer identity and shared room/media callbacks.
+ * @returns {Promise<void>} Resolves once transport teardown and UI cleanup are complete.
+ *
+ * @example
+ * ```typescript
+ * await producerMediaClosed({
+ *   producerId: '12345',
+ *   kind: 'screenshare',
+ *   parameters,
+ * });
+ * ```
+ */
+export const producerMediaClosed = async <
+  TTransport extends ProducerMediaClosedTransportLike = ProducerMediaClosedTransportLike,
+  TCloseAndResizeParameters = CloseAndResizeParameters,
+  TPrepopulateUserMediaParameters = PrepopulateUserMediaParameters,
+  TReorderStreamsParameters = ReorderStreamsParameters,
+  TAllParameters extends TCloseAndResizeParameters &
+    TPrepopulateUserMediaParameters &
+    TReorderStreamsParameters = TCloseAndResizeParameters &
+    TPrepopulateUserMediaParameters &
+    TReorderStreamsParameters,
+>({
+  producerId,
+  kind,
+  parameters,
+}: ProducerMediaClosedOptions<
+  TTransport,
+  TCloseAndResizeParameters,
+  TPrepopulateUserMediaParameters,
+  TReorderStreamsParameters,
+  TAllParameters
+>): Promise<void> => {
+  const updatedParameters = parameters.getUpdatedAllParams();
+
+  const {
+    consumerTransports,
+    updateConsumerTransports,
+    hostLabel,
+    shared,
+    updateShared,
+    updateShareScreenStarted,
+    updateScreenId,
+    updateShareEnded,
+    closeAndResize,
+    prepopulateUserMedia,
+    reorderStreams,
+  } = updatedParameters;
+
+  const producerToClose = consumerTransports.find(
+    (transportData) => transportData.producerId === producerId,
+  );
+
+  if (producerToClose) {
+    try {
+      await producerToClose.consumerTransport?.close();
+    } catch (error) {
+      console.error('Error closing consumer transport:', error);
+    }
+
+    try {
+      producerToClose.consumer.close();
+    } catch (error) {
+      console.error('Error closing consumer:', error);
+    }
+
+    const updatedTransports = consumerTransports.filter(
+      (transportData) => transportData.producerId !== producerId,
+    );
+    updateConsumerTransports(updatedTransports);
+
+    await closeAndResize({
+      producerId,
+      kind,
+      parameters: updatedParameters,
+    });
+  } else if (kind === 'screenshare' || kind === 'screen') {
+    if (shared) {
+      updateShared(false);
+    } else {
+      updateShareScreenStarted(false);
+      updateScreenId('');
+    }
+    updateShareEnded(true);
+    await prepopulateUserMedia({ name: hostLabel, parameters: updatedParameters });
+    await reorderStreams({
+      add: false,
+      screenChanged: true,
+      parameters: updatedParameters,
+    });
+  }
+};