mediasfu-angular 1.0.0

package/dist/esm2022/lib/components/display-components/pagination/pagination.component.mjs

@@ -0,0 +1,328 @@
+import { Component, Input } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { FontAwesomeModule } from '@fortawesome/angular-fontawesome';
+import { faStar, faLock } from '@fortawesome/free-solid-svg-icons';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../consumers/generate-page-content.service";
+import * as i2 from "@angular/common";
+import * as i3 from "@fortawesome/angular-fontawesome";
+/**
+ * Pagination component for displaying and handling pagination controls.
+ *
+ * @component
+ * @selector app-pagination
+ * @standalone true
+ * @imports [CommonModule, FontAwesomeModule]
+ *
+ * @description
+ * This component renders pagination controls with customizable styles and behavior.
+ * It supports horizontal and vertical layouts, different positions, and dynamic data.
+ *
+ * @example
+ * <app-pagination
+ *   [totalPages]="10"
+ *   [currentUserPage]="1"
+ *   [handlePageChange]="handlePageChange"
+ *   [position]="'middle'"
+ *   [location]="'bottom'"
+ *   [direction]="'horizontal'"
+ *   [backgroundColor]="'#ffffff'"
+ *   [paginationHeight]="40"
+ *   [showAspect]="true"
+ *   [parameters]="paginationParameters">
+ * </app-pagination>
+ *
+ * @input {number} totalPages - Total number of pages.
+ * @input {number} currentUserPage - Current active page.
+ * @input {Function} handlePageChange - Function to handle page change.
+ * @input {'left' | 'middle' | 'right' | string} position - Position of the pagination controls.
+ * @input {'top' | 'middle' | 'bottom' | string} location - Location of the pagination controls.
+ * @input {'horizontal' | 'vertical' | string} direction - Direction of the pagination controls.
+ * @input {any} buttonsContainerStyle - Custom styles for the buttons container.
+ * @input {any} activePageStyle - Custom styles for the active page button.
+ * @input {any} inactivePageStyle - Custom styles for the inactive page buttons.
+ * @input {string} backgroundColor - Background color of the pagination controls.
+ * @input {number} paginationHeight - Height of the pagination controls.
+ * @input {boolean} showAspect - Flag to show or hide the pagination controls.
+ * @input {PaginationParameters} parameters - Additional parameters for pagination.
+ *
+ * @method ngOnInit - Initializes the component and sets up initial data.
+ * @method ngOnChanges - Handles changes to input properties and updates data accordingly.
+ * @method handleClick - Handles click events on pagination buttons and performs necessary actions.
+ * @method getPageStyle - Returns the style for a given page button based on its state.
+ * @method isBreakoutRoom - Determines if a given item represents a breakout room.
+ * @method getDisplayItem - Returns the display text for a given item.
+ */
+export class Pagination {
+    generatePageContentService;
+    totalPages = 0;
+    currentUserPage = 0;
+    handlePageChange;
+    position = 'middle';
+    location = 'middle';
+    direction = 'horizontal';
+    buttonsContainerStyle = {};
+    activePageStyle = { backgroundColor: '#2c678f' };
+    inactivePageStyle = {};
+    backgroundColor = '#ffffff';
+    paginationHeight = 40;
+    showAspect = true;
+    parameters = {};
+    constructor(generatePageContentService) {
+        this.generatePageContentService = generatePageContentService;
+    }
+    faStar = faStar;
+    faLock = faLock;
+    data = [];
+    ngOnInit() {
+        this.data = Array.from({ length: this.totalPages + 1 }, (_, index) => index);
+        this.componentSizes = this.parameters.componentSizes;
+        if (!this.handlePageChange) {
+            this.handlePageChange = this.generatePageContentService.generatePageContent.bind(this.generatePageContentService);
+        }
+    }
+    ngOnChanges(changes) {
+        if (changes['totalPages'] || changes['currentUserPage']) {
+            this.data = Array.from({ length: this.totalPages + 1 }, (_, index) => index);
+        }
+    }
+    handleClick = async (page) => {
+        if (page == this.currentUserPage) {
+            return;
+        }
+        this.parameters = this.parameters.getUpdatedAllParams();
+        const params = { ...this.parameters };
+        this.componentSizes = params.componentSizes;
+        if (this.parameters.breakOutRoomStarted && !this.parameters.breakOutRoomEnded && page !== 0) {
+            const roomMember = this.parameters.breakoutRooms.find((r) => r.find((p) => p.name == this.parameters.member));
+            const pageInt = page - this.parameters.mainRoomsLength;
+            let memberBreakRoom = -1;
+            if (roomMember) {
+                memberBreakRoom = this.parameters.breakoutRooms.indexOf(roomMember);
+            }
+            if ((memberBreakRoom == -1 || memberBreakRoom !== pageInt) && pageInt >= 0) {
+                if (this.parameters.islevel !== '2') {
+                    if (this.parameters.showAlert) {
+                        this.parameters.showAlert({
+                            message: `You are not part of the breakout room ${pageInt + 1}.`,
+                            type: 'danger',
+                        });
+                    }
+                    return;
+                }
+                await this.handlePageChange({
+                    page,
+                    parameters: params,
+                    breakRoom: pageInt,
+                    inBreakRoom: true,
+                });
+                if (this.parameters.hostNewRoom !== pageInt) {
+                    this.parameters.socket.emit('updateHostBreakout', {
+                        newRoom: pageInt,
+                        roomName: this.parameters.roomName,
+                    });
+                }
+            }
+            else {
+                await this.handlePageChange({
+                    page,
+                    parameters: params,
+                    breakRoom: pageInt,
+                    inBreakRoom: pageInt >= 0,
+                });
+                if (this.parameters.islevel == '2' && this.parameters.hostNewRoom !== -1) {
+                    this.parameters.socket.emit('updateHostBreakout', {
+                        prevRoom: this.parameters.hostNewRoom,
+                        newRoom: -1,
+                        roomName: this.parameters.roomName,
+                    });
+                }
+            }
+        }
+        else {
+            await this.handlePageChange({ page, parameters: params, breakRoom: 0, inBreakRoom: false });
+            if (this.parameters.islevel == '2' && this.parameters.hostNewRoom !== -1) {
+                this.parameters.socket.emit('updateHostBreakout', {
+                    prevRoom: this.parameters.hostNewRoom,
+                    newRoom: -1,
+                    roomName: this.parameters.roomName,
+                });
+            }
+        }
+    };
+    componentSizes = {};
+    getPageStyle(item) {
+        return item == this.currentUserPage ? this.activePageStyle : this.inactivePageStyle;
+    }
+    isBreakoutRoom = (item) => {
+        this.parameters = this.parameters.getUpdatedAllParams();
+        return (this.parameters.breakOutRoomStarted &&
+            !this.parameters.breakOutRoomEnded &&
+            item >= this.parameters.mainRoomsLength);
+    };
+    getDisplayItem(item) {
+        const roomNumber = item - (this.parameters.mainRoomsLength - 1);
+        if (this.isBreakoutRoom(item)) {
+            if (this.parameters.memberRoom + 1 !== roomNumber) {
+                return `Room ${roomNumber}`;
+            }
+            else {
+                return `Room ${roomNumber}`;
+            }
+        }
+        return item.toString();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: Pagination, deps: [{ token: i1.GeneratePageContent }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.8", type: Pagination, isStandalone: true, selector: "app-pagination", inputs: { totalPages: "totalPages", currentUserPage: "currentUserPage", handlePageChange: "handlePageChange", position: "position", location: "location", direction: "direction", buttonsContainerStyle: "buttonsContainerStyle", activePageStyle: "activePageStyle", inactivePageStyle: "inactivePageStyle", backgroundColor: "backgroundColor", paginationHeight: "paginationHeight", showAspect: "showAspect", parameters: "parameters" }, usesOnChanges: true, ngImport: i0, template: `
+    <div
+      [ngStyle]="{
+        'background-color': backgroundColor,
+        'justify-content': position == 'middle' ? 'space-evenly' : position == 'left' ? 'flex-start' : 'flex-end',
+        'align-items': location == 'middle' ? 'center' : location == 'top' ? 'flex-start' : 'flex-end',
+        'padding': '0',
+        'margin': '0',
+        'min-height': direction == 'horizontal' ? paginationHeight + 'px' : componentSizes.otherHeight + 'px',
+        'min-width': direction == 'horizontal' ? componentSizes.otherWidth + 'px' : paginationHeight + 'px',
+        'width': direction == 'horizontal' ? '100%' : paginationHeight + 'px',
+        'height': direction == 'horizontal' ? paginationHeight + 'px' : '100%',
+        'display': showAspect ? 'flex' : 'none',
+        'max-height': direction == 'horizontal' ? paginationHeight + 'px' : '100%',
+        'max-width': direction == 'horizontal' ? '100%' : paginationHeight + 'px',
+        'flex-direction': direction == 'vertical' ? 'column' : 'row',
+        'overflow-x': 'auto',
+      }"
+    >
+      <ng-container *ngFor="let item of data; let index = index">
+        <button
+          *ngIf="item == 0"
+          [ngClass]="{ active: item == currentUserPage }"
+          [ngStyle]="getPageStyle(item)"
+          (click)="handleClick(item)"
+        >
+          <fa-icon
+            [icon]="faStar"
+            size="lg"
+            [style.color]="item == currentUserPage ? 'yellow' : 'gray'"
+          ></fa-icon>
+        </button>
+        <button
+          *ngIf="item !== 0"
+          [ngClass]="{ active: item == currentUserPage }"
+          [ngStyle]="getPageStyle(item)"
+          (click)="handleClick(item)"
+        >
+          <span
+            *ngIf="!isBreakoutRoom(item)"
+            class="pageText"
+            [ngStyle]="{ color: item == currentUserPage ? '#ffffff' : '#000000' }"
+            >{{ item }}</span
+          >
+          <span
+            *ngIf="isBreakoutRoom(item)"
+            class="pageText"
+            [ngStyle]="{ color: item == currentUserPage ? '#ffffff' : '#000000' }"
+            >{{ getDisplayItem(item) }}
+            <fa-icon
+              *ngIf="
+                parameters.memberRoom + 1 !== item - (parameters.mainRoomsLength - 1) &&
+                parameters.islevel !== '2'
+              "
+              [icon]="faLock"
+            ></fa-icon
+          ></span>
+        </button>
+      </ng-container>
+    </div>
+  `, isInline: true, styles: [".pageButton.active{background-color:#2c678f}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i2.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "ngmodule", type: FontAwesomeModule }, { kind: "component", type: i3.FaIconComponent, selector: "fa-icon", inputs: ["icon", "title", "animation", "mask", "flip", "size", "pull", "border", "inverse", "symbol", "rotate", "fixedWidth", "transform", "a11yRole"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: Pagination, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-pagination', standalone: true, imports: [CommonModule, FontAwesomeModule], template: `
+    <div
+      [ngStyle]="{
+        'background-color': backgroundColor,
+        'justify-content': position == 'middle' ? 'space-evenly' : position == 'left' ? 'flex-start' : 'flex-end',
+        'align-items': location == 'middle' ? 'center' : location == 'top' ? 'flex-start' : 'flex-end',
+        'padding': '0',
+        'margin': '0',
+        'min-height': direction == 'horizontal' ? paginationHeight + 'px' : componentSizes.otherHeight + 'px',
+        'min-width': direction == 'horizontal' ? componentSizes.otherWidth + 'px' : paginationHeight + 'px',
+        'width': direction == 'horizontal' ? '100%' : paginationHeight + 'px',
+        'height': direction == 'horizontal' ? paginationHeight + 'px' : '100%',
+        'display': showAspect ? 'flex' : 'none',
+        'max-height': direction == 'horizontal' ? paginationHeight + 'px' : '100%',
+        'max-width': direction == 'horizontal' ? '100%' : paginationHeight + 'px',
+        'flex-direction': direction == 'vertical' ? 'column' : 'row',
+        'overflow-x': 'auto',
+      }"
+    >
+      <ng-container *ngFor="let item of data; let index = index">
+        <button
+          *ngIf="item == 0"
+          [ngClass]="{ active: item == currentUserPage }"
+          [ngStyle]="getPageStyle(item)"
+          (click)="handleClick(item)"
+        >
+          <fa-icon
+            [icon]="faStar"
+            size="lg"
+            [style.color]="item == currentUserPage ? 'yellow' : 'gray'"
+          ></fa-icon>
+        </button>
+        <button
+          *ngIf="item !== 0"
+          [ngClass]="{ active: item == currentUserPage }"
+          [ngStyle]="getPageStyle(item)"
+          (click)="handleClick(item)"
+        >
+          <span
+            *ngIf="!isBreakoutRoom(item)"
+            class="pageText"
+            [ngStyle]="{ color: item == currentUserPage ? '#ffffff' : '#000000' }"
+            >{{ item }}</span
+          >
+          <span
+            *ngIf="isBreakoutRoom(item)"
+            class="pageText"
+            [ngStyle]="{ color: item == currentUserPage ? '#ffffff' : '#000000' }"
+            >{{ getDisplayItem(item) }}
+            <fa-icon
+              *ngIf="
+                parameters.memberRoom + 1 !== item - (parameters.mainRoomsLength - 1) &&
+                parameters.islevel !== '2'
+              "
+              [icon]="faLock"
+            ></fa-icon
+          ></span>
+        </button>
+      </ng-container>
+    </div>
+  `, styles: [".pageButton.active{background-color:#2c678f}\n"] }]
+        }], ctorParameters: () => [{ type: i1.GeneratePageContent }], propDecorators: { totalPages: [{
+                type: Input
+            }], currentUserPage: [{
+                type: Input
+            }], handlePageChange: [{
+                type: Input
+            }], position: [{
+                type: Input
+            }], location: [{
+                type: Input
+            }], direction: [{
+                type: Input
+            }], buttonsContainerStyle: [{
+                type: Input
+            }], activePageStyle: [{
+                type: Input
+            }], inactivePageStyle: [{
+                type: Input
+            }], backgroundColor: [{
+                type: Input
+            }], paginationHeight: [{
+                type: Input
+            }], showAspect: [{
+                type: Input
+            }], parameters: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pagination.component.js","sourceRoot":"","sources":["../../../../../../../projects/mediasfu-angular/src/lib/components/display-components/pagination/pagination.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, OnInit, OnChanges, SimpleChanges } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { FontAwesomeModule } from '@fortawesome/angular-fontawesome';\nimport { faStar, faLock } from '@fortawesome/free-solid-svg-icons';\nimport {\n  GeneratePageContent,\n  GeneratePageContentParameters,\n} from '../../../consumers/generate-page-content.service';\nimport { Socket } from 'socket.io-client';\nimport { BreakoutParticipant, ComponentSizes, ShowAlert } from '../../../@types/types';\n\nexport interface PaginationParameters extends GeneratePageContentParameters {\n  mainRoomsLength: number;\n  memberRoom: number;\n  breakOutRoomStarted: boolean;\n  breakOutRoomEnded: boolean;\n  member: string;\n  breakoutRooms: BreakoutParticipant[][];\n  hostNewRoom: number;\n  roomName: string;\n  islevel: string;\n  showAlert?: ShowAlert;\n  socket: Socket;\n\n  // mediasfu functions\n  getUpdatedAllParams: () => PaginationParameters;\n  [key: string]: any;\n}\n\nexport interface PaginationOptions {\n  totalPages: number;\n  currentUserPage: number;\n  handlePageChange: (options: any) => Promise<void>;\n  position: 'left' | 'middle' | 'right' | string;\n  location: 'top' | 'middle' | 'bottom' | string;\n  direction: 'horizontal' | 'vertical';\n  buttonsContainerStyle: any;\n  activePageStyle: any;\n  inactivePageStyle: any;\n  backgroundColor: string;\n  paginationHeight: number;\n  showAspect?: boolean;\n  parameters: PaginationParameters;\n}\n\nexport type PaginationType = (options: PaginationOptions) => HTMLElement;\n\n/**\n * Pagination component for displaying and handling pagination controls.\n *\n * @component\n * @selector app-pagination\n * @standalone true\n * @imports [CommonModule, FontAwesomeModule]\n *\n * @description\n * This component renders pagination controls with customizable styles and behavior.\n * It supports horizontal and vertical layouts, different positions, and dynamic data.\n *\n * @example\n * <app-pagination\n *   [totalPages]=\"10\"\n *   [currentUserPage]=\"1\"\n *   [handlePageChange]=\"handlePageChange\"\n *   [position]=\"'middle'\"\n *   [location]=\"'bottom'\"\n *   [direction]=\"'horizontal'\"\n *   [backgroundColor]=\"'#ffffff'\"\n *   [paginationHeight]=\"40\"\n *   [showAspect]=\"true\"\n *   [parameters]=\"paginationParameters\">\n * </app-pagination>\n *\n * @input {number} totalPages - Total number of pages.\n * @input {number} currentUserPage - Current active page.\n * @input {Function} handlePageChange - Function to handle page change.\n * @input {'left' | 'middle' | 'right' | string} position - Position of the pagination controls.\n * @input {'top' | 'middle' | 'bottom' | string} location - Location of the pagination controls.\n * @input {'horizontal' | 'vertical' | string} direction - Direction of the pagination controls.\n * @input {any} buttonsContainerStyle - Custom styles for the buttons container.\n * @input {any} activePageStyle - Custom styles for the active page button.\n * @input {any} inactivePageStyle - Custom styles for the inactive page buttons.\n * @input {string} backgroundColor - Background color of the pagination controls.\n * @input {number} paginationHeight - Height of the pagination controls.\n * @input {boolean} showAspect - Flag to show or hide the pagination controls.\n * @input {PaginationParameters} parameters - Additional parameters for pagination.\n *\n * @method ngOnInit - Initializes the component and sets up initial data.\n * @method ngOnChanges - Handles changes to input properties and updates data accordingly.\n * @method handleClick - Handles click events on pagination buttons and performs necessary actions.\n * @method getPageStyle - Returns the style for a given page button based on its state.\n * @method isBreakoutRoom - Determines if a given item represents a breakout room.\n * @method getDisplayItem - Returns the display text for a given item.\n */\n@Component({\n  selector: 'app-pagination',\n  standalone: true,\n  imports: [CommonModule, FontAwesomeModule],\n  template: `\n    <div\n      [ngStyle]=\"{\n        'background-color': backgroundColor,\n        'justify-content': position == 'middle' ? 'space-evenly' : position == 'left' ? 'flex-start' : 'flex-end',\n        'align-items': location == 'middle' ? 'center' : location == 'top' ? 'flex-start' : 'flex-end',\n        'padding': '0',\n        'margin': '0',\n        'min-height': direction == 'horizontal' ? paginationHeight + 'px' : componentSizes.otherHeight + 'px',\n        'min-width': direction == 'horizontal' ? componentSizes.otherWidth + 'px' : paginationHeight + 'px',\n        'width': direction == 'horizontal' ? '100%' : paginationHeight + 'px',\n        'height': direction == 'horizontal' ? paginationHeight + 'px' : '100%',\n        'display': showAspect ? 'flex' : 'none',\n        'max-height': direction == 'horizontal' ? paginationHeight + 'px' : '100%',\n        'max-width': direction == 'horizontal' ? '100%' : paginationHeight + 'px',\n        'flex-direction': direction == 'vertical' ? 'column' : 'row',\n        'overflow-x': 'auto',\n      }\"\n    >\n      <ng-container *ngFor=\"let item of data; let index = index\">\n        <button\n          *ngIf=\"item == 0\"\n          [ngClass]=\"{ active: item == currentUserPage }\"\n          [ngStyle]=\"getPageStyle(item)\"\n          (click)=\"handleClick(item)\"\n        >\n          <fa-icon\n            [icon]=\"faStar\"\n            size=\"lg\"\n            [style.color]=\"item == currentUserPage ? 'yellow' : 'gray'\"\n          ></fa-icon>\n        </button>\n        <button\n          *ngIf=\"item !== 0\"\n          [ngClass]=\"{ active: item == currentUserPage }\"\n          [ngStyle]=\"getPageStyle(item)\"\n          (click)=\"handleClick(item)\"\n        >\n          <span\n            *ngIf=\"!isBreakoutRoom(item)\"\n            class=\"pageText\"\n            [ngStyle]=\"{ color: item == currentUserPage ? '#ffffff' : '#000000' }\"\n            >{{ item }}</span\n          >\n          <span\n            *ngIf=\"isBreakoutRoom(item)\"\n            class=\"pageText\"\n            [ngStyle]=\"{ color: item == currentUserPage ? '#ffffff' : '#000000' }\"\n            >{{ getDisplayItem(item) }}\n            <fa-icon\n              *ngIf=\"\n                parameters.memberRoom + 1 !== item - (parameters.mainRoomsLength - 1) &&\n                parameters.islevel !== '2'\n              \"\n              [icon]=\"faLock\"\n            ></fa-icon\n          ></span>\n        </button>\n      </ng-container>\n    </div>\n  `,\n  styles: [\n    `\n      .pageButton.active {\n        background-color: #2c678f;\n      }\n    `,\n  ],\n})\nexport class Pagination implements OnInit, OnChanges {\n  @Input() totalPages = 0;\n  @Input() currentUserPage = 0;\n  @Input() handlePageChange!: (options: any) => Promise<void>;\n  @Input() position: 'left' | 'middle' | 'right' | string = 'middle';\n  @Input() location: 'top' | 'middle' | 'bottom' | string = 'middle';\n  @Input() direction: 'horizontal' | 'vertical' = 'horizontal';\n  @Input() buttonsContainerStyle: any = {};\n  @Input() activePageStyle: any = { backgroundColor: '#2c678f' };\n  @Input() inactivePageStyle: any = {};\n  @Input() backgroundColor = '#ffffff';\n  @Input() paginationHeight = 40;\n  @Input() showAspect = true;\n  @Input() parameters: PaginationParameters = {} as PaginationParameters;\n\n  constructor(private generatePageContentService: GeneratePageContent) {}\n\n  faStar = faStar;\n  faLock = faLock;\n\n  data: number[] = [];\n\n  ngOnInit() {\n    this.data = Array.from({ length: this.totalPages + 1 }, (_, index) => index);\n    this.componentSizes = this.parameters.componentSizes;\n    if (!this.handlePageChange) {\n      this.handlePageChange = this.generatePageContentService.generatePageContent.bind(\n        this.generatePageContentService,\n      );\n    }\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    if (changes['totalPages'] || changes['currentUserPage']) {\n      this.data = Array.from({ length: this.totalPages + 1 }, (_, index) => index);\n    }\n  }\n\n  handleClick = async (page: number): Promise<void> => {\n    if (page == this.currentUserPage) {\n      return;\n    }\n\n    this.parameters = this.parameters.getUpdatedAllParams();\n    const params = { ...this.parameters };\n    this.componentSizes = params.componentSizes;\n\n    if (this.parameters.breakOutRoomStarted && !this.parameters.breakOutRoomEnded && page !== 0) {\n      const roomMember = this.parameters.breakoutRooms.find((r: any[]) =>\n        r.find((p) => p.name == this.parameters.member),\n      );\n      const pageInt = page - this.parameters.mainRoomsLength;\n      let memberBreakRoom = -1;\n      if (roomMember) {\n        memberBreakRoom = this.parameters.breakoutRooms.indexOf(roomMember);\n      }\n\n      if ((memberBreakRoom == -1 || memberBreakRoom !== pageInt) && pageInt >= 0) {\n        if (this.parameters.islevel !== '2') {\n          if (this.parameters.showAlert) {\n            this.parameters.showAlert({\n              message: `You are not part of the breakout room ${pageInt + 1}.`,\n              type: 'danger',\n            });\n          }\n          return;\n        }\n\n        await this.handlePageChange({\n          page,\n          parameters: params,\n          breakRoom: pageInt,\n          inBreakRoom: true,\n        });\n        if (this.parameters.hostNewRoom !== pageInt) {\n          this.parameters.socket.emit('updateHostBreakout', {\n            newRoom: pageInt,\n            roomName: this.parameters.roomName,\n          });\n        }\n      } else {\n        await this.handlePageChange({\n          page,\n          parameters: params,\n          breakRoom: pageInt,\n          inBreakRoom: pageInt >= 0,\n        });\n        if (this.parameters.islevel == '2' && this.parameters.hostNewRoom !== -1) {\n          this.parameters.socket.emit('updateHostBreakout', {\n            prevRoom: this.parameters.hostNewRoom,\n            newRoom: -1,\n            roomName: this.parameters.roomName,\n          });\n        }\n      }\n    } else {\n      await this.handlePageChange({ page, parameters: params, breakRoom: 0, inBreakRoom: false });\n      if (this.parameters.islevel == '2' && this.parameters.hostNewRoom !== -1) {\n        this.parameters.socket.emit('updateHostBreakout', {\n          prevRoom: this.parameters.hostNewRoom,\n          newRoom: -1,\n          roomName: this.parameters.roomName,\n        });\n      }\n    }\n  };\n\n  componentSizes: ComponentSizes = {} as ComponentSizes;\n\n  getPageStyle(item: number) {\n    return item == this.currentUserPage ? this.activePageStyle : this.inactivePageStyle;\n  }\n\n  isBreakoutRoom = (item: number): boolean => {\n    this.parameters = this.parameters.getUpdatedAllParams();\n    return (\n      this.parameters.breakOutRoomStarted &&\n      !this.parameters.breakOutRoomEnded &&\n      item >= this.parameters.mainRoomsLength\n    );\n  };\n\n  getDisplayItem(item: number) {\n    const roomNumber = item - (this.parameters.mainRoomsLength - 1);\n\n    if (this.isBreakoutRoom(item)) {\n      if (this.parameters.memberRoom + 1 !== roomNumber) {\n        return `Room ${roomNumber}`;\n      } else {\n        return `Room ${roomNumber}`;\n      }\n    }\n\n    return item.toString();\n  }\n}\n"]}

package/dist/esm2022/lib/components/display-components/sub-aspect-component/sub-aspect-component.component.mjs

@@ -0,0 +1,118 @@
+import { Component, Input } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+/**
+ * @fileoverview SubAspectComponent is an Angular component that displays a sub-aspect of a media element.
+ * It adjusts its size and visibility based on input properties and window events.
+ *
+ * @component
+ * @selector app-sub-aspect-component
+ * @standalone true
+ * @imports CommonModule
+ *
+ * @template
+ * <div *ngIf="showControls" [ngStyle]="{ position: 'absolute', bottom: '0', margin: '0', backgroundColor: backgroundColor, height: aspectStyles.height + 'px', width: aspectStyles.width + 'px' }">
+ *   <ng-content></ng-content>
+ * </div>
+ *
+ * @styles []
+ *
+ * @class SubAspectComponent
+ * @implements OnInit, OnDestroy, OnChanges
+ *
+ * @property {string} backgroundColor - The background color of the component. Default is 'transparent'.
+ * @property {boolean} showControls - Determines whether the controls are shown. Default is true.
+ * @property {number} containerWidthFraction - The fraction of the container's width. Default is 1.
+ * @property {number} containerHeightFraction - The fraction of the container's height. Default is 1.
+ * @property {number} defaultFractionSub - The default fraction for the sub-aspect. Default is 0.0.
+ * @property {object} aspectStyles - The styles for the aspect, including height and width.
+ * @property {number} aspectStyles.height - The height of the aspect.
+ * @property {number} aspectStyles.width - The width of the aspect.
+ * @property {number} subAspectFraction - The fraction of the sub-aspect.
+ *
+ * @method ngOnInit - Lifecycle hook that is called after data-bound properties are initialized. Adds event listeners for window resize and orientation change.
+ * @method ngOnChanges - Lifecycle hook that is called when any data-bound property changes. Updates aspect styles if relevant properties change.
+ * @method ngOnDestroy - Lifecycle hook that is called just before the component is destroyed. Removes event listeners for window resize and orientation change.
+ * @method updateAspectStyles - Updates the aspect styles based on the current window size and input properties.
+ */
+export class SubAspectComponent {
+    backgroundColor = 'transparent';
+    showControls = true;
+    containerWidthFraction = 1;
+    containerHeightFraction = 1;
+    defaultFractionSub = 0.0;
+    aspectStyles = {
+        height: 0,
+        width: 0,
+    };
+    ngOnInit() {
+        this.updateAspectStyles();
+        window.addEventListener('resize', this.updateAspectStyles.bind(this));
+        window.addEventListener('orientationchange', this.updateAspectStyles.bind(this));
+    }
+    ngOnChanges(changes) {
+        if (changes['showControls'] ||
+            changes['containerWidthFraction'] ||
+            changes['containerHeightFraction'] ||
+            changes['defaultFractionSub']) {
+            this.updateAspectStyles();
+        }
+    }
+    ngOnDestroy() {
+        window.removeEventListener('resize', this.updateAspectStyles.bind(this));
+        window.removeEventListener('orientationchange', this.updateAspectStyles.bind(this));
+    }
+    updateAspectStyles() {
+        const windowWidth = window.innerWidth;
+        this.aspectStyles = {
+            height: this.showControls ? 40 : 0,
+            width: this.containerWidthFraction ? this.containerWidthFraction * windowWidth : windowWidth,
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: SubAspectComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.8", type: SubAspectComponent, isStandalone: true, selector: "app-sub-aspect-component", inputs: { backgroundColor: "backgroundColor", showControls: "showControls", containerWidthFraction: "containerWidthFraction", containerHeightFraction: "containerHeightFraction", defaultFractionSub: "defaultFractionSub" }, usesOnChanges: true, ngImport: i0, template: `
+    <div
+      *ngIf="showControls"
+      [ngStyle]="{
+        position: 'absolute',
+        bottom: '0',
+        margin: '0',
+        backgroundColor: backgroundColor,
+        height: aspectStyles.height + 'px',
+        width: aspectStyles.width + 'px'
+      }"
+    >
+      <ng-content></ng-content>
+    </div>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: SubAspectComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-sub-aspect-component', standalone: true, imports: [CommonModule], template: `
+    <div
+      *ngIf="showControls"
+      [ngStyle]="{
+        position: 'absolute',
+        bottom: '0',
+        margin: '0',
+        backgroundColor: backgroundColor,
+        height: aspectStyles.height + 'px',
+        width: aspectStyles.width + 'px'
+      }"
+    >
+      <ng-content></ng-content>
+    </div>
+  ` }]
+        }], propDecorators: { backgroundColor: [{
+                type: Input
+            }], showControls: [{
+                type: Input
+            }], containerWidthFraction: [{
+                type: Input
+            }], containerHeightFraction: [{
+                type: Input
+            }], defaultFractionSub: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sub-aspect-component.component.js","sourceRoot":"","sources":["../../../../../../../projects/mediasfu-angular/src/lib/components/display-components/sub-aspect-component/sub-aspect-component.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,EAA+C,MAAM,eAAe,CAAC;AAC9F,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;;;AAY/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAsBH,MAAM,OAAO,kBAAkB;IACpB,eAAe,GAAG,aAAa,CAAC;IAChC,YAAY,GAAG,IAAI,CAAC;IACpB,sBAAsB,GAAG,CAAC,CAAC;IAC3B,uBAAuB,GAAG,CAAC,CAAC;IAC5B,kBAAkB,GAAG,GAAG,CAAC;IAElC,YAAY,GAAG;QACb,MAAM,EAAE,CAAC;QACT,KAAK,EAAE,CAAC;KACT,CAAC;IAEF,QAAQ;QACN,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAC1B,MAAM,CAAC,gBAAgB,CAAC,QAAQ,EAAE,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;QACtE,MAAM,CAAC,gBAAgB,CAAC,mBAAmB,EAAE,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;IACnF,CAAC;IAED,WAAW,CAAC,OAAsB;QAChC,IACE,OAAO,CAAC,cAAc,CAAC;YACvB,OAAO,CAAC,wBAAwB,CAAC;YACjC,OAAO,CAAC,yBAAyB,CAAC;YAClC,OAAO,CAAC,oBAAoB,CAAC,EAC7B,CAAC;YACD,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAC5B,CAAC;IACH,CAAC;IAED,WAAW;QACT,MAAM,CAAC,mBAAmB,CAAC,QAAQ,EAAE,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;QACzE,MAAM,CAAC,mBAAmB,CAAC,mBAAmB,EAAE,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;IACtF,CAAC;IAEO,kBAAkB;QACxB,MAAM,WAAW,GAAG,MAAM,CAAC,UAAU,CAAC;QAEtC,IAAI,CAAC,YAAY,GAAG;YAClB,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;YAClC,KAAK,EAAE,IAAI,CAAC,sBAAsB,CAAC,CAAC,CAAC,IAAI,CAAC,sBAAsB,GAAG,WAAW,CAAC,CAAC,CAAC,WAAW;SAC7F,CAAC;IACJ,CAAC;uGAzCU,kBAAkB;2FAAlB,kBAAkB,uUAjBnB;;;;;;;;;;;;;;GAcT,2DAfS,YAAY;;2FAkBX,kBAAkB;kBArB9B,SAAS;+BACE,0BAA0B,cACxB,IAAI,WACP,CAAC,YAAY,CAAC,YACb;;;;;;;;;;;;;;GAcT;8BAIQ,eAAe;sBAAvB,KAAK;gBACG,YAAY;sBAApB,KAAK;gBACG,sBAAsB;sBAA9B,KAAK;gBACG,uBAAuB;sBAA/B,KAAK;gBACG,kBAAkB;sBAA1B,KAAK","sourcesContent":["import { Component, Input, OnInit, OnDestroy, OnChanges, SimpleChanges } from '@angular/core';\nimport { CommonModule } from '@angular/common';\n\nexport interface SubAspectComponentOptions {\n  backgroundColor?: string;\n  showControls?: boolean;\n  containerWidthFraction?: number;\n  containerHeightFraction?: number;\n  defaultFractionSub?: number;\n}\n\nexport type SubAspectComponentType = (options: SubAspectComponentOptions) => HTMLElement;\n\n/**\n * @fileoverview SubAspectComponent is an Angular component that displays a sub-aspect of a media element.\n * It adjusts its size and visibility based on input properties and window events.\n *\n * @component\n * @selector app-sub-aspect-component\n * @standalone true\n * @imports CommonModule\n *\n * @template\n * <div *ngIf=\"showControls\" [ngStyle]=\"{ position: 'absolute', bottom: '0', margin: '0', backgroundColor: backgroundColor, height: aspectStyles.height + 'px', width: aspectStyles.width + 'px' }\">\n *   <ng-content></ng-content>\n * </div>\n *\n * @styles []\n *\n * @class SubAspectComponent\n * @implements OnInit, OnDestroy, OnChanges\n *\n * @property {string} backgroundColor - The background color of the component. Default is 'transparent'.\n * @property {boolean} showControls - Determines whether the controls are shown. Default is true.\n * @property {number} containerWidthFraction - The fraction of the container's width. Default is 1.\n * @property {number} containerHeightFraction - The fraction of the container's height. Default is 1.\n * @property {number} defaultFractionSub - The default fraction for the sub-aspect. Default is 0.0.\n * @property {object} aspectStyles - The styles for the aspect, including height and width.\n * @property {number} aspectStyles.height - The height of the aspect.\n * @property {number} aspectStyles.width - The width of the aspect.\n * @property {number} subAspectFraction - The fraction of the sub-aspect.\n *\n * @method ngOnInit - Lifecycle hook that is called after data-bound properties are initialized. Adds event listeners for window resize and orientation change.\n * @method ngOnChanges - Lifecycle hook that is called when any data-bound property changes. Updates aspect styles if relevant properties change.\n * @method ngOnDestroy - Lifecycle hook that is called just before the component is destroyed. Removes event listeners for window resize and orientation change.\n * @method updateAspectStyles - Updates the aspect styles based on the current window size and input properties.\n */\n@Component({\n  selector: 'app-sub-aspect-component',\n  standalone: true,\n  imports: [CommonModule],\n  template: `\n    <div\n      *ngIf=\"showControls\"\n      [ngStyle]=\"{\n        position: 'absolute',\n        bottom: '0',\n        margin: '0',\n        backgroundColor: backgroundColor,\n        height: aspectStyles.height + 'px',\n        width: aspectStyles.width + 'px'\n      }\"\n    >\n      <ng-content></ng-content>\n    </div>\n  `,\n  styles: [],\n})\nexport class SubAspectComponent implements OnInit, OnDestroy, OnChanges {\n  @Input() backgroundColor = 'transparent';\n  @Input() showControls = true;\n  @Input() containerWidthFraction = 1;\n  @Input() containerHeightFraction = 1;\n  @Input() defaultFractionSub = 0.0;\n\n  aspectStyles = {\n    height: 0,\n    width: 0,\n  };\n\n  ngOnInit() {\n    this.updateAspectStyles();\n    window.addEventListener('resize', this.updateAspectStyles.bind(this));\n    window.addEventListener('orientationchange', this.updateAspectStyles.bind(this));\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    if (\n      changes['showControls'] ||\n      changes['containerWidthFraction'] ||\n      changes['containerHeightFraction'] ||\n      changes['defaultFractionSub']\n    ) {\n      this.updateAspectStyles();\n    }\n  }\n\n  ngOnDestroy() {\n    window.removeEventListener('resize', this.updateAspectStyles.bind(this));\n    window.removeEventListener('orientationchange', this.updateAspectStyles.bind(this));\n  }\n\n  private updateAspectStyles() {\n    const windowWidth = window.innerWidth;\n\n    this.aspectStyles = {\n      height: this.showControls ? 40 : 0,\n      width: this.containerWidthFraction ? this.containerWidthFraction * windowWidth : windowWidth,\n    };\n  }\n}\n"]}