mediasfu-angular 1.0.0 → 1.0.2

package/dist/esm2022/lib/consumers/re-port.service.mjs

@@ -1,5 +1,53 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * RePort function that handles the reporting logic based on the provided parameters.
+ *
+ * This method checks the current state of the recording process and updates the screen states
+ * accordingly. It also compares active names and screen states based on the provided parameters.
+ *
+ * @param {RePortOptions} options - The options for the rePort function.
+ * @param {boolean} [options.restart=false] - Flag indicating whether to restart the process.
+ * @param {RePortParameters} options.parameters - The parameters object containing various states and functions.
+ * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+ * @param {string} options.parameters.islevel - The current level of the process.
+ * @param {string} options.parameters.mainScreenPerson - The person on the main screen.
+ * @param {boolean} options.parameters.adminOnMainScreen - Flag indicating if admin is on the main screen.
+ * @param {boolean} options.parameters.mainScreenFilled - Flag indicating if the main screen is filled.
+ * @param {boolean} options.parameters.recordStarted - Flag indicating if recording has started.
+ * @param {boolean} options.parameters.recordStopped - Flag indicating if recording has stopped.
+ * @param {boolean} options.parameters.recordPaused - Flag indicating if recording is paused.
+ * @param {boolean} options.parameters.recordResumed - Flag indicating if recording has resumed.
+ * @param {Array<ScreenState>} options.parameters.screenStates - Array of current screen states.
+ * @param {Function} options.parameters.updateScreenStates - Function to update the current screen states.
+ * @param {Function} options.parameters.updatePrevScreenStates - Function to update the previous screen states.
+ * @param {Function} options.parameters.compareActiveNames - Function to compare active names.
+ * @param {Function} options.parameters.compareScreenStates - Function to compare screen states.
+ *
+ * @returns {Promise<void>} A promise that resolves when the reporting process is complete.
+ *
+ * @throws {Error} Throws an error if there is an issue during the reporting process.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   restart: false,
+ *   parameters: {
+ *     islevel: '1',
+ *     mainScreenPerson: 'John Doe',
+ *     adminOnMainScreen: false,
+ *     mainScreenFilled: true,
+ *     recordStarted: true,
+ *     screenStates: [],
+ *     updateScreenStates: (states) => { console.log(updated) },
+ *     compareActiveNames: async (opts) => {  },
+ *     compareScreenStates: async (opts) => {  },
+ *   },
+ * };
+ *
+ * await rePort(options);
+ * ```
+ */
 export class RePort {
     /**
      * RePort function that handles the reporting logic based on the provided parameters.
@@ -63,4 +111,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"re-port.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/re-port.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AA4C3C,MAAM,OAAO,MAAM;IACjB;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IAEH,KAAK,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,KAAK,EAAE,UAAU,EAAiB;QACzD,MAAM,EAAE,mBAAmB,EAAE,GAAG,UAAU,CAAC;QAC3C,MAAM,aAAa,GAAG,mBAAmB,EAAE,CAAC;QAE5C,MAAM,EACJ,OAAO,EACP,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,EAChB,aAAa,EACb,aAAa,EACb,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,kBAAkB,EAClB,sBAAsB,EACtB,kBAAkB,EAClB,mBAAmB,GACpB,GAAG,aAAa,CAAC;QAElB,IAAI,CAAC;YACH,IAAI,aAAa,IAAI,aAAa,EAAE,CAAC;gBACnC,IAAI,aAAa,IAAI,YAAY,EAAE,CAAC;oBAClC,0CAA0C;gBAC5C,CAAC;qBAAM,CAAC;oBACN,IAAI,OAAO,KAAK,GAAG,EAAE,CAAC;wBACpB,MAAM,oBAAoB,GAAG,CAAC,GAAG,YAAY,CAAC,CAAC;wBAC/C,sBAAsB,CAAC,oBAAoB,CAAC,CAAC;wBAE7C,MAAM,eAAe,GAAG,CAAC,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,CAAC,CAAC;wBACpF,kBAAkB,CAAC,eAAe,CAAC,CAAC;wBAEpC,MAAM,kBAAkB,CAAC,EAAE,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,CAAC,CAAC;wBACjE,IAAI,CAAC,OAAO,EAAE,CAAC;4BACb,MAAM,mBAAmB,CAAC,EAAE,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,CAAC,CAAC;wBACpE,CAAC;oBACH,CAAC;gBACH,CAAC;YACH,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,gDAAgD;YAChD,OAAO,CAAC,KAAK,CAAC,0BAA0B,EAAE,KAAK,CAAC,CAAC;QACnD,CAAC;IACH,CAAC;uGAtEU,MAAM;2GAAN,MAAM,cAFL,MAAM;;2FAEP,MAAM;kBAHlB,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  ScreenState,\n  CompareScreenStatesParameters,\n  CompareScreenStatesType,\n  CompareActiveNamesParameters,\n  CompareActiveNamesType,\n} from '../@types/types';\n\nexport interface RePortParameters\n  extends CompareScreenStatesParameters,\n    CompareActiveNamesParameters {\n  islevel: string;\n  mainScreenPerson: string;\n  adminOnMainScreen: boolean;\n  mainScreenFilled: boolean;\n  recordStarted: boolean;\n  recordStopped: boolean;\n  recordPaused: boolean;\n  recordResumed: boolean;\n  screenStates: ScreenState[];\n  prevScreenStates: ScreenState[];\n  updateScreenStates: (states: ScreenState[]) => void;\n  updatePrevScreenStates: (states: ScreenState[]) => void;\n\n  // mediasfu functions\n  compareActiveNames: CompareActiveNamesType;\n  compareScreenStates: CompareScreenStatesType;\n\n  getUpdatedAllParams: () => RePortParameters;\n  [key: string]: any;\n}\n\nexport interface RePortOptions {\n  restart?: boolean;\n  parameters: RePortParameters;\n}\n\n// Export the type definition for the function\nexport type RePortType = (options: RePortOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class RePort {\n  /**\n   * RePort function that handles the reporting logic based on the provided parameters.\n   *\n   * @param {RePortOptions} options - The options for the rePort function.\n   * @param {boolean} [options.restart=false] - Flag indicating whether to restart the process.\n   * @param {Object} options.parameters - The parameters object containing various states and functions.\n   * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.\n   * @param {string} options.parameters.islevel - The current level of the process.\n   * @param {string} options.parameters.mainScreenPerson - The person on the main screen.\n   * @param {boolean} options.parameters.adminOnMainScreen - Flag indicating if admin is on the main screen.\n   * @param {boolean} options.parameters.mainScreenFilled - Flag indicating if the main screen is filled.\n   * @param {boolean} options.parameters.recordStarted - Flag indicating if recording has started.\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 {boolean} options.parameters.recordResumed - Flag indicating if recording has resumed.\n   * @param {Array} options.parameters.screenStates - Array of current screen states.\n   * @param {Function} options.parameters.updateScreenStates - Function to update the current screen states.\n   * @param {Function} options.parameters.updatePrevScreenStates - Function to update the previous screen states.\n   * @param {Function} options.parameters.compareActiveNames - Function to compare active names.\n   * @param {Function} options.parameters.compareScreenStates - Function to compare screen states.\n   *\n   * @returns {Promise<void>} A promise that resolves when the reporting process is complete.\n   *\n   * @throws {Error} Throws an error if there is an issue during the reporting process.\n   */\n\n  async rePort({ restart = false, parameters }: RePortOptions): Promise<void> {\n    const { getUpdatedAllParams } = parameters;\n    const updatedParams = getUpdatedAllParams();\n\n    const {\n      islevel,\n      mainScreenPerson,\n      adminOnMainScreen,\n      mainScreenFilled,\n      recordStarted,\n      recordStopped,\n      recordPaused,\n      recordResumed,\n      screenStates,\n      updateScreenStates,\n      updatePrevScreenStates,\n      compareActiveNames,\n      compareScreenStates,\n    } = updatedParams;\n\n    try {\n      if (recordStarted || recordResumed) {\n        if (recordStopped || recordPaused) {\n          // Recording stopped or paused, do nothing\n        } else {\n          if (islevel === '2') {\n            const prevScreenStatesCopy = [...screenStates];\n            updatePrevScreenStates(prevScreenStatesCopy);\n\n            const newScreenStates = [{ mainScreenPerson, adminOnMainScreen, mainScreenFilled }];\n            updateScreenStates(newScreenStates);\n\n            await compareActiveNames({ restart, parameters: updatedParams });\n            if (!restart) {\n              await compareScreenStates({ restart, parameters: updatedParams });\n            }\n          }\n        }\n      }\n    } catch (error) {\n      // Handle errors during the process of rePorting\n      console.error('Error during rePorting: ', error);\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"re-port.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/re-port.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAyC3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AAKH,MAAM,OAAO,MAAM;IACjB;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IAEH,KAAK,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,KAAK,EAAE,UAAU,EAAiB;QACzD,MAAM,EAAE,mBAAmB,EAAE,GAAG,UAAU,CAAC;QAC3C,MAAM,aAAa,GAAG,mBAAmB,EAAE,CAAC;QAE5C,MAAM,EACJ,OAAO,EACP,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,EAChB,aAAa,EACb,aAAa,EACb,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,kBAAkB,EAClB,sBAAsB,EACtB,kBAAkB,EAClB,mBAAmB,GACpB,GAAG,aAAa,CAAC;QAElB,IAAI,CAAC;YACH,IAAI,aAAa,IAAI,aAAa,EAAE,CAAC;gBACnC,IAAI,aAAa,IAAI,YAAY,EAAE,CAAC;oBAClC,0CAA0C;gBAC5C,CAAC;qBAAM,CAAC;oBACN,IAAI,OAAO,KAAK,GAAG,EAAE,CAAC;wBACpB,MAAM,oBAAoB,GAAG,CAAC,GAAG,YAAY,CAAC,CAAC;wBAC/C,sBAAsB,CAAC,oBAAoB,CAAC,CAAC;wBAE7C,MAAM,eAAe,GAAG,CAAC,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,CAAC,CAAC;wBACpF,kBAAkB,CAAC,eAAe,CAAC,CAAC;wBAEpC,MAAM,kBAAkB,CAAC,EAAE,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,CAAC,CAAC;wBACjE,IAAI,CAAC,OAAO,EAAE,CAAC;4BACb,MAAM,mBAAmB,CAAC,EAAE,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,CAAC,CAAC;wBACpE,CAAC;oBACH,CAAC;gBACH,CAAC;YACH,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,gDAAgD;YAChD,OAAO,CAAC,KAAK,CAAC,0BAA0B,EAAE,KAAK,CAAC,CAAC;QACnD,CAAC;IACH,CAAC;uGAtEU,MAAM;2GAAN,MAAM,cAFL,MAAM;;2FAEP,MAAM;kBAHlB,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  ScreenState,\n  CompareScreenStatesParameters,\n  CompareScreenStatesType,\n  CompareActiveNamesParameters,\n  CompareActiveNamesType,\n} from '../@types/types';\n\nexport interface RePortParameters\n  extends CompareScreenStatesParameters,\n    CompareActiveNamesParameters {\n  islevel: string;\n  mainScreenPerson: string;\n  adminOnMainScreen: boolean;\n  mainScreenFilled: boolean;\n  recordStarted: boolean;\n  recordStopped: boolean;\n  recordPaused: boolean;\n  recordResumed: boolean;\n  screenStates: ScreenState[];\n  prevScreenStates: ScreenState[];\n  updateScreenStates: (states: ScreenState[]) => void;\n  updatePrevScreenStates: (states: ScreenState[]) => void;\n\n  // mediasfu functions\n  compareActiveNames: CompareActiveNamesType;\n  compareScreenStates: CompareScreenStatesType;\n\n  getUpdatedAllParams: () => RePortParameters;\n  [key: string]: any;\n}\n\nexport interface RePortOptions {\n  restart?: boolean;\n  parameters: RePortParameters;\n}\n\n// Export the type definition for the function\nexport type RePortType = (options: RePortOptions) => Promise<void>;\n\n/**\n * RePort function that handles the reporting logic based on the provided parameters.\n *\n * This method checks the current state of the recording process and updates the screen states\n * accordingly. It also compares active names and screen states based on the provided parameters.\n *\n * @param {RePortOptions} options - The options for the rePort function.\n * @param {boolean} [options.restart=false] - Flag indicating whether to restart the process.\n * @param {RePortParameters} options.parameters - The parameters object containing various states and functions.\n * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.\n * @param {string} options.parameters.islevel - The current level of the process.\n * @param {string} options.parameters.mainScreenPerson - The person on the main screen.\n * @param {boolean} options.parameters.adminOnMainScreen - Flag indicating if admin is on the main screen.\n * @param {boolean} options.parameters.mainScreenFilled - Flag indicating if the main screen is filled.\n * @param {boolean} options.parameters.recordStarted - Flag indicating if recording has started.\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 {boolean} options.parameters.recordResumed - Flag indicating if recording has resumed.\n * @param {Array<ScreenState>} options.parameters.screenStates - Array of current screen states.\n * @param {Function} options.parameters.updateScreenStates - Function to update the current screen states.\n * @param {Function} options.parameters.updatePrevScreenStates - Function to update the previous screen states.\n * @param {Function} options.parameters.compareActiveNames - Function to compare active names.\n * @param {Function} options.parameters.compareScreenStates - Function to compare screen states.\n *\n * @returns {Promise<void>} A promise that resolves when the reporting process is complete.\n *\n * @throws {Error} Throws an error if there is an issue during the reporting process.\n *\n * @example\n * ```typescript\n * const options = {\n *   restart: false,\n *   parameters: {\n *     islevel: '1',\n *     mainScreenPerson: 'John Doe',\n *     adminOnMainScreen: false,\n *     mainScreenFilled: true,\n *     recordStarted: true,\n *     screenStates: [],\n *     updateScreenStates: (states) => { console.log(updated) },\n *     compareActiveNames: async (opts) => {  },\n *     compareScreenStates: async (opts) => {  },\n *   },\n * };\n *\n * await rePort(options);\n * ```\n */\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class RePort {\n  /**\n   * RePort function that handles the reporting logic based on the provided parameters.\n   *\n   * @param {RePortOptions} options - The options for the rePort function.\n   * @param {boolean} [options.restart=false] - Flag indicating whether to restart the process.\n   * @param {Object} options.parameters - The parameters object containing various states and functions.\n   * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.\n   * @param {string} options.parameters.islevel - The current level of the process.\n   * @param {string} options.parameters.mainScreenPerson - The person on the main screen.\n   * @param {boolean} options.parameters.adminOnMainScreen - Flag indicating if admin is on the main screen.\n   * @param {boolean} options.parameters.mainScreenFilled - Flag indicating if the main screen is filled.\n   * @param {boolean} options.parameters.recordStarted - Flag indicating if recording has started.\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 {boolean} options.parameters.recordResumed - Flag indicating if recording has resumed.\n   * @param {Array} options.parameters.screenStates - Array of current screen states.\n   * @param {Function} options.parameters.updateScreenStates - Function to update the current screen states.\n   * @param {Function} options.parameters.updatePrevScreenStates - Function to update the previous screen states.\n   * @param {Function} options.parameters.compareActiveNames - Function to compare active names.\n   * @param {Function} options.parameters.compareScreenStates - Function to compare screen states.\n   *\n   * @returns {Promise<void>} A promise that resolves when the reporting process is complete.\n   *\n   * @throws {Error} Throws an error if there is an issue during the reporting process.\n   */\n\n  async rePort({ restart = false, parameters }: RePortOptions): Promise<void> {\n    const { getUpdatedAllParams } = parameters;\n    const updatedParams = getUpdatedAllParams();\n\n    const {\n      islevel,\n      mainScreenPerson,\n      adminOnMainScreen,\n      mainScreenFilled,\n      recordStarted,\n      recordStopped,\n      recordPaused,\n      recordResumed,\n      screenStates,\n      updateScreenStates,\n      updatePrevScreenStates,\n      compareActiveNames,\n      compareScreenStates,\n    } = updatedParams;\n\n    try {\n      if (recordStarted || recordResumed) {\n        if (recordStopped || recordPaused) {\n          // Recording stopped or paused, do nothing\n        } else {\n          if (islevel === '2') {\n            const prevScreenStatesCopy = [...screenStates];\n            updatePrevScreenStates(prevScreenStatesCopy);\n\n            const newScreenStates = [{ mainScreenPerson, adminOnMainScreen, mainScreenFilled }];\n            updateScreenStates(newScreenStates);\n\n            await compareActiveNames({ restart, parameters: updatedParams });\n            if (!restart) {\n              await compareScreenStates({ restart, parameters: updatedParams });\n            }\n          }\n        }\n      }\n    } catch (error) {\n      // Handle errors during the process of rePorting\n      console.error('Error during rePorting: ', error);\n    }\n  }\n}\n"]}

package/dist/esm2022/lib/consumers/re-update-inter.service.mjs

@@ -1,5 +1,87 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Updates the interaction state based on the provided options and parameters.
+ *
+ * This method handles the updating of participant interactions based on the event type, screen sharing status,
+ * and various other parameters. It manages the addition and removal of streams in the context of screen sharing
+ * and video/audio management.
+ *
+ * @param {ReUpdateInterOptions} options - The options for updating the interaction.
+ * @param {string} options.name - The name of the participant.
+ * @param {boolean} [options.add=false] - Whether to add the participant to the interaction.
+ * @param {boolean} [options.force=false] - Whether to force the update.
+ * @param {number} [options.average=127] - The average value used for determining reorder intervals.
+ * @param {ReUpdateInterParameters} options.parameters - The parameters for updating the interaction.
+ * @param {number} options.parameters.screenPageLimit - The screen page limit.
+ * @param {number} options.parameters.itemPageLimit - The item page limit.
+ * @param {number} options.parameters.reorderInterval - The reorder interval.
+ * @param {number} options.parameters.fastReorderInterval - The fast reorder interval.
+ * @param {string} options.parameters.eventType - The type of event (e.g., "broadcast", "chat", "conference").
+ * @param {Array<Participant>} options.parameters.participants - The list of participants.
+ * @param {Array<Stream | Participant>} options.parameters.allVideoStreams - The list of all video streams.
+ * @param {boolean} options.parameters.shared - Indicates if the screen is shared.
+ * @param {boolean} options.parameters.shareScreenStarted - Indicates if screen sharing has started.
+ * @param {string} options.parameters.adminNameStream - The admin name stream.
+ * @param {string} options.parameters.screenShareNameStream - The screen share name stream.
+ * @param {boolean} options.parameters.updateMainWindow - Whether to update the main window.
+ * @param {boolean} options.parameters.sortAudioLoudness - Whether to sort audio by loudness.
+ * @param {number} options.parameters.lastReorderTime - The last reorder time.
+ * @param {Array<Stream | Participant>} options.parameters.newLimitedStreams - The list of new limited streams.
+ * @param {Array<string>} options.parameters.newLimitedStreamsIDs - The list of new limited stream IDs.
+ * @param {Array<string>} options.parameters.oldSoundIds - The list of old sound IDs.
+ * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window.
+ * @param {Function} options.parameters.updateSortAudioLoudness - Function to update the audio loudness sorting.
+ * @param {Function} options.parameters.updateLastReorderTime - Function to update the last reorder time.
+ * @param {Function} options.parameters.updateNewLimitedStreams - Function to update the new limited streams.
+ * @param {Function} options.parameters.updateNewLimitedStreamsIDs - Function to update the new limited stream IDs.
+ * @param {Function} options.parameters.updateOldSoundIds - Function to update the old sound IDs.
+ * @param {Function} options.parameters.onScreenChanges - Function to handle screen changes.
+ * @param {Function} options.parameters.reorderStreams - Function to reorder streams.
+ * @param {Function} options.parameters.changeVids - Function to change videos.
+ *
+ * @returns {Promise<void>} A promise that resolves when the interaction update is complete.
+ *
+ * @throws {Error} Throws an error if there is an issue during the interaction update.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   name: 'John Doe',
+ *   add: true,
+ *   parameters: {
+ *     screenPageLimit: 5,
+ *     itemPageLimit: 10,
+ *     reorderInterval: 1000,
+ *     fastReorderInterval: 500,
+ *     eventType: 'conference',
+ *     participants: [...],
+ *     allVideoStreams: [...],
+ *     shared: false,
+ *     shareScreenStarted: false,
+ *     adminNameStream: 'Admin',
+ *     screenShareNameStream: 'ScreenShare',
+ *     updateMainWindow: true,
+ *     sortAudioLoudness: false,
+ *     lastReorderTime: Date.now(),
+ *     newLimitedStreams: [],
+ *     newLimitedStreamsIDs: [],
+ *     oldSoundIds: [],
+ *     updateUpdateMainWindow: (value) => { console.log(updated) },
+ *     updateSortAudioLoudness: (value) => { console.log(updated) },
+ *     updateLastReorderTime: (value) => { console.log(updated) },
+ *     updateNewLimitedStreams: (streams) => { console.log(updated) },
+ *     updateNewLimitedStreamsIDs: (ids) => { console.log(updated) },
+ *     updateOldSoundIds: (ids) => { console.log(updated) },
+ *     onScreenChanges: async (opts) => {  },
+ *     reorderStreams: async (opts) => {  },
+ *     changeVids: async (opts) => {  },
+ *   },
+ * };
+ *
+ * await reUpdateInter(options);
+ * ```
+ */
 export class ReUpdateInter {
     /**
      * Updates the interaction state based on the provided options and parameters.
@@ -154,4 +236,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"re-update-inter.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/re-update-inter.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AA+D3C,MAAM,OAAO,aAAa;IACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IAEH,aAAa,GAAG,KAAK,EAAE,EACrB,IAAI,EACJ,GAAG,GAAG,KAAK,EACX,KAAK,GAAG,KAAK,EACb,OAAO,GAAG,GAAG,EACb,UAAU,GACW,EAAiB,EAAE;QACxC,IAAI,EACF,eAAe,EACf,aAAa,EACb,eAAe,EACf,mBAAmB,EACnB,SAAS,EACT,YAAY,EACZ,eAAe,EACf,MAAM,EACN,kBAAkB,EAClB,eAAe,EACf,qBAAqB,EACrB,gBAAgB,EAChB,iBAAiB,EACjB,eAAe,EACf,iBAAiB,EACjB,oBAAoB,EACpB,WAAW,EACX,sBAAsB,EACtB,uBAAuB,EACvB,qBAAqB,EACrB,uBAAuB,EACvB,0BAA0B,EAC1B,iBAAiB,EACjB,eAAe,EACf,cAAc,EACd,UAAU,GACX,GAAG,UAAU,CAAC;QAEf,IAAI,SAAS,IAAI,WAAW,IAAI,SAAS,IAAI,MAAM,EAAE,CAAC;YACpD,OAAO;QACT,CAAC;QAED,IAAI,QAAQ,GAAG,eAAe,GAAG,CAAC,CAAC;QAEnC,IAAI,kBAAkB,IAAI,MAAM,EAAE,CAAC;YACjC,gEAAgE;QAClE,CAAC;aAAM,CAAC;YACN,QAAQ,GAAG,aAAa,GAAG,CAAC,CAAC;YAE7B,IAAI,GAAG,EAAE,CAAC;gBACR,MAAM,WAAW,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;gBAC/B,IACE,CAAC,WAAW,GAAG,eAAe,IAAI,eAAe,IAAI,OAAO,GAAG,KAAK,CAAC;oBACrE,CAAC,OAAO,GAAG,GAAG,IAAI,WAAW,GAAG,eAAe,IAAI,mBAAmB,CAAC,EACvE,CAAC;oBACD,eAAe,GAAG,WAAW,CAAC;oBAC9B,iBAAiB,GAAG,IAAI,CAAC;oBACzB,IAAI,SAAS,IAAI,YAAY,EAAE,CAAC;wBAC9B,MAAM,eAAe,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC,CAAC;oBACvD,CAAC;yBAAM,CAAC;wBACN,MAAM,cAAc,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC,CAAC;oBACxE,CAAC;oBACD,iBAAiB,GAAG,KAAK,CAAC;oBAE1B,uBAAuB,CAAC,iBAAiB,CAAC,CAAC;oBAC3C,sBAAsB,CAAC,gBAAgB,CAAC,CAAC;oBACzC,qBAAqB,CAAC,eAAe,CAAC,CAAC;oBAEvC,OAAO;gBACT,CAAC;YACH,CAAC;QACH,CAAC;QAED,IAAI,OAAO,GAAkB,IAAI,CAAC;QAClC,IAAI,kBAAkB,IAAI,MAAM,EAAE,CAAC;YACjC,IAAI,GAAG,EAAE,CAAC;gBACR,MAAM,WAAW,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;gBAC9D,OAAO,GAAG,WAAW,EAAE,OAAO,IAAI,IAAI,CAAC;gBAEvC,IAAI,CAAC,OAAO,EAAE,CAAC;oBACb,OAAO;gBACT,CAAC;gBAED,IAAI,CAAC,oBAAoB,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;oBAC5C,gHAAgH;oBAChH,IAAI,iBAAiB,CAAC,MAAM,GAAG,QAAQ,EAAE,CAAC;wBACxC,IAAI,YAAY,GAAG,CAAC,GAAG,WAAW,CAAC,CAAC;wBACpC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,WAAW,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;4BAC5C,IAAI,iBAAiB,CAAC,MAAM,GAAG,QAAQ,EAAE,CAAC;gCACxC,uCAAuC;gCACvC,IAAI,iBAAiB,CAAC,MAAM,GAAG,eAAe,EAAE,CAAC;oCAC/C,OAAO;gCACT,CAAC;gCACD,MAAM,SAAS,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC;gCACjC,IAAI,SAAS,KAAK,qBAAqB,IAAI,SAAS,KAAK,eAAe,EAAE,CAAC;oCACzE,iBAAiB,GAAG,iBAAiB,CAAC,MAAM,CAC1C,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,UAAU,KAAK,SAAS,CAC5C,CAAC;oCACF,oBAAoB,GAAG,oBAAoB,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,KAAK,SAAS,CAAC,CAAC;oCAC7E,YAAY,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,KAAK,SAAS,CAAC,CAAC;gCAC/D,CAAC;4BACH,CAAC;wBACH,CAAC;wBACD,WAAW,GAAG,CAAC,GAAG,YAAY,CAAC,CAAC;oBAClC,CAAC;oBAED,MAAM,MAAM,GAAG,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,UAAU,KAAK,OAAO,CAAC,CAAC;oBACrE,IAAI,MAAM,IAAI,iBAAiB,CAAC,MAAM,GAAG,eAAe,EAAE,CAAC;wBACzD,iBAAiB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;wBAC/B,oBAAoB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;wBACnC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;4BAChC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;wBACzB,CAAC;wBACD,MAAM,UAAU,CAAC,EAAE,aAAa,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC,CAAC;oBACxD,CAAC;gBACH,CAAC;YACH,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,KAAK,EAAE,CAAC;oBACX,IAAI,CAAC;wBACH,uCAAuC;wBACvC,IAAI,iBAAiB,CAAC,MAAM,GAAG,eAAe,EAAE,CAAC;4BAC/C,OAAO;wBACT,CAAC;wBACD,iBAAiB,GAAG,iBAAiB,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,UAAU,IAAI,OAAO,CAAC,CAAC;wBACvF,oBAAoB,GAAG,oBAAoB,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,KAAK,OAAO,CAAC,CAAC;wBAC3E,WAAW,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC,CAAC;wBACtD,MAAM,UAAU,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC;oBACnC,CAAC;oBAAC,MAAM,CAAC;wBACP,kBAAkB;oBACpB,CAAC;gBACH,CAAC;qBAAM,CAAC;oBACN,MAAM,WAAW,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;oBAC9D,IAAI,WAAW,EAAE,KAAK,EAAE,CAAC;wBACvB,IAAI,CAAC;4BACH,iBAAiB,GAAG,iBAAiB,CAAC,MAAM,CAC1C,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,UAAU,KAAK,OAAO,CAC1C,CAAC;4BACF,oBAAoB,GAAG,oBAAoB,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,KAAK,OAAO,CAAC,CAAC;4BAC3E,WAAW,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC,CAAC;4BACtD,MAAM,UAAU,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC;wBACnC,CAAC;wBAAC,MAAM,CAAC;4BACP,kBAAkB;wBACpB,CAAC;oBACH,CAAC;gBACH,CAAC;YACH,CAAC;YAED,uBAAuB,CAAC,iBAAiB,CAAC,CAAC;YAC3C,0BAA0B,CAAC,oBAAoB,CAAC,CAAC;YACjD,iBAAiB,CAAC,WAAW,CAAC,CAAC;QACjC,CAAC;IACH,CAAC,CAAC;uGA7LS,aAAa;2GAAb,aAAa,cAFZ,MAAM;;2FAEP,aAAa;kBAHzB,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  Participant,\n  Stream,\n  OnScreenChangesType,\n  ReorderStreamsType,\n  ChangeVidsType,\n  OnScreenChangesParameters,\n  ReorderStreamsParameters,\n  ChangeVidsParameters,\n  EventType,\n} from '../@types/types';\nexport interface ReUpdateInterParameters\n  extends OnScreenChangesParameters,\n    ReorderStreamsParameters,\n    ChangeVidsParameters {\n  screenPageLimit: number;\n  itemPageLimit: number;\n  reorderInterval: number;\n  fastReorderInterval: number;\n  eventType: EventType;\n  participants: Participant[];\n  allVideoStreams: (Participant | Stream)[];\n  shared: boolean;\n  shareScreenStarted: boolean;\n  adminNameStream?: string;\n  screenShareNameStream?: string;\n  updateMainWindow: boolean;\n  sortAudioLoudness: boolean;\n  lastReorderTime: number;\n  newLimitedStreams: (Participant | Stream)[];\n  newLimitedStreamsIDs: string[];\n  oldSoundIds: string[];\n  updateUpdateMainWindow: (value: boolean) => void;\n  updateSortAudioLoudness: (value: boolean) => void;\n  updateLastReorderTime: (value: number) => void;\n  updateNewLimitedStreams: (streams: (Participant | Stream)[]) => void;\n  updateNewLimitedStreamsIDs: (ids: string[]) => void;\n  updateOldSoundIds: (ids: string[]) => void;\n\n  // mediasfu functions\n  onScreenChanges: OnScreenChangesType;\n  reorderStreams: ReorderStreamsType;\n  changeVids: ChangeVidsType;\n\n  getUpdatedAllParams: () => ReUpdateInterParameters;\n  [key: string]: any;\n}\n\nexport interface ReUpdateInterOptions {\n  name: string;\n  add?: boolean;\n  force?: boolean;\n  average?: number;\n  parameters: ReUpdateInterParameters;\n}\n\n// Export the type definition for the function\nexport type ReUpdateInterType = (options: ReUpdateInterOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ReUpdateInter {\n  /**\n   * Updates the interaction state based on the provided options and parameters.\n   *\n   * @param {ReUpdateInterOptions} options - The options for updating the interaction.\n   * @param {string} options.name - The name of the participant.\n   * @param {boolean} [options.add=false] - Whether to add the participant to the interaction.\n   * @param {boolean} [options.force=false] - Whether to force the update.\n   * @param {number} [options.average=127] - The average value used for determining reorder intervals.\n   * @param {Object} options.parameters - The parameters for updating the interaction.\n   * @param {number} options.parameters.screenPageLimit - The screen page limit.\n   * @param {number} options.parameters.itemPageLimit - The item page limit.\n   * @param {number} options.parameters.reorderInterval - The reorder interval.\n   * @param {number} options.parameters.fastReorderInterval - The fast reorder interval.\n   * @param {string} options.parameters.eventType - The type of event.\n   * @param {Array} options.parameters.participants - The list of participants.\n   * @param {Array} options.parameters.allVideoStreams - The list of all video streams.\n   * @param {boolean} options.parameters.shared - Whether the screen is shared.\n   * @param {boolean} options.parameters.shareScreenStarted - Whether screen sharing has started.\n   * @param {string} options.parameters.adminNameStream - The admin name stream.\n   * @param {string} options.parameters.screenShareNameStream - The screen share name stream.\n   * @param {boolean} options.parameters.updateMainWindow - Whether to update the main window.\n   * @param {boolean} options.parameters.sortAudioLoudness - Whether to sort audio by loudness.\n   * @param {number} options.parameters.lastReorderTime - The last reorder time.\n   * @param {Array} options.parameters.newLimitedStreams - The list of new limited streams.\n   * @param {Array} options.parameters.newLimitedStreamsIDs - The list of new limited stream IDs.\n   * @param {Array} options.parameters.oldSoundIds - The list of old sound IDs.\n   * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window.\n   * @param {Function} options.parameters.updateSortAudioLoudness - Function to update the audio loudness sorting.\n   * @param {Function} options.parameters.updateLastReorderTime - Function to update the last reorder time.\n   * @param {Function} options.parameters.updateNewLimitedStreams - Function to update the new limited streams.\n   * @param {Function} options.parameters.updateNewLimitedStreamsIDs - Function to update the new limited stream IDs.\n   * @param {Function} options.parameters.updateOldSoundIds - Function to update the old sound IDs.\n   * @param {Function} options.parameters.onScreenChanges - Function to handle screen changes.\n   * @param {Function} options.parameters.reorderStreams - Function to reorder streams.\n   * @param {Function} options.parameters.changeVids - Function to change videos.\n   *\n   * @returns {Promise<void>} A promise that resolves when the interaction update is complete.\n   */\n\n  reUpdateInter = async ({\n    name,\n    add = false,\n    force = false,\n    average = 127,\n    parameters,\n  }: ReUpdateInterOptions): Promise<void> => {\n    let {\n      screenPageLimit,\n      itemPageLimit,\n      reorderInterval,\n      fastReorderInterval,\n      eventType,\n      participants,\n      allVideoStreams,\n      shared,\n      shareScreenStarted,\n      adminNameStream,\n      screenShareNameStream,\n      updateMainWindow,\n      sortAudioLoudness,\n      lastReorderTime,\n      newLimitedStreams,\n      newLimitedStreamsIDs,\n      oldSoundIds,\n      updateUpdateMainWindow,\n      updateSortAudioLoudness,\n      updateLastReorderTime,\n      updateNewLimitedStreams,\n      updateNewLimitedStreamsIDs,\n      updateOldSoundIds,\n      onScreenChanges,\n      reorderStreams,\n      changeVids,\n    } = parameters;\n\n    if (eventType == 'broadcast' || eventType == 'chat') {\n      return;\n    }\n\n    let refLimit = screenPageLimit - 1;\n\n    if (shareScreenStarted || shared) {\n      // Do something when screen is shared or screen share is started\n    } else {\n      refLimit = itemPageLimit - 1;\n\n      if (add) {\n        const currentTime = Date.now();\n        if (\n          (currentTime - lastReorderTime >= reorderInterval && average > 128.5) ||\n          (average > 130 && currentTime - lastReorderTime >= fastReorderInterval)\n        ) {\n          lastReorderTime = currentTime;\n          sortAudioLoudness = true;\n          if (eventType == 'conference') {\n            await onScreenChanges({ changed: true, parameters });\n          } else {\n            await reorderStreams({ add: false, screenChanged: true, parameters });\n          }\n          sortAudioLoudness = false;\n\n          updateSortAudioLoudness(sortAudioLoudness);\n          updateUpdateMainWindow(updateMainWindow);\n          updateLastReorderTime(lastReorderTime);\n\n          return;\n        }\n      }\n    }\n\n    let videoID: string | null = null;\n    if (shareScreenStarted || shared) {\n      if (add) {\n        const participant = participants.find((p) => p.name === name);\n        videoID = participant?.videoID ?? null;\n\n        if (!videoID) {\n          return;\n        }\n\n        if (!newLimitedStreamsIDs.includes(videoID)) {\n          //first check length of newLimitedStreams to not exceed refLimit, if so remove oldSoundID from newLimitedStreams\n          if (newLimitedStreams.length > refLimit) {\n            let oldoldSounds = [...oldSoundIds];\n            for (let i = 0; i < oldSoundIds.length; i++) {\n              if (newLimitedStreams.length > refLimit) {\n                // remove stream from newLimitedStreams\n                if (newLimitedStreams.length < screenPageLimit) {\n                  return;\n                }\n                const currentId = oldSoundIds[i];\n                if (currentId !== screenShareNameStream && currentId !== adminNameStream) {\n                  newLimitedStreams = newLimitedStreams.filter(\n                    (stream) => stream.producerId !== currentId,\n                  );\n                  newLimitedStreamsIDs = newLimitedStreamsIDs.filter((id) => id !== currentId);\n                  oldoldSounds = oldoldSounds.filter((id) => id !== currentId);\n                }\n              }\n            }\n            oldSoundIds = [...oldoldSounds];\n          }\n\n          const stream = allVideoStreams.find((s) => s.producerId === videoID);\n          if (stream && newLimitedStreams.length < screenPageLimit) {\n            newLimitedStreams.push(stream);\n            newLimitedStreamsIDs.push(videoID);\n            if (!oldSoundIds.includes(name)) {\n              oldSoundIds.push(name);\n            }\n            await changeVids({ screenChanged: true, parameters });\n          }\n        }\n      } else {\n        if (!force) {\n          try {\n            // remove stream from newLimitedStreams\n            if (newLimitedStreams.length < screenPageLimit) {\n              return;\n            }\n            newLimitedStreams = newLimitedStreams.filter((stream) => stream.producerId != videoID);\n            newLimitedStreamsIDs = newLimitedStreamsIDs.filter((id) => id !== videoID);\n            oldSoundIds = oldSoundIds.filter((id) => id !== name);\n            await changeVids({ parameters });\n          } catch {\n            /* handle error */\n          }\n        } else {\n          const participant = participants.find((p) => p.name === name);\n          if (participant?.muted) {\n            try {\n              newLimitedStreams = newLimitedStreams.filter(\n                (stream) => stream.producerId !== videoID,\n              );\n              newLimitedStreamsIDs = newLimitedStreamsIDs.filter((id) => id !== videoID);\n              oldSoundIds = oldSoundIds.filter((id) => id !== name);\n              await changeVids({ parameters });\n            } catch {\n              /* handle error */\n            }\n          }\n        }\n      }\n\n      updateNewLimitedStreams(newLimitedStreams);\n      updateNewLimitedStreamsIDs(newLimitedStreamsIDs);\n      updateOldSoundIds(oldSoundIds);\n    }\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"re-update-inter.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/re-update-inter.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  Participant,\n  Stream,\n  OnScreenChangesType,\n  ReorderStreamsType,\n  ChangeVidsType,\n  OnScreenChangesParameters,\n  ReorderStreamsParameters,\n  ChangeVidsParameters,\n  EventType,\n} from '../@types/types';\nexport interface ReUpdateInterParameters\n  extends OnScreenChangesParameters,\n    ReorderStreamsParameters,\n    ChangeVidsParameters {\n  screenPageLimit: number;\n  itemPageLimit: number;\n  reorderInterval: number;\n  fastReorderInterval: number;\n  eventType: EventType;\n  participants: Participant[];\n  allVideoStreams: (Participant | Stream)[];\n  shared: boolean;\n  shareScreenStarted: boolean;\n  adminNameStream?: string;\n  screenShareNameStream?: string;\n  updateMainWindow: boolean;\n  sortAudioLoudness: boolean;\n  lastReorderTime: number;\n  newLimitedStreams: (Participant | Stream)[];\n  newLimitedStreamsIDs: string[];\n  oldSoundIds: string[];\n  updateUpdateMainWindow: (value: boolean) => void;\n  updateSortAudioLoudness: (value: boolean) => void;\n  updateLastReorderTime: (value: number) => void;\n  updateNewLimitedStreams: (streams: (Participant | Stream)[]) => void;\n  updateNewLimitedStreamsIDs: (ids: string[]) => void;\n  updateOldSoundIds: (ids: string[]) => void;\n\n  // mediasfu functions\n  onScreenChanges: OnScreenChangesType;\n  reorderStreams: ReorderStreamsType;\n  changeVids: ChangeVidsType;\n\n  getUpdatedAllParams: () => ReUpdateInterParameters;\n  [key: string]: any;\n}\n\nexport interface ReUpdateInterOptions {\n  name: string;\n  add?: boolean;\n  force?: boolean;\n  average?: number;\n  parameters: ReUpdateInterParameters;\n}\n\n// Export the type definition for the function\nexport type ReUpdateInterType = (options: ReUpdateInterOptions) => Promise<void>;\n\n/**\n * Updates the interaction state based on the provided options and parameters.\n *\n * This method handles the updating of participant interactions based on the event type, screen sharing status,\n * and various other parameters. It manages the addition and removal of streams in the context of screen sharing\n * and video/audio management.\n *\n * @param {ReUpdateInterOptions} options - The options for updating the interaction.\n * @param {string} options.name - The name of the participant.\n * @param {boolean} [options.add=false] - Whether to add the participant to the interaction.\n * @param {boolean} [options.force=false] - Whether to force the update.\n * @param {number} [options.average=127] - The average value used for determining reorder intervals.\n * @param {ReUpdateInterParameters} options.parameters - The parameters for updating the interaction.\n * @param {number} options.parameters.screenPageLimit - The screen page limit.\n * @param {number} options.parameters.itemPageLimit - The item page limit.\n * @param {number} options.parameters.reorderInterval - The reorder interval.\n * @param {number} options.parameters.fastReorderInterval - The fast reorder interval.\n * @param {string} options.parameters.eventType - The type of event (e.g., \"broadcast\", \"chat\", \"conference\").\n * @param {Array<Participant>} options.parameters.participants - The list of participants.\n * @param {Array<Stream | Participant>} options.parameters.allVideoStreams - The list of all video streams.\n * @param {boolean} options.parameters.shared - Indicates if the screen is shared.\n * @param {boolean} options.parameters.shareScreenStarted - Indicates if screen sharing has started.\n * @param {string} options.parameters.adminNameStream - The admin name stream.\n * @param {string} options.parameters.screenShareNameStream - The screen share name stream.\n * @param {boolean} options.parameters.updateMainWindow - Whether to update the main window.\n * @param {boolean} options.parameters.sortAudioLoudness - Whether to sort audio by loudness.\n * @param {number} options.parameters.lastReorderTime - The last reorder time.\n * @param {Array<Stream | Participant>} options.parameters.newLimitedStreams - The list of new limited streams.\n * @param {Array<string>} options.parameters.newLimitedStreamsIDs - The list of new limited stream IDs.\n * @param {Array<string>} options.parameters.oldSoundIds - The list of old sound IDs.\n * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window.\n * @param {Function} options.parameters.updateSortAudioLoudness - Function to update the audio loudness sorting.\n * @param {Function} options.parameters.updateLastReorderTime - Function to update the last reorder time.\n * @param {Function} options.parameters.updateNewLimitedStreams - Function to update the new limited streams.\n * @param {Function} options.parameters.updateNewLimitedStreamsIDs - Function to update the new limited stream IDs.\n * @param {Function} options.parameters.updateOldSoundIds - Function to update the old sound IDs.\n * @param {Function} options.parameters.onScreenChanges - Function to handle screen changes.\n * @param {Function} options.parameters.reorderStreams - Function to reorder streams.\n * @param {Function} options.parameters.changeVids - Function to change videos.\n *\n * @returns {Promise<void>} A promise that resolves when the interaction update is complete.\n *\n * @throws {Error} Throws an error if there is an issue during the interaction update.\n *\n * @example\n * ```typescript\n * const options = {\n *   name: 'John Doe',\n *   add: true,\n *   parameters: {\n *     screenPageLimit: 5,\n *     itemPageLimit: 10,\n *     reorderInterval: 1000,\n *     fastReorderInterval: 500,\n *     eventType: 'conference',\n *     participants: [...],\n *     allVideoStreams: [...],\n *     shared: false,\n *     shareScreenStarted: false,\n *     adminNameStream: 'Admin',\n *     screenShareNameStream: 'ScreenShare',\n *     updateMainWindow: true,\n *     sortAudioLoudness: false,\n *     lastReorderTime: Date.now(),\n *     newLimitedStreams: [],\n *     newLimitedStreamsIDs: [],\n *     oldSoundIds: [],\n *     updateUpdateMainWindow: (value) => { console.log(updated) },\n *     updateSortAudioLoudness: (value) => { console.log(updated) },\n *     updateLastReorderTime: (value) => { console.log(updated) },\n *     updateNewLimitedStreams: (streams) => { console.log(updated) },\n *     updateNewLimitedStreamsIDs: (ids) => { console.log(updated) },\n *     updateOldSoundIds: (ids) => { console.log(updated) },\n *     onScreenChanges: async (opts) => {  },\n *     reorderStreams: async (opts) => {  },\n *     changeVids: async (opts) => {  },\n *   },\n * };\n *\n * await reUpdateInter(options);\n * ```\n */\n\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ReUpdateInter {\n  /**\n   * Updates the interaction state based on the provided options and parameters.\n   *\n   * @param {ReUpdateInterOptions} options - The options for updating the interaction.\n   * @param {string} options.name - The name of the participant.\n   * @param {boolean} [options.add=false] - Whether to add the participant to the interaction.\n   * @param {boolean} [options.force=false] - Whether to force the update.\n   * @param {number} [options.average=127] - The average value used for determining reorder intervals.\n   * @param {Object} options.parameters - The parameters for updating the interaction.\n   * @param {number} options.parameters.screenPageLimit - The screen page limit.\n   * @param {number} options.parameters.itemPageLimit - The item page limit.\n   * @param {number} options.parameters.reorderInterval - The reorder interval.\n   * @param {number} options.parameters.fastReorderInterval - The fast reorder interval.\n   * @param {string} options.parameters.eventType - The type of event.\n   * @param {Array} options.parameters.participants - The list of participants.\n   * @param {Array} options.parameters.allVideoStreams - The list of all video streams.\n   * @param {boolean} options.parameters.shared - Whether the screen is shared.\n   * @param {boolean} options.parameters.shareScreenStarted - Whether screen sharing has started.\n   * @param {string} options.parameters.adminNameStream - The admin name stream.\n   * @param {string} options.parameters.screenShareNameStream - The screen share name stream.\n   * @param {boolean} options.parameters.updateMainWindow - Whether to update the main window.\n   * @param {boolean} options.parameters.sortAudioLoudness - Whether to sort audio by loudness.\n   * @param {number} options.parameters.lastReorderTime - The last reorder time.\n   * @param {Array} options.parameters.newLimitedStreams - The list of new limited streams.\n   * @param {Array} options.parameters.newLimitedStreamsIDs - The list of new limited stream IDs.\n   * @param {Array} options.parameters.oldSoundIds - The list of old sound IDs.\n   * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window.\n   * @param {Function} options.parameters.updateSortAudioLoudness - Function to update the audio loudness sorting.\n   * @param {Function} options.parameters.updateLastReorderTime - Function to update the last reorder time.\n   * @param {Function} options.parameters.updateNewLimitedStreams - Function to update the new limited streams.\n   * @param {Function} options.parameters.updateNewLimitedStreamsIDs - Function to update the new limited stream IDs.\n   * @param {Function} options.parameters.updateOldSoundIds - Function to update the old sound IDs.\n   * @param {Function} options.parameters.onScreenChanges - Function to handle screen changes.\n   * @param {Function} options.parameters.reorderStreams - Function to reorder streams.\n   * @param {Function} options.parameters.changeVids - Function to change videos.\n   *\n   * @returns {Promise<void>} A promise that resolves when the interaction update is complete.\n   */\n\n  reUpdateInter = async ({\n    name,\n    add = false,\n    force = false,\n    average = 127,\n    parameters,\n  }: ReUpdateInterOptions): Promise<void> => {\n    let {\n      screenPageLimit,\n      itemPageLimit,\n      reorderInterval,\n      fastReorderInterval,\n      eventType,\n      participants,\n      allVideoStreams,\n      shared,\n      shareScreenStarted,\n      adminNameStream,\n      screenShareNameStream,\n      updateMainWindow,\n      sortAudioLoudness,\n      lastReorderTime,\n      newLimitedStreams,\n      newLimitedStreamsIDs,\n      oldSoundIds,\n      updateUpdateMainWindow,\n      updateSortAudioLoudness,\n      updateLastReorderTime,\n      updateNewLimitedStreams,\n      updateNewLimitedStreamsIDs,\n      updateOldSoundIds,\n      onScreenChanges,\n      reorderStreams,\n      changeVids,\n    } = parameters;\n\n    if (eventType == 'broadcast' || eventType == 'chat') {\n      return;\n    }\n\n    let refLimit = screenPageLimit - 1;\n\n    if (shareScreenStarted || shared) {\n      // Do something when screen is shared or screen share is started\n    } else {\n      refLimit = itemPageLimit - 1;\n\n      if (add) {\n        const currentTime = Date.now();\n        if (\n          (currentTime - lastReorderTime >= reorderInterval && average > 128.5) ||\n          (average > 130 && currentTime - lastReorderTime >= fastReorderInterval)\n        ) {\n          lastReorderTime = currentTime;\n          sortAudioLoudness = true;\n          if (eventType == 'conference') {\n            await onScreenChanges({ changed: true, parameters });\n          } else {\n            await reorderStreams({ add: false, screenChanged: true, parameters });\n          }\n          sortAudioLoudness = false;\n\n          updateSortAudioLoudness(sortAudioLoudness);\n          updateUpdateMainWindow(updateMainWindow);\n          updateLastReorderTime(lastReorderTime);\n\n          return;\n        }\n      }\n    }\n\n    let videoID: string | null = null;\n    if (shareScreenStarted || shared) {\n      if (add) {\n        const participant = participants.find((p) => p.name === name);\n        videoID = participant?.videoID ?? null;\n\n        if (!videoID) {\n          return;\n        }\n\n        if (!newLimitedStreamsIDs.includes(videoID)) {\n          //first check length of newLimitedStreams to not exceed refLimit, if so remove oldSoundID from newLimitedStreams\n          if (newLimitedStreams.length > refLimit) {\n            let oldoldSounds = [...oldSoundIds];\n            for (let i = 0; i < oldSoundIds.length; i++) {\n              if (newLimitedStreams.length > refLimit) {\n                // remove stream from newLimitedStreams\n                if (newLimitedStreams.length < screenPageLimit) {\n                  return;\n                }\n                const currentId = oldSoundIds[i];\n                if (currentId !== screenShareNameStream && currentId !== adminNameStream) {\n                  newLimitedStreams = newLimitedStreams.filter(\n                    (stream) => stream.producerId !== currentId,\n                  );\n                  newLimitedStreamsIDs = newLimitedStreamsIDs.filter((id) => id !== currentId);\n                  oldoldSounds = oldoldSounds.filter((id) => id !== currentId);\n                }\n              }\n            }\n            oldSoundIds = [...oldoldSounds];\n          }\n\n          const stream = allVideoStreams.find((s) => s.producerId === videoID);\n          if (stream && newLimitedStreams.length < screenPageLimit) {\n            newLimitedStreams.push(stream);\n            newLimitedStreamsIDs.push(videoID);\n            if (!oldSoundIds.includes(name)) {\n              oldSoundIds.push(name);\n            }\n            await changeVids({ screenChanged: true, parameters });\n          }\n        }\n      } else {\n        if (!force) {\n          try {\n            // remove stream from newLimitedStreams\n            if (newLimitedStreams.length < screenPageLimit) {\n              return;\n            }\n            newLimitedStreams = newLimitedStreams.filter((stream) => stream.producerId != videoID);\n            newLimitedStreamsIDs = newLimitedStreamsIDs.filter((id) => id !== videoID);\n            oldSoundIds = oldSoundIds.filter((id) => id !== name);\n            await changeVids({ parameters });\n          } catch {\n            /* handle error */\n          }\n        } else {\n          const participant = participants.find((p) => p.name === name);\n          if (participant?.muted) {\n            try {\n              newLimitedStreams = newLimitedStreams.filter(\n                (stream) => stream.producerId !== videoID,\n              );\n              newLimitedStreamsIDs = newLimitedStreamsIDs.filter((id) => id !== videoID);\n              oldSoundIds = oldSoundIds.filter((id) => id !== name);\n              await changeVids({ parameters });\n            } catch {\n              /* handle error */\n            }\n          }\n        }\n      }\n\n      updateNewLimitedStreams(newLimitedStreams);\n      updateNewLimitedStreamsIDs(newLimitedStreamsIDs);\n      updateOldSoundIds(oldSoundIds);\n    }\n  };\n}\n"]}

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

@@ -1,5 +1,55 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Adjusts the layout parameters based on the provided options.
+ *
+ * This method calculates the layout dimensions and updates the main window size based on the current event type,
+ * the number of participants, and whether screen sharing is active. It also manages the state transitions
+ * to ensure that the UI reflects the correct configuration based on user interactions.
+ *
+ * @param {ReadjustOptions} options - The options for readjusting the layout.
+ * @param {number} options.n - The number of participants or elements.
+ * @param {number} options.state - The current state of the layout.
+ * @param {Object} options.parameters - The parameters for the layout adjustment.
+ * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+ * @param {string} options.parameters.eventType - The type of event (e.g., "broadcast", "chat", "conference").
+ * @param {boolean} options.parameters.shareScreenStarted - Indicates if screen sharing has started.
+ * @param {boolean} options.parameters.shared - Indicates if content is being shared.
+ * @param {number} options.parameters.mainHeightWidth - The main height and width value.
+ * @param {number} options.parameters.prevMainHeightWidth - The previous main height and width value.
+ * @param {string} options.parameters.hostLabel - The label for the host.
+ * @param {boolean} options.parameters.first_round - Indicates if it is the first round.
+ * @param {boolean} options.parameters.lock_screen - Indicates if the screen is locked.
+ * @param {Function} options.parameters.updateMainHeightWidth - Function to update the main height and width.
+ * @param {Function} options.parameters.prepopulateUserMedia - Function to prepopulate user media.
+ *
+ * @returns {Promise<void>} A promise that resolves when the layout adjustment is complete.
+ *
+ * @throws {Error} Throws an error if there is an issue updating the grid sizes.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   n: 5,
+ *   state: 0,
+ *   parameters: {
+ *     getUpdatedAllParams: () => updatedParams,
+ *     eventType: 'conference',
+ *     shareScreenStarted: false,
+ *     shared: false,
+ *     mainHeightWidth: 100,
+ *     prevMainHeightWidth: 100,
+ *     hostLabel: 'Host Name',
+ *     first_round: false,
+ *     lock_screen: false,
+ *     updateMainHeightWidth: (value) => { console.log(updated) },
+ *     prepopulateUserMedia: async ({ name, parameters }) => {  },
+ *   },
+ * };
+ *
+ * await readjust(options);
+ * ```
+ */
 export class Readjust {
     /**
      * Adjusts the layout parameters based on the provided options.
@@ -120,4 +170,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"readjust.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/readjust.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  PrepopulateUserMediaType,\n  PrepopulateUserMediaParameters,\n  EventType,\n} from '../@types/types';\nexport interface ReadjustParameters extends PrepopulateUserMediaParameters {\n  eventType: EventType;\n  shareScreenStarted: boolean;\n  shared: boolean;\n  mainHeightWidth: number;\n  prevMainHeightWidth: number;\n  hostLabel: string;\n  first_round: boolean;\n  lock_screen: boolean;\n  updateMainHeightWidth: (value: number) => void;\n\n  // mediasfu functions\n  prepopulateUserMedia: PrepopulateUserMediaType;\n  getUpdatedAllParams: () => ReadjustParameters;\n  [key: string]: any;\n}\n\nexport interface ReadjustOptions {\n  n: number;\n  state: number;\n  parameters: ReadjustParameters;\n}\n\n// Export the type definition for the function\nexport type ReadjustType = (options: ReadjustOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class Readjust {\n  /**\n   * Adjusts the layout parameters based on the provided options.\n   *\n   * @param {ReadjustOptions} options - The options for readjusting the layout.\n   * @param {number} options.n - The number of participants or elements.\n   * @param {number} options.state - The current state of the layout.\n   * @param {object} options.parameters - The parameters for the layout adjustment.\n   * @param {function} options.parameters.getUpdatedAllParams - Function to get updated parameters.\n   * @param {string} options.parameters.eventType - The type of event (e.g., \"broadcast\", \"chat\", \"conference\").\n   * @param {boolean} options.parameters.shareScreenStarted - Indicates if screen sharing has started.\n   * @param {boolean} options.parameters.shared - Indicates if content is being shared.\n   * @param {number} options.parameters.mainHeightWidth - The main height and width value.\n   * @param {number} options.parameters.prevMainHeightWidth - The previous main height and width value.\n   * @param {string} options.parameters.hostLabel - The label for the host.\n   * @param {boolean} options.parameters.first_round - Indicates if it is the first round.\n   * @param {boolean} options.parameters.lock_screen - Indicates if the screen is locked.\n   * @param {function} options.parameters.updateMainHeightWidth - Function to update the main height and width.\n   * @param {function} options.parameters.prepopulateUserMedia - Function to prepopulate user media.\n   * @returns {Promise<void>} A promise that resolves when the layout adjustment is complete.\n   * @throws {Error} Throws an error if there is an issue updating the grid sizes.\n   */\n  readjust = async ({ n, state, parameters }: ReadjustOptions): Promise<void> => {\n    let { getUpdatedAllParams, prepopulateUserMedia } = parameters;\n    parameters = getUpdatedAllParams();\n\n    try {\n      // Destructure parameters\n      let {\n        eventType,\n        shareScreenStarted,\n        shared,\n        mainHeightWidth,\n        prevMainHeightWidth,\n        hostLabel,\n        first_round,\n        lock_screen,\n        updateMainHeightWidth,\n      } = parameters;\n\n      if (state == 0) {\n        prevMainHeightWidth = mainHeightWidth;\n      }\n\n      let val1 = 6;\n      let val2 = 12 - val1;\n      let cal1 = Math.floor((val1 / 12) * 100);\n      let cal2 = 100 - cal1;\n\n      if (eventType == 'broadcast') {\n        val1 = 0;\n        val2 = 12 - val1;\n\n        if (n == 0) {\n          val1 = 0;\n          val2 = 12 - val1;\n        }\n      } else if (\n        eventType == 'chat' ||\n        (eventType == 'conference' && !(shareScreenStarted || shared))\n      ) {\n        val1 = 12;\n        val2 = 12 - val1;\n      } else {\n        if (shareScreenStarted || shared) {\n          val2 = 10;\n          val1 = 12 - val2;\n        } else {\n          if (n == 0) {\n            val1 = 1;\n            val2 = 12 - val1;\n          } else if (n >= 1 && n < 4) {\n            val1 = 4;\n            val2 = 12 - val1;\n          } else if (n >= 4 && n < 6) {\n            val1 = 6;\n            val2 = 12 - val1;\n          } else if (n >= 6 && n < 9) {\n            val1 = 6;\n            val2 = 12 - val1;\n          } else if (n >= 9 && n < 12) {\n            val1 = 6;\n            val2 = 12 - val1;\n          } else if (n >= 12 && n < 20) {\n            val1 = 8;\n            val2 = 12 - val1;\n          } else if (n >= 20 && n < 50) {\n            val1 = 8;\n            val2 = 12 - val1;\n          } else {\n            val1 = 10;\n            val2 = 12 - val1;\n          }\n        }\n      }\n\n      if (state == 0) {\n        mainHeightWidth = val2;\n      }\n\n      cal1 = Math.floor((val1 / 12) * 100);\n      cal2 = 100 - cal1;\n\n      updateMainHeightWidth(cal2);\n\n      if (prevMainHeightWidth != mainHeightWidth) {\n        if (!lock_screen && !shared) {\n          await prepopulateUserMedia({ name: hostLabel, parameters });\n        } else {\n          if (!first_round) {\n            await prepopulateUserMedia({ name: hostLabel, parameters });\n          }\n        }\n      }\n    } catch (error: any) {\n      // Handle errors during the process of updating grid sizes\n      console.log('Error updating grid sizes:', error.message);\n      // throw error;\n    }\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"readjust.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/readjust.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAgC3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAMH,MAAM,OAAO,QAAQ;IACnB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,QAAQ,GAAG,KAAK,EAAE,EAAE,CAAC,EAAE,KAAK,EAAE,UAAU,EAAmB,EAAiB,EAAE;QAC5E,IAAI,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,GAAG,UAAU,CAAC;QAC/D,UAAU,GAAG,mBAAmB,EAAE,CAAC;QAEnC,IAAI,CAAC;YACH,yBAAyB;YACzB,IAAI,EACF,SAAS,EACT,kBAAkB,EAClB,MAAM,EACN,eAAe,EACf,mBAAmB,EACnB,SAAS,EACT,WAAW,EACX,WAAW,EACX,qBAAqB,GACtB,GAAG,UAAU,CAAC;YAEf,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;gBACf,mBAAmB,GAAG,eAAe,CAAC;YACxC,CAAC;YAED,IAAI,IAAI,GAAG,CAAC,CAAC;YACb,IAAI,IAAI,GAAG,EAAE,GAAG,IAAI,CAAC;YACrB,IAAI,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,GAAG,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC;YACzC,IAAI,IAAI,GAAG,GAAG,GAAG,IAAI,CAAC;YAEtB,IAAI,SAAS,IAAI,WAAW,EAAE,CAAC;gBAC7B,IAAI,GAAG,CAAC,CAAC;gBACT,IAAI,GAAG,EAAE,GAAG,IAAI,CAAC;gBAEjB,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;oBACX,IAAI,GAAG,CAAC,CAAC;oBACT,IAAI,GAAG,EAAE,GAAG,IAAI,CAAC;gBACnB,CAAC;YACH,CAAC;iBAAM,IACL,SAAS,IAAI,MAAM;gBACnB,CAAC,SAAS,IAAI,YAAY,IAAI,CAAC,CAAC,kBAAkB,IAAI,MAAM,CAAC,CAAC,EAC9D,CAAC;gBACD,IAAI,GAAG,EAAE,CAAC;gBACV,IAAI,GAAG,EAAE,GAAG,IAAI,CAAC;YACnB,CAAC;iBAAM,CAAC;gBACN,IAAI,kBAAkB,IAAI,MAAM,EAAE,CAAC;oBACjC,IAAI,GAAG,EAAE,CAAC;oBACV,IAAI,GAAG,EAAE,GAAG,IAAI,CAAC;gBACnB,CAAC;qBAAM,CAAC;oBACN,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;wBACX,IAAI,GAAG,CAAC,CAAC;wBACT,IAAI,GAAG,EAAE,GAAG,IAAI,CAAC;oBACnB,CAAC;yBAAM,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;wBAC3B,IAAI,GAAG,CAAC,CAAC;wBACT,IAAI,GAAG,EAAE,GAAG,IAAI,CAAC;oBACnB,CAAC;yBAAM,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;wBAC3B,IAAI,GAAG,CAAC,CAAC;wBACT,IAAI,GAAG,EAAE,GAAG,IAAI,CAAC;oBACnB,CAAC;yBAAM,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;wBAC3B,IAAI,GAAG,CAAC,CAAC;wBACT,IAAI,GAAG,EAAE,GAAG,IAAI,CAAC;oBACnB,CAAC;yBAAM,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC;wBAC5B,IAAI,GAAG,CAAC,CAAC;wBACT,IAAI,GAAG,EAAE,GAAG,IAAI,CAAC;oBACnB,CAAC;yBAAM,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC;wBAC7B,IAAI,GAAG,CAAC,CAAC;wBACT,IAAI,GAAG,EAAE,GAAG,IAAI,CAAC;oBACnB,CAAC;yBAAM,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC;wBAC7B,IAAI,GAAG,CAAC,CAAC;wBACT,IAAI,GAAG,EAAE,GAAG,IAAI,CAAC;oBACnB,CAAC;yBAAM,CAAC;wBACN,IAAI,GAAG,EAAE,CAAC;wBACV,IAAI,GAAG,EAAE,GAAG,IAAI,CAAC;oBACnB,CAAC;gBACH,CAAC;YACH,CAAC;YAED,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;gBACf,eAAe,GAAG,IAAI,CAAC;YACzB,CAAC;YAED,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,GAAG,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC;YACrC,IAAI,GAAG,GAAG,GAAG,IAAI,CAAC;YAElB,qBAAqB,CAAC,IAAI,CAAC,CAAC;YAE5B,IAAI,mBAAmB,IAAI,eAAe,EAAE,CAAC;gBAC3C,IAAI,CAAC,WAAW,IAAI,CAAC,MAAM,EAAE,CAAC;oBAC5B,MAAM,oBAAoB,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,UAAU,EAAE,CAAC,CAAC;gBAC9D,CAAC;qBAAM,CAAC;oBACN,IAAI,CAAC,WAAW,EAAE,CAAC;wBACjB,MAAM,oBAAoB,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,UAAU,EAAE,CAAC,CAAC;oBAC9D,CAAC;gBACH,CAAC;YACH,CAAC;QACH,CAAC;QAAC,OAAO,KAAU,EAAE,CAAC;YACpB,0DAA0D;YAC1D,OAAO,CAAC,GAAG,CAAC,4BAA4B,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;YACzD,eAAe;QACjB,CAAC;IACH,CAAC,CAAC;uGAvHS,QAAQ;2GAAR,QAAQ,cAFP,MAAM;;2FAEP,QAAQ;kBAHpB,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  PrepopulateUserMediaType,\n  PrepopulateUserMediaParameters,\n  EventType,\n} from '../@types/types';\nexport interface ReadjustParameters extends PrepopulateUserMediaParameters {\n  eventType: EventType;\n  shareScreenStarted: boolean;\n  shared: boolean;\n  mainHeightWidth: number;\n  prevMainHeightWidth: number;\n  hostLabel: string;\n  first_round: boolean;\n  lock_screen: boolean;\n  updateMainHeightWidth: (value: number) => void;\n\n  // mediasfu functions\n  prepopulateUserMedia: PrepopulateUserMediaType;\n  getUpdatedAllParams: () => ReadjustParameters;\n  [key: string]: any;\n}\n\nexport interface ReadjustOptions {\n  n: number;\n  state: number;\n  parameters: ReadjustParameters;\n}\n\n// Export the type definition for the function\nexport type ReadjustType = (options: ReadjustOptions) => Promise<void>;\n\n/**\n * Adjusts the layout parameters based on the provided options.\n *\n * This method calculates the layout dimensions and updates the main window size based on the current event type,\n * the number of participants, and whether screen sharing is active. It also manages the state transitions\n * to ensure that the UI reflects the correct configuration based on user interactions.\n *\n * @param {ReadjustOptions} options - The options for readjusting the layout.\n * @param {number} options.n - The number of participants or elements.\n * @param {number} options.state - The current state of the layout.\n * @param {Object} options.parameters - The parameters for the layout adjustment.\n * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.\n * @param {string} options.parameters.eventType - The type of event (e.g., \"broadcast\", \"chat\", \"conference\").\n * @param {boolean} options.parameters.shareScreenStarted - Indicates if screen sharing has started.\n * @param {boolean} options.parameters.shared - Indicates if content is being shared.\n * @param {number} options.parameters.mainHeightWidth - The main height and width value.\n * @param {number} options.parameters.prevMainHeightWidth - The previous main height and width value.\n * @param {string} options.parameters.hostLabel - The label for the host.\n * @param {boolean} options.parameters.first_round - Indicates if it is the first round.\n * @param {boolean} options.parameters.lock_screen - Indicates if the screen is locked.\n * @param {Function} options.parameters.updateMainHeightWidth - Function to update the main height and width.\n * @param {Function} options.parameters.prepopulateUserMedia - Function to prepopulate user media.\n *\n * @returns {Promise<void>} A promise that resolves when the layout adjustment is complete.\n *\n * @throws {Error} Throws an error if there is an issue updating the grid sizes.\n *\n * @example\n * ```typescript\n * const options = {\n *   n: 5,\n *   state: 0,\n *   parameters: {\n *     getUpdatedAllParams: () => updatedParams,\n *     eventType: 'conference',\n *     shareScreenStarted: false,\n *     shared: false,\n *     mainHeightWidth: 100,\n *     prevMainHeightWidth: 100,\n *     hostLabel: 'Host Name',\n *     first_round: false,\n *     lock_screen: false,\n *     updateMainHeightWidth: (value) => { console.log(updated) },\n *     prepopulateUserMedia: async ({ name, parameters }) => {  },\n *   },\n * };\n *\n * await readjust(options);\n * ```\n */\n\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class Readjust {\n  /**\n   * Adjusts the layout parameters based on the provided options.\n   *\n   * @param {ReadjustOptions} options - The options for readjusting the layout.\n   * @param {number} options.n - The number of participants or elements.\n   * @param {number} options.state - The current state of the layout.\n   * @param {object} options.parameters - The parameters for the layout adjustment.\n   * @param {function} options.parameters.getUpdatedAllParams - Function to get updated parameters.\n   * @param {string} options.parameters.eventType - The type of event (e.g., \"broadcast\", \"chat\", \"conference\").\n   * @param {boolean} options.parameters.shareScreenStarted - Indicates if screen sharing has started.\n   * @param {boolean} options.parameters.shared - Indicates if content is being shared.\n   * @param {number} options.parameters.mainHeightWidth - The main height and width value.\n   * @param {number} options.parameters.prevMainHeightWidth - The previous main height and width value.\n   * @param {string} options.parameters.hostLabel - The label for the host.\n   * @param {boolean} options.parameters.first_round - Indicates if it is the first round.\n   * @param {boolean} options.parameters.lock_screen - Indicates if the screen is locked.\n   * @param {function} options.parameters.updateMainHeightWidth - Function to update the main height and width.\n   * @param {function} options.parameters.prepopulateUserMedia - Function to prepopulate user media.\n   * @returns {Promise<void>} A promise that resolves when the layout adjustment is complete.\n   * @throws {Error} Throws an error if there is an issue updating the grid sizes.\n   */\n  readjust = async ({ n, state, parameters }: ReadjustOptions): Promise<void> => {\n    let { getUpdatedAllParams, prepopulateUserMedia } = parameters;\n    parameters = getUpdatedAllParams();\n\n    try {\n      // Destructure parameters\n      let {\n        eventType,\n        shareScreenStarted,\n        shared,\n        mainHeightWidth,\n        prevMainHeightWidth,\n        hostLabel,\n        first_round,\n        lock_screen,\n        updateMainHeightWidth,\n      } = parameters;\n\n      if (state == 0) {\n        prevMainHeightWidth = mainHeightWidth;\n      }\n\n      let val1 = 6;\n      let val2 = 12 - val1;\n      let cal1 = Math.floor((val1 / 12) * 100);\n      let cal2 = 100 - cal1;\n\n      if (eventType == 'broadcast') {\n        val1 = 0;\n        val2 = 12 - val1;\n\n        if (n == 0) {\n          val1 = 0;\n          val2 = 12 - val1;\n        }\n      } else if (\n        eventType == 'chat' ||\n        (eventType == 'conference' && !(shareScreenStarted || shared))\n      ) {\n        val1 = 12;\n        val2 = 12 - val1;\n      } else {\n        if (shareScreenStarted || shared) {\n          val2 = 10;\n          val1 = 12 - val2;\n        } else {\n          if (n == 0) {\n            val1 = 1;\n            val2 = 12 - val1;\n          } else if (n >= 1 && n < 4) {\n            val1 = 4;\n            val2 = 12 - val1;\n          } else if (n >= 4 && n < 6) {\n            val1 = 6;\n            val2 = 12 - val1;\n          } else if (n >= 6 && n < 9) {\n            val1 = 6;\n            val2 = 12 - val1;\n          } else if (n >= 9 && n < 12) {\n            val1 = 6;\n            val2 = 12 - val1;\n          } else if (n >= 12 && n < 20) {\n            val1 = 8;\n            val2 = 12 - val1;\n          } else if (n >= 20 && n < 50) {\n            val1 = 8;\n            val2 = 12 - val1;\n          } else {\n            val1 = 10;\n            val2 = 12 - val1;\n          }\n        }\n      }\n\n      if (state == 0) {\n        mainHeightWidth = val2;\n      }\n\n      cal1 = Math.floor((val1 / 12) * 100);\n      cal2 = 100 - cal1;\n\n      updateMainHeightWidth(cal2);\n\n      if (prevMainHeightWidth != mainHeightWidth) {\n        if (!lock_screen && !shared) {\n          await prepopulateUserMedia({ name: hostLabel, parameters });\n        } else {\n          if (!first_round) {\n            await prepopulateUserMedia({ name: hostLabel, parameters });\n          }\n        }\n      }\n    } catch (error: any) {\n      // Handle errors during the process of updating grid sizes\n      console.log('Error updating grid sizes:', error.message);\n      // throw error;\n    }\n  };\n}\n"]}

package/dist/esm2022/lib/consumers/receive-all-piped-transports.service.mjs

@@ -1,5 +1,36 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Receives all piped transports by emitting an event to the server and processing the response.
+ *
+ * This method communicates with the server to request piped transports for a specific room and member.
+ * It checks if any producers exist and, if so, iterates through different levels to retrieve piped producers.
+ *
+ * @param {ReceiveAllPipedTransportsOptions} options - The options for receiving all piped transports.
+ * @param {Socket} options.nsock - The socket instance used for communication.
+ * @param {ReceiveAllPipedTransportsParameters} options.parameters - The parameters for the operation.
+ * @param {string} options.parameters.roomName - The name of the room.
+ * @param {string} options.parameters.member - The member identifier.
+ * @param {GetPipedProducersAltType} options.parameters.getPipedProducersAlt - The function to get piped producers for a given level.
+ *
+ * @returns {Promise<void>} A promise that resolves when the operation is complete.
+ *
+ * @throws Will log an error message if the operation fails.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   nsock: socketInstance,
+ *   parameters: {
+ *     roomName: 'Room1',
+ *     member: 'Member1',
+ *     getPipedProducersAlt: getPipedProducersAltFunction,
+ *   },
+ * };
+ *
+ * await receiveAllPipedTransports(options);
+ * ```
+ */
 export class ReceiveAllPipedTransports {
     /**
      * Receives all piped transports by emitting an event to the server and processing the response.
@@ -53,4 +84,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/consumers/receive-room-messages.service.mjs

@@ -1,5 +1,32 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Asynchronously retrieves and updates messages for a specified room from the server.
+ *
+ * This method communicates with the server to request messages for a specific room and updates the messages array accordingly.
+ *
+ * @param {ReceiveRoomMessagesOptions} options - The function parameters.
+ * @param {Socket} options.socket - The socket instance used for communication.
+ * @param {string} options.roomName - The name of the room to retrieve messages for.
+ * @param {function} options.updateMessages - Function to update the messages array with the retrieved messages.
+ *
+ * @returns {Promise<void>} A promise that resolves when the messages have been successfully retrieved and updated.
+ *
+ * @throws Will log an error message if an error occurs during the process of retrieving messages.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   socket: socketInstance,
+ *   roomName: 'Room1',
+ *   updateMessages: (messages) => {
+ *     // Logic to update messages
+ *   },
+ * };
+ *
+ * await receiveRoomMessages(options);
+ * ```
+ */
 export class ReceiveRoomMessages {
     /**
      * Asynchronously retrieves and updates messages for a specified room from the server.
@@ -39,4 +66,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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