mediasfu-angular 1.0.0 → 1.0.2

package/dist/esm2022/lib/consumers/trigger.service.mjs

@@ -1,5 +1,43 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Triggers an update to the screen client based on the provided parameters.
+ *
+ * This function handles various conditions to determine the main screen person,
+ * adjusts the screen states, and emits an update to the screen client via socket.
+ *
+ * @param {TriggerOptions} options - The options for triggering the update.
+ * @param {string[]} options.ref_ActiveNames - Reference to the active names.
+ * @param {TriggerParameters} options.parameters - The parameters for the trigger.
+ * @returns {Promise<void>} A promise that resolves when the trigger is complete.
+ *
+ * @throws Will throw an error if the updateScreenClient operation fails.
+ *
+ * @example
+ * ```typescript
+ * await trigger({
+ *   ref_ActiveNames: ["user1", "user2"],
+ *   parameters: {
+ *     socket: socketInstance,
+ *     roomName: "room1",
+ *     screenStates: [{ mainScreenPerson: "user1", mainScreenFilled: true, adminOnMainScreen: false }],
+ *     participants: [{ name: "admin", islevel: "2" }],
+ *     updateDateState: 0,
+ *     lastUpdate: null,
+ *     nForReadjust: 0,
+ *     eventType: "conference",
+ *     shared: false,
+ *     shareScreenStarted: false,
+ *     whiteboardStarted: false,
+ *     whiteboardEnded: false,
+ *     updateUpdateDateState: (date) => {},
+ *     updateLastUpdate: (date) => {},
+ *     updateNForReadjust: (n) => {},
+ *     autoAdjust: async ({ n, parameters }) => [n, 0],
+ *   },
+ * });
+ * ```
+ */
 export class Trigger {
     /**
      * Triggers an update to the screen client based on the provided parameters.
@@ -169,4 +207,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"trigger.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/trigger.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Socket } from 'socket.io-client';\nimport { Participant, AutoAdjustType, ScreenState, EventType } from '../@types/types';\n\nexport interface TriggerParameters {\n  socket: Socket;\n  roomName: string;\n  screenStates: ScreenState[];\n  participants: Participant[];\n  updateDateState?: number | null;\n  lastUpdate: number | null;\n  nForReadjust: number;\n  eventType: EventType;\n  shared: boolean;\n  shareScreenStarted: boolean;\n  whiteboardStarted: boolean;\n  whiteboardEnded: boolean;\n  updateUpdateDateState: (timestamp: number | null) => void;\n  updateLastUpdate: (lastUpdate: number | null) => void;\n  updateNForReadjust: (nForReadjust: number) => void;\n\n  // mediasfu functions\n  autoAdjust: AutoAdjustType;\n\n  getUpdatedAllParams: () => TriggerParameters;\n  [key: string]: any;\n}\n\nexport interface TriggerOptions {\n  ref_ActiveNames: string[];\n  parameters: TriggerParameters;\n}\n\n// Export the type definition for the function\nexport type TriggerType = (options: TriggerOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class Trigger {\n  /**\n   * Triggers an update to the screen client based on the provided parameters.\n   *\n   * @param {TriggerOptions} options - The options for triggering the update.\n   * @param {string[]} options.ref_ActiveNames - Reference to the active names.\n   * @param {Parameters} options.parameters - The parameters for the trigger.\n   * @returns {Promise<void>} A promise that resolves when the trigger is complete.\n   *\n   * @throws Will throw an error if the updateScreenClient operation fails.\n   *\n   * @remarks\n   * This function handles various conditions to determine the main screen person,\n   * adjusts the screen states, and emits an update to the screen client via socket.\n   *\n   * @example\n   * ```typescript\n   * await trigger({\n   *   ref_ActiveNames: [\"user1\", \"user2\"],\n   *   parameters: {\n   *     socket: socketInstance,\n   *     roomName: \"room1\",\n   *     screenStates: [{ mainScreenPerson: \"user1\", mainScreenFilled: true, adminOnMainScreen: false }],\n   *     participants: [{ name: \"admin\", islevel: \"2\" }],\n   *     updateDateState: 0,\n   *     lastUpdate: null,\n   *     nForReadjust: 0,\n   *     eventType: \"conference\",\n   *     shared: false,\n   *     shareScreenStarted: false,\n   *     whiteboardStarted: false,\n   *     whiteboardEnded: false,\n   *     updateUpdateDateState: (date) => {},\n   *     updateLastUpdate: (date) => {},\n   *     updateNForReadjust: (n) => {},\n   *     autoAdjust: async ({ n, parameters }) => [n, 0],\n   *   },\n   * });\n   * ```\n   */\n  async trigger({ ref_ActiveNames, parameters }: TriggerOptions): Promise<void> {\n    // Function to trigger the updateScreen event\n\n    try {\n      let {\n        socket,\n        roomName,\n        screenStates,\n        participants,\n        updateDateState,\n        lastUpdate,\n        nForReadjust,\n        eventType,\n        shared,\n        shareScreenStarted,\n        whiteboardStarted,\n        whiteboardEnded,\n\n        updateUpdateDateState,\n        updateLastUpdate,\n        updateNForReadjust,\n\n        autoAdjust,\n      } = parameters;\n\n      let personOnMainScreen = screenStates[0].mainScreenPerson;\n\n      let adminName = '';\n      const admin = participants.filter((participant: Participant) => participant.islevel == '2');\n      if (admin.length > 0) {\n        adminName = admin[0].name || '';\n      }\n      if (personOnMainScreen === 'WhiteboardActive') {\n        personOnMainScreen = adminName;\n      }\n\n      let mainfilled = screenStates[0].mainScreenFilled;\n      let adminOnMain = screenStates[0].adminOnMainScreen;\n      let nForReadjust_;\n      let val1;\n\n      let noww = new Date().getTime();\n      // get now in seconds\n      let timestamp = Math.floor(noww / 1000);\n\n      let eventPass = false;\n      if (eventType === 'conference' && !(shared || shareScreenStarted)) {\n        eventPass = true;\n        personOnMainScreen = adminName;\n        if (!ref_ActiveNames.includes(adminName)) {\n          ref_ActiveNames.unshift(adminName);\n        }\n      }\n\n      if ((mainfilled && personOnMainScreen != null && adminOnMain) || eventPass) {\n        if (eventType === 'conference') {\n          nForReadjust = nForReadjust + 1;\n          updateNForReadjust(nForReadjust);\n        }\n\n        if (!ref_ActiveNames.includes(adminName) && whiteboardStarted && !whiteboardEnded) {\n          ref_ActiveNames.unshift(adminName);\n        }\n\n        nForReadjust_ = ref_ActiveNames.length;\n\n        if (nForReadjust_ === 0 && eventType === 'webinar') {\n          val1 = 0;\n        } else {\n          const [val11] = await autoAdjust({\n            n: nForReadjust_,\n            eventType,\n            shared,\n            shareScreenStarted,\n          });\n          val1 = val11;\n        }\n\n        let calc1 = Math.floor((val1 / 12) * 100);\n        let calc2 = 100 - calc1;\n\n        // check if lastUpdate is not null and at least same seconds\n        if (lastUpdate == null || updateDateState != timestamp) {\n          let now = new Date();\n\n          socket.emit(\n            'updateScreenClient',\n            {\n              roomName,\n              names: ref_ActiveNames,\n              mainPercent: calc2,\n              mainScreenPerson: personOnMainScreen,\n              viewType: eventType,\n            },\n            ({ success, reason }: { success: boolean; reason: string }) => {\n              updateDateState = timestamp;\n              updateUpdateDateState(updateDateState);\n              lastUpdate = Math.floor(now.getTime() / 1000);\n              updateLastUpdate(lastUpdate);\n              if (success) {\n                // handle success\n              } else {\n                console.log(reason, 'updateScreenClient failed');\n              }\n            },\n          );\n        }\n      } else if (mainfilled && personOnMainScreen != null && !adminOnMain) {\n        nForReadjust_ = ref_ActiveNames.length;\n\n        if (!ref_ActiveNames.includes(adminName)) {\n          ref_ActiveNames.unshift(adminName);\n          nForReadjust_ = ref_ActiveNames.length;\n        }\n\n        const [val11] = await autoAdjust({\n          n: nForReadjust_,\n          eventType,\n          shared,\n          shareScreenStarted,\n        });\n\n        val1 = val11;\n\n        const calc1 = Math.floor((val1 / 12) * 100);\n        const calc2 = 100 - calc1;\n\n        if (lastUpdate == null || updateDateState != timestamp) {\n          let now = new Date();\n\n          socket.emit(\n            'updateScreenClient',\n            {\n              roomName,\n              names: ref_ActiveNames,\n              mainPercent: calc2,\n              mainScreenPerson: personOnMainScreen,\n              viewType: eventType,\n            },\n            ({ success, reason }: { success: boolean; reason: string }) => {\n              updateDateState = timestamp;\n              updateUpdateDateState(updateDateState);\n              lastUpdate = Math.floor(now.getTime() / 1000);\n              updateLastUpdate(lastUpdate);\n              if (success) {\n                // handle success\n              } else {\n                console.log(reason, 'updateScreenClient failed');\n              }\n            },\n          );\n        }\n      } else {\n        // stop recording\n        console.log('trigger stopRecording');\n      }\n    } catch (error) {\n      console.log('Error triggering updateScreen:', error);\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"trigger.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/trigger.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Socket } from 'socket.io-client';\nimport { Participant, AutoAdjustType, ScreenState, EventType } from '../@types/types';\n\nexport interface TriggerParameters {\n  socket: Socket;\n  roomName: string;\n  screenStates: ScreenState[];\n  participants: Participant[];\n  updateDateState?: number | null;\n  lastUpdate: number | null;\n  nForReadjust: number;\n  eventType: EventType;\n  shared: boolean;\n  shareScreenStarted: boolean;\n  whiteboardStarted: boolean;\n  whiteboardEnded: boolean;\n  updateUpdateDateState: (timestamp: number | null) => void;\n  updateLastUpdate: (lastUpdate: number | null) => void;\n  updateNForReadjust: (nForReadjust: number) => void;\n\n  // mediasfu functions\n  autoAdjust: AutoAdjustType;\n\n  getUpdatedAllParams: () => TriggerParameters;\n  [key: string]: any;\n}\n\nexport interface TriggerOptions {\n  ref_ActiveNames: string[];\n  parameters: TriggerParameters;\n}\n\n// Export the type definition for the function\nexport type TriggerType = (options: TriggerOptions) => Promise<void>;\n\n/**\n * Triggers an update to the screen client based on the provided parameters.\n *\n * This function handles various conditions to determine the main screen person,\n * adjusts the screen states, and emits an update to the screen client via socket.\n *\n * @param {TriggerOptions} options - The options for triggering the update.\n * @param {string[]} options.ref_ActiveNames - Reference to the active names.\n * @param {TriggerParameters} options.parameters - The parameters for the trigger.\n * @returns {Promise<void>} A promise that resolves when the trigger is complete.\n *\n * @throws Will throw an error if the updateScreenClient operation fails.\n *\n * @example\n * ```typescript\n * await trigger({\n *   ref_ActiveNames: [\"user1\", \"user2\"],\n *   parameters: {\n *     socket: socketInstance,\n *     roomName: \"room1\",\n *     screenStates: [{ mainScreenPerson: \"user1\", mainScreenFilled: true, adminOnMainScreen: false }],\n *     participants: [{ name: \"admin\", islevel: \"2\" }],\n *     updateDateState: 0,\n *     lastUpdate: null,\n *     nForReadjust: 0,\n *     eventType: \"conference\",\n *     shared: false,\n *     shareScreenStarted: false,\n *     whiteboardStarted: false,\n *     whiteboardEnded: false,\n *     updateUpdateDateState: (date) => {},\n *     updateLastUpdate: (date) => {},\n *     updateNForReadjust: (n) => {},\n *     autoAdjust: async ({ n, parameters }) => [n, 0],\n *   },\n * });\n * ```\n */\n\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class Trigger {\n  /**\n   * Triggers an update to the screen client based on the provided parameters.\n   *\n   * @param {TriggerOptions} options - The options for triggering the update.\n   * @param {string[]} options.ref_ActiveNames - Reference to the active names.\n   * @param {Parameters} options.parameters - The parameters for the trigger.\n   * @returns {Promise<void>} A promise that resolves when the trigger is complete.\n   *\n   * @throws Will throw an error if the updateScreenClient operation fails.\n   *\n   * @remarks\n   * This function handles various conditions to determine the main screen person,\n   * adjusts the screen states, and emits an update to the screen client via socket.\n   *\n   * @example\n   * ```typescript\n   * await trigger({\n   *   ref_ActiveNames: [\"user1\", \"user2\"],\n   *   parameters: {\n   *     socket: socketInstance,\n   *     roomName: \"room1\",\n   *     screenStates: [{ mainScreenPerson: \"user1\", mainScreenFilled: true, adminOnMainScreen: false }],\n   *     participants: [{ name: \"admin\", islevel: \"2\" }],\n   *     updateDateState: 0,\n   *     lastUpdate: null,\n   *     nForReadjust: 0,\n   *     eventType: \"conference\",\n   *     shared: false,\n   *     shareScreenStarted: false,\n   *     whiteboardStarted: false,\n   *     whiteboardEnded: false,\n   *     updateUpdateDateState: (date) => {},\n   *     updateLastUpdate: (date) => {},\n   *     updateNForReadjust: (n) => {},\n   *     autoAdjust: async ({ n, parameters }) => [n, 0],\n   *   },\n   * });\n   * ```\n   */\n  async trigger({ ref_ActiveNames, parameters }: TriggerOptions): Promise<void> {\n    // Function to trigger the updateScreen event\n\n    try {\n      let {\n        socket,\n        roomName,\n        screenStates,\n        participants,\n        updateDateState,\n        lastUpdate,\n        nForReadjust,\n        eventType,\n        shared,\n        shareScreenStarted,\n        whiteboardStarted,\n        whiteboardEnded,\n\n        updateUpdateDateState,\n        updateLastUpdate,\n        updateNForReadjust,\n\n        autoAdjust,\n      } = parameters;\n\n      let personOnMainScreen = screenStates[0].mainScreenPerson;\n\n      let adminName = '';\n      const admin = participants.filter((participant: Participant) => participant.islevel == '2');\n      if (admin.length > 0) {\n        adminName = admin[0].name || '';\n      }\n      if (personOnMainScreen === 'WhiteboardActive') {\n        personOnMainScreen = adminName;\n      }\n\n      let mainfilled = screenStates[0].mainScreenFilled;\n      let adminOnMain = screenStates[0].adminOnMainScreen;\n      let nForReadjust_;\n      let val1;\n\n      let noww = new Date().getTime();\n      // get now in seconds\n      let timestamp = Math.floor(noww / 1000);\n\n      let eventPass = false;\n      if (eventType === 'conference' && !(shared || shareScreenStarted)) {\n        eventPass = true;\n        personOnMainScreen = adminName;\n        if (!ref_ActiveNames.includes(adminName)) {\n          ref_ActiveNames.unshift(adminName);\n        }\n      }\n\n      if ((mainfilled && personOnMainScreen != null && adminOnMain) || eventPass) {\n        if (eventType === 'conference') {\n          nForReadjust = nForReadjust + 1;\n          updateNForReadjust(nForReadjust);\n        }\n\n        if (!ref_ActiveNames.includes(adminName) && whiteboardStarted && !whiteboardEnded) {\n          ref_ActiveNames.unshift(adminName);\n        }\n\n        nForReadjust_ = ref_ActiveNames.length;\n\n        if (nForReadjust_ === 0 && eventType === 'webinar') {\n          val1 = 0;\n        } else {\n          const [val11] = await autoAdjust({\n            n: nForReadjust_,\n            eventType,\n            shared,\n            shareScreenStarted,\n          });\n          val1 = val11;\n        }\n\n        let calc1 = Math.floor((val1 / 12) * 100);\n        let calc2 = 100 - calc1;\n\n        // check if lastUpdate is not null and at least same seconds\n        if (lastUpdate == null || updateDateState != timestamp) {\n          let now = new Date();\n\n          socket.emit(\n            'updateScreenClient',\n            {\n              roomName,\n              names: ref_ActiveNames,\n              mainPercent: calc2,\n              mainScreenPerson: personOnMainScreen,\n              viewType: eventType,\n            },\n            ({ success, reason }: { success: boolean; reason: string }) => {\n              updateDateState = timestamp;\n              updateUpdateDateState(updateDateState);\n              lastUpdate = Math.floor(now.getTime() / 1000);\n              updateLastUpdate(lastUpdate);\n              if (success) {\n                // handle success\n              } else {\n                console.log(reason, 'updateScreenClient failed');\n              }\n            },\n          );\n        }\n      } else if (mainfilled && personOnMainScreen != null && !adminOnMain) {\n        nForReadjust_ = ref_ActiveNames.length;\n\n        if (!ref_ActiveNames.includes(adminName)) {\n          ref_ActiveNames.unshift(adminName);\n          nForReadjust_ = ref_ActiveNames.length;\n        }\n\n        const [val11] = await autoAdjust({\n          n: nForReadjust_,\n          eventType,\n          shared,\n          shareScreenStarted,\n        });\n\n        val1 = val11;\n\n        const calc1 = Math.floor((val1 / 12) * 100);\n        const calc2 = 100 - calc1;\n\n        if (lastUpdate == null || updateDateState != timestamp) {\n          let now = new Date();\n\n          socket.emit(\n            'updateScreenClient',\n            {\n              roomName,\n              names: ref_ActiveNames,\n              mainPercent: calc2,\n              mainScreenPerson: personOnMainScreen,\n              viewType: eventType,\n            },\n            ({ success, reason }: { success: boolean; reason: string }) => {\n              updateDateState = timestamp;\n              updateUpdateDateState(updateDateState);\n              lastUpdate = Math.floor(now.getTime() / 1000);\n              updateLastUpdate(lastUpdate);\n              if (success) {\n                // handle success\n              } else {\n                console.log(reason, 'updateScreenClient failed');\n              }\n            },\n          );\n        }\n      } else {\n        // stop recording\n        console.log('trigger stopRecording');\n      }\n    } catch (error) {\n      console.log('Error triggering updateScreen:', error);\n    }\n  }\n}\n"]}

package/dist/esm2022/lib/consumers/update-mini-cards-grid.service.mjs

@@ -1,5 +1,59 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Updates the mini cards grid based on the specified rows and columns.
+ *
+ * This method calculates the dimensions for the mini cards based on the provided
+ * rows and columns, as well as the container sizes. It also considers pagination
+ * settings and updates the grid sizes accordingly. The method can update either
+ * the default grid or an alternative grid based on the `defal` parameter.
+ *
+ * @param {UpdateMiniCardsGridOptions} options - The options for updating the mini cards grid.
+ * @param {number} options.rows - The number of rows in the grid.
+ * @param {number} options.cols - The number of columns in the grid.
+ * @param {boolean} [options.defal=true] - Flag indicating whether to update the default grid or an alternative grid.
+ * @param {number} [options.actualRows=2] - The actual number of rows in the grid.
+ * @param {UpdateMiniCardsGridParameters} options.parameters - Additional parameters needed for the function.
+ * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+ * @param {Function} options.parameters.updateGridRows - Function to update the grid rows.
+ * @param {Function} options.parameters.updateGridCols - Function to update the grid columns.
+ * @param {Function} options.parameters.updateAltGridRows - Function to update the alternative grid rows.
+ * @param {Function} options.parameters.updateAltGridCols - Function to update the alternative grid columns.
+ * @param {Function} options.parameters.updateGridSizes - Function to update the grid sizes.
+ * @param {GridSizes} options.parameters.gridSizes - Object containing grid width and height.
+ * @param {string} options.parameters.paginationDirection - The direction of pagination ('horizontal' or 'vertical').
+ * @param {number} options.parameters.paginationHeightWidth - The height or width of pagination.
+ * @param {boolean} options.parameters.doPaginate - Flag indicating whether pagination is enabled.
+ * @param {ComponentSizes} options.parameters.componentSizes - Object containing container width and height.
+ * @param {EventType} options.parameters.eventType - The type of event ('chat', etc.).
+ *
+ * @returns {Promise<void>} - A Promise that resolves after updating the mini cards grid.
+ *
+ * @example
+ * ```typescript
+ * const gridOptions = {
+ *   rows: 3,
+ *   cols: 4,
+ *   parameters: {
+ *     getUpdatedAllParams: () => updatedParams,
+ *     updateGridRows: (rows) => console.log(`Grid Rows Updated: ${rows}`),
+ *     updateGridCols: (cols) => console.log(`Grid Cols Updated: ${cols}`),
+ *     updateAltGridRows: (rows) => console.log(`Alt Grid Rows Updated: ${rows}`),
+ *     updateAltGridCols: (cols) => console.log(`Alt Grid Cols Updated: ${cols}`),
+ *     updateGridSizes: (sizes) => console.log(`Grid Sizes Updated: ${JSON.stringify(sizes)}`),
+ *     gridSizes: { gridWidth: 100, gridHeight: 100 },
+ *     paginationDirection: 'horizontal',
+ *     paginationHeightWidth: 50,
+ *     doPaginate: true,
+ *     componentSizes: { otherWidth: 800, otherHeight: 600 },
+ *     eventType: 'chat',
+ *   },
+ * };
+ *
+ * const miniCardGridService = new UpdateMiniCardsGrid();
+ * miniCardGridService.updateMiniCardsGrid(gridOptions);
+ * ```
+ */
 export class UpdateMiniCardsGrid {
     /**
      * Updates the mini cards grid based on the specified rows and columns.
@@ -78,4 +132,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"update-mini-cards-grid.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/update-mini-cards-grid.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAiC3C,MAAM,OAAO,mBAAmB;IAC9B;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,KAAK,CAAC,mBAAmB,CAAC,EACxB,IAAI,EACJ,IAAI,EACJ,KAAK,GAAG,IAAI,EACZ,UAAU,GAAG,CAAC,EACd,UAAU,GACiB;QAC3B,IAAI,EAAE,mBAAmB,EAAE,GAAG,UAAU,CAAC;QACzC,UAAU,GAAG,mBAAmB,EAAE,CAAC;QAEnC,IAAI,EACF,cAAc,EACd,cAAc,EACd,iBAAiB,EACjB,iBAAiB,EACjB,eAAe,EAEf,SAAS,EACT,mBAAmB,EACnB,qBAAqB,EACrB,UAAU,EACV,cAAc,EACd,SAAS,GACV,GAAG,UAAU,CAAC;QAEf,IAAI,cAAc,GAAG,cAAc,CAAC,UAAU,CAAC;QAC/C,IAAI,eAAe,GAAG,cAAc,CAAC,WAAW,CAAC;QAEjD,IAAI,UAAU,EAAE,CAAC;YACf,uDAAuD;YACvD,IAAI,mBAAmB,IAAI,YAAY,EAAE,CAAC;gBACxC,eAAe,GAAG,eAAe,GAAG,qBAAqB,CAAC;YAC5D,CAAC;iBAAM,CAAC;gBACN,cAAc,GAAG,cAAc,GAAG,qBAAqB,CAAC;YAC1D,CAAC;QACH,CAAC;QAED,IAAI,WAAW,GAAG,CAAC,CAAC,CAAC,2BAA2B;QAChD,IAAI,SAAS,IAAI,MAAM,EAAE,CAAC;YACxB,WAAW,GAAG,CAAC,CAAC;QAClB,CAAC;QACD,IAAI,sBAAsB,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,WAAW,CAAC;QACtD,IAAI,oBAAoB,GAAG,CAAC,UAAU,GAAG,CAAC,CAAC,GAAG,WAAW,CAAC;QAC1D,IAAI,SAAS,CAAC;QACd,IAAI,UAAU,CAAC;QACf,IAAI,IAAI,IAAI,CAAC,IAAI,UAAU,IAAI,CAAC,EAAE,CAAC;YACjC,SAAS,GAAG,CAAC,CAAC;YACd,UAAU,GAAG,CAAC,CAAC;QACjB,CAAC;aAAM,CAAC;YACN,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,cAAc,GAAG,sBAAsB,CAAC,GAAG,IAAI,CAAC,CAAC;YACzE,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,eAAe,GAAG,oBAAoB,CAAC,GAAG,UAAU,CAAC,CAAC;QACjF,CAAC;QAED,IAAI,KAAK,EAAE,CAAC;YACV,cAAc,CAAC,IAAI,CAAC,CAAC;YACrB,cAAc,CAAC,IAAI,CAAC,CAAC;YAErB,SAAS,GAAG,EAAE,GAAG,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU,EAAE,CAAC;YAC3E,eAAe,CAAC,SAAS,CAAC,CAAC;QAC7B,CAAC;aAAM,CAAC;YACN,iBAAiB,CAAC,IAAI,CAAC,CAAC;YACxB,iBAAiB,CAAC,IAAI,CAAC,CAAC;YAExB,SAAS,GAAG,EAAE,GAAG,SAAS,EAAE,YAAY,EAAE,SAAS,EAAE,aAAa,EAAE,UAAU,EAAE,CAAC;YACjF,eAAe,CAAC,SAAS,CAAC,CAAC;QAC7B,CAAC;IACH,CAAC;uGA3FU,mBAAmB;2GAAnB,mBAAmB,cAFlB,MAAM;;2FAEP,mBAAmB;kBAH/B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { GridSizes, ComponentSizes, EventType } from '../@types/types';\nexport interface UpdateMiniCardsGridParameters {\n  updateGridRows: (rows: number) => void;\n  updateGridCols: (cols: number) => void;\n  updateAltGridRows: (rows: number) => void;\n  updateAltGridCols: (cols: number) => void;\n  updateGridSizes: (gridSizes: GridSizes) => void;\n  gridSizes: GridSizes;\n  paginationDirection: string;\n  paginationHeightWidth: number;\n  doPaginate: boolean;\n  componentSizes: ComponentSizes;\n  eventType: EventType;\n\n  getUpdatedAllParams: () => UpdateMiniCardsGridParameters;\n  [key: string]: any;\n}\n\nexport interface UpdateMiniCardsGridOptions {\n  rows: number;\n  cols: number;\n  defal?: boolean;\n  actualRows?: number;\n  parameters: UpdateMiniCardsGridParameters;\n}\n\n// Export the type definition for the function\nexport type UpdateMiniCardsGridType = (options: UpdateMiniCardsGridOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class UpdateMiniCardsGrid {\n  /**\n   * Updates the mini cards grid based on the specified rows and columns.\n   *\n   * @param {object} options - The function parameters.\n   * @param {number} options.rows - The number of rows in the grid.\n   * @param {number} options.cols - The number of columns in the grid.\n   * @param {boolean} options.defal - Flag indicating whether to update the default grid or an alternative grid.\n   * @param {number} options.actualRows - The actual number of rows in the grid.\n   * @param {number} options.ind - The index parameter.\n   * @param {object} options.parameters - Additional parameters needed for the function.\n   * @param {function} options.parameters.getUpdatedAllParams - Function to get updated parameters.\n   * @param {function} options.parameters.updateGridRows - Function to update the grid rows.\n   * @param {function} options.parameters.updateGridCols - Function to update the grid columns.\n   * @param {function} options.parameters.updateAltGridRows - Function to update the alternative grid rows.\n   * @param {function} options.parameters.updateAltGridCols - Function to update the alternative grid columns.\n   * @param {function} options.parameters.updateGridSizes - Function to update the grid sizes.\n   * @param {object} options.parameters.gridSizes - Object containing grid width and height.\n   * @param {string} options.parameters.paginationDirection - The direction of pagination ('horizontal' or 'vertical').\n   * @param {number} options.parameters.paginationHeightWidth - The height or width of pagination.\n   * @param {boolean} options.parameters.doPaginate - Flag indicating whether pagination is enabled.\n   * @param {object} options.parameters.componentSizes - Object containing container width and height.\n   * @param {string} options.parameters.eventType - The type of event ('chat', etc.).\n   * @returns {Promise<void>} - A Promise that resolves after updating the mini cards grid.\n   */\n  async updateMiniCardsGrid({\n    rows,\n    cols,\n    defal = true,\n    actualRows = 2,\n    parameters,\n  }: UpdateMiniCardsGridOptions): Promise<void> {\n    let { getUpdatedAllParams } = parameters;\n    parameters = getUpdatedAllParams();\n\n    let {\n      updateGridRows,\n      updateGridCols,\n      updateAltGridRows,\n      updateAltGridCols,\n      updateGridSizes,\n\n      gridSizes,\n      paginationDirection,\n      paginationHeightWidth,\n      doPaginate,\n      componentSizes,\n      eventType,\n    } = parameters;\n\n    let containerWidth = componentSizes.otherWidth;\n    let containerHeight = componentSizes.otherHeight;\n\n    if (doPaginate) {\n      // if pagination is enabled and direction is horizontal\n      if (paginationDirection == 'horizontal') {\n        containerHeight = containerHeight - paginationHeightWidth;\n      } else {\n        containerWidth = containerWidth - paginationHeightWidth;\n      }\n    }\n\n    let cardSpacing = 3; // 3px margin between cards\n    if (eventType == 'chat') {\n      cardSpacing = 0;\n    }\n    let totalSpacingHorizontal = (cols - 1) * cardSpacing;\n    let totalSpacingVertical = (actualRows - 1) * cardSpacing;\n    let cardWidth;\n    let cardHeight;\n    if (cols == 0 || actualRows == 0) {\n      cardWidth = 0;\n      cardHeight = 0;\n    } else {\n      cardWidth = Math.floor((containerWidth - totalSpacingHorizontal) / cols);\n      cardHeight = Math.floor((containerHeight - totalSpacingVertical) / actualRows);\n    }\n\n    if (defal) {\n      updateGridRows(rows);\n      updateGridCols(cols);\n\n      gridSizes = { ...gridSizes, gridWidth: cardWidth, gridHeight: cardHeight };\n      updateGridSizes(gridSizes);\n    } else {\n      updateAltGridRows(rows);\n      updateAltGridCols(cols);\n\n      gridSizes = { ...gridSizes, altGridWidth: cardWidth, altGridHeight: cardHeight };\n      updateGridSizes(gridSizes);\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"update-mini-cards-grid.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/update-mini-cards-grid.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AA8B3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AAMH,MAAM,OAAO,mBAAmB;IAC9B;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,KAAK,CAAC,mBAAmB,CAAC,EACxB,IAAI,EACJ,IAAI,EACJ,KAAK,GAAG,IAAI,EACZ,UAAU,GAAG,CAAC,EACd,UAAU,GACiB;QAC3B,IAAI,EAAE,mBAAmB,EAAE,GAAG,UAAU,CAAC;QACzC,UAAU,GAAG,mBAAmB,EAAE,CAAC;QAEnC,IAAI,EACF,cAAc,EACd,cAAc,EACd,iBAAiB,EACjB,iBAAiB,EACjB,eAAe,EAEf,SAAS,EACT,mBAAmB,EACnB,qBAAqB,EACrB,UAAU,EACV,cAAc,EACd,SAAS,GACV,GAAG,UAAU,CAAC;QAEf,IAAI,cAAc,GAAG,cAAc,CAAC,UAAU,CAAC;QAC/C,IAAI,eAAe,GAAG,cAAc,CAAC,WAAW,CAAC;QAEjD,IAAI,UAAU,EAAE,CAAC;YACf,uDAAuD;YACvD,IAAI,mBAAmB,IAAI,YAAY,EAAE,CAAC;gBACxC,eAAe,GAAG,eAAe,GAAG,qBAAqB,CAAC;YAC5D,CAAC;iBAAM,CAAC;gBACN,cAAc,GAAG,cAAc,GAAG,qBAAqB,CAAC;YAC1D,CAAC;QACH,CAAC;QAED,IAAI,WAAW,GAAG,CAAC,CAAC,CAAC,2BAA2B;QAChD,IAAI,SAAS,IAAI,MAAM,EAAE,CAAC;YACxB,WAAW,GAAG,CAAC,CAAC;QAClB,CAAC;QACD,IAAI,sBAAsB,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,WAAW,CAAC;QACtD,IAAI,oBAAoB,GAAG,CAAC,UAAU,GAAG,CAAC,CAAC,GAAG,WAAW,CAAC;QAC1D,IAAI,SAAS,CAAC;QACd,IAAI,UAAU,CAAC;QACf,IAAI,IAAI,IAAI,CAAC,IAAI,UAAU,IAAI,CAAC,EAAE,CAAC;YACjC,SAAS,GAAG,CAAC,CAAC;YACd,UAAU,GAAG,CAAC,CAAC;QACjB,CAAC;aAAM,CAAC;YACN,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,cAAc,GAAG,sBAAsB,CAAC,GAAG,IAAI,CAAC,CAAC;YACzE,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,eAAe,GAAG,oBAAoB,CAAC,GAAG,UAAU,CAAC,CAAC;QACjF,CAAC;QAED,IAAI,KAAK,EAAE,CAAC;YACV,cAAc,CAAC,IAAI,CAAC,CAAC;YACrB,cAAc,CAAC,IAAI,CAAC,CAAC;YAErB,SAAS,GAAG,EAAE,GAAG,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU,EAAE,CAAC;YAC3E,eAAe,CAAC,SAAS,CAAC,CAAC;QAC7B,CAAC;aAAM,CAAC;YACN,iBAAiB,CAAC,IAAI,CAAC,CAAC;YACxB,iBAAiB,CAAC,IAAI,CAAC,CAAC;YAExB,SAAS,GAAG,EAAE,GAAG,SAAS,EAAE,YAAY,EAAE,SAAS,EAAE,aAAa,EAAE,UAAU,EAAE,CAAC;YACjF,eAAe,CAAC,SAAS,CAAC,CAAC;QAC7B,CAAC;IACH,CAAC;uGA3FU,mBAAmB;2GAAnB,mBAAmB,cAFlB,MAAM;;2FAEP,mBAAmB;kBAH/B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { GridSizes, ComponentSizes, EventType } from '../@types/types';\nexport interface UpdateMiniCardsGridParameters {\n  updateGridRows: (rows: number) => void;\n  updateGridCols: (cols: number) => void;\n  updateAltGridRows: (rows: number) => void;\n  updateAltGridCols: (cols: number) => void;\n  updateGridSizes: (gridSizes: GridSizes) => void;\n  gridSizes: GridSizes;\n  paginationDirection: string;\n  paginationHeightWidth: number;\n  doPaginate: boolean;\n  componentSizes: ComponentSizes;\n  eventType: EventType;\n\n  getUpdatedAllParams: () => UpdateMiniCardsGridParameters;\n  [key: string]: any;\n}\n\nexport interface UpdateMiniCardsGridOptions {\n  rows: number;\n  cols: number;\n  defal?: boolean;\n  actualRows?: number;\n  parameters: UpdateMiniCardsGridParameters;\n}\n\n// Export the type definition for the function\nexport type UpdateMiniCardsGridType = (options: UpdateMiniCardsGridOptions) => Promise<void>;\n\n/**\n * Updates the mini cards grid based on the specified rows and columns.\n *\n * This method calculates the dimensions for the mini cards based on the provided\n * rows and columns, as well as the container sizes. It also considers pagination\n * settings and updates the grid sizes accordingly. The method can update either\n * the default grid or an alternative grid based on the `defal` parameter.\n *\n * @param {UpdateMiniCardsGridOptions} options - The options for updating the mini cards grid.\n * @param {number} options.rows - The number of rows in the grid.\n * @param {number} options.cols - The number of columns in the grid.\n * @param {boolean} [options.defal=true] - Flag indicating whether to update the default grid or an alternative grid.\n * @param {number} [options.actualRows=2] - The actual number of rows in the grid.\n * @param {UpdateMiniCardsGridParameters} options.parameters - Additional parameters needed for the function.\n * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.\n * @param {Function} options.parameters.updateGridRows - Function to update the grid rows.\n * @param {Function} options.parameters.updateGridCols - Function to update the grid columns.\n * @param {Function} options.parameters.updateAltGridRows - Function to update the alternative grid rows.\n * @param {Function} options.parameters.updateAltGridCols - Function to update the alternative grid columns.\n * @param {Function} options.parameters.updateGridSizes - Function to update the grid sizes.\n * @param {GridSizes} options.parameters.gridSizes - Object containing grid width and height.\n * @param {string} options.parameters.paginationDirection - The direction of pagination ('horizontal' or 'vertical').\n * @param {number} options.parameters.paginationHeightWidth - The height or width of pagination.\n * @param {boolean} options.parameters.doPaginate - Flag indicating whether pagination is enabled.\n * @param {ComponentSizes} options.parameters.componentSizes - Object containing container width and height.\n * @param {EventType} options.parameters.eventType - The type of event ('chat', etc.).\n *\n * @returns {Promise<void>} - A Promise that resolves after updating the mini cards grid.\n *\n * @example\n * ```typescript\n * const gridOptions = {\n *   rows: 3,\n *   cols: 4,\n *   parameters: {\n *     getUpdatedAllParams: () => updatedParams,\n *     updateGridRows: (rows) => console.log(`Grid Rows Updated: ${rows}`),\n *     updateGridCols: (cols) => console.log(`Grid Cols Updated: ${cols}`),\n *     updateAltGridRows: (rows) => console.log(`Alt Grid Rows Updated: ${rows}`),\n *     updateAltGridCols: (cols) => console.log(`Alt Grid Cols Updated: ${cols}`),\n *     updateGridSizes: (sizes) => console.log(`Grid Sizes Updated: ${JSON.stringify(sizes)}`),\n *     gridSizes: { gridWidth: 100, gridHeight: 100 },\n *     paginationDirection: 'horizontal',\n *     paginationHeightWidth: 50,\n *     doPaginate: true,\n *     componentSizes: { otherWidth: 800, otherHeight: 600 },\n *     eventType: 'chat',\n *   },\n * };\n *\n * const miniCardGridService = new UpdateMiniCardsGrid();\n * miniCardGridService.updateMiniCardsGrid(gridOptions);\n * ```\n */\n\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class UpdateMiniCardsGrid {\n  /**\n   * Updates the mini cards grid based on the specified rows and columns.\n   *\n   * @param {object} options - The function parameters.\n   * @param {number} options.rows - The number of rows in the grid.\n   * @param {number} options.cols - The number of columns in the grid.\n   * @param {boolean} options.defal - Flag indicating whether to update the default grid or an alternative grid.\n   * @param {number} options.actualRows - The actual number of rows in the grid.\n   * @param {number} options.ind - The index parameter.\n   * @param {object} options.parameters - Additional parameters needed for the function.\n   * @param {function} options.parameters.getUpdatedAllParams - Function to get updated parameters.\n   * @param {function} options.parameters.updateGridRows - Function to update the grid rows.\n   * @param {function} options.parameters.updateGridCols - Function to update the grid columns.\n   * @param {function} options.parameters.updateAltGridRows - Function to update the alternative grid rows.\n   * @param {function} options.parameters.updateAltGridCols - Function to update the alternative grid columns.\n   * @param {function} options.parameters.updateGridSizes - Function to update the grid sizes.\n   * @param {object} options.parameters.gridSizes - Object containing grid width and height.\n   * @param {string} options.parameters.paginationDirection - The direction of pagination ('horizontal' or 'vertical').\n   * @param {number} options.parameters.paginationHeightWidth - The height or width of pagination.\n   * @param {boolean} options.parameters.doPaginate - Flag indicating whether pagination is enabled.\n   * @param {object} options.parameters.componentSizes - Object containing container width and height.\n   * @param {string} options.parameters.eventType - The type of event ('chat', etc.).\n   * @returns {Promise<void>} - A Promise that resolves after updating the mini cards grid.\n   */\n  async updateMiniCardsGrid({\n    rows,\n    cols,\n    defal = true,\n    actualRows = 2,\n    parameters,\n  }: UpdateMiniCardsGridOptions): Promise<void> {\n    let { getUpdatedAllParams } = parameters;\n    parameters = getUpdatedAllParams();\n\n    let {\n      updateGridRows,\n      updateGridCols,\n      updateAltGridRows,\n      updateAltGridCols,\n      updateGridSizes,\n\n      gridSizes,\n      paginationDirection,\n      paginationHeightWidth,\n      doPaginate,\n      componentSizes,\n      eventType,\n    } = parameters;\n\n    let containerWidth = componentSizes.otherWidth;\n    let containerHeight = componentSizes.otherHeight;\n\n    if (doPaginate) {\n      // if pagination is enabled and direction is horizontal\n      if (paginationDirection == 'horizontal') {\n        containerHeight = containerHeight - paginationHeightWidth;\n      } else {\n        containerWidth = containerWidth - paginationHeightWidth;\n      }\n    }\n\n    let cardSpacing = 3; // 3px margin between cards\n    if (eventType == 'chat') {\n      cardSpacing = 0;\n    }\n    let totalSpacingHorizontal = (cols - 1) * cardSpacing;\n    let totalSpacingVertical = (actualRows - 1) * cardSpacing;\n    let cardWidth;\n    let cardHeight;\n    if (cols == 0 || actualRows == 0) {\n      cardWidth = 0;\n      cardHeight = 0;\n    } else {\n      cardWidth = Math.floor((containerWidth - totalSpacingHorizontal) / cols);\n      cardHeight = Math.floor((containerHeight - totalSpacingVertical) / actualRows);\n    }\n\n    if (defal) {\n      updateGridRows(rows);\n      updateGridCols(cols);\n\n      gridSizes = { ...gridSizes, gridWidth: cardWidth, gridHeight: cardHeight };\n      updateGridSizes(gridSizes);\n    } else {\n      updateAltGridRows(rows);\n      updateAltGridCols(cols);\n\n      gridSizes = { ...gridSizes, altGridWidth: cardWidth, altGridHeight: cardHeight };\n      updateGridSizes(gridSizes);\n    }\n  }\n}\n"]}

package/dist/esm2022/lib/consumers/update-participant-audio-decibels.service.mjs

@@ -1,5 +1,50 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Updates or adds a participant's audio decibel data in the array.
+ *
+ * This method checks if a participant's name exists in the audio decibels array.
+ * If it does, it updates the participant's `averageLoudness`; otherwise, it adds a new entry.
+ * After modification, it calls `updateAudioDecibels` to apply the changes to the array.
+ *
+ * @param {UpdateParticipantAudioDecibelsOptions} options - The options for updating participant audio decibels.
+ * @param {string} options.name - The name of the participant.
+ * @param {number} options.averageLoudness - The current average loudness of the participant.
+ * @param {AudioDecibels[]} options.audioDecibels - The array of current audio decibel entries.
+ * @param {Function} options.updateAudioDecibels - The function to update the audio decibels array.
+ *
+ * @returns {void} - This function does not return a value.
+ *
+ * @example
+ * ```typescript
+ * const audioDecibels = [
+ *   { name: 'Alice', averageLoudness: -10 },
+ *   { name: 'Bob', averageLoudness: -12 },
+ * ];
+ *
+ * const updateAudioDecibels = (newDecibels) => {
+ *   console.log('Updated audio decibels:', newDecibels);
+ * };
+ *
+ * const updateService = new UpdateParticipantAudioDecibels();
+ *
+ * // Update existing participant
+ * updateService.updateParticipantAudioDecibels({
+ *   name: 'Alice',
+ *   averageLoudness: -8,
+ *   audioDecibels,
+ *   updateAudioDecibels,
+ * });
+ *
+ * // Add a new participant
+ * updateService.updateParticipantAudioDecibels({
+ *   name: 'Charlie',
+ *   averageLoudness: -15,
+ *   audioDecibels,
+ *   updateAudioDecibels,
+ * });
+ * ```
+ */
 export class UpdateParticipantAudioDecibels {
     /**
      * Updates the audio decibels for a participant.
@@ -36,4 +81,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/background-methods/launch-background.service.mjs

@@ -1,5 +1,30 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Toggles the visibility of the background modal.
+ *
+ * This method updates the visibility state of the background modal by calling
+ * the provided update function with the negation of the current visibility state.
+ *
+ * @param {LaunchBackgroundOptions} options - The options object containing necessary variables and functions.
+ * @param {Function} options.updateIsBackgroundModalVisible - Function to update the visibility state of the background modal.
+ * @param {boolean} options.isBackgroundModalVisible - Current visibility state of the background modal.
+ *
+ * @returns {void}
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   updateIsBackgroundModalVisible: (isVisible) => {
+ *     console.log(`Background modal is now ${isVisible ? 'visible' : 'hidden'}.`);
+ *   },
+ *   isBackgroundModalVisible: false,
+ * };
+ *
+ * const launchBackgroundService = new LaunchBackground();
+ * launchBackgroundService.launchBackground(options);
+ * ```
+ */
 export class LaunchBackground {
     /**
      * Toggles the visibility of the background modal.
@@ -20,4 +45,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/breakout-room-methods/breakout-room-updated.service.mjs

@@ -1,5 +1,76 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Updates the state of breakout rooms based on the provided data and parameters.
+ *
+ * This method handles changes in breakout rooms, updates the relevant state variables,
+ * and triggers necessary UI updates based on the current status of the breakout rooms.
+ *
+ * @param {BreakoutRoomUpdatedOptions} options - The options object containing the data and parameters.
+ * @param {BreakoutRoomUpdatedData} options.data - The data object containing information about the breakout rooms.
+ * @param {BreakoutRoomUpdatedParameters} options.parameters - The parameters object containing various state update functions and other parameters.
+ * @param {boolean} options.parameters.breakOutRoomStarted - Indicates if the breakout room has started.
+ * @param {boolean} options.parameters.breakOutRoomEnded - Indicates if the breakout room has ended.
+ * @param {Array<BreakoutParticipant[]>} options.parameters.breakoutRooms - The list of current breakout rooms.
+ * @param {number} options.parameters.hostNewRoom - The ID of the new room for the host.
+ * @param {string} options.parameters.islevel - The level of the breakout room (e.g., '2' for host).
+ * @param {Array<Participant>} options.parameters.participantsAll - The list of all participants.
+ * @param {Array<Participant>} options.parameters.participants - The list of participants who are not banned.
+ * @param {string} options.parameters.meetingDisplayType - The current display type of the meeting.
+ * @param {string} options.parameters.prevMeetingDisplayType - The previous display type of the meeting.
+ * @param {Function} options.parameters.updateBreakoutRooms - Function to update the breakout rooms.
+ * @param {Function} options.parameters.updateBreakOutRoomStarted - Function to update the breakout room started state.
+ * @param {Function} options.parameters.updateBreakOutRoomEnded - Function to update the breakout room ended state.
+ * @param {Function} options.parameters.updateHostNewRoom - Function to update the host's new room.
+ * @param {Function} options.parameters.updateMeetingDisplayType - Function to update the meeting display type.
+ * @param {Function} options.parameters.updateParticipantsAll - Function to update the list of all participants.
+ * @param {Function} options.parameters.updateParticipants - Function to update the list of participants who are not banned.
+ * @param {Function} options.parameters.onScreenChanges - Function to handle screen changes.
+ * @param {Function} options.parameters.rePort - Function to handle reporting.
+ *
+ * @returns {Promise<void>} A promise that resolves when the breakout room state has been updated.
+ *
+ * @throws Will throw an error if the update process fails.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   data: {
+ *     forHost: true,
+ *     newRoom: 3,
+ *     status: 'started',
+ *     members: [
+ *       { name: 'user1', isBanned: false, audioID: 'audio1', videoID: 'video1' },
+ *       { name: 'user2', isBanned: true, audioID: 'audio2', videoID: 'video2' },
+ *     ],
+ *     breakoutRooms: [[{ name: 'user1' }, { name: 'user2' }]],
+ *   },
+ *   parameters: {
+ *     socket: socketInstance,
+ *     roomName: 'mainRoom',
+ *     screenStates: [{ mainScreenPerson: 'user1', mainScreenFilled: true, adminOnMainScreen: false }],
+ *     participants: [{ name: 'admin', islevel: '2' }],
+ *     breakOutRoomStarted: false,
+ *     breakOutRoomEnded: false,
+ *     hostNewRoom: 0,
+ *     islevel: '2',
+ *     participantsAll: [],
+ *     updateBreakoutRooms: (rooms) => {},
+ *     updateBreakOutRoomStarted: (started) => {},
+ *     updateBreakOutRoomEnded: (ended) => {},
+ *     updateHostNewRoom: (room) => {},
+ *     updateMeetingDisplayType: (type) => {},
+ *     updateParticipantsAll: (participants) => {},
+ *     updateParticipants: (participants) => {},
+ *     onScreenChanges: async () => {},
+ *     rePort: async () => {},
+ *   },
+ * };
+ *
+ * const breakoutRoomService = new BreakoutRoomUpdated();
+ * await breakoutRoomService.breakoutRoomUpdated(options);
+ * ```
+ */
 export class BreakoutRoomUpdated {
     /**
      * Updates the state of breakout rooms based on the provided data and parameters.
@@ -109,4 +180,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"breakout-room-updated.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/methods/breakout-room-methods/breakout-room-updated.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  BreakoutParticipant,\n  BreakoutRoomUpdatedData,\n  OnScreenChangesParameters,\n  OnScreenChangesType,\n  Participant,\n  RePortParameters,\n  RePortType,\n} from '../../@types/types';\n\nexport interface BreakoutRoomUpdatedParameters extends OnScreenChangesParameters, RePortParameters {\n  breakOutRoomStarted: boolean;\n  breakOutRoomEnded: boolean;\n  breakoutRooms: BreakoutParticipant[][];\n  hostNewRoom: number;\n  islevel: string;\n  participantsAll: Participant[];\n  participants: Participant[];\n  meetingDisplayType: string;\n  prevMeetingDisplayType: string;\n  updateBreakoutRooms: (rooms: BreakoutParticipant[][]) => void;\n  updateBreakOutRoomStarted: (started: boolean) => void;\n  updateBreakOutRoomEnded: (ended: boolean) => void;\n  updateHostNewRoom: (room: number) => void;\n  updateMeetingDisplayType: (type: string) => void;\n  updateParticipantsAll: (participants: Participant[]) => void;\n  updateParticipants: (participants: Participant[]) => void;\n\n  //mediasfu functions\n  onScreenChanges: OnScreenChangesType;\n  rePort: RePortType;\n\n  getUpdatedAllParams: () => BreakoutRoomUpdatedParameters;\n  [key: string]: any;\n}\n\nexport interface BreakoutRoomUpdatedOptions {\n  data: BreakoutRoomUpdatedData;\n  parameters: BreakoutRoomUpdatedParameters;\n}\n\n// Export the type definition for the function\nexport type BreakoutRoomUpdatedType = (options: BreakoutRoomUpdatedOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class BreakoutRoomUpdated {\n  /**\n   * Updates the state of breakout rooms based on the provided data and parameters.\n   *\n   * @param {Object} options - The options object.\n   * @param {Object} options.data - The data object containing information about the breakout rooms.\n   * @param {Object} options.parameters - The parameters object containing various state update functions and other parameters.\n   * @param {boolean} options.parameters.breakOutRoomStarted - Indicates if the breakout room has started.\n   * @param {boolean} options.parameters.breakOutRoomEnded - Indicates if the breakout room has ended.\n   * @param {Array} options.parameters.breakoutRooms - The list of current breakout rooms.\n   * @param {number} options.parameters.hostNewRoom - The ID of the new room for the host.\n   * @param {string} options.parameters.islevel - The level of the breakout room.\n   * @param {Array} options.parameters.participantsAll - The list of all participants.\n   * @param {Array} options.parameters.participants - The list of participants who are not banned.\n   * @param {string} options.parameters.meetingDisplayType - The current display type of the meeting.\n   * @param {string} options.parameters.prevMeetingDisplayType - The previous display type of the meeting.\n   * @param {Function} options.parameters.updateBreakoutRooms - Function to update the breakout rooms.\n   * @param {Function} options.parameters.updateBreakOutRoomStarted - Function to update the breakout room started state.\n   * @param {Function} options.parameters.updateBreakOutRoomEnded - Function to update the breakout room ended state.\n   * @param {Function} options.parameters.updateHostNewRoom - Function to update the host's new room.\n   * @param {Function} options.parameters.updateMeetingDisplayType - Function to update the meeting display type.\n   * @param {Function} options.parameters.updateParticipantsAll - Function to update the list of all participants.\n   * @param {Function} options.parameters.updateParticipants - Function to update the list of participants who are not banned.\n   * @param {Function} options.parameters.onScreenChanges - Function to handle screen changes.\n   * @param {Function} options.parameters.rePort - Function to handle reporting.\n   *\n   * @returns {Promise<void>} A promise that resolves when the breakout room state has been updated.\n   *\n   * @throws Will throw an error if the update process fails.\n   */\n\n  breakoutRoomUpdated = async ({ data, parameters }: BreakoutRoomUpdatedOptions): Promise<void> => {\n    try {\n      parameters = parameters.getUpdatedAllParams();\n\n      let {\n        breakOutRoomStarted,\n        breakOutRoomEnded,\n        breakoutRooms,\n        islevel,\n        participantsAll,\n        participants,\n\n        updateBreakoutRooms,\n        updateBreakOutRoomStarted,\n        updateBreakOutRoomEnded,\n        updateHostNewRoom,\n        updateMeetingDisplayType,\n        meetingDisplayType,\n        prevMeetingDisplayType,\n        updateParticipantsAll,\n        updateParticipants,\n\n        //mediaSfu functions\n        onScreenChanges,\n        rePort,\n      } = parameters;\n\n      if (data.forHost) {\n        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        updateHostNewRoom(data.newRoom!);\n        await onScreenChanges({ changed: true, parameters });\n        return;\n      }\n\n      if (islevel == '2' && data.members) {\n        //filter out the participant that isBanned == true\n        participantsAll = data.members;\n        //remove every field other than isBanned and name from participantsAll\n        participantsAll = data.members.map((participant) => ({\n          isBanned: participant.isBanned,\n          name: participant.name,\n          audioID: participant.audioID,\n          videoID: participant.videoID,\n        }));\n        updateParticipantsAll(participantsAll);\n\n        participants = data.members.filter(\n          (participant: Participant) => participant.isBanned == false,\n        );\n        updateParticipants(participants);\n      }\n\n      breakoutRooms = data.breakoutRooms || [];\n      updateBreakoutRooms(breakoutRooms);\n\n      if (data.status == 'started' && (breakOutRoomStarted || !breakOutRoomEnded)) {\n        breakOutRoomStarted = true;\n        breakOutRoomEnded = false;\n        updateBreakOutRoomStarted(true);\n        updateBreakOutRoomEnded(false);\n        prevMeetingDisplayType = meetingDisplayType;\n        if (meetingDisplayType != 'all') {\n          meetingDisplayType = 'all';\n          updateMeetingDisplayType('all');\n        }\n        await onScreenChanges({ changed: true, parameters });\n        if (islevel == '2') {\n          await rePort({ restart: true, parameters });\n        }\n      } else if (data.status == 'ended') {\n        breakOutRoomEnded = true;\n        updateBreakOutRoomEnded(true);\n        if (meetingDisplayType != prevMeetingDisplayType) {\n          meetingDisplayType = prevMeetingDisplayType;\n          updateMeetingDisplayType(prevMeetingDisplayType);\n        }\n        await onScreenChanges({ changed: true, parameters });\n        if (islevel == '2') {\n          await rePort({ restart: true, parameters });\n        }\n      } else if (data.status == 'started' && breakOutRoomStarted) {\n        breakOutRoomStarted = true;\n        breakOutRoomEnded = false;\n        updateBreakOutRoomStarted(true);\n        updateBreakOutRoomEnded(false);\n        await onScreenChanges({ changed: true, parameters });\n        if (islevel == '2') {\n          await rePort({ restart: true, parameters });\n        }\n      }\n    } catch (error: any) {\n      // console.log('Error updating breakout room:', error.message);\n    }\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"breakout-room-updated.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/methods/breakout-room-methods/breakout-room-updated.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  BreakoutParticipant,\n  BreakoutRoomUpdatedData,\n  OnScreenChangesParameters,\n  OnScreenChangesType,\n  Participant,\n  RePortParameters,\n  RePortType,\n} from '../../@types/types';\n\nexport interface BreakoutRoomUpdatedParameters extends OnScreenChangesParameters, RePortParameters {\n  breakOutRoomStarted: boolean;\n  breakOutRoomEnded: boolean;\n  breakoutRooms: BreakoutParticipant[][];\n  hostNewRoom: number;\n  islevel: string;\n  participantsAll: Participant[];\n  participants: Participant[];\n  meetingDisplayType: string;\n  prevMeetingDisplayType: string;\n  updateBreakoutRooms: (rooms: BreakoutParticipant[][]) => void;\n  updateBreakOutRoomStarted: (started: boolean) => void;\n  updateBreakOutRoomEnded: (ended: boolean) => void;\n  updateHostNewRoom: (room: number) => void;\n  updateMeetingDisplayType: (type: string) => void;\n  updateParticipantsAll: (participants: Participant[]) => void;\n  updateParticipants: (participants: Participant[]) => void;\n\n  //mediasfu functions\n  onScreenChanges: OnScreenChangesType;\n  rePort: RePortType;\n\n  getUpdatedAllParams: () => BreakoutRoomUpdatedParameters;\n  [key: string]: any;\n}\n\nexport interface BreakoutRoomUpdatedOptions {\n  data: BreakoutRoomUpdatedData;\n  parameters: BreakoutRoomUpdatedParameters;\n}\n\n// Export the type definition for the function\nexport type BreakoutRoomUpdatedType = (options: BreakoutRoomUpdatedOptions) => Promise<void>;\n\n/**\n * Updates the state of breakout rooms based on the provided data and parameters.\n *\n * This method handles changes in breakout rooms, updates the relevant state variables,\n * and triggers necessary UI updates based on the current status of the breakout rooms.\n *\n * @param {BreakoutRoomUpdatedOptions} options - The options object containing the data and parameters.\n * @param {BreakoutRoomUpdatedData} options.data - The data object containing information about the breakout rooms.\n * @param {BreakoutRoomUpdatedParameters} options.parameters - The parameters object containing various state update functions and other parameters.\n * @param {boolean} options.parameters.breakOutRoomStarted - Indicates if the breakout room has started.\n * @param {boolean} options.parameters.breakOutRoomEnded - Indicates if the breakout room has ended.\n * @param {Array<BreakoutParticipant[]>} options.parameters.breakoutRooms - The list of current breakout rooms.\n * @param {number} options.parameters.hostNewRoom - The ID of the new room for the host.\n * @param {string} options.parameters.islevel - The level of the breakout room (e.g., '2' for host).\n * @param {Array<Participant>} options.parameters.participantsAll - The list of all participants.\n * @param {Array<Participant>} options.parameters.participants - The list of participants who are not banned.\n * @param {string} options.parameters.meetingDisplayType - The current display type of the meeting.\n * @param {string} options.parameters.prevMeetingDisplayType - The previous display type of the meeting.\n * @param {Function} options.parameters.updateBreakoutRooms - Function to update the breakout rooms.\n * @param {Function} options.parameters.updateBreakOutRoomStarted - Function to update the breakout room started state.\n * @param {Function} options.parameters.updateBreakOutRoomEnded - Function to update the breakout room ended state.\n * @param {Function} options.parameters.updateHostNewRoom - Function to update the host's new room.\n * @param {Function} options.parameters.updateMeetingDisplayType - Function to update the meeting display type.\n * @param {Function} options.parameters.updateParticipantsAll - Function to update the list of all participants.\n * @param {Function} options.parameters.updateParticipants - Function to update the list of participants who are not banned.\n * @param {Function} options.parameters.onScreenChanges - Function to handle screen changes.\n * @param {Function} options.parameters.rePort - Function to handle reporting.\n *\n * @returns {Promise<void>} A promise that resolves when the breakout room state has been updated.\n *\n * @throws Will throw an error if the update process fails.\n *\n * @example\n * ```typescript\n * const options = {\n *   data: {\n *     forHost: true,\n *     newRoom: 3,\n *     status: 'started',\n *     members: [\n *       { name: 'user1', isBanned: false, audioID: 'audio1', videoID: 'video1' },\n *       { name: 'user2', isBanned: true, audioID: 'audio2', videoID: 'video2' },\n *     ],\n *     breakoutRooms: [[{ name: 'user1' }, { name: 'user2' }]],\n *   },\n *   parameters: {\n *     socket: socketInstance,\n *     roomName: 'mainRoom',\n *     screenStates: [{ mainScreenPerson: 'user1', mainScreenFilled: true, adminOnMainScreen: false }],\n *     participants: [{ name: 'admin', islevel: '2' }],\n *     breakOutRoomStarted: false,\n *     breakOutRoomEnded: false,\n *     hostNewRoom: 0,\n *     islevel: '2',\n *     participantsAll: [],\n *     updateBreakoutRooms: (rooms) => {},\n *     updateBreakOutRoomStarted: (started) => {},\n *     updateBreakOutRoomEnded: (ended) => {},\n *     updateHostNewRoom: (room) => {},\n *     updateMeetingDisplayType: (type) => {},\n *     updateParticipantsAll: (participants) => {},\n *     updateParticipants: (participants) => {},\n *     onScreenChanges: async () => {},\n *     rePort: async () => {},\n *   },\n * };\n *\n * const breakoutRoomService = new BreakoutRoomUpdated();\n * await breakoutRoomService.breakoutRoomUpdated(options);\n * ```\n */\n\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class BreakoutRoomUpdated {\n  /**\n   * Updates the state of breakout rooms based on the provided data and parameters.\n   *\n   * @param {Object} options - The options object.\n   * @param {Object} options.data - The data object containing information about the breakout rooms.\n   * @param {Object} options.parameters - The parameters object containing various state update functions and other parameters.\n   * @param {boolean} options.parameters.breakOutRoomStarted - Indicates if the breakout room has started.\n   * @param {boolean} options.parameters.breakOutRoomEnded - Indicates if the breakout room has ended.\n   * @param {Array} options.parameters.breakoutRooms - The list of current breakout rooms.\n   * @param {number} options.parameters.hostNewRoom - The ID of the new room for the host.\n   * @param {string} options.parameters.islevel - The level of the breakout room.\n   * @param {Array} options.parameters.participantsAll - The list of all participants.\n   * @param {Array} options.parameters.participants - The list of participants who are not banned.\n   * @param {string} options.parameters.meetingDisplayType - The current display type of the meeting.\n   * @param {string} options.parameters.prevMeetingDisplayType - The previous display type of the meeting.\n   * @param {Function} options.parameters.updateBreakoutRooms - Function to update the breakout rooms.\n   * @param {Function} options.parameters.updateBreakOutRoomStarted - Function to update the breakout room started state.\n   * @param {Function} options.parameters.updateBreakOutRoomEnded - Function to update the breakout room ended state.\n   * @param {Function} options.parameters.updateHostNewRoom - Function to update the host's new room.\n   * @param {Function} options.parameters.updateMeetingDisplayType - Function to update the meeting display type.\n   * @param {Function} options.parameters.updateParticipantsAll - Function to update the list of all participants.\n   * @param {Function} options.parameters.updateParticipants - Function to update the list of participants who are not banned.\n   * @param {Function} options.parameters.onScreenChanges - Function to handle screen changes.\n   * @param {Function} options.parameters.rePort - Function to handle reporting.\n   *\n   * @returns {Promise<void>} A promise that resolves when the breakout room state has been updated.\n   *\n   * @throws Will throw an error if the update process fails.\n   */\n\n  breakoutRoomUpdated = async ({ data, parameters }: BreakoutRoomUpdatedOptions): Promise<void> => {\n    try {\n      parameters = parameters.getUpdatedAllParams();\n\n      let {\n        breakOutRoomStarted,\n        breakOutRoomEnded,\n        breakoutRooms,\n        islevel,\n        participantsAll,\n        participants,\n\n        updateBreakoutRooms,\n        updateBreakOutRoomStarted,\n        updateBreakOutRoomEnded,\n        updateHostNewRoom,\n        updateMeetingDisplayType,\n        meetingDisplayType,\n        prevMeetingDisplayType,\n        updateParticipantsAll,\n        updateParticipants,\n\n        //mediaSfu functions\n        onScreenChanges,\n        rePort,\n      } = parameters;\n\n      if (data.forHost) {\n        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        updateHostNewRoom(data.newRoom!);\n        await onScreenChanges({ changed: true, parameters });\n        return;\n      }\n\n      if (islevel == '2' && data.members) {\n        //filter out the participant that isBanned == true\n        participantsAll = data.members;\n        //remove every field other than isBanned and name from participantsAll\n        participantsAll = data.members.map((participant) => ({\n          isBanned: participant.isBanned,\n          name: participant.name,\n          audioID: participant.audioID,\n          videoID: participant.videoID,\n        }));\n        updateParticipantsAll(participantsAll);\n\n        participants = data.members.filter(\n          (participant: Participant) => participant.isBanned == false,\n        );\n        updateParticipants(participants);\n      }\n\n      breakoutRooms = data.breakoutRooms || [];\n      updateBreakoutRooms(breakoutRooms);\n\n      if (data.status == 'started' && (breakOutRoomStarted || !breakOutRoomEnded)) {\n        breakOutRoomStarted = true;\n        breakOutRoomEnded = false;\n        updateBreakOutRoomStarted(true);\n        updateBreakOutRoomEnded(false);\n        prevMeetingDisplayType = meetingDisplayType;\n        if (meetingDisplayType != 'all') {\n          meetingDisplayType = 'all';\n          updateMeetingDisplayType('all');\n        }\n        await onScreenChanges({ changed: true, parameters });\n        if (islevel == '2') {\n          await rePort({ restart: true, parameters });\n        }\n      } else if (data.status == 'ended') {\n        breakOutRoomEnded = true;\n        updateBreakOutRoomEnded(true);\n        if (meetingDisplayType != prevMeetingDisplayType) {\n          meetingDisplayType = prevMeetingDisplayType;\n          updateMeetingDisplayType(prevMeetingDisplayType);\n        }\n        await onScreenChanges({ changed: true, parameters });\n        if (islevel == '2') {\n          await rePort({ restart: true, parameters });\n        }\n      } else if (data.status == 'started' && breakOutRoomStarted) {\n        breakOutRoomStarted = true;\n        breakOutRoomEnded = false;\n        updateBreakOutRoomStarted(true);\n        updateBreakOutRoomEnded(false);\n        await onScreenChanges({ changed: true, parameters });\n        if (islevel == '2') {\n          await rePort({ restart: true, parameters });\n        }\n      }\n    } catch (error: any) {\n      // console.log('Error updating breakout room:', error.message);\n    }\n  };\n}\n"]}

package/dist/esm2022/lib/methods/breakout-room-methods/launch-breakout-rooms.service.mjs

@@ -1,5 +1,29 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Launches the breakout rooms by toggling the visibility of the breakout rooms modal.
+ *
+ * This method is used to show or hide the breakout rooms modal based on the current visibility state.
+ *
+ * @param {LaunchBreakoutRoomsOptions} options - The options object containing necessary variables and functions.
+ * @param {Function} options.updateIsBreakoutRoomsModalVisible - Function to update the visibility state of the breakout rooms modal.
+ * @param {boolean} options.isBreakoutRoomsModalVisible - Current visibility state of the breakout rooms modal.
+ *
+ * @returns {void}
+ *
+ * @example
+ * ```typescript
+ * const options: LaunchBreakoutRoomsOptions = {
+ *   updateIsBreakoutRoomsModalVisible: (isVisible) => {
+ *     console.log('Breakout Rooms Modal is now:', isVisible ? 'Visible' : 'Hidden');
+ *   },
+ *   isBreakoutRoomsModalVisible: false,
+ * };
+ *
+ * const launchBreakoutRoomsService = new LaunchBreakoutRooms();
+ * launchBreakoutRoomsService.launchBreakoutRooms(options);
+ * ```
+ */
 export class LaunchBreakoutRooms {
     /**
      * Launches the breakout rooms by toggling the visibility of the breakout rooms modal.
@@ -19,4 +43,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGF1bmNoLWJyZWFrb3V0LXJvb21zLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tZWRpYXNmdS1hbmd1bGFyL3NyYy9saWIvbWV0aG9kcy9icmVha291dC1yb29tLW1ldGhvZHMvbGF1bmNoLWJyZWFrb3V0LXJvb21zLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFZM0MsTUFBTSxPQUFPLG1CQUFtQjtJQUM5Qjs7Ozs7T0FLRztJQUVILG1CQUFtQixDQUFDLEVBQ2xCLGlDQUFpQyxFQUNqQywyQkFBMkIsR0FDQTtRQUMzQixpQ0FBaUMsQ0FBQyxDQUFDLDJCQUEyQixDQUFDLENBQUM7SUFDbEUsQ0FBQzt1R0FiVSxtQkFBbUI7MkdBQW5CLG1CQUFtQixjQUZsQixNQUFNOzsyRkFFUCxtQkFBbUI7a0JBSC9CLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuZXhwb3J0IGludGVyZmFjZSBMYXVuY2hCcmVha291dFJvb21zT3B0aW9ucyB7XG4gIHVwZGF0ZUlzQnJlYWtvdXRSb29tc01vZGFsVmlzaWJsZTogKGlzVmlzaWJsZTogYm9vbGVhbikgPT4gdm9pZDtcbiAgaXNCcmVha291dFJvb21zTW9kYWxWaXNpYmxlOiBib29sZWFuO1xufVxuXG4vLyBFeHBvcnQgdGhlIHR5cGUgZGVmaW5pdGlvbiBmb3IgdGhlIGZ1bmN0aW9uXG5leHBvcnQgdHlwZSBMYXVuY2hCcmVha291dFJvb21zVHlwZSA9IChvcHRpb25zOiBMYXVuY2hCcmVha291dFJvb21zT3B0aW9ucykgPT4gdm9pZDtcblxuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCcsXG59KVxuZXhwb3J0IGNsYXNzIExhdW5jaEJyZWFrb3V0Um9vbXMge1xuICAvKipcbiAgICogTGF1bmNoZXMgdGhlIGJyZWFrb3V0IHJvb21zIGJ5IHRvZ2dsaW5nIHRoZSB2aXNpYmlsaXR5IG9mIHRoZSBicmVha291dCByb29tcyBtb2RhbC5cbiAgICpcbiAgICogQHBhcmFtIHVwZGF0ZUlzQnJlYWtvdXRSb29tc01vZGFsVmlzaWJsZSAtIEZ1bmN0aW9uIHRvIHVwZGF0ZSB0aGUgdmlzaWJpbGl0eSBzdGF0ZSBvZiB0aGUgYnJlYWtvdXQgcm9vbXMgbW9kYWwuXG4gICAqIEBwYXJhbSBpc0JyZWFrb3V0Um9vbXNNb2RhbFZpc2libGUgLSBDdXJyZW50IHZpc2liaWxpdHkgc3RhdGUgb2YgdGhlIGJyZWFrb3V0IHJvb21zIG1vZGFsLlxuICAgKi9cblxuICBsYXVuY2hCcmVha291dFJvb21zKHtcbiAgICB1cGRhdGVJc0JyZWFrb3V0Um9vbXNNb2RhbFZpc2libGUsXG4gICAgaXNCcmVha291dFJvb21zTW9kYWxWaXNpYmxlLFxuICB9OiBMYXVuY2hCcmVha291dFJvb21zT3B0aW9ucyk6IHZvaWQge1xuICAgIHVwZGF0ZUlzQnJlYWtvdXRSb29tc01vZGFsVmlzaWJsZSghaXNCcmVha291dFJvb21zTW9kYWxWaXNpYmxlKTtcbiAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,5 +1,29 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Toggles the visibility of the co-host modal.
+ *
+ * This method is used to show or hide the co-host modal based on the current visibility state.
+ *
+ * @param {LaunchCoHostOptions} options - The options object containing necessary variables and functions.
+ * @param {Function} options.updateIsCoHostModalVisible - Function to update the visibility state of the co-host modal.
+ * @param {boolean} options.isCoHostModalVisible - Current visibility state of the co-host modal.
+ *
+ * @returns {void}
+ *
+ * @example
+ * ```typescript
+ * const options: LaunchCoHostOptions = {
+ *   updateIsCoHostModalVisible: (isVisible) => {
+ *     console.log('Co-Host Modal is now:', isVisible ? 'Visible' : 'Hidden');
+ *   },
+ *   isCoHostModalVisible: false,
+ * };
+ *
+ * const launchCoHostService = new launchCoHost();
+ * launchCoHostService.launchCoHost(options);
+ * ```
+ */
 export class launchCoHost {
     /**
      * Toggles the visibility of the co-host modal.
@@ -19,4 +43,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGF1bmNoLWNvLWhvc3Quc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL21lZGlhc2Z1LWFuZ3VsYXIvc3JjL2xpYi9tZXRob2RzL2NvLWhvc3QtbWV0aG9kcy9sYXVuY2gtY28taG9zdC5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBWTNDLE1BQU0sT0FBTyxZQUFZO0lBQ3ZCOzs7OztPQUtHO0lBRUgsWUFBWSxDQUFDLEVBQUUsMEJBQTBCLEVBQUUsb0JBQW9CLEVBQXVCO1FBQ3BGLDBCQUEwQixDQUFDLENBQUMsb0JBQW9CLENBQUMsQ0FBQztJQUNwRCxDQUFDO3VHQVZVLFlBQVk7MkdBQVosWUFBWSxjQUZYLE1BQU07OzJGQUVQLFlBQVk7a0JBSHhCLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuZXhwb3J0IGludGVyZmFjZSBMYXVuY2hDb0hvc3RPcHRpb25zIHtcbiAgdXBkYXRlSXNDb0hvc3RNb2RhbFZpc2libGU6IChpc1Zpc2libGU6IGJvb2xlYW4pID0+IHZvaWQ7XG4gIGlzQ29Ib3N0TW9kYWxWaXNpYmxlOiBib29sZWFuO1xufVxuXG4vLyBFeHBvcnQgdGhlIHR5cGUgZGVmaW5pdGlvbiBmb3IgdGhlIGZ1bmN0aW9uXG5leHBvcnQgdHlwZSBMYXVuY2hDb0hvc3RUeXBlID0gKG9wdGlvbnM6IExhdW5jaENvSG9zdE9wdGlvbnMpID0+IHZvaWQ7XG5cbkBJbmplY3RhYmxlKHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnLFxufSlcbmV4cG9ydCBjbGFzcyBsYXVuY2hDb0hvc3Qge1xuICAvKipcbiAgICogVG9nZ2xlcyB0aGUgdmlzaWJpbGl0eSBvZiB0aGUgY28taG9zdCBtb2RhbC5cbiAgICpcbiAgICogQHBhcmFtIHVwZGF0ZUlzQ29Ib3N0TW9kYWxWaXNpYmxlIC0gRnVuY3Rpb24gdG8gdXBkYXRlIHRoZSB2aXNpYmlsaXR5IHN0YXRlIG9mIHRoZSBjby1ob3N0IG1vZGFsLlxuICAgKiBAcGFyYW0gaXNDb0hvc3RNb2RhbFZpc2libGUgLSBDdXJyZW50IHZpc2liaWxpdHkgc3RhdGUgb2YgdGhlIGNvLWhvc3QgbW9kYWwuXG4gICAqL1xuXG4gIGxhdW5jaENvSG9zdCh7IHVwZGF0ZUlzQ29Ib3N0TW9kYWxWaXNpYmxlLCBpc0NvSG9zdE1vZGFsVmlzaWJsZSB9OiBMYXVuY2hDb0hvc3RPcHRpb25zKTogdm9pZCB7XG4gICAgdXBkYXRlSXNDb0hvc3RNb2RhbFZpc2libGUoIWlzQ29Ib3N0TW9kYWxWaXNpYmxlKTtcbiAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,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