mediasfu-angular 1.0.0 → 1.0.2

package/dist/esm2022/lib/methods/stream-methods/switch-audio.service.mjs

@@ -1,5 +1,52 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Switches the audio input device based on user preference.
+ *
+ * @param {SwitchAudioOptions} options - The options for switching the audio input.
+ * @param {string} options.audioPreference - The ID of the preferred audio input device.
+ * @param {SwitchAudioParameters} options.parameters - The parameters required for switching the audio.
+ * @param {string} options.parameters.defAudioID - The default audio input device ID.
+ * @param {string} options.parameters.userDefaultAudioInputDevice - The current default audio input device ID.
+ * @param {string} options.parameters.prevAudioInputDevice - The previously used audio input device ID.
+ * @param {Function} options.parameters.updateUserDefaultAudioInputDevice - Function to update the user's default audio input device.
+ * @param {Function} options.parameters.updatePrevAudioInputDevice - Function to update the previous audio input device.
+ * @param {Function} options.parameters.switchUserAudio - Function to switch the user's audio.
+ *
+ * @returns {Promise<void>} A promise that resolves when the audio input has been switched.
+ *
+ * @remarks
+ * This function checks if the user's preferred audio device differs from the current default.
+ * If so, it updates the previous audio device and the current default audio device.
+ * It then calls the function to switch the user's audio.
+ *
+ * @example
+ * ```typescript
+ * const options: SwitchAudioOptions = {
+ *   audioPreference: 'newAudioDeviceID',
+ *   parameters: {
+ *     defAudioID: 'defaultAudioDeviceID',
+ *     userDefaultAudioInputDevice: 'currentAudioDeviceID',
+ *     prevAudioInputDevice: '',
+ *     updateUserDefaultAudioInputDevice: (deviceId) => console.log(`Updated to: ${deviceId}`),
+ *     updatePrevAudioInputDevice: (deviceId) => console.log(`Previous device was: ${deviceId}`),
+ *     switchUserAudio: async ({ audioPreference, parameters }) => {
+ *       console.log(`Switching audio to: ${audioPreference}`);
+ *     },
+ *     getUpdatedAllParams: () => {
+ *       return {
+ *         defAudioID: 'defaultAudioDeviceID',
+ *         userDefaultAudioInputDevice: 'currentAudioDeviceID',
+ *         prevAudioInputDevice: '',
+ *       };
+ *     },
+ *   },
+ * };
+ *
+ * const switchAudioService = new SwitchAudio();
+ * await switchAudioService.switchAudio(options);
+ * ```
+ */
 export class SwitchAudio {
     /**
      * Switches the audio input device based on user preference.
@@ -30,4 +77,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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3dpdGNoLWF1ZGlvLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tZWRpYXNmdS1hbmd1bGFyL3NyYy9saWIvbWV0aG9kcy9zdHJlYW0tbWV0aG9kcy9zd2l0Y2gtYXVkaW8uc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQXlCM0M7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0E4Q0c7QUFLSCxNQUFNLE9BQU8sV0FBVztJQUN0Qjs7Ozs7T0FLRztJQUVILEtBQUssQ0FBQyxXQUFXLENBQUMsRUFBRSxlQUFlLEVBQUUsVUFBVSxFQUFzQjtRQUNuRSxJQUFJLEVBQ0YsVUFBVSxFQUNWLDJCQUEyQixFQUMzQixvQkFBb0IsRUFDcEIsaUNBQWlDLEVBQ2pDLDBCQUEwQjtRQUUxQixvQkFBb0I7UUFDcEIsZUFBZSxHQUNoQixHQUFHLFVBQVUsQ0FBQztRQUVmLElBQUksZUFBZSxLQUFLLFVBQVUsRUFBRSxDQUFDO1lBQ25DLG9CQUFvQixHQUFHLDJCQUEyQixDQUFDO1lBQ25ELDBCQUEwQixDQUFDLG9CQUFvQixDQUFDLENBQUM7WUFDakQsMkJBQTJCLEdBQUcsZUFBZSxDQUFDO1lBQzlDLGlDQUFpQyxDQUFDLDJCQUEyQixDQUFDLENBQUM7WUFFL0QsSUFBSSxVQUFVLEVBQUUsQ0FBQztnQkFDZixNQUFNLGVBQWUsQ0FBQyxFQUFFLGVBQWUsRUFBRSxVQUFVLEVBQUUsQ0FBQyxDQUFDO1lBQ3pELENBQUM7UUFDSCxDQUFDO0lBQ0gsQ0FBQzt1R0E5QlUsV0FBVzsyR0FBWCxXQUFXLGNBRlYsTUFBTTs7MkZBRVAsV0FBVztrQkFIdkIsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBTd2l0Y2hVc2VyQXVkaW9UeXBlLCBTd2l0Y2hVc2VyQXVkaW9QYXJhbWV0ZXJzIH0gZnJvbSAnLi4vLi4vQHR5cGVzL3R5cGVzJztcblxuZXhwb3J0IGludGVyZmFjZSBTd2l0Y2hBdWRpb1BhcmFtZXRlcnMgZXh0ZW5kcyBTd2l0Y2hVc2VyQXVkaW9QYXJhbWV0ZXJzIHtcbiAgZGVmQXVkaW9JRDogc3RyaW5nO1xuICB1c2VyRGVmYXVsdEF1ZGlvSW5wdXREZXZpY2U6IHN0cmluZztcbiAgcHJldkF1ZGlvSW5wdXREZXZpY2U6IHN0cmluZztcbiAgdXBkYXRlVXNlckRlZmF1bHRBdWRpb0lucHV0RGV2aWNlOiAoZGV2aWNlSWQ6IHN0cmluZykgPT4gdm9pZDtcbiAgdXBkYXRlUHJldkF1ZGlvSW5wdXREZXZpY2U6IChkZXZpY2VJZDogc3RyaW5nKSA9PiB2b2lkO1xuXG4gIC8vIG1lZGlhc2Z1IGZ1bmN0aW9uc1xuICBzd2l0Y2hVc2VyQXVkaW86IFN3aXRjaFVzZXJBdWRpb1R5cGU7XG5cbiAgZ2V0VXBkYXRlZEFsbFBhcmFtczogKCkgPT4gU3dpdGNoQXVkaW9QYXJhbWV0ZXJzO1xuICBba2V5OiBzdHJpbmddOiBhbnk7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgU3dpdGNoQXVkaW9PcHRpb25zIHtcbiAgYXVkaW9QcmVmZXJlbmNlOiBzdHJpbmc7XG4gIHBhcmFtZXRlcnM6IFN3aXRjaEF1ZGlvUGFyYW1ldGVycztcbn1cblxuLy8gRXhwb3J0IHRoZSB0eXBlIGRlZmluaXRpb24gZm9yIHRoZSBmdW5jdGlvblxuZXhwb3J0IHR5cGUgU3dpdGNoQXVkaW9UeXBlID0gKG9wdGlvbnM6IFN3aXRjaEF1ZGlvT3B0aW9ucykgPT4gUHJvbWlzZTx2b2lkPjtcblxuLyoqXG4gKiBTd2l0Y2hlcyB0aGUgYXVkaW8gaW5wdXQgZGV2aWNlIGJhc2VkIG9uIHVzZXIgcHJlZmVyZW5jZS5cbiAqXG4gKiBAcGFyYW0ge1N3aXRjaEF1ZGlvT3B0aW9uc30gb3B0aW9ucyAtIFRoZSBvcHRpb25zIGZvciBzd2l0Y2hpbmcgdGhlIGF1ZGlvIGlucHV0LlxuICogQHBhcmFtIHtzdHJpbmd9IG9wdGlvbnMuYXVkaW9QcmVmZXJlbmNlIC0gVGhlIElEIG9mIHRoZSBwcmVmZXJyZWQgYXVkaW8gaW5wdXQgZGV2aWNlLlxuICogQHBhcmFtIHtTd2l0Y2hBdWRpb1BhcmFtZXRlcnN9IG9wdGlvbnMucGFyYW1ldGVycyAtIFRoZSBwYXJhbWV0ZXJzIHJlcXVpcmVkIGZvciBzd2l0Y2hpbmcgdGhlIGF1ZGlvLlxuICogQHBhcmFtIHtzdHJpbmd9IG9wdGlvbnMucGFyYW1ldGVycy5kZWZBdWRpb0lEIC0gVGhlIGRlZmF1bHQgYXVkaW8gaW5wdXQgZGV2aWNlIElELlxuICogQHBhcmFtIHtzdHJpbmd9IG9wdGlvbnMucGFyYW1ldGVycy51c2VyRGVmYXVsdEF1ZGlvSW5wdXREZXZpY2UgLSBUaGUgY3VycmVudCBkZWZhdWx0IGF1ZGlvIGlucHV0IGRldmljZSBJRC5cbiAqIEBwYXJhbSB7c3RyaW5nfSBvcHRpb25zLnBhcmFtZXRlcnMucHJldkF1ZGlvSW5wdXREZXZpY2UgLSBUaGUgcHJldmlvdXNseSB1c2VkIGF1ZGlvIGlucHV0IGRldmljZSBJRC5cbiAqIEBwYXJhbSB7RnVuY3Rpb259IG9wdGlvbnMucGFyYW1ldGVycy51cGRhdGVVc2VyRGVmYXVsdEF1ZGlvSW5wdXREZXZpY2UgLSBGdW5jdGlvbiB0byB1cGRhdGUgdGhlIHVzZXIncyBkZWZhdWx0IGF1ZGlvIGlucHV0IGRldmljZS5cbiAqIEBwYXJhbSB7RnVuY3Rpb259IG9wdGlvbnMucGFyYW1ldGVycy51cGRhdGVQcmV2QXVkaW9JbnB1dERldmljZSAtIEZ1bmN0aW9uIHRvIHVwZGF0ZSB0aGUgcHJldmlvdXMgYXVkaW8gaW5wdXQgZGV2aWNlLlxuICogQHBhcmFtIHtGdW5jdGlvbn0gb3B0aW9ucy5wYXJhbWV0ZXJzLnN3aXRjaFVzZXJBdWRpbyAtIEZ1bmN0aW9uIHRvIHN3aXRjaCB0aGUgdXNlcidzIGF1ZGlvLlxuICpcbiAqIEByZXR1cm5zIHtQcm9taXNlPHZvaWQ+fSBBIHByb21pc2UgdGhhdCByZXNvbHZlcyB3aGVuIHRoZSBhdWRpbyBpbnB1dCBoYXMgYmVlbiBzd2l0Y2hlZC5cbiAqXG4gKiBAcmVtYXJrc1xuICogVGhpcyBmdW5jdGlvbiBjaGVja3MgaWYgdGhlIHVzZXIncyBwcmVmZXJyZWQgYXVkaW8gZGV2aWNlIGRpZmZlcnMgZnJvbSB0aGUgY3VycmVudCBkZWZhdWx0LlxuICogSWYgc28sIGl0IHVwZGF0ZXMgdGhlIHByZXZpb3VzIGF1ZGlvIGRldmljZSBhbmQgdGhlIGN1cnJlbnQgZGVmYXVsdCBhdWRpbyBkZXZpY2UuXG4gKiBJdCB0aGVuIGNhbGxzIHRoZSBmdW5jdGlvbiB0byBzd2l0Y2ggdGhlIHVzZXIncyBhdWRpby5cbiAqXG4gKiBAZXhhbXBsZVxuICogYGBgdHlwZXNjcmlwdFxuICogY29uc3Qgb3B0aW9uczogU3dpdGNoQXVkaW9PcHRpb25zID0ge1xuICogICBhdWRpb1ByZWZlcmVuY2U6ICduZXdBdWRpb0RldmljZUlEJyxcbiAqICAgcGFyYW1ldGVyczoge1xuICogICAgIGRlZkF1ZGlvSUQ6ICdkZWZhdWx0QXVkaW9EZXZpY2VJRCcsXG4gKiAgICAgdXNlckRlZmF1bHRBdWRpb0lucHV0RGV2aWNlOiAnY3VycmVudEF1ZGlvRGV2aWNlSUQnLFxuICogICAgIHByZXZBdWRpb0lucHV0RGV2aWNlOiAnJyxcbiAqICAgICB1cGRhdGVVc2VyRGVmYXVsdEF1ZGlvSW5wdXREZXZpY2U6IChkZXZpY2VJZCkgPT4gY29uc29sZS5sb2coYFVwZGF0ZWQgdG86ICR7ZGV2aWNlSWR9YCksXG4gKiAgICAgdXBkYXRlUHJldkF1ZGlvSW5wdXREZXZpY2U6IChkZXZpY2VJZCkgPT4gY29uc29sZS5sb2coYFByZXZpb3VzIGRldmljZSB3YXM6ICR7ZGV2aWNlSWR9YCksXG4gKiAgICAgc3dpdGNoVXNlckF1ZGlvOiBhc3luYyAoeyBhdWRpb1ByZWZlcmVuY2UsIHBhcmFtZXRlcnMgfSkgPT4ge1xuICogICAgICAgY29uc29sZS5sb2coYFN3aXRjaGluZyBhdWRpbyB0bzogJHthdWRpb1ByZWZlcmVuY2V9YCk7XG4gKiAgICAgfSxcbiAqICAgICBnZXRVcGRhdGVkQWxsUGFyYW1zOiAoKSA9PiB7XG4gKiAgICAgICByZXR1cm4ge1xuICogICAgICAgICBkZWZBdWRpb0lEOiAnZGVmYXVsdEF1ZGlvRGV2aWNlSUQnLFxuICogICAgICAgICB1c2VyRGVmYXVsdEF1ZGlvSW5wdXREZXZpY2U6ICdjdXJyZW50QXVkaW9EZXZpY2VJRCcsXG4gKiAgICAgICAgIHByZXZBdWRpb0lucHV0RGV2aWNlOiAnJyxcbiAqICAgICAgIH07XG4gKiAgICAgfSxcbiAqICAgfSxcbiAqIH07XG4gKlxuICogY29uc3Qgc3dpdGNoQXVkaW9TZXJ2aWNlID0gbmV3IFN3aXRjaEF1ZGlvKCk7XG4gKiBhd2FpdCBzd2l0Y2hBdWRpb1NlcnZpY2Uuc3dpdGNoQXVkaW8ob3B0aW9ucyk7XG4gKiBgYGBcbiAqL1xuXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290Jyxcbn0pXG5leHBvcnQgY2xhc3MgU3dpdGNoQXVkaW8ge1xuICAvKipcbiAgICogU3dpdGNoZXMgdGhlIGF1ZGlvIGlucHV0IGRldmljZSBiYXNlZCBvbiB1c2VyIHByZWZlcmVuY2UuXG4gICAqXG4gICAqIEBwYXJhbSB7U3dpdGNoQXVkaW9QYXJhbXN9IG9wdGlvbnMgLSBUaGUgZnVuY3Rpb24gcGFyYW1ldGVycy5cbiAgICogQHJldHVybnMge1Byb21pc2U8dm9pZD59XG4gICAqL1xuXG4gIGFzeW5jIHN3aXRjaEF1ZGlvKHsgYXVkaW9QcmVmZXJlbmNlLCBwYXJhbWV0ZXJzIH06IFN3aXRjaEF1ZGlvT3B0aW9ucyk6IFByb21pc2U8dm9pZD4ge1xuICAgIGxldCB7XG4gICAgICBkZWZBdWRpb0lELFxuICAgICAgdXNlckRlZmF1bHRBdWRpb0lucHV0RGV2aWNlLFxuICAgICAgcHJldkF1ZGlvSW5wdXREZXZpY2UsXG4gICAgICB1cGRhdGVVc2VyRGVmYXVsdEF1ZGlvSW5wdXREZXZpY2UsXG4gICAgICB1cGRhdGVQcmV2QXVkaW9JbnB1dERldmljZSxcblxuICAgICAgLy9tZWRpYXNmdSBmdW5jdGlvbnNcbiAgICAgIHN3aXRjaFVzZXJBdWRpbyxcbiAgICB9ID0gcGFyYW1ldGVycztcblxuICAgIGlmIChhdWRpb1ByZWZlcmVuY2UgIT09IGRlZkF1ZGlvSUQpIHtcbiAgICAgIHByZXZBdWRpb0lucHV0RGV2aWNlID0gdXNlckRlZmF1bHRBdWRpb0lucHV0RGV2aWNlO1xuICAgICAgdXBkYXRlUHJldkF1ZGlvSW5wdXREZXZpY2UocHJldkF1ZGlvSW5wdXREZXZpY2UpO1xuICAgICAgdXNlckRlZmF1bHRBdWRpb0lucHV0RGV2aWNlID0gYXVkaW9QcmVmZXJlbmNlO1xuICAgICAgdXBkYXRlVXNlckRlZmF1bHRBdWRpb0lucHV0RGV2aWNlKHVzZXJEZWZhdWx0QXVkaW9JbnB1dERldmljZSk7XG5cbiAgICAgIGlmIChkZWZBdWRpb0lEKSB7XG4gICAgICAgIGF3YWl0IHN3aXRjaFVzZXJBdWRpbyh7IGF1ZGlvUHJlZmVyZW5jZSwgcGFyYW1ldGVycyB9KTtcbiAgICAgIH1cbiAgICB9XG4gIH1cbn1cbiJdfQ==

package/dist/esm2022/lib/methods/stream-methods/switch-video-alt.service.mjs

@@ -1,5 +1,55 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Switches the video input based on user preference and current state.
+ *
+ * @param {SwitchVideoAltOptions} options - The options for switching the video input.
+ * @param {SwitchVideoAltParameters} options.parameters - The parameters required for switching the video input.
+ * @param {boolean} options.parameters.recordStarted - Indicates if recording has started.
+ * @param {boolean} options.parameters.recordResumed - Indicates if recording has resumed.
+ * @param {boolean} options.parameters.recordStopped - Indicates if recording has stopped.
+ * @param {boolean} options.parameters.recordPaused - Indicates if recording is paused.
+ * @param {string} options.parameters.recordingMediaOptions - The current media options (e.g., "video").
+ * @param {boolean} options.parameters.videoAlreadyOn - Indicates if the video is currently on.
+ * @param {string} options.parameters.currentFacingMode - The current facing mode of the camera (e.g., "environment").
+ * @param {boolean} options.parameters.allowed - Indicates if the user is allowed to switch video.
+ * @param {boolean} options.parameters.audioOnlyRoom - Indicates if the current room is audio-only.
+ * @param {Function} options.parameters.updateCurrentFacingMode - Function to update the current facing mode.
+ * @param {Function} options.parameters.updateIsMediaSettingsModalVisible - Function to update the visibility of the media settings modal.
+ * @param {Function} [options.parameters.showAlert] - Optional function to show alert messages.
+ * @param {Function} options.parameters.switchUserVideoAlt - Function to switch the user's video input.
+ *
+ * @returns {Promise<void>} A promise that resolves when the video input has been switched.
+ *
+ * @remarks
+ * This function checks if the user is allowed to switch the video input based on the current state,
+ * and it shows alerts if there are any issues. If the video is already on, it cannot be switched until
+ * it is turned off, and vice versa. The facing mode of the camera is toggled between "user" and "environment".
+ *
+ * @example
+ * ```typescript
+ * const options: SwitchVideoAltOptions = {
+ *   parameters: {
+ *     recordStarted: false,
+ *     recordResumed: false,
+ *     recordStopped: false,
+ *     recordPaused: false,
+ *     recordingMediaOptions: 'video',
+ *     videoAlreadyOn: true,
+ *     currentFacingMode: 'user',
+ *     allowed: true,
+ *     audioOnlyRoom: false,
+ *     updateCurrentFacingMode: (mode) => console.log(`Facing mode updated to: ${mode}`),
+ *     updateIsMediaSettingsModalVisible: (isVisible) => console.log(`Media settings modal is now ${isVisible ? 'visible' : 'hidden'}`),
+ *     switchUserVideoAlt: async ({ videoPreference }) => console.log(`Switched video to: ${videoPreference}`),
+ *     getUpdatedAllParams: () => ({ }),
+ *   },
+ * };
+ *
+ * const switchVideoService = new SwitchVideoAlt();
+ * await switchVideoService.switchVideoAlt(options);
+ * ```
+ */
 export class SwitchVideoAlt {
     async switchVideoAlt({ parameters }) {
         let { recordStarted, recordResumed, recordStopped, recordPaused, recordingMediaOptions, videoAlreadyOn, currentFacingMode, allowed, audioOnlyRoom, updateCurrentFacingMode, updateIsMediaSettingsModalVisible, showAlert, 
@@ -63,4 +113,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":"switch-video-alt.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/methods/stream-methods/switch-video-alt.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAiC3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAKH,MAAM,OAAO,cAAc;IACzB,KAAK,CAAC,cAAc,CAAC,EAAE,UAAU,EAAyB;QACxD,IAAI,EACF,aAAa,EACb,aAAa,EACb,aAAa,EACb,YAAY,EACZ,qBAAqB,EACrB,cAAc,EACd,iBAAiB,EACjB,OAAO,EACP,aAAa,EACb,uBAAuB,EACvB,iCAAiC,EAEjC,SAAS;QAET,iBAAiB;QACjB,kBAAkB,GACnB,GAAG,UAAU,CAAC;QAEf,IAAI,aAAa,EAAE,CAAC;YAClB,SAAS,EAAE,CAAC;gBACV,OAAO,EAAE,wDAAwD;gBACjE,IAAI,EAAE,QAAQ;gBACd,QAAQ,EAAE,IAAI;aACf,CAAC,CAAC;YACH,OAAO;QACT,CAAC;QAED,IAAI,QAAQ,GAAG,KAAK,CAAC;QACrB,IACE,CAAC,aAAa,IAAI,aAAa,CAAC;YAChC,CAAC,aAAa;YACd,CAAC,YAAY;YACb,qBAAqB,KAAK,OAAO,EACjC,CAAC;YACD,QAAQ,GAAG,IAAI,CAAC;QAClB,CAAC;QAED,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,SAAS,EAAE,CAAC;gBACV,OAAO,EAAE,gEAAgE;gBACzE,IAAI,EAAE,QAAQ;gBACd,QAAQ,EAAE,IAAI;aACf,CAAC,CAAC;YACH,OAAO;QACT,CAAC;QAED,IAAI,QAAQ,EAAE,CAAC;YACb,IAAI,cAAc,EAAE,CAAC;gBACnB,SAAS,EAAE,CAAC;oBACV,OAAO,EAAE,8CAA8C;oBACvD,IAAI,EAAE,QAAQ;oBACd,QAAQ,EAAE,IAAI;iBACf,CAAC,CAAC;gBACH,OAAO;YACT,CAAC;QACH,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,cAAc,EAAE,CAAC;gBACpB,SAAS,EAAE,CAAC;oBACV,OAAO,EAAE,6CAA6C;oBACtD,IAAI,EAAE,QAAQ;oBACd,QAAQ,EAAE,IAAI;iBACf,CAAC,CAAC;gBACH,OAAO;YACT,CAAC;QACH,CAAC;QAED,8BAA8B;QAC9B,IAAI,aAAa,GAAG,iBAAiB,KAAK,aAAa,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,aAAa,CAAC;QAEjF,uBAAuB,CAAC,aAAa,CAAC,CAAC;QACvC,iCAAiC,CAAC,KAAK,CAAC,CAAC;QAEzC,MAAM,kBAAkB,CAAC,EAAE,eAAe,EAAE,aAAa,EAAE,QAAQ,EAAE,UAAU,EAAE,CAAC,CAAC;IACrF,CAAC;uGA5EU,cAAc;2GAAd,cAAc,cAFb,MAAM;;2FAEP,cAAc;kBAH1B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { ShowAlert, SwitchUserVideoAltType, SwitchUserVideoParameters } from '../../@types/types';\n\nexport interface SwitchVideoAltParameters extends SwitchUserVideoParameters {\n  recordStarted: boolean;\n  recordResumed: boolean;\n  recordStopped: boolean;\n  recordPaused: boolean;\n  recordingMediaOptions: string;\n  videoAlreadyOn: boolean;\n  currentFacingMode: string;\n  prevFacingMode: string;\n  allowed: boolean;\n  audioOnlyRoom: boolean;\n  updateCurrentFacingMode: (mode: string) => void;\n  updatePrevFacingMode: (mode: string) => void;\n  updateIsMediaSettingsModalVisible: (isVisible: boolean) => void;\n  showAlert?: ShowAlert;\n\n  // mediasfu functions\n  switchUserVideoAlt: SwitchUserVideoAltType;\n\n  getUpdatedAllParams: () => SwitchVideoAltParameters;\n  // [key: string]: any;\n}\n\nexport interface SwitchVideoAltOptions {\n  parameters: SwitchVideoAltParameters;\n}\n\n// Export the type definition for the function\nexport type SwitchVideoAltType = (options: SwitchVideoAltOptions) => Promise<void>;\n\n/**\n * Switches the video input based on user preference and current state.\n *\n * @param {SwitchVideoAltOptions} options - The options for switching the video input.\n * @param {SwitchVideoAltParameters} options.parameters - The parameters required for switching the video input.\n * @param {boolean} options.parameters.recordStarted - Indicates if recording has started.\n * @param {boolean} options.parameters.recordResumed - Indicates if recording has resumed.\n * @param {boolean} options.parameters.recordStopped - Indicates if recording has stopped.\n * @param {boolean} options.parameters.recordPaused - Indicates if recording is paused.\n * @param {string} options.parameters.recordingMediaOptions - The current media options (e.g., \"video\").\n * @param {boolean} options.parameters.videoAlreadyOn - Indicates if the video is currently on.\n * @param {string} options.parameters.currentFacingMode - The current facing mode of the camera (e.g., \"environment\").\n * @param {boolean} options.parameters.allowed - Indicates if the user is allowed to switch video.\n * @param {boolean} options.parameters.audioOnlyRoom - Indicates if the current room is audio-only.\n * @param {Function} options.parameters.updateCurrentFacingMode - Function to update the current facing mode.\n * @param {Function} options.parameters.updateIsMediaSettingsModalVisible - Function to update the visibility of the media settings modal.\n * @param {Function} [options.parameters.showAlert] - Optional function to show alert messages.\n * @param {Function} options.parameters.switchUserVideoAlt - Function to switch the user's video input.\n *\n * @returns {Promise<void>} A promise that resolves when the video input has been switched.\n *\n * @remarks\n * This function checks if the user is allowed to switch the video input based on the current state,\n * and it shows alerts if there are any issues. If the video is already on, it cannot be switched until\n * it is turned off, and vice versa. The facing mode of the camera is toggled between \"user\" and \"environment\".\n *\n * @example\n * ```typescript\n * const options: SwitchVideoAltOptions = {\n *   parameters: {\n *     recordStarted: false,\n *     recordResumed: false,\n *     recordStopped: false,\n *     recordPaused: false,\n *     recordingMediaOptions: 'video',\n *     videoAlreadyOn: true,\n *     currentFacingMode: 'user',\n *     allowed: true,\n *     audioOnlyRoom: false,\n *     updateCurrentFacingMode: (mode) => console.log(`Facing mode updated to: ${mode}`),\n *     updateIsMediaSettingsModalVisible: (isVisible) => console.log(`Media settings modal is now ${isVisible ? 'visible' : 'hidden'}`),\n *     switchUserVideoAlt: async ({ videoPreference }) => console.log(`Switched video to: ${videoPreference}`),\n *     getUpdatedAllParams: () => ({ }),\n *   },\n * };\n *\n * const switchVideoService = new SwitchVideoAlt();\n * await switchVideoService.switchVideoAlt(options);\n * ```\n */\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class SwitchVideoAlt {\n  async switchVideoAlt({ parameters }: SwitchVideoAltOptions): Promise<void> {\n    let {\n      recordStarted,\n      recordResumed,\n      recordStopped,\n      recordPaused,\n      recordingMediaOptions,\n      videoAlreadyOn,\n      currentFacingMode,\n      allowed,\n      audioOnlyRoom,\n      updateCurrentFacingMode,\n      updateIsMediaSettingsModalVisible,\n\n      showAlert,\n\n      //media functions\n      switchUserVideoAlt,\n    } = parameters;\n\n    if (audioOnlyRoom) {\n      showAlert?.({\n        message: 'You cannot turn on your camera in an audio-only event.',\n        type: 'danger',\n        duration: 3000,\n      });\n      return;\n    }\n\n    let checkoff = false;\n    if (\n      (recordStarted || recordResumed) &&\n      !recordStopped &&\n      !recordPaused &&\n      recordingMediaOptions === 'video'\n    ) {\n      checkoff = true;\n    }\n\n    if (!allowed) {\n      showAlert?.({\n        message: 'Allow access to your camera by starting it for the first time.',\n        type: 'danger',\n        duration: 3000,\n      });\n      return;\n    }\n\n    if (checkoff) {\n      if (videoAlreadyOn) {\n        showAlert?.({\n          message: 'Please turn off your video before switching.',\n          type: 'danger',\n          duration: 3000,\n        });\n        return;\n      }\n    } else {\n      if (!videoAlreadyOn) {\n        showAlert?.({\n          message: 'Please turn on your video before switching.',\n          type: 'danger',\n          duration: 3000,\n        });\n        return;\n      }\n    }\n\n    // Camera switching logic here\n    let newFacingMode = currentFacingMode === 'environment' ? 'user' : 'environment';\n\n    updateCurrentFacingMode(newFacingMode);\n    updateIsMediaSettingsModalVisible(false);\n\n    await switchUserVideoAlt({ videoPreference: newFacingMode, checkoff, parameters });\n  }\n}\n"]}

package/dist/esm2022/lib/methods/stream-methods/switch-video.service.mjs

@@ -1,5 +1,61 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Switches the user's video device based on the provided video preference.
+ *
+ * @param {SwitchVideoOptions} options - The options for switching the video input.
+ * @param {string} options.videoPreference - The preferred video device to switch to.
+ * @param {SwitchVideoParameters} options.parameters - The parameters required for switching the video input.
+ * @param {boolean} options.parameters.recordStarted - Indicates if recording has started.
+ * @param {boolean} options.parameters.recordResumed - Indicates if recording has resumed.
+ * @param {boolean} options.parameters.recordStopped - Indicates if recording has stopped.
+ * @param {boolean} options.parameters.recordPaused - Indicates if recording is paused.
+ * @param {string} options.parameters.recordingMediaOptions - The current media options (e.g., "video").
+ * @param {boolean} options.parameters.videoAlreadyOn - Indicates if the video is currently on.
+ * @param {string} options.parameters.userDefaultVideoInputDevice - The default video input device for the user.
+ * @param {string} options.parameters.defVideoID - The default video ID for the input device.
+ * @param {boolean} options.parameters.allowed - Indicates if the user is allowed to switch video.
+ * @param {Function} options.parameters.updateDefVideoID - Function to update the default video ID.
+ * @param {Function} options.parameters.updatePrevVideoInputDevice - Function to update the previous video input device.
+ * @param {Function} options.parameters.updateUserDefaultVideoInputDevice - Function to update the user’s default video input device.
+ * @param {Function} options.parameters.updateIsMediaSettingsModalVisible - Function to update the visibility of the media settings modal.
+ * @param {Function} [options.parameters.showAlert] - Optional function to show alert messages.
+ * @param {Function} options.parameters.switchUserVideo - Function to switch the user's video input.
+ *
+ * @returns {Promise<void>} A promise that resolves when the video input has been switched.
+ *
+ * @remarks
+ * This function checks if the user is allowed to switch the video input based on the current state,
+ * and it shows alerts if there are any issues. If the video is already on, it cannot be switched until
+ * it is turned off, and vice versa. The default video input device is updated if necessary.
+ *
+ * @example
+ * ```typescript
+ * const options: SwitchVideoOptions = {
+ *   videoPreference: 'newDeviceId',
+ *   parameters: {
+ *     recordStarted: false,
+ *     recordResumed: false,
+ *     recordStopped: false,
+ *     recordPaused: false,
+ *     recordingMediaOptions: 'video',
+ *     videoAlreadyOn: true,
+ *     userDefaultVideoInputDevice: 'currentDeviceId',
+ *     defVideoID: 'defaultDeviceId',
+ *     allowed: true,
+ *     updateDefVideoID: (deviceId) => console.log(`Default video ID updated to: ${deviceId}`),
+ *     updatePrevVideoInputDevice: (deviceId) => console.log(`Previous video input device updated to: ${deviceId}`),
+ *     updateUserDefaultVideoInputDevice: (deviceId) => console.log(`User default video input device updated to: ${deviceId}`),
+ *     updateIsMediaSettingsModalVisible: (isVisible) => console.log(`Media settings modal is now ${isVisible ? 'visible' : 'hidden'}`),
+ *     switchUserVideo: async ({ videoPreference }) => console.log(`Switched video to: ${videoPreference}`),
+ *     getUpdatedAllParams: () => ({ }),
+ *   },
+ * };
+ *
+ * const switchVideoService = new SwitchVideo();
+ * await switchVideoService.switchVideo(options);
+ * ```
+ */
 export class SwitchVideo {
     /**
      * Switches the user's video device based on the provided video preference.
@@ -73,4 +129,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":"switch-video.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/methods/stream-methods/switch-video.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAiC3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AAKH,MAAM,OAAO,WAAW;IACtB;;;;OAIG;IAEH,KAAK,CAAC,WAAW,CAAC,EAAE,eAAe,EAAE,UAAU,EAAsB;QACnE,IAAI,EACF,aAAa,EACb,aAAa,EACb,aAAa,EACb,YAAY,EACZ,qBAAqB,EACrB,cAAc,EACd,2BAA2B,EAC3B,UAAU,EACV,OAAO,EACP,gBAAgB,EAChB,0BAA0B,EAC1B,iCAAiC,EACjC,iCAAiC;QAEjC,oBAAoB;QACpB,SAAS,EACT,eAAe,GAChB,GAAG,UAAU,CAAC;QAEf,6FAA6F;QAC7F,IAAI,QAAQ,GAAG,KAAK,CAAC;QACrB,IAAI,CAAC,aAAa,IAAI,aAAa,CAAC,IAAI,CAAC,aAAa,IAAI,CAAC,YAAY,EAAE,CAAC;YACxE,IAAI,qBAAqB,KAAK,OAAO,EAAE,CAAC;gBACtC,QAAQ,GAAG,IAAI,CAAC;YAClB,CAAC;QACH,CAAC;QAED,iCAAiC;QACjC,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,SAAS,EAAE,CAAC;gBACV,OAAO,EAAE,gEAAgE;gBACzE,IAAI,EAAE,QAAQ;gBACd,QAAQ,EAAE,IAAI;aACf,CAAC,CAAC;YACH,OAAO;QACT,CAAC;QAED,2DAA2D;QAC3D,IAAI,QAAQ,EAAE,CAAC;YACb,IAAI,cAAc,EAAE,CAAC;gBACnB,SAAS,EAAE,CAAC;oBACV,OAAO,EAAE,8CAA8C;oBACvD,IAAI,EAAE,QAAQ;oBACd,QAAQ,EAAE,IAAI;iBACf,CAAC,CAAC;gBACH,OAAO;YACT,CAAC;QACH,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,cAAc,EAAE,CAAC;gBACpB,SAAS,EAAE,CAAC;oBACV,OAAO,EAAE,6CAA6C;oBACtD,IAAI,EAAE,QAAQ;oBACd,QAAQ,EAAE,IAAI;iBACf,CAAC,CAAC;gBACH,OAAO;YACT,CAAC;QACH,CAAC;QAED,0CAA0C;QAC1C,IAAI,CAAC,UAAU,EAAE,CAAC;YAChB,UAAU,GAAG,2BAA2B,IAAI,SAAS,CAAC;YACtD,gBAAgB,CAAC,UAAU,CAAC,CAAC;QAC/B,CAAC;QAED,+EAA+E;QAC/E,IAAI,eAAe,KAAK,UAAU,EAAE,CAAC;YACnC,MAAM,oBAAoB,GAAG,2BAA2B,CAAC;YACzD,0BAA0B,CAAC,oBAAoB,CAAC,CAAC;YAEjD,2BAA2B,GAAG,eAAe,CAAC;YAC9C,iCAAiC,CAAC,2BAA2B,CAAC,CAAC;YAE/D,IAAI,UAAU,EAAE,CAAC;gBACf,iCAAiC,CAAC,KAAK,CAAC,CAAC;gBACzC,MAAM,eAAe,CAAC,EAAE,eAAe,EAAE,QAAQ,EAAE,UAAU,EAAE,CAAC,CAAC;YACnE,CAAC;QACH,CAAC;IACH,CAAC;uGAtFU,WAAW;2GAAX,WAAW,cAFV,MAAM;;2FAEP,WAAW;kBAHvB,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { ShowAlert, SwitchUserVideoParameters, SwitchUserVideoType } from '../../@types/types';\n\nexport interface SwitchVideoParameters extends SwitchUserVideoParameters {\n  recordStarted: boolean;\n  recordResumed: boolean;\n  recordStopped: boolean;\n  recordPaused: boolean;\n  recordingMediaOptions: string;\n  videoAlreadyOn: boolean;\n  userDefaultVideoInputDevice: string;\n  defVideoID: string;\n  allowed: boolean;\n  updateDefVideoID: (deviceId: string) => void;\n  updatePrevVideoInputDevice: (deviceId: string) => void;\n  updateUserDefaultVideoInputDevice: (deviceId: string) => void;\n  updateIsMediaSettingsModalVisible: (isVisible: boolean) => void;\n  showAlert?: ShowAlert;\n\n  // Mediasfu functions\n  switchUserVideo: SwitchUserVideoType;\n\n  [key: string]: any;\n}\n\nexport interface SwitchVideoOptions {\n  videoPreference: string;\n  parameters: SwitchVideoParameters;\n}\n\n// Export the type definition for the function\nexport type SwitchVideoType = (options: SwitchVideoOptions) => Promise<void>;\n\n/**\n * Switches the user's video device based on the provided video preference.\n *\n * @param {SwitchVideoOptions} options - The options for switching the video input.\n * @param {string} options.videoPreference - The preferred video device to switch to.\n * @param {SwitchVideoParameters} options.parameters - The parameters required for switching the video input.\n * @param {boolean} options.parameters.recordStarted - Indicates if recording has started.\n * @param {boolean} options.parameters.recordResumed - Indicates if recording has resumed.\n * @param {boolean} options.parameters.recordStopped - Indicates if recording has stopped.\n * @param {boolean} options.parameters.recordPaused - Indicates if recording is paused.\n * @param {string} options.parameters.recordingMediaOptions - The current media options (e.g., \"video\").\n * @param {boolean} options.parameters.videoAlreadyOn - Indicates if the video is currently on.\n * @param {string} options.parameters.userDefaultVideoInputDevice - The default video input device for the user.\n * @param {string} options.parameters.defVideoID - The default video ID for the input device.\n * @param {boolean} options.parameters.allowed - Indicates if the user is allowed to switch video.\n * @param {Function} options.parameters.updateDefVideoID - Function to update the default video ID.\n * @param {Function} options.parameters.updatePrevVideoInputDevice - Function to update the previous video input device.\n * @param {Function} options.parameters.updateUserDefaultVideoInputDevice - Function to update the user’s default video input device.\n * @param {Function} options.parameters.updateIsMediaSettingsModalVisible - Function to update the visibility of the media settings modal.\n * @param {Function} [options.parameters.showAlert] - Optional function to show alert messages.\n * @param {Function} options.parameters.switchUserVideo - Function to switch the user's video input.\n *\n * @returns {Promise<void>} A promise that resolves when the video input has been switched.\n *\n * @remarks\n * This function checks if the user is allowed to switch the video input based on the current state,\n * and it shows alerts if there are any issues. If the video is already on, it cannot be switched until\n * it is turned off, and vice versa. The default video input device is updated if necessary.\n *\n * @example\n * ```typescript\n * const options: SwitchVideoOptions = {\n *   videoPreference: 'newDeviceId',\n *   parameters: {\n *     recordStarted: false,\n *     recordResumed: false,\n *     recordStopped: false,\n *     recordPaused: false,\n *     recordingMediaOptions: 'video',\n *     videoAlreadyOn: true,\n *     userDefaultVideoInputDevice: 'currentDeviceId',\n *     defVideoID: 'defaultDeviceId',\n *     allowed: true,\n *     updateDefVideoID: (deviceId) => console.log(`Default video ID updated to: ${deviceId}`),\n *     updatePrevVideoInputDevice: (deviceId) => console.log(`Previous video input device updated to: ${deviceId}`),\n *     updateUserDefaultVideoInputDevice: (deviceId) => console.log(`User default video input device updated to: ${deviceId}`),\n *     updateIsMediaSettingsModalVisible: (isVisible) => console.log(`Media settings modal is now ${isVisible ? 'visible' : 'hidden'}`),\n *     switchUserVideo: async ({ videoPreference }) => console.log(`Switched video to: ${videoPreference}`),\n *     getUpdatedAllParams: () => ({ }),\n *   },\n * };\n *\n * const switchVideoService = new SwitchVideo();\n * await switchVideoService.switchVideo(options);\n * ```\n */\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class SwitchVideo {\n  /**\n   * Switches the user's video device based on the provided video preference.\n   *\n   * @param {SwitchVideoParams} options - The function parameters.\n   */\n\n  async switchVideo({ videoPreference, parameters }: SwitchVideoOptions): Promise<void> {\n    let {\n      recordStarted,\n      recordResumed,\n      recordStopped,\n      recordPaused,\n      recordingMediaOptions,\n      videoAlreadyOn,\n      userDefaultVideoInputDevice,\n      defVideoID,\n      allowed,\n      updateDefVideoID,\n      updatePrevVideoInputDevice,\n      updateUserDefaultVideoInputDevice,\n      updateIsMediaSettingsModalVisible,\n\n      //mediasfu functions\n      showAlert,\n      switchUserVideo,\n    } = parameters;\n\n    // Check if recording is in progress and whether the selected video device is the default one\n    let checkoff = false;\n    if ((recordStarted || recordResumed) && !recordStopped && !recordPaused) {\n      if (recordingMediaOptions === 'video') {\n        checkoff = true;\n      }\n    }\n\n    // Check camera access permission\n    if (!allowed) {\n      showAlert?.({\n        message: 'Allow access to your camera by starting it for the first time.',\n        type: 'danger',\n        duration: 3000,\n      });\n      return;\n    }\n\n    // Check video state and display appropriate alert messages\n    if (checkoff) {\n      if (videoAlreadyOn) {\n        showAlert?.({\n          message: 'Please turn off your video before switching.',\n          type: 'danger',\n          duration: 3000,\n        });\n        return;\n      }\n    } else {\n      if (!videoAlreadyOn) {\n        showAlert?.({\n          message: 'Please turn on your video before switching.',\n          type: 'danger',\n          duration: 3000,\n        });\n        return;\n      }\n    }\n\n    // Set default video ID if not already set\n    if (!defVideoID) {\n      defVideoID = userDefaultVideoInputDevice ?? 'default';\n      updateDefVideoID(defVideoID);\n    }\n\n    // Switch video only if the selected video device is different from the default\n    if (videoPreference !== defVideoID) {\n      const prevVideoInputDevice = userDefaultVideoInputDevice;\n      updatePrevVideoInputDevice(prevVideoInputDevice);\n\n      userDefaultVideoInputDevice = videoPreference;\n      updateUserDefaultVideoInputDevice(userDefaultVideoInputDevice);\n\n      if (defVideoID) {\n        updateIsMediaSettingsModalVisible(false);\n        await switchUserVideo({ videoPreference, checkoff, parameters });\n      }\n    }\n  }\n}\n"]}

package/dist/esm2022/lib/methods/utils/format-number.service.mjs

@@ -1,20 +1,32 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * The `FormatNumber` service provides functionality to format numeric values
+ * into a more readable string representation, appending appropriate suffixes
+ * like K (thousands), M (millions), and B (billions).
+ *
+ * @service
+ * @example
+ * ```typescript
+ * import { FormatNumber } from 'mediasfu-angular';
+ *
+ * constructor(private formatNumber: FormatNumber) {}
+ *
+ * async displayFormattedNumber() {
+ *   const formatted = await this.formatNumber.formatNumber({ number: 1500 });
+ *   console.log(formatted); // Outputs: "1.5K"
+ * }
+ * ```
+ *
+ * @remarks
+ * This service can be useful for displaying large numbers in a more compact form
+ * in user interfaces, especially in dashboards or reports where space is limited.
+ *
+ * @property {FormatNumberOptions} options - Options containing the number to format.
+ *
+ * @returns {FormatNumber} The FormatNumber service for formatting numeric values.
+ */
 export class FormatNumber {
-    /**
-     * Formats a number into a string representation with appropriate suffixes (K, M, B).
-     *
-     * @param number - The number to format.
-     * @returns A promise that resolves to a formatted string or undefined if the input is falsy.
-     *
-     * @example
-     * ```typescript
-     * formatNumber(500); // "500"
-     * formatNumber(1500); // "1.5K"
-     * formatNumber(1500000); // "1.5M"
-     * formatNumber(1500000000); // "1.5B"
-     * ```
-     */
     async formatNumber({ number }) {
         if (number) {
             if (number < 1e3) {
@@ -42,4 +54,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/generate-random-messages.service.mjs

@@ -1,5 +1,38 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * GenerateRandomMessages - Service to generate random chat messages from participants.
+ *
+ * This service generates random direct and group messages based on participants and a given host setup,
+ * with options to tailor messages for chat broadcast.
+ *
+ * @class
+ * @name GenerateRandomMessages
+ * @example
+ * ```typescript
+ * const generateRandomMessagesService = new GenerateRandomMessages();
+ * const messages = generateRandomMessagesService.generateRandomMessages({
+ *   participants: [
+ *     { name: 'Alice' },
+ *     { name: 'Bob' },
+ *     { name: 'Charlie' }
+ *   ],
+ *   member: 'Alice',
+ *   coHost: 'Bob',
+ *   host: 'Charlie',
+ *   forChatBroadcast: true
+ * });
+ * console.log(messages);
+ * ```
+ *
+ * @param {Object} options - Options for generating random messages.
+ * @param {Participant[]} options.participants - List of participants for message generation.
+ * @param {string} options.member - The primary member in the chat.
+ * @param {string} [options.coHost] - Optional co-host participant.
+ * @param {string} options.host - The chat host.
+ * @param {boolean} [options.forChatBroadcast=false] - Flag to indicate if messages are for chat broadcast.
+ * @returns {Message[]} Array of randomly generated messages with direct and group messaging.
+ */
 export class GenerateRandomMessages {
     /**
      * Generates random messages for a given set of participants.
@@ -84,4 +117,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":"generate-random-messages.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/methods/utils/generate-random-messages.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Message, Participant } from '../../@types/types';\n\nexport interface GenerateRandomMessagesOptions {\n  participants: Participant[];\n  member: string;\n  coHost?: string;\n  host: string;\n  forChatBroadcast?: boolean;\n}\n\n// Export the type definition for the function\nexport type GenerateRandomMessagesType = (options: GenerateRandomMessagesOptions) => Message[];\n\n/**\n * GenerateRandomMessages - Service to generate random chat messages from participants.\n *\n * This service generates random direct and group messages based on participants and a given host setup,\n * with options to tailor messages for chat broadcast.\n *\n * @class\n * @name GenerateRandomMessages\n * @example\n * ```typescript\n * const generateRandomMessagesService = new GenerateRandomMessages();\n * const messages = generateRandomMessagesService.generateRandomMessages({\n *   participants: [\n *     { name: 'Alice' },\n *     { name: 'Bob' },\n *     { name: 'Charlie' }\n *   ],\n *   member: 'Alice',\n *   coHost: 'Bob',\n *   host: 'Charlie',\n *   forChatBroadcast: true\n * });\n * console.log(messages);\n * ```\n *\n * @param {Object} options - Options for generating random messages.\n * @param {Participant[]} options.participants - List of participants for message generation.\n * @param {string} options.member - The primary member in the chat.\n * @param {string} [options.coHost] - Optional co-host participant.\n * @param {string} options.host - The chat host.\n * @param {boolean} [options.forChatBroadcast=false] - Flag to indicate if messages are for chat broadcast.\n * @returns {Message[]} Array of randomly generated messages with direct and group messaging.\n */\n\n\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class GenerateRandomMessages {\n  /**\n   * Generates random messages for a given set of participants.\n   *\n   * @param {Object} options - The options for generating random messages.\n   * @param {Array} options.participants - The list of participants.\n   * @param {string} options.member - The member who is part of the chat.\n   * @param {string} [options.coHost=\"\"] - The co-host of the chat.\n   * @param {string} options.host - The host of the chat.\n   * @param {boolean} [options.forChatBroadcast=false] - Flag to indicate if the messages are for chat broadcast.\n   * @returns {Message[]} An array of generated messages.\n   */\n  generateRandomMessages({\n    participants,\n    member,\n    coHost = '',\n    host,\n    forChatBroadcast = false,\n  }: GenerateRandomMessagesOptions): Message[] {\n    const messages: Message[] = [];\n\n    // Function to get a random participant other than the sender\n    const getRandomReceiver = (sender: string): string => {\n      const potentialReceivers = participants.filter((participant) => participant.name !== sender);\n      const randomReceiver =\n        potentialReceivers[Math.floor(Math.random() * potentialReceivers.length)];\n      return randomReceiver.name || '';\n    };\n\n    // Force add messages for specific participants\n    let refNames: string[] = [];\n    if (forChatBroadcast) {\n      refNames = [member, host];\n    } else {\n      if (coHost) {\n        refNames = [\n          member,\n          coHost,\n          host,\n          ...participants\n            .map((participant) => participant.name)\n            .filter((name): name is string => name !== undefined),\n        ];\n      } else {\n        refNames = [\n          member,\n          host,\n          ...participants\n            .map((participant) => participant.name)\n            .filter((name): name is string => name !== undefined),\n        ];\n      }\n    }\n\n    // Return unique names for the refNames\n    refNames = [...new Set(refNames)];\n\n    // Generate messages\n    let timeIncrement = 0;\n    refNames.forEach((sender) => {\n      // Send direct messages\n      const directMessage: Message = {\n        sender: sender,\n        receivers: [getRandomReceiver(sender)],\n        message: `Direct message from ${sender}`,\n        timestamp: new Date(Date.now() + timeIncrement).toLocaleTimeString(),\n        group: false,\n      };\n\n      messages.push(directMessage);\n\n      // Send group messages\n      const groupMessage: Message = {\n        sender: sender,\n        receivers: participants\n          .map((participant) => participant.name)\n          .filter((name): name is string => name !== undefined),\n        message: `Group message from ${sender}`,\n        timestamp: new Date(Date.now() + timeIncrement).toLocaleTimeString(),\n        group: true,\n      };\n      messages.push(groupMessage);\n\n      timeIncrement += 15000; // Increment time by 15 seconds for each message\n    });\n\n    return messages;\n  }\n}\n"]}

package/dist/esm2022/lib/methods/utils/generate-random-participants.service.mjs

@@ -1,5 +1,32 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * GenerateRandomParticipants - Service to generate a list of random participants.
+ *
+ * This service creates a list of participants based on a set of specified options, with customization for chat broadcasts
+ * and designation of specific roles like member, co-host, and host.
+ *
+ * @class
+ * @name GenerateRandomParticipants
+ * @example
+ * ```typescript
+ * const generateRandomParticipantsService = new GenerateRandomParticipants();
+ * const participants = generateRandomParticipantsService.generateRandomParticipants({
+ *   member: 'Alice',
+ *   coHost: 'Bob',
+ *   host: 'Charlie',
+ *   forChatBroadcast: true
+ * });
+ * console.log(participants);
+ * ```
+ *
+ * @param {Object} options - Options for generating participants.
+ * @param {string} options.member - Primary member to include in the participants list.
+ * @param {string} [options.coHost] - Optional co-host in the participants list.
+ * @param {string} options.host - Host to include in the participants list.
+ * @param {boolean} [options.forChatBroadcast=false] - Indicates if participants are for a chat broadcast.
+ * @returns {Participant[]} Array of generated participants with randomized levels, muted states, and identifiers.
+ */
 export class GenerateRandomParticipants {
     /**
      * Generates a list of random participants with specified options.
@@ -96,4 +123,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"generate-random-participants.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/methods/utils/generate-random-participants.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Participant } from '../../@types/types';\nexport interface GenerateRandomParticipantsOptions {\n  member: string;\n  coHost?: string;\n  host: string;\n  forChatBroadcast?: boolean;\n}\n\n// Export the type definition for the function\nexport type GenerateRandomParticipantsType = (\n  options: GenerateRandomParticipantsOptions,\n) => Participant[];\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class GenerateRandomParticipants {\n  /**\n   * Generates a list of random participants with specified options.\n   *\n   * @param {Object} options - The options for generating participants.\n   * @param {string} options.member - The member to include in the participants list.\n   * @param {string} [options.coHost=\"\"] - The co-host to include in the participants list.\n   * @param {string} options.host - The host to include in the participants list.\n   * @param {boolean} [options.forChatBroadcast=false] - Whether the participants are for a chat broadcast.\n   * @returns {Participant[]} An array of generated participants.\n   */\n  generateRandomParticipants({\n    member,\n    coHost = '',\n    host,\n    forChatBroadcast = false,\n  }: GenerateRandomParticipantsOptions): Participant[] {\n    const participants: Participant[] = [];\n    let names = [\n      'Alice',\n      'Bob',\n      'Charlie',\n      'David',\n      'Eve',\n      'Frank',\n      'Grace',\n      'Hank',\n      'Ivy',\n      'Jack',\n      'Kate',\n      'Liam',\n      'Mia',\n      'Nina',\n      'Olivia',\n      'Pete',\n      'Quinn',\n      'Rachel',\n      'Steve',\n      'Tina',\n      'Ursula',\n      'Vince',\n      'Wendy',\n      'Xander',\n      'Yvonne',\n      'Zack',\n    ];\n\n    // Limit names to 2 for chat broadcast\n    if (forChatBroadcast) {\n      names.splice(2);\n    }\n\n    // Place member, coHost, and host at the beginning if not already included\n    if (!names.includes(member)) {\n      names.unshift(member);\n    }\n    if (!names.includes(coHost) && !forChatBroadcast) {\n      names.unshift(coHost);\n    }\n    if (!names.includes(host)) {\n      names.unshift(host);\n    }\n\n    // Limit names to 2 for chat broadcast\n    if (forChatBroadcast) {\n      names.splice(2);\n    }\n\n    // Remove names of length 1 or less\n    names = names.filter((name) => name.length > 1);\n\n    // Shuffle the names array to ensure unique names for each participant\n    const shuffledNames = [...names];\n    for (let i = shuffledNames.length - 1; i > 0; i--) {\n      const j = Math.floor(Math.random() * (i + 1));\n      [shuffledNames[i], shuffledNames[j]] = [shuffledNames[j], shuffledNames[i]];\n    }\n\n    let hasLevel2Participant = false;\n\n    // Generate participant objects\n    for (let i = 0; i < shuffledNames.length; i++) {\n      const randomName = shuffledNames[i];\n      const randomLevel = hasLevel2Participant ? '1' : randomName == host ? '2' : '1'; // Set islevel to '2' only once\n      const randomMuted = forChatBroadcast ? true : Math.random() < 0.5; // Set muted to false for chat broadcast\n\n      if (randomLevel === '2') {\n        hasLevel2Participant = true;\n      }\n\n      participants.push({\n        name: randomName,\n        islevel: randomLevel,\n        muted: randomMuted,\n        id: i.toString(),\n        audioID: `audio-${i}`,\n        videoID: `video-${i}`,\n      });\n    }\n\n    return participants;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"generate-random-participants.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/methods/utils/generate-random-participants.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Participant } from '../../@types/types';\nexport interface GenerateRandomParticipantsOptions {\n  member: string;\n  coHost?: string;\n  host: string;\n  forChatBroadcast?: boolean;\n}\n\n// Export the type definition for the function\nexport type GenerateRandomParticipantsType = (\n  options: GenerateRandomParticipantsOptions,\n) => Participant[];\n\n/**\n * GenerateRandomParticipants - Service to generate a list of random participants.\n *\n * This service creates a list of participants based on a set of specified options, with customization for chat broadcasts\n * and designation of specific roles like member, co-host, and host.\n *\n * @class\n * @name GenerateRandomParticipants\n * @example\n * ```typescript\n * const generateRandomParticipantsService = new GenerateRandomParticipants();\n * const participants = generateRandomParticipantsService.generateRandomParticipants({\n *   member: 'Alice',\n *   coHost: 'Bob',\n *   host: 'Charlie',\n *   forChatBroadcast: true\n * });\n * console.log(participants);\n * ```\n *\n * @param {Object} options - Options for generating participants.\n * @param {string} options.member - Primary member to include in the participants list.\n * @param {string} [options.coHost] - Optional co-host in the participants list.\n * @param {string} options.host - Host to include in the participants list.\n * @param {boolean} [options.forChatBroadcast=false] - Indicates if participants are for a chat broadcast.\n * @returns {Participant[]} Array of generated participants with randomized levels, muted states, and identifiers.\n */\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class GenerateRandomParticipants {\n  /**\n   * Generates a list of random participants with specified options.\n   *\n   * @param {Object} options - The options for generating participants.\n   * @param {string} options.member - The member to include in the participants list.\n   * @param {string} [options.coHost=\"\"] - The co-host to include in the participants list.\n   * @param {string} options.host - The host to include in the participants list.\n   * @param {boolean} [options.forChatBroadcast=false] - Whether the participants are for a chat broadcast.\n   * @returns {Participant[]} An array of generated participants.\n   */\n  generateRandomParticipants({\n    member,\n    coHost = '',\n    host,\n    forChatBroadcast = false,\n  }: GenerateRandomParticipantsOptions): Participant[] {\n    const participants: Participant[] = [];\n    let names = [\n      'Alice',\n      'Bob',\n      'Charlie',\n      'David',\n      'Eve',\n      'Frank',\n      'Grace',\n      'Hank',\n      'Ivy',\n      'Jack',\n      'Kate',\n      'Liam',\n      'Mia',\n      'Nina',\n      'Olivia',\n      'Pete',\n      'Quinn',\n      'Rachel',\n      'Steve',\n      'Tina',\n      'Ursula',\n      'Vince',\n      'Wendy',\n      'Xander',\n      'Yvonne',\n      'Zack',\n    ];\n\n    // Limit names to 2 for chat broadcast\n    if (forChatBroadcast) {\n      names.splice(2);\n    }\n\n    // Place member, coHost, and host at the beginning if not already included\n    if (!names.includes(member)) {\n      names.unshift(member);\n    }\n    if (!names.includes(coHost) && !forChatBroadcast) {\n      names.unshift(coHost);\n    }\n    if (!names.includes(host)) {\n      names.unshift(host);\n    }\n\n    // Limit names to 2 for chat broadcast\n    if (forChatBroadcast) {\n      names.splice(2);\n    }\n\n    // Remove names of length 1 or less\n    names = names.filter((name) => name.length > 1);\n\n    // Shuffle the names array to ensure unique names for each participant\n    const shuffledNames = [...names];\n    for (let i = shuffledNames.length - 1; i > 0; i--) {\n      const j = Math.floor(Math.random() * (i + 1));\n      [shuffledNames[i], shuffledNames[j]] = [shuffledNames[j], shuffledNames[i]];\n    }\n\n    let hasLevel2Participant = false;\n\n    // Generate participant objects\n    for (let i = 0; i < shuffledNames.length; i++) {\n      const randomName = shuffledNames[i];\n      const randomLevel = hasLevel2Participant ? '1' : randomName == host ? '2' : '1'; // Set islevel to '2' only once\n      const randomMuted = forChatBroadcast ? true : Math.random() < 0.5; // Set muted to false for chat broadcast\n\n      if (randomLevel === '2') {\n        hasLevel2Participant = true;\n      }\n\n      participants.push({\n        name: randomName,\n        islevel: randomLevel,\n        muted: randomMuted,\n        id: i.toString(),\n        audioID: `audio-${i}`,\n        videoID: `video-${i}`,\n      });\n    }\n\n    return participants;\n  }\n}\n"]}

package/dist/esm2022/lib/methods/utils/generate-random-polls.service.mjs

@@ -1,5 +1,31 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+   * Generates an array of random poll objects with varying types and options.
+   *
+   * Each poll includes a question, a type (e.g., "trueFalse", "yesNo", or "custom"), and multiple choice options.
+   * Poll types determine the options generated:
+   * - `"trueFalse"` polls have "True" and "False" options.
+   * - `"yesNo"` polls have "Yes" and "No" options.
+   * - `"custom"` polls generate 2–6 custom options labeled as "Option 1", "Option 2", etc.
+   *
+   * @param {GenerateRandomPollsOptions} options - An object containing the number of polls to generate.
+   * @param {number} options.numberOfPolls - The number of random polls to generate.
+   * @returns {Poll[]} An array of generated polls with unique IDs and randomly selected types and options.
+   *
+   * @example
+   * const pollService = new GenerateRandomPolls();
+   * const options = { numberOfPolls: 3 };
+   * const randomPolls = pollService.generateRandomPolls(options);
+   *
+   * console.log(randomPolls);
+   * // Output:
+   * // [
+   * //   { id: '1', question: 'Random Question 1', type: 'yesNo', options: ['Yes', 'No'], votes: [0, 0], status: 'inactive', voters: {} },
+   * //   { id: '2', question: 'Random Question 2', type: 'trueFalse', options: ['True', 'False'], votes: [0, 0], status: 'inactive', voters: {} },
+   * //   { id: '3', question: 'Random Question 3', type: 'custom', options: ['Option 1', 'Option 2', 'Option 3'], votes: [0, 0, 0], status: 'inactive', voters: {} }
+   * // ]
+   */
 export class GenerateRandomPolls {
     /**
      * Generates an array of random poll objects.
@@ -49,4 +75,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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2VuZXJhdGUtcmFuZG9tLXBvbGxzLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tZWRpYXNmdS1hbmd1bGFyL3NyYy9saWIvbWV0aG9kcy91dGlscy9nZW5lcmF0ZS1yYW5kb20tcG9sbHMuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQVMzQzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztLQXlCSztBQUlMLE1BQU0sT0FBTyxtQkFBbUI7SUFDOUI7Ozs7OztPQU1HO0lBQ0gsbUJBQW1CLENBQUMsRUFBRSxhQUFhLEVBQThCO1FBQy9ELE1BQU0sU0FBUyxHQUFhLENBQUMsV0FBVyxFQUFFLE9BQU8sRUFBRSxRQUFRLENBQUMsQ0FBQztRQUM3RCxNQUFNLEtBQUssR0FBVyxFQUFFLENBQUM7UUFFekIsS0FBSyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLGFBQWEsRUFBRSxDQUFDLEVBQUUsRUFBRSxDQUFDO1lBQ3ZDLE1BQU0sSUFBSSxHQUFHLFNBQVMsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxNQUFNLEVBQUUsR0FBRyxTQUFTLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQztZQUNyRSxJQUFJLE9BQWlCLENBQUM7WUFFdEIsUUFBUSxJQUFJLEVBQUUsQ0FBQztnQkFDYixLQUFLLFdBQVc7b0JBQ2QsT0FBTyxHQUFHLENBQUMsTUFBTSxFQUFFLE9BQU8sQ0FBQyxDQUFDO29CQUM1QixNQUFNO2dCQUNSLEtBQUssT0FBTztvQkFDVixPQUFPLEdBQUcsQ0FBQyxLQUFLLEVBQUUsSUFBSSxDQUFDLENBQUM7b0JBQ3hCLE1BQU07Z0JBQ1IsS0FBSyxRQUFRO29CQUNYLE9BQU8sR0FBRyxLQUFLLENBQUMsSUFBSSxDQUNsQixFQUFFLE1BQU0sRUFBRSxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxNQUFNLEVBQUUsR0FBRyxDQUFDLENBQUMsR0FBRyxDQUFDLEVBQUUsRUFDN0MsQ0FBQyxDQUFDLEVBQUUsR0FBRyxFQUFFLEVBQUUsQ0FBQyxVQUFVLEdBQUcsR0FBRyxDQUFDLEVBQUUsQ0FDaEMsQ0FBQztvQkFDRixNQUFNO2dCQUNSO29CQUNFLE9BQU8sR0FBRyxFQUFFLENBQUM7WUFDakIsQ0FBQztZQUVELE1BQU0sSUFBSSxHQUFTO2dCQUNqQixFQUFFLEVBQUUsR0FBRyxDQUFDLEdBQUcsQ0FBQyxFQUFFO2dCQUNkLFFBQVEsRUFBRSxtQkFBbUIsQ0FBQyxHQUFHLENBQUMsRUFBRTtnQkFDcEMsSUFBSTtnQkFDSixPQUFPO2dCQUNQLEtBQUssRUFBRSxLQUFLLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUM7Z0JBQ3BDLE1BQU0sRUFBRSxVQUFVLEVBQUUsY0FBYztnQkFDbEMsTUFBTSxFQUFFLEVBQUU7YUFDWCxDQUFDO1lBRUYsS0FBSyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUNuQixDQUFDO1FBRUQsT0FBTyxLQUFLLENBQUM7SUFDZixDQUFDO3VHQS9DVSxtQkFBbUI7MkdBQW5CLG1CQUFtQixjQUZsQixNQUFNOzsyRkFFUCxtQkFBbUI7a0JBSC9CLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgUG9sbCB9IGZyb20gJy4uLy4uL0B0eXBlcy90eXBlcyc7XG5leHBvcnQgaW50ZXJmYWNlIEdlbmVyYXRlUmFuZG9tUG9sbHNPcHRpb25zIHtcbiAgbnVtYmVyT2ZQb2xsczogbnVtYmVyO1xufVxuXG4vLyBFeHBvcnQgdGhlIHR5cGUgZGVmaW5pdGlvbiBmb3IgdGhlIGZ1bmN0aW9uXG5leHBvcnQgdHlwZSBHZW5lcmF0ZVJhbmRvbVBvbGxzVHlwZSA9IChvcHRpb25zOiBHZW5lcmF0ZVJhbmRvbVBvbGxzT3B0aW9ucykgPT4gUG9sbFtdO1xuXG4vKipcbiAgICogR2VuZXJhdGVzIGFuIGFycmF5IG9mIHJhbmRvbSBwb2xsIG9iamVjdHMgd2l0aCB2YXJ5aW5nIHR5cGVzIGFuZCBvcHRpb25zLlxuICAgKlxuICAgKiBFYWNoIHBvbGwgaW5jbHVkZXMgYSBxdWVzdGlvbiwgYSB0eXBlIChlLmcuLCBcInRydWVGYWxzZVwiLCBcInllc05vXCIsIG9yIFwiY3VzdG9tXCIpLCBhbmQgbXVsdGlwbGUgY2hvaWNlIG9wdGlvbnMuXG4gICAqIFBvbGwgdHlwZXMgZGV0ZXJtaW5lIHRoZSBvcHRpb25zIGdlbmVyYXRlZDpcbiAgICogLSBgXCJ0cnVlRmFsc2VcImAgcG9sbHMgaGF2ZSBcIlRydWVcIiBhbmQgXCJGYWxzZVwiIG9wdGlvbnMuXG4gICAqIC0gYFwieWVzTm9cImAgcG9sbHMgaGF2ZSBcIlllc1wiIGFuZCBcIk5vXCIgb3B0aW9ucy5cbiAgICogLSBgXCJjdXN0b21cImAgcG9sbHMgZ2VuZXJhdGUgMuKAkzYgY3VzdG9tIG9wdGlvbnMgbGFiZWxlZCBhcyBcIk9wdGlvbiAxXCIsIFwiT3B0aW9uIDJcIiwgZXRjLlxuICAgKlxuICAgKiBAcGFyYW0ge0dlbmVyYXRlUmFuZG9tUG9sbHNPcHRpb25zfSBvcHRpb25zIC0gQW4gb2JqZWN0IGNvbnRhaW5pbmcgdGhlIG51bWJlciBvZiBwb2xscyB0byBnZW5lcmF0ZS5cbiAgICogQHBhcmFtIHtudW1iZXJ9IG9wdGlvbnMubnVtYmVyT2ZQb2xscyAtIFRoZSBudW1iZXIgb2YgcmFuZG9tIHBvbGxzIHRvIGdlbmVyYXRlLlxuICAgKiBAcmV0dXJucyB7UG9sbFtdfSBBbiBhcnJheSBvZiBnZW5lcmF0ZWQgcG9sbHMgd2l0aCB1bmlxdWUgSURzIGFuZCByYW5kb21seSBzZWxlY3RlZCB0eXBlcyBhbmQgb3B0aW9ucy5cbiAgICpcbiAgICogQGV4YW1wbGVcbiAgICogY29uc3QgcG9sbFNlcnZpY2UgPSBuZXcgR2VuZXJhdGVSYW5kb21Qb2xscygpO1xuICAgKiBjb25zdCBvcHRpb25zID0geyBudW1iZXJPZlBvbGxzOiAzIH07XG4gICAqIGNvbnN0IHJhbmRvbVBvbGxzID0gcG9sbFNlcnZpY2UuZ2VuZXJhdGVSYW5kb21Qb2xscyhvcHRpb25zKTtcbiAgICpcbiAgICogY29uc29sZS5sb2cocmFuZG9tUG9sbHMpO1xuICAgKiAvLyBPdXRwdXQ6XG4gICAqIC8vIFtcbiAgICogLy8gICB7IGlkOiAnMScsIHF1ZXN0aW9uOiAnUmFuZG9tIFF1ZXN0aW9uIDEnLCB0eXBlOiAneWVzTm8nLCBvcHRpb25zOiBbJ1llcycsICdObyddLCB2b3RlczogWzAsIDBdLCBzdGF0dXM6ICdpbmFjdGl2ZScsIHZvdGVyczoge30gfSxcbiAgICogLy8gICB7IGlkOiAnMicsIHF1ZXN0aW9uOiAnUmFuZG9tIFF1ZXN0aW9uIDInLCB0eXBlOiAndHJ1ZUZhbHNlJywgb3B0aW9uczogWydUcnVlJywgJ0ZhbHNlJ10sIHZvdGVzOiBbMCwgMF0sIHN0YXR1czogJ2luYWN0aXZlJywgdm90ZXJzOiB7fSB9LFxuICAgKiAvLyAgIHsgaWQ6ICczJywgcXVlc3Rpb246ICdSYW5kb20gUXVlc3Rpb24gMycsIHR5cGU6ICdjdXN0b20nLCBvcHRpb25zOiBbJ09wdGlvbiAxJywgJ09wdGlvbiAyJywgJ09wdGlvbiAzJ10sIHZvdGVzOiBbMCwgMCwgMF0sIHN0YXR1czogJ2luYWN0aXZlJywgdm90ZXJzOiB7fSB9XG4gICAqIC8vIF1cbiAgICovXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290Jyxcbn0pXG5leHBvcnQgY2xhc3MgR2VuZXJhdGVSYW5kb21Qb2xscyB7XG4gIC8qKlxuICAgKiBHZW5lcmF0ZXMgYW4gYXJyYXkgb2YgcmFuZG9tIHBvbGwgb2JqZWN0cy5cbiAgICpcbiAgICogQHBhcmFtIHtHZW5lcmF0ZVJhbmRvbVBvbGxzT3B0aW9uc30gb3B0aW9ucyAtIEFuIG9iamVjdCBjb250YWluaW5nIHRoZSBudW1iZXIgb2YgcG9sbHMgdG8gZ2VuZXJhdGUuXG4gICAqIEBwYXJhbSB7bnVtYmVyfSBvcHRpb25zLm51bWJlck9mUG9sbHMgLSBUaGUgbnVtYmVyIG9mIHJhbmRvbSBwb2xscyB0byBnZW5lcmF0ZS5cbiAgICogQHJldHVybnMge1BvbGxbXX0gQW4gYXJyYXkgb2YgcmFuZG9tIHBvbGwgb2JqZWN0cy5cbiAgICovXG4gIGdlbmVyYXRlUmFuZG9tUG9sbHMoeyBudW1iZXJPZlBvbGxzIH06IEdlbmVyYXRlUmFuZG9tUG9sbHNPcHRpb25zKTogUG9sbFtdIHtcbiAgICBjb25zdCBwb2xsVHlwZXM6IHN0cmluZ1tdID0gWyd0cnVlRmFsc2UnLCAneWVzTm8nLCAnY3VzdG9tJ107XG4gICAgY29uc3QgcG9sbHM6IFBvbGxbXSA9IFtdO1xuXG4gICAgZm9yIChsZXQgaSA9IDA7IGkgPCBudW1iZXJPZlBvbGxzOyBpKyspIHtcbiAgICAgIGNvbnN0IHR5cGUgPSBwb2xsVHlwZXNbTWF0aC5mbG9vcihNYXRoLnJhbmRvbSgpICogcG9sbFR5cGVzLmxlbmd0aCldO1xuICAgICAgbGV0IG9wdGlvbnM6IHN0cmluZ1tdO1xuXG4gICAgICBzd2l0Y2ggKHR5cGUpIHtcbiAgICAgICAgY2FzZSAndHJ1ZUZhbHNlJzpcbiAgICAgICAgICBvcHRpb25zID0gWydUcnVlJywgJ0ZhbHNlJ107XG4gICAgICAgICAgYnJlYWs7XG4gICAgICAgIGNhc2UgJ3llc05vJzpcbiAgICAgICAgICBvcHRpb25zID0gWydZZXMnLCAnTm8nXTtcbiAgICAgICAgICBicmVhaztcbiAgICAgICAgY2FzZSAnY3VzdG9tJzpcbiAgICAgICAgICBvcHRpb25zID0gQXJyYXkuZnJvbShcbiAgICAgICAgICAgIHsgbGVuZ3RoOiBNYXRoLmZsb29yKE1hdGgucmFuZG9tKCkgKiA1KSArIDIgfSxcbiAgICAgICAgICAgIChfLCBpZHgpID0+IGBPcHRpb24gJHtpZHggKyAxfWAsXG4gICAgICAgICAgKTtcbiAgICAgICAgICBicmVhaztcbiAgICAgICAgZGVmYXVsdDpcbiAgICAgICAgICBvcHRpb25zID0gW107XG4gICAgICB9XG5cbiAgICAgIGNvbnN0IHBvbGw6IFBvbGwgPSB7XG4gICAgICAgIGlkOiBgJHtpICsgMX1gLFxuICAgICAgICBxdWVzdGlvbjogYFJhbmRvbSBRdWVzdGlvbiAke2kgKyAxfWAsXG4gICAgICAgIHR5cGUsXG4gICAgICAgIG9wdGlvbnMsXG4gICAgICAgIHZvdGVzOiBBcnJheShvcHRpb25zLmxlbmd0aCkuZmlsbCgwKSxcbiAgICAgICAgc3RhdHVzOiAnaW5hY3RpdmUnLCAvLyBvciAnYWN0aXZlJ1xuICAgICAgICB2b3RlcnM6IHt9LFxuICAgICAgfTtcblxuICAgICAgcG9sbHMucHVzaChwb2xsKTtcbiAgICB9XG5cbiAgICByZXR1cm4gcG9sbHM7XG4gIH1cbn1cbiJdfQ==