mediasfu-angular 1.0.0

package/dist/esm2022/lib/consumers/process-consumer-transports.service.mjs

@@ -0,0 +1,91 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ProcessConsumerTransports {
+    /**
+     * Processes consumer transports by pausing and resuming them based on certain conditions.
+     *
+     * @param {Object} options - The options for processing consumer transports.
+     * @param {Array} options.consumerTransports - The list of consumer transports to process.
+     * @param {Array} options.lStreams_ - The list of local streams.
+     * @param {Object} options.parameters - The parameters object containing various stream arrays and utility functions.
+     *
+     * @returns {Promise<void>} - A promise that resolves when the processing is complete.
+     *
+     * @throws {Error} - Throws an error if there is an issue processing consumer transports.
+     *
+     * The function performs the following steps:
+     * 1. Destructures and updates the parameters.
+     * 2. Defines a helper function to check if a producerId is valid in given stream arrays.
+     * 3. Filters consumer transports to resume based on certain conditions.
+     * 4. Filters consumer transports to pause based on certain conditions.
+     * 5. Pauses consumer transports after a short delay.
+     * 6. Emits `consumer-pause` event for each filtered transport (not audio).
+     * 7. Emits `consumer-resume` event for each filtered transport (not audio).
+     */
+    processConsumerTransports = async ({ consumerTransports, lStreams_, parameters, }) => {
+        try {
+            // Destructure parameters
+            let { getUpdatedAllParams } = parameters;
+            parameters = getUpdatedAllParams();
+            const { remoteScreenStream, oldAllStreams, newLimitedStreams, 
+            // mediasfu functions
+            sleep, } = parameters;
+            // Function to check if the producerId is valid in the given stream arrays
+            const isValidProducerId = (producerId, ...streamArrays) => {
+                return (producerId !== null &&
+                    producerId !== '' &&
+                    streamArrays.some((streamArray) => {
+                        return (streamArray.length > 0 &&
+                            streamArray.some((stream) => stream?.producerId === producerId));
+                    }));
+            };
+            // Get paused consumer transports that are not audio
+            const consumerTransportsToResume = consumerTransports.filter((transport) => isValidProducerId(transport.producerId, lStreams_, remoteScreenStream, oldAllStreams, newLimitedStreams) &&
+                transport.consumer?.paused === true &&
+                transport.consumer.kind !== 'audio');
+            // Get unpaused consumer transports that are not audio
+            const consumerTransportsToPause = consumerTransports.filter((transport) => transport.producerId &&
+                transport.producerId !== null &&
+                transport.producerId !== '' &&
+                !lStreams_.some((stream) => stream.producerId === transport.producerId) &&
+                transport.consumer &&
+                transport.consumer.kind &&
+                transport.consumer.paused !== true &&
+                transport.consumer.kind !== 'audio' &&
+                !remoteScreenStream.some((stream) => stream.producerId === transport.producerId) &&
+                !oldAllStreams.some((stream) => stream.producerId === transport.producerId) &&
+                !newLimitedStreams.some((stream) => stream.producerId === transport.producerId));
+            // Pause consumer transports after a short delay
+            await sleep({ ms: 100 });
+            // Emit consumer.pause() for each filtered transport (not audio)
+            for (const transport of consumerTransportsToPause) {
+                transport.consumer.pause();
+                transport.socket_.emit('consumer-pause', { serverConsumerId: transport.serverConsumerTransportId }, async () => {
+                    // Handle the response if needed
+                });
+            }
+            // Emit consumer.resume() for each filtered transport (not audio)
+            for (const transport of consumerTransportsToResume) {
+                transport.socket_.emit('consumer-resume', { serverConsumerId: transport.serverConsumerTransportId }, async ({ resumed }) => {
+                    if (resumed) {
+                        transport.consumer.resume();
+                    }
+                });
+            }
+        }
+        catch (error) {
+            // Handle errors during the process of pausing or resuming consumer transports
+            console.log(`Error processing consumer transports: ${error.message}`);
+            // throw new Error(`Error processing consumer transports: ${error.message}`);
+        }
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ProcessConsumerTransports, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ProcessConsumerTransports, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ProcessConsumerTransports, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"process-consumer-transports.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/process-consumer-transports.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Stream, Participant, Transport, SleepType } from '../@types/types';\n\nexport interface ProcessConsumerTransportsParameters {\n  remoteScreenStream: Stream[];\n  oldAllStreams: (Stream | Participant)[];\n  newLimitedStreams: (Stream | Participant)[];\n\n  // mediasfu functions\n  sleep: SleepType;\n  getUpdatedAllParams: () => ProcessConsumerTransportsParameters;\n  [key: string]: any;\n}\n\nexport interface ProcessConsumerTransportsOptions {\n  consumerTransports: Transport[];\n  lStreams_: (Stream | Participant)[];\n  parameters: ProcessConsumerTransportsParameters;\n}\n\n// Export the type definition for the function\nexport type ProcessConsumerTransportsType = (\n  options: ProcessConsumerTransportsOptions,\n) => Promise<void>;\n@Injectable({\n  providedIn: 'root',\n})\nexport class ProcessConsumerTransports {\n  /**\n   * Processes consumer transports by pausing and resuming them based on certain conditions.\n   *\n   * @param {Object} options - The options for processing consumer transports.\n   * @param {Array} options.consumerTransports - The list of consumer transports to process.\n   * @param {Array} options.lStreams_ - The list of local streams.\n   * @param {Object} options.parameters - The parameters object containing various stream arrays and utility functions.\n   *\n   * @returns {Promise<void>} - A promise that resolves when the processing is complete.\n   *\n   * @throws {Error} - Throws an error if there is an issue processing consumer transports.\n   *\n   * The function performs the following steps:\n   * 1. Destructures and updates the parameters.\n   * 2. Defines a helper function to check if a producerId is valid in given stream arrays.\n   * 3. Filters consumer transports to resume based on certain conditions.\n   * 4. Filters consumer transports to pause based on certain conditions.\n   * 5. Pauses consumer transports after a short delay.\n   * 6. Emits `consumer-pause` event for each filtered transport (not audio).\n   * 7. Emits `consumer-resume` event for each filtered transport (not audio).\n   */\n  processConsumerTransports = async ({\n    consumerTransports,\n    lStreams_,\n    parameters,\n  }: ProcessConsumerTransportsOptions): Promise<void> => {\n    try {\n      // Destructure parameters\n      let { getUpdatedAllParams } = parameters;\n      parameters = getUpdatedAllParams();\n\n      const {\n        remoteScreenStream,\n        oldAllStreams,\n        newLimitedStreams,\n        // mediasfu functions\n        sleep,\n      } = parameters;\n\n      // Function to check if the producerId is valid in the given stream arrays\n      const isValidProducerId = (\n        producerId: string,\n        ...streamArrays: (Stream | Participant)[][]\n      ): boolean => {\n        return (\n          producerId !== null &&\n          producerId !== '' &&\n          streamArrays.some((streamArray) => {\n            return (\n              streamArray.length > 0 &&\n              streamArray.some((stream) => stream?.producerId === producerId)\n            );\n          })\n        );\n      };\n\n      // Get paused consumer transports that are not audio\n      const consumerTransportsToResume = consumerTransports.filter(\n        (transport) =>\n          isValidProducerId(\n            transport.producerId,\n            lStreams_,\n            remoteScreenStream,\n            oldAllStreams,\n            newLimitedStreams,\n          ) &&\n          transport.consumer?.paused === true &&\n          transport.consumer.kind !== 'audio',\n      );\n\n      // Get unpaused consumer transports that are not audio\n      const consumerTransportsToPause = consumerTransports.filter(\n        (transport) =>\n          transport.producerId &&\n          transport.producerId !== null &&\n          transport.producerId !== '' &&\n          !lStreams_.some((stream) => stream.producerId === transport.producerId) &&\n          transport.consumer &&\n          transport.consumer.kind &&\n          transport.consumer.paused !== true &&\n          transport.consumer.kind !== 'audio' &&\n          !remoteScreenStream.some((stream: any) => stream.producerId === transport.producerId) &&\n          !oldAllStreams.some((stream: any) => stream.producerId === transport.producerId) &&\n          !newLimitedStreams.some((stream: any) => stream.producerId === transport.producerId),\n      );\n\n      // Pause consumer transports after a short delay\n      await sleep({ ms: 100 });\n\n      // Emit consumer.pause() for each filtered transport (not audio)\n      for (const transport of consumerTransportsToPause) {\n        transport.consumer.pause();\n        transport.socket_.emit(\n          'consumer-pause',\n          { serverConsumerId: transport.serverConsumerTransportId },\n          async () => {\n            // Handle the response if needed\n          },\n        );\n      }\n\n      // Emit consumer.resume() for each filtered transport (not audio)\n      for (const transport of consumerTransportsToResume) {\n        transport.socket_.emit(\n          'consumer-resume',\n          { serverConsumerId: transport.serverConsumerTransportId },\n          async ({ resumed }: { resumed: boolean }) => {\n            if (resumed) {\n              transport.consumer.resume();\n            }\n          },\n        );\n      }\n    } catch (error: any) {\n      // Handle errors during the process of pausing or resuming consumer transports\n      console.log(`Error processing consumer transports: ${error.message}`);\n      // throw new Error(`Error processing consumer transports: ${error.message}`);\n    }\n  };\n}\n"]}

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

@@ -0,0 +1,66 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class RePort {
+    /**
+     * RePort function that handles the reporting logic 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 {Object} 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} 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.
+     */
+    async rePort({ restart = false, parameters }) {
+        const { getUpdatedAllParams } = parameters;
+        const updatedParams = getUpdatedAllParams();
+        const { islevel, mainScreenPerson, adminOnMainScreen, mainScreenFilled, recordStarted, recordStopped, recordPaused, recordResumed, screenStates, updateScreenStates, updatePrevScreenStates, compareActiveNames, compareScreenStates, } = updatedParams;
+        try {
+            if (recordStarted || recordResumed) {
+                if (recordStopped || recordPaused) {
+                    // Recording stopped or paused, do nothing
+                }
+                else {
+                    if (islevel === '2') {
+                        const prevScreenStatesCopy = [...screenStates];
+                        updatePrevScreenStates(prevScreenStatesCopy);
+                        const newScreenStates = [{ mainScreenPerson, adminOnMainScreen, mainScreenFilled }];
+                        updateScreenStates(newScreenStates);
+                        await compareActiveNames({ restart, parameters: updatedParams });
+                        if (!restart) {
+                            await compareScreenStates({ restart, parameters: updatedParams });
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Handle errors during the process of rePorting
+            console.error('Error during rePorting: ', error);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: RePort, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: RePort, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: RePort, decorators: [{
+            type: Injectable,
+            args: [{
+                    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"]}

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

@@ -0,0 +1,157 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ReUpdateInter {
+    /**
+     * Updates the interaction state based on the provided options and parameters.
+     *
+     * @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 {Object} 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.
+     * @param {Array} options.parameters.participants - The list of participants.
+     * @param {Array} options.parameters.allVideoStreams - The list of all video streams.
+     * @param {boolean} options.parameters.shared - Whether the screen is shared.
+     * @param {boolean} options.parameters.shareScreenStarted - Whether 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} options.parameters.newLimitedStreams - The list of new limited streams.
+     * @param {Array} options.parameters.newLimitedStreamsIDs - The list of new limited stream IDs.
+     * @param {Array} 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.
+     */
+    reUpdateInter = async ({ name, add = false, force = false, average = 127, parameters, }) => {
+        let { screenPageLimit, itemPageLimit, reorderInterval, fastReorderInterval, eventType, participants, allVideoStreams, shared, shareScreenStarted, adminNameStream, screenShareNameStream, updateMainWindow, sortAudioLoudness, lastReorderTime, newLimitedStreams, newLimitedStreamsIDs, oldSoundIds, updateUpdateMainWindow, updateSortAudioLoudness, updateLastReorderTime, updateNewLimitedStreams, updateNewLimitedStreamsIDs, updateOldSoundIds, onScreenChanges, reorderStreams, changeVids, } = parameters;
+        if (eventType == 'broadcast' || eventType == 'chat') {
+            return;
+        }
+        let refLimit = screenPageLimit - 1;
+        if (shareScreenStarted || shared) {
+            // Do something when screen is shared or screen share is started
+        }
+        else {
+            refLimit = itemPageLimit - 1;
+            if (add) {
+                const currentTime = Date.now();
+                if ((currentTime - lastReorderTime >= reorderInterval && average > 128.5) ||
+                    (average > 130 && currentTime - lastReorderTime >= fastReorderInterval)) {
+                    lastReorderTime = currentTime;
+                    sortAudioLoudness = true;
+                    if (eventType == 'conference') {
+                        await onScreenChanges({ changed: true, parameters });
+                    }
+                    else {
+                        await reorderStreams({ add: false, screenChanged: true, parameters });
+                    }
+                    sortAudioLoudness = false;
+                    updateSortAudioLoudness(sortAudioLoudness);
+                    updateUpdateMainWindow(updateMainWindow);
+                    updateLastReorderTime(lastReorderTime);
+                    return;
+                }
+            }
+        }
+        let videoID = null;
+        if (shareScreenStarted || shared) {
+            if (add) {
+                const participant = participants.find((p) => p.name === name);
+                videoID = participant?.videoID ?? null;
+                if (!videoID) {
+                    return;
+                }
+                if (!newLimitedStreamsIDs.includes(videoID)) {
+                    //first check length of newLimitedStreams to not exceed refLimit, if so remove oldSoundID from newLimitedStreams
+                    if (newLimitedStreams.length > refLimit) {
+                        let oldoldSounds = [...oldSoundIds];
+                        for (let i = 0; i < oldSoundIds.length; i++) {
+                            if (newLimitedStreams.length > refLimit) {
+                                // remove stream from newLimitedStreams
+                                if (newLimitedStreams.length < screenPageLimit) {
+                                    return;
+                                }
+                                const currentId = oldSoundIds[i];
+                                if (currentId !== screenShareNameStream && currentId !== adminNameStream) {
+                                    newLimitedStreams = newLimitedStreams.filter((stream) => stream.producerId !== currentId);
+                                    newLimitedStreamsIDs = newLimitedStreamsIDs.filter((id) => id !== currentId);
+                                    oldoldSounds = oldoldSounds.filter((id) => id !== currentId);
+                                }
+                            }
+                        }
+                        oldSoundIds = [...oldoldSounds];
+                    }
+                    const stream = allVideoStreams.find((s) => s.producerId === videoID);
+                    if (stream && newLimitedStreams.length < screenPageLimit) {
+                        newLimitedStreams.push(stream);
+                        newLimitedStreamsIDs.push(videoID);
+                        if (!oldSoundIds.includes(name)) {
+                            oldSoundIds.push(name);
+                        }
+                        await changeVids({ screenChanged: true, parameters });
+                    }
+                }
+            }
+            else {
+                if (!force) {
+                    try {
+                        // remove stream from newLimitedStreams
+                        if (newLimitedStreams.length < screenPageLimit) {
+                            return;
+                        }
+                        newLimitedStreams = newLimitedStreams.filter((stream) => stream.producerId != videoID);
+                        newLimitedStreamsIDs = newLimitedStreamsIDs.filter((id) => id !== videoID);
+                        oldSoundIds = oldSoundIds.filter((id) => id !== name);
+                        await changeVids({ parameters });
+                    }
+                    catch {
+                        /* handle error */
+                    }
+                }
+                else {
+                    const participant = participants.find((p) => p.name === name);
+                    if (participant?.muted) {
+                        try {
+                            newLimitedStreams = newLimitedStreams.filter((stream) => stream.producerId !== videoID);
+                            newLimitedStreamsIDs = newLimitedStreamsIDs.filter((id) => id !== videoID);
+                            oldSoundIds = oldSoundIds.filter((id) => id !== name);
+                            await changeVids({ parameters });
+                        }
+                        catch {
+                            /* handle error */
+                        }
+                    }
+                }
+            }
+            updateNewLimitedStreams(newLimitedStreams);
+            updateNewLimitedStreamsIDs(newLimitedStreamsIDs);
+            updateOldSoundIds(oldSoundIds);
+        }
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ReUpdateInter, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ReUpdateInter, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ReUpdateInter, decorators: [{
+            type: Injectable,
+            args: [{
+                    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":"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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@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

@@ -0,0 +1,123 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class Readjust {
+    /**
+     * Adjusts the layout parameters based on the provided options.
+     *
+     * @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.
+     */
+    readjust = async ({ n, state, parameters }) => {
+        let { getUpdatedAllParams, prepopulateUserMedia } = parameters;
+        parameters = getUpdatedAllParams();
+        try {
+            // Destructure parameters
+            let { eventType, shareScreenStarted, shared, mainHeightWidth, prevMainHeightWidth, hostLabel, first_round, lock_screen, updateMainHeightWidth, } = parameters;
+            if (state == 0) {
+                prevMainHeightWidth = mainHeightWidth;
+            }
+            let val1 = 6;
+            let val2 = 12 - val1;
+            let cal1 = Math.floor((val1 / 12) * 100);
+            let cal2 = 100 - cal1;
+            if (eventType == 'broadcast') {
+                val1 = 0;
+                val2 = 12 - val1;
+                if (n == 0) {
+                    val1 = 0;
+                    val2 = 12 - val1;
+                }
+            }
+            else if (eventType == 'chat' ||
+                (eventType == 'conference' && !(shareScreenStarted || shared))) {
+                val1 = 12;
+                val2 = 12 - val1;
+            }
+            else {
+                if (shareScreenStarted || shared) {
+                    val2 = 10;
+                    val1 = 12 - val2;
+                }
+                else {
+                    if (n == 0) {
+                        val1 = 1;
+                        val2 = 12 - val1;
+                    }
+                    else if (n >= 1 && n < 4) {
+                        val1 = 4;
+                        val2 = 12 - val1;
+                    }
+                    else if (n >= 4 && n < 6) {
+                        val1 = 6;
+                        val2 = 12 - val1;
+                    }
+                    else if (n >= 6 && n < 9) {
+                        val1 = 6;
+                        val2 = 12 - val1;
+                    }
+                    else if (n >= 9 && n < 12) {
+                        val1 = 6;
+                        val2 = 12 - val1;
+                    }
+                    else if (n >= 12 && n < 20) {
+                        val1 = 8;
+                        val2 = 12 - val1;
+                    }
+                    else if (n >= 20 && n < 50) {
+                        val1 = 8;
+                        val2 = 12 - val1;
+                    }
+                    else {
+                        val1 = 10;
+                        val2 = 12 - val1;
+                    }
+                }
+            }
+            if (state == 0) {
+                mainHeightWidth = val2;
+            }
+            cal1 = Math.floor((val1 / 12) * 100);
+            cal2 = 100 - cal1;
+            updateMainHeightWidth(cal2);
+            if (prevMainHeightWidth != mainHeightWidth) {
+                if (!lock_screen && !shared) {
+                    await prepopulateUserMedia({ name: hostLabel, parameters });
+                }
+                else {
+                    if (!first_round) {
+                        await prepopulateUserMedia({ name: hostLabel, parameters });
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Handle errors during the process of updating grid sizes
+            console.log('Error updating grid sizes:', error.message);
+            // throw error;
+        }
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: Readjust, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: Readjust, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: Readjust, decorators: [{
+            type: Injectable,
+            args: [{
+                    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"]}

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

@@ -0,0 +1,56 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ReceiveAllPipedTransports {
+    /**
+     * Receives all piped transports by emitting an event to the server and processing the response.
+     *
+     * @param {ReceiveAllPipedTransportsOptions} options - The options for receiving all piped transports.
+     * @param {any} options.nsock - The socket instance used for communication.
+     * @param {Object} 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 {Function} 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.
+     */
+    receiveAllPipedTransports = async ({ nsock, parameters, }) => {
+        try {
+            // Destructure parameters
+            const { roomName, member, getPipedProducersAlt } = parameters;
+            // Emit createReceiveAllTransportsPiped event to the server
+            await new Promise((resolve, reject) => {
+                nsock.emit('createReceiveAllTransportsPiped', { roomName, member }, async ({ producersExist }) => {
+                    try {
+                        // Array of options representing different levels
+                        const options = ['0', '1', '2'];
+                        // If producers exist, loop through each level and get producers
+                        if (producersExist) {
+                            for (const islevel of options) {
+                                await getPipedProducersAlt({ nsock, islevel, parameters });
+                            }
+                        }
+                        resolve();
+                    }
+                    catch (err) {
+                        reject(err);
+                    }
+                });
+            });
+        }
+        catch (error) {
+            console.log('receiveAllPipedTransports error', error);
+            // throw error;
+        }
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ReceiveAllPipedTransports, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ReceiveAllPipedTransports, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ReceiveAllPipedTransports, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVjZWl2ZS1hbGwtcGlwZWQtdHJhbnNwb3J0cy5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbWVkaWFzZnUtYW5ndWxhci9zcmMvbGliL2NvbnN1bWVycy9yZWNlaXZlLWFsbC1waXBlZC10cmFuc3BvcnRzLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUEwQjNDLE1BQU0sT0FBTyx5QkFBeUI7SUFDcEM7Ozs7Ozs7Ozs7Ozs7T0FhRztJQUNILHlCQUF5QixHQUFHLEtBQUssRUFBRSxFQUNqQyxLQUFLLEVBQ0wsVUFBVSxHQUN1QixFQUFpQixFQUFFO1FBQ3BELElBQUksQ0FBQztZQUNILHlCQUF5QjtZQUN6QixNQUFNLEVBQUUsUUFBUSxFQUFFLE1BQU0sRUFBRSxvQkFBb0IsRUFBRSxHQUFHLFVBQVUsQ0FBQztZQUU5RCwyREFBMkQ7WUFDM0QsTUFBTSxJQUFJLE9BQU8sQ0FBTyxDQUFDLE9BQU8sRUFBRSxNQUFNLEVBQUUsRUFBRTtnQkFDMUMsS0FBSyxDQUFDLElBQUksQ0FDUixpQ0FBaUMsRUFDakMsRUFBRSxRQUFRLEVBQUUsTUFBTSxFQUFFLEVBQ3BCLEtBQUssRUFBRSxFQUFFLGNBQWMsRUFBK0IsRUFBRSxFQUFFO29CQUN4RCxJQUFJLENBQUM7d0JBQ0gsaURBQWlEO3dCQUNqRCxNQUFNLE9BQU8sR0FBRyxDQUFDLEdBQUcsRUFBRSxHQUFHLEVBQUUsR0FBRyxDQUFDLENBQUM7d0JBRWhDLGdFQUFnRTt3QkFDaEUsSUFBSSxjQUFjLEVBQUUsQ0FBQzs0QkFDbkIsS0FBSyxNQUFNLE9BQU8sSUFBSSxPQUFPLEVBQUUsQ0FBQztnQ0FDOUIsTUFBTSxvQkFBb0IsQ0FBQyxFQUFFLEtBQUssRUFBRSxPQUFPLEVBQUUsVUFBVSxFQUFFLENBQUMsQ0FBQzs0QkFDN0QsQ0FBQzt3QkFDSCxDQUFDO3dCQUNELE9BQU8sRUFBRSxDQUFDO29CQUNaLENBQUM7b0JBQUMsT0FBTyxHQUFHLEVBQUUsQ0FBQzt3QkFDYixNQUFNLENBQUMsR0FBRyxDQUFDLENBQUM7b0JBQ2QsQ0FBQztnQkFDSCxDQUFDLENBQ0YsQ0FBQztZQUNKLENBQUMsQ0FBQyxDQUFDO1FBQ0wsQ0FBQztRQUFDLE9BQU8sS0FBSyxFQUFFLENBQUM7WUFDZixPQUFPLENBQUMsR0FBRyxDQUFDLGlDQUFpQyxFQUFFLEtBQUssQ0FBQyxDQUFDO1lBQ3RELGVBQWU7UUFDakIsQ0FBQztJQUNILENBQUMsQ0FBQzt1R0FsRFMseUJBQXlCOzJHQUF6Qix5QkFBeUIsY0FGeEIsTUFBTTs7MkZBRVAseUJBQXlCO2tCQUhyQyxVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFNvY2tldCB9IGZyb20gJ3NvY2tldC5pby1jbGllbnQnO1xuaW1wb3J0IHsgR2V0UGlwZWRQcm9kdWNlcnNBbHRUeXBlLCBHZXRQaXBlZFByb2R1Y2Vyc0FsdFBhcmFtZXRlcnMgfSBmcm9tICcuLi9AdHlwZXMvdHlwZXMnO1xuXG5leHBvcnQgaW50ZXJmYWNlIFJlY2VpdmVBbGxQaXBlZFRyYW5zcG9ydHNQYXJhbWV0ZXJzIGV4dGVuZHMgR2V0UGlwZWRQcm9kdWNlcnNBbHRQYXJhbWV0ZXJzIHtcbiAgcm9vbU5hbWU6IHN0cmluZztcbiAgbWVtYmVyOiBzdHJpbmc7XG5cbiAgLy8gbWVkaWFzZnUgZnVuY3Rpb25zXG4gIGdldFBpcGVkUHJvZHVjZXJzQWx0OiBHZXRQaXBlZFByb2R1Y2Vyc0FsdFR5cGU7XG4gIFtrZXk6IHN0cmluZ106IGFueTtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBSZWNlaXZlQWxsUGlwZWRUcmFuc3BvcnRzT3B0aW9ucyB7XG4gIG5zb2NrOiBTb2NrZXQ7XG4gIHBhcmFtZXRlcnM6IFJlY2VpdmVBbGxQaXBlZFRyYW5zcG9ydHNQYXJhbWV0ZXJzO1xufVxuXG4vLyBFeHBvcnQgdGhlIHR5cGUgZGVmaW5pdGlvbiBmb3IgdGhlIGZ1bmN0aW9uXG5leHBvcnQgdHlwZSBSZWNlaXZlQWxsUGlwZWRUcmFuc3BvcnRzVHlwZSA9IChcbiAgb3B0aW9uczogUmVjZWl2ZUFsbFBpcGVkVHJhbnNwb3J0c09wdGlvbnMsXG4pID0+IFByb21pc2U8dm9pZD47XG5cbkBJbmplY3RhYmxlKHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnLFxufSlcbmV4cG9ydCBjbGFzcyBSZWNlaXZlQWxsUGlwZWRUcmFuc3BvcnRzIHtcbiAgLyoqXG4gICAqIFJlY2VpdmVzIGFsbCBwaXBlZCB0cmFuc3BvcnRzIGJ5IGVtaXR0aW5nIGFuIGV2ZW50IHRvIHRoZSBzZXJ2ZXIgYW5kIHByb2Nlc3NpbmcgdGhlIHJlc3BvbnNlLlxuICAgKlxuICAgKiBAcGFyYW0ge1JlY2VpdmVBbGxQaXBlZFRyYW5zcG9ydHNPcHRpb25zfSBvcHRpb25zIC0gVGhlIG9wdGlvbnMgZm9yIHJlY2VpdmluZyBhbGwgcGlwZWQgdHJhbnNwb3J0cy5cbiAgICogQHBhcmFtIHthbnl9IG9wdGlvbnMubnNvY2sgLSBUaGUgc29ja2V0IGluc3RhbmNlIHVzZWQgZm9yIGNvbW11bmljYXRpb24uXG4gICAqIEBwYXJhbSB7T2JqZWN0fSBvcHRpb25zLnBhcmFtZXRlcnMgLSBUaGUgcGFyYW1ldGVycyBmb3IgdGhlIG9wZXJhdGlvbi5cbiAgICogQHBhcmFtIHtzdHJpbmd9IG9wdGlvbnMucGFyYW1ldGVycy5yb29tTmFtZSAtIFRoZSBuYW1lIG9mIHRoZSByb29tLlxuICAgKiBAcGFyYW0ge3N0cmluZ30gb3B0aW9ucy5wYXJhbWV0ZXJzLm1lbWJlciAtIFRoZSBtZW1iZXIgaWRlbnRpZmllci5cbiAgICogQHBhcmFtIHtGdW5jdGlvbn0gb3B0aW9ucy5wYXJhbWV0ZXJzLmdldFBpcGVkUHJvZHVjZXJzQWx0IC0gVGhlIGZ1bmN0aW9uIHRvIGdldCBwaXBlZCBwcm9kdWNlcnMgZm9yIGEgZ2l2ZW4gbGV2ZWwuXG4gICAqXG4gICAqIEByZXR1cm5zIHtQcm9taXNlPHZvaWQ+fSBBIHByb21pc2UgdGhhdCByZXNvbHZlcyB3aGVuIHRoZSBvcGVyYXRpb24gaXMgY29tcGxldGUuXG4gICAqXG4gICAqIEB0aHJvd3MgV2lsbCBsb2cgYW4gZXJyb3IgbWVzc2FnZSBpZiB0aGUgb3BlcmF0aW9uIGZhaWxzLlxuICAgKi9cbiAgcmVjZWl2ZUFsbFBpcGVkVHJhbnNwb3J0cyA9IGFzeW5jICh7XG4gICAgbnNvY2ssXG4gICAgcGFyYW1ldGVycyxcbiAgfTogUmVjZWl2ZUFsbFBpcGVkVHJhbnNwb3J0c09wdGlvbnMpOiBQcm9taXNlPHZvaWQ+ID0+IHtcbiAgICB0cnkge1xuICAgICAgLy8gRGVzdHJ1Y3R1cmUgcGFyYW1ldGVyc1xuICAgICAgY29uc3QgeyByb29tTmFtZSwgbWVtYmVyLCBnZXRQaXBlZFByb2R1Y2Vyc0FsdCB9ID0gcGFyYW1ldGVycztcblxuICAgICAgLy8gRW1pdCBjcmVhdGVSZWNlaXZlQWxsVHJhbnNwb3J0c1BpcGVkIGV2ZW50IHRvIHRoZSBzZXJ2ZXJcbiAgICAgIGF3YWl0IG5ldyBQcm9taXNlPHZvaWQ+KChyZXNvbHZlLCByZWplY3QpID0+IHtcbiAgICAgICAgbnNvY2suZW1pdChcbiAgICAgICAgICAnY3JlYXRlUmVjZWl2ZUFsbFRyYW5zcG9ydHNQaXBlZCcsXG4gICAgICAgICAgeyByb29tTmFtZSwgbWVtYmVyIH0sXG4gICAgICAgICAgYXN5bmMgKHsgcHJvZHVjZXJzRXhpc3QgfTogeyBwcm9kdWNlcnNFeGlzdDogYm9vbGVhbiB9KSA9PiB7XG4gICAgICAgICAgICB0cnkge1xuICAgICAgICAgICAgICAvLyBBcnJheSBvZiBvcHRpb25zIHJlcHJlc2VudGluZyBkaWZmZXJlbnQgbGV2ZWxzXG4gICAgICAgICAgICAgIGNvbnN0IG9wdGlvbnMgPSBbJzAnLCAnMScsICcyJ107XG5cbiAgICAgICAgICAgICAgLy8gSWYgcHJvZHVjZXJzIGV4aXN0LCBsb29wIHRocm91Z2ggZWFjaCBsZXZlbCBhbmQgZ2V0IHByb2R1Y2Vyc1xuICAgICAgICAgICAgICBpZiAocHJvZHVjZXJzRXhpc3QpIHtcbiAgICAgICAgICAgICAgICBmb3IgKGNvbnN0IGlzbGV2ZWwgb2Ygb3B0aW9ucykge1xuICAgICAgICAgICAgICAgICAgYXdhaXQgZ2V0UGlwZWRQcm9kdWNlcnNBbHQoeyBuc29jaywgaXNsZXZlbCwgcGFyYW1ldGVycyB9KTtcbiAgICAgICAgICAgICAgICB9XG4gICAgICAgICAgICAgIH1cbiAgICAgICAgICAgICAgcmVzb2x2ZSgpO1xuICAgICAgICAgICAgfSBjYXRjaCAoZXJyKSB7XG4gICAgICAgICAgICAgIHJlamVjdChlcnIpO1xuICAgICAgICAgICAgfVxuICAgICAgICAgIH0sXG4gICAgICAgICk7XG4gICAgICB9KTtcbiAgICB9IGNhdGNoIChlcnJvcikge1xuICAgICAgY29uc29sZS5sb2coJ3JlY2VpdmVBbGxQaXBlZFRyYW5zcG9ydHMgZXJyb3InLCBlcnJvcik7XG4gICAgICAvLyB0aHJvdyBlcnJvcjtcbiAgICB9XG4gIH07XG59XG4iXX0=