mediasfu-angular 1.0.1 → 1.0.2

package/dist/esm2022/lib/producers/socket-receive-methods/update-consuming-domains.service.mjs

@@ -1,5 +1,47 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Service to update consuming domains based on specified options and parameters.
+ *
+ * @class
+ * @name UpdateConsumingDomains
+ * @description Provides a method to update consuming domains and optionally connect IPs based on the domains provided.
+ *
+ * @method
+ * updateConsumingDomains
+ *
+ * @param {UpdateConsumingDomainsOptions} options - Options for updating consuming domains:
+ *   - `domains` {Array<string>}: The list of domains to be updated.
+ *   - `alt_domains` {AltDomains}: Alternative domains for fallback scenarios.
+ *   - `apiUserName` {string}: API username for authentication.
+ *   - `apiKey` {string}: API key for access.
+ *   - `apiToken` {string}: API token for additional security.
+ *   - `parameters` {UpdateConsumingDomainsParameters}: The parameters needed for updating, including:
+ *     - `participants` {Array<Participant>}: List of participants.
+ *     - `consume_sockets` {Array<ConsumeSocket>}: Sockets to use for consuming domains.
+ *     - `getDomains` {Function}: Function to retrieve current domain configurations.
+ *     - `connectIps` {Function}: Function to initiate IP connections.
+ *     - `getUpdatedAllParams` {Function}: Refreshes and returns the latest parameters.
+ *
+ * @returns {Promise<void>} Resolves when the consuming domains have been successfully updated.
+ *
+ * @example
+ * const options = {
+ *   domains: ['example.com', 'sample.org'],
+ *   alt_domains: { primary: 'primary.com', backup: 'backup.com' },
+ *   apiUserName: 'user123',
+ *   apiKey: 'apikey123',
+ *   apiToken: 'token123',
+ *   parameters: {
+ *     participants: [{ id: '1', name: 'John Doe' }],
+ *     consume_sockets: [socket1, socket2],
+ *     getDomains: (opts) => fetchDomains(opts),
+ *     connectIps: (opts) => connectToIPs(opts),
+ *     getUpdatedAllParams: () => refreshParams(),
+ *   },
+ * };
+ * await updateConsumingDomainsService.updateConsumingDomains(options);
+ */
 export class UpdateConsumingDomains {
     /**
      * Updates the consuming domains based on the provided options.
@@ -60,4 +102,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":"update-consuming-domains.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/producers/socket-receive-methods/update-consuming-domains.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAqC3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAMH,MAAM,OAAO,sBAAsB;IACjC;;;;;;;;;;;;;;;;;;;OAmBG;IACH,sBAAsB,GAAG,KAAK,EAAE,EAC9B,OAAO,EACP,WAAW,EACX,UAAU,EACV,WAAW,EACX,MAAM,EACN,QAAQ,GACsB,EAAiB,EAAE;QACjD,IAAI,EAAE,YAAY,EAAE,UAAU,EAAE,eAAe,EAAE,UAAU,EAAE,GAAG,UAAU,CAAC;QAE3E,UAAU,GAAG,UAAU,CAAC,mBAAmB,EAAE,CAAC;QAC9C,eAAe,GAAG,UAAU,CAAC,eAAe,CAAC;QAE7C,OAAO,CAAC,GAAG,CAAC,+BAA+B,CAAC,CAAC;QAE7C,IAAI,CAAC;YACH,2CAA2C;YAC3C,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAC5B,sDAAsD;gBACtD,IAAI,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBACxC,OAAO,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC;oBAClC,MAAM,UAAU,CAAC,EAAE,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,CAAC,CAAC;gBACxF,CAAC;qBAAM,CAAC;oBACN,MAAM,UAAU,CAAC;wBACf,eAAe;wBACf,KAAK,EAAE,OAAO;wBACd,UAAU;wBACV,WAAW;wBACX,MAAM;wBACN,QAAQ;qBACT,CAAC,CAAC;gBACL,CAAC;YACH,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,GAAG,CAAC,mCAAmC,EAAE,KAAK,CAAC,CAAC;YACxD,0DAA0D;QAC5D,CAAC;IACH,CAAC,CAAC;uGA1DS,sBAAsB;2GAAtB,sBAAsB,cAFrB,MAAM;;2FAEP,sBAAsB;kBAHlC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  ConnectIpsType,\n  GetDomainsType,\n  ConnectIpsParameters,\n  GetDomainsParameters,\n  AltDomains,\n  Participant,\n  ConsumeSocket,\n} from '../../@types/types';\n\nexport interface UpdateConsumingDomainsParameters\n  extends ConnectIpsParameters,\n    GetDomainsParameters {\n  participants: Participant[];\n  consume_sockets: ConsumeSocket[];\n\n  // mediasfu functions\n  connectIps: ConnectIpsType;\n  getDomains: GetDomainsType;\n\n  getUpdatedAllParams: () => UpdateConsumingDomainsParameters;\n  [key: string]: any;\n}\n\nexport interface UpdateConsumingDomainsOptions {\n  domains: string[];\n  alt_domains: AltDomains;\n  apiUserName: string;\n  apiKey: string;\n  apiToken: string;\n  parameters: UpdateConsumingDomainsParameters;\n}\n\n// Export the type definition for the function\nexport type UpdateConsumingDomainsType = (options: UpdateConsumingDomainsOptions) => Promise<void>;\n\n/**\n * Service to update consuming domains based on specified options and parameters.\n *\n * @class\n * @name UpdateConsumingDomains\n * @description Provides a method to update consuming domains and optionally connect IPs based on the domains provided.\n *\n * @method\n * updateConsumingDomains\n *\n * @param {UpdateConsumingDomainsOptions} options - Options for updating consuming domains:\n *   - `domains` {Array<string>}: The list of domains to be updated.\n *   - `alt_domains` {AltDomains}: Alternative domains for fallback scenarios.\n *   - `apiUserName` {string}: API username for authentication.\n *   - `apiKey` {string}: API key for access.\n *   - `apiToken` {string}: API token for additional security.\n *   - `parameters` {UpdateConsumingDomainsParameters}: The parameters needed for updating, including:\n *     - `participants` {Array<Participant>}: List of participants.\n *     - `consume_sockets` {Array<ConsumeSocket>}: Sockets to use for consuming domains.\n *     - `getDomains` {Function}: Function to retrieve current domain configurations.\n *     - `connectIps` {Function}: Function to initiate IP connections.\n *     - `getUpdatedAllParams` {Function}: Refreshes and returns the latest parameters.\n *\n * @returns {Promise<void>} Resolves when the consuming domains have been successfully updated.\n *\n * @example\n * const options = {\n *   domains: ['example.com', 'sample.org'],\n *   alt_domains: { primary: 'primary.com', backup: 'backup.com' },\n *   apiUserName: 'user123',\n *   apiKey: 'apikey123',\n *   apiToken: 'token123',\n *   parameters: {\n *     participants: [{ id: '1', name: 'John Doe' }],\n *     consume_sockets: [socket1, socket2],\n *     getDomains: (opts) => fetchDomains(opts),\n *     connectIps: (opts) => connectToIPs(opts),\n *     getUpdatedAllParams: () => refreshParams(),\n *   },\n * };\n * await updateConsumingDomainsService.updateConsumingDomains(options);\n */\n\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class UpdateConsumingDomains {\n  /**\n   * Updates the consuming domains based on the provided options.\n   *\n   * @param {Object} options - The options for updating the consuming domains.\n   * @param {Array<string>} options.domains - The consuming domains to update.\n   * @param {Object} options.alt_domains - The alternative consuming domains to update.\n   * @param {string} options.apiUserName - The API username for the consuming domains.\n   * @param {string} options.apiKey - The API key for the consuming domains.\n   * @param {string} options.apiToken - The API token for the consuming domains.\n   * @param {Object} options.parameters - The parameters for updating the consuming domains.\n   * @param {Array<Participant>} options.parameters.participants - The participants to update consuming domains for.\n   * @param {Array<ConsumeSocket>} options.parameters.consume_sockets - The consume sockets to update consuming domains for.\n   * @param {Function} options.parameters.getDomains - Function to get the consuming domains.\n   * @param {Function} options.parameters.connectIps - Function to connect IPs.\n   * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.\n   *\n   * @returns {Promise<void>} A promise that resolves when the consuming domains have been updated.\n   *\n   * @throws Will log an error message if an error occurs during the update process.\n   */\n  updateConsumingDomains = async ({\n    domains,\n    alt_domains,\n    parameters,\n    apiUserName,\n    apiKey,\n    apiToken,\n  }: UpdateConsumingDomainsOptions): Promise<void> => {\n    let { participants, getDomains, consume_sockets, connectIps } = parameters;\n\n    parameters = parameters.getUpdatedAllParams();\n    consume_sockets = parameters.consume_sockets;\n\n    console.log('Updating consuming domains...');\n\n    try {\n      // Check if participants array is not empty\n      if (participants.length > 0) {\n        // Check if alt_domains has keys and remove duplicates\n        if (Object.keys(alt_domains).length > 0) {\n          console.log('Getting domains...');\n          await getDomains({ domains, alt_domains, apiUserName, apiKey, apiToken, parameters });\n        } else {\n          await connectIps({\n            consume_sockets,\n            remIP: domains,\n            parameters,\n            apiUserName,\n            apiKey,\n            apiToken,\n          });\n        }\n      }\n    } catch (error) {\n      console.log('Error in updateConsumingDomains: ', error);\n      // throw new Error('Failed to update consuming domains.');\n    }\n  };\n}\n"]}

package/dist/esm2022/lib/producers/socket-receive-methods/update-media-settings.service.mjs

@@ -1,5 +1,35 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Service for updating media settings including audio, video, screenshare, and chat.
+ *
+ * @class
+ * @name UpdateMediaSettings
+ * @description Provides a method to update multiple media settings at once using specified update functions.
+ *
+ * @method
+ * updateMediaSettings
+ *
+ * @param {UpdateMediaSettingsOptions} options - Options for updating media settings:
+ *   - `settings` {Settings}: The settings values to apply.
+ *   - `updateAudioSetting` {Function}: Function to update the audio setting.
+ *   - `updateVideoSetting` {Function}: Function to update the video setting.
+ *   - `updateScreenshareSetting` {Function}: Function to update the screenshare setting.
+ *   - `updateChatSetting` {Function}: Function to update the chat setting.
+ *
+ * @returns {void} Updates settings directly through the provided functions.
+ *
+ * @example
+ * const settings = ['mute', 'HD', 'enabled', 'disabled'];
+ * const options = {
+ *   settings,
+ *   updateAudioSetting: (value) => console.log(`Audio setting updated to: ${value}`),
+ *   updateVideoSetting: (value) => console.log(`Video setting updated to: ${value}`),
+ *   updateScreenshareSetting: (value) => console.log(`Screenshare setting updated to: ${value}`),
+ *   updateChatSetting: (value) => console.log(`Chat setting updated to: ${value}`)
+ * };
+ * updateMediaSettingsService.updateMediaSettings(options);
+ */
 export class UpdateMediaSettings {
     /**
      * Updates the media settings by invoking the provided update functions for each setting.
@@ -33,4 +63,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/producers/socket-receive-methods/updated-co-host.service.mjs

@@ -1,5 +1,45 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Service for updating co-host information, responsibilities, and the user's co-host status.
+ *
+ * @class
+ * @name UpdatedCoHost
+ * @description Manages co-host updates for different event types, assigning responsibilities and notifying the user if their co-host status changes.
+ *
+ * @method
+ * updatedCoHost
+ * @async
+ *
+ * @param {UpdatedCoHostOptions} options - The options for co-host updates:
+ *   - `coHost` {string}: The name of the co-host.
+ *   - `coHostResponsibility` {CoHostResponsibility[]}: List of responsibilities assigned to the co-host.
+ *   - `showAlert` {ShowAlert}: Optional function to display an alert message.
+ *   - `eventType` {EventType}: Type of the event, determining if co-host can be updated.
+ *   - `islevel` {string}: Current level of the event.
+ *   - `member` {string}: The current user's identifier.
+ *   - `youAreCoHost` {boolean}: Current user's co-host status.
+ *   - `updateCoHost` {Function}: Function to set the new co-host.
+ *   - `updateCoHostResponsibility` {Function}: Function to assign responsibilities to the co-host.
+ *   - `updateYouAreCoHost` {Function}: Function to update the user's co-host status.
+ *
+ * @returns {Promise<void>} Resolves after co-host information is updated.
+ *
+ * @example
+ * const options = {
+ *   coHost: 'Alice',
+ *   coHostResponsibility: ['moderate', 'manageParticipants'],
+ *   showAlert: ({ message, type, duration }) => console.log(message),
+ *   eventType: 'conference',
+ *   islevel: '1',
+ *   member: 'Alice',
+ *   youAreCoHost: false,
+ *   updateCoHost: (newCoHost) => console.log(`Updated co-host: ${newCoHost}`),
+ *   updateCoHostResponsibility: (responsibilities) => console.log(responsibilities),
+ *   updateYouAreCoHost: (status) => console.log(`You are co-host: ${status}`)
+ * };
+ * await updatedCoHostService.updatedCoHost(options);
+ */
 export class UpdatedCoHost {
     /**
      * Updates the co-host information, responsibility, and user's co-host status based on the provided options.
@@ -53,4 +93,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXBkYXRlZC1jby1ob3N0LnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tZWRpYXNmdS1hbmd1bGFyL3NyYy9saWIvcHJvZHVjZXJzL3NvY2tldC1yZWNlaXZlLW1ldGhvZHMvdXBkYXRlZC1jby1ob3N0LnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFxQjNDLE1BQU0sT0FBTyxhQUFhO0lBQ3hCOzs7Ozs7Ozs7Ozs7Ozs7O09BZ0JHO0lBQ0gsYUFBYSxHQUFHLEtBQUssRUFBRSxFQUNyQixNQUFNLEVBQ04sb0JBQW9CLEVBQ3BCLFNBQVMsRUFDVCxTQUFTLEVBQ1QsT0FBTyxFQUNQLE1BQU0sRUFDTixZQUFZLEVBQ1osWUFBWSxFQUNaLDBCQUEwQixFQUMxQixrQkFBa0IsR0FDRyxFQUFpQixFQUFFO1FBQ3hDLHdFQUF3RTtRQUN4RSxJQUFJLFNBQVMsS0FBSyxXQUFXLElBQUksU0FBUyxLQUFLLE1BQU0sRUFBRSxDQUFDO1lBQ3RELHFFQUFxRTtZQUNyRSxZQUFZLENBQUMsTUFBTSxDQUFDLENBQUM7WUFDckIsMEJBQTBCLENBQUMsb0JBQW9CLENBQUMsQ0FBQztZQUVqRCxJQUFJLE1BQU0sS0FBSyxNQUFNLEVBQUUsQ0FBQztnQkFDdEIsSUFBSSxDQUFDLFlBQVksRUFBRSxDQUFDO29CQUNsQixrQkFBa0IsQ0FBQyxJQUFJLENBQUMsQ0FBQztvQkFFekIsU0FBUyxFQUFFLENBQUM7d0JBQ1YsT0FBTyxFQUFFLHdCQUF3Qjt3QkFDakMsSUFBSSxFQUFFLFNBQVM7d0JBQ2YsUUFBUSxFQUFFLElBQUk7cUJBQ2YsQ0FBQyxDQUFDO2dCQUNMLENBQUM7WUFDSCxDQUFDO2lCQUFNLENBQUM7Z0JBQ04sa0JBQWtCLENBQUMsS0FBSyxDQUFDLENBQUM7WUFDNUIsQ0FBQztRQUNILENBQUM7YUFBTSxDQUFDO1lBQ04sSUFBSSxPQUFPLEtBQUssR0FBRyxFQUFFLENBQUM7Z0JBQ3BCLGtCQUFrQixDQUFDLElBQUksQ0FBQyxDQUFDO1lBQzNCLENBQUM7UUFDSCxDQUFDO0lBQ0gsQ0FBQyxDQUFDO3VHQXREUyxhQUFhOzJHQUFiLGFBQWEsY0FGWixNQUFNOzsyRkFFUCxhQUFhO2tCQUh6QixVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IENvSG9zdFJlc3BvbnNpYmlsaXR5LCBFdmVudFR5cGUsIFNob3dBbGVydCB9IGZyb20gJy4uLy4uL0B0eXBlcy90eXBlcyc7XG5leHBvcnQgaW50ZXJmYWNlIFVwZGF0ZWRDb0hvc3RPcHRpb25zIHtcbiAgY29Ib3N0OiBzdHJpbmc7XG4gIGNvSG9zdFJlc3BvbnNpYmlsaXR5OiBDb0hvc3RSZXNwb25zaWJpbGl0eVtdO1xuICBzaG93QWxlcnQ/OiBTaG93QWxlcnQ7XG4gIGV2ZW50VHlwZTogRXZlbnRUeXBlO1xuICBpc2xldmVsOiBzdHJpbmc7XG4gIG1lbWJlcjogc3RyaW5nO1xuICB5b3VBcmVDb0hvc3Q6IGJvb2xlYW47XG4gIHVwZGF0ZUNvSG9zdDogKGNvSG9zdDogc3RyaW5nKSA9PiB2b2lkO1xuICB1cGRhdGVDb0hvc3RSZXNwb25zaWJpbGl0eTogKHJlc3BvbnNpYmlsaXR5OiBDb0hvc3RSZXNwb25zaWJpbGl0eVtdKSA9PiB2b2lkO1xuICB1cGRhdGVZb3VBcmVDb0hvc3Q6ICh5b3VBcmVDb0hvc3Q6IGJvb2xlYW4pID0+IHZvaWQ7XG59XG5cbi8vIEV4cG9ydCB0aGUgdHlwZSBkZWZpbml0aW9uIGZvciB0aGUgZnVuY3Rpb25cbmV4cG9ydCB0eXBlIFVwZGF0ZWRDb0hvc3RUeXBlID0gKG9wdGlvbnM6IFVwZGF0ZWRDb0hvc3RPcHRpb25zKSA9PiBQcm9taXNlPHZvaWQ+O1xuXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290Jyxcbn0pXG5leHBvcnQgY2xhc3MgVXBkYXRlZENvSG9zdCB7XG4gIC8qKlxuICAgKiBVcGRhdGVzIHRoZSBjby1ob3N0IGluZm9ybWF0aW9uLCByZXNwb25zaWJpbGl0eSwgYW5kIHVzZXIncyBjby1ob3N0IHN0YXR1cyBiYXNlZCBvbiB0aGUgcHJvdmlkZWQgb3B0aW9ucy5cbiAgICpcbiAgICogQHBhcmFtIG9wdGlvbnMgLSBUaGUgb3B0aW9ucyBmb3IgdXBkYXRpbmcgdGhlIGNvLWhvc3QuXG4gICAqIEBwYXJhbSBvcHRpb25zLmNvSG9zdCAtIFRoZSBjby1ob3N0IHRvIGJlIHVwZGF0ZWQuXG4gICAqIEBwYXJhbSBvcHRpb25zLmNvSG9zdFJlc3BvbnNpYmlsaXR5IC0gVGhlIHJlc3BvbnNpYmlsaXR5IG9mIHRoZSBjby1ob3N0LlxuICAgKiBAcGFyYW0gb3B0aW9ucy5zaG93QWxlcnQgLSBBIGZ1bmN0aW9uIHRvIHNob3cgYWxlcnRzLlxuICAgKiBAcGFyYW0gb3B0aW9ucy5ldmVudFR5cGUgLSBUaGUgdHlwZSBvZiBldmVudCB0cmlnZ2VyaW5nIHRoZSB1cGRhdGUuXG4gICAqIEBwYXJhbSBvcHRpb25zLmlzbGV2ZWwgLSBUaGUgbGV2ZWwgb2YgdGhlIGV2ZW50LlxuICAgKiBAcGFyYW0gb3B0aW9ucy5tZW1iZXIgLSBUaGUgbWVtYmVyIHRvIGJlIGNoZWNrZWQgYWdhaW5zdCB0aGUgY28taG9zdC5cbiAgICogQHBhcmFtIG9wdGlvbnMueW91QXJlQ29Ib3N0IC0gVGhlIGN1cnJlbnQgY28taG9zdCBzdGF0dXMgb2YgdGhlIHVzZXIuXG4gICAqIEBwYXJhbSBvcHRpb25zLnVwZGF0ZUNvSG9zdCAtIEEgZnVuY3Rpb24gdG8gdXBkYXRlIHRoZSBjby1ob3N0LlxuICAgKiBAcGFyYW0gb3B0aW9ucy51cGRhdGVDb0hvc3RSZXNwb25zaWJpbGl0eSAtIEEgZnVuY3Rpb24gdG8gdXBkYXRlIHRoZSBjby1ob3N0J3MgcmVzcG9uc2liaWxpdHkuXG4gICAqIEBwYXJhbSBvcHRpb25zLnVwZGF0ZVlvdUFyZUNvSG9zdCAtIEEgZnVuY3Rpb24gdG8gdXBkYXRlIHRoZSB1c2VyJ3MgY28taG9zdCBzdGF0dXMuXG4gICAqXG4gICAqIEByZXR1cm5zIEEgcHJvbWlzZSB0aGF0IHJlc29sdmVzIHdoZW4gdGhlIGNvLWhvc3QgaW5mb3JtYXRpb24gaGFzIGJlZW4gdXBkYXRlZC5cbiAgICovXG4gIHVwZGF0ZWRDb0hvc3QgPSBhc3luYyAoe1xuICAgIGNvSG9zdCxcbiAgICBjb0hvc3RSZXNwb25zaWJpbGl0eSxcbiAgICBzaG93QWxlcnQsXG4gICAgZXZlbnRUeXBlLFxuICAgIGlzbGV2ZWwsXG4gICAgbWVtYmVyLFxuICAgIHlvdUFyZUNvSG9zdCxcbiAgICB1cGRhdGVDb0hvc3QsXG4gICAgdXBkYXRlQ29Ib3N0UmVzcG9uc2liaWxpdHksXG4gICAgdXBkYXRlWW91QXJlQ29Ib3N0LFxuICB9OiBVcGRhdGVkQ29Ib3N0T3B0aW9ucyk6IFByb21pc2U8dm9pZD4gPT4ge1xuICAgIC8vIFVwZGF0ZSBjby1ob3N0IGluZm9ybWF0aW9uLCByZXNwb25zaWJpbGl0eSwgYW5kIHVzZXIncyBjby1ob3N0IHN0YXR1c1xuICAgIGlmIChldmVudFR5cGUgIT09ICdicm9hZGNhc3QnICYmIGV2ZW50VHlwZSAhPT0gJ2NoYXQnKSB7XG4gICAgICAvLyBPbmx5IHVwZGF0ZSB0aGUgY28taG9zdCBpZiB0aGUgZXZlbnQgdHlwZSBpcyBub3QgYnJvYWRjYXN0IG9yIGNoYXRcbiAgICAgIHVwZGF0ZUNvSG9zdChjb0hvc3QpO1xuICAgICAgdXBkYXRlQ29Ib3N0UmVzcG9uc2liaWxpdHkoY29Ib3N0UmVzcG9uc2liaWxpdHkpO1xuXG4gICAgICBpZiAobWVtYmVyID09PSBjb0hvc3QpIHtcbiAgICAgICAgaWYgKCF5b3VBcmVDb0hvc3QpIHtcbiAgICAgICAgICB1cGRhdGVZb3VBcmVDb0hvc3QodHJ1ZSk7XG5cbiAgICAgICAgICBzaG93QWxlcnQ/Lih7XG4gICAgICAgICAgICBtZXNzYWdlOiAnWW91IGFyZSBub3cgYSBjby1ob3N0LicsXG4gICAgICAgICAgICB0eXBlOiAnc3VjY2VzcycsXG4gICAgICAgICAgICBkdXJhdGlvbjogMzAwMCxcbiAgICAgICAgICB9KTtcbiAgICAgICAgfVxuICAgICAgfSBlbHNlIHtcbiAgICAgICAgdXBkYXRlWW91QXJlQ29Ib3N0KGZhbHNlKTtcbiAgICAgIH1cbiAgICB9IGVsc2Uge1xuICAgICAgaWYgKGlzbGV2ZWwgIT09ICcyJykge1xuICAgICAgICB1cGRhdGVZb3VBcmVDb0hvc3QodHJ1ZSk7XG4gICAgICB9XG4gICAgfVxuICB9O1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/producers/socket-receive-methods/user-waiting.service.mjs

@@ -1,56 +1,30 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
 /**
- * @fileoverview Service to handle user waiting functionality.
- *
- * @description
- * This service provides methods to handle the logic when a user joins the waiting room.
- * It displays an alert/notification and updates the total number of requests waiting.
- */
-/**
- * Options for the userWaiting method.
- *
- * @interface UserWaitingOptions
- * @property {string} name - The name of the user joining the waiting room.
- * @property {(options: { message: string; type: string; duration: number }) => void} [showAlert] - Optional function to display an alert/notification.
- * @property {number} totalReqWait - The current total number of requests waiting.
- * @property {(total: number) => void} updateTotalReqWait - Function to update the total number of requests waiting.
- */
-/**
- * Service to handle user waiting functionality.
+ * Service for handling user waiting room actions, including notifications and updating request counts.
  *
  * @class
  * @name UserWaiting
- * @description
- * This service provides methods to handle the logic when a user joins the waiting room.
- * It displays an alert/notification and updates the total number of requests waiting.
- *
- * @example
- * const userWaitingService = new UserWaiting();
- * userWaitingService.userWaiting({
- *   name: 'John Doe',
- *   showAlert: (options) => console.log(options.message),
- *   totalReqWait: 5,
- *   updateTotalReqWait: (total) => console.log(`Total requests: ${total}`),
- * });
- */
-/**
- * Handles the logic when a user joins the waiting room.
+ * @description Manages the logic when a user joins the waiting room by displaying alerts and incrementing the total request count.
  *
  * @method
- * @name userWaiting
- * @memberof UserWaiting
+ * userWaiting
  * @async
  *
- * @param {UserWaitingOptions} options - The options for the user waiting method.
- * @returns {Promise<void>} A promise that resolves when the operation is complete.
+ * @param {UserWaitingOptions} options - The options for handling user waiting actions:
+ *   - `name` {string}: Name of the user joining the waiting room.
+ *   - `showAlert` {ShowAlert}: Optional function for showing an alert with a customizable message, type, and duration.
+ *   - `totalReqWait` {number}: Current count of waiting requests.
+ *   - `updateTotalReqWait` {Function}: Updates the total waiting request count.
+ *
+ * @returns {Promise<void>} Resolves after alert is shown and request count is updated.
  *
  * @example
  * const options = {
- *   name: 'John Doe',
- *   showAlert: (options) => console.log(options.message),
- *   totalReqWait: 5,
- *   updateTotalReqWait: (total) => console.log(`Total requests: ${total}`),
+ *   name: 'Alice',
+ *   showAlert: ({ message, type, duration }) => console.log(message),
+ *   totalReqWait: 3,
+ *   updateTotalReqWait: (newTotal) => console.log(`Updated count: ${newTotal}`)
  * };
  * await userWaitingService.userWaiting(options);
  */
@@ -75,4 +49,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/sockets/socket-manager.service.mjs

@@ -2,6 +2,46 @@ import { Injectable } from '@angular/core';
 // Socket manager for media socket.
 import io from 'socket.io-client'; // Importing socket type
 import * as i0 from "@angular/core";
+/**
+ * Manages connections to a media socket, allowing users to connect or disconnect based on API credentials.
+ *
+ * @class
+ * @name SocketManager
+ * @description Provides methods to connect and disconnect from a media socket using a provided API key or token.
+ *
+ * @method
+ * validateApiKeyToken - Validates the API key or token for correct format.
+ * connectSocket - Establishes a connection to the media socket using either the API key or token.
+ * disconnectSocket - Disconnects an active socket connection.
+ *
+ * @example
+ * ```typescript
+ * const socketManager = new SocketManager();
+ *
+ * // Example of connecting to the socket
+ * const socketConnection = await socketManager.connectSocket({
+ *   apiUserName: 'user123',
+ *   apiKey: 'validApiKeyOf64Characters',
+ *   link: 'https://socketserver.example.com'
+ * });
+ *
+ * // Example of disconnecting the socket
+ * const isDisconnected = await socketManager.disconnectSocket({
+ *   socket: socketConnection
+ * });
+ * ```
+ *
+ * @typedef {Object} ConnectSocketOptions
+ * @property {string} apiUserName - Username for the API.
+ * @property {string} [apiKey] - The API key for authentication.
+ * @property {string} [apiToken] - The API token for authentication.
+ * @property {string} link - The socket server link.
+ *
+ * @typedef {Object} DisconnectSocketOptions
+ * @property {Socket} socket - The socket instance to disconnect.
+ *
+ * @returns {Promise<Socket | boolean>} The active socket instance on connection, or a boolean indicating disconnection success.
+ */
 export class SocketManager {
     socket;
     async validateApiKeyToken(value) {
@@ -70,4 +110,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":"socket-manager.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/sockets/socket-manager.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,mCAAmC;AACnC,OAAO,EAAc,MAAM,kBAAkB,CAAC,CAAC,wBAAwB;;AAuBvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAMH,MAAM,OAAO,aAAa;IAChB,MAAM,CAAU;IAExB,KAAK,CAAC,mBAAmB,CAAC,KAAa;QACrC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;YACnC,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAC;QAC/C,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,aAAa,GAAG,KAAK,EAAE,EACrB,WAAW,EACX,MAAM,EACN,QAAQ,EACR,IAAI,GACiB,EAAmB,EAAE;QAC1C,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,MAAM,IAAI,KAAK,CAAC,wBAAwB,CAAC,CAAC;QAC5C,CAAC;QACD,IAAI,CAAC,CAAC,MAAM,IAAI,QAAQ,CAAC,EAAE,CAAC;YAC1B,MAAM,IAAI,KAAK,CAAC,4BAA4B,CAAC,CAAC;QAChD,CAAC;QACD,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,MAAM,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAC;QAC3C,CAAC;QAED,IAAI,MAAM,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC;YACH,IAAI,MAAM,IAAI,MAAM,CAAC,MAAM,KAAK,EAAE,EAAE,CAAC;gBACnC,MAAM,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC;gBACvC,MAAM,GAAG,IAAI,CAAC;YAChB,CAAC;iBAAM,CAAC;gBACN,IAAI,QAAQ,EAAE,CAAC;oBACb,MAAM,IAAI,CAAC,mBAAmB,CAAC,QAAQ,CAAC,CAAC;gBAC3C,CAAC;qBAAM,CAAC;oBACN,MAAM,IAAI,KAAK,CAAC,wBAAwB,CAAC,CAAC;gBAC5C,CAAC;gBACD,MAAM,GAAG,KAAK,CAAC;YACjB,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAC;QAC/C,CAAC;QAED,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,MAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,QAAQ,EAAE,CAAC;YAE3E,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC,GAAG,IAAI,QAAQ,EAAE;gBAChC,UAAU,EAAE,CAAC,WAAW,CAAC;gBACzB,KAAK;aACN,CAAC,CAAC;YAEH,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,SAAS,EAAE,GAAG,EAAE;gBAC7B,OAAO,CAAC,GAAG,CAAC,4BAA4B,EAAE,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;gBAC1D,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YACvB,CAAC,CAAC,CAAC;YAEH,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,eAAe,EAAE,GAAG,EAAE;gBACnC,MAAM,CAAC,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC,CAAC;YACzD,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC,CAAC;IAEF,gBAAgB,GAAG,KAAK,EAAE,EAAE,MAAM,EAA2B,EAAoB,EAAE;QACjF,IAAI,MAAM,EAAE,CAAC;YACX,MAAM,CAAC,UAAU,EAAE,CAAC;YACpB,OAAO,IAAI,CAAC;QACd,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC,CAAC;uGApES,aAAa;2GAAb,aAAa,cAFZ,MAAM;;2FAEP,aAAa;kBAHzB,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\n// Socket manager for media socket.\nimport io, { Socket } from 'socket.io-client'; // Importing socket type\n\n/**\n * Validates the provided API key or token.\n * @param {string} value - The API key or token to validate.\n * @returns {Promise<Boolean>} - True if the API key or token is valid, false otherwise.\n */\n\nexport interface ConnectSocketOptions {\n  apiUserName: string;\n  apiKey?: string;\n  apiToken?: string;\n  link: string;\n}\n\nexport interface DisconnectSocketOptions {\n  socket: Socket;\n}\n\n// Export the type definition for the function\nexport type ConnectSocketType = (options: ConnectSocketOptions) => Promise<Socket>;\nexport type DisconnectSocketType = (options: DisconnectSocketOptions) => Promise<boolean>;\n\n/**\n * Manages connections to a media socket, allowing users to connect or disconnect based on API credentials.\n *\n * @class\n * @name SocketManager\n * @description Provides methods to connect and disconnect from a media socket using a provided API key or token.\n *\n * @method\n * validateApiKeyToken - Validates the API key or token for correct format.\n * connectSocket - Establishes a connection to the media socket using either the API key or token.\n * disconnectSocket - Disconnects an active socket connection.\n *\n * @example\n * ```typescript\n * const socketManager = new SocketManager();\n *\n * // Example of connecting to the socket\n * const socketConnection = await socketManager.connectSocket({\n *   apiUserName: 'user123',\n *   apiKey: 'validApiKeyOf64Characters',\n *   link: 'https://socketserver.example.com'\n * });\n *\n * // Example of disconnecting the socket\n * const isDisconnected = await socketManager.disconnectSocket({\n *   socket: socketConnection\n * });\n * ```\n *\n * @typedef {Object} ConnectSocketOptions\n * @property {string} apiUserName - Username for the API.\n * @property {string} [apiKey] - The API key for authentication.\n * @property {string} [apiToken] - The API token for authentication.\n * @property {string} link - The socket server link.\n *\n * @typedef {Object} DisconnectSocketOptions\n * @property {Socket} socket - The socket instance to disconnect.\n *\n * @returns {Promise<Socket | boolean>} The active socket instance on connection, or a boolean indicating disconnection success.\n */\n\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class SocketManager {\n  private socket!: Socket;\n\n  async validateApiKeyToken(value: string): Promise<boolean> {\n    if (!/^[a-z0-9]{64}$/i.test(value)) {\n      throw new Error('Invalid API key or token.');\n    }\n    return true;\n  }\n\n  connectSocket = async ({\n    apiUserName,\n    apiKey,\n    apiToken,\n    link,\n  }: ConnectSocketOptions): Promise<Socket> => {\n    if (!apiUserName) {\n      throw new Error('API username required.');\n    }\n    if (!(apiKey || apiToken)) {\n      throw new Error('API key or token required.');\n    }\n    if (!link) {\n      throw new Error('Socket link required.');\n    }\n\n    let useKey = false;\n    try {\n      if (apiKey && apiKey.length === 64) {\n        await this.validateApiKeyToken(apiKey);\n        useKey = true;\n      } else {\n        if (apiToken) {\n          await this.validateApiKeyToken(apiToken);\n        } else {\n          throw new Error('API token is required.');\n        }\n        useKey = false;\n      }\n    } catch (error) {\n      throw new Error('Invalid API key or token.');\n    }\n\n    return new Promise((resolve, reject) => {\n      const query = useKey ? { apiUserName, apiKey } : { apiUserName, apiToken };\n\n      this.socket = io(`${link}/media`, {\n        transports: ['websocket'],\n        query,\n      });\n\n      this.socket.on('connect', () => {\n        console.log('Connected to media socket.', this.socket.id);\n        resolve(this.socket);\n      });\n\n      this.socket.on('connect_error', () => {\n        reject(new Error('Error connecting to media socket.'));\n      });\n    });\n  };\n\n  disconnectSocket = async ({ socket }: DisconnectSocketOptions): Promise<boolean> => {\n    if (socket) {\n      socket.disconnect();\n      return true;\n    }\n    return false;\n  };\n}\n"]}