mediasfu-angular 1.0.0 → 1.0.2

package/dist/esm2022/lib/methods/polls-methods/launch-poll.service.mjs

@@ -1,5 +1,25 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Toggles the visibility of the poll modal.
+ *
+ * @param {LaunchPollOptions} options - The options object containing necessary variables and functions.
+ * @param {Function} options.updateIsPollModalVisible - Function to update the visibility state of the poll modal.
+ * @param {boolean} options.isPollModalVisible - Current visibility state of the poll modal.
+ *
+ * @returns {void}
+ *
+ * @example
+ * ```typescript
+ * const launchPollService = new LaunchPoll();
+ * launchPollService.launchPoll({
+ *   updateIsPollModalVisible: (isVisible) => {
+ *     console.log('Poll modal visibility:', isVisible);
+ *   },
+ *   isPollModalVisible: false,
+ * });
+ * ```
+ */
 export class LaunchPoll {
     /**
      * Toggles the visibility of the poll modal.
@@ -20,4 +40,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGF1bmNoLXBvbGwuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL21lZGlhc2Z1LWFuZ3VsYXIvc3JjL2xpYi9tZXRob2RzL3BvbGxzLW1ldGhvZHMvbGF1bmNoLXBvbGwuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQVkzQyxNQUFNLE9BQU8sVUFBVTtJQUNyQjs7Ozs7O09BTUc7SUFFSCxVQUFVLENBQUMsRUFBRSx3QkFBd0IsRUFBRSxrQkFBa0IsRUFBcUI7UUFDNUUsd0JBQXdCLENBQUMsQ0FBQyxrQkFBa0IsQ0FBQyxDQUFDO0lBQ2hELENBQUM7dUdBWFUsVUFBVTsyR0FBVixVQUFVLGNBRlQsTUFBTTs7MkZBRVAsVUFBVTtrQkFIdEIsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5leHBvcnQgaW50ZXJmYWNlIExhdW5jaFBvbGxPcHRpb25zIHtcbiAgdXBkYXRlSXNQb2xsTW9kYWxWaXNpYmxlOiAoaXNWaXNpYmxlOiBib29sZWFuKSA9PiB2b2lkO1xuICBpc1BvbGxNb2RhbFZpc2libGU6IGJvb2xlYW47XG59XG5cbi8vIEV4cG9ydCB0aGUgdHlwZSBkZWZpbml0aW9uIGZvciB0aGUgZnVuY3Rpb25cbmV4cG9ydCB0eXBlIExhdW5jaFBvbGxUeXBlID0gKG9wdGlvbnM6IExhdW5jaFBvbGxPcHRpb25zKSA9PiB2b2lkO1xuXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290Jyxcbn0pXG5leHBvcnQgY2xhc3MgTGF1bmNoUG9sbCB7XG4gIC8qKlxuICAgKiBUb2dnbGVzIHRoZSB2aXNpYmlsaXR5IG9mIHRoZSBwb2xsIG1vZGFsLlxuICAgKiBAZnVuY3Rpb25cbiAgICogQHBhcmFtIHtPYmplY3R9IG9wdGlvbnMgLSBUaGUgb3B0aW9ucyBvYmplY3QgY29udGFpbmluZyBuZWNlc3NhcnkgdmFyaWFibGVzIGFuZCBmdW5jdGlvbnMuXG4gICAqIEBwYXJhbSB7RnVuY3Rpb259IG9wdGlvbnMudXBkYXRlSXNQb2xsTW9kYWxWaXNpYmxlIC0gRnVuY3Rpb24gdG8gdXBkYXRlIHRoZSB2aXNpYmlsaXR5IHN0YXRlIG9mIHRoZSBwb2xsIG1vZGFsLlxuICAgKiBAcGFyYW0ge2Jvb2xlYW59IG9wdGlvbnMuaXNQb2xsTW9kYWxWaXNpYmxlIC0gQ3VycmVudCB2aXNpYmlsaXR5IHN0YXRlIG9mIHRoZSBwb2xsIG1vZGFsLlxuICAgKi9cblxuICBsYXVuY2hQb2xsKHsgdXBkYXRlSXNQb2xsTW9kYWxWaXNpYmxlLCBpc1BvbGxNb2RhbFZpc2libGUgfTogTGF1bmNoUG9sbE9wdGlvbnMpOiB2b2lkIHtcbiAgICB1cGRhdGVJc1BvbGxNb2RhbFZpc2libGUoIWlzUG9sbE1vZGFsVmlzaWJsZSk7XG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/methods/polls-methods/poll-updated.service.mjs

@@ -1,5 +1,36 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Updates the poll state based on the provided data.
+ *
+ * @param {PollUpdatedOptions} options - The options for updating the poll.
+ * @param {PollUpdatedData} options.data - The data containing poll information.
+ * @param {Poll[]} options.polls - The current list of polls.
+ * @param {Poll} options.poll - The current poll.
+ * @param {string} options.member - The member identifier.
+ * @param {string} options.islevel - The level of the member.
+ * @param {Function} [options.showAlert] - Function to show alerts.
+ * @param {Function} options.updatePolls - Function to update the list of polls.
+ * @param {Function} options.updatePoll - Function to update the current poll.
+ * @param {Function} options.updateIsPollModalVisible - Function to update the visibility of the poll modal.
+ * @returns {Promise<void>} A promise that resolves when the poll update is complete.
+ *
+ * @example
+ * ```typescript
+ * const pollUpdatedService = new PollUpdated();
+ * pollUpdatedService.pollUpdated({
+ *   data: { polls: [], poll: { id: '123', question: 'Sample Poll?', status: 'started' } },
+ *   polls: [],
+ *   poll: { id: '123', question: 'Sample Poll?', status: 'started' },
+ *   member: 'user1',
+ *   islevel: '1',
+ *   showAlert: (alert) => console.log(alert.message),
+ *   updatePolls: (polls) => console.log('Updated polls:', polls),
+ *   updatePoll: (poll) => console.log('Updated poll:', poll),
+ *   updateIsPollModalVisible: (visible) => console.log('Poll modal visibility:', visible),
+ * });
+ * ```
+ */
 export class PollUpdated {
     /**
      * Updates the poll state based on the provided data.
@@ -61,4 +92,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":"poll-updated.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/methods/polls-methods/poll-updated.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAiB3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAMH,MAAM,OAAO,WAAW;IACtB;;;;;;;;;;;;;;OAcG;IAEH,KAAK,CAAC,WAAW,CAAC,EAChB,IAAI,EACJ,KAAK,EACL,IAAI,EACJ,MAAM,EACN,OAAO,EACP,SAAS,EACT,WAAW,EACX,UAAU,EACV,wBAAwB,GACL;QACnB,IAAI,CAAC;YACH,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;gBACf,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;gBACnB,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAC1B,CAAC;iBAAM,CAAC;gBACN,KAAK,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBACpB,WAAW,CAAC,KAAK,CAAC,CAAC;YACrB,CAAC;YAED,IAAI,SAAS,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC;YAE3B,IAAI,IAAI,EAAE,CAAC;gBACT,SAAS,GAAG,EAAE,GAAG,IAAI,EAAE,CAAC;YAC1B,CAAC;YAED,IAAI,IAAI,CAAC,MAAM,IAAI,OAAO,EAAE,CAAC;gBAC3B,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;gBACjB,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACxB,CAAC;YAED,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,IAAI,OAAO,KAAK,GAAG,EAAE,CAAC;gBACjD,IAAI,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;oBAC1D,SAAS,EAAE,CAAC,EAAE,OAAO,EAAE,kBAAkB,EAAE,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;oBAC9E,wBAAwB,CAAC,IAAI,CAAC,CAAC;gBACjC,CAAC;YACH,CAAC;iBAAM,IAAI,IAAI,CAAC,MAAM,KAAK,OAAO,EAAE,CAAC;gBACnC,IAAI,SAAS,CAAC,EAAE,KAAK,IAAI,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC;oBAClC,SAAS,EAAE,CAAC,EAAE,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;oBACvE,kBAAkB;oBAClB,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBACxB,CAAC;YACH,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,sBAAsB;QACxB,CAAC;IACH,CAAC;uGA/DU,WAAW;2GAAX,WAAW,cAFV,MAAM;;2FAEP,WAAW;kBAHvB,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Poll, ShowAlert, PollUpdatedData } from '../../@types/types';\nexport interface PollUpdatedOptions {\n  data: PollUpdatedData;\n  polls: Poll[];\n  poll: Poll;\n  member: string;\n  islevel: string;\n  showAlert?: ShowAlert;\n  updatePolls: (polls: Poll[]) => void;\n  updatePoll: (poll: Poll) => void;\n  updateIsPollModalVisible: (isVisible: boolean) => void;\n}\n\n// Export the type definition for the function\nexport type PollUpdatedType = (options: PollUpdatedOptions) => Promise<void>;\n\n/**\n * Updates the poll state based on the provided data.\n *\n * @param {PollUpdatedOptions} options - The options for updating the poll.\n * @param {PollUpdatedData} options.data - The data containing poll information.\n * @param {Poll[]} options.polls - The current list of polls.\n * @param {Poll} options.poll - The current poll.\n * @param {string} options.member - The member identifier.\n * @param {string} options.islevel - The level of the member.\n * @param {Function} [options.showAlert] - Function to show alerts.\n * @param {Function} options.updatePolls - Function to update the list of polls.\n * @param {Function} options.updatePoll - Function to update the current poll.\n * @param {Function} options.updateIsPollModalVisible - Function to update the visibility of the poll modal.\n * @returns {Promise<void>} A promise that resolves when the poll update is complete.\n *\n * @example\n * ```typescript\n * const pollUpdatedService = new PollUpdated();\n * pollUpdatedService.pollUpdated({\n *   data: { polls: [], poll: { id: '123', question: 'Sample Poll?', status: 'started' } },\n *   polls: [],\n *   poll: { id: '123', question: 'Sample Poll?', status: 'started' },\n *   member: 'user1',\n *   islevel: '1',\n *   showAlert: (alert) => console.log(alert.message),\n *   updatePolls: (polls) => console.log('Updated polls:', polls),\n *   updatePoll: (poll) => console.log('Updated poll:', poll),\n *   updateIsPollModalVisible: (visible) => console.log('Poll modal visibility:', visible),\n * });\n * ```\n */\n\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class PollUpdated {\n  /**\n   * Updates the poll state based on the provided data.\n   *\n   * @param {Object} options - The options for updating the poll.\n   * @param {any} options.data - The data containing poll information.\n   * @param {any[]} options.polls - The current list of polls.\n   * @param {any} options.poll - The current poll.\n   * @param {string} options.member - The member identifier.\n   * @param {string} options.islevel - The level of the member.\n   * @param {Function} options.showAlert - Function to show alerts.\n   * @param {Function} options.updatePolls - Function to update the list of polls.\n   * @param {Function} options.updatePoll - Function to update the current poll.\n   * @param {Function} options.updateIsPollModalVisible - Function to update the visibility of the poll modal.\n   * @returns {Promise<void>} A promise that resolves when the poll update is complete.\n   */\n\n  async pollUpdated({\n    data,\n    polls,\n    poll,\n    member,\n    islevel,\n    showAlert,\n    updatePolls,\n    updatePoll,\n    updateIsPollModalVisible,\n  }: PollUpdatedOptions): Promise<void> {\n    try {\n      if (data.polls) {\n        polls = data.polls;\n        updatePolls(data.polls);\n      } else {\n        polls = [data.poll];\n        updatePolls(polls);\n      }\n\n      let temp_poll = { id: '' };\n\n      if (poll) {\n        temp_poll = { ...poll };\n      }\n\n      if (data.status != 'ended') {\n        poll = data.poll;\n        updatePoll(data.poll);\n      }\n\n      if (data.status === 'started' && islevel !== '2') {\n        if (!poll.voters || (poll.voters && !poll.voters[member])) {\n          showAlert?.({ message: 'New poll started', type: 'success', duration: 3000 });\n          updateIsPollModalVisible(true);\n        }\n      } else if (data.status === 'ended') {\n        if (temp_poll.id === data.poll.id) {\n          showAlert?.({ message: 'Poll ended', type: 'danger', duration: 3000 });\n          // update the poll\n          updatePoll(data.poll);\n        }\n      }\n    } catch (error) {\n      // console.log(error);\n    }\n  }\n}\n"]}

package/dist/esm2022/lib/methods/recording-methods/check-pause-state.service.mjs

@@ -1,5 +1,29 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Checks if the recording can be paused based on the current pause count and the allowed pause limits.
+ *
+ * @param {CheckPauseStateOptions} options - The options for checking the pause state.
+ * @param {string} options.recordingMediaOptions - The type of media being recorded ("video" or "audio").
+ * @param {number} options.recordingVideoPausesLimit - The maximum number of pauses allowed for video recordings.
+ * @param {number} options.recordingAudioPausesLimit - The maximum number of pauses allowed for audio recordings.
+ * @param {number} options.pauseRecordCount - The current count of pauses that have been made.
+ * @param {Function} [options.showAlert] - A function to show an alert message if the pause limit is reached.
+ * @returns {Promise<boolean>} A promise that resolves to `true` if the recording can be paused, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * const checkPauseStateService = new CheckPauseState();
+ * const canPause = await checkPauseStateService.checkPauseState({
+ *   recordingMediaOptions: 'video',
+ *   recordingVideoPausesLimit: 3,
+ *   recordingAudioPausesLimit: 5,
+ *   pauseRecordCount: 2,
+ *   showAlert: (alert) => console.log(alert.message),
+ * });
+ * console.log('Can pause recording:', canPause);
+ * ```
+ */
 export class CheckPauseState {
     /**
      * Checks if the recording can be paused based on the current pause count and the allowed pause limits.
@@ -42,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/recording-methods/check-resume-state.service.mjs

@@ -1,5 +1,27 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Checks if the recording can be resumed based on the media type and pause limits.
+ *
+ * @param {CheckResumeStateOptions} options - The options for checking resume state.
+ * @param {string} options.recordingMediaOptions - The type of media being recorded ("video" or "audio").
+ * @param {number} options.recordingVideoPausesLimit - The maximum number of pauses allowed for video recording.
+ * @param {number} options.recordingAudioPausesLimit - The maximum number of pauses allowed for audio recording.
+ * @param {number} options.pauseRecordCount - The current number of pauses that have occurred.
+ * @returns {Promise<boolean>} A promise that resolves to a boolean indicating whether the recording can be resumed.
+ *
+ * @example
+ * ```typescript
+ * const checkResumeStateService = new CheckResumeState();
+ * const canResume = await checkResumeStateService.checkResumeState({
+ *   recordingMediaOptions: 'audio',
+ *   recordingVideoPausesLimit: 3,
+ *   recordingAudioPausesLimit: 5,
+ *   pauseRecordCount: 2,
+ * });
+ * console.log('Can resume recording:', canResume);
+ * ```
+ */
 export class CheckResumeState {
     /**
      * Checks if the recording can be resumed based on the media type and pause limits.
@@ -31,4 +53,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/recording-methods/confirm-recording.service.mjs

@@ -1,5 +1,68 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Confirms the recording settings based on the provided parameters and updates the recording state.
+ *
+ * @param {ConfirmRecordingOptions} options - The options for confirming the recording.
+ * @param {ConfirmRecordingParameters} options.parameters - The parameters for the recording, including:
+ *   - {ShowAlert} [options.parameters.showAlert] - Optional function to show alert messages.
+ *   - {string} options.parameters.recordingMediaOptions - Type of media being recorded ("video" or "audio").
+ *   - {string} options.parameters.recordingAudioOptions - Audio recording options.
+ *   - {string} options.parameters.recordingVideoOptions - Video recording options.
+ *   - {string} options.parameters.recordingVideoType - Type of video recording.
+ *   - {'video' | 'media' | 'all'} options.parameters.recordingDisplayType - The display type for the recording.
+ *   - {boolean} options.parameters.recordingNameTags - Flag for including name tags in the recording.
+ *   - {string} options.parameters.recordingBackgroundColor - Background color for the recording.
+ *   - {string} options.parameters.recordingNameTagsColor - Color for the name tags.
+ *   - {string} options.parameters.recordingOrientationVideo - Orientation for video recording.
+ *   - {boolean} options.parameters.recordingAddHLS - Flag for adding HLS support.
+ *   - {boolean} options.parameters.recordingAddText - Flag for adding custom text.
+ *   - {string} options.parameters.recordingCustomText - Custom text for the recording.
+ *   - {string} options.parameters.recordingCustomTextPosition - Position of the custom text.
+ *   - {string} options.parameters.recordingCustomTextColor - Color of the custom text.
+ *   - {string} options.parameters.meetingDisplayType - Current display type of the meeting.
+ *   - {boolean} options.parameters.recordingVideoParticipantsFullRoomSupport - Support for video participants in full room.
+ *   - {boolean} options.parameters.recordingAllParticipantsSupport - Support for recording all participants.
+ *   - {boolean} options.parameters.recordingVideoParticipantsSupport - Support for video participants.
+ *   - {boolean} options.parameters.recordingSupportForOtherOrientation - Support for other orientations.
+ *   - {string} options.parameters.recordingPreferredOrientation - Preferred orientation for recording.
+ *   - {boolean} options.parameters.recordingMultiFormatsSupport - Support for multiple formats.
+ *   - {boolean} options.parameters.recordingVideoOptimized - Flag for video optimization.
+ *   - {boolean} options.parameters.recordingAllParticipantsFullRoomSupport - Support for recording all participants in full room.
+ *   - {boolean} options.parameters.meetingVideoOptimized - Flag for meeting video optimization.
+ *   - {EventType} options.parameters.eventType - Type of the event.
+ *   - {boolean} options.parameters.breakOutRoomStarted - Indicates if a breakout room has started.
+ *   - {boolean} options.parameters.breakOutRoomEnded - Indicates if a breakout room has ended.
+ *   - {Function} options.parameters.updateRecordingDisplayType - Function to update the recording display type.
+ *   - {Function} options.parameters.updateRecordingVideoOptimized - Function to update video optimization status.
+ *   - {Function} options.parameters.updateUserRecordingParams - Function to update user recording parameters.
+ *   - {Function} options.parameters.updateConfirmedToRecord - Function to confirm the recording.
+ *
+ * @returns {Promise<void>} A promise that resolves when the recording settings have been confirmed.
+ *
+ * @remarks
+ * This function performs several checks to ensure that the recording settings are valid based on the provided parameters.
+ * If any of the checks fail, an alert is shown and the function returns early without updating the recording state.
+ *
+ * The function checks for the following conditions:
+ * - Whether recording videos of all participants is allowed.
+ * - Whether recording all participants is allowed.
+ * - Whether recording other video participants is allowed.
+ * - Whether recording all orientations is allowed.
+ * - Whether recording the preferred orientation is allowed.
+ * - Whether recording all formats is allowed.
+ * - Whether the recording display type is valid based on the meeting display type.
+ * - Whether recording all participants with media is allowed.
+ *
+ * If all checks pass, the function constructs the `mainSpecs`, `dispSpecs`, and `textSpecs` objects based on the state variables,
+ * updates the user recording parameters, and confirms the recording.
+ *
+ * @example
+ * ```typescript
+ * const options: ConfirmRecordingOptions = { parameters: someParameters };
+ * await confirmRecording(options);
+ * ```
+ */
 export class ConfirmRecording {
     /**
      * Confirms the recording settings based on the provided parameters and updates the recording state.
@@ -212,4 +275,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"confirm-recording.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/methods/recording-methods/confirm-recording.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  ShowAlert,\n  MainSpecs,\n  DispSpecs,\n  TextSpecs,\n  EventType,\n  UserRecordingParams,\n} from '../../@types/types';\n\nexport interface ConfirmRecordingParameters {\n  showAlert?: ShowAlert;\n  recordingMediaOptions: string;\n  recordingAudioOptions: string;\n  recordingVideoOptions: string;\n  recordingVideoType: string;\n  recordingDisplayType: 'video' | 'media' | 'all';\n  recordingNameTags: boolean;\n  recordingBackgroundColor: string;\n  recordingNameTagsColor: string;\n  recordingOrientationVideo: string;\n  recordingAddHLS: boolean;\n  recordingAddText: boolean;\n  recordingCustomText: string;\n  recordingCustomTextPosition: string;\n  recordingCustomTextColor: string;\n  meetingDisplayType: string;\n  recordingVideoParticipantsFullRoomSupport: boolean;\n  recordingAllParticipantsSupport: boolean;\n  recordingVideoParticipantsSupport: boolean;\n  recordingSupportForOtherOrientation: boolean;\n  recordingPreferredOrientation: string;\n  recordingMultiFormatsSupport: boolean;\n  recordingVideoOptimized: boolean;\n  recordingAllParticipantsFullRoomSupport: boolean;\n  meetingVideoOptimized: boolean;\n  eventType: EventType;\n  breakOutRoomStarted: boolean;\n  breakOutRoomEnded: boolean;\n  updateRecordingDisplayType: (value: 'video' | 'media' | 'all') => void;\n  updateRecordingVideoOptimized: (value: boolean) => void;\n  updateUserRecordingParams: (params: UserRecordingParams) => void;\n  updateConfirmedToRecord: (value: boolean) => void;\n\n  // Mediasfu functions\n  getUpdatedAllParams: () => ConfirmRecordingParameters;\n  [key: string]: any;\n}\n\nexport interface ConfirmRecordingOptions {\n  parameters: ConfirmRecordingParameters;\n}\n\n// Export the type definition for the function\nexport type ConfirmRecordingType = (options: ConfirmRecordingOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ConfirmRecording {\n  /**\n   * Confirms the recording settings based on the provided parameters and updates the recording state.\n   *\n   * @param {ConfirmRecordingOptions} options - The options for confirming the recording.\n   * @param {Parameters} options.parameters - The parameters for the recording.\n   *\n   * @returns {Promise<void>} A promise that resolves when the recording settings have been confirmed.\n   *\n   * @remarks\n   * This function performs several checks to ensure that the recording settings are valid based on the provided parameters.\n   * If any of the checks fail, an alert is shown and the function returns early without updating the recording state.\n   *\n   * The function checks for the following conditions:\n   * - Whether recording videos of all participants is allowed.\n   * - Whether recording all participants is allowed.\n   * - Whether recording other video participants is allowed.\n   * - Whether recording all orientations is allowed.\n   * - Whether recording the preferred orientation is allowed.\n   * - Whether recording all formats is allowed.\n   * - Whether the recording display type is valid based on the meeting display type.\n   * - Whether recording all participants with media is allowed.\n   *\n   * If all checks pass, the function constructs the `mainSpecs`, `dispSpecs`, and `textSpecs` objects based on the state variables,\n   * updates the user recording parameters, and confirms the recording.\n   *\n   * @example\n   * ```typescript\n   * const options: ConfirmRecordingOptions = { parameters: someParameters };\n   * await confirmRecording(options);\n   * ```\n   */\n\n  confirmRecording = async ({ parameters }: ConfirmRecordingOptions): Promise<void> => {\n    let { getUpdatedAllParams } = parameters;\n    parameters = getUpdatedAllParams();\n\n    let {\n      showAlert,\n      recordingMediaOptions,\n      recordingAudioOptions,\n      recordingVideoOptions,\n      recordingVideoType,\n      recordingDisplayType,\n      recordingNameTags,\n      recordingBackgroundColor,\n      recordingNameTagsColor,\n      recordingOrientationVideo,\n      recordingAddHLS,\n      recordingAddText,\n      recordingCustomText,\n      recordingCustomTextPosition,\n      recordingCustomTextColor,\n      meetingDisplayType,\n      recordingVideoParticipantsFullRoomSupport,\n      recordingAllParticipantsSupport,\n      recordingVideoParticipantsSupport,\n      recordingSupportForOtherOrientation,\n      recordingPreferredOrientation,\n      recordingMultiFormatsSupport,\n      recordingVideoOptimized,\n      recordingAllParticipantsFullRoomSupport,\n      meetingVideoOptimized,\n      eventType,\n      breakOutRoomStarted,\n      breakOutRoomEnded,\n\n      updateRecordingDisplayType,\n      updateRecordingVideoOptimized,\n      updateRecordingVideoParticipantsFullRoomSupport,\n      updateRecordingAllParticipantsSupport,\n      updateRecordingVideoParticipantsSupport,\n      updateRecordingSupportForOtherOrientation,\n      updateRecordingPreferredOrientation,\n      updateRecordingMultiFormatsSupport,\n      updateUserRecordingParams,\n      updateConfirmedToRecord,\n    } = parameters;\n\n    // Retrieve the values from the state\n\n    const mediaOptions = recordingMediaOptions;\n\n    // Other variables not provided in the guide\n    const selectedRecordOption = recordingDisplayType;\n\n    // Additional logic similar to the provided guide\n    // recordingVideoParticipantsFullRoomSupport = minigrid and main video\n    if (eventType !== 'broadcast') {\n      if (\n        !recordingVideoParticipantsFullRoomSupport &&\n        recordingVideoOptions === 'all' &&\n        mediaOptions === 'video'\n      ) {\n        if (meetingDisplayType == 'all') {\n          if (breakOutRoomStarted && !breakOutRoomEnded) {\n            // breakout rooms are started\n          } else {\n            showAlert?.({\n              message:\n                'You are not allowed to record videos of all participants; change the meeting display type to video or video optimized.',\n              type: 'danger',\n              duration: 3000,\n            });\n\n            return;\n          }\n        }\n      }\n\n      // recordingAllParticipantsSupport  = others other than host screen (video + audio)\n      if (!recordingAllParticipantsSupport && recordingVideoOptions === 'all') {\n        showAlert?.({\n          message: 'You are only allowed to record yourself.',\n          type: 'danger',\n          duration: 3000,\n        });\n\n        return;\n      }\n\n      // recordingVideoParticipantsSupport (maingrid + non-host screenshare person)\n      if (!recordingVideoParticipantsSupport && recordingDisplayType === 'video') {\n        showAlert?.({\n          message: 'You are not allowed to record other video participants.',\n          type: 'danger',\n          duration: 3000,\n        });\n\n        return;\n      }\n    }\n\n    if (!recordingSupportForOtherOrientation && recordingOrientationVideo === 'all') {\n      showAlert?.({\n        message: 'You are not allowed to record all orientations.',\n        type: 'danger',\n        duration: 3000,\n      });\n\n      return;\n    }\n\n    if (\n      recordingPreferredOrientation === 'landscape' &&\n      recordingOrientationVideo === 'portrait' &&\n      !recordingSupportForOtherOrientation\n    ) {\n      showAlert?.({\n        message: 'You are not allowed to record portrait orientation.',\n        type: 'danger',\n        duration: 3000,\n      });\n\n      return;\n    } else if (\n      recordingPreferredOrientation === 'portrait' &&\n      recordingOrientationVideo === 'landscape' &&\n      !recordingSupportForOtherOrientation\n    ) {\n      showAlert?.({\n        message: 'You are not allowed to record landscape orientation.',\n        type: 'danger',\n        duration: 3000,\n      });\n\n      return;\n    }\n\n    if (!recordingMultiFormatsSupport && recordingVideoType === 'all') {\n      showAlert?.({\n        message: 'You are not allowed to record all formats.',\n        type: 'danger',\n        duration: 3000,\n      });\n\n      return;\n    }\n\n    if (eventType !== 'broadcast') {\n      if (recordingMediaOptions === 'video') {\n        if (meetingDisplayType === 'media') {\n          if (recordingDisplayType === 'all') {\n            showAlert?.({\n              message:\n                'Recording display type can be either video, video optimized, or media when meeting display type is media.',\n              type: 'danger',\n              duration: 3000,\n            });\n\n            recordingDisplayType = meetingDisplayType;\n            return;\n          }\n        } else if (meetingDisplayType === 'video') {\n          if (recordingDisplayType === 'all' || recordingDisplayType === 'media') {\n            showAlert?.({\n              message:\n                'Recording display type can be either video or video optimized when meeting display type is video.',\n              type: 'danger',\n              duration: 3000,\n            });\n\n            recordingDisplayType = meetingDisplayType;\n            return;\n          }\n\n          if (meetingVideoOptimized && !recordingVideoOptimized) {\n            showAlert?.({\n              message:\n                'Recording display type can be only video optimized when meeting display type is video optimized.',\n              type: 'danger',\n              duration: 3000,\n            });\n\n            recordingVideoOptimized = meetingVideoOptimized;\n            return;\n          }\n        }\n      } else {\n        if (recordingDisplayType === 'all' || recordingDisplayType === 'media') {\n          // do nothing\n        } else {\n          recordingDisplayType = 'media';\n        }\n        recordingVideoOptimized = false;\n      }\n    }\n\n    if (recordingDisplayType === 'all' && !recordingAllParticipantsFullRoomSupport) {\n      showAlert?.({\n        message: 'You can only record all participants with media.',\n        type: 'danger',\n        duration: 3000,\n      });\n\n      return;\n    }\n    // Construct mainSpecs and dispSpecs objects based on the state variables\n    const mainSpecs: MainSpecs = {\n      mediaOptions: recordingMediaOptions,\n      audioOptions: recordingAudioOptions,\n      videoOptions: recordingVideoOptions,\n      videoType: recordingVideoType,\n      videoOptimized: recordingVideoOptimized,\n      recordingDisplayType: recordingDisplayType,\n      addHLS: recordingAddHLS,\n    };\n\n    const dispSpecs: DispSpecs = {\n      nameTags: recordingNameTags,\n      backgroundColor: recordingBackgroundColor,\n      nameTagsColor: recordingNameTagsColor,\n      orientationVideo: recordingOrientationVideo,\n    };\n\n    const textSpecs: TextSpecs = {\n      addText: recordingAddText,\n      customText: recordingCustomText,\n      customTextPosition: recordingCustomTextPosition,\n      customTextColor: recordingCustomTextColor,\n    };\n\n    // Construct userRecordingParams object\n    const userRecordingParams = { mainSpecs, dispSpecs, textSpecs };\n    // Update state variables based on the logic\n    updateUserRecordingParams(userRecordingParams);\n    updateConfirmedToRecord(true);\n    updateRecordingDisplayType(selectedRecordOption);\n    updateRecordingVideoOptimized(recordingVideoOptimized);\n    updateRecordingVideoParticipantsFullRoomSupport(recordingVideoParticipantsFullRoomSupport);\n    updateRecordingAllParticipantsSupport(recordingAllParticipantsSupport);\n    updateRecordingVideoParticipantsSupport(recordingVideoParticipantsSupport);\n    updateRecordingSupportForOtherOrientation(recordingSupportForOtherOrientation);\n    updateRecordingPreferredOrientation(recordingPreferredOrientation);\n    updateRecordingMultiFormatsSupport(recordingMultiFormatsSupport);\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"confirm-recording.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/methods/recording-methods/confirm-recording.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  ShowAlert,\n  MainSpecs,\n  DispSpecs,\n  TextSpecs,\n  EventType,\n  UserRecordingParams,\n} from '../../@types/types';\n\nexport interface ConfirmRecordingParameters {\n  showAlert?: ShowAlert;\n  recordingMediaOptions: string;\n  recordingAudioOptions: string;\n  recordingVideoOptions: string;\n  recordingVideoType: string;\n  recordingDisplayType: 'video' | 'media' | 'all';\n  recordingNameTags: boolean;\n  recordingBackgroundColor: string;\n  recordingNameTagsColor: string;\n  recordingOrientationVideo: string;\n  recordingAddHLS: boolean;\n  recordingAddText: boolean;\n  recordingCustomText: string;\n  recordingCustomTextPosition: string;\n  recordingCustomTextColor: string;\n  meetingDisplayType: string;\n  recordingVideoParticipantsFullRoomSupport: boolean;\n  recordingAllParticipantsSupport: boolean;\n  recordingVideoParticipantsSupport: boolean;\n  recordingSupportForOtherOrientation: boolean;\n  recordingPreferredOrientation: string;\n  recordingMultiFormatsSupport: boolean;\n  recordingVideoOptimized: boolean;\n  recordingAllParticipantsFullRoomSupport: boolean;\n  meetingVideoOptimized: boolean;\n  eventType: EventType;\n  breakOutRoomStarted: boolean;\n  breakOutRoomEnded: boolean;\n  updateRecordingDisplayType: (value: 'video' | 'media' | 'all') => void;\n  updateRecordingVideoOptimized: (value: boolean) => void;\n  updateUserRecordingParams: (params: UserRecordingParams) => void;\n  updateConfirmedToRecord: (value: boolean) => void;\n\n  // Mediasfu functions\n  getUpdatedAllParams: () => ConfirmRecordingParameters;\n  [key: string]: any;\n}\n\nexport interface ConfirmRecordingOptions {\n  parameters: ConfirmRecordingParameters;\n}\n\n// Export the type definition for the function\nexport type ConfirmRecordingType = (options: ConfirmRecordingOptions) => Promise<void>;\n\n/**\n * Confirms the recording settings based on the provided parameters and updates the recording state.\n *\n * @param {ConfirmRecordingOptions} options - The options for confirming the recording.\n * @param {ConfirmRecordingParameters} options.parameters - The parameters for the recording, including:\n *   - {ShowAlert} [options.parameters.showAlert] - Optional function to show alert messages.\n *   - {string} options.parameters.recordingMediaOptions - Type of media being recorded (\"video\" or \"audio\").\n *   - {string} options.parameters.recordingAudioOptions - Audio recording options.\n *   - {string} options.parameters.recordingVideoOptions - Video recording options.\n *   - {string} options.parameters.recordingVideoType - Type of video recording.\n *   - {'video' | 'media' | 'all'} options.parameters.recordingDisplayType - The display type for the recording.\n *   - {boolean} options.parameters.recordingNameTags - Flag for including name tags in the recording.\n *   - {string} options.parameters.recordingBackgroundColor - Background color for the recording.\n *   - {string} options.parameters.recordingNameTagsColor - Color for the name tags.\n *   - {string} options.parameters.recordingOrientationVideo - Orientation for video recording.\n *   - {boolean} options.parameters.recordingAddHLS - Flag for adding HLS support.\n *   - {boolean} options.parameters.recordingAddText - Flag for adding custom text.\n *   - {string} options.parameters.recordingCustomText - Custom text for the recording.\n *   - {string} options.parameters.recordingCustomTextPosition - Position of the custom text.\n *   - {string} options.parameters.recordingCustomTextColor - Color of the custom text.\n *   - {string} options.parameters.meetingDisplayType - Current display type of the meeting.\n *   - {boolean} options.parameters.recordingVideoParticipantsFullRoomSupport - Support for video participants in full room.\n *   - {boolean} options.parameters.recordingAllParticipantsSupport - Support for recording all participants.\n *   - {boolean} options.parameters.recordingVideoParticipantsSupport - Support for video participants.\n *   - {boolean} options.parameters.recordingSupportForOtherOrientation - Support for other orientations.\n *   - {string} options.parameters.recordingPreferredOrientation - Preferred orientation for recording.\n *   - {boolean} options.parameters.recordingMultiFormatsSupport - Support for multiple formats.\n *   - {boolean} options.parameters.recordingVideoOptimized - Flag for video optimization.\n *   - {boolean} options.parameters.recordingAllParticipantsFullRoomSupport - Support for recording all participants in full room.\n *   - {boolean} options.parameters.meetingVideoOptimized - Flag for meeting video optimization.\n *   - {EventType} options.parameters.eventType - Type of the event.\n *   - {boolean} options.parameters.breakOutRoomStarted - Indicates if a breakout room has started.\n *   - {boolean} options.parameters.breakOutRoomEnded - Indicates if a breakout room has ended.\n *   - {Function} options.parameters.updateRecordingDisplayType - Function to update the recording display type.\n *   - {Function} options.parameters.updateRecordingVideoOptimized - Function to update video optimization status.\n *   - {Function} options.parameters.updateUserRecordingParams - Function to update user recording parameters.\n *   - {Function} options.parameters.updateConfirmedToRecord - Function to confirm the recording.\n *\n * @returns {Promise<void>} A promise that resolves when the recording settings have been confirmed.\n *\n * @remarks\n * This function performs several checks to ensure that the recording settings are valid based on the provided parameters.\n * If any of the checks fail, an alert is shown and the function returns early without updating the recording state.\n *\n * The function checks for the following conditions:\n * - Whether recording videos of all participants is allowed.\n * - Whether recording all participants is allowed.\n * - Whether recording other video participants is allowed.\n * - Whether recording all orientations is allowed.\n * - Whether recording the preferred orientation is allowed.\n * - Whether recording all formats is allowed.\n * - Whether the recording display type is valid based on the meeting display type.\n * - Whether recording all participants with media is allowed.\n *\n * If all checks pass, the function constructs the `mainSpecs`, `dispSpecs`, and `textSpecs` objects based on the state variables,\n * updates the user recording parameters, and confirms the recording.\n *\n * @example\n * ```typescript\n * const options: ConfirmRecordingOptions = { parameters: someParameters };\n * await confirmRecording(options);\n * ```\n */\n\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ConfirmRecording {\n  /**\n   * Confirms the recording settings based on the provided parameters and updates the recording state.\n   *\n   * @param {ConfirmRecordingOptions} options - The options for confirming the recording.\n   * @param {Parameters} options.parameters - The parameters for the recording.\n   *\n   * @returns {Promise<void>} A promise that resolves when the recording settings have been confirmed.\n   *\n   * @remarks\n   * This function performs several checks to ensure that the recording settings are valid based on the provided parameters.\n   * If any of the checks fail, an alert is shown and the function returns early without updating the recording state.\n   *\n   * The function checks for the following conditions:\n   * - Whether recording videos of all participants is allowed.\n   * - Whether recording all participants is allowed.\n   * - Whether recording other video participants is allowed.\n   * - Whether recording all orientations is allowed.\n   * - Whether recording the preferred orientation is allowed.\n   * - Whether recording all formats is allowed.\n   * - Whether the recording display type is valid based on the meeting display type.\n   * - Whether recording all participants with media is allowed.\n   *\n   * If all checks pass, the function constructs the `mainSpecs`, `dispSpecs`, and `textSpecs` objects based on the state variables,\n   * updates the user recording parameters, and confirms the recording.\n   *\n   * @example\n   * ```typescript\n   * const options: ConfirmRecordingOptions = { parameters: someParameters };\n   * await confirmRecording(options);\n   * ```\n   */\n\n  confirmRecording = async ({ parameters }: ConfirmRecordingOptions): Promise<void> => {\n    let { getUpdatedAllParams } = parameters;\n    parameters = getUpdatedAllParams();\n\n    let {\n      showAlert,\n      recordingMediaOptions,\n      recordingAudioOptions,\n      recordingVideoOptions,\n      recordingVideoType,\n      recordingDisplayType,\n      recordingNameTags,\n      recordingBackgroundColor,\n      recordingNameTagsColor,\n      recordingOrientationVideo,\n      recordingAddHLS,\n      recordingAddText,\n      recordingCustomText,\n      recordingCustomTextPosition,\n      recordingCustomTextColor,\n      meetingDisplayType,\n      recordingVideoParticipantsFullRoomSupport,\n      recordingAllParticipantsSupport,\n      recordingVideoParticipantsSupport,\n      recordingSupportForOtherOrientation,\n      recordingPreferredOrientation,\n      recordingMultiFormatsSupport,\n      recordingVideoOptimized,\n      recordingAllParticipantsFullRoomSupport,\n      meetingVideoOptimized,\n      eventType,\n      breakOutRoomStarted,\n      breakOutRoomEnded,\n\n      updateRecordingDisplayType,\n      updateRecordingVideoOptimized,\n      updateRecordingVideoParticipantsFullRoomSupport,\n      updateRecordingAllParticipantsSupport,\n      updateRecordingVideoParticipantsSupport,\n      updateRecordingSupportForOtherOrientation,\n      updateRecordingPreferredOrientation,\n      updateRecordingMultiFormatsSupport,\n      updateUserRecordingParams,\n      updateConfirmedToRecord,\n    } = parameters;\n\n    // Retrieve the values from the state\n\n    const mediaOptions = recordingMediaOptions;\n\n    // Other variables not provided in the guide\n    const selectedRecordOption = recordingDisplayType;\n\n    // Additional logic similar to the provided guide\n    // recordingVideoParticipantsFullRoomSupport = minigrid and main video\n    if (eventType !== 'broadcast') {\n      if (\n        !recordingVideoParticipantsFullRoomSupport &&\n        recordingVideoOptions === 'all' &&\n        mediaOptions === 'video'\n      ) {\n        if (meetingDisplayType == 'all') {\n          if (breakOutRoomStarted && !breakOutRoomEnded) {\n            // breakout rooms are started\n          } else {\n            showAlert?.({\n              message:\n                'You are not allowed to record videos of all participants; change the meeting display type to video or video optimized.',\n              type: 'danger',\n              duration: 3000,\n            });\n\n            return;\n          }\n        }\n      }\n\n      // recordingAllParticipantsSupport  = others other than host screen (video + audio)\n      if (!recordingAllParticipantsSupport && recordingVideoOptions === 'all') {\n        showAlert?.({\n          message: 'You are only allowed to record yourself.',\n          type: 'danger',\n          duration: 3000,\n        });\n\n        return;\n      }\n\n      // recordingVideoParticipantsSupport (maingrid + non-host screenshare person)\n      if (!recordingVideoParticipantsSupport && recordingDisplayType === 'video') {\n        showAlert?.({\n          message: 'You are not allowed to record other video participants.',\n          type: 'danger',\n          duration: 3000,\n        });\n\n        return;\n      }\n    }\n\n    if (!recordingSupportForOtherOrientation && recordingOrientationVideo === 'all') {\n      showAlert?.({\n        message: 'You are not allowed to record all orientations.',\n        type: 'danger',\n        duration: 3000,\n      });\n\n      return;\n    }\n\n    if (\n      recordingPreferredOrientation === 'landscape' &&\n      recordingOrientationVideo === 'portrait' &&\n      !recordingSupportForOtherOrientation\n    ) {\n      showAlert?.({\n        message: 'You are not allowed to record portrait orientation.',\n        type: 'danger',\n        duration: 3000,\n      });\n\n      return;\n    } else if (\n      recordingPreferredOrientation === 'portrait' &&\n      recordingOrientationVideo === 'landscape' &&\n      !recordingSupportForOtherOrientation\n    ) {\n      showAlert?.({\n        message: 'You are not allowed to record landscape orientation.',\n        type: 'danger',\n        duration: 3000,\n      });\n\n      return;\n    }\n\n    if (!recordingMultiFormatsSupport && recordingVideoType === 'all') {\n      showAlert?.({\n        message: 'You are not allowed to record all formats.',\n        type: 'danger',\n        duration: 3000,\n      });\n\n      return;\n    }\n\n    if (eventType !== 'broadcast') {\n      if (recordingMediaOptions === 'video') {\n        if (meetingDisplayType === 'media') {\n          if (recordingDisplayType === 'all') {\n            showAlert?.({\n              message:\n                'Recording display type can be either video, video optimized, or media when meeting display type is media.',\n              type: 'danger',\n              duration: 3000,\n            });\n\n            recordingDisplayType = meetingDisplayType;\n            return;\n          }\n        } else if (meetingDisplayType === 'video') {\n          if (recordingDisplayType === 'all' || recordingDisplayType === 'media') {\n            showAlert?.({\n              message:\n                'Recording display type can be either video or video optimized when meeting display type is video.',\n              type: 'danger',\n              duration: 3000,\n            });\n\n            recordingDisplayType = meetingDisplayType;\n            return;\n          }\n\n          if (meetingVideoOptimized && !recordingVideoOptimized) {\n            showAlert?.({\n              message:\n                'Recording display type can be only video optimized when meeting display type is video optimized.',\n              type: 'danger',\n              duration: 3000,\n            });\n\n            recordingVideoOptimized = meetingVideoOptimized;\n            return;\n          }\n        }\n      } else {\n        if (recordingDisplayType === 'all' || recordingDisplayType === 'media') {\n          // do nothing\n        } else {\n          recordingDisplayType = 'media';\n        }\n        recordingVideoOptimized = false;\n      }\n    }\n\n    if (recordingDisplayType === 'all' && !recordingAllParticipantsFullRoomSupport) {\n      showAlert?.({\n        message: 'You can only record all participants with media.',\n        type: 'danger',\n        duration: 3000,\n      });\n\n      return;\n    }\n    // Construct mainSpecs and dispSpecs objects based on the state variables\n    const mainSpecs: MainSpecs = {\n      mediaOptions: recordingMediaOptions,\n      audioOptions: recordingAudioOptions,\n      videoOptions: recordingVideoOptions,\n      videoType: recordingVideoType,\n      videoOptimized: recordingVideoOptimized,\n      recordingDisplayType: recordingDisplayType,\n      addHLS: recordingAddHLS,\n    };\n\n    const dispSpecs: DispSpecs = {\n      nameTags: recordingNameTags,\n      backgroundColor: recordingBackgroundColor,\n      nameTagsColor: recordingNameTagsColor,\n      orientationVideo: recordingOrientationVideo,\n    };\n\n    const textSpecs: TextSpecs = {\n      addText: recordingAddText,\n      customText: recordingCustomText,\n      customTextPosition: recordingCustomTextPosition,\n      customTextColor: recordingCustomTextColor,\n    };\n\n    // Construct userRecordingParams object\n    const userRecordingParams = { mainSpecs, dispSpecs, textSpecs };\n    // Update state variables based on the logic\n    updateUserRecordingParams(userRecordingParams);\n    updateConfirmedToRecord(true);\n    updateRecordingDisplayType(selectedRecordOption);\n    updateRecordingVideoOptimized(recordingVideoOptimized);\n    updateRecordingVideoParticipantsFullRoomSupport(recordingVideoParticipantsFullRoomSupport);\n    updateRecordingAllParticipantsSupport(recordingAllParticipantsSupport);\n    updateRecordingVideoParticipantsSupport(recordingVideoParticipantsSupport);\n    updateRecordingSupportForOtherOrientation(recordingSupportForOtherOrientation);\n    updateRecordingPreferredOrientation(recordingPreferredOrientation);\n    updateRecordingMultiFormatsSupport(recordingMultiFormatsSupport);\n  };\n}\n"]}

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

@@ -1,5 +1,48 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Launches the recording process based on various conditions and updates the UI accordingly.
+ *
+ * @param {LaunchRecordingOptions} options - The options for launching the recording.
+ * @param {Function} options.updateIsRecordingModalVisible - Function to update the visibility of the recording modal.
+ * @param {boolean} options.isRecordingModalVisible - Indicates if the recording modal is currently visible.
+ * @param {Function} [options.showAlert] - Optional function to show an alert message.
+ * @param {boolean} options.stopLaunchRecord - Indicates if the recording launch should be stopped.
+ * @param {boolean} options.canLaunchRecord - Indicates if the recording can be launched.
+ * @param {boolean} options.recordingAudioSupport - Indicates if audio recording is supported.
+ * @param {boolean} options.recordingVideoSupport - Indicates if video recording is supported.
+ * @param {Function} options.updateCanRecord - Function to update the recording capability.
+ * @param {Function} options.updateClearedToRecord - Function to update the cleared-to-record status.
+ * @param {boolean} options.recordStarted - Indicates if the recording has started.
+ * @param {boolean} options.recordPaused - Indicates if the recording is paused.
+ * @param {boolean} options.localUIMode - Indicates if the local UI mode is active.
+ *
+ * @returns {void}
+ *
+ * @throws Will show an alert if:
+ * - The recording has already ended or the user is not allowed to record.
+ * - The recording initiation is not allowed due to insufficient permissions.
+ * - The recording is currently running and cannot be reconfigured unless paused.
+ *
+ * @example
+ * ```typescript
+ * const options: LaunchRecordingOptions = {
+ *   updateIsRecordingModalVisible: (visible) => { /* update visibility logic *\/ },
+ *   isRecordingModalVisible: false,
+ *   showAlert: (alert) => { /* show alert logic *\/ },
+ *   stopLaunchRecord: false,
+ *   canLaunchRecord: true,
+ *   recordingAudioSupport: true,
+ *   recordingVideoSupport: true,
+ *   updateCanRecord: (canRecord) => { /* update record capability *\/ },
+ *   updateClearedToRecord: (cleared) => { /* update cleared status *\/ },
+ *   recordStarted: false,
+ *   recordPaused: false,
+ *   localUIMode: false,
+ * };
+ * launchRecording(options);
+ * ```
+ */
 export class LaunchRecording {
     /**
      * Launches the recording process based on various conditions and updates the UI accordingly.
@@ -79,4 +122,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":"launch-recording.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/methods/recording-methods/launch-recording.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAuB3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAMH,MAAM,OAAO,eAAe;IAC1B;;;;;;;;;;;;;;;;;;OAkBG;IAEH,eAAe,CAAC,EACd,6BAA6B,EAC7B,uBAAuB,EACvB,SAAS,EACT,gBAAgB,EAChB,eAAe,EACf,qBAAqB,EACrB,qBAAqB,EACrB,eAAe,EACf,qBAAqB,EACrB,aAAa,EACb,YAAY,EACZ,WAAW,GACY;QACvB,yCAAyC;QACzC,IAAI,CAAC,uBAAuB,IAAI,gBAAgB,IAAI,CAAC,WAAW,EAAE,CAAC;YACjE,SAAS,EAAE,CAAC;gBACV,OAAO,EAAE,8DAA8D;gBACvE,IAAI,EAAE,QAAQ;gBACd,QAAQ,EAAE,IAAI;aACf,CAAC,CAAC;YAEH,OAAO;QACT,CAAC;QAED,2CAA2C;QAC3C,IAAI,CAAC,uBAAuB,IAAI,eAAe,IAAI,CAAC,WAAW,EAAE,CAAC;YAChE,0DAA0D;YAC1D,IAAI,CAAC,qBAAqB,IAAI,CAAC,qBAAqB,EAAE,CAAC;gBACrD,SAAS,EAAE,CAAC;oBACV,OAAO,EAAE,+BAA+B;oBACxC,IAAI,EAAE,QAAQ;oBACd,QAAQ,EAAE,IAAI;iBACf,CAAC,CAAC;gBAEH,OAAO;YACT,CAAC;YAED,kCAAkC;YAClC,qBAAqB,CAAC,KAAK,CAAC,CAAC;YAC7B,4BAA4B;YAC5B,eAAe,CAAC,KAAK,CAAC,CAAC;QACzB,CAAC;QAED,IAAI,CAAC,uBAAuB,IAAI,aAAa,EAAE,CAAC;YAC9C,IAAI,CAAC,YAAY,EAAE,CAAC;gBAClB,SAAS,EAAE,CAAC;oBACV,OAAO,EAAE,sDAAsD;oBAC/D,IAAI,EAAE,QAAQ;oBACd,QAAQ,EAAE,IAAI;iBACf,CAAC,CAAC;gBAEH,OAAO;YACT,CAAC;QACH,CAAC;QAED,IACE,CAAC,uBAAuB;YACxB,CAAC,qBAAqB;YACtB,CAAC,qBAAqB;YACtB,CAAC,WAAW,EACZ,CAAC;YACD,SAAS,EAAE,CAAC;gBACV,OAAO,EAAE,+BAA+B;gBACxC,IAAI,EAAE,QAAQ;gBACd,QAAQ,EAAE,IAAI;aACf,CAAC,CAAC;YAEH,OAAO;QACT,CAAC;QAED,+CAA+C;QAC/C,6BAA6B,CAAC,CAAC,uBAAuB,CAAC,CAAC;IAC1D,CAAC;uGA9FU,eAAe;2GAAf,eAAe,cAFd,MAAM;;2FAEP,eAAe;kBAH3B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { ShowAlert } from '../../@types/types';\n\nexport interface LaunchRecordingOptions {\n  updateIsRecordingModalVisible: (visible: boolean) => void;\n  isRecordingModalVisible: boolean;\n  showAlert?: ShowAlert;\n  stopLaunchRecord: boolean;\n  canLaunchRecord: boolean;\n  recordingAudioSupport: boolean;\n  recordingVideoSupport: boolean;\n  updateCanRecord: (canRecord: boolean) => void;\n  updateClearedToRecord: (cleared: boolean) => void;\n  recordStarted: boolean;\n  recordPaused: boolean;\n  localUIMode: boolean;\n\n  [key: string]: any;\n}\n\n// Export the type definition for the function\nexport type LaunchRecordingType = (options: LaunchRecordingOptions) => void;\n\n/**\n * Launches the recording process based on various conditions and updates the UI accordingly.\n *\n * @param {LaunchRecordingOptions} options - The options for launching the recording.\n * @param {Function} options.updateIsRecordingModalVisible - Function to update the visibility of the recording modal.\n * @param {boolean} options.isRecordingModalVisible - Indicates if the recording modal is currently visible.\n * @param {Function} [options.showAlert] - Optional function to show an alert message.\n * @param {boolean} options.stopLaunchRecord - Indicates if the recording launch should be stopped.\n * @param {boolean} options.canLaunchRecord - Indicates if the recording can be launched.\n * @param {boolean} options.recordingAudioSupport - Indicates if audio recording is supported.\n * @param {boolean} options.recordingVideoSupport - Indicates if video recording is supported.\n * @param {Function} options.updateCanRecord - Function to update the recording capability.\n * @param {Function} options.updateClearedToRecord - Function to update the cleared-to-record status.\n * @param {boolean} options.recordStarted - Indicates if the recording has started.\n * @param {boolean} options.recordPaused - Indicates if the recording is paused.\n * @param {boolean} options.localUIMode - Indicates if the local UI mode is active.\n *\n * @returns {void}\n *\n * @throws Will show an alert if:\n * - The recording has already ended or the user is not allowed to record.\n * - The recording initiation is not allowed due to insufficient permissions.\n * - The recording is currently running and cannot be reconfigured unless paused.\n *\n * @example\n * ```typescript\n * const options: LaunchRecordingOptions = {\n *   updateIsRecordingModalVisible: (visible) => { /* update visibility logic *\\/ },\n *   isRecordingModalVisible: false,\n *   showAlert: (alert) => { /* show alert logic *\\/ },\n *   stopLaunchRecord: false,\n *   canLaunchRecord: true,\n *   recordingAudioSupport: true,\n *   recordingVideoSupport: true,\n *   updateCanRecord: (canRecord) => { /* update record capability *\\/ },\n *   updateClearedToRecord: (cleared) => { /* update cleared status *\\/ },\n *   recordStarted: false,\n *   recordPaused: false,\n *   localUIMode: false,\n * };\n * launchRecording(options);\n * ```\n */\n\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class LaunchRecording {\n  /**\n   * Launches the recording process based on various conditions and updates the UI accordingly.\n   *\n   * @param {Object} options - The options for launching the recording.\n   * @param {Function} options.updateIsRecordingModalVisible - Function to update the visibility of the recording modal.\n   * @param {boolean} options.isRecordingModalVisible - Indicates if the recording modal is currently visible.\n   * @param {Function} options.showAlert - Function to show an alert message.\n   * @param {boolean} options.stopLaunchRecord - Indicates if the recording launch should be stopped.\n   * @param {boolean} options.canLaunchRecord - Indicates if the recording can be launched.\n   * @param {boolean} options.recordingAudioSupport - Indicates if audio recording is supported.\n   * @param {boolean} options.recordingVideoSupport - Indicates if video recording is supported.\n   * @param {Function} options.updateCanRecord - Function to update the recording capability.\n   * @param {Function} options.updateClearedToRecord - Function to update the cleared-to-record status.\n   * @param {boolean} options.recordStarted - Indicates if the recording has started.\n   * @param {boolean} options.recordPaused - Indicates if the recording is paused.\n   * @param {boolean} options.localUIMode - Indicates if the local UI mode is active.\n   *\n   * @returns {void}\n   */\n\n  launchRecording({\n    updateIsRecordingModalVisible,\n    isRecordingModalVisible,\n    showAlert,\n    stopLaunchRecord,\n    canLaunchRecord,\n    recordingAudioSupport,\n    recordingVideoSupport,\n    updateCanRecord,\n    updateClearedToRecord,\n    recordStarted,\n    recordPaused,\n    localUIMode,\n  }: LaunchRecordingOptions): void {\n    // Check if recording is already launched\n    if (!isRecordingModalVisible && stopLaunchRecord && !localUIMode) {\n      showAlert?.({\n        message: 'Recording has already ended or you are not allowed to record',\n        type: 'danger',\n        duration: 3000,\n      });\n\n      return;\n    }\n\n    // Check if recording initiation is allowed\n    if (!isRecordingModalVisible && canLaunchRecord && !localUIMode) {\n      // Check if both audio and video recording are not allowed\n      if (!recordingAudioSupport && !recordingVideoSupport) {\n        showAlert?.({\n          message: 'You are not allowed to record',\n          type: 'danger',\n          duration: 3000,\n        });\n\n        return;\n      }\n\n      // update clearedToRecord to false\n      updateClearedToRecord(false);\n      // update canRecord to false\n      updateCanRecord(false);\n    }\n\n    if (!isRecordingModalVisible && recordStarted) {\n      if (!recordPaused) {\n        showAlert?.({\n          message: 'You can only re-configure recording after pausing it',\n          type: 'danger',\n          duration: 3000,\n        });\n\n        return;\n      }\n    }\n\n    if (\n      !isRecordingModalVisible &&\n      !recordingAudioSupport &&\n      !recordingVideoSupport &&\n      !localUIMode\n    ) {\n      showAlert?.({\n        message: 'You are not allowed to record',\n        type: 'danger',\n        duration: 3000,\n      });\n\n      return;\n    }\n\n    // Update the visibility of the recording modal\n    updateIsRecordingModalVisible(!isRecordingModalVisible);\n  }\n}\n"]}

package/dist/esm2022/lib/methods/recording-methods/record-pause-timer.service.mjs

@@ -1,5 +1,32 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Controls the pause and resume functionality of a recording timer.
+ *
+ * @param {RecordPauseTimerOptions} options - The options for controlling the timer.
+ * @param {boolean} [options.stop=false] - Indicates whether to stop the timer.
+ * @param {boolean} options.isTimerRunning - Indicates if the timer is currently running.
+ * @param {boolean} options.canPauseResume - Indicates if the timer can be paused or resumed.
+ * @param {Function} [options.showAlert] - Optional function to show an alert message.
+ * @returns {boolean} - Returns true if the timer can be paused or resumed, otherwise false.
+ *
+ * @throws Will show an alert message if:
+ * - The timer cannot be stopped, paused, or resumed due to not meeting the required time condition.
+ *
+ * @example
+ * ```typescript
+ * const options: RecordPauseTimerOptions = {
+ *   stop: false,
+ *   isTimerRunning: true,
+ *   canPauseResume: true,
+ *   showAlert: (alert) => {  },
+ * };
+ * const canPause = recordPauseTimer(options);
+ * if (canPause) {
+ *   // proceed with pausing or resuming the recording
+ * }
+ * ```
+ */
 export class RecordPauseTimer {
     /**
      * Controls the pause and resume functionality of a recording timer.
@@ -37,4 +64,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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