mediasfu-angular 1.0.1 → 1.0.2

package/dist/lib/methods/utils/generate-random-request-list.service.d.ts

@@ -7,6 +7,42 @@ export interface GenerateRandomRequestListOptions {
     numberOfRequests: number;
 }
 export type GenerateRandomRequestListType = (options: GenerateRandomRequestListOptions) => Request[];
+/**
+  * Generates a random list of requests for participants, ensuring unique icons per participant
+  * and excluding the host and co-host from the request list.
+  *
+  * @param {GenerateRandomRequestListOptions} options - Configuration options for generating requests.
+  * @param {Participant[]} options.participants - Array of participant objects.
+  * @param {string} options.hostName - Name of the host to be excluded.
+  * @param {string} [options.coHostName] - Optional name of the co-host to be excluded.
+  * @param {number} options.numberOfRequests - Number of requests to generate per participant.
+  * @returns {Request[]} Array of requests, each uniquely associated with a participant.
+  *
+  * @example
+  * ```typescript
+  * const requestService = new GenerateRandomRequestList();
+  * const participants = [
+  *   { id: '1', name: 'Alice' },
+  *   { id: '2', name: 'Bob' },
+  *   { id: '3', name: 'Charlie' }
+  * ];
+  * const options = {
+  *   participants,
+  *   hostName: 'Alice',
+  *   coHostName: 'Bob',
+  *   numberOfRequests: 2
+  * };
+  *
+  * const requests = requestService.generateRandomRequestList(options);
+  *
+  * console.log(requests);
+  * // Output:
+  * // [
+  * //   { id: '3', name: 'charlie', icon: 'fa-microphone', username: 'charlie' },
+  * //   { id: '3', name: 'charlie', icon: 'fa-desktop', username: 'charlie' }
+  * // ]
+  * ```
+  */
 export declare class GenerateRandomRequestList {
     /**
      * Generates a list of random requests for participants, excluding the host and co-host.

package/dist/lib/methods/utils/generate-random-waiting-room-list.service.d.ts

@@ -1,6 +1,27 @@
 import { WaitingRoomParticipant } from '../../@types/types';
 import * as i0 from "@angular/core";
 export type GenerateRandomWaitingRoomListType = () => WaitingRoomParticipant[];
+/**
+  * Generates a random list of participants for a waiting room.
+  *
+  * @returns {WaitingRoomParticipant[]} An array of `WaitingRoomParticipant` objects, each with a unique ID and random name.
+  *
+  * @example
+  * ```typescript
+  * const generateListService = new GenerateRandomWaitingRoomList();
+  * const waitingRoomList = generateListService.generateRandomWaitingRoomList();
+  *
+  * console.log(waitingRoomList);
+  * // Output:
+  * // [
+  * //   { name: 'Dimen', id: '0' },
+  * //   { name: 'Nore', id: '1' },
+  * //   { name: 'Ker', id: '2' },
+  * //   { name: 'Lor', id: '3' },
+  * //   { name: 'Mik', id: '4' }
+  * // ]
+  * ```
+  */
 export declare class GenerateRandomWaitingRoomList {
     /**
      * Generates a random list of participants for a waiting room.

package/dist/lib/methods/utils/get-modal-position.util.d.ts

@@ -8,8 +8,18 @@ export interface GetModalPositionOptions {
 export type GetModalPositionType = (options: GetModalPositionOptions) => ModalPositionStyle;
 /**
  * Gets the style for positioning a modal based on the specified position.
- * @function
- * @param {string} position - The desired position for the modal ('center', 'topLeft', 'topRight', 'bottomLeft', 'bottomRight').
- * @returns {ModalPositionStyle} - The style object for positioning the modal.
+ *
+ * @param {GetModalPositionOptions} options - Object containing the desired modal position.
+ * @param {string} options.position - The modal position ('center', 'topLeft', 'topRight', 'bottomLeft', 'bottomRight').
+ * @returns {ModalPositionStyle} - Style object for aligning the modal according to the specified position.
+ *
+ * @example
+ * ```typescript
+ * const positionStyle = getModalPosition({ position: 'center' });
+ * // Output: { justifyContent: 'center', alignItems: 'center' }
+ *
+ * const topLeftStyle = getModalPosition({ position: 'topLeft' });
+ * // Output: { justifyContent: 'flex-start', alignItems: 'flex-start' }
+ * ```
  */
 export declare function getModalPosition({ position }: GetModalPositionOptions): ModalPositionStyle;

package/dist/lib/methods/utils/get-overlay-position.util.d.ts

@@ -5,8 +5,18 @@ export interface GetOverlayPositionOptions {
 export type GetOverlayPositionType = (options: GetOverlayPositionOptions) => OverlayPositionStyle;
 /**
  * Gets the style for positioning an overlay based on the specified position.
- * @function
- * @param {string} position - The desired position for the overlay ('topLeft', 'topRight', 'bottomLeft', 'bottomRight').
- * @returns {OverlayPositionStyle} - The style object for positioning the overlay.
+ *
+ * @param {GetOverlayPositionOptions} options - Contains the desired position for the overlay.
+ * @param {string} options.position - The position for the overlay ('topLeft', 'topRight', 'bottomLeft', 'bottomRight').
+ * @returns {OverlayPositionStyle} - Style object defining the overlay position.
+ *
+ * @example
+ * ```typescript
+ * const topLeftPosition = getOverlayPosition({ position: 'topLeft' });
+ * // Output: { top: 0, left: 0 }
+ *
+ * const bottomRightPosition = getOverlayPosition({ position: 'bottomRight' });
+ * // Output: { bottom: 0, right: 0 }
+ * ```
  */
 export declare function getOverlayPosition({ position }: GetOverlayPositionOptions): OverlayPositionStyle;

package/dist/lib/methods/utils/meeting-timer/start-meeting-progress-timer.service.d.ts

@@ -11,6 +11,43 @@ export interface StartMeetingProgressTimerOptions {
     parameters: StartMeetingProgressTimerParameters;
 }
 export type StartMeetingProgressTimerType = (options: StartMeetingProgressTimerOptions) => void;
+/**
+ * Starts a timer to track the progress of a meeting.
+ *
+ * @param {StartMeetingProgressTimerOptions} options - The options for starting the meeting progress timer.
+ * @param {number} options.startTime - The custom start time for the meeting progress timer in seconds since epoch.
+ * @param {StartMeetingProgressTimerParameters} options.parameters - The parameters required for updating the meeting progress.
+ * @param {Function} options.parameters.updateMeetingProgressTime - Function to update the formatted meeting progress time.
+ * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+ *
+ * @returns {void}
+ *
+ * @remarks
+ * This function calculates the elapsed time since the meeting started and updates the meeting progress every second.
+ * The timer will stop if the validated flag is set to false or if the room name is not valid.
+ *
+ * The time is formatted in HH:MM:SS format, and the update function is called with the formatted time.
+ *
+ * @example
+ * ```typescript
+ * const options: StartMeetingProgressTimerOptions = {
+ *   startTime: Math.floor(Date.now() / 1000), // Current time in seconds
+ *   parameters: {
+ *     updateMeetingProgressTime: (formattedTime) => console.log(`Meeting Progress: ${formattedTime}`),
+ *     validated: true,
+ *     roomName: 'Room123',
+ *     getUpdatedAllParams: () => ({
+ *       validated: true,
+ *       roomName: 'Room123',
+ *       updateMeetingProgressTime: options.parameters.updateMeetingProgressTime,
+ *     }),
+ *   },
+ * };
+ *
+ * const timerService = new StartMeetingProgressTimer();
+ * timerService.startMeetingProgressTimer(options);
+ * ```
+ */
 export declare class StartMeetingProgressTimer {
     private timeProgress;
     /**

package/dist/lib/methods/utils/mini-audio-player/mini-audio-player.component.d.ts

@@ -18,6 +18,61 @@ export interface MiniAudioPlayerOptions {
     miniAudioProps?: Record<string, any>;
 }
 export type MiniAudioPlayerType = (options: MiniAudioPlayerOptions) => HTMLElement;
+/**
+ * The `MiniAudioPlayer` component manages audio playback for participants in a meeting, including volume control, audio visualization, and connection to the main application state.
+ * It uses audio analysis to display waveforms for active speakers and supports breakout room conditions, participant-specific audio decibel updates, and other media state dependencies.
+ *
+ * @component
+ * @example
+ * ```html
+ * <app-mini-audio-player
+ *    [stream]="audioStream"
+ *    [remoteProducerId]="producerId"
+ *    [parameters]="audioPlayerParameters">
+ * </app-mini-audio-player>
+ * ```
+ *
+ * @param {MediaStream} [stream] - The audio stream from the participant.
+ * @param {string} [remoteProducerId] - Unique ID for the remote producer of the audio stream.
+ * @param {MiniAudioPlayerParameters} [parameters] - Configuration object with various parameters and utility functions for audio management.
+ * @param {Component} [MiniAudioComponent] - Optional audio visualization component injected into the `MiniAudioPlayer`.
+ * @param {Record<string, any>} [miniAudioProps] - Additional properties for configuring the audio visualization component.
+ *
+ * @returns {HTMLElement} The created audio player element.
+ *
+ * @remarks
+ * The `MiniAudioPlayer` leverages the `AudioContext` API to process audio data, analyze frequency, and manage audio levels.
+ * It supports a dynamic breakout room feature that restricts audio visibility to limited participants, updates decibel levels for individual participants, and adjusts the waveforms based on audio activity.
+ *
+ * Key functionalities include:
+ * - Automatically toggling wave visualization for active speakers.
+ * - Handling audio settings for different room states (e.g., shared screens, breakout rooms).
+ * - Injecting configuration and parameter dependencies dynamically through `Injector`.
+ *
+ * @dependencies
+ * - `AudioContext`: Web API for processing and analyzing audio data.
+ * - `setInterval` for periodic volume level checks (auto-clears on component destruction).
+ * - `ReUpdateInterType` and `UpdateParticipantAudioDecibelsType` for dynamic participant audio decibel management.
+ *
+ * @example
+ * ```typescript
+ * const audioPlayerParameters: MiniAudioPlayerParameters = {
+ *   breakOutRoomStarted: true,
+ *   breakOutRoomEnded: false,
+ *   limitedBreakRoom: participantList,
+ *   reUpdateInter: reUpdateInterFunc,
+ *   updateParticipantAudioDecibels: updateAudioDecibelsFunc,
+ *   getUpdatedAllParams: () => getParams(),
+ * };
+ *
+ * // Initialize component with required inputs
+ * <app-mini-audio-player
+ *   [stream]="audioStream"
+ *   [remoteProducerId]="participantId"
+ *   [parameters]="audioPlayerParameters"
+ * ></app-mini-audio-player>
+ * ```
+ */
 export declare class MiniAudioPlayer implements OnInit, OnDestroy {
     private injector;
     stream: MediaStream | null;

package/dist/lib/methods/utils/producer/a-params.service.d.ts

@@ -4,6 +4,43 @@ export type AParamsType = {
     encodings: RtpEncodingParameters[];
     codecOptions?: ProducerCodecOptions;
 };
+/**
+ * The `AParams` service provides the encoding parameters for audio production in a media session using the Mediasoup library.
+ * It includes a default configuration for RTP encoding parameters, which can be used when creating audio producers.
+ *
+ * @service
+ * @example
+ * ```typescript
+ * import { AParams } from './path/to/a-params.service';
+ *
+ * constructor(private aParamsService: AParams) {
+ *   console.log(this.aParamsService.aParams);
+ * }
+ * ```
+ *
+ * @typedef AParamsType
+ * @property {RtpEncodingParameters[]} encodings - Array of RTP encoding parameters for audio.
+ * @property {ProducerCodecOptions} [codecOptions] - Optional codec options for the audio producer.
+ *
+ * @example
+ * const aParams: AParamsType = {
+ *   encodings: [
+ *     {
+ *       rid: 'r0',
+ *       maxBitrate: 64000, // Max bitrate for the audio stream (in bps)
+ *     },
+ *   ],
+ *   codecOptions: {
+ *     // Additional codec options can be defined here
+ *   },
+ * };
+ *
+ * @remarks
+ * The default `aParams` contains a single encoding with a `rid` of "r0" and a maximum bitrate of 64 kbps.
+ * This configuration can be adjusted based on application requirements.
+ *
+ * @returns {AParamsType} The audio parameters for use in audio producer configuration.
+ */
 export declare class AParams {
     aParams: AParamsType;
     static ɵfac: i0.ɵɵFactoryDeclaration<AParams, never>;

package/dist/lib/methods/utils/producer/h-params.service.d.ts

@@ -4,6 +4,56 @@ export type HParamsType = {
     encodings: RtpEncodingParameters[];
     codecOptions?: ProducerCodecOptions;
 };
+/**
+ * The `HParams` service provides encoding parameters for video production in a media session using the Mediasoup library.
+ * It includes a default configuration for RTP encoding parameters designed for handling high-quality video streams.
+ *
+ * @service
+ * @example
+ * ```typescript
+ * import { HParams } from './path/to/h-params.service';
+ *
+ * constructor(private hParamsService: HParams) {
+ *   console.log(this.hParamsService.hParams);
+ * }
+ * ```
+ *
+ * @typedef HParamsType
+ * @property {RtpEncodingParameters[]} encodings - Array of RTP encoding parameters for video.
+ * @property {ProducerCodecOptions} [codecOptions] - Optional codec options for the video producer.
+ *
+ * @example
+ * const hParams: HParamsType = {
+ *   encodings: [
+ *     {
+ *       rid: 'r8',
+ *       maxBitrate: 240000, // Max bitrate for this encoding (in bps)
+ *       scalabilityMode: 'L1T3', // Scalable video coding mode
+ *       scaleResolutionDownBy: 4.0, // Scale down the resolution by a factor of 4
+ *     },
+ *     {
+ *       rid: 'r9',
+ *       maxBitrate: 480000,
+ *       scalabilityMode: 'L1T3',
+ *       scaleResolutionDownBy: 2.0, // Scale down the resolution by a factor of 2
+ *     },
+ *     {
+ *       rid: 'r10',
+ *       maxBitrate: 960000,
+ *       scalabilityMode: 'L1T3',
+ *     },
+ *   ],
+ *   codecOptions: {
+ *     videoGoogleStartBitrate: 320, // Initial bitrate for the Google codec
+ *   },
+ * };
+ *
+ * @remarks
+ * The default `hParams` includes three encoding configurations with different resolutions and bitrates.
+ * The configurations are optimized for scalable video encoding, allowing for adaptive bitrate streaming based on network conditions.
+ *
+ * @returns {HParamsType} The video parameters for use in video producer configuration.
+ */
 export declare class HParams {
     hParams: HParamsType;
     static ɵfac: i0.ɵɵFactoryDeclaration<HParams, never>;

package/dist/lib/methods/utils/producer/screen-params.service.d.ts

@@ -4,6 +4,43 @@ export type ScreenParamsType = {
     encodings: RtpEncodingParameters[];
     codecOptions?: ProducerCodecOptions;
 };
+/**
+ * The `ScreenParams` service provides encoding parameters specifically for screen sharing in a media session using the Mediasoup library.
+ * It includes a default configuration for RTP encoding parameters optimized for high-quality screen sharing.
+ *
+ * @service
+ * @example
+ * ```typescript
+ * import { ScreenParams } from './path/to/screen-params.service';
+ *
+ * constructor(private screenParamsService: ScreenParams) {
+ *   console.log(this.screenParamsService.screenParams);
+ * }
+ * ```
+ *
+ * @typedef ScreenParamsType
+ * @property {RtpEncodingParameters[]} encodings - Array of RTP encoding parameters for screen sharing.
+ * @property {ProducerCodecOptions} [codecOptions] - Optional codec options for the screen sharing producer.
+ *
+ * @example
+ * const screenParams: ScreenParamsType = {
+ *   encodings: [
+ *     {
+ *       rid: 'r7',
+ *       maxBitrate: 3000000, // Max bitrate for this encoding (in bps)
+ *     },
+ *   ],
+ *   codecOptions: {
+ *     videoGoogleStartBitrate: 1000, // Initial bitrate for the Google codec
+ *   },
+ * };
+ *
+ * @remarks
+ * The default `screenParams` includes one encoding configuration with a high maximum bitrate suitable for sharing detailed screen content.
+ * The parameters are optimized to ensure a smooth experience during screen sharing sessions.
+ *
+ * @returns {ScreenParamsType} The screen sharing parameters for use in screen sharing producer configuration.
+ */
 export declare class ScreenParams {
     screenParams: ScreenParamsType;
     static ɵfac: i0.ɵɵFactoryDeclaration<ScreenParams, never>;

package/dist/lib/methods/utils/producer/v-params.service.d.ts

@@ -4,6 +4,56 @@ export type VParamsType = {
     encodings: RtpEncodingParameters[];
     codecOptions?: ProducerCodecOptions;
 };
+/**
+ * The `VParams` service provides encoding parameters for video in a media session using the Mediasoup library.
+ * It includes a default configuration for RTP encoding parameters optimized for video streaming.
+ *
+ * @service
+ * @example
+ * ```typescript
+ * import { VParams } from './path/to/v-params.service';
+ *
+ * constructor(private vParamsService: VParams) {
+ *   console.log(this.vParamsService.vParams);
+ * }
+ * ```
+ *
+ * @typedef VParamsType
+ * @property {RtpEncodingParameters[]} encodings - Array of RTP encoding parameters for video.
+ * @property {ProducerCodecOptions} [codecOptions] - Optional codec options for the video producer.
+ *
+ * @example
+ * const vParams: VParamsType = {
+ *   encodings: [
+ *     {
+ *       rid: 'r3',
+ *       maxBitrate: 200000, // Max bitrate for this encoding (in bps)
+ *       scalabilityMode: 'L1T3', // Scalability mode for encoding
+ *       scaleResolutionDownBy: 4.0, // Scale down resolution by this factor
+ *     },
+ *     {
+ *       rid: 'r4',
+ *       maxBitrate: 400000,
+ *       scalabilityMode: 'L1T3',
+ *       scaleResolutionDownBy: 2.0,
+ *     },
+ *     {
+ *       rid: 'r5',
+ *       maxBitrate: 800000,
+ *       scalabilityMode: 'L1T3',
+ *     },
+ *   ],
+ *   codecOptions: {
+ *     videoGoogleStartBitrate: 320, // Initial bitrate for the Google codec
+ *   },
+ * };
+ *
+ * @remarks
+ * The default `vParams` includes multiple encoding configurations with different maximum bitrates,
+ * allowing for adaptive streaming based on network conditions and participant capabilities.
+ *
+ * @returns {VParamsType} The video parameters for use in video producer configuration.
+ */
 export declare class VParams {
     vParams: VParamsType;
     static ɵfac: i0.ɵɵFactoryDeclaration<VParams, never>;

package/dist/lib/methods/utils/producer/video-capture-constraints.service.d.ts

@@ -1,4 +1,50 @@
 import * as i0 from "@angular/core";
+/**
+ * The `VideoCaptureConstraints` service provides various video capture constraints
+ * including resolution and frame rate settings for different display sizes (landscape, portrait, and neutral).
+ *
+ * @service
+ * @example
+ * ```typescript
+ * import { VideoCaptureConstraints } from './path/to/video-capture-constraints.service';
+ *
+ * constructor(private videoConstraints: VideoCaptureConstraints) {
+ *   console.log(this.videoConstraints.hdCons); // Access HD constraints
+ * }
+ * ```
+ *
+ * @remarks
+ * This service contains predefined constraints that can be used for video capture
+ * settings based on the desired quality and aspect ratio. These constraints can
+ * be applied when requesting media streams from the user's camera.
+ *
+ * @property {Object} QnHDCons - Video capture constraints for QnHD resolution (320x180).
+ * @property {Object} sdCons - Video capture constraints for SD resolution (640x360).
+ * @property {Object} hdCons - Video capture constraints for HD resolution (1280x720).
+ * @property {Object} fhdCons - Video capture constraints for FHD resolution (1920x1080).
+ * @property {Object} qhdCons - Video capture constraints for QHD resolution (2560x1440).
+ *
+ * @property {Object} QnHDConsPort - Video capture constraints for QnHD resolution in portrait mode.
+ * @property {Object} sdConsPort - Video capture constraints for SD resolution in portrait mode.
+ * @property {Object} hdConsPort - Video capture constraints for HD resolution in portrait mode.
+ * @property {Object} fhdConsPort - Video capture constraints for FHD resolution in portrait mode.
+ * @property {Object} qhdConsPort - Video capture constraints for QHD resolution in portrait mode.
+ *
+ * @property {Object} QnHDConsNeu - Video capture constraints for QnHD resolution in neutral mode.
+ * @property {Object} sdConsNeu - Video capture constraints for SD resolution in neutral mode.
+ * @property {Object} hdConsNeu - Video capture constraints for HD resolution in neutral mode.
+ * @property {Object} fhdConsNeu - Video capture constraints for FHD resolution in neutral mode.
+ * @property {Object} qhdConsNeu - Video capture constraints for QnHD resolution in neutral mode.
+ *
+ * @property {number} QnHDFrameRate - Frame rate for QnHD video capture (5 FPS).
+ * @property {number} sdFrameRate - Frame rate for SD video capture (10 FPS).
+ * @property {number} hdFrameRate - Frame rate for HD video capture (15 FPS).
+ * @property {number} fhdFrameRate - Frame rate for FHD video capture (20 FPS).
+ * @property {number} qhdFrameRate - Frame rate for QHD video capture (30 FPS).
+ * @property {number} screenFrameRate - Frame rate for screen capture (30 FPS).
+ *
+ * @returns {VideoCaptureConstraints} The video capture constraints for use in media requests.
+ */
 export declare class VideoCaptureConstraints {
     QnHDCons: {
         width: {

package/dist/lib/methods/utils/sleep.util.d.ts

@@ -5,8 +5,14 @@ export type SleepType = (options: SleepOptions) => Promise<void>;
 /**
  * Pauses the execution for a specified number of milliseconds.
  *
- * @param {SleepOptions} options - An object containing the sleep duration.
- * @param {number} options.ms - The number of milliseconds to sleep.
- * @returns {Promise<void>} A promise that resolves after the specified duration.
+ * @param {SleepOptions} options - Contains the duration to pause.
+ * @param {number} options.ms - Number of milliseconds to delay.
+ * @returns {Promise<void>} Resolves after the specified duration.
+ *
+ * @example
+ * ```typescript
+ * await sleep({ ms: 2000 });
+ * // Pauses execution for 2 seconds
+ * ```
  */
 export declare function sleep({ ms }: SleepOptions): Promise<void>;

package/dist/lib/methods/utils/sound-player.service.d.ts

@@ -4,6 +4,27 @@ export interface SoundPlayerOptions {
     soundUrl: string;
 }
 export type SoundPlayerType = (options: SoundPlayerOptions) => void;
+/**
+ * SoundPlayer service for playing a sound from a provided URL.
+ *
+ * @class SoundPlayer
+ * @implements {OnInit}
+ *
+ * @example
+ * ```typescript
+ * const soundUrl = 'https://example.com/sound.mp3';
+ * const soundPlayer = new SoundPlayer();
+ * soundPlayer.playSound({ soundUrl });
+ * ```
+ *
+ * ### Details
+ * - **soundUrl**: URL to the sound file that will be played.
+ * - **playSound**: Initiates the audio playback.
+ * - **ngOnInit**: Automatically triggers sound playback if `soundUrl` is set.
+ *
+ * @param {SoundPlayerOptions} options - Contains the URL of the sound to play.
+ * @returns {void} - No return; sound is played asynchronously.
+ */
 export declare class SoundPlayer implements OnInit {
     soundUrl: string | undefined;
     ngOnInit(): void;

package/dist/lib/methods/utils/validate-alphanumeric.service.d.ts

@@ -3,6 +3,22 @@ export interface ValidateAlphanumericOptions {
     str: string;
 }
 export type ValidateAlphanumericType = (options: ValidateAlphanumericOptions) => Promise<boolean>;
+/**
+ * Service to validate if a given string contains only alphanumeric characters.
+ *
+ * @class ValidateAlphanumeric
+ *
+ * @example
+ * ```typescript
+ * const validator = new ValidateAlphanumeric();
+ * validator.validateAlphanumeric({ str: 'abc123' }).then(isValid => console.log(isValid)); // true
+ * validator.validateAlphanumeric({ str: 'abc 123!' }).then(isValid => console.log(isValid)); // false
+ * ```
+ *
+ * @param {ValidateAlphanumericOptions} options - Contains the string to validate.
+ * @param {string} options.str - The input string that needs to be validated.
+ * @returns {Promise<boolean>} - A promise resolving to `true` if the input string is alphanumeric, otherwise `false`.
+ */
 export declare class ValidateAlphanumeric {
     /**
      * Validates if the given string contains only alphanumeric characters.

package/dist/lib/methods/waiting-methods/launch-waiting.service.d.ts

@@ -4,6 +4,24 @@ export interface LaunchWaitingOptions {
     isWaitingModalVisible: boolean;
 }
 export type LaunchWaitingType = (options: LaunchWaitingOptions) => void;
+/**
+ * Service to toggle the visibility of a waiting modal.
+ *
+ * @param {LaunchWaitingOptions} options - The options to control the waiting modal visibility.
+ * @param {Function} options.updateIsWaitingModalVisible - Function to update the visibility of the waiting modal.
+ * @param {boolean} options.isWaitingModalVisible - Current visibility state of the waiting modal.
+ *
+ * @example
+ * ```typescript
+ * const launchWaitingService = new LaunchWaiting();
+ * launchWaitingService.launchWaiting({
+ *   updateIsWaitingModalVisible: (isVisible) => console.log(`Modal is now ${isVisible ? 'visible' : 'hidden'}`),
+ *   isWaitingModalVisible: false,
+ * });
+ * ```
+ *
+ * This example toggles the modal's visibility state, making it visible if it was hidden and vice versa.
+ */
 export declare class LaunchWaiting {
     /**
      * Toggles the visibility of the waiting modal.

package/dist/lib/methods/waiting-methods/respond-to-waiting.service.d.ts

@@ -11,6 +11,35 @@ export interface RespondToWaitingOptions {
     socket: Socket;
 }
 export type RespondToWaitingType = (options: RespondToWaitingOptions) => Promise<void>;
+/**
+ * Handles the response to a participant in the waiting room, either allowing or denying their entry.
+ *
+ * @param {RespondToWaitingOptions} options - Options for handling the participant's entry request.
+ * @param {string} options.participantId - Unique identifier for the participant.
+ * @param {string} options.participantName - Name of the participant.
+ * @param {Function} options.updateWaitingList - Function to update the waiting list by removing the responded participant.
+ * @param {WaitingRoomParticipant[]} options.waitingList - Current list of participants in the waiting room.
+ * @param {boolean | string} options.type - Indicates whether to allow ("true") or deny ("false") the participant's entry.
+ * @param {string} options.roomName - The name of the room the participant is requesting to join.
+ * @param {Socket} options.socket - The socket instance used to emit the response event.
+ * @returns {Promise<void>} Resolves when the response has been processed.
+ *
+ * @example
+ * ```typescript
+ * const respondService = new RespondToWaiting();
+ * respondService.respondToWaiting({
+ *   participantId: '12345',
+ *   participantName: 'John Doe',
+ *   updateWaitingList: (newList) => console.log('Updated Waiting List:', newList),
+ *   waitingList: currentWaitingList,
+ *   type: 'true',
+ *   roomName: 'Room1',
+ *   socket: io('http://localhost:3000'),
+ * });
+ * ```
+ *
+ * In this example, the participant 'John Doe' is allowed to join 'Room1', and the updated waiting list is logged.
+ */
 export declare class RespondToWaiting {
     /**
      * Responds to a participant waiting to join a room by either allowing or denying their entry.

package/dist/lib/methods/whiteboard-methods/capture-canvas-stream.service.d.ts

@@ -20,6 +20,35 @@ export interface CaptureCanvasStreamOptions {
     start?: boolean;
 }
 export type CaptureCanvasStreamType = (options: CaptureCanvasStreamOptions) => Promise<void>;
+/**
+ * Manages capturing and streaming from a canvas element.
+ *
+ * @param {CaptureCanvasStreamOptions} options - Options to control canvas streaming.
+ * @param {CaptureCanvasStreamParameters} options.parameters - Object containing media settings and state management functions.
+ * @param {boolean} [options.start=true] - If `true`, initiates canvas capture; if `false`, stops the capture.
+ * @returns {Promise<void>} A promise that resolves once the canvas stream has started or stopped.
+ *
+ * The function first checks the availability of `canvasWhiteboard` to capture the canvas stream. If unavailable, it attempts multiple times until a timeout. If successful:
+ * - It starts the canvas capture, creating or reconnecting the transport for streaming.
+ * - If stopping, it disconnects the transport and halts the stream.
+ *
+ * @example
+ * ```typescript
+ * const captureService = new CaptureCanvasStream();
+ * captureService.captureCanvasStream({
+ *   parameters: {
+ *     canvasWhiteboard: document.getElementById('myCanvas') as HTMLCanvasElement,
+ *     updateCanvasStream: (stream) => console.log('Canvas Stream:', stream),
+ *     screenProducer: null,
+ *     transportCreated: false,
+ *     // other required parameters...
+ *   },
+ *   start: true
+ * });
+ * ```
+ *
+ * This example initiates a capture of `myCanvas`, updating the canvas stream upon successful connection.
+ */
 export declare class CaptureCanvasStream {
     /**
      * Capture the canvas stream.