mediasfu-angular 1.0.0 → 1.0.2

package/dist/esm2022/lib/producer-client/producer-client-emits/update-room-parameters-client.service.mjs

@@ -7,6 +7,50 @@ import * as i2 from "../../methods/utils/producer/h-params.service";
 import * as i3 from "../../methods/utils/producer/v-params.service";
 import * as i4 from "../../methods/utils/producer/screen-params.service";
 import * as i5 from "../../methods/utils/producer/a-params.service";
+/**
+ * Updates room parameters for the client after joining a room and receiving server-provided parameters.
+ *
+ * @param {UpdateRoomParametersClientOptions} options - An object containing:
+ *  - various room settings and parameters,
+ *  - functions to update those parameters.
+ *
+ * - **Screen/Page Settings:** Adjusts screen and item page limits, meeting room parameters, and video constraints based on server data.
+ * - **Recording and Media Settings:** Applies bitrate and frame rate adjustments, based on the target resolution and media options.
+ * - **Role-Specific Settings:** Configures admin, host, and co-host settings for permissions, orientations, and resolutions.
+ * - **Alerting**: Uses `showAlert` to notify the client on issues or permissions restrictions.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   parameters: {
+ *     rtpCapabilities: myRtpCapabilities,
+ *     roomRecvIPs: ['192.168.1.1'],
+ *     meetingRoomParams: myMeetingParams,
+ *     itemPageLimit: 3,
+ *     audioOnlyRoom: false,
+ *     addForBasic: true,
+ *     screenPageLimit: 2,
+ *     shareScreenStarted: false,
+ *     shared: true,
+ *     targetOrientation: 'landscape',
+ *     recordingVideoSupport: true,
+ *     frameRate: 15,
+ *     adminPasscode: 'admin123',
+ *     eventType: 'conference',
+ *     youAreCoHost: false,
+ *     updateRtpCapabilities: (rtp) => console.log('Updating RTP:', rtp),
+ *     updateRoomRecvIPs: (ips) => console.log('Updating IPs:', ips),
+ *     updateMeetingRoomParams: (params) => console.log('Updating room params:', params),
+ *     // Additional parameters...
+ *   },
+ * };
+ *
+ * const updateRoomParametersClient = new UpdateRoomParametersClient(videoCaptureConstraints, hParams, vParams, screenParams, aParams);
+ * updateRoomParametersClient.updateRoomParametersClient(options);
+ * ```
+ *
+ * This example demonstrates setting up room parameters for a conference-type room with recording support and custom update functions.
+ */
 export class UpdateRoomParametersClient {
     videoCaptureConstraints;
     hParams;
@@ -229,4 +273,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }], ctorParameters: () => [{ type: i1.VideoCaptureConstraints }, { type: i2.HParams }, { type: i3.VParams }, { type: i4.ScreenParams }, { type: i5.AParams }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"update-room-parameters-client.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/producer-client/producer-client-emits/update-room-parameters-client.service.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-non-null-assertion */\n// room.service.ts\nimport { Injectable } from '@angular/core';\nimport { VideoCaptureConstraints } from '../../methods/utils/producer/video-capture-constraints.service';\nimport { HParams, HParamsType } from '../../methods/utils/producer/h-params.service';\nimport { VParams, VParamsType } from '../../methods/utils/producer/v-params.service';\nimport { ScreenParams } from '../../methods/utils/producer/screen-params.service';\nimport { AParams } from '../../methods/utils/producer/a-params.service';\nimport { RtpCapabilities } from 'mediasoup-client/lib/types';\nimport {\n  EventType,\n  ShowAlert,\n  VidCons,\n  ResponseJoinRoom,\n  ScreenParamsType,\n  AParamsType,\n  MeetingRoomParams,\n} from '../../@types/types';\n\nexport interface UpdateRoomParametersClientParameters {\n  rtpCapabilities: RtpCapabilities | null;\n  roomRecvIPs: string[];\n  meetingRoomParams: MeetingRoomParams | null;\n  itemPageLimit: number;\n  audioOnlyRoom: boolean;\n  addForBasic: boolean;\n  screenPageLimit: number;\n  shareScreenStarted: boolean;\n  shared: boolean;\n  targetOrientation: string;\n  vidCons: any;\n  recordingVideoSupport: boolean;\n  frameRate: number;\n  adminPasscode: string;\n  eventType: EventType;\n  youAreCoHost: boolean;\n  autoWave: boolean;\n  forceFullDisplay: boolean;\n  chatSetting: string;\n  meetingDisplayType: string;\n  audioSetting: string;\n  videoSetting: string;\n  screenshareSetting: string;\n  hParams: HParamsType;\n  vParams: VParamsType;\n  screenParams: ScreenParamsType;\n  aParams: AParamsType;\n  islevel: string;\n  showAlert?: ShowAlert;\n  data: ResponseJoinRoom;\n\n  // update functions\n  updateRtpCapabilities: (rtpCapabilities: RtpCapabilities | null) => void;\n  updateRoomRecvIPs: (roomRecvIPs: string[]) => void;\n  updateMeetingRoomParams: (params: MeetingRoomParams | null) => void;\n  updateItemPageLimit: (limit: number) => void;\n  updateAudioOnlyRoom: (isAudioOnly: boolean) => void;\n  updateAddForBasic: (addForBasic: boolean) => void;\n  updateScreenPageLimit: (limit: number) => void;\n  updateVidCons: (cons: any) => void;\n  updateFrameRate: (frameRate: number) => void;\n  updateAdminPasscode: (passcode: string) => void;\n  updateEventType: (eventType: EventType) => void;\n  updateYouAreCoHost: (coHost: boolean) => void;\n  updateAutoWave: (autoWave: boolean) => void;\n  updateForceFullDisplay: (forceFull: boolean) => void;\n  updateChatSetting: (setting: string) => void;\n  updateMeetingDisplayType: (type: string) => void;\n  updateAudioSetting: (setting: string) => void;\n  updateVideoSetting: (setting: string) => void;\n  updateScreenshareSetting: (setting: string) => void;\n  updateHParams: (params: HParamsType) => void;\n  updateVParams: (params: VParamsType) => void;\n  updateScreenParams: (params: ScreenParamsType) => void;\n  updateAParams: (params: AParamsType) => void;\n  updateMainHeightWidth: (heightWidth: number) => void;\n  updateTargetResolution: (resolution: string) => void;\n  updateTargetResolutionHost: (resolution: string) => void;\n\n  // Recording-related update functions\n  updateRecordingAudioPausesLimit: (limit: number) => void;\n  updateRecordingAudioPausesCount: (count: number) => void;\n  updateRecordingAudioSupport: (support: boolean) => void;\n  updateRecordingAudioPeopleLimit: (limit: number) => void;\n  updateRecordingAudioParticipantsTimeLimit: (limit: number) => void;\n  updateRecordingVideoPausesCount: (count: number) => void;\n  updateRecordingVideoPausesLimit: (limit: number) => void;\n  updateRecordingVideoSupport: (support: boolean) => void;\n  updateRecordingVideoPeopleLimit: (limit: number) => void;\n  updateRecordingVideoParticipantsTimeLimit: (limit: number) => void;\n  updateRecordingAllParticipantsSupport: (support: boolean) => void;\n  updateRecordingVideoParticipantsSupport: (support: boolean) => void;\n  updateRecordingAllParticipantsFullRoomSupport: (support: boolean) => void;\n  updateRecordingVideoParticipantsFullRoomSupport: (support: boolean) => void;\n  updateRecordingPreferredOrientation: (orientation: string) => void;\n  updateRecordingSupportForOtherOrientation: (support: boolean) => void;\n  updateRecordingMultiFormatsSupport: (support: boolean) => void;\n  updateRecordingVideoOptions: (options: string) => void;\n  updateRecordingAudioOptions: (options: string) => void;\n}\n\nexport type UpdateRoomParametersClientOptions = {\n  parameters: UpdateRoomParametersClientParameters;\n};\n\n// Export the type definition for the function\nexport type UpdateRoomParametersClientType = (options: UpdateRoomParametersClientOptions) => void;\n@Injectable({\n  providedIn: 'root',\n})\nexport class UpdateRoomParametersClient {\n  constructor(\n    private videoCaptureConstraints: VideoCaptureConstraints,\n    private hParams: HParams,\n    private vParams: VParams,\n    private screenParams: ScreenParams,\n    private aParams: AParams,\n  ) {}\n\n  /**\n   * Update Room Parameters Client after the user has joined the room and the room parameters have been received from the server.\n   * @param {Object} parameters - An object containing various parameters and update functions.\n   */\n  updateRoomParametersClient = ({ parameters }: UpdateRoomParametersClientOptions): void => {\n    try {\n      const {\n        screenPageLimit,\n        shareScreenStarted,\n        shared,\n\n        hParams,\n        vParams,\n        frameRate,\n\n        islevel,\n        showAlert,\n        data,\n\n        //updates\n        updateRtpCapabilities,\n        updateRoomRecvIPs,\n        updateMeetingRoomParams,\n        updateItemPageLimit,\n        updateAudioOnlyRoom,\n        updateScreenPageLimit,\n        updateVidCons,\n        updateFrameRate,\n        updateAdminPasscode,\n        updateEventType,\n        updateYouAreCoHost,\n        updateAutoWave,\n        updateForceFullDisplay,\n        updateChatSetting,\n        updateMeetingDisplayType,\n        updateAudioSetting,\n        updateVideoSetting,\n        updateScreenshareSetting,\n        updateHParams,\n        updateVParams,\n        updateScreenParams,\n        updateAParams,\n        updateTargetResolution,\n        updateTargetResolutionHost,\n\n        // Recording updates\n        updateRecordingAudioPausesLimit,\n        updateRecordingAudioPausesCount,\n        updateRecordingAudioSupport,\n        updateRecordingAudioPeopleLimit,\n        updateRecordingAudioParticipantsTimeLimit,\n        updateRecordingVideoPausesCount,\n        updateRecordingVideoPausesLimit,\n        updateRecordingVideoSupport,\n        updateRecordingVideoPeopleLimit,\n        updateRecordingVideoParticipantsTimeLimit,\n        updateRecordingAllParticipantsSupport,\n        updateRecordingVideoParticipantsSupport,\n        updateRecordingAllParticipantsFullRoomSupport,\n        updateRecordingVideoParticipantsFullRoomSupport,\n        updateRecordingPreferredOrientation,\n        updateRecordingSupportForOtherOrientation,\n        updateRecordingMultiFormatsSupport,\n        updateRecordingVideoOptions,\n        updateRecordingAudioOptions,\n        updateMainHeightWidth,\n      } = parameters;\n\n      if (data.rtpCapabilities == null) {\n        let reason = data.reason || '';\n        showAlert?.({\n          message: 'Sorry, you are not allowed to join this room. ' + reason,\n          type: 'danger',\n          duration: 3000,\n        });\n        return;\n      }\n\n      // Update all values\n      updateRtpCapabilities(data.rtpCapabilities);\n      updateAdminPasscode(data.secureCode);\n      updateRoomRecvIPs(data.roomRecvIPs);\n      updateMeetingRoomParams(data.meetingRoomParams);\n\n      // Update recording values\n      updateRecordingAudioPausesLimit(data.recordingParams.recordingAudioPausesLimit);\n      updateRecordingAudioPausesCount(data.recordingParams.recordingAudioPausesCount!);\n      updateRecordingAudioSupport(data.recordingParams.recordingAudioSupport);\n      updateRecordingAudioPeopleLimit(data.recordingParams.recordingAudioPeopleLimit);\n      updateRecordingAudioParticipantsTimeLimit(\n        data.recordingParams.recordingAudioParticipantsTimeLimit,\n      );\n      updateRecordingVideoPausesCount(data.recordingParams.recordingVideoPausesCount!);\n      updateRecordingVideoPausesLimit(data.recordingParams.recordingVideoPausesLimit);\n      updateRecordingVideoSupport(data.recordingParams.recordingVideoSupport);\n      updateRecordingVideoPeopleLimit(data.recordingParams.recordingVideoPeopleLimit);\n      updateRecordingVideoParticipantsTimeLimit(\n        data.recordingParams.recordingVideoParticipantsTimeLimit,\n      );\n      updateRecordingAllParticipantsSupport(data.recordingParams.recordingAllParticipantsSupport);\n      updateRecordingVideoParticipantsSupport(\n        data.recordingParams.recordingVideoParticipantsSupport,\n      );\n      updateRecordingAllParticipantsFullRoomSupport(\n        data.recordingParams.recordingAllParticipantsFullRoomSupport,\n      );\n      updateRecordingVideoParticipantsFullRoomSupport(\n        data.recordingParams.recordingVideoParticipantsFullRoomSupport,\n      );\n      updateRecordingPreferredOrientation(data.recordingParams.recordingPreferredOrientation);\n      updateRecordingSupportForOtherOrientation(\n        data.recordingParams.recordingSupportForOtherOrientation,\n      );\n      updateRecordingMultiFormatsSupport(data.recordingParams.recordingMultiFormatsSupport);\n\n      // Update other meeting room settings\n      updateItemPageLimit(data.meetingRoomParams.itemPageLimit);\n      updateEventType(data.meetingRoomParams.type);\n\n      if (data.meetingRoomParams.type == 'chat' && islevel != '2') {\n        updateYouAreCoHost(true);\n      }\n\n      if (['chat', 'broadcast'].includes(data.meetingRoomParams.type)) {\n        updateAutoWave(false);\n        updateMeetingDisplayType('all');\n        updateForceFullDisplay(true);\n        updateChatSetting('allow');\n      }\n\n      updateAudioSetting(data.meetingRoomParams.audioSetting);\n      updateVideoSetting(data.meetingRoomParams.videoSetting);\n      updateScreenshareSetting(data.meetingRoomParams.screenshareSetting);\n      updateChatSetting(data.meetingRoomParams.chatSetting);\n\n      updateAudioOnlyRoom(data.meetingRoomParams.mediaType != 'video');\n\n      if (data.meetingRoomParams.type == 'chat' || data.meetingRoomParams.type == 'broadcast') {\n        if (data.meetingRoomParams.type == 'broadcast') {\n          updateItemPageLimit(1);\n          updateRecordingVideoOptions('mainScreen');\n          updateRecordingAudioOptions('host');\n        } else {\n          updateItemPageLimit(2);\n        }\n      }\n\n      if (data.meetingRoomParams.type == 'conference' && (shared || shareScreenStarted)) {\n        updateMainHeightWidth(100);\n      } else {\n        updateMainHeightWidth(0);\n      }\n\n      updateScreenPageLimit(Math.min(data.meetingRoomParams.itemPageLimit, screenPageLimit));\n\n      // Assign media capture constraints based on the user's role and room settings\n      let targetOrientation =\n        islevel == '2'\n          ? data.meetingRoomParams.targetOrientationHost\n          : data.meetingRoomParams.targetOrientation;\n      let targetResolution =\n        islevel == '2'\n          ? data.meetingRoomParams.targetResolutionHost\n          : data.meetingRoomParams.targetResolution;\n\n      let vidCons: VidCons;\n      if (targetOrientation == 'landscape') {\n        vidCons =\n          targetResolution == 'hd'\n            ? this.videoCaptureConstraints.hdCons\n            : targetResolution == 'QnHD'\n            ? this.videoCaptureConstraints.QnHDCons\n            : targetResolution == 'fhd'\n            ? this.videoCaptureConstraints.fhdCons\n            : targetResolution == 'qhd'\n            ? this.videoCaptureConstraints.qhdCons\n            : this.videoCaptureConstraints.sdCons;\n      } else if (targetOrientation == 'neutral') {\n        vidCons =\n          targetResolution == 'hd'\n            ? this.videoCaptureConstraints.hdConsNeu\n            : targetResolution == 'QnHD'\n            ? this.videoCaptureConstraints.QnHDConsNeu\n            : targetResolution == 'fhd'\n            ? this.videoCaptureConstraints.fhdConsNeu\n            : targetResolution == 'qhd'\n            ? this.videoCaptureConstraints.qhdConsNeu\n            : this.videoCaptureConstraints.sdConsNeu;\n      } else {\n        vidCons =\n          targetResolution == 'hd'\n            ? this.videoCaptureConstraints.hdConsPort\n            : targetResolution == 'QnHD'\n            ? this.videoCaptureConstraints.QnHDConsPort\n            : targetResolution == 'fhd'\n            ? this.videoCaptureConstraints.fhdConsPort\n            : targetResolution == 'qhd'\n            ? this.videoCaptureConstraints.qhdConsPort\n            : this.videoCaptureConstraints.sdConsPort;\n      }\n\n      let frameRateValue = frameRate ? frameRate : 10;\n\n      let vParamsValue = { ...vParams };\n      let hParamsValue = { ...hParams };\n      if (Object.keys(vParamsValue).length === 0) {\n        vParamsValue = this.vParams.vParams;\n      }\n      if (Object.keys(hParamsValue).length === 0) {\n        hParamsValue = this.hParams.hParams;\n      }\n\n      if (targetResolution == 'hd') {\n        frameRateValue = this.videoCaptureConstraints.hdFrameRate;\n\n        vParamsValue.encodings.forEach((encoding: Partial<VParamsType['encodings'][0]>) => {\n          encoding.maxBitrate && (encoding.maxBitrate *= 4);\n        });\n\n        hParamsValue.encodings.forEach((encoding: Partial<HParamsType['encodings'][0]>) => {\n          encoding.maxBitrate && (encoding.maxBitrate *= 4);\n        });\n      } else if (targetResolution == 'QnHD') {\n        frameRateValue = this.videoCaptureConstraints.QnHDFrameRate;\n        vParamsValue.encodings.forEach((encoding: Partial<VParamsType['encodings'][0]>) => {\n          encoding.maxBitrate && (encoding.maxBitrate *= 0.25);\n        });\n\n        hParamsValue.encodings.forEach((encoding: Partial<HParamsType['encodings'][0]>) => {\n          encoding.maxBitrate && (encoding.maxBitrate *= 0.25);\n        });\n\n        hParamsValue.codecOptions!.videoGoogleStartBitrate! *= 0.25;\n        vParamsValue.codecOptions!.videoGoogleStartBitrate! *= 0.25;\n      } else if (targetResolution == 'fhd') {\n        frameRateValue = this.videoCaptureConstraints.fhdFrameRate;\n        vParamsValue.encodings.forEach((encoding: Partial<VParamsType['encodings'][0]>) => {\n          encoding.maxBitrate && (encoding.maxBitrate *= 8);\n        });\n\n        hParamsValue.encodings.forEach((encoding: Partial<HParamsType['encodings'][0]>) => {\n          encoding.maxBitrate && (encoding.maxBitrate *= 8);\n        });\n\n        hParamsValue.codecOptions!.videoGoogleStartBitrate! *= 8;\n        vParamsValue.codecOptions!.videoGoogleStartBitrate! *= 8;\n      } else if (targetResolution == 'qhd') {\n        frameRateValue = this.videoCaptureConstraints.qhdFrameRate;\n        vParamsValue.encodings.forEach((encoding: Partial<VParamsType['encodings'][0]>) => {\n          encoding.maxBitrate && (encoding.maxBitrate *= 16);\n        });\n\n        hParamsValue.encodings.forEach((encoding: Partial<HParamsType['encodings'][0]>) => {\n          encoding.maxBitrate && (encoding.maxBitrate *= 16);\n        });\n\n        hParamsValue.codecOptions!.videoGoogleStartBitrate! *= 16;\n        vParamsValue.codecOptions!.videoGoogleStartBitrate! *= 16;\n      }\n\n      if (data.recordingParams.recordingVideoSupport) {\n        vParamsValue.encodings.forEach((encoding: Partial<VParamsType['encodings'][0]>) => {\n          encoding.maxBitrate && (encoding.maxBitrate *= 1.2);\n        });\n\n        hParamsValue.encodings.forEach((encoding: Partial<HParamsType['encodings'][0]>) => {\n          encoding.maxBitrate && (encoding.maxBitrate *= 1.2);\n        });\n\n        hParamsValue.codecOptions!.videoGoogleStartBitrate! *= 1.2;\n        vParamsValue.codecOptions!.videoGoogleStartBitrate! *= 1.2;\n      }\n\n      updateVidCons(vidCons);\n      updateFrameRate(frameRateValue);\n      updateHParams(hParamsValue);\n      updateVParams(vParamsValue);\n      updateScreenParams(this.screenParams.screenParams);\n      updateAParams(this.aParams.aParams);\n      updateTargetResolution(data.meetingRoomParams.targetResolution);\n      updateTargetResolutionHost(data.meetingRoomParams.targetResolutionHost);\n    } catch (error) {\n      console.log('updateRoomParametersClient error', error);\n      parameters.showAlert?.({\n        message: (error as Error).message,\n        type: 'danger',\n        duration: 3000,\n      });\n    }\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"update-room-parameters-client.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/producer-client/producer-client-emits/update-room-parameters-client.service.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-non-null-assertion */\n// room.service.ts\nimport { Injectable } from '@angular/core';\nimport { VideoCaptureConstraints } from '../../methods/utils/producer/video-capture-constraints.service';\nimport { HParams, HParamsType } from '../../methods/utils/producer/h-params.service';\nimport { VParams, VParamsType } from '../../methods/utils/producer/v-params.service';\nimport { ScreenParams } from '../../methods/utils/producer/screen-params.service';\nimport { AParams } from '../../methods/utils/producer/a-params.service';\nimport { RtpCapabilities } from 'mediasoup-client/lib/types';\nimport {\n  EventType,\n  ShowAlert,\n  VidCons,\n  ResponseJoinRoom,\n  ScreenParamsType,\n  AParamsType,\n  MeetingRoomParams,\n} from '../../@types/types';\n\nexport interface UpdateRoomParametersClientParameters {\n  rtpCapabilities: RtpCapabilities | null;\n  roomRecvIPs: string[];\n  meetingRoomParams: MeetingRoomParams | null;\n  itemPageLimit: number;\n  audioOnlyRoom: boolean;\n  addForBasic: boolean;\n  screenPageLimit: number;\n  shareScreenStarted: boolean;\n  shared: boolean;\n  targetOrientation: string;\n  vidCons: any;\n  recordingVideoSupport: boolean;\n  frameRate: number;\n  adminPasscode: string;\n  eventType: EventType;\n  youAreCoHost: boolean;\n  autoWave: boolean;\n  forceFullDisplay: boolean;\n  chatSetting: string;\n  meetingDisplayType: string;\n  audioSetting: string;\n  videoSetting: string;\n  screenshareSetting: string;\n  hParams: HParamsType;\n  vParams: VParamsType;\n  screenParams: ScreenParamsType;\n  aParams: AParamsType;\n  islevel: string;\n  showAlert?: ShowAlert;\n  data: ResponseJoinRoom;\n\n  // update functions\n  updateRtpCapabilities: (rtpCapabilities: RtpCapabilities | null) => void;\n  updateRoomRecvIPs: (roomRecvIPs: string[]) => void;\n  updateMeetingRoomParams: (params: MeetingRoomParams | null) => void;\n  updateItemPageLimit: (limit: number) => void;\n  updateAudioOnlyRoom: (isAudioOnly: boolean) => void;\n  updateAddForBasic: (addForBasic: boolean) => void;\n  updateScreenPageLimit: (limit: number) => void;\n  updateVidCons: (cons: any) => void;\n  updateFrameRate: (frameRate: number) => void;\n  updateAdminPasscode: (passcode: string) => void;\n  updateEventType: (eventType: EventType) => void;\n  updateYouAreCoHost: (coHost: boolean) => void;\n  updateAutoWave: (autoWave: boolean) => void;\n  updateForceFullDisplay: (forceFull: boolean) => void;\n  updateChatSetting: (setting: string) => void;\n  updateMeetingDisplayType: (type: string) => void;\n  updateAudioSetting: (setting: string) => void;\n  updateVideoSetting: (setting: string) => void;\n  updateScreenshareSetting: (setting: string) => void;\n  updateHParams: (params: HParamsType) => void;\n  updateVParams: (params: VParamsType) => void;\n  updateScreenParams: (params: ScreenParamsType) => void;\n  updateAParams: (params: AParamsType) => void;\n  updateMainHeightWidth: (heightWidth: number) => void;\n  updateTargetResolution: (resolution: string) => void;\n  updateTargetResolutionHost: (resolution: string) => void;\n\n  // Recording-related update functions\n  updateRecordingAudioPausesLimit: (limit: number) => void;\n  updateRecordingAudioPausesCount: (count: number) => void;\n  updateRecordingAudioSupport: (support: boolean) => void;\n  updateRecordingAudioPeopleLimit: (limit: number) => void;\n  updateRecordingAudioParticipantsTimeLimit: (limit: number) => void;\n  updateRecordingVideoPausesCount: (count: number) => void;\n  updateRecordingVideoPausesLimit: (limit: number) => void;\n  updateRecordingVideoSupport: (support: boolean) => void;\n  updateRecordingVideoPeopleLimit: (limit: number) => void;\n  updateRecordingVideoParticipantsTimeLimit: (limit: number) => void;\n  updateRecordingAllParticipantsSupport: (support: boolean) => void;\n  updateRecordingVideoParticipantsSupport: (support: boolean) => void;\n  updateRecordingAllParticipantsFullRoomSupport: (support: boolean) => void;\n  updateRecordingVideoParticipantsFullRoomSupport: (support: boolean) => void;\n  updateRecordingPreferredOrientation: (orientation: string) => void;\n  updateRecordingSupportForOtherOrientation: (support: boolean) => void;\n  updateRecordingMultiFormatsSupport: (support: boolean) => void;\n  updateRecordingVideoOptions: (options: string) => void;\n  updateRecordingAudioOptions: (options: string) => void;\n}\n\nexport type UpdateRoomParametersClientOptions = {\n  parameters: UpdateRoomParametersClientParameters;\n};\n\n// Export the type definition for the function\nexport type UpdateRoomParametersClientType = (options: UpdateRoomParametersClientOptions) => void;\n\n/**\n * Updates room parameters for the client after joining a room and receiving server-provided parameters.\n *\n * @param {UpdateRoomParametersClientOptions} options - An object containing:\n *  - various room settings and parameters,\n *  - functions to update those parameters.\n *\n * - **Screen/Page Settings:** Adjusts screen and item page limits, meeting room parameters, and video constraints based on server data.\n * - **Recording and Media Settings:** Applies bitrate and frame rate adjustments, based on the target resolution and media options.\n * - **Role-Specific Settings:** Configures admin, host, and co-host settings for permissions, orientations, and resolutions.\n * - **Alerting**: Uses `showAlert` to notify the client on issues or permissions restrictions.\n *\n * @example\n * ```typescript\n * const options = {\n *   parameters: {\n *     rtpCapabilities: myRtpCapabilities,\n *     roomRecvIPs: ['192.168.1.1'],\n *     meetingRoomParams: myMeetingParams,\n *     itemPageLimit: 3,\n *     audioOnlyRoom: false,\n *     addForBasic: true,\n *     screenPageLimit: 2,\n *     shareScreenStarted: false,\n *     shared: true,\n *     targetOrientation: 'landscape',\n *     recordingVideoSupport: true,\n *     frameRate: 15,\n *     adminPasscode: 'admin123',\n *     eventType: 'conference',\n *     youAreCoHost: false,\n *     updateRtpCapabilities: (rtp) => console.log('Updating RTP:', rtp),\n *     updateRoomRecvIPs: (ips) => console.log('Updating IPs:', ips),\n *     updateMeetingRoomParams: (params) => console.log('Updating room params:', params),\n *     // Additional parameters...\n *   },\n * };\n *\n * const updateRoomParametersClient = new UpdateRoomParametersClient(videoCaptureConstraints, hParams, vParams, screenParams, aParams);\n * updateRoomParametersClient.updateRoomParametersClient(options);\n * ```\n *\n * This example demonstrates setting up room parameters for a conference-type room with recording support and custom update functions.\n */\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class UpdateRoomParametersClient {\n  constructor(\n    private videoCaptureConstraints: VideoCaptureConstraints,\n    private hParams: HParams,\n    private vParams: VParams,\n    private screenParams: ScreenParams,\n    private aParams: AParams,\n  ) {}\n\n  /**\n   * Update Room Parameters Client after the user has joined the room and the room parameters have been received from the server.\n   * @param {Object} parameters - An object containing various parameters and update functions.\n   */\n  updateRoomParametersClient = ({ parameters }: UpdateRoomParametersClientOptions): void => {\n    try {\n      const {\n        screenPageLimit,\n        shareScreenStarted,\n        shared,\n\n        hParams,\n        vParams,\n        frameRate,\n\n        islevel,\n        showAlert,\n        data,\n\n        //updates\n        updateRtpCapabilities,\n        updateRoomRecvIPs,\n        updateMeetingRoomParams,\n        updateItemPageLimit,\n        updateAudioOnlyRoom,\n        updateScreenPageLimit,\n        updateVidCons,\n        updateFrameRate,\n        updateAdminPasscode,\n        updateEventType,\n        updateYouAreCoHost,\n        updateAutoWave,\n        updateForceFullDisplay,\n        updateChatSetting,\n        updateMeetingDisplayType,\n        updateAudioSetting,\n        updateVideoSetting,\n        updateScreenshareSetting,\n        updateHParams,\n        updateVParams,\n        updateScreenParams,\n        updateAParams,\n        updateTargetResolution,\n        updateTargetResolutionHost,\n\n        // Recording updates\n        updateRecordingAudioPausesLimit,\n        updateRecordingAudioPausesCount,\n        updateRecordingAudioSupport,\n        updateRecordingAudioPeopleLimit,\n        updateRecordingAudioParticipantsTimeLimit,\n        updateRecordingVideoPausesCount,\n        updateRecordingVideoPausesLimit,\n        updateRecordingVideoSupport,\n        updateRecordingVideoPeopleLimit,\n        updateRecordingVideoParticipantsTimeLimit,\n        updateRecordingAllParticipantsSupport,\n        updateRecordingVideoParticipantsSupport,\n        updateRecordingAllParticipantsFullRoomSupport,\n        updateRecordingVideoParticipantsFullRoomSupport,\n        updateRecordingPreferredOrientation,\n        updateRecordingSupportForOtherOrientation,\n        updateRecordingMultiFormatsSupport,\n        updateRecordingVideoOptions,\n        updateRecordingAudioOptions,\n        updateMainHeightWidth,\n      } = parameters;\n\n      if (data.rtpCapabilities == null) {\n        let reason = data.reason || '';\n        showAlert?.({\n          message: 'Sorry, you are not allowed to join this room. ' + reason,\n          type: 'danger',\n          duration: 3000,\n        });\n        return;\n      }\n\n      // Update all values\n      updateRtpCapabilities(data.rtpCapabilities);\n      updateAdminPasscode(data.secureCode);\n      updateRoomRecvIPs(data.roomRecvIPs);\n      updateMeetingRoomParams(data.meetingRoomParams);\n\n      // Update recording values\n      updateRecordingAudioPausesLimit(data.recordingParams.recordingAudioPausesLimit);\n      updateRecordingAudioPausesCount(data.recordingParams.recordingAudioPausesCount!);\n      updateRecordingAudioSupport(data.recordingParams.recordingAudioSupport);\n      updateRecordingAudioPeopleLimit(data.recordingParams.recordingAudioPeopleLimit);\n      updateRecordingAudioParticipantsTimeLimit(\n        data.recordingParams.recordingAudioParticipantsTimeLimit,\n      );\n      updateRecordingVideoPausesCount(data.recordingParams.recordingVideoPausesCount!);\n      updateRecordingVideoPausesLimit(data.recordingParams.recordingVideoPausesLimit);\n      updateRecordingVideoSupport(data.recordingParams.recordingVideoSupport);\n      updateRecordingVideoPeopleLimit(data.recordingParams.recordingVideoPeopleLimit);\n      updateRecordingVideoParticipantsTimeLimit(\n        data.recordingParams.recordingVideoParticipantsTimeLimit,\n      );\n      updateRecordingAllParticipantsSupport(data.recordingParams.recordingAllParticipantsSupport);\n      updateRecordingVideoParticipantsSupport(\n        data.recordingParams.recordingVideoParticipantsSupport,\n      );\n      updateRecordingAllParticipantsFullRoomSupport(\n        data.recordingParams.recordingAllParticipantsFullRoomSupport,\n      );\n      updateRecordingVideoParticipantsFullRoomSupport(\n        data.recordingParams.recordingVideoParticipantsFullRoomSupport,\n      );\n      updateRecordingPreferredOrientation(data.recordingParams.recordingPreferredOrientation);\n      updateRecordingSupportForOtherOrientation(\n        data.recordingParams.recordingSupportForOtherOrientation,\n      );\n      updateRecordingMultiFormatsSupport(data.recordingParams.recordingMultiFormatsSupport);\n\n      // Update other meeting room settings\n      updateItemPageLimit(data.meetingRoomParams.itemPageLimit);\n      updateEventType(data.meetingRoomParams.type);\n\n      if (data.meetingRoomParams.type == 'chat' && islevel != '2') {\n        updateYouAreCoHost(true);\n      }\n\n      if (['chat', 'broadcast'].includes(data.meetingRoomParams.type)) {\n        updateAutoWave(false);\n        updateMeetingDisplayType('all');\n        updateForceFullDisplay(true);\n        updateChatSetting('allow');\n      }\n\n      updateAudioSetting(data.meetingRoomParams.audioSetting);\n      updateVideoSetting(data.meetingRoomParams.videoSetting);\n      updateScreenshareSetting(data.meetingRoomParams.screenshareSetting);\n      updateChatSetting(data.meetingRoomParams.chatSetting);\n\n      updateAudioOnlyRoom(data.meetingRoomParams.mediaType != 'video');\n\n      if (data.meetingRoomParams.type == 'chat' || data.meetingRoomParams.type == 'broadcast') {\n        if (data.meetingRoomParams.type == 'broadcast') {\n          updateItemPageLimit(1);\n          updateRecordingVideoOptions('mainScreen');\n          updateRecordingAudioOptions('host');\n        } else {\n          updateItemPageLimit(2);\n        }\n      }\n\n      if (data.meetingRoomParams.type == 'conference' && (shared || shareScreenStarted)) {\n        updateMainHeightWidth(100);\n      } else {\n        updateMainHeightWidth(0);\n      }\n\n      updateScreenPageLimit(Math.min(data.meetingRoomParams.itemPageLimit, screenPageLimit));\n\n      // Assign media capture constraints based on the user's role and room settings\n      let targetOrientation =\n        islevel == '2'\n          ? data.meetingRoomParams.targetOrientationHost\n          : data.meetingRoomParams.targetOrientation;\n      let targetResolution =\n        islevel == '2'\n          ? data.meetingRoomParams.targetResolutionHost\n          : data.meetingRoomParams.targetResolution;\n\n      let vidCons: VidCons;\n      if (targetOrientation == 'landscape') {\n        vidCons =\n          targetResolution == 'hd'\n            ? this.videoCaptureConstraints.hdCons\n            : targetResolution == 'QnHD'\n            ? this.videoCaptureConstraints.QnHDCons\n            : targetResolution == 'fhd'\n            ? this.videoCaptureConstraints.fhdCons\n            : targetResolution == 'qhd'\n            ? this.videoCaptureConstraints.qhdCons\n            : this.videoCaptureConstraints.sdCons;\n      } else if (targetOrientation == 'neutral') {\n        vidCons =\n          targetResolution == 'hd'\n            ? this.videoCaptureConstraints.hdConsNeu\n            : targetResolution == 'QnHD'\n            ? this.videoCaptureConstraints.QnHDConsNeu\n            : targetResolution == 'fhd'\n            ? this.videoCaptureConstraints.fhdConsNeu\n            : targetResolution == 'qhd'\n            ? this.videoCaptureConstraints.qhdConsNeu\n            : this.videoCaptureConstraints.sdConsNeu;\n      } else {\n        vidCons =\n          targetResolution == 'hd'\n            ? this.videoCaptureConstraints.hdConsPort\n            : targetResolution == 'QnHD'\n            ? this.videoCaptureConstraints.QnHDConsPort\n            : targetResolution == 'fhd'\n            ? this.videoCaptureConstraints.fhdConsPort\n            : targetResolution == 'qhd'\n            ? this.videoCaptureConstraints.qhdConsPort\n            : this.videoCaptureConstraints.sdConsPort;\n      }\n\n      let frameRateValue = frameRate ? frameRate : 10;\n\n      let vParamsValue = { ...vParams };\n      let hParamsValue = { ...hParams };\n      if (Object.keys(vParamsValue).length === 0) {\n        vParamsValue = this.vParams.vParams;\n      }\n      if (Object.keys(hParamsValue).length === 0) {\n        hParamsValue = this.hParams.hParams;\n      }\n\n      if (targetResolution == 'hd') {\n        frameRateValue = this.videoCaptureConstraints.hdFrameRate;\n\n        vParamsValue.encodings.forEach((encoding: Partial<VParamsType['encodings'][0]>) => {\n          encoding.maxBitrate && (encoding.maxBitrate *= 4);\n        });\n\n        hParamsValue.encodings.forEach((encoding: Partial<HParamsType['encodings'][0]>) => {\n          encoding.maxBitrate && (encoding.maxBitrate *= 4);\n        });\n      } else if (targetResolution == 'QnHD') {\n        frameRateValue = this.videoCaptureConstraints.QnHDFrameRate;\n        vParamsValue.encodings.forEach((encoding: Partial<VParamsType['encodings'][0]>) => {\n          encoding.maxBitrate && (encoding.maxBitrate *= 0.25);\n        });\n\n        hParamsValue.encodings.forEach((encoding: Partial<HParamsType['encodings'][0]>) => {\n          encoding.maxBitrate && (encoding.maxBitrate *= 0.25);\n        });\n\n        hParamsValue.codecOptions!.videoGoogleStartBitrate! *= 0.25;\n        vParamsValue.codecOptions!.videoGoogleStartBitrate! *= 0.25;\n      } else if (targetResolution == 'fhd') {\n        frameRateValue = this.videoCaptureConstraints.fhdFrameRate;\n        vParamsValue.encodings.forEach((encoding: Partial<VParamsType['encodings'][0]>) => {\n          encoding.maxBitrate && (encoding.maxBitrate *= 8);\n        });\n\n        hParamsValue.encodings.forEach((encoding: Partial<HParamsType['encodings'][0]>) => {\n          encoding.maxBitrate && (encoding.maxBitrate *= 8);\n        });\n\n        hParamsValue.codecOptions!.videoGoogleStartBitrate! *= 8;\n        vParamsValue.codecOptions!.videoGoogleStartBitrate! *= 8;\n      } else if (targetResolution == 'qhd') {\n        frameRateValue = this.videoCaptureConstraints.qhdFrameRate;\n        vParamsValue.encodings.forEach((encoding: Partial<VParamsType['encodings'][0]>) => {\n          encoding.maxBitrate && (encoding.maxBitrate *= 16);\n        });\n\n        hParamsValue.encodings.forEach((encoding: Partial<HParamsType['encodings'][0]>) => {\n          encoding.maxBitrate && (encoding.maxBitrate *= 16);\n        });\n\n        hParamsValue.codecOptions!.videoGoogleStartBitrate! *= 16;\n        vParamsValue.codecOptions!.videoGoogleStartBitrate! *= 16;\n      }\n\n      if (data.recordingParams.recordingVideoSupport) {\n        vParamsValue.encodings.forEach((encoding: Partial<VParamsType['encodings'][0]>) => {\n          encoding.maxBitrate && (encoding.maxBitrate *= 1.2);\n        });\n\n        hParamsValue.encodings.forEach((encoding: Partial<HParamsType['encodings'][0]>) => {\n          encoding.maxBitrate && (encoding.maxBitrate *= 1.2);\n        });\n\n        hParamsValue.codecOptions!.videoGoogleStartBitrate! *= 1.2;\n        vParamsValue.codecOptions!.videoGoogleStartBitrate! *= 1.2;\n      }\n\n      updateVidCons(vidCons);\n      updateFrameRate(frameRateValue);\n      updateHParams(hParamsValue);\n      updateVParams(vParamsValue);\n      updateScreenParams(this.screenParams.screenParams);\n      updateAParams(this.aParams.aParams);\n      updateTargetResolution(data.meetingRoomParams.targetResolution);\n      updateTargetResolutionHost(data.meetingRoomParams.targetResolutionHost);\n    } catch (error) {\n      console.log('updateRoomParametersClient error', error);\n      parameters.showAlert?.({\n        message: (error as Error).message,\n        type: 'danger',\n        duration: 3000,\n      });\n    }\n  };\n}\n"]}

package/dist/esm2022/lib/producers/producer-emits/join-con-room.service.mjs

@@ -1,6 +1,44 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
 import * as i1 from "../../methods/utils/validate-alphanumeric.service";
+/**
+ * Joins a conference room with the provided options and performs validation checks.
+ *
+ * @param {JoinConRoomOptions} options - Contains:
+ *   - socket: Socket instance for communication.
+ *   - roomName: Name of the room to join.
+ *   - islevel: User level within the room.
+ *   - member: Member identifier.
+ *   - sec: Security token.
+ *   - apiUserName: API username for authentication.
+ *
+ * - **Validation**:
+ *   - Checks that `roomName`, `apiUserName`, and `member` are alphanumeric.
+ *   - Ensures `roomName` starts with 's' or 'p' and meets length requirements.
+ *   - Verifies `sec`, `islevel`, and `apiUserName` comply with length and format expectations.
+ *
+ * - **Response Handling**:
+ *   - Resolves to the server's response data upon a successful join.
+ *   - Rejects with specific reasons if the user is banned, suspended, or if the room host is not present.
+ *
+ * @returns {Promise<JoinConRoomResponse>} Resolves with the join response data, or rejects with error details.
+ * @throws {Error} Throws validation errors or issues encountered while joining the room.
+ *
+ * @example
+ * ```typescript
+ * const joinOptions = {
+ *   socket: mySocket,
+ *   roomName: 'sMyRoom',
+ *   islevel: '1',
+ *   member: 'participant123',
+ *   sec: '64-character-long-secret-key-here...',
+ *   apiUserName: 'apiUser123',
+ * };
+ * joinConRoom(joinOptions)
+ *   .then(response => console.log('Joined room:', response))
+ *   .catch(error => console.error('Failed to join room:', error));
+ * ```
+ */
 export class JoinConRoom {
     validateAlphanumeric;
     constructor(validateAlphanumeric) {
@@ -111,4 +149,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }], ctorParameters: () => [{ type: i1.ValidateAlphanumeric }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"join-con-room.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/producers/producer-emits/join-con-room.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Socket } from 'socket.io-client';\nimport { ValidateAlphanumeric } from '../../methods/utils/validate-alphanumeric.service';\nimport { RtpCapabilities } from 'mediasoup-client/lib/types';\n\nexport interface JoinConRoomOptions {\n  socket: Socket;\n  roomName: string;\n  islevel: string;\n  member: string;\n  sec: string;\n  apiUserName: string;\n}\n\nexport interface JoinConRoomResponse {\n  success: boolean;\n  rtpCapabilities: RtpCapabilities | null;\n  reason?: string;\n  banned?: boolean;\n  suspended?: boolean;\n  noAdmin?: boolean;\n  [key: string]: any;\n}\n\n// Export the type definition for the function\nexport type JoinConRoomType = (options: JoinConRoomOptions) => Promise<JoinConRoomResponse>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class JoinConRoom {\n  constructor(private validateAlphanumeric: ValidateAlphanumeric) {}\n\n  /**\n   * Joins a conference room using the provided options.\n   *\n   * @param {JoinConRoomOptions} options - The options for joining the conference room.\n   * @param {Socket} options.socket - The socket instance to use for communication.\n   * @param {string} options.roomName - The name of the room to join.\n   * @param {string} options.islevel - The level of the user.\n   * @param {string} options.member - The member identifier.\n   * @param {string} options.sec - The security token.\n   * @param {string} options.apiUserName - The API username.\n   * @returns {Promise<JoinConRoomResponse>} A promise that resolves with the response of the join operation.\n   *\n   * @throws {Error} If any of the required parameters are missing or invalid.\n   * @throws {Error} If the user is banned, suspended, or if the host has not joined the room yet.\n   */\n  async joinConRoom({\n    socket,\n    roomName,\n    islevel,\n    member,\n    sec,\n    apiUserName,\n  }: JoinConRoomOptions): Promise<object> {\n    return new Promise((resolve, reject) => {\n      // Validate inputs\n      if (!(sec && roomName && islevel && apiUserName && member)) {\n        const validationError = {\n          success: false,\n          rtpCapabilities: null,\n          reason: 'Missing required parameters',\n        };\n        reject(validationError);\n        return;\n      }\n\n      // Validate alphanumeric for roomName, apiUserName, and member\n      try {\n        this.validateAlphanumeric.validateAlphanumeric({ str: roomName });\n        this.validateAlphanumeric.validateAlphanumeric({ str: apiUserName });\n        this.validateAlphanumeric.validateAlphanumeric({ str: member });\n      } catch (error) {\n        const validationError = {\n          success: false,\n          rtpCapabilities: null,\n          reason: 'Invalid roomName or apiUserName or member',\n        };\n        reject(validationError);\n        return;\n      }\n\n      // Validate roomName starts with 's' or 'p'\n      if (!(roomName.startsWith('s') || roomName.startsWith('p'))) {\n        const validationError = {\n          success: false,\n          rtpCapabilities: null,\n          reason: 'Invalid roomName, must start with s or p',\n        };\n        reject(validationError);\n        return;\n      }\n\n      // Validate other conditions for sec, roomName, islevel, apiUserName\n      if (\n        !(\n          sec.length === 64 &&\n          roomName.length >= 8 &&\n          islevel.length === 1 &&\n          apiUserName.length >= 6 &&\n          (islevel === '0' || islevel === '1' || islevel === '2')\n        )\n      ) {\n        const validationError = {\n          success: false,\n          rtpCapabilities: null,\n          reason: 'Invalid roomName or islevel or apiUserName or secret',\n        };\n        reject(validationError);\n        return;\n      }\n\n      socket.emit(\n        'joinConRoom',\n        { roomName, islevel, member, sec, apiUserName },\n        async (data: any) => {\n          try {\n            // Check if rtpCapabilities is null\n            if (data.rtpCapabilities === null) {\n              // Check if banned, suspended, or noAdmin\n              if (data.banned) {\n                throw new Error('User is banned.');\n              }\n              if (data.suspended) {\n                throw new Error('User is suspended.');\n              }\n              if (data.noAdmin) {\n                throw new Error('Host has not joined the room yet.');\n              }\n\n              // Resolve with the data received from the 'joinConRoom' event\n              resolve(data);\n            } else {\n              // Resolve with the data received from the 'joinConRoom' event\n              resolve(data);\n            }\n          } catch (error) {\n            // Handle errors during the joinConRoom process\n            console.log('Error joining room:', error);\n            reject(error);\n          }\n        },\n      );\n    });\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"join-con-room.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/producers/producer-emits/join-con-room.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Socket } from 'socket.io-client';\nimport { ValidateAlphanumeric } from '../../methods/utils/validate-alphanumeric.service';\nimport { RtpCapabilities } from 'mediasoup-client/lib/types';\n\nexport interface JoinConRoomOptions {\n  socket: Socket;\n  roomName: string;\n  islevel: string;\n  member: string;\n  sec: string;\n  apiUserName: string;\n}\n\nexport interface JoinConRoomResponse {\n  success: boolean;\n  rtpCapabilities: RtpCapabilities | null;\n  reason?: string;\n  banned?: boolean;\n  suspended?: boolean;\n  noAdmin?: boolean;\n  [key: string]: any;\n}\n\n// Export the type definition for the function\nexport type JoinConRoomType = (options: JoinConRoomOptions) => Promise<JoinConRoomResponse>;\n\n/**\n * Joins a conference room with the provided options and performs validation checks.\n *\n * @param {JoinConRoomOptions} options - Contains:\n *   - socket: Socket instance for communication.\n *   - roomName: Name of the room to join.\n *   - islevel: User level within the room.\n *   - member: Member identifier.\n *   - sec: Security token.\n *   - apiUserName: API username for authentication.\n *\n * - **Validation**:\n *   - Checks that `roomName`, `apiUserName`, and `member` are alphanumeric.\n *   - Ensures `roomName` starts with 's' or 'p' and meets length requirements.\n *   - Verifies `sec`, `islevel`, and `apiUserName` comply with length and format expectations.\n *\n * - **Response Handling**:\n *   - Resolves to the server's response data upon a successful join.\n *   - Rejects with specific reasons if the user is banned, suspended, or if the room host is not present.\n *\n * @returns {Promise<JoinConRoomResponse>} Resolves with the join response data, or rejects with error details.\n * @throws {Error} Throws validation errors or issues encountered while joining the room.\n *\n * @example\n * ```typescript\n * const joinOptions = {\n *   socket: mySocket,\n *   roomName: 'sMyRoom',\n *   islevel: '1',\n *   member: 'participant123',\n *   sec: '64-character-long-secret-key-here...',\n *   apiUserName: 'apiUser123',\n * };\n * joinConRoom(joinOptions)\n *   .then(response => console.log('Joined room:', response))\n *   .catch(error => console.error('Failed to join room:', error));\n * ```\n */\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class JoinConRoom {\n  constructor(private validateAlphanumeric: ValidateAlphanumeric) {}\n\n  /**\n   * Joins a conference room using the provided options.\n   *\n   * @param {JoinConRoomOptions} options - The options for joining the conference room.\n   * @param {Socket} options.socket - The socket instance to use for communication.\n   * @param {string} options.roomName - The name of the room to join.\n   * @param {string} options.islevel - The level of the user.\n   * @param {string} options.member - The member identifier.\n   * @param {string} options.sec - The security token.\n   * @param {string} options.apiUserName - The API username.\n   * @returns {Promise<JoinConRoomResponse>} A promise that resolves with the response of the join operation.\n   *\n   * @throws {Error} If any of the required parameters are missing or invalid.\n   * @throws {Error} If the user is banned, suspended, or if the host has not joined the room yet.\n   */\n  async joinConRoom({\n    socket,\n    roomName,\n    islevel,\n    member,\n    sec,\n    apiUserName,\n  }: JoinConRoomOptions): Promise<object> {\n    return new Promise((resolve, reject) => {\n      // Validate inputs\n      if (!(sec && roomName && islevel && apiUserName && member)) {\n        const validationError = {\n          success: false,\n          rtpCapabilities: null,\n          reason: 'Missing required parameters',\n        };\n        reject(validationError);\n        return;\n      }\n\n      // Validate alphanumeric for roomName, apiUserName, and member\n      try {\n        this.validateAlphanumeric.validateAlphanumeric({ str: roomName });\n        this.validateAlphanumeric.validateAlphanumeric({ str: apiUserName });\n        this.validateAlphanumeric.validateAlphanumeric({ str: member });\n      } catch (error) {\n        const validationError = {\n          success: false,\n          rtpCapabilities: null,\n          reason: 'Invalid roomName or apiUserName or member',\n        };\n        reject(validationError);\n        return;\n      }\n\n      // Validate roomName starts with 's' or 'p'\n      if (!(roomName.startsWith('s') || roomName.startsWith('p'))) {\n        const validationError = {\n          success: false,\n          rtpCapabilities: null,\n          reason: 'Invalid roomName, must start with s or p',\n        };\n        reject(validationError);\n        return;\n      }\n\n      // Validate other conditions for sec, roomName, islevel, apiUserName\n      if (\n        !(\n          sec.length === 64 &&\n          roomName.length >= 8 &&\n          islevel.length === 1 &&\n          apiUserName.length >= 6 &&\n          (islevel === '0' || islevel === '1' || islevel === '2')\n        )\n      ) {\n        const validationError = {\n          success: false,\n          rtpCapabilities: null,\n          reason: 'Invalid roomName or islevel or apiUserName or secret',\n        };\n        reject(validationError);\n        return;\n      }\n\n      socket.emit(\n        'joinConRoom',\n        { roomName, islevel, member, sec, apiUserName },\n        async (data: any) => {\n          try {\n            // Check if rtpCapabilities is null\n            if (data.rtpCapabilities === null) {\n              // Check if banned, suspended, or noAdmin\n              if (data.banned) {\n                throw new Error('User is banned.');\n              }\n              if (data.suspended) {\n                throw new Error('User is suspended.');\n              }\n              if (data.noAdmin) {\n                throw new Error('Host has not joined the room yet.');\n              }\n\n              // Resolve with the data received from the 'joinConRoom' event\n              resolve(data);\n            } else {\n              // Resolve with the data received from the 'joinConRoom' event\n              resolve(data);\n            }\n          } catch (error) {\n            // Handle errors during the joinConRoom process\n            console.log('Error joining room:', error);\n            reject(error);\n          }\n        },\n      );\n    });\n  }\n}\n"]}

package/dist/esm2022/lib/producers/producer-emits/join-room.service.mjs

@@ -1,6 +1,44 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
 import * as i1 from "../../methods/utils/validate-alphanumeric.service";
+/**
+ * Joins a user to a room using socket communication with validation checks.
+ *
+ * @param {JoinRoomOptions} options - Contains:
+ *   - `socket`: Socket instance for communication.
+ *   - `roomName`: Name of the room to join.
+ *   - `islevel`: User's level indicator.
+ *   - `member`: User identifier.
+ *   - `sec`: Security token.
+ *   - `apiUserName`: API username for authentication.
+ *
+ * - **Validation**:
+ *   - Ensures `roomName`, `apiUserName`, and `member` are alphanumeric.
+ *   - Verifies that `roomName` starts with 's' or 'p' and meets length requirements.
+ *   - Validates `sec`, `islevel`, and `apiUserName` against specified length and format conditions.
+ *
+ * - **Response Handling**:
+ *   - Resolves with the server's response upon a successful join.
+ *   - Rejects with a descriptive error if the user is banned, suspended, or if the host has not yet joined the room.
+ *
+ * @returns {Promise<object>} Resolves with data from the 'joinRoom' event or rejects with validation errors.
+ * @throws {Error} Throws errors encountered during validation or join process.
+ *
+ * @example
+ * ```typescript
+ * const joinOptions = {
+ *   socket: mySocket,
+ *   roomName: 'sMyRoom',
+ *   islevel: '1',
+ *   member: 'participant123',
+ *   sec: '64-character-secure-key...',
+ *   apiUserName: 'apiUser123',
+ * };
+ * joinRoom(joinOptions)
+ *   .then(response => console.log('Room joined:', response))
+ *   .catch(error => console.error('Join failed:', error));
+ * ```
+ */
 export class JoinRoom {
     validateAlphanumeric;
     constructor(validateAlphanumeric) {
@@ -111,4 +149,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }], ctorParameters: () => [{ type: i1.ValidateAlphanumeric }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"join-room.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/producers/producer-emits/join-room.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Socket } from 'socket.io-client';\nimport { ValidateAlphanumeric } from '../../methods/utils/validate-alphanumeric.service';\n\nexport interface JoinRoomOptions {\n  socket: Socket;\n  roomName: string;\n  islevel: string;\n  member: string;\n  sec: string;\n  apiUserName: string;\n}\n\n// Export the type definition for the function\nexport type JoinRoomType = (\n  socket: Socket,\n  roomName: string,\n  islevel: string,\n  member: string,\n  sec: string,\n  apiUserName: string,\n) => Promise<object>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class JoinRoom {\n  constructor(private validateAlphanumeric: ValidateAlphanumeric) {}\n\n  /**\n   * Joins a user to a specified room via a socket connection.\n   *\n   * @param {Object} options - The options for joining the room.\n   * @param {Socket} options.socket - The socket instance to use for communication.\n   * @param {string} options.roomName - The name of the room to join.\n   * @param {string} options.islevel - The level of the user.\n   * @param {string} options.member - The member identifier.\n   * @param {string} options.sec - The security token.\n   * @param {string} options.apiUserName - The API username of the user.\n   *\n   * @returns {Promise<object>} A promise that resolves with the data received from the 'joinRoom' event or rejects with a validation error.\n   *\n   * @throws {Error} Throws an error if the user is banned, suspended, or if the host has not joined the room yet.\n   */\n  async joinRoom({\n    socket,\n    roomName,\n    islevel,\n    member,\n    sec,\n    apiUserName,\n  }: JoinRoomOptions): Promise<object> {\n    return new Promise((resolve, reject) => {\n      // Validate inputs\n      if (!(sec && roomName && islevel && apiUserName && member)) {\n        const validationError = {\n          success: false,\n          rtpCapabilities: null,\n          reason: 'Missing required parameters',\n        };\n        reject(validationError);\n        return;\n      }\n\n      // Validate alphanumeric for roomName, apiUserName, and member\n      try {\n        this.validateAlphanumeric.validateAlphanumeric({ str: roomName });\n        this.validateAlphanumeric.validateAlphanumeric({ str: apiUserName });\n        this.validateAlphanumeric.validateAlphanumeric({ str: member });\n      } catch (error) {\n        const validationError = {\n          success: false,\n          rtpCapabilities: null,\n          reason: 'Invalid roomName or apiUserName or member',\n        };\n        reject(validationError);\n        return;\n      }\n\n      // Validate roomName starts with 's' or 'p'\n      if (!(roomName.startsWith('s') || roomName.startsWith('p'))) {\n        const validationError = {\n          success: false,\n          rtpCapabilities: null,\n          reason: 'Invalid roomName, must start with s or p',\n        };\n        reject(validationError);\n        return;\n      }\n\n      // Validate other conditions for sec, roomName, islevel, apiUserName\n      if (\n        !(\n          sec.length === 64 &&\n          roomName.length >= 8 &&\n          islevel.length === 1 &&\n          apiUserName.length >= 6 &&\n          (islevel === '0' || islevel === '1' || islevel === '2')\n        )\n      ) {\n        const validationError = {\n          success: false,\n          rtpCapabilities: null,\n          reason: 'Invalid roomName or islevel or apiUserName or secret',\n        };\n        reject(validationError);\n        return;\n      }\n\n      socket.emit(\n        'joinRoom',\n        { roomName, islevel, member, sec, apiUserName },\n        async (data: any) => {\n          try {\n            // Check if rtpCapabilities is null\n            if (data.rtpCapabilities === null) {\n              // Check if banned, suspended, or noAdmin\n              if (data.banned) {\n                throw new Error('User is banned.');\n              }\n              if (data.suspended) {\n                throw new Error('User is suspended.');\n              }\n              if (data.noAdmin) {\n                throw new Error('Host has not joined the room yet.');\n              }\n\n              // Resolve with the data received from the 'joinRoom' event\n              resolve(data);\n            } else {\n              // Resolve with the data received from the 'joinRoom' event\n              resolve(data);\n            }\n          } catch (error) {\n            // Handle errors during the joinRoom process\n            console.log('Error joining room:', error);\n            reject(error);\n          }\n        },\n      );\n    });\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"join-room.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/producers/producer-emits/join-room.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Socket } from 'socket.io-client';\nimport { ValidateAlphanumeric } from '../../methods/utils/validate-alphanumeric.service';\n\nexport interface JoinRoomOptions {\n  socket: Socket;\n  roomName: string;\n  islevel: string;\n  member: string;\n  sec: string;\n  apiUserName: string;\n}\n\n// Export the type definition for the function\nexport type JoinRoomType = (\n  socket: Socket,\n  roomName: string,\n  islevel: string,\n  member: string,\n  sec: string,\n  apiUserName: string,\n) => Promise<object>;\n\n/**\n * Joins a user to a room using socket communication with validation checks.\n *\n * @param {JoinRoomOptions} options - Contains:\n *   - `socket`: Socket instance for communication.\n *   - `roomName`: Name of the room to join.\n *   - `islevel`: User's level indicator.\n *   - `member`: User identifier.\n *   - `sec`: Security token.\n *   - `apiUserName`: API username for authentication.\n *\n * - **Validation**:\n *   - Ensures `roomName`, `apiUserName`, and `member` are alphanumeric.\n *   - Verifies that `roomName` starts with 's' or 'p' and meets length requirements.\n *   - Validates `sec`, `islevel`, and `apiUserName` against specified length and format conditions.\n *\n * - **Response Handling**:\n *   - Resolves with the server's response upon a successful join.\n *   - Rejects with a descriptive error if the user is banned, suspended, or if the host has not yet joined the room.\n *\n * @returns {Promise<object>} Resolves with data from the 'joinRoom' event or rejects with validation errors.\n * @throws {Error} Throws errors encountered during validation or join process.\n *\n * @example\n * ```typescript\n * const joinOptions = {\n *   socket: mySocket,\n *   roomName: 'sMyRoom',\n *   islevel: '1',\n *   member: 'participant123',\n *   sec: '64-character-secure-key...',\n *   apiUserName: 'apiUser123',\n * };\n * joinRoom(joinOptions)\n *   .then(response => console.log('Room joined:', response))\n *   .catch(error => console.error('Join failed:', error));\n * ```\n */\n\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class JoinRoom {\n  constructor(private validateAlphanumeric: ValidateAlphanumeric) {}\n\n  /**\n   * Joins a user to a specified room via a socket connection.\n   *\n   * @param {Object} options - The options for joining the room.\n   * @param {Socket} options.socket - The socket instance to use for communication.\n   * @param {string} options.roomName - The name of the room to join.\n   * @param {string} options.islevel - The level of the user.\n   * @param {string} options.member - The member identifier.\n   * @param {string} options.sec - The security token.\n   * @param {string} options.apiUserName - The API username of the user.\n   *\n   * @returns {Promise<object>} A promise that resolves with the data received from the 'joinRoom' event or rejects with a validation error.\n   *\n   * @throws {Error} Throws an error if the user is banned, suspended, or if the host has not joined the room yet.\n   */\n  async joinRoom({\n    socket,\n    roomName,\n    islevel,\n    member,\n    sec,\n    apiUserName,\n  }: JoinRoomOptions): Promise<object> {\n    return new Promise((resolve, reject) => {\n      // Validate inputs\n      if (!(sec && roomName && islevel && apiUserName && member)) {\n        const validationError = {\n          success: false,\n          rtpCapabilities: null,\n          reason: 'Missing required parameters',\n        };\n        reject(validationError);\n        return;\n      }\n\n      // Validate alphanumeric for roomName, apiUserName, and member\n      try {\n        this.validateAlphanumeric.validateAlphanumeric({ str: roomName });\n        this.validateAlphanumeric.validateAlphanumeric({ str: apiUserName });\n        this.validateAlphanumeric.validateAlphanumeric({ str: member });\n      } catch (error) {\n        const validationError = {\n          success: false,\n          rtpCapabilities: null,\n          reason: 'Invalid roomName or apiUserName or member',\n        };\n        reject(validationError);\n        return;\n      }\n\n      // Validate roomName starts with 's' or 'p'\n      if (!(roomName.startsWith('s') || roomName.startsWith('p'))) {\n        const validationError = {\n          success: false,\n          rtpCapabilities: null,\n          reason: 'Invalid roomName, must start with s or p',\n        };\n        reject(validationError);\n        return;\n      }\n\n      // Validate other conditions for sec, roomName, islevel, apiUserName\n      if (\n        !(\n          sec.length === 64 &&\n          roomName.length >= 8 &&\n          islevel.length === 1 &&\n          apiUserName.length >= 6 &&\n          (islevel === '0' || islevel === '1' || islevel === '2')\n        )\n      ) {\n        const validationError = {\n          success: false,\n          rtpCapabilities: null,\n          reason: 'Invalid roomName or islevel or apiUserName or secret',\n        };\n        reject(validationError);\n        return;\n      }\n\n      socket.emit(\n        'joinRoom',\n        { roomName, islevel, member, sec, apiUserName },\n        async (data: any) => {\n          try {\n            // Check if rtpCapabilities is null\n            if (data.rtpCapabilities === null) {\n              // Check if banned, suspended, or noAdmin\n              if (data.banned) {\n                throw new Error('User is banned.');\n              }\n              if (data.suspended) {\n                throw new Error('User is suspended.');\n              }\n              if (data.noAdmin) {\n                throw new Error('Host has not joined the room yet.');\n              }\n\n              // Resolve with the data received from the 'joinRoom' event\n              resolve(data);\n            } else {\n              // Resolve with the data received from the 'joinRoom' event\n              resolve(data);\n            }\n          } catch (error) {\n            // Handle errors during the joinRoom process\n            console.log('Error joining room:', error);\n            reject(error);\n          }\n        },\n      );\n    });\n  }\n}\n"]}

package/dist/esm2022/lib/producers/socket-receive-methods/all-members-rest.service.mjs

@@ -1,5 +1,78 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Manages participant settings and UI updates, including connecting IPs, reordering streams,
+ * updating settings, and handling participant display based on various session parameters.
+ *
+ * @async
+ * @param {AllMembersRestOptions} options - Parameters for managing members.
+ * @param {Participant[]} options.members - The array of participant objects.
+ * @param {Settings} options.settings - The session settings for audio, video, screenshare, and chat.
+ * @param {string} [options.coHoste] - The current co-host name.
+ * @param {CoHostResponsibility[]} [options.coHostRes] - The responsibilities assigned to the co-host.
+ * @param {AllMembersRestParameters} options.parameters - Additional parameters for managing members and UI updates.
+ * @param {ConsumeSocket[]} options.consume_sockets - Array of sockets for participant communication.
+ * @param {string} options.apiUserName - API username for authentication.
+ * @param {string} options.apiKey - API key for authentication.
+ * @param {string} options.apiToken - API token for authentication.
+ *
+ * @returns {Promise<void>} A promise that resolves when updates and changes for members are completed.
+ *
+ * @example
+ * ```typescript
+ * const allMembersRestService = new AllMembersRest();
+ * await allMembersRestService.allMembersRest({
+ *   members: [{ name: 'John', isBanned: false, isSuspended: false, audioID: '123', videoID: '456' }],
+ *   settings: ['enabled', 'HD', 'allowed', 'public'],
+ *   coHoste: 'Jane',
+ *   coHostRes: ['manage-chat'],
+ *   parameters: {
+ *     participantsAll: [],
+ *     participants: [],
+ *     dispActiveNames: ['John'],
+ *     requestList: [],
+ *     coHost: '',
+ *     coHostResponsibility: [],
+ *     lock_screen: false,
+ *     firstAll: false,
+ *     membersReceived: false,
+ *     roomRecvIPs: [],
+ *     deferScreenReceived: false,
+ *     screenId: null,
+ *     shareScreenStarted: false,
+ *     meetingDisplayType: 'grid',
+ *     audioSetting: '',
+ *     videoSetting: '',
+ *     screenshareSetting: '',
+ *     chatSetting: '',
+ *     updateParticipantsAll: (participantsAll) => console.log(participantsAll),
+ *     updateParticipants: (participants) => console.log(participants),
+ *     updateRequestList: (requestList) => console.log(requestList),
+ *     updateCoHost: (coHost) => console.log(coHost),
+ *     updateCoHostResponsibility: (coHostRes) => console.log(coHostRes),
+ *     updateFirstAll: (firstAll) => console.log(firstAll),
+ *     updateMembersReceived: (membersReceived) => console.log(membersReceived),
+ *     updateDeferScreenReceived: (deferScreenReceived) => console.log(deferScreenReceived),
+ *     updateShareScreenStarted: (shareScreenStarted) => console.log(shareScreenStarted),
+ *     updateAudioSetting: (audioSetting) => console.log(audioSetting),
+ *     updateVideoSetting: (videoSetting) => console.log(videoSetting),
+ *     updateScreenshareSetting: (screenshareSetting) => console.log(screenshareSetting),
+ *     updateChatSetting: (chatSetting) => console.log(chatSetting),
+ *     updateConsume_sockets: (sockets) => console.log(sockets),
+ *     updateRoomRecvIPs: (ips) => console.log(ips),
+ *     updateIsLoadingModalVisible: (visible) => console.log(visible),
+ *     onScreenChanges: (params) => console.log('onScreenChanges called with', params),
+ *     connectIps: async (params) => [['socket1'], ['ip1']],
+ *     sleep: async ({ ms }) => new Promise((resolve) => setTimeout(resolve, ms)),
+ *     reorderStreams: async (params) => console.log('reorderStreams called with', params),
+ *   },
+ *   consume_sockets: [{ socketId: 'abc123' }],
+ *   apiUserName: 'testUser',
+ *   apiKey: 'apiKeyExample',
+ *   apiToken: 'apiTokenExample',
+ * });
+ * ```
+ */
 export class AllMembersRest {
     /**
      * Handles various tasks related to participant management and UI updates.
@@ -152,4 +225,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"all-members-rest.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/producers/socket-receive-methods/all-members-rest.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\n\nimport {\n  Participant,\n  CoHostResponsibility,\n  OnScreenChangesType,\n  OnScreenChangesParameters,\n  Request,\n  ConnectIpsParameters,\n  ReorderStreamsParameters,\n  ConnectIpsType,\n  SleepType,\n  ReorderStreamsType,\n  Settings,\n  ConsumeSocket,\n} from '../../@types/types';\nexport interface AllMembersRestParameters\n  extends OnScreenChangesParameters,\n    ConnectIpsParameters,\n    ReorderStreamsParameters {\n  participantsAll: Participant[];\n  participants: Participant[];\n  dispActiveNames: string[];\n  requestList: Request[];\n  coHost: string;\n  coHostResponsibility: CoHostResponsibility[];\n  lock_screen: boolean;\n  firstAll: boolean;\n  membersReceived: boolean;\n  roomRecvIPs: string[];\n  deferScreenReceived: boolean;\n  screenId?: string;\n  shareScreenStarted: boolean;\n  meetingDisplayType: string;\n  audioSetting: string;\n  videoSetting: string;\n  screenshareSetting: string;\n  chatSetting: string;\n\n  updateParticipantsAll: (participantsAll: Participant[]) => void;\n  updateParticipants: (participants: Participant[]) => void;\n  updateRequestList: (requestList: Request[]) => void;\n  updateCoHost: (coHost: string) => void;\n  updateCoHostResponsibility: (coHostResponsibility: CoHostResponsibility[]) => void;\n  updateFirstAll: (firstAll: boolean) => void;\n  updateMembersReceived: (membersReceived: boolean) => void;\n  updateDeferScreenReceived: (deferScreenReceived: boolean) => void;\n  updateShareScreenStarted: (shareScreenStarted: boolean) => void;\n  updateAudioSetting: (audioSetting: string) => void;\n  updateVideoSetting: (videoSetting: string) => void;\n  updateScreenshareSetting: (screenshareSetting: string) => void;\n  updateChatSetting: (chatSetting: string) => void;\n  updateConsume_sockets: (consume_sockets: ConsumeSocket[]) => void;\n  updateRoomRecvIPs: (ips: string[]) => void;\n  updateIsLoadingModalVisible: (visible: boolean) => void;\n\n  // mediasfu functions\n  onScreenChanges: OnScreenChangesType;\n  connectIps: ConnectIpsType;\n  sleep: SleepType;\n  reorderStreams: ReorderStreamsType;\n\n  getUpdatedAllParams: () => AllMembersRestParameters;\n  [key: string]: any;\n}\n\nexport interface AllMembersRestOptions {\n  members: Participant[];\n  settings: Settings;\n  coHoste?: string;\n  coHostRes?: CoHostResponsibility[];\n  parameters: AllMembersRestParameters;\n  consume_sockets: ConsumeSocket[];\n  apiUserName: string;\n  apiKey: string;\n  apiToken: string;\n}\n\n// Export the type definition for the function\nexport type AllMembersRestType = (options: AllMembersRestOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class AllMembersRest {\n  /**\n   * Handles various tasks related to participant management and UI updates.\n   * @param {Object} params - The parameters passed to the allMembersRest method.\n   * @param {Array} params.members - The array of participant members.\n   * @param {Array} params.settings - The array of settings.\n   * @param {boolean} params.coHoste - The co-host state.\n   * @param {boolean} params.coHostRes - The co-host responsibility state.\n   * @param {Object} params.parameters - The object containing parameters for the allMembersRest method.\n   * @param {Array} params.consume_sockets - The array of consume sockets.\n   * @param {string} params.apiUserName - The API username.\n   * @param {string} params.apiKey - The API key.\n   * @param {string} params.apiToken - The API token.\n   * @returns {void} - No return value.\n   */\n  async allMembersRest({\n    members,\n    settings,\n    coHoste,\n    coHostRes,\n    parameters,\n    consume_sockets,\n    apiUserName,\n    apiKey,\n    apiToken,\n  }: AllMembersRestOptions): Promise<void> {\n    let {\n      participantsAll,\n      participants,\n      dispActiveNames,\n      requestList,\n      coHost,\n      coHostResponsibility,\n      lock_screen,\n      firstAll,\n      membersReceived,\n      roomRecvIPs,\n      deferScreenReceived,\n      screenId,\n      shareScreenStarted,\n      meetingDisplayType,\n      audioSetting,\n      videoSetting,\n      screenshareSetting,\n      chatSetting,\n      updateParticipantsAll,\n      updateParticipants,\n      updateRequestList,\n      updateCoHost,\n      updateCoHostResponsibility,\n      updateFirstAll,\n      updateMembersReceived,\n      updateDeferScreenReceived,\n      updateShareScreenStarted,\n      updateAudioSetting,\n      updateVideoSetting,\n      updateScreenshareSetting,\n      updateChatSetting,\n      updateConsume_sockets,\n      updateRoomRecvIPs,\n      updateIsLoadingModalVisible,\n\n      onScreenChanges,\n      connectIps,\n      reorderStreams,\n      sleep,\n    } = parameters;\n\n    // Filter out the participant that isBanned == true or isSuspended == true\n    participantsAll = members.map((participant) => ({\n      isBanned: participant.isBanned,\n      isSuspended: participant.isSuspended,\n      name: participant.name,\n      audioID: participant.audioID,\n      videoID: participant.videoID,\n    }));\n    updateParticipantsAll(participantsAll);\n\n    participants = members.filter(\n      (participant) => !participant.isBanned && !participant.isSuspended,\n    );\n    updateParticipants(participants);\n\n    // Check if dispActiveNames is not empty and contains the name of the participant that is not in the participants array\n    if (dispActiveNames.length > 0) {\n      let dispActiveNames_ = dispActiveNames.filter(\n        (name: string) => !participants.map((participant: any) => participant.name).includes(name),\n      );\n      if (dispActiveNames_.length > 0 && membersReceived) {\n        await reorderStreams({ add: false, screenChanged: true, parameters });\n      }\n    }\n\n    // Operations to update the UI; make sure we are connected to the server before updating the UI\n    if (!membersReceived) {\n      if (roomRecvIPs.length < 1) {\n        // Keep checking every 0.01s\n        let checkIPs = setInterval(async () => {\n          if (roomRecvIPs.length > 0) {\n            clearInterval(checkIPs);\n\n            if (deferScreenReceived && screenId != null) {\n              shareScreenStarted = true;\n              updateShareScreenStarted(shareScreenStarted);\n            }\n\n            const [sockets_, ips_] = await connectIps({\n              consume_sockets,\n              remIP: roomRecvIPs,\n              parameters,\n              apiUserName,\n              apiKey,\n              apiToken,\n            });\n\n            if (sockets_ && ips_) {\n              updateConsume_sockets(sockets_);\n              updateRoomRecvIPs(ips_);\n            }\n\n            membersReceived = true;\n            updateMembersReceived(membersReceived);\n\n            await sleep({ ms: 250 });\n            updateIsLoadingModalVisible(false);\n            deferScreenReceived = false;\n            updateDeferScreenReceived(deferScreenReceived);\n          }\n        }, 10);\n      } else {\n        const [sockets_, ips_] = await connectIps({\n          consume_sockets,\n          remIP: roomRecvIPs,\n          parameters,\n          apiUserName,\n          apiKey,\n          apiToken,\n        });\n\n        if (sockets_ && ips_) {\n          updateConsume_sockets(sockets_);\n          updateRoomRecvIPs(ips_);\n        }\n        membersReceived = true;\n        updateMembersReceived(membersReceived);\n\n        if (deferScreenReceived && screenId != null) {\n          shareScreenStarted = true;\n          updateShareScreenStarted(shareScreenStarted);\n        }\n\n        await sleep({ ms: 250 });\n        updateIsLoadingModalVisible(false);\n        deferScreenReceived = false;\n        updateDeferScreenReceived(deferScreenReceived);\n      }\n    } else {\n      if (screenId != null) {\n        let host = participants.find(\n          (participant: any) => participant.ScreenID == screenId && participant.ScreenOn == true,\n        );\n        if (deferScreenReceived && screenId != null && host) {\n          shareScreenStarted = true;\n          updateShareScreenStarted(shareScreenStarted);\n        }\n      }\n    }\n\n    // Return requests for only ids that are in the participants array and update the count badge\n    let requests = requestList;\n    requestList = requests.filter((request: any) =>\n      participants.some((participant: any) => participant.id == request.id),\n    );\n    updateRequestList(requestList);\n\n    if (coHoste !== undefined && coHoste !== null) {\n      coHost = coHoste;\n    }\n    if (coHost !== undefined && coHost !== null) {\n      updateCoHost(coHost);\n    }\n    if (coHostRes !== undefined && coHostRes !== null) {\n      coHostResponsibility = coHostRes;\n    }\n    updateCoHostResponsibility(coHostResponsibility);\n\n    try {\n      if (!lock_screen && !firstAll) {\n        await onScreenChanges({ parameters });\n\n        if (meetingDisplayType != 'all') {\n          firstAll = true;\n          updateFirstAll(firstAll);\n        }\n      }\n    } catch (error) {\n      console.log('allMembersRest OnScreen', error);\n    }\n\n    try {\n      if (membersReceived) {\n        audioSetting = settings[0];\n        videoSetting = settings[1];\n        screenshareSetting = settings[2];\n        chatSetting = settings[3];\n\n        updateAudioSetting(audioSetting);\n        updateVideoSetting(videoSetting);\n        updateScreenshareSetting(screenshareSetting);\n        updateChatSetting(chatSetting);\n      }\n    } catch (error) {\n      console.log('allMembersRest Settings', error);\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"all-members-rest.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/producers/socket-receive-methods/all-members-rest.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\n\nimport {\n  Participant,\n  CoHostResponsibility,\n  OnScreenChangesType,\n  OnScreenChangesParameters,\n  Request,\n  ConnectIpsParameters,\n  ReorderStreamsParameters,\n  ConnectIpsType,\n  SleepType,\n  ReorderStreamsType,\n  Settings,\n  ConsumeSocket,\n} from '../../@types/types';\nexport interface AllMembersRestParameters\n  extends OnScreenChangesParameters,\n    ConnectIpsParameters,\n    ReorderStreamsParameters {\n  participantsAll: Participant[];\n  participants: Participant[];\n  dispActiveNames: string[];\n  requestList: Request[];\n  coHost: string;\n  coHostResponsibility: CoHostResponsibility[];\n  lock_screen: boolean;\n  firstAll: boolean;\n  membersReceived: boolean;\n  roomRecvIPs: string[];\n  deferScreenReceived: boolean;\n  screenId?: string;\n  shareScreenStarted: boolean;\n  meetingDisplayType: string;\n  audioSetting: string;\n  videoSetting: string;\n  screenshareSetting: string;\n  chatSetting: string;\n\n  updateParticipantsAll: (participantsAll: Participant[]) => void;\n  updateParticipants: (participants: Participant[]) => void;\n  updateRequestList: (requestList: Request[]) => void;\n  updateCoHost: (coHost: string) => void;\n  updateCoHostResponsibility: (coHostResponsibility: CoHostResponsibility[]) => void;\n  updateFirstAll: (firstAll: boolean) => void;\n  updateMembersReceived: (membersReceived: boolean) => void;\n  updateDeferScreenReceived: (deferScreenReceived: boolean) => void;\n  updateShareScreenStarted: (shareScreenStarted: boolean) => void;\n  updateAudioSetting: (audioSetting: string) => void;\n  updateVideoSetting: (videoSetting: string) => void;\n  updateScreenshareSetting: (screenshareSetting: string) => void;\n  updateChatSetting: (chatSetting: string) => void;\n  updateConsume_sockets: (consume_sockets: ConsumeSocket[]) => void;\n  updateRoomRecvIPs: (ips: string[]) => void;\n  updateIsLoadingModalVisible: (visible: boolean) => void;\n\n  // mediasfu functions\n  onScreenChanges: OnScreenChangesType;\n  connectIps: ConnectIpsType;\n  sleep: SleepType;\n  reorderStreams: ReorderStreamsType;\n\n  getUpdatedAllParams: () => AllMembersRestParameters;\n  [key: string]: any;\n}\n\nexport interface AllMembersRestOptions {\n  members: Participant[];\n  settings: Settings;\n  coHoste?: string;\n  coHostRes?: CoHostResponsibility[];\n  parameters: AllMembersRestParameters;\n  consume_sockets: ConsumeSocket[];\n  apiUserName: string;\n  apiKey: string;\n  apiToken: string;\n}\n\n// Export the type definition for the function\nexport type AllMembersRestType = (options: AllMembersRestOptions) => Promise<void>;\n\n/**\n * Manages participant settings and UI updates, including connecting IPs, reordering streams,\n * updating settings, and handling participant display based on various session parameters.\n *\n * @async\n * @param {AllMembersRestOptions} options - Parameters for managing members.\n * @param {Participant[]} options.members - The array of participant objects.\n * @param {Settings} options.settings - The session settings for audio, video, screenshare, and chat.\n * @param {string} [options.coHoste] - The current co-host name.\n * @param {CoHostResponsibility[]} [options.coHostRes] - The responsibilities assigned to the co-host.\n * @param {AllMembersRestParameters} options.parameters - Additional parameters for managing members and UI updates.\n * @param {ConsumeSocket[]} options.consume_sockets - Array of sockets for participant communication.\n * @param {string} options.apiUserName - API username for authentication.\n * @param {string} options.apiKey - API key for authentication.\n * @param {string} options.apiToken - API token for authentication.\n *\n * @returns {Promise<void>} A promise that resolves when updates and changes for members are completed.\n *\n * @example\n * ```typescript\n * const allMembersRestService = new AllMembersRest();\n * await allMembersRestService.allMembersRest({\n *   members: [{ name: 'John', isBanned: false, isSuspended: false, audioID: '123', videoID: '456' }],\n *   settings: ['enabled', 'HD', 'allowed', 'public'],\n *   coHoste: 'Jane',\n *   coHostRes: ['manage-chat'],\n *   parameters: {\n *     participantsAll: [],\n *     participants: [],\n *     dispActiveNames: ['John'],\n *     requestList: [],\n *     coHost: '',\n *     coHostResponsibility: [],\n *     lock_screen: false,\n *     firstAll: false,\n *     membersReceived: false,\n *     roomRecvIPs: [],\n *     deferScreenReceived: false,\n *     screenId: null,\n *     shareScreenStarted: false,\n *     meetingDisplayType: 'grid',\n *     audioSetting: '',\n *     videoSetting: '',\n *     screenshareSetting: '',\n *     chatSetting: '',\n *     updateParticipantsAll: (participantsAll) => console.log(participantsAll),\n *     updateParticipants: (participants) => console.log(participants),\n *     updateRequestList: (requestList) => console.log(requestList),\n *     updateCoHost: (coHost) => console.log(coHost),\n *     updateCoHostResponsibility: (coHostRes) => console.log(coHostRes),\n *     updateFirstAll: (firstAll) => console.log(firstAll),\n *     updateMembersReceived: (membersReceived) => console.log(membersReceived),\n *     updateDeferScreenReceived: (deferScreenReceived) => console.log(deferScreenReceived),\n *     updateShareScreenStarted: (shareScreenStarted) => console.log(shareScreenStarted),\n *     updateAudioSetting: (audioSetting) => console.log(audioSetting),\n *     updateVideoSetting: (videoSetting) => console.log(videoSetting),\n *     updateScreenshareSetting: (screenshareSetting) => console.log(screenshareSetting),\n *     updateChatSetting: (chatSetting) => console.log(chatSetting),\n *     updateConsume_sockets: (sockets) => console.log(sockets),\n *     updateRoomRecvIPs: (ips) => console.log(ips),\n *     updateIsLoadingModalVisible: (visible) => console.log(visible),\n *     onScreenChanges: (params) => console.log('onScreenChanges called with', params),\n *     connectIps: async (params) => [['socket1'], ['ip1']],\n *     sleep: async ({ ms }) => new Promise((resolve) => setTimeout(resolve, ms)),\n *     reorderStreams: async (params) => console.log('reorderStreams called with', params),\n *   },\n *   consume_sockets: [{ socketId: 'abc123' }],\n *   apiUserName: 'testUser',\n *   apiKey: 'apiKeyExample',\n *   apiToken: 'apiTokenExample',\n * });\n * ```\n */\n\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class AllMembersRest {\n  /**\n   * Handles various tasks related to participant management and UI updates.\n   * @param {Object} params - The parameters passed to the allMembersRest method.\n   * @param {Array} params.members - The array of participant members.\n   * @param {Array} params.settings - The array of settings.\n   * @param {boolean} params.coHoste - The co-host state.\n   * @param {boolean} params.coHostRes - The co-host responsibility state.\n   * @param {Object} params.parameters - The object containing parameters for the allMembersRest method.\n   * @param {Array} params.consume_sockets - The array of consume sockets.\n   * @param {string} params.apiUserName - The API username.\n   * @param {string} params.apiKey - The API key.\n   * @param {string} params.apiToken - The API token.\n   * @returns {void} - No return value.\n   */\n  async allMembersRest({\n    members,\n    settings,\n    coHoste,\n    coHostRes,\n    parameters,\n    consume_sockets,\n    apiUserName,\n    apiKey,\n    apiToken,\n  }: AllMembersRestOptions): Promise<void> {\n    let {\n      participantsAll,\n      participants,\n      dispActiveNames,\n      requestList,\n      coHost,\n      coHostResponsibility,\n      lock_screen,\n      firstAll,\n      membersReceived,\n      roomRecvIPs,\n      deferScreenReceived,\n      screenId,\n      shareScreenStarted,\n      meetingDisplayType,\n      audioSetting,\n      videoSetting,\n      screenshareSetting,\n      chatSetting,\n      updateParticipantsAll,\n      updateParticipants,\n      updateRequestList,\n      updateCoHost,\n      updateCoHostResponsibility,\n      updateFirstAll,\n      updateMembersReceived,\n      updateDeferScreenReceived,\n      updateShareScreenStarted,\n      updateAudioSetting,\n      updateVideoSetting,\n      updateScreenshareSetting,\n      updateChatSetting,\n      updateConsume_sockets,\n      updateRoomRecvIPs,\n      updateIsLoadingModalVisible,\n\n      onScreenChanges,\n      connectIps,\n      reorderStreams,\n      sleep,\n    } = parameters;\n\n    // Filter out the participant that isBanned == true or isSuspended == true\n    participantsAll = members.map((participant) => ({\n      isBanned: participant.isBanned,\n      isSuspended: participant.isSuspended,\n      name: participant.name,\n      audioID: participant.audioID,\n      videoID: participant.videoID,\n    }));\n    updateParticipantsAll(participantsAll);\n\n    participants = members.filter(\n      (participant) => !participant.isBanned && !participant.isSuspended,\n    );\n    updateParticipants(participants);\n\n    // Check if dispActiveNames is not empty and contains the name of the participant that is not in the participants array\n    if (dispActiveNames.length > 0) {\n      let dispActiveNames_ = dispActiveNames.filter(\n        (name: string) => !participants.map((participant: any) => participant.name).includes(name),\n      );\n      if (dispActiveNames_.length > 0 && membersReceived) {\n        await reorderStreams({ add: false, screenChanged: true, parameters });\n      }\n    }\n\n    // Operations to update the UI; make sure we are connected to the server before updating the UI\n    if (!membersReceived) {\n      if (roomRecvIPs.length < 1) {\n        // Keep checking every 0.01s\n        let checkIPs = setInterval(async () => {\n          if (roomRecvIPs.length > 0) {\n            clearInterval(checkIPs);\n\n            if (deferScreenReceived && screenId != null) {\n              shareScreenStarted = true;\n              updateShareScreenStarted(shareScreenStarted);\n            }\n\n            const [sockets_, ips_] = await connectIps({\n              consume_sockets,\n              remIP: roomRecvIPs,\n              parameters,\n              apiUserName,\n              apiKey,\n              apiToken,\n            });\n\n            if (sockets_ && ips_) {\n              updateConsume_sockets(sockets_);\n              updateRoomRecvIPs(ips_);\n            }\n\n            membersReceived = true;\n            updateMembersReceived(membersReceived);\n\n            await sleep({ ms: 250 });\n            updateIsLoadingModalVisible(false);\n            deferScreenReceived = false;\n            updateDeferScreenReceived(deferScreenReceived);\n          }\n        }, 10);\n      } else {\n        const [sockets_, ips_] = await connectIps({\n          consume_sockets,\n          remIP: roomRecvIPs,\n          parameters,\n          apiUserName,\n          apiKey,\n          apiToken,\n        });\n\n        if (sockets_ && ips_) {\n          updateConsume_sockets(sockets_);\n          updateRoomRecvIPs(ips_);\n        }\n        membersReceived = true;\n        updateMembersReceived(membersReceived);\n\n        if (deferScreenReceived && screenId != null) {\n          shareScreenStarted = true;\n          updateShareScreenStarted(shareScreenStarted);\n        }\n\n        await sleep({ ms: 250 });\n        updateIsLoadingModalVisible(false);\n        deferScreenReceived = false;\n        updateDeferScreenReceived(deferScreenReceived);\n      }\n    } else {\n      if (screenId != null) {\n        let host = participants.find(\n          (participant: any) => participant.ScreenID == screenId && participant.ScreenOn == true,\n        );\n        if (deferScreenReceived && screenId != null && host) {\n          shareScreenStarted = true;\n          updateShareScreenStarted(shareScreenStarted);\n        }\n      }\n    }\n\n    // Return requests for only ids that are in the participants array and update the count badge\n    let requests = requestList;\n    requestList = requests.filter((request: any) =>\n      participants.some((participant: any) => participant.id == request.id),\n    );\n    updateRequestList(requestList);\n\n    if (coHoste !== undefined && coHoste !== null) {\n      coHost = coHoste;\n    }\n    if (coHost !== undefined && coHost !== null) {\n      updateCoHost(coHost);\n    }\n    if (coHostRes !== undefined && coHostRes !== null) {\n      coHostResponsibility = coHostRes;\n    }\n    updateCoHostResponsibility(coHostResponsibility);\n\n    try {\n      if (!lock_screen && !firstAll) {\n        await onScreenChanges({ parameters });\n\n        if (meetingDisplayType != 'all') {\n          firstAll = true;\n          updateFirstAll(firstAll);\n        }\n      }\n    } catch (error) {\n      console.log('allMembersRest OnScreen', error);\n    }\n\n    try {\n      if (membersReceived) {\n        audioSetting = settings[0];\n        videoSetting = settings[1];\n        screenshareSetting = settings[2];\n        chatSetting = settings[3];\n\n        updateAudioSetting(audioSetting);\n        updateVideoSetting(videoSetting);\n        updateScreenshareSetting(screenshareSetting);\n        updateChatSetting(chatSetting);\n      }\n    } catch (error) {\n      console.log('allMembersRest Settings', error);\n    }\n  }\n}\n"]}