mediasfu-angular 1.0.0

package/dist/esm2022/lib/consumers/get-estimate.service.mjs

@@ -0,0 +1,70 @@
+// estimate.service.ts
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class GetEstimate {
+    /**
+     * Estimates the number of rows and columns for a given set of parameters.
+     *
+     * @param {GetEstimateOptions} options - The options for the estimation.
+     * @param {number} options.n - The number of items to estimate for.
+     * @param {Object} options.parameters - The parameters for the estimation.
+     * @param {number} options.parameters.fixedPageLimit - The fixed page limit.
+     * @param {number} options.parameters.screenPageLimit - The screen page limit.
+     * @param {boolean} options.parameters.shareScreenStarted - Indicates if screen sharing has started.
+     * @param {boolean} options.parameters.shared - Indicates if sharing is active.
+     * @param {string} options.parameters.eventType - The type of event (e.g., "chat", "conference").
+     * @param {boolean} options.parameters.removeAltGrid - Indicates if the alternate grid should be removed.
+     * @param {boolean} options.parameters.isWideScreen - Indicates if the screen is wide.
+     * @param {boolean} options.parameters.isMediumScreen - Indicates if the screen is medium-sized.
+     * @param {Function} options.parameters.updateRemoveAltGrid - Function to update the removeAltGrid parameter.
+     * @param {Function} options.parameters.calculateRowsAndColumns - Function to calculate rows and columns.
+     *
+     * @returns {number[]} An array containing the estimated number of items, rows, and columns.
+     *
+     * @throws Will log an error message if an error occurs during estimation.
+     */
+    getEstimate({ n, parameters }) {
+        try {
+            // Destructure parameters
+            let { fixedPageLimit, screenPageLimit, shareScreenStarted, shared, eventType, removeAltGrid, isWideScreen, isMediumScreen, updateRemoveAltGrid, 
+            // mediaSfu functions
+            calculateRowsAndColumns, } = parameters;
+            // Calculate rows and columns
+            const [rows, cols] = calculateRowsAndColumns({ n });
+            // Check conditions for removing alt grid
+            if (n < fixedPageLimit || ((shareScreenStarted || shared) && n < screenPageLimit + 1)) {
+                removeAltGrid = true;
+                updateRemoveAltGrid(removeAltGrid);
+                // Return estimated values based on screen width
+                if (!(isMediumScreen || isWideScreen)) {
+                    return eventType === 'chat' ||
+                        (eventType === 'conference' && !(shareScreenStarted || shared))
+                        ? [n, n, 1]
+                        : [n, 1, n];
+                }
+                else {
+                    return eventType === 'chat' ||
+                        (eventType === 'conference' && !(shareScreenStarted || shared))
+                        ? [n, 1, n]
+                        : [n, n, 1];
+                }
+            }
+            return [rows * cols, rows, cols];
+        }
+        catch (error) {
+            // Handle errors during estimation
+            console.log('Error estimating rows and columns:', error.message);
+            // throw error;
+            return [0, 0, 0];
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: GetEstimate, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: GetEstimate, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: GetEstimate, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/consumers/get-piped-producers-alt.service.mjs

@@ -0,0 +1,49 @@
+// piped-producers.service.ts
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class GetPipedProducersAlt {
+    /**
+     * Retrieves piped producers and signals new consumer transport for each retrieved producer.
+     *
+     * @param {Object} options - The options for retrieving piped producers.
+     * @param {WebSocket} options.nsock - The WebSocket instance used for communication.
+     * @param {boolean} options.islevel - A flag indicating the level of the request.
+     * @param {Object} options.parameters - Additional parameters for the request.
+     * @param {string} options.parameters.member - The member identifier.
+     * @param {Function} options.parameters.signalNewConsumerTransport - A function to signal new consumer transport.
+     *
+     * @returns {Promise<void>} A promise that resolves when the operation is complete.
+     *
+     * @throws {Error} If an error occurs during the process of retrieving producers.
+     */
+    async getPipedProducersAlt({ nsock, islevel, parameters, }) {
+        try {
+            // Destructure parameters
+            const { member, signalNewConsumerTransport } = parameters;
+            // Emit request to get piped producers using WebSocket
+            nsock.emit('getProducersPipedAlt', { islevel, member }, async (producerIds) => {
+                // Check if producers are retrieved
+                if (producerIds.length > 0) {
+                    // Signal new consumer transport for each retrieved producer
+                    for (const id of producerIds) {
+                        await signalNewConsumerTransport({ nsock, remoteProducerId: id, islevel, parameters });
+                    }
+                }
+            });
+        }
+        catch (error) {
+            // Handle errors during the process of retrieving producers
+            console.log('Error getting piped producers:', error.message);
+            // throw error;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: GetPipedProducersAlt, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: GetPipedProducersAlt, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: GetPipedProducersAlt, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/consumers/get-producers-piped.service.mjs

@@ -0,0 +1,46 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class GetProducersPiped {
+    /**
+     * Retrieves piped producers and signals new consumer transport for each retrieved producer.
+     *
+     * @param {Object} options - The options for getting piped producers.
+     * @param {WebSocket} options.nsock - The WebSocket instance used for communication.
+     * @param {boolean} options.islevel - A flag indicating the level of the operation.
+     * @param {Object} options.parameters - Additional parameters for the operation.
+     * @param {string} options.parameters.member - The member identifier.
+     * @param {Function} options.parameters.signalNewConsumerTransport - The function to signal new consumer transport.
+     *
+     * @returns {Promise<void>} A promise that resolves when the operation is complete.
+     *
+     * @throws {Error} If an error occurs during the process of retrieving producers.
+     */
+    async getProducersPiped({ nsock, islevel, parameters }) {
+        try {
+            // Destructure parameters
+            const { member, signalNewConsumerTransport } = parameters;
+            // Emit request to get piped producers using WebSocket
+            nsock.emit('getProducersPipedAlt', { islevel, member }, async (producerIds) => {
+                // Check if producers are retrieved
+                if (producerIds.length > 0) {
+                    // Signal new consumer transport for each retrieved producer
+                    await Promise.all(producerIds.map((id) => signalNewConsumerTransport({ remoteProducerId: id, islevel, nsock, parameters })));
+                }
+            });
+        }
+        catch (error) {
+            // Handle errors during the process of retrieving producers
+            console.log('Error getting piped producers:', error.message);
+            // throw error;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: GetProducersPiped, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: GetProducersPiped, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: GetProducersPiped, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/consumers/get-videos.service.mjs

@@ -0,0 +1,58 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class GetVideos {
+    /**
+     * Asynchronously processes and updates video streams by filtering out the admin's video stream.
+     *
+     * @param {GetVideosOptions} options - The options for getting videos.
+     * @param {Participant[]} options.participants - The list of participants.
+     * @param {Stream[]} options.allVideoStreams - The list of all video streams.
+     * @param {(Stream | Participant)[]} options.oldAllStreams - The list of old video streams.
+     * @param {string} options.adminVidID - The ID of the admin's video stream.
+     * @param {Function} options.updateAllVideoStreams - Function to update the state variable for all video streams.
+     * @param {Function} options.updateOldAllStreams - Function to update the state variable for old video streams.
+     * @returns {Promise<void>} A promise that resolves when the video streams have been processed and updated.
+     */
+    async getVideos({ participants, allVideoStreams, oldAllStreams, adminVidID, updateAllVideoStreams, updateOldAllStreams, }) {
+        try {
+            // Filter out the admin's video stream and update state variables
+            let admin = participants.filter((participant) => participant.islevel === '2');
+            if (admin.length > 0) {
+                adminVidID = admin[0].videoID;
+                if (adminVidID != null && adminVidID !== '') {
+                    let oldAllStreams_ = [];
+                    // Check if the length of oldAllStreams is greater than 0
+                    if (oldAllStreams.length > 0) {
+                        oldAllStreams_ = oldAllStreams;
+                    }
+                    // Filter out admin's video stream from oldAllStreams
+                    oldAllStreams = allVideoStreams.filter((streame) => streame.producerId === adminVidID);
+                    // If no admin's video stream found, revert to the previous state
+                    if (oldAllStreams.length < 1) {
+                        oldAllStreams = oldAllStreams_;
+                    }
+                    // Update the state variable for old video streams
+                    updateOldAllStreams(oldAllStreams);
+                    // Filter out admin's video stream from allVideoStreams
+                    allVideoStreams = allVideoStreams.filter((streame) => streame.producerId !== adminVidID);
+                    // Update the state variable for all video streams
+                    updateAllVideoStreams(allVideoStreams);
+                }
+            }
+        }
+        catch (error) {
+            // Handle errors during the process of updating video streams
+            console.log('Error updating video streams:', error.message);
+            // throw error;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: GetVideos, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: GetVideos, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: GetVideos, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/consumers/mix-streams.service.mjs

@@ -0,0 +1,73 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class MixStreams {
+    /**
+     * Mixes video and audio streams and participants based on specified parameters.
+     *
+     * @param {Object} options - The options for mixing streams.
+     * @param {Array} options.alVideoStreams - The list of audio and video streams to mix.
+     * @param {Array} options.non_alVideoStreams - The list of non-audio and video streams to mix.
+     * @param {Array} options.ref_participants - The list of reference participants to mix.
+     * @returns {Promise<Array>} A promise that resolves with the mixed streams.
+     * @throws Will throw an error if there is an issue mixing the streams.
+     * @example
+     * ```typescript
+     * mixStreams({
+     *   alVideoStreams: [stream1, stream2],
+     *  non_alVideoStreams: [participant1, participant2],
+     * ref_participants: [participant1, participant2]
+     * });
+     *
+     * ```
+     */
+    async mixStreams({ alVideoStreams, non_alVideoStreams, ref_participants, }) {
+        try {
+            const mixedStreams = [];
+            const youyouStream = alVideoStreams.find((obj) => obj.producerId === 'youyou' || obj.producerId === 'youyouyou');
+            alVideoStreams = alVideoStreams.filter((obj) => obj.producerId !== 'youyou' && obj.producerId !== 'youyouyou');
+            const unmutedAlVideoStreams = alVideoStreams.filter((obj) => {
+                const participant = ref_participants.find((p) => p.videoID === obj.producerId);
+                return !obj.muted && participant && participant.muted === false;
+            });
+            const mutedAlVideoStreams = alVideoStreams.filter((obj) => {
+                const participant = ref_participants.find((p) => p.videoID === obj.producerId);
+                return obj.muted || (participant && participant.muted === true);
+            });
+            const nonAlVideoStreams = non_alVideoStreams.slice(); // Create a copy of non_alVideoStreams
+            // Add unmutedAlVideoStreams to mixedStreams
+            mixedStreams.push(...unmutedAlVideoStreams);
+            // Interleave the mutedAlVideoStreams and nonAlVideoStreams
+            let nonAlIndex = 0;
+            for (let i = 0; i < mutedAlVideoStreams.length; i++) {
+                if (nonAlIndex < nonAlVideoStreams.length) {
+                    mixedStreams.push(nonAlVideoStreams[nonAlIndex]);
+                    nonAlIndex++;
+                }
+                mixedStreams.push(mutedAlVideoStreams[i]);
+            }
+            // Handle remaining nonAlVideoStreams (if any)
+            for (let i = nonAlIndex; i < nonAlVideoStreams.length; i++) {
+                mixedStreams.push(nonAlVideoStreams[i]);
+            }
+            // Unshift 'youyou' or 'youyouyou' stream to mixedStreams
+            if (youyouStream) {
+                mixedStreams.unshift(youyouStream);
+            }
+            return mixedStreams;
+        }
+        catch (error) {
+            // Handle errors during the process of mixing streams
+            console.log('Error mixing streams:', error.message);
+            throw error;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: MixStreams, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: MixStreams, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: MixStreams, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/consumers/on-screen-changes.service.mjs

@@ -0,0 +1,63 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class OnScreenChanges {
+    /**
+     * Handles changes in screen events such as broadcast, chat, and conference.
+     *
+     * @param {OnScreenChangesOptions} options - The options for handling screen changes.
+     * @param {boolean} options.changed - Indicates if the screen has changed.
+     * @param {object} options.parameters - The parameters for handling screen changes.
+     * @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 the screen is shared.
+     * @param {boolean} options.parameters.addForBasic - Flag to add basic controls.
+     * @param {function} options.parameters.updateMainHeightWidth - Function to update the main height and width.
+     * @param {function} options.parameters.updateAddForBasic - Function to update the addForBasic flag.
+     * @param {number} options.parameters.itemPageLimit - The limit for item pages.
+     * @param {function} options.parameters.updateItemPageLimit - Function to update the item page limit.
+     * @param {function} options.parameters.reorderStreams - Function to reorder streams.
+     *
+     * @returns {Promise<void>} A promise that resolves when the screen changes have been handled.
+     *
+     * @throws {Error} Throws an error if there is an issue handling screen changes.
+     */
+    onScreenChanges = async ({ changed = false, parameters, }) => {
+        try {
+            // Destructure parameters
+            let { eventType, shareScreenStarted, shared, addForBasic, updateMainHeightWidth, updateAddForBasic, itemPageLimit, updateItemPageLimit, 
+            // mediasfu functions
+            reorderStreams, } = parameters;
+            // Remove element with id 'controlButtons'
+            addForBasic = false;
+            updateAddForBasic(addForBasic);
+            if (eventType == 'broadcast' || eventType == 'chat') {
+                addForBasic = true;
+                updateAddForBasic(addForBasic);
+                itemPageLimit = eventType == 'broadcast' ? 1 : 2;
+                updateItemPageLimit(itemPageLimit);
+                updateMainHeightWidth(eventType == 'broadcast' ? 100 : 0);
+            }
+            else {
+                if (eventType == 'conference' && !(shareScreenStarted || shared)) {
+                    updateMainHeightWidth(0);
+                }
+            }
+            // Update the mini cards grid
+            await reorderStreams({ add: false, screenChanged: changed, parameters });
+        }
+        catch (error) {
+            // Handle errors during the process of handling screen changes
+            console.log('Error handling screen changes:', error.message);
+            // throw error;
+        }
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: OnScreenChanges, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: OnScreenChanges, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: OnScreenChanges, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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