mediasfu-angular 1.0.0 → 1.0.2

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

@@ -1,6 +1,50 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
 import * as i1 from "./record-update-timer.service";
+/**
+ * Resumes the recording timer if it is not already running and can be paused/resumed.
+ *
+ * @param {RecordResumeTimerOptions} options - The options for resuming the recording timer.
+ * @param {Object} options.parameters - The parameters for the recording timer.
+ * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+ * @param {boolean} options.parameters.isTimerRunning - Indicates if the timer is currently running.
+ * @param {boolean} options.parameters.canPauseResume - Indicates if the timer can be paused/resumed.
+ * @param {number} options.parameters.recordElapsedTime - The elapsed recording time in seconds.
+ * @param {number} options.parameters.recordStartTime - The start time of the recording.
+ * @param {NodeJS.Timeout | null} options.parameters.recordTimerInterval - The interval ID for the recording timer.
+ * @param {Function} options.parameters.showAlert - Function to show an alert message.
+ * @param {Function} options.parameters.updateRecordStartTime - Function to update the recording start time.
+ * @param {Function} options.parameters.updateRecordTimerInterval - Function to update the recording timer interval.
+ * @param {Function} options.parameters.updateIsTimerRunning - Function to update the timer running status.
+ * @param {Function} options.parameters.updateCanPauseResume - Function to update the pause/resume status.
+ *
+ * @returns {Promise<boolean>} - Returns a promise that resolves to true if the timer was successfully resumed, otherwise false.
+ *
+ * @throws Will show an alert if the timer cannot be resumed due to conditions not being met.
+ *
+ * @example
+ * ```typescript
+ * const options: RecordResumeTimerOptions = {
+ *   parameters: {
+ *     isTimerRunning: false,
+ *     canPauseResume: true,
+ *     recordElapsedTime: 10,
+ *     recordStartTime: Date.now(),
+ *     recordTimerInterval: null,
+ *     showAlert: (alert) => { },
+ *     updateRecordStartTime: (time) => { },
+ *     updateRecordTimerInterval: (interval) => { },
+ *     updateIsTimerRunning: (isRunning) => { },
+ *     updateCanPauseResume: (canPause) => {  },
+ *     getUpdatedAllParams: () => ({  }),
+ *   },
+ * };
+ * const canResume = await recordResumeTimer(options);
+ * if (canResume) {
+ *   // proceed with the resumed recording
+ * }
+ * ```
+ */
 export class RecordResumeTimer {
     RecordUpdateTimerService;
     constructor(RecordUpdateTimerService) {
@@ -83,4 +127,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }], ctorParameters: () => [{ type: i1.RecordUpdateTimer }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"record-resume-timer.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/methods/recording-methods/record-resume-timer.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;;AA6B3C,MAAM,OAAO,iBAAiB;IACR;IAApB,YAAoB,wBAA2C;QAA3C,6BAAwB,GAAxB,wBAAwB,CAAmB;IAAG,CAAC;IAEnE;;;;;;;;;;;;;;;;;;OAkBG;IAEH,iBAAiB,GAAG,KAAK,EAAE,EAAE,UAAU,EAA4B,EAAoB,EAAE;QACvF,IAAI,EAAE,mBAAmB,EAAE,GAAG,UAAU,CAAC;QACzC,UAAU,GAAG,mBAAmB,EAAE,CAAC;QAEnC,IAAI,EACF,cAAc,EACd,cAAc,EACd,iBAAiB,EACjB,eAAe,EACf,mBAAmB,EACnB,SAAS,EACT,qBAAqB,EACrB,yBAAyB,EACzB,oBAAoB,EACpB,oBAAoB;QAEpB,oBAAoB;QACpB,qBAAqB;UACtB,GAAG,UAAU,CAAC;QAEf,IAAI,CAAC,cAAc,IAAI,cAAc,EAAE,CAAC;YACtC,eAAe,GAAG,IAAI,IAAI,EAAE,CAAC,OAAO,EAAE,GAAG,iBAAiB,GAAG,IAAI,CAAC,CAAC,oDAAoD;YACvH,qBAAqB,CAAC,eAAe,CAAC,CAAC;YACvC,mBAAmB,GAAG,WAAW,CAAC,GAAG,EAAE;gBACrC,oDAAoD;gBACpD,IAAI,CAAC,wBAAwB,CAAC,iBAAiB,CAAC;oBAC9C,iBAAiB,EAAE,iBAAiB;oBACpC,eAAe,EAAE,eAAe;oBAChC,uBAAuB,EAAE,UAAU,CAAC,yBAAyB,CAAC;oBAC9D,2BAA2B,EAAE,UAAU,CAAC,6BAA6B,CAAC;iBACvE,CAAC,CAAC;gBAEH,UAAU,GAAG,mBAAmB,EAAE,CAAC;gBAEnC,4EAA4E;gBAC5E,IACE,UAAU,CAAC,cAAc,CAAC;oBAC1B,UAAU,CAAC,eAAe,CAAC;oBAC3B,UAAU,CAAC,UAAU,CAAC,IAAI,EAAE;oBAC5B,UAAU,CAAC,UAAU,CAAC,IAAI,IAAI,EAC9B,CAAC;oBACD,IAAI,mBAAmB,IAAI,IAAI,EAAE,CAAC;wBAChC,aAAa,CAAC,mBAAmB,CAAC,CAAC;oBACrC,CAAC;oBACD,yBAAyB,CAAC,IAAI,CAAC,CAAC;oBAChC,cAAc,GAAG,KAAK,CAAC;oBACvB,oBAAoB,CAAC,cAAc,CAAC,CAAC;oBACrC,cAAc,GAAG,KAAK,CAAC;oBACvB,oBAAoB,CAAC,cAAc,CAAC,CAAC;gBACvC,CAAC;YACH,CAAC,EAAE,IAAI,CAAC,CAAC;YACT,yBAAyB,CAAC,mBAAmB,CAAC,CAAC;YAC/C,cAAc,GAAG,IAAI,CAAC;YACtB,oBAAoB,CAAC,cAAc,CAAC,CAAC;YACrC,cAAc,GAAG,KAAK,CAAC,CAAC,kDAAkD;YAC1E,oBAAoB,CAAC,cAAc,CAAC,CAAC;YACrC,OAAO,IAAI,CAAC;QACd,CAAC;aAAM,CAAC;YACN,SAAS,EAAE,CAAC;gBACV,IAAI,EAAE,QAAQ;gBACd,OAAO,EACL,wFAAwF;aAC3F,CAAC,CAAC;YACH,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC,CAAC;uGAxFS,iBAAiB;2GAAjB,iBAAiB,cAFhB,MAAM;;2FAEP,iBAAiB;kBAH7B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { ShowAlert } from '../../@types/types';\nimport { RecordUpdateTimer } from './record-update-timer.service';\nexport interface RecordResumeTimerParameters {\n  isTimerRunning: boolean;\n  canPauseResume: boolean;\n  recordElapsedTime: number;\n  recordStartTime: number;\n  recordTimerInterval?: NodeJS.Timeout | null;\n  showAlert?: ShowAlert;\n  updateRecordStartTime: (time: number) => void;\n  updateRecordTimerInterval: (interval: NodeJS.Timeout | null) => void;\n  updateIsTimerRunning: (isRunning: boolean) => void;\n  updateCanPauseResume: (canPause: boolean) => void;\n\n  getUpdatedAllParams: () => RecordResumeTimerParameters;\n  [key: string]: any;\n}\n\nexport interface RecordResumeTimerOptions {\n  parameters: RecordResumeTimerParameters;\n}\n\n// Export the type definition for the function\nexport type RecordResumeTimerType = (options: RecordResumeTimerOptions) => Promise<boolean>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class RecordResumeTimer {\n  constructor(private RecordUpdateTimerService: RecordUpdateTimer) {}\n\n  /**\n   * Resumes the recording timer if it is not already running and can be paused/resumed.\n   *\n   * @param {RecordResumeTimerOptions} options - The options for resuming the recording timer.\n   * @param {Object} options.parameters - The parameters for the recording timer.\n   * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.\n   * @param {boolean} options.parameters.isTimerRunning - Indicates if the timer is currently running.\n   * @param {boolean} options.parameters.canPauseResume - Indicates if the timer can be paused/resumed.\n   * @param {number} options.parameters.recordElapsedTime - The elapsed recording time in seconds.\n   * @param {number} options.parameters.recordStartTime - The start time of the recording.\n   * @param {number | null} options.parameters.recordTimerInterval - The interval ID for the recording timer.\n   * @param {Function} options.parameters.showAlert - Function to show an alert message.\n   * @param {Function} options.parameters.updateRecordStartTime - Function to update the recording start time.\n   * @param {Function} options.parameters.updateRecordTimerInterval - Function to update the recording timer interval.\n   * @param {Function} options.parameters.updateIsTimerRunning - Function to update the timer running status.\n   * @param {Function} options.parameters.updateCanPauseResume - Function to update the pause/resume status.\n   *\n   * @returns {Promise<boolean>} - Returns a promise that resolves to true if the timer was successfully resumed, otherwise false.\n   */\n\n  recordResumeTimer = async ({ parameters }: RecordResumeTimerOptions): Promise<boolean> => {\n    let { getUpdatedAllParams } = parameters;\n    parameters = getUpdatedAllParams();\n\n    let {\n      isTimerRunning,\n      canPauseResume,\n      recordElapsedTime,\n      recordStartTime,\n      recordTimerInterval,\n      showAlert,\n      updateRecordStartTime,\n      updateRecordTimerInterval,\n      updateIsTimerRunning,\n      updateCanPauseResume,\n\n      //mediasfu Functions\n      // recordUpdateTimer,\n    } = parameters;\n\n    if (!isTimerRunning && canPauseResume) {\n      recordStartTime = new Date().getTime() - recordElapsedTime * 1000; // Calculate the starting time based on elapsed time\n      updateRecordStartTime(recordStartTime);\n      recordTimerInterval = setInterval(() => {\n        // Update the timer every second (1000 milliseconds)\n        this.RecordUpdateTimerService.recordUpdateTimer({\n          recordElapsedTime: recordElapsedTime,\n          recordStartTime: recordStartTime,\n          updateRecordElapsedTime: parameters['updateRecordElapsedTime'],\n          updateRecordingProgressTime: parameters['updateRecordingProgressTime'],\n        });\n\n        parameters = getUpdatedAllParams();\n\n        // Check if recording is paused or stopped, and close the interval if needed\n        if (\n          parameters['recordPaused'] ||\n          parameters['recordStopped'] ||\n          parameters['roomName'] == '' ||\n          parameters['roomName'] == null\n        ) {\n          if (recordTimerInterval != null) {\n            clearInterval(recordTimerInterval);\n          }\n          updateRecordTimerInterval(null);\n          isTimerRunning = false;\n          updateIsTimerRunning(isTimerRunning);\n          canPauseResume = false;\n          updateCanPauseResume(canPauseResume);\n        }\n      }, 1000);\n      updateRecordTimerInterval(recordTimerInterval);\n      isTimerRunning = true;\n      updateIsTimerRunning(isTimerRunning);\n      canPauseResume = false; // Disable pause/resume actions until paused again\n      updateCanPauseResume(canPauseResume);\n      return true;\n    } else {\n      showAlert?.({\n        type: 'danger',\n        message:\n          'Can only pause or resume after 15 seconds of starting or pausing or resuming recording',\n      });\n      return false;\n    }\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"record-resume-timer.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/methods/recording-methods/record-resume-timer.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;;AA0B3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAMH,MAAM,OAAO,iBAAiB;IACR;IAApB,YAAoB,wBAA2C;QAA3C,6BAAwB,GAAxB,wBAAwB,CAAmB;IAAG,CAAC;IAEnE;;;;;;;;;;;;;;;;;;OAkBG;IAEH,iBAAiB,GAAG,KAAK,EAAE,EAAE,UAAU,EAA4B,EAAoB,EAAE;QACvF,IAAI,EAAE,mBAAmB,EAAE,GAAG,UAAU,CAAC;QACzC,UAAU,GAAG,mBAAmB,EAAE,CAAC;QAEnC,IAAI,EACF,cAAc,EACd,cAAc,EACd,iBAAiB,EACjB,eAAe,EACf,mBAAmB,EACnB,SAAS,EACT,qBAAqB,EACrB,yBAAyB,EACzB,oBAAoB,EACpB,oBAAoB;QAEpB,oBAAoB;QACpB,qBAAqB;UACtB,GAAG,UAAU,CAAC;QAEf,IAAI,CAAC,cAAc,IAAI,cAAc,EAAE,CAAC;YACtC,eAAe,GAAG,IAAI,IAAI,EAAE,CAAC,OAAO,EAAE,GAAG,iBAAiB,GAAG,IAAI,CAAC,CAAC,oDAAoD;YACvH,qBAAqB,CAAC,eAAe,CAAC,CAAC;YACvC,mBAAmB,GAAG,WAAW,CAAC,GAAG,EAAE;gBACrC,oDAAoD;gBACpD,IAAI,CAAC,wBAAwB,CAAC,iBAAiB,CAAC;oBAC9C,iBAAiB,EAAE,iBAAiB;oBACpC,eAAe,EAAE,eAAe;oBAChC,uBAAuB,EAAE,UAAU,CAAC,yBAAyB,CAAC;oBAC9D,2BAA2B,EAAE,UAAU,CAAC,6BAA6B,CAAC;iBACvE,CAAC,CAAC;gBAEH,UAAU,GAAG,mBAAmB,EAAE,CAAC;gBAEnC,4EAA4E;gBAC5E,IACE,UAAU,CAAC,cAAc,CAAC;oBAC1B,UAAU,CAAC,eAAe,CAAC;oBAC3B,UAAU,CAAC,UAAU,CAAC,IAAI,EAAE;oBAC5B,UAAU,CAAC,UAAU,CAAC,IAAI,IAAI,EAC9B,CAAC;oBACD,IAAI,mBAAmB,IAAI,IAAI,EAAE,CAAC;wBAChC,aAAa,CAAC,mBAAmB,CAAC,CAAC;oBACrC,CAAC;oBACD,yBAAyB,CAAC,IAAI,CAAC,CAAC;oBAChC,cAAc,GAAG,KAAK,CAAC;oBACvB,oBAAoB,CAAC,cAAc,CAAC,CAAC;oBACrC,cAAc,GAAG,KAAK,CAAC;oBACvB,oBAAoB,CAAC,cAAc,CAAC,CAAC;gBACvC,CAAC;YACH,CAAC,EAAE,IAAI,CAAC,CAAC;YACT,yBAAyB,CAAC,mBAAmB,CAAC,CAAC;YAC/C,cAAc,GAAG,IAAI,CAAC;YACtB,oBAAoB,CAAC,cAAc,CAAC,CAAC;YACrC,cAAc,GAAG,KAAK,CAAC,CAAC,kDAAkD;YAC1E,oBAAoB,CAAC,cAAc,CAAC,CAAC;YACrC,OAAO,IAAI,CAAC;QACd,CAAC;aAAM,CAAC;YACN,SAAS,EAAE,CAAC;gBACV,IAAI,EAAE,QAAQ;gBACd,OAAO,EACL,wFAAwF;aAC3F,CAAC,CAAC;YACH,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC,CAAC;uGAxFS,iBAAiB;2GAAjB,iBAAiB,cAFhB,MAAM;;2FAEP,iBAAiB;kBAH7B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { ShowAlert } from '../../@types/types';\nimport { RecordUpdateTimer } from './record-update-timer.service';\nexport interface RecordResumeTimerParameters {\n  isTimerRunning: boolean;\n  canPauseResume: boolean;\n  recordElapsedTime: number;\n  recordStartTime: number;\n  recordTimerInterval?: NodeJS.Timeout | null;\n  showAlert?: ShowAlert;\n  updateRecordStartTime: (time: number) => void;\n  updateRecordTimerInterval: (interval: NodeJS.Timeout | null) => void;\n  updateIsTimerRunning: (isRunning: boolean) => void;\n  updateCanPauseResume: (canPause: boolean) => void;\n\n  getUpdatedAllParams: () => RecordResumeTimerParameters;\n  [key: string]: any;\n}\n\nexport interface RecordResumeTimerOptions {\n  parameters: RecordResumeTimerParameters;\n}\n\n// Export the type definition for the function\nexport type RecordResumeTimerType = (options: RecordResumeTimerOptions) => Promise<boolean>;\n\n/**\n * Resumes the recording timer if it is not already running and can be paused/resumed.\n *\n * @param {RecordResumeTimerOptions} options - The options for resuming the recording timer.\n * @param {Object} options.parameters - The parameters for the recording timer.\n * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.\n * @param {boolean} options.parameters.isTimerRunning - Indicates if the timer is currently running.\n * @param {boolean} options.parameters.canPauseResume - Indicates if the timer can be paused/resumed.\n * @param {number} options.parameters.recordElapsedTime - The elapsed recording time in seconds.\n * @param {number} options.parameters.recordStartTime - The start time of the recording.\n * @param {NodeJS.Timeout | null} options.parameters.recordTimerInterval - The interval ID for the recording timer.\n * @param {Function} options.parameters.showAlert - Function to show an alert message.\n * @param {Function} options.parameters.updateRecordStartTime - Function to update the recording start time.\n * @param {Function} options.parameters.updateRecordTimerInterval - Function to update the recording timer interval.\n * @param {Function} options.parameters.updateIsTimerRunning - Function to update the timer running status.\n * @param {Function} options.parameters.updateCanPauseResume - Function to update the pause/resume status.\n *\n * @returns {Promise<boolean>} - Returns a promise that resolves to true if the timer was successfully resumed, otherwise false.\n *\n * @throws Will show an alert if the timer cannot be resumed due to conditions not being met.\n *\n * @example\n * ```typescript\n * const options: RecordResumeTimerOptions = {\n *   parameters: {\n *     isTimerRunning: false,\n *     canPauseResume: true,\n *     recordElapsedTime: 10,\n *     recordStartTime: Date.now(),\n *     recordTimerInterval: null,\n *     showAlert: (alert) => { },\n *     updateRecordStartTime: (time) => { },\n *     updateRecordTimerInterval: (interval) => { },\n *     updateIsTimerRunning: (isRunning) => { },\n *     updateCanPauseResume: (canPause) => {  },\n *     getUpdatedAllParams: () => ({  }),\n *   },\n * };\n * const canResume = await recordResumeTimer(options);\n * if (canResume) {\n *   // proceed with the resumed recording\n * }\n * ```\n */\n\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class RecordResumeTimer {\n  constructor(private RecordUpdateTimerService: RecordUpdateTimer) {}\n\n  /**\n   * Resumes the recording timer if it is not already running and can be paused/resumed.\n   *\n   * @param {RecordResumeTimerOptions} options - The options for resuming the recording timer.\n   * @param {Object} options.parameters - The parameters for the recording timer.\n   * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.\n   * @param {boolean} options.parameters.isTimerRunning - Indicates if the timer is currently running.\n   * @param {boolean} options.parameters.canPauseResume - Indicates if the timer can be paused/resumed.\n   * @param {number} options.parameters.recordElapsedTime - The elapsed recording time in seconds.\n   * @param {number} options.parameters.recordStartTime - The start time of the recording.\n   * @param {number | null} options.parameters.recordTimerInterval - The interval ID for the recording timer.\n   * @param {Function} options.parameters.showAlert - Function to show an alert message.\n   * @param {Function} options.parameters.updateRecordStartTime - Function to update the recording start time.\n   * @param {Function} options.parameters.updateRecordTimerInterval - Function to update the recording timer interval.\n   * @param {Function} options.parameters.updateIsTimerRunning - Function to update the timer running status.\n   * @param {Function} options.parameters.updateCanPauseResume - Function to update the pause/resume status.\n   *\n   * @returns {Promise<boolean>} - Returns a promise that resolves to true if the timer was successfully resumed, otherwise false.\n   */\n\n  recordResumeTimer = async ({ parameters }: RecordResumeTimerOptions): Promise<boolean> => {\n    let { getUpdatedAllParams } = parameters;\n    parameters = getUpdatedAllParams();\n\n    let {\n      isTimerRunning,\n      canPauseResume,\n      recordElapsedTime,\n      recordStartTime,\n      recordTimerInterval,\n      showAlert,\n      updateRecordStartTime,\n      updateRecordTimerInterval,\n      updateIsTimerRunning,\n      updateCanPauseResume,\n\n      //mediasfu Functions\n      // recordUpdateTimer,\n    } = parameters;\n\n    if (!isTimerRunning && canPauseResume) {\n      recordStartTime = new Date().getTime() - recordElapsedTime * 1000; // Calculate the starting time based on elapsed time\n      updateRecordStartTime(recordStartTime);\n      recordTimerInterval = setInterval(() => {\n        // Update the timer every second (1000 milliseconds)\n        this.RecordUpdateTimerService.recordUpdateTimer({\n          recordElapsedTime: recordElapsedTime,\n          recordStartTime: recordStartTime,\n          updateRecordElapsedTime: parameters['updateRecordElapsedTime'],\n          updateRecordingProgressTime: parameters['updateRecordingProgressTime'],\n        });\n\n        parameters = getUpdatedAllParams();\n\n        // Check if recording is paused or stopped, and close the interval if needed\n        if (\n          parameters['recordPaused'] ||\n          parameters['recordStopped'] ||\n          parameters['roomName'] == '' ||\n          parameters['roomName'] == null\n        ) {\n          if (recordTimerInterval != null) {\n            clearInterval(recordTimerInterval);\n          }\n          updateRecordTimerInterval(null);\n          isTimerRunning = false;\n          updateIsTimerRunning(isTimerRunning);\n          canPauseResume = false;\n          updateCanPauseResume(canPauseResume);\n        }\n      }, 1000);\n      updateRecordTimerInterval(recordTimerInterval);\n      isTimerRunning = true;\n      updateIsTimerRunning(isTimerRunning);\n      canPauseResume = false; // Disable pause/resume actions until paused again\n      updateCanPauseResume(canPauseResume);\n      return true;\n    } else {\n      showAlert?.({\n        type: 'danger',\n        message:\n          'Can only pause or resume after 15 seconds of starting or pausing or resuming recording',\n      });\n      return false;\n    }\n  };\n}\n"]}

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

@@ -1,6 +1,51 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
 import * as i1 from "./record-update-timer.service";
+/**
+ * Starts the recording timer and manages its state.
+ *
+ * @param {RecordStartTimerOptions} options - The options for starting the recording timer.
+ * @param {Object} options.parameters - The parameters for the recording timer.
+ * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+ * @param {number} options.parameters.recordStartTime - The start time of the recording.
+ * @param {NodeJS.Timeout | null} options.parameters.recordTimerInterval - The interval ID for the recording timer.
+ * @param {boolean} options.parameters.isTimerRunning - Flag indicating if the timer is currently running.
+ * @param {boolean} options.parameters.canPauseResume - Flag indicating if pause/resume actions are enabled.
+ * @param {number} options.parameters.recordChangeSeconds - The time after which pause/resume actions are enabled.
+ * @param {Function} options.parameters.updateRecordStartTime - Function to update the recording start time.
+ * @param {Function} options.parameters.updateRecordTimerInterval - Function to update the recording timer interval.
+ * @param {Function} options.parameters.updateIsTimerRunning - Function to update the timer running state.
+ * @param {Function} options.parameters.updateCanPauseResume - Function to update the pause/resume state.
+ *
+ * @returns {Promise<void>} A promise that resolves when the timer is started.
+ *
+ * @remarks
+ * This function initializes the recording start time and sets up an interval to update the timer every second.
+ * It also manages the state of the timer, including enabling and disabling pause/resume actions.
+ * The timer is stopped if the recording is paused, stopped, or if the room name is invalid.
+ *
+ * @example
+ * ```typescript
+ * const options: RecordStartTimerOptions = {
+ *   parameters: {
+ *     recordStartTime: Date.now(),
+ *     recordTimerInterval: null,
+ *     isTimerRunning: false,
+ *     canPauseResume: false,
+ *     recordChangeSeconds: 15,
+ *     recordPaused: false,
+ *     recordStopped: false,
+ *     roomName: 'room1',
+ *     updateRecordStartTime: (time) => {  },
+ *     updateRecordTimerInterval: (interval) => {  },
+ *     updateIsTimerRunning: (isRunning) => { },
+ *     updateCanPauseResume: (canPause) => {},
+ *     getUpdatedAllParams: () => { },
+ *   },
+ * };
+ * await recordStartTimer(options);
+ * ```
+ */
 export class RecordStartTimer {
     RecordUpdateTimerService;
     constructor(RecordUpdateTimerService) {
@@ -86,4 +131,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }], ctorParameters: () => [{ type: i1.RecordUpdateTimer }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"record-start-timer.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/methods/recording-methods/record-start-timer.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;;AAgC3C,MAAM,OAAO,gBAAgB;IACP;IAApB,YAAoB,wBAA2C;QAA3C,6BAAwB,GAAxB,wBAAwB,CAAmB;IAAG,CAAC;IAEnE;;;;OAIG;IACH;;;;;;;;;;;;;;;;;;;;;OAqBG;IAEH,gBAAgB,GAAG,KAAK,EAAE,EAAE,UAAU,EAAuB,EAAiB,EAAE;QAC9E,IAAI,EAAE,mBAAmB,EAAE,GAAG,UAAU,CAAC;QACzC,UAAU,GAAG,mBAAmB,EAAE,CAAC;QAEnC,IAAI,EACF,eAAe,EACf,mBAAmB,EACnB,cAAc,EACd,cAAc,EACd,mBAAmB,EAEnB,qBAAqB,EACrB,yBAAyB,EACzB,oBAAoB,EACpB,oBAAoB,GACrB,GAAG,UAAU,CAAC;QAEf;;WAEG;QACH,SAAS,iBAAiB;YACxB,cAAc,GAAG,IAAI,CAAC;YACtB,oBAAoB,CAAC,cAAc,CAAC,CAAC;QACvC,CAAC;QAED,IAAI,CAAC,cAAc,EAAE,CAAC;YACpB,eAAe,GAAG,IAAI,IAAI,EAAE,CAAC,OAAO,EAAE,CAAC,CAAC,4BAA4B;YACpE,qBAAqB,CAAC,eAAe,CAAC,CAAC;YACvC,mBAAmB,GAAG,WAAW,CAAC,GAAG,EAAE;gBACrC,oDAAoD;gBACpD,IAAI,CAAC,wBAAwB,CAAC,iBAAiB,CAAC;oBAC9C,iBAAiB,EAAE,UAAU,CAAC,iBAAiB;oBAC/C,eAAe,EAAE,eAAe;oBAChC,uBAAuB,EAAE,UAAU,CAAC,uBAAuB;oBAC3D,2BAA2B,EAAE,UAAU,CAAC,2BAA2B;iBACpE,CAAC,CAAC;gBAEH,UAAU,GAAG,mBAAmB,EAAE,CAAC;gBAEnC,4EAA4E;gBAC5E,IACE,UAAU,CAAC,YAAY;oBACvB,UAAU,CAAC,aAAa;oBACxB,UAAU,CAAC,QAAQ,IAAI,EAAE;oBACzB,UAAU,CAAC,QAAQ,IAAI,IAAI,EAC3B,CAAC;oBACD,aAAa,CAAC,mBAAmB,CAAC,CAAC;oBACnC,yBAAyB,CAAC,IAAI,CAAC,CAAC;oBAChC,cAAc,GAAG,KAAK,CAAC;oBACvB,oBAAoB,CAAC,cAAc,CAAC,CAAC;oBACrC,cAAc,GAAG,KAAK,CAAC;oBACvB,oBAAoB,CAAC,cAAc,CAAC,CAAC;gBACvC,CAAC;YACH,CAAC,EAAE,IAAI,CAAC,CAAC;YACT,yBAAyB,CAAC,mBAAmB,CAAC,CAAC;YAC/C,cAAc,GAAG,IAAI,CAAC;YACtB,oBAAoB,CAAC,cAAc,CAAC,CAAC;YACrC,cAAc,GAAG,KAAK,CAAC,CAAC,yCAAyC;YACjE,oBAAoB,CAAC,cAAc,CAAC,CAAC;YACrC,UAAU,CAAC,iBAAiB,EAAE,mBAAmB,CAAC,CAAC,CAAC,mDAAmD;QACzG,CAAC;IACH,CAAC,CAAC;uGA5FS,gBAAgB;2GAAhB,gBAAgB,cAFf,MAAM;;2FAEP,gBAAgB;kBAH5B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { RecordUpdateTimer } from './record-update-timer.service';\n\nexport interface RecordStartTimerParameters {\n  recordStartTime: number;\n  recordTimerInterval?: NodeJS.Timeout | null;\n  isTimerRunning: boolean;\n  canPauseResume: boolean;\n  recordChangeSeconds: number;\n  recordPaused: boolean;\n  recordStopped: boolean;\n  roomName: string | null;\n  updateRecordStartTime: (time: number) => void;\n  updateRecordTimerInterval: (interval: NodeJS.Timeout | null) => void;\n  updateIsTimerRunning: (isRunning: boolean) => void;\n  updateCanPauseResume: (canPause: boolean) => void;\n\n  // Mediasfu functions\n  getUpdatedAllParams: () => RecordStartTimerParameters;\n  [key: string]: any;\n}\n\nexport interface RecordStartTimerOptions {\n  parameters: RecordStartTimerParameters;\n}\n\n// Export the type definition for the function\nexport type RecordStartTimerType = (options: RecordStartTimerOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class RecordStartTimer {\n  constructor(private RecordUpdateTimerService: RecordUpdateTimer) {}\n\n  /**\n   * Starts the recording timer.\n   * @function\n   * @param {RecordStartTimerOptions} options - The options object containing necessary variables and functions.\n   */\n  /**\n   * Starts a recording timer and manages its state.\n   *\n   * @param {RecordStartTimerOptions} options - The options for starting the recording timer.\n   * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.\n   * @param {number} options.parameters.recordStartTime - The start time of the recording.\n   * @param {number | null} options.parameters.recordTimerInterval - The interval ID for the recording timer.\n   * @param {boolean} options.parameters.isTimerRunning - Flag indicating if the timer is running.\n   * @param {boolean} options.parameters.canPauseResume - Flag indicating if pause/resume actions are enabled.\n   * @param {number} options.parameters.recordChangeSeconds - The time after which pause/resume actions are enabled.\n   * @param {Function} options.parameters.updateRecordStartTime - Function to update the recording start time.\n   * @param {Function} options.parameters.updateRecordTimerInterval - Function to update the recording timer interval.\n   * @param {Function} options.parameters.updateIsTimerRunning - Function to update the timer running state.\n   * @param {Function} options.parameters.updateCanPauseResume - Function to update the pause/resume state.\n   *\n   * @returns {Promise<void>} A promise that resolves when the timer is started.\n   *\n   * @remarks\n   * This function initializes the recording start time and sets up an interval to update the timer every second.\n   * It also manages the state of the timer, including enabling and disabling pause/resume actions.\n   * The timer is stopped if the recording is paused, stopped, or if the room name is invalid.\n   */\n\n  recordStartTimer = async ({ parameters }: { parameters: any }): Promise<void> => {\n    let { getUpdatedAllParams } = parameters;\n    parameters = getUpdatedAllParams();\n\n    let {\n      recordStartTime,\n      recordTimerInterval,\n      isTimerRunning,\n      canPauseResume,\n      recordChangeSeconds,\n\n      updateRecordStartTime,\n      updateRecordTimerInterval,\n      updateIsTimerRunning,\n      updateCanPauseResume,\n    } = parameters;\n\n    /**\n     * Utility function to enable pause/resume actions after a specified time.\n     */\n    function enablePauseResume() {\n      canPauseResume = true;\n      updateCanPauseResume(canPauseResume);\n    }\n\n    if (!isTimerRunning) {\n      recordStartTime = new Date().getTime(); // Get the current timestamp\n      updateRecordStartTime(recordStartTime);\n      recordTimerInterval = setInterval(() => {\n        // Update the timer every second (1000 milliseconds)\n        this.RecordUpdateTimerService.recordUpdateTimer({\n          recordElapsedTime: parameters.recordElapsedTime,\n          recordStartTime: recordStartTime,\n          updateRecordElapsedTime: parameters.updateRecordElapsedTime,\n          updateRecordingProgressTime: parameters.updateRecordingProgressTime,\n        });\n\n        parameters = getUpdatedAllParams();\n\n        // Check if recording is paused or stopped, and close the interval if needed\n        if (\n          parameters.recordPaused ||\n          parameters.recordStopped ||\n          parameters.roomName == '' ||\n          parameters.roomName == null\n        ) {\n          clearInterval(recordTimerInterval);\n          updateRecordTimerInterval(null);\n          isTimerRunning = false;\n          updateIsTimerRunning(isTimerRunning);\n          canPauseResume = false;\n          updateCanPauseResume(canPauseResume);\n        }\n      }, 1000);\n      updateRecordTimerInterval(recordTimerInterval);\n      isTimerRunning = true;\n      updateIsTimerRunning(isTimerRunning);\n      canPauseResume = false; // Disable pause/resume actions initially\n      updateCanPauseResume(canPauseResume);\n      setTimeout(enablePauseResume, recordChangeSeconds); // Enable pause/resume actions after specified time\n    }\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"record-start-timer.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/methods/recording-methods/record-start-timer.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;;AA6B3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAKH,MAAM,OAAO,gBAAgB;IACP;IAApB,YAAoB,wBAA2C;QAA3C,6BAAwB,GAAxB,wBAAwB,CAAmB;IAAG,CAAC;IAEnE;;;;OAIG;IACH;;;;;;;;;;;;;;;;;;;;;OAqBG;IAEH,gBAAgB,GAAG,KAAK,EAAE,EAAE,UAAU,EAAuB,EAAiB,EAAE;QAC9E,IAAI,EAAE,mBAAmB,EAAE,GAAG,UAAU,CAAC;QACzC,UAAU,GAAG,mBAAmB,EAAE,CAAC;QAEnC,IAAI,EACF,eAAe,EACf,mBAAmB,EACnB,cAAc,EACd,cAAc,EACd,mBAAmB,EAEnB,qBAAqB,EACrB,yBAAyB,EACzB,oBAAoB,EACpB,oBAAoB,GACrB,GAAG,UAAU,CAAC;QAEf;;WAEG;QACH,SAAS,iBAAiB;YACxB,cAAc,GAAG,IAAI,CAAC;YACtB,oBAAoB,CAAC,cAAc,CAAC,CAAC;QACvC,CAAC;QAED,IAAI,CAAC,cAAc,EAAE,CAAC;YACpB,eAAe,GAAG,IAAI,IAAI,EAAE,CAAC,OAAO,EAAE,CAAC,CAAC,4BAA4B;YACpE,qBAAqB,CAAC,eAAe,CAAC,CAAC;YACvC,mBAAmB,GAAG,WAAW,CAAC,GAAG,EAAE;gBACrC,oDAAoD;gBACpD,IAAI,CAAC,wBAAwB,CAAC,iBAAiB,CAAC;oBAC9C,iBAAiB,EAAE,UAAU,CAAC,iBAAiB;oBAC/C,eAAe,EAAE,eAAe;oBAChC,uBAAuB,EAAE,UAAU,CAAC,uBAAuB;oBAC3D,2BAA2B,EAAE,UAAU,CAAC,2BAA2B;iBACpE,CAAC,CAAC;gBAEH,UAAU,GAAG,mBAAmB,EAAE,CAAC;gBAEnC,4EAA4E;gBAC5E,IACE,UAAU,CAAC,YAAY;oBACvB,UAAU,CAAC,aAAa;oBACxB,UAAU,CAAC,QAAQ,IAAI,EAAE;oBACzB,UAAU,CAAC,QAAQ,IAAI,IAAI,EAC3B,CAAC;oBACD,aAAa,CAAC,mBAAmB,CAAC,CAAC;oBACnC,yBAAyB,CAAC,IAAI,CAAC,CAAC;oBAChC,cAAc,GAAG,KAAK,CAAC;oBACvB,oBAAoB,CAAC,cAAc,CAAC,CAAC;oBACrC,cAAc,GAAG,KAAK,CAAC;oBACvB,oBAAoB,CAAC,cAAc,CAAC,CAAC;gBACvC,CAAC;YACH,CAAC,EAAE,IAAI,CAAC,CAAC;YACT,yBAAyB,CAAC,mBAAmB,CAAC,CAAC;YAC/C,cAAc,GAAG,IAAI,CAAC;YACtB,oBAAoB,CAAC,cAAc,CAAC,CAAC;YACrC,cAAc,GAAG,KAAK,CAAC,CAAC,yCAAyC;YACjE,oBAAoB,CAAC,cAAc,CAAC,CAAC;YACrC,UAAU,CAAC,iBAAiB,EAAE,mBAAmB,CAAC,CAAC,CAAC,mDAAmD;QACzG,CAAC;IACH,CAAC,CAAC;uGA5FS,gBAAgB;2GAAhB,gBAAgB,cAFf,MAAM;;2FAEP,gBAAgB;kBAH5B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { RecordUpdateTimer } from './record-update-timer.service';\n\nexport interface RecordStartTimerParameters {\n  recordStartTime: number;\n  recordTimerInterval?: NodeJS.Timeout | null;\n  isTimerRunning: boolean;\n  canPauseResume: boolean;\n  recordChangeSeconds: number;\n  recordPaused: boolean;\n  recordStopped: boolean;\n  roomName: string | null;\n  updateRecordStartTime: (time: number) => void;\n  updateRecordTimerInterval: (interval: NodeJS.Timeout | null) => void;\n  updateIsTimerRunning: (isRunning: boolean) => void;\n  updateCanPauseResume: (canPause: boolean) => void;\n\n  // Mediasfu functions\n  getUpdatedAllParams: () => RecordStartTimerParameters;\n  [key: string]: any;\n}\n\nexport interface RecordStartTimerOptions {\n  parameters: RecordStartTimerParameters;\n}\n\n// Export the type definition for the function\nexport type RecordStartTimerType = (options: RecordStartTimerOptions) => Promise<void>;\n\n/**\n * Starts the recording timer and manages its state.\n *\n * @param {RecordStartTimerOptions} options - The options for starting the recording timer.\n * @param {Object} options.parameters - The parameters for the recording timer.\n * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.\n * @param {number} options.parameters.recordStartTime - The start time of the recording.\n * @param {NodeJS.Timeout | null} options.parameters.recordTimerInterval - The interval ID for the recording timer.\n * @param {boolean} options.parameters.isTimerRunning - Flag indicating if the timer is currently running.\n * @param {boolean} options.parameters.canPauseResume - Flag indicating if pause/resume actions are enabled.\n * @param {number} options.parameters.recordChangeSeconds - The time after which pause/resume actions are enabled.\n * @param {Function} options.parameters.updateRecordStartTime - Function to update the recording start time.\n * @param {Function} options.parameters.updateRecordTimerInterval - Function to update the recording timer interval.\n * @param {Function} options.parameters.updateIsTimerRunning - Function to update the timer running state.\n * @param {Function} options.parameters.updateCanPauseResume - Function to update the pause/resume state.\n *\n * @returns {Promise<void>} A promise that resolves when the timer is started.\n *\n * @remarks\n * This function initializes the recording start time and sets up an interval to update the timer every second.\n * It also manages the state of the timer, including enabling and disabling pause/resume actions.\n * The timer is stopped if the recording is paused, stopped, or if the room name is invalid.\n *\n * @example\n * ```typescript\n * const options: RecordStartTimerOptions = {\n *   parameters: {\n *     recordStartTime: Date.now(),\n *     recordTimerInterval: null,\n *     isTimerRunning: false,\n *     canPauseResume: false,\n *     recordChangeSeconds: 15,\n *     recordPaused: false,\n *     recordStopped: false,\n *     roomName: 'room1',\n *     updateRecordStartTime: (time) => {  },\n *     updateRecordTimerInterval: (interval) => {  },\n *     updateIsTimerRunning: (isRunning) => { },\n *     updateCanPauseResume: (canPause) => {},\n *     getUpdatedAllParams: () => { },\n *   },\n * };\n * await recordStartTimer(options);\n * ```\n */\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class RecordStartTimer {\n  constructor(private RecordUpdateTimerService: RecordUpdateTimer) {}\n\n  /**\n   * Starts the recording timer.\n   * @function\n   * @param {RecordStartTimerOptions} options - The options object containing necessary variables and functions.\n   */\n  /**\n   * Starts a recording timer and manages its state.\n   *\n   * @param {RecordStartTimerOptions} options - The options for starting the recording timer.\n   * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.\n   * @param {number} options.parameters.recordStartTime - The start time of the recording.\n   * @param {number | null} options.parameters.recordTimerInterval - The interval ID for the recording timer.\n   * @param {boolean} options.parameters.isTimerRunning - Flag indicating if the timer is running.\n   * @param {boolean} options.parameters.canPauseResume - Flag indicating if pause/resume actions are enabled.\n   * @param {number} options.parameters.recordChangeSeconds - The time after which pause/resume actions are enabled.\n   * @param {Function} options.parameters.updateRecordStartTime - Function to update the recording start time.\n   * @param {Function} options.parameters.updateRecordTimerInterval - Function to update the recording timer interval.\n   * @param {Function} options.parameters.updateIsTimerRunning - Function to update the timer running state.\n   * @param {Function} options.parameters.updateCanPauseResume - Function to update the pause/resume state.\n   *\n   * @returns {Promise<void>} A promise that resolves when the timer is started.\n   *\n   * @remarks\n   * This function initializes the recording start time and sets up an interval to update the timer every second.\n   * It also manages the state of the timer, including enabling and disabling pause/resume actions.\n   * The timer is stopped if the recording is paused, stopped, or if the room name is invalid.\n   */\n\n  recordStartTimer = async ({ parameters }: { parameters: any }): Promise<void> => {\n    let { getUpdatedAllParams } = parameters;\n    parameters = getUpdatedAllParams();\n\n    let {\n      recordStartTime,\n      recordTimerInterval,\n      isTimerRunning,\n      canPauseResume,\n      recordChangeSeconds,\n\n      updateRecordStartTime,\n      updateRecordTimerInterval,\n      updateIsTimerRunning,\n      updateCanPauseResume,\n    } = parameters;\n\n    /**\n     * Utility function to enable pause/resume actions after a specified time.\n     */\n    function enablePauseResume() {\n      canPauseResume = true;\n      updateCanPauseResume(canPauseResume);\n    }\n\n    if (!isTimerRunning) {\n      recordStartTime = new Date().getTime(); // Get the current timestamp\n      updateRecordStartTime(recordStartTime);\n      recordTimerInterval = setInterval(() => {\n        // Update the timer every second (1000 milliseconds)\n        this.RecordUpdateTimerService.recordUpdateTimer({\n          recordElapsedTime: parameters.recordElapsedTime,\n          recordStartTime: recordStartTime,\n          updateRecordElapsedTime: parameters.updateRecordElapsedTime,\n          updateRecordingProgressTime: parameters.updateRecordingProgressTime,\n        });\n\n        parameters = getUpdatedAllParams();\n\n        // Check if recording is paused or stopped, and close the interval if needed\n        if (\n          parameters.recordPaused ||\n          parameters.recordStopped ||\n          parameters.roomName == '' ||\n          parameters.roomName == null\n        ) {\n          clearInterval(recordTimerInterval);\n          updateRecordTimerInterval(null);\n          isTimerRunning = false;\n          updateIsTimerRunning(isTimerRunning);\n          canPauseResume = false;\n          updateCanPauseResume(canPauseResume);\n        }\n      }, 1000);\n      updateRecordTimerInterval(recordTimerInterval);\n      isTimerRunning = true;\n      updateIsTimerRunning(isTimerRunning);\n      canPauseResume = false; // Disable pause/resume actions initially\n      updateCanPauseResume(canPauseResume);\n      setTimeout(enablePauseResume, recordChangeSeconds); // Enable pause/resume actions after specified time\n    }\n  };\n}\n"]}

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

@@ -1,5 +1,37 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Updates the recording timer and progress time.
+ * @function
+ * @param {RecordUpdateTimerOptions} options - The options object containing necessary variables and functions.
+ */
+/**
+ * Updates the recording timer by calculating the elapsed time since the recording started
+ * and formatting it in HH:MM:SS format.
+ *
+ * @param {Object} options - The options object.
+ * @param {number} options.recordElapsedTime - The elapsed recording time in seconds.
+ * @param {number} options.recordStartTime - The timestamp when the recording started.
+ * @param {Function} options.updateRecordElapsedTime - Callback to update the elapsed recording time.
+ * @param {Function} options.updateRecordingProgressTime - Callback to update the formatted recording time.
+ * @returns {void}
+ *
+ * @remarks
+ * This function calculates the elapsed time since the recording started and formats it into
+ * a string in HH:MM:SS format. It updates both the elapsed time in seconds and the formatted
+ * time via the provided callback functions.
+ *
+ * @example
+ * ```typescript
+ * const options: RecordUpdateTimerOptions = {
+ *   recordElapsedTime: 0,
+ *   recordStartTime: Date.now(),
+ *   updateRecordElapsedTime: (elapsedTime) => { console.log(`Elapsed Time: ${elapsedTime} seconds`); },
+ *   updateRecordingProgressTime: (formattedTime) => { console.log(`Formatted Time: ${formattedTime}`); },
+ * };
+ * recordUpdateTimer(options);
+ * ```
+ */
 export class RecordUpdateTimer {
     /**
      * Updates the recording timer and progress time.
@@ -45,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,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

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

@@ -2,6 +2,56 @@ import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
 import * as i1 from "./record-start-timer.service";
 import * as i2 from "./record-resume-timer.service";
+/**
+ * Starts the recording process based on the provided parameters.
+ *
+ * @param {StartRecordingOptions} options - The options for starting the recording.
+ * @param {object} options.parameters - The parameters required for starting the recording.
+ * @param {string} options.parameters.roomName - The name of the room where recording is to be started.
+ * @param {object} options.parameters.userRecordingParams - User-specific recording parameters.
+ * @param {object} options.parameters.socket - The socket instance for communication.
+ * @param {function} options.parameters.updateIsRecordingModalVisible - Function to update the visibility of the recording modal.
+ * @param {boolean} options.parameters.confirmedToRecord - Flag indicating if the user has confirmed to record.
+ * @param {function} options.parameters.showAlert - Function to show alerts.
+ * @param {string} options.parameters.recordingMediaOptions - The media options for recording (e.g., "video", "audio").
+ * @param {boolean} options.parameters.videoAlreadyOn - Flag indicating if the video is already on.
+ * @param {boolean} options.parameters.audioAlreadyOn - Flag indicating if the audio is already on.
+ * @param {boolean} options.parameters.recordStarted - Flag indicating if the recording has started.
+ * @param {boolean} options.parameters.recordPaused - Flag indicating if the recording is paused.
+ * @param {boolean} options.parameters.recordResumed - Flag indicating if the recording is resumed.
+ * @param {boolean} options.parameters.recordStopped - Flag indicating if the recording is stopped.
+ * @param {boolean} options.parameters.startReport - Flag indicating if the start report is active.
+ * @param {boolean} options.parameters.endReport - Flag indicating if the end report is active.
+ * @param {boolean} options.parameters.canRecord - Flag indicating if recording is allowed.
+ * @param {function} options.parameters.updateClearedToRecord - Function to update the cleared to record status.
+ * @param {function} options.parameters.updateRecordStarted - Function to update the record started status.
+ * @param {function} options.parameters.updateRecordPaused - Function to update the record paused status.
+ * @param {function} options.parameters.updateRecordResumed - Function to update the record resumed status.
+ * @param {function} options.parameters.updateStartReport - Function to update the start report status.
+ * @param {function} options.parameters.updateEndReport - Function to update the end report status.
+ * @param {function} options.parameters.updateCanRecord - Function to update the can record status.
+ * @param {boolean} options.parameters.whiteboardStarted - Flag indicating if the whiteboard has started.
+ * @param {boolean} options.parameters.whiteboardEnded - Flag indicating if the whiteboard has ended.
+ * @param {function} options.parameters.rePort - Function to report the recording status.
+ * @param {function} options.parameters.captureCanvasStream - Function to capture the canvas stream.
+ *
+ * @returns {Promise<boolean | undefined>} - A promise that resolves to a boolean indicating if the recording attempt was successful, or undefined if not applicable.
+ *
+ * @remarks
+ * This method checks various conditions, such as whether the user has confirmed recording and whether audio or video is already on,
+ * before starting the recording. It updates the recording state, manages socket communication, and handles whiteboard functionality if applicable.
+ *
+ * @example
+ * ```typescript
+ * const options: StartRecordingOptions = { parameters: someParameters };
+ * const result = await startRecording(options);
+ * if (result) {
+ *   console.log('Recording started successfully.');
+ * } else {
+ *   console.log('Failed to start recording.');
+ * }
+ * ```
+ */
 export class StartRecording {
     RecordStartTimerService;
     RecordResumeTimerService;
@@ -144,4 +194,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }], ctorParameters: () => [{ type: i1.RecordStartTimer }, { type: i2.RecordResumeTimer }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"start-recording.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/methods/recording-methods/start-recording.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { RecordStartTimer } from './record-start-timer.service';\nimport { RecordResumeTimer, RecordResumeTimerParameters } from './record-resume-timer.service';\n\nimport { Socket } from 'socket.io-client';\nimport {\n  RePortType,\n  UserRecordingParams,\n  CaptureCanvasStreamType,\n  CaptureCanvasStreamParameters,\n  RePortParameters,\n  ShowAlert,\n} from '../../@types/types';\n\nexport interface StartRecordingParameters\n  extends CaptureCanvasStreamParameters,\n    RePortParameters,\n    RecordResumeTimerParameters {\n  roomName: string;\n  userRecordingParams: UserRecordingParams;\n  socket: Socket;\n  updateIsRecordingModalVisible: (visible: boolean) => void;\n  confirmedToRecord: boolean;\n  showAlert?: ShowAlert;\n  recordingMediaOptions: string;\n  videoAlreadyOn: boolean;\n  audioAlreadyOn: boolean;\n  recordStarted: boolean;\n  recordPaused: boolean;\n  recordResumed: boolean;\n  recordStopped: boolean;\n  startReport: boolean;\n  endReport: boolean;\n  canRecord: boolean;\n  updateClearedToRecord: (cleared: boolean) => void;\n  updateRecordStarted: (started: boolean) => void;\n  updateRecordPaused: (paused: boolean) => void;\n  updateRecordResumed: (resumed: boolean) => void;\n  updateStartReport: (started: boolean) => void;\n  updateEndReport: (ended: boolean) => void;\n  updateCanRecord: (canRecord: boolean) => void;\n  whiteboardStarted: boolean;\n  whiteboardEnded: boolean;\n\n  // Mediasfu functions\n  rePort: RePortType;\n  captureCanvasStream: CaptureCanvasStreamType;\n\n  getUpdatedAllParams: () => StartRecordingParameters;\n  [key: string]: any;\n}\n\nexport interface StartRecordingOptions {\n  parameters: StartRecordingParameters;\n}\n\n// Export the type definition for the function\nexport type StartRecordingType = (options: StartRecordingOptions) => Promise<boolean | undefined>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class StartRecording {\n  constructor(\n    private RecordStartTimerService: RecordStartTimer,\n    private RecordResumeTimerService: RecordResumeTimer,\n  ) {}\n\n  /**\n   * Starts the recording process based on the provided parameters.\n   *\n   * @param {StartRecordingOptions} options - The options for starting the recording.\n   * @param {object} options.parameters - The parameters required for starting the recording.\n   * @param {string} options.parameters.roomName - The name of the room where recording is to be started.\n   * @param {object} options.parameters.userRecordingParams - User-specific recording parameters.\n   * @param {object} options.parameters.socket - The socket instance for communication.\n   * @param {function} options.parameters.updateIsRecordingModalVisible - Function to update the visibility of the recording modal.\n   * @param {boolean} options.parameters.confirmedToRecord - Flag indicating if the user has confirmed to record.\n   * @param {function} options.parameters.showAlert - Function to show alerts.\n   * @param {string} options.parameters.recordingMediaOptions - The media options for recording (e.g., \"video\", \"audio\").\n   * @param {boolean} options.parameters.videoAlreadyOn - Flag indicating if the video is already on.\n   * @param {boolean} options.parameters.audioAlreadyOn - Flag indicating if the audio is already on.\n   * @param {boolean} options.parameters.recordStarted - Flag indicating if the recording has started.\n   * @param {boolean} options.parameters.recordPaused - Flag indicating if the recording is paused.\n   * @param {boolean} options.parameters.recordResumed - Flag indicating if the recording is resumed.\n   * @param {boolean} options.parameters.recordStopped - Flag indicating if the recording is stopped.\n   * @param {boolean} options.parameters.startReport - Flag indicating if the start report is active.\n   * @param {boolean} options.parameters.endReport - Flag indicating if the end report is active.\n   * @param {boolean} options.parameters.canRecord - Flag indicating if recording is allowed.\n   * @param {function} options.parameters.updateClearedToRecord - Function to update the cleared to record status.\n   * @param {function} options.parameters.updateRecordStarted - Function to update the record started status.\n   * @param {function} options.parameters.updateRecordPaused - Function to update the record paused status.\n   * @param {function} options.parameters.updateRecordResumed - Function to update the record resumed status.\n   * @param {function} options.parameters.updateStartReport - Function to update the start report status.\n   * @param {function} options.parameters.updateEndReport - Function to update the end report status.\n   * @param {function} options.parameters.updateCanRecord - Function to update the can record status.\n   * @param {boolean} options.parameters.whiteboardStarted - Flag indicating if the whiteboard has started.\n   * @param {boolean} options.parameters.whiteboardEnded - Flag indicating if the whiteboard has ended.\n   * @param {function} options.parameters.rePort - Function to report the recording status.\n   * @param {function} options.parameters.captureCanvasStream - Function to capture the canvas stream.\n   *\n   * @returns {Promise<boolean | undefined>} - A promise that resolves to a boolean indicating if the recording attempt was successful, or undefined if not applicable.\n   */\n\n  startRecording = async ({ parameters }: StartRecordingOptions): Promise<boolean | undefined> => {\n    parameters = parameters.getUpdatedAllParams();\n\n    let {\n      roomName,\n      userRecordingParams,\n      socket,\n      updateIsRecordingModalVisible,\n      confirmedToRecord,\n      showAlert,\n      recordingMediaOptions,\n      videoAlreadyOn,\n      audioAlreadyOn,\n      recordStarted,\n      recordPaused,\n      recordResumed,\n      recordStopped,\n      startReport,\n      endReport,\n      canRecord,\n      updateClearedToRecord,\n      updateRecordStarted,\n      updateRecordPaused,\n      updateRecordResumed,\n      updateStartReport,\n      updateEndReport,\n      updateCanRecord,\n\n      whiteboardStarted,\n      whiteboardEnded,\n\n      //mediasfu functions\n      rePort,\n      captureCanvasStream,\n    } = parameters;\n\n    // Check if recording is confirmed before starting\n    if (!confirmedToRecord) {\n      showAlert?.({\n        message: 'You must click confirm before you can start recording',\n        type: 'danger',\n      });\n      return false;\n    }\n\n    // Check for recordingMediaOptions for video\n    if (recordingMediaOptions === 'video' && !videoAlreadyOn) {\n      showAlert?.({\n        message: 'You must turn on your video before you can start recording',\n        type: 'danger',\n      });\n      return false;\n    }\n\n    // Check for recordingMediaOptions for audio\n    if (recordingMediaOptions === 'audio' && !audioAlreadyOn) {\n      showAlert?.({\n        message: 'You must turn on your audio before you can start recording',\n        type: 'danger',\n      });\n      return false;\n    }\n\n    // Set clearedToRecord to true\n    updateClearedToRecord(true);\n\n    let action = 'startRecord';\n    if (recordStarted && recordPaused && !recordResumed && !recordStopped) {\n      action = 'resumeRecord';\n    } else {\n      action = 'startRecord';\n    }\n\n    let recAttempt = false;\n\n    await new Promise<void>((resolve) => {\n      socket.emit(\n        action,\n        { roomName, userRecordingParams },\n        async ({ success, reason }: { success: boolean; reason: string; recordState: any }) => {\n          if (success) {\n            recordStarted = true;\n            startReport = true;\n            endReport = false;\n            recordPaused = false;\n            recAttempt = true;\n\n            updateRecordStarted(recordStarted);\n            updateStartReport(startReport);\n            updateEndReport(endReport);\n            updateRecordPaused(recordPaused);\n\n            if (action === 'startRecord') {\n              await rePort({ parameters });\n              await this.RecordStartTimerService.recordStartTimer({ parameters });\n            } else {\n              recordResumed = true;\n              updateRecordResumed(recordResumed);\n              await rePort({ restart: true, parameters });\n              await this.RecordResumeTimerService.recordResumeTimer({ parameters });\n            }\n          } else {\n            showAlert?.({ message: `Recording could not start - ${reason}`, type: 'danger' });\n            canRecord = true;\n            startReport = false;\n            endReport = true;\n            recAttempt = false;\n\n            updateCanRecord(canRecord);\n            updateStartReport(startReport);\n            updateEndReport(endReport);\n          }\n\n          resolve();\n        },\n      );\n    });\n\n    // Capture canvas stream if recording is successful and whiteboard is active\n    try {\n      if (\n        recAttempt &&\n        whiteboardStarted &&\n        !whiteboardEnded &&\n        recordingMediaOptions === 'video'\n      ) {\n        captureCanvasStream({ parameters });\n      }\n    } catch (error) {\n      console.log('Error capturing canvas stream:', error);\n    }\n\n    // Set isRecordingModalVisible to false\n    updateIsRecordingModalVisible(false);\n\n    return recAttempt;\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"start-recording.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/methods/recording-methods/start-recording.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { RecordStartTimer } from './record-start-timer.service';\nimport { RecordResumeTimer, RecordResumeTimerParameters } from './record-resume-timer.service';\n\nimport { Socket } from 'socket.io-client';\nimport {\n  RePortType,\n  UserRecordingParams,\n  CaptureCanvasStreamType,\n  CaptureCanvasStreamParameters,\n  RePortParameters,\n  ShowAlert,\n} from '../../@types/types';\n\nexport interface StartRecordingParameters\n  extends CaptureCanvasStreamParameters,\n    RePortParameters,\n    RecordResumeTimerParameters {\n  roomName: string;\n  userRecordingParams: UserRecordingParams;\n  socket: Socket;\n  updateIsRecordingModalVisible: (visible: boolean) => void;\n  confirmedToRecord: boolean;\n  showAlert?: ShowAlert;\n  recordingMediaOptions: string;\n  videoAlreadyOn: boolean;\n  audioAlreadyOn: boolean;\n  recordStarted: boolean;\n  recordPaused: boolean;\n  recordResumed: boolean;\n  recordStopped: boolean;\n  startReport: boolean;\n  endReport: boolean;\n  canRecord: boolean;\n  updateClearedToRecord: (cleared: boolean) => void;\n  updateRecordStarted: (started: boolean) => void;\n  updateRecordPaused: (paused: boolean) => void;\n  updateRecordResumed: (resumed: boolean) => void;\n  updateStartReport: (started: boolean) => void;\n  updateEndReport: (ended: boolean) => void;\n  updateCanRecord: (canRecord: boolean) => void;\n  whiteboardStarted: boolean;\n  whiteboardEnded: boolean;\n\n  // Mediasfu functions\n  rePort: RePortType;\n  captureCanvasStream: CaptureCanvasStreamType;\n\n  getUpdatedAllParams: () => StartRecordingParameters;\n  [key: string]: any;\n}\n\nexport interface StartRecordingOptions {\n  parameters: StartRecordingParameters;\n}\n\n// Export the type definition for the function\nexport type StartRecordingType = (options: StartRecordingOptions) => Promise<boolean | undefined>;\n\n/**\n * Starts the recording process based on the provided parameters.\n *\n * @param {StartRecordingOptions} options - The options for starting the recording.\n * @param {object} options.parameters - The parameters required for starting the recording.\n * @param {string} options.parameters.roomName - The name of the room where recording is to be started.\n * @param {object} options.parameters.userRecordingParams - User-specific recording parameters.\n * @param {object} options.parameters.socket - The socket instance for communication.\n * @param {function} options.parameters.updateIsRecordingModalVisible - Function to update the visibility of the recording modal.\n * @param {boolean} options.parameters.confirmedToRecord - Flag indicating if the user has confirmed to record.\n * @param {function} options.parameters.showAlert - Function to show alerts.\n * @param {string} options.parameters.recordingMediaOptions - The media options for recording (e.g., \"video\", \"audio\").\n * @param {boolean} options.parameters.videoAlreadyOn - Flag indicating if the video is already on.\n * @param {boolean} options.parameters.audioAlreadyOn - Flag indicating if the audio is already on.\n * @param {boolean} options.parameters.recordStarted - Flag indicating if the recording has started.\n * @param {boolean} options.parameters.recordPaused - Flag indicating if the recording is paused.\n * @param {boolean} options.parameters.recordResumed - Flag indicating if the recording is resumed.\n * @param {boolean} options.parameters.recordStopped - Flag indicating if the recording is stopped.\n * @param {boolean} options.parameters.startReport - Flag indicating if the start report is active.\n * @param {boolean} options.parameters.endReport - Flag indicating if the end report is active.\n * @param {boolean} options.parameters.canRecord - Flag indicating if recording is allowed.\n * @param {function} options.parameters.updateClearedToRecord - Function to update the cleared to record status.\n * @param {function} options.parameters.updateRecordStarted - Function to update the record started status.\n * @param {function} options.parameters.updateRecordPaused - Function to update the record paused status.\n * @param {function} options.parameters.updateRecordResumed - Function to update the record resumed status.\n * @param {function} options.parameters.updateStartReport - Function to update the start report status.\n * @param {function} options.parameters.updateEndReport - Function to update the end report status.\n * @param {function} options.parameters.updateCanRecord - Function to update the can record status.\n * @param {boolean} options.parameters.whiteboardStarted - Flag indicating if the whiteboard has started.\n * @param {boolean} options.parameters.whiteboardEnded - Flag indicating if the whiteboard has ended.\n * @param {function} options.parameters.rePort - Function to report the recording status.\n * @param {function} options.parameters.captureCanvasStream - Function to capture the canvas stream.\n *\n * @returns {Promise<boolean | undefined>} - A promise that resolves to a boolean indicating if the recording attempt was successful, or undefined if not applicable.\n *\n * @remarks\n * This method checks various conditions, such as whether the user has confirmed recording and whether audio or video is already on,\n * before starting the recording. It updates the recording state, manages socket communication, and handles whiteboard functionality if applicable.\n *\n * @example\n * ```typescript\n * const options: StartRecordingOptions = { parameters: someParameters };\n * const result = await startRecording(options);\n * if (result) {\n *   console.log('Recording started successfully.');\n * } else {\n *   console.log('Failed to start recording.');\n * }\n * ```\n */\n\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class StartRecording {\n  constructor(\n    private RecordStartTimerService: RecordStartTimer,\n    private RecordResumeTimerService: RecordResumeTimer,\n  ) {}\n\n  /**\n   * Starts the recording process based on the provided parameters.\n   *\n   * @param {StartRecordingOptions} options - The options for starting the recording.\n   * @param {object} options.parameters - The parameters required for starting the recording.\n   * @param {string} options.parameters.roomName - The name of the room where recording is to be started.\n   * @param {object} options.parameters.userRecordingParams - User-specific recording parameters.\n   * @param {object} options.parameters.socket - The socket instance for communication.\n   * @param {function} options.parameters.updateIsRecordingModalVisible - Function to update the visibility of the recording modal.\n   * @param {boolean} options.parameters.confirmedToRecord - Flag indicating if the user has confirmed to record.\n   * @param {function} options.parameters.showAlert - Function to show alerts.\n   * @param {string} options.parameters.recordingMediaOptions - The media options for recording (e.g., \"video\", \"audio\").\n   * @param {boolean} options.parameters.videoAlreadyOn - Flag indicating if the video is already on.\n   * @param {boolean} options.parameters.audioAlreadyOn - Flag indicating if the audio is already on.\n   * @param {boolean} options.parameters.recordStarted - Flag indicating if the recording has started.\n   * @param {boolean} options.parameters.recordPaused - Flag indicating if the recording is paused.\n   * @param {boolean} options.parameters.recordResumed - Flag indicating if the recording is resumed.\n   * @param {boolean} options.parameters.recordStopped - Flag indicating if the recording is stopped.\n   * @param {boolean} options.parameters.startReport - Flag indicating if the start report is active.\n   * @param {boolean} options.parameters.endReport - Flag indicating if the end report is active.\n   * @param {boolean} options.parameters.canRecord - Flag indicating if recording is allowed.\n   * @param {function} options.parameters.updateClearedToRecord - Function to update the cleared to record status.\n   * @param {function} options.parameters.updateRecordStarted - Function to update the record started status.\n   * @param {function} options.parameters.updateRecordPaused - Function to update the record paused status.\n   * @param {function} options.parameters.updateRecordResumed - Function to update the record resumed status.\n   * @param {function} options.parameters.updateStartReport - Function to update the start report status.\n   * @param {function} options.parameters.updateEndReport - Function to update the end report status.\n   * @param {function} options.parameters.updateCanRecord - Function to update the can record status.\n   * @param {boolean} options.parameters.whiteboardStarted - Flag indicating if the whiteboard has started.\n   * @param {boolean} options.parameters.whiteboardEnded - Flag indicating if the whiteboard has ended.\n   * @param {function} options.parameters.rePort - Function to report the recording status.\n   * @param {function} options.parameters.captureCanvasStream - Function to capture the canvas stream.\n   *\n   * @returns {Promise<boolean | undefined>} - A promise that resolves to a boolean indicating if the recording attempt was successful, or undefined if not applicable.\n   */\n\n  startRecording = async ({ parameters }: StartRecordingOptions): Promise<boolean | undefined> => {\n    parameters = parameters.getUpdatedAllParams();\n\n    let {\n      roomName,\n      userRecordingParams,\n      socket,\n      updateIsRecordingModalVisible,\n      confirmedToRecord,\n      showAlert,\n      recordingMediaOptions,\n      videoAlreadyOn,\n      audioAlreadyOn,\n      recordStarted,\n      recordPaused,\n      recordResumed,\n      recordStopped,\n      startReport,\n      endReport,\n      canRecord,\n      updateClearedToRecord,\n      updateRecordStarted,\n      updateRecordPaused,\n      updateRecordResumed,\n      updateStartReport,\n      updateEndReport,\n      updateCanRecord,\n\n      whiteboardStarted,\n      whiteboardEnded,\n\n      //mediasfu functions\n      rePort,\n      captureCanvasStream,\n    } = parameters;\n\n    // Check if recording is confirmed before starting\n    if (!confirmedToRecord) {\n      showAlert?.({\n        message: 'You must click confirm before you can start recording',\n        type: 'danger',\n      });\n      return false;\n    }\n\n    // Check for recordingMediaOptions for video\n    if (recordingMediaOptions === 'video' && !videoAlreadyOn) {\n      showAlert?.({\n        message: 'You must turn on your video before you can start recording',\n        type: 'danger',\n      });\n      return false;\n    }\n\n    // Check for recordingMediaOptions for audio\n    if (recordingMediaOptions === 'audio' && !audioAlreadyOn) {\n      showAlert?.({\n        message: 'You must turn on your audio before you can start recording',\n        type: 'danger',\n      });\n      return false;\n    }\n\n    // Set clearedToRecord to true\n    updateClearedToRecord(true);\n\n    let action = 'startRecord';\n    if (recordStarted && recordPaused && !recordResumed && !recordStopped) {\n      action = 'resumeRecord';\n    } else {\n      action = 'startRecord';\n    }\n\n    let recAttempt = false;\n\n    await new Promise<void>((resolve) => {\n      socket.emit(\n        action,\n        { roomName, userRecordingParams },\n        async ({ success, reason }: { success: boolean; reason: string; recordState: any }) => {\n          if (success) {\n            recordStarted = true;\n            startReport = true;\n            endReport = false;\n            recordPaused = false;\n            recAttempt = true;\n\n            updateRecordStarted(recordStarted);\n            updateStartReport(startReport);\n            updateEndReport(endReport);\n            updateRecordPaused(recordPaused);\n\n            if (action === 'startRecord') {\n              await rePort({ parameters });\n              await this.RecordStartTimerService.recordStartTimer({ parameters });\n            } else {\n              recordResumed = true;\n              updateRecordResumed(recordResumed);\n              await rePort({ restart: true, parameters });\n              await this.RecordResumeTimerService.recordResumeTimer({ parameters });\n            }\n          } else {\n            showAlert?.({ message: `Recording could not start - ${reason}`, type: 'danger' });\n            canRecord = true;\n            startReport = false;\n            endReport = true;\n            recAttempt = false;\n\n            updateCanRecord(canRecord);\n            updateStartReport(startReport);\n            updateEndReport(endReport);\n          }\n\n          resolve();\n        },\n      );\n    });\n\n    // Capture canvas stream if recording is successful and whiteboard is active\n    try {\n      if (\n        recAttempt &&\n        whiteboardStarted &&\n        !whiteboardEnded &&\n        recordingMediaOptions === 'video'\n      ) {\n        captureCanvasStream({ parameters });\n      }\n    } catch (error) {\n      console.log('Error capturing canvas stream:', error);\n    }\n\n    // Set isRecordingModalVisible to false\n    updateIsRecordingModalVisible(false);\n\n    return recAttempt;\n  };\n}\n"]}

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

@@ -1,6 +1,44 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
 import * as i1 from "./record-pause-timer.service";
+/**
+ * Stops the recording process based on the provided parameters.
+ *
+ * @param {StopRecordingOptions} options - The options for stopping the recording.
+ * @param {Object} options.parameters - The parameters required for stopping the recording.
+ * @param {string} options.parameters.roomName - The name of the room where the recording is being stopped.
+ * @param {Socket} options.parameters.socket - The socket instance for communication.
+ * @param {Function} options.parameters.showAlert - Function to show alerts.
+ * @param {boolean} options.parameters.startReport - Flag indicating if the start report is active.
+ * @param {boolean} options.parameters.endReport - Flag indicating if the end report is active.
+ * @param {boolean} options.parameters.recordStarted - Flag indicating if the recording has started.
+ * @param {boolean} options.parameters.recordPaused - Flag indicating if the recording is paused.
+ * @param {boolean} options.parameters.recordStopped - Flag indicating if the recording is stopped.
+ * @param {Function} options.parameters.updateRecordPaused - Function to update the record paused status.
+ * @param {Function} options.parameters.updateRecordStopped - Function to update the record stopped status.
+ * @param {Function} options.parameters.updateStartReport - Function to update the start report status.
+ * @param {Function} options.parameters.updateEndReport - Function to update the end report status.
+ * @param {Function} options.parameters.updateShowRecordButtons - Function to update the visibility of recording buttons.
+ * @param {boolean} options.parameters.whiteboardStarted - Flag indicating if the whiteboard has started.
+ * @param {boolean} options.parameters.whiteboardEnded - Flag indicating if the whiteboard has ended.
+ * @param {string} options.parameters.recordingMediaOptions - The media options for recording (e.g., "video", "audio").
+ * @param {Function} options.parameters.captureCanvasStream - Function to capture the canvas stream.
+ *
+ * @returns {Promise<void>} - A promise that resolves when the recording is stopped.
+ *
+ * @remarks
+ * This method checks if the recording has started and is not already stopped.
+ * It pauses the timer and emits a stop recording event via socket communication.
+ * If successful, it updates the recording state and alerts the user.
+ * Additionally, if the whiteboard feature is active, it captures the canvas stream.
+ *
+ * @example
+ * ```typescript
+ * const options: StopRecordingOptions = { parameters: someParameters };
+ * await stopRecording(options);
+ * console.log('Recording stopped successfully.');
+ * ```
+ */
 export class StopRecording {
     RecordPauseTimerService;
     constructor(RecordPauseTimerService) {
@@ -71,4 +109,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }], ctorParameters: () => [{ type: i1.RecordPauseTimer }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stop-recording.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/methods/recording-methods/stop-recording.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;;AAsC3C,MAAM,OAAO,aAAa;IACJ;IAApB,YAAoB,uBAAyC;QAAzC,4BAAuB,GAAvB,uBAAuB,CAAkB;IAAG,CAAC;IAEjE,KAAK,CAAC,aAAa,CAAC,EAAE,UAAU,EAAwB;QACtD,IAAI,EACF,QAAQ,EACR,MAAM,EACN,SAAS,EACT,WAAW,EACX,SAAS,EACT,aAAa,EACb,YAAY,EACZ,aAAa,EACb,kBAAkB,EAClB,mBAAmB,EACnB,iBAAiB,EACjB,eAAe,EACf,uBAAuB,EAEvB,iBAAiB,EACjB,eAAe,EACf,qBAAqB;QAErB,oBAAoB;QACpB,mBAAmB,GACpB,GAAG,UAAU,CAAC;QAEf,IAAI,UAAU,CAAC;QAEf,IAAI,aAAa,IAAI,CAAC,aAAa,EAAE,CAAC;YACpC,IAAI,IAAI,GAAG,MAAM,IAAI,CAAC,uBAAuB,CAAC,gBAAgB,CAAC;gBAC7D,IAAI,EAAE,IAAI;gBACV,cAAc,EAAE,UAAU,CAAC,gBAAgB,CAAC;gBAC5C,cAAc,EAAE,UAAU,CAAC,gBAAgB,CAAC;gBAC5C,SAAS,EAAE,UAAU,CAAC,SAAS;aAChC,CAAC,CAAC;YAEH,IAAI,IAAI,EAAE,CAAC;gBACT,IAAI,MAAM,GAAG,YAAY,CAAC;gBAE1B,MAAM,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE;oBAClC,MAAM,CAAC,IAAI,CACT,MAAM,EACN,EAAE,QAAQ,EAAE,EACZ,CAAC,EACC,OAAO,EACP,MAAM,EACN,WAAW,GAKZ,EAAE,EAAE;wBACH,IAAI,OAAO,EAAE,CAAC;4BACZ,WAAW,GAAG,KAAK,CAAC;4BACpB,SAAS,GAAG,IAAI,CAAC;4BACjB,YAAY,GAAG,KAAK,CAAC;4BACrB,aAAa,GAAG,IAAI,CAAC;4BACrB,UAAU,GAAG,IAAI,CAAC;4BAElB,iBAAiB,CAAC,WAAW,CAAC,CAAC;4BAC/B,eAAe,CAAC,SAAS,CAAC,CAAC;4BAC3B,kBAAkB,CAAC,YAAY,CAAC,CAAC;4BACjC,mBAAmB,CAAC,aAAa,CAAC,CAAC;4BACnC,SAAS,EAAE,CAAC,EAAE,OAAO,EAAE,mBAAmB,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC,CAAC;4BAC/D,uBAAuB,CAAC,KAAK,CAAC,CAAC;wBACjC,CAAC;6BAAM,CAAC;4BACN,IAAI,aAAa,GAAG,0BAA0B,MAAM,gCAAgC,WAAW,EAAE,CAAC;4BAClG,SAAS,EAAE,CAAC,EAAE,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;4BACxD,UAAU,GAAG,KAAK,CAAC;wBACrB,CAAC;wBAED,OAAO,EAAE,CAAC;oBACZ,CAAC,CACF,CAAC;gBACJ,CAAC,CAAC,CAAC;gBAEH,IAAI,CAAC;oBACH,IAAI,UAAU,IAAI,iBAAiB,IAAI,CAAC,eAAe,EAAE,CAAC;wBACxD,IAAI,qBAAqB,KAAK,OAAO,EAAE,CAAC;4BACtC,mBAAmB,CAAC,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC;wBACpD,CAAC;oBACH,CAAC;gBACH,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,OAAO,CAAC,GAAG,CAAC,gCAAgC,EAAE,KAAK,CAAC,CAAC;gBACvD,CAAC;YACH,CAAC;iBAAM,CAAC;gBACN,OAAO;YACT,CAAC;QACH,CAAC;aAAM,CAAC;YACN,SAAS,EAAE,CAAC,EAAE,OAAO,EAAE,iDAAiD,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;QAC9F,CAAC;IACH,CAAC;uGA5FU,aAAa;2GAAb,aAAa,cAFZ,MAAM;;2FAEP,aAAa;kBAHzB,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { RecordPauseTimer } from './record-pause-timer.service';\nimport { ShowAlert } from '../../@types/types';\n\nexport interface StopRecordingParameters {\n  roomName: string;\n  socket: any;\n  showAlert?: ShowAlert;\n  startReport: boolean;\n  endReport: boolean;\n  recordStarted: boolean;\n  recordPaused: boolean;\n  recordStopped: boolean;\n  updateRecordPaused: (paused: boolean) => void;\n  updateRecordStopped: (stopped: boolean) => void;\n  updateStartReport: (startReport: boolean) => void;\n  updateEndReport: (endReport: boolean) => void;\n  updateShowRecordButtons: (show: boolean) => void;\n  whiteboardStarted: boolean;\n  whiteboardEnded: boolean;\n  recordingMediaOptions: string;\n\n  // mediasfu functions\n  captureCanvasStream: (options: { parameters: any; start?: boolean }) => void;\n\n  [key: string]: any;\n}\n\nexport interface StopRecordingOptions {\n  parameters: StopRecordingParameters;\n}\n\n// Export the type definition for the function\nexport type StopRecordingType = (options: StopRecordingOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class StopRecording {\n  constructor(private RecordPauseTimerService: RecordPauseTimer) {}\n\n  async stopRecording({ parameters }: StopRecordingOptions): Promise<void> {\n    let {\n      roomName,\n      socket,\n      showAlert,\n      startReport,\n      endReport,\n      recordStarted,\n      recordPaused,\n      recordStopped,\n      updateRecordPaused,\n      updateRecordStopped,\n      updateStartReport,\n      updateEndReport,\n      updateShowRecordButtons,\n\n      whiteboardStarted,\n      whiteboardEnded,\n      recordingMediaOptions,\n\n      //mediasfu functions\n      captureCanvasStream,\n    } = parameters;\n\n    let recAttempt;\n\n    if (recordStarted && !recordStopped) {\n      let stop = await this.RecordPauseTimerService.recordPauseTimer({\n        stop: true,\n        isTimerRunning: parameters['isTimerRunning'],\n        canPauseResume: parameters['canPauseResume'],\n        showAlert: parameters.showAlert,\n      });\n\n      if (stop) {\n        let action = 'stopRecord';\n\n        await new Promise<void>((resolve) => {\n          socket.emit(\n            action,\n            { roomName },\n            ({\n              success,\n              reason,\n              recordState,\n            }: {\n              success: boolean;\n              reason: string;\n              recordState: string;\n            }) => {\n              if (success) {\n                startReport = false;\n                endReport = true;\n                recordPaused = false;\n                recordStopped = true;\n                recAttempt = true;\n\n                updateStartReport(startReport);\n                updateEndReport(endReport);\n                updateRecordPaused(recordPaused);\n                updateRecordStopped(recordStopped);\n                showAlert?.({ message: 'Recording Stopped', type: 'success' });\n                updateShowRecordButtons(false);\n              } else {\n                let reasonMessage = `Recording Stop Failed: ${reason}; the recording is currently ${recordState}`;\n                showAlert?.({ message: reasonMessage, type: 'danger' });\n                recAttempt = false;\n              }\n\n              resolve();\n            },\n          );\n        });\n\n        try {\n          if (recAttempt && whiteboardStarted && !whiteboardEnded) {\n            if (recordingMediaOptions === 'video') {\n              captureCanvasStream({ parameters, start: false });\n            }\n          }\n        } catch (error) {\n          console.log('Error capturing canvas stream:', error);\n        }\n      } else {\n        return;\n      }\n    } else {\n      showAlert?.({ message: 'Recording is not started yet or already stopped', type: 'danger' });\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stop-recording.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/methods/recording-methods/stop-recording.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { RecordPauseTimer } from './record-pause-timer.service';\nimport { ShowAlert } from '../../@types/types';\n\nexport interface StopRecordingParameters {\n  roomName: string;\n  socket: any;\n  showAlert?: ShowAlert;\n  startReport: boolean;\n  endReport: boolean;\n  recordStarted: boolean;\n  recordPaused: boolean;\n  recordStopped: boolean;\n  updateRecordPaused: (paused: boolean) => void;\n  updateRecordStopped: (stopped: boolean) => void;\n  updateStartReport: (startReport: boolean) => void;\n  updateEndReport: (endReport: boolean) => void;\n  updateShowRecordButtons: (show: boolean) => void;\n  whiteboardStarted: boolean;\n  whiteboardEnded: boolean;\n  recordingMediaOptions: string;\n\n  // mediasfu functions\n  captureCanvasStream: (options: { parameters: any; start?: boolean }) => void;\n\n  [key: string]: any;\n}\n\nexport interface StopRecordingOptions {\n  parameters: StopRecordingParameters;\n}\n\n// Export the type definition for the function\nexport type StopRecordingType = (options: StopRecordingOptions) => Promise<void>;\n\n/**\n * Stops the recording process based on the provided parameters.\n *\n * @param {StopRecordingOptions} options - The options for stopping the recording.\n * @param {Object} options.parameters - The parameters required for stopping the recording.\n * @param {string} options.parameters.roomName - The name of the room where the recording is being stopped.\n * @param {Socket} options.parameters.socket - The socket instance for communication.\n * @param {Function} options.parameters.showAlert - Function to show alerts.\n * @param {boolean} options.parameters.startReport - Flag indicating if the start report is active.\n * @param {boolean} options.parameters.endReport - Flag indicating if the end report is active.\n * @param {boolean} options.parameters.recordStarted - Flag indicating if the recording has started.\n * @param {boolean} options.parameters.recordPaused - Flag indicating if the recording is paused.\n * @param {boolean} options.parameters.recordStopped - Flag indicating if the recording is stopped.\n * @param {Function} options.parameters.updateRecordPaused - Function to update the record paused status.\n * @param {Function} options.parameters.updateRecordStopped - Function to update the record stopped status.\n * @param {Function} options.parameters.updateStartReport - Function to update the start report status.\n * @param {Function} options.parameters.updateEndReport - Function to update the end report status.\n * @param {Function} options.parameters.updateShowRecordButtons - Function to update the visibility of recording buttons.\n * @param {boolean} options.parameters.whiteboardStarted - Flag indicating if the whiteboard has started.\n * @param {boolean} options.parameters.whiteboardEnded - Flag indicating if the whiteboard has ended.\n * @param {string} options.parameters.recordingMediaOptions - The media options for recording (e.g., \"video\", \"audio\").\n * @param {Function} options.parameters.captureCanvasStream - Function to capture the canvas stream.\n *\n * @returns {Promise<void>} - A promise that resolves when the recording is stopped.\n *\n * @remarks\n * This method checks if the recording has started and is not already stopped.\n * It pauses the timer and emits a stop recording event via socket communication.\n * If successful, it updates the recording state and alerts the user.\n * Additionally, if the whiteboard feature is active, it captures the canvas stream.\n *\n * @example\n * ```typescript\n * const options: StopRecordingOptions = { parameters: someParameters };\n * await stopRecording(options);\n * console.log('Recording stopped successfully.');\n * ```\n */\n\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class StopRecording {\n  constructor(private RecordPauseTimerService: RecordPauseTimer) {}\n\n  async stopRecording({ parameters }: StopRecordingOptions): Promise<void> {\n    let {\n      roomName,\n      socket,\n      showAlert,\n      startReport,\n      endReport,\n      recordStarted,\n      recordPaused,\n      recordStopped,\n      updateRecordPaused,\n      updateRecordStopped,\n      updateStartReport,\n      updateEndReport,\n      updateShowRecordButtons,\n\n      whiteboardStarted,\n      whiteboardEnded,\n      recordingMediaOptions,\n\n      //mediasfu functions\n      captureCanvasStream,\n    } = parameters;\n\n    let recAttempt;\n\n    if (recordStarted && !recordStopped) {\n      let stop = await this.RecordPauseTimerService.recordPauseTimer({\n        stop: true,\n        isTimerRunning: parameters['isTimerRunning'],\n        canPauseResume: parameters['canPauseResume'],\n        showAlert: parameters.showAlert,\n      });\n\n      if (stop) {\n        let action = 'stopRecord';\n\n        await new Promise<void>((resolve) => {\n          socket.emit(\n            action,\n            { roomName },\n            ({\n              success,\n              reason,\n              recordState,\n            }: {\n              success: boolean;\n              reason: string;\n              recordState: string;\n            }) => {\n              if (success) {\n                startReport = false;\n                endReport = true;\n                recordPaused = false;\n                recordStopped = true;\n                recAttempt = true;\n\n                updateStartReport(startReport);\n                updateEndReport(endReport);\n                updateRecordPaused(recordPaused);\n                updateRecordStopped(recordStopped);\n                showAlert?.({ message: 'Recording Stopped', type: 'success' });\n                updateShowRecordButtons(false);\n              } else {\n                let reasonMessage = `Recording Stop Failed: ${reason}; the recording is currently ${recordState}`;\n                showAlert?.({ message: reasonMessage, type: 'danger' });\n                recAttempt = false;\n              }\n\n              resolve();\n            },\n          );\n        });\n\n        try {\n          if (recAttempt && whiteboardStarted && !whiteboardEnded) {\n            if (recordingMediaOptions === 'video') {\n              captureCanvasStream({ parameters, start: false });\n            }\n          }\n        } catch (error) {\n          console.log('Error capturing canvas stream:', error);\n        }\n      } else {\n        return;\n      }\n    } else {\n      showAlert?.({ message: 'Recording is not started yet or already stopped', type: 'danger' });\n    }\n  }\n}\n"]}