mediasfu-angular 1.0.0

package/dist/esm2022/lib/methods/stream-methods/click-video.service.mjs

@@ -0,0 +1,183 @@
+// click-video.service.ts
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ClickVideo {
+    /**
+     * Handles the click event to toggle the participant's video on/off and manages video permission requests.
+     *
+     * @param {ClickVideoParams} options - The function parameters.
+     * @returns {Promise<void>}
+     */
+    clickVideo = async ({ parameters }) => {
+        let { checkMediaPermission, hasCameraPermission, videoAlreadyOn, audioOnlyRoom, recordStarted, recordResumed, recordPaused, recordStopped, recordingMediaOptions, islevel, youAreCoHost, adminRestrictSetting, videoRequestState, videoRequestTime, member, socket, roomName, userDefaultVideoInputDevice, currentFacingMode, vidCons, frameRate, videoAction, localStream, audioSetting, videoSetting, screenshareSetting, chatSetting, updateRequestIntervalSeconds, streamSuccessVideo, showAlert, updateVideoAlreadyOn, updateVideoRequestState, updateLocalStream, disconnectSendTransportVideo, requestPermissionCamera, checkPermission, } = parameters;
+        if (audioOnlyRoom) {
+            showAlert?.({
+                message: 'You cannot turn on your camera in an audio only event.',
+                type: 'danger',
+                duration: 3000,
+            });
+            return;
+        }
+        if (videoAlreadyOn) {
+            if (islevel === '2' && (recordStarted || recordResumed)) {
+                if (!(recordPaused || recordStopped) && recordingMediaOptions === 'video') {
+                    showAlert?.({
+                        message: 'You cannot turn off your camera while recording video, please pause or stop recording first.',
+                        type: 'danger',
+                        duration: 3000,
+                    });
+                    return;
+                }
+            }
+            videoAlreadyOn = false;
+            updateVideoAlreadyOn(videoAlreadyOn);
+            if (localStream) {
+                localStream.getVideoTracks()[0].enabled = false;
+            }
+            updateLocalStream(localStream);
+            await disconnectSendTransportVideo({ parameters });
+        }
+        else {
+            if (adminRestrictSetting) {
+                showAlert?.({
+                    message: 'You cannot turn on your camera. Access denied by host.',
+                    type: 'danger',
+                    duration: 3000,
+                });
+                return;
+            }
+            let response = 2;
+            if (!videoAction && islevel !== '2' && !youAreCoHost) {
+                response = await checkPermission({
+                    permissionType: 'videoSetting',
+                    audioSetting,
+                    videoSetting,
+                    screenshareSetting,
+                    chatSetting,
+                });
+            }
+            else {
+                response = 0;
+            }
+            if (response === 1) {
+                if (videoRequestState === 'pending') {
+                    showAlert?.({
+                        message: 'A request is pending. Please wait for the host to respond.',
+                        type: 'danger',
+                        duration: 3000,
+                    });
+                    return;
+                }
+                if (videoRequestState === 'rejected' &&
+                    Date.now() - videoRequestTime < updateRequestIntervalSeconds) {
+                    showAlert?.({
+                        message: `A request was rejected. Please wait for ${updateRequestIntervalSeconds} seconds before sending another request.`,
+                        type: 'danger',
+                        duration: 3000,
+                    });
+                    return;
+                }
+                showAlert?.({
+                    message: 'Request sent to host.',
+                    type: 'success',
+                    duration: 3000,
+                });
+                videoRequestState = 'pending';
+                updateVideoRequestState(videoRequestState);
+                let userRequest = { id: socket.id, name: member, icon: 'fa-video' };
+                socket.emit('participantRequest', { userRequest, roomName });
+            }
+            else if (response === 2) {
+                showAlert?.({
+                    message: 'You cannot turn on your camera. Access denied by host.',
+                    type: 'danger',
+                    duration: 3000,
+                });
+            }
+            else {
+                if (!hasCameraPermission) {
+                    if (checkMediaPermission) {
+                        let statusCamera = await requestPermissionCamera();
+                        if (statusCamera !== 'granted') {
+                            showAlert?.({
+                                message: 'Allow access to your camera or check if your camera is not being used by another application.',
+                                type: 'danger',
+                                duration: 3000,
+                            });
+                            return;
+                        }
+                    }
+                }
+                let mediaConstraints = {};
+                let altMediaConstraints = {};
+                if (userDefaultVideoInputDevice) {
+                    if (vidCons && vidCons.width && vidCons.height) {
+                        mediaConstraints = {
+                            video: {
+                                deviceId: userDefaultVideoInputDevice,
+                                facingMode: currentFacingMode,
+                                ...vidCons,
+                                frameRate: { ideal: frameRate },
+                            },
+                            audio: false,
+                        };
+                        altMediaConstraints = {
+                            video: { ...vidCons, frameRate: { ideal: frameRate } },
+                            audio: false,
+                        };
+                    }
+                    else {
+                        mediaConstraints = {
+                            video: { ...vidCons, frameRate: { ideal: frameRate } },
+                            audio: false,
+                        };
+                        altMediaConstraints = { video: { frameRate: { ideal: frameRate } }, audio: false };
+                    }
+                }
+                else {
+                    if (vidCons && vidCons.width && vidCons.height) {
+                        mediaConstraints = {
+                            video: { ...vidCons, frameRate: { ideal: frameRate } },
+                            audio: false,
+                        };
+                        altMediaConstraints = {
+                            video: { ...vidCons, frameRate: { ideal: frameRate } },
+                            audio: false,
+                        };
+                    }
+                    else {
+                        mediaConstraints = { video: { frameRate: { ideal: frameRate } }, audio: false };
+                    }
+                }
+                await navigator.mediaDevices
+                    .getUserMedia(mediaConstraints)
+                    .then(async (stream) => {
+                    await streamSuccessVideo({ stream, parameters });
+                })
+                    .catch(async () => {
+                    await navigator.mediaDevices
+                        .getUserMedia(altMediaConstraints)
+                        .then(async (stream) => {
+                        await streamSuccessVideo({ stream, parameters });
+                    })
+                        .catch(() => {
+                        showAlert?.({
+                            message: 'Allow access to your camera or check if your camera is not being used by another application.',
+                            type: 'danger',
+                            duration: 3000,
+                        });
+                    });
+                });
+            }
+        }
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ClickVideo, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ClickVideo, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ClickVideo, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"click-video.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/methods/stream-methods/click-video.service.ts"],"names":[],"mappings":"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","sourcesContent":["// click-video.service.ts\nimport { Injectable } from '@angular/core';\nimport {\n  CheckPermissionType,\n  DisconnectSendTransportVideoParameters,\n  DisconnectSendTransportVideoType,\n  RequestPermissionCameraType,\n  ShowAlert,\n  StreamSuccessVideoParameters,\n  StreamSuccessVideoType,\n  VidCons,\n} from '../../@types/types';\nimport { Socket } from 'socket.io-client';\n\nexport interface ClickVideoParameters\n  extends DisconnectSendTransportVideoParameters,\n    StreamSuccessVideoParameters {\n  checkMediaPermission: boolean;\n  hasCameraPermission: boolean;\n  videoAlreadyOn: boolean;\n  audioOnlyRoom: boolean;\n  recordStarted: boolean;\n  recordResumed: boolean;\n  recordPaused: boolean;\n  recordStopped: boolean;\n  recordingMediaOptions: string;\n  islevel: string;\n  youAreCoHost: boolean;\n  adminRestrictSetting: boolean;\n  videoRequestState: string | null;\n  videoRequestTime: number;\n  member: string;\n  socket: Socket;\n  roomName: string;\n  userDefaultVideoInputDevice: string;\n  currentFacingMode: string;\n  vidCons: VidCons;\n  frameRate: number;\n  videoAction: boolean;\n  localStream: MediaStream | null;\n  audioSetting: string;\n  videoSetting: string;\n  screenshareSetting: string;\n  chatSetting: string;\n  updateRequestIntervalSeconds: number;\n\n  showAlert?: ShowAlert;\n  updateVideoAlreadyOn: (value: boolean) => void;\n  updateVideoRequestState: (state: string) => void;\n  updateLocalStream: (stream: MediaStream | null) => void;\n\n  streamSuccessVideo: StreamSuccessVideoType;\n  disconnectSendTransportVideo: DisconnectSendTransportVideoType;\n  requestPermissionCamera: RequestPermissionCameraType;\n  checkPermission: CheckPermissionType;\n\n  getUpdatedAllParams: () => ClickVideoParameters;\n  [key: string]: any;\n}\n\nexport interface ClickVideoOptions {\n  parameters: ClickVideoParameters;\n}\n\n// Export the type definition for the function\nexport type ClickVideoType = (options: ClickVideoOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ClickVideo {\n  /**\n   * Handles the click event to toggle the participant's video on/off and manages video permission requests.\n   *\n   * @param {ClickVideoParams} options - The function parameters.\n   * @returns {Promise<void>}\n   */\n\n  clickVideo = async ({ parameters }: ClickVideoOptions): Promise<void> => {\n    let {\n      checkMediaPermission,\n      hasCameraPermission,\n      videoAlreadyOn,\n      audioOnlyRoom,\n      recordStarted,\n      recordResumed,\n      recordPaused,\n      recordStopped,\n      recordingMediaOptions,\n      islevel,\n      youAreCoHost,\n      adminRestrictSetting,\n      videoRequestState,\n      videoRequestTime,\n      member,\n      socket,\n      roomName,\n      userDefaultVideoInputDevice,\n      currentFacingMode,\n      vidCons,\n      frameRate,\n      videoAction,\n      localStream,\n      audioSetting,\n      videoSetting,\n      screenshareSetting,\n      chatSetting,\n      updateRequestIntervalSeconds,\n      streamSuccessVideo,\n      showAlert,\n      updateVideoAlreadyOn,\n      updateVideoRequestState,\n      updateLocalStream,\n      disconnectSendTransportVideo,\n      requestPermissionCamera,\n      checkPermission,\n    } = parameters;\n\n    if (audioOnlyRoom) {\n      showAlert?.({\n        message: 'You cannot turn on your camera in an audio only event.',\n        type: 'danger',\n        duration: 3000,\n      });\n\n      return;\n    }\n\n    if (videoAlreadyOn) {\n      if (islevel === '2' && (recordStarted || recordResumed)) {\n        if (!(recordPaused || recordStopped) && recordingMediaOptions === 'video') {\n          showAlert?.({\n            message:\n              'You cannot turn off your camera while recording video, please pause or stop recording first.',\n            type: 'danger',\n            duration: 3000,\n          });\n\n          return;\n        }\n      }\n\n      videoAlreadyOn = false;\n      updateVideoAlreadyOn(videoAlreadyOn);\n      if (localStream) {\n        localStream.getVideoTracks()[0].enabled = false;\n      }\n      updateLocalStream(localStream);\n      await disconnectSendTransportVideo({ parameters });\n    } else {\n      if (adminRestrictSetting) {\n        showAlert?.({\n          message: 'You cannot turn on your camera. Access denied by host.',\n          type: 'danger',\n          duration: 3000,\n        });\n\n        return;\n      }\n\n      let response = 2;\n\n      if (!videoAction && islevel !== '2' && !youAreCoHost) {\n        response = await checkPermission({\n          permissionType: 'videoSetting',\n          audioSetting,\n          videoSetting,\n          screenshareSetting,\n          chatSetting,\n        });\n      } else {\n        response = 0;\n      }\n\n      if (response === 1) {\n        if (videoRequestState === 'pending') {\n          showAlert?.({\n            message: 'A request is pending. Please wait for the host to respond.',\n            type: 'danger',\n            duration: 3000,\n          });\n\n          return;\n        }\n\n        if (\n          videoRequestState === 'rejected' &&\n          Date.now() - videoRequestTime < updateRequestIntervalSeconds\n        ) {\n          showAlert?.({\n            message: `A request was rejected. Please wait for ${updateRequestIntervalSeconds} seconds before sending another request.`,\n            type: 'danger',\n            duration: 3000,\n          });\n\n          return;\n        }\n\n        showAlert?.({\n          message: 'Request sent to host.',\n          type: 'success',\n          duration: 3000,\n        });\n\n        videoRequestState = 'pending';\n        updateVideoRequestState(videoRequestState);\n\n        let userRequest = { id: socket.id, name: member, icon: 'fa-video' };\n        socket.emit('participantRequest', { userRequest, roomName });\n      } else if (response === 2) {\n        showAlert?.({\n          message: 'You cannot turn on your camera. Access denied by host.',\n          type: 'danger',\n          duration: 3000,\n        });\n      } else {\n        if (!hasCameraPermission) {\n          if (checkMediaPermission) {\n            let statusCamera = await requestPermissionCamera();\n            if (statusCamera !== 'granted') {\n              showAlert?.({\n                message:\n                  'Allow access to your camera or check if your camera is not being used by another application.',\n                type: 'danger',\n                duration: 3000,\n              });\n\n              return;\n            }\n          }\n        }\n\n        let mediaConstraints = {};\n        let altMediaConstraints = {};\n        if (userDefaultVideoInputDevice) {\n          if (vidCons && vidCons.width && vidCons.height) {\n            mediaConstraints = {\n              video: {\n                deviceId: userDefaultVideoInputDevice,\n                facingMode: currentFacingMode,\n                ...vidCons,\n                frameRate: { ideal: frameRate },\n              },\n              audio: false,\n            };\n            altMediaConstraints = {\n              video: { ...vidCons, frameRate: { ideal: frameRate } },\n              audio: false,\n            };\n          } else {\n            mediaConstraints = {\n              video: { ...vidCons, frameRate: { ideal: frameRate } },\n              audio: false,\n            };\n            altMediaConstraints = { video: { frameRate: { ideal: frameRate } }, audio: false };\n          }\n        } else {\n          if (vidCons && vidCons.width && vidCons.height) {\n            mediaConstraints = {\n              video: { ...vidCons, frameRate: { ideal: frameRate } },\n              audio: false,\n            };\n            altMediaConstraints = {\n              video: { ...vidCons, frameRate: { ideal: frameRate } },\n              audio: false,\n            };\n          } else {\n            mediaConstraints = { video: { frameRate: { ideal: frameRate } }, audio: false };\n          }\n        }\n\n        await navigator.mediaDevices\n          .getUserMedia(mediaConstraints)\n          .then(async (stream: MediaStream) => {\n            await streamSuccessVideo({ stream, parameters });\n          })\n          .catch(async () => {\n            await navigator.mediaDevices\n              .getUserMedia(altMediaConstraints)\n              .then(async (stream: MediaStream) => {\n                await streamSuccessVideo({ stream, parameters });\n              })\n              .catch(() => {\n                showAlert?.({\n                  message:\n                    'Allow access to your camera or check if your camera is not being used by another application.',\n                  type: 'danger',\n                  duration: 3000,\n                });\n              });\n          });\n      }\n    }\n  };\n}\n"]}

package/dist/esm2022/lib/methods/stream-methods/switch-audio.service.mjs

@@ -0,0 +1,33 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class SwitchAudio {
+    /**
+     * Switches the audio input device based on user preference.
+     *
+     * @param {SwitchAudioParams} options - The function parameters.
+     * @returns {Promise<void>}
+     */
+    async switchAudio({ audioPreference, parameters }) {
+        let { defAudioID, userDefaultAudioInputDevice, prevAudioInputDevice, updateUserDefaultAudioInputDevice, updatePrevAudioInputDevice, 
+        //mediasfu functions
+        switchUserAudio, } = parameters;
+        if (audioPreference !== defAudioID) {
+            prevAudioInputDevice = userDefaultAudioInputDevice;
+            updatePrevAudioInputDevice(prevAudioInputDevice);
+            userDefaultAudioInputDevice = audioPreference;
+            updateUserDefaultAudioInputDevice(userDefaultAudioInputDevice);
+            if (defAudioID) {
+                await switchUserAudio({ audioPreference, parameters });
+            }
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: SwitchAudio, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: SwitchAudio, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: SwitchAudio, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/methods/stream-methods/switch-video-alt.service.mjs

@@ -0,0 +1,66 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class SwitchVideoAlt {
+    async switchVideoAlt({ parameters }) {
+        let { recordStarted, recordResumed, recordStopped, recordPaused, recordingMediaOptions, videoAlreadyOn, currentFacingMode, allowed, audioOnlyRoom, updateCurrentFacingMode, updateIsMediaSettingsModalVisible, showAlert, 
+        //media functions
+        switchUserVideoAlt, } = parameters;
+        if (audioOnlyRoom) {
+            showAlert?.({
+                message: 'You cannot turn on your camera in an audio-only event.',
+                type: 'danger',
+                duration: 3000,
+            });
+            return;
+        }
+        let checkoff = false;
+        if ((recordStarted || recordResumed) &&
+            !recordStopped &&
+            !recordPaused &&
+            recordingMediaOptions === 'video') {
+            checkoff = true;
+        }
+        if (!allowed) {
+            showAlert?.({
+                message: 'Allow access to your camera by starting it for the first time.',
+                type: 'danger',
+                duration: 3000,
+            });
+            return;
+        }
+        if (checkoff) {
+            if (videoAlreadyOn) {
+                showAlert?.({
+                    message: 'Please turn off your video before switching.',
+                    type: 'danger',
+                    duration: 3000,
+                });
+                return;
+            }
+        }
+        else {
+            if (!videoAlreadyOn) {
+                showAlert?.({
+                    message: 'Please turn on your video before switching.',
+                    type: 'danger',
+                    duration: 3000,
+                });
+                return;
+            }
+        }
+        // Camera switching logic here
+        let newFacingMode = currentFacingMode === 'environment' ? 'user' : 'environment';
+        updateCurrentFacingMode(newFacingMode);
+        updateIsMediaSettingsModalVisible(false);
+        await switchUserVideoAlt({ videoPreference: newFacingMode, checkoff, parameters });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: SwitchVideoAlt, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: SwitchVideoAlt, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: SwitchVideoAlt, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/methods/stream-methods/switch-video.service.mjs

@@ -0,0 +1,76 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class SwitchVideo {
+    /**
+     * Switches the user's video device based on the provided video preference.
+     *
+     * @param {SwitchVideoParams} options - The function parameters.
+     */
+    async switchVideo({ videoPreference, parameters }) {
+        let { recordStarted, recordResumed, recordStopped, recordPaused, recordingMediaOptions, videoAlreadyOn, userDefaultVideoInputDevice, defVideoID, allowed, updateDefVideoID, updatePrevVideoInputDevice, updateUserDefaultVideoInputDevice, updateIsMediaSettingsModalVisible, 
+        //mediasfu functions
+        showAlert, switchUserVideo, } = parameters;
+        // Check if recording is in progress and whether the selected video device is the default one
+        let checkoff = false;
+        if ((recordStarted || recordResumed) && !recordStopped && !recordPaused) {
+            if (recordingMediaOptions === 'video') {
+                checkoff = true;
+            }
+        }
+        // Check camera access permission
+        if (!allowed) {
+            showAlert?.({
+                message: 'Allow access to your camera by starting it for the first time.',
+                type: 'danger',
+                duration: 3000,
+            });
+            return;
+        }
+        // Check video state and display appropriate alert messages
+        if (checkoff) {
+            if (videoAlreadyOn) {
+                showAlert?.({
+                    message: 'Please turn off your video before switching.',
+                    type: 'danger',
+                    duration: 3000,
+                });
+                return;
+            }
+        }
+        else {
+            if (!videoAlreadyOn) {
+                showAlert?.({
+                    message: 'Please turn on your video before switching.',
+                    type: 'danger',
+                    duration: 3000,
+                });
+                return;
+            }
+        }
+        // Set default video ID if not already set
+        if (!defVideoID) {
+            defVideoID = userDefaultVideoInputDevice ?? 'default';
+            updateDefVideoID(defVideoID);
+        }
+        // Switch video only if the selected video device is different from the default
+        if (videoPreference !== defVideoID) {
+            const prevVideoInputDevice = userDefaultVideoInputDevice;
+            updatePrevVideoInputDevice(prevVideoInputDevice);
+            userDefaultVideoInputDevice = videoPreference;
+            updateUserDefaultVideoInputDevice(userDefaultVideoInputDevice);
+            if (defVideoID) {
+                updateIsMediaSettingsModalVisible(false);
+                await switchUserVideo({ videoPreference, checkoff, parameters });
+            }
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: SwitchVideo, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: SwitchVideo, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: SwitchVideo, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/methods/utils/format-number.service.mjs

@@ -0,0 +1,45 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class FormatNumber {
+    /**
+     * Formats a number into a string representation with appropriate suffixes (K, M, B).
+     *
+     * @param number - The number to format.
+     * @returns A promise that resolves to a formatted string or undefined if the input is falsy.
+     *
+     * @example
+     * ```typescript
+     * formatNumber(500); // "500"
+     * formatNumber(1500); // "1.5K"
+     * formatNumber(1500000); // "1.5M"
+     * formatNumber(1500000000); // "1.5B"
+     * ```
+     */
+    async formatNumber({ number }) {
+        if (number) {
+            if (number < 1e3) {
+                return number.toString();
+            }
+            else if (number < 1e6) {
+                return (number / 1e3).toFixed(1) + 'K';
+            }
+            else if (number < 1e9) {
+                return (number / 1e6).toFixed(1) + 'M';
+            }
+            else if (number < 1e12) {
+                return (number / 1e9).toFixed(1) + 'B';
+            }
+        }
+        // Return undefined for falsy input values
+        return undefined;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: FormatNumber, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: FormatNumber, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: FormatNumber, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/methods/utils/generate-random-messages.service.mjs

@@ -0,0 +1,87 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class GenerateRandomMessages {
+    /**
+     * Generates random messages for a given set of participants.
+     *
+     * @param {Object} options - The options for generating random messages.
+     * @param {Array} options.participants - The list of participants.
+     * @param {string} options.member - The member who is part of the chat.
+     * @param {string} [options.coHost=""] - The co-host of the chat.
+     * @param {string} options.host - The host of the chat.
+     * @param {boolean} [options.forChatBroadcast=false] - Flag to indicate if the messages are for chat broadcast.
+     * @returns {Message[]} An array of generated messages.
+     */
+    generateRandomMessages({ participants, member, coHost = '', host, forChatBroadcast = false, }) {
+        const messages = [];
+        // Function to get a random participant other than the sender
+        const getRandomReceiver = (sender) => {
+            const potentialReceivers = participants.filter((participant) => participant.name !== sender);
+            const randomReceiver = potentialReceivers[Math.floor(Math.random() * potentialReceivers.length)];
+            return randomReceiver.name || '';
+        };
+        // Force add messages for specific participants
+        let refNames = [];
+        if (forChatBroadcast) {
+            refNames = [member, host];
+        }
+        else {
+            if (coHost) {
+                refNames = [
+                    member,
+                    coHost,
+                    host,
+                    ...participants
+                        .map((participant) => participant.name)
+                        .filter((name) => name !== undefined),
+                ];
+            }
+            else {
+                refNames = [
+                    member,
+                    host,
+                    ...participants
+                        .map((participant) => participant.name)
+                        .filter((name) => name !== undefined),
+                ];
+            }
+        }
+        // Return unique names for the refNames
+        refNames = [...new Set(refNames)];
+        // Generate messages
+        let timeIncrement = 0;
+        refNames.forEach((sender) => {
+            // Send direct messages
+            const directMessage = {
+                sender: sender,
+                receivers: [getRandomReceiver(sender)],
+                message: `Direct message from ${sender}`,
+                timestamp: new Date(Date.now() + timeIncrement).toLocaleTimeString(),
+                group: false,
+            };
+            messages.push(directMessage);
+            // Send group messages
+            const groupMessage = {
+                sender: sender,
+                receivers: participants
+                    .map((participant) => participant.name)
+                    .filter((name) => name !== undefined),
+                message: `Group message from ${sender}`,
+                timestamp: new Date(Date.now() + timeIncrement).toLocaleTimeString(),
+                group: true,
+            };
+            messages.push(groupMessage);
+            timeIncrement += 15000; // Increment time by 15 seconds for each message
+        });
+        return messages;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: GenerateRandomMessages, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: GenerateRandomMessages, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: GenerateRandomMessages, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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