mediasfu-angular 1.0.1 → 1.0.2

package/dist/esm2022/lib/methods/utils/producer/screen-params.service.mjs

@@ -1,5 +1,42 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * 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 class ScreenParams {
     screenParams = {
         encodings: [
@@ -21,4 +58,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NyZWVuLXBhcmFtcy5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbWVkaWFzZnUtYW5ndWxhci9zcmMvbGliL21ldGhvZHMvdXRpbHMvcHJvZHVjZXIvc2NyZWVuLXBhcmFtcy5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBVTNDLE1BQU0sT0FBTyxZQUFZO0lBQ3ZCLFlBQVksR0FBcUI7UUFDL0IsU0FBUyxFQUFFO1lBQ1Q7Z0JBQ0UsR0FBRyxFQUFFLElBQUk7Z0JBQ1QsVUFBVSxFQUFFLE9BQU87YUFDcEI7U0FDRjtRQUNELFlBQVksRUFBRTtZQUNaLHVCQUF1QixFQUFFLElBQUk7U0FDOUI7S0FDRixDQUFDO3VHQVhTLFlBQVk7MkdBQVosWUFBWSxjQUZYLE1BQU07OzJGQUVQLFlBQVk7a0JBSHhCLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgUHJvZHVjZXJDb2RlY09wdGlvbnMsIFJ0cEVuY29kaW5nUGFyYW1ldGVycyB9IGZyb20gJ21lZGlhc291cC1jbGllbnQvbGliL3R5cGVzJztcbmV4cG9ydCB0eXBlIFNjcmVlblBhcmFtc1R5cGUgPSB7XG4gIGVuY29kaW5nczogUnRwRW5jb2RpbmdQYXJhbWV0ZXJzW107XG4gIGNvZGVjT3B0aW9ucz86IFByb2R1Y2VyQ29kZWNPcHRpb25zO1xufTtcblxuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCcsXG59KVxuZXhwb3J0IGNsYXNzIFNjcmVlblBhcmFtcyB7XG4gIHNjcmVlblBhcmFtczogU2NyZWVuUGFyYW1zVHlwZSA9IHtcbiAgICBlbmNvZGluZ3M6IFtcbiAgICAgIHtcbiAgICAgICAgcmlkOiAncjcnLFxuICAgICAgICBtYXhCaXRyYXRlOiAzMDAwMDAwLFxuICAgICAgfSxcbiAgICBdLFxuICAgIGNvZGVjT3B0aW9uczoge1xuICAgICAgdmlkZW9Hb29nbGVTdGFydEJpdHJhdGU6IDEwMDAsXG4gICAgfSxcbiAgfTtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/methods/utils/producer/v-params.service.mjs

@@ -1,5 +1,55 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * 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 class VParams {
     vParams = {
         encodings: [
@@ -34,4 +84,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/methods/utils/producer/video-capture-constraints.service.mjs

@@ -1,5 +1,51 @@
 import { Injectable } from '@angular/core';
 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 class VideoCaptureConstraints {
     // Landscape display sizes
     QnHDCons = { width: { ideal: 320 }, height: { ideal: 180 } };
@@ -35,4 +81,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmlkZW8tY2FwdHVyZS1jb25zdHJhaW50cy5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbWVkaWFzZnUtYW5ndWxhci9zcmMvbGliL21ldGhvZHMvdXRpbHMvcHJvZHVjZXIvdmlkZW8tY2FwdHVyZS1jb25zdHJhaW50cy5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBSzNDLE1BQU0sT0FBTyx1QkFBdUI7SUFDbEMsMEJBQTBCO0lBQzFCLFFBQVEsR0FBRyxFQUFFLEtBQUssRUFBRSxFQUFFLEtBQUssRUFBRSxHQUFHLEVBQUUsRUFBRSxNQUFNLEVBQUUsRUFBRSxLQUFLLEVBQUUsR0FBRyxFQUFFLEVBQUUsQ0FBQztJQUM3RCxNQUFNLEdBQUcsRUFBRSxLQUFLLEVBQUUsRUFBRSxLQUFLLEVBQUUsR0FBRyxFQUFFLEVBQUUsTUFBTSxFQUFFLEVBQUUsS0FBSyxFQUFFLEdBQUcsRUFBRSxFQUFFLENBQUM7SUFDM0QsTUFBTSxHQUFHLEVBQUUsS0FBSyxFQUFFLEVBQUUsS0FBSyxFQUFFLElBQUksRUFBRSxFQUFFLE1BQU0sRUFBRSxFQUFFLEtBQUssRUFBRSxHQUFHLEVBQUUsRUFBRSxDQUFDO0lBQzVELE9BQU8sR0FBRyxFQUFFLEtBQUssRUFBRSxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUUsRUFBRSxNQUFNLEVBQUUsRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFLEVBQUUsQ0FBQztJQUM5RCxPQUFPLEdBQUcsRUFBRSxLQUFLLEVBQUUsRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFLEVBQUUsTUFBTSxFQUFFLEVBQUUsS0FBSyxFQUFFLElBQUksRUFBRSxFQUFFLENBQUM7SUFFOUQseUJBQXlCO0lBQ3pCLFlBQVksR0FBRyxFQUFFLEtBQUssRUFBRSxFQUFFLEtBQUssRUFBRSxHQUFHLEVBQUUsRUFBRSxNQUFNLEVBQUUsRUFBRSxLQUFLLEVBQUUsR0FBRyxFQUFFLEVBQUUsQ0FBQztJQUNqRSxVQUFVLEdBQUcsRUFBRSxLQUFLLEVBQUUsRUFBRSxLQUFLLEVBQUUsR0FBRyxFQUFFLEVBQUUsTUFBTSxFQUFFLEVBQUUsS0FBSyxFQUFFLEdBQUcsRUFBRSxFQUFFLENBQUM7SUFDL0QsVUFBVSxHQUFHLEVBQUUsS0FBSyxFQUFFLEVBQUUsS0FBSyxFQUFFLEdBQUcsRUFBRSxFQUFFLE1BQU0sRUFBRSxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUUsRUFBRSxDQUFDO0lBQ2hFLFdBQVcsR0FBRyxFQUFFLEtBQUssRUFBRSxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUUsRUFBRSxNQUFNLEVBQUUsRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFLEVBQUUsQ0FBQztJQUNsRSxXQUFXLEdBQUcsRUFBRSxLQUFLLEVBQUUsRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFLEVBQUUsTUFBTSxFQUFFLEVBQUUsS0FBSyxFQUFFLElBQUksRUFBRSxFQUFFLENBQUM7SUFFbEUsaUNBQWlDO0lBQ2pDLFdBQVcsR0FBRyxFQUFFLEtBQUssRUFBRSxFQUFFLEtBQUssRUFBRSxHQUFHLEVBQUUsRUFBRSxNQUFNLEVBQUUsRUFBRSxLQUFLLEVBQUUsR0FBRyxFQUFFLEVBQUUsQ0FBQztJQUNoRSxTQUFTLEdBQUcsRUFBRSxLQUFLLEVBQUUsRUFBRSxLQUFLLEVBQUUsR0FBRyxFQUFFLEVBQUUsTUFBTSxFQUFFLEVBQUUsS0FBSyxFQUFFLEdBQUcsRUFBRSxFQUFFLENBQUM7SUFDOUQsU0FBUyxHQUFHLEVBQUUsS0FBSyxFQUFFLEVBQUUsS0FBSyxFQUFFLEdBQUcsRUFBRSxFQUFFLE1BQU0sRUFBRSxFQUFFLEtBQUssRUFBRSxHQUFHLEVBQUUsRUFBRSxDQUFDO0lBQzlELFVBQVUsR0FBRyxFQUFFLEtBQUssRUFBRSxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUUsRUFBRSxNQUFNLEVBQUUsRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFLEVBQUUsQ0FBQztJQUNqRSxVQUFVLEdBQUcsRUFBRSxLQUFLLEVBQUUsRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFLEVBQUUsTUFBTSxFQUFFLEVBQUUsS0FBSyxFQUFFLElBQUksRUFBRSxFQUFFLENBQUM7SUFFakUsZ0NBQWdDO0lBQ2hDLGFBQWEsR0FBRyxDQUFDLENBQUM7SUFDbEIsV0FBVyxHQUFHLEVBQUUsQ0FBQztJQUNqQixXQUFXLEdBQUcsRUFBRSxDQUFDO0lBQ2pCLFlBQVksR0FBRyxFQUFFLENBQUM7SUFDbEIsWUFBWSxHQUFHLEVBQUUsQ0FBQztJQUNsQixlQUFlLEdBQUcsRUFBRSxDQUFDO3VHQTVCVix1QkFBdUI7MkdBQXZCLHVCQUF1QixjQUZ0QixNQUFNOzsyRkFFUCx1QkFBdUI7a0JBSG5DLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290Jyxcbn0pXG5leHBvcnQgY2xhc3MgVmlkZW9DYXB0dXJlQ29uc3RyYWludHMge1xuICAvLyBMYW5kc2NhcGUgZGlzcGxheSBzaXplc1xuICBRbkhEQ29ucyA9IHsgd2lkdGg6IHsgaWRlYWw6IDMyMCB9LCBoZWlnaHQ6IHsgaWRlYWw6IDE4MCB9IH07XG4gIHNkQ29ucyA9IHsgd2lkdGg6IHsgaWRlYWw6IDY0MCB9LCBoZWlnaHQ6IHsgaWRlYWw6IDM2MCB9IH07XG4gIGhkQ29ucyA9IHsgd2lkdGg6IHsgaWRlYWw6IDEyODAgfSwgaGVpZ2h0OiB7IGlkZWFsOiA3MjAgfSB9O1xuICBmaGRDb25zID0geyB3aWR0aDogeyBpZGVhbDogMTkyMCB9LCBoZWlnaHQ6IHsgaWRlYWw6IDEwODAgfSB9O1xuICBxaGRDb25zID0geyB3aWR0aDogeyBpZGVhbDogMjU2MCB9LCBoZWlnaHQ6IHsgaWRlYWw6IDE0NDAgfSB9O1xuXG4gIC8vIFBvcnRyYWl0IGRpc3BsYXkgc2l6ZXNcbiAgUW5IRENvbnNQb3J0ID0geyB3aWR0aDogeyBpZGVhbDogMTgwIH0sIGhlaWdodDogeyBpZGVhbDogMzIwIH0gfTtcbiAgc2RDb25zUG9ydCA9IHsgd2lkdGg6IHsgaWRlYWw6IDM2MCB9LCBoZWlnaHQ6IHsgaWRlYWw6IDY0MCB9IH07XG4gIGhkQ29uc1BvcnQgPSB7IHdpZHRoOiB7IGlkZWFsOiA3MjAgfSwgaGVpZ2h0OiB7IGlkZWFsOiAxMjgwIH0gfTtcbiAgZmhkQ29uc1BvcnQgPSB7IHdpZHRoOiB7IGlkZWFsOiAxMDgwIH0sIGhlaWdodDogeyBpZGVhbDogMTkyMCB9IH07XG4gIHFoZENvbnNQb3J0ID0geyB3aWR0aDogeyBpZGVhbDogMTQ0MCB9LCBoZWlnaHQ6IHsgaWRlYWw6IDI1NjAgfSB9O1xuXG4gIC8vIE5ldXRyYWwgKFNxdWFyZSkgZGlzcGxheSBzaXplc1xuICBRbkhEQ29uc05ldSA9IHsgd2lkdGg6IHsgaWRlYWw6IDI0MCB9LCBoZWlnaHQ6IHsgaWRlYWw6IDI0MCB9IH07XG4gIHNkQ29uc05ldSA9IHsgd2lkdGg6IHsgaWRlYWw6IDQ4MCB9LCBoZWlnaHQ6IHsgaWRlYWw6IDQ4MCB9IH07XG4gIGhkQ29uc05ldSA9IHsgd2lkdGg6IHsgaWRlYWw6IDk2MCB9LCBoZWlnaHQ6IHsgaWRlYWw6IDk2MCB9IH07XG4gIGZoZENvbnNOZXUgPSB7IHdpZHRoOiB7IGlkZWFsOiAxNDQwIH0sIGhlaWdodDogeyBpZGVhbDogMTQ0MCB9IH07XG4gIHFoZENvbnNOZXUgPSB7IHdpZHRoOiB7IGlkZWFsOiAxOTIwIH0sIGhlaWdodDogeyBpZGVhbDogMTkyMCB9IH07XG5cbiAgLy8gRnJhbWUgcmF0ZXMgZm9yIHZpZGVvIGNhcHR1cmVcbiAgUW5IREZyYW1lUmF0ZSA9IDU7XG4gIHNkRnJhbWVSYXRlID0gMTA7XG4gIGhkRnJhbWVSYXRlID0gMTU7XG4gIGZoZEZyYW1lUmF0ZSA9IDIwO1xuICBxaGRGcmFtZVJhdGUgPSAzMDtcbiAgc2NyZWVuRnJhbWVSYXRlID0gMzA7XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"video-capture-constraints.service.js","sourceRoot":"","sources":["../../../../../../../projects/mediasfu-angular/src/lib/methods/utils/producer/video-capture-constraints.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAKH,MAAM,OAAO,uBAAuB;IAClC,0BAA0B;IAC1B,QAAQ,GAAG,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,CAAC;IAC7D,MAAM,GAAG,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,CAAC;IAC3D,MAAM,GAAG,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,CAAC;IAC5D,OAAO,GAAG,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,CAAC;IAC9D,OAAO,GAAG,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,CAAC;IAE9D,yBAAyB;IACzB,YAAY,GAAG,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,CAAC;IACjE,UAAU,GAAG,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,CAAC;IAC/D,UAAU,GAAG,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,CAAC;IAChE,WAAW,GAAG,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,CAAC;IAClE,WAAW,GAAG,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,CAAC;IAElE,iCAAiC;IACjC,WAAW,GAAG,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,CAAC;IAChE,SAAS,GAAG,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,CAAC;IAC9D,SAAS,GAAG,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,CAAC;IAC9D,UAAU,GAAG,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,CAAC;IACjE,UAAU,GAAG,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,CAAC;IAEjE,gCAAgC;IAChC,aAAa,GAAG,CAAC,CAAC;IAClB,WAAW,GAAG,EAAE,CAAC;IACjB,WAAW,GAAG,EAAE,CAAC;IACjB,YAAY,GAAG,EAAE,CAAC;IAClB,YAAY,GAAG,EAAE,CAAC;IAClB,eAAe,GAAG,EAAE,CAAC;uGA5BV,uBAAuB;2GAAvB,uBAAuB,cAFtB,MAAM;;2FAEP,uBAAuB;kBAHnC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\n\n/**\n * The `VideoCaptureConstraints` service provides various video capture constraints\n * including resolution and frame rate settings for different display sizes (landscape, portrait, and neutral).\n *\n * @service\n * @example\n * ```typescript\n * import { VideoCaptureConstraints } from './path/to/video-capture-constraints.service';\n *\n * constructor(private videoConstraints: VideoCaptureConstraints) {\n *   console.log(this.videoConstraints.hdCons); // Access HD constraints\n * }\n * ```\n *\n * @remarks\n * This service contains predefined constraints that can be used for video capture\n * settings based on the desired quality and aspect ratio. These constraints can\n * be applied when requesting media streams from the user's camera.\n *\n * @property {Object} QnHDCons - Video capture constraints for QnHD resolution (320x180).\n * @property {Object} sdCons - Video capture constraints for SD resolution (640x360).\n * @property {Object} hdCons - Video capture constraints for HD resolution (1280x720).\n * @property {Object} fhdCons - Video capture constraints for FHD resolution (1920x1080).\n * @property {Object} qhdCons - Video capture constraints for QHD resolution (2560x1440).\n *\n * @property {Object} QnHDConsPort - Video capture constraints for QnHD resolution in portrait mode.\n * @property {Object} sdConsPort - Video capture constraints for SD resolution in portrait mode.\n * @property {Object} hdConsPort - Video capture constraints for HD resolution in portrait mode.\n * @property {Object} fhdConsPort - Video capture constraints for FHD resolution in portrait mode.\n * @property {Object} qhdConsPort - Video capture constraints for QHD resolution in portrait mode.\n *\n * @property {Object} QnHDConsNeu - Video capture constraints for QnHD resolution in neutral mode.\n * @property {Object} sdConsNeu - Video capture constraints for SD resolution in neutral mode.\n * @property {Object} hdConsNeu - Video capture constraints for HD resolution in neutral mode.\n * @property {Object} fhdConsNeu - Video capture constraints for FHD resolution in neutral mode.\n * @property {Object} qhdConsNeu - Video capture constraints for QnHD resolution in neutral mode.\n *\n * @property {number} QnHDFrameRate - Frame rate for QnHD video capture (5 FPS).\n * @property {number} sdFrameRate - Frame rate for SD video capture (10 FPS).\n * @property {number} hdFrameRate - Frame rate for HD video capture (15 FPS).\n * @property {number} fhdFrameRate - Frame rate for FHD video capture (20 FPS).\n * @property {number} qhdFrameRate - Frame rate for QHD video capture (30 FPS).\n * @property {number} screenFrameRate - Frame rate for screen capture (30 FPS).\n *\n * @returns {VideoCaptureConstraints} The video capture constraints for use in media requests.\n */\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class VideoCaptureConstraints {\n  // Landscape display sizes\n  QnHDCons = { width: { ideal: 320 }, height: { ideal: 180 } };\n  sdCons = { width: { ideal: 640 }, height: { ideal: 360 } };\n  hdCons = { width: { ideal: 1280 }, height: { ideal: 720 } };\n  fhdCons = { width: { ideal: 1920 }, height: { ideal: 1080 } };\n  qhdCons = { width: { ideal: 2560 }, height: { ideal: 1440 } };\n\n  // Portrait display sizes\n  QnHDConsPort = { width: { ideal: 180 }, height: { ideal: 320 } };\n  sdConsPort = { width: { ideal: 360 }, height: { ideal: 640 } };\n  hdConsPort = { width: { ideal: 720 }, height: { ideal: 1280 } };\n  fhdConsPort = { width: { ideal: 1080 }, height: { ideal: 1920 } };\n  qhdConsPort = { width: { ideal: 1440 }, height: { ideal: 2560 } };\n\n  // Neutral (Square) display sizes\n  QnHDConsNeu = { width: { ideal: 240 }, height: { ideal: 240 } };\n  sdConsNeu = { width: { ideal: 480 }, height: { ideal: 480 } };\n  hdConsNeu = { width: { ideal: 960 }, height: { ideal: 960 } };\n  fhdConsNeu = { width: { ideal: 1440 }, height: { ideal: 1440 } };\n  qhdConsNeu = { width: { ideal: 1920 }, height: { ideal: 1920 } };\n\n  // Frame rates for video capture\n  QnHDFrameRate = 5;\n  sdFrameRate = 10;\n  hdFrameRate = 15;\n  fhdFrameRate = 20;\n  qhdFrameRate = 30;\n  screenFrameRate = 30;\n}\n"]}

package/dist/esm2022/lib/methods/utils/sleep.util.mjs

@@ -1,11 +1,17 @@
 /**
  * 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 function sleep({ ms }) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2xlZXAudXRpbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL21lZGlhc2Z1LWFuZ3VsYXIvc3JjL2xpYi9tZXRob2RzL3V0aWxzL3NsZWVwLnV0aWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBT0E7Ozs7OztHQU1HO0FBRUgsTUFBTSxVQUFVLEtBQUssQ0FBQyxFQUFFLEVBQUUsRUFBZ0I7SUFDeEMsT0FBTyxJQUFJLE9BQU8sQ0FBQyxDQUFDLE9BQU8sRUFBRSxFQUFFLENBQUMsVUFBVSxDQUFDLE9BQU8sRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDO0FBQzNELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIFNsZWVwT3B0aW9ucyB7XG4gIG1zOiBudW1iZXI7XG59XG5cbi8vIEV4cG9ydCB0aGUgdHlwZSBkZWZpbml0aW9uIGZvciB0aGUgZnVuY3Rpb25cbmV4cG9ydCB0eXBlIFNsZWVwVHlwZSA9IChvcHRpb25zOiBTbGVlcE9wdGlvbnMpID0+IFByb21pc2U8dm9pZD47XG5cbi8qKlxuICogUGF1c2VzIHRoZSBleGVjdXRpb24gZm9yIGEgc3BlY2lmaWVkIG51bWJlciBvZiBtaWxsaXNlY29uZHMuXG4gKlxuICogQHBhcmFtIHtTbGVlcE9wdGlvbnN9IG9wdGlvbnMgLSBBbiBvYmplY3QgY29udGFpbmluZyB0aGUgc2xlZXAgZHVyYXRpb24uXG4gKiBAcGFyYW0ge251bWJlcn0gb3B0aW9ucy5tcyAtIFRoZSBudW1iZXIgb2YgbWlsbGlzZWNvbmRzIHRvIHNsZWVwLlxuICogQHJldHVybnMge1Byb21pc2U8dm9pZD59IEEgcHJvbWlzZSB0aGF0IHJlc29sdmVzIGFmdGVyIHRoZSBzcGVjaWZpZWQgZHVyYXRpb24uXG4gKi9cblxuZXhwb3J0IGZ1bmN0aW9uIHNsZWVwKHsgbXMgfTogU2xlZXBPcHRpb25zKTogUHJvbWlzZTx2b2lkPiB7XG4gIHJldHVybiBuZXcgUHJvbWlzZSgocmVzb2x2ZSkgPT4gc2V0VGltZW91dChyZXNvbHZlLCBtcykpO1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2xlZXAudXRpbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL21lZGlhc2Z1LWFuZ3VsYXIvc3JjL2xpYi9tZXRob2RzL3V0aWxzL3NsZWVwLnV0aWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBT0E7Ozs7Ozs7Ozs7OztHQVlHO0FBR0gsTUFBTSxVQUFVLEtBQUssQ0FBQyxFQUFFLEVBQUUsRUFBZ0I7SUFDeEMsT0FBTyxJQUFJLE9BQU8sQ0FBQyxDQUFDLE9BQU8sRUFBRSxFQUFFLENBQUMsVUFBVSxDQUFDLE9BQU8sRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDO0FBQzNELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIFNsZWVwT3B0aW9ucyB7XG4gIG1zOiBudW1iZXI7XG59XG5cbi8vIEV4cG9ydCB0aGUgdHlwZSBkZWZpbml0aW9uIGZvciB0aGUgZnVuY3Rpb25cbmV4cG9ydCB0eXBlIFNsZWVwVHlwZSA9IChvcHRpb25zOiBTbGVlcE9wdGlvbnMpID0+IFByb21pc2U8dm9pZD47XG5cbi8qKlxuICogUGF1c2VzIHRoZSBleGVjdXRpb24gZm9yIGEgc3BlY2lmaWVkIG51bWJlciBvZiBtaWxsaXNlY29uZHMuXG4gKlxuICogQHBhcmFtIHtTbGVlcE9wdGlvbnN9IG9wdGlvbnMgLSBDb250YWlucyB0aGUgZHVyYXRpb24gdG8gcGF1c2UuXG4gKiBAcGFyYW0ge251bWJlcn0gb3B0aW9ucy5tcyAtIE51bWJlciBvZiBtaWxsaXNlY29uZHMgdG8gZGVsYXkuXG4gKiBAcmV0dXJucyB7UHJvbWlzZTx2b2lkPn0gUmVzb2x2ZXMgYWZ0ZXIgdGhlIHNwZWNpZmllZCBkdXJhdGlvbi5cbiAqXG4gKiBAZXhhbXBsZVxuICogYGBgdHlwZXNjcmlwdFxuICogYXdhaXQgc2xlZXAoeyBtczogMjAwMCB9KTtcbiAqIC8vIFBhdXNlcyBleGVjdXRpb24gZm9yIDIgc2Vjb25kc1xuICogYGBgXG4gKi9cblxuXG5leHBvcnQgZnVuY3Rpb24gc2xlZXAoeyBtcyB9OiBTbGVlcE9wdGlvbnMpOiBQcm9taXNlPHZvaWQ+IHtcbiAgcmV0dXJuIG5ldyBQcm9taXNlKChyZXNvbHZlKSA9PiBzZXRUaW1lb3V0KHJlc29sdmUsIG1zKSk7XG59XG4iXX0=

package/dist/esm2022/lib/methods/utils/sound-player.service.mjs

@@ -1,5 +1,26 @@
 import { Injectable, Input } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * 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.
+ */
 /**
  * Plays a sound from a given URL.
  * @class
@@ -39,4 +60,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
         }], propDecorators: { soundUrl: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/methods/utils/validate-alphanumeric.service.mjs

@@ -1,5 +1,21 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * 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 class ValidateAlphanumeric {
     /**
      * Validates if the given string contains only alphanumeric characters.
@@ -30,4 +46,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/methods/waiting-methods/launch-waiting.service.mjs

@@ -1,5 +1,23 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * 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 class LaunchWaiting {
     /**
      * Toggles the visibility of the waiting modal.
@@ -20,4 +38,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGF1bmNoLXdhaXRpbmcuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL21lZGlhc2Z1LWFuZ3VsYXIvc3JjL2xpYi9tZXRob2RzL3dhaXRpbmctbWV0aG9kcy9sYXVuY2gtd2FpdGluZy5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBWTNDLE1BQU0sT0FBTyxhQUFhO0lBQ3hCOzs7OztPQUtHO0lBRUgsYUFBYSxDQUFDLEVBQ1osMkJBQTJCLEVBQzNCLHFCQUFxQixHQUNBO1FBQ3JCLCtCQUErQjtRQUMvQiwyQkFBMkIsQ0FBQyxDQUFDLHFCQUFxQixDQUFDLENBQUM7SUFDdEQsQ0FBQzt1R0FkVSxhQUFhOzJHQUFiLGFBQWEsY0FGWixNQUFNOzsyRkFFUCxhQUFhO2tCQUh6QixVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmV4cG9ydCBpbnRlcmZhY2UgTGF1bmNoV2FpdGluZ09wdGlvbnMge1xuICB1cGRhdGVJc1dhaXRpbmdNb2RhbFZpc2libGU6ICh2aXNpYmxlOiBib29sZWFuKSA9PiB2b2lkO1xuICBpc1dhaXRpbmdNb2RhbFZpc2libGU6IGJvb2xlYW47XG59XG5cbi8vIEV4cG9ydCB0aGUgdHlwZSBkZWZpbml0aW9uIGZvciB0aGUgZnVuY3Rpb25cbmV4cG9ydCB0eXBlIExhdW5jaFdhaXRpbmdUeXBlID0gKG9wdGlvbnM6IExhdW5jaFdhaXRpbmdPcHRpb25zKSA9PiB2b2lkO1xuXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290Jyxcbn0pXG5leHBvcnQgY2xhc3MgTGF1bmNoV2FpdGluZyB7XG4gIC8qKlxuICAgKiBUb2dnbGVzIHRoZSB2aXNpYmlsaXR5IG9mIHRoZSB3YWl0aW5nIG1vZGFsLlxuICAgKlxuICAgKiBAcGFyYW0gdXBkYXRlSXNXYWl0aW5nTW9kYWxWaXNpYmxlIC0gRnVuY3Rpb24gdG8gdXBkYXRlIHRoZSB2aXNpYmlsaXR5IHN0YXRlIG9mIHRoZSB3YWl0aW5nIG1vZGFsLlxuICAgKiBAcGFyYW0gaXNXYWl0aW5nTW9kYWxWaXNpYmxlIC0gQ3VycmVudCB2aXNpYmlsaXR5IHN0YXRlIG9mIHRoZSB3YWl0aW5nIG1vZGFsLlxuICAgKi9cblxuICBsYXVuY2hXYWl0aW5nKHtcbiAgICB1cGRhdGVJc1dhaXRpbmdNb2RhbFZpc2libGUsXG4gICAgaXNXYWl0aW5nTW9kYWxWaXNpYmxlLFxuICB9OiBMYXVuY2hXYWl0aW5nT3B0aW9ucyk6IHZvaWQge1xuICAgIC8vIE9wZW4gb3IgY2xvc2UgdGhlIG1lbnUgbW9kYWxcbiAgICB1cGRhdGVJc1dhaXRpbmdNb2RhbFZpc2libGUoIWlzV2FpdGluZ01vZGFsVmlzaWJsZSk7XG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/methods/waiting-methods/respond-to-waiting.service.mjs

@@ -1,5 +1,34 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * 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 class RespondToWaiting {
     /**
      * Responds to a participant waiting to join a room by either allowing or denying their entry.
@@ -37,4 +66,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/methods/whiteboard-methods/capture-canvas-stream.service.mjs

@@ -2,6 +2,35 @@
 // canvas.service.ts
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * 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 class CaptureCanvasStream {
     /**
      * Capture the canvas stream.
@@ -66,4 +95,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"capture-canvas-stream.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/methods/whiteboard-methods/capture-canvas-stream.service.ts"],"names":[],"mappings":"AAAA,6DAA6D;AAC7D,oBAAoB;AACpB,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAwC3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAMH,MAAM,OAAO,mBAAmB;IAC9B;;;;;OAKG;IACH,mBAAmB,GAAG,KAAK,EAAE,EAC3B,UAAU,EACV,KAAK,GAAG,IAAI,GACe,EAAiB,EAAE;QAC9C,IAAI,CAAC;YACH,UAAU,GAAG,UAAU,CAAC,mBAAmB,EAAE,CAAC;YAE9C,IAAI,EACF,gBAAgB,EAChB,YAAY,EACZ,kBAAkB,EAClB,cAAc,EACd,gBAAgB,EAChB,oBAAoB,EACpB,KAAK,EACL,mBAAmB,EACnB,0BAA0B,EAC1B,6BAA6B,GAC9B,GAAG,UAAU,CAAC;YAEf,IAAI,KAAK,IAAI,CAAC,YAAY,EAAE,CAAC;gBAC3B,4CAA4C;gBAC5C,IAAI,QAAQ,GAAG,CAAC,CAAC;gBACjB,MAAM,WAAW,GAAG,EAAE,CAAC,CAAC,8BAA8B;gBACtD,OAAO,CAAC,gBAAgB,IAAI,QAAQ,GAAG,WAAW,EAAE,CAAC;oBACnD,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC,CAAC;oBACzD,UAAU,GAAG,UAAU,CAAC,mBAAmB,EAAE,CAAC;oBAC9C,gBAAgB,GAAG,UAAU,CAAC,gBAAgB,CAAC;oBAC/C,QAAQ,EAAE,CAAC;gBACb,CAAC;gBAED,IAAI,CAAC,gBAAgB,EAAE,CAAC;oBACtB,MAAM,IAAI,KAAK,CAAC,kCAAkC,CAAC,CAAC;gBACtD,CAAC;gBACD,MAAM,MAAM,GAAG,gBAAiB,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC;gBACnD,YAAY,GAAG,MAAM,CAAC;gBACtB,kBAAkB,CAAC,MAAM,CAAC,CAAC;gBAE3B,IAAI,CAAC,gBAAgB,EAAE,CAAC;oBACtB,MAAM,mBAAmB,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,CAAC,CAAC;gBAC9D,CAAC;qBAAM,CAAC;oBACN,IAAI,CAAC;wBACH,cAAe,CAAC,KAAK,EAAE,CAAC;wBACxB,oBAAoB,CAAC,IAAI,CAAC,CAAC;wBAC3B,MAAM,KAAK,CAAC,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC;oBAC3B,CAAC;oBAAC,MAAM,CAAC;wBACP,kBAAkB;oBACpB,CAAC;oBAED,MAAM,0BAA0B,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC,CAAC;gBAC3D,CAAC;YACH,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,KAAK,IAAI,YAAY,EAAE,CAAC;oBAC3B,YAAY,CAAC,SAAS,EAAE,CAAC,OAAO,CAAC,CAAC,KAAuB,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;oBAC5E,YAAY,GAAG,IAAI,CAAC;oBACpB,kBAAkB,CAAC,IAAI,CAAC,CAAC;oBACzB,6BAA6B,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC;gBAChD,CAAC;YACH,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,GAAG,CAAC,+BAA+B,EAAE,KAAK,CAAC,CAAC;QACtD,CAAC;IACH,CAAC,CAAC;uGArES,mBAAmB;2GAAnB,mBAAmB,cAFlB,MAAM;;2FAEP,mBAAmB;kBAH/B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["/* eslint-disable @typescript-eslint/no-non-null-assertion */\n// canvas.service.ts\nimport { Injectable } from '@angular/core';\nimport { Producer } from 'mediasoup-client/lib/types';\nimport {\n  ConnectSendTransportScreenType,\n  CreateSendTransportType,\n  DisconnectSendTransportScreenType,\n  SleepType,\n  CreateSendTransportParameters,\n  DisconnectSendTransportScreenParameters,\n  ConnectSendTransportScreenParameters,\n} from '../../@types/types';\nexport interface CaptureCanvasStreamParameters\n  extends CreateSendTransportParameters,\n    DisconnectSendTransportScreenParameters,\n    ConnectSendTransportScreenParameters {\n  canvasWhiteboard: HTMLCanvasElement | null;\n  canvasStream: MediaStream | null;\n  updateCanvasStream: (stream: MediaStream | null) => void;\n  screenProducer: Producer | null;\n  transportCreated: boolean;\n  updateScreenProducer: (producer: Producer | null) => void;\n\n  // mediasfu functions\n  sleep: SleepType;\n  createSendTransport: CreateSendTransportType;\n  connectSendTransportScreen: ConnectSendTransportScreenType;\n  disconnectSendTransportScreen: DisconnectSendTransportScreenType;\n\n  getUpdatedAllParams: () => CaptureCanvasStreamParameters;\n  [key: string]: any;\n}\n\nexport interface CaptureCanvasStreamOptions {\n  parameters: CaptureCanvasStreamParameters;\n  start?: boolean;\n}\n\n// Export the type definition for the function\nexport type CaptureCanvasStreamType = (options: CaptureCanvasStreamOptions) => Promise<void>;\n\n/**\n * Manages capturing and streaming from a canvas element.\n *\n * @param {CaptureCanvasStreamOptions} options - Options to control canvas streaming.\n * @param {CaptureCanvasStreamParameters} options.parameters - Object containing media settings and state management functions.\n * @param {boolean} [options.start=true] - If `true`, initiates canvas capture; if `false`, stops the capture.\n * @returns {Promise<void>} A promise that resolves once the canvas stream has started or stopped.\n *\n * The function first checks the availability of `canvasWhiteboard` to capture the canvas stream. If unavailable, it attempts multiple times until a timeout. If successful:\n * - It starts the canvas capture, creating or reconnecting the transport for streaming.\n * - If stopping, it disconnects the transport and halts the stream.\n *\n * @example\n * ```typescript\n * const captureService = new CaptureCanvasStream();\n * captureService.captureCanvasStream({\n *   parameters: {\n *     canvasWhiteboard: document.getElementById('myCanvas') as HTMLCanvasElement,\n *     updateCanvasStream: (stream) => console.log('Canvas Stream:', stream),\n *     screenProducer: null,\n *     transportCreated: false,\n *     // other required parameters...\n *   },\n *   start: true\n * });\n * ```\n *\n * This example initiates a capture of `myCanvas`, updating the canvas stream upon successful connection.\n */\n\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class CaptureCanvasStream {\n  /**\n   * Capture the canvas stream.\n   * @param {Object} parameters - The parameters object.\n   * @param {boolean} [start=true] - Indicates whether to start capturing the stream.\n   * @returns {Promise<void>} - A promise that resolves when the canvas stream is captured.\n   */\n  captureCanvasStream = async ({\n    parameters,\n    start = true,\n  }: CaptureCanvasStreamOptions): Promise<void> => {\n    try {\n      parameters = parameters.getUpdatedAllParams();\n\n      let {\n        canvasWhiteboard,\n        canvasStream,\n        updateCanvasStream,\n        screenProducer,\n        transportCreated,\n        updateScreenProducer,\n        sleep,\n        createSendTransport,\n        connectSendTransportScreen,\n        disconnectSendTransportScreen,\n      } = parameters;\n\n      if (start && !canvasStream) {\n        // Wait for canvasWhiteboard to be available\n        let attempts = 0;\n        const maxAttempts = 20; // 2 seconds / 100ms intervals\n        while (!canvasWhiteboard && attempts < maxAttempts) {\n          await new Promise((resolve) => setTimeout(resolve, 100));\n          parameters = parameters.getUpdatedAllParams();\n          canvasWhiteboard = parameters.canvasWhiteboard;\n          attempts++;\n        }\n\n        if (!canvasWhiteboard) {\n          throw new Error('Canvas whiteboard not available.');\n        }\n        const stream = canvasWhiteboard!.captureStream(30);\n        canvasStream = stream;\n        updateCanvasStream(stream);\n\n        if (!transportCreated) {\n          await createSendTransport({ option: 'screen', parameters });\n        } else {\n          try {\n            screenProducer!.close();\n            updateScreenProducer(null);\n            await sleep({ ms: 500 });\n          } catch {\n            /* handle error */\n          }\n\n          await connectSendTransportScreen({ stream, parameters });\n        }\n      } else {\n        if (!start && canvasStream) {\n          canvasStream.getTracks().forEach((track: MediaStreamTrack) => track.stop());\n          canvasStream = null;\n          updateCanvasStream(null);\n          disconnectSendTransportScreen({ parameters });\n        }\n      }\n    } catch (error) {\n      console.log('Error in captureCanvasStream:', error);\n    }\n  };\n}\n"]}

package/dist/esm2022/lib/methods/whiteboard-methods/launch-configure-whiteboard.service.mjs

@@ -1,6 +1,26 @@
 // whiteboard.service.ts
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * 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 class LaunchConfigureWhiteboard {
     /**
      * Toggles the visibility of the configure whiteboard modal.
@@ -21,4 +41,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/producer-client/producer-client-emits/create-device-client.service.mjs

@@ -1,6 +1,29 @@
 import { Injectable } from '@angular/core';
 import * as mediasoupClient from 'mediasoup-client';
 import * as i0 from "@angular/core";
+/**
+ * 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 class CreateDeviceClient {
     /**
      * Creates a mediasoup client device with the provided RTP capabilities.
@@ -48,4 +71,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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