mediasfu-angular 1.0.1 → 1.0.2

package/dist/esm2022/lib/consumers/check-permission.service.mjs

@@ -1,5 +1,30 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Checks the permission based on the provided settings.
+ *
+ * @param {CheckPermissionOptions} options - The options for checking permissions.
+ * @param {string} options.permissionType - The type of permission to check. Can be "audioSetting", "videoSetting", "screenshareSetting", or "chatSetting".
+ * @param {string} options.audioSetting - The setting for audio permission. Can be "allow", "approval", or other.
+ * @param {string} options.videoSetting - The setting for video permission. Can be "allow", "approval", or other.
+ * @param {string} options.screenshareSetting - The setting for screenshare permission. Can be "allow", "approval", or other.
+ * @param {string} options.chatSetting - The setting for chat permission. Can be "allow", "approval", or other.
+ * @returns {Promise<number>} - Returns 0 if the setting is "allow", 1 if the setting is "approval", and 2 for other settings or invalid permission types.
+ * @throws Will throw an error if an unexpected error occurs during the permission check.
+ *
+ * @example
+ * const options = {
+ *   permissionType: 'videoSetting',
+ *   audioSetting: 'allow',
+ *   videoSetting: 'approval',
+ *   screenshareSetting: 'deny',
+ *   chatSetting: 'allow',
+ * };
+ *
+ * const result = await checkPermissionService.checkPermission(options);
+ * console.log(result);
+ * // Output: 1 (since videoSetting is 'approval')
+ */
 export class CheckPermission {
     /**
      * Checks the permission based on the provided settings.
@@ -77,4 +102,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlY2stcGVybWlzc2lvbi5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbWVkaWFzZnUtYW5ndWxhci9zcmMvbGliL2NvbnN1bWVycy9jaGVjay1wZXJtaXNzaW9uLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFlM0MsTUFBTSxPQUFPLGVBQWU7SUFDMUI7Ozs7Ozs7Ozs7O09BV0c7SUFFSCxLQUFLLENBQUMsZUFBZSxDQUFDLEVBQ3BCLGNBQWMsRUFDZCxZQUFZLEVBQ1osWUFBWSxFQUNaLGtCQUFrQixFQUNsQixXQUFXLEdBQ1k7UUFDdkIsSUFBSSxDQUFDO1lBQ0gsZ0ZBQWdGO1lBQ2hGLFFBQVEsY0FBYyxFQUFFLENBQUM7Z0JBQ3ZCLEtBQUssY0FBYztvQkFDakIsSUFBSSxZQUFZLEtBQUssT0FBTyxFQUFFLENBQUM7d0JBQzdCLE9BQU8sQ0FBQyxDQUFDO29CQUNYLENBQUM7eUJBQU0sSUFBSSxZQUFZLEtBQUssVUFBVSxFQUFFLENBQUM7d0JBQ3ZDLE9BQU8sQ0FBQyxDQUFDO29CQUNYLENBQUM7eUJBQU0sQ0FBQzt3QkFDTixPQUFPLENBQUMsQ0FBQztvQkFDWCxDQUFDO2dCQUNILEtBQUssY0FBYztvQkFDakIsSUFBSSxZQUFZLEtBQUssT0FBTyxFQUFFLENBQUM7d0JBQzdCLE9BQU8sQ0FBQyxDQUFDO29CQUNYLENBQUM7eUJBQU0sSUFBSSxZQUFZLEtBQUssVUFBVSxFQUFFLENBQUM7d0JBQ3ZDLE9BQU8sQ0FBQyxDQUFDO29CQUNYLENBQUM7eUJBQU0sQ0FBQzt3QkFDTixPQUFPLENBQUMsQ0FBQztvQkFDWCxDQUFDO2dCQUNILEtBQUssb0JBQW9CO29CQUN2QixJQUFJLGtCQUFrQixLQUFLLE9BQU8sRUFBRSxDQUFDO3dCQUNuQyxPQUFPLENBQUMsQ0FBQztvQkFDWCxDQUFDO3lCQUFNLElBQUksa0JBQWtCLEtBQUssVUFBVSxFQUFFLENBQUM7d0JBQzdDLE9BQU8sQ0FBQyxDQUFDO29CQUNYLENBQUM7eUJBQU0sQ0FBQzt3QkFDTixPQUFPLENBQUMsQ0FBQztvQkFDWCxDQUFDO2dCQUNILEtBQUssYUFBYTtvQkFDaEIsSUFBSSxXQUFXLEtBQUssT0FBTyxFQUFFLENBQUM7d0JBQzVCLE9BQU8sQ0FBQyxDQUFDO29CQUNYLENBQUM7eUJBQU0sSUFBSSxXQUFXLEtBQUssVUFBVSxFQUFFLENBQUM7d0JBQ3RDLE9BQU8sQ0FBQyxDQUFDO29CQUNYLENBQUM7eUJBQU0sQ0FBQzt3QkFDTixPQUFPLENBQUMsQ0FBQztvQkFDWCxDQUFDO2dCQUNIO29CQUNFLGdFQUFnRTtvQkFDaEUsT0FBTyxDQUFDLENBQUM7WUFDYixDQUFDO1FBQ0gsQ0FBQztRQUFDLE9BQU8sS0FBSyxFQUFFLENBQUM7WUFDZiwrQ0FBK0M7WUFDL0MsZUFBZTtZQUNmLE9BQU8sQ0FBQyxDQUFDO1FBQ1gsQ0FBQztJQUNILENBQUM7dUdBakVVLGVBQWU7MkdBQWYsZUFBZSxjQUZkLE1BQU07OzJGQUVQLGVBQWU7a0JBSDNCLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuZXhwb3J0IGludGVyZmFjZSBDaGVja1Blcm1pc3Npb25PcHRpb25zIHtcbiAgYXVkaW9TZXR0aW5nOiBzdHJpbmc7XG4gIHZpZGVvU2V0dGluZzogc3RyaW5nO1xuICBzY3JlZW5zaGFyZVNldHRpbmc6IHN0cmluZztcbiAgY2hhdFNldHRpbmc6IHN0cmluZztcbiAgcGVybWlzc2lvblR5cGU6ICdhdWRpb1NldHRpbmcnIHwgJ3ZpZGVvU2V0dGluZycgfCAnc2NyZWVuc2hhcmVTZXR0aW5nJyB8ICdjaGF0U2V0dGluZyc7XG59XG5cbi8vIEV4cG9ydCB0aGUgdHlwZSBkZWZpbml0aW9uIGZvciB0aGUgZnVuY3Rpb25cbmV4cG9ydCB0eXBlIENoZWNrUGVybWlzc2lvblR5cGUgPSAob3B0aW9uczogQ2hlY2tQZXJtaXNzaW9uT3B0aW9ucykgPT4gUHJvbWlzZTxudW1iZXI+O1xuXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290Jyxcbn0pXG5leHBvcnQgY2xhc3MgQ2hlY2tQZXJtaXNzaW9uIHtcbiAgLyoqXG4gICAqIENoZWNrcyB0aGUgcGVybWlzc2lvbiBiYXNlZCBvbiB0aGUgcHJvdmlkZWQgc2V0dGluZ3MuXG4gICAqXG4gICAqIEBwYXJhbSB7Q2hlY2tQZXJtaXNzaW9uT3B0aW9uc30gb3B0aW9ucyAtIFRoZSBvcHRpb25zIGZvciBjaGVja2luZyBwZXJtaXNzaW9ucy5cbiAgICogQHBhcmFtIHtzdHJpbmd9IG9wdGlvbnMucGVybWlzc2lvblR5cGUgLSBUaGUgdHlwZSBvZiBwZXJtaXNzaW9uIHRvIGNoZWNrLiBDYW4gYmUgXCJhdWRpb1NldHRpbmdcIiwgXCJ2aWRlb1NldHRpbmdcIiwgXCJzY3JlZW5zaGFyZVNldHRpbmdcIiwgb3IgXCJjaGF0U2V0dGluZ1wiLlxuICAgKiBAcGFyYW0ge3N0cmluZ30gb3B0aW9ucy5hdWRpb1NldHRpbmcgLSBUaGUgc2V0dGluZyBmb3IgYXVkaW8gcGVybWlzc2lvbi4gQ2FuIGJlIFwiYWxsb3dcIiwgXCJhcHByb3ZhbFwiLCBvciBvdGhlci5cbiAgICogQHBhcmFtIHtzdHJpbmd9IG9wdGlvbnMudmlkZW9TZXR0aW5nIC0gVGhlIHNldHRpbmcgZm9yIHZpZGVvIHBlcm1pc3Npb24uIENhbiBiZSBcImFsbG93XCIsIFwiYXBwcm92YWxcIiwgb3Igb3RoZXIuXG4gICAqIEBwYXJhbSB7c3RyaW5nfSBvcHRpb25zLnNjcmVlbnNoYXJlU2V0dGluZyAtIFRoZSBzZXR0aW5nIGZvciBzY3JlZW5zaGFyZSBwZXJtaXNzaW9uLiBDYW4gYmUgXCJhbGxvd1wiLCBcImFwcHJvdmFsXCIsIG9yIG90aGVyLlxuICAgKiBAcGFyYW0ge3N0cmluZ30gb3B0aW9ucy5jaGF0U2V0dGluZyAtIFRoZSBzZXR0aW5nIGZvciBjaGF0IHBlcm1pc3Npb24uIENhbiBiZSBcImFsbG93XCIsIFwiYXBwcm92YWxcIiwgb3Igb3RoZXIuXG4gICAqIEByZXR1cm5zIHtQcm9taXNlPG51bWJlcj59IC0gUmV0dXJucyAwIGlmIHRoZSBzZXR0aW5nIGlzIFwiYWxsb3dcIiwgMSBpZiB0aGUgc2V0dGluZyBpcyBcImFwcHJvdmFsXCIsIGFuZCAyIGZvciBvdGhlciBzZXR0aW5ncyBvciBpbnZhbGlkIHBlcm1pc3Npb24gdHlwZXMuXG4gICAqIEB0aHJvd3MgV2lsbCB0aHJvdyBhbiBlcnJvciBpZiBhbiB1bmV4cGVjdGVkIGVycm9yIG9jY3VycyBkdXJpbmcgdGhlIHBlcm1pc3Npb24gY2hlY2suXG4gICAqL1xuXG4gIGFzeW5jIGNoZWNrUGVybWlzc2lvbih7XG4gICAgcGVybWlzc2lvblR5cGUsXG4gICAgYXVkaW9TZXR0aW5nLFxuICAgIHZpZGVvU2V0dGluZyxcbiAgICBzY3JlZW5zaGFyZVNldHRpbmcsXG4gICAgY2hhdFNldHRpbmcsXG4gIH06IENoZWNrUGVybWlzc2lvbk9wdGlvbnMpOiBQcm9taXNlPG51bWJlcj4ge1xuICAgIHRyeSB7XG4gICAgICAvLyBQZXJmb3JtIGEgc3dpdGNoIGNhc2UgdG8gY2hlY2sgZm9yIHRoZSBwZXJtaXNzaW9uVHlwZSBhbmQgcmV0dXJuIHRoZSByZXNwb25zZVxuICAgICAgc3dpdGNoIChwZXJtaXNzaW9uVHlwZSkge1xuICAgICAgICBjYXNlICdhdWRpb1NldHRpbmcnOlxuICAgICAgICAgIGlmIChhdWRpb1NldHRpbmcgPT09ICdhbGxvdycpIHtcbiAgICAgICAgICAgIHJldHVybiAwO1xuICAgICAgICAgIH0gZWxzZSBpZiAoYXVkaW9TZXR0aW5nID09PSAnYXBwcm92YWwnKSB7XG4gICAgICAgICAgICByZXR1cm4gMTtcbiAgICAgICAgICB9IGVsc2Uge1xuICAgICAgICAgICAgcmV0dXJuIDI7XG4gICAgICAgICAgfVxuICAgICAgICBjYXNlICd2aWRlb1NldHRpbmcnOlxuICAgICAgICAgIGlmICh2aWRlb1NldHRpbmcgPT09ICdhbGxvdycpIHtcbiAgICAgICAgICAgIHJldHVybiAwO1xuICAgICAgICAgIH0gZWxzZSBpZiAodmlkZW9TZXR0aW5nID09PSAnYXBwcm92YWwnKSB7XG4gICAgICAgICAgICByZXR1cm4gMTtcbiAgICAgICAgICB9IGVsc2Uge1xuICAgICAgICAgICAgcmV0dXJuIDI7XG4gICAgICAgICAgfVxuICAgICAgICBjYXNlICdzY3JlZW5zaGFyZVNldHRpbmcnOlxuICAgICAgICAgIGlmIChzY3JlZW5zaGFyZVNldHRpbmcgPT09ICdhbGxvdycpIHtcbiAgICAgICAgICAgIHJldHVybiAwO1xuICAgICAgICAgIH0gZWxzZSBpZiAoc2NyZWVuc2hhcmVTZXR0aW5nID09PSAnYXBwcm92YWwnKSB7XG4gICAgICAgICAgICByZXR1cm4gMTtcbiAgICAgICAgICB9IGVsc2Uge1xuICAgICAgICAgICAgcmV0dXJuIDI7XG4gICAgICAgICAgfVxuICAgICAgICBjYXNlICdjaGF0U2V0dGluZyc6XG4gICAgICAgICAgaWYgKGNoYXRTZXR0aW5nID09PSAnYWxsb3cnKSB7XG4gICAgICAgICAgICByZXR1cm4gMDtcbiAgICAgICAgICB9IGVsc2UgaWYgKGNoYXRTZXR0aW5nID09PSAnYXBwcm92YWwnKSB7XG4gICAgICAgICAgICByZXR1cm4gMTtcbiAgICAgICAgICB9IGVsc2Uge1xuICAgICAgICAgICAgcmV0dXJuIDI7XG4gICAgICAgICAgfVxuICAgICAgICBkZWZhdWx0OlxuICAgICAgICAgIC8vIHRocm93IG5ldyBFcnJvcihgSW52YWxpZCBwZXJtaXNzaW9uVHlwZTogJHtwZXJtaXNzaW9uVHlwZX1gKTtcbiAgICAgICAgICByZXR1cm4gMjtcbiAgICAgIH1cbiAgICB9IGNhdGNoIChlcnJvcikge1xuICAgICAgLy8gY29uc29sZS5sb2coJ2NoZWNrUGVybWlzc2lvbiBlcnJvcicsIGVycm9yKTtcbiAgICAgIC8vIHRocm93IGVycm9yO1xuICAgICAgcmV0dXJuIDI7XG4gICAgfVxuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"check-permission.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/check-permission.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAYzC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAML,MAAM,OAAO,eAAe;IAC1B;;;;;;;;;;;OAWG;IAEH,KAAK,CAAC,eAAe,CAAC,EACpB,cAAc,EACd,YAAY,EACZ,YAAY,EACZ,kBAAkB,EAClB,WAAW,GACY;QACvB,IAAI,CAAC;YACH,gFAAgF;YAChF,QAAQ,cAAc,EAAE,CAAC;gBACvB,KAAK,cAAc;oBACjB,IAAI,YAAY,KAAK,OAAO,EAAE,CAAC;wBAC7B,OAAO,CAAC,CAAC;oBACX,CAAC;yBAAM,IAAI,YAAY,KAAK,UAAU,EAAE,CAAC;wBACvC,OAAO,CAAC,CAAC;oBACX,CAAC;yBAAM,CAAC;wBACN,OAAO,CAAC,CAAC;oBACX,CAAC;gBACH,KAAK,cAAc;oBACjB,IAAI,YAAY,KAAK,OAAO,EAAE,CAAC;wBAC7B,OAAO,CAAC,CAAC;oBACX,CAAC;yBAAM,IAAI,YAAY,KAAK,UAAU,EAAE,CAAC;wBACvC,OAAO,CAAC,CAAC;oBACX,CAAC;yBAAM,CAAC;wBACN,OAAO,CAAC,CAAC;oBACX,CAAC;gBACH,KAAK,oBAAoB;oBACvB,IAAI,kBAAkB,KAAK,OAAO,EAAE,CAAC;wBACnC,OAAO,CAAC,CAAC;oBACX,CAAC;yBAAM,IAAI,kBAAkB,KAAK,UAAU,EAAE,CAAC;wBAC7C,OAAO,CAAC,CAAC;oBACX,CAAC;yBAAM,CAAC;wBACN,OAAO,CAAC,CAAC;oBACX,CAAC;gBACH,KAAK,aAAa;oBAChB,IAAI,WAAW,KAAK,OAAO,EAAE,CAAC;wBAC5B,OAAO,CAAC,CAAC;oBACX,CAAC;yBAAM,IAAI,WAAW,KAAK,UAAU,EAAE,CAAC;wBACtC,OAAO,CAAC,CAAC;oBACX,CAAC;yBAAM,CAAC;wBACN,OAAO,CAAC,CAAC;oBACX,CAAC;gBACH;oBACE,gEAAgE;oBAChE,OAAO,CAAC,CAAC;YACb,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,+CAA+C;YAC/C,eAAe;YACf,OAAO,CAAC,CAAC;QACX,CAAC;IACH,CAAC;uGAjEU,eAAe;2GAAf,eAAe,cAFd,MAAM;;2FAEP,eAAe;kBAH3B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nexport interface CheckPermissionOptions {\n  audioSetting: string;\n  videoSetting: string;\n  screenshareSetting: string;\n  chatSetting: string;\n  permissionType: 'audioSetting' | 'videoSetting' | 'screenshareSetting' | 'chatSetting';\n}\n\n// Export the type definition for the function\nexport type CheckPermissionType = (options: CheckPermissionOptions) => Promise<number>;\n\n  /**\n   * Checks the permission based on the provided settings.\n   *\n   * @param {CheckPermissionOptions} options - The options for checking permissions.\n   * @param {string} options.permissionType - The type of permission to check. Can be \"audioSetting\", \"videoSetting\", \"screenshareSetting\", or \"chatSetting\".\n   * @param {string} options.audioSetting - The setting for audio permission. Can be \"allow\", \"approval\", or other.\n   * @param {string} options.videoSetting - The setting for video permission. Can be \"allow\", \"approval\", or other.\n   * @param {string} options.screenshareSetting - The setting for screenshare permission. Can be \"allow\", \"approval\", or other.\n   * @param {string} options.chatSetting - The setting for chat permission. Can be \"allow\", \"approval\", or other.\n   * @returns {Promise<number>} - Returns 0 if the setting is \"allow\", 1 if the setting is \"approval\", and 2 for other settings or invalid permission types.\n   * @throws Will throw an error if an unexpected error occurs during the permission check.\n   *\n   * @example\n   * const options = {\n   *   permissionType: 'videoSetting',\n   *   audioSetting: 'allow',\n   *   videoSetting: 'approval',\n   *   screenshareSetting: 'deny',\n   *   chatSetting: 'allow',\n   * };\n   *\n   * const result = await checkPermissionService.checkPermission(options);\n   * console.log(result);\n   * // Output: 1 (since videoSetting is 'approval')\n   */\n\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class CheckPermission {\n  /**\n   * Checks the permission based on the provided settings.\n   *\n   * @param {CheckPermissionOptions} options - The options for checking permissions.\n   * @param {string} options.permissionType - The type of permission to check. Can be \"audioSetting\", \"videoSetting\", \"screenshareSetting\", or \"chatSetting\".\n   * @param {string} options.audioSetting - The setting for audio permission. Can be \"allow\", \"approval\", or other.\n   * @param {string} options.videoSetting - The setting for video permission. Can be \"allow\", \"approval\", or other.\n   * @param {string} options.screenshareSetting - The setting for screenshare permission. Can be \"allow\", \"approval\", or other.\n   * @param {string} options.chatSetting - The setting for chat permission. Can be \"allow\", \"approval\", or other.\n   * @returns {Promise<number>} - Returns 0 if the setting is \"allow\", 1 if the setting is \"approval\", and 2 for other settings or invalid permission types.\n   * @throws Will throw an error if an unexpected error occurs during the permission check.\n   */\n\n  async checkPermission({\n    permissionType,\n    audioSetting,\n    videoSetting,\n    screenshareSetting,\n    chatSetting,\n  }: CheckPermissionOptions): Promise<number> {\n    try {\n      // Perform a switch case to check for the permissionType and return the response\n      switch (permissionType) {\n        case 'audioSetting':\n          if (audioSetting === 'allow') {\n            return 0;\n          } else if (audioSetting === 'approval') {\n            return 1;\n          } else {\n            return 2;\n          }\n        case 'videoSetting':\n          if (videoSetting === 'allow') {\n            return 0;\n          } else if (videoSetting === 'approval') {\n            return 1;\n          } else {\n            return 2;\n          }\n        case 'screenshareSetting':\n          if (screenshareSetting === 'allow') {\n            return 0;\n          } else if (screenshareSetting === 'approval') {\n            return 1;\n          } else {\n            return 2;\n          }\n        case 'chatSetting':\n          if (chatSetting === 'allow') {\n            return 0;\n          } else if (chatSetting === 'approval') {\n            return 1;\n          } else {\n            return 2;\n          }\n        default:\n          // throw new Error(`Invalid permissionType: ${permissionType}`);\n          return 2;\n      }\n    } catch (error) {\n      // console.log('checkPermission error', error);\n      // throw error;\n      return 2;\n    }\n  }\n}\n"]}

package/dist/esm2022/lib/consumers/check-screen-share.service.mjs

@@ -1,5 +1,40 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Checks the current screen sharing status and either stops or requests screen sharing based on the provided parameters.
+ *
+ * @param {CheckScreenShareOptions} options - The options for checking screen share.
+ * @param {Object} options.parameters - The parameters for screen sharing.
+ * @param {boolean} options.parameters.shared - Indicates if the screen is currently being shared.
+ * @param {Function} [options.parameters.showAlert] - Function to show alerts.
+ * @param {boolean} options.parameters.whiteboardStarted - Indicates if the whiteboard session has started.
+ * @param {boolean} options.parameters.whiteboardEnded - Indicates if the whiteboard session has ended.
+ * @param {boolean} options.parameters.breakOutRoomStarted - Indicates if the breakout room session has started.
+ * @param {boolean} options.parameters.breakOutRoomEnded - Indicates if the breakout room session has ended.
+ * @param {Function} options.parameters.stopShareScreen - Function to stop screen sharing.
+ * @param {Function} options.parameters.requestScreenShare - Function to request screen sharing.
+ *
+ * @returns {Promise<void>} A promise that resolves when the screen sharing status has been checked and the appropriate action has been taken.
+ *
+ * @throws Will log an error message if an error occurs during the process.
+ *
+ * @example
+ * const options = {
+ *   parameters: {
+ *     shared: false,
+ *     whiteboardStarted: false,
+ *     whiteboardEnded: false,
+ *     breakOutRoomStarted: false,
+ *     breakOutRoomEnded: false,
+ *     stopShareScreen: async () => { /* Logic to stop screen sharing *\/ },
+ *     requestScreenShare: async () => { /* Logic to request screen sharing *\/ },
+ *     showAlert: (alert) => { console.log(alert.message); },
+ *   },
+ * };
+ *
+ * await checkScreenShareService.checkScreenShare(options);
+ * // Output: Logic to request screen sharing will be executed.
+ */
 export class CheckScreenShare {
     /**
      * Checks the current screen sharing status and either stops or requests screen sharing based on the provided parameters.
@@ -68,4 +103,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":"check-screen-share.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/check-screen-share.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAiCzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAML,MAAM,OAAO,gBAAgB;IAC3B;;;;;;;;;;;;;;;;;OAiBG;IACH,gBAAgB,GAAG,KAAK,EAAE,EAAE,UAAU,EAA2B,EAAiB,EAAE;QAClF,IAAI,CAAC;YACH,MAAM,EACJ,MAAM,EACN,SAAS,EACT,iBAAiB,EACjB,eAAe,EACf,mBAAmB,EACnB,iBAAiB;YAEjB,qBAAqB;YACrB,eAAe,EACf,kBAAkB,GACnB,GAAG,UAAU,CAAC;YAEf,4EAA4E;YAC5E,IAAI,MAAM,EAAE,CAAC;gBACX,IAAI,iBAAiB,IAAI,CAAC,eAAe,EAAE,CAAC;oBAC1C,SAAS,EAAE,CAAC;wBACV,OAAO,EAAE,uDAAuD;wBAChE,IAAI,EAAE,QAAQ;qBACf,CAAC,CAAC;oBACH,OAAO;gBACT,CAAC;gBACD,MAAM,eAAe,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC;YACxC,CAAC;iBAAM,CAAC;gBACN,yCAAyC;gBACzC,IAAI,mBAAmB,IAAI,CAAC,iBAAiB,EAAE,CAAC;oBAC9C,SAAS,EAAE,CAAC;wBACV,OAAO,EAAE,0DAA0D;wBACnE,IAAI,EAAE,QAAQ;qBACf,CAAC,CAAC;oBACH,OAAO;gBACT,CAAC;gBAED,IAAI,iBAAiB,IAAI,CAAC,eAAe,EAAE,CAAC;oBAC1C,SAAS,EAAE,CAAC;wBACV,OAAO,EAAE,uDAAuD;wBAChE,IAAI,EAAE,QAAQ;qBACf,CAAC,CAAC;oBACH,OAAO;gBACT,CAAC;gBACD,MAAM,kBAAkB,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC;YAC3C,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,GAAG,CAAC,wBAAwB,EAAE,KAAK,CAAC,CAAC;YAC7C,eAAe;QACjB,CAAC;IACH,CAAC,CAAC;uGAnES,gBAAgB;2GAAhB,gBAAgB,cAFf,MAAM;;2FAEP,gBAAgB;kBAH5B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  StopShareScreenType,\n  StopShareScreenParameters,\n  RequestScreenShareType,\n  RequestScreenShareParameters,\n  ShowAlert,\n} from '../@types/types';\nexport interface CheckScreenShareParameters\n  extends StopShareScreenParameters,\n    RequestScreenShareParameters {\n  shared: boolean;\n  whiteboardStarted: boolean;\n  whiteboardEnded: boolean;\n  breakOutRoomStarted: boolean;\n  breakOutRoomEnded: boolean;\n  showAlert?: ShowAlert;\n\n  // Mediasfu functions\n  stopShareScreen: StopShareScreenType;\n  requestScreenShare: RequestScreenShareType;\n\n  getUpdatedAllParams: () => CheckScreenShareParameters;\n  [key: string]: any;\n}\n\nexport interface CheckScreenShareOptions {\n  parameters: CheckScreenShareParameters;\n}\n\n// Export the type definition for the function\nexport type CheckScreenShareType = (options: CheckScreenShareOptions) => Promise<void>;\n\n  /**\n   * Checks the current screen sharing status and either stops or requests screen sharing based on the provided parameters.\n   *\n   * @param {CheckScreenShareOptions} options - The options for checking screen share.\n   * @param {Object} options.parameters - The parameters for screen sharing.\n   * @param {boolean} options.parameters.shared - Indicates if the screen is currently being shared.\n   * @param {Function} [options.parameters.showAlert] - Function to show alerts.\n   * @param {boolean} options.parameters.whiteboardStarted - Indicates if the whiteboard session has started.\n   * @param {boolean} options.parameters.whiteboardEnded - Indicates if the whiteboard session has ended.\n   * @param {boolean} options.parameters.breakOutRoomStarted - Indicates if the breakout room session has started.\n   * @param {boolean} options.parameters.breakOutRoomEnded - Indicates if the breakout room session has ended.\n   * @param {Function} options.parameters.stopShareScreen - Function to stop screen sharing.\n   * @param {Function} options.parameters.requestScreenShare - Function to request screen sharing.\n   *\n   * @returns {Promise<void>} A promise that resolves when the screen sharing status has been checked and the appropriate action has been taken.\n   *\n   * @throws Will log an error message if an error occurs during the process.\n   *\n   * @example\n   * const options = {\n   *   parameters: {\n   *     shared: false,\n   *     whiteboardStarted: false,\n   *     whiteboardEnded: false,\n   *     breakOutRoomStarted: false,\n   *     breakOutRoomEnded: false,\n   *     stopShareScreen: async () => { /* Logic to stop screen sharing *\\/ },\n   *     requestScreenShare: async () => { /* Logic to request screen sharing *\\/ },\n   *     showAlert: (alert) => { console.log(alert.message); },\n   *   },\n   * };\n   *\n   * await checkScreenShareService.checkScreenShare(options);\n   * // Output: Logic to request screen sharing will be executed.\n   */\n\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class CheckScreenShare {\n  /**\n   * Checks the current screen sharing status and either stops or requests screen sharing based on the provided parameters.\n   *\n   * @param {CheckScreenShareOptions} options - The options for checking screen share.\n   * @param {Object} options.parameters - The parameters for screen sharing.\n   * @param {boolean} options.parameters.shared - Indicates if the screen is currently being shared.\n   * @param {Function} [options.parameters.showAlert] - Function to show alerts.\n   * @param {boolean} options.parameters.whiteboardStarted - Indicates if the whiteboard session has started.\n   * @param {boolean} options.parameters.whiteboardEnded - Indicates if the whiteboard session has ended.\n   * @param {boolean} options.parameters.breakOutRoomStarted - Indicates if the breakout room session has started.\n   * @param {boolean} options.parameters.breakOutRoomEnded - Indicates if the breakout room session has ended.\n   * @param {Function} options.parameters.stopShareScreen - Function to stop screen sharing.\n   * @param {Function} options.parameters.requestScreenShare - Function to request screen sharing.\n   *\n   * @returns {Promise<void>} A promise that resolves when the screen sharing status has been checked and the appropriate action has been taken.\n   *\n   * @throws Will log an error message if an error occurs during the process.\n   */\n  checkScreenShare = async ({ parameters }: CheckScreenShareOptions): Promise<void> => {\n    try {\n      const {\n        shared,\n        showAlert,\n        whiteboardStarted,\n        whiteboardEnded,\n        breakOutRoomStarted,\n        breakOutRoomEnded,\n\n        // mediasfu functions\n        stopShareScreen,\n        requestScreenShare,\n      } = parameters;\n\n      // Stop screen share if already shared or request screen share if not shared\n      if (shared) {\n        if (whiteboardStarted && !whiteboardEnded) {\n          showAlert?.({\n            message: 'Screen share is not allowed when whiteboard is active',\n            type: 'danger',\n          });\n          return;\n        }\n        await stopShareScreen({ parameters });\n      } else {\n        // Can't share if breakout room is active\n        if (breakOutRoomStarted && !breakOutRoomEnded) {\n          showAlert?.({\n            message: 'Screen share is not allowed when breakout room is active',\n            type: 'danger',\n          });\n          return;\n        }\n\n        if (whiteboardStarted && !whiteboardEnded) {\n          showAlert?.({\n            message: 'Screen share is not allowed when whiteboard is active',\n            type: 'danger',\n          });\n          return;\n        }\n        await requestScreenShare({ parameters });\n      }\n    } catch (error) {\n      console.log('checkScreenShare error', error);\n      // throw error;\n    }\n  };\n}\n"]}

package/dist/esm2022/lib/consumers/close-and-resize.service.mjs

@@ -1,5 +1,107 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Closes and resizes the video and audio elements based on the provided options.
+ *
+ * @param {CloseAndResizeOptions} options - The options for closing and resizing.
+ * @param {string} options.producerId - The ID of the producer.
+ * @param {string} options.kind - The kind of media (audio, video, screenshare, or screen).
+ * @param {object} options.parameters - The parameters for the operation.
+ * @param {function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+ * @param {Array} options.parameters.allAudioStreams - Array of all audio streams.
+ * @param {Array} options.parameters.allVideoStreams - Array of all video streams.
+ * @param {Array} options.parameters.activeNames - Array of active participant names.
+ * @param {Array} options.parameters.participants - Array of participants.
+ * @param {Array} options.parameters.streamNames - Array of stream names.
+ * @param {string} options.parameters.recordingDisplayType - Type of recording display.
+ * @param {boolean} options.parameters.recordingVideoOptimized - Whether recording is video optimized.
+ * @param {string} options.parameters.adminIDStream - ID of the admin stream.
+ * @param {Array} options.parameters.newLimitedStreams - Array of new limited streams.
+ * @param {Array} options.parameters.newLimitedStreamsIDs - Array of new limited stream IDs.
+ * @param {Array} options.parameters.oldAllStreams - Array of old all streams.
+ * @param {boolean} options.parameters.shareScreenStarted - Whether screen sharing has started.
+ * @param {boolean} options.parameters.shared - Whether sharing is active.
+ * @param {string} options.parameters.meetingDisplayType - Type of meeting display.
+ * @param {boolean} options.parameters.defer_receive - Whether to defer receiving.
+ * @param {boolean} options.parameters.lock_screen - Whether the screen is locked.
+ * @param {boolean} options.parameters.firstAll - Whether it is the first all.
+ * @param {boolean} options.parameters.first_round - Whether it is the first round.
+ * @param {boolean} options.parameters.gotAllVids - Whether all videos are received.
+ * @param {string} options.parameters.eventType - Type of event.
+ * @param {string} options.parameters.hostLabel - Label of the host.
+ * @param {boolean} options.parameters.shareEnded - Whether sharing has ended.
+ * @param {boolean} options.parameters.updateMainWindow - Whether to update the main window.
+ * @param {function} options.parameters.updateActiveNames - Function to update active names.
+ * @param {function} options.parameters.updateAllAudioStreams - Function to update all audio streams.
+ * @param {function} options.parameters.updateAllVideoStreams - Function to update all video streams.
+ * @param {function} options.parameters.updateShareScreenStarted - Function to update share screen started status.
+ * @param {function} options.parameters.updateUpdateMainWindow - Function to update main window status.
+ * @param {function} options.parameters.updateNewLimitedStreams - Function to update new limited streams.
+ * @param {function} options.parameters.updateOldAllStreams - Function to update old all streams.
+ * @param {function} options.parameters.updateDefer_receive - Function to update defer receive status.
+ * @param {function} options.parameters.updateMainHeightWidth - Function to update main height and width.
+ * @param {function} options.parameters.updateShareEnded - Function to update share ended status.
+ * @param {function} options.parameters.updateLock_screen - Function to update lock screen status.
+ * @param {function} options.parameters.updateFirstAll - Function to update first all status.
+ * @param {function} options.parameters.updateFirst_round - Function to update first round status.
+ * @param {function} options.parameters.reorderStreams - Function to reorder streams.
+ * @param {function} options.parameters.prepopulateUserMedia - Function to prepopulate user media.
+ * @param {function} options.parameters.getVideos - Function to get videos.
+ * @param {function} options.parameters.rePort - Function to report.
+ *
+ * @returns {Promise<void>} A promise that resolves when the operation is complete.
+ *
+ * @example
+ * const options = {
+ *   producerId: '12345',
+ *   kind: 'video',
+ *   parameters: {
+ *     getUpdatedAllParams: () => { /* Logic to get updated parameters *\/ },
+ *     allAudioStreams: [],
+ *     allVideoStreams: [],
+ *     activeNames: ['Participant1', 'Participant2'],
+ *     participants: [],
+ *     streamNames: [],
+ *     recordingDisplayType: 'video',
+ *     recordingVideoOptimized: true,
+ *     adminIDStream: 'admin123',
+ *     newLimitedStreams: [],
+ *     newLimitedStreamsIDs: [],
+ *     oldAllStreams: [],
+ *     shareScreenStarted: false,
+ *     shared: false,
+ *     meetingDisplayType: 'media',
+ *     defer_receive: false,
+ *     lock_screen: false,
+ *     firstAll: false,
+ *     first_round: false,
+ *     gotAllVids: false,
+ *     eventType: 'conference',
+ *     hostLabel: 'Host',
+ *     shareEnded: false,
+ *     updateMainWindow: false,
+ *     updateActiveNames: (names) => { /* Logic to update active names *\/ },
+ *     updateAllAudioStreams: (streams) => { /* Logic to update audio streams *\/ },
+ *     updateShareScreenStarted: (status) => { /* Logic to update share screen status *\/ },
+ *     updateUpdateMainWindow: (status) => { /* Logic to update main window status *\/ },
+ *     updateNewLimitedStreams: (streams) => { /* Logic to update new limited streams *\/ },
+ *     updateOldAllStreams: (streams) => { /* Logic to update old streams *\/ },
+ *     updateDefer_receive: (status) => { /* Logic to update defer receive status *\/ },
+ *     updateMainHeightWidth: (size) => { /* Logic to update main height and width *\/ },
+ *     updateShareEnded: (status) => { /* Logic to update share ended status *\/ },
+ *     updateLock_screen: (status) => { /* Logic to update lock screen status *\/ },
+ *     updateFirstAll: (status) => { /* Logic to update first all status *\/ },
+ *     updateFirst_round: (status) => { /* Logic to update first round status *\/ },
+ *     reorderStreams: async () => { /* Logic to reorder streams *\/ },
+ *     prepopulateUserMedia: async () => { /* Logic to prepopulate user media *\/ },
+ *     getVideos: async () => { /* Logic to get videos *\/ },
+ *     rePort: async () => { /* Logic to report *\/ },
+ *   },
+ * };
+ *
+ * await closeAndResizeService.closeAndResize(options);
+ * // The operation will adjust the video and audio elements as per the given parameters.
+ */
 export class CloseAndResize {
     /**
      * Closes and resizes the video and audio elements based on the provided options.
@@ -226,4 +328,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"close-and-resize.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/close-and-resize.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  Stream,\n  Participant,\n  ReorderStreamsType,\n  ReorderStreamsParameters,\n  PrepopulateUserMediaParameters,\n  PrepopulateUserMediaType,\n  GetVideosType,\n  RePortType,\n  RePortParameters,\n  EventType,\n} from '../@types/types';\n\nexport interface CloseAndResizeParameters\n  extends ReorderStreamsParameters,\n    PrepopulateUserMediaParameters,\n    RePortParameters {\n  allAudioStreams: (Stream | Participant)[];\n  allVideoStreams: (Stream | Participant)[];\n  activeNames: string[];\n  participants: Participant[];\n  streamNames: Stream[];\n  recordingDisplayType: 'video' | 'media' | 'all';\n  recordingVideoOptimized: boolean;\n  adminIDStream?: string;\n  newLimitedStreams: (Stream | Participant)[];\n  newLimitedStreamsIDs: string[];\n  oldAllStreams: (Stream | Participant)[];\n  shareScreenStarted: boolean;\n  shared: boolean;\n  meetingDisplayType: string;\n  defer_receive: boolean;\n  lock_screen: boolean;\n  firstAll: boolean;\n  first_round: boolean;\n  gotAllVids: boolean;\n  eventType: EventType;\n  hostLabel: string;\n  shareEnded: boolean;\n  updateMainWindow: boolean;\n  updateActiveNames: (activeNames: string[]) => void;\n  updateAllAudioStreams: (allAudioStreams: (Stream | Participant)[]) => void;\n  updateShareScreenStarted: (shareScreenStarted: boolean) => void;\n  updateUpdateMainWindow: (updateMainWindow: boolean) => void;\n  updateNewLimitedStreams: (newLimitedStreams: (Stream | Participant)[]) => void;\n  updateOldAllStreams: (oldAllStreams: (Stream | Participant)[]) => void;\n  updateDefer_receive: (defer_receive: boolean) => void;\n  updateMainHeightWidth: (heightWidth: number) => void;\n  updateShareEnded: (shareEnded: boolean) => void;\n  updateLock_screen: (lock_screen: boolean) => void;\n  updateFirstAll: (firstAll: boolean) => void;\n  updateFirst_round: (first_round: boolean) => void;\n\n  // mediasfu functions\n  reorderStreams: ReorderStreamsType;\n  prepopulateUserMedia: PrepopulateUserMediaType;\n  getVideos: GetVideosType;\n  rePort: RePortType;\n  getUpdatedAllParams: () => CloseAndResizeParameters;\n  [key: string]: any;\n}\n\nexport interface CloseAndResizeOptions {\n  producerId: string;\n  kind: string;\n  parameters: CloseAndResizeParameters;\n}\n\n// Export the type definition for the function\nexport type CloseAndResizeType = (options: CloseAndResizeOptions) => Promise<void>;\n@Injectable({\n  providedIn: 'root',\n})\nexport class CloseAndResize {\n  /**\n   * Closes and resizes the video and audio elements based on the provided options.\n   *\n   * @param {CloseAndResizeOptions} options - The options for closing and resizing.\n   * @param {string} options.producerId - The ID of the producer.\n   * @param {string} options.kind - The kind of media (audio, video, screenshare, or screen).\n   * @param {object} options.parameters - The parameters for the operation.\n   * @param {function} options.parameters.getUpdatedAllParams - Function to get updated parameters.\n   * @param {Array} options.parameters.allAudioStreams - Array of all audio streams.\n   * @param {Array} options.parameters.allVideoStreams - Array of all video streams.\n   * @param {Array} options.parameters.activeNames - Array of active participant names.\n   * @param {Array} options.parameters.participants - Array of participants.\n   * @param {Array} options.parameters.streamNames - Array of stream names.\n   * @param {string} options.parameters.recordingDisplayType - Type of recording display.\n   * @param {boolean} options.parameters.recordingVideoOptimized - Whether recording is video optimized.\n   * @param {string} options.parameters.adminIDStream - ID of the admin stream.\n   * @param {Array} options.parameters.newLimitedStreams - Array of new limited streams.\n   * @param {Array} options.parameters.newLimitedStreamsIDs - Array of new limited stream IDs.\n   * @param {Array} options.parameters.oldAllStreams - Array of old all streams.\n   * @param {boolean} options.parameters.shareScreenStarted - Whether screen sharing has started.\n   * @param {boolean} options.parameters.shared - Whether sharing is active.\n   * @param {string} options.parameters.meetingDisplayType - Type of meeting display.\n   * @param {boolean} options.parameters.defer_receive - Whether to defer receiving.\n   * @param {boolean} options.parameters.lock_screen - Whether the screen is locked.\n   * @param {boolean} options.parameters.firstAll - Whether it is the first all.\n   * @param {boolean} options.parameters.first_round - Whether it is the first round.\n   * @param {boolean} options.parameters.gotAllVids - Whether all videos are received.\n   * @param {string} options.parameters.eventType - Type of event.\n   * @param {string} options.parameters.hostLabel - Label of the host.\n   * @param {boolean} options.parameters.shareEnded - Whether sharing has ended.\n   * @param {boolean} options.parameters.updateMainWindow - Whether to update the main window.\n   * @param {function} options.parameters.updateActiveNames - Function to update active names.\n   * @param {function} options.parameters.updateAllAudioStreams - Function to update all audio streams.\n   * @param {function} options.parameters.updateAllVideoStreams - Function to update all video streams.\n   * @param {function} options.parameters.updateShareScreenStarted - Function to update share screen started status.\n   * @param {function} options.parameters.updateUpdateMainWindow - Function to update main window status.\n   * @param {function} options.parameters.updateNewLimitedStreams - Function to update new limited streams.\n   * @param {function} options.parameters.updateOldAllStreams - Function to update old all streams.\n   * @param {function} options.parameters.updateDefer_receive - Function to update defer receive status.\n   * @param {function} options.parameters.updateMainHeightWidth - Function to update main height and width.\n   * @param {function} options.parameters.updateShareEnded - Function to update share ended status.\n   * @param {function} options.parameters.updateLock_screen - Function to update lock screen status.\n   * @param {function} options.parameters.updateFirstAll - Function to update first all status.\n   * @param {function} options.parameters.updateFirst_round - Function to update first round status.\n   * @param {function} options.parameters.reorderStreams - Function to reorder streams.\n   * @param {function} options.parameters.prepopulateUserMedia - Function to prepopulate user media.\n   * @param {function} options.parameters.getVideos - Function to get videos.\n   * @param {function} options.parameters.rePort - Function to report.\n   *\n   * @returns {Promise<void>} A promise that resolves when the operation is complete.\n   */\n\n  closeAndResize = async ({\n    producerId,\n    kind,\n    parameters,\n  }: CloseAndResizeOptions): Promise<void> => {\n    let { getUpdatedAllParams } = parameters;\n    parameters = getUpdatedAllParams();\n\n    let {\n      allAudioStreams,\n      allVideoStreams,\n      activeNames,\n      participants,\n      streamNames,\n      recordingDisplayType,\n      recordingVideoOptimized,\n      adminIDStream,\n      newLimitedStreams,\n      newLimitedStreamsIDs,\n      oldAllStreams,\n      shareScreenStarted,\n      shared,\n      meetingDisplayType,\n      defer_receive,\n      lock_screen,\n      firstAll,\n      first_round,\n      gotAllVids,\n      eventType,\n\n      hostLabel,\n      shareEnded,\n      updateMainWindow,\n      updateActiveNames,\n      updateAllAudioStreams,\n      updateAllVideoStreams,\n\n      updateShareScreenStarted,\n      updateUpdateMainWindow,\n      updateNewLimitedStreams,\n      updateOldAllStreams,\n      updateDefer_receive,\n      updateMainHeightWidth,\n      updateShareEnded,\n      updateLock_screen,\n      updateFirstAll,\n      updateFirst_round,\n\n      //mediasfu functions\n      reorderStreams,\n      prepopulateUserMedia,\n      getVideos,\n      rePort,\n    } = parameters;\n\n    //function to close and resize the video and audio elements\n\n    let participant: Participant | undefined;\n\n    if (kind === 'audio') {\n      //stop the audio by removing the miniAudio with id = producerId\n\n      //remove the audio from the allAudioStreams array\n      allAudioStreams = allAudioStreams.filter(function (audioStream) {\n        return audioStream.producerId !== producerId;\n      });\n\n      updateAllAudioStreams(allAudioStreams);\n\n      if (recordingDisplayType == 'video' && recordingVideoOptimized == true) {\n        // do nothing\n      } else {\n        //get the name of the participant with the producerId\n        participant = participants.find((obj) => obj.audioID === producerId);\n\n        if (participant) {\n          //check if the participants videoID is not null or \"\"\n          if (participant.videoID !== null && participant.videoID !== '') {\n            // do nothing\n          } else {\n            //remove the participant from the activeNames array\n            activeNames = activeNames.filter(function (name) {\n              return name !== participant?.name;\n            });\n            updateActiveNames(activeNames);\n          }\n        }\n      }\n\n      let checker = false;\n      let alt_checker = false;\n\n      if (meetingDisplayType == 'video' && participant) {\n        checker =\n          participant[0].videoID != null &&\n          participant[0].videoID != '' &&\n          participant[0].videoID != undefined;\n      } else {\n        checker = true;\n        alt_checker = true;\n      }\n\n      if (checker) {\n        if (shareScreenStarted || shared) {\n          if (!alt_checker) {\n            await reorderStreams({ parameters });\n          }\n        } else {\n          if (alt_checker && meetingDisplayType != 'video') {\n            await reorderStreams({ add: false, screenChanged: true, parameters });\n          }\n        }\n      }\n    } else if (kind === 'video') {\n      //update the video elements by removing the miniVideo with id = producerId\n      //remove the video from the allVideoStreams array\n\n      //check if producerId == adminidstream\n      if (producerId == adminIDStream) {\n        updateMainWindow = true;\n        updateUpdateMainWindow(updateMainWindow);\n      }\n\n      try {\n        allVideoStreams = allVideoStreams.filter(function (videoStream) {\n          return videoStream.producerId !== producerId;\n        });\n\n        updateAllVideoStreams(allVideoStreams);\n\n        try {\n          //try remove it from oldVideoStreams\n          oldAllStreams = oldAllStreams.filter(function (videoStream) {\n            return videoStream.producerId !== producerId;\n          });\n\n          updateOldAllStreams(oldAllStreams);\n        } catch {\n          /* handle error */\n        }\n\n        try {\n          //try remove it from newLimitedStreams\n          newLimitedStreams = newLimitedStreams.filter(function (videoStream) {\n            return videoStream.producerId !== producerId;\n          });\n\n          updateNewLimitedStreams(newLimitedStreams);\n        } catch {\n          /* handle error */\n        }\n      } catch (error) {\n        try {\n          //try remove it from oldVideoStreams\n          oldAllStreams = oldAllStreams.filter(function (videoStream) {\n            return videoStream.producerId !== producerId;\n          });\n          updateOldAllStreams(oldAllStreams);\n        } catch {\n          /* handle error */\n        }\n      }\n\n      try {\n        //remove the participant from activeNames\n        activeNames = activeNames.filter(function (name) {\n          //get the participant with the producerId\n          let participant = streamNames.find((obj) => obj.producerId === producerId);\n\n          return name !== (participant?.name ?? '');\n        });\n\n        updateActiveNames(activeNames);\n      } catch {\n        /* handle error */\n      }\n\n      if (lock_screen) {\n        defer_receive = true;\n        // check if the video is the one being displayed (i.e. (newLimitedStreamsIDs))\n        if (newLimitedStreamsIDs.includes(producerId)) {\n          await prepopulateUserMedia({ name: hostLabel, parameters });\n          await reorderStreams({ add: false, screenChanged: true, parameters });\n        }\n      } else {\n        await prepopulateUserMedia({ name: hostLabel, parameters });\n        await reorderStreams({ add: false, screenChanged: true, parameters });\n      }\n    } else if (kind === 'screenshare' || kind === 'screen') {\n      //update the video elements by removing the mainVideo with id = producerId\n      updateMainWindow = true;\n\n      //screenshare stuff\n      shareScreenStarted = false;\n      shareEnded = true;\n\n      lock_screen = false;\n      firstAll = false;\n      first_round = false;\n\n      updateUpdateMainWindow(updateMainWindow);\n      updateShareScreenStarted(shareScreenStarted);\n      updateShareEnded(shareEnded);\n      updateLock_screen(lock_screen);\n      updateFirstAll(firstAll);\n      updateFirst_round(first_round);\n\n      if (!gotAllVids || defer_receive) {\n        defer_receive = false;\n        updateDefer_receive(defer_receive);\n        await getVideos({\n          participants,\n          allVideoStreams,\n          oldAllStreams,\n          updateAllVideoStreams,\n          updateOldAllStreams,\n        });\n        await rePort({ parameters });\n      }\n\n      if (eventType == 'conference') {\n        updateMainHeightWidth(0);\n      }\n\n      await prepopulateUserMedia({ name: hostLabel, parameters });\n      await reorderStreams({ add: false, screenChanged: true, parameters });\n    }\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"close-and-resize.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/close-and-resize.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  Stream,\n  Participant,\n  ReorderStreamsType,\n  ReorderStreamsParameters,\n  PrepopulateUserMediaParameters,\n  PrepopulateUserMediaType,\n  GetVideosType,\n  RePortType,\n  RePortParameters,\n  EventType,\n} from '../@types/types';\n\nexport interface CloseAndResizeParameters\n  extends ReorderStreamsParameters,\n    PrepopulateUserMediaParameters,\n    RePortParameters {\n  allAudioStreams: (Stream | Participant)[];\n  allVideoStreams: (Stream | Participant)[];\n  activeNames: string[];\n  participants: Participant[];\n  streamNames: Stream[];\n  recordingDisplayType: 'video' | 'media' | 'all';\n  recordingVideoOptimized: boolean;\n  adminIDStream?: string;\n  newLimitedStreams: (Stream | Participant)[];\n  newLimitedStreamsIDs: string[];\n  oldAllStreams: (Stream | Participant)[];\n  shareScreenStarted: boolean;\n  shared: boolean;\n  meetingDisplayType: string;\n  defer_receive: boolean;\n  lock_screen: boolean;\n  firstAll: boolean;\n  first_round: boolean;\n  gotAllVids: boolean;\n  eventType: EventType;\n  hostLabel: string;\n  shareEnded: boolean;\n  updateMainWindow: boolean;\n  updateActiveNames: (activeNames: string[]) => void;\n  updateAllAudioStreams: (allAudioStreams: (Stream | Participant)[]) => void;\n  updateShareScreenStarted: (shareScreenStarted: boolean) => void;\n  updateUpdateMainWindow: (updateMainWindow: boolean) => void;\n  updateNewLimitedStreams: (newLimitedStreams: (Stream | Participant)[]) => void;\n  updateOldAllStreams: (oldAllStreams: (Stream | Participant)[]) => void;\n  updateDefer_receive: (defer_receive: boolean) => void;\n  updateMainHeightWidth: (heightWidth: number) => void;\n  updateShareEnded: (shareEnded: boolean) => void;\n  updateLock_screen: (lock_screen: boolean) => void;\n  updateFirstAll: (firstAll: boolean) => void;\n  updateFirst_round: (first_round: boolean) => void;\n\n  // mediasfu functions\n  reorderStreams: ReorderStreamsType;\n  prepopulateUserMedia: PrepopulateUserMediaType;\n  getVideos: GetVideosType;\n  rePort: RePortType;\n  getUpdatedAllParams: () => CloseAndResizeParameters;\n  [key: string]: any;\n}\n\nexport interface CloseAndResizeOptions {\n  producerId: string;\n  kind: string;\n  parameters: CloseAndResizeParameters;\n}\n\n// Export the type definition for the function\nexport type CloseAndResizeType = (options: CloseAndResizeOptions) => Promise<void>;\n\n  /**\n   * Closes and resizes the video and audio elements based on the provided options.\n   *\n   * @param {CloseAndResizeOptions} options - The options for closing and resizing.\n   * @param {string} options.producerId - The ID of the producer.\n   * @param {string} options.kind - The kind of media (audio, video, screenshare, or screen).\n   * @param {object} options.parameters - The parameters for the operation.\n   * @param {function} options.parameters.getUpdatedAllParams - Function to get updated parameters.\n   * @param {Array} options.parameters.allAudioStreams - Array of all audio streams.\n   * @param {Array} options.parameters.allVideoStreams - Array of all video streams.\n   * @param {Array} options.parameters.activeNames - Array of active participant names.\n   * @param {Array} options.parameters.participants - Array of participants.\n   * @param {Array} options.parameters.streamNames - Array of stream names.\n   * @param {string} options.parameters.recordingDisplayType - Type of recording display.\n   * @param {boolean} options.parameters.recordingVideoOptimized - Whether recording is video optimized.\n   * @param {string} options.parameters.adminIDStream - ID of the admin stream.\n   * @param {Array} options.parameters.newLimitedStreams - Array of new limited streams.\n   * @param {Array} options.parameters.newLimitedStreamsIDs - Array of new limited stream IDs.\n   * @param {Array} options.parameters.oldAllStreams - Array of old all streams.\n   * @param {boolean} options.parameters.shareScreenStarted - Whether screen sharing has started.\n   * @param {boolean} options.parameters.shared - Whether sharing is active.\n   * @param {string} options.parameters.meetingDisplayType - Type of meeting display.\n   * @param {boolean} options.parameters.defer_receive - Whether to defer receiving.\n   * @param {boolean} options.parameters.lock_screen - Whether the screen is locked.\n   * @param {boolean} options.parameters.firstAll - Whether it is the first all.\n   * @param {boolean} options.parameters.first_round - Whether it is the first round.\n   * @param {boolean} options.parameters.gotAllVids - Whether all videos are received.\n   * @param {string} options.parameters.eventType - Type of event.\n   * @param {string} options.parameters.hostLabel - Label of the host.\n   * @param {boolean} options.parameters.shareEnded - Whether sharing has ended.\n   * @param {boolean} options.parameters.updateMainWindow - Whether to update the main window.\n   * @param {function} options.parameters.updateActiveNames - Function to update active names.\n   * @param {function} options.parameters.updateAllAudioStreams - Function to update all audio streams.\n   * @param {function} options.parameters.updateAllVideoStreams - Function to update all video streams.\n   * @param {function} options.parameters.updateShareScreenStarted - Function to update share screen started status.\n   * @param {function} options.parameters.updateUpdateMainWindow - Function to update main window status.\n   * @param {function} options.parameters.updateNewLimitedStreams - Function to update new limited streams.\n   * @param {function} options.parameters.updateOldAllStreams - Function to update old all streams.\n   * @param {function} options.parameters.updateDefer_receive - Function to update defer receive status.\n   * @param {function} options.parameters.updateMainHeightWidth - Function to update main height and width.\n   * @param {function} options.parameters.updateShareEnded - Function to update share ended status.\n   * @param {function} options.parameters.updateLock_screen - Function to update lock screen status.\n   * @param {function} options.parameters.updateFirstAll - Function to update first all status.\n   * @param {function} options.parameters.updateFirst_round - Function to update first round status.\n   * @param {function} options.parameters.reorderStreams - Function to reorder streams.\n   * @param {function} options.parameters.prepopulateUserMedia - Function to prepopulate user media.\n   * @param {function} options.parameters.getVideos - Function to get videos.\n   * @param {function} options.parameters.rePort - Function to report.\n   *\n   * @returns {Promise<void>} A promise that resolves when the operation is complete.\n   *\n   * @example\n   * const options = {\n   *   producerId: '12345',\n   *   kind: 'video',\n   *   parameters: {\n   *     getUpdatedAllParams: () => { /* Logic to get updated parameters *\\/ },\n   *     allAudioStreams: [],\n   *     allVideoStreams: [],\n   *     activeNames: ['Participant1', 'Participant2'],\n   *     participants: [],\n   *     streamNames: [],\n   *     recordingDisplayType: 'video',\n   *     recordingVideoOptimized: true,\n   *     adminIDStream: 'admin123',\n   *     newLimitedStreams: [],\n   *     newLimitedStreamsIDs: [],\n   *     oldAllStreams: [],\n   *     shareScreenStarted: false,\n   *     shared: false,\n   *     meetingDisplayType: 'media',\n   *     defer_receive: false,\n   *     lock_screen: false,\n   *     firstAll: false,\n   *     first_round: false,\n   *     gotAllVids: false,\n   *     eventType: 'conference',\n   *     hostLabel: 'Host',\n   *     shareEnded: false,\n   *     updateMainWindow: false,\n   *     updateActiveNames: (names) => { /* Logic to update active names *\\/ },\n   *     updateAllAudioStreams: (streams) => { /* Logic to update audio streams *\\/ },\n   *     updateShareScreenStarted: (status) => { /* Logic to update share screen status *\\/ },\n   *     updateUpdateMainWindow: (status) => { /* Logic to update main window status *\\/ },\n   *     updateNewLimitedStreams: (streams) => { /* Logic to update new limited streams *\\/ },\n   *     updateOldAllStreams: (streams) => { /* Logic to update old streams *\\/ },\n   *     updateDefer_receive: (status) => { /* Logic to update defer receive status *\\/ },\n   *     updateMainHeightWidth: (size) => { /* Logic to update main height and width *\\/ },\n   *     updateShareEnded: (status) => { /* Logic to update share ended status *\\/ },\n   *     updateLock_screen: (status) => { /* Logic to update lock screen status *\\/ },\n   *     updateFirstAll: (status) => { /* Logic to update first all status *\\/ },\n   *     updateFirst_round: (status) => { /* Logic to update first round status *\\/ },\n   *     reorderStreams: async () => { /* Logic to reorder streams *\\/ },\n   *     prepopulateUserMedia: async () => { /* Logic to prepopulate user media *\\/ },\n   *     getVideos: async () => { /* Logic to get videos *\\/ },\n   *     rePort: async () => { /* Logic to report *\\/ },\n   *   },\n   * };\n   *\n   * await closeAndResizeService.closeAndResize(options);\n   * // The operation will adjust the video and audio elements as per the given parameters.\n   */\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class CloseAndResize {\n  /**\n   * Closes and resizes the video and audio elements based on the provided options.\n   *\n   * @param {CloseAndResizeOptions} options - The options for closing and resizing.\n   * @param {string} options.producerId - The ID of the producer.\n   * @param {string} options.kind - The kind of media (audio, video, screenshare, or screen).\n   * @param {object} options.parameters - The parameters for the operation.\n   * @param {function} options.parameters.getUpdatedAllParams - Function to get updated parameters.\n   * @param {Array} options.parameters.allAudioStreams - Array of all audio streams.\n   * @param {Array} options.parameters.allVideoStreams - Array of all video streams.\n   * @param {Array} options.parameters.activeNames - Array of active participant names.\n   * @param {Array} options.parameters.participants - Array of participants.\n   * @param {Array} options.parameters.streamNames - Array of stream names.\n   * @param {string} options.parameters.recordingDisplayType - Type of recording display.\n   * @param {boolean} options.parameters.recordingVideoOptimized - Whether recording is video optimized.\n   * @param {string} options.parameters.adminIDStream - ID of the admin stream.\n   * @param {Array} options.parameters.newLimitedStreams - Array of new limited streams.\n   * @param {Array} options.parameters.newLimitedStreamsIDs - Array of new limited stream IDs.\n   * @param {Array} options.parameters.oldAllStreams - Array of old all streams.\n   * @param {boolean} options.parameters.shareScreenStarted - Whether screen sharing has started.\n   * @param {boolean} options.parameters.shared - Whether sharing is active.\n   * @param {string} options.parameters.meetingDisplayType - Type of meeting display.\n   * @param {boolean} options.parameters.defer_receive - Whether to defer receiving.\n   * @param {boolean} options.parameters.lock_screen - Whether the screen is locked.\n   * @param {boolean} options.parameters.firstAll - Whether it is the first all.\n   * @param {boolean} options.parameters.first_round - Whether it is the first round.\n   * @param {boolean} options.parameters.gotAllVids - Whether all videos are received.\n   * @param {string} options.parameters.eventType - Type of event.\n   * @param {string} options.parameters.hostLabel - Label of the host.\n   * @param {boolean} options.parameters.shareEnded - Whether sharing has ended.\n   * @param {boolean} options.parameters.updateMainWindow - Whether to update the main window.\n   * @param {function} options.parameters.updateActiveNames - Function to update active names.\n   * @param {function} options.parameters.updateAllAudioStreams - Function to update all audio streams.\n   * @param {function} options.parameters.updateAllVideoStreams - Function to update all video streams.\n   * @param {function} options.parameters.updateShareScreenStarted - Function to update share screen started status.\n   * @param {function} options.parameters.updateUpdateMainWindow - Function to update main window status.\n   * @param {function} options.parameters.updateNewLimitedStreams - Function to update new limited streams.\n   * @param {function} options.parameters.updateOldAllStreams - Function to update old all streams.\n   * @param {function} options.parameters.updateDefer_receive - Function to update defer receive status.\n   * @param {function} options.parameters.updateMainHeightWidth - Function to update main height and width.\n   * @param {function} options.parameters.updateShareEnded - Function to update share ended status.\n   * @param {function} options.parameters.updateLock_screen - Function to update lock screen status.\n   * @param {function} options.parameters.updateFirstAll - Function to update first all status.\n   * @param {function} options.parameters.updateFirst_round - Function to update first round status.\n   * @param {function} options.parameters.reorderStreams - Function to reorder streams.\n   * @param {function} options.parameters.prepopulateUserMedia - Function to prepopulate user media.\n   * @param {function} options.parameters.getVideos - Function to get videos.\n   * @param {function} options.parameters.rePort - Function to report.\n   *\n   * @returns {Promise<void>} A promise that resolves when the operation is complete.\n   */\n\n  closeAndResize = async ({\n    producerId,\n    kind,\n    parameters,\n  }: CloseAndResizeOptions): Promise<void> => {\n    let { getUpdatedAllParams } = parameters;\n    parameters = getUpdatedAllParams();\n\n    let {\n      allAudioStreams,\n      allVideoStreams,\n      activeNames,\n      participants,\n      streamNames,\n      recordingDisplayType,\n      recordingVideoOptimized,\n      adminIDStream,\n      newLimitedStreams,\n      newLimitedStreamsIDs,\n      oldAllStreams,\n      shareScreenStarted,\n      shared,\n      meetingDisplayType,\n      defer_receive,\n      lock_screen,\n      firstAll,\n      first_round,\n      gotAllVids,\n      eventType,\n\n      hostLabel,\n      shareEnded,\n      updateMainWindow,\n      updateActiveNames,\n      updateAllAudioStreams,\n      updateAllVideoStreams,\n\n      updateShareScreenStarted,\n      updateUpdateMainWindow,\n      updateNewLimitedStreams,\n      updateOldAllStreams,\n      updateDefer_receive,\n      updateMainHeightWidth,\n      updateShareEnded,\n      updateLock_screen,\n      updateFirstAll,\n      updateFirst_round,\n\n      //mediasfu functions\n      reorderStreams,\n      prepopulateUserMedia,\n      getVideos,\n      rePort,\n    } = parameters;\n\n    //function to close and resize the video and audio elements\n\n    let participant: Participant | undefined;\n\n    if (kind === 'audio') {\n      //stop the audio by removing the miniAudio with id = producerId\n\n      //remove the audio from the allAudioStreams array\n      allAudioStreams = allAudioStreams.filter(function (audioStream) {\n        return audioStream.producerId !== producerId;\n      });\n\n      updateAllAudioStreams(allAudioStreams);\n\n      if (recordingDisplayType == 'video' && recordingVideoOptimized == true) {\n        // do nothing\n      } else {\n        //get the name of the participant with the producerId\n        participant = participants.find((obj) => obj.audioID === producerId);\n\n        if (participant) {\n          //check if the participants videoID is not null or \"\"\n          if (participant.videoID !== null && participant.videoID !== '') {\n            // do nothing\n          } else {\n            //remove the participant from the activeNames array\n            activeNames = activeNames.filter(function (name) {\n              return name !== participant?.name;\n            });\n            updateActiveNames(activeNames);\n          }\n        }\n      }\n\n      let checker = false;\n      let alt_checker = false;\n\n      if (meetingDisplayType == 'video' && participant) {\n        checker =\n          participant[0].videoID != null &&\n          participant[0].videoID != '' &&\n          participant[0].videoID != undefined;\n      } else {\n        checker = true;\n        alt_checker = true;\n      }\n\n      if (checker) {\n        if (shareScreenStarted || shared) {\n          if (!alt_checker) {\n            await reorderStreams({ parameters });\n          }\n        } else {\n          if (alt_checker && meetingDisplayType != 'video') {\n            await reorderStreams({ add: false, screenChanged: true, parameters });\n          }\n        }\n      }\n    } else if (kind === 'video') {\n      //update the video elements by removing the miniVideo with id = producerId\n      //remove the video from the allVideoStreams array\n\n      //check if producerId == adminidstream\n      if (producerId == adminIDStream) {\n        updateMainWindow = true;\n        updateUpdateMainWindow(updateMainWindow);\n      }\n\n      try {\n        allVideoStreams = allVideoStreams.filter(function (videoStream) {\n          return videoStream.producerId !== producerId;\n        });\n\n        updateAllVideoStreams(allVideoStreams);\n\n        try {\n          //try remove it from oldVideoStreams\n          oldAllStreams = oldAllStreams.filter(function (videoStream) {\n            return videoStream.producerId !== producerId;\n          });\n\n          updateOldAllStreams(oldAllStreams);\n        } catch {\n          /* handle error */\n        }\n\n        try {\n          //try remove it from newLimitedStreams\n          newLimitedStreams = newLimitedStreams.filter(function (videoStream) {\n            return videoStream.producerId !== producerId;\n          });\n\n          updateNewLimitedStreams(newLimitedStreams);\n        } catch {\n          /* handle error */\n        }\n      } catch (error) {\n        try {\n          //try remove it from oldVideoStreams\n          oldAllStreams = oldAllStreams.filter(function (videoStream) {\n            return videoStream.producerId !== producerId;\n          });\n          updateOldAllStreams(oldAllStreams);\n        } catch {\n          /* handle error */\n        }\n      }\n\n      try {\n        //remove the participant from activeNames\n        activeNames = activeNames.filter(function (name) {\n          //get the participant with the producerId\n          let participant = streamNames.find((obj) => obj.producerId === producerId);\n\n          return name !== (participant?.name ?? '');\n        });\n\n        updateActiveNames(activeNames);\n      } catch {\n        /* handle error */\n      }\n\n      if (lock_screen) {\n        defer_receive = true;\n        // check if the video is the one being displayed (i.e. (newLimitedStreamsIDs))\n        if (newLimitedStreamsIDs.includes(producerId)) {\n          await prepopulateUserMedia({ name: hostLabel, parameters });\n          await reorderStreams({ add: false, screenChanged: true, parameters });\n        }\n      } else {\n        await prepopulateUserMedia({ name: hostLabel, parameters });\n        await reorderStreams({ add: false, screenChanged: true, parameters });\n      }\n    } else if (kind === 'screenshare' || kind === 'screen') {\n      //update the video elements by removing the mainVideo with id = producerId\n      updateMainWindow = true;\n\n      //screenshare stuff\n      shareScreenStarted = false;\n      shareEnded = true;\n\n      lock_screen = false;\n      firstAll = false;\n      first_round = false;\n\n      updateUpdateMainWindow(updateMainWindow);\n      updateShareScreenStarted(shareScreenStarted);\n      updateShareEnded(shareEnded);\n      updateLock_screen(lock_screen);\n      updateFirstAll(firstAll);\n      updateFirst_round(first_round);\n\n      if (!gotAllVids || defer_receive) {\n        defer_receive = false;\n        updateDefer_receive(defer_receive);\n        await getVideos({\n          participants,\n          allVideoStreams,\n          oldAllStreams,\n          updateAllVideoStreams,\n          updateOldAllStreams,\n        });\n        await rePort({ parameters });\n      }\n\n      if (eventType == 'conference') {\n        updateMainHeightWidth(0);\n      }\n\n      await prepopulateUserMedia({ name: hostLabel, parameters });\n      await reorderStreams({ add: false, screenChanged: true, parameters });\n    }\n  };\n}\n"]}

package/dist/esm2022/lib/consumers/compare-active-names.service.mjs

@@ -1,5 +1,36 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Compares the current active names with the previous active names and triggers an action if there are changes.
+ *
+ * @param {CompareActiveNamesOptions} options - The options for comparing active names.
+ * @param {boolean} [options.restart=false] - Whether to restart the comparison.
+ * @param {CompareActiveNamesParameters} options.parameters - The parameters for the comparison.
+ * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+ * @param {string[]} options.parameters.activeNames - The current active names.
+ * @param {string[]} options.parameters.prevActiveNames - The previous active names.
+ * @param {Function} options.parameters.updatePrevActiveNames - Function to update the previous active names.
+ * @param {Function} options.parameters.trigger - Function to trigger an action when names change.
+ *
+ * @returns {Promise<void>} A promise that resolves when the comparison is complete.
+ *
+ * @throws Will log an error message if an error occurs during the comparison.
+ *
+ * @example
+ * const options = {
+ *   restart: false,
+ *   parameters: {
+ *     getUpdatedAllParams: () => { /* Logic to get updated parameters *\/ },
+ *     activeNames: ['Alice', 'Bob'],
+ *     prevActiveNames: ['Alice', 'Charlie'],
+ *     updatePrevActiveNames: (names) => { /* Logic to update previous active names *\/ },
+ *     trigger: async (data) => { /* Logic to handle the trigger *\/ },
+ *   },
+ * };
+ *
+ * await compareActiveNamesService.compareActiveNames(options);
+ * // If 'Bob' is not in the previous active names, it will trigger the action.
+ */
 export class CompareActiveNames {
     /**
      * Compares the current active names with the previous active names and triggers an action if there are changes.
@@ -72,4 +103,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":"compare-active-names.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/compare-active-names.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAuBzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAKL,MAAM,OAAO,kBAAkB;IAC7B;;;;;;;;;;;;;;;OAeG;IACH,KAAK,CAAC,kBAAkB,CAAC,EACvB,OAAO,GAAG,KAAK,EACf,UAAU,GACgB;QAC1B,IAAI,CAAC;YACH,IAAI,EAAE,mBAAmB,EAAE,GAAG,UAAU,CAAC;YACzC,UAAU,GAAG,mBAAmB,EAAE,CAAC;YAEnC,IAAI,EAAE,WAAW,EAAE,eAAe,EAAE,qBAAqB,EAAE,OAAO,EAAE,GAAG,UAAU,CAAC;YAElF,mCAAmC;YACnC,IAAI,OAAO,EAAE,CAAC;gBACZ,MAAM,OAAO,CAAC,EAAE,eAAe,EAAE,WAAW,EAAE,UAAU,EAAE,CAAC,CAAC;gBAC5D,OAAO;YACT,CAAC;YAED,wCAAwC;YACxC,IAAI,WAAW,GAAG,EAAE,CAAC;YAErB,mCAAmC;YACnC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,WAAW,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC5C,MAAM,WAAW,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC;gBAEnC,kDAAkD;gBAClD,MAAM,cAAc,GAAG,CAAC,eAAe,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;gBAE9D,IAAI,cAAc,EAAE,CAAC;oBACnB,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;oBACvB,OAAO,CAAC,EAAE,eAAe,EAAE,WAAW,EAAE,UAAU,EAAE,CAAC,CAAC;oBACtD,MAAM;gBACR,CAAC;YACH,CAAC;YAED,0CAA0C;YAC1C,IAAI,KAAK,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,KAAK,IAAI,CAAC,CAAC,MAAM,CAAC;YAEjE,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;gBACd,yCAAyC;gBACzC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,eAAe,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;oBAChD,MAAM,WAAW,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC;oBAEvC,8CAA8C;oBAC9C,MAAM,cAAc,GAAG,CAAC,WAAW,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;oBAE1D,mCAAmC;oBACnC,IAAI,cAAc,EAAE,CAAC;wBACnB,OAAO,CAAC,EAAE,eAAe,EAAE,WAAW,EAAE,UAAU,EAAE,CAAC,CAAC;wBACtD,MAAM;oBACR,CAAC;gBACH,CAAC;YACH,CAAC;YAED,kDAAkD;YAClD,eAAe,GAAG,CAAC,GAAG,WAAW,CAAC,CAAC;YACnC,qBAAqB,CAAC,eAAe,CAAC,CAAC;QACzC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,GAAG,CAAC,0BAA0B,EAAE,KAAK,CAAC,CAAC;QACjD,CAAC;IACH,CAAC;uGA3EU,kBAAkB;2GAAlB,kBAAkB,cAFjB,MAAM;;2FAEP,kBAAkB;kBAH9B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { TriggerType, TriggerParameters } from '../@types/types';\n\nexport interface CompareActiveNamesParameters extends TriggerParameters {\n  activeNames: string[];\n  prevActiveNames: string[];\n  updateActiveNames: (activeNames: string[]) => void;\n  updatePrevActiveNames: (prevActiveNames: string[]) => void;\n\n  // mediasfu functions\n  trigger: TriggerType;\n  getUpdatedAllParams: () => CompareActiveNamesParameters;\n  [key: string]: any;\n}\n\nexport interface CompareActiveNamesOptions {\n  restart?: boolean;\n  parameters: CompareActiveNamesParameters;\n}\n\n// Export the type definition for the function\nexport type CompareActiveNamesType = (options: CompareActiveNamesOptions) => Promise<void>;\n\n  /**\n   * Compares the current active names with the previous active names and triggers an action if there are changes.\n   *\n   * @param {CompareActiveNamesOptions} options - The options for comparing active names.\n   * @param {boolean} [options.restart=false] - Whether to restart the comparison.\n   * @param {CompareActiveNamesParameters} options.parameters - The parameters for the comparison.\n   * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.\n   * @param {string[]} options.parameters.activeNames - The current active names.\n   * @param {string[]} options.parameters.prevActiveNames - The previous active names.\n   * @param {Function} options.parameters.updatePrevActiveNames - Function to update the previous active names.\n   * @param {Function} options.parameters.trigger - Function to trigger an action when names change.\n   *\n   * @returns {Promise<void>} A promise that resolves when the comparison is complete.\n   *\n   * @throws Will log an error message if an error occurs during the comparison.\n   *\n   * @example\n   * const options = {\n   *   restart: false,\n   *   parameters: {\n   *     getUpdatedAllParams: () => { /* Logic to get updated parameters *\\/ },\n   *     activeNames: ['Alice', 'Bob'],\n   *     prevActiveNames: ['Alice', 'Charlie'],\n   *     updatePrevActiveNames: (names) => { /* Logic to update previous active names *\\/ },\n   *     trigger: async (data) => { /* Logic to handle the trigger *\\/ },\n   *   },\n   * };\n   *\n   * await compareActiveNamesService.compareActiveNames(options);\n   * // If 'Bob' is not in the previous active names, it will trigger the action.\n   */\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class CompareActiveNames {\n  /**\n   * Compares the current active names with the previous active names and triggers an action if there are changes.\n   *\n   * @param {Object} options - The options for comparing active names.\n   * @param {boolean} [options.restart=false] - Whether to restart the comparison.\n   * @param {CompareActiveNamesOptions} options.parameters - The parameters for the comparison.\n   * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.\n   * @param {string[]} options.parameters.activeNames - The current active names.\n   * @param {string[]} options.parameters.prevActiveNames - The previous active names.\n   * @param {Function} options.parameters.updatePrevActiveNames - Function to update the previous active names.\n   * @param {Function} options.parameters.trigger - Function to trigger an action when names change.\n   *\n   * @returns {Promise<void>} A promise that resolves when the comparison is complete.\n   *\n   * @throws Will log an error message if an error occurs during the comparison.\n   */\n  async compareActiveNames({\n    restart = false,\n    parameters,\n  }: CompareActiveNamesOptions): Promise<void> {\n    try {\n      let { getUpdatedAllParams } = parameters;\n      parameters = getUpdatedAllParams();\n\n      let { activeNames, prevActiveNames, updatePrevActiveNames, trigger } = parameters;\n\n      // Restart the comparison if needed\n      if (restart) {\n        await trigger({ ref_ActiveNames: activeNames, parameters });\n        return;\n      }\n\n      // Array to track changes in activeNames\n      let nameChanged = [];\n\n      // Compare each name in activeNames\n      for (let i = 0; i < activeNames.length; i++) {\n        const currentName = activeNames[i];\n\n        // Check if the name is present in prevActiveNames\n        const hasNameChanged = !prevActiveNames.includes(currentName);\n\n        if (hasNameChanged) {\n          nameChanged.push(true);\n          trigger({ ref_ActiveNames: activeNames, parameters });\n          break;\n        }\n      }\n\n      // Count the number of true in nameChanged\n      let count = nameChanged.filter((value) => value === true).length;\n\n      if (count < 1) {\n        // Check for new names in prevActiveNames\n        for (let i = 0; i < prevActiveNames.length; i++) {\n          const currentName = prevActiveNames[i];\n\n          // Check if the name is present in activeNames\n          const hasNameChanged = !activeNames.includes(currentName);\n\n          // Signal change if the name is new\n          if (hasNameChanged) {\n            trigger({ ref_ActiveNames: activeNames, parameters });\n            break;\n          }\n        }\n      }\n\n      // Update prevActiveNames with current activeNames\n      prevActiveNames = [...activeNames];\n      updatePrevActiveNames(prevActiveNames);\n    } catch (error) {\n      console.log('compareActiveNames error', error);\n    }\n  }\n}\n"]}

package/dist/esm2022/lib/consumers/compare-screen-states.service.mjs

@@ -1,5 +1,40 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+   * Compares the current screen states with the previous screen states and triggers actions based on changes.
+   *
+   * @param {CompareScreenStatesOptions} options - The options for comparing screen states.
+   * @param {boolean} [options.restart=false] - Whether to restart the comparison process.
+   * @param {CompareScreenStatesParameters} options.parameters - The parameters for the comparison.
+   * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+   * @param {string} options.parameters.recordingDisplayType - The type of display being recorded.
+   * @param {boolean} options.parameters.recordingVideoOptimized - Whether the recording is optimized for video.
+   * @param {ScreenState[]} options.parameters.screenStates - The current screen states.
+   * @param {ScreenState[]} options.parameters.prevScreenStates - The previous screen states.
+   * @param {string[]} options.parameters.activeNames - The active names in the current context.
+   * @param {Function} options.parameters.trigger - Function to trigger actions based on changes.
+   *
+   * @returns {Promise<void>} A promise that resolves when the comparison and any triggered actions are complete.
+   *
+   * @throws Will log an error message if an error occurs during the comparison process.
+   *
+   * @example
+   * const options = {
+   *   restart: false,
+   *   parameters: {
+   *     getUpdatedAllParams: () => { /* Logic to get updated parameters *\/ },
+   *     recordingDisplayType: 'video',
+   *     recordingVideoOptimized: true,
+   *     screenStates: [{ state: 'active' }, { state: 'inactive' }],
+   *     prevScreenStates: [{ state: 'inactive' }, { state: 'active' }],
+   *     activeNames: ['Alice', 'Bob'],
+   *     trigger: async (data) => { /* Logic to handle the trigger *\/ },
+   *   },
+   * };
+   *
+   * await compareScreenStatesService.compareScreenStates(options);
+   * // If any screen state has changed, the trigger function will be called accordingly.
+   */
 export class CompareScreenStates {
     /**
      * Compares the current screen states with the previous screen states and triggers actions based on changes.
@@ -60,4 +95,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":"compare-screen-states.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/compare-screen-states.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAyB3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAkCK;AAML,MAAM,OAAO,mBAAmB;IAC9B;;;;;;;;;;;;;;;;;OAiBG;IACH,KAAK,CAAC,mBAAmB,CAAC,EACxB,OAAO,GAAG,KAAK,EACf,UAAU,GACiB;QAC3B,IAAI,CAAC;YACH,IAAI,EAAE,mBAAmB,EAAE,GAAG,UAAU,CAAC;YACzC,UAAU,GAAG,mBAAmB,EAAE,CAAC;YAEnC,IAAI,EACF,oBAAoB,EACpB,uBAAuB,EACvB,YAAY,EACZ,gBAAgB,EAChB,WAAW,EACX,OAAO,GACR,GAAG,UAAU,CAAC;YAEf,mCAAmC;YACnC,IAAI,OAAO,EAAE,CAAC;gBACZ,uCAAuC;gBACvC,OAAO;YACT,CAAC;YAED,0DAA0D;YAC1D,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC7C,MAAM,kBAAkB,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC;gBAC3C,MAAM,eAAe,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAAC;gBAE5C,iCAAiC;gBACjC,MAAM,UAAU,GAAI,MAAM,CAAC,IAAI,CAAC,kBAAkB,CAA2B,CAAC,IAAI,CAChF,CAAC,GAAG,EAAE,EAAE,CAAC,kBAAkB,CAAC,GAAG,CAAC,KAAK,eAAe,CAAC,GAAG,CAAC,CAC1D,CAAC;gBAEF,yCAAyC;gBACzC,IAAI,UAAU,EAAE,CAAC;oBACf,wDAAwD;oBACxD,IAAI,oBAAoB,KAAK,OAAO,IAAI,uBAAuB,EAAE,CAAC;wBAChE,MAAM,OAAO,CAAC,EAAE,eAAe,EAAE,WAAW,EAAE,UAAU,EAAE,CAAC,CAAC;wBAC5D,MAAM;oBACR,CAAC;oBACD,MAAM,OAAO,CAAC,EAAE,eAAe,EAAE,WAAW,EAAE,UAAU,EAAE,CAAC,CAAC;oBAC5D,MAAM;gBACR,CAAC;YACH,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,GAAG,CAAC,2BAA2B,EAAE,KAAK,CAAC,CAAC;QAClD,CAAC;IACH,CAAC;uGAlEU,mBAAmB;2GAAnB,mBAAmB,cAFlB,MAAM;;2FAEP,mBAAmB;kBAH/B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\n\nimport { ScreenState, TriggerType, TriggerParameters } from '../@types/types';\n\nexport interface CompareScreenStatesParameters extends TriggerParameters {\n  recordingDisplayType: 'video' | 'media' | 'all';\n  recordingVideoOptimized: boolean;\n  screenStates: ScreenState[];\n  prevScreenStates: ScreenState[];\n  activeNames: string[];\n\n  // mediasfu functions\n  trigger: TriggerType;\n  getUpdatedAllParams: () => CompareScreenStatesParameters;\n  [key: string]: any;\n}\n\nexport interface CompareScreenStatesOptions {\n  restart?: boolean;\n  parameters: CompareScreenStatesParameters;\n}\n\n// Export the type definition for the function\nexport type CompareScreenStatesType = (options: CompareScreenStatesOptions) => Promise<void>;\n\n/**\n   * Compares the current screen states with the previous screen states and triggers actions based on changes.\n   *\n   * @param {CompareScreenStatesOptions} options - The options for comparing screen states.\n   * @param {boolean} [options.restart=false] - Whether to restart the comparison process.\n   * @param {CompareScreenStatesParameters} options.parameters - The parameters for the comparison.\n   * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.\n   * @param {string} options.parameters.recordingDisplayType - The type of display being recorded.\n   * @param {boolean} options.parameters.recordingVideoOptimized - Whether the recording is optimized for video.\n   * @param {ScreenState[]} options.parameters.screenStates - The current screen states.\n   * @param {ScreenState[]} options.parameters.prevScreenStates - The previous screen states.\n   * @param {string[]} options.parameters.activeNames - The active names in the current context.\n   * @param {Function} options.parameters.trigger - Function to trigger actions based on changes.\n   *\n   * @returns {Promise<void>} A promise that resolves when the comparison and any triggered actions are complete.\n   *\n   * @throws Will log an error message if an error occurs during the comparison process.\n   *\n   * @example\n   * const options = {\n   *   restart: false,\n   *   parameters: {\n   *     getUpdatedAllParams: () => { /* Logic to get updated parameters *\\/ },\n   *     recordingDisplayType: 'video',\n   *     recordingVideoOptimized: true,\n   *     screenStates: [{ state: 'active' }, { state: 'inactive' }],\n   *     prevScreenStates: [{ state: 'inactive' }, { state: 'active' }],\n   *     activeNames: ['Alice', 'Bob'],\n   *     trigger: async (data) => { /* Logic to handle the trigger *\\/ },\n   *   },\n   * };\n   *\n   * await compareScreenStatesService.compareScreenStates(options);\n   * // If any screen state has changed, the trigger function will be called accordingly.\n   */\n\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class CompareScreenStates {\n  /**\n   * Compares the current screen states with the previous screen states and triggers actions based on changes.\n   *\n   * @param {Object} options - The options for comparing screen states.\n   * @param {boolean} [options.restart=false] - Whether to restart the comparison process.\n   * @param {CompareScreenStatesOptions} options.parameters - The parameters for the comparison.\n   * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.\n   * @param {string} options.parameters.recordingDisplayType - The type of display being recorded.\n   * @param {boolean} options.parameters.recordingVideoOptimized - Whether the recording is optimized for video.\n   * @param {Array<ScreenState>} options.parameters.screenStates - The current screen states.\n   * @param {Array<ScreenState>} options.parameters.prevScreenStates - The previous screen states.\n   * @param {Array<string>} options.parameters.activeNames - The active names in the current context.\n   * @param {Function} options.parameters.trigger - Function to trigger actions based on changes.\n   *\n   * @returns {Promise<void>} A promise that resolves when the comparison and any triggered actions are complete.\n   *\n   * @throws Will log an error message if an error occurs during the comparison process.\n   */\n  async compareScreenStates({\n    restart = false,\n    parameters,\n  }: CompareScreenStatesOptions): Promise<void> {\n    try {\n      let { getUpdatedAllParams } = parameters;\n      parameters = getUpdatedAllParams();\n\n      let {\n        recordingDisplayType,\n        recordingVideoOptimized,\n        screenStates,\n        prevScreenStates,\n        activeNames,\n        trigger,\n      } = parameters;\n\n      // Restart the comparison if needed\n      if (restart) {\n        // Perform necessary actions on restart\n        return;\n      }\n\n      // Compare each key-value pair in the screenStates objects\n      for (let i = 0; i < screenStates.length; i++) {\n        const currentScreenState = screenStates[i];\n        const prevScreenState = prevScreenStates[i];\n\n        // Check if any value has changed\n        const hasChanged = (Object.keys(currentScreenState) as (keyof ScreenState)[]).some(\n          (key) => currentScreenState[key] !== prevScreenState[key],\n        );\n\n        // Signal change if any value has changed\n        if (hasChanged) {\n          // Perform actions or trigger events based on the change\n          if (recordingDisplayType === 'video' && recordingVideoOptimized) {\n            await trigger({ ref_ActiveNames: activeNames, parameters });\n            break;\n          }\n          await trigger({ ref_ActiveNames: activeNames, parameters });\n          break;\n        }\n      }\n    } catch (error) {\n      console.log('compareScreenStates error', error);\n    }\n  }\n}\n"]}