mediasfu-angular 1.0.0

package/dist/esm2022/lib/producers/socket-receive-methods/host-request-response.service.mjs

@@ -0,0 +1,167 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Service to handle host request responses.
+ *
+ * @example
+ * ```typescript
+ * const hostRequestResponseService = new HostRequestResponse();
+ * await hostRequestResponseService.hostRequestResponse({
+ *   requestResponse: { id: '1', type: 'fa-microphone', name: 'John Doe', username: 'johndoe', action: 'accepted' },
+ *   showAlert: (alert) => console.log(alert),
+ *   requestList: [],
+ *   updateRequestList: (list) => console.log(list),
+ *   updateMicAction: (state) => console.log(state),
+ *   updateVideoAction: (state) => console.log(state),
+ *   updateScreenAction: (state) => console.log(state),
+ *   updateChatAction: (state) => console.log(state),
+ *   updateAudioRequestState: (state) => console.log(state),
+ *   updateVideoRequestState: (state) => console.log(state),
+ *   updateScreenRequestState: (state) => console.log(state),
+ *   updateChatRequestState: (state) => console.log(state),
+ *   updateAudioRequestTime: (time) => console.log(time),
+ *   updateVideoRequestTime: (time) => console.log(time),
+ *   updateScreenRequestTime: (time) => console.log(time),
+ *   updateChatRequestTime: (time) => console.log(time),
+ *   updateRequestIntervalSeconds: 30,
+ * });
+ * ```
+ *
+ * @typedef {Object} HostRequestResponseOptions
+ * @property {Object} requestResponse - The request response object.
+ * @property {Function} showAlert - Function to show alert messages.
+ * @property {Array} requestList - List of current requests.
+ * @property {Function} updateRequestList - Function to update the request list.
+ * @property {Function} updateMicAction - Function to update microphone action state.
+ * @property {Function} updateVideoAction - Function to update video action state.
+ * @property {Function} updateScreenAction - Function to update screen action state.
+ * @property {Function} updateChatAction - Function to update chat action state.
+ * @property {Function} updateAudioRequestState - Function to update audio request state.
+ * @property {Function} updateVideoRequestState - Function to update video request state.
+ * @property {Function} updateScreenRequestState - Function to update screen request state.
+ * @property {Function} updateChatRequestState - Function to update chat request state.
+ * @property {Function} updateAudioRequestTime - Function to update audio request time.
+ * @property {Function} updateVideoRequestTime - Function to update video request time.
+ * @property {Function} updateScreenRequestTime - Function to update screen request time.
+ * @property {Function} updateChatRequestTime - Function to update chat request time.
+ * @property {number} updateRequestIntervalSeconds - Interval in seconds to update request time.
+ *
+ * @class
+ * @classdesc This service handles the responses to host requests, updating the state and showing alerts based on the response.
+ *
+ * @method hostRequestResponse
+ * @async
+ * @param {HostRequestResponseOptions} options - The options for handling the host request response.
+ * @returns {Promise<void>} A promise that resolves when the request response has been handled.
+ */
+export class HostRequestResponse {
+    hostRequestResponse = async ({ requestResponse, showAlert, requestList, updateRequestList, updateMicAction, updateVideoAction, updateScreenAction, updateChatAction, updateAudioRequestState, updateVideoRequestState, updateScreenRequestState, updateChatRequestState, updateAudioRequestTime, updateVideoRequestTime, updateScreenRequestTime, updateChatRequestTime, updateRequestIntervalSeconds, }) => {
+        // Filter out the request from the list
+        const filteredRequests = requestList.filter((request) => request.id !== requestResponse.id &&
+            request.icon !== requestResponse.type &&
+            request.name !== requestResponse.name &&
+            request.username !== requestResponse.username);
+        updateRequestList(filteredRequests);
+        const requestType = requestResponse.type;
+        // Handle accepted actions
+        if (requestResponse.action === 'accepted') {
+            switch (requestType) {
+                case 'fa-microphone':
+                    showAlert?.({
+                        message: 'Unmute request was accepted; click the mic button again to begin.',
+                        type: 'success',
+                        duration: 10000,
+                    });
+                    updateMicAction(true);
+                    updateAudioRequestState('accepted');
+                    break;
+                case 'fa-video':
+                    showAlert?.({
+                        message: 'Video request was accepted; click the video button again to begin.',
+                        type: 'success',
+                        duration: 10000,
+                    });
+                    updateVideoAction(true);
+                    updateVideoRequestState('accepted');
+                    break;
+                case 'fa-desktop':
+                    showAlert?.({
+                        message: 'Screenshare request was accepted; click the screen button again to begin.',
+                        type: 'success',
+                        duration: 10000,
+                    });
+                    updateScreenAction(true);
+                    updateScreenRequestState('accepted');
+                    break;
+                case 'fa-comments':
+                    showAlert?.({
+                        message: 'Chat request was accepted; click the chat button again to begin.',
+                        type: 'success',
+                        duration: 10000,
+                    });
+                    updateChatAction(true);
+                    updateChatRequestState('accepted');
+                    break;
+            }
+        }
+        else {
+            // Handle rejected actions
+            let timerDate;
+            switch (requestType) {
+                case 'fa-microphone':
+                    showAlert?.({
+                        message: 'Unmute request was not accepted',
+                        type: 'danger',
+                        duration: 10000,
+                    });
+                    updateAudioRequestState('rejected');
+                    timerDate = new Date();
+                    timerDate.setSeconds(timerDate.getSeconds() + updateRequestIntervalSeconds);
+                    updateAudioRequestTime(timerDate.getTime());
+                    break;
+                case 'fa-video':
+                    showAlert?.({
+                        message: 'Video request was not accepted',
+                        type: 'danger',
+                        duration: 10000,
+                    });
+                    updateVideoRequestState('rejected');
+                    timerDate = new Date();
+                    timerDate.setSeconds(timerDate.getSeconds() + updateRequestIntervalSeconds);
+                    updateVideoRequestTime(timerDate.getTime());
+                    break;
+                case 'fa-desktop':
+                    showAlert?.({
+                        message: 'Screenshare request was not accepted',
+                        type: 'danger',
+                        duration: 10000,
+                    });
+                    updateScreenRequestState('rejected');
+                    timerDate = new Date();
+                    timerDate.setSeconds(timerDate.getSeconds() + updateRequestIntervalSeconds);
+                    updateScreenRequestTime(timerDate.getTime());
+                    break;
+                case 'fa-comments':
+                    showAlert?.({
+                        message: 'Chat request was not accepted',
+                        type: 'danger',
+                        duration: 10000,
+                    });
+                    updateChatRequestState('rejected');
+                    timerDate = new Date();
+                    timerDate.setSeconds(timerDate.getSeconds() + updateRequestIntervalSeconds);
+                    updateChatRequestTime(timerDate.getTime());
+                    break;
+            }
+        }
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: HostRequestResponse, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: HostRequestResponse, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: HostRequestResponse, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"host-request-response.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/producers/socket-receive-methods/host-request-response.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AA2B3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AAIH,MAAM,OAAO,mBAAmB;IAC9B,mBAAmB,GAAG,KAAK,EAAE,EAC3B,eAAe,EACf,SAAS,EACT,WAAW,EACX,iBAAiB,EACjB,eAAe,EACf,iBAAiB,EACjB,kBAAkB,EAClB,gBAAgB,EAChB,uBAAuB,EACvB,uBAAuB,EACvB,wBAAwB,EACxB,sBAAsB,EACtB,sBAAsB,EACtB,sBAAsB,EACtB,uBAAuB,EACvB,qBAAqB,EACrB,4BAA4B,GACD,EAAiB,EAAE;QAC9C,uCAAuC;QACvC,MAAM,gBAAgB,GAAG,WAAW,CAAC,MAAM,CACzC,CAAC,OAAO,EAAE,EAAE,CACV,OAAO,CAAC,EAAE,KAAK,eAAe,CAAC,EAAE;YACjC,OAAO,CAAC,IAAI,KAAK,eAAe,CAAC,IAAI;YACrC,OAAO,CAAC,IAAI,KAAK,eAAe,CAAC,IAAI;YACrC,OAAO,CAAC,QAAQ,KAAK,eAAe,CAAC,QAAQ,CAChD,CAAC;QACF,iBAAiB,CAAC,gBAAgB,CAAC,CAAC;QAEpC,MAAM,WAAW,GAAG,eAAe,CAAC,IAAI,CAAC;QAEzC,0BAA0B;QAC1B,IAAI,eAAe,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;YAC1C,QAAQ,WAAW,EAAE,CAAC;gBACpB,KAAK,eAAe;oBAClB,SAAS,EAAE,CAAC;wBACV,OAAO,EAAE,mEAAmE;wBAC5E,IAAI,EAAE,SAAS;wBACf,QAAQ,EAAE,KAAK;qBAChB,CAAC,CAAC;oBACH,eAAe,CAAC,IAAI,CAAC,CAAC;oBACtB,uBAAuB,CAAC,UAAU,CAAC,CAAC;oBACpC,MAAM;gBACR,KAAK,UAAU;oBACb,SAAS,EAAE,CAAC;wBACV,OAAO,EAAE,oEAAoE;wBAC7E,IAAI,EAAE,SAAS;wBACf,QAAQ,EAAE,KAAK;qBAChB,CAAC,CAAC;oBACH,iBAAiB,CAAC,IAAI,CAAC,CAAC;oBACxB,uBAAuB,CAAC,UAAU,CAAC,CAAC;oBACpC,MAAM;gBACR,KAAK,YAAY;oBACf,SAAS,EAAE,CAAC;wBACV,OAAO,EAAE,2EAA2E;wBACpF,IAAI,EAAE,SAAS;wBACf,QAAQ,EAAE,KAAK;qBAChB,CAAC,CAAC;oBACH,kBAAkB,CAAC,IAAI,CAAC,CAAC;oBACzB,wBAAwB,CAAC,UAAU,CAAC,CAAC;oBACrC,MAAM;gBACR,KAAK,aAAa;oBAChB,SAAS,EAAE,CAAC;wBACV,OAAO,EAAE,kEAAkE;wBAC3E,IAAI,EAAE,SAAS;wBACf,QAAQ,EAAE,KAAK;qBAChB,CAAC,CAAC;oBACH,gBAAgB,CAAC,IAAI,CAAC,CAAC;oBACvB,sBAAsB,CAAC,UAAU,CAAC,CAAC;oBACnC,MAAM;YACV,CAAC;QACH,CAAC;aAAM,CAAC;YACN,0BAA0B;YAC1B,IAAI,SAAe,CAAC;YACpB,QAAQ,WAAW,EAAE,CAAC;gBACpB,KAAK,eAAe;oBAClB,SAAS,EAAE,CAAC;wBACV,OAAO,EAAE,iCAAiC;wBAC1C,IAAI,EAAE,QAAQ;wBACd,QAAQ,EAAE,KAAK;qBAChB,CAAC,CAAC;oBACH,uBAAuB,CAAC,UAAU,CAAC,CAAC;oBACpC,SAAS,GAAG,IAAI,IAAI,EAAE,CAAC;oBACvB,SAAS,CAAC,UAAU,CAAC,SAAS,CAAC,UAAU,EAAE,GAAG,4BAA4B,CAAC,CAAC;oBAC5E,sBAAsB,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC,CAAC;oBAC5C,MAAM;gBACR,KAAK,UAAU;oBACb,SAAS,EAAE,CAAC;wBACV,OAAO,EAAE,gCAAgC;wBACzC,IAAI,EAAE,QAAQ;wBACd,QAAQ,EAAE,KAAK;qBAChB,CAAC,CAAC;oBACH,uBAAuB,CAAC,UAAU,CAAC,CAAC;oBACpC,SAAS,GAAG,IAAI,IAAI,EAAE,CAAC;oBACvB,SAAS,CAAC,UAAU,CAAC,SAAS,CAAC,UAAU,EAAE,GAAG,4BAA4B,CAAC,CAAC;oBAC5E,sBAAsB,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC,CAAC;oBAC5C,MAAM;gBACR,KAAK,YAAY;oBACf,SAAS,EAAE,CAAC;wBACV,OAAO,EAAE,sCAAsC;wBAC/C,IAAI,EAAE,QAAQ;wBACd,QAAQ,EAAE,KAAK;qBAChB,CAAC,CAAC;oBACH,wBAAwB,CAAC,UAAU,CAAC,CAAC;oBACrC,SAAS,GAAG,IAAI,IAAI,EAAE,CAAC;oBACvB,SAAS,CAAC,UAAU,CAAC,SAAS,CAAC,UAAU,EAAE,GAAG,4BAA4B,CAAC,CAAC;oBAC5E,uBAAuB,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC,CAAC;oBAC7C,MAAM;gBACR,KAAK,aAAa;oBAChB,SAAS,EAAE,CAAC;wBACV,OAAO,EAAE,+BAA+B;wBACxC,IAAI,EAAE,QAAQ;wBACd,QAAQ,EAAE,KAAK;qBAChB,CAAC,CAAC;oBACH,sBAAsB,CAAC,UAAU,CAAC,CAAC;oBACnC,SAAS,GAAG,IAAI,IAAI,EAAE,CAAC;oBACvB,SAAS,CAAC,UAAU,CAAC,SAAS,CAAC,UAAU,EAAE,GAAG,4BAA4B,CAAC,CAAC;oBAC5E,qBAAqB,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC,CAAC;oBAC3C,MAAM;YACV,CAAC;QACH,CAAC;IACH,CAAC,CAAC;uGA1HS,mBAAmB;2GAAnB,mBAAmB,cAFlB,MAAM;;2FAEP,mBAAmB;kBAH/B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { ShowAlert, Request, RequestResponse } from '../../@types/types';\n\nexport interface HostRequestResponseOptions {\n  requestResponse: RequestResponse;\n\n  showAlert?: ShowAlert;\n  requestList: Request[];\n  updateRequestList: (requestList: Request[]) => void;\n  updateMicAction: (action: boolean) => void;\n  updateVideoAction: (action: boolean) => void;\n  updateScreenAction: (action: boolean) => void;\n  updateChatAction: (action: boolean) => void;\n  updateAudioRequestState: (state: string | null) => void;\n  updateVideoRequestState: (state: string | null) => void;\n  updateScreenRequestState: (state: string | null) => void;\n  updateChatRequestState: (state: string | null) => void;\n  updateAudioRequestTime: (time: number) => void;\n  updateVideoRequestTime: (time: number) => void;\n  updateScreenRequestTime: (time: number) => void;\n  updateChatRequestTime: (time: number) => void;\n  updateRequestIntervalSeconds: number;\n}\n\n// Export the type definition for the function\nexport type HostRequestResponseType = (options: HostRequestResponseOptions) => Promise<void>;\n\n/**\n * Service to handle host request responses.\n *\n * @example\n * ```typescript\n * const hostRequestResponseService = new HostRequestResponse();\n * await hostRequestResponseService.hostRequestResponse({\n *   requestResponse: { id: '1', type: 'fa-microphone', name: 'John Doe', username: 'johndoe', action: 'accepted' },\n *   showAlert: (alert) => console.log(alert),\n *   requestList: [],\n *   updateRequestList: (list) => console.log(list),\n *   updateMicAction: (state) => console.log(state),\n *   updateVideoAction: (state) => console.log(state),\n *   updateScreenAction: (state) => console.log(state),\n *   updateChatAction: (state) => console.log(state),\n *   updateAudioRequestState: (state) => console.log(state),\n *   updateVideoRequestState: (state) => console.log(state),\n *   updateScreenRequestState: (state) => console.log(state),\n *   updateChatRequestState: (state) => console.log(state),\n *   updateAudioRequestTime: (time) => console.log(time),\n *   updateVideoRequestTime: (time) => console.log(time),\n *   updateScreenRequestTime: (time) => console.log(time),\n *   updateChatRequestTime: (time) => console.log(time),\n *   updateRequestIntervalSeconds: 30,\n * });\n * ```\n *\n * @typedef {Object} HostRequestResponseOptions\n * @property {Object} requestResponse - The request response object.\n * @property {Function} showAlert - Function to show alert messages.\n * @property {Array} requestList - List of current requests.\n * @property {Function} updateRequestList - Function to update the request list.\n * @property {Function} updateMicAction - Function to update microphone action state.\n * @property {Function} updateVideoAction - Function to update video action state.\n * @property {Function} updateScreenAction - Function to update screen action state.\n * @property {Function} updateChatAction - Function to update chat action state.\n * @property {Function} updateAudioRequestState - Function to update audio request state.\n * @property {Function} updateVideoRequestState - Function to update video request state.\n * @property {Function} updateScreenRequestState - Function to update screen request state.\n * @property {Function} updateChatRequestState - Function to update chat request state.\n * @property {Function} updateAudioRequestTime - Function to update audio request time.\n * @property {Function} updateVideoRequestTime - Function to update video request time.\n * @property {Function} updateScreenRequestTime - Function to update screen request time.\n * @property {Function} updateChatRequestTime - Function to update chat request time.\n * @property {number} updateRequestIntervalSeconds - Interval in seconds to update request time.\n *\n * @class\n * @classdesc This service handles the responses to host requests, updating the state and showing alerts based on the response.\n *\n * @method hostRequestResponse\n * @async\n * @param {HostRequestResponseOptions} options - The options for handling the host request response.\n * @returns {Promise<void>} A promise that resolves when the request response has been handled.\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class HostRequestResponse {\n  hostRequestResponse = async ({\n    requestResponse,\n    showAlert,\n    requestList,\n    updateRequestList,\n    updateMicAction,\n    updateVideoAction,\n    updateScreenAction,\n    updateChatAction,\n    updateAudioRequestState,\n    updateVideoRequestState,\n    updateScreenRequestState,\n    updateChatRequestState,\n    updateAudioRequestTime,\n    updateVideoRequestTime,\n    updateScreenRequestTime,\n    updateChatRequestTime,\n    updateRequestIntervalSeconds,\n  }: HostRequestResponseOptions): Promise<void> => {\n    // Filter out the request from the list\n    const filteredRequests = requestList.filter(\n      (request) =>\n        request.id !== requestResponse.id &&\n        request.icon !== requestResponse.type &&\n        request.name !== requestResponse.name &&\n        request.username !== requestResponse.username,\n    );\n    updateRequestList(filteredRequests);\n\n    const requestType = requestResponse.type;\n\n    // Handle accepted actions\n    if (requestResponse.action === 'accepted') {\n      switch (requestType) {\n        case 'fa-microphone':\n          showAlert?.({\n            message: 'Unmute request was accepted; click the mic button again to begin.',\n            type: 'success',\n            duration: 10000,\n          });\n          updateMicAction(true);\n          updateAudioRequestState('accepted');\n          break;\n        case 'fa-video':\n          showAlert?.({\n            message: 'Video request was accepted; click the video button again to begin.',\n            type: 'success',\n            duration: 10000,\n          });\n          updateVideoAction(true);\n          updateVideoRequestState('accepted');\n          break;\n        case 'fa-desktop':\n          showAlert?.({\n            message: 'Screenshare request was accepted; click the screen button again to begin.',\n            type: 'success',\n            duration: 10000,\n          });\n          updateScreenAction(true);\n          updateScreenRequestState('accepted');\n          break;\n        case 'fa-comments':\n          showAlert?.({\n            message: 'Chat request was accepted; click the chat button again to begin.',\n            type: 'success',\n            duration: 10000,\n          });\n          updateChatAction(true);\n          updateChatRequestState('accepted');\n          break;\n      }\n    } else {\n      // Handle rejected actions\n      let timerDate: Date;\n      switch (requestType) {\n        case 'fa-microphone':\n          showAlert?.({\n            message: 'Unmute request was not accepted',\n            type: 'danger',\n            duration: 10000,\n          });\n          updateAudioRequestState('rejected');\n          timerDate = new Date();\n          timerDate.setSeconds(timerDate.getSeconds() + updateRequestIntervalSeconds);\n          updateAudioRequestTime(timerDate.getTime());\n          break;\n        case 'fa-video':\n          showAlert?.({\n            message: 'Video request was not accepted',\n            type: 'danger',\n            duration: 10000,\n          });\n          updateVideoRequestState('rejected');\n          timerDate = new Date();\n          timerDate.setSeconds(timerDate.getSeconds() + updateRequestIntervalSeconds);\n          updateVideoRequestTime(timerDate.getTime());\n          break;\n        case 'fa-desktop':\n          showAlert?.({\n            message: 'Screenshare request was not accepted',\n            type: 'danger',\n            duration: 10000,\n          });\n          updateScreenRequestState('rejected');\n          timerDate = new Date();\n          timerDate.setSeconds(timerDate.getSeconds() + updateRequestIntervalSeconds);\n          updateScreenRequestTime(timerDate.getTime());\n          break;\n        case 'fa-comments':\n          showAlert?.({\n            message: 'Chat request was not accepted',\n            type: 'danger',\n            duration: 10000,\n          });\n          updateChatRequestState('rejected');\n          timerDate = new Date();\n          timerDate.setSeconds(timerDate.getSeconds() + updateRequestIntervalSeconds);\n          updateChatRequestTime(timerDate.getTime());\n          break;\n      }\n    }\n  };\n}\n"]}

package/dist/esm2022/lib/producers/socket-receive-methods/meeting-ended.service.mjs

@@ -0,0 +1,44 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class MeetingEnded {
+    /**
+     * Handles the end of a meeting by showing an alert and redirecting the user.
+     *
+     * @param {MeetingEndedOptions} options - The options for handling the meeting end.
+     * @param {Function} options.showAlert - Function to show an alert message.
+     * @param {string} options.redirectURL - URL to redirect to after the meeting ends.
+     * @param {boolean} options.onWeb - Flag indicating if the application is running on the web.
+     * @param {string} options.eventType - Type of the event that triggered the meeting end.
+     *
+     * @returns {Promise<void>} A promise that resolves when the meeting end handling is complete.
+     */
+    meetingEnded = async ({ showAlert, redirectURL, onWeb, eventType, }) => {
+        // Show an alert that the meeting has ended and wait for 2 seconds before redirecting to the home page
+        if (eventType !== 'chat') {
+            showAlert?.({
+                message: 'The event has ended. You will be redirected to the home page in 2 seconds.',
+                type: 'danger',
+                duration: 2000,
+            });
+        }
+        if (onWeb && redirectURL) {
+            setTimeout(() => {
+                window.location.href = redirectURL;
+            }, 2000);
+        }
+        else {
+            // setTimeout(() => {
+            //   updateValidated(false);
+            // }, 2000);
+        }
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: MeetingEnded, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: MeetingEnded, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: MeetingEnded, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/producers/socket-receive-methods/meeting-still-there.service.mjs

@@ -0,0 +1,24 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class MeetingStillThere {
+    /**
+     * Handles the "still there?" meeting check by updating the visibility of the confirmation modal.
+     *
+     * @param {Object} options - The options for the meeting still there check.
+     * @param {Function} options.updateIsConfirmHereModalVisible - Function to update the visibility of the "still there?" modal.
+     * @returns {Promise<void>} A promise that resolves when the modal visibility is updated.
+     */
+    meetingStillThere = ({ updateIsConfirmHereModalVisible }) => {
+        // Update the visibility of the "still there?" modal
+        updateIsConfirmHereModalVisible(true);
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: MeetingStillThere, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: MeetingStillThere, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: MeetingStillThere, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/producers/socket-receive-methods/meeting-time-remaining.service.mjs

@@ -0,0 +1,36 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class MeetingTimeRemaining {
+    /**
+     * Handles the remaining time for a meeting and shows an alert if the event type is not 'chat'.
+     *
+     * @param {Object} options - The options for the meeting time remaining.
+     * @param {number} options.timeRemaining - The remaining time in milliseconds.
+     * @param {Function} options.showAlert - The function to show an alert message.
+     * @param {string} options.eventType - The type of the event.
+     * @returns {Promise<void>} A promise that resolves when the operation is complete.
+     */
+    meetingTimeRemaining = async ({ timeRemaining, showAlert, eventType, }) => {
+        // Convert time from milliseconds to readable format of minutes and seconds
+        const minutes = Math.floor(timeRemaining / 60000);
+        const seconds = Math.floor((timeRemaining % 60000) / 1000);
+        const timeRemainingString = `${minutes}:${seconds < 10 ? '0' : ''}${seconds}`;
+        // Show alert with time remaining if eventType is not 'chat'
+        if (eventType !== 'chat') {
+            showAlert?.({
+                message: `The event will end in ${timeRemainingString} minutes.`,
+                type: 'success',
+                duration: 3000,
+            });
+        }
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: MeetingTimeRemaining, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: MeetingTimeRemaining, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: MeetingTimeRemaining, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/producers/socket-receive-methods/participant-requested.service.mjs

@@ -0,0 +1,32 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ParticipantRequested {
+    /**
+     * Handles a participant's request by adding it to the request list and updating the total count of requests and waiting room participants.
+     *
+     * @param {ParticipantRequestedOptions} options - The options for handling the participant's request.
+     * @param {UserRequest} options.userRequest - The user request to be added to the request list.
+     * @param {UserRequest[]} options.requestList - The current list of user requests.
+     * @param {UserRequest[]} options.waitingRoomList - The current list of participants in the waiting room.
+     * @param {Function} options.updateTotalReqWait - Function to update the total count of requests and waiting room participants.
+     * @param {Function} options.updateRequestList - Function to update the request list.
+     * @returns {Promise<void>} A promise that resolves when the participant's request has been handled.
+     */
+    participantRequested = async ({ userRequest, requestList, waitingRoomList, updateTotalReqWait, updateRequestList, }) => {
+        // Add the user request to the request list
+        const updatedRequestList = [...requestList, userRequest];
+        updateRequestList(updatedRequestList);
+        // Update the total count of requests and waiting room participants
+        const reqCount = updatedRequestList.length + waitingRoomList.length;
+        updateTotalReqWait(reqCount);
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ParticipantRequested, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ParticipantRequested, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ParticipantRequested, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/producers/socket-receive-methods/person-joined.service.mjs

@@ -0,0 +1,29 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class PersonJoined {
+    /**
+     * Handles the event when a person joins.
+     *
+     * @param {PersonJoinedOptions} options - The options for the person joined event.
+     * @param {string} options.name - The name of the person who joined.
+     * @param {Function} options.showAlert - A function to display an alert/notification.
+     * @returns {Promise<void>} A promise that resolves when the alert has been shown.
+     */
+    personJoined = ({ name, showAlert }) => {
+        // Display an alert/notification about the person joining the event
+        showAlert?.({
+            message: `${name} joined the event.`,
+            type: 'success',
+            duration: 3000,
+        });
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: PersonJoined, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: PersonJoined, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: PersonJoined, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/producers/socket-receive-methods/producer-media-closed.service.mjs

@@ -0,0 +1,68 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ProducerMediaClosed {
+    /**
+     * Handles the closure of a media producer.
+     *
+     * @param {ProducerMediaClosedOptions} options - The options for closing the media producer.
+     * @param {string} options.producerId - The ID of the producer to close.
+     * @param {string} options.kind - The kind of media (e.g., "screenshare" or "screen").
+     * @param {Parameters} options.parameters - The parameters object containing various methods and properties.
+     *
+     * @returns {Promise<void>} - A promise that resolves when the producer has been closed and necessary updates are made.
+     *
+     * @remarks
+     * This function performs the following steps:
+     * 1. Retrieves updated parameters.
+     * 2. Finds the transport associated with the producer to close.
+     * 3. Closes the consumer transport and consumer if found.
+     * 4. Updates the consumer transports list.
+     * 5. Calls `closeAndResize` with the necessary parameters.
+     * 6. If the producer kind is "screenshare" or "screen", updates shared state and calls various update methods.
+     */
+    producerMediaClosed = async ({ producerId, kind, parameters, }) => {
+        parameters = parameters.getUpdatedAllParams();
+        const { consumerTransports, updateConsumerTransports, hostLabel, shared, updateShared, updateShareScreenStarted, updateScreenId, updateShareEnded, closeAndResize, prepopulateUserMedia, reorderStreams, } = parameters;
+        const producerToClose = consumerTransports.find((transportData) => transportData.producerId === producerId);
+        if (producerToClose) {
+            try {
+                await producerToClose['consumerTransport'].close();
+            }
+            catch (error) {
+                console.error('Error closing consumer transport:', error);
+            }
+            try {
+                producerToClose.consumer.close();
+            }
+            catch (error) {
+                console.error('Error closing consumer:', error);
+            }
+            const updatedConsumerTransports = consumerTransports.filter((transportData) => transportData.producerId !== producerId);
+            updateConsumerTransports(updatedConsumerTransports);
+            await closeAndResize({ producerId, kind, parameters });
+        }
+        else {
+            if (kind === 'screenshare' || kind === 'screen') {
+                if (shared) {
+                    updateShared(false);
+                }
+                else {
+                    updateShareScreenStarted(false);
+                    updateScreenId('');
+                }
+                updateShareEnded(true);
+                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: ProducerMediaClosed, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ProducerMediaClosed, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ProducerMediaClosed, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/producers/socket-receive-methods/producer-media-paused.service.mjs

@@ -0,0 +1,90 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ProducerMediaPaused {
+    /**
+     * Handles the event when media is paused for a producer.
+     *
+     * @param {ProducerMediaPausedOptions} options - The options for the producer media paused event.
+     * @param {string} options.producerId - The ID of the producer.
+     * @param {string} options.kind - The kind of media (e.g., "audio", "video").
+     * @param {string} options.name - The name of the producer.
+     * @param {Parameters} options.parameters - The parameters for the event.
+     *
+     * @returns {Promise<void>} A promise that resolves when the media paused handling is complete.
+     *
+     * @description
+     * This function handles the event when media is paused for a producer. It performs the following tasks:
+     * - Updates the parameters.
+     * - Iterates through participants and updates the UI based on their muted status and other conditions.
+     * - Handles meeting display type and optimizes the UI accordingly.
+     * - Manages audio media by updating the relevant participant's state.
+     */
+    producerMediaPaused = async ({ producerId, kind, name, parameters, }) => {
+        parameters = parameters.getUpdatedAllParams();
+        let { activeSounds, meetingDisplayType, meetingVideoOptimized, participants, oldSoundIds, shared, shareScreenStarted, updateMainWindow, hostLabel, islevel, updateActiveSounds, updateUpdateMainWindow, reorderStreams, prepopulateUserMedia, reUpdateInter, } = parameters;
+        await Promise.all(participants.map(async (participant) => {
+            if (participant.muted) {
+                try {
+                    if (participant.islevel == '2' &&
+                        !participant.videoID &&
+                        !shared &&
+                        !shareScreenStarted &&
+                        islevel != '2') {
+                        updateMainWindow = true;
+                        updateUpdateMainWindow(updateMainWindow);
+                        await prepopulateUserMedia({ name: hostLabel, parameters });
+                        updateMainWindow = false;
+                        updateUpdateMainWindow(updateMainWindow);
+                    }
+                }
+                catch {
+                    /* handle error */
+                }
+                if (shareScreenStarted || shared) {
+                    if (activeSounds.includes(participant.name)) {
+                        activeSounds = activeSounds.filter((audioStream) => audioStream != participant.name);
+                        updateActiveSounds(activeSounds);
+                    }
+                    await reUpdateInter({ name: participant.name, add: false, force: true, parameters });
+                }
+            }
+        }));
+        let checker = false;
+        if (meetingDisplayType == 'media' ||
+            (meetingDisplayType == 'video' && !meetingVideoOptimized)) {
+            const participant = participants.find((obj) => obj.name == name);
+            checker = !!participant?.videoID;
+            if (!checker && !shareScreenStarted && !shared) {
+                await reorderStreams({ add: false, screenChanged: true, parameters });
+            }
+        }
+        if (kind == 'audio') {
+            try {
+                const participant = participants.find((obj) => obj.audioID == producerId) ||
+                    participants.find((obj) => obj.name == name);
+                if (participant &&
+                    ((participant.name && oldSoundIds.includes(participant.name)) ||
+                        (name && oldSoundIds.includes(name)))) {
+                    reUpdateInter({
+                        name: participant.name ?? '',
+                        add: false,
+                        force: true,
+                        parameters,
+                    });
+                }
+            }
+            catch {
+                /* handle error */
+            }
+        }
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ProducerMediaPaused, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ProducerMediaPaused, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ProducerMediaPaused, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"producer-media-paused.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/producers/socket-receive-methods/producer-media-paused.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  Participant,\n  PrepopulateUserMediaType,\n  ReorderStreamsType,\n  ReUpdateInterParameters,\n  ReUpdateInterType,\n  ReorderStreamsParameters,\n  PrepopulateUserMediaParameters,\n} from '../../@types/types';\n\nexport interface ProducerMediaPausedParameters\n  extends PrepopulateUserMediaParameters,\n    ReorderStreamsParameters,\n    ReUpdateInterParameters {\n  activeSounds: string[];\n  meetingDisplayType: string;\n  meetingVideoOptimized: boolean;\n  participants: Participant[];\n  oldSoundIds: string[];\n  shared: boolean;\n  shareScreenStarted: boolean;\n  updateMainWindow: boolean;\n  hostLabel: string;\n  islevel: string;\n  updateActiveSounds: (activeSounds: string[]) => void;\n  updateUpdateMainWindow: (updateMainWindow: boolean) => void;\n\n  // mediasfu functions\n  reorderStreams: ReorderStreamsType;\n  prepopulateUserMedia: PrepopulateUserMediaType;\n  reUpdateInter: ReUpdateInterType;\n\n  getUpdatedAllParams: () => ProducerMediaPausedParameters;\n  [key: string]: any;\n}\n\nexport interface ProducerMediaPausedOptions {\n  producerId: string;\n  kind: 'audio' | 'video' | 'screenshare' | 'screen';\n  name: string;\n  parameters: ProducerMediaPausedParameters;\n}\n\n// Export the type definition for the function\nexport type ProducerMediaPausedType = (options: ProducerMediaPausedOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ProducerMediaPaused {\n  /**\n   * Handles the event when media is paused for a producer.\n   *\n   * @param {ProducerMediaPausedOptions} options - The options for the producer media paused event.\n   * @param {string} options.producerId - The ID of the producer.\n   * @param {string} options.kind - The kind of media (e.g., \"audio\", \"video\").\n   * @param {string} options.name - The name of the producer.\n   * @param {Parameters} options.parameters - The parameters for the event.\n   *\n   * @returns {Promise<void>} A promise that resolves when the media paused handling is complete.\n   *\n   * @description\n   * This function handles the event when media is paused for a producer. It performs the following tasks:\n   * - Updates the parameters.\n   * - Iterates through participants and updates the UI based on their muted status and other conditions.\n   * - Handles meeting display type and optimizes the UI accordingly.\n   * - Manages audio media by updating the relevant participant's state.\n   */\n  producerMediaPaused = async ({\n    producerId,\n    kind,\n    name,\n    parameters,\n  }: ProducerMediaPausedOptions): Promise<void> => {\n    parameters = parameters.getUpdatedAllParams();\n\n    let {\n      activeSounds,\n      meetingDisplayType,\n      meetingVideoOptimized,\n      participants,\n      oldSoundIds,\n      shared,\n      shareScreenStarted,\n      updateMainWindow,\n      hostLabel,\n      islevel,\n      updateActiveSounds,\n      updateUpdateMainWindow,\n      reorderStreams,\n      prepopulateUserMedia,\n      reUpdateInter,\n    } = parameters;\n\n    await Promise.all(\n      participants.map(async (participant: any) => {\n        if (participant.muted) {\n          try {\n            if (\n              participant.islevel == '2' &&\n              !participant.videoID &&\n              !shared &&\n              !shareScreenStarted &&\n              islevel != '2'\n            ) {\n              updateMainWindow = true;\n              updateUpdateMainWindow(updateMainWindow);\n              await prepopulateUserMedia({ name: hostLabel, parameters });\n              updateMainWindow = false;\n              updateUpdateMainWindow(updateMainWindow);\n            }\n          } catch {\n            /* handle error */\n          }\n\n          if (shareScreenStarted || shared) {\n            if (activeSounds.includes(participant.name)) {\n              activeSounds = activeSounds.filter(\n                (audioStream: any) => audioStream != participant.name,\n              );\n              updateActiveSounds(activeSounds);\n            }\n            await reUpdateInter({ name: participant.name, add: false, force: true, parameters });\n          }\n        }\n      }),\n    );\n\n    let checker = false;\n    if (\n      meetingDisplayType == 'media' ||\n      (meetingDisplayType == 'video' && !meetingVideoOptimized)\n    ) {\n      const participant = participants.find((obj: any) => obj.name == name);\n      checker = !!participant?.videoID;\n      if (!checker && !shareScreenStarted && !shared) {\n        await reorderStreams({ add: false, screenChanged: true, parameters });\n      }\n    }\n\n    if (kind == 'audio') {\n      try {\n        const participant =\n          participants.find((obj: any) => obj.audioID == producerId) ||\n          participants.find((obj: any) => obj.name == name);\n        if (\n          participant &&\n          ((participant.name && oldSoundIds.includes(participant.name)) ||\n            (name && oldSoundIds.includes(name)))\n        ) {\n          reUpdateInter({\n            name: participant.name ?? '',\n            add: false,\n            force: true,\n            parameters,\n          });\n        }\n      } catch {\n        /* handle error */\n      }\n    }\n  };\n}\n"]}