mediasfu-angular 1.0.0 → 1.0.2

package/dist/esm2022/lib/methods/co-host-methods/modify-co-host-settings.service.mjs

@@ -1,6 +1,50 @@
 // This method is used to modify the co-host settings in the chat room.
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Modifies the co-host settings for a given room.
+ *
+ * This method allows you to update the co-host for a chat room, set their responsibilities,
+ * and emit the relevant changes to the server. It also handles demo mode restrictions.
+ *
+ * @param {ModifyCoHostSettingsOptions} options - The options for modifying co-host settings.
+ * @param {string} options.roomName - The name of the room.
+ * @param {Function} options.showAlert - Function to show an alert message.
+ * @param {string} options.selectedParticipant - The participant selected to be co-host.
+ * @param {string} options.coHost - The current co-host.
+ * @param {Array<CoHostResponsibility>} options.coHostResponsibility - The responsibilities assigned to the co-host.
+ * @param {Function} options.updateIsCoHostModalVisible - Function to update the visibility of the co-host modal.
+ * @param {Function} options.updateCoHostResponsibility - Function to update the co-host responsibility.
+ * @param {Function} options.updateCoHost - Function to update the co-host.
+ * @param {Socket} options.socket - The socket instance for emitting events.
+ *
+ * @returns {Promise<void>} A promise that resolves when the co-host settings have been modified.
+ *
+ * @remarks
+ * - If the room is in demo mode (room name starts with "d"), co-host cannot be added and an alert is shown.
+ * - If a valid participant is selected, they are set as the new co-host.
+ * - The co-host responsibility is updated.
+ * - A socket event is emitted to update the co-host information.
+ * - The co-host modal is closed after updating the settings.
+ *
+ * @example
+ * ```typescript
+ * const options: ModifyCoHostSettingsOptions = {
+ *   roomName: 'mainRoom',
+ *   showAlert: (alert) => console.log(alert.message),
+ *   selectedParticipant: 'JohnDoe',
+ *   coHost: 'No coHost',
+ *   coHostResponsibility: ['manage participants', 'start/stop recording'],
+ *   updateIsCoHostModalVisible: (isVisible) => console.log('Co-host modal visible:', isVisible),
+ *   updateCoHostResponsibility: (responsibility) => console.log('Updated co-host responsibility:', responsibility),
+ *   updateCoHost: (coHost) => console.log('New co-host:', coHost),
+ *   socket: socketInstance,
+ * };
+ *
+ * const modifyCoHostService = new ModifyCoHostSettings();
+ * await modifyCoHostService.modifyCoHostSettings(options);
+ * ```
+ */
 export class ModifyCoHostSettings {
     /**
      * Modifies the co-host settings for a given room.
@@ -57,4 +101,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":"modify-co-host-settings.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/methods/co-host-methods/modify-co-host-settings.service.ts"],"names":[],"mappings":"AAAA,uEAAuE;AAEvE,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAmB3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAMH,MAAM,OAAO,oBAAoB;IAC/B;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,KAAK,CAAC,oBAAoB,CAAC,EACzB,QAAQ,EACR,SAAS,EACT,mBAAmB,EACnB,MAAM,EACN,oBAAoB,EACpB,0BAA0B,EAC1B,0BAA0B,EAC1B,YAAY,EACZ,MAAM,GACsB;QAC5B,yCAAyC;QACzC,IAAI,QAAQ,CAAC,WAAW,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;YAC3C,SAAS,EAAE,CAAC;gBACV,OAAO,EAAE,sCAAsC;gBAC/C,IAAI,EAAE,QAAQ;gBACd,QAAQ,EAAE,IAAI;aACf,CAAC,CAAC;YAEH,OAAO;QACT,CAAC;QAED,IAAI,SAAS,GAAG,MAAM,CAAC;QAEvB,IACE,MAAM,IAAI,WAAW;YACrB,CAAC,mBAAmB,IAAI,mBAAmB,IAAI,sBAAsB,CAAC,EACtE,CAAC;YACD,IAAI,mBAAmB,IAAI,mBAAmB,IAAI,sBAAsB,EAAE,CAAC;gBACzE,SAAS,GAAG,mBAAmB,CAAC;gBAChC,YAAY,CAAC,SAAS,CAAC,CAAC;YAC1B,CAAC;YAED,0BAA0B,CAAC,oBAAoB,CAAC,CAAC;YAEjD,oDAAoD;YACpD,MAAM,CAAC,IAAI,CAAC,cAAc,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,oBAAoB,EAAE,CAAC,CAAC;QACrF,CAAC;QAED,0BAA0B;QAC1B,0BAA0B,CAAC,KAAK,CAAC,CAAC;IACpC,CAAC;uGAhEU,oBAAoB;2GAApB,oBAAoB,cAFnB,MAAM;;2FAEP,oBAAoB;kBAHhC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["// This method is used to modify the co-host settings in the chat room.\n\nimport { Injectable } from '@angular/core';\nimport { ShowAlert, CoHostResponsibility } from '../../@types/types';\nimport { Socket } from 'socket.io-client';\n\nexport interface ModifyCoHostSettingsOptions {\n  roomName: string;\n  showAlert?: ShowAlert;\n  selectedParticipant: string;\n  coHost: string;\n  coHostResponsibility: CoHostResponsibility[];\n  updateIsCoHostModalVisible: (isVisible: boolean) => void;\n  updateCoHostResponsibility: (coHostResponsibility: CoHostResponsibility[]) => void;\n  updateCoHost: (coHost: string) => void;\n  socket: Socket;\n}\n\n// Export the type definition for the function\nexport type ModifyCoHostSettingsType = (options: ModifyCoHostSettingsOptions) => Promise<void>;\n\n/**\n * Modifies the co-host settings for a given room.\n *\n * This method allows you to update the co-host for a chat room, set their responsibilities,\n * and emit the relevant changes to the server. It also handles demo mode restrictions.\n *\n * @param {ModifyCoHostSettingsOptions} options - The options for modifying co-host settings.\n * @param {string} options.roomName - The name of the room.\n * @param {Function} options.showAlert - Function to show an alert message.\n * @param {string} options.selectedParticipant - The participant selected to be co-host.\n * @param {string} options.coHost - The current co-host.\n * @param {Array<CoHostResponsibility>} options.coHostResponsibility - The responsibilities assigned to the co-host.\n * @param {Function} options.updateIsCoHostModalVisible - Function to update the visibility of the co-host modal.\n * @param {Function} options.updateCoHostResponsibility - Function to update the co-host responsibility.\n * @param {Function} options.updateCoHost - Function to update the co-host.\n * @param {Socket} options.socket - The socket instance for emitting events.\n *\n * @returns {Promise<void>} A promise that resolves when the co-host settings have been modified.\n *\n * @remarks\n * - If the room is in demo mode (room name starts with \"d\"), co-host cannot be added and an alert is shown.\n * - If a valid participant is selected, they are set as the new co-host.\n * - The co-host responsibility is updated.\n * - A socket event is emitted to update the co-host information.\n * - The co-host modal is closed after updating the settings.\n *\n * @example\n * ```typescript\n * const options: ModifyCoHostSettingsOptions = {\n *   roomName: 'mainRoom',\n *   showAlert: (alert) => console.log(alert.message),\n *   selectedParticipant: 'JohnDoe',\n *   coHost: 'No coHost',\n *   coHostResponsibility: ['manage participants', 'start/stop recording'],\n *   updateIsCoHostModalVisible: (isVisible) => console.log('Co-host modal visible:', isVisible),\n *   updateCoHostResponsibility: (responsibility) => console.log('Updated co-host responsibility:', responsibility),\n *   updateCoHost: (coHost) => console.log('New co-host:', coHost),\n *   socket: socketInstance,\n * };\n *\n * const modifyCoHostService = new ModifyCoHostSettings();\n * await modifyCoHostService.modifyCoHostSettings(options);\n * ```\n */\n\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ModifyCoHostSettings {\n  /**\n   * Modifies the co-host settings for a given room.\n   *\n   * @param {Object} options - The options for modifying co-host settings.\n   * @param {string} options.roomName - The name of the room.\n   * @param {Function} options.showAlert - Function to show an alert message.\n   * @param {string} options.selectedParticipant - The participant selected to be co-host.\n   * @param {string} options.coHost - The current co-host.\n   * @param {string} options.coHostResponsibility - The responsibility assigned to the co-host.\n   * @param {Function} options.updateIsCoHostModalVisible - Function to update the visibility of the co-host modal.\n   * @param {Function} options.updateCoHostResponsibility - Function to update the co-host responsibility.\n   * @param {Function} options.updateCoHost - Function to update the co-host.\n   * @param {Object} options.socket - The socket instance for emitting events.\n   * @returns {Promise<void>} A promise that resolves when the co-host settings have been modified.\n   *\n   * @remarks\n   * - If the room is in demo mode (room name starts with \"d\"), co-host cannot be added and an alert is shown.\n   * - If a valid participant is selected, they are set as the new co-host.\n   * - The co-host responsibility is updated.\n   * - A socket event is emitted to update the co-host information.\n   * - The co-host modal is closed after updating the settings.\n   */\n  async modifyCoHostSettings({\n    roomName,\n    showAlert,\n    selectedParticipant,\n    coHost,\n    coHostResponsibility,\n    updateIsCoHostModalVisible,\n    updateCoHostResponsibility,\n    updateCoHost,\n    socket,\n  }: ModifyCoHostSettingsOptions): Promise<void> {\n    // Check if the chat room is in demo mode\n    if (roomName.toLowerCase().startsWith('d')) {\n      showAlert?.({\n        message: 'You cannot add co-host in demo mode.',\n        type: 'danger',\n        duration: 3000,\n      });\n\n      return;\n    }\n\n    let newCoHost = coHost;\n\n    if (\n      coHost != 'No coHost' ||\n      (selectedParticipant && selectedParticipant != 'Select a participant')\n    ) {\n      if (selectedParticipant && selectedParticipant != 'Select a participant') {\n        newCoHost = selectedParticipant;\n        updateCoHost(newCoHost);\n      }\n\n      updateCoHostResponsibility(coHostResponsibility);\n\n      // Emit a socket event to update co-host information\n      socket.emit('updateCoHost', { roomName, coHost: newCoHost, coHostResponsibility });\n    }\n\n    // Close the co-host modal\n    updateIsCoHostModalVisible(false);\n  }\n}\n"]}

package/dist/esm2022/lib/methods/display-settings-methods/launch-display-settings.service.mjs

@@ -1,6 +1,28 @@
 // display-settings.service.ts
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Toggles the visibility of the display settings modal.
+ *
+ * This method allows you to show or hide the display settings modal by updating its visibility state.
+ *
+ * @param {LaunchDisplaySettingsOptions} options - The options for launching the display settings.
+ * @param {Function} options.updateIsDisplaySettingsModalVisible - Function to update the visibility state of the display settings modal.
+ * @param {boolean} options.isDisplaySettingsModalVisible - Current visibility state of the display settings modal.
+ *
+ * @returns {void}
+ *
+ * @example
+ * ```typescript
+ * const options: LaunchDisplaySettingsOptions = {
+ *   updateIsDisplaySettingsModalVisible: (isVisible) => console.log('Display settings modal is now:', isVisible),
+ *   isDisplaySettingsModalVisible: false,
+ * };
+ *
+ * const launchDisplaySettingsService = new LaunchDisplaySettings();
+ * launchDisplaySettingsService.launchDisplaySettings(options);
+ * ```
+ */
 export class LaunchDisplaySettings {
     /**
      * Toggles the visibility of the display settings modal.
@@ -21,4 +43,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGF1bmNoLWRpc3BsYXktc2V0dGluZ3Muc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL21lZGlhc2Z1LWFuZ3VsYXIvc3JjL2xpYi9tZXRob2RzL2Rpc3BsYXktc2V0dGluZ3MtbWV0aG9kcy9sYXVuY2gtZGlzcGxheS1zZXR0aW5ncy5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDhCQUE4QjtBQUM5QixPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQWEzQyxNQUFNLE9BQU8scUJBQXFCO0lBQ2hDOzs7OztPQUtHO0lBRUgscUJBQXFCLENBQUMsRUFDcEIsbUNBQW1DLEVBQ25DLDZCQUE2QixHQUNBO1FBQzdCLHVEQUF1RDtRQUN2RCxtQ0FBbUMsQ0FBQyxDQUFDLDZCQUE2QixDQUFDLENBQUM7SUFDdEUsQ0FBQzt1R0FkVSxxQkFBcUI7MkdBQXJCLHFCQUFxQixjQUZwQixNQUFNOzsyRkFFUCxxQkFBcUI7a0JBSGpDLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiLy8gZGlzcGxheS1zZXR0aW5ncy5zZXJ2aWNlLnRzXG5pbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgTGF1bmNoRGlzcGxheVNldHRpbmdzT3B0aW9ucyB7XG4gIHVwZGF0ZUlzRGlzcGxheVNldHRpbmdzTW9kYWxWaXNpYmxlOiAoaXNWaXNpYmxlOiBib29sZWFuKSA9PiB2b2lkO1xuICBpc0Rpc3BsYXlTZXR0aW5nc01vZGFsVmlzaWJsZTogYm9vbGVhbjtcbn1cblxuLy8gRXhwb3J0IHRoZSB0eXBlIGRlZmluaXRpb24gZm9yIHRoZSBmdW5jdGlvblxuZXhwb3J0IHR5cGUgTGF1bmNoRGlzcGxheVNldHRpbmdzVHlwZSA9IChvcHRpb25zOiBMYXVuY2hEaXNwbGF5U2V0dGluZ3NPcHRpb25zKSA9PiB2b2lkO1xuXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290Jyxcbn0pXG5leHBvcnQgY2xhc3MgTGF1bmNoRGlzcGxheVNldHRpbmdzIHtcbiAgLyoqXG4gICAqIFRvZ2dsZXMgdGhlIHZpc2liaWxpdHkgb2YgdGhlIGRpc3BsYXkgc2V0dGluZ3MgbW9kYWwuXG4gICAqXG4gICAqIEBwYXJhbSB1cGRhdGVJc0Rpc3BsYXlTZXR0aW5nc01vZGFsVmlzaWJsZSAtIEZ1bmN0aW9uIHRvIHVwZGF0ZSB0aGUgdmlzaWJpbGl0eSBzdGF0ZSBvZiB0aGUgZGlzcGxheSBzZXR0aW5ncyBtb2RhbC5cbiAgICogQHBhcmFtIGlzRGlzcGxheVNldHRpbmdzTW9kYWxWaXNpYmxlIC0gQ3VycmVudCB2aXNpYmlsaXR5IHN0YXRlIG9mIHRoZSBkaXNwbGF5IHNldHRpbmdzIG1vZGFsLlxuICAgKi9cblxuICBsYXVuY2hEaXNwbGF5U2V0dGluZ3Moe1xuICAgIHVwZGF0ZUlzRGlzcGxheVNldHRpbmdzTW9kYWxWaXNpYmxlLFxuICAgIGlzRGlzcGxheVNldHRpbmdzTW9kYWxWaXNpYmxlLFxuICB9OiBMYXVuY2hEaXNwbGF5U2V0dGluZ3NPcHRpb25zKTogdm9pZCB7XG4gICAgLy8gVG9nZ2xlIHRoZSB2aXNpYmlsaXR5IG9mIHRoZSBkaXNwbGF5IHNldHRpbmdzIG1vZGFsLlxuICAgIHVwZGF0ZUlzRGlzcGxheVNldHRpbmdzTW9kYWxWaXNpYmxlKCFpc0Rpc3BsYXlTZXR0aW5nc01vZGFsVmlzaWJsZSk7XG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGF1bmNoLWRpc3BsYXktc2V0dGluZ3Muc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL21lZGlhc2Z1LWFuZ3VsYXIvc3JjL2xpYi9tZXRob2RzL2Rpc3BsYXktc2V0dGluZ3MtbWV0aG9kcy9sYXVuY2gtZGlzcGxheS1zZXR0aW5ncy5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDhCQUE4QjtBQUM5QixPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQVUzQzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBcUJHO0FBS0gsTUFBTSxPQUFPLHFCQUFxQjtJQUNoQzs7Ozs7T0FLRztJQUVILHFCQUFxQixDQUFDLEVBQ3BCLG1DQUFtQyxFQUNuQyw2QkFBNkIsR0FDQTtRQUM3Qix1REFBdUQ7UUFDdkQsbUNBQW1DLENBQUMsQ0FBQyw2QkFBNkIsQ0FBQyxDQUFDO0lBQ3RFLENBQUM7dUdBZFUscUJBQXFCOzJHQUFyQixxQkFBcUIsY0FGcEIsTUFBTTs7MkZBRVAscUJBQXFCO2tCQUhqQyxVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbIi8vIGRpc3BsYXktc2V0dGluZ3Muc2VydmljZS50c1xuaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5leHBvcnQgaW50ZXJmYWNlIExhdW5jaERpc3BsYXlTZXR0aW5nc09wdGlvbnMge1xuICB1cGRhdGVJc0Rpc3BsYXlTZXR0aW5nc01vZGFsVmlzaWJsZTogKGlzVmlzaWJsZTogYm9vbGVhbikgPT4gdm9pZDtcbiAgaXNEaXNwbGF5U2V0dGluZ3NNb2RhbFZpc2libGU6IGJvb2xlYW47XG59XG5cbi8vIEV4cG9ydCB0aGUgdHlwZSBkZWZpbml0aW9uIGZvciB0aGUgZnVuY3Rpb25cbmV4cG9ydCB0eXBlIExhdW5jaERpc3BsYXlTZXR0aW5nc1R5cGUgPSAob3B0aW9uczogTGF1bmNoRGlzcGxheVNldHRpbmdzT3B0aW9ucykgPT4gdm9pZDtcblxuLyoqXG4gKiBUb2dnbGVzIHRoZSB2aXNpYmlsaXR5IG9mIHRoZSBkaXNwbGF5IHNldHRpbmdzIG1vZGFsLlxuICpcbiAqIFRoaXMgbWV0aG9kIGFsbG93cyB5b3UgdG8gc2hvdyBvciBoaWRlIHRoZSBkaXNwbGF5IHNldHRpbmdzIG1vZGFsIGJ5IHVwZGF0aW5nIGl0cyB2aXNpYmlsaXR5IHN0YXRlLlxuICpcbiAqIEBwYXJhbSB7TGF1bmNoRGlzcGxheVNldHRpbmdzT3B0aW9uc30gb3B0aW9ucyAtIFRoZSBvcHRpb25zIGZvciBsYXVuY2hpbmcgdGhlIGRpc3BsYXkgc2V0dGluZ3MuXG4gKiBAcGFyYW0ge0Z1bmN0aW9ufSBvcHRpb25zLnVwZGF0ZUlzRGlzcGxheVNldHRpbmdzTW9kYWxWaXNpYmxlIC0gRnVuY3Rpb24gdG8gdXBkYXRlIHRoZSB2aXNpYmlsaXR5IHN0YXRlIG9mIHRoZSBkaXNwbGF5IHNldHRpbmdzIG1vZGFsLlxuICogQHBhcmFtIHtib29sZWFufSBvcHRpb25zLmlzRGlzcGxheVNldHRpbmdzTW9kYWxWaXNpYmxlIC0gQ3VycmVudCB2aXNpYmlsaXR5IHN0YXRlIG9mIHRoZSBkaXNwbGF5IHNldHRpbmdzIG1vZGFsLlxuICpcbiAqIEByZXR1cm5zIHt2b2lkfVxuICpcbiAqIEBleGFtcGxlXG4gKiBgYGB0eXBlc2NyaXB0XG4gKiBjb25zdCBvcHRpb25zOiBMYXVuY2hEaXNwbGF5U2V0dGluZ3NPcHRpb25zID0ge1xuICogICB1cGRhdGVJc0Rpc3BsYXlTZXR0aW5nc01vZGFsVmlzaWJsZTogKGlzVmlzaWJsZSkgPT4gY29uc29sZS5sb2coJ0Rpc3BsYXkgc2V0dGluZ3MgbW9kYWwgaXMgbm93OicsIGlzVmlzaWJsZSksXG4gKiAgIGlzRGlzcGxheVNldHRpbmdzTW9kYWxWaXNpYmxlOiBmYWxzZSxcbiAqIH07XG4gKlxuICogY29uc3QgbGF1bmNoRGlzcGxheVNldHRpbmdzU2VydmljZSA9IG5ldyBMYXVuY2hEaXNwbGF5U2V0dGluZ3MoKTtcbiAqIGxhdW5jaERpc3BsYXlTZXR0aW5nc1NlcnZpY2UubGF1bmNoRGlzcGxheVNldHRpbmdzKG9wdGlvbnMpO1xuICogYGBgXG4gKi9cblxuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCcsXG59KVxuZXhwb3J0IGNsYXNzIExhdW5jaERpc3BsYXlTZXR0aW5ncyB7XG4gIC8qKlxuICAgKiBUb2dnbGVzIHRoZSB2aXNpYmlsaXR5IG9mIHRoZSBkaXNwbGF5IHNldHRpbmdzIG1vZGFsLlxuICAgKlxuICAgKiBAcGFyYW0gdXBkYXRlSXNEaXNwbGF5U2V0dGluZ3NNb2RhbFZpc2libGUgLSBGdW5jdGlvbiB0byB1cGRhdGUgdGhlIHZpc2liaWxpdHkgc3RhdGUgb2YgdGhlIGRpc3BsYXkgc2V0dGluZ3MgbW9kYWwuXG4gICAqIEBwYXJhbSBpc0Rpc3BsYXlTZXR0aW5nc01vZGFsVmlzaWJsZSAtIEN1cnJlbnQgdmlzaWJpbGl0eSBzdGF0ZSBvZiB0aGUgZGlzcGxheSBzZXR0aW5ncyBtb2RhbC5cbiAgICovXG5cbiAgbGF1bmNoRGlzcGxheVNldHRpbmdzKHtcbiAgICB1cGRhdGVJc0Rpc3BsYXlTZXR0aW5nc01vZGFsVmlzaWJsZSxcbiAgICBpc0Rpc3BsYXlTZXR0aW5nc01vZGFsVmlzaWJsZSxcbiAgfTogTGF1bmNoRGlzcGxheVNldHRpbmdzT3B0aW9ucyk6IHZvaWQge1xuICAgIC8vIFRvZ2dsZSB0aGUgdmlzaWJpbGl0eSBvZiB0aGUgZGlzcGxheSBzZXR0aW5ncyBtb2RhbC5cbiAgICB1cGRhdGVJc0Rpc3BsYXlTZXR0aW5nc01vZGFsVmlzaWJsZSghaXNEaXNwbGF5U2V0dGluZ3NNb2RhbFZpc2libGUpO1xuICB9XG59XG4iXX0=

package/dist/esm2022/lib/methods/display-settings-methods/modify-display-settings.service.mjs

@@ -1,5 +1,80 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Modifies the display settings based on the provided parameters.
+ *
+ * This method updates the display settings for the meeting based on the participant's level,
+ * recording status, and other conditions. It validates display types and shows alerts
+ * when necessary. It also handles the display settings for breakout rooms.
+ *
+ * @param {ModifyDisplaySettingsOptions} options - The options containing the parameters to modify the display settings.
+ * @param {Object} options.parameters - The parameters for modifying the display settings.
+ * @param {Function} options.parameters.showAlert - Function to show alert messages.
+ * @param {string} options.parameters.meetingDisplayType - The current meeting display type.
+ * @param {boolean} options.parameters.autoWave - Flag indicating if auto wave is enabled.
+ * @param {boolean} options.parameters.forceFullDisplay - Flag indicating if full display is forced.
+ * @param {boolean} options.parameters.meetingVideoOptimized - Flag indicating if the meeting video is optimized.
+ * @param {string} options.parameters.islevel - The current level of the meeting.
+ * @param {boolean} options.parameters.recordStarted - Flag indicating if recording has started.
+ * @param {boolean} options.parameters.recordResumed - Flag indicating if recording has resumed.
+ * @param {boolean} options.parameters.recordStopped - Flag indicating if recording has stopped.
+ * @param {boolean} options.parameters.recordPaused - Flag indicating if recording is paused.
+ * @param {string} options.parameters.recordingDisplayType - The current recording display type.
+ * @param {boolean} options.parameters.recordingVideoOptimized - Flag indicating if the recording video is optimized.
+ * @param {string} options.parameters.prevForceFullDisplay - The previous force full display value.
+ * @param {string} options.parameters.prevMeetingDisplayType - The previous meeting display type.
+ * @param {Function} options.parameters.updateMeetingDisplayType - Function to update the meeting display type.
+ * @param {Function} options.parameters.updateAutoWave - Function to update the auto wave setting.
+ * @param {Function} options.parameters.updateForceFullDisplay - Function to update the force full display setting.
+ * @param {Function} options.parameters.updateMeetingVideoOptimized - Function to update the meeting video optimization setting.
+ * @param {Function} options.parameters.updatePrevForceFullDisplay - Function to update the previous force full display setting.
+ * @param {Function} options.parameters.updatePrevMeetingDisplayType - Function to update the previous meeting display type.
+ * @param {Function} options.parameters.updateIsDisplaySettingsModalVisible - Function to update the visibility of the display settings modal.
+ * @param {Function} options.parameters.updateFirstAll - Function to update the first all setting.
+ * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window.
+ * @param {boolean} options.parameters.breakOutRoomStarted - Flag indicating if a breakout room has started.
+ * @param {boolean} options.parameters.breakOutRoomEnded - Flag indicating if a breakout room has ended.
+ * @param {Function} options.parameters.onScreenChanges - Function to handle screen changes.
+ *
+ * @returns {Promise<void>} A promise that resolves when the display settings have been modified.
+ *
+ * @example
+ * ```typescript
+ * const options: ModifyDisplaySettingsOptions = {
+ *   parameters: {
+ *     showAlert: (alert) => console.log(alert.message),
+ *     meetingDisplayType: 'video',
+ *     autoWave: true,
+ *     forceFullDisplay: false,
+ *     meetingVideoOptimized: true,
+ *     islevel: '1',
+ *     recordStarted: false,
+ *     recordResumed: false,
+ *     recordStopped: false,
+ *     recordPaused: false,
+ *     recordingDisplayType: 'media',
+ *     recordingVideoOptimized: false,
+ *     prevForceFullDisplay: false,
+ *     prevMeetingDisplayType: 'media',
+ *     updateMeetingDisplayType: (type) => console.log('Updated display type:', type),
+ *     updateAutoWave: (wave) => console.log('Updated auto wave:', wave),
+ *     updateForceFullDisplay: (fullDisplay) => console.log('Updated force full display:', fullDisplay),
+ *     updateMeetingVideoOptimized: (optimized) => console.log('Updated video optimization:', optimized),
+ *     updatePrevForceFullDisplay: (fullDisplay) => console.log('Updated previous full display:', fullDisplay),
+ *     updatePrevMeetingDisplayType: (type) => console.log('Updated previous display type:', type),
+ *     updateIsDisplaySettingsModalVisible: (isVisible) => console.log('Display settings modal is now:', isVisible),
+ *     updateFirstAll: (firstAll) => console.log('Updated first all:', firstAll),
+ *     updateUpdateMainWindow: (update) => console.log('Updated main window:', update),
+ *     breakOutRoomStarted: false,
+ *     breakOutRoomEnded: false,
+ *     onScreenChanges: async ({ changed, parameters }) => console.log('Screen changes:', changed),
+ *   },
+ * };
+ *
+ * const modifyDisplaySettingsService = new ModifyDisplaySettings();
+ * await modifyDisplaySettingsService.modifyDisplaySettings(options);
+ * ```
+ */
 export class ModifyDisplaySettings {
     /**
      * Modifies the display settings based on the provided parameters.
@@ -116,4 +191,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"modify-display-settings.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/methods/display-settings-methods/modify-display-settings.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { OnScreenChangesParameters, OnScreenChangesType, ShowAlert } from '../../@types/types';\n\nexport interface ModifyDisplaySettingsParameters extends OnScreenChangesParameters {\n  showAlert?: ShowAlert;\n  meetingDisplayType: string;\n  autoWave: boolean;\n  forceFullDisplay: boolean;\n  meetingVideoOptimized: boolean;\n  islevel: string;\n  recordStarted: boolean;\n  recordResumed: boolean;\n  recordStopped: boolean;\n  recordPaused: boolean;\n  recordingDisplayType: 'video' | 'media' | 'all';\n  recordingVideoOptimized: boolean;\n  prevForceFullDisplay: boolean;\n  prevMeetingDisplayType: string;\n  updateMeetingDisplayType: (displayType: string) => void;\n  updateAutoWave: (autoWave: boolean) => void;\n  updateForceFullDisplay: (forceFullDisplay: boolean) => void;\n  updateMeetingVideoOptimized: (optimized: boolean) => void;\n  updatePrevForceFullDisplay: (forceFullDisplay: boolean) => void;\n  updatePrevMeetingDisplayType: (displayType: string) => void;\n  updateIsDisplaySettingsModalVisible: (isVisible: boolean) => void;\n  updateFirstAll: (firstAll: boolean) => void;\n  updateUpdateMainWindow: (update: boolean) => void;\n  breakOutRoomStarted: boolean;\n  breakOutRoomEnded: boolean;\n\n  // mediasfu functions\n  onScreenChanges: OnScreenChangesType;\n\n  [key: string]: any;\n}\n\nexport interface ModifyDisplaySettingsOptions {\n  parameters: ModifyDisplaySettingsParameters;\n}\n\n// Export the type definition for the function\nexport type ModifyDisplaySettingsType = (options: ModifyDisplaySettingsOptions) => Promise<void>;\n@Injectable({\n  providedIn: 'root',\n})\nexport class ModifyDisplaySettings {\n  /**\n   * Modifies the display settings based on the provided parameters.\n   *\n   * @param {ModifyDisplaySettingsOptions} options - The options containing the parameters to modify the display settings.\n   * @param {Object} options.parameters - The parameters for modifying the display settings.\n   * @param {Function} options.parameters.showAlert - Function to show alert messages.\n   * @param {string} options.parameters.meetingDisplayType - The current meeting display type.\n   * @param {boolean} options.parameters.autoWave - Flag indicating if auto wave is enabled.\n   * @param {boolean} options.parameters.forceFullDisplay - Flag indicating if full display is forced.\n   * @param {boolean} options.parameters.meetingVideoOptimized - Flag indicating if the meeting video is optimized.\n   * @param {string} options.parameters.islevel - The current level of the meeting.\n   * @param {boolean} options.parameters.recordStarted - Flag indicating if recording has started.\n   * @param {boolean} options.parameters.recordResumed - Flag indicating if recording has resumed.\n   * @param {boolean} options.parameters.recordStopped - Flag indicating if recording has stopped.\n   * @param {boolean} options.parameters.recordPaused - Flag indicating if recording is paused.\n   * @param {string} options.parameters.recordingDisplayType - The current recording display type.\n   * @param {boolean} options.parameters.recordingVideoOptimized - Flag indicating if the recording video is optimized.\n   * @param {string} options.parameters.prevForceFullDisplay - The previous force full display value.\n   * @param {string} options.parameters.prevMeetingDisplayType - The previous meeting display type.\n   * @param {Function} options.parameters.updateMeetingDisplayType - Function to update the meeting display type.\n   * @param {Function} options.parameters.updateAutoWave - Function to update the auto wave setting.\n   * @param {Function} options.parameters.updateForceFullDisplay - Function to update the force full display setting.\n   * @param {Function} options.parameters.updateMeetingVideoOptimized - Function to update the meeting video optimization setting.\n   * @param {Function} options.parameters.updatePrevForceFullDisplay - Function to update the previous force full display setting.\n   * @param {Function} options.parameters.updatePrevMeetingDisplayType - Function to update the previous meeting display type.\n   * @param {Function} options.parameters.updateIsDisplaySettingsModalVisible - Function to update the visibility of the display settings modal.\n   * @param {Function} options.parameters.updateFirstAll - Function to update the first all setting.\n   * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window.\n   * @param {boolean} options.parameters.breakOutRoomStarted - Flag indicating if a breakout room has started.\n   * @param {boolean} options.parameters.breakOutRoomEnded - Flag indicating if a breakout room has ended.\n   * @param {Function} options.parameters.onScreenChanges - Function to handle screen changes.\n   *\n   * @returns {Promise<void>} A promise that resolves when the display settings have been modified.\n   */\n\n  modifyDisplaySettings = async ({ parameters }: ModifyDisplaySettingsOptions): Promise<void> => {\n    // Destructure the parameters\n    let {\n      showAlert,\n      meetingDisplayType,\n      autoWave,\n      forceFullDisplay,\n      meetingVideoOptimized,\n      islevel,\n      recordStarted,\n      recordResumed,\n      recordStopped,\n      recordPaused,\n      recordingDisplayType,\n      recordingVideoOptimized,\n      prevForceFullDisplay,\n      prevMeetingDisplayType,\n      updateMeetingDisplayType,\n      updateAutoWave,\n      updateForceFullDisplay,\n      updateMeetingVideoOptimized,\n      updatePrevForceFullDisplay,\n      updatePrevMeetingDisplayType,\n      updateIsDisplaySettingsModalVisible,\n      updateFirstAll,\n      updateUpdateMainWindow,\n      breakOutRoomStarted,\n      breakOutRoomEnded,\n      onScreenChanges,\n    } = parameters;\n\n    // Update previous states\n    updateAutoWave(autoWave);\n    updateForceFullDisplay(forceFullDisplay);\n\n    if (islevel === '2' && (recordStarted || recordResumed) && !recordStopped && !recordPaused) {\n      if (\n        recordingDisplayType === 'video' &&\n        meetingDisplayType === 'video' &&\n        meetingVideoOptimized &&\n        !recordingVideoOptimized\n      ) {\n        showAlert?.({\n          message:\n            'Meeting display type can be either video, media, or all when recording display type is non-optimized video.',\n          type: 'danger',\n          duration: 3000,\n        });\n        // Reset to previous values or handle as needed\n        meetingDisplayType = recordingDisplayType;\n        updateMeetingDisplayType(meetingDisplayType);\n        meetingVideoOptimized = recordingVideoOptimized;\n        updateMeetingVideoOptimized(meetingVideoOptimized);\n        return;\n      } else if (recordingDisplayType === 'media' && meetingDisplayType === 'video') {\n        showAlert?.({\n          message:\n            'Meeting display type can be either media or all when recording display type is media.',\n          type: 'danger',\n          duration: 3000,\n        });\n\n        // Reset to previous values or handle as needed\n        meetingDisplayType = recordingDisplayType;\n        updateMeetingDisplayType(meetingDisplayType);\n        return;\n      } else if (\n        recordingDisplayType === 'all' &&\n        (meetingDisplayType === 'video' || meetingDisplayType === 'media')\n      ) {\n        showAlert?.({\n          message: 'Meeting display type can be only all when recording display type is all.',\n          type: 'danger',\n          duration: 3000,\n        });\n        // Reset to previous values or handle as needed\n        meetingDisplayType = recordingDisplayType;\n        updateMeetingDisplayType(meetingDisplayType);\n        return;\n      }\n    }\n\n    updateMeetingDisplayType(meetingDisplayType);\n    updateMeetingVideoOptimized(meetingVideoOptimized);\n\n    // Close the modal or perform additional actions\n    updateIsDisplaySettingsModalVisible(false);\n\n    if (\n      prevMeetingDisplayType !== meetingDisplayType ||\n      prevForceFullDisplay !== forceFullDisplay\n    ) {\n      if (breakOutRoomStarted && !breakOutRoomEnded && meetingDisplayType !== 'all') {\n        showAlert?.({\n          message: 'Breakout room is active. Display type can only be all.',\n          type: 'danger',\n        });\n        meetingDisplayType = prevMeetingDisplayType;\n        updateMeetingDisplayType(prevMeetingDisplayType);\n        return;\n      }\n\n      updateFirstAll(meetingDisplayType !== 'all' ? true : false);\n      updateUpdateMainWindow(true);\n      await onScreenChanges({\n        changed: true,\n        parameters: { ...parameters, meetingDisplayType, forceFullDisplay },\n      });\n      updatePrevForceFullDisplay(forceFullDisplay);\n      updatePrevMeetingDisplayType(meetingDisplayType);\n    }\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"modify-display-settings.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/methods/display-settings-methods/modify-display-settings.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { OnScreenChangesParameters, OnScreenChangesType, ShowAlert } from '../../@types/types';\n\nexport interface ModifyDisplaySettingsParameters extends OnScreenChangesParameters {\n  showAlert?: ShowAlert;\n  meetingDisplayType: string;\n  autoWave: boolean;\n  forceFullDisplay: boolean;\n  meetingVideoOptimized: boolean;\n  islevel: string;\n  recordStarted: boolean;\n  recordResumed: boolean;\n  recordStopped: boolean;\n  recordPaused: boolean;\n  recordingDisplayType: 'video' | 'media' | 'all';\n  recordingVideoOptimized: boolean;\n  prevForceFullDisplay: boolean;\n  prevMeetingDisplayType: string;\n  updateMeetingDisplayType: (displayType: string) => void;\n  updateAutoWave: (autoWave: boolean) => void;\n  updateForceFullDisplay: (forceFullDisplay: boolean) => void;\n  updateMeetingVideoOptimized: (optimized: boolean) => void;\n  updatePrevForceFullDisplay: (forceFullDisplay: boolean) => void;\n  updatePrevMeetingDisplayType: (displayType: string) => void;\n  updateIsDisplaySettingsModalVisible: (isVisible: boolean) => void;\n  updateFirstAll: (firstAll: boolean) => void;\n  updateUpdateMainWindow: (update: boolean) => void;\n  breakOutRoomStarted: boolean;\n  breakOutRoomEnded: boolean;\n\n  // mediasfu functions\n  onScreenChanges: OnScreenChangesType;\n\n  [key: string]: any;\n}\n\nexport interface ModifyDisplaySettingsOptions {\n  parameters: ModifyDisplaySettingsParameters;\n}\n\n// Export the type definition for the function\nexport type ModifyDisplaySettingsType = (options: ModifyDisplaySettingsOptions) => Promise<void>;\n\n/**\n * Modifies the display settings based on the provided parameters.\n *\n * This method updates the display settings for the meeting based on the participant's level,\n * recording status, and other conditions. It validates display types and shows alerts\n * when necessary. It also handles the display settings for breakout rooms.\n *\n * @param {ModifyDisplaySettingsOptions} options - The options containing the parameters to modify the display settings.\n * @param {Object} options.parameters - The parameters for modifying the display settings.\n * @param {Function} options.parameters.showAlert - Function to show alert messages.\n * @param {string} options.parameters.meetingDisplayType - The current meeting display type.\n * @param {boolean} options.parameters.autoWave - Flag indicating if auto wave is enabled.\n * @param {boolean} options.parameters.forceFullDisplay - Flag indicating if full display is forced.\n * @param {boolean} options.parameters.meetingVideoOptimized - Flag indicating if the meeting video is optimized.\n * @param {string} options.parameters.islevel - The current level of the meeting.\n * @param {boolean} options.parameters.recordStarted - Flag indicating if recording has started.\n * @param {boolean} options.parameters.recordResumed - Flag indicating if recording has resumed.\n * @param {boolean} options.parameters.recordStopped - Flag indicating if recording has stopped.\n * @param {boolean} options.parameters.recordPaused - Flag indicating if recording is paused.\n * @param {string} options.parameters.recordingDisplayType - The current recording display type.\n * @param {boolean} options.parameters.recordingVideoOptimized - Flag indicating if the recording video is optimized.\n * @param {string} options.parameters.prevForceFullDisplay - The previous force full display value.\n * @param {string} options.parameters.prevMeetingDisplayType - The previous meeting display type.\n * @param {Function} options.parameters.updateMeetingDisplayType - Function to update the meeting display type.\n * @param {Function} options.parameters.updateAutoWave - Function to update the auto wave setting.\n * @param {Function} options.parameters.updateForceFullDisplay - Function to update the force full display setting.\n * @param {Function} options.parameters.updateMeetingVideoOptimized - Function to update the meeting video optimization setting.\n * @param {Function} options.parameters.updatePrevForceFullDisplay - Function to update the previous force full display setting.\n * @param {Function} options.parameters.updatePrevMeetingDisplayType - Function to update the previous meeting display type.\n * @param {Function} options.parameters.updateIsDisplaySettingsModalVisible - Function to update the visibility of the display settings modal.\n * @param {Function} options.parameters.updateFirstAll - Function to update the first all setting.\n * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window.\n * @param {boolean} options.parameters.breakOutRoomStarted - Flag indicating if a breakout room has started.\n * @param {boolean} options.parameters.breakOutRoomEnded - Flag indicating if a breakout room has ended.\n * @param {Function} options.parameters.onScreenChanges - Function to handle screen changes.\n *\n * @returns {Promise<void>} A promise that resolves when the display settings have been modified.\n *\n * @example\n * ```typescript\n * const options: ModifyDisplaySettingsOptions = {\n *   parameters: {\n *     showAlert: (alert) => console.log(alert.message),\n *     meetingDisplayType: 'video',\n *     autoWave: true,\n *     forceFullDisplay: false,\n *     meetingVideoOptimized: true,\n *     islevel: '1',\n *     recordStarted: false,\n *     recordResumed: false,\n *     recordStopped: false,\n *     recordPaused: false,\n *     recordingDisplayType: 'media',\n *     recordingVideoOptimized: false,\n *     prevForceFullDisplay: false,\n *     prevMeetingDisplayType: 'media',\n *     updateMeetingDisplayType: (type) => console.log('Updated display type:', type),\n *     updateAutoWave: (wave) => console.log('Updated auto wave:', wave),\n *     updateForceFullDisplay: (fullDisplay) => console.log('Updated force full display:', fullDisplay),\n *     updateMeetingVideoOptimized: (optimized) => console.log('Updated video optimization:', optimized),\n *     updatePrevForceFullDisplay: (fullDisplay) => console.log('Updated previous full display:', fullDisplay),\n *     updatePrevMeetingDisplayType: (type) => console.log('Updated previous display type:', type),\n *     updateIsDisplaySettingsModalVisible: (isVisible) => console.log('Display settings modal is now:', isVisible),\n *     updateFirstAll: (firstAll) => console.log('Updated first all:', firstAll),\n *     updateUpdateMainWindow: (update) => console.log('Updated main window:', update),\n *     breakOutRoomStarted: false,\n *     breakOutRoomEnded: false,\n *     onScreenChanges: async ({ changed, parameters }) => console.log('Screen changes:', changed),\n *   },\n * };\n *\n * const modifyDisplaySettingsService = new ModifyDisplaySettings();\n * await modifyDisplaySettingsService.modifyDisplaySettings(options);\n * ```\n */\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ModifyDisplaySettings {\n  /**\n   * Modifies the display settings based on the provided parameters.\n   *\n   * @param {ModifyDisplaySettingsOptions} options - The options containing the parameters to modify the display settings.\n   * @param {Object} options.parameters - The parameters for modifying the display settings.\n   * @param {Function} options.parameters.showAlert - Function to show alert messages.\n   * @param {string} options.parameters.meetingDisplayType - The current meeting display type.\n   * @param {boolean} options.parameters.autoWave - Flag indicating if auto wave is enabled.\n   * @param {boolean} options.parameters.forceFullDisplay - Flag indicating if full display is forced.\n   * @param {boolean} options.parameters.meetingVideoOptimized - Flag indicating if the meeting video is optimized.\n   * @param {string} options.parameters.islevel - The current level of the meeting.\n   * @param {boolean} options.parameters.recordStarted - Flag indicating if recording has started.\n   * @param {boolean} options.parameters.recordResumed - Flag indicating if recording has resumed.\n   * @param {boolean} options.parameters.recordStopped - Flag indicating if recording has stopped.\n   * @param {boolean} options.parameters.recordPaused - Flag indicating if recording is paused.\n   * @param {string} options.parameters.recordingDisplayType - The current recording display type.\n   * @param {boolean} options.parameters.recordingVideoOptimized - Flag indicating if the recording video is optimized.\n   * @param {string} options.parameters.prevForceFullDisplay - The previous force full display value.\n   * @param {string} options.parameters.prevMeetingDisplayType - The previous meeting display type.\n   * @param {Function} options.parameters.updateMeetingDisplayType - Function to update the meeting display type.\n   * @param {Function} options.parameters.updateAutoWave - Function to update the auto wave setting.\n   * @param {Function} options.parameters.updateForceFullDisplay - Function to update the force full display setting.\n   * @param {Function} options.parameters.updateMeetingVideoOptimized - Function to update the meeting video optimization setting.\n   * @param {Function} options.parameters.updatePrevForceFullDisplay - Function to update the previous force full display setting.\n   * @param {Function} options.parameters.updatePrevMeetingDisplayType - Function to update the previous meeting display type.\n   * @param {Function} options.parameters.updateIsDisplaySettingsModalVisible - Function to update the visibility of the display settings modal.\n   * @param {Function} options.parameters.updateFirstAll - Function to update the first all setting.\n   * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window.\n   * @param {boolean} options.parameters.breakOutRoomStarted - Flag indicating if a breakout room has started.\n   * @param {boolean} options.parameters.breakOutRoomEnded - Flag indicating if a breakout room has ended.\n   * @param {Function} options.parameters.onScreenChanges - Function to handle screen changes.\n   *\n   * @returns {Promise<void>} A promise that resolves when the display settings have been modified.\n   */\n\n  modifyDisplaySettings = async ({ parameters }: ModifyDisplaySettingsOptions): Promise<void> => {\n    // Destructure the parameters\n    let {\n      showAlert,\n      meetingDisplayType,\n      autoWave,\n      forceFullDisplay,\n      meetingVideoOptimized,\n      islevel,\n      recordStarted,\n      recordResumed,\n      recordStopped,\n      recordPaused,\n      recordingDisplayType,\n      recordingVideoOptimized,\n      prevForceFullDisplay,\n      prevMeetingDisplayType,\n      updateMeetingDisplayType,\n      updateAutoWave,\n      updateForceFullDisplay,\n      updateMeetingVideoOptimized,\n      updatePrevForceFullDisplay,\n      updatePrevMeetingDisplayType,\n      updateIsDisplaySettingsModalVisible,\n      updateFirstAll,\n      updateUpdateMainWindow,\n      breakOutRoomStarted,\n      breakOutRoomEnded,\n      onScreenChanges,\n    } = parameters;\n\n    // Update previous states\n    updateAutoWave(autoWave);\n    updateForceFullDisplay(forceFullDisplay);\n\n    if (islevel === '2' && (recordStarted || recordResumed) && !recordStopped && !recordPaused) {\n      if (\n        recordingDisplayType === 'video' &&\n        meetingDisplayType === 'video' &&\n        meetingVideoOptimized &&\n        !recordingVideoOptimized\n      ) {\n        showAlert?.({\n          message:\n            'Meeting display type can be either video, media, or all when recording display type is non-optimized video.',\n          type: 'danger',\n          duration: 3000,\n        });\n        // Reset to previous values or handle as needed\n        meetingDisplayType = recordingDisplayType;\n        updateMeetingDisplayType(meetingDisplayType);\n        meetingVideoOptimized = recordingVideoOptimized;\n        updateMeetingVideoOptimized(meetingVideoOptimized);\n        return;\n      } else if (recordingDisplayType === 'media' && meetingDisplayType === 'video') {\n        showAlert?.({\n          message:\n            'Meeting display type can be either media or all when recording display type is media.',\n          type: 'danger',\n          duration: 3000,\n        });\n\n        // Reset to previous values or handle as needed\n        meetingDisplayType = recordingDisplayType;\n        updateMeetingDisplayType(meetingDisplayType);\n        return;\n      } else if (\n        recordingDisplayType === 'all' &&\n        (meetingDisplayType === 'video' || meetingDisplayType === 'media')\n      ) {\n        showAlert?.({\n          message: 'Meeting display type can be only all when recording display type is all.',\n          type: 'danger',\n          duration: 3000,\n        });\n        // Reset to previous values or handle as needed\n        meetingDisplayType = recordingDisplayType;\n        updateMeetingDisplayType(meetingDisplayType);\n        return;\n      }\n    }\n\n    updateMeetingDisplayType(meetingDisplayType);\n    updateMeetingVideoOptimized(meetingVideoOptimized);\n\n    // Close the modal or perform additional actions\n    updateIsDisplaySettingsModalVisible(false);\n\n    if (\n      prevMeetingDisplayType !== meetingDisplayType ||\n      prevForceFullDisplay !== forceFullDisplay\n    ) {\n      if (breakOutRoomStarted && !breakOutRoomEnded && meetingDisplayType !== 'all') {\n        showAlert?.({\n          message: 'Breakout room is active. Display type can only be all.',\n          type: 'danger',\n        });\n        meetingDisplayType = prevMeetingDisplayType;\n        updateMeetingDisplayType(prevMeetingDisplayType);\n        return;\n      }\n\n      updateFirstAll(meetingDisplayType !== 'all' ? true : false);\n      updateUpdateMainWindow(true);\n      await onScreenChanges({\n        changed: true,\n        parameters: { ...parameters, meetingDisplayType, forceFullDisplay },\n      });\n      updatePrevForceFullDisplay(forceFullDisplay);\n      updatePrevMeetingDisplayType(meetingDisplayType);\n    }\n  };\n}\n"]}

package/dist/esm2022/lib/methods/exit-methods/confirm-exit.service.mjs

@@ -1,6 +1,30 @@
 // confirm-exit.service.ts
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Confirms the exit of a member from a room and optionally bans them.
+ *
+ * This method emits a socket event to disconnect the specified member from the given room.
+ * If the `ban` option is set to true, the member will be banned from rejoining the room.
+ *
+ * @param {ConfirmExitOptions} options - The options for confirming the exit.
+ * @param {Socket} options.socket - The socket instance to emit the event.
+ * @param {string} options.member - The member who is exiting.
+ * @param {string} options.roomName - The name of the room the member is exiting from.
+ * @param {boolean} [options.ban=false] - Whether to ban the member from the room.
+ * @returns {Promise<void>} A promise that resolves when the exit is confirmed.
+ *
+ * @example
+ * ```typescript
+ * const confirmExitService = new ConfirmExit();
+ * await confirmExitService.confirmExit({
+ *   socket: socketInstance,
+ *   member: 'JohnDoe',
+ *   roomName: 'Room1',
+ *   ban: true, // Optional: set to true if you want to ban the member
+ * });
+ * ```
+ */
 export class ConfirmExit {
     /**
      * Confirms the exit of a member from a room and optionally bans them.
@@ -25,4 +49,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/exit-methods/launch-confirm-exit.service.mjs

@@ -1,5 +1,25 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Toggles the visibility of the confirmation exit modal.
+ *
+ * This method updates the state of the confirmation exit modal by inverting its current visibility status.
+ *
+ * @param {LaunchConfirmExitOptions} options - The options for toggling the confirmation exit modal visibility.
+ * @param {Function} options.updateIsConfirmExitModalVisible - Function to update the visibility state of the confirmation exit modal.
+ * @param {boolean} options.isConfirmExitModalVisible - Current visibility state of the confirmation exit modal.
+ *
+ * @example
+ * ```typescript
+ * const launchConfirmExitService = new LaunchConfirmExit();
+ * launchConfirmExitService.launchConfirmExit({
+ *   updateIsConfirmExitModalVisible: (isVisible) => {
+ *     console.log('Confirm exit modal is now:', isVisible ? 'Visible' : 'Hidden');
+ *   },
+ *   isConfirmExitModalVisible: false, // Initially not visible
+ * });
+ * ```
+ */
 export class LaunchConfirmExit {
     /**
      * Toggles the visibility of the confirmation exit modal.
@@ -19,4 +39,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGF1bmNoLWNvbmZpcm0tZXhpdC5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbWVkaWFzZnUtYW5ndWxhci9zcmMvbGliL21ldGhvZHMvZXhpdC1tZXRob2RzL2xhdW5jaC1jb25maXJtLWV4aXQuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQVkzQyxNQUFNLE9BQU8saUJBQWlCO0lBQzVCOzs7OztPQUtHO0lBRUgsaUJBQWlCLENBQUMsRUFDaEIsK0JBQStCLEVBQy9CLHlCQUF5QixHQUNBO1FBQ3pCLCtCQUErQixDQUFDLENBQUMseUJBQXlCLENBQUMsQ0FBQztJQUM5RCxDQUFDO3VHQWJVLGlCQUFpQjsyR0FBakIsaUJBQWlCLGNBRmhCLE1BQU07OzJGQUVQLGlCQUFpQjtrQkFIN0IsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5leHBvcnQgaW50ZXJmYWNlIExhdW5jaENvbmZpcm1FeGl0T3B0aW9ucyB7XG4gIHVwZGF0ZUlzQ29uZmlybUV4aXRNb2RhbFZpc2libGU6IChpc1Zpc2libGU6IGJvb2xlYW4pID0+IHZvaWQ7XG4gIGlzQ29uZmlybUV4aXRNb2RhbFZpc2libGU6IGJvb2xlYW47XG59XG5cbi8vIEV4cG9ydCB0aGUgdHlwZSBkZWZpbml0aW9uIGZvciB0aGUgZnVuY3Rpb25cbmV4cG9ydCB0eXBlIExhdW5jaENvbmZpcm1FeGl0VHlwZSA9IChvcHRpb25zOiBMYXVuY2hDb25maXJtRXhpdE9wdGlvbnMpID0+IHZvaWQ7XG5cbkBJbmplY3RhYmxlKHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnLFxufSlcbmV4cG9ydCBjbGFzcyBMYXVuY2hDb25maXJtRXhpdCB7XG4gIC8qKlxuICAgKiBUb2dnbGVzIHRoZSB2aXNpYmlsaXR5IG9mIHRoZSBjb25maXJtYXRpb24gZXhpdCBtb2RhbC5cbiAgICpcbiAgICogQHBhcmFtIHVwZGF0ZUlzQ29uZmlybUV4aXRNb2RhbFZpc2libGUgLSBGdW5jdGlvbiB0byB1cGRhdGUgdGhlIHZpc2liaWxpdHkgc3RhdGUgb2YgdGhlIGNvbmZpcm1hdGlvbiBleGl0IG1vZGFsLlxuICAgKiBAcGFyYW0gaXNDb25maXJtRXhpdE1vZGFsVmlzaWJsZSAtIEN1cnJlbnQgdmlzaWJpbGl0eSBzdGF0ZSBvZiB0aGUgY29uZmlybWF0aW9uIGV4aXQgbW9kYWwuXG4gICAqL1xuXG4gIGxhdW5jaENvbmZpcm1FeGl0KHtcbiAgICB1cGRhdGVJc0NvbmZpcm1FeGl0TW9kYWxWaXNpYmxlLFxuICAgIGlzQ29uZmlybUV4aXRNb2RhbFZpc2libGUsXG4gIH06IExhdW5jaENvbmZpcm1FeGl0T3B0aW9ucyk6IHZvaWQge1xuICAgIHVwZGF0ZUlzQ29uZmlybUV4aXRNb2RhbFZpc2libGUoIWlzQ29uZmlybUV4aXRNb2RhbFZpc2libGUpO1xuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/methods/media-settings-methods/launch-media-settings.service.mjs

@@ -1,5 +1,40 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Launches the media settings modal and updates the available audio and video input devices.
+ *
+ * This method checks the current visibility of the media settings modal and, if it is not visible,
+ * retrieves the list of available audio and video input devices. It then updates the state with
+ * these devices and opens the modal. If the modal is already visible, it closes the modal.
+ *
+ * @param {LaunchMediaSettingsOptions} options - The options for launching media settings.
+ * @param {Function} options.updateIsMediaSettingsModalVisible - Function to update the visibility state of the media settings modal.
+ * @param {boolean} options.isMediaSettingsModalVisible - Current visibility state of the media settings modal.
+ * @param {MediaDeviceInfo[]} options.audioInputs - Array to store available audio input devices.
+ * @param {MediaDeviceInfo[]} options.videoInputs - Array to store available video input devices.
+ * @param {Function} options.updateAudioInputs - Function to update the available audio input devices.
+ * @param {Function} options.updateVideoInputs - Function to update the available video input devices.
+ * @returns {Promise<void>} A promise that resolves when the media settings have been updated.
+ *
+ * @example
+ * ```typescript
+ * const launchMediaSettingsService = new LaunchMediaSettings();
+ * launchMediaSettingsService.launchMediaSettings({
+ *   updateIsMediaSettingsModalVisible: (isVisible) => {
+ *     console.log('Media settings modal is now:', isVisible ? 'Visible' : 'Hidden');
+ *   },
+ *   isMediaSettingsModalVisible: false, // Initially not visible
+ *   audioInputs: [],
+ *   videoInputs: [],
+ *   updateAudioInputs: (inputs) => {
+ *     console.log('Available audio inputs:', inputs);
+ *   },
+ *   updateVideoInputs: (inputs) => {
+ *     console.log('Available video inputs:', inputs);
+ *   },
+ * });
+ * ```
+ */
 export class LaunchMediaSettings {
     /**
      * Launches the media settings modal and updates the available audio and video input devices.
@@ -47,4 +82,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/menu-methods/launch-menu-modal.service.mjs

@@ -1,5 +1,27 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Toggles the visibility of the menu modal.
+ *
+ * This method updates the visibility state of the menu modal by calling the provided
+ * function with the negated current visibility state. If the modal is currently visible,
+ * it will be hidden, and vice versa.
+ *
+ * @param {LaunchMenuModalOptions} options - The options for launching the menu modal.
+ * @param {Function} options.updateIsMenuModalVisible - Function to update the visibility state of the menu modal.
+ * @param {boolean} options.isMenuModalVisible - Current visibility state of the menu modal.
+ *
+ * @example
+ * ```typescript
+ * const launchMenuModalService = new LaunchMenuModal();
+ * launchMenuModalService.launchMenuModal({
+ *   updateIsMenuModalVisible: (isVisible) => {
+ *     console.log('Menu modal is now:', isVisible ? 'Visible' : 'Hidden');
+ *   },
+ *   isMenuModalVisible: false, // Initially not visible
+ * });
+ * ```
+ */
 export class LaunchMenuModal {
     /**
      * Toggles the visibility of the menu modal.
@@ -19,4 +41,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGF1bmNoLW1lbnUtbW9kYWwuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL21lZGlhc2Z1LWFuZ3VsYXIvc3JjL2xpYi9tZXRob2RzL21lbnUtbWV0aG9kcy9sYXVuY2gtbWVudS1tb2RhbC5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBWTNDLE1BQU0sT0FBTyxlQUFlO0lBQzFCOzs7OztPQUtHO0lBRUgsZUFBZSxDQUFDLEVBQUUsd0JBQXdCLEVBQUUsa0JBQWtCLEVBQTBCO1FBQ3RGLHdCQUF3QixDQUFDLENBQUMsa0JBQWtCLENBQUMsQ0FBQztJQUNoRCxDQUFDO3VHQVZVLGVBQWU7MkdBQWYsZUFBZSxjQUZkLE1BQU07OzJGQUVQLGVBQWU7a0JBSDNCLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuZXhwb3J0IGludGVyZmFjZSBMYXVuY2hNZW51TW9kYWxPcHRpb25zIHtcbiAgdXBkYXRlSXNNZW51TW9kYWxWaXNpYmxlOiAoaXNWaXNpYmxlOiBib29sZWFuKSA9PiB2b2lkO1xuICBpc01lbnVNb2RhbFZpc2libGU6IGJvb2xlYW47XG59XG5cbi8vIEV4cG9ydCB0aGUgdHlwZSBkZWZpbml0aW9uIGZvciB0aGUgZnVuY3Rpb25cbmV4cG9ydCB0eXBlIExhdW5jaE1lbnVNb2RhbFR5cGUgPSAob3B0aW9uczogTGF1bmNoTWVudU1vZGFsT3B0aW9ucykgPT4gdm9pZDtcblxuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCcsXG59KVxuZXhwb3J0IGNsYXNzIExhdW5jaE1lbnVNb2RhbCB7XG4gIC8qKlxuICAgKiBUb2dnbGVzIHRoZSB2aXNpYmlsaXR5IG9mIHRoZSBtZW51IG1vZGFsLlxuICAgKlxuICAgKiBAcGFyYW0gdXBkYXRlSXNNZW51TW9kYWxWaXNpYmxlIC0gRnVuY3Rpb24gdG8gdXBkYXRlIHRoZSB2aXNpYmlsaXR5IHN0YXRlIG9mIHRoZSBtZW51IG1vZGFsLlxuICAgKiBAcGFyYW0gaXNNZW51TW9kYWxWaXNpYmxlIC0gQ3VycmVudCB2aXNpYmlsaXR5IHN0YXRlIG9mIHRoZSBtZW51IG1vZGFsLlxuICAgKi9cblxuICBsYXVuY2hNZW51TW9kYWwoeyB1cGRhdGVJc01lbnVNb2RhbFZpc2libGUsIGlzTWVudU1vZGFsVmlzaWJsZSB9OiBMYXVuY2hNZW51TW9kYWxPcHRpb25zKTogdm9pZCB7XG4gICAgdXBkYXRlSXNNZW51TW9kYWxWaXNpYmxlKCFpc01lbnVNb2RhbFZpc2libGUpO1xuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/methods/message-methods/launch-messages.service.mjs

@@ -1,5 +1,27 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Toggles the visibility state of the messages modal.
+ *
+ * This method updates the visibility state of the messages modal by calling the provided
+ * function with the negated current visibility state. If the modal is currently visible,
+ * it will be closed; if it's hidden, it will be opened.
+ *
+ * @param {LaunchMessagesOptions} options - The options for launching the messages modal.
+ * @param {Function} options.updateIsMessagesModalVisible - Function to update the visibility state of the messages modal.
+ * @param {boolean} options.isMessagesModalVisible - Current visibility state of the messages modal.
+ *
+ * @example
+ * ```typescript
+ * const launchMessagesService = new LaunchMessages();
+ * launchMessagesService.launchMessages({
+ *   updateIsMessagesModalVisible: (visible) => {
+ *     console.log('Messages modal is now:', visible ? 'Visible' : 'Hidden');
+ *   },
+ *   isMessagesModalVisible: false, // Initially not visible
+ * });
+ * ```
+ */
 export class LaunchMessages {
     /**
      * Toggles the visibility state of the messages modal.
@@ -20,4 +42,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGF1bmNoLW1lc3NhZ2VzLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tZWRpYXNmdS1hbmd1bGFyL3NyYy9saWIvbWV0aG9kcy9tZXNzYWdlLW1ldGhvZHMvbGF1bmNoLW1lc3NhZ2VzLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFZM0MsTUFBTSxPQUFPLGNBQWM7SUFDekI7Ozs7OztPQU1HO0lBQ0gsY0FBYyxDQUFDLEVBQ2IsNEJBQTRCLEVBQzVCLHNCQUFzQixHQUNBO1FBQ3RCLDRCQUE0QixDQUFDLENBQUMsc0JBQXNCLENBQUMsQ0FBQztJQUN4RCxDQUFDO3VHQWJVLGNBQWM7MkdBQWQsY0FBYyxjQUZiLE1BQU07OzJGQUVQLGNBQWM7a0JBSDFCLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuZXhwb3J0IGludGVyZmFjZSBMYXVuY2hNZXNzYWdlc09wdGlvbnMge1xuICB1cGRhdGVJc01lc3NhZ2VzTW9kYWxWaXNpYmxlOiAodmlzaWJsZTogYm9vbGVhbikgPT4gdm9pZDtcbiAgaXNNZXNzYWdlc01vZGFsVmlzaWJsZTogYm9vbGVhbjtcbn1cblxuLy8gRXhwb3J0IHRoZSB0eXBlIGRlZmluaXRpb24gZm9yIHRoZSBmdW5jdGlvblxuZXhwb3J0IHR5cGUgTGF1bmNoTWVzc2FnZXNUeXBlID0gKG9wdGlvbnM6IExhdW5jaE1lc3NhZ2VzT3B0aW9ucykgPT4gdm9pZDtcblxuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCcsXG59KVxuZXhwb3J0IGNsYXNzIExhdW5jaE1lc3NhZ2VzIHtcbiAgLyoqXG4gICAqIFRvZ2dsZXMgdGhlIHZpc2liaWxpdHkgc3RhdGUgb2YgdGhlIG1lc3NhZ2VzIG1vZGFsLlxuICAgKiBJZiB0aGUgbW9kYWwgaXMgY3VycmVudGx5IHZpc2libGUsIGl0IHdpbGwgYmUgY2xvc2VkLiBJZiBpdCdzIGhpZGRlbiwgaXQgd2lsbCBiZSBvcGVuZWQuXG4gICAqXG4gICAqIEBwYXJhbSB1cGRhdGVJc01lc3NhZ2VzTW9kYWxWaXNpYmxlIC0gRnVuY3Rpb24gdG8gdXBkYXRlIHRoZSB2aXNpYmlsaXR5IHN0YXRlIG9mIHRoZSBtZXNzYWdlcyBtb2RhbC5cbiAgICogQHBhcmFtIGlzTWVzc2FnZXNNb2RhbFZpc2libGUgLSBDdXJyZW50IHZpc2liaWxpdHkgc3RhdGUgb2YgdGhlIG1lc3NhZ2VzIG1vZGFsLlxuICAgKi9cbiAgbGF1bmNoTWVzc2FnZXMoe1xuICAgIHVwZGF0ZUlzTWVzc2FnZXNNb2RhbFZpc2libGUsXG4gICAgaXNNZXNzYWdlc01vZGFsVmlzaWJsZSxcbiAgfTogTGF1bmNoTWVzc2FnZXNPcHRpb25zKTogdm9pZCB7XG4gICAgdXBkYXRlSXNNZXNzYWdlc01vZGFsVmlzaWJsZSghaXNNZXNzYWdlc01vZGFsVmlzaWJsZSk7XG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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