mediasfu-angular 1.0.0 → 1.0.2

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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGF1bmNoLXdhaXRpbmcuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL21lZGlhc2Z1LWFuZ3VsYXIvc3JjL2xpYi9tZXRob2RzL3dhaXRpbmctbWV0aG9kcy9sYXVuY2gtd2FpdGluZy5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBUzNDOzs7Ozs7Ozs7Ozs7Ozs7OztHQWlCRztBQU1ILE1BQU0sT0FBTyxhQUFhO0lBQ3hCOzs7OztPQUtHO0lBRUgsYUFBYSxDQUFDLEVBQ1osMkJBQTJCLEVBQzNCLHFCQUFxQixHQUNBO1FBQ3JCLCtCQUErQjtRQUMvQiwyQkFBMkIsQ0FBQyxDQUFDLHFCQUFxQixDQUFDLENBQUM7SUFDdEQsQ0FBQzt1R0FkVSxhQUFhOzJHQUFiLGFBQWEsY0FGWixNQUFNOzsyRkFFUCxhQUFhO2tCQUh6QixVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmV4cG9ydCBpbnRlcmZhY2UgTGF1bmNoV2FpdGluZ09wdGlvbnMge1xuICB1cGRhdGVJc1dhaXRpbmdNb2RhbFZpc2libGU6ICh2aXNpYmxlOiBib29sZWFuKSA9PiB2b2lkO1xuICBpc1dhaXRpbmdNb2RhbFZpc2libGU6IGJvb2xlYW47XG59XG5cbi8vIEV4cG9ydCB0aGUgdHlwZSBkZWZpbml0aW9uIGZvciB0aGUgZnVuY3Rpb25cbmV4cG9ydCB0eXBlIExhdW5jaFdhaXRpbmdUeXBlID0gKG9wdGlvbnM6IExhdW5jaFdhaXRpbmdPcHRpb25zKSA9PiB2b2lkO1xuXG4vKipcbiAqIFNlcnZpY2UgdG8gdG9nZ2xlIHRoZSB2aXNpYmlsaXR5IG9mIGEgd2FpdGluZyBtb2RhbC5cbiAqXG4gKiBAcGFyYW0ge0xhdW5jaFdhaXRpbmdPcHRpb25zfSBvcHRpb25zIC0gVGhlIG9wdGlvbnMgdG8gY29udHJvbCB0aGUgd2FpdGluZyBtb2RhbCB2aXNpYmlsaXR5LlxuICogQHBhcmFtIHtGdW5jdGlvbn0gb3B0aW9ucy51cGRhdGVJc1dhaXRpbmdNb2RhbFZpc2libGUgLSBGdW5jdGlvbiB0byB1cGRhdGUgdGhlIHZpc2liaWxpdHkgb2YgdGhlIHdhaXRpbmcgbW9kYWwuXG4gKiBAcGFyYW0ge2Jvb2xlYW59IG9wdGlvbnMuaXNXYWl0aW5nTW9kYWxWaXNpYmxlIC0gQ3VycmVudCB2aXNpYmlsaXR5IHN0YXRlIG9mIHRoZSB3YWl0aW5nIG1vZGFsLlxuICpcbiAqIEBleGFtcGxlXG4gKiBgYGB0eXBlc2NyaXB0XG4gKiBjb25zdCBsYXVuY2hXYWl0aW5nU2VydmljZSA9IG5ldyBMYXVuY2hXYWl0aW5nKCk7XG4gKiBsYXVuY2hXYWl0aW5nU2VydmljZS5sYXVuY2hXYWl0aW5nKHtcbiAqICAgdXBkYXRlSXNXYWl0aW5nTW9kYWxWaXNpYmxlOiAoaXNWaXNpYmxlKSA9PiBjb25zb2xlLmxvZyhgTW9kYWwgaXMgbm93ICR7aXNWaXNpYmxlID8gJ3Zpc2libGUnIDogJ2hpZGRlbid9YCksXG4gKiAgIGlzV2FpdGluZ01vZGFsVmlzaWJsZTogZmFsc2UsXG4gKiB9KTtcbiAqIGBgYFxuICpcbiAqIFRoaXMgZXhhbXBsZSB0b2dnbGVzIHRoZSBtb2RhbCdzIHZpc2liaWxpdHkgc3RhdGUsIG1ha2luZyBpdCB2aXNpYmxlIGlmIGl0IHdhcyBoaWRkZW4gYW5kIHZpY2UgdmVyc2EuXG4gKi9cblxuXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290Jyxcbn0pXG5leHBvcnQgY2xhc3MgTGF1bmNoV2FpdGluZyB7XG4gIC8qKlxuICAgKiBUb2dnbGVzIHRoZSB2aXNpYmlsaXR5IG9mIHRoZSB3YWl0aW5nIG1vZGFsLlxuICAgKlxuICAgKiBAcGFyYW0gdXBkYXRlSXNXYWl0aW5nTW9kYWxWaXNpYmxlIC0gRnVuY3Rpb24gdG8gdXBkYXRlIHRoZSB2aXNpYmlsaXR5IHN0YXRlIG9mIHRoZSB3YWl0aW5nIG1vZGFsLlxuICAgKiBAcGFyYW0gaXNXYWl0aW5nTW9kYWxWaXNpYmxlIC0gQ3VycmVudCB2aXNpYmlsaXR5IHN0YXRlIG9mIHRoZSB3YWl0aW5nIG1vZGFsLlxuICAgKi9cblxuICBsYXVuY2hXYWl0aW5nKHtcbiAgICB1cGRhdGVJc1dhaXRpbmdNb2RhbFZpc2libGUsXG4gICAgaXNXYWl0aW5nTW9kYWxWaXNpYmxlLFxuICB9OiBMYXVuY2hXYWl0aW5nT3B0aW9ucyk6IHZvaWQge1xuICAgIC8vIE9wZW4gb3IgY2xvc2UgdGhlIG1lbnUgbW9kYWxcbiAgICB1cGRhdGVJc1dhaXRpbmdNb2RhbFZpc2libGUoIWlzV2FpdGluZ01vZGFsVmlzaWJsZSk7XG4gIH1cbn1cbiJdfQ==

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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

package/dist/esm2022/lib/producer-client/producer-client-emits/join-room-client.service.mjs

@@ -2,6 +2,37 @@ import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
 import * as i1 from "../../producers/producer-emits/join-room.service";
 import * as i2 from "../../producers/producer-emits/join-con-room.service";
+/**
+ * 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 class JoinRoomClient {
     JoinRoomService;
     JoinConRoomService;
@@ -62,4 +93,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }], ctorParameters: () => [{ type: i1.JoinRoom }, { type: i2.JoinConRoom }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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