mediasfu-angular 1.0.0

package/dist/esm2022/lib/methods/requests-methods/respond-to-requests.service.mjs

@@ -0,0 +1,45 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class RespondToRequests {
+    /**
+     * Responds to incoming requests by updating the request list and emitting a response to the server.
+     *
+     * @param {Object} options - The options for responding to requests.
+     * @param {Socket} options.socket - The socket instance used to emit the response.
+     * @param {Request} options.request - The request object containing details of the request.
+     * @param {Function} options.updateRequestList - The function to update the request list.
+     * @param {Request[]} options.requestList - The current list of requests.
+     * @param {string} options.action - The action to be taken on the request.
+     * @param {string} options.roomName - The name of the room to which the response should be emitted.
+     *
+     * @returns {Promise<void>} A promise that resolves when the response has been emitted.
+     */
+    async respondToRequests({ socket, request, updateRequestList, requestList, action, roomName, }) {
+        // Filter out the request that is being responded to
+        let newRequestList = requestList.filter((request_) => {
+            return !(request_.id === request.id &&
+                request_.icon === request.icon &&
+                request_.name === request.name);
+        });
+        // Update the request list
+        updateRequestList(newRequestList);
+        // Prepare the request response object
+        let requestResponse = {
+            id: request.id,
+            name: request.name,
+            type: request.icon,
+            action: action,
+        };
+        // Emit the response via the socket
+        socket.emit('updateUserofRequestStatus', { requestResponse, roomName });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: RespondToRequests, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: RespondToRequests, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: RespondToRequests, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/methods/settings-methods/launch-settings.service.mjs

@@ -0,0 +1,26 @@
+// settings.service.ts
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class LaunchSettings {
+    /**
+     * Toggles the visibility state of the settings modal.
+     *
+     * @param {LaunchSettingsOptions} options - The options for launching settings.
+     * @param {Function} options.updateIsSettingsModalVisible - Function to update the visibility state of the settings modal.
+     * @param {boolean} options.isSettingsModalVisible - Current visibility state of the settings modal.
+     * @returns {void}
+     */
+    launchSettings({ updateIsSettingsModalVisible, isSettingsModalVisible, }) {
+        // Toggle the visibility of the display settings modal.
+        updateIsSettingsModalVisible(!isSettingsModalVisible);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: LaunchSettings, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: LaunchSettings, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: LaunchSettings, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/methods/settings-methods/modify-settings.service.mjs

@@ -0,0 +1,67 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ModifySettings {
+    /**
+     * Modifies the settings for a given room and updates the state accordingly.
+     *
+     * @param {Object} options - The options for modifying settings.
+     * @param {Function} options.showAlert - Function to show alert messages.
+     * @param {string} options.roomName - The name of the room.
+     * @param {string} options.audioSet - The audio setting to be applied.
+     * @param {string} options.videoSet - The video setting to be applied.
+     * @param {string} options.screenshareSet - The screenshare setting to be applied.
+     * @param {string} options.chatSet - The chat setting to be applied.
+     * @param {Object} options.socket - The socket instance for emitting events.
+     * @param {Function} options.updateAudioSetting - Function to update the audio setting state.
+     * @param {Function} options.updateVideoSetting - Function to update the video setting state.
+     * @param {Function} options.updateScreenshareSetting - Function to update the screenshare setting state.
+     * @param {Function} options.updateChatSetting - Function to update the chat setting state.
+     * @param {Function} options.updateIsSettingsModalVisible - Function to update the visibility of the settings modal.
+     *
+     * @returns {Promise<void>} A promise that resolves when the settings have been modified.
+     *
+     * @throws Will show an alert if any setting is set to "approval" in demo mode (room name starts with "d").
+     */
+    modifySettings = async ({ showAlert, roomName, audioSet, videoSet, screenshareSet, chatSet, socket, updateAudioSetting, updateVideoSetting, updateScreenshareSetting, updateChatSetting, updateIsSettingsModalVisible, }) => {
+        if (roomName.toLowerCase().startsWith('d')) {
+            // none should be approval
+            if (audioSet === 'approval' ||
+                videoSet === 'approval' ||
+                screenshareSet === 'approval' ||
+                chatSet === 'approval') {
+                showAlert?.({
+                    message: 'You cannot set approval for demo mode.',
+                    type: 'danger',
+                    duration: 3000,
+                });
+                return;
+            }
+        }
+        // Check and update state variables based on the provided logic
+        if (audioSet) {
+            updateAudioSetting(audioSet);
+        }
+        if (videoSet) {
+            updateVideoSetting(videoSet);
+        }
+        if (screenshareSet) {
+            updateScreenshareSetting(screenshareSet);
+        }
+        if (chatSet) {
+            updateChatSetting(chatSet);
+        }
+        const settings = [audioSet, videoSet, screenshareSet, chatSet];
+        socket.emit('updateSettingsForRequests', { settings, roomName });
+        // Close modal
+        updateIsSettingsModalVisible(false);
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ModifySettings, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ModifySettings, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ModifySettings, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/methods/stream-methods/click-audio.service.mjs

@@ -0,0 +1,178 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ClickAudio {
+    /**
+     * Handles the click event for toggling audio in a media session.
+     *
+     * @param {ClickAudioOptions} parameters - The parameters required for handling the audio click event.
+     * @returns {Promise<void>} A promise that resolves when the audio click event has been handled.
+     *
+     * The function performs the following actions:
+     * - If the event is audio-only, it shows an alert and exits.
+     * - If the audio is already on, it handles the logic for turning it off, including checking recording states and permissions.
+     * - If the audio is off, it checks for admin restrictions, user permissions, and handles the logic for turning the audio on.
+     * - It updates various states and emits socket events as necessary.
+     *
+     * The function makes use of several helper functions and state update functions passed in through the parameters.
+     */
+    async clickAudio({ parameters }) {
+        let { checkMediaPermission, hasAudioPermission, audioPaused, audioAlreadyOn, audioOnlyRoom, recordStarted, recordResumed, recordPaused, recordStopped, recordingMediaOptions, islevel, youAreCoHost, adminRestrictSetting, audioRequestState, audioRequestTime, member, socket, roomName, userDefaultAudioInputDevice, micAction, localStream, audioSetting, videoSetting, screenshareSetting, chatSetting, updateRequestIntervalSeconds, participants, showAlert, transportCreated, transportCreatedAudio, updateAudioAlreadyOn, updateAudioRequestState, updateAudioPaused, updateLocalStream, updateParticipants, updateTransportCreated, updateTransportCreatedAudio, updateMicAction, checkPermission, streamSuccessAudio, requestPermissionAudio, resumeSendTransportAudio, disconnectSendTransportAudio, } = parameters;
+        if (audioOnlyRoom) {
+            showAlert?.({
+                message: 'You cannot turn on your camera in an audio-only event.',
+                type: 'danger',
+                duration: 3000,
+            });
+            return;
+        }
+        if (audioAlreadyOn) {
+            if (islevel === '2' && (recordStarted || recordResumed)) {
+                if (!(recordPaused || recordStopped)) {
+                    if (recordingMediaOptions === 'audio') {
+                        showAlert?.({
+                            message: 'You cannot turn off your audio while recording, please pause or stop recording first.',
+                            type: 'danger',
+                            duration: 3000,
+                        });
+                        return;
+                    }
+                }
+            }
+            audioAlreadyOn = false;
+            updateAudioAlreadyOn(audioAlreadyOn);
+            if (localStream) {
+                localStream.getAudioTracks()[0].enabled = false;
+            }
+            updateLocalStream(localStream);
+            await disconnectSendTransportAudio({ parameters }); //disconnect function here actuall calls audioProducer.pause() instead of close() as in mediasfu
+            audioPaused = true;
+            updateAudioPaused(audioPaused);
+        }
+        else {
+            if (adminRestrictSetting) {
+                showAlert?.({
+                    message: 'You cannot turn on your microphone. Access denied by host.',
+                    type: 'danger',
+                    duration: 3000,
+                });
+                return;
+            }
+            let response = 2;
+            if (!micAction && islevel !== '2' && !youAreCoHost) {
+                response = await checkPermission({
+                    permissionType: 'audioSetting',
+                    audioSetting,
+                    videoSetting,
+                    screenshareSetting,
+                    chatSetting,
+                });
+            }
+            else {
+                response = 0;
+            }
+            switch (response) {
+                case 1: {
+                    if (audioRequestState === 'pending') {
+                        showAlert?.({
+                            message: 'A request is pending. Please wait for the host to respond.',
+                            type: 'danger',
+                            duration: 3000,
+                        });
+                        return;
+                    }
+                    showAlert?.({
+                        message: 'Request sent to host.',
+                        type: 'success',
+                        duration: 3000,
+                    });
+                    audioRequestState = 'pending';
+                    updateAudioRequestState(audioRequestState);
+                    //create a request and add to the request list and send to host
+                    const userRequest = {
+                        id: socket.id,
+                        name: member,
+                        icon: 'fa-microphone',
+                    };
+                    socket.emit('participantRequest', { userRequest, roomName });
+                    break;
+                }
+                case 2:
+                    if (audioRequestState === 'rejected' &&
+                        Date.now() - audioRequestTime < updateRequestIntervalSeconds * 1000) {
+                        showAlert?.({
+                            message: `A request was rejected. Please wait for ${updateRequestIntervalSeconds} seconds before sending another request.`,
+                            type: 'danger',
+                            duration: 3000,
+                        });
+                        return;
+                    }
+                    break;
+                case 0:
+                    //allow
+                    if (audioPaused) {
+                        if (localStream) {
+                            localStream.getAudioTracks()[0].enabled = true;
+                        }
+                        updateAudioAlreadyOn(true);
+                        await resumeSendTransportAudio({ parameters });
+                        socket.emit('resumeProducerAudio', { mediaTag: 'audio', roomName });
+                        updateLocalStream(localStream);
+                        updateAudioAlreadyOn(audioAlreadyOn);
+                        if (micAction == true) {
+                            micAction = false;
+                            updateMicAction(micAction);
+                        }
+                        participants.forEach((participant) => {
+                            if (participant['socketId'] === socket.id && participant.name === member) {
+                                participant.muted = false;
+                            }
+                        });
+                        updateParticipants(participants);
+                        transportCreated = true;
+                        updateTransportCreated(transportCreated);
+                        transportCreatedAudio = true;
+                        updateTransportCreatedAudio(transportCreatedAudio);
+                    }
+                    else {
+                        if (!hasAudioPermission && checkMediaPermission) {
+                            const statusMic = await requestPermissionAudio();
+                            if (statusMic !== 'granted') {
+                                showAlert?.({
+                                    message: 'Allow access to your microphone or check if your microphone is not being used by another application.',
+                                    type: 'danger',
+                                    duration: 3000,
+                                });
+                                return;
+                            }
+                        }
+                        const mediaConstraints = userDefaultAudioInputDevice
+                            ? { audio: { deviceId: userDefaultAudioInputDevice }, video: false }
+                            : { audio: true, video: false };
+                        try {
+                            const stream = await navigator.mediaDevices.getUserMedia(mediaConstraints);
+                            await streamSuccessAudio({ stream, parameters });
+                        }
+                        catch (error) {
+                            console.error(error);
+                            showAlert?.({
+                                message: 'Allow access to your microphone or check if your microphone is not being used by another application.',
+                                type: 'danger',
+                                duration: 3000,
+                            });
+                        }
+                    }
+                    break;
+                default:
+            }
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ClickAudio, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ClickAudio, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ClickAudio, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"click-audio.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/methods/stream-methods/click-audio.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAiF3C,MAAM,OAAO,UAAU;IACrB;;;;;;;;;;;;;OAaG;IAEH,KAAK,CAAC,UAAU,CAAC,EAAE,UAAU,EAAqB;QAChD,IAAI,EACF,oBAAoB,EACpB,kBAAkB,EAClB,WAAW,EACX,cAAc,EACd,aAAa,EACb,aAAa,EACb,aAAa,EACb,YAAY,EACZ,aAAa,EACb,qBAAqB,EACrB,OAAO,EACP,YAAY,EACZ,oBAAoB,EACpB,iBAAiB,EACjB,gBAAgB,EAChB,MAAM,EACN,MAAM,EACN,QAAQ,EACR,2BAA2B,EAC3B,SAAS,EACT,WAAW,EACX,YAAY,EACZ,YAAY,EACZ,kBAAkB,EAClB,WAAW,EACX,4BAA4B,EAC5B,YAAY,EACZ,SAAS,EACT,gBAAgB,EAChB,qBAAqB,EAErB,oBAAoB,EACpB,uBAAuB,EACvB,iBAAiB,EACjB,iBAAiB,EACjB,kBAAkB,EAClB,sBAAsB,EACtB,2BAA2B,EAC3B,eAAe,EAEf,eAAe,EACf,kBAAkB,EAClB,sBAAsB,EACtB,wBAAwB,EACxB,4BAA4B,GAC7B,GAAG,UAAU,CAAC;QAEf,IAAI,aAAa,EAAE,CAAC;YAClB,SAAS,EAAE,CAAC;gBACV,OAAO,EAAE,wDAAwD;gBACjE,IAAI,EAAE,QAAQ;gBACd,QAAQ,EAAE,IAAI;aACf,CAAC,CAAC;YACH,OAAO;QACT,CAAC;QAED,IAAI,cAAc,EAAE,CAAC;YACnB,IAAI,OAAO,KAAK,GAAG,IAAI,CAAC,aAAa,IAAI,aAAa,CAAC,EAAE,CAAC;gBACxD,IAAI,CAAC,CAAC,YAAY,IAAI,aAAa,CAAC,EAAE,CAAC;oBACrC,IAAI,qBAAqB,KAAK,OAAO,EAAE,CAAC;wBACtC,SAAS,EAAE,CAAC;4BACV,OAAO,EACL,uFAAuF;4BACzF,IAAI,EAAE,QAAQ;4BACd,QAAQ,EAAE,IAAI;yBACf,CAAC,CAAC;wBACH,OAAO;oBACT,CAAC;gBACH,CAAC;YACH,CAAC;YAED,cAAc,GAAG,KAAK,CAAC;YACvB,oBAAoB,CAAC,cAAc,CAAC,CAAC;YACrC,IAAI,WAAW,EAAE,CAAC;gBAChB,WAAW,CAAC,cAAc,EAAE,CAAC,CAAC,CAAC,CAAC,OAAO,GAAG,KAAK,CAAC;YAClD,CAAC;YACD,iBAAiB,CAAC,WAAW,CAAC,CAAC;YAC/B,MAAM,4BAA4B,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC,CAAC,gGAAgG;YACpJ,WAAW,GAAG,IAAI,CAAC;YACnB,iBAAiB,CAAC,WAAW,CAAC,CAAC;QACjC,CAAC;aAAM,CAAC;YACN,IAAI,oBAAoB,EAAE,CAAC;gBACzB,SAAS,EAAE,CAAC;oBACV,OAAO,EAAE,4DAA4D;oBACrE,IAAI,EAAE,QAAQ;oBACd,QAAQ,EAAE,IAAI;iBACf,CAAC,CAAC;gBACH,OAAO;YACT,CAAC;YAED,IAAI,QAAQ,GAAG,CAAC,CAAC;YACjB,IAAI,CAAC,SAAS,IAAI,OAAO,KAAK,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;gBACnD,QAAQ,GAAG,MAAM,eAAe,CAAC;oBAC/B,cAAc,EAAE,cAAc;oBAC9B,YAAY;oBACZ,YAAY;oBACZ,kBAAkB;oBAClB,WAAW;iBACZ,CAAC,CAAC;YACL,CAAC;iBAAM,CAAC;gBACN,QAAQ,GAAG,CAAC,CAAC;YACf,CAAC;YAED,QAAQ,QAAQ,EAAE,CAAC;gBACjB,KAAK,CAAC,CAAC,CAAC,CAAC;oBACP,IAAI,iBAAiB,KAAK,SAAS,EAAE,CAAC;wBACpC,SAAS,EAAE,CAAC;4BACV,OAAO,EAAE,4DAA4D;4BACrE,IAAI,EAAE,QAAQ;4BACd,QAAQ,EAAE,IAAI;yBACf,CAAC,CAAC;wBACH,OAAO;oBACT,CAAC;oBAED,SAAS,EAAE,CAAC;wBACV,OAAO,EAAE,uBAAuB;wBAChC,IAAI,EAAE,SAAS;wBACf,QAAQ,EAAE,IAAI;qBACf,CAAC,CAAC;oBAEH,iBAAiB,GAAG,SAAS,CAAC;oBAC9B,uBAAuB,CAAC,iBAAiB,CAAC,CAAC;oBAC3C,+DAA+D;oBAE/D,MAAM,WAAW,GAAG;wBAClB,EAAE,EAAE,MAAM,CAAC,EAAE;wBACb,IAAI,EAAE,MAAM;wBACZ,IAAI,EAAE,eAAe;qBACtB,CAAC;oBACF,MAAM,CAAC,IAAI,CAAC,oBAAoB,EAAE,EAAE,WAAW,EAAE,QAAQ,EAAE,CAAC,CAAC;oBAC7D,MAAM;gBACR,CAAC;gBAED,KAAK,CAAC;oBACJ,IACE,iBAAiB,KAAK,UAAU;wBAChC,IAAI,CAAC,GAAG,EAAE,GAAG,gBAAgB,GAAG,4BAA4B,GAAG,IAAI,EACnE,CAAC;wBACD,SAAS,EAAE,CAAC;4BACV,OAAO,EAAE,2CAA2C,4BAA4B,0CAA0C;4BAC1H,IAAI,EAAE,QAAQ;4BACd,QAAQ,EAAE,IAAI;yBACf,CAAC,CAAC;wBACH,OAAO;oBACT,CAAC;oBACD,MAAM;gBAER,KAAK,CAAC;oBACJ,OAAO;oBAEP,IAAI,WAAW,EAAE,CAAC;wBAChB,IAAI,WAAW,EAAE,CAAC;4BAChB,WAAW,CAAC,cAAc,EAAE,CAAC,CAAC,CAAC,CAAC,OAAO,GAAG,IAAI,CAAC;wBACjD,CAAC;wBACD,oBAAoB,CAAC,IAAI,CAAC,CAAC;wBAC3B,MAAM,wBAAwB,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC;wBAC/C,MAAM,CAAC,IAAI,CAAC,qBAAqB,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,CAAC;wBAEpE,iBAAiB,CAAC,WAAW,CAAC,CAAC;wBAC/B,oBAAoB,CAAC,cAAc,CAAC,CAAC;wBAErC,IAAI,SAAS,IAAI,IAAI,EAAE,CAAC;4BACtB,SAAS,GAAG,KAAK,CAAC;4BAClB,eAAe,CAAC,SAAS,CAAC,CAAC;wBAC7B,CAAC;wBAED,YAAY,CAAC,OAAO,CAAC,CAAC,WAAW,EAAE,EAAE;4BACnC,IAAI,WAAW,CAAC,UAAU,CAAC,KAAK,MAAM,CAAC,EAAE,IAAI,WAAW,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;gCACzE,WAAW,CAAC,KAAK,GAAG,KAAK,CAAC;4BAC5B,CAAC;wBACH,CAAC,CAAC,CAAC;wBACH,kBAAkB,CAAC,YAAY,CAAC,CAAC;wBAEjC,gBAAgB,GAAG,IAAI,CAAC;wBACxB,sBAAsB,CAAC,gBAAgB,CAAC,CAAC;wBAEzC,qBAAqB,GAAG,IAAI,CAAC;wBAC7B,2BAA2B,CAAC,qBAAqB,CAAC,CAAC;oBACrD,CAAC;yBAAM,CAAC;wBACN,IAAI,CAAC,kBAAkB,IAAI,oBAAoB,EAAE,CAAC;4BAChD,MAAM,SAAS,GAAG,MAAM,sBAAsB,EAAE,CAAC;4BACjD,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;gCAC5B,SAAS,EAAE,CAAC;oCACV,OAAO,EACL,uGAAuG;oCACzG,IAAI,EAAE,QAAQ;oCACd,QAAQ,EAAE,IAAI;iCACf,CAAC,CAAC;gCACH,OAAO;4BACT,CAAC;wBACH,CAAC;wBAED,MAAM,gBAAgB,GAAG,2BAA2B;4BAClD,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,QAAQ,EAAE,2BAA2B,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE;4BACpE,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;wBAElC,IAAI,CAAC;4BACH,MAAM,MAAM,GAAG,MAAM,SAAS,CAAC,YAAY,CAAC,YAAY,CAAC,gBAAgB,CAAC,CAAC;4BAC3E,MAAM,kBAAkB,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC,CAAC;wBACnD,CAAC;wBAAC,OAAO,KAAK,EAAE,CAAC;4BACf,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;4BACrB,SAAS,EAAE,CAAC;gCACV,OAAO,EACL,uGAAuG;gCACzG,IAAI,EAAE,QAAQ;gCACd,QAAQ,EAAE,IAAI;6BACf,CAAC,CAAC;wBACL,CAAC;oBACH,CAAC;oBACD,MAAM;gBAER,QAAQ;YACV,CAAC;QACH,CAAC;IACH,CAAC;uGAxOU,UAAU;2GAAV,UAAU,cAFT,MAAM;;2FAEP,UAAU;kBAHtB,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  CheckPermissionType,\n  DisconnectSendTransportAudioParameters,\n  DisconnectSendTransportAudioType,\n  Participant,\n  RequestPermissionAudioType,\n  ResumeSendTransportAudioParameters,\n  ResumeSendTransportAudioType,\n  ShowAlert,\n  StreamSuccessAudioParameters,\n  StreamSuccessAudioType,\n} from '../../@types/types';\nimport { Socket } from 'socket.io-client';\n\n/* eslint-disable eqeqeq */\nexport interface ClickAudioParameters\n  extends DisconnectSendTransportAudioParameters,\n    ResumeSendTransportAudioParameters,\n    StreamSuccessAudioParameters {\n  checkMediaPermission: boolean;\n  hasAudioPermission: boolean;\n  audioPaused: boolean;\n  audioAlreadyOn: boolean;\n  audioOnlyRoom: boolean;\n  recordStarted: boolean;\n  recordResumed: boolean;\n  recordPaused: boolean;\n  recordStopped: boolean;\n  recordingMediaOptions: string;\n  islevel: string;\n  youAreCoHost: boolean;\n  adminRestrictSetting: boolean;\n  audioRequestState: string | null;\n  audioRequestTime: number;\n  member: string;\n  socket: Socket;\n  roomName: string;\n  userDefaultAudioInputDevice: string;\n  micAction: boolean;\n  localStream: MediaStream | null;\n  audioSetting: string;\n  videoSetting: string;\n  screenshareSetting: string;\n  chatSetting: string;\n  updateRequestIntervalSeconds: number;\n  participants: Participant[];\n  transportCreated: boolean;\n  transportCreatedAudio: boolean;\n\n  updateAudioAlreadyOn: (status: boolean) => void;\n  updateAudioRequestState: (state: string | null) => void;\n  updateAudioPaused: (status: boolean) => void;\n  updateLocalStream: (stream: MediaStream | null) => void;\n  updateParticipants: (participants: Participant[]) => void;\n  updateTransportCreated: (status: boolean) => void;\n  updateTransportCreatedAudio: (status: boolean) => void;\n  updateMicAction: (action: boolean) => void;\n  showAlert?: ShowAlert;\n\n  // mediasfu functions\n  checkPermission: CheckPermissionType;\n  streamSuccessAudio: StreamSuccessAudioType;\n  disconnectSendTransportAudio: DisconnectSendTransportAudioType;\n  requestPermissionAudio: RequestPermissionAudioType;\n  resumeSendTransportAudio: ResumeSendTransportAudioType;\n\n  getUpdatedAllParams: () => ClickAudioParameters;\n  [key: string]: any;\n}\n\nexport interface ClickAudioOptions {\n  parameters: ClickAudioParameters;\n}\n\n// Export the type definition for the function\nexport type ClickAudioType = (options: ClickAudioOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ClickAudio {\n  /**\n   * Handles the click event for toggling audio in a media session.\n   *\n   * @param {ClickAudioOptions} parameters - The parameters required for handling the audio click event.\n   * @returns {Promise<void>} A promise that resolves when the audio click event has been handled.\n   *\n   * The function performs the following actions:\n   * - If the event is audio-only, it shows an alert and exits.\n   * - If the audio is already on, it handles the logic for turning it off, including checking recording states and permissions.\n   * - If the audio is off, it checks for admin restrictions, user permissions, and handles the logic for turning the audio on.\n   * - It updates various states and emits socket events as necessary.\n   *\n   * The function makes use of several helper functions and state update functions passed in through the parameters.\n   */\n\n  async clickAudio({ parameters }: ClickAudioOptions): Promise<void> {\n    let {\n      checkMediaPermission,\n      hasAudioPermission,\n      audioPaused,\n      audioAlreadyOn,\n      audioOnlyRoom,\n      recordStarted,\n      recordResumed,\n      recordPaused,\n      recordStopped,\n      recordingMediaOptions,\n      islevel,\n      youAreCoHost,\n      adminRestrictSetting,\n      audioRequestState,\n      audioRequestTime,\n      member,\n      socket,\n      roomName,\n      userDefaultAudioInputDevice,\n      micAction,\n      localStream,\n      audioSetting,\n      videoSetting,\n      screenshareSetting,\n      chatSetting,\n      updateRequestIntervalSeconds,\n      participants,\n      showAlert,\n      transportCreated,\n      transportCreatedAudio,\n\n      updateAudioAlreadyOn,\n      updateAudioRequestState,\n      updateAudioPaused,\n      updateLocalStream,\n      updateParticipants,\n      updateTransportCreated,\n      updateTransportCreatedAudio,\n      updateMicAction,\n\n      checkPermission,\n      streamSuccessAudio,\n      requestPermissionAudio,\n      resumeSendTransportAudio,\n      disconnectSendTransportAudio,\n    } = parameters;\n\n    if (audioOnlyRoom) {\n      showAlert?.({\n        message: 'You cannot turn on your camera in an audio-only event.',\n        type: 'danger',\n        duration: 3000,\n      });\n      return;\n    }\n\n    if (audioAlreadyOn) {\n      if (islevel === '2' && (recordStarted || recordResumed)) {\n        if (!(recordPaused || recordStopped)) {\n          if (recordingMediaOptions === 'audio') {\n            showAlert?.({\n              message:\n                'You cannot turn off your audio while recording, please pause or stop recording first.',\n              type: 'danger',\n              duration: 3000,\n            });\n            return;\n          }\n        }\n      }\n\n      audioAlreadyOn = false;\n      updateAudioAlreadyOn(audioAlreadyOn);\n      if (localStream) {\n        localStream.getAudioTracks()[0].enabled = false;\n      }\n      updateLocalStream(localStream);\n      await disconnectSendTransportAudio({ parameters }); //disconnect function here actuall calls audioProducer.pause() instead of close() as in mediasfu\n      audioPaused = true;\n      updateAudioPaused(audioPaused);\n    } else {\n      if (adminRestrictSetting) {\n        showAlert?.({\n          message: 'You cannot turn on your microphone. Access denied by host.',\n          type: 'danger',\n          duration: 3000,\n        });\n        return;\n      }\n\n      let response = 2;\n      if (!micAction && islevel !== '2' && !youAreCoHost) {\n        response = await checkPermission({\n          permissionType: 'audioSetting',\n          audioSetting,\n          videoSetting,\n          screenshareSetting,\n          chatSetting,\n        });\n      } else {\n        response = 0;\n      }\n\n      switch (response) {\n        case 1: {\n          if (audioRequestState === 'pending') {\n            showAlert?.({\n              message: 'A request is pending. Please wait for the host to respond.',\n              type: 'danger',\n              duration: 3000,\n            });\n            return;\n          }\n\n          showAlert?.({\n            message: 'Request sent to host.',\n            type: 'success',\n            duration: 3000,\n          });\n\n          audioRequestState = 'pending';\n          updateAudioRequestState(audioRequestState);\n          //create a request and add to the request list and send to host\n\n          const userRequest = {\n            id: socket.id,\n            name: member,\n            icon: 'fa-microphone',\n          };\n          socket.emit('participantRequest', { userRequest, roomName });\n          break;\n        }\n\n        case 2:\n          if (\n            audioRequestState === 'rejected' &&\n            Date.now() - audioRequestTime < updateRequestIntervalSeconds * 1000\n          ) {\n            showAlert?.({\n              message: `A request was rejected. Please wait for ${updateRequestIntervalSeconds} seconds before sending another request.`,\n              type: 'danger',\n              duration: 3000,\n            });\n            return;\n          }\n          break;\n\n        case 0:\n          //allow\n\n          if (audioPaused) {\n            if (localStream) {\n              localStream.getAudioTracks()[0].enabled = true;\n            }\n            updateAudioAlreadyOn(true);\n            await resumeSendTransportAudio({ parameters });\n            socket.emit('resumeProducerAudio', { mediaTag: 'audio', roomName });\n\n            updateLocalStream(localStream);\n            updateAudioAlreadyOn(audioAlreadyOn);\n\n            if (micAction == true) {\n              micAction = false;\n              updateMicAction(micAction);\n            }\n\n            participants.forEach((participant) => {\n              if (participant['socketId'] === socket.id && participant.name === member) {\n                participant.muted = false;\n              }\n            });\n            updateParticipants(participants);\n\n            transportCreated = true;\n            updateTransportCreated(transportCreated);\n\n            transportCreatedAudio = true;\n            updateTransportCreatedAudio(transportCreatedAudio);\n          } else {\n            if (!hasAudioPermission && checkMediaPermission) {\n              const statusMic = await requestPermissionAudio();\n              if (statusMic !== 'granted') {\n                showAlert?.({\n                  message:\n                    'Allow access to your microphone or check if your microphone is not being used by another application.',\n                  type: 'danger',\n                  duration: 3000,\n                });\n                return;\n              }\n            }\n\n            const mediaConstraints = userDefaultAudioInputDevice\n              ? { audio: { deviceId: userDefaultAudioInputDevice }, video: false }\n              : { audio: true, video: false };\n\n            try {\n              const stream = await navigator.mediaDevices.getUserMedia(mediaConstraints);\n              await streamSuccessAudio({ stream, parameters });\n            } catch (error) {\n              console.error(error);\n              showAlert?.({\n                message:\n                  'Allow access to your microphone or check if your microphone is not being used by another application.',\n                type: 'danger',\n                duration: 3000,\n              });\n            }\n          }\n          break;\n\n        default:\n      }\n    }\n  }\n}\n"]}

package/dist/esm2022/lib/methods/stream-methods/click-chat.service.mjs

@@ -0,0 +1,44 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ClickChat {
+    /**
+     * Toggles the visibility of the chat modal based on the current state and event settings.
+     *
+     * @param {Object} options - The options for the clickChat function.
+     * @param {boolean} options.isMessagesModalVisible - Indicates if the messages modal is currently visible.
+     * @param {Function} options.updateIsMessagesModalVisible - Function to update the visibility state of the messages modal.
+     * @param {string} options.chatSetting - The chat setting for the event, which can be "allow" or other values.
+     * @param {string} options.islevel - The participant's level, where "2" indicates a level that allows chat.
+     * @param {Function} [options.showAlert] - Optional function to show an alert message.
+     *
+     * @returns {Promise<void>} A promise that resolves when the operation is complete.
+     */
+    async clickChat({ isMessagesModalVisible, updateIsMessagesModalVisible, chatSetting, islevel, showAlert, }) {
+        if (isMessagesModalVisible) {
+            updateIsMessagesModalVisible(false);
+        }
+        else {
+            // Check if chat is allowed based on event settings and participant level
+            if (chatSetting !== 'allow' && islevel !== '2') {
+                updateIsMessagesModalVisible(false);
+                showAlert?.({
+                    message: 'Chat is disabled for this event.',
+                    type: 'danger',
+                    duration: 3000,
+                });
+            }
+            else {
+                updateIsMessagesModalVisible(true);
+            }
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ClickChat, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ClickChat, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ClickChat, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/methods/stream-methods/click-screen-share.service.mjs

@@ -0,0 +1,110 @@
+// screen-share.service.ts
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ClickScreenShare {
+    /**
+     * Handles the action for the screen button, including starting and stopping screen sharing.
+     *
+     * @param {ClickScreenShareParams} options - Options for handling the screen button action.
+     * @returns {Promise<void>}
+     */
+    clickScreenShare = async ({ parameters }) => {
+        parameters = { ...parameters, ...parameters.getUpdatedAllParams() };
+        let { showAlert, roomName, member, socket, islevel, youAreCoHost, adminRestrictSetting, audioSetting, videoSetting, screenshareSetting, chatSetting, screenAction, screenAlreadyOn, screenRequestState, screenRequestTime, audioOnlyRoom, updateRequestIntervalSeconds, updateScreenRequestState, updateScreenAlreadyOn, checkPermission, checkScreenShare, stopShareScreen, } = parameters;
+        if (audioOnlyRoom) {
+            showAlert?.({
+                message: 'You cannot turn on your camera in an audio-only event.',
+                type: 'danger',
+                duration: 3000,
+            });
+            return;
+        }
+        if (roomName.startsWith('d')) {
+            showAlert?.({
+                message: 'You cannot start screen share in a demo room.',
+                type: 'danger',
+                duration: 3000,
+            });
+            return;
+        }
+        if (screenAlreadyOn) {
+            screenAlreadyOn = false;
+            updateScreenAlreadyOn(screenAlreadyOn);
+            await stopShareScreen({ parameters });
+        }
+        else {
+            if (adminRestrictSetting) {
+                showAlert?.({
+                    message: 'You cannot start screen share. Access denied by host.',
+                    type: 'danger',
+                    duration: 3000,
+                });
+                return;
+            }
+            let response = 2;
+            if (!screenAction && islevel != '2' && !youAreCoHost) {
+                response = await checkPermission({
+                    permissionType: 'screenshareSetting',
+                    audioSetting,
+                    videoSetting,
+                    screenshareSetting,
+                    chatSetting,
+                });
+            }
+            else {
+                response = 0;
+            }
+            switch (response) {
+                case 0:
+                    checkScreenShare({ parameters });
+                    break;
+                case 1: {
+                    if (screenRequestState === 'pending') {
+                        showAlert?.({
+                            message: 'A request is already pending. Please wait for the host to respond.',
+                            type: 'danger',
+                            duration: 3000,
+                        });
+                        return;
+                    }
+                    if (screenRequestState === 'rejected' &&
+                        Date.now() - screenRequestTime < updateRequestIntervalSeconds) {
+                        showAlert?.({
+                            message: 'You cannot send another request at this time.',
+                            type: 'danger',
+                            duration: 3000,
+                        });
+                        return;
+                    }
+                    showAlert?.({
+                        message: 'Your request has been sent to the host.',
+                        type: 'success',
+                        duration: 3000,
+                    });
+                    screenRequestState = 'pending';
+                    updateScreenRequestState(screenRequestState);
+                    let userRequest = { id: socket.id, name: member, icon: 'fa-desktop' };
+                    socket.emit('participantRequest', { userRequest, roomName });
+                    break;
+                }
+                case 2:
+                    showAlert?.({
+                        message: 'You are not allowed to start screen share.',
+                        type: 'danger',
+                        duration: 3000,
+                    });
+                    break;
+                default:
+            }
+        }
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ClickScreenShare, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ClickScreenShare, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ClickScreenShare, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"click-screen-share.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/methods/stream-methods/click-screen-share.service.ts"],"names":[],"mappings":"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","sourcesContent":["// screen-share.service.ts\nimport { Injectable } from '@angular/core';\nimport { Socket } from 'socket.io-client';\nimport {\n  CheckPermissionType,\n  CheckScreenShareParameters,\n  CheckScreenShareType,\n  ShowAlert,\n  StopShareScreenParameters,\n  StopShareScreenType,\n} from '../../@types/types';\n\nexport interface ClickScreenShareParameters\n  extends CheckScreenShareParameters,\n    StopShareScreenParameters {\n  showAlert?: ShowAlert;\n  roomName: string;\n  member: string;\n  socket: Socket;\n  islevel: string;\n  youAreCoHost: boolean;\n  adminRestrictSetting: boolean;\n  audioSetting: string;\n  videoSetting: string;\n  screenshareSetting: string;\n  chatSetting: string;\n  screenAction: boolean;\n  screenAlreadyOn: boolean;\n  screenRequestState: string | null;\n  screenRequestTime: number;\n  audioOnlyRoom: boolean;\n  updateRequestIntervalSeconds: number;\n  updateScreenRequestState: (state: string | null) => void;\n  updateScreenAlreadyOn: (status: boolean) => void;\n\n  // mediasfu functions\n  checkPermission: CheckPermissionType;\n  checkScreenShare: CheckScreenShareType;\n  stopShareScreen: StopShareScreenType;\n\n  getUpdatedAllParams: () => ClickScreenShareParameters;\n  [key: string]: any;\n}\n\nexport interface ClickScreenShareOptions {\n  parameters: ClickScreenShareParameters;\n}\n\n// Export the type definition for the function\nexport type ClickScreenShareType = (options: ClickScreenShareOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ClickScreenShare {\n  /**\n   * Handles the action for the screen button, including starting and stopping screen sharing.\n   *\n   * @param {ClickScreenShareParams} options - Options for handling the screen button action.\n   * @returns {Promise<void>}\n   */\n  clickScreenShare = async ({ parameters }: ClickScreenShareOptions): Promise<void> => {\n    parameters = { ...parameters, ...parameters.getUpdatedAllParams() };\n    let {\n      showAlert,\n      roomName,\n      member,\n      socket,\n      islevel,\n      youAreCoHost,\n      adminRestrictSetting,\n      audioSetting,\n      videoSetting,\n      screenshareSetting,\n      chatSetting,\n      screenAction,\n      screenAlreadyOn,\n      screenRequestState,\n      screenRequestTime,\n      audioOnlyRoom,\n      updateRequestIntervalSeconds,\n      updateScreenRequestState,\n      updateScreenAlreadyOn,\n      checkPermission,\n      checkScreenShare,\n      stopShareScreen,\n    } = parameters;\n\n    if (audioOnlyRoom) {\n      showAlert?.({\n        message: 'You cannot turn on your camera in an audio-only event.',\n        type: 'danger',\n        duration: 3000,\n      });\n      return;\n    }\n\n    if (roomName.startsWith('d')) {\n      showAlert?.({\n        message: 'You cannot start screen share in a demo room.',\n        type: 'danger',\n        duration: 3000,\n      });\n      return;\n    }\n\n    if (screenAlreadyOn) {\n      screenAlreadyOn = false;\n      updateScreenAlreadyOn(screenAlreadyOn);\n      await stopShareScreen({ parameters });\n    } else {\n      if (adminRestrictSetting) {\n        showAlert?.({\n          message: 'You cannot start screen share. Access denied by host.',\n          type: 'danger',\n          duration: 3000,\n        });\n        return;\n      }\n\n      let response = 2;\n      if (!screenAction && islevel != '2' && !youAreCoHost) {\n        response = await checkPermission({\n          permissionType: 'screenshareSetting',\n          audioSetting,\n          videoSetting,\n          screenshareSetting,\n          chatSetting,\n        });\n      } else {\n        response = 0;\n      }\n\n      switch (response) {\n        case 0:\n          checkScreenShare({ parameters });\n          break;\n        case 1: {\n          if (screenRequestState === 'pending') {\n            showAlert?.({\n              message: 'A request is already pending. Please wait for the host to respond.',\n              type: 'danger',\n              duration: 3000,\n            });\n            return;\n          }\n\n          if (\n            screenRequestState === 'rejected' &&\n            Date.now() - screenRequestTime < updateRequestIntervalSeconds\n          ) {\n            showAlert?.({\n              message: 'You cannot send another request at this time.',\n              type: 'danger',\n              duration: 3000,\n            });\n\n            return;\n          }\n\n          showAlert?.({\n            message: 'Your request has been sent to the host.',\n            type: 'success',\n            duration: 3000,\n          });\n\n          screenRequestState = 'pending';\n          updateScreenRequestState(screenRequestState);\n\n          let userRequest = { id: socket.id, name: member, icon: 'fa-desktop' };\n          socket.emit('participantRequest', { userRequest, roomName });\n          break;\n        }\n        case 2:\n          showAlert?.({\n            message: 'You are not allowed to start screen share.',\n            type: 'danger',\n            duration: 3000,\n          });\n\n          break;\n        default:\n      }\n    }\n  };\n}\n"]}