mediasfu-angular 1.0.0 → 1.0.2

package/dist/esm2022/lib/producers/socket-receive-methods/producer-media-closed.service.mjs

@@ -1,5 +1,66 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Service to handle closing a media producer and associated UI and state updates.
+ *
+ * @class
+ * @name ProducerMediaClosed
+ * @description
+ * Manages the closure of a media producer by identifying associated consumer transports, closing necessary resources,
+ * and updating the user interface to reflect the change. For screen sharing, it resets the shared state and adjusts the main view.
+ *
+ * @method
+ * producerMediaClosed
+ *
+ * @param {ProducerMediaClosedOptions} options - Contains details on the producer and parameters for state updates:
+ *   - `producerId` {string}: ID of the producer to close.
+ *   - `kind` {string}: The type of media to close (e.g., "screenshare" or "audio").
+ *   - `parameters` {ProducerMediaClosedParameters}: Settings and update functions to manage the closure process.
+ *      - `consumerTransports` {Transport[]}: List of active transports for consumers.
+ *      - `updateConsumerTransports` {Function}: Updates the list of active consumer transports.
+ *      - `hostLabel` {string}: Label of the host to revert to if screen sharing ends.
+ *      - `shared` {boolean}: Indicates whether a screen is currently shared.
+ *      - `updateShared` {Function}: Updates the shared screen state.
+ *      - `updateShareScreenStarted` {Function}: Marks the start or end of screen sharing.
+ *      - `updateScreenId` {Function}: Clears the screen ID when screen sharing ends.
+ *      - `updateShareEnded` {Function}: Marks the end of screen sharing.
+ *      - `closeAndResize` {Function}: Adjusts the screen display upon closing the media.
+ *      - `prepopulateUserMedia` {Function}: Loads default media after screen sharing ends.
+ *      - `reorderStreams` {Function}: Reorders streams to optimize layout when media is closed.
+ *
+ * @returns {Promise<void>} Resolves when all updates are complete and the producer closure is handled.
+ *
+ * @example
+ * const options = {
+ *   producerId: '12345',
+ *   kind: 'screenshare',
+ *   parameters: {
+ *     consumerTransports: [...],
+ *     updateConsumerTransports: (transports) => { ... },
+ *     hostLabel: 'Host',
+ *     shared: true,
+ *     updateShared: (shared) => { ... },
+ *     updateShareScreenStarted: (started) => { ... },
+ *     updateScreenId: (id) => { ... },
+ *     updateShareEnded: (ended) => { ... },
+ *     closeAndResize: ({ producerId, kind, parameters }) => { ... },
+ *     prepopulateUserMedia: ({ name, parameters }) => { ... },
+ *     reorderStreams: ({ add, screenChanged, parameters }) => { ... },
+ *   }
+ * };
+ *
+ * producerMediaClosedService.producerMediaClosed(options)
+ *   .then(() => console.log('Producer closed successfully'))
+ *   .catch(error => console.error('Error:', error));
+ *
+ * @remarks
+ * This service performs the following steps:
+ * 1. Retrieves updated parameters.
+ * 2. Finds and closes the transport associated with the producer.
+ * 3. Updates the list of consumer transports.
+ * 4. Adjusts the display layout with `closeAndResize`.
+ * 5. If the producer is a screen share, resets shared state and reloads default media.
+ */
 export class ProducerMediaClosed {
     /**
      * Handles the closure of a media producer.
@@ -65,4 +126,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"producer-media-closed.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/producers/socket-receive-methods/producer-media-closed.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AA0C3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AAKH,MAAM,OAAO,mBAAmB;IAC9B;;;;;;;;;;;;;;;;;;OAkBG;IACH,mBAAmB,GAAG,KAAK,EAAE,EAC3B,UAAU,EACV,IAAI,EACJ,UAAU,GACiB,EAAiB,EAAE;QAC9C,UAAU,GAAG,UAAU,CAAC,mBAAmB,EAAE,CAAC;QAE9C,MAAM,EACJ,kBAAkB,EAClB,wBAAwB,EACxB,SAAS,EACT,MAAM,EACN,YAAY,EACZ,wBAAwB,EACxB,cAAc,EACd,gBAAgB,EAChB,cAAc,EACd,oBAAoB,EACpB,cAAc,GACf,GAAG,UAAU,CAAC;QAEf,MAAM,eAAe,GAAG,kBAAkB,CAAC,IAAI,CAC7C,CAAC,aAAkB,EAAE,EAAE,CAAC,aAAa,CAAC,UAAU,KAAK,UAAU,CAChE,CAAC;QAEF,IAAI,eAAe,EAAE,CAAC;YACpB,IAAI,CAAC;gBACH,MAAM,eAAe,CAAC,mBAAmB,CAAC,CAAC,KAAK,EAAE,CAAC;YACrD,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,OAAO,CAAC,KAAK,CAAC,mCAAmC,EAAE,KAAK,CAAC,CAAC;YAC5D,CAAC;YAED,IAAI,CAAC;gBACH,eAAe,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;YACnC,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,OAAO,CAAC,KAAK,CAAC,yBAAyB,EAAE,KAAK,CAAC,CAAC;YAClD,CAAC;YAED,MAAM,yBAAyB,GAAG,kBAAkB,CAAC,MAAM,CACzD,CAAC,aAAkB,EAAE,EAAE,CAAC,aAAa,CAAC,UAAU,KAAK,UAAU,CAChE,CAAC;YACF,wBAAwB,CAAC,yBAAyB,CAAC,CAAC;YAEpD,MAAM,cAAc,CAAC,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC,CAAC;QACzD,CAAC;aAAM,CAAC;YACN,IAAI,IAAI,KAAK,aAAa,IAAI,IAAI,KAAK,QAAQ,EAAE,CAAC;gBAChD,IAAI,MAAM,EAAE,CAAC;oBACX,YAAY,CAAC,KAAK,CAAC,CAAC;gBACtB,CAAC;qBAAM,CAAC;oBACN,wBAAwB,CAAC,KAAK,CAAC,CAAC;oBAChC,cAAc,CAAC,EAAE,CAAC,CAAC;gBACrB,CAAC;gBACD,gBAAgB,CAAC,IAAI,CAAC,CAAC;gBACvB,MAAM,oBAAoB,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,UAAU,EAAE,CAAC,CAAC;gBAC5D,MAAM,cAAc,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC,CAAC;YACxE,CAAC;QACH,CAAC;IACH,CAAC,CAAC;uGA7ES,mBAAmB;2GAAnB,mBAAmB,cAFlB,MAAM;;2FAEP,mBAAmB;kBAH/B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  CloseAndResizeParameters,\n  CloseAndResizeType,\n  PrepopulateUserMediaParameters,\n  PrepopulateUserMediaType,\n  ReorderStreamsParameters,\n  ReorderStreamsType,\n  Transport,\n} from '../../@types/types';\n\nexport interface ProducerMediaClosedParameters\n  extends CloseAndResizeParameters,\n    PrepopulateUserMediaParameters,\n    ReorderStreamsParameters {\n  consumerTransports: Transport[];\n  updateConsumerTransports: (transports: Transport[]) => void;\n  hostLabel: string;\n  shared: boolean;\n  updateShared: (shared: boolean) => void;\n  updateShareScreenStarted: (started: boolean) => void;\n  updateScreenId: (screenId: string) => void;\n  updateShareEnded: (ended: boolean) => void;\n\n  // mediasfu functions\n  closeAndResize: CloseAndResizeType;\n  prepopulateUserMedia: PrepopulateUserMediaType;\n  reorderStreams: ReorderStreamsType;\n\n  getUpdatedAllParams: () => ProducerMediaClosedParameters;\n  [key: string]: any;\n}\n\nexport interface ProducerMediaClosedOptions {\n  producerId: string;\n  kind: 'video' | 'screen' | 'audio' | 'screenshare';\n  parameters: ProducerMediaClosedParameters;\n}\n\n// Export the type definition for the function\nexport type ProducerMediaClosedType = (options: ProducerMediaClosedOptions) => Promise<void>;\n\n/**\n * Service to handle closing a media producer and associated UI and state updates.\n *\n * @class\n * @name ProducerMediaClosed\n * @description\n * Manages the closure of a media producer by identifying associated consumer transports, closing necessary resources,\n * and updating the user interface to reflect the change. For screen sharing, it resets the shared state and adjusts the main view.\n *\n * @method\n * producerMediaClosed\n *\n * @param {ProducerMediaClosedOptions} options - Contains details on the producer and parameters for state updates:\n *   - `producerId` {string}: ID of the producer to close.\n *   - `kind` {string}: The type of media to close (e.g., \"screenshare\" or \"audio\").\n *   - `parameters` {ProducerMediaClosedParameters}: Settings and update functions to manage the closure process.\n *      - `consumerTransports` {Transport[]}: List of active transports for consumers.\n *      - `updateConsumerTransports` {Function}: Updates the list of active consumer transports.\n *      - `hostLabel` {string}: Label of the host to revert to if screen sharing ends.\n *      - `shared` {boolean}: Indicates whether a screen is currently shared.\n *      - `updateShared` {Function}: Updates the shared screen state.\n *      - `updateShareScreenStarted` {Function}: Marks the start or end of screen sharing.\n *      - `updateScreenId` {Function}: Clears the screen ID when screen sharing ends.\n *      - `updateShareEnded` {Function}: Marks the end of screen sharing.\n *      - `closeAndResize` {Function}: Adjusts the screen display upon closing the media.\n *      - `prepopulateUserMedia` {Function}: Loads default media after screen sharing ends.\n *      - `reorderStreams` {Function}: Reorders streams to optimize layout when media is closed.\n *\n * @returns {Promise<void>} Resolves when all updates are complete and the producer closure is handled.\n *\n * @example\n * const options = {\n *   producerId: '12345',\n *   kind: 'screenshare',\n *   parameters: {\n *     consumerTransports: [...],\n *     updateConsumerTransports: (transports) => { ... },\n *     hostLabel: 'Host',\n *     shared: true,\n *     updateShared: (shared) => { ... },\n *     updateShareScreenStarted: (started) => { ... },\n *     updateScreenId: (id) => { ... },\n *     updateShareEnded: (ended) => { ... },\n *     closeAndResize: ({ producerId, kind, parameters }) => { ... },\n *     prepopulateUserMedia: ({ name, parameters }) => { ... },\n *     reorderStreams: ({ add, screenChanged, parameters }) => { ... },\n *   }\n * };\n *\n * producerMediaClosedService.producerMediaClosed(options)\n *   .then(() => console.log('Producer closed successfully'))\n *   .catch(error => console.error('Error:', error));\n *\n * @remarks\n * This service performs the following steps:\n * 1. Retrieves updated parameters.\n * 2. Finds and closes the transport associated with the producer.\n * 3. Updates the list of consumer transports.\n * 4. Adjusts the display layout with `closeAndResize`.\n * 5. If the producer is a screen share, resets shared state and reloads default media.\n */\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ProducerMediaClosed {\n  /**\n   * Handles the closure of a media producer.\n   *\n   * @param {ProducerMediaClosedOptions} options - The options for closing the media producer.\n   * @param {string} options.producerId - The ID of the producer to close.\n   * @param {string} options.kind - The kind of media (e.g., \"screenshare\" or \"screen\").\n   * @param {Parameters} options.parameters - The parameters object containing various methods and properties.\n   *\n   * @returns {Promise<void>} - A promise that resolves when the producer has been closed and necessary updates are made.\n   *\n   * @remarks\n   * This function performs the following steps:\n   * 1. Retrieves updated parameters.\n   * 2. Finds the transport associated with the producer to close.\n   * 3. Closes the consumer transport and consumer if found.\n   * 4. Updates the consumer transports list.\n   * 5. Calls `closeAndResize` with the necessary parameters.\n   * 6. If the producer kind is \"screenshare\" or \"screen\", updates shared state and calls various update methods.\n   */\n  producerMediaClosed = async ({\n    producerId,\n    kind,\n    parameters,\n  }: ProducerMediaClosedOptions): Promise<void> => {\n    parameters = parameters.getUpdatedAllParams();\n\n    const {\n      consumerTransports,\n      updateConsumerTransports,\n      hostLabel,\n      shared,\n      updateShared,\n      updateShareScreenStarted,\n      updateScreenId,\n      updateShareEnded,\n      closeAndResize,\n      prepopulateUserMedia,\n      reorderStreams,\n    } = parameters;\n\n    const producerToClose = consumerTransports.find(\n      (transportData: any) => transportData.producerId === producerId,\n    );\n\n    if (producerToClose) {\n      try {\n        await producerToClose['consumerTransport'].close();\n      } catch (error) {\n        console.error('Error closing consumer transport:', error);\n      }\n\n      try {\n        producerToClose.consumer.close();\n      } catch (error) {\n        console.error('Error closing consumer:', error);\n      }\n\n      const updatedConsumerTransports = consumerTransports.filter(\n        (transportData: any) => transportData.producerId !== producerId,\n      );\n      updateConsumerTransports(updatedConsumerTransports);\n\n      await closeAndResize({ producerId, kind, parameters });\n    } else {\n      if (kind === 'screenshare' || kind === 'screen') {\n        if (shared) {\n          updateShared(false);\n        } else {\n          updateShareScreenStarted(false);\n          updateScreenId('');\n        }\n        updateShareEnded(true);\n        await prepopulateUserMedia({ name: hostLabel, parameters });\n        await reorderStreams({ add: false, screenChanged: true, parameters });\n      }\n    }\n  };\n}\n"]}

package/dist/esm2022/lib/producers/socket-receive-methods/producer-media-paused.service.mjs

@@ -1,5 +1,67 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Service to handle the paused state of media for a producer.
+ *
+ * @class
+ * @name ProducerMediaPaused
+ * @description
+ * Handles the actions required when media is paused for a specified producer, including UI updates, participant state handling, and managing meeting display optimizations.
+ *
+ * @method
+ * producerMediaPaused
+ *
+ * @param {ProducerMediaPausedOptions} options - Options to specify the producer and event details:
+ *   - `producerId` {string}: The ID of the paused producer.
+ *   - `kind` {string}: The type of media paused (e.g., "audio", "video").
+ *   - `name` {string}: Name of the producer whose media is paused.
+ *   - `parameters` {ProducerMediaPausedParameters}: Configuration and state parameters for the meeting.
+ *      - `activeSounds` {string[]}: Active audio streams currently displayed.
+ *      - `meetingDisplayType` {string}: Current meeting layout type (e.g., "media", "video").
+ *      - `meetingVideoOptimized` {boolean}: Indicates if video is optimized.
+ *      - `participants` {Participant[]}: List of all meeting participants.
+ *      - `oldSoundIds` {string[]}: List of previously active audio stream IDs.
+ *      - `shared` {boolean}: Indicates if the screen is currently shared.
+ *      - `shareScreenStarted` {boolean}: Indicates if screen sharing has started.
+ *      - `updateMainWindow` {boolean}: Specifies if the main display window should update.
+ *      - `hostLabel` {string}: The label representing the host participant.
+ *      - `islevel` {string}: The access level of the participant.
+ *      - `updateActiveSounds` {Function}: Updates the list of active audio streams.
+ *      - `updateUpdateMainWindow` {Function}: Updates the status of the main display window.
+ *      - `reorderStreams` {Function}: Reorders media streams for optimized display.
+ *      - `prepopulateUserMedia` {Function}: Preloads user media based on display needs.
+ *      - `reUpdateInter` {Function}: Refreshes participant interactions on the UI.
+ *
+ * @returns {Promise<void>} Resolves when media pause handling is complete.
+ *
+ * @example
+ * const options = {
+ *   producerId: '12345',
+ *   kind: 'audio',
+ *   name: 'Participant A',
+ *   parameters: {
+ *     activeSounds: ['Participant B'],
+ *     meetingDisplayType: 'video',
+ *     meetingVideoOptimized: false,
+ *     participants: [...],
+ *     oldSoundIds: ['Participant A'],
+ *     shared: false,
+ *     shareScreenStarted: false,
+ *     updateMainWindow: true,
+ *     hostLabel: 'Host',
+ *     islevel: '1',
+ *     updateActiveSounds: (sounds) => { ... },
+ *     updateUpdateMainWindow: (status) => { ... },
+ *     reorderStreams: ({ add, screenChanged, parameters }) => { ... },
+ *     prepopulateUserMedia: ({ name, parameters }) => { ... },
+ *     reUpdateInter: ({ name, add, force, parameters }) => { ... }
+ *   }
+ * };
+ *
+ * producerMediaPausedService.producerMediaPaused(options)
+ *   .then(() => console.log('Media pause handled'))
+ *   .catch(error => console.error('Error:', error));
+ */
 export class ProducerMediaPaused {
     /**
      * Handles the event when media is paused for a producer.
@@ -87,4 +149,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"producer-media-paused.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/producers/socket-receive-methods/producer-media-paused.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAkD3C,MAAM,OAAO,mBAAmB;IAC9B;;;;;;;;;;;;;;;;;OAiBG;IACH,mBAAmB,GAAG,KAAK,EAAE,EAC3B,UAAU,EACV,IAAI,EACJ,IAAI,EACJ,UAAU,GACiB,EAAiB,EAAE;QAC9C,UAAU,GAAG,UAAU,CAAC,mBAAmB,EAAE,CAAC;QAE9C,IAAI,EACF,YAAY,EACZ,kBAAkB,EAClB,qBAAqB,EACrB,YAAY,EACZ,WAAW,EACX,MAAM,EACN,kBAAkB,EAClB,gBAAgB,EAChB,SAAS,EACT,OAAO,EACP,kBAAkB,EAClB,sBAAsB,EACtB,cAAc,EACd,oBAAoB,EACpB,aAAa,GACd,GAAG,UAAU,CAAC;QAEf,MAAM,OAAO,CAAC,GAAG,CACf,YAAY,CAAC,GAAG,CAAC,KAAK,EAAE,WAAgB,EAAE,EAAE;YAC1C,IAAI,WAAW,CAAC,KAAK,EAAE,CAAC;gBACtB,IAAI,CAAC;oBACH,IACE,WAAW,CAAC,OAAO,IAAI,GAAG;wBAC1B,CAAC,WAAW,CAAC,OAAO;wBACpB,CAAC,MAAM;wBACP,CAAC,kBAAkB;wBACnB,OAAO,IAAI,GAAG,EACd,CAAC;wBACD,gBAAgB,GAAG,IAAI,CAAC;wBACxB,sBAAsB,CAAC,gBAAgB,CAAC,CAAC;wBACzC,MAAM,oBAAoB,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,UAAU,EAAE,CAAC,CAAC;wBAC5D,gBAAgB,GAAG,KAAK,CAAC;wBACzB,sBAAsB,CAAC,gBAAgB,CAAC,CAAC;oBAC3C,CAAC;gBACH,CAAC;gBAAC,MAAM,CAAC;oBACP,kBAAkB;gBACpB,CAAC;gBAED,IAAI,kBAAkB,IAAI,MAAM,EAAE,CAAC;oBACjC,IAAI,YAAY,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC;wBAC5C,YAAY,GAAG,YAAY,CAAC,MAAM,CAChC,CAAC,WAAgB,EAAE,EAAE,CAAC,WAAW,IAAI,WAAW,CAAC,IAAI,CACtD,CAAC;wBACF,kBAAkB,CAAC,YAAY,CAAC,CAAC;oBACnC,CAAC;oBACD,MAAM,aAAa,CAAC,EAAE,IAAI,EAAE,WAAW,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC,CAAC;gBACvF,CAAC;YACH,CAAC;QACH,CAAC,CAAC,CACH,CAAC;QAEF,IAAI,OAAO,GAAG,KAAK,CAAC;QACpB,IACE,kBAAkB,IAAI,OAAO;YAC7B,CAAC,kBAAkB,IAAI,OAAO,IAAI,CAAC,qBAAqB,CAAC,EACzD,CAAC;YACD,MAAM,WAAW,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC,GAAQ,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,IAAI,IAAI,CAAC,CAAC;YACtE,OAAO,GAAG,CAAC,CAAC,WAAW,EAAE,OAAO,CAAC;YACjC,IAAI,CAAC,OAAO,IAAI,CAAC,kBAAkB,IAAI,CAAC,MAAM,EAAE,CAAC;gBAC/C,MAAM,cAAc,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC,CAAC;YACxE,CAAC;QACH,CAAC;QAED,IAAI,IAAI,IAAI,OAAO,EAAE,CAAC;YACpB,IAAI,CAAC;gBACH,MAAM,WAAW,GACf,YAAY,CAAC,IAAI,CAAC,CAAC,GAAQ,EAAE,EAAE,CAAC,GAAG,CAAC,OAAO,IAAI,UAAU,CAAC;oBAC1D,YAAY,CAAC,IAAI,CAAC,CAAC,GAAQ,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,IAAI,IAAI,CAAC,CAAC;gBACpD,IACE,WAAW;oBACX,CAAC,CAAC,WAAW,CAAC,IAAI,IAAI,WAAW,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;wBAC3D,CAAC,IAAI,IAAI,WAAW,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EACvC,CAAC;oBACD,aAAa,CAAC;wBACZ,IAAI,EAAE,WAAW,CAAC,IAAI,IAAI,EAAE;wBAC5B,GAAG,EAAE,KAAK;wBACV,KAAK,EAAE,IAAI;wBACX,UAAU;qBACX,CAAC,CAAC;gBACL,CAAC;YACH,CAAC;YAAC,MAAM,CAAC;gBACP,kBAAkB;YACpB,CAAC;QACH,CAAC;IACH,CAAC,CAAC;uGAhHS,mBAAmB;2GAAnB,mBAAmB,cAFlB,MAAM;;2FAEP,mBAAmB;kBAH/B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  Participant,\n  PrepopulateUserMediaType,\n  ReorderStreamsType,\n  ReUpdateInterParameters,\n  ReUpdateInterType,\n  ReorderStreamsParameters,\n  PrepopulateUserMediaParameters,\n} from '../../@types/types';\n\nexport interface ProducerMediaPausedParameters\n  extends PrepopulateUserMediaParameters,\n    ReorderStreamsParameters,\n    ReUpdateInterParameters {\n  activeSounds: string[];\n  meetingDisplayType: string;\n  meetingVideoOptimized: boolean;\n  participants: Participant[];\n  oldSoundIds: string[];\n  shared: boolean;\n  shareScreenStarted: boolean;\n  updateMainWindow: boolean;\n  hostLabel: string;\n  islevel: string;\n  updateActiveSounds: (activeSounds: string[]) => void;\n  updateUpdateMainWindow: (updateMainWindow: boolean) => void;\n\n  // mediasfu functions\n  reorderStreams: ReorderStreamsType;\n  prepopulateUserMedia: PrepopulateUserMediaType;\n  reUpdateInter: ReUpdateInterType;\n\n  getUpdatedAllParams: () => ProducerMediaPausedParameters;\n  [key: string]: any;\n}\n\nexport interface ProducerMediaPausedOptions {\n  producerId: string;\n  kind: 'audio' | 'video' | 'screenshare' | 'screen';\n  name: string;\n  parameters: ProducerMediaPausedParameters;\n}\n\n// Export the type definition for the function\nexport type ProducerMediaPausedType = (options: ProducerMediaPausedOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ProducerMediaPaused {\n  /**\n   * Handles the event when media is paused for a producer.\n   *\n   * @param {ProducerMediaPausedOptions} options - The options for the producer media paused event.\n   * @param {string} options.producerId - The ID of the producer.\n   * @param {string} options.kind - The kind of media (e.g., \"audio\", \"video\").\n   * @param {string} options.name - The name of the producer.\n   * @param {Parameters} options.parameters - The parameters for the event.\n   *\n   * @returns {Promise<void>} A promise that resolves when the media paused handling is complete.\n   *\n   * @description\n   * This function handles the event when media is paused for a producer. It performs the following tasks:\n   * - Updates the parameters.\n   * - Iterates through participants and updates the UI based on their muted status and other conditions.\n   * - Handles meeting display type and optimizes the UI accordingly.\n   * - Manages audio media by updating the relevant participant's state.\n   */\n  producerMediaPaused = async ({\n    producerId,\n    kind,\n    name,\n    parameters,\n  }: ProducerMediaPausedOptions): Promise<void> => {\n    parameters = parameters.getUpdatedAllParams();\n\n    let {\n      activeSounds,\n      meetingDisplayType,\n      meetingVideoOptimized,\n      participants,\n      oldSoundIds,\n      shared,\n      shareScreenStarted,\n      updateMainWindow,\n      hostLabel,\n      islevel,\n      updateActiveSounds,\n      updateUpdateMainWindow,\n      reorderStreams,\n      prepopulateUserMedia,\n      reUpdateInter,\n    } = parameters;\n\n    await Promise.all(\n      participants.map(async (participant: any) => {\n        if (participant.muted) {\n          try {\n            if (\n              participant.islevel == '2' &&\n              !participant.videoID &&\n              !shared &&\n              !shareScreenStarted &&\n              islevel != '2'\n            ) {\n              updateMainWindow = true;\n              updateUpdateMainWindow(updateMainWindow);\n              await prepopulateUserMedia({ name: hostLabel, parameters });\n              updateMainWindow = false;\n              updateUpdateMainWindow(updateMainWindow);\n            }\n          } catch {\n            /* handle error */\n          }\n\n          if (shareScreenStarted || shared) {\n            if (activeSounds.includes(participant.name)) {\n              activeSounds = activeSounds.filter(\n                (audioStream: any) => audioStream != participant.name,\n              );\n              updateActiveSounds(activeSounds);\n            }\n            await reUpdateInter({ name: participant.name, add: false, force: true, parameters });\n          }\n        }\n      }),\n    );\n\n    let checker = false;\n    if (\n      meetingDisplayType == 'media' ||\n      (meetingDisplayType == 'video' && !meetingVideoOptimized)\n    ) {\n      const participant = participants.find((obj: any) => obj.name == name);\n      checker = !!participant?.videoID;\n      if (!checker && !shareScreenStarted && !shared) {\n        await reorderStreams({ add: false, screenChanged: true, parameters });\n      }\n    }\n\n    if (kind == 'audio') {\n      try {\n        const participant =\n          participants.find((obj: any) => obj.audioID == producerId) ||\n          participants.find((obj: any) => obj.name == name);\n        if (\n          participant &&\n          ((participant.name && oldSoundIds.includes(participant.name)) ||\n            (name && oldSoundIds.includes(name)))\n        ) {\n          reUpdateInter({\n            name: participant.name ?? '',\n            add: false,\n            force: true,\n            parameters,\n          });\n        }\n      } catch {\n        /* handle error */\n      }\n    }\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"producer-media-paused.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/producers/socket-receive-methods/producer-media-paused.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  Participant,\n  PrepopulateUserMediaType,\n  ReorderStreamsType,\n  ReUpdateInterParameters,\n  ReUpdateInterType,\n  ReorderStreamsParameters,\n  PrepopulateUserMediaParameters,\n} from '../../@types/types';\n\nexport interface ProducerMediaPausedParameters\n  extends PrepopulateUserMediaParameters,\n    ReorderStreamsParameters,\n    ReUpdateInterParameters {\n  activeSounds: string[];\n  meetingDisplayType: string;\n  meetingVideoOptimized: boolean;\n  participants: Participant[];\n  oldSoundIds: string[];\n  shared: boolean;\n  shareScreenStarted: boolean;\n  updateMainWindow: boolean;\n  hostLabel: string;\n  islevel: string;\n  updateActiveSounds: (activeSounds: string[]) => void;\n  updateUpdateMainWindow: (updateMainWindow: boolean) => void;\n\n  // mediasfu functions\n  reorderStreams: ReorderStreamsType;\n  prepopulateUserMedia: PrepopulateUserMediaType;\n  reUpdateInter: ReUpdateInterType;\n\n  getUpdatedAllParams: () => ProducerMediaPausedParameters;\n  [key: string]: any;\n}\n\nexport interface ProducerMediaPausedOptions {\n  producerId: string;\n  kind: 'audio' | 'video' | 'screenshare' | 'screen';\n  name: string;\n  parameters: ProducerMediaPausedParameters;\n}\n\n// Export the type definition for the function\nexport type ProducerMediaPausedType = (options: ProducerMediaPausedOptions) => Promise<void>;\n\n/**\n * Service to handle the paused state of media for a producer.\n *\n * @class\n * @name ProducerMediaPaused\n * @description\n * Handles the actions required when media is paused for a specified producer, including UI updates, participant state handling, and managing meeting display optimizations.\n *\n * @method\n * producerMediaPaused\n *\n * @param {ProducerMediaPausedOptions} options - Options to specify the producer and event details:\n *   - `producerId` {string}: The ID of the paused producer.\n *   - `kind` {string}: The type of media paused (e.g., \"audio\", \"video\").\n *   - `name` {string}: Name of the producer whose media is paused.\n *   - `parameters` {ProducerMediaPausedParameters}: Configuration and state parameters for the meeting.\n *      - `activeSounds` {string[]}: Active audio streams currently displayed.\n *      - `meetingDisplayType` {string}: Current meeting layout type (e.g., \"media\", \"video\").\n *      - `meetingVideoOptimized` {boolean}: Indicates if video is optimized.\n *      - `participants` {Participant[]}: List of all meeting participants.\n *      - `oldSoundIds` {string[]}: List of previously active audio stream IDs.\n *      - `shared` {boolean}: Indicates if the screen is currently shared.\n *      - `shareScreenStarted` {boolean}: Indicates if screen sharing has started.\n *      - `updateMainWindow` {boolean}: Specifies if the main display window should update.\n *      - `hostLabel` {string}: The label representing the host participant.\n *      - `islevel` {string}: The access level of the participant.\n *      - `updateActiveSounds` {Function}: Updates the list of active audio streams.\n *      - `updateUpdateMainWindow` {Function}: Updates the status of the main display window.\n *      - `reorderStreams` {Function}: Reorders media streams for optimized display.\n *      - `prepopulateUserMedia` {Function}: Preloads user media based on display needs.\n *      - `reUpdateInter` {Function}: Refreshes participant interactions on the UI.\n *\n * @returns {Promise<void>} Resolves when media pause handling is complete.\n *\n * @example\n * const options = {\n *   producerId: '12345',\n *   kind: 'audio',\n *   name: 'Participant A',\n *   parameters: {\n *     activeSounds: ['Participant B'],\n *     meetingDisplayType: 'video',\n *     meetingVideoOptimized: false,\n *     participants: [...],\n *     oldSoundIds: ['Participant A'],\n *     shared: false,\n *     shareScreenStarted: false,\n *     updateMainWindow: true,\n *     hostLabel: 'Host',\n *     islevel: '1',\n *     updateActiveSounds: (sounds) => { ... },\n *     updateUpdateMainWindow: (status) => { ... },\n *     reorderStreams: ({ add, screenChanged, parameters }) => { ... },\n *     prepopulateUserMedia: ({ name, parameters }) => { ... },\n *     reUpdateInter: ({ name, add, force, parameters }) => { ... }\n *   }\n * };\n *\n * producerMediaPausedService.producerMediaPaused(options)\n *   .then(() => console.log('Media pause handled'))\n *   .catch(error => console.error('Error:', error));\n */\n\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ProducerMediaPaused {\n  /**\n   * Handles the event when media is paused for a producer.\n   *\n   * @param {ProducerMediaPausedOptions} options - The options for the producer media paused event.\n   * @param {string} options.producerId - The ID of the producer.\n   * @param {string} options.kind - The kind of media (e.g., \"audio\", \"video\").\n   * @param {string} options.name - The name of the producer.\n   * @param {Parameters} options.parameters - The parameters for the event.\n   *\n   * @returns {Promise<void>} A promise that resolves when the media paused handling is complete.\n   *\n   * @description\n   * This function handles the event when media is paused for a producer. It performs the following tasks:\n   * - Updates the parameters.\n   * - Iterates through participants and updates the UI based on their muted status and other conditions.\n   * - Handles meeting display type and optimizes the UI accordingly.\n   * - Manages audio media by updating the relevant participant's state.\n   */\n  producerMediaPaused = async ({\n    producerId,\n    kind,\n    name,\n    parameters,\n  }: ProducerMediaPausedOptions): Promise<void> => {\n    parameters = parameters.getUpdatedAllParams();\n\n    let {\n      activeSounds,\n      meetingDisplayType,\n      meetingVideoOptimized,\n      participants,\n      oldSoundIds,\n      shared,\n      shareScreenStarted,\n      updateMainWindow,\n      hostLabel,\n      islevel,\n      updateActiveSounds,\n      updateUpdateMainWindow,\n      reorderStreams,\n      prepopulateUserMedia,\n      reUpdateInter,\n    } = parameters;\n\n    await Promise.all(\n      participants.map(async (participant: any) => {\n        if (participant.muted) {\n          try {\n            if (\n              participant.islevel == '2' &&\n              !participant.videoID &&\n              !shared &&\n              !shareScreenStarted &&\n              islevel != '2'\n            ) {\n              updateMainWindow = true;\n              updateUpdateMainWindow(updateMainWindow);\n              await prepopulateUserMedia({ name: hostLabel, parameters });\n              updateMainWindow = false;\n              updateUpdateMainWindow(updateMainWindow);\n            }\n          } catch {\n            /* handle error */\n          }\n\n          if (shareScreenStarted || shared) {\n            if (activeSounds.includes(participant.name)) {\n              activeSounds = activeSounds.filter(\n                (audioStream: any) => audioStream != participant.name,\n              );\n              updateActiveSounds(activeSounds);\n            }\n            await reUpdateInter({ name: participant.name, add: false, force: true, parameters });\n          }\n        }\n      }),\n    );\n\n    let checker = false;\n    if (\n      meetingDisplayType == 'media' ||\n      (meetingDisplayType == 'video' && !meetingVideoOptimized)\n    ) {\n      const participant = participants.find((obj: any) => obj.name == name);\n      checker = !!participant?.videoID;\n      if (!checker && !shareScreenStarted && !shared) {\n        await reorderStreams({ add: false, screenChanged: true, parameters });\n      }\n    }\n\n    if (kind == 'audio') {\n      try {\n        const participant =\n          participants.find((obj: any) => obj.audioID == producerId) ||\n          participants.find((obj: any) => obj.name == name);\n        if (\n          participant &&\n          ((participant.name && oldSoundIds.includes(participant.name)) ||\n            (name && oldSoundIds.includes(name)))\n        ) {\n          reUpdateInter({\n            name: participant.name ?? '',\n            add: false,\n            force: true,\n            parameters,\n          });\n        }\n      } catch {\n        /* handle error */\n      }\n    }\n  };\n}\n"]}

package/dist/esm2022/lib/producers/socket-receive-methods/producer-media-resumed.service.mjs

@@ -1,5 +1,50 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Service to handle resuming media for a specific participant in a meeting.
+ *
+ * @class
+ * @name ProducerMediaResumed
+ * @description Resumes media (audio only) for a participant and updates the meeting display based on the meeting layout and participant status.
+ *
+ * @method
+ * producerMediaResumed
+ *
+ * @param {ProducerMediaResumedOptions} options - Options to control media resumption:
+ *   - `name` {string}: Name of the participant whose media is to be resumed.
+ *   - `parameters` {ProducerMediaResumedParameters}: Meeting and participant-specific configurations.
+ *      - `meetingDisplayType` {string}: Type of meeting display (e.g., "media").
+ *      - `participants` {Participant[]}: List of participants in the meeting.
+ *      - `shared` {boolean}: Indicates if the screen is currently shared.
+ *      - `shareScreenStarted` {boolean}: Indicates if screen sharing has started.
+ *      - `mainScreenFilled` {boolean}: Indicates if the main screen is filled.
+ *      - `hostLabel` {string}: Label or name of the host.
+ *      - `updateUpdateMainWindow` {Function}: Function to update the main window display.
+ *      - `reorderStreams` {Function}: Function to manage stream ordering when display changes.
+ *      - `prepopulateUserMedia` {Function}: Function to preload user media for the main screen.
+ *
+ * @returns {Promise<void>} Resolves when media for the specified participant has resumed.
+ *
+ * @example
+ * const options = {
+ *   name: 'Participant A',
+ *   parameters: {
+ *     meetingDisplayType: 'media',
+ *     participants: [...],
+ *     shared: false,
+ *     shareScreenStarted: false,
+ *     mainScreenFilled: false,
+ *     hostLabel: 'Host',
+ *     updateUpdateMainWindow: (updateMainWindow) => { ... },
+ *     reorderStreams: ({ add, screenChanged, parameters }) => { ... },
+ *     prepopulateUserMedia: ({ name, parameters }) => { ... }
+ *   }
+ * };
+ *
+ * producerMediaResumedService.producerMediaResumed(options)
+ *   .then(() => console.log('Media resumed'))
+ *   .catch(error => console.error('Error:', error));
+ */
 export class ProducerMediaResumed {
     /**
      * Resumes media for a specific participant in a meeting.
@@ -51,4 +96,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvZHVjZXItbWVkaWEtcmVzdW1lZC5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbWVkaWFzZnUtYW5ndWxhci9zcmMvbGliL3Byb2R1Y2Vycy9zb2NrZXQtcmVjZWl2ZS1tZXRob2RzL3Byb2R1Y2VyLW1lZGlhLXJlc3VtZWQuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQXdDM0MsTUFBTSxPQUFPLG9CQUFvQjtJQUMvQjs7Ozs7Ozs7Ozs7Ozs7Ozs7T0FpQkc7SUFDSCxvQkFBb0IsR0FBRyxLQUFLLEVBQUUsRUFDNUIsSUFBSSxFQUNKLFVBQVUsR0FDa0IsRUFBaUIsRUFBRTtRQUMvQyxVQUFVLEdBQUcsVUFBVSxDQUFDLG1CQUFtQixFQUFFLENBQUM7UUFFOUMsSUFBSSxFQUNGLGtCQUFrQixFQUNsQixZQUFZLEVBQ1osTUFBTSxFQUNOLGtCQUFrQixFQUNsQixnQkFBZ0IsRUFDaEIsZ0JBQWdCLEVBQ2hCLFNBQVMsRUFDVCxzQkFBc0IsRUFDdEIsY0FBYyxFQUNkLG9CQUFvQixHQUNyQixHQUFHLFVBQVUsQ0FBQztRQUVmLG1EQUFtRDtRQUNuRCxzQ0FBc0M7UUFDdEMsMkNBQTJDO1FBRTNDLHNEQUFzRDtRQUN0RCxNQUFNLFdBQVcsR0FBRyxZQUFZLENBQUMsSUFBSSxDQUFDLENBQUMsR0FBUSxFQUFFLEVBQUUsQ0FBQyxHQUFHLENBQUMsSUFBSSxJQUFJLElBQUksQ0FBQyxDQUFDO1FBRXRFLElBQUksQ0FBQyxnQkFBZ0IsSUFBSSxXQUFXLEVBQUUsT0FBTyxJQUFJLEdBQUcsRUFBRSxDQUFDO1lBQ3JELGdCQUFnQixHQUFHLElBQUksQ0FBQztZQUN4QixzQkFBc0IsQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDO1lBQ3pDLE1BQU0sb0JBQW9CLENBQUMsRUFBRSxJQUFJLEVBQUUsU0FBUyxFQUFFLFVBQVUsRUFBRSxDQUFDLENBQUM7WUFDNUQsZ0JBQWdCLEdBQUcsS0FBSyxDQUFDO1lBQ3pCLHNCQUFzQixDQUFDLGdCQUFnQixDQUFDLENBQUM7UUFDM0MsQ0FBQztRQUVELElBQUksT0FBTyxDQUFDO1FBQ1osSUFBSSxrQkFBa0IsSUFBSSxPQUFPLEVBQUUsQ0FBQztZQUNsQyxPQUFPLEdBQUcsV0FBVyxFQUFFLE9BQU8sSUFBSSxJQUFJLElBQUksV0FBVyxDQUFDLE9BQU8sS0FBSyxFQUFFLENBQUM7WUFFckUsSUFBSSxDQUFDLE9BQU8sSUFBSSxDQUFDLENBQUMsa0JBQWtCLElBQUksTUFBTSxDQUFDLEVBQUUsQ0FBQztnQkFDaEQsTUFBTSxjQUFjLENBQUMsRUFBRSxHQUFHLEVBQUUsS0FBSyxFQUFFLGFBQWEsRUFBRSxJQUFJLEVBQUUsVUFBVSxFQUFFLENBQUMsQ0FBQztZQUN4RSxDQUFDO1FBQ0gsQ0FBQztJQUNILENBQUMsQ0FBQzt1R0E3RFMsb0JBQW9COzJHQUFwQixvQkFBb0IsY0FGbkIsTUFBTTs7MkZBRVAsb0JBQW9CO2tCQUhoQyxVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7XG4gIFBhcnRpY2lwYW50LFxuICBQcmVwb3B1bGF0ZVVzZXJNZWRpYVBhcmFtZXRlcnMsXG4gIFByZXBvcHVsYXRlVXNlck1lZGlhVHlwZSxcbiAgUmVvcmRlclN0cmVhbXNQYXJhbWV0ZXJzLFxuICBSZW9yZGVyU3RyZWFtc1R5cGUsXG59IGZyb20gJy4uLy4uL0B0eXBlcy90eXBlcyc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgUHJvZHVjZXJNZWRpYVJlc3VtZWRQYXJhbWV0ZXJzXG4gIGV4dGVuZHMgUHJlcG9wdWxhdGVVc2VyTWVkaWFQYXJhbWV0ZXJzLFxuICAgIFJlb3JkZXJTdHJlYW1zUGFyYW1ldGVycyB7XG4gIG1lZXRpbmdEaXNwbGF5VHlwZTogc3RyaW5nO1xuICBwYXJ0aWNpcGFudHM6IFBhcnRpY2lwYW50W107XG4gIHNoYXJlZDogYm9vbGVhbjtcbiAgc2hhcmVTY3JlZW5TdGFydGVkOiBib29sZWFuO1xuICBtYWluU2NyZWVuRmlsbGVkOiBib29sZWFuO1xuICBob3N0TGFiZWw6IHN0cmluZztcbiAgdXBkYXRlVXBkYXRlTWFpbldpbmRvdzogKHVwZGF0ZU1haW5XaW5kb3c6IGJvb2xlYW4pID0+IHZvaWQ7XG5cbiAgLy8gbWVkaWFzZnUgZnVuY3Rpb25zXG4gIHJlb3JkZXJTdHJlYW1zOiBSZW9yZGVyU3RyZWFtc1R5cGU7XG4gIHByZXBvcHVsYXRlVXNlck1lZGlhOiBQcmVwb3B1bGF0ZVVzZXJNZWRpYVR5cGU7XG5cbiAgZ2V0VXBkYXRlZEFsbFBhcmFtczogKCkgPT4gUHJvZHVjZXJNZWRpYVJlc3VtZWRQYXJhbWV0ZXJzO1xuICBba2V5OiBzdHJpbmddOiBhbnk7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgUHJvZHVjZXJNZWRpYVJlc3VtZWRPcHRpb25zIHtcbiAgbmFtZTogc3RyaW5nO1xuICBraW5kOiAnYXVkaW8nO1xuICBwYXJhbWV0ZXJzOiBQcm9kdWNlck1lZGlhUmVzdW1lZFBhcmFtZXRlcnM7XG59XG5cbi8vIEV4cG9ydCB0aGUgdHlwZSBkZWZpbml0aW9uIGZvciB0aGUgZnVuY3Rpb25cbmV4cG9ydCB0eXBlIFByb2R1Y2VyTWVkaWFSZXN1bWVkVHlwZSA9IChvcHRpb25zOiBQcm9kdWNlck1lZGlhUmVzdW1lZE9wdGlvbnMpID0+IFByb21pc2U8dm9pZD47XG5cbkBJbmplY3RhYmxlKHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnLFxufSlcbmV4cG9ydCBjbGFzcyBQcm9kdWNlck1lZGlhUmVzdW1lZCB7XG4gIC8qKlxuICAgKiBSZXN1bWVzIG1lZGlhIGZvciBhIHNwZWNpZmljIHBhcnRpY2lwYW50IGluIGEgbWVldGluZy5cbiAgICpcbiAgICogQHBhcmFtIHtQcm9kdWNlck1lZGlhUmVzdW1lZE9wdGlvbnN9IG9wdGlvbnMgLSBUaGUgb3B0aW9ucyBmb3IgcmVzdW1pbmcgbWVkaWEuXG4gICAqIEBwYXJhbSB7c3RyaW5nfSBvcHRpb25zLm5hbWUgLSBUaGUgbmFtZSBvZiB0aGUgcGFydGljaXBhbnQgd2hvc2UgbWVkaWEgaXMgdG8gYmUgcmVzdW1lZC5cbiAgICogQHBhcmFtIHtPYmplY3R9IG9wdGlvbnMucGFyYW1ldGVycyAtIFRoZSBwYXJhbWV0ZXJzIHJlbGF0ZWQgdG8gdGhlIG1lZXRpbmcgYW5kIHBhcnRpY2lwYW50cy5cbiAgICogQHBhcmFtIHtzdHJpbmd9IG9wdGlvbnMucGFyYW1ldGVycy5tZWV0aW5nRGlzcGxheVR5cGUgLSBUaGUgdHlwZSBvZiBtZWV0aW5nIGRpc3BsYXkuXG4gICAqIEBwYXJhbSB7QXJyYXl9IG9wdGlvbnMucGFyYW1ldGVycy5wYXJ0aWNpcGFudHMgLSBUaGUgbGlzdCBvZiBwYXJ0aWNpcGFudHMgaW4gdGhlIG1lZXRpbmcuXG4gICAqIEBwYXJhbSB7Ym9vbGVhbn0gb3B0aW9ucy5wYXJhbWV0ZXJzLnNoYXJlZCAtIEluZGljYXRlcyBpZiB0aGUgc2NyZWVuIGlzIGJlaW5nIHNoYXJlZC5cbiAgICogQHBhcmFtIHtib29sZWFufSBvcHRpb25zLnBhcmFtZXRlcnMuc2hhcmVTY3JlZW5TdGFydGVkIC0gSW5kaWNhdGVzIGlmIHNjcmVlbiBzaGFyaW5nIGhhcyBzdGFydGVkLlxuICAgKiBAcGFyYW0ge2Jvb2xlYW59IG9wdGlvbnMucGFyYW1ldGVycy5tYWluU2NyZWVuRmlsbGVkIC0gSW5kaWNhdGVzIGlmIHRoZSBtYWluIHNjcmVlbiBpcyBmaWxsZWQuXG4gICAqIEBwYXJhbSB7c3RyaW5nfSBvcHRpb25zLnBhcmFtZXRlcnMuaG9zdExhYmVsIC0gVGhlIGxhYmVsIG9mIHRoZSBob3N0LlxuICAgKiBAcGFyYW0ge0Z1bmN0aW9ufSBvcHRpb25zLnBhcmFtZXRlcnMudXBkYXRlVXBkYXRlTWFpbldpbmRvdyAtIEZ1bmN0aW9uIHRvIHVwZGF0ZSB0aGUgbWFpbiB3aW5kb3cuXG4gICAqIEBwYXJhbSB7RnVuY3Rpb259IG9wdGlvbnMucGFyYW1ldGVycy5yZW9yZGVyU3RyZWFtcyAtIEZ1bmN0aW9uIHRvIHJlb3JkZXIgdGhlIHN0cmVhbXMuXG4gICAqIEBwYXJhbSB7RnVuY3Rpb259IG9wdGlvbnMucGFyYW1ldGVycy5wcmVwb3B1bGF0ZVVzZXJNZWRpYSAtIEZ1bmN0aW9uIHRvIHByZXBvcHVsYXRlIHVzZXIgbWVkaWEuXG4gICAqXG4gICAqIEByZXR1cm5zIHtQcm9taXNlPHZvaWQ+fSBBIHByb21pc2UgdGhhdCByZXNvbHZlcyB3aGVuIHRoZSBtZWRpYSBoYXMgYmVlbiByZXN1bWVkLlxuICAgKi9cbiAgcHJvZHVjZXJNZWRpYVJlc3VtZWQgPSBhc3luYyAoe1xuICAgIG5hbWUsXG4gICAgcGFyYW1ldGVycyxcbiAgfTogUHJvZHVjZXJNZWRpYVJlc3VtZWRPcHRpb25zKTogUHJvbWlzZTx2b2lkPiA9PiB7XG4gICAgcGFyYW1ldGVycyA9IHBhcmFtZXRlcnMuZ2V0VXBkYXRlZEFsbFBhcmFtcygpO1xuXG4gICAgbGV0IHtcbiAgICAgIG1lZXRpbmdEaXNwbGF5VHlwZSxcbiAgICAgIHBhcnRpY2lwYW50cyxcbiAgICAgIHNoYXJlZCxcbiAgICAgIHNoYXJlU2NyZWVuU3RhcnRlZCxcbiAgICAgIHVwZGF0ZU1haW5XaW5kb3csXG4gICAgICBtYWluU2NyZWVuRmlsbGVkLFxuICAgICAgaG9zdExhYmVsLFxuICAgICAgdXBkYXRlVXBkYXRlTWFpbldpbmRvdyxcbiAgICAgIHJlb3JkZXJTdHJlYW1zLFxuICAgICAgcHJlcG9wdWxhdGVVc2VyTWVkaWEsXG4gICAgfSA9IHBhcmFtZXRlcnM7XG5cbiAgICAvLyBVcGRhdGUgdG8gcmVzdW1lIHRoZSBhdWRpbyBvbmx5IG9mIGEgcGFydGljaXBhbnRcbiAgICAvLyBuYW1lIGlzIHRoZSBuYW1lIG9mIHRoZSBwYXJ0aWNpcGFudFxuICAgIC8vIGtpbmQgaXMgdGhlIGtpbmQgb2YgbWVkaWEgKGFsd2F5cyBhdWRpbylcblxuICAgIC8vIE9wZXJhdGlvbnMgdG8gdXBkYXRlIFVJIHRvIG9wdGltaXplIGludGVyZXN0IGxldmVsc1xuICAgIGNvbnN0IHBhcnRpY2lwYW50ID0gcGFydGljaXBhbnRzLmZpbmQoKG9iajogYW55KSA9PiBvYmoubmFtZSA9PSBuYW1lKTtcblxuICAgIGlmICghbWFpblNjcmVlbkZpbGxlZCAmJiBwYXJ0aWNpcGFudD8uaXNsZXZlbCA9PSAnMicpIHtcbiAgICAgIHVwZGF0ZU1haW5XaW5kb3cgPSB0cnVlO1xuICAgICAgdXBkYXRlVXBkYXRlTWFpbldpbmRvdyh1cGRhdGVNYWluV2luZG93KTtcbiAgICAgIGF3YWl0IHByZXBvcHVsYXRlVXNlck1lZGlhKHsgbmFtZTogaG9zdExhYmVsLCBwYXJhbWV0ZXJzIH0pO1xuICAgICAgdXBkYXRlTWFpbldpbmRvdyA9IGZhbHNlO1xuICAgICAgdXBkYXRlVXBkYXRlTWFpbldpbmRvdyh1cGRhdGVNYWluV2luZG93KTtcbiAgICB9XG5cbiAgICBsZXQgY2hlY2tlcjtcbiAgICBpZiAobWVldGluZ0Rpc3BsYXlUeXBlID09ICdtZWRpYScpIHtcbiAgICAgIGNoZWNrZXIgPSBwYXJ0aWNpcGFudD8udmlkZW9JRCAhPSBudWxsICYmIHBhcnRpY2lwYW50LnZpZGVvSUQgIT09ICcnO1xuXG4gICAgICBpZiAoIWNoZWNrZXIgJiYgIShzaGFyZVNjcmVlblN0YXJ0ZWQgfHwgc2hhcmVkKSkge1xuICAgICAgICBhd2FpdCByZW9yZGVyU3RyZWFtcyh7IGFkZDogZmFsc2UsIHNjcmVlbkNoYW5nZWQ6IHRydWUsIHBhcmFtZXRlcnMgfSk7XG4gICAgICB9XG4gICAgfVxuICB9O1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"producer-media-resumed.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/producers/socket-receive-methods/producer-media-resumed.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAqC3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAMH,MAAM,OAAO,oBAAoB;IAC/B;;;;;;;;;;;;;;;;;OAiBG;IACH,oBAAoB,GAAG,KAAK,EAAE,EAC5B,IAAI,EACJ,UAAU,GACkB,EAAiB,EAAE;QAC/C,UAAU,GAAG,UAAU,CAAC,mBAAmB,EAAE,CAAC;QAE9C,IAAI,EACF,kBAAkB,EAClB,YAAY,EACZ,MAAM,EACN,kBAAkB,EAClB,gBAAgB,EAChB,gBAAgB,EAChB,SAAS,EACT,sBAAsB,EACtB,cAAc,EACd,oBAAoB,GACrB,GAAG,UAAU,CAAC;QAEf,mDAAmD;QACnD,sCAAsC;QACtC,2CAA2C;QAE3C,sDAAsD;QACtD,MAAM,WAAW,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC,GAAQ,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,IAAI,IAAI,CAAC,CAAC;QAEtE,IAAI,CAAC,gBAAgB,IAAI,WAAW,EAAE,OAAO,IAAI,GAAG,EAAE,CAAC;YACrD,gBAAgB,GAAG,IAAI,CAAC;YACxB,sBAAsB,CAAC,gBAAgB,CAAC,CAAC;YACzC,MAAM,oBAAoB,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,UAAU,EAAE,CAAC,CAAC;YAC5D,gBAAgB,GAAG,KAAK,CAAC;YACzB,sBAAsB,CAAC,gBAAgB,CAAC,CAAC;QAC3C,CAAC;QAED,IAAI,OAAO,CAAC;QACZ,IAAI,kBAAkB,IAAI,OAAO,EAAE,CAAC;YAClC,OAAO,GAAG,WAAW,EAAE,OAAO,IAAI,IAAI,IAAI,WAAW,CAAC,OAAO,KAAK,EAAE,CAAC;YAErE,IAAI,CAAC,OAAO,IAAI,CAAC,CAAC,kBAAkB,IAAI,MAAM,CAAC,EAAE,CAAC;gBAChD,MAAM,cAAc,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC,CAAC;YACxE,CAAC;QACH,CAAC;IACH,CAAC,CAAC;uGA7DS,oBAAoB;2GAApB,oBAAoB,cAFnB,MAAM;;2FAEP,oBAAoB;kBAHhC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  Participant,\n  PrepopulateUserMediaParameters,\n  PrepopulateUserMediaType,\n  ReorderStreamsParameters,\n  ReorderStreamsType,\n} from '../../@types/types';\n\nexport interface ProducerMediaResumedParameters\n  extends PrepopulateUserMediaParameters,\n    ReorderStreamsParameters {\n  meetingDisplayType: string;\n  participants: Participant[];\n  shared: boolean;\n  shareScreenStarted: boolean;\n  mainScreenFilled: boolean;\n  hostLabel: string;\n  updateUpdateMainWindow: (updateMainWindow: boolean) => void;\n\n  // mediasfu functions\n  reorderStreams: ReorderStreamsType;\n  prepopulateUserMedia: PrepopulateUserMediaType;\n\n  getUpdatedAllParams: () => ProducerMediaResumedParameters;\n  [key: string]: any;\n}\n\nexport interface ProducerMediaResumedOptions {\n  name: string;\n  kind: 'audio';\n  parameters: ProducerMediaResumedParameters;\n}\n\n// Export the type definition for the function\nexport type ProducerMediaResumedType = (options: ProducerMediaResumedOptions) => Promise<void>;\n\n/**\n * Service to handle resuming media for a specific participant in a meeting.\n *\n * @class\n * @name ProducerMediaResumed\n * @description Resumes media (audio only) for a participant and updates the meeting display based on the meeting layout and participant status.\n *\n * @method\n * producerMediaResumed\n *\n * @param {ProducerMediaResumedOptions} options - Options to control media resumption:\n *   - `name` {string}: Name of the participant whose media is to be resumed.\n *   - `parameters` {ProducerMediaResumedParameters}: Meeting and participant-specific configurations.\n *      - `meetingDisplayType` {string}: Type of meeting display (e.g., \"media\").\n *      - `participants` {Participant[]}: List of participants in the meeting.\n *      - `shared` {boolean}: Indicates if the screen is currently shared.\n *      - `shareScreenStarted` {boolean}: Indicates if screen sharing has started.\n *      - `mainScreenFilled` {boolean}: Indicates if the main screen is filled.\n *      - `hostLabel` {string}: Label or name of the host.\n *      - `updateUpdateMainWindow` {Function}: Function to update the main window display.\n *      - `reorderStreams` {Function}: Function to manage stream ordering when display changes.\n *      - `prepopulateUserMedia` {Function}: Function to preload user media for the main screen.\n *\n * @returns {Promise<void>} Resolves when media for the specified participant has resumed.\n *\n * @example\n * const options = {\n *   name: 'Participant A',\n *   parameters: {\n *     meetingDisplayType: 'media',\n *     participants: [...],\n *     shared: false,\n *     shareScreenStarted: false,\n *     mainScreenFilled: false,\n *     hostLabel: 'Host',\n *     updateUpdateMainWindow: (updateMainWindow) => { ... },\n *     reorderStreams: ({ add, screenChanged, parameters }) => { ... },\n *     prepopulateUserMedia: ({ name, parameters }) => { ... }\n *   }\n * };\n *\n * producerMediaResumedService.producerMediaResumed(options)\n *   .then(() => console.log('Media resumed'))\n *   .catch(error => console.error('Error:', error));\n */\n\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ProducerMediaResumed {\n  /**\n   * Resumes media for a specific participant in a meeting.\n   *\n   * @param {ProducerMediaResumedOptions} options - The options for resuming media.\n   * @param {string} options.name - The name of the participant whose media is to be resumed.\n   * @param {Object} options.parameters - The parameters related to the meeting and participants.\n   * @param {string} options.parameters.meetingDisplayType - The type of meeting display.\n   * @param {Array} options.parameters.participants - The list of participants in the meeting.\n   * @param {boolean} options.parameters.shared - Indicates if the screen is being shared.\n   * @param {boolean} options.parameters.shareScreenStarted - Indicates if screen sharing has started.\n   * @param {boolean} options.parameters.mainScreenFilled - Indicates if the main screen is filled.\n   * @param {string} options.parameters.hostLabel - The label of the host.\n   * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window.\n   * @param {Function} options.parameters.reorderStreams - Function to reorder the streams.\n   * @param {Function} options.parameters.prepopulateUserMedia - Function to prepopulate user media.\n   *\n   * @returns {Promise<void>} A promise that resolves when the media has been resumed.\n   */\n  producerMediaResumed = async ({\n    name,\n    parameters,\n  }: ProducerMediaResumedOptions): Promise<void> => {\n    parameters = parameters.getUpdatedAllParams();\n\n    let {\n      meetingDisplayType,\n      participants,\n      shared,\n      shareScreenStarted,\n      updateMainWindow,\n      mainScreenFilled,\n      hostLabel,\n      updateUpdateMainWindow,\n      reorderStreams,\n      prepopulateUserMedia,\n    } = parameters;\n\n    // Update to resume the audio only of a participant\n    // name is the name of the participant\n    // kind is the kind of media (always audio)\n\n    // Operations to update UI to optimize interest levels\n    const participant = participants.find((obj: any) => obj.name == name);\n\n    if (!mainScreenFilled && participant?.islevel == '2') {\n      updateMainWindow = true;\n      updateUpdateMainWindow(updateMainWindow);\n      await prepopulateUserMedia({ name: hostLabel, parameters });\n      updateMainWindow = false;\n      updateUpdateMainWindow(updateMainWindow);\n    }\n\n    let checker;\n    if (meetingDisplayType == 'media') {\n      checker = participant?.videoID != null && participant.videoID !== '';\n\n      if (!checker && !(shareScreenStarted || shared)) {\n        await reorderStreams({ add: false, screenChanged: true, parameters });\n      }\n    }\n  };\n}\n"]}

package/dist/esm2022/lib/producers/socket-receive-methods/re-initiate-recording.service.mjs

@@ -1,5 +1,34 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Service to re-initiate recording in a specific room, considering administrative restrictions.
+ *
+ * @class
+ * @name ReInitiateRecording
+ * @description Attempts to re-initiate recording if administrative restrictions permit.
+ *
+ * @method
+ * reInitiateRecording
+ *
+ * @param {ReInitiateRecordingOptions} options - Configuration options for re-initiating recording:
+ *   - `roomName` {string}: The name of the room to start recording in.
+ *   - `member` {string}: The name of the member initiating the recording.
+ *   - `socket` {Socket}: The socket instance for server communication.
+ *   - `adminRestrictSetting` {boolean}: Flag indicating if the admin restrict setting is active, preventing re-initiation.
+ *
+ * @returns {Promise<void>} Resolves if recording is successfully re-initiated; otherwise, it throws an error if re-initiation fails.
+ *
+ * @example
+ * const options = {
+ *   roomName: 'Room101',
+ *   member: 'Alice',
+ *   socket: mySocketInstance,
+ *   adminRestrictSetting: false
+ * };
+ * reInitiateRecordingService.reInitiateRecording(options)
+ *   .then(() => console.log('Recording re-initiated'))
+ *   .catch(error => console.error(error.message));
+ */
 export class ReInitiateRecording {
     /**
      * Re-initiates recording based on specific conditions.
@@ -35,4 +64,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,5 +1,43 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Service for receiving and processing messages, including handling group and direct messages, filtering banned senders, and updating message states.
+ *
+ * @class
+ * @name ReceiveMessage
+ * @description Manages incoming messages, appends them to the existing messages array, filters out banned senders, and updates message badge visibility as needed.
+ *
+ * @method
+ * receiveMessage
+ *
+ * @param {ReceiveMessageOptions} options - Options for handling a received message:
+ *   - `message` {Message}: The new message object to process.
+ *   - `messages` {Message[]}: The current list of messages.
+ *   - `participantsAll` {Participant[]}: All participants in the chat.
+ *   - `member` {string}: The current member's name.
+ *   - `eventType` {EventType}: The type of event (e.g., "broadcast" or "chat").
+ *   - `islevel` {string}: The level of the current user.
+ *   - `coHost` {string}: The name of the co-host.
+ *   - `updateMessages` {Function}: A function to update the messages list.
+ *   - `updateShowMessagesBadge` {Function}: A function to toggle the visibility of the message badge.
+ *
+ * @returns {Promise<void>} Resolves when the message processing and updates are complete.
+ *
+ * @example
+ * const message = { sender: 'Alice', receivers: ['Bob'], message: 'Hello!', timestamp: Date.now(), group: false };
+ * const options = {
+ *   message,
+ *   messages: [],
+ *   participantsAll: [{ name: 'Alice' }, { name: 'Bob' }],
+ *   member: 'Bob',
+ *   eventType: 'chat',
+ *   islevel: '1',
+ *   coHost: 'Charlie',
+ *   updateMessages: (updatedMessages) => console.log('Messages updated:', updatedMessages),
+ *   updateShowMessagesBadge: (show) => console.log('Show badge:', show)
+ * };
+ * receiveMessageService.receiveMessage(options);
+ */
 export class ReceiveMessage {
     /**
      * Receives and processes a message, updating the messages array and handling
@@ -93,4 +131,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"receive-message.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/producers/socket-receive-methods/receive-message.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { EventType, Message, Participant } from '../../@types/types';\n\nexport interface ReceiveMessageOptions {\n  message: Message;\n  messages: Message[];\n  participantsAll: Participant[];\n  member: string;\n  eventType: EventType;\n  islevel: string;\n  coHost: string;\n  updateMessages: (messages: Message[]) => void;\n  updateShowMessagesBadge: (showBadge: boolean) => void;\n}\n\n// Export the type definition for the function\nexport type ReceiveMessageType = (options: ReceiveMessageOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ReceiveMessage {\n  /**\n   * Receives and processes a message, updating the messages array and handling\n   * various message types and events.\n   *\n   * @param {ReceiveMessageOptions} options - The options for receiving the message.\n   * @param {Object} options.message - The message object containing sender, receivers, content, timestamp, and group.\n   * @param {Function} options.getUpdatedAllParams - Function to get updated parameters.\n   * @param {Array} options.messages - Array of current messages.\n   * @param {Array} options.participantsAll - Array of all participants.\n   * @param {string} options.member - The current member.\n   * @param {string} options.eventType - The type of event (e.g., \"broadcast\", \"chat\").\n   * @param {string} options.islevel - The level of the current member.\n   * @param {string} options.coHost - The co-host of the event.\n   * @param {Function} options.updateMessages - Function to update the messages array.\n   * @param {Function} options.updateShowMessagesBadge - Function to update the visibility of the messages badge.\n   *\n   * @returns {Promise<void>} A promise that resolves when the message has been processed.\n   */\n\n  receiveMessage = async ({\n    message,\n    messages,\n    participantsAll,\n    member,\n    eventType,\n    islevel,\n    coHost,\n    updateMessages,\n    updateShowMessagesBadge,\n  }: ReceiveMessageOptions): Promise<void> => {\n    // Add the received message to the messages array\n    const { sender, receivers, message: content, timestamp, group } = message;\n    let oldMessages = messages;\n    messages = [...messages, { sender, receivers, message: content, timestamp, group }];\n\n    // Filter out messages with banned senders in the participants array\n    if (eventType !== 'broadcast' && eventType !== 'chat') {\n      messages = messages.filter((message: Message) =>\n        participantsAll.some(\n          (participant: any) => participant.name === message.sender && !participant.isBanned,\n        ),\n      );\n    } else {\n      messages = messages.filter((message: Message) => {\n        const participant = participantsAll.find(\n          (participant: any) => participant.name === message.sender,\n        );\n        return !participant || !participant.isBanned;\n      });\n    }\n    updateMessages(messages);\n\n    // Separate group and direct messages\n    const oldGroupMessages = oldMessages.filter((message: Message) => message.group);\n    const oldDirectMessages = oldMessages.filter((message: Message) => !message.group);\n\n    // Render and update counts for group messages\n    const groupMessages = messages.filter((message: Message) => message.group);\n\n    if (eventType !== 'broadcast' && eventType !== 'chat') {\n      // Check if oldGroupMessages length is different from groupMessages length\n      if (oldGroupMessages.length !== groupMessages.length) {\n        // Identify new messages\n        const newGroupMessages = groupMessages.filter(\n          (message: Message) =>\n            !oldGroupMessages.some(\n              (oldMessage: Message) => oldMessage.timestamp === message.timestamp,\n            ),\n        );\n\n        // Check if newGroupMessages sender is the member or receivers include the member\n        const newGroupMessages2 = newGroupMessages.filter(\n          (message: Message) => message.sender === member || message.receivers.includes(member),\n        );\n\n        // Check if member is the sender of any newGroupMessages\n        const newGroupMessages3 = newGroupMessages2.filter(\n          (message: Message) => message.sender === member,\n        );\n\n        // Check if member is the receiver of any newGroupMessages\n        if (newGroupMessages.length > 0 && newGroupMessages.length !== newGroupMessages3.length) {\n          updateShowMessagesBadge(true);\n        }\n      }\n    }\n\n    // Render and update counts for direct messages\n    const directMessages = messages.filter((message: Message) => !message.group);\n\n    if (eventType !== 'broadcast' && eventType !== 'chat') {\n      // Check if oldDirectMessages length is different from directMessages length\n      if (oldDirectMessages.length !== directMessages.length) {\n        // Identify new direct messages\n        const newDirectMessages = directMessages.filter(\n          (message: Message) =>\n            !oldDirectMessages.some(\n              (oldMessage: Message) => oldMessage.timestamp === message.timestamp,\n            ),\n        );\n\n        // Check if newDirectMessages sender is the member or receivers include the member\n        const newDirectMessages2 = newDirectMessages.filter(\n          (message: Message) => message.sender === member || message.receivers.includes(member),\n        );\n\n        // Check if member is the sender of any newDirectMessages\n        const newDirectMessages3 = newDirectMessages2.filter(\n          (message: Message) => message.sender === member,\n        );\n\n        if (\n          (newDirectMessages.length > 0 && newDirectMessages2.length > 0) ||\n          (newDirectMessages.length > 0 && islevel === '2') ||\n          coHost === member\n        ) {\n          if (islevel === '2' || coHost === member) {\n            if (newDirectMessages.length !== newDirectMessages3.length) {\n              updateShowMessagesBadge(true);\n            }\n          } else {\n            if (\n              newDirectMessages2.length > 0 &&\n              newDirectMessages.length !== newDirectMessages3.length\n            ) {\n              updateShowMessagesBadge(true);\n            }\n          }\n        }\n      }\n    }\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"receive-message.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/producers/socket-receive-methods/receive-message.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { EventType, Message, Participant } from '../../@types/types';\n\nexport interface ReceiveMessageOptions {\n  message: Message;\n  messages: Message[];\n  participantsAll: Participant[];\n  member: string;\n  eventType: EventType;\n  islevel: string;\n  coHost: string;\n  updateMessages: (messages: Message[]) => void;\n  updateShowMessagesBadge: (showBadge: boolean) => void;\n}\n\n// Export the type definition for the function\nexport type ReceiveMessageType = (options: ReceiveMessageOptions) => Promise<void>;\n\n/**\n * Service for receiving and processing messages, including handling group and direct messages, filtering banned senders, and updating message states.\n *\n * @class\n * @name ReceiveMessage\n * @description Manages incoming messages, appends them to the existing messages array, filters out banned senders, and updates message badge visibility as needed.\n *\n * @method\n * receiveMessage\n *\n * @param {ReceiveMessageOptions} options - Options for handling a received message:\n *   - `message` {Message}: The new message object to process.\n *   - `messages` {Message[]}: The current list of messages.\n *   - `participantsAll` {Participant[]}: All participants in the chat.\n *   - `member` {string}: The current member's name.\n *   - `eventType` {EventType}: The type of event (e.g., \"broadcast\" or \"chat\").\n *   - `islevel` {string}: The level of the current user.\n *   - `coHost` {string}: The name of the co-host.\n *   - `updateMessages` {Function}: A function to update the messages list.\n *   - `updateShowMessagesBadge` {Function}: A function to toggle the visibility of the message badge.\n *\n * @returns {Promise<void>} Resolves when the message processing and updates are complete.\n *\n * @example\n * const message = { sender: 'Alice', receivers: ['Bob'], message: 'Hello!', timestamp: Date.now(), group: false };\n * const options = {\n *   message,\n *   messages: [],\n *   participantsAll: [{ name: 'Alice' }, { name: 'Bob' }],\n *   member: 'Bob',\n *   eventType: 'chat',\n *   islevel: '1',\n *   coHost: 'Charlie',\n *   updateMessages: (updatedMessages) => console.log('Messages updated:', updatedMessages),\n *   updateShowMessagesBadge: (show) => console.log('Show badge:', show)\n * };\n * receiveMessageService.receiveMessage(options);\n */\n\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ReceiveMessage {\n  /**\n   * Receives and processes a message, updating the messages array and handling\n   * various message types and events.\n   *\n   * @param {ReceiveMessageOptions} options - The options for receiving the message.\n   * @param {Object} options.message - The message object containing sender, receivers, content, timestamp, and group.\n   * @param {Function} options.getUpdatedAllParams - Function to get updated parameters.\n   * @param {Array} options.messages - Array of current messages.\n   * @param {Array} options.participantsAll - Array of all participants.\n   * @param {string} options.member - The current member.\n   * @param {string} options.eventType - The type of event (e.g., \"broadcast\", \"chat\").\n   * @param {string} options.islevel - The level of the current member.\n   * @param {string} options.coHost - The co-host of the event.\n   * @param {Function} options.updateMessages - Function to update the messages array.\n   * @param {Function} options.updateShowMessagesBadge - Function to update the visibility of the messages badge.\n   *\n   * @returns {Promise<void>} A promise that resolves when the message has been processed.\n   */\n\n  receiveMessage = async ({\n    message,\n    messages,\n    participantsAll,\n    member,\n    eventType,\n    islevel,\n    coHost,\n    updateMessages,\n    updateShowMessagesBadge,\n  }: ReceiveMessageOptions): Promise<void> => {\n    // Add the received message to the messages array\n    const { sender, receivers, message: content, timestamp, group } = message;\n    let oldMessages = messages;\n    messages = [...messages, { sender, receivers, message: content, timestamp, group }];\n\n    // Filter out messages with banned senders in the participants array\n    if (eventType !== 'broadcast' && eventType !== 'chat') {\n      messages = messages.filter((message: Message) =>\n        participantsAll.some(\n          (participant: any) => participant.name === message.sender && !participant.isBanned,\n        ),\n      );\n    } else {\n      messages = messages.filter((message: Message) => {\n        const participant = participantsAll.find(\n          (participant: any) => participant.name === message.sender,\n        );\n        return !participant || !participant.isBanned;\n      });\n    }\n    updateMessages(messages);\n\n    // Separate group and direct messages\n    const oldGroupMessages = oldMessages.filter((message: Message) => message.group);\n    const oldDirectMessages = oldMessages.filter((message: Message) => !message.group);\n\n    // Render and update counts for group messages\n    const groupMessages = messages.filter((message: Message) => message.group);\n\n    if (eventType !== 'broadcast' && eventType !== 'chat') {\n      // Check if oldGroupMessages length is different from groupMessages length\n      if (oldGroupMessages.length !== groupMessages.length) {\n        // Identify new messages\n        const newGroupMessages = groupMessages.filter(\n          (message: Message) =>\n            !oldGroupMessages.some(\n              (oldMessage: Message) => oldMessage.timestamp === message.timestamp,\n            ),\n        );\n\n        // Check if newGroupMessages sender is the member or receivers include the member\n        const newGroupMessages2 = newGroupMessages.filter(\n          (message: Message) => message.sender === member || message.receivers.includes(member),\n        );\n\n        // Check if member is the sender of any newGroupMessages\n        const newGroupMessages3 = newGroupMessages2.filter(\n          (message: Message) => message.sender === member,\n        );\n\n        // Check if member is the receiver of any newGroupMessages\n        if (newGroupMessages.length > 0 && newGroupMessages.length !== newGroupMessages3.length) {\n          updateShowMessagesBadge(true);\n        }\n      }\n    }\n\n    // Render and update counts for direct messages\n    const directMessages = messages.filter((message: Message) => !message.group);\n\n    if (eventType !== 'broadcast' && eventType !== 'chat') {\n      // Check if oldDirectMessages length is different from directMessages length\n      if (oldDirectMessages.length !== directMessages.length) {\n        // Identify new direct messages\n        const newDirectMessages = directMessages.filter(\n          (message: Message) =>\n            !oldDirectMessages.some(\n              (oldMessage: Message) => oldMessage.timestamp === message.timestamp,\n            ),\n        );\n\n        // Check if newDirectMessages sender is the member or receivers include the member\n        const newDirectMessages2 = newDirectMessages.filter(\n          (message: Message) => message.sender === member || message.receivers.includes(member),\n        );\n\n        // Check if member is the sender of any newDirectMessages\n        const newDirectMessages3 = newDirectMessages2.filter(\n          (message: Message) => message.sender === member,\n        );\n\n        if (\n          (newDirectMessages.length > 0 && newDirectMessages2.length > 0) ||\n          (newDirectMessages.length > 0 && islevel === '2') ||\n          coHost === member\n        ) {\n          if (islevel === '2' || coHost === member) {\n            if (newDirectMessages.length !== newDirectMessages3.length) {\n              updateShowMessagesBadge(true);\n            }\n          } else {\n            if (\n              newDirectMessages2.length > 0 &&\n              newDirectMessages.length !== newDirectMessages3.length\n            ) {\n              updateShowMessagesBadge(true);\n            }\n          }\n        }\n      }\n    }\n  };\n}\n"]}