mediasfu-angular 1.0.1 → 2.0.0

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

@@ -1,13 +1,18 @@
 import { Producer } from 'mediasoup-client/lib/types';
 import { ConnectSendTransportScreenType, CreateSendTransportType, DisconnectSendTransportScreenType, SleepType, CreateSendTransportParameters, DisconnectSendTransportScreenParameters, ConnectSendTransportScreenParameters } from '../../@types/types';
+import { Socket } from 'socket.io-client';
 import * as i0 from "@angular/core";
 export interface CaptureCanvasStreamParameters extends CreateSendTransportParameters, DisconnectSendTransportScreenParameters, ConnectSendTransportScreenParameters {
     canvasWhiteboard: HTMLCanvasElement | null;
     canvasStream: MediaStream | null;
     updateCanvasStream: (stream: MediaStream | null) => void;
     screenProducer: Producer | null;
+    localScreenProducer?: Producer | null;
     transportCreated: boolean;
+    localTransportCreated?: boolean;
+    localSocket?: Socket;
     updateScreenProducer: (producer: Producer | null) => void;
+    updateLocalScreenProducer?: (localProducer: Producer | null) => void;
     sleep: SleepType;
     createSendTransport: CreateSendTransportType;
     connectSendTransportScreen: ConnectSendTransportScreenType;
@@ -20,6 +25,47 @@ export interface CaptureCanvasStreamOptions {
     start?: boolean;
 }
 export type CaptureCanvasStreamType = (options: CaptureCanvasStreamOptions) => Promise<void>;
+/**
+ * Captures the canvas stream and handles the transport connection for screen sharing.
+ *
+ * @param {CaptureCanvasStreamOptions} options - The options for capturing the canvas stream.
+ * @param {Object} options.parameters - The parameters required for capturing and managing the canvas stream.
+ * @param {HTMLCanvasElement} options.parameters.canvasWhiteboard - The canvas element to capture the stream from.
+ * @param {MediaStream} [options.parameters.canvasStream] - The current canvas stream, if any.
+ * @param {Function} options.parameters.updateCanvasStream - Function to update the canvas stream state.
+ * @param {Producer | null} [options.parameters.screenProducer] - The current screen producer, if any.
+ * @param {Producer | null} [options.parameters.localScreenProducer] - The current local screen producer, if any.
+ * @param {boolean} [options.parameters.transportCreated] - Flag indicating if the transport has been created.
+ * @param {boolean} [options.parameters.localTransportCreated] - Flag indicating if the local transport has been created.
+ * @param {Socket} [options.parameters.localSocket] - The local socket instance used for communication.
+ * @param {Function} options.parameters.updateScreenProducer - Function to update the screen producer state.
+ * @param {Function} options.parameters.updateLocalScreenProducer - Function to update the local screen producer state.
+ * @param {Function} options.parameters.sleep - Function to pause execution for a specified duration.
+ * @param {Function} options.parameters.createSendTransport - Function to create a send transport for the screen.
+ * @param {Function} options.parameters.connectSendTransportScreen - Function to connect the send transport for the screen.
+ * @param {Function} options.parameters.disconnectSendTransportScreen - Function to disconnect the send transport for the screen.
+ * @param {boolean} [start=true] - Flag indicating whether to start or stop the canvas stream.
+ * @returns {Promise<void>} A promise that resolves when the operation is complete.
+ *
+ * @example
+ * ```typescript
+ * const canvasElement = document.querySelector('#canvas') as HTMLCanvasElement;
+ * const options = {
+ *   parameters: {
+ *     canvasWhiteboard: canvasElement,
+ *     updateCanvasStream: (stream) => console.log("Canvas Stream Updated:", stream),
+ *     updateScreenProducer: (producer) => console.log("Screen Producer Updated:", producer),
+ *     updateLocalScreenProducer: (localProducer) => console.log("Local Screen Producer Updated:", localProducer),
+ *     createSendTransport: async (params) => console.log("Transport created with", params),
+ *     connectSendTransportScreen: async (options) => console.log("Transport connected with", options),
+ *     disconnectSendTransportScreen: async (params) => console.log("Transport disconnected with", params),
+ *     sleep: ({ ms }) => new Promise(resolve => setTimeout(resolve, ms)),
+ *   },
+ *   start: true,
+ * };
+ * await captureCanvasStream(options);
+ * ```
+ */
 export declare class CaptureCanvasStream {
     /**
      * Capture the canvas stream.

package/dist/lib/methods/whiteboard-methods/launch-configure-whiteboard.service.d.ts

@@ -4,6 +4,26 @@ export interface LaunchConfigureWhiteboardOptions {
     isConfigureWhiteboardModalVisible: boolean;
 }
 export type LaunchConfigureWhiteboardType = (options: LaunchConfigureWhiteboardOptions) => void;
+/**
+ * Toggles the visibility of the configure whiteboard modal.
+ *
+ * @param {LaunchConfigureWhiteboardOptions} options - Options to control whiteboard configuration modal.
+ * @param {Function} options.updateIsConfigureWhiteboardModalVisible - Function to update the modal's visibility state.
+ * @param {boolean} options.isConfigureWhiteboardModalVisible - Current visibility state of the configure whiteboard modal.
+ *
+ * This function uses the current visibility state to toggle the whiteboard configuration modal on or off.
+ *
+ * @example
+ * ```typescript
+ * const launchService = new LaunchConfigureWhiteboard();
+ * launchService.launchConfigureWhiteboard({
+ *   updateIsConfigureWhiteboardModalVisible: (visible) => console.log('Modal Visible:', visible),
+ *   isConfigureWhiteboardModalVisible: false
+ * });
+ * ```
+ *
+ * In this example, the modal visibility state is toggled, and the updated visibility state is logged.
+ */
 export declare class LaunchConfigureWhiteboard {
     /**
      * Toggles the visibility of the configure whiteboard modal.

package/dist/lib/producer-client/producer-client-emits/create-device-client.service.d.ts

@@ -4,6 +4,29 @@ export interface CreateDeviceClientOptions {
     rtpCapabilities: RtpCapabilities | null;
 }
 export type CreateDeviceClientType = (options: CreateDeviceClientOptions) => Promise<Device | null>;
+/**
+ * Creates a mediasoup client device using the provided RTP capabilities.
+ *
+ * @param {CreateDeviceClientOptions} options - Options containing the required RTP capabilities.
+ * @param {RtpCapabilities | null} options.rtpCapabilities - The RTP capabilities necessary for initializing the device.
+ * @returns {Promise<Device | null>} - A promise resolving to the created `Device` instance or `null` if creation fails.
+ * @throws {Error} - Throws an error if RTP capabilities or the mediasoup client library are not provided, or if the device is unsupported by the browser.
+ *
+ * This function initializes a mediasoup client `Device` using the specified RTP capabilities, enabling communication capabilities according to provided media configurations. It filters out unsupported video orientation extensions and loads router capabilities, ensuring compatibility with client configurations.
+ *
+ * @example
+ * ```typescript
+ * const client = new CreateDeviceClient();
+ * const device = await client.createDeviceClient({ rtpCapabilities });
+ * if (device) {
+ *   console.log('Device created successfully:', device);
+ * } else {
+ *   console.log('Failed to create device.');
+ * }
+ * ```
+ *
+ * In this example, the function creates a device based on RTP capabilities, handling errors and unsupported devices gracefully.
+ */
 export declare class CreateDeviceClient {
     /**
      * Creates a mediasoup client device with the provided RTP capabilities.

package/dist/lib/producer-client/producer-client-emits/join-room-client.service.d.ts

@@ -12,6 +12,37 @@ export interface JoinRoomClientOptions {
     consume?: boolean;
 }
 export type JoinRoomClientType = (params: JoinRoomClientOptions) => Promise<any>;
+/**
+ * Facilitates joining a room by emitting the `joinRoom` event to the server through a socket connection.
+ *
+ * @param {JoinRoomClientOptions} options - Configuration options for joining the room.
+ * @param {Socket} options.socket - The socket instance for server communication.
+ * @param {string} options.roomName - The name of the room to join.
+ * @param {string} options.islevel - Level identifier for the user in the room.
+ * @param {string} options.member - Member identifier for the joining user.
+ * @param {string} options.sec - Security token or identifier for access.
+ * @param {string} options.apiUserName - API username for server authentication.
+ * @param {boolean} [options.consume=false] - If `true`, joins via `joinConRoom`; otherwise, joins via `joinRoom`.
+ * @returns {Promise<any>} - A promise resolving with the server response data.
+ * @throws {Error} - Throws an error if the room joining attempt fails.
+ *
+ * @example
+ * ```typescript
+ * const joinRoomClient = new JoinRoomClient(joinRoomService, joinConRoomService);
+ * const response = await joinRoomClient.joinRoomClient({
+ *   socket: mySocket,
+ *   roomName: 'myRoom',
+ *   islevel: '1',
+ *   member: 'user123',
+ *   sec: 'secureToken',
+ *   apiUserName: 'apiUser',
+ *   consume: true,
+ * });
+ * console.log('Joined room with response:', response);
+ * ```
+ *
+ * This example demonstrates using `joinRoomClient` to join a room, either as a consumer or a producer, based on the `consume` flag.
+ */
 export declare class JoinRoomClient {
     private JoinRoomService;
     private JoinConRoomService;

package/dist/lib/producer-client/producer-client-emits/update-room-parameters-client.service.d.ts

@@ -87,6 +87,50 @@ export type UpdateRoomParametersClientOptions = {
     parameters: UpdateRoomParametersClientParameters;
 };
 export type UpdateRoomParametersClientType = (options: UpdateRoomParametersClientOptions) => void;
+/**
+ * Updates room parameters for the client after joining a room and receiving server-provided parameters.
+ *
+ * @param {UpdateRoomParametersClientOptions} options - An object containing:
+ *  - various room settings and parameters,
+ *  - functions to update those parameters.
+ *
+ * - **Screen/Page Settings:** Adjusts screen and item page limits, meeting room parameters, and video constraints based on server data.
+ * - **Recording and Media Settings:** Applies bitrate and frame rate adjustments, based on the target resolution and media options.
+ * - **Role-Specific Settings:** Configures admin, host, and co-host settings for permissions, orientations, and resolutions.
+ * - **Alerting**: Uses `showAlert` to notify the client on issues or permissions restrictions.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   parameters: {
+ *     rtpCapabilities: myRtpCapabilities,
+ *     roomRecvIPs: ['192.168.1.1'],
+ *     meetingRoomParams: myMeetingParams,
+ *     itemPageLimit: 3,
+ *     audioOnlyRoom: false,
+ *     addForBasic: true,
+ *     screenPageLimit: 2,
+ *     shareScreenStarted: false,
+ *     shared: true,
+ *     targetOrientation: 'landscape',
+ *     recordingVideoSupport: true,
+ *     frameRate: 15,
+ *     adminPasscode: 'admin123',
+ *     eventType: 'conference',
+ *     youAreCoHost: false,
+ *     updateRtpCapabilities: (rtp) => console.log('Updating RTP:', rtp),
+ *     updateRoomRecvIPs: (ips) => console.log('Updating IPs:', ips),
+ *     updateMeetingRoomParams: (params) => console.log('Updating room params:', params),
+ *     // Additional parameters...
+ *   },
+ * };
+ *
+ * const updateRoomParametersClient = new UpdateRoomParametersClient(videoCaptureConstraints, hParams, vParams, screenParams, aParams);
+ * updateRoomParametersClient.updateRoomParametersClient(options);
+ * ```
+ *
+ * This example demonstrates setting up room parameters for a conference-type room with recording support and custom update functions.
+ */
 export declare class UpdateRoomParametersClient {
     private videoCaptureConstraints;
     private hParams;

package/dist/lib/producers/producer-emits/join-con-room.service.d.ts

@@ -20,6 +20,44 @@ export interface JoinConRoomResponse {
     [key: string]: any;
 }
 export type JoinConRoomType = (options: JoinConRoomOptions) => Promise<JoinConRoomResponse>;
+/**
+ * Joins a conference room with the provided options and performs validation checks.
+ *
+ * @param {JoinConRoomOptions} options - Contains:
+ *   - socket: Socket instance for communication.
+ *   - roomName: Name of the room to join.
+ *   - islevel: User level within the room.
+ *   - member: Member identifier.
+ *   - sec: Security token.
+ *   - apiUserName: API username for authentication.
+ *
+ * - **Validation**:
+ *   - Checks that `roomName`, `apiUserName`, and `member` are alphanumeric.
+ *   - Ensures `roomName` starts with 's' or 'p' and meets length requirements.
+ *   - Verifies `sec`, `islevel`, and `apiUserName` comply with length and format expectations.
+ *
+ * - **Response Handling**:
+ *   - Resolves to the server's response data upon a successful join.
+ *   - Rejects with specific reasons if the user is banned, suspended, or if the room host is not present.
+ *
+ * @returns {Promise<JoinConRoomResponse>} Resolves with the join response data, or rejects with error details.
+ * @throws {Error} Throws validation errors or issues encountered while joining the room.
+ *
+ * @example
+ * ```typescript
+ * const joinOptions = {
+ *   socket: mySocket,
+ *   roomName: 'sMyRoom',
+ *   islevel: '1',
+ *   member: 'participant123',
+ *   sec: '64-character-long-secret-key-here...',
+ *   apiUserName: 'apiUser123',
+ * };
+ * joinConRoom(joinOptions)
+ *   .then(response => console.log('Joined room:', response))
+ *   .catch(error => console.error('Failed to join room:', error));
+ * ```
+ */
 export declare class JoinConRoom {
     private validateAlphanumeric;
     constructor(validateAlphanumeric: ValidateAlphanumeric);

package/dist/lib/producers/producer-emits/join-local-room.service.d.ts

@@ -0,0 +1,125 @@
+import { Socket } from 'socket.io-client';
+import { ValidateAlphanumeric } from '../../methods/utils/validate-alphanumeric.service';
+import { ResponseJoinLocalRoom, PreJoinPageParameters } from '../../@types/types';
+import { CheckLimitsAndMakeRequest } from '../../methods/utils/check-limits-and-make-request.service';
+import { JoinRoomOnMediaSFU } from '../../methods/utils/join-room-on-media-sfu.service';
+import * as i0 from "@angular/core";
+export interface JoinLocalRoomOptions {
+    socket: Socket;
+    roomName: string;
+    islevel: string;
+    member: string;
+    sec: string;
+    apiUserName: string;
+    parameters: PreJoinPageParameters;
+    checkConnect?: boolean;
+}
+export type JoinLocalRoomType = (options: JoinLocalRoomOptions) => Promise<ResponseJoinLocalRoom>;
+export interface CheckMediasfuURLOptions {
+    data: ResponseJoinLocalRoom;
+    member: string;
+    roomName: string;
+    islevel: string;
+    socket: Socket;
+    parameters: PreJoinPageParameters;
+}
+export type CheckMediasfuURLType = (options: CheckMediasfuURLOptions) => Promise<void>;
+/**
+ * Checks the MediaSFU URL and processes the necessary actions based on the URL's validity.
+ *
+ * @param {CheckMediasfuURLOptions} options - The options for checking and handling the MediaSFU URL.
+ * @param {ResponseJoinLocalRoom} options.data - The data received from the room join response.
+ * @param {string} options.member - The member identifier.
+ * @param {string} options.roomName - The name of the room to join.
+ * @param {string} options.islevel - The level of the user.
+ * @param {Socket} options.socket - The socket instance to use for communication.
+ * @param {PreJoinPageParameters} options.parameters - Additional parameters for pre-join page actions.
+ *
+ * @returns {Promise<void>} A promise that resolves when the actions are complete.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   data: {
+ *     mediasfuURL: "https://example.com/meet/room123/secret",
+ *     allowRecord: true,
+ *     apiKey: "1234567890123456789012345678901234567890123456789012345678901234",
+ *     apiUserName: "user123",
+ *   },
+ *   member: "user123",
+ *   roomName: "s12345678",
+ *   islevel: "1",
+ *   socket: socketInstance,
+ *   parameters: {
+ *     someParameter: "value",
+ *   },
+ * };
+ *
+ * try {
+ *   await checkMediasfuURL(options);
+ *   console.log("MediaSFU URL processed successfully.");
+ * } catch (error) {
+ *   console.error("Failed to process MediaSFU URL:", error);
+ * }
+ * ```
+ */
+export declare class JoinLocalRoom {
+    private validateAlphanumericService;
+    private checkLimitsService;
+    private joinRoomOnMediaSFU;
+    constructor(validateAlphanumericService: ValidateAlphanumeric, checkLimitsService: CheckLimitsAndMakeRequest, joinRoomOnMediaSFU: JoinRoomOnMediaSFU);
+    /**
+     * Checks the MediaSFU URL and processes the necessary actions based on the URL's validity.
+     *
+     * @param {CheckMediasfuURLOptions} options - The options for checking and handling the MediaSFU URL.
+     * @param {ResponseJoinLocalRoom} options.data - The data received from the room join response.
+     * @param {string} options.member - The member identifier.
+     * @param {string} options.roomName - The name of the room to join.
+     * @param {string} options.islevel - The level of the user.
+     * @param {Socket} options.socket - The socket instance to use for communication.
+     * @param {PreJoinPageParameters} options.parameters - Additional parameters for pre-join page actions.
+     *
+     * @returns {Promise<void>} A promise that resolves when the actions are complete.
+     *
+     * @example
+     * ```typescript
+     * const options = {
+     *   data: {
+     *     mediasfuURL: "https://example.com/meet/room123/secret",
+     *     allowRecord: true,
+     *     apiKey: "1234567890123456789012345678901234567890123456789012345678901234",
+     *     apiUserName: "user123",
+     *   },
+     *   member: "user123",
+     *   roomName: "s12345678",
+     *   islevel: "1",
+     *   socket: socketInstance,
+     *   parameters: {
+     *     someParameter: "value",
+     *   },
+     * };
+     *
+     * try {
+     *   await checkMediasfuURL(options);
+     *   console.log("MediaSFU URL processed successfully.");
+     * } catch (error) {
+     *   console.error("Failed to process MediaSFU URL:", error);
+     * }
+     * ```
+     */
+    joinLocalRoom(options: JoinLocalRoomOptions): Promise<ResponseJoinLocalRoom>;
+    /**
+     * Checks the MediaSFU URL and processes necessary actions based on its validity.
+     *
+     * @param {Object} options - Contains:
+     *   - `data`: Data received from the room join response.
+     *   - `member`: User identifier.
+     *   - `roomName`: Name of the room to join.
+     *   - `islevel`: User's level indicator.
+     *   - `socket`: Socket instance for communication.
+     *   - `parameters`: Additional parameters for pre-join page actions.
+     */
+    private checkMediasfuURL;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JoinLocalRoom, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<JoinLocalRoom>;
+}

package/dist/lib/producers/producer-emits/join-room.service.d.ts

@@ -10,6 +10,44 @@ export interface JoinRoomOptions {
     apiUserName: string;
 }
 export type JoinRoomType = (socket: Socket, roomName: string, islevel: string, member: string, sec: string, apiUserName: string) => Promise<object>;
+/**
+ * Joins a user to a room using socket communication with validation checks.
+ *
+ * @param {JoinRoomOptions} options - Contains:
+ *   - `socket`: Socket instance for communication.
+ *   - `roomName`: Name of the room to join.
+ *   - `islevel`: User's level indicator.
+ *   - `member`: User identifier.
+ *   - `sec`: Security token.
+ *   - `apiUserName`: API username for authentication.
+ *
+ * - **Validation**:
+ *   - Ensures `roomName`, `apiUserName`, and `member` are alphanumeric.
+ *   - Verifies that `roomName` starts with 's' or 'p' and meets length requirements.
+ *   - Validates `sec`, `islevel`, and `apiUserName` against specified length and format conditions.
+ *
+ * - **Response Handling**:
+ *   - Resolves with the server's response upon a successful join.
+ *   - Rejects with a descriptive error if the user is banned, suspended, or if the host has not yet joined the room.
+ *
+ * @returns {Promise<object>} Resolves with data from the 'joinRoom' event or rejects with validation errors.
+ * @throws {Error} Throws errors encountered during validation or join process.
+ *
+ * @example
+ * ```typescript
+ * const joinOptions = {
+ *   socket: mySocket,
+ *   roomName: 'sMyRoom',
+ *   islevel: '1',
+ *   member: 'participant123',
+ *   sec: '64-character-secure-key...',
+ *   apiUserName: 'apiUser123',
+ * };
+ * joinRoom(joinOptions)
+ *   .then(response => console.log('Room joined:', response))
+ *   .catch(error => console.error('Join failed:', error));
+ * ```
+ */
 export declare class JoinRoom {
     private validateAlphanumeric;
     constructor(validateAlphanumeric: ValidateAlphanumeric);