mediasfu-angular 1.0.0

package/dist/esm2022/lib/components/display-components/flexible-video/flexible-video.component.mjs

@@ -0,0 +1,265 @@
+import { Component, Input, Injector } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+/**
+ * Component for displaying a flexible video grid.
+ *
+ * @component
+ * @selector app-flexible-video
+ * @standalone true
+ * @imports CommonModule
+ *
+ * @template
+ * <div>
+ *   <!-- Dynamic styles and layout for video grid -->
+ *   <div *ngFor="let rowComponents of grid; let rowIndex = index">
+ *     <div *ngFor="let component of rowComponents; let colIndex = index">
+ *       <ng-container *ngComponentOutlet="component.component; injector: createInjector(component.inputs)"></ng-container>
+ *     </div>
+ *   </div>
+ *   <div *ngIf="Screenboard && Screenboard.component">
+ *     <ng-container *ngComponentOutlet="Screenboard.component; injector: createInjector(Screenboard.inputs)"></ng-container>
+ *   </div>
+ * </div>
+ *
+ * @class FlexibleVideo
+ * @implements OnInit, OnChanges
+ *
+ * @property {number} customWidth - Custom width for the video grid.
+ * @property {number} customHeight - Custom height for the video grid.
+ * @property {number} rows - Number of rows in the video grid.
+ * @property {number} columns - Number of columns in the video grid.
+ * @property {Array<{ component: ComponentType<any>, inputs: any }>} componentsToRender - Components to render in the grid.
+ * @property {boolean} showAspect - Flag to show or hide the aspect ratio.
+ * @property {string} [backgroundColor='transparent'] - Background color for the video grid.
+ * @property {{ component: ComponentType<any>, inputs: any }} [Screenboard] - Screenboard component to overlay on the grid.
+ * @property {boolean} [annotateScreenStream=false] - Flag to annotate the screen stream.
+ * @property {MediaStream} [localStreamScreen] - Local media stream for the screen.
+ *
+ * @property {number} key - Key for tracking changes.
+ * @property {number} cardWidth - Width of each card in the grid.
+ * @property {number} cardHeight - Height of each card in the grid.
+ * @property {number} cardTop - Top position of each card in the grid.
+ * @property {number} cardLeft - Left position of each card in the grid.
+ * @property {number} canvasLeft - Left position of the canvas.
+ * @property {any[][]} grid - Grid structure for the components.
+ *
+ * @constructor
+ * @param {Injector} injector - Angular injector for dependency injection.
+ *
+ * @method ngOnInit - Lifecycle hook that is called after data-bound properties are initialized.
+ * @method ngOnChanges - Lifecycle hook that is called when any data-bound property changes.
+ * @method generateGrid - Generates the grid structure based on rows and columns.
+ * @method createInjector - Creates an injector for the given inputs.
+ * @param {any} inputs - Inputs for the component.
+ * @returns {Injector} - The created injector.
+ */
+export class FlexibleVideo {
+    injector;
+    customWidth = 0;
+    customHeight = 0;
+    rows = 0;
+    columns = 0;
+    componentsToRender = [];
+    showAspect = false;
+    backgroundColor = 'transparent';
+    Screenboard;
+    annotateScreenStream = false;
+    localStreamScreen;
+    key = 0;
+    cardWidth = 0;
+    cardHeight = 0;
+    cardTop = 0;
+    cardLeft = 0;
+    canvasLeft = 0;
+    grid = [];
+    injectorCache = new WeakMap();
+    constructor(injector) {
+        this.injector = injector;
+    }
+    ngOnInit() {
+        if (this.showAspect) {
+            this.generateGrid();
+        }
+    }
+    ngOnChanges(changes) {
+        if (changes['columns'] ||
+            changes['rows'] ||
+            changes['componentsToRender'] ||
+            changes['customWidth'] ||
+            changes['customHeight']) {
+            if (this.showAspect) {
+                this.key++;
+                this.generateGrid();
+            }
+        }
+        if (this.annotateScreenStream && this.localStreamScreen) {
+            const videoHeight = this.localStreamScreen.getVideoTracks()[0].getSettings().height || 0;
+            const videoWidth = this.localStreamScreen.getVideoTracks()[0].getSettings().width || 0;
+            this.cardWidth = videoWidth;
+            this.cardHeight = videoHeight;
+            this.cardTop = Math.floor((this.customHeight - videoHeight) / 2);
+            this.cardLeft = Math.floor((this.customWidth - videoWidth) / 2);
+            this.canvasLeft = this.cardLeft < 0 ? this.cardLeft : 0;
+        }
+        else {
+            this.cardWidth = this.customWidth;
+            this.cardHeight = this.customHeight;
+            this.cardTop = 0;
+            this.cardLeft = 0;
+            this.canvasLeft = 0;
+        }
+    }
+    generateGrid() {
+        this.grid = [];
+        for (let row = 0; row < this.rows; row++) {
+            const rowComponents = [];
+            for (let col = 0; col < this.columns; col++) {
+                const index = row * this.columns + col;
+                const component = this.componentsToRender[index];
+                rowComponents.push(component);
+            }
+            this.grid.push(rowComponents);
+        }
+    }
+    createInjector(inputs) {
+        if (!this.injectorCache.has(inputs)) {
+            const injector = Injector.create({
+                providers: Object.keys(inputs).map((key) => ({ provide: key, useValue: inputs[key] })),
+                parent: this.injector,
+            });
+            this.injectorCache.set(inputs, injector);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        return this.injectorCache.get(inputs);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: FlexibleVideo, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.8", type: FlexibleVideo, isStandalone: true, selector: "app-flexible-video", inputs: { customWidth: "customWidth", customHeight: "customHeight", rows: "rows", columns: "columns", componentsToRender: "componentsToRender", showAspect: "showAspect", backgroundColor: "backgroundColor", Screenboard: "Screenboard", annotateScreenStream: "annotateScreenStream", localStreamScreen: "localStreamScreen" }, usesOnChanges: true, ngImport: i0, template: `
+    <div
+      style="padding: 0; flex: 1; margin: 0; position: relative; display: {{
+        showAspect ? 'flex' : 'none'
+      }};
+             max-width: {{ customWidth }}px; overflow-x: hidden; overflow-y: auto; left: {{
+        cardLeft > 0 ? cardLeft : 0
+      }}px;"
+    >
+      <div
+        *ngFor="let rowComponents of grid; let rowIndex = index"
+        style="display: flex; flex-direction: row;"
+      >
+        <div
+          *ngFor="let component of rowComponents; let colIndex = index"
+          [ngStyle]="{
+            flex: 1,
+            width: cardWidth + 'px',
+            height: cardHeight + 'px',
+            backgroundColor: backgroundColor,
+            margin: '1px',
+            padding: 0,
+            borderRadius: '0px',
+            left: cardLeft + 'px'
+          }"
+        >
+          <ng-container
+            *ngComponentOutlet="component.component; injector: createInjector(component.inputs)"
+          ></ng-container>
+        </div>
+      </div>
+      <div
+        *ngIf="Screenboard && Screenboard.component"
+        [ngStyle]="{
+          position: 'absolute',
+          top: '0',
+          left: canvasLeft + 'px',
+          width: cardWidth + 'px',
+          height: cardHeight + 'px',
+          backgroundColor: 'rgba(0, 0, 0, 0.005)',
+          zIndex: '2'
+        }"
+      >
+        <ng-container
+          *ngComponentOutlet="Screenboard.component; injector: createInjector(Screenboard.inputs)"
+        ></ng-container>
+      </div>
+    </div>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletContent", "ngComponentOutletNgModule", "ngComponentOutletNgModuleFactory"] }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { 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: FlexibleVideo, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'app-flexible-video',
+                    standalone: true,
+                    imports: [CommonModule],
+                    template: `
+    <div
+      style="padding: 0; flex: 1; margin: 0; position: relative; display: {{
+        showAspect ? 'flex' : 'none'
+      }};
+             max-width: {{ customWidth }}px; overflow-x: hidden; overflow-y: auto; left: {{
+        cardLeft > 0 ? cardLeft : 0
+      }}px;"
+    >
+      <div
+        *ngFor="let rowComponents of grid; let rowIndex = index"
+        style="display: flex; flex-direction: row;"
+      >
+        <div
+          *ngFor="let component of rowComponents; let colIndex = index"
+          [ngStyle]="{
+            flex: 1,
+            width: cardWidth + 'px',
+            height: cardHeight + 'px',
+            backgroundColor: backgroundColor,
+            margin: '1px',
+            padding: 0,
+            borderRadius: '0px',
+            left: cardLeft + 'px'
+          }"
+        >
+          <ng-container
+            *ngComponentOutlet="component.component; injector: createInjector(component.inputs)"
+          ></ng-container>
+        </div>
+      </div>
+      <div
+        *ngIf="Screenboard && Screenboard.component"
+        [ngStyle]="{
+          position: 'absolute',
+          top: '0',
+          left: canvasLeft + 'px',
+          width: cardWidth + 'px',
+          height: cardHeight + 'px',
+          backgroundColor: 'rgba(0, 0, 0, 0.005)',
+          zIndex: '2'
+        }"
+      >
+        <ng-container
+          *ngComponentOutlet="Screenboard.component; injector: createInjector(Screenboard.inputs)"
+        ></ng-container>
+      </div>
+    </div>
+  `,
+                }]
+        }], ctorParameters: () => [{ type: i0.Injector }], propDecorators: { customWidth: [{
+                type: Input
+            }], customHeight: [{
+                type: Input
+            }], rows: [{
+                type: Input
+            }], columns: [{
+                type: Input
+            }], componentsToRender: [{
+                type: Input
+            }], showAspect: [{
+                type: Input
+            }], backgroundColor: [{
+                type: Input
+            }], Screenboard: [{
+                type: Input
+            }], annotateScreenStream: [{
+                type: Input
+            }], localStreamScreen: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flexible-video.component.js","sourceRoot":"","sources":["../../../../../../../projects/mediasfu-angular/src/lib/components/display-components/flexible-video/flexible-video.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, OnChanges, OnInit, SimpleChanges, Injector } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { CustomMediaComponent } from '../../../@types/types';\nexport interface FlexibleVideoOptions {\n  customWidth: number;\n  customHeight: number;\n  rows: number;\n  columns: number;\n  componentsToRender: CustomMediaComponent[];\n  showAspect?: boolean;\n  backgroundColor?: string;\n  Screenboard?: CustomMediaComponent;\n  annotateScreenStream?: boolean;\n  localStreamScreen: MediaStream | null;\n}\n\nexport type FlexibleVideoType = (options: FlexibleVideoOptions) => HTMLElement;\n\n/**\n * Component for displaying a flexible video grid.\n *\n * @component\n * @selector app-flexible-video\n * @standalone true\n * @imports CommonModule\n *\n * @template\n * <div>\n *   <!-- Dynamic styles and layout for video grid -->\n *   <div *ngFor=\"let rowComponents of grid; let rowIndex = index\">\n *     <div *ngFor=\"let component of rowComponents; let colIndex = index\">\n *       <ng-container *ngComponentOutlet=\"component.component; injector: createInjector(component.inputs)\"></ng-container>\n *     </div>\n *   </div>\n *   <div *ngIf=\"Screenboard && Screenboard.component\">\n *     <ng-container *ngComponentOutlet=\"Screenboard.component; injector: createInjector(Screenboard.inputs)\"></ng-container>\n *   </div>\n * </div>\n *\n * @class FlexibleVideo\n * @implements OnInit, OnChanges\n *\n * @property {number} customWidth - Custom width for the video grid.\n * @property {number} customHeight - Custom height for the video grid.\n * @property {number} rows - Number of rows in the video grid.\n * @property {number} columns - Number of columns in the video grid.\n * @property {Array<{ component: ComponentType<any>, inputs: any }>} componentsToRender - Components to render in the grid.\n * @property {boolean} showAspect - Flag to show or hide the aspect ratio.\n * @property {string} [backgroundColor='transparent'] - Background color for the video grid.\n * @property {{ component: ComponentType<any>, inputs: any }} [Screenboard] - Screenboard component to overlay on the grid.\n * @property {boolean} [annotateScreenStream=false] - Flag to annotate the screen stream.\n * @property {MediaStream} [localStreamScreen] - Local media stream for the screen.\n *\n * @property {number} key - Key for tracking changes.\n * @property {number} cardWidth - Width of each card in the grid.\n * @property {number} cardHeight - Height of each card in the grid.\n * @property {number} cardTop - Top position of each card in the grid.\n * @property {number} cardLeft - Left position of each card in the grid.\n * @property {number} canvasLeft - Left position of the canvas.\n * @property {any[][]} grid - Grid structure for the components.\n *\n * @constructor\n * @param {Injector} injector - Angular injector for dependency injection.\n *\n * @method ngOnInit - Lifecycle hook that is called after data-bound properties are initialized.\n * @method ngOnChanges - Lifecycle hook that is called when any data-bound property changes.\n * @method generateGrid - Generates the grid structure based on rows and columns.\n * @method createInjector - Creates an injector for the given inputs.\n * @param {any} inputs - Inputs for the component.\n * @returns {Injector} - The created injector.\n */\n@Component({\n  selector: 'app-flexible-video',\n  standalone: true,\n  imports: [CommonModule],\n  template: `\n    <div\n      style=\"padding: 0; flex: 1; margin: 0; position: relative; display: {{\n        showAspect ? 'flex' : 'none'\n      }};\n             max-width: {{ customWidth }}px; overflow-x: hidden; overflow-y: auto; left: {{\n        cardLeft > 0 ? cardLeft : 0\n      }}px;\"\n    >\n      <div\n        *ngFor=\"let rowComponents of grid; let rowIndex = index\"\n        style=\"display: flex; flex-direction: row;\"\n      >\n        <div\n          *ngFor=\"let component of rowComponents; let colIndex = index\"\n          [ngStyle]=\"{\n            flex: 1,\n            width: cardWidth + 'px',\n            height: cardHeight + 'px',\n            backgroundColor: backgroundColor,\n            margin: '1px',\n            padding: 0,\n            borderRadius: '0px',\n            left: cardLeft + 'px'\n          }\"\n        >\n          <ng-container\n            *ngComponentOutlet=\"component.component; injector: createInjector(component.inputs)\"\n          ></ng-container>\n        </div>\n      </div>\n      <div\n        *ngIf=\"Screenboard && Screenboard.component\"\n        [ngStyle]=\"{\n          position: 'absolute',\n          top: '0',\n          left: canvasLeft + 'px',\n          width: cardWidth + 'px',\n          height: cardHeight + 'px',\n          backgroundColor: 'rgba(0, 0, 0, 0.005)',\n          zIndex: '2'\n        }\"\n      >\n        <ng-container\n          *ngComponentOutlet=\"Screenboard.component; injector: createInjector(Screenboard.inputs)\"\n        ></ng-container>\n      </div>\n    </div>\n  `,\n})\nexport class FlexibleVideo implements OnInit, OnChanges {\n  @Input() customWidth = 0;\n  @Input() customHeight = 0;\n  @Input() rows = 0;\n  @Input() columns = 0;\n  @Input() componentsToRender: CustomMediaComponent[] = [];\n  @Input() showAspect = false;\n  @Input() backgroundColor?: string = 'transparent';\n  @Input() Screenboard?: CustomMediaComponent;\n  @Input() annotateScreenStream?: boolean = false;\n  @Input() localStreamScreen?: MediaStream;\n\n  key = 0;\n  cardWidth = 0;\n  cardHeight = 0;\n  cardTop = 0;\n  cardLeft = 0;\n  canvasLeft = 0;\n  grid: any[][] = [];\n\n  private injectorCache = new WeakMap<any, Injector>();\n\n  constructor(private injector: Injector) {}\n\n  ngOnInit() {\n    if (this.showAspect) {\n      this.generateGrid();\n    }\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    if (\n      changes['columns'] ||\n      changes['rows'] ||\n      changes['componentsToRender'] ||\n      changes['customWidth'] ||\n      changes['customHeight']\n    ) {\n      if (this.showAspect) {\n        this.key++;\n        this.generateGrid();\n      }\n    }\n\n    if (this.annotateScreenStream && this.localStreamScreen) {\n      const videoHeight = this.localStreamScreen.getVideoTracks()[0].getSettings().height || 0;\n      const videoWidth = this.localStreamScreen.getVideoTracks()[0].getSettings().width || 0;\n      this.cardWidth = videoWidth;\n      this.cardHeight = videoHeight;\n      this.cardTop = Math.floor((this.customHeight - videoHeight) / 2);\n      this.cardLeft = Math.floor((this.customWidth - videoWidth) / 2);\n      this.canvasLeft = this.cardLeft < 0 ? this.cardLeft : 0;\n    } else {\n      this.cardWidth = this.customWidth;\n      this.cardHeight = this.customHeight;\n      this.cardTop = 0;\n      this.cardLeft = 0;\n      this.canvasLeft = 0;\n    }\n  }\n\n  generateGrid() {\n    this.grid = [];\n    for (let row = 0; row < this.rows; row++) {\n      const rowComponents = [];\n      for (let col = 0; col < this.columns; col++) {\n        const index = row * this.columns + col;\n        const component = this.componentsToRender[index];\n        rowComponents.push(component);\n      }\n      this.grid.push(rowComponents);\n    }\n  }\n\n  createInjector(inputs: any) {\n    if (!this.injectorCache.has(inputs)) {\n      const injector = Injector.create({\n        providers: Object.keys(inputs).map((key) => ({ provide: key, useValue: inputs[key] })),\n        parent: this.injector,\n      });\n      this.injectorCache.set(inputs, injector);\n    }\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    return this.injectorCache.get(inputs)!;\n  }\n}\n"]}

package/dist/esm2022/lib/components/display-components/loading-modal/loading-modal.component.mjs

@@ -0,0 +1,100 @@
+import { Component, Input } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+/**
+ * Component representing a loading modal.
+ *
+ * @selector app-loading-modal
+ * @standalone true
+ * @imports CommonModule
+ *
+ * @description
+ * This component displays a loading modal with a spinner and a loading text.
+ * It is designed to be displayed as an overlay with customizable background and text colors.
+ *
+ * @example
+ * <app-loading-modal [isVisible]="true" [backgroundColor]="'rgba(0, 0, 0, 0.5)'" [displayColor]="'white'"></app-loading-modal>
+ *
+ * @styles
+ * - .spinner: Styles for the loading spinner.
+ * - @keyframes spin: Keyframes for the spinner animation.
+ * - .modal-content: Styles for the modal content container.
+ * - .loading-text: Styles for the loading text.
+ *
+ * @inputs
+ * - `isVisible` (boolean): Determines if the modal is visible. Default is `false`.
+ * - `backgroundColor` (string): Background color of the modal. Default is `'rgba(0, 0, 0, 0.5)'`.
+ * - `displayColor` (string): Color of the loading text. Default is `'white'`.
+ *
+ * @properties
+ * - `modalContainerStyle` (object): Computed styles for the modal container.
+ * - `modalContentStyle` (object): Computed styles for the modal content.
+ * - `spinnerContainerStyle` (object): Computed styles for the spinner container.
+ * - `loadingTextStyle` (object): Computed styles for the loading text.
+ */
+export class LoadingModal {
+    isVisible = false;
+    backgroundColor = 'rgba(0, 0, 0, 0.5)';
+    displayColor = 'white';
+    get modalContainerStyle() {
+        return {
+            position: 'fixed',
+            top: '0',
+            left: '0',
+            width: '100%',
+            height: '100%',
+            backgroundColor: this.backgroundColor,
+            display: 'flex',
+            alignItems: 'center',
+            justifyContent: 'center',
+            zIndex: '999',
+        };
+    }
+    get modalContentStyle() {
+        return {
+            backgroundColor: this.backgroundColor,
+            borderRadius: '10px',
+            padding: '10px',
+            maxWidth: '200px',
+            textAlign: 'center',
+        };
+    }
+    get spinnerContainerStyle() {
+        return {
+            marginBottom: '20px',
+        };
+    }
+    get loadingTextStyle() {
+        return {
+            color: this.displayColor,
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: LoadingModal, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.8", type: LoadingModal, isStandalone: true, selector: "app-loading-modal", inputs: { isVisible: "isVisible", backgroundColor: "backgroundColor", displayColor: "displayColor" }, ngImport: i0, template: `
+    <div *ngIf="isVisible" [ngStyle]="modalContainerStyle">
+      <div [ngStyle]="modalContentStyle" class="modal-content">
+        <div class="spinner" [ngStyle]="spinnerContainerStyle"></div>
+        <div [ngStyle]="loadingTextStyle" class="loading-text">Loading...</div>
+      </div>
+    </div>
+  `, isInline: true, styles: [".spinner{border:12px solid #f3f3f3;border-top:12px solid black;border-radius:50%;width:50px;height:50px;animation:spin 2s linear infinite}@keyframes spin{0%{transform:rotate(0)}to{transform:rotate(360deg)}}.modal-content{display:flex;flex-direction:column;align-items:center}.loading-text{margin-top:10px}\n"], 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: LoadingModal, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-loading-modal', standalone: true, imports: [CommonModule], template: `
+    <div *ngIf="isVisible" [ngStyle]="modalContainerStyle">
+      <div [ngStyle]="modalContentStyle" class="modal-content">
+        <div class="spinner" [ngStyle]="spinnerContainerStyle"></div>
+        <div [ngStyle]="loadingTextStyle" class="loading-text">Loading...</div>
+      </div>
+    </div>
+  `, styles: [".spinner{border:12px solid #f3f3f3;border-top:12px solid black;border-radius:50%;width:50px;height:50px;animation:spin 2s linear infinite}@keyframes spin{0%{transform:rotate(0)}to{transform:rotate(360deg)}}.modal-content{display:flex;flex-direction:column;align-items:center}.loading-text{margin-top:10px}\n"] }]
+        }], propDecorators: { isVisible: [{
+                type: Input
+            }], backgroundColor: [{
+                type: Input
+            }], displayColor: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,132 @@
+import { Component, Input } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+/**
+ * MainAspectComponent is a standalone Angular component that adjusts its aspect ratio
+ * based on the window size and other input properties. It listens to window resize
+ * and orientation change events to dynamically update its styles.
+ *
+ * @selector app-main-aspect-component
+ * @standalone true
+ * @imports [CommonModule]
+ *
+ * @template
+ * ```html
+ * <div [ngStyle]="aspectStyles" [style.backgroundColor]="backgroundColor" class="aspect-container">
+ *   <ng-content></ng-content>
+ * </div>
+ * ```
+ *
+ * @styles
+ * ```css
+ * .aspect-container {
+ *   overflow: hidden;
+ * }
+ * ```
+ *
+ * @class MainAspectComponent
+ * @implements OnInit, OnDestroy, OnChanges
+ *
+ * @property {string} backgroundColor - The background color of the aspect container.
+ * @property {boolean} showControls - Flag to show or hide controls.
+ * @property {number} containerWidthFraction - Fraction of the window width for the container.
+ * @property {number} containerHeightFraction - Fraction of the window height for the container.
+ * @property {number} defaultFraction - Default fraction to adjust the height when controls are shown.
+ * @property {(isWideScreen: boolean) => void} updateIsWideScreen - Callback to update wide screen status.
+ * @property {(isMediumScreen: boolean) => void} updateIsMediumScreen - Callback to update medium screen status.
+ * @property {(isSmallScreen: boolean) => void} updateIsSmallScreen - Callback to update small screen status.
+ *
+ * @method ngOnInit - Lifecycle hook that is called after data-bound properties are initialized.
+ * @method ngOnChanges - Lifecycle hook that is called when any data-bound property changes.
+ * @method ngOnDestroy - Lifecycle hook that is called just before the component is destroyed.
+ * @method private updateAspectStyles - Updates the aspect styles based on the window size and input properties.
+ */
+export class MainAspectComponent {
+    backgroundColor = '';
+    showControls = true;
+    containerWidthFraction = 1;
+    containerHeightFraction = 1;
+    defaultFraction = 0.94;
+    updateIsWideScreen;
+    updateIsMediumScreen;
+    updateIsSmallScreen;
+    aspectStyles = {};
+    ngOnInit() {
+        this.updateAspectStyles();
+        window.addEventListener('resize', this.updateAspectStyles);
+        window.addEventListener('orientationchange', this.updateAspectStyles);
+    }
+    ngOnChanges(changes) {
+        if (changes['showControls'] ||
+            changes['containerWidthFraction'] ||
+            changes['containerHeightFraction'] ||
+            changes['defaultFraction']) {
+            this.updateAspectStyles();
+        }
+    }
+    ngOnDestroy() {
+        window.removeEventListener('resize', this.updateAspectStyles);
+        window.removeEventListener('orientationchange', this.updateAspectStyles);
+    }
+    updateAspectStyles = () => {
+        const windowHeight = window.innerHeight;
+        const windowWidth = window.innerWidth;
+        const parentWidth = Math.floor(this.containerWidthFraction * windowWidth);
+        const parentHeight = this.showControls
+            ? Math.floor(this.containerHeightFraction * windowHeight * this.defaultFraction)
+            : Math.floor(this.containerHeightFraction * windowHeight);
+        let isWideScreen = parentWidth >= 768;
+        const isMediumScreen = parentWidth >= 576 && parentWidth < 768;
+        const isSmallScreen = parentWidth < 576;
+        if (!isWideScreen && parentWidth > 1.5 * parentHeight) {
+            isWideScreen = true;
+        }
+        this.updateIsWideScreen(isWideScreen);
+        this.updateIsMediumScreen(isMediumScreen);
+        this.updateIsSmallScreen(isSmallScreen);
+        this.aspectStyles = {
+            height: parentHeight + 'px',
+            width: parentWidth + 'px',
+        };
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: MainAspectComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.8", type: MainAspectComponent, isStandalone: true, selector: "app-main-aspect-component", inputs: { backgroundColor: "backgroundColor", showControls: "showControls", containerWidthFraction: "containerWidthFraction", containerHeightFraction: "containerHeightFraction", defaultFraction: "defaultFraction", updateIsWideScreen: "updateIsWideScreen", updateIsMediumScreen: "updateIsMediumScreen", updateIsSmallScreen: "updateIsSmallScreen" }, usesOnChanges: true, ngImport: i0, template: `
+    <div
+      [ngStyle]="aspectStyles"
+      [style.backgroundColor]="backgroundColor"
+      class="aspect-container"
+    >
+      <ng-content></ng-content>
+    </div>
+  `, isInline: true, styles: [".aspect-container{overflow:hidden}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: MainAspectComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-main-aspect-component', standalone: true, imports: [CommonModule], template: `
+    <div
+      [ngStyle]="aspectStyles"
+      [style.backgroundColor]="backgroundColor"
+      class="aspect-container"
+    >
+      <ng-content></ng-content>
+    </div>
+  `, styles: [".aspect-container{overflow:hidden}\n"] }]
+        }], propDecorators: { backgroundColor: [{
+                type: Input
+            }], showControls: [{
+                type: Input
+            }], containerWidthFraction: [{
+                type: Input
+            }], containerHeightFraction: [{
+                type: Input
+            }], defaultFraction: [{
+                type: Input
+            }], updateIsWideScreen: [{
+                type: Input
+            }], updateIsMediumScreen: [{
+                type: Input
+            }], updateIsSmallScreen: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"main-aspect-component.component.js","sourceRoot":"","sources":["../../../../../../../projects/mediasfu-angular/src/lib/components/display-components/main-aspect-component/main-aspect-component.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, OnInit, OnDestroy, OnChanges, SimpleChanges } from '@angular/core';\nimport { CommonModule } from '@angular/common';\n\nexport interface MainAspectComponentOptions {\n  backgroundColor?: string;\n  showControls?: boolean;\n  containerWidthFraction?: number;\n  containerHeightFraction?: number;\n  defaultFraction?: number;\n  updateIsWideScreen: (isWideScreen: boolean) => void;\n  updateIsMediumScreen: (isMediumScreen: boolean) => void;\n  updateIsSmallScreen: (isSmallScreen: boolean) => void;\n}\n\nexport type MainAspectComponentType = (options: MainAspectComponentOptions) => HTMLElement;\n\n/**\n * MainAspectComponent is a standalone Angular component that adjusts its aspect ratio\n * based on the window size and other input properties. It listens to window resize\n * and orientation change events to dynamically update its styles.\n *\n * @selector app-main-aspect-component\n * @standalone true\n * @imports [CommonModule]\n *\n * @template\n * ```html\n * <div [ngStyle]=\"aspectStyles\" [style.backgroundColor]=\"backgroundColor\" class=\"aspect-container\">\n *   <ng-content></ng-content>\n * </div>\n * ```\n *\n * @styles\n * ```css\n * .aspect-container {\n *   overflow: hidden;\n * }\n * ```\n *\n * @class MainAspectComponent\n * @implements OnInit, OnDestroy, OnChanges\n *\n * @property {string} backgroundColor - The background color of the aspect container.\n * @property {boolean} showControls - Flag to show or hide controls.\n * @property {number} containerWidthFraction - Fraction of the window width for the container.\n * @property {number} containerHeightFraction - Fraction of the window height for the container.\n * @property {number} defaultFraction - Default fraction to adjust the height when controls are shown.\n * @property {(isWideScreen: boolean) => void} updateIsWideScreen - Callback to update wide screen status.\n * @property {(isMediumScreen: boolean) => void} updateIsMediumScreen - Callback to update medium screen status.\n * @property {(isSmallScreen: boolean) => void} updateIsSmallScreen - Callback to update small screen status.\n *\n * @method ngOnInit - Lifecycle hook that is called after data-bound properties are initialized.\n * @method ngOnChanges - Lifecycle hook that is called when any data-bound property changes.\n * @method ngOnDestroy - Lifecycle hook that is called just before the component is destroyed.\n * @method private updateAspectStyles - Updates the aspect styles based on the window size and input properties.\n */\n@Component({\n  selector: 'app-main-aspect-component',\n  standalone: true,\n  imports: [CommonModule],\n  template: `\n    <div\n      [ngStyle]=\"aspectStyles\"\n      [style.backgroundColor]=\"backgroundColor\"\n      class=\"aspect-container\"\n    >\n      <ng-content></ng-content>\n    </div>\n  `,\n  styles: [\n    `\n      .aspect-container {\n        overflow: hidden;\n      }\n    `,\n  ],\n})\nexport class MainAspectComponent implements OnInit, OnDestroy, OnChanges {\n  @Input() backgroundColor = '';\n  @Input() showControls = true;\n  @Input() containerWidthFraction = 1;\n  @Input() containerHeightFraction = 1;\n  @Input() defaultFraction = 0.94;\n  @Input() updateIsWideScreen!: (isWideScreen: boolean) => void;\n  @Input() updateIsMediumScreen!: (isMediumScreen: boolean) => void;\n  @Input() updateIsSmallScreen!: (isSmallScreen: boolean) => void;\n\n  aspectStyles: { [key: string]: any } = {};\n\n  ngOnInit() {\n    this.updateAspectStyles();\n\n    window.addEventListener('resize', this.updateAspectStyles);\n    window.addEventListener('orientationchange', this.updateAspectStyles);\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    if (\n      changes['showControls'] ||\n      changes['containerWidthFraction'] ||\n      changes['containerHeightFraction'] ||\n      changes['defaultFraction']\n    ) {\n      this.updateAspectStyles();\n    }\n  }\n\n  ngOnDestroy() {\n    window.removeEventListener('resize', this.updateAspectStyles);\n    window.removeEventListener('orientationchange', this.updateAspectStyles);\n  }\n\n  private updateAspectStyles = () => {\n    const windowHeight = window.innerHeight;\n    const windowWidth = window.innerWidth;\n\n    const parentWidth = Math.floor(this.containerWidthFraction * windowWidth);\n    const parentHeight = this.showControls\n      ? Math.floor(this.containerHeightFraction * windowHeight * this.defaultFraction)\n      : Math.floor(this.containerHeightFraction * windowHeight);\n\n    let isWideScreen = parentWidth >= 768;\n    const isMediumScreen = parentWidth >= 576 && parentWidth < 768;\n    const isSmallScreen = parentWidth < 576;\n\n    if (!isWideScreen && parentWidth > 1.5 * parentHeight) {\n      isWideScreen = true;\n    }\n\n    this.updateIsWideScreen(isWideScreen);\n    this.updateIsMediumScreen(isMediumScreen);\n    this.updateIsSmallScreen(isSmallScreen);\n\n    this.aspectStyles = {\n      height: parentHeight + 'px',\n      width: parentWidth + 'px',\n    };\n  };\n}\n"]}