mediasfu-shared 1.0.1 → 1.0.2

package/src/methods/socketReceive/producerMediaPaused.ts

@@ -0,0 +1,267 @@
+import type {
+  PrepopulateUserMediaParameters,
+  ReorderStreamsParameters,
+  ReUpdateInterParameters,
+} from '../../types/types';
+
+export interface ProducerMediaPausedPrepopulateUserMediaOptions<
+  TParameters = unknown,
+> {
+  name: string;
+  parameters: TParameters;
+}
+
+export type ProducerMediaPausedPrepopulateUserMediaType<
+  TParameters = unknown,
+> = (
+  options: ProducerMediaPausedPrepopulateUserMediaOptions<TParameters>,
+) => Promise<unknown>;
+
+export interface ProducerMediaPausedReorderStreamsOptions<
+  TParameters = unknown,
+> {
+  add: boolean;
+  screenChanged?: boolean;
+  parameters: TParameters;
+}
+
+export type ProducerMediaPausedReorderStreamsType<TParameters = unknown> = (
+  options: ProducerMediaPausedReorderStreamsOptions<TParameters>,
+) => Promise<unknown>;
+
+export interface ProducerMediaPausedReUpdateInterOptions<
+  TParameters = unknown,
+> {
+  name: string;
+  add: boolean;
+  force?: boolean;
+  parameters: TParameters;
+}
+
+export type ProducerMediaPausedReUpdateInterType<TParameters = unknown> = (
+  options: ProducerMediaPausedReUpdateInterOptions<TParameters>,
+) => Promise<unknown>;
+
+export interface ProducerMediaPausedParticipantLike {
+  name?: string | null;
+  muted?: boolean;
+  islevel?: string | null;
+  videoID?: string | null;
+  audioID?: string | null;
+}
+
+export interface ProducerMediaPausedParameters<
+  TParticipant extends ProducerMediaPausedParticipantLike = ProducerMediaPausedParticipantLike,
+  TPrepopulateUserMediaParameters = PrepopulateUserMediaParameters,
+  TReorderStreamsParameters = ReorderStreamsParameters,
+  TReUpdateInterParameters = ReUpdateInterParameters,
+  TAllParameters extends TPrepopulateUserMediaParameters &
+    TReorderStreamsParameters &
+    TReUpdateInterParameters = TPrepopulateUserMediaParameters &
+    TReorderStreamsParameters &
+    TReUpdateInterParameters,
+>
+  {
+  activeSounds: string[];
+  meetingDisplayType: string;
+  meetingVideoOptimized: boolean;
+  participants: TParticipant[];
+  oldSoundIds: string[];
+  shared: boolean;
+  shareScreenStarted: boolean;
+  updateMainWindow: boolean;
+  hostLabel: string;
+  islevel: string;
+  updateActiveSounds: (activeSounds: string[]) => void;
+  updateUpdateMainWindow: (updateMainWindow: boolean) => void;
+  reorderStreams: ProducerMediaPausedReorderStreamsType<TReorderStreamsParameters>;
+  prepopulateUserMedia: ProducerMediaPausedPrepopulateUserMediaType<TPrepopulateUserMediaParameters>;
+  reUpdateInter: ProducerMediaPausedReUpdateInterType<TReUpdateInterParameters>;
+  getUpdatedAllParams: () =>
+    ProducerMediaPausedParameters<
+      TParticipant,
+      TPrepopulateUserMediaParameters,
+      TReorderStreamsParameters,
+      TReUpdateInterParameters,
+      TAllParameters
+    > & TAllParameters;
+  [key: string]: any;
+}
+
+export interface ProducerMediaPausedOptions<
+  TParticipant extends ProducerMediaPausedParticipantLike = ProducerMediaPausedParticipantLike,
+  TPrepopulateUserMediaParameters = PrepopulateUserMediaParameters,
+  TReorderStreamsParameters = ReorderStreamsParameters,
+  TReUpdateInterParameters = ReUpdateInterParameters,
+  TAllParameters extends TPrepopulateUserMediaParameters &
+    TReorderStreamsParameters &
+    TReUpdateInterParameters = TPrepopulateUserMediaParameters &
+    TReorderStreamsParameters &
+    TReUpdateInterParameters,
+> {
+  producerId: string;
+  kind: 'audio' | 'video' | 'screenshare' | 'screen';
+  name: string;
+  parameters:
+    ProducerMediaPausedParameters<
+      TParticipant,
+      TPrepopulateUserMediaParameters,
+      TReorderStreamsParameters,
+      TReUpdateInterParameters,
+      TAllParameters
+    > & TAllParameters;
+}
+
+export type ProducerMediaPausedType<
+  TParticipant extends ProducerMediaPausedParticipantLike = ProducerMediaPausedParticipantLike,
+  TPrepopulateUserMediaParameters = PrepopulateUserMediaParameters,
+  TReorderStreamsParameters = ReorderStreamsParameters,
+  TReUpdateInterParameters = ReUpdateInterParameters,
+  TAllParameters extends TPrepopulateUserMediaParameters &
+    TReorderStreamsParameters &
+    TReUpdateInterParameters = TPrepopulateUserMediaParameters &
+    TReorderStreamsParameters &
+    TReUpdateInterParameters,
+> = (
+  options: ProducerMediaPausedOptions<
+    TParticipant,
+    TPrepopulateUserMediaParameters,
+    TReorderStreamsParameters,
+    TReUpdateInterParameters,
+    TAllParameters
+  >,
+) => Promise<void>;
+
+/**
+ * Reacts to a producer pause event by reconciling waveform state, main-window media, and layout ordering.
+ *
+ * @param {ProducerMediaPausedOptions} options - Producer identity and shared room/media callbacks.
+ * @returns {Promise<void>} Resolves once paused-media side effects are synchronized.
+ *
+ * @example
+ * ```typescript
+ * await producerMediaPaused({
+ *   producerId: 'abc123',
+ *   kind: 'audio',
+ *   name: 'Participant1',
+ *   parameters,
+ * });
+ * ```
+ */
+export const producerMediaPaused = async <
+  TParticipant extends ProducerMediaPausedParticipantLike = ProducerMediaPausedParticipantLike,
+  TPrepopulateUserMediaParameters = PrepopulateUserMediaParameters,
+  TReorderStreamsParameters = ReorderStreamsParameters,
+  TReUpdateInterParameters = ReUpdateInterParameters,
+  TAllParameters extends TPrepopulateUserMediaParameters &
+    TReorderStreamsParameters &
+    TReUpdateInterParameters = TPrepopulateUserMediaParameters &
+    TReorderStreamsParameters &
+    TReUpdateInterParameters,
+>({
+  producerId,
+  kind,
+  name,
+  parameters,
+}: ProducerMediaPausedOptions<
+  TParticipant,
+  TPrepopulateUserMediaParameters,
+  TReorderStreamsParameters,
+  TReUpdateInterParameters,
+  TAllParameters
+>): Promise<void> => {
+  parameters = parameters.getUpdatedAllParams();
+
+  let {
+    activeSounds,
+    meetingDisplayType,
+    meetingVideoOptimized,
+    participants,
+    oldSoundIds,
+    shared,
+    shareScreenStarted,
+    updateMainWindow,
+    hostLabel,
+    islevel,
+    updateActiveSounds,
+    updateUpdateMainWindow,
+    reorderStreams,
+    prepopulateUserMedia,
+    reUpdateInter,
+  } = parameters;
+
+  await Promise.all(
+    participants.map(async (participant) => {
+      if (participant.muted) {
+        try {
+          if (
+            participant.islevel === '2' &&
+            !participant.videoID &&
+            !shared &&
+            !shareScreenStarted &&
+            islevel !== '2'
+          ) {
+            updateMainWindow = true;
+            updateUpdateMainWindow(updateMainWindow);
+            await prepopulateUserMedia({ name: hostLabel, parameters });
+            updateMainWindow = false;
+            updateUpdateMainWindow(updateMainWindow);
+          }
+        } catch {
+          // no-op
+        }
+
+        if (shareScreenStarted || shared) {
+          if (participant.name && activeSounds.includes(participant.name)) {
+            activeSounds = activeSounds.filter(
+              (audioStream) => audioStream !== participant.name,
+            );
+            updateActiveSounds(activeSounds);
+          }
+
+          reUpdateInter({
+            name: participant.name!,
+            add: false,
+            force: true,
+            parameters,
+          });
+        }
+      }
+    }),
+  );
+
+  if (
+    meetingDisplayType === 'media' ||
+    (meetingDisplayType === 'video' && !meetingVideoOptimized)
+  ) {
+    const participant = participants.find((item) => item.name === name);
+    const hasVideo = participant?.videoID !== null && participant?.videoID !== '';
+
+    if (!hasVideo && !(shareScreenStarted || shared)) {
+      await reorderStreams({ add: false, screenChanged: true, parameters });
+    }
+  }
+
+  if (kind === 'audio') {
+    try {
+      const participant =
+        participants.find((item) => item.audioID === producerId) ||
+        participants.find((item) => item.name === name);
+
+      if (
+        participant &&
+        ((participant.name && oldSoundIds.includes(participant.name)) ||
+          (name && oldSoundIds.includes(name)))
+      ) {
+        reUpdateInter({
+          name: participant.name!,
+          add: false,
+          force: true,
+          parameters,
+        });
+      }
+    } catch {
+      // no-op
+    }
+  }
+};

package/src/methods/socketReceive/producerMediaResumed.ts

@@ -0,0 +1,157 @@
+import type {
+  PrepopulateUserMediaParameters,
+  ReorderStreamsParameters,
+} from '../../types/types';
+
+export interface ProducerMediaResumedPrepopulateUserMediaOptions<
+  TParameters = unknown,
+> {
+  name: string;
+  parameters: TParameters;
+}
+
+export type ProducerMediaResumedPrepopulateUserMediaType<
+  TParameters = unknown,
+> = (
+  options: ProducerMediaResumedPrepopulateUserMediaOptions<TParameters>,
+) => Promise<unknown>;
+
+export interface ProducerMediaResumedReorderStreamsOptions<
+  TParameters = unknown,
+> {
+  add: boolean;
+  screenChanged?: boolean;
+  parameters: TParameters;
+}
+
+export type ProducerMediaResumedReorderStreamsType<TParameters = unknown> = (
+  options: ProducerMediaResumedReorderStreamsOptions<TParameters>,
+) => Promise<unknown>;
+
+export interface ProducerMediaResumedParticipantLike {
+  name?: string | null;
+  islevel?: string | null;
+  videoID?: string | null;
+}
+
+export interface ProducerMediaResumedParameters<
+  TParticipant extends ProducerMediaResumedParticipantLike = ProducerMediaResumedParticipantLike,
+  TPrepopulateUserMediaParameters = PrepopulateUserMediaParameters,
+  TReorderStreamsParameters = ReorderStreamsParameters,
+  TAllParameters extends TPrepopulateUserMediaParameters &
+    TReorderStreamsParameters = TPrepopulateUserMediaParameters &
+    TReorderStreamsParameters,
+> {
+  meetingDisplayType: string;
+  participants: TParticipant[];
+  shared: boolean;
+  shareScreenStarted: boolean;
+  mainScreenFilled: boolean;
+  hostLabel: string;
+  updateUpdateMainWindow: (updateMainWindow: boolean) => void;
+  reorderStreams: ProducerMediaResumedReorderStreamsType<TReorderStreamsParameters>;
+  prepopulateUserMedia: ProducerMediaResumedPrepopulateUserMediaType<TPrepopulateUserMediaParameters>;
+  getUpdatedAllParams: () =>
+    ProducerMediaResumedParameters<
+      TParticipant,
+      TPrepopulateUserMediaParameters,
+      TReorderStreamsParameters,
+      TAllParameters
+    > & TAllParameters;
+  [key: string]: any;
+}
+
+export interface ProducerMediaResumedOptions<
+  TParticipant extends ProducerMediaResumedParticipantLike = ProducerMediaResumedParticipantLike,
+  TPrepopulateUserMediaParameters = PrepopulateUserMediaParameters,
+  TReorderStreamsParameters = ReorderStreamsParameters,
+  TAllParameters extends TPrepopulateUserMediaParameters &
+    TReorderStreamsParameters = TPrepopulateUserMediaParameters &
+    TReorderStreamsParameters,
+> {
+  name: string;
+  kind: 'audio';
+  parameters:
+    ProducerMediaResumedParameters<
+      TParticipant,
+      TPrepopulateUserMediaParameters,
+      TReorderStreamsParameters,
+      TAllParameters
+    > & TAllParameters;
+}
+
+export type ProducerMediaResumedType<
+  TParticipant extends ProducerMediaResumedParticipantLike = ProducerMediaResumedParticipantLike,
+  TPrepopulateUserMediaParameters = PrepopulateUserMediaParameters,
+  TReorderStreamsParameters = ReorderStreamsParameters,
+  TAllParameters extends TPrepopulateUserMediaParameters &
+    TReorderStreamsParameters = TPrepopulateUserMediaParameters &
+    TReorderStreamsParameters,
+> = (
+  options: ProducerMediaResumedOptions<
+    TParticipant,
+    TPrepopulateUserMediaParameters,
+    TReorderStreamsParameters,
+    TAllParameters
+  >,
+) => Promise<void>;
+
+/**
+ * Restores paused producer media state and refills the main window when needed.
+ *
+ * @param {ProducerMediaResumedOptions} options - Producer identity and shared room/media callbacks.
+ * @returns {Promise<void>} Resolves once the resumed-media UI state is synchronized.
+ *
+ * @example
+ * ```typescript
+ * await producerMediaResumed({
+ *   name: 'John Doe',
+ *   kind: 'audio',
+ *   parameters,
+ * });
+ * ```
+ */
+export const producerMediaResumed = async <
+  TParticipant extends ProducerMediaResumedParticipantLike = ProducerMediaResumedParticipantLike,
+  TPrepopulateUserMediaParameters = PrepopulateUserMediaParameters,
+  TReorderStreamsParameters = ReorderStreamsParameters,
+  TAllParameters extends TPrepopulateUserMediaParameters &
+    TReorderStreamsParameters = TPrepopulateUserMediaParameters &
+    TReorderStreamsParameters,
+>({
+  name,
+  parameters,
+}: ProducerMediaResumedOptions<
+  TParticipant,
+  TPrepopulateUserMediaParameters,
+  TReorderStreamsParameters,
+  TAllParameters
+>): Promise<void> => {
+  const {
+    meetingDisplayType,
+    participants,
+    shared,
+    shareScreenStarted,
+    mainScreenFilled,
+    hostLabel,
+    updateUpdateMainWindow,
+    reorderStreams,
+    prepopulateUserMedia,
+  } = parameters;
+
+  const participant = participants.find((item) => item.name === name);
+
+  if (participant && !mainScreenFilled && participant.islevel === '2') {
+    updateUpdateMainWindow(true);
+    await prepopulateUserMedia({ name: hostLabel, parameters });
+    updateUpdateMainWindow(false);
+  }
+
+  if (meetingDisplayType === 'media' && participant) {
+    const hasVideo = participant.videoID !== null && participant.videoID !== '';
+
+    if (!hasVideo && !(shareScreenStarted || shared)) {
+      await reorderStreams({ add: false, screenChanged: true, parameters });
+    }
+  }
+};

package/src/methods/socketReceive/reInitiateRecording.ts

@@ -0,0 +1,53 @@
+export interface ReInitiateRecordingSocketLike {
+  emit: (
+    event: string,
+    payload: { roomName: string; member: string },
+    callback?: (response: { success: boolean }) => void,
+  ) => void;
+}
+
+export interface ReInitiateRecordingOptions {
+  roomName: string;
+  member: string;
+  socket: ReInitiateRecordingSocketLike;
+  adminRestrictSetting: boolean;
+}
+
+export type ReInitiateRecordingType = (
+  options: ReInitiateRecordingOptions,
+) => Promise<void>;
+
+/**
+ * Re-requests recording startup when host controls allow it.
+ *
+ * @param {ReInitiateRecordingOptions} options - Room identity, socket, and admin restriction state.
+ * @returns {Promise<void>} Resolves after the emit request is sent or skipped.
+ *
+ * @example
+ * ```typescript
+ * await reInitiateRecording({
+ *   roomName: 'exampleRoom',
+ *   member: 'adminUser',
+ *   socket,
+ *   adminRestrictSetting: false,
+ * });
+ * ```
+ */
+export const reInitiateRecording = async ({
+  roomName,
+  member,
+  socket,
+  adminRestrictSetting,
+}: ReInitiateRecordingOptions): Promise<void> => {
+  if (!adminRestrictSetting) {
+    socket.emit(
+      'startRecordIng',
+      { roomName, member },
+      ({ success }: { success: boolean }) => {
+        if (!success) {
+          // no-op: caller-controlled UX
+        }
+      },
+    );
+  }
+};

package/src/methods/socketReceive/receiveMessage.ts

@@ -0,0 +1,117 @@
+import type { EventType, Message, Participant } from '../../types/types';
+
+export interface ReceiveMessageOptions {
+  message: Message;
+  messages: Message[];
+  participantsAll: Participant[];
+  member: string;
+  eventType: EventType;
+  islevel: string;
+  coHost: string;
+  updateMessages: (messages: Message[]) => void;
+  updateShowMessagesBadge: (showBadge: boolean) => void;
+}
+
+export type ReceiveMessageType = (options: ReceiveMessageOptions) => Promise<void>;
+
+/**
+ * Appends an inbound chat message, filters banned senders, and updates unread badge state.
+ *
+ * @param {ReceiveMessageOptions} options - Message payload, participant state, and update callbacks.
+ * @returns {Promise<void>} Resolves after message state is reconciled.
+ *
+ * @example
+ * ```typescript
+ * await receiveMessage({
+ *   message,
+ *   messages,
+ *   participantsAll,
+ *   member: 'Ada',
+ *   eventType: 'conference',
+ *   islevel: '1',
+ *   coHost: '',
+ *   updateMessages: setMessages,
+ *   updateShowMessagesBadge: setShowMessagesBadge,
+ * });
+ * ```
+ */
+export const receiveMessage = async ({
+  message,
+  messages,
+  participantsAll,
+  member,
+  eventType,
+  islevel,
+  coHost,
+  updateMessages,
+  updateShowMessagesBadge,
+}: ReceiveMessageOptions): Promise<void> => {
+  const { sender, receivers, message: content, timestamp, group } = message;
+  const oldMessages = messages;
+  messages = [...messages, { sender, receivers, message: content, timestamp, group }];
+
+  if (eventType !== 'broadcast' && eventType !== 'chat') {
+    messages = messages.filter((msg) =>
+      participantsAll.some(
+        (participant) => participant.name === msg.sender && !participant.isBanned,
+      ),
+    );
+  } else {
+    messages = messages.filter((msg) => {
+      const participant = participantsAll.find((p) => p.name === msg.sender);
+      return !participant || !participant.isBanned;
+    });
+  }
+
+  updateMessages(messages);
+
+  const oldGroupMessages = oldMessages.filter((msg) => msg.group);
+  const oldDirectMessages = oldMessages.filter((msg) => !msg.group);
+  const groupMessages = messages.filter((msg) => msg.group);
+  const directMessages = messages.filter((msg) => !msg.group);
+
+  if (eventType !== 'broadcast' && eventType !== 'chat') {
+    if (oldGroupMessages.length !== groupMessages.length) {
+      const newGroupMessages = groupMessages.filter(
+        (msg) => !oldGroupMessages.some((oldMsg) => oldMsg.timestamp === msg.timestamp),
+      );
+      const relevantGroupMessages = newGroupMessages.filter(
+        (msg) => msg.sender === member || msg.receivers.includes(member),
+      );
+      const selfSentGroupMessages = relevantGroupMessages.filter(
+        (msg) => msg.sender === member,
+      );
+
+      if (
+        newGroupMessages.length > 0 &&
+        relevantGroupMessages.length > selfSentGroupMessages.length
+      ) {
+        updateShowMessagesBadge(true);
+      }
+    }
+
+    if (oldDirectMessages.length !== directMessages.length) {
+      const newDirectMessages = directMessages.filter(
+        (msg) => !oldDirectMessages.some((oldMsg) => oldMsg.timestamp === msg.timestamp),
+      );
+      const relevantDirectMessages = newDirectMessages.filter(
+        (msg) => msg.sender === member || msg.receivers.includes(member),
+      );
+      const selfSentDirectMessages = relevantDirectMessages.filter(
+        (msg) => msg.sender === member,
+      );
+
+      const isPrivileged = islevel === '2' || coHost === member;
+      const hasRelevantDirectMessages = isPrivileged
+        ? newDirectMessages.length > 0
+        : relevantDirectMessages.length > 0;
+
+      if (
+        hasRelevantDirectMessages &&
+        newDirectMessages.length > selfSentDirectMessages.length
+      ) {
+        updateShowMessagesBadge(true);
+      }
+    }
+  }
+};