mediasfu-angular 1.0.1 → 1.0.2

package/dist/lib/producers/socket-receive-methods/screen-producer-id.service.d.ts

@@ -12,6 +12,47 @@ export interface ScreenProducerIdOptions {
     updateDeferScreenReceived: (received: boolean) => void;
 }
 export type ScreenProducerIdType = (options: ScreenProducerIdOptions) => void;
+/**
+ * Service to manage screen producer ID and screen sharing status for participants.
+ *
+ * @class
+ * @name ScreenProducerId
+ * @description This service processes and updates the screen producer ID, manages screen sharing states, and defers screen updates as needed based on participant data.
+ *
+ * @method
+ * screenProducerId
+ *
+ * @param {ScreenProducerIdOptions} options - Options for handling screen producer ID:
+ *   - `producerId` {string}: The ID of the screen producer.
+ *   - `screenId` {string}: The current screen ID.
+ *   - `membersReceived` {boolean}: Indicates if members data has been received.
+ *   - `shareScreenStarted` {boolean}: Indicates if screen sharing has started.
+ *   - `deferScreenReceived` {boolean}: Indicates if screen sharing should be deferred.
+ *   - `participants` {Participant[]}: The list of current participants.
+ *   - `updateScreenId` {Function}: Function to update the screen ID.
+ *   - `updateShareScreenStarted` {Function}: Function to update the screen sharing status.
+ *   - `updateDeferScreenReceived` {Function}: Function to update the deferred screen status.
+ *
+ * @returns {void} Updates states directly through provided functions.
+ *
+ * @example
+ * const options = {
+ *   producerId: 'abc123',
+ *   screenId: 'screen45',
+ *   membersReceived: true,
+ *   shareScreenStarted: false,
+ *   deferScreenReceived: false,
+ *   participants: [
+ *     { id: 'p1', ScreenID: 'screen45', ScreenOn: true },
+ *     // Additional participants
+ *   ],
+ *   updateScreenId: (id) => console.log(`Screen ID updated to: ${id}`),
+ *   updateShareScreenStarted: (started) => console.log(`Screen sharing started: ${started}`),
+ *   updateDeferScreenReceived: (received) => console.log(`Screen sharing deferred: ${received}`)
+ * };
+ *
+ * screenProducerIdService.screenProducerId(options);
+ */
 export declare class ScreenProducerId {
     /**
      * Handles the screen producer id.

package/dist/lib/producers/socket-receive-methods/start-records.service.d.ts

@@ -6,6 +6,31 @@ export interface StartRecordsOptions {
     socket: Socket;
 }
 export type StartRecordsType = (options: StartRecordsOptions) => Promise<void>;
+/**
+ * Service to initiate recording for a specified room.
+ *
+ * @class
+ * @name StartRecords
+ * @description Sends a request to the server to begin recording a room, using socket communication.
+ *
+ * @method
+ * startRecords
+ *
+ * @param {StartRecordsOptions} options - Options required to start the recording:
+ *   - `roomName` {string}: The name of the room to record.
+ *   - `member` {string}: The identifier of the member initiating the recording.
+ *   - `socket` {Socket}: The socket instance for server communication.
+ *
+ * @returns {Promise<void>} Resolves when the server confirms the recording start request.
+ *
+ * @example
+ * const options = {
+ *   roomName: 'Room101',
+ *   member: 'user123',
+ *   socket: io('http://localhost:3000')
+ * };
+ * startRecordsService.startRecords(options);
+ */
 export declare class StartRecords {
     /**
      * Starts recording the room.

package/dist/lib/producers/socket-receive-methods/stopped-recording.service.d.ts

@@ -6,6 +6,31 @@ export interface StoppedRecordingOptions {
     showAlert?: ShowAlert;
 }
 export type StoppedRecordingType = (options: StoppedRecordingOptions) => Promise<void>;
+/**
+ * Service to display an alert message when recording has stopped.
+ *
+ * @class
+ * @name StoppedRecording
+ * @description Provides a method to show an alert indicating that the recording has stopped.
+ *
+ * @method
+ * stoppedRecording
+ *
+ * @param {StoppedRecordingOptions} options - Options for displaying the alert:
+ *   - `state` {string}: The state of the recording, typically 'stop'.
+ *   - `reason` {string}: The reason for stopping the recording.
+ *   - `showAlert` {Function}: Optional function to show alert messages.
+ *
+ * @returns {Promise<void>} Resolves when the alert message has been displayed.
+ *
+ * @example
+ * const options = {
+ *   state: 'stop',
+ *   reason: 'User ended recording',
+ *   showAlert: ({ message, duration, type }) => console.log(message)
+ * };
+ * stoppedRecordingService.stoppedRecording(options);
+ */
 export declare class StoppedRecording {
     /**
      * Displays an alert message when the recording has stopped.

package/dist/lib/producers/socket-receive-methods/time-left-recording.service.d.ts

@@ -5,6 +5,27 @@ export interface TimeLeftRecordingOptions {
     showAlert?: ShowAlert;
 }
 export type TimeLeftRecordingType = (options: TimeLeftRecordingOptions) => void;
+/**
+ * Service to display an alert indicating the remaining recording time.
+ *
+ * @class
+ * @name TimeLeftRecording
+ * @description Provides a method to show an alert when the recording is close to its end.
+ *
+ * @method
+ * timeLeftRecording
+ *
+ * @param {TimeLeftRecordingOptions} options - Options for the remaining time alert:
+ *   - `timeLeft` {number}: The time left in seconds before the recording stops.
+ *   - `showAlert` {Function}: Optional function to display the alert message.
+ *
+ * @example
+ * const options = {
+ *   timeLeft: 30,
+ *   showAlert: ({ message, duration, type }) => console.log(message)
+ * };
+ * timeLeftRecordingService.timeLeftRecording(options);
+ */
 export declare class TimeLeftRecording {
     /**
      * Displays an alert message indicating the remaining time left for recording.

package/dist/lib/producers/socket-receive-methods/update-consuming-domains.service.d.ts

@@ -17,6 +17,48 @@ export interface UpdateConsumingDomainsOptions {
     parameters: UpdateConsumingDomainsParameters;
 }
 export type UpdateConsumingDomainsType = (options: UpdateConsumingDomainsOptions) => Promise<void>;
+/**
+ * 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 declare class UpdateConsumingDomains {
     /**
      * Updates the consuming domains based on the provided options.

package/dist/lib/producers/socket-receive-methods/update-media-settings.service.d.ts

@@ -8,6 +8,36 @@ export interface UpdateMediaSettingsOptions {
     updateChatSetting: (value: string) => void;
 }
 export type UpdateMediaSettingsType = (options: UpdateMediaSettingsOptions) => void;
+/**
+ * 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 declare class UpdateMediaSettings {
     /**
      * Updates the media settings by invoking the provided update functions for each setting.

package/dist/lib/producers/socket-receive-methods/updated-co-host.service.d.ts

@@ -13,6 +13,46 @@ export interface UpdatedCoHostOptions {
     updateYouAreCoHost: (youAreCoHost: boolean) => void;
 }
 export type UpdatedCoHostType = (options: UpdatedCoHostOptions) => Promise<void>;
+/**
+ * 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 declare class UpdatedCoHost {
     /**
      * Updates the co-host information, responsibility, and user's co-host status based on the provided options.

package/dist/lib/producers/socket-receive-methods/user-waiting.service.d.ts

@@ -8,56 +8,30 @@ export interface UserWaitingOptions {
 }
 export type UserWaitingType = (options: UserWaitingOptions) => Promise<void>;
 /**
- * @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);
  */

package/dist/lib/sockets/socket-manager.service.d.ts

@@ -16,6 +16,46 @@ export interface DisconnectSocketOptions {
 }
 export type ConnectSocketType = (options: ConnectSocketOptions) => Promise<Socket>;
 export type DisconnectSocketType = (options: DisconnectSocketOptions) => Promise<boolean>;
+/**
+ * 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 declare class SocketManager {
     private socket;
     validateApiKeyToken(value: string): Promise<boolean>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mediasfu-angular",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "author": "MediaSFU",
   "license": "MIT",
   "description": "MediaSFU Prebuilt Angular SDK",