mediasfu-angular 1.0.0

package/dist/esm2022/lib/methods/participants-methods/remove-participants.service.mjs

@@ -0,0 +1,62 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class RemoveParticipants {
+    /**
+     * Removes a participant from the room if the user has the appropriate permissions.
+     *
+     * @param {RemoveParticipantsOptions} options - The options for removing a participant.
+     * @param {Array} options.coHostResponsibility - The responsibilities of the co-host.
+     * @param {Object} options.participant - The participant to be removed.
+     * @param {Object} options.member - The current member attempting to remove the participant.
+     * @param {string} options.islevel - The level of the current member.
+     * @param {Function} [options.showAlert] - Function to show an alert message.
+     * @param {Object} options.coHost - The co-host information.
+     * @param {Array} options.participants - The list of current participants.
+     * @param {Object} options.socket - The socket instance for emitting events.
+     * @param {string} options.roomName - The name of the room.
+     * @param {Function} options.updateParticipants - Function to update the participants list.
+     *
+     * @returns {Promise<void>} - A promise that resolves when the participant is removed.
+     */
+    async removeParticipants({ coHostResponsibility, participant, member, islevel, showAlert, coHost, participants, socket, roomName, updateParticipants, }) {
+        let participantsValue = false;
+        try {
+            participantsValue =
+                coHostResponsibility.find((item) => item.name === 'participants')?.value ?? false;
+        }
+        catch (error) {
+            participantsValue = false;
+        }
+        if (islevel === '2' || (coHost === member && participantsValue === true)) {
+            if (participant.islevel !== '2') {
+                const participantId = participant.id;
+                // Emit a socket event to disconnect the user
+                socket.emit('disconnectUserInitiate', {
+                    member: participant.name,
+                    roomName,
+                    id: participantId,
+                });
+                // Remove the participant from the local array
+                participants.splice(participants.findIndex((obj) => obj.name === participant.name), 1);
+                // Update the participants array
+                updateParticipants(participants);
+            }
+        }
+        else {
+            showAlert?.({
+                message: 'You are not allowed to remove other participants',
+                type: 'danger',
+                duration: 3000,
+            });
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: RemoveParticipants, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: RemoveParticipants, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: RemoveParticipants, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/methods/polls-methods/handle-create-poll.service.mjs

@@ -0,0 +1,37 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class HandleCreatePoll {
+    /**
+     * Handles the creation of a poll.
+     *
+     * @param {Object} options - The options for creating the poll.
+     * @param {Poll} options.poll - The poll object containing the poll details.
+     * @param {Object} options.parameters - Additional parameters for creating the poll.
+     * @returns {Promise<void>} - A promise that resolves when the poll is created successfully.
+     */
+    async handleCreatePoll({ poll, socket, roomName, showAlert, updateIsPollModalVisible, }) {
+        try {
+            socket.emit('createPoll', { roomName, poll }, (response) => {
+                if (response.success) {
+                    showAlert?.({ message: 'Poll created successfully', type: 'success' });
+                    updateIsPollModalVisible(false);
+                }
+                else {
+                    showAlert?.({ message: response.reason || 'Failed to create poll', type: 'danger' });
+                }
+            });
+        }
+        catch {
+            /* handle error */
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: HandleCreatePoll, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: HandleCreatePoll, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: HandleCreatePoll, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/methods/polls-methods/handle-end-poll.service.mjs

@@ -0,0 +1,40 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class HandleEndPoll {
+    /**
+     * Handles the end of a poll by emitting an "endPoll" event through the provided socket.
+     * Displays an alert based on the success or failure of the operation.
+     *
+     * @param {Object} options - The options for ending the poll.
+     * @param {string} options.pollId - The ID of the poll to end.
+     * @param {Socket} options.socket - The socket instance to emit the event.
+     * @param {Function} [options.showAlert] - Optional function to display alerts.
+     * @param {string} options.roomName - The name of the room where the poll is being conducted.
+     * @returns {Promise<void>} A promise that resolves when the poll end operation is complete.
+     */
+    async handleEndPoll({ pollId, socket, showAlert, roomName, updateIsPollModalVisible, }) {
+        try {
+            socket.emit('endPoll', { roomName, poll_id: pollId }, (response) => {
+                if (response.success) {
+                    showAlert?.({ message: 'Poll ended successfully', type: 'success' });
+                    updateIsPollModalVisible(false);
+                }
+                else {
+                    showAlert?.({ message: response.reason || 'Failed to end poll', type: 'danger' });
+                }
+            });
+        }
+        catch (error) {
+            console.log(error);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: HandleEndPoll, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: HandleEndPoll, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: HandleEndPoll, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/methods/polls-methods/handle-vote-poll.service.mjs

@@ -0,0 +1,49 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class HandleVotePoll {
+    /**
+     * Handles the voting process for a poll.
+     *
+     * @param {Object} options - The options for handling the vote.
+     * @param {string} options.pollId - The ID of the poll.
+     * @param {number} options.optionIndex - The index of the selected option.
+     * @param {Socket} options.socket - The socket instance for communication.
+     * @param {Function} [options.showAlert] - Optional function to show alerts.
+     * @param {Object} options.member - The member who is voting.
+     * @param {string} options.roomName - The name of the room where the poll is conducted.
+     * @param {Function} options.updateIsPollModalVisible - Function to update the visibility of the poll modal.
+     * @returns {Promise<void>} A promise that resolves when the vote is handled.
+     *
+     * @throws Will log an error message if there is an issue submitting the vote.
+     */
+    async handleVotePoll({ pollId, optionIndex, socket, showAlert, member, roomName, updateIsPollModalVisible, }) {
+        try {
+            socket.emit('votePoll', {
+                roomName,
+                poll_id: pollId,
+                member,
+                choice: optionIndex,
+            }, (response) => {
+                if (response.success) {
+                    showAlert?.({ message: 'Vote submitted successfully', type: 'success' });
+                    updateIsPollModalVisible(false);
+                }
+                else {
+                    showAlert?.({ message: response.reason, type: 'danger' });
+                }
+            });
+        }
+        catch (error) {
+            // console.log(error);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: HandleVotePoll, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: HandleVotePoll, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: HandleVotePoll, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/methods/polls-methods/launch-poll.service.mjs

@@ -0,0 +1,23 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class LaunchPoll {
+    /**
+     * Toggles the visibility of the poll modal.
+     * @function
+     * @param {Object} options - The options object containing necessary variables and functions.
+     * @param {Function} options.updateIsPollModalVisible - Function to update the visibility state of the poll modal.
+     * @param {boolean} options.isPollModalVisible - Current visibility state of the poll modal.
+     */
+    launchPoll({ updateIsPollModalVisible, isPollModalVisible }) {
+        updateIsPollModalVisible(!isPollModalVisible);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: LaunchPoll, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: LaunchPoll, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: LaunchPoll, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGF1bmNoLXBvbGwuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL21lZGlhc2Z1LWFuZ3VsYXIvc3JjL2xpYi9tZXRob2RzL3BvbGxzLW1ldGhvZHMvbGF1bmNoLXBvbGwuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQVkzQyxNQUFNLE9BQU8sVUFBVTtJQUNyQjs7Ozs7O09BTUc7SUFFSCxVQUFVLENBQUMsRUFBRSx3QkFBd0IsRUFBRSxrQkFBa0IsRUFBcUI7UUFDNUUsd0JBQXdCLENBQUMsQ0FBQyxrQkFBa0IsQ0FBQyxDQUFDO0lBQ2hELENBQUM7dUdBWFUsVUFBVTsyR0FBVixVQUFVLGNBRlQsTUFBTTs7MkZBRVAsVUFBVTtrQkFIdEIsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5leHBvcnQgaW50ZXJmYWNlIExhdW5jaFBvbGxPcHRpb25zIHtcbiAgdXBkYXRlSXNQb2xsTW9kYWxWaXNpYmxlOiAoaXNWaXNpYmxlOiBib29sZWFuKSA9PiB2b2lkO1xuICBpc1BvbGxNb2RhbFZpc2libGU6IGJvb2xlYW47XG59XG5cbi8vIEV4cG9ydCB0aGUgdHlwZSBkZWZpbml0aW9uIGZvciB0aGUgZnVuY3Rpb25cbmV4cG9ydCB0eXBlIExhdW5jaFBvbGxUeXBlID0gKG9wdGlvbnM6IExhdW5jaFBvbGxPcHRpb25zKSA9PiB2b2lkO1xuXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290Jyxcbn0pXG5leHBvcnQgY2xhc3MgTGF1bmNoUG9sbCB7XG4gIC8qKlxuICAgKiBUb2dnbGVzIHRoZSB2aXNpYmlsaXR5IG9mIHRoZSBwb2xsIG1vZGFsLlxuICAgKiBAZnVuY3Rpb25cbiAgICogQHBhcmFtIHtPYmplY3R9IG9wdGlvbnMgLSBUaGUgb3B0aW9ucyBvYmplY3QgY29udGFpbmluZyBuZWNlc3NhcnkgdmFyaWFibGVzIGFuZCBmdW5jdGlvbnMuXG4gICAqIEBwYXJhbSB7RnVuY3Rpb259IG9wdGlvbnMudXBkYXRlSXNQb2xsTW9kYWxWaXNpYmxlIC0gRnVuY3Rpb24gdG8gdXBkYXRlIHRoZSB2aXNpYmlsaXR5IHN0YXRlIG9mIHRoZSBwb2xsIG1vZGFsLlxuICAgKiBAcGFyYW0ge2Jvb2xlYW59IG9wdGlvbnMuaXNQb2xsTW9kYWxWaXNpYmxlIC0gQ3VycmVudCB2aXNpYmlsaXR5IHN0YXRlIG9mIHRoZSBwb2xsIG1vZGFsLlxuICAgKi9cblxuICBsYXVuY2hQb2xsKHsgdXBkYXRlSXNQb2xsTW9kYWxWaXNpYmxlLCBpc1BvbGxNb2RhbFZpc2libGUgfTogTGF1bmNoUG9sbE9wdGlvbnMpOiB2b2lkIHtcbiAgICB1cGRhdGVJc1BvbGxNb2RhbFZpc2libGUoIWlzUG9sbE1vZGFsVmlzaWJsZSk7XG4gIH1cbn1cbiJdfQ==

package/dist/esm2022/lib/methods/polls-methods/poll-updated.service.mjs

@@ -0,0 +1,64 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class PollUpdated {
+    /**
+     * Updates the poll state based on the provided data.
+     *
+     * @param {Object} options - The options for updating the poll.
+     * @param {any} options.data - The data containing poll information.
+     * @param {any[]} options.polls - The current list of polls.
+     * @param {any} options.poll - The current poll.
+     * @param {string} options.member - The member identifier.
+     * @param {string} options.islevel - The level of the member.
+     * @param {Function} options.showAlert - Function to show alerts.
+     * @param {Function} options.updatePolls - Function to update the list of polls.
+     * @param {Function} options.updatePoll - Function to update the current poll.
+     * @param {Function} options.updateIsPollModalVisible - Function to update the visibility of the poll modal.
+     * @returns {Promise<void>} A promise that resolves when the poll update is complete.
+     */
+    async pollUpdated({ data, polls, poll, member, islevel, showAlert, updatePolls, updatePoll, updateIsPollModalVisible, }) {
+        try {
+            if (data.polls) {
+                polls = data.polls;
+                updatePolls(data.polls);
+            }
+            else {
+                polls = [data.poll];
+                updatePolls(polls);
+            }
+            let temp_poll = { id: '' };
+            if (poll) {
+                temp_poll = { ...poll };
+            }
+            if (data.status != 'ended') {
+                poll = data.poll;
+                updatePoll(data.poll);
+            }
+            if (data.status === 'started' && islevel !== '2') {
+                if (!poll.voters || (poll.voters && !poll.voters[member])) {
+                    showAlert?.({ message: 'New poll started', type: 'success', duration: 3000 });
+                    updateIsPollModalVisible(true);
+                }
+            }
+            else if (data.status === 'ended') {
+                if (temp_poll.id === data.poll.id) {
+                    showAlert?.({ message: 'Poll ended', type: 'danger', duration: 3000 });
+                    // update the poll
+                    updatePoll(data.poll);
+                }
+            }
+        }
+        catch (error) {
+            // console.log(error);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: PollUpdated, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: PollUpdated, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: PollUpdated, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/methods/recording-methods/check-pause-state.service.mjs

@@ -0,0 +1,45 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class CheckPauseState {
+    /**
+     * Checks if the recording can be paused based on the current pause count and the allowed pause limits.
+     *
+     * @param {Object} options - The options for checking the pause state.
+     * @param {string} options.recordingMediaOptions - The type of media being recorded ("video" or "audio").
+     * @param {number} options.recordingVideoPausesLimit - The maximum number of pauses allowed for video recordings.
+     * @param {number} options.recordingAudioPausesLimit - The maximum number of pauses allowed for audio recordings.
+     * @param {number} options.pauseRecordCount - The current count of pauses that have been made.
+     * @param {Function} options.showAlert - A function to show an alert message if the pause limit is reached.
+     * @returns {Promise<boolean>} - A promise that resolves to `true` if the recording can be paused, otherwise `false`.
+     */
+    checkPauseState = async ({ recordingMediaOptions, recordingVideoPausesLimit, recordingAudioPausesLimit, pauseRecordCount, showAlert, }) => {
+        // function to check if the user can pause recording
+        let ref_limit = 0;
+        if (recordingMediaOptions == 'video') {
+            ref_limit = recordingVideoPausesLimit;
+        }
+        else {
+            ref_limit = recordingAudioPausesLimit;
+        }
+        if (pauseRecordCount < ref_limit) {
+            return true;
+        }
+        else {
+            showAlert?.({
+                message: 'You have reached the limit of pauses - you can choose to stop recording.',
+                type: 'danger',
+                duration: 3000,
+            });
+            return false;
+        }
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: CheckPauseState, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: CheckPauseState, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: CheckPauseState, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/methods/recording-methods/check-resume-state.service.mjs

@@ -0,0 +1,34 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class CheckResumeState {
+    /**
+     * Checks if the recording can be resumed based on the media type and pause limits.
+     *
+     * @param {Object} options - The options for checking resume state.
+     * @param {string} options.recordingMediaOptions - The type of media being recorded ("video" or "audio").
+     * @param {number} options.recordingVideoPausesLimit - The maximum number of pauses allowed for video recording.
+     * @param {number} options.recordingAudioPausesLimit - The maximum number of pauses allowed for audio recording.
+     * @param {number} options.pauseRecordCount - The current number of pauses that have occurred.
+     * @returns {Promise<boolean>} - A promise that resolves to a boolean indicating whether the recording can be resumed.
+     */
+    checkResumeState = async ({ recordingMediaOptions, recordingVideoPausesLimit, recordingAudioPausesLimit, pauseRecordCount, }) => {
+        // function to check if the user can resume recording
+        let ref_limit = 0;
+        if (recordingMediaOptions == 'video') {
+            ref_limit = recordingVideoPausesLimit;
+        }
+        else {
+            ref_limit = recordingAudioPausesLimit;
+        }
+        return pauseRecordCount <= ref_limit;
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: CheckResumeState, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: CheckResumeState, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: CheckResumeState, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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