mediasfu-angular 1.0.0 → 1.0.2

package/dist/esm2022/lib/methods/message-methods/send-message.service.mjs

@@ -1,5 +1,54 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Sends a message to the specified room.
+ *
+ * This method validates the message and its recipients, checks user permissions,
+ * and then emits the message to the server via a socket connection. It also
+ * handles alerting the user for any errors encountered during the process,
+ * such as exceeding message limits or invalid input.
+ *
+ * @param {SendMessageOptions} options - The options for sending the message.
+ * @param {string} options.member - The member sending the message.
+ * @param {string} options.islevel - The level of the member.
+ * @param {Function} options.showAlert - Function to show alert messages.
+ * @param {Array} options.coHostResponsibility - List of co-host responsibilities.
+ * @param {string} options.coHost - The co-host of the room.
+ * @param {string} options.chatSetting - Chat setting for the room.
+ * @param {string} options.message - The message to be sent.
+ * @param {string} options.roomName - The name of the room.
+ * @param {number} options.messagesLength - The current number of messages in the room.
+ * @param {Array} options.receivers - List of receivers for the message.
+ * @param {boolean} options.group - Indicates if the message is for a group.
+ * @param {string} options.sender - The sender of the message.
+ * @param {Object} options.socket - The socket instance for emitting events.
+ *
+ * @returns {Promise<void>} A promise that resolves when the message is sent.
+ *
+ * @throws Will throw an error if the message count limit is exceeded.
+ * @throws Will throw an error if the message, sender, or receivers are not valid.
+ * @throws Will throw an error if the user is not allowed to send a message in the event room.
+ *
+ * @example
+ * ```typescript
+ * const sendMessageService = new SendMessage();
+ * await sendMessageService.sendMessage({
+ *   member: 'JohnDoe',
+ *   islevel: '1',
+ *   showAlert: (alert) => console.log(alert.message),
+ *   coHostResponsibility: [],
+ *   coHost: 'JaneDoe',
+ *   chatSetting: 'allowed',
+ *   message: 'Hello everyone!',
+ *   roomName: 'Room1',
+ *   messagesLength: 50,
+ *   receivers: ['user1', 'user2'],
+ *   group: true,
+ *   sender: 'JohnDoe',
+ *   socket: socketInstance,
+ * });
+ * ```
+ */
 export class SendMessage {
     /**
      * Sends a message to the specified room.
@@ -91,4 +140,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"send-message.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/methods/message-methods/send-message.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AA0B3C,MAAM,OAAO,WAAW;IACtB;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IAEH,KAAK,CAAC,WAAW,CAAC,EAChB,MAAM,EACN,OAAO,EACP,SAAS,EACT,oBAAoB,EACpB,MAAM,EACN,WAAW,EACX,OAAO,EACP,QAAQ,EACR,cAAc,EACd,SAAS,EACT,KAAK,EACL,MAAM,EACN,MAAM,GACa;QACnB,IAAI,SAAS,GAAG,KAAK,CAAC;QAEtB,mDAAmD;QACnD,IACE,CAAC,cAAc,GAAG,GAAG,IAAI,QAAQ,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;YAClD,CAAC,cAAc,GAAG,GAAG,IAAI,QAAQ,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;YAClD,CAAC,cAAc,GAAG,MAAM,IAAI,QAAQ,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,EACrD,CAAC;YACD,SAAS,EAAE,CAAC;gBACV,OAAO,EAAE,0DAA0D;gBACnE,IAAI,EAAE,QAAQ;gBACd,QAAQ,EAAE,IAAI;aACf,CAAC,CAAC;YACH,OAAO;QACT,CAAC;QAED,0CAA0C;QAC1C,IAAI,CAAC,OAAO,IAAI,CAAC,SAAS,IAAI,CAAC,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;YACnD,SAAS,EAAE,CAAC;gBACV,OAAO,EAAE,uBAAuB;gBAChC,IAAI,EAAE,QAAQ;gBACd,QAAQ,EAAE,IAAI;aACf,CAAC,CAAC;YACH,OAAO;QACT,CAAC;QAED,4BAA4B;QAC5B,MAAM,aAAa,GAAY;YAC7B,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM;YAChC,SAAS,EAAE,SAAS;YACpB,OAAO,EAAE,OAAO;YAChB,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,kBAAkB,EAAE;YAC1C,KAAK,EAAE,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK;SAC7D,CAAC;QAEF,IAAI,CAAC;YACH,wCAAwC;YACxC,SAAS,GAAG,oBAAoB,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,MAAM,CAAC,EAAE,KAAK,IAAI,KAAK,CAAC;QACxF,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QACvB,CAAC;QAED,IAAI,OAAO,KAAK,GAAG,IAAI,CAAC,MAAM,KAAK,MAAM,IAAI,SAAS,KAAK,IAAI,CAAC,EAAE,CAAC;YACjE,wBAAwB;QAC1B,CAAC;aAAM,CAAC;YACN,+DAA+D;YAC/D,IAAI,CAAC,WAAW,EAAE,CAAC;gBACjB,SAAS,EAAE,CAAC;oBACV,OAAO,EAAE,0DAA0D;oBACnE,IAAI,EAAE,QAAQ;oBACd,QAAQ,EAAE,IAAI;iBACf,CAAC,CAAC;gBACH,OAAO;YACT,CAAC;QACH,CAAC;QAED,iCAAiC;QACjC,MAAM,CAAC,IAAI,CAAC,aAAa,EAAE;YACzB,aAAa,EAAE,aAAa;YAC5B,QAAQ,EAAE,QAAQ;SACnB,CAAC,CAAC;IACL,CAAC;uGAtGU,WAAW;2GAAX,WAAW,cAFV,MAAM;;2FAEP,WAAW;kBAHvB,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Socket } from 'socket.io-client';\nimport { CoHostResponsibility, Message, ShowAlert } from '../../@types/types';\n\nexport interface SendMessageOptions {\n  member: string;\n  islevel: string;\n  showAlert?: ShowAlert;\n  coHostResponsibility: CoHostResponsibility[];\n  coHost: string;\n  chatSetting: string;\n  message: string;\n  roomName: string;\n  messagesLength: number;\n  receivers: string[];\n  group: boolean;\n  sender: string;\n  socket: Socket;\n}\n\n// Export the type definition for the function\nexport type SendMessageType = (options: SendMessageOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class SendMessage {\n  /**\n   * Sends a message to the specified room.\n   *\n   * @param {Object} options - The options for sending the message.\n   * @param {string} options.member - The member sending the message.\n   * @param {string} options.islevel - The level of the member.\n   * @param {Function} options.showAlert - Function to show alert messages.\n   * @param {Array} options.coHostResponsibility - List of co-host responsibilities.\n   * @param {string} options.coHost - The co-host of the room.\n   * @param {boolean} options.chatSetting - Chat setting for the room.\n   * @param {string} options.message - The message to be sent.\n   * @param {string} options.roomName - The name of the room.\n   * @param {number} options.messagesLength - The current number of messages in the room.\n   * @param {Array} options.receivers - List of receivers for the message.\n   * @param {boolean} options.group - Indicates if the message is for a group.\n   * @param {string} options.sender - The sender of the message.\n   * @param {Object} options.socket - The socket instance for communication.\n   *\n   * @returns {Promise<void>} A promise that resolves when the message is sent.\n   *\n   * @throws Will throw an error if the message count limit is exceeded.\n   * @throws Will throw an error if the message, sender, or receivers are not valid.\n   * @throws Will throw an error if the user is not allowed to send a message in the event room.\n   */\n\n  async sendMessage({\n    member,\n    islevel,\n    showAlert,\n    coHostResponsibility,\n    coHost,\n    chatSetting,\n    message,\n    roomName,\n    messagesLength,\n    receivers,\n    group,\n    sender,\n    socket,\n  }: SendMessageOptions): Promise<void> {\n    let chatValue = false;\n\n    // Check message count limit based on the room type\n    if (\n      (messagesLength > 100 && roomName.startsWith('d')) ||\n      (messagesLength > 500 && roomName.startsWith('s')) ||\n      (messagesLength > 100000 && roomName.startsWith('p'))\n    ) {\n      showAlert?.({\n        message: 'You have reached the maximum number of messages allowed.',\n        type: 'danger',\n        duration: 3000,\n      });\n      return;\n    }\n\n    // Validate message, sender, and receivers\n    if (!message || !receivers || (!member && !sender)) {\n      showAlert?.({\n        message: 'Message is not valid.',\n        type: 'danger',\n        duration: 3000,\n      });\n      return;\n    }\n\n    // Create the message object\n    const messageObject: Message = {\n      sender: sender ? sender : member,\n      receivers: receivers,\n      message: message,\n      timestamp: new Date().toLocaleTimeString(),\n      group: group !== undefined && group !== null ? group : false,\n    };\n\n    try {\n      // Check co-host responsibility for chat\n      chatValue = coHostResponsibility.find((item) => item.name === 'chat')?.value ?? false;\n    } catch (error) {\n      console.error(error);\n    }\n\n    if (islevel === '2' || (coHost === member && chatValue === true)) {\n      // Allow sending message\n    } else {\n      // Check if user is allowed to send a message in the event room\n      if (!chatSetting) {\n        showAlert?.({\n          message: 'You are not allowed to send a message in this event room',\n          type: 'danger',\n          duration: 3000,\n        });\n        return;\n      }\n    }\n\n    // Send the message to the server\n    socket.emit('sendMessage', {\n      messageObject: messageObject,\n      roomName: roomName,\n    });\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"send-message.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/methods/message-methods/send-message.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAuB3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AAKH,MAAM,OAAO,WAAW;IACtB;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IAEH,KAAK,CAAC,WAAW,CAAC,EAChB,MAAM,EACN,OAAO,EACP,SAAS,EACT,oBAAoB,EACpB,MAAM,EACN,WAAW,EACX,OAAO,EACP,QAAQ,EACR,cAAc,EACd,SAAS,EACT,KAAK,EACL,MAAM,EACN,MAAM,GACa;QACnB,IAAI,SAAS,GAAG,KAAK,CAAC;QAEtB,mDAAmD;QACnD,IACE,CAAC,cAAc,GAAG,GAAG,IAAI,QAAQ,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;YAClD,CAAC,cAAc,GAAG,GAAG,IAAI,QAAQ,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;YAClD,CAAC,cAAc,GAAG,MAAM,IAAI,QAAQ,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,EACrD,CAAC;YACD,SAAS,EAAE,CAAC;gBACV,OAAO,EAAE,0DAA0D;gBACnE,IAAI,EAAE,QAAQ;gBACd,QAAQ,EAAE,IAAI;aACf,CAAC,CAAC;YACH,OAAO;QACT,CAAC;QAED,0CAA0C;QAC1C,IAAI,CAAC,OAAO,IAAI,CAAC,SAAS,IAAI,CAAC,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;YACnD,SAAS,EAAE,CAAC;gBACV,OAAO,EAAE,uBAAuB;gBAChC,IAAI,EAAE,QAAQ;gBACd,QAAQ,EAAE,IAAI;aACf,CAAC,CAAC;YACH,OAAO;QACT,CAAC;QAED,4BAA4B;QAC5B,MAAM,aAAa,GAAY;YAC7B,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM;YAChC,SAAS,EAAE,SAAS;YACpB,OAAO,EAAE,OAAO;YAChB,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,kBAAkB,EAAE;YAC1C,KAAK,EAAE,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK;SAC7D,CAAC;QAEF,IAAI,CAAC;YACH,wCAAwC;YACxC,SAAS,GAAG,oBAAoB,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,MAAM,CAAC,EAAE,KAAK,IAAI,KAAK,CAAC;QACxF,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QACvB,CAAC;QAED,IAAI,OAAO,KAAK,GAAG,IAAI,CAAC,MAAM,KAAK,MAAM,IAAI,SAAS,KAAK,IAAI,CAAC,EAAE,CAAC;YACjE,wBAAwB;QAC1B,CAAC;aAAM,CAAC;YACN,+DAA+D;YAC/D,IAAI,CAAC,WAAW,EAAE,CAAC;gBACjB,SAAS,EAAE,CAAC;oBACV,OAAO,EAAE,0DAA0D;oBACnE,IAAI,EAAE,QAAQ;oBACd,QAAQ,EAAE,IAAI;iBACf,CAAC,CAAC;gBACH,OAAO;YACT,CAAC;QACH,CAAC;QAED,iCAAiC;QACjC,MAAM,CAAC,IAAI,CAAC,aAAa,EAAE;YACzB,aAAa,EAAE,aAAa;YAC5B,QAAQ,EAAE,QAAQ;SACnB,CAAC,CAAC;IACL,CAAC;uGAtGU,WAAW;2GAAX,WAAW,cAFV,MAAM;;2FAEP,WAAW;kBAHvB,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Socket } from 'socket.io-client';\nimport { CoHostResponsibility, Message, ShowAlert } from '../../@types/types';\n\nexport interface SendMessageOptions {\n  member: string;\n  islevel: string;\n  showAlert?: ShowAlert;\n  coHostResponsibility: CoHostResponsibility[];\n  coHost: string;\n  chatSetting: string;\n  message: string;\n  roomName: string;\n  messagesLength: number;\n  receivers: string[];\n  group: boolean;\n  sender: string;\n  socket: Socket;\n}\n\n// Export the type definition for the function\nexport type SendMessageType = (options: SendMessageOptions) => Promise<void>;\n\n/**\n * Sends a message to the specified room.\n *\n * This method validates the message and its recipients, checks user permissions,\n * and then emits the message to the server via a socket connection. It also\n * handles alerting the user for any errors encountered during the process,\n * such as exceeding message limits or invalid input.\n *\n * @param {SendMessageOptions} options - The options for sending the message.\n * @param {string} options.member - The member sending the message.\n * @param {string} options.islevel - The level of the member.\n * @param {Function} options.showAlert - Function to show alert messages.\n * @param {Array} options.coHostResponsibility - List of co-host responsibilities.\n * @param {string} options.coHost - The co-host of the room.\n * @param {string} options.chatSetting - Chat setting for the room.\n * @param {string} options.message - The message to be sent.\n * @param {string} options.roomName - The name of the room.\n * @param {number} options.messagesLength - The current number of messages in the room.\n * @param {Array} options.receivers - List of receivers for the message.\n * @param {boolean} options.group - Indicates if the message is for a group.\n * @param {string} options.sender - The sender of the message.\n * @param {Object} options.socket - The socket instance for emitting events.\n *\n * @returns {Promise<void>} A promise that resolves when the message is sent.\n *\n * @throws Will throw an error if the message count limit is exceeded.\n * @throws Will throw an error if the message, sender, or receivers are not valid.\n * @throws Will throw an error if the user is not allowed to send a message in the event room.\n *\n * @example\n * ```typescript\n * const sendMessageService = new SendMessage();\n * await sendMessageService.sendMessage({\n *   member: 'JohnDoe',\n *   islevel: '1',\n *   showAlert: (alert) => console.log(alert.message),\n *   coHostResponsibility: [],\n *   coHost: 'JaneDoe',\n *   chatSetting: 'allowed',\n *   message: 'Hello everyone!',\n *   roomName: 'Room1',\n *   messagesLength: 50,\n *   receivers: ['user1', 'user2'],\n *   group: true,\n *   sender: 'JohnDoe',\n *   socket: socketInstance,\n * });\n * ```\n */\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class SendMessage {\n  /**\n   * Sends a message to the specified room.\n   *\n   * @param {Object} options - The options for sending the message.\n   * @param {string} options.member - The member sending the message.\n   * @param {string} options.islevel - The level of the member.\n   * @param {Function} options.showAlert - Function to show alert messages.\n   * @param {Array} options.coHostResponsibility - List of co-host responsibilities.\n   * @param {string} options.coHost - The co-host of the room.\n   * @param {boolean} options.chatSetting - Chat setting for the room.\n   * @param {string} options.message - The message to be sent.\n   * @param {string} options.roomName - The name of the room.\n   * @param {number} options.messagesLength - The current number of messages in the room.\n   * @param {Array} options.receivers - List of receivers for the message.\n   * @param {boolean} options.group - Indicates if the message is for a group.\n   * @param {string} options.sender - The sender of the message.\n   * @param {Object} options.socket - The socket instance for communication.\n   *\n   * @returns {Promise<void>} A promise that resolves when the message is sent.\n   *\n   * @throws Will throw an error if the message count limit is exceeded.\n   * @throws Will throw an error if the message, sender, or receivers are not valid.\n   * @throws Will throw an error if the user is not allowed to send a message in the event room.\n   */\n\n  async sendMessage({\n    member,\n    islevel,\n    showAlert,\n    coHostResponsibility,\n    coHost,\n    chatSetting,\n    message,\n    roomName,\n    messagesLength,\n    receivers,\n    group,\n    sender,\n    socket,\n  }: SendMessageOptions): Promise<void> {\n    let chatValue = false;\n\n    // Check message count limit based on the room type\n    if (\n      (messagesLength > 100 && roomName.startsWith('d')) ||\n      (messagesLength > 500 && roomName.startsWith('s')) ||\n      (messagesLength > 100000 && roomName.startsWith('p'))\n    ) {\n      showAlert?.({\n        message: 'You have reached the maximum number of messages allowed.',\n        type: 'danger',\n        duration: 3000,\n      });\n      return;\n    }\n\n    // Validate message, sender, and receivers\n    if (!message || !receivers || (!member && !sender)) {\n      showAlert?.({\n        message: 'Message is not valid.',\n        type: 'danger',\n        duration: 3000,\n      });\n      return;\n    }\n\n    // Create the message object\n    const messageObject: Message = {\n      sender: sender ? sender : member,\n      receivers: receivers,\n      message: message,\n      timestamp: new Date().toLocaleTimeString(),\n      group: group !== undefined && group !== null ? group : false,\n    };\n\n    try {\n      // Check co-host responsibility for chat\n      chatValue = coHostResponsibility.find((item) => item.name === 'chat')?.value ?? false;\n    } catch (error) {\n      console.error(error);\n    }\n\n    if (islevel === '2' || (coHost === member && chatValue === true)) {\n      // Allow sending message\n    } else {\n      // Check if user is allowed to send a message in the event room\n      if (!chatSetting) {\n        showAlert?.({\n          message: 'You are not allowed to send a message in this event room',\n          type: 'danger',\n          duration: 3000,\n        });\n        return;\n      }\n    }\n\n    // Send the message to the server\n    socket.emit('sendMessage', {\n      messageObject: messageObject,\n      roomName: roomName,\n    });\n  }\n}\n"]}

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

@@ -1,5 +1,29 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Toggles the visibility of the participants modal.
+ *
+ * This method checks the current visibility state of the participants modal
+ * and updates it accordingly. If the modal is currently visible, it will be hidden.
+ * If it is hidden, it will be displayed.
+ *
+ * @param {LaunchParticipantsOptions} options - The options for toggling the participants modal.
+ * @param {Function} options.updateIsParticipantsModalVisible - Function to update the visibility state of the participants modal.
+ * @param {boolean} options.isParticipantsModalVisible - Current visibility state of the participants modal.
+ *
+ * @returns {void}
+ *
+ * @example
+ * ```typescript
+ * const launchParticipantsService = new LaunchParticipants();
+ * launchParticipantsService.launchParticipants({
+ *   updateIsParticipantsModalVisible: (isVisible) => {
+ *     console.log(`Participants modal is now ${isVisible ? 'visible' : 'hidden'}`);
+ *   },
+ *   isParticipantsModalVisible: false,
+ * });
+ * ```
+ */
 export class LaunchParticipants {
     /**
      * Toggles the visibility of the participants modal.
@@ -20,4 +44,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,5 +1,51 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Sends a direct message to a participant if certain conditions are met.
+ *
+ * This method checks the current user's level and their co-host responsibilities
+ * to determine if they are allowed to send a direct message to a specified participant.
+ * If the user has the appropriate permissions, the method updates the direct message
+ * details and opens the messages modal. If the user is not allowed to send the message,
+ * an alert is displayed.
+ *
+ * @param {MessageParticipantsOptions} options - The options for sending a message to a participant.
+ * @param {CoHostResponsibility[]} options.coHostResponsibility - Array of responsibilities assigned to the co-host.
+ * @param {Participant} options.participant - The participant to whom the message is to be sent.
+ * @param {string} options.member - The current member attempting to send the message.
+ * @param {string} options.islevel - The level of the current member.
+ * @param {Function} [options.showAlert] - Function to show an alert message if the message cannot be sent.
+ * @param {string} options.coHost - The co-host member.
+ * @param {Function} options.updateIsMessagesModalVisible - Function to update the visibility of the messages modal.
+ * @param {Function} options.updateDirectMessageDetails - Function to update the details of the direct message.
+ * @param {Function} options.updateStartDirectMessage - Function to start the direct message.
+ *
+ * @returns {void}
+ *
+ * @example
+ * ```typescript
+ * const messageService = new MessageParticipants();
+ * messageService.messageParticipants({
+ *   coHostResponsibility: [{ name: 'chat', value: true }],
+ *   participant: { name: 'John', islevel: '1' },
+ *   member: 'Alice',
+ *   islevel: '1',
+ *   showAlert: ({ message, type, duration }) => {
+ *     console.log(`Alert: ${message} - Type: ${type} - Duration: ${duration}`);
+ *   },
+ *   coHost: 'Bob',
+ *   updateIsMessagesModalVisible: (isVisible) => {
+ *     console.log(`Messages modal is now ${isVisible ? 'visible' : 'hidden'}`);
+ *   },
+ *   updateDirectMessageDetails: (participant) => {
+ *     console.log(`Direct messaging: ${participant.name}`);
+ *   },
+ *   updateStartDirectMessage: (start) => {
+ *     console.log(`Direct messaging started: ${start}`);
+ *   },
+ * });
+ * ```
+ */
 export class MessageParticipants {
     /**
      * Sends a direct message to a participant if certain conditions are met.
@@ -49,4 +95,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"message-participants.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/methods/participants-methods/message-participants.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAiB3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAMH,MAAM,OAAO,mBAAmB;IAC9B;;;;;;;;;;;;;;OAcG;IACH,mBAAmB,CAAC,EAClB,oBAAoB,EACpB,WAAW,EACX,MAAM,EACN,OAAO,EACP,SAAS,EACT,MAAM,EACN,4BAA4B,EAC5B,0BAA0B,EAC1B,wBAAwB,GACG;QAC3B,IAAI,SAAS,GAAG,KAAK,CAAC;QAEtB,IAAI,CAAC;YACH,SAAS,GAAG,oBAAoB,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,MAAM,CAAC,EAAE,KAAK,IAAI,KAAK,CAAC;QACxF,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QACvB,CAAC;QAED,IAAI,OAAO,KAAK,GAAG,IAAI,CAAC,MAAM,KAAK,MAAM,IAAI,SAAS,KAAK,IAAI,CAAC,EAAE,CAAC;YACjE,IAAI,WAAW,CAAC,OAAO,KAAK,GAAG,EAAE,CAAC;gBAChC,0BAA0B,CAAC,WAAW,CAAC,CAAC;gBACxC,wBAAwB,CAAC,IAAI,CAAC,CAAC;gBAC/B,4BAA4B,CAAC,IAAI,CAAC,CAAC;YACrC,CAAC;QACH,CAAC;aAAM,CAAC;YACN,SAAS,EAAE,CAAC;gBACV,OAAO,EAAE,0CAA0C;gBACnD,IAAI,EAAE,QAAQ;gBACd,QAAQ,EAAE,IAAI;aACf,CAAC,CAAC;YAEH,OAAO;QACT,CAAC;IACH,CAAC;uGAlDU,mBAAmB;2GAAnB,mBAAmB,cAFlB,MAAM;;2FAEP,mBAAmB;kBAH/B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Participant, CoHostResponsibility, ShowAlert } from '../../@types/types';\nexport interface MessageParticipantsOptions {\n  coHostResponsibility: CoHostResponsibility[];\n  participant: Participant;\n  member: string;\n  islevel: string;\n  showAlert?: ShowAlert;\n  coHost: string;\n  updateIsMessagesModalVisible: (isVisible: boolean) => void;\n  updateDirectMessageDetails: (participant: Participant | null) => void;\n  updateStartDirectMessage: (start: boolean) => void;\n}\n\n// Export the type definition for the function\nexport type MessageParticipantsType = (options: MessageParticipantsOptions) => void;\n\n/**\n * Sends a direct message to a participant if certain conditions are met.\n *\n * This method checks the current user's level and their co-host responsibilities\n * to determine if they are allowed to send a direct message to a specified participant.\n * If the user has the appropriate permissions, the method updates the direct message\n * details and opens the messages modal. If the user is not allowed to send the message,\n * an alert is displayed.\n *\n * @param {MessageParticipantsOptions} options - The options for sending a message to a participant.\n * @param {CoHostResponsibility[]} options.coHostResponsibility - Array of responsibilities assigned to the co-host.\n * @param {Participant} options.participant - The participant to whom the message is to be sent.\n * @param {string} options.member - The current member attempting to send the message.\n * @param {string} options.islevel - The level of the current member.\n * @param {Function} [options.showAlert] - Function to show an alert message if the message cannot be sent.\n * @param {string} options.coHost - The co-host member.\n * @param {Function} options.updateIsMessagesModalVisible - Function to update the visibility of the messages modal.\n * @param {Function} options.updateDirectMessageDetails - Function to update the details of the direct message.\n * @param {Function} options.updateStartDirectMessage - Function to start the direct message.\n *\n * @returns {void}\n *\n * @example\n * ```typescript\n * const messageService = new MessageParticipants();\n * messageService.messageParticipants({\n *   coHostResponsibility: [{ name: 'chat', value: true }],\n *   participant: { name: 'John', islevel: '1' },\n *   member: 'Alice',\n *   islevel: '1',\n *   showAlert: ({ message, type, duration }) => {\n *     console.log(`Alert: ${message} - Type: ${type} - Duration: ${duration}`);\n *   },\n *   coHost: 'Bob',\n *   updateIsMessagesModalVisible: (isVisible) => {\n *     console.log(`Messages modal is now ${isVisible ? 'visible' : 'hidden'}`);\n *   },\n *   updateDirectMessageDetails: (participant) => {\n *     console.log(`Direct messaging: ${participant.name}`);\n *   },\n *   updateStartDirectMessage: (start) => {\n *     console.log(`Direct messaging started: ${start}`);\n *   },\n * });\n * ```\n */\n\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class MessageParticipants {\n  /**\n   * Sends a direct message to a participant if certain conditions are met.\n   *s\n   * @param coHostResponsibility - Array of responsibilities assigned to the co-host.\n   * @param participant - The participant to whom the message is to be sent.\n   * @param member - The current member attempting to send the message.\n   * @param islevel - The level of the current member.\n   * @param showAlert - Function to show an alert message.\n   * @param coHost - The co-host member.\n   * @param updateIsMessagesModalVisible - Function to update the visibility of the messages modal.\n   * @param updateDirectMessageDetails - Function to update the details of the direct message.\n   * @param updateStartDirectMessage - Function to start the direct message.\n   *\n   * @returns void\n   */\n  messageParticipants({\n    coHostResponsibility,\n    participant,\n    member,\n    islevel,\n    showAlert,\n    coHost,\n    updateIsMessagesModalVisible,\n    updateDirectMessageDetails,\n    updateStartDirectMessage,\n  }: MessageParticipantsOptions): void {\n    let chatValue = false;\n\n    try {\n      chatValue = coHostResponsibility.find((item) => item.name === 'chat')?.value ?? false;\n    } catch (error) {\n      console.error(error);\n    }\n\n    if (islevel === '2' || (coHost === member && chatValue === true)) {\n      if (participant.islevel !== '2') {\n        updateDirectMessageDetails(participant);\n        updateStartDirectMessage(true);\n        updateIsMessagesModalVisible(true);\n      }\n    } else {\n      showAlert?.({\n        message: 'You are not allowed to send this message',\n        type: 'danger',\n        duration: 3000,\n      });\n\n      return;\n    }\n  }\n}\n"]}

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

@@ -1,5 +1,44 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Mutes a participant in a media session if certain conditions are met.
+ *
+ * This method checks the current user's level and their co-host responsibilities
+ * to determine if they are allowed to mute a specified participant. If allowed,
+ * the method emits a socket event to mute the participant. If not allowed, an alert
+ * is displayed.
+ *
+ * @param {MuteParticipantsOptions} options - The options for muting participants.
+ * @param {Socket} options.socket - The socket instance for communication.
+ * @param {CoHostResponsibility[]} options.coHostResponsibility - List of co-host responsibilities.
+ * @param {Participant} options.participant - The participant to be muted.
+ * @param {string} options.member - The current member attempting to mute.
+ * @param {string} options.islevel - The level of the current member.
+ * @param {Function} [options.showAlert] - Optional function to show alerts.
+ * @param {string} options.coHost - The co-host information.
+ * @param {string} options.roomName - The name of the room.
+ *
+ * @returns {Promise<void>} A promise that resolves when the participant is muted.
+ *
+ * @throws Will log an error if there is an issue accessing co-host responsibilities.
+ *
+ * @example
+ * ```typescript
+ * const muteService = new MuteParticipants();
+ * muteService.muteParticipants({
+ *   socket: socketInstance,
+ *   coHostResponsibility: [{ name: 'media', value: true }],
+ *   participant: { id: '123', name: 'John', islevel: '1', muted: false },
+ *   member: 'Alice',
+ *   islevel: '1',
+ *   showAlert: ({ message, type }) => {
+ *     console.log(`Alert: ${message} - Type: ${type}`);
+ *   },
+ *   coHost: 'Bob',
+ *   roomName: 'room1',
+ * });
+ * ```
+ */
 export class MuteParticipants {
     /**
      * Mutes a participant in a media session if certain conditions are met.
@@ -54,4 +93,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,5 +1,50 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Removes a participant from the room if the user has the appropriate permissions.
+ *
+ * This method checks the current user's level and their co-host responsibilities
+ * to determine if they are allowed to remove a specified participant. If allowed,
+ * the method emits a socket event to disconnect the participant and updates
+ * the local list of participants. If not allowed, an alert is displayed.
+ *
+ * @param {RemoveParticipantsOptions} options - The options for removing a participant.
+ * @param {CoHostResponsibility[]} options.coHostResponsibility - The responsibilities of the co-host.
+ * @param {Participant} options.participant - The participant to be removed.
+ * @param {string} options.member - The current member attempting to remove the participant.
+ * @param {string} options.islevel - The level of the current member.
+ * @param {Function} [options.showAlert] - Optional function to show alert messages.
+ * @param {string} options.coHost - The co-host information.
+ * @param {Participant[]} options.participants - The list of current participants.
+ * @param {Socket} 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.
+ *
+ * @throws Will log an error if there is an issue accessing co-host responsibilities.
+ *
+ * @example
+ * ```typescript
+ * const removeParticipantsService = new RemoveParticipants();
+ * await removeParticipantsService.removeParticipants({
+ *   coHostResponsibility: [{ name: 'participants', value: true }],
+ *   participant: { id: '123', name: 'John', islevel: '1' },
+ *   member: 'Alice',
+ *   islevel: '1',
+ *   showAlert: ({ message, type }) => {
+ *     console.log(`Alert: ${message} - Type: ${type}`);
+ *   },
+ *   coHost: 'Bob',
+ *   participants: [{ id: '123', name: 'John', islevel: '1' }],
+ *   socket: socketInstance,
+ *   roomName: 'room1',
+ *   updateParticipants: (updatedList) => {
+ *     console.log('Updated participants:', updatedList);
+ *   },
+ * });
+ * ```
+ */
 export class RemoveParticipants {
     /**
      * Removes a participant from the room if the user has the appropriate permissions.
@@ -59,4 +104,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVtb3ZlLXBhcnRpY2lwYW50cy5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbWVkaWFzZnUtYW5ndWxhci9zcmMvbGliL21ldGhvZHMvcGFydGljaXBhbnRzLW1ldGhvZHMvcmVtb3ZlLXBhcnRpY2lwYW50cy5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBdUIzQyxNQUFNLE9BQU8sa0JBQWtCO0lBQzdCOzs7Ozs7Ozs7Ozs7Ozs7O09BZ0JHO0lBRUgsS0FBSyxDQUFDLGtCQUFrQixDQUFDLEVBQ3ZCLG9CQUFvQixFQUNwQixXQUFXLEVBQ1gsTUFBTSxFQUNOLE9BQU8sRUFDUCxTQUFTLEVBQ1QsTUFBTSxFQUNOLFlBQVksRUFDWixNQUFNLEVBQ04sUUFBUSxFQUNSLGtCQUFrQixHQUNRO1FBQzFCLElBQUksaUJBQWlCLEdBQUcsS0FBSyxDQUFDO1FBRTlCLElBQUksQ0FBQztZQUNILGlCQUFpQjtnQkFDZixvQkFBb0IsQ0FBQyxJQUFJLENBQUMsQ0FBQyxJQUFJLEVBQUUsRUFBRSxDQUFDLElBQUksQ0FBQyxJQUFJLEtBQUssY0FBYyxDQUFDLEVBQUUsS0FBSyxJQUFJLEtBQUssQ0FBQztRQUN0RixDQUFDO1FBQUMsT0FBTyxLQUFLLEVBQUUsQ0FBQztZQUNmLGlCQUFpQixHQUFHLEtBQUssQ0FBQztRQUM1QixDQUFDO1FBRUQsSUFBSSxPQUFPLEtBQUssR0FBRyxJQUFJLENBQUMsTUFBTSxLQUFLLE1BQU0sSUFBSSxpQkFBaUIsS0FBSyxJQUFJLENBQUMsRUFBRSxDQUFDO1lBQ3pFLElBQUksV0FBVyxDQUFDLE9BQU8sS0FBSyxHQUFHLEVBQUUsQ0FBQztnQkFDaEMsTUFBTSxhQUFhLEdBQUcsV0FBVyxDQUFDLEVBQUUsQ0FBQztnQkFFckMsNkNBQTZDO2dCQUM3QyxNQUFNLENBQUMsSUFBSSxDQUFDLHdCQUF3QixFQUFFO29CQUNwQyxNQUFNLEVBQUUsV0FBVyxDQUFDLElBQUk7b0JBQ3hCLFFBQVE7b0JBQ1IsRUFBRSxFQUFFLGFBQWE7aUJBQ2xCLENBQUMsQ0FBQztnQkFFSCw4Q0FBOEM7Z0JBQzlDLFlBQVksQ0FBQyxNQUFNLENBQ2pCLFlBQVksQ0FBQyxTQUFTLENBQUMsQ0FBQyxHQUFRLEVBQUUsRUFBRSxDQUFDLEdBQUcsQ0FBQyxJQUFJLEtBQUssV0FBVyxDQUFDLElBQUksQ0FBQyxFQUNuRSxDQUFDLENBQ0YsQ0FBQztnQkFFRixnQ0FBZ0M7Z0JBQ2hDLGtCQUFrQixDQUFDLFlBQVksQ0FBQyxDQUFDO1lBQ25DLENBQUM7UUFDSCxDQUFDO2FBQU0sQ0FBQztZQUNOLFNBQVMsRUFBRSxDQUFDO2dCQUNWLE9BQU8sRUFBRSxrREFBa0Q7Z0JBQzNELElBQUksRUFBRSxRQUFRO2dCQUNkLFFBQVEsRUFBRSxJQUFJO2FBQ2YsQ0FBQyxDQUFDO1FBQ0wsQ0FBQztJQUNILENBQUM7dUdBbkVVLGtCQUFrQjsyR0FBbEIsa0JBQWtCLGNBRmpCLE1BQU07OzJGQUVQLGtCQUFrQjtrQkFIOUIsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBTb2NrZXQgfSBmcm9tICdzb2NrZXQuaW8tY2xpZW50JztcbmltcG9ydCB7IENvSG9zdFJlc3BvbnNpYmlsaXR5LCBQYXJ0aWNpcGFudCwgU2hvd0FsZXJ0IH0gZnJvbSAnLi4vLi4vQHR5cGVzL3R5cGVzJztcblxuZXhwb3J0IGludGVyZmFjZSBSZW1vdmVQYXJ0aWNpcGFudHNPcHRpb25zIHtcbiAgY29Ib3N0UmVzcG9uc2liaWxpdHk6IENvSG9zdFJlc3BvbnNpYmlsaXR5W107XG4gIHBhcnRpY2lwYW50OiBQYXJ0aWNpcGFudDtcbiAgbWVtYmVyOiBzdHJpbmc7XG4gIGlzbGV2ZWw6IHN0cmluZztcbiAgc2hvd0FsZXJ0PzogU2hvd0FsZXJ0O1xuICBjb0hvc3Q6IHN0cmluZztcbiAgcGFydGljaXBhbnRzOiBQYXJ0aWNpcGFudFtdO1xuICBzb2NrZXQ6IFNvY2tldDtcbiAgcm9vbU5hbWU6IHN0cmluZztcbiAgdXBkYXRlUGFydGljaXBhbnRzOiAocGFydGljaXBhbnRzOiBQYXJ0aWNpcGFudFtdKSA9PiB2b2lkO1xufVxuXG4vLyBFeHBvcnQgdGhlIHR5cGUgZGVmaW5pdGlvbiBmb3IgdGhlIGZ1bmN0aW9uXG5leHBvcnQgdHlwZSBSZW1vdmVQYXJ0aWNpcGFudHNUeXBlID0gKG9wdGlvbnM6IFJlbW92ZVBhcnRpY2lwYW50c09wdGlvbnMpID0+IFByb21pc2U8dm9pZD47XG5cbkBJbmplY3RhYmxlKHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnLFxufSlcbmV4cG9ydCBjbGFzcyBSZW1vdmVQYXJ0aWNpcGFudHMge1xuICAvKipcbiAgICogUmVtb3ZlcyBhIHBhcnRpY2lwYW50IGZyb20gdGhlIHJvb20gaWYgdGhlIHVzZXIgaGFzIHRoZSBhcHByb3ByaWF0ZSBwZXJtaXNzaW9ucy5cbiAgICpcbiAgICogQHBhcmFtIHtSZW1vdmVQYXJ0aWNpcGFudHNPcHRpb25zfSBvcHRpb25zIC0gVGhlIG9wdGlvbnMgZm9yIHJlbW92aW5nIGEgcGFydGljaXBhbnQuXG4gICAqIEBwYXJhbSB7QXJyYXl9IG9wdGlvbnMuY29Ib3N0UmVzcG9uc2liaWxpdHkgLSBUaGUgcmVzcG9uc2liaWxpdGllcyBvZiB0aGUgY28taG9zdC5cbiAgICogQHBhcmFtIHtPYmplY3R9IG9wdGlvbnMucGFydGljaXBhbnQgLSBUaGUgcGFydGljaXBhbnQgdG8gYmUgcmVtb3ZlZC5cbiAgICogQHBhcmFtIHtPYmplY3R9IG9wdGlvbnMubWVtYmVyIC0gVGhlIGN1cnJlbnQgbWVtYmVyIGF0dGVtcHRpbmcgdG8gcmVtb3ZlIHRoZSBwYXJ0aWNpcGFudC5cbiAgICogQHBhcmFtIHtzdHJpbmd9IG9wdGlvbnMuaXNsZXZlbCAtIFRoZSBsZXZlbCBvZiB0aGUgY3VycmVudCBtZW1iZXIuXG4gICAqIEBwYXJhbSB7RnVuY3Rpb259IFtvcHRpb25zLnNob3dBbGVydF0gLSBGdW5jdGlvbiB0byBzaG93IGFuIGFsZXJ0IG1lc3NhZ2UuXG4gICAqIEBwYXJhbSB7T2JqZWN0fSBvcHRpb25zLmNvSG9zdCAtIFRoZSBjby1ob3N0IGluZm9ybWF0aW9uLlxuICAgKiBAcGFyYW0ge0FycmF5fSBvcHRpb25zLnBhcnRpY2lwYW50cyAtIFRoZSBsaXN0IG9mIGN1cnJlbnQgcGFydGljaXBhbnRzLlxuICAgKiBAcGFyYW0ge09iamVjdH0gb3B0aW9ucy5zb2NrZXQgLSBUaGUgc29ja2V0IGluc3RhbmNlIGZvciBlbWl0dGluZyBldmVudHMuXG4gICAqIEBwYXJhbSB7c3RyaW5nfSBvcHRpb25zLnJvb21OYW1lIC0gVGhlIG5hbWUgb2YgdGhlIHJvb20uXG4gICAqIEBwYXJhbSB7RnVuY3Rpb259IG9wdGlvbnMudXBkYXRlUGFydGljaXBhbnRzIC0gRnVuY3Rpb24gdG8gdXBkYXRlIHRoZSBwYXJ0aWNpcGFudHMgbGlzdC5cbiAgICpcbiAgICogQHJldHVybnMge1Byb21pc2U8dm9pZD59IC0gQSBwcm9taXNlIHRoYXQgcmVzb2x2ZXMgd2hlbiB0aGUgcGFydGljaXBhbnQgaXMgcmVtb3ZlZC5cbiAgICovXG5cbiAgYXN5bmMgcmVtb3ZlUGFydGljaXBhbnRzKHtcbiAgICBjb0hvc3RSZXNwb25zaWJpbGl0eSxcbiAgICBwYXJ0aWNpcGFudCxcbiAgICBtZW1iZXIsXG4gICAgaXNsZXZlbCxcbiAgICBzaG93QWxlcnQsXG4gICAgY29Ib3N0LFxuICAgIHBhcnRpY2lwYW50cyxcbiAgICBzb2NrZXQsXG4gICAgcm9vbU5hbWUsXG4gICAgdXBkYXRlUGFydGljaXBhbnRzLFxuICB9OiBSZW1vdmVQYXJ0aWNpcGFudHNPcHRpb25zKTogUHJvbWlzZTx2b2lkPiB7XG4gICAgbGV0IHBhcnRpY2lwYW50c1ZhbHVlID0gZmFsc2U7XG5cbiAgICB0cnkge1xuICAgICAgcGFydGljaXBhbnRzVmFsdWUgPVxuICAgICAgICBjb0hvc3RSZXNwb25zaWJpbGl0eS5maW5kKChpdGVtKSA9PiBpdGVtLm5hbWUgPT09ICdwYXJ0aWNpcGFudHMnKT8udmFsdWUgPz8gZmFsc2U7XG4gICAgfSBjYXRjaCAoZXJyb3IpIHtcbiAgICAgIHBhcnRpY2lwYW50c1ZhbHVlID0gZmFsc2U7XG4gICAgfVxuXG4gICAgaWYgKGlzbGV2ZWwgPT09ICcyJyB8fCAoY29Ib3N0ID09PSBtZW1iZXIgJiYgcGFydGljaXBhbnRzVmFsdWUgPT09IHRydWUpKSB7XG4gICAgICBpZiAocGFydGljaXBhbnQuaXNsZXZlbCAhPT0gJzInKSB7XG4gICAgICAgIGNvbnN0IHBhcnRpY2lwYW50SWQgPSBwYXJ0aWNpcGFudC5pZDtcblxuICAgICAgICAvLyBFbWl0IGEgc29ja2V0IGV2ZW50IHRvIGRpc2Nvbm5lY3QgdGhlIHVzZXJcbiAgICAgICAgc29ja2V0LmVtaXQoJ2Rpc2Nvbm5lY3RVc2VySW5pdGlhdGUnLCB7XG4gICAgICAgICAgbWVtYmVyOiBwYXJ0aWNpcGFudC5uYW1lLFxuICAgICAgICAgIHJvb21OYW1lLFxuICAgICAgICAgIGlkOiBwYXJ0aWNpcGFudElkLFxuICAgICAgICB9KTtcblxuICAgICAgICAvLyBSZW1vdmUgdGhlIHBhcnRpY2lwYW50IGZyb20gdGhlIGxvY2FsIGFycmF5XG4gICAgICAgIHBhcnRpY2lwYW50cy5zcGxpY2UoXG4gICAgICAgICAgcGFydGljaXBhbnRzLmZpbmRJbmRleCgob2JqOiBhbnkpID0+IG9iai5uYW1lID09PSBwYXJ0aWNpcGFudC5uYW1lKSxcbiAgICAgICAgICAxLFxuICAgICAgICApO1xuXG4gICAgICAgIC8vIFVwZGF0ZSB0aGUgcGFydGljaXBhbnRzIGFycmF5XG4gICAgICAgIHVwZGF0ZVBhcnRpY2lwYW50cyhwYXJ0aWNpcGFudHMpO1xuICAgICAgfVxuICAgIH0gZWxzZSB7XG4gICAgICBzaG93QWxlcnQ/Lih7XG4gICAgICAgIG1lc3NhZ2U6ICdZb3UgYXJlIG5vdCBhbGxvd2VkIHRvIHJlbW92ZSBvdGhlciBwYXJ0aWNpcGFudHMnLFxuICAgICAgICB0eXBlOiAnZGFuZ2VyJyxcbiAgICAgICAgZHVyYXRpb246IDMwMDAsXG4gICAgICB9KTtcbiAgICB9XG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"remove-participants.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/methods/participants-methods/remove-participants.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAoB3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAMH,MAAM,OAAO,kBAAkB;IAC7B;;;;;;;;;;;;;;;;OAgBG;IAEH,KAAK,CAAC,kBAAkB,CAAC,EACvB,oBAAoB,EACpB,WAAW,EACX,MAAM,EACN,OAAO,EACP,SAAS,EACT,MAAM,EACN,YAAY,EACZ,MAAM,EACN,QAAQ,EACR,kBAAkB,GACQ;QAC1B,IAAI,iBAAiB,GAAG,KAAK,CAAC;QAE9B,IAAI,CAAC;YACH,iBAAiB;gBACf,oBAAoB,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,cAAc,CAAC,EAAE,KAAK,IAAI,KAAK,CAAC;QACtF,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,iBAAiB,GAAG,KAAK,CAAC;QAC5B,CAAC;QAED,IAAI,OAAO,KAAK,GAAG,IAAI,CAAC,MAAM,KAAK,MAAM,IAAI,iBAAiB,KAAK,IAAI,CAAC,EAAE,CAAC;YACzE,IAAI,WAAW,CAAC,OAAO,KAAK,GAAG,EAAE,CAAC;gBAChC,MAAM,aAAa,GAAG,WAAW,CAAC,EAAE,CAAC;gBAErC,6CAA6C;gBAC7C,MAAM,CAAC,IAAI,CAAC,wBAAwB,EAAE;oBACpC,MAAM,EAAE,WAAW,CAAC,IAAI;oBACxB,QAAQ;oBACR,EAAE,EAAE,aAAa;iBAClB,CAAC,CAAC;gBAEH,8CAA8C;gBAC9C,YAAY,CAAC,MAAM,CACjB,YAAY,CAAC,SAAS,CAAC,CAAC,GAAQ,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,KAAK,WAAW,CAAC,IAAI,CAAC,EACnE,CAAC,CACF,CAAC;gBAEF,gCAAgC;gBAChC,kBAAkB,CAAC,YAAY,CAAC,CAAC;YACnC,CAAC;QACH,CAAC;aAAM,CAAC;YACN,SAAS,EAAE,CAAC;gBACV,OAAO,EAAE,kDAAkD;gBAC3D,IAAI,EAAE,QAAQ;gBACd,QAAQ,EAAE,IAAI;aACf,CAAC,CAAC;QACL,CAAC;IACH,CAAC;uGAnEU,kBAAkB;2GAAlB,kBAAkB,cAFjB,MAAM;;2FAEP,kBAAkB;kBAH9B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Socket } from 'socket.io-client';\nimport { CoHostResponsibility, Participant, ShowAlert } from '../../@types/types';\n\nexport interface RemoveParticipantsOptions {\n  coHostResponsibility: CoHostResponsibility[];\n  participant: Participant;\n  member: string;\n  islevel: string;\n  showAlert?: ShowAlert;\n  coHost: string;\n  participants: Participant[];\n  socket: Socket;\n  roomName: string;\n  updateParticipants: (participants: Participant[]) => void;\n}\n\n// Export the type definition for the function\nexport type RemoveParticipantsType = (options: RemoveParticipantsOptions) => Promise<void>;\n\n/**\n * Removes a participant from the room if the user has the appropriate permissions.\n *\n * This method checks the current user's level and their co-host responsibilities\n * to determine if they are allowed to remove a specified participant. If allowed,\n * the method emits a socket event to disconnect the participant and updates\n * the local list of participants. If not allowed, an alert is displayed.\n *\n * @param {RemoveParticipantsOptions} options - The options for removing a participant.\n * @param {CoHostResponsibility[]} options.coHostResponsibility - The responsibilities of the co-host.\n * @param {Participant} options.participant - The participant to be removed.\n * @param {string} options.member - The current member attempting to remove the participant.\n * @param {string} options.islevel - The level of the current member.\n * @param {Function} [options.showAlert] - Optional function to show alert messages.\n * @param {string} options.coHost - The co-host information.\n * @param {Participant[]} options.participants - The list of current participants.\n * @param {Socket} options.socket - The socket instance for emitting events.\n * @param {string} options.roomName - The name of the room.\n * @param {Function} options.updateParticipants - Function to update the participants list.\n *\n * @returns {Promise<void>} A promise that resolves when the participant is removed.\n *\n * @throws Will log an error if there is an issue accessing co-host responsibilities.\n *\n * @example\n * ```typescript\n * const removeParticipantsService = new RemoveParticipants();\n * await removeParticipantsService.removeParticipants({\n *   coHostResponsibility: [{ name: 'participants', value: true }],\n *   participant: { id: '123', name: 'John', islevel: '1' },\n *   member: 'Alice',\n *   islevel: '1',\n *   showAlert: ({ message, type }) => {\n *     console.log(`Alert: ${message} - Type: ${type}`);\n *   },\n *   coHost: 'Bob',\n *   participants: [{ id: '123', name: 'John', islevel: '1' }],\n *   socket: socketInstance,\n *   roomName: 'room1',\n *   updateParticipants: (updatedList) => {\n *     console.log('Updated participants:', updatedList);\n *   },\n * });\n * ```\n */\n\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class RemoveParticipants {\n  /**\n   * Removes a participant from the room if the user has the appropriate permissions.\n   *\n   * @param {RemoveParticipantsOptions} options - The options for removing a participant.\n   * @param {Array} options.coHostResponsibility - The responsibilities of the co-host.\n   * @param {Object} options.participant - The participant to be removed.\n   * @param {Object} options.member - The current member attempting to remove the participant.\n   * @param {string} options.islevel - The level of the current member.\n   * @param {Function} [options.showAlert] - Function to show an alert message.\n   * @param {Object} options.coHost - The co-host information.\n   * @param {Array} options.participants - The list of current participants.\n   * @param {Object} options.socket - The socket instance for emitting events.\n   * @param {string} options.roomName - The name of the room.\n   * @param {Function} options.updateParticipants - Function to update the participants list.\n   *\n   * @returns {Promise<void>} - A promise that resolves when the participant is removed.\n   */\n\n  async removeParticipants({\n    coHostResponsibility,\n    participant,\n    member,\n    islevel,\n    showAlert,\n    coHost,\n    participants,\n    socket,\n    roomName,\n    updateParticipants,\n  }: RemoveParticipantsOptions): Promise<void> {\n    let participantsValue = false;\n\n    try {\n      participantsValue =\n        coHostResponsibility.find((item) => item.name === 'participants')?.value ?? false;\n    } catch (error) {\n      participantsValue = false;\n    }\n\n    if (islevel === '2' || (coHost === member && participantsValue === true)) {\n      if (participant.islevel !== '2') {\n        const participantId = participant.id;\n\n        // Emit a socket event to disconnect the user\n        socket.emit('disconnectUserInitiate', {\n          member: participant.name,\n          roomName,\n          id: participantId,\n        });\n\n        // Remove the participant from the local array\n        participants.splice(\n          participants.findIndex((obj: any) => obj.name === participant.name),\n          1,\n        );\n\n        // Update the participants array\n        updateParticipants(participants);\n      }\n    } else {\n      showAlert?.({\n        message: 'You are not allowed to remove other participants',\n        type: 'danger',\n        duration: 3000,\n      });\n    }\n  }\n}\n"]}

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

@@ -1,5 +1,43 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Handles the creation of a poll.
+ *
+ * This method sends a request to create a poll in the specified room via a socket event.
+ * It also handles the response from the server to notify the user whether the poll was
+ * created successfully or if there was an error.
+ *
+ * @param {HandleCreatePollOptions} options - The options for creating the poll.
+ * @param {Poll} options.poll - The poll object containing the poll details.
+ * @param {Socket} options.socket - The socket instance for emitting events.
+ * @param {string} options.roomName - The name of the room where the poll will be created.
+ * @param {Function} [options.showAlert] - Optional function to show alert messages.
+ * @param {Function} options.updateIsPollModalVisible - Function to update the visibility of the poll modal.
+ *
+ * @returns {Promise<void>} A promise that resolves when the poll is created successfully.
+ *
+ * @throws Will handle any errors during the poll creation process silently.
+ *
+ * @example
+ * ```typescript
+ * const handleCreatePollService = new HandleCreatePoll();
+ * const pollData = {
+ *   question: 'What is your favorite color?',
+ *   options: ['Red', 'Blue', 'Green'],
+ * };
+ * await handleCreatePollService.handleCreatePoll({
+ *   poll: pollData,
+ *   socket: socketInstance,
+ *   roomName: 'room1',
+ *   showAlert: ({ message, type }) => {
+ *     console.log(`Alert: ${message} - Type: ${type}`);
+ *   },
+ *   updateIsPollModalVisible: (isVisible) => {
+ *     console.log('Poll modal visibility:', isVisible);
+ *   },
+ * });
+ * ```
+ */
 export class HandleCreatePoll {
     /**
      * Handles the creation of a poll.
@@ -34,4 +72,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,5 +1,37 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * 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 {HandleEndPollOptions} 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.
+ * @param {Function} options.updateIsPollModalVisible - Function to update the visibility of the poll modal.
+ *
+ * @returns {Promise<void>} A promise that resolves when the poll end operation is complete.
+ *
+ * @throws Will log an error if the operation fails to emit the end poll event.
+ *
+ * @example
+ * ```typescript
+ * const handleEndPollService = new HandleEndPoll();
+ * const pollId = '12345';
+ * await handleEndPollService.handleEndPoll({
+ *   pollId: pollId,
+ *   socket: socketInstance,
+ *   roomName: 'room1',
+ *   showAlert: ({ message, type }) => {
+ *     console.log(`Alert: ${message} - Type: ${type}`);
+ *   },
+ *   updateIsPollModalVisible: (isVisible) => {
+ *     console.log('Poll modal visibility:', isVisible);
+ *   },
+ * });
+ * ```
+ */
 export class HandleEndPoll {
     /**
      * Handles the end of a poll by emitting an "endPoll" event through the provided socket.
@@ -37,4 +69,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,5 +1,39 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Handles the voting process for a poll.
+ *
+ * @param {HandleVotePollOptions} 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 {string} 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.
+ *
+ * @example
+ * ```typescript
+ * const handleVotePollService = new HandleVotePoll();
+ * await handleVotePollService.handleVotePoll({
+ *   pollId: '12345',
+ *   optionIndex: 1,
+ *   socket: socketInstance,
+ *   member: 'user1',
+ *   roomName: 'room1',
+ *   showAlert: ({ message, type }) => {
+ *     console.log(`Alert: ${message} - Type: ${type}`);
+ *   },
+ *   updateIsPollModalVisible: (isVisible) => {
+ *     console.log('Poll modal visibility:', isVisible);
+ *   },
+ * });
+ * ```
+ */
 export class HandleVotePoll {
     /**
      * Handles the voting process for a poll.
@@ -46,4 +80,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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