mediasfu-angular 1.0.0

package/dist/lib/methods/recording-methods/launch-recording.service.d.ts

@@ -0,0 +1,42 @@
+import { ShowAlert } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface LaunchRecordingOptions {
+    updateIsRecordingModalVisible: (visible: boolean) => void;
+    isRecordingModalVisible: boolean;
+    showAlert?: ShowAlert;
+    stopLaunchRecord: boolean;
+    canLaunchRecord: boolean;
+    recordingAudioSupport: boolean;
+    recordingVideoSupport: boolean;
+    updateCanRecord: (canRecord: boolean) => void;
+    updateClearedToRecord: (cleared: boolean) => void;
+    recordStarted: boolean;
+    recordPaused: boolean;
+    localUIMode: boolean;
+    [key: string]: any;
+}
+export type LaunchRecordingType = (options: LaunchRecordingOptions) => void;
+export declare class LaunchRecording {
+    /**
+     * Launches the recording process based on various conditions and updates the UI accordingly.
+     *
+     * @param {Object} options - The options for launching the recording.
+     * @param {Function} options.updateIsRecordingModalVisible - Function to update the visibility of the recording modal.
+     * @param {boolean} options.isRecordingModalVisible - Indicates if the recording modal is currently visible.
+     * @param {Function} options.showAlert - Function to show an alert message.
+     * @param {boolean} options.stopLaunchRecord - Indicates if the recording launch should be stopped.
+     * @param {boolean} options.canLaunchRecord - Indicates if the recording can be launched.
+     * @param {boolean} options.recordingAudioSupport - Indicates if audio recording is supported.
+     * @param {boolean} options.recordingVideoSupport - Indicates if video recording is supported.
+     * @param {Function} options.updateCanRecord - Function to update the recording capability.
+     * @param {Function} options.updateClearedToRecord - Function to update the cleared-to-record status.
+     * @param {boolean} options.recordStarted - Indicates if the recording has started.
+     * @param {boolean} options.recordPaused - Indicates if the recording is paused.
+     * @param {boolean} options.localUIMode - Indicates if the local UI mode is active.
+     *
+     * @returns {void}
+     */
+    launchRecording({ updateIsRecordingModalVisible, isRecordingModalVisible, showAlert, stopLaunchRecord, canLaunchRecord, recordingAudioSupport, recordingVideoSupport, updateCanRecord, updateClearedToRecord, recordStarted, recordPaused, localUIMode, }: LaunchRecordingOptions): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LaunchRecording, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LaunchRecording>;
+}

package/dist/lib/methods/recording-methods/record-pause-timer.service.d.ts

@@ -0,0 +1,25 @@
+import { ShowAlert } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface RecordPauseTimerOptions {
+    stop?: boolean;
+    isTimerRunning: boolean;
+    canPauseResume: boolean;
+    showAlert?: ShowAlert;
+}
+export type RecordPauseTimerType = (options: RecordPauseTimerOptions) => boolean;
+export declare class RecordPauseTimer {
+    /**
+     * Controls the pause and resume functionality of a recording timer.
+     *
+     * @param {Object} options - The options for controlling the timer.
+     * @param {boolean} [options.stop=false] - Indicates whether to stop the timer.
+     * @param {Object} options.parameters - The parameters for the timer control.
+     * @param {boolean} options.parameters.isTimerRunning - Indicates if the timer is currently running.
+     * @param {boolean} options.parameters.canPauseResume - Indicates if the timer can be paused or resumed.
+     * @param {Function} [options.parameters.showAlert] - Optional function to show an alert message.
+     * @returns {boolean} - Returns true if the timer can be paused or resumed, otherwise false.
+     */
+    recordPauseTimer: ({ stop, isTimerRunning, canPauseResume, showAlert, }: RecordPauseTimerOptions) => boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RecordPauseTimer, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RecordPauseTimer>;
+}

package/dist/lib/methods/recording-methods/record-resume-timer.service.d.ts

@@ -0,0 +1,47 @@
+import { ShowAlert } from '../../@types/types';
+import { RecordUpdateTimer } from './record-update-timer.service';
+import * as i0 from "@angular/core";
+export interface RecordResumeTimerParameters {
+    isTimerRunning: boolean;
+    canPauseResume: boolean;
+    recordElapsedTime: number;
+    recordStartTime: number;
+    recordTimerInterval?: NodeJS.Timeout | null;
+    showAlert?: ShowAlert;
+    updateRecordStartTime: (time: number) => void;
+    updateRecordTimerInterval: (interval: NodeJS.Timeout | null) => void;
+    updateIsTimerRunning: (isRunning: boolean) => void;
+    updateCanPauseResume: (canPause: boolean) => void;
+    getUpdatedAllParams: () => RecordResumeTimerParameters;
+    [key: string]: any;
+}
+export interface RecordResumeTimerOptions {
+    parameters: RecordResumeTimerParameters;
+}
+export type RecordResumeTimerType = (options: RecordResumeTimerOptions) => Promise<boolean>;
+export declare class RecordResumeTimer {
+    private RecordUpdateTimerService;
+    constructor(RecordUpdateTimerService: RecordUpdateTimer);
+    /**
+     * Resumes the recording timer if it is not already running and can be paused/resumed.
+     *
+     * @param {RecordResumeTimerOptions} options - The options for resuming the recording timer.
+     * @param {Object} options.parameters - The parameters for the recording timer.
+     * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+     * @param {boolean} options.parameters.isTimerRunning - Indicates if the timer is currently running.
+     * @param {boolean} options.parameters.canPauseResume - Indicates if the timer can be paused/resumed.
+     * @param {number} options.parameters.recordElapsedTime - The elapsed recording time in seconds.
+     * @param {number} options.parameters.recordStartTime - The start time of the recording.
+     * @param {number | null} options.parameters.recordTimerInterval - The interval ID for the recording timer.
+     * @param {Function} options.parameters.showAlert - Function to show an alert message.
+     * @param {Function} options.parameters.updateRecordStartTime - Function to update the recording start time.
+     * @param {Function} options.parameters.updateRecordTimerInterval - Function to update the recording timer interval.
+     * @param {Function} options.parameters.updateIsTimerRunning - Function to update the timer running status.
+     * @param {Function} options.parameters.updateCanPauseResume - Function to update the pause/resume status.
+     *
+     * @returns {Promise<boolean>} - Returns a promise that resolves to true if the timer was successfully resumed, otherwise false.
+     */
+    recordResumeTimer: ({ parameters }: RecordResumeTimerOptions) => Promise<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RecordResumeTimer, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RecordResumeTimer>;
+}

package/dist/lib/methods/recording-methods/record-start-timer.service.d.ts

@@ -0,0 +1,58 @@
+import { RecordUpdateTimer } from './record-update-timer.service';
+import * as i0 from "@angular/core";
+export interface RecordStartTimerParameters {
+    recordStartTime: number;
+    recordTimerInterval?: NodeJS.Timeout | null;
+    isTimerRunning: boolean;
+    canPauseResume: boolean;
+    recordChangeSeconds: number;
+    recordPaused: boolean;
+    recordStopped: boolean;
+    roomName: string | null;
+    updateRecordStartTime: (time: number) => void;
+    updateRecordTimerInterval: (interval: NodeJS.Timeout | null) => void;
+    updateIsTimerRunning: (isRunning: boolean) => void;
+    updateCanPauseResume: (canPause: boolean) => void;
+    getUpdatedAllParams: () => RecordStartTimerParameters;
+    [key: string]: any;
+}
+export interface RecordStartTimerOptions {
+    parameters: RecordStartTimerParameters;
+}
+export type RecordStartTimerType = (options: RecordStartTimerOptions) => Promise<void>;
+export declare class RecordStartTimer {
+    private RecordUpdateTimerService;
+    constructor(RecordUpdateTimerService: RecordUpdateTimer);
+    /**
+     * Starts the recording timer.
+     * @function
+     * @param {RecordStartTimerOptions} options - The options object containing necessary variables and functions.
+     */
+    /**
+     * Starts a recording timer and manages its state.
+     *
+     * @param {RecordStartTimerOptions} options - The options for starting the recording timer.
+     * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+     * @param {number} options.parameters.recordStartTime - The start time of the recording.
+     * @param {number | null} options.parameters.recordTimerInterval - The interval ID for the recording timer.
+     * @param {boolean} options.parameters.isTimerRunning - Flag indicating if the timer is running.
+     * @param {boolean} options.parameters.canPauseResume - Flag indicating if pause/resume actions are enabled.
+     * @param {number} options.parameters.recordChangeSeconds - The time after which pause/resume actions are enabled.
+     * @param {Function} options.parameters.updateRecordStartTime - Function to update the recording start time.
+     * @param {Function} options.parameters.updateRecordTimerInterval - Function to update the recording timer interval.
+     * @param {Function} options.parameters.updateIsTimerRunning - Function to update the timer running state.
+     * @param {Function} options.parameters.updateCanPauseResume - Function to update the pause/resume state.
+     *
+     * @returns {Promise<void>} A promise that resolves when the timer is started.
+     *
+     * @remarks
+     * This function initializes the recording start time and sets up an interval to update the timer every second.
+     * It also manages the state of the timer, including enabling and disabling pause/resume actions.
+     * The timer is stopped if the recording is paused, stopped, or if the room name is invalid.
+     */
+    recordStartTimer: ({ parameters }: {
+        parameters: any;
+    }) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RecordStartTimer, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RecordStartTimer>;
+}

package/dist/lib/methods/recording-methods/record-update-timer.service.d.ts

@@ -0,0 +1,29 @@
+import * as i0 from "@angular/core";
+export interface RecordUpdateTimerOptions {
+    recordElapsedTime: number;
+    recordStartTime: number;
+    updateRecordElapsedTime: (elapsedTime: number) => void;
+    updateRecordingProgressTime: (formattedTime: string) => void;
+}
+export type RecordUpdateTimerType = (options: RecordUpdateTimerOptions) => void;
+export declare class RecordUpdateTimer {
+    /**
+     * Updates the recording timer and progress time.
+     * @function
+     * @param {RecordUpdateTimerOptions} options - The options object containing necessary variables and functions.
+     */
+    /**
+     * Updates the recording timer by calculating the elapsed time since the recording started
+     * and formatting it in HH:MM:SS format.
+     *
+     * @param {Object} options - The options object.
+     * @param {number} options.recordElapsedTime - The elapsed recording time in seconds.
+     * @param {number} options.recordStartTime - The timestamp when the recording started.
+     * @param {Function} options.updateRecordElapsedTime - Callback to update the elapsed recording time.
+     * @param {Function} options.updateRecordingProgressTime - Callback to update the formatted recording time.
+     * @returns {void}
+     */
+    recordUpdateTimer({ recordElapsedTime, recordStartTime, updateRecordElapsedTime, updateRecordingProgressTime, }: RecordUpdateTimerOptions): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RecordUpdateTimer, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RecordUpdateTimer>;
+}

package/dist/lib/methods/recording-methods/start-recording.service.d.ts

@@ -0,0 +1,83 @@
+import { RecordStartTimer } from './record-start-timer.service';
+import { RecordResumeTimer, RecordResumeTimerParameters } from './record-resume-timer.service';
+import { Socket } from 'socket.io-client';
+import { RePortType, UserRecordingParams, CaptureCanvasStreamType, CaptureCanvasStreamParameters, RePortParameters, ShowAlert } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface StartRecordingParameters extends CaptureCanvasStreamParameters, RePortParameters, RecordResumeTimerParameters {
+    roomName: string;
+    userRecordingParams: UserRecordingParams;
+    socket: Socket;
+    updateIsRecordingModalVisible: (visible: boolean) => void;
+    confirmedToRecord: boolean;
+    showAlert?: ShowAlert;
+    recordingMediaOptions: string;
+    videoAlreadyOn: boolean;
+    audioAlreadyOn: boolean;
+    recordStarted: boolean;
+    recordPaused: boolean;
+    recordResumed: boolean;
+    recordStopped: boolean;
+    startReport: boolean;
+    endReport: boolean;
+    canRecord: boolean;
+    updateClearedToRecord: (cleared: boolean) => void;
+    updateRecordStarted: (started: boolean) => void;
+    updateRecordPaused: (paused: boolean) => void;
+    updateRecordResumed: (resumed: boolean) => void;
+    updateStartReport: (started: boolean) => void;
+    updateEndReport: (ended: boolean) => void;
+    updateCanRecord: (canRecord: boolean) => void;
+    whiteboardStarted: boolean;
+    whiteboardEnded: boolean;
+    rePort: RePortType;
+    captureCanvasStream: CaptureCanvasStreamType;
+    getUpdatedAllParams: () => StartRecordingParameters;
+    [key: string]: any;
+}
+export interface StartRecordingOptions {
+    parameters: StartRecordingParameters;
+}
+export type StartRecordingType = (options: StartRecordingOptions) => Promise<boolean | undefined>;
+export declare class StartRecording {
+    private RecordStartTimerService;
+    private RecordResumeTimerService;
+    constructor(RecordStartTimerService: RecordStartTimer, RecordResumeTimerService: RecordResumeTimer);
+    /**
+     * Starts the recording process based on the provided parameters.
+     *
+     * @param {StartRecordingOptions} options - The options for starting the recording.
+     * @param {object} options.parameters - The parameters required for starting the recording.
+     * @param {string} options.parameters.roomName - The name of the room where recording is to be started.
+     * @param {object} options.parameters.userRecordingParams - User-specific recording parameters.
+     * @param {object} options.parameters.socket - The socket instance for communication.
+     * @param {function} options.parameters.updateIsRecordingModalVisible - Function to update the visibility of the recording modal.
+     * @param {boolean} options.parameters.confirmedToRecord - Flag indicating if the user has confirmed to record.
+     * @param {function} options.parameters.showAlert - Function to show alerts.
+     * @param {string} options.parameters.recordingMediaOptions - The media options for recording (e.g., "video", "audio").
+     * @param {boolean} options.parameters.videoAlreadyOn - Flag indicating if the video is already on.
+     * @param {boolean} options.parameters.audioAlreadyOn - Flag indicating if the audio is already on.
+     * @param {boolean} options.parameters.recordStarted - Flag indicating if the recording has started.
+     * @param {boolean} options.parameters.recordPaused - Flag indicating if the recording is paused.
+     * @param {boolean} options.parameters.recordResumed - Flag indicating if the recording is resumed.
+     * @param {boolean} options.parameters.recordStopped - Flag indicating if the recording is stopped.
+     * @param {boolean} options.parameters.startReport - Flag indicating if the start report is active.
+     * @param {boolean} options.parameters.endReport - Flag indicating if the end report is active.
+     * @param {boolean} options.parameters.canRecord - Flag indicating if recording is allowed.
+     * @param {function} options.parameters.updateClearedToRecord - Function to update the cleared to record status.
+     * @param {function} options.parameters.updateRecordStarted - Function to update the record started status.
+     * @param {function} options.parameters.updateRecordPaused - Function to update the record paused status.
+     * @param {function} options.parameters.updateRecordResumed - Function to update the record resumed status.
+     * @param {function} options.parameters.updateStartReport - Function to update the start report status.
+     * @param {function} options.parameters.updateEndReport - Function to update the end report status.
+     * @param {function} options.parameters.updateCanRecord - Function to update the can record status.
+     * @param {boolean} options.parameters.whiteboardStarted - Flag indicating if the whiteboard has started.
+     * @param {boolean} options.parameters.whiteboardEnded - Flag indicating if the whiteboard has ended.
+     * @param {function} options.parameters.rePort - Function to report the recording status.
+     * @param {function} options.parameters.captureCanvasStream - Function to capture the canvas stream.
+     *
+     * @returns {Promise<boolean | undefined>} - A promise that resolves to a boolean indicating if the recording attempt was successful, or undefined if not applicable.
+     */
+    startRecording: ({ parameters }: StartRecordingOptions) => Promise<boolean | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StartRecording, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StartRecording>;
+}

package/dist/lib/methods/recording-methods/stop-recording.service.d.ts

@@ -0,0 +1,37 @@
+import { RecordPauseTimer } from './record-pause-timer.service';
+import { ShowAlert } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface StopRecordingParameters {
+    roomName: string;
+    socket: any;
+    showAlert?: ShowAlert;
+    startReport: boolean;
+    endReport: boolean;
+    recordStarted: boolean;
+    recordPaused: boolean;
+    recordStopped: boolean;
+    updateRecordPaused: (paused: boolean) => void;
+    updateRecordStopped: (stopped: boolean) => void;
+    updateStartReport: (startReport: boolean) => void;
+    updateEndReport: (endReport: boolean) => void;
+    updateShowRecordButtons: (show: boolean) => void;
+    whiteboardStarted: boolean;
+    whiteboardEnded: boolean;
+    recordingMediaOptions: string;
+    captureCanvasStream: (options: {
+        parameters: any;
+        start?: boolean;
+    }) => void;
+    [key: string]: any;
+}
+export interface StopRecordingOptions {
+    parameters: StopRecordingParameters;
+}
+export type StopRecordingType = (options: StopRecordingOptions) => Promise<void>;
+export declare class StopRecording {
+    private RecordPauseTimerService;
+    constructor(RecordPauseTimerService: RecordPauseTimer);
+    stopRecording({ parameters }: StopRecordingOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StopRecording, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StopRecording>;
+}

package/dist/lib/methods/recording-methods/update-recording.service.d.ts

@@ -0,0 +1,88 @@
+import { CheckPauseState } from './check-pause-state.service';
+import { CheckResumeState } from './check-resume-state.service';
+import { RecordPauseTimer } from './record-pause-timer.service';
+import { RecordResumeTimer, RecordResumeTimerParameters } from './record-resume-timer.service';
+import { RePortParameters, RePortType, ShowAlert, UserRecordingParams } from '../../@types/types';
+import { Socket } from 'socket.io-client';
+import * as i0 from "@angular/core";
+export interface UpdateRecordingParameters extends RecordResumeTimerParameters, RePortParameters {
+    roomName: string;
+    userRecordingParams: UserRecordingParams;
+    socket: Socket;
+    updateIsRecordingModalVisible: (visible: boolean) => void;
+    confirmedToRecord: boolean;
+    showAlert?: ShowAlert;
+    recordingMediaOptions: string;
+    videoAlreadyOn: boolean;
+    audioAlreadyOn: boolean;
+    recordStarted: boolean;
+    recordPaused: boolean;
+    recordResumed: boolean;
+    recordStopped: boolean;
+    recordChangeSeconds: number;
+    pauseRecordCount: number;
+    startReport: boolean;
+    endReport: boolean;
+    canRecord: boolean;
+    canPauseResume: boolean;
+    updateCanPauseResume: (canPauseResume: boolean) => void;
+    updatePauseRecordCount: (count: number) => void;
+    updateClearedToRecord: (cleared: boolean) => void;
+    updateRecordPaused: (paused: boolean) => void;
+    updateRecordResumed: (resumed: boolean) => void;
+    updateStartReport: (start: boolean) => void;
+    updateEndReport: (end: boolean) => void;
+    updateCanRecord: (canRecord: boolean) => void;
+    rePort: RePortType;
+    getUpdatedAllParams: () => UpdateRecordingParameters;
+    [key: string]: any;
+}
+export interface UpdateRecordingOptions {
+    parameters: UpdateRecordingParameters;
+}
+export type UpdateRecordingType = (options: UpdateRecordingOptions) => Promise<void>;
+export declare class UpdateRecording {
+    private CheckPauseStateService;
+    private CheckResumeStateService;
+    private RecordPauseTimerService;
+    private RecordResumeTimerService;
+    constructor(CheckPauseStateService: CheckPauseState, CheckResumeStateService: CheckResumeState, RecordPauseTimerService: RecordPauseTimer, RecordResumeTimerService: RecordResumeTimer);
+    /**
+     * Updates the recording state based on the provided parameters.
+     *
+     * @param {UpdateRecordingOptions} parameters - The parameters for updating the recording state.
+     * @returns {Promise<void>} A promise that resolves when the recording state has been updated.
+     *
+     * @property {string} roomName - The name of the room where the recording is taking place.
+     * @property {any} userRecordingParams - Parameters related to the user's recording settings.
+     * @property {any} socket - The socket connection used for communication.
+     * @property {Function} updateIsRecordingModalVisible - Function to update the visibility of the recording modal.
+     * @property {boolean} confirmedToRecord - Indicates if the user has confirmed to start recording.
+     * @property {Function} showAlert - Function to show alert messages.
+     * @property {string} recordingMediaOptions - The media options for recording (e.g., "video", "audio").
+     * @property {boolean} videoAlreadyOn - Indicates if the video is already turned on.
+     * @property {boolean} audioAlreadyOn - Indicates if the audio is already turned on.
+     * @property {boolean} recordStarted - Indicates if the recording has started.
+     * @property {boolean} recordPaused - Indicates if the recording is paused.
+     * @property {boolean} recordResumed - Indicates if the recording has resumed.
+     * @property {boolean} recordStopped - Indicates if the recording has stopped.
+     * @property {number} recordChangeSeconds - The interval in seconds for changing the recording state.
+     * @property {number} pauseRecordCount - The count of pauses during the recording.
+     * @property {boolean} startReport - Indicates if the start report is active.
+     * @property {boolean} endReport - Indicates if the end report is active.
+     * @property {boolean} canRecord - Indicates if recording is allowed.
+     * @property {boolean} canPauseResume - Indicates if pausing and resuming the recording is allowed.
+     * @property {Function} updateCanPauseResume - Function to update the pause/resume state.
+     * @property {Function} updatePauseRecordCount - Function to update the pause record count.
+     * @property {Function} updateClearedToRecord - Function to update the cleared-to-record state.
+     * @property {Function} updateRecordPaused - Function to update the record paused state.
+     * @property {Function} updateRecordResumed - Function to update the record resumed state.
+     * @property {Function} updateStartReport - Function to update the start report state.
+     * @property {Function} updateEndReport - Function to update the end report state.
+     * @property {Function} updateCanRecord - Function to update the can record state.
+     * @property {Function} rePort - Function to handle reporting.
+     */
+    updateRecording: ({ parameters }: UpdateRecordingOptions) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UpdateRecording, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UpdateRecording>;
+}

package/dist/lib/methods/requests-methods/launch-requests.service.d.ts

@@ -0,0 +1,19 @@
+import * as i0 from "@angular/core";
+export interface LaunchRequestsOptions {
+    updateIsRequestsModalVisible: (isVisible: boolean) => void;
+    isRequestsModalVisible: boolean;
+}
+export type LaunchRequestsType = (options: LaunchRequestsOptions) => void;
+export declare class LaunchRequests {
+    /**
+     * Toggles the visibility state of the requests modal.
+     *
+     * @param {LaunchRequestsOptions} options - The options for launching requests.
+     * @param {Function} options.updateIsRequestsModalVisible - Function to update the visibility state of the requests modal.
+     * @param {boolean} options.isRequestsModalVisible - Current visibility state of the requests modal.
+     * @returns {void}
+     */
+    launchRequests({ updateIsRequestsModalVisible, isRequestsModalVisible, }: LaunchRequestsOptions): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LaunchRequests, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LaunchRequests>;
+}

package/dist/lib/methods/requests-methods/respond-to-requests.service.d.ts

@@ -0,0 +1,30 @@
+import { Socket } from 'socket.io-client';
+import { Request } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface RespondToRequestsOptions {
+    socket: Socket;
+    request: Request;
+    updateRequestList: (newRequestList: Request[]) => void;
+    requestList: Request[];
+    action: string;
+    roomName: string;
+}
+export type RespondToRequestsType = (options: RespondToRequestsOptions) => Promise<void>;
+export declare class RespondToRequests {
+    /**
+     * Responds to incoming requests by updating the request list and emitting a response to the server.
+     *
+     * @param {Object} options - The options for responding to requests.
+     * @param {Socket} options.socket - The socket instance used to emit the response.
+     * @param {Request} options.request - The request object containing details of the request.
+     * @param {Function} options.updateRequestList - The function to update the request list.
+     * @param {Request[]} options.requestList - The current list of requests.
+     * @param {string} options.action - The action to be taken on the request.
+     * @param {string} options.roomName - The name of the room to which the response should be emitted.
+     *
+     * @returns {Promise<void>} A promise that resolves when the response has been emitted.
+     */
+    respondToRequests({ socket, request, updateRequestList, requestList, action, roomName, }: RespondToRequestsOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RespondToRequests, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RespondToRequests>;
+}

package/dist/lib/methods/settings-methods/launch-settings.service.d.ts

@@ -0,0 +1,19 @@
+import * as i0 from "@angular/core";
+export interface LaunchSettingsOptions {
+    updateIsSettingsModalVisible: (isVisible: boolean) => void;
+    isSettingsModalVisible: boolean;
+}
+export type LaunchSettingsType = (options: LaunchSettingsOptions) => void;
+export declare class LaunchSettings {
+    /**
+     * Toggles the visibility state of the settings modal.
+     *
+     * @param {LaunchSettingsOptions} options - The options for launching settings.
+     * @param {Function} options.updateIsSettingsModalVisible - Function to update the visibility state of the settings modal.
+     * @param {boolean} options.isSettingsModalVisible - Current visibility state of the settings modal.
+     * @returns {void}
+     */
+    launchSettings({ updateIsSettingsModalVisible, isSettingsModalVisible, }: LaunchSettingsOptions): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LaunchSettings, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LaunchSettings>;
+}

package/dist/lib/methods/settings-methods/modify-settings.service.d.ts

@@ -0,0 +1,44 @@
+import { Socket } from 'socket.io-client';
+import { ShowAlert } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface ModifySettingsOptions {
+    showAlert?: ShowAlert;
+    roomName: string;
+    audioSet: string;
+    videoSet: string;
+    screenshareSet: string;
+    chatSet: string;
+    socket: Socket;
+    updateAudioSetting: (audioSet: string) => void;
+    updateVideoSetting: (videoSet: string) => void;
+    updateScreenshareSetting: (screenshareSet: string) => void;
+    updateChatSetting: (chatSet: string) => void;
+    updateIsSettingsModalVisible: (isVisible: boolean) => void;
+}
+export type ModifySettingsType = (options: ModifySettingsOptions) => Promise<void>;
+export declare class ModifySettings {
+    /**
+     * Modifies the settings for a given room and updates the state accordingly.
+     *
+     * @param {Object} options - The options for modifying settings.
+     * @param {Function} options.showAlert - Function to show alert messages.
+     * @param {string} options.roomName - The name of the room.
+     * @param {string} options.audioSet - The audio setting to be applied.
+     * @param {string} options.videoSet - The video setting to be applied.
+     * @param {string} options.screenshareSet - The screenshare setting to be applied.
+     * @param {string} options.chatSet - The chat setting to be applied.
+     * @param {Object} options.socket - The socket instance for emitting events.
+     * @param {Function} options.updateAudioSetting - Function to update the audio setting state.
+     * @param {Function} options.updateVideoSetting - Function to update the video setting state.
+     * @param {Function} options.updateScreenshareSetting - Function to update the screenshare setting state.
+     * @param {Function} options.updateChatSetting - Function to update the chat setting state.
+     * @param {Function} options.updateIsSettingsModalVisible - Function to update the visibility of the settings modal.
+     *
+     * @returns {Promise<void>} A promise that resolves when the settings have been modified.
+     *
+     * @throws Will show an alert if any setting is set to "approval" in demo mode (room name starts with "d").
+     */
+    modifySettings: ({ showAlert, roomName, audioSet, videoSet, screenshareSet, chatSet, socket, updateAudioSetting, updateVideoSetting, updateScreenshareSetting, updateChatSetting, updateIsSettingsModalVisible, }: ModifySettingsOptions) => Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModifySettings, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ModifySettings>;
+}

package/dist/lib/methods/stream-methods/click-audio.service.d.ts

@@ -0,0 +1,73 @@
+import { CheckPermissionType, DisconnectSendTransportAudioParameters, DisconnectSendTransportAudioType, Participant, RequestPermissionAudioType, ResumeSendTransportAudioParameters, ResumeSendTransportAudioType, ShowAlert, StreamSuccessAudioParameters, StreamSuccessAudioType } from '../../@types/types';
+import { Socket } from 'socket.io-client';
+import * as i0 from "@angular/core";
+export interface ClickAudioParameters extends DisconnectSendTransportAudioParameters, ResumeSendTransportAudioParameters, StreamSuccessAudioParameters {
+    checkMediaPermission: boolean;
+    hasAudioPermission: boolean;
+    audioPaused: boolean;
+    audioAlreadyOn: boolean;
+    audioOnlyRoom: boolean;
+    recordStarted: boolean;
+    recordResumed: boolean;
+    recordPaused: boolean;
+    recordStopped: boolean;
+    recordingMediaOptions: string;
+    islevel: string;
+    youAreCoHost: boolean;
+    adminRestrictSetting: boolean;
+    audioRequestState: string | null;
+    audioRequestTime: number;
+    member: string;
+    socket: Socket;
+    roomName: string;
+    userDefaultAudioInputDevice: string;
+    micAction: boolean;
+    localStream: MediaStream | null;
+    audioSetting: string;
+    videoSetting: string;
+    screenshareSetting: string;
+    chatSetting: string;
+    updateRequestIntervalSeconds: number;
+    participants: Participant[];
+    transportCreated: boolean;
+    transportCreatedAudio: boolean;
+    updateAudioAlreadyOn: (status: boolean) => void;
+    updateAudioRequestState: (state: string | null) => void;
+    updateAudioPaused: (status: boolean) => void;
+    updateLocalStream: (stream: MediaStream | null) => void;
+    updateParticipants: (participants: Participant[]) => void;
+    updateTransportCreated: (status: boolean) => void;
+    updateTransportCreatedAudio: (status: boolean) => void;
+    updateMicAction: (action: boolean) => void;
+    showAlert?: ShowAlert;
+    checkPermission: CheckPermissionType;
+    streamSuccessAudio: StreamSuccessAudioType;
+    disconnectSendTransportAudio: DisconnectSendTransportAudioType;
+    requestPermissionAudio: RequestPermissionAudioType;
+    resumeSendTransportAudio: ResumeSendTransportAudioType;
+    getUpdatedAllParams: () => ClickAudioParameters;
+    [key: string]: any;
+}
+export interface ClickAudioOptions {
+    parameters: ClickAudioParameters;
+}
+export type ClickAudioType = (options: ClickAudioOptions) => Promise<void>;
+export declare class ClickAudio {
+    /**
+     * Handles the click event for toggling audio in a media session.
+     *
+     * @param {ClickAudioOptions} parameters - The parameters required for handling the audio click event.
+     * @returns {Promise<void>} A promise that resolves when the audio click event has been handled.
+     *
+     * The function performs the following actions:
+     * - If the event is audio-only, it shows an alert and exits.
+     * - If the audio is already on, it handles the logic for turning it off, including checking recording states and permissions.
+     * - If the audio is off, it checks for admin restrictions, user permissions, and handles the logic for turning the audio on.
+     * - It updates various states and emits socket events as necessary.
+     *
+     * The function makes use of several helper functions and state update functions passed in through the parameters.
+     */
+    clickAudio({ parameters }: ClickAudioOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClickAudio, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ClickAudio>;
+}

package/dist/lib/methods/stream-methods/click-chat.service.d.ts

@@ -0,0 +1,27 @@
+import { ShowAlert } from '../../@types/types';
+import * as i0 from "@angular/core";
+export interface ClickChatOptions {
+    isMessagesModalVisible: boolean;
+    updateIsMessagesModalVisible: (isVisible: boolean) => void;
+    chatSetting: string;
+    islevel: string;
+    showAlert?: ShowAlert;
+}
+export type ClickChatType = (options: ClickChatOptions) => Promise<void>;
+export declare class ClickChat {
+    /**
+     * Toggles the visibility of the chat modal based on the current state and event settings.
+     *
+     * @param {Object} options - The options for the clickChat function.
+     * @param {boolean} options.isMessagesModalVisible - Indicates if the messages modal is currently visible.
+     * @param {Function} options.updateIsMessagesModalVisible - Function to update the visibility state of the messages modal.
+     * @param {string} options.chatSetting - The chat setting for the event, which can be "allow" or other values.
+     * @param {string} options.islevel - The participant's level, where "2" indicates a level that allows chat.
+     * @param {Function} [options.showAlert] - Optional function to show an alert message.
+     *
+     * @returns {Promise<void>} A promise that resolves when the operation is complete.
+     */
+    clickChat({ isMessagesModalVisible, updateIsMessagesModalVisible, chatSetting, islevel, showAlert, }: ClickChatOptions): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClickChat, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ClickChat>;
+}