mediasfu-angular 1.0.0

package/dist/esm2022/lib/consumers/check-grid.service.mjs

@@ -0,0 +1,79 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class CheckGrid {
+    /**
+     * Checks the grid configuration and calculates various parameters based on the number of rows, columns, and active elements.
+     *
+     * @param {CheckGridOptions} options - The options for checking the grid.
+     * @param {number} options.rows - The number of rows in the grid.
+     * @param {number} options.cols - The number of columns in the grid.
+     * @param {number} options.actives - The number of active elements in the grid.
+     * @returns {Promise<[boolean, number, number, number, number, number, number] | void>} A promise that resolves to a tuple containing:
+     * - `removeAltGrid` (boolean): Indicates whether to remove the alternate grid.
+     * - `numtoadd` (number): The number of elements to add.
+     * - `numRows` (number): The number of rows.
+     * - `numCols` (number): The number of columns.
+     * - `remainingVideos` (number): The number of remaining videos.
+     * - `actualRows` (number): The actual number of rows.
+     * - `lastrowcols` (number): The number of columns in the last row.
+     *
+     * If an error occurs, it logs the error to the console.
+     */
+    async checkGrid({ rows, cols, actives, }) {
+        try {
+            let numRows = 0;
+            let numCols = 0;
+            let lastrow = 0;
+            let lastrowcols = 0;
+            let remainingVideos = 0;
+            let numtoadd = 0;
+            let actualRows = 0;
+            let removeAltGrid = false;
+            if (rows * cols !== actives) {
+                if (rows * cols > actives) {
+                    const res = actives - (rows - 1) * cols;
+                    if (cols * 0.5 < res) {
+                        lastrow = rows;
+                        lastrowcols = res;
+                        remainingVideos = lastrowcols;
+                    }
+                    else {
+                        lastrowcols = res + cols;
+                        lastrow = rows - 1;
+                        remainingVideos = lastrowcols;
+                    }
+                    numRows = lastrow - 1;
+                    numCols = cols;
+                    numtoadd = (lastrow - 1) * numCols;
+                    actualRows = lastrow;
+                    removeAltGrid = false;
+                }
+            }
+            else {
+                // Perfect fit
+                numCols = cols;
+                numRows = rows;
+                lastrow = rows;
+                lastrowcols = cols;
+                remainingVideos = 0;
+                numtoadd = lastrow * numCols;
+                actualRows = lastrow;
+                removeAltGrid = true;
+            }
+            return [removeAltGrid, numtoadd, numRows, numCols, remainingVideos, actualRows, lastrowcols];
+        }
+        catch (error) {
+            console.log('checkGrid error', error);
+            throw error;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: CheckGrid, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: CheckGrid, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: CheckGrid, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/consumers/check-permission.service.mjs

@@ -0,0 +1,80 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class CheckPermission {
+    /**
+     * Checks the permission based on the provided settings.
+     *
+     * @param {CheckPermissionOptions} options - The options for checking permissions.
+     * @param {string} options.permissionType - The type of permission to check. Can be "audioSetting", "videoSetting", "screenshareSetting", or "chatSetting".
+     * @param {string} options.audioSetting - The setting for audio permission. Can be "allow", "approval", or other.
+     * @param {string} options.videoSetting - The setting for video permission. Can be "allow", "approval", or other.
+     * @param {string} options.screenshareSetting - The setting for screenshare permission. Can be "allow", "approval", or other.
+     * @param {string} options.chatSetting - The setting for chat permission. Can be "allow", "approval", or other.
+     * @returns {Promise<number>} - Returns 0 if the setting is "allow", 1 if the setting is "approval", and 2 for other settings or invalid permission types.
+     * @throws Will throw an error if an unexpected error occurs during the permission check.
+     */
+    async checkPermission({ permissionType, audioSetting, videoSetting, screenshareSetting, chatSetting, }) {
+        try {
+            // Perform a switch case to check for the permissionType and return the response
+            switch (permissionType) {
+                case 'audioSetting':
+                    if (audioSetting === 'allow') {
+                        return 0;
+                    }
+                    else if (audioSetting === 'approval') {
+                        return 1;
+                    }
+                    else {
+                        return 2;
+                    }
+                case 'videoSetting':
+                    if (videoSetting === 'allow') {
+                        return 0;
+                    }
+                    else if (videoSetting === 'approval') {
+                        return 1;
+                    }
+                    else {
+                        return 2;
+                    }
+                case 'screenshareSetting':
+                    if (screenshareSetting === 'allow') {
+                        return 0;
+                    }
+                    else if (screenshareSetting === 'approval') {
+                        return 1;
+                    }
+                    else {
+                        return 2;
+                    }
+                case 'chatSetting':
+                    if (chatSetting === 'allow') {
+                        return 0;
+                    }
+                    else if (chatSetting === 'approval') {
+                        return 1;
+                    }
+                    else {
+                        return 2;
+                    }
+                default:
+                    // throw new Error(`Invalid permissionType: ${permissionType}`);
+                    return 2;
+            }
+        }
+        catch (error) {
+            // console.log('checkPermission error', error);
+            // throw error;
+            return 2;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: CheckPermission, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: CheckPermission, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: CheckPermission, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/consumers/check-screen-share.service.mjs

@@ -0,0 +1,71 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class CheckScreenShare {
+    /**
+     * Checks the current screen sharing status and either stops or requests screen sharing based on the provided parameters.
+     *
+     * @param {CheckScreenShareOptions} options - The options for checking screen share.
+     * @param {Object} options.parameters - The parameters for screen sharing.
+     * @param {boolean} options.parameters.shared - Indicates if the screen is currently being shared.
+     * @param {Function} [options.parameters.showAlert] - Function to show alerts.
+     * @param {boolean} options.parameters.whiteboardStarted - Indicates if the whiteboard session has started.
+     * @param {boolean} options.parameters.whiteboardEnded - Indicates if the whiteboard session has ended.
+     * @param {boolean} options.parameters.breakOutRoomStarted - Indicates if the breakout room session has started.
+     * @param {boolean} options.parameters.breakOutRoomEnded - Indicates if the breakout room session has ended.
+     * @param {Function} options.parameters.stopShareScreen - Function to stop screen sharing.
+     * @param {Function} options.parameters.requestScreenShare - Function to request screen sharing.
+     *
+     * @returns {Promise<void>} A promise that resolves when the screen sharing status has been checked and the appropriate action has been taken.
+     *
+     * @throws Will log an error message if an error occurs during the process.
+     */
+    checkScreenShare = async ({ parameters }) => {
+        try {
+            const { shared, showAlert, whiteboardStarted, whiteboardEnded, breakOutRoomStarted, breakOutRoomEnded, 
+            // mediasfu functions
+            stopShareScreen, requestScreenShare, } = parameters;
+            // Stop screen share if already shared or request screen share if not shared
+            if (shared) {
+                if (whiteboardStarted && !whiteboardEnded) {
+                    showAlert?.({
+                        message: 'Screen share is not allowed when whiteboard is active',
+                        type: 'danger',
+                    });
+                    return;
+                }
+                await stopShareScreen({ parameters });
+            }
+            else {
+                // Can't share if breakout room is active
+                if (breakOutRoomStarted && !breakOutRoomEnded) {
+                    showAlert?.({
+                        message: 'Screen share is not allowed when breakout room is active',
+                        type: 'danger',
+                    });
+                    return;
+                }
+                if (whiteboardStarted && !whiteboardEnded) {
+                    showAlert?.({
+                        message: 'Screen share is not allowed when whiteboard is active',
+                        type: 'danger',
+                    });
+                    return;
+                }
+                await requestScreenShare({ parameters });
+            }
+        }
+        catch (error) {
+            console.log('checkScreenShare error', error);
+            // throw error;
+        }
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: CheckScreenShare, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: CheckScreenShare, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: CheckScreenShare, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlY2stc2NyZWVuLXNoYXJlLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tZWRpYXNmdS1hbmd1bGFyL3NyYy9saWIvY29uc3VtZXJzL2NoZWNrLXNjcmVlbi1zaGFyZS5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBb0MzQyxNQUFNLE9BQU8sZ0JBQWdCO0lBQzNCOzs7Ozs7Ozs7Ozs7Ozs7OztPQWlCRztJQUNILGdCQUFnQixHQUFHLEtBQUssRUFBRSxFQUFFLFVBQVUsRUFBMkIsRUFBaUIsRUFBRTtRQUNsRixJQUFJLENBQUM7WUFDSCxNQUFNLEVBQ0osTUFBTSxFQUNOLFNBQVMsRUFDVCxpQkFBaUIsRUFDakIsZUFBZSxFQUNmLG1CQUFtQixFQUNuQixpQkFBaUI7WUFFakIscUJBQXFCO1lBQ3JCLGVBQWUsRUFDZixrQkFBa0IsR0FDbkIsR0FBRyxVQUFVLENBQUM7WUFFZiw0RUFBNEU7WUFDNUUsSUFBSSxNQUFNLEVBQUUsQ0FBQztnQkFDWCxJQUFJLGlCQUFpQixJQUFJLENBQUMsZUFBZSxFQUFFLENBQUM7b0JBQzFDLFNBQVMsRUFBRSxDQUFDO3dCQUNWLE9BQU8sRUFBRSx1REFBdUQ7d0JBQ2hFLElBQUksRUFBRSxRQUFRO3FCQUNmLENBQUMsQ0FBQztvQkFDSCxPQUFPO2dCQUNULENBQUM7Z0JBQ0QsTUFBTSxlQUFlLENBQUMsRUFBRSxVQUFVLEVBQUUsQ0FBQyxDQUFDO1lBQ3hDLENBQUM7aUJBQU0sQ0FBQztnQkFDTix5Q0FBeUM7Z0JBQ3pDLElBQUksbUJBQW1CLElBQUksQ0FBQyxpQkFBaUIsRUFBRSxDQUFDO29CQUM5QyxTQUFTLEVBQUUsQ0FBQzt3QkFDVixPQUFPLEVBQUUsMERBQTBEO3dCQUNuRSxJQUFJLEVBQUUsUUFBUTtxQkFDZixDQUFDLENBQUM7b0JBQ0gsT0FBTztnQkFDVCxDQUFDO2dCQUVELElBQUksaUJBQWlCLElBQUksQ0FBQyxlQUFlLEVBQUUsQ0FBQztvQkFDMUMsU0FBUyxFQUFFLENBQUM7d0JBQ1YsT0FBTyxFQUFFLHVEQUF1RDt3QkFDaEUsSUFBSSxFQUFFLFFBQVE7cUJBQ2YsQ0FBQyxDQUFDO29CQUNILE9BQU87Z0JBQ1QsQ0FBQztnQkFDRCxNQUFNLGtCQUFrQixDQUFDLEVBQUUsVUFBVSxFQUFFLENBQUMsQ0FBQztZQUMzQyxDQUFDO1FBQ0gsQ0FBQztRQUFDLE9BQU8sS0FBSyxFQUFFLENBQUM7WUFDZixPQUFPLENBQUMsR0FBRyxDQUFDLHdCQUF3QixFQUFFLEtBQUssQ0FBQyxDQUFDO1lBQzdDLGVBQWU7UUFDakIsQ0FBQztJQUNILENBQUMsQ0FBQzt1R0FuRVMsZ0JBQWdCOzJHQUFoQixnQkFBZ0IsY0FGZixNQUFNOzsyRkFFUCxnQkFBZ0I7a0JBSDVCLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHtcbiAgU3RvcFNoYXJlU2NyZWVuVHlwZSxcbiAgU3RvcFNoYXJlU2NyZWVuUGFyYW1ldGVycyxcbiAgUmVxdWVzdFNjcmVlblNoYXJlVHlwZSxcbiAgUmVxdWVzdFNjcmVlblNoYXJlUGFyYW1ldGVycyxcbiAgU2hvd0FsZXJ0LFxufSBmcm9tICcuLi9AdHlwZXMvdHlwZXMnO1xuZXhwb3J0IGludGVyZmFjZSBDaGVja1NjcmVlblNoYXJlUGFyYW1ldGVyc1xuICBleHRlbmRzIFN0b3BTaGFyZVNjcmVlblBhcmFtZXRlcnMsXG4gICAgUmVxdWVzdFNjcmVlblNoYXJlUGFyYW1ldGVycyB7XG4gIHNoYXJlZDogYm9vbGVhbjtcbiAgd2hpdGVib2FyZFN0YXJ0ZWQ6IGJvb2xlYW47XG4gIHdoaXRlYm9hcmRFbmRlZDogYm9vbGVhbjtcbiAgYnJlYWtPdXRSb29tU3RhcnRlZDogYm9vbGVhbjtcbiAgYnJlYWtPdXRSb29tRW5kZWQ6IGJvb2xlYW47XG4gIHNob3dBbGVydD86IFNob3dBbGVydDtcblxuICAvLyBNZWRpYXNmdSBmdW5jdGlvbnNcbiAgc3RvcFNoYXJlU2NyZWVuOiBTdG9wU2hhcmVTY3JlZW5UeXBlO1xuICByZXF1ZXN0U2NyZWVuU2hhcmU6IFJlcXVlc3RTY3JlZW5TaGFyZVR5cGU7XG5cbiAgZ2V0VXBkYXRlZEFsbFBhcmFtczogKCkgPT4gQ2hlY2tTY3JlZW5TaGFyZVBhcmFtZXRlcnM7XG4gIFtrZXk6IHN0cmluZ106IGFueTtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBDaGVja1NjcmVlblNoYXJlT3B0aW9ucyB7XG4gIHBhcmFtZXRlcnM6IENoZWNrU2NyZWVuU2hhcmVQYXJhbWV0ZXJzO1xufVxuXG4vLyBFeHBvcnQgdGhlIHR5cGUgZGVmaW5pdGlvbiBmb3IgdGhlIGZ1bmN0aW9uXG5leHBvcnQgdHlwZSBDaGVja1NjcmVlblNoYXJlVHlwZSA9IChvcHRpb25zOiBDaGVja1NjcmVlblNoYXJlT3B0aW9ucykgPT4gUHJvbWlzZTx2b2lkPjtcblxuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCcsXG59KVxuZXhwb3J0IGNsYXNzIENoZWNrU2NyZWVuU2hhcmUge1xuICAvKipcbiAgICogQ2hlY2tzIHRoZSBjdXJyZW50IHNjcmVlbiBzaGFyaW5nIHN0YXR1cyBhbmQgZWl0aGVyIHN0b3BzIG9yIHJlcXVlc3RzIHNjcmVlbiBzaGFyaW5nIGJhc2VkIG9uIHRoZSBwcm92aWRlZCBwYXJhbWV0ZXJzLlxuICAgKlxuICAgKiBAcGFyYW0ge0NoZWNrU2NyZWVuU2hhcmVPcHRpb25zfSBvcHRpb25zIC0gVGhlIG9wdGlvbnMgZm9yIGNoZWNraW5nIHNjcmVlbiBzaGFyZS5cbiAgICogQHBhcmFtIHtPYmplY3R9IG9wdGlvbnMucGFyYW1ldGVycyAtIFRoZSBwYXJhbWV0ZXJzIGZvciBzY3JlZW4gc2hhcmluZy5cbiAgICogQHBhcmFtIHtib29sZWFufSBvcHRpb25zLnBhcmFtZXRlcnMuc2hhcmVkIC0gSW5kaWNhdGVzIGlmIHRoZSBzY3JlZW4gaXMgY3VycmVudGx5IGJlaW5nIHNoYXJlZC5cbiAgICogQHBhcmFtIHtGdW5jdGlvbn0gW29wdGlvbnMucGFyYW1ldGVycy5zaG93QWxlcnRdIC0gRnVuY3Rpb24gdG8gc2hvdyBhbGVydHMuXG4gICAqIEBwYXJhbSB7Ym9vbGVhbn0gb3B0aW9ucy5wYXJhbWV0ZXJzLndoaXRlYm9hcmRTdGFydGVkIC0gSW5kaWNhdGVzIGlmIHRoZSB3aGl0ZWJvYXJkIHNlc3Npb24gaGFzIHN0YXJ0ZWQuXG4gICAqIEBwYXJhbSB7Ym9vbGVhbn0gb3B0aW9ucy5wYXJhbWV0ZXJzLndoaXRlYm9hcmRFbmRlZCAtIEluZGljYXRlcyBpZiB0aGUgd2hpdGVib2FyZCBzZXNzaW9uIGhhcyBlbmRlZC5cbiAgICogQHBhcmFtIHtib29sZWFufSBvcHRpb25zLnBhcmFtZXRlcnMuYnJlYWtPdXRSb29tU3RhcnRlZCAtIEluZGljYXRlcyBpZiB0aGUgYnJlYWtvdXQgcm9vbSBzZXNzaW9uIGhhcyBzdGFydGVkLlxuICAgKiBAcGFyYW0ge2Jvb2xlYW59IG9wdGlvbnMucGFyYW1ldGVycy5icmVha091dFJvb21FbmRlZCAtIEluZGljYXRlcyBpZiB0aGUgYnJlYWtvdXQgcm9vbSBzZXNzaW9uIGhhcyBlbmRlZC5cbiAgICogQHBhcmFtIHtGdW5jdGlvbn0gb3B0aW9ucy5wYXJhbWV0ZXJzLnN0b3BTaGFyZVNjcmVlbiAtIEZ1bmN0aW9uIHRvIHN0b3Agc2NyZWVuIHNoYXJpbmcuXG4gICAqIEBwYXJhbSB7RnVuY3Rpb259IG9wdGlvbnMucGFyYW1ldGVycy5yZXF1ZXN0U2NyZWVuU2hhcmUgLSBGdW5jdGlvbiB0byByZXF1ZXN0IHNjcmVlbiBzaGFyaW5nLlxuICAgKlxuICAgKiBAcmV0dXJucyB7UHJvbWlzZTx2b2lkPn0gQSBwcm9taXNlIHRoYXQgcmVzb2x2ZXMgd2hlbiB0aGUgc2NyZWVuIHNoYXJpbmcgc3RhdHVzIGhhcyBiZWVuIGNoZWNrZWQgYW5kIHRoZSBhcHByb3ByaWF0ZSBhY3Rpb24gaGFzIGJlZW4gdGFrZW4uXG4gICAqXG4gICAqIEB0aHJvd3MgV2lsbCBsb2cgYW4gZXJyb3IgbWVzc2FnZSBpZiBhbiBlcnJvciBvY2N1cnMgZHVyaW5nIHRoZSBwcm9jZXNzLlxuICAgKi9cbiAgY2hlY2tTY3JlZW5TaGFyZSA9IGFzeW5jICh7IHBhcmFtZXRlcnMgfTogQ2hlY2tTY3JlZW5TaGFyZU9wdGlvbnMpOiBQcm9taXNlPHZvaWQ+ID0+IHtcbiAgICB0cnkge1xuICAgICAgY29uc3Qge1xuICAgICAgICBzaGFyZWQsXG4gICAgICAgIHNob3dBbGVydCxcbiAgICAgICAgd2hpdGVib2FyZFN0YXJ0ZWQsXG4gICAgICAgIHdoaXRlYm9hcmRFbmRlZCxcbiAgICAgICAgYnJlYWtPdXRSb29tU3RhcnRlZCxcbiAgICAgICAgYnJlYWtPdXRSb29tRW5kZWQsXG5cbiAgICAgICAgLy8gbWVkaWFzZnUgZnVuY3Rpb25zXG4gICAgICAgIHN0b3BTaGFyZVNjcmVlbixcbiAgICAgICAgcmVxdWVzdFNjcmVlblNoYXJlLFxuICAgICAgfSA9IHBhcmFtZXRlcnM7XG5cbiAgICAgIC8vIFN0b3Agc2NyZWVuIHNoYXJlIGlmIGFscmVhZHkgc2hhcmVkIG9yIHJlcXVlc3Qgc2NyZWVuIHNoYXJlIGlmIG5vdCBzaGFyZWRcbiAgICAgIGlmIChzaGFyZWQpIHtcbiAgICAgICAgaWYgKHdoaXRlYm9hcmRTdGFydGVkICYmICF3aGl0ZWJvYXJkRW5kZWQpIHtcbiAgICAgICAgICBzaG93QWxlcnQ/Lih7XG4gICAgICAgICAgICBtZXNzYWdlOiAnU2NyZWVuIHNoYXJlIGlzIG5vdCBhbGxvd2VkIHdoZW4gd2hpdGVib2FyZCBpcyBhY3RpdmUnLFxuICAgICAgICAgICAgdHlwZTogJ2RhbmdlcicsXG4gICAgICAgICAgfSk7XG4gICAgICAgICAgcmV0dXJuO1xuICAgICAgICB9XG4gICAgICAgIGF3YWl0IHN0b3BTaGFyZVNjcmVlbih7IHBhcmFtZXRlcnMgfSk7XG4gICAgICB9IGVsc2Uge1xuICAgICAgICAvLyBDYW4ndCBzaGFyZSBpZiBicmVha291dCByb29tIGlzIGFjdGl2ZVxuICAgICAgICBpZiAoYnJlYWtPdXRSb29tU3RhcnRlZCAmJiAhYnJlYWtPdXRSb29tRW5kZWQpIHtcbiAgICAgICAgICBzaG93QWxlcnQ/Lih7XG4gICAgICAgICAgICBtZXNzYWdlOiAnU2NyZWVuIHNoYXJlIGlzIG5vdCBhbGxvd2VkIHdoZW4gYnJlYWtvdXQgcm9vbSBpcyBhY3RpdmUnLFxuICAgICAgICAgICAgdHlwZTogJ2RhbmdlcicsXG4gICAgICAgICAgfSk7XG4gICAgICAgICAgcmV0dXJuO1xuICAgICAgICB9XG5cbiAgICAgICAgaWYgKHdoaXRlYm9hcmRTdGFydGVkICYmICF3aGl0ZWJvYXJkRW5kZWQpIHtcbiAgICAgICAgICBzaG93QWxlcnQ/Lih7XG4gICAgICAgICAgICBtZXNzYWdlOiAnU2NyZWVuIHNoYXJlIGlzIG5vdCBhbGxvd2VkIHdoZW4gd2hpdGVib2FyZCBpcyBhY3RpdmUnLFxuICAgICAgICAgICAgdHlwZTogJ2RhbmdlcicsXG4gICAgICAgICAgfSk7XG4gICAgICAgICAgcmV0dXJuO1xuICAgICAgICB9XG4gICAgICAgIGF3YWl0IHJlcXVlc3RTY3JlZW5TaGFyZSh7IHBhcmFtZXRlcnMgfSk7XG4gICAgICB9XG4gICAgfSBjYXRjaCAoZXJyb3IpIHtcbiAgICAgIGNvbnNvbGUubG9nKCdjaGVja1NjcmVlblNoYXJlIGVycm9yJywgZXJyb3IpO1xuICAgICAgLy8gdGhyb3cgZXJyb3I7XG4gICAgfVxuICB9O1xufVxuIl19

package/dist/esm2022/lib/consumers/close-and-resize.service.mjs

@@ -0,0 +1,229 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class CloseAndResize {
+    /**
+     * Closes and resizes the video and audio elements based on the provided options.
+     *
+     * @param {CloseAndResizeOptions} options - The options for closing and resizing.
+     * @param {string} options.producerId - The ID of the producer.
+     * @param {string} options.kind - The kind of media (audio, video, screenshare, or screen).
+     * @param {object} options.parameters - The parameters for the operation.
+     * @param {function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+     * @param {Array} options.parameters.allAudioStreams - Array of all audio streams.
+     * @param {Array} options.parameters.allVideoStreams - Array of all video streams.
+     * @param {Array} options.parameters.activeNames - Array of active participant names.
+     * @param {Array} options.parameters.participants - Array of participants.
+     * @param {Array} options.parameters.streamNames - Array of stream names.
+     * @param {string} options.parameters.recordingDisplayType - Type of recording display.
+     * @param {boolean} options.parameters.recordingVideoOptimized - Whether recording is video optimized.
+     * @param {string} options.parameters.adminIDStream - ID of the admin stream.
+     * @param {Array} options.parameters.newLimitedStreams - Array of new limited streams.
+     * @param {Array} options.parameters.newLimitedStreamsIDs - Array of new limited stream IDs.
+     * @param {Array} options.parameters.oldAllStreams - Array of old all streams.
+     * @param {boolean} options.parameters.shareScreenStarted - Whether screen sharing has started.
+     * @param {boolean} options.parameters.shared - Whether sharing is active.
+     * @param {string} options.parameters.meetingDisplayType - Type of meeting display.
+     * @param {boolean} options.parameters.defer_receive - Whether to defer receiving.
+     * @param {boolean} options.parameters.lock_screen - Whether the screen is locked.
+     * @param {boolean} options.parameters.firstAll - Whether it is the first all.
+     * @param {boolean} options.parameters.first_round - Whether it is the first round.
+     * @param {boolean} options.parameters.gotAllVids - Whether all videos are received.
+     * @param {string} options.parameters.eventType - Type of event.
+     * @param {string} options.parameters.hostLabel - Label of the host.
+     * @param {boolean} options.parameters.shareEnded - Whether sharing has ended.
+     * @param {boolean} options.parameters.updateMainWindow - Whether to update the main window.
+     * @param {function} options.parameters.updateActiveNames - Function to update active names.
+     * @param {function} options.parameters.updateAllAudioStreams - Function to update all audio streams.
+     * @param {function} options.parameters.updateAllVideoStreams - Function to update all video streams.
+     * @param {function} options.parameters.updateShareScreenStarted - Function to update share screen started status.
+     * @param {function} options.parameters.updateUpdateMainWindow - Function to update main window status.
+     * @param {function} options.parameters.updateNewLimitedStreams - Function to update new limited streams.
+     * @param {function} options.parameters.updateOldAllStreams - Function to update old all streams.
+     * @param {function} options.parameters.updateDefer_receive - Function to update defer receive status.
+     * @param {function} options.parameters.updateMainHeightWidth - Function to update main height and width.
+     * @param {function} options.parameters.updateShareEnded - Function to update share ended status.
+     * @param {function} options.parameters.updateLock_screen - Function to update lock screen status.
+     * @param {function} options.parameters.updateFirstAll - Function to update first all status.
+     * @param {function} options.parameters.updateFirst_round - Function to update first round status.
+     * @param {function} options.parameters.reorderStreams - Function to reorder streams.
+     * @param {function} options.parameters.prepopulateUserMedia - Function to prepopulate user media.
+     * @param {function} options.parameters.getVideos - Function to get videos.
+     * @param {function} options.parameters.rePort - Function to report.
+     *
+     * @returns {Promise<void>} A promise that resolves when the operation is complete.
+     */
+    closeAndResize = async ({ producerId, kind, parameters, }) => {
+        let { getUpdatedAllParams } = parameters;
+        parameters = getUpdatedAllParams();
+        let { allAudioStreams, allVideoStreams, activeNames, participants, streamNames, recordingDisplayType, recordingVideoOptimized, adminIDStream, newLimitedStreams, newLimitedStreamsIDs, oldAllStreams, shareScreenStarted, shared, meetingDisplayType, defer_receive, lock_screen, firstAll, first_round, gotAllVids, eventType, hostLabel, shareEnded, updateMainWindow, updateActiveNames, updateAllAudioStreams, updateAllVideoStreams, updateShareScreenStarted, updateUpdateMainWindow, updateNewLimitedStreams, updateOldAllStreams, updateDefer_receive, updateMainHeightWidth, updateShareEnded, updateLock_screen, updateFirstAll, updateFirst_round, 
+        //mediasfu functions
+        reorderStreams, prepopulateUserMedia, getVideos, rePort, } = parameters;
+        //function to close and resize the video and audio elements
+        let participant;
+        if (kind === 'audio') {
+            //stop the audio by removing the miniAudio with id = producerId
+            //remove the audio from the allAudioStreams array
+            allAudioStreams = allAudioStreams.filter(function (audioStream) {
+                return audioStream.producerId !== producerId;
+            });
+            updateAllAudioStreams(allAudioStreams);
+            if (recordingDisplayType == 'video' && recordingVideoOptimized == true) {
+                // do nothing
+            }
+            else {
+                //get the name of the participant with the producerId
+                participant = participants.find((obj) => obj.audioID === producerId);
+                if (participant) {
+                    //check if the participants videoID is not null or ""
+                    if (participant.videoID !== null && participant.videoID !== '') {
+                        // do nothing
+                    }
+                    else {
+                        //remove the participant from the activeNames array
+                        activeNames = activeNames.filter(function (name) {
+                            return name !== participant?.name;
+                        });
+                        updateActiveNames(activeNames);
+                    }
+                }
+            }
+            let checker = false;
+            let alt_checker = false;
+            if (meetingDisplayType == 'video' && participant) {
+                checker =
+                    participant[0].videoID != null &&
+                        participant[0].videoID != '' &&
+                        participant[0].videoID != undefined;
+            }
+            else {
+                checker = true;
+                alt_checker = true;
+            }
+            if (checker) {
+                if (shareScreenStarted || shared) {
+                    if (!alt_checker) {
+                        await reorderStreams({ parameters });
+                    }
+                }
+                else {
+                    if (alt_checker && meetingDisplayType != 'video') {
+                        await reorderStreams({ add: false, screenChanged: true, parameters });
+                    }
+                }
+            }
+        }
+        else if (kind === 'video') {
+            //update the video elements by removing the miniVideo with id = producerId
+            //remove the video from the allVideoStreams array
+            //check if producerId == adminidstream
+            if (producerId == adminIDStream) {
+                updateMainWindow = true;
+                updateUpdateMainWindow(updateMainWindow);
+            }
+            try {
+                allVideoStreams = allVideoStreams.filter(function (videoStream) {
+                    return videoStream.producerId !== producerId;
+                });
+                updateAllVideoStreams(allVideoStreams);
+                try {
+                    //try remove it from oldVideoStreams
+                    oldAllStreams = oldAllStreams.filter(function (videoStream) {
+                        return videoStream.producerId !== producerId;
+                    });
+                    updateOldAllStreams(oldAllStreams);
+                }
+                catch {
+                    /* handle error */
+                }
+                try {
+                    //try remove it from newLimitedStreams
+                    newLimitedStreams = newLimitedStreams.filter(function (videoStream) {
+                        return videoStream.producerId !== producerId;
+                    });
+                    updateNewLimitedStreams(newLimitedStreams);
+                }
+                catch {
+                    /* handle error */
+                }
+            }
+            catch (error) {
+                try {
+                    //try remove it from oldVideoStreams
+                    oldAllStreams = oldAllStreams.filter(function (videoStream) {
+                        return videoStream.producerId !== producerId;
+                    });
+                    updateOldAllStreams(oldAllStreams);
+                }
+                catch {
+                    /* handle error */
+                }
+            }
+            try {
+                //remove the participant from activeNames
+                activeNames = activeNames.filter(function (name) {
+                    //get the participant with the producerId
+                    let participant = streamNames.find((obj) => obj.producerId === producerId);
+                    return name !== (participant?.name ?? '');
+                });
+                updateActiveNames(activeNames);
+            }
+            catch {
+                /* handle error */
+            }
+            if (lock_screen) {
+                defer_receive = true;
+                // check if the video is the one being displayed (i.e. (newLimitedStreamsIDs))
+                if (newLimitedStreamsIDs.includes(producerId)) {
+                    await prepopulateUserMedia({ name: hostLabel, parameters });
+                    await reorderStreams({ add: false, screenChanged: true, parameters });
+                }
+            }
+            else {
+                await prepopulateUserMedia({ name: hostLabel, parameters });
+                await reorderStreams({ add: false, screenChanged: true, parameters });
+            }
+        }
+        else if (kind === 'screenshare' || kind === 'screen') {
+            //update the video elements by removing the mainVideo with id = producerId
+            updateMainWindow = true;
+            //screenshare stuff
+            shareScreenStarted = false;
+            shareEnded = true;
+            lock_screen = false;
+            firstAll = false;
+            first_round = false;
+            updateUpdateMainWindow(updateMainWindow);
+            updateShareScreenStarted(shareScreenStarted);
+            updateShareEnded(shareEnded);
+            updateLock_screen(lock_screen);
+            updateFirstAll(firstAll);
+            updateFirst_round(first_round);
+            if (!gotAllVids || defer_receive) {
+                defer_receive = false;
+                updateDefer_receive(defer_receive);
+                await getVideos({
+                    participants,
+                    allVideoStreams,
+                    oldAllStreams,
+                    updateAllVideoStreams,
+                    updateOldAllStreams,
+                });
+                await rePort({ parameters });
+            }
+            if (eventType == 'conference') {
+                updateMainHeightWidth(0);
+            }
+            await prepopulateUserMedia({ name: hostLabel, parameters });
+            await reorderStreams({ add: false, screenChanged: true, parameters });
+        }
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: CloseAndResize, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: CloseAndResize, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: CloseAndResize, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"close-and-resize.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/close-and-resize.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  Stream,\n  Participant,\n  ReorderStreamsType,\n  ReorderStreamsParameters,\n  PrepopulateUserMediaParameters,\n  PrepopulateUserMediaType,\n  GetVideosType,\n  RePortType,\n  RePortParameters,\n  EventType,\n} from '../@types/types';\n\nexport interface CloseAndResizeParameters\n  extends ReorderStreamsParameters,\n    PrepopulateUserMediaParameters,\n    RePortParameters {\n  allAudioStreams: (Stream | Participant)[];\n  allVideoStreams: (Stream | Participant)[];\n  activeNames: string[];\n  participants: Participant[];\n  streamNames: Stream[];\n  recordingDisplayType: 'video' | 'media' | 'all';\n  recordingVideoOptimized: boolean;\n  adminIDStream?: string;\n  newLimitedStreams: (Stream | Participant)[];\n  newLimitedStreamsIDs: string[];\n  oldAllStreams: (Stream | Participant)[];\n  shareScreenStarted: boolean;\n  shared: boolean;\n  meetingDisplayType: string;\n  defer_receive: boolean;\n  lock_screen: boolean;\n  firstAll: boolean;\n  first_round: boolean;\n  gotAllVids: boolean;\n  eventType: EventType;\n  hostLabel: string;\n  shareEnded: boolean;\n  updateMainWindow: boolean;\n  updateActiveNames: (activeNames: string[]) => void;\n  updateAllAudioStreams: (allAudioStreams: (Stream | Participant)[]) => void;\n  updateShareScreenStarted: (shareScreenStarted: boolean) => void;\n  updateUpdateMainWindow: (updateMainWindow: boolean) => void;\n  updateNewLimitedStreams: (newLimitedStreams: (Stream | Participant)[]) => void;\n  updateOldAllStreams: (oldAllStreams: (Stream | Participant)[]) => void;\n  updateDefer_receive: (defer_receive: boolean) => void;\n  updateMainHeightWidth: (heightWidth: number) => void;\n  updateShareEnded: (shareEnded: boolean) => void;\n  updateLock_screen: (lock_screen: boolean) => void;\n  updateFirstAll: (firstAll: boolean) => void;\n  updateFirst_round: (first_round: boolean) => void;\n\n  // mediasfu functions\n  reorderStreams: ReorderStreamsType;\n  prepopulateUserMedia: PrepopulateUserMediaType;\n  getVideos: GetVideosType;\n  rePort: RePortType;\n  getUpdatedAllParams: () => CloseAndResizeParameters;\n  [key: string]: any;\n}\n\nexport interface CloseAndResizeOptions {\n  producerId: string;\n  kind: string;\n  parameters: CloseAndResizeParameters;\n}\n\n// Export the type definition for the function\nexport type CloseAndResizeType = (options: CloseAndResizeOptions) => Promise<void>;\n@Injectable({\n  providedIn: 'root',\n})\nexport class CloseAndResize {\n  /**\n   * Closes and resizes the video and audio elements based on the provided options.\n   *\n   * @param {CloseAndResizeOptions} options - The options for closing and resizing.\n   * @param {string} options.producerId - The ID of the producer.\n   * @param {string} options.kind - The kind of media (audio, video, screenshare, or screen).\n   * @param {object} options.parameters - The parameters for the operation.\n   * @param {function} options.parameters.getUpdatedAllParams - Function to get updated parameters.\n   * @param {Array} options.parameters.allAudioStreams - Array of all audio streams.\n   * @param {Array} options.parameters.allVideoStreams - Array of all video streams.\n   * @param {Array} options.parameters.activeNames - Array of active participant names.\n   * @param {Array} options.parameters.participants - Array of participants.\n   * @param {Array} options.parameters.streamNames - Array of stream names.\n   * @param {string} options.parameters.recordingDisplayType - Type of recording display.\n   * @param {boolean} options.parameters.recordingVideoOptimized - Whether recording is video optimized.\n   * @param {string} options.parameters.adminIDStream - ID of the admin stream.\n   * @param {Array} options.parameters.newLimitedStreams - Array of new limited streams.\n   * @param {Array} options.parameters.newLimitedStreamsIDs - Array of new limited stream IDs.\n   * @param {Array} options.parameters.oldAllStreams - Array of old all streams.\n   * @param {boolean} options.parameters.shareScreenStarted - Whether screen sharing has started.\n   * @param {boolean} options.parameters.shared - Whether sharing is active.\n   * @param {string} options.parameters.meetingDisplayType - Type of meeting display.\n   * @param {boolean} options.parameters.defer_receive - Whether to defer receiving.\n   * @param {boolean} options.parameters.lock_screen - Whether the screen is locked.\n   * @param {boolean} options.parameters.firstAll - Whether it is the first all.\n   * @param {boolean} options.parameters.first_round - Whether it is the first round.\n   * @param {boolean} options.parameters.gotAllVids - Whether all videos are received.\n   * @param {string} options.parameters.eventType - Type of event.\n   * @param {string} options.parameters.hostLabel - Label of the host.\n   * @param {boolean} options.parameters.shareEnded - Whether sharing has ended.\n   * @param {boolean} options.parameters.updateMainWindow - Whether to update the main window.\n   * @param {function} options.parameters.updateActiveNames - Function to update active names.\n   * @param {function} options.parameters.updateAllAudioStreams - Function to update all audio streams.\n   * @param {function} options.parameters.updateAllVideoStreams - Function to update all video streams.\n   * @param {function} options.parameters.updateShareScreenStarted - Function to update share screen started status.\n   * @param {function} options.parameters.updateUpdateMainWindow - Function to update main window status.\n   * @param {function} options.parameters.updateNewLimitedStreams - Function to update new limited streams.\n   * @param {function} options.parameters.updateOldAllStreams - Function to update old all streams.\n   * @param {function} options.parameters.updateDefer_receive - Function to update defer receive status.\n   * @param {function} options.parameters.updateMainHeightWidth - Function to update main height and width.\n   * @param {function} options.parameters.updateShareEnded - Function to update share ended status.\n   * @param {function} options.parameters.updateLock_screen - Function to update lock screen status.\n   * @param {function} options.parameters.updateFirstAll - Function to update first all status.\n   * @param {function} options.parameters.updateFirst_round - Function to update first round status.\n   * @param {function} options.parameters.reorderStreams - Function to reorder streams.\n   * @param {function} options.parameters.prepopulateUserMedia - Function to prepopulate user media.\n   * @param {function} options.parameters.getVideos - Function to get videos.\n   * @param {function} options.parameters.rePort - Function to report.\n   *\n   * @returns {Promise<void>} A promise that resolves when the operation is complete.\n   */\n\n  closeAndResize = async ({\n    producerId,\n    kind,\n    parameters,\n  }: CloseAndResizeOptions): Promise<void> => {\n    let { getUpdatedAllParams } = parameters;\n    parameters = getUpdatedAllParams();\n\n    let {\n      allAudioStreams,\n      allVideoStreams,\n      activeNames,\n      participants,\n      streamNames,\n      recordingDisplayType,\n      recordingVideoOptimized,\n      adminIDStream,\n      newLimitedStreams,\n      newLimitedStreamsIDs,\n      oldAllStreams,\n      shareScreenStarted,\n      shared,\n      meetingDisplayType,\n      defer_receive,\n      lock_screen,\n      firstAll,\n      first_round,\n      gotAllVids,\n      eventType,\n\n      hostLabel,\n      shareEnded,\n      updateMainWindow,\n      updateActiveNames,\n      updateAllAudioStreams,\n      updateAllVideoStreams,\n\n      updateShareScreenStarted,\n      updateUpdateMainWindow,\n      updateNewLimitedStreams,\n      updateOldAllStreams,\n      updateDefer_receive,\n      updateMainHeightWidth,\n      updateShareEnded,\n      updateLock_screen,\n      updateFirstAll,\n      updateFirst_round,\n\n      //mediasfu functions\n      reorderStreams,\n      prepopulateUserMedia,\n      getVideos,\n      rePort,\n    } = parameters;\n\n    //function to close and resize the video and audio elements\n\n    let participant: Participant | undefined;\n\n    if (kind === 'audio') {\n      //stop the audio by removing the miniAudio with id = producerId\n\n      //remove the audio from the allAudioStreams array\n      allAudioStreams = allAudioStreams.filter(function (audioStream) {\n        return audioStream.producerId !== producerId;\n      });\n\n      updateAllAudioStreams(allAudioStreams);\n\n      if (recordingDisplayType == 'video' && recordingVideoOptimized == true) {\n        // do nothing\n      } else {\n        //get the name of the participant with the producerId\n        participant = participants.find((obj) => obj.audioID === producerId);\n\n        if (participant) {\n          //check if the participants videoID is not null or \"\"\n          if (participant.videoID !== null && participant.videoID !== '') {\n            // do nothing\n          } else {\n            //remove the participant from the activeNames array\n            activeNames = activeNames.filter(function (name) {\n              return name !== participant?.name;\n            });\n            updateActiveNames(activeNames);\n          }\n        }\n      }\n\n      let checker = false;\n      let alt_checker = false;\n\n      if (meetingDisplayType == 'video' && participant) {\n        checker =\n          participant[0].videoID != null &&\n          participant[0].videoID != '' &&\n          participant[0].videoID != undefined;\n      } else {\n        checker = true;\n        alt_checker = true;\n      }\n\n      if (checker) {\n        if (shareScreenStarted || shared) {\n          if (!alt_checker) {\n            await reorderStreams({ parameters });\n          }\n        } else {\n          if (alt_checker && meetingDisplayType != 'video') {\n            await reorderStreams({ add: false, screenChanged: true, parameters });\n          }\n        }\n      }\n    } else if (kind === 'video') {\n      //update the video elements by removing the miniVideo with id = producerId\n      //remove the video from the allVideoStreams array\n\n      //check if producerId == adminidstream\n      if (producerId == adminIDStream) {\n        updateMainWindow = true;\n        updateUpdateMainWindow(updateMainWindow);\n      }\n\n      try {\n        allVideoStreams = allVideoStreams.filter(function (videoStream) {\n          return videoStream.producerId !== producerId;\n        });\n\n        updateAllVideoStreams(allVideoStreams);\n\n        try {\n          //try remove it from oldVideoStreams\n          oldAllStreams = oldAllStreams.filter(function (videoStream) {\n            return videoStream.producerId !== producerId;\n          });\n\n          updateOldAllStreams(oldAllStreams);\n        } catch {\n          /* handle error */\n        }\n\n        try {\n          //try remove it from newLimitedStreams\n          newLimitedStreams = newLimitedStreams.filter(function (videoStream) {\n            return videoStream.producerId !== producerId;\n          });\n\n          updateNewLimitedStreams(newLimitedStreams);\n        } catch {\n          /* handle error */\n        }\n      } catch (error) {\n        try {\n          //try remove it from oldVideoStreams\n          oldAllStreams = oldAllStreams.filter(function (videoStream) {\n            return videoStream.producerId !== producerId;\n          });\n          updateOldAllStreams(oldAllStreams);\n        } catch {\n          /* handle error */\n        }\n      }\n\n      try {\n        //remove the participant from activeNames\n        activeNames = activeNames.filter(function (name) {\n          //get the participant with the producerId\n          let participant = streamNames.find((obj) => obj.producerId === producerId);\n\n          return name !== (participant?.name ?? '');\n        });\n\n        updateActiveNames(activeNames);\n      } catch {\n        /* handle error */\n      }\n\n      if (lock_screen) {\n        defer_receive = true;\n        // check if the video is the one being displayed (i.e. (newLimitedStreamsIDs))\n        if (newLimitedStreamsIDs.includes(producerId)) {\n          await prepopulateUserMedia({ name: hostLabel, parameters });\n          await reorderStreams({ add: false, screenChanged: true, parameters });\n        }\n      } else {\n        await prepopulateUserMedia({ name: hostLabel, parameters });\n        await reorderStreams({ add: false, screenChanged: true, parameters });\n      }\n    } else if (kind === 'screenshare' || kind === 'screen') {\n      //update the video elements by removing the mainVideo with id = producerId\n      updateMainWindow = true;\n\n      //screenshare stuff\n      shareScreenStarted = false;\n      shareEnded = true;\n\n      lock_screen = false;\n      firstAll = false;\n      first_round = false;\n\n      updateUpdateMainWindow(updateMainWindow);\n      updateShareScreenStarted(shareScreenStarted);\n      updateShareEnded(shareEnded);\n      updateLock_screen(lock_screen);\n      updateFirstAll(firstAll);\n      updateFirst_round(first_round);\n\n      if (!gotAllVids || defer_receive) {\n        defer_receive = false;\n        updateDefer_receive(defer_receive);\n        await getVideos({\n          participants,\n          allVideoStreams,\n          oldAllStreams,\n          updateAllVideoStreams,\n          updateOldAllStreams,\n        });\n        await rePort({ parameters });\n      }\n\n      if (eventType == 'conference') {\n        updateMainHeightWidth(0);\n      }\n\n      await prepopulateUserMedia({ name: hostLabel, parameters });\n      await reorderStreams({ add: false, screenChanged: true, parameters });\n    }\n  };\n}\n"]}