mediasfu-shared 1.0.1 → 1.0.2

package/src/consumers/mixStreams.ts

@@ -1,13 +1,41 @@
 import { Stream, Participant } from "../types/types";
 
-export interface MixStreamsOptions {
-  alVideoStreams: (Stream | Participant)[];
-  non_alVideoStreams: Participant[];
-  ref_participants: (Stream | Participant)[];
+interface MixStreamLike {
+  producerId?: string | null;
+  muted?: boolean | null;
+}
+
+interface MixParticipantLike {
+  videoID?: string | null;
+  muted?: boolean | null;
+}
+
+const getProducerId = (value: unknown): string | null | undefined => {
+  return (value as MixStreamLike | null | undefined)?.producerId;
+};
+
+const getVideoId = (value: unknown): string | null | undefined => {
+  return (value as MixParticipantLike | null | undefined)?.videoID;
+};
+
+const getMuted = (value: unknown): boolean | null | undefined => {
+  return (value as (MixStreamLike & MixParticipantLike) | null | undefined)?.muted;
+};
+
+export interface MixStreamsOptions<
+  TStream extends MixStreamLike = Stream,
+  TParticipant extends MixParticipantLike = Participant,
+> {
+  alVideoStreams: (TStream | TParticipant)[];
+  non_alVideoStreams: TParticipant[];
+  ref_participants: (TStream | TParticipant)[];
 }
 
 // Export the type definition for the function
-export type MixStreamsType = (options: MixStreamsOptions) => Promise<(Stream | Participant)[]>;
+export type MixStreamsType = <
+  TStream extends MixStreamLike = Stream,
+  TParticipant extends MixParticipantLike = Participant,
+>(options: MixStreamsOptions<TStream, TParticipant>) => Promise<(TStream | TParticipant)[]>;
 
 /**
  * Mixes video and audio streams and participants based on specified parameters.
@@ -30,37 +58,40 @@ export type MixStreamsType = (options: MixStreamsOptions) => Promise<(Stream | P
  */
 
 
-export async function mixStreams({
+export async function mixStreams<
+  TStream extends MixStreamLike = Stream,
+  TParticipant extends MixParticipantLike = Participant,
+>({
   alVideoStreams,
   non_alVideoStreams,
   ref_participants,
-}: MixStreamsOptions): Promise<(Stream | Participant)[]> {
+}: MixStreamsOptions<TStream, TParticipant>): Promise<(TStream | TParticipant)[]> {
   try {
 
-    const mixedStreams: (Stream | Participant)[] = [];
+    const mixedStreams: (TStream | TParticipant)[] = [];
 
     // Find "youyou" or "youyouyou" stream
     const youyouStream = alVideoStreams.find(
-      (obj) => obj.producerId === "youyou" || obj.producerId === "youyouyou"
+      (obj) => getProducerId(obj) === "youyou" || getProducerId(obj) === "youyouyou"
     );
 
     let remainingAlVideoStreams = alVideoStreams.filter(
-      (obj) => obj.producerId !== "youyou" && obj.producerId !== "youyouyou"
+      (obj) => getProducerId(obj) !== "youyou" && getProducerId(obj) !== "youyouyou"
     );
 
     // Separate unmuted and muted streams
     const unmutedAlVideoStreams = remainingAlVideoStreams.filter((obj) => {
       const participant = ref_participants.find(
-        (p) => p.videoID === obj.producerId
+        (p) => getVideoId(p) === getProducerId(obj)
       );
-      return !obj.muted && participant && participant.muted === false;
+      return !getMuted(obj) && participant && getMuted(participant) === false;
     });
 
     const mutedAlVideoStreams = remainingAlVideoStreams.filter((obj) => {
       const participant = ref_participants.find(
-        (p) => p.videoID === obj.producerId
+        (p) => getVideoId(p) === getProducerId(obj)
       );
-      return obj.muted || (participant && participant.muted === true);
+      return !!getMuted(obj) || (participant && getMuted(participant) === true);
     });
 
     const nonAlVideoStreams = [...non_alVideoStreams]; // Create a copy of non_alVideoStreams

package/src/consumers/onScreenChanges.ts

@@ -1,6 +1,10 @@
-import { ReorderStreamsType, ReorderStreamsParameters, EventType } from "../types/types";
+import { ReorderStreamsParameters, EventType } from "../types/types";
 
-export interface OnScreenChangesParameters extends ReorderStreamsParameters {
+type OpaqueReorderStreamsInvoker = {
+  bivarianceHack: (options: any) => Promise<void>;
+}["bivarianceHack"];
+
+export interface OnScreenChangesParameters extends ReorderStreamsParameters<any, any, any> {
   eventType: EventType;
   shareScreenStarted: boolean;
   shared: boolean;
@@ -10,18 +14,22 @@ export interface OnScreenChangesParameters extends ReorderStreamsParameters {
   updateItemPageLimit: (value: number) => void;
   updateMainHeightWidth: (value: number) => void;
 
-  //mediasfu functions
-  reorderStreams: ReorderStreamsType;
+  // mediasfu functions
+  reorderStreams: OpaqueReorderStreamsInvoker;
   [key: string]: any;
 }
 
-export interface OnScreenChangesOptions {
+export interface OnScreenChangesOptions<
+  TParameters extends OnScreenChangesParameters = OnScreenChangesParameters,
+> {
   changed?: boolean;
-  parameters: OnScreenChangesParameters;
+  parameters: TParameters;
 }
 
 // Export the type definition for the function
-export type OnScreenChangesType = (options: OnScreenChangesOptions) => Promise<void>;
+export type OnScreenChangesType = <
+  TParameters extends OnScreenChangesParameters = OnScreenChangesParameters,
+>(options: OnScreenChangesOptions<TParameters>) => Promise<void>;
 
 /**
  * Handles changes in screen events such as broadcast, chat, and conference.
@@ -62,13 +70,17 @@ export type OnScreenChangesType = (options: OnScreenChangesOptions) => Promise<v
  * ```
  */ 
 
-export async function onScreenChanges({ changed, parameters }: OnScreenChangesOptions): Promise<void> {
+export async function onScreenChanges<
+  TParameters extends OnScreenChangesParameters = OnScreenChangesParameters,
+>({ changed, parameters }: OnScreenChangesOptions<TParameters>): Promise<void> {
   try {
     // Destructure parameters
     let {
       eventType,
       shareScreenStarted,
       shared,
+      whiteboardStarted,
+      whiteboardEnded,
       addForBasic,
       updateMainHeightWidth,
       updateAddForBasic,
@@ -78,6 +90,7 @@ export async function onScreenChanges({ changed, parameters }: OnScreenChangesOp
       //mediasfu functions
       reorderStreams,
     } = parameters;
+    const screenFlowActive = shareScreenStarted || shared || (whiteboardStarted && !whiteboardEnded);
 
     // Remove element with id 'controlButtons'
     addForBasic = false;
@@ -89,9 +102,11 @@ export async function onScreenChanges({ changed, parameters }: OnScreenChangesOp
 
       itemPageLimit = eventType === "broadcast" ? 1 : 2;
       updateItemPageLimit(itemPageLimit);
-      updateMainHeightWidth(eventType === "broadcast" ? 100 : 0);
+      updateMainHeightWidth(screenFlowActive ? 84 : eventType === "broadcast" ? 100 : 0);
+    } else if (screenFlowActive) {
+      updateMainHeightWidth(84);
     } else {
-      if (eventType === "conference" && !(shareScreenStarted || shared)) {
+      if (eventType === "conference") {
         updateMainHeightWidth(0);
       }
     }

package/src/consumers/prepopulateUserMedia.ts

@@ -1,6 +1,8 @@
 // Stub export for prepopulateUserMedia
 // This is a React component in the original and not needed for the shared package
 
+import { createFrameworkConsumerContractError } from './frameworkConsumerContract';
+
 export interface PrepopulateUserMediaParameters {
   [key: string]: any;
 }
@@ -13,6 +15,5 @@ export interface PrepopulateUserMediaOptions {
 export type PrepopulateUserMediaType = (options: PrepopulateUserMediaOptions) => Promise<void>;
 
 export const prepopulateUserMedia: PrepopulateUserMediaType = async () => {
-  // Stub implementation - actual logic handled in framework-specific packages
-  console.warn('prepopulateUserMedia called on shared package - should be implemented in framework package');
+  throw createFrameworkConsumerContractError('prepopulateUserMedia');
 };

package/src/consumers/processConsumerTransports.ts

@@ -1,24 +1,65 @@
 import { Stream, Participant, Transport, SleepType } from "../types/types";
 
-export interface ProcessConsumerTransportsParameters {
-  remoteScreenStream: Stream[];
-  oldAllStreams: (Stream | Participant)[];
-  newLimitedStreams: (Stream | Participant)[];
+interface ProducerIdCarrier {
+  producerId?: string | null;
+}
+
+const getProducerId = (value: unknown): string | null | undefined => {
+  return (value as ProducerIdCarrier | null | undefined)?.producerId;
+};
+
+interface ConsumerLike {
+  paused?: boolean;
+  kind?: string;
+  pause: () => unknown;
+  resume: () => unknown;
+}
+
+interface SocketLike {
+  emit: (
+    event: string,
+    payload: { serverConsumerId: string },
+    callback?: ((payload?: { resumed: boolean }) => void | Promise<unknown>)
+  ) => void;
+}
+
+interface TransportLike {
+  producerId?: string | null;
+  consumer?: ConsumerLike;
+  socket_: SocketLike;
+  serverConsumerTransportId: string;
+}
+
+export interface ProcessConsumerTransportsParameters<
+  TStreamEntry = Stream,
+  TMediaEntry = Stream | Participant,
+> {
+  remoteScreenStream: TStreamEntry[];
+  oldAllStreams: TMediaEntry[];
+  newLimitedStreams: TMediaEntry[];
 
   // mediasfu functions
   sleep: SleepType;
-  getUpdatedAllParams: () => ProcessConsumerTransportsParameters;
+  getUpdatedAllParams: () => ProcessConsumerTransportsParameters<TStreamEntry, TMediaEntry>;
   [key: string]: any;
 }
 
-export interface ProcessConsumerTransportsOptions {
-  consumerTransports: Transport[];
-  lStreams_: (Stream | Participant)[];
-  parameters: ProcessConsumerTransportsParameters;
+export interface ProcessConsumerTransportsOptions<
+  TTransport extends TransportLike = Transport,
+  TStreamEntry = Stream,
+  TMediaEntry = Stream | Participant,
+> {
+  consumerTransports: TTransport[];
+  lStreams_: TMediaEntry[];
+  parameters: ProcessConsumerTransportsParameters<TStreamEntry, TMediaEntry>;
 }
 
 // Export the type definition for the function
-export type ProcessConsumerTransportsType = (options: ProcessConsumerTransportsOptions) => Promise<void>;
+export type ProcessConsumerTransportsType = <
+  TTransport extends TransportLike = Transport,
+  TStreamEntry = Stream,
+  TMediaEntry = Stream | Participant,
+>(options: ProcessConsumerTransportsOptions<TTransport, TStreamEntry, TMediaEntry>) => Promise<void>;
 
 /**
  * Processes consumer transports by pausing and resuming them based on certain conditions.
@@ -57,11 +98,15 @@ export type ProcessConsumerTransportsType = (options: ProcessConsumerTransportsO
  * ```
  */
 
-export async function processConsumerTransports({
+export async function processConsumerTransports<
+  TTransport extends TransportLike = Transport,
+  TStreamEntry = Stream,
+  TMediaEntry = Stream | Participant,
+>({
   consumerTransports,
   lStreams_,
   parameters,
-}: ProcessConsumerTransportsOptions): Promise<void> {
+}: ProcessConsumerTransportsOptions<TTransport, TStreamEntry, TMediaEntry>): Promise<void> {
   try {
     // Destructure parameters and get updated values
     parameters = parameters.getUpdatedAllParams();
@@ -74,14 +119,14 @@ export async function processConsumerTransports({
     } = parameters;
 
     // Function to check if the producerId is valid in the given stream arrays
-    function isValidProducerId(producerId: string, ...streamArrays: (Stream | Participant)[][]): boolean {
+    function isValidProducerId(producerId: string | null | undefined, ...streamArrays: unknown[][]): boolean {
       return (
         producerId !== null &&
         producerId !== "" &&
         streamArrays.some((streamArray) => {
           return (
             streamArray.length > 0 &&
-            streamArray.some((stream) => stream?.producerId === producerId)
+            streamArray.some((stream) => getProducerId(stream) === producerId)
           );
         })
       );
@@ -98,7 +143,7 @@ export async function processConsumerTransports({
           newLimitedStreams
         ) &&
         transport.consumer?.paused === true &&
-        transport.consumer.kind !== "audio"
+        transport.consumer?.kind !== "audio"
     );
 
     // Get unpaused consumer transports that are not audio
@@ -108,15 +153,15 @@ export async function processConsumerTransports({
         transport.producerId !== null &&
         transport.producerId !== "" &&
         !lStreams_.some(
-          (stream) => stream.producerId === transport.producerId
+          (stream) => getProducerId(stream) === transport.producerId
         ) &&
         transport.consumer &&
-        transport.consumer.kind &&
+        transport.consumer?.kind &&
         transport.consumer.paused !== true &&
         transport.consumer.kind !== "audio" &&
-        !remoteScreenStream.some((stream) => stream.producerId === transport.producerId) &&
-        !oldAllStreams.some((stream) => stream.producerId === transport.producerId) &&
-        !newLimitedStreams.some((stream) => stream.producerId === transport.producerId)
+        !remoteScreenStream.some((stream) => getProducerId(stream) === transport.producerId) &&
+        !oldAllStreams.some((stream) => getProducerId(stream) === transport.producerId) &&
+        !newLimitedStreams.some((stream) => getProducerId(stream) === transport.producerId)
     );
 
     // Pause consumer transports after a short delay
@@ -124,7 +169,7 @@ export async function processConsumerTransports({
 
     // Emit consumer.pause() for each filtered transport (not audio)
     for (const transport of consumerTransportsToPause) {
-     transport.consumer.pause();
+     transport.consumer?.pause();
        transport.socket_.emit(
         "consumer-pause",
         { serverConsumerId: transport.serverConsumerTransportId },
@@ -139,9 +184,9 @@ export async function processConsumerTransports({
       transport.socket_.emit(
         "consumer-resume",
         { serverConsumerId: transport.serverConsumerTransportId },
-        async ({ resumed }: { resumed: boolean }) => {
+        async ({ resumed }: { resumed: boolean } = { resumed: false }) => {
           if (resumed) {
-            transport.consumer.resume();
+            transport.consumer?.resume();
           }
         }
       );

package/src/consumers/processConsumerTransportsAudio.ts

@@ -1,5 +1,35 @@
 import { Stream, Transport, Participant, SleepType } from "../types/types";
 
+interface ProducerIdCarrier {
+  producerId?: string | null;
+}
+
+const getProducerId = (value: unknown): string | null | undefined => {
+  return (value as ProducerIdCarrier | null | undefined)?.producerId;
+};
+
+interface ConsumerLike {
+  paused?: boolean;
+  kind?: string;
+  pause: () => unknown;
+  resume: () => unknown;
+}
+
+interface SocketLike {
+  emit: (
+    event: string,
+    payload: { serverConsumerId: string },
+    callback?: ((payload?: { resumed: boolean }) => void | Promise<unknown>)
+  ) => void;
+}
+
+interface TransportLike {
+  producerId?: string | null;
+  consumer?: ConsumerLike;
+  socket_: SocketLike;
+  serverConsumerTransportId: string;
+}
+
 export interface ProcessConsumerTransportsAudioParameters {
 
   // mediasfu functions
@@ -7,16 +37,20 @@ export interface ProcessConsumerTransportsAudioParameters {
   [key: string]: any;
 }
 
-export interface ProcessConsumerTransportsAudioOptions {
-  consumerTransports: Transport[];
-  lStreams: (Stream | Participant)[];
+export interface ProcessConsumerTransportsAudioOptions<
+  TTransport extends TransportLike = Transport,
+  TMediaEntry = Stream | Participant,
+> {
+  consumerTransports: TTransport[];
+  lStreams: TMediaEntry[];
   parameters: ProcessConsumerTransportsAudioParameters;
 }
 
 // Export the type definition for the function
-export type ProcessConsumerTransportsAudioType = (
-  options: ProcessConsumerTransportsAudioOptions
-) => Promise<void>;
+export type ProcessConsumerTransportsAudioType = <
+  TTransport extends TransportLike = Transport,
+  TMediaEntry = Stream | Participant,
+>(options: ProcessConsumerTransportsAudioOptions<TTransport, TMediaEntry>) => Promise<void>;
 
 /**
  * Processes consumer transports for audio streams by pausing and resuming them based on their current state and the provided streams.
@@ -43,23 +77,26 @@ export type ProcessConsumerTransportsAudioType = (
  * ```
  */
 
-export const processConsumerTransportsAudio = async ({
+export const processConsumerTransportsAudio = async <
+  TTransport extends TransportLike = Transport,
+  TMediaEntry = Stream | Participant,
+>({
   consumerTransports,
   lStreams,
   parameters,
-}: ProcessConsumerTransportsAudioOptions): Promise<void> => {
+}: ProcessConsumerTransportsAudioOptions<TTransport, TMediaEntry>): Promise<void> => {
   try {
     const { sleep } = parameters;
 
     // Function to check if the producerId is valid in the given stream arrays
-    const isValidProducerId = (producerId: string, ...streamArrays: (Stream | Participant)[][]): boolean => {
+    const isValidProducerId = (producerId: string | null | undefined, ...streamArrays: unknown[][]): boolean => {
       return (
         producerId !== null &&
         producerId !== "" &&
         streamArrays.some((streamArray) => {
           return (
             streamArray.length > 0 &&
-          streamArray.some((stream) => stream?.producerId === producerId)
+          streamArray.some((stream) => getProducerId(stream) === producerId)
           );
         })
       );
@@ -70,7 +107,7 @@ export const processConsumerTransportsAudio = async ({
       (transport) =>
         isValidProducerId(transport.producerId, lStreams) &&
         transport.consumer?.paused === true &&
-        transport.consumer.kind === "audio"
+        transport.consumer?.kind === "audio"
     );
 
     // Get unpaused consumer transports that are audio
@@ -80,10 +117,10 @@ export const processConsumerTransportsAudio = async ({
         transport.producerId !== null &&
         transport.producerId !== "" &&
         !lStreams.some(
-          (stream) => stream.producerId === transport.producerId
+          (stream) => getProducerId(stream) === transport.producerId
         ) &&
         transport.consumer &&
-        transport.consumer.kind &&
+        transport.consumer?.kind &&
         transport.consumer.paused !== true &&
         transport.consumer.kind === "audio"
     );
@@ -92,7 +129,7 @@ export const processConsumerTransportsAudio = async ({
 
     // Emit consumer.pause() for each transport to pause
     for (const transport of consumerTransportsToPause) {
-      transport.consumer.pause();
+      transport.consumer?.pause();
       transport.socket_.emit(
         "consumer-pause",
         { serverConsumerId: transport.serverConsumerTransportId },
@@ -107,9 +144,9 @@ export const processConsumerTransportsAudio = async ({
       transport.socket_.emit(
         "consumer-resume",
         { serverConsumerId: transport.serverConsumerTransportId },
-        async ({ resumed }: { resumed: boolean }) => {
+        async ({ resumed }: { resumed: boolean } = { resumed: false }) => {
           if (resumed) {
-            transport.consumer.resume();
+            transport.consumer?.resume();
           }
         }
       );

package/src/consumers/reUpdateInter.ts

@@ -1,13 +1,47 @@
  
-import { Participant, Stream, OnScreenChangesType, ReorderStreamsType, ChangeVidsType, OnScreenChangesParameters, ReorderStreamsParameters, ChangeVidsParameters, EventType } from "../types/types";
-export interface ReUpdateInterParameters extends OnScreenChangesParameters, ReorderStreamsParameters, ChangeVidsParameters {
+import { Participant, Stream, EventType } from "../types/types";
+
+interface ReUpdateInterStreamLike {
+  producerId?: string | null;
+}
+
+interface ReUpdateInterParticipantLike {
+  name: string;
+  videoID?: string | null;
+  muted?: boolean | null;
+}
+
+type BooleanUpdater = (value: boolean) => void;
+type NumberUpdater = (value: number) => void;
+type StringListUpdater = (ids: string[]) => void;
+
+type OnScreenChangesInvoker = (options: {
+  changed?: boolean;
+  parameters: any;
+}) => Promise<void>;
+
+type ReorderStreamsInvoker = (options: {
+  add?: boolean;
+  screenChanged?: boolean;
+  parameters: any;
+}) => Promise<void>;
+
+type ChangeVidsInvoker = (options: {
+  screenChanged?: boolean;
+  parameters: any;
+}) => Promise<void>;
+
+export interface ReUpdateInterParameters<
+  TStream extends ReUpdateInterStreamLike = Stream,
+  TParticipant extends ReUpdateInterParticipantLike = Participant,
+> {
   screenPageLimit: number;
   itemPageLimit: number;
   reorderInterval: number;
   fastReorderInterval: number;
   eventType: EventType;
-  participants: Participant[];
-  allVideoStreams: (Participant | Stream)[];
+  participants: TParticipant[];
+  allVideoStreams: (TParticipant | TStream)[];
   shared: boolean;
   shareScreenStarted: boolean;
   adminNameStream?: string;
@@ -15,35 +49,39 @@ export interface ReUpdateInterParameters extends OnScreenChangesParameters, Reor
   updateMainWindow: boolean;
   sortAudioLoudness: boolean;
   lastReorderTime: number;
-  newLimitedStreams: (Participant | Stream)[];
+  newLimitedStreams: (TParticipant | TStream)[];
   newLimitedStreamsIDs: string[];
   oldSoundIds: string[];
-  updateUpdateMainWindow: (value: boolean) => void;
-  updateSortAudioLoudness: (value: boolean) => void;
-  updateLastReorderTime: (value: number) => void;
-  updateNewLimitedStreams: (streams: (Participant | Stream)[]) => void;
-  updateNewLimitedStreamsIDs: (ids: string[]) => void;
-  updateOldSoundIds: (ids: string[]) => void;
+  updateUpdateMainWindow: BooleanUpdater;
+  updateSortAudioLoudness: BooleanUpdater;
+  updateLastReorderTime: NumberUpdater;
+  updateNewLimitedStreams: (streams: (TParticipant | TStream)[]) => void;
+  updateNewLimitedStreamsIDs: StringListUpdater;
+  updateOldSoundIds: StringListUpdater;
 
   // mediasfu functions
-  onScreenChanges: OnScreenChangesType;
-  reorderStreams: ReorderStreamsType;
-  changeVids: ChangeVidsType;
+  onScreenChanges: OnScreenChangesInvoker;
+  reorderStreams: ReorderStreamsInvoker;
+  changeVids: ChangeVidsInvoker;
 
-  getUpdatedAllParams: () => ReUpdateInterParameters;
+  getUpdatedAllParams: () => ReUpdateInterParameters<TStream, TParticipant>;
   [key: string]: any;
 }
 
-export interface ReUpdateInterOptions {
+export interface ReUpdateInterOptions<
+  TParameters extends ReUpdateInterParameters<any, any> = ReUpdateInterParameters,
+> {
   name: string;
   add?: boolean;
   force?: boolean;
   average?: number;
-  parameters: ReUpdateInterParameters;
+  parameters: TParameters;
 }
 
 // Export the type definition for the function
-export type ReUpdateInterType = (options: ReUpdateInterOptions) => Promise<void>;
+export type ReUpdateInterType = <
+  TParameters extends ReUpdateInterParameters<any, any> = ReUpdateInterParameters,
+>(options: ReUpdateInterOptions<TParameters>) => Promise<void>;
 
 /**
  * Updates the interaction state based on the provided options and parameters.
@@ -123,13 +161,15 @@ export type ReUpdateInterType = (options: ReUpdateInterOptions) => Promise<void>
  */
 
 
-export async function reUpdateInter({
+export async function reUpdateInter<
+  TParameters extends ReUpdateInterParameters<any, any> = ReUpdateInterParameters,
+>({
   name,
   add = false,
   force = false,
   average = 127,
   parameters,
-}: ReUpdateInterOptions): Promise<void> {
+}: ReUpdateInterOptions<TParameters>): Promise<void> {
   let {
     screenPageLimit,
     itemPageLimit,
@@ -159,7 +199,7 @@ export async function reUpdateInter({
     onScreenChanges,
     reorderStreams,
     changeVids,
-  } = parameters;
+  } = parameters as TParameters;
 
   if (eventType === "broadcast" || eventType === "chat") {
     return;