@entake/particle 17.0.0

package/esm2022/app/modules/popover/popover.component.mjs

@@ -0,0 +1,352 @@
+import { animate, style, transition, trigger } from '@angular/animations';
+import { Component, EventEmitter, HostListener, Input, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/cdk/a11y";
+/**
+ * Component to display a popover with custom content
+ */
+export class PopoverComponent {
+    renderer;
+    window = window;
+    /**
+     * The offset of the popover from its target (in pixels)
+     */
+    offset = 5;
+    /**
+     * Set the width of the popover in pixels (defaults to auto)
+     */
+    set width(width) {
+        this._width = !width ? 'auto' : `${width}px`;
+    }
+    get width() {
+        return this._width;
+    }
+    /**
+     * Set the height of the popover in pixels (defaults to auto)
+     */
+    set height(height) {
+        this._height = !height ? 'auto' : `${height}px`;
+    }
+    get height() {
+        return this._height;
+    }
+    /**
+     * A class-list to apply to the popover content
+     */
+    classList = 'content_color particle_popover_shadow';
+    targetOverride = null;
+    openDirection = 'above';
+    alignment = 'left';
+    scaleForMobile = '1';
+    /**
+     * Event emitted on popover open
+     */
+    opened = new EventEmitter();
+    /**
+     * Event emitted on popover close
+     */
+    closed = new EventEmitter();
+    /**
+     * Whether the popover should render
+     */
+    render = false;
+    /**
+     * Whether the popover is visible
+     */
+    visible = false;
+    /**
+     * The width of the popover
+     */
+    _width = 'auto';
+    /**
+     * The height of the popover
+     */
+    _height = 'auto';
+    /**
+     * The element to target
+     * @private
+     */
+    target = null;
+    /**
+     * The popover content container
+     * @private
+     */
+    container = null;
+    /**
+     * Array of escape keyup unlisten functions
+     * @private
+     */
+    escapeKeyUpUnlisteners = [];
+    /**
+     * Dependency injection site
+     * @param renderer the Angular renderer
+     */
+    constructor(renderer) {
+        this.renderer = renderer;
+    }
+    /**
+     * Destroy component, clean up event listeners
+     */
+    ngOnDestroy() {
+        this.removeEventListeners();
+    }
+    /**
+     * Close popover on click
+     * @param event the click MouseEvent
+     */
+    onClick(event) {
+        if (this.visible) {
+            const { pageX, pageY } = event;
+            if (pageX > 0 && pageY > 0) {
+                const { left, right, top, bottom } = this.container.getBoundingClientRect();
+                const xPositionValid = pageX >= left && pageX <= right;
+                const yPositionValid = pageY >= top && pageY <= bottom;
+                const shouldClose = !(xPositionValid && yPositionValid);
+                if (shouldClose) {
+                    this.close();
+                }
+            }
+        }
+    }
+    /**
+     * Re-position popover on window resize
+     */
+    onWindowResize() {
+        if (this.visible) {
+            this.positionPopover();
+        }
+    }
+    /**
+     * Toggle the popover from open to closed or closed to open
+     * @param event the event whose target element will act as
+     *              the popover target. If an event is not provided,
+     *              the popover will close
+     */
+    toggle(event) {
+        if (this.targetOverride) {
+            this.target = this.targetOverride;
+        }
+        else {
+            if (event) {
+                this.target = event.currentTarget ?? event.target;
+                event.stopImmediatePropagation();
+            }
+            else {
+                this.target = null;
+            }
+        }
+        if (!this.visible && this.target) {
+            this.open();
+        }
+        else {
+            this.close();
+        }
+    }
+    /**
+     * Handle animation start
+     * @param event the AnimationEvent
+     */
+    onAnimationStart(event) {
+        if (event.toState === 'open') {
+            this.container = event.element;
+            this.addEventListeners();
+            this.positionPopover();
+            this.opened.emit();
+        }
+    }
+    /**
+     * Handle animation end
+     * @param event the AnimationEvent
+     */
+    onAnimationDone(event) {
+        if (event.toState === 'close') {
+            this.render = false;
+            this.removeEventListeners();
+            this.closed.emit();
+        }
+    }
+    /**
+     * Open the popover
+     * @private
+     */
+    open() {
+        this.render = true;
+        this.visible = true;
+    }
+    /**
+     * Close the popover
+     */
+    close() {
+        this.visible = false;
+    }
+    /**
+     * Position the popover
+     * @private
+     */
+    positionPopover() {
+        const { left, top, bottom, width } = this.target.getBoundingClientRect();
+        const { offsetHeight, offsetWidth } = this.container;
+        const popoverBottomLeftAnchor = bottom;
+        const availableBottomSpace = window.innerHeight - popoverBottomLeftAnchor;
+        const availableTopSpace = top;
+        const offsetListHeight = offsetHeight + this.offset;
+        let transformOrigin = null;
+        let positionTop = null;
+        const canOpenAbove = availableTopSpace > offsetListHeight;
+        const canOpenBelow = availableBottomSpace > offsetListHeight;
+        if (canOpenAbove && this.openDirection === 'above') {
+            transformOrigin = 'bottom left';
+            positionTop = `${top - offsetListHeight}px`;
+        }
+        if (canOpenBelow && this.openDirection === 'below') {
+            transformOrigin = 'top left';
+            positionTop = `${popoverBottomLeftAnchor + this.offset}px`;
+        }
+        if (!transformOrigin) {
+            if (availableTopSpace > offsetListHeight) {
+                transformOrigin = 'bottom left';
+                positionTop = `${top - offsetListHeight}px`;
+            }
+            else if (availableBottomSpace > offsetListHeight) {
+                transformOrigin = 'top left';
+                positionTop = `${popoverBottomLeftAnchor + this.offset}px`;
+            }
+            else {
+                if (offsetHeight > window.innerHeight) {
+                    positionTop = '0px';
+                }
+                else {
+                    const availableSpace = window.innerHeight - offsetHeight;
+                    positionTop = `${String(availableSpace / 2)}px`;
+                }
+                transformOrigin = 'top left';
+            }
+        }
+        let leftPosition = left;
+        if (this.alignment === 'center') {
+            leftPosition = (leftPosition - (offsetWidth / 2)) + (width / 2);
+        }
+        if ((left + offsetWidth) > window.innerWidth) {
+            leftPosition = left - ((left + offsetWidth) - window.innerWidth) - 10;
+        }
+        if (leftPosition < 0) {
+            leftPosition = 0;
+        }
+        this.renderer.setStyle(this.container, 'transform-origin', transformOrigin);
+        this.renderer.setStyle(this.container, 'left', `${leftPosition}px`);
+        this.renderer.setStyle(this.container, 'top', positionTop);
+    }
+    /**
+     * Add escape keyup listeners to all focusable elements to close
+     * the popover
+     * @private
+     */
+    addEventListeners() {
+        const focusableElements = this.getFocusableElements(this.container);
+        for (const element of focusableElements) {
+            this.renderer.setAttribute(element, 'data-dialog-close-override', 'true');
+            this.escapeKeyUpUnlisteners.push(this.renderer.listen(element, 'keyup', (event) => {
+                if (this.visible) {
+                    event.stopImmediatePropagation();
+                    const { key } = event;
+                    if (key === 'Esc' || key === 'Escape') {
+                        this.close();
+                    }
+                }
+            }));
+        }
+    }
+    /**
+     * Get all focusable child elements of the input node
+     * @param node the node to query for focusable children
+     * @param elements the found focusable elements
+     * @private
+     */
+    getFocusableElements(node, elements = []) {
+        if (node.hasChildNodes()) {
+            node.childNodes.forEach(child => elements.concat(this.getFocusableElements(child, elements)));
+            if ('tabIndex' in node) {
+                const { tabIndex } = node;
+                if (tabIndex >= 0) {
+                    elements.push(node);
+                }
+            }
+            return elements;
+        }
+        else {
+            if ('tabIndex' in node) {
+                const { tabIndex } = node;
+                if (tabIndex >= 0) {
+                    elements.push(node);
+                }
+            }
+            return elements;
+        }
+    }
+    /**
+     * Invoke escape keyup unlisten functions
+     * @private
+     */
+    removeEventListeners() {
+        for (const unlistener of this.escapeKeyUpUnlisteners) {
+            unlistener();
+        }
+        this.escapeKeyUpUnlisteners = [];
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: PopoverComponent, deps: [{ token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.2", type: PopoverComponent, selector: "particle-popover", inputs: { offset: "offset", width: "width", height: "height", classList: "classList", targetOverride: "targetOverride", openDirection: "openDirection", alignment: "alignment", scaleForMobile: "scaleForMobile" }, outputs: { opened: "opened", closed: "closed" }, host: { listeners: { "window:click": "onClick($event)", "window:resize": "onWindowResize()" } }, ngImport: i0, template: "<div *ngIf=\"render\" class=\"particle_popover_overlay\" [style.scale]=\"window.innerWidth > 768 ? 1 : scaleForMobile\">\n  <div [cdkTrapFocus]=\"render && visible\"\n       [cdkTrapFocusAutoCapture]=\"true\"\n       [@openClose]=\"visible ? 'open' : 'close'\"\n       [ngStyle]=\"{ 'width': width, 'height': height }\"\n       [ngClass]=\"classList\"\n       (@openClose.start)=\"onAnimationStart($event)\"\n       (@openClose.done)=\"onAnimationDone($event)\"\n       class=\"position_absolute particle_popover\">\n    <ng-content></ng-content>\n  </div>\n</div>\n", styles: [".particle_popover_overlay{position:fixed;inset:0;z-index:var(--z-notification)}.particle_popover{border-radius:3px;overflow-x:hidden;overflow-y:auto;font-size:12px;font-weight:400;z-index:var(--z-notification);width:auto;min-width:10px;height:auto;min-height:10px}.particle_popover_shadow{box-shadow:0 2px 4px -1px #0003,0 4px 5px #00000024,0 1px 10px #0000001f}\n"], dependencies: [{ kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "directive", type: i2.CdkTrapFocus, selector: "[cdkTrapFocus]", inputs: ["cdkTrapFocus", "cdkTrapFocusAutoCapture"], exportAs: ["cdkTrapFocus"] }], animations: [
+            trigger('openClose', [
+                transition('void => open', [
+                    style({ transform: 'scaleY(0.5)', opacity: 0 }),
+                    animate('200ms ease', style({ transform: 'scaleY(1)', opacity: 1 }))
+                ]),
+                transition('open => close', [
+                    style({ transform: 'scaleY(1)', opacity: 1 }),
+                    animate('200ms ease', style({ transform: 'scaleY(0.5)', opacity: 0 }))
+                ]),
+            ])
+        ] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: PopoverComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'particle-popover', animations: [
+                        trigger('openClose', [
+                            transition('void => open', [
+                                style({ transform: 'scaleY(0.5)', opacity: 0 }),
+                                animate('200ms ease', style({ transform: 'scaleY(1)', opacity: 1 }))
+                            ]),
+                            transition('open => close', [
+                                style({ transform: 'scaleY(1)', opacity: 1 }),
+                                animate('200ms ease', style({ transform: 'scaleY(0.5)', opacity: 0 }))
+                            ]),
+                        ])
+                    ], template: "<div *ngIf=\"render\" class=\"particle_popover_overlay\" [style.scale]=\"window.innerWidth > 768 ? 1 : scaleForMobile\">\n  <div [cdkTrapFocus]=\"render && visible\"\n       [cdkTrapFocusAutoCapture]=\"true\"\n       [@openClose]=\"visible ? 'open' : 'close'\"\n       [ngStyle]=\"{ 'width': width, 'height': height }\"\n       [ngClass]=\"classList\"\n       (@openClose.start)=\"onAnimationStart($event)\"\n       (@openClose.done)=\"onAnimationDone($event)\"\n       class=\"position_absolute particle_popover\">\n    <ng-content></ng-content>\n  </div>\n</div>\n", styles: [".particle_popover_overlay{position:fixed;inset:0;z-index:var(--z-notification)}.particle_popover{border-radius:3px;overflow-x:hidden;overflow-y:auto;font-size:12px;font-weight:400;z-index:var(--z-notification);width:auto;min-width:10px;height:auto;min-height:10px}.particle_popover_shadow{box-shadow:0 2px 4px -1px #0003,0 4px 5px #00000024,0 1px 10px #0000001f}\n"] }]
+        }], ctorParameters: () => [{ type: i0.Renderer2 }], propDecorators: { offset: [{
+                type: Input
+            }], width: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }], classList: [{
+                type: Input
+            }], targetOverride: [{
+                type: Input
+            }], openDirection: [{
+                type: Input
+            }], alignment: [{
+                type: Input
+            }], scaleForMobile: [{
+                type: Input
+            }], opened: [{
+                type: Output
+            }], closed: [{
+                type: Output
+            }], onClick: [{
+                type: HostListener,
+                args: ['window:click', ['$event']]
+            }], onWindowResize: [{
+                type: HostListener,
+                args: ['window:resize']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"popover.component.js","sourceRoot":"","sources":["../../../../../src/app/modules/popover/popover.component.ts","../../../../../src/app/modules/popover/popover.component.html"],"names":[],"mappings":"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","sourcesContent":["import { animate, AnimationEvent, style, transition, trigger } from '@angular/animations';\r\nimport { Component, EventEmitter, HostListener, Input, OnDestroy, Output, Renderer2 } from '@angular/core';\r\n\r\n/**\r\n * Component to display a popover with custom content\r\n */\r\n@Component({\r\n  selector: 'particle-popover',\r\n  templateUrl: './popover.component.html',\r\n  styleUrls: ['./popover.component.css'],\r\n  animations: [\r\n    trigger('openClose', [\r\n      transition('void => open', [\r\n        style({ transform: 'scaleY(0.5)', opacity: 0 }),\r\n        animate('200ms ease',\r\n          style({ transform: 'scaleY(1)', opacity: 1 }))\r\n      ]),\r\n      transition('open => close', [\r\n        style({ transform: 'scaleY(1)', opacity: 1 }),\r\n        animate('200ms ease',\r\n          style({ transform: 'scaleY(0.5)', opacity: 0 }))\r\n      ]),\r\n    ])\r\n  ]\r\n})\r\nexport class PopoverComponent implements OnDestroy {\r\n\r\n  protected readonly window = window;\r\n\r\n  /**\r\n   * The offset of the popover from its target (in pixels)\r\n   */\r\n  @Input()\r\n  offset = 5;\r\n\r\n  /**\r\n   * Set the width of the popover in pixels (defaults to auto)\r\n   */\r\n  @Input()\r\n  set width(width: string) {\r\n    this._width = !width ? 'auto' : `${width}px`;\r\n  }\r\n\r\n  get width(): string {\r\n    return this._width;\r\n  }\r\n\r\n  /**\r\n   * Set the height of the popover in pixels (defaults to auto)\r\n   */\r\n  @Input()\r\n  set height(height: string) {\r\n    this._height = !height ? 'auto' : `${height}px`;\r\n  }\r\n\r\n  get height(): string {\r\n    return this._height;\r\n  }\r\n\r\n  /**\r\n   * A class-list to apply to the popover content\r\n   */\r\n  @Input()\r\n  classList = 'content_color particle_popover_shadow';\r\n\r\n  @Input()\r\n  targetOverride: EventTarget = null as any;\r\n\r\n  @Input()\r\n  openDirection: 'above' | 'below' = 'above';\r\n\r\n  @Input()\r\n  alignment: 'left' | 'center' = 'left';\r\n\r\n  @Input()\r\n  scaleForMobile = '1';\r\n\r\n  /**\r\n   * Event emitted on popover open\r\n   */\r\n  @Output()\r\n  opened = new EventEmitter<void>();\r\n\r\n  /**\r\n   * Event emitted on popover close\r\n   */\r\n  @Output()\r\n  closed = new EventEmitter<void>();\r\n\r\n  /**\r\n   * Whether the popover should render\r\n   */\r\n  render: boolean = false;\r\n\r\n  /**\r\n   * Whether the popover is visible\r\n   */\r\n  visible: boolean = false;\r\n\r\n  /**\r\n   * The width of the popover\r\n   */\r\n  private _width = 'auto';\r\n\r\n  /**\r\n   * The height of the popover\r\n   */\r\n  private _height = 'auto';\r\n\r\n  /**\r\n   * The element to target\r\n   * @private\r\n   */\r\n  private target: EventTarget = null as any;\r\n\r\n  /**\r\n   * The popover content container\r\n   * @private\r\n   */\r\n  private container: HTMLDivElement = null as any;\r\n\r\n  /**\r\n   * Array of escape keyup unlisten functions\r\n   * @private\r\n   */\r\n  private escapeKeyUpUnlisteners: Array<() => void> = [];\r\n\r\n  /**\r\n   * Dependency injection site\r\n   * @param renderer the Angular renderer\r\n   */\r\n  constructor(private renderer: Renderer2) { }\r\n\r\n  /**\r\n   * Destroy component, clean up event listeners\r\n   */\r\n  ngOnDestroy(): void {\r\n    this.removeEventListeners();\r\n  }\r\n\r\n  /**\r\n   * Close popover on click\r\n   * @param event the click MouseEvent\r\n   */\r\n  @HostListener('window:click', ['$event'])\r\n  onClick(event: MouseEvent): void {\r\n    if (this.visible) {\r\n      const {pageX, pageY} = event;\r\n\r\n      if (pageX > 0 && pageY > 0) {\r\n        const { left, right, top, bottom } = this.container.getBoundingClientRect();\r\n        const xPositionValid = pageX >= left && pageX <= right;\r\n        const yPositionValid = pageY >= top && pageY <= bottom;\r\n        const shouldClose = !(xPositionValid && yPositionValid);\r\n\r\n        if (shouldClose) {\r\n          this.close();\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Re-position popover on window resize\r\n   */\r\n  @HostListener('window:resize')\r\n  onWindowResize(): void {\r\n    if (this.visible) {\r\n      this.positionPopover();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Toggle the popover from open to closed or closed to open\r\n   * @param event the event whose target element will act as\r\n   *              the popover target. If an event is not provided,\r\n   *              the popover will close\r\n   */\r\n  toggle(event?: Event): void {\r\n    if (this.targetOverride) {\r\n      this.target = this.targetOverride;\r\n    } else {\r\n      if (event) {\r\n        this.target = event.currentTarget ?? event.target as EventTarget;\r\n        event.stopImmediatePropagation();\r\n      } else {\r\n        this.target = null as any;\r\n      }\r\n    }\r\n\r\n    if (!this.visible && this.target) {\r\n      this.open();\r\n    } else {\r\n      this.close();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Handle animation start\r\n   * @param event the AnimationEvent\r\n   */\r\n  onAnimationStart(event: AnimationEvent): void {\r\n    if (event.toState === 'open') {\r\n      this.container = event.element;\r\n      this.addEventListeners();\r\n      this.positionPopover();\r\n      this.opened.emit();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Handle animation end\r\n   * @param event the AnimationEvent\r\n   */\r\n  onAnimationDone(event: AnimationEvent): void {\r\n    if (event.toState === 'close') {\r\n      this.render = false;\r\n      this.removeEventListeners();\r\n      this.closed.emit();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Open the popover\r\n   * @private\r\n   */\r\n  private open(): void {\r\n    this.render = true;\r\n    this.visible = true;\r\n  }\r\n\r\n  /**\r\n   * Close the popover\r\n   */\r\n  public close(): void {\r\n    this.visible = false;\r\n  }\r\n\r\n  /**\r\n   * Position the popover\r\n   * @private\r\n   */\r\n  private positionPopover(): void {\r\n    const {left, top, bottom, width} = (this.target as HTMLElement).getBoundingClientRect();\r\n    const {offsetHeight, offsetWidth} = this.container;\r\n    const popoverBottomLeftAnchor = bottom;\r\n    const availableBottomSpace = window.innerHeight - popoverBottomLeftAnchor;\r\n    const availableTopSpace = top;\r\n    const offsetListHeight = offsetHeight + this.offset;\r\n    let transformOrigin: string = null as any;\r\n    let positionTop: string = null as any;\r\n\r\n    const canOpenAbove = availableTopSpace > offsetListHeight;\r\n    const canOpenBelow = availableBottomSpace > offsetListHeight;\r\n\r\n    if (canOpenAbove && this.openDirection === 'above') {\r\n      transformOrigin = 'bottom left';\r\n      positionTop = `${top - offsetListHeight}px`;\r\n    }\r\n\r\n    if (canOpenBelow && this.openDirection === 'below') {\r\n      transformOrigin = 'top left';\r\n      positionTop = `${popoverBottomLeftAnchor + this.offset}px`;\r\n    }\r\n\r\n    if (!transformOrigin) {\r\n      if (availableTopSpace > offsetListHeight) {\r\n        transformOrigin = 'bottom left';\r\n        positionTop = `${top - offsetListHeight}px`;\r\n      } else if (availableBottomSpace > offsetListHeight) {\r\n        transformOrigin = 'top left';\r\n        positionTop = `${popoverBottomLeftAnchor + this.offset}px`;\r\n      } else {\r\n        if (offsetHeight > window.innerHeight) {\r\n          positionTop = '0px';\r\n        } else {\r\n          const availableSpace = window.innerHeight - offsetHeight;\r\n          positionTop = `${String(availableSpace / 2)}px`;\r\n        }\r\n\r\n        transformOrigin = 'top left';\r\n      }\r\n    }\r\n\r\n    let leftPosition = left;\r\n\r\n    if (this.alignment === 'center') {\r\n      leftPosition = (leftPosition - (offsetWidth/2)) + (width/2);\r\n    }\r\n\r\n    if ((left + offsetWidth) > window.innerWidth) {\r\n      leftPosition = left - ((left + offsetWidth) - window.innerWidth) - 10;\r\n    }\r\n\r\n    if (leftPosition < 0) {\r\n      leftPosition = 0;\r\n    }\r\n\r\n    this.renderer.setStyle(this.container, 'transform-origin', transformOrigin);\r\n    this.renderer.setStyle(this.container, 'left', `${leftPosition}px`);\r\n    this.renderer.setStyle(this.container, 'top', positionTop);\r\n  }\r\n\r\n  /**\r\n   * Add escape keyup listeners to all focusable elements to close\r\n   * the popover\r\n   * @private\r\n   */\r\n  private addEventListeners(): void {\r\n    const focusableElements = this.getFocusableElements(this.container);\r\n\r\n    for (const element of focusableElements) {\r\n      this.renderer.setAttribute(element, 'data-dialog-close-override', 'true');\r\n      this.escapeKeyUpUnlisteners.push(\r\n        this.renderer.listen(element, 'keyup', (event: KeyboardEvent) => {\r\n          if (this.visible) {\r\n            event.stopImmediatePropagation();\r\n\r\n            const { key } = event;\r\n\r\n            if (key === 'Esc' || key === 'Escape') {\r\n              this.close();\r\n            }\r\n          }\r\n        })\r\n      );\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get all focusable child elements of the input node\r\n   * @param node the node to query for focusable children\r\n   * @param elements the found focusable elements\r\n   * @private\r\n   */\r\n  private getFocusableElements(node: Node, elements: Array<Element> = []): Array<any> {\r\n    if (node.hasChildNodes()) {\r\n      node.childNodes.forEach(child => elements.concat(this.getFocusableElements(child, elements)));\r\n\r\n      if ('tabIndex' in node) {\r\n        const { tabIndex } = node as unknown as HTMLOrSVGElement;\r\n\r\n        if (tabIndex >= 0) {\r\n          elements.push(node as any);\r\n        }\r\n      }\r\n\r\n      return elements;\r\n    } else {\r\n      if ('tabIndex' in node) {\r\n        const { tabIndex } = node as unknown as HTMLOrSVGElement;\r\n\r\n        if (tabIndex >= 0) {\r\n          elements.push(node as any);\r\n        }\r\n      }\r\n\r\n      return elements;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Invoke escape keyup unlisten functions\r\n   * @private\r\n   */\r\n  private removeEventListeners(): void {\r\n    for (const unlistener of this.escapeKeyUpUnlisteners) {\r\n      unlistener();\r\n    }\r\n\r\n    this.escapeKeyUpUnlisteners = [];\r\n  }\r\n\r\n}\r\n","<div *ngIf=\"render\" class=\"particle_popover_overlay\" [style.scale]=\"window.innerWidth > 768 ? 1 : scaleForMobile\">\n  <div [cdkTrapFocus]=\"render && visible\"\n       [cdkTrapFocusAutoCapture]=\"true\"\n       [@openClose]=\"visible ? 'open' : 'close'\"\n       [ngStyle]=\"{ 'width': width, 'height': height }\"\n       [ngClass]=\"classList\"\n       (@openClose.start)=\"onAnimationStart($event)\"\n       (@openClose.done)=\"onAnimationDone($event)\"\n       class=\"position_absolute particle_popover\">\n    <ng-content></ng-content>\n  </div>\n</div>\n"]}

package/esm2022/app/modules/popover/popover.module.mjs

@@ -0,0 +1,24 @@
+import { A11yModule } from '@angular/cdk/a11y';
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { PopoverComponent } from './popover.component';
+import * as i0 from "@angular/core";
+export class ParticlePopoverModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: ParticlePopoverModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.2", ngImport: i0, type: ParticlePopoverModule, declarations: [PopoverComponent], imports: [CommonModule,
+            A11yModule], exports: [PopoverComponent] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: ParticlePopoverModule, imports: [CommonModule,
+            A11yModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: ParticlePopoverModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [PopoverComponent],
+                    imports: [
+                        CommonModule,
+                        A11yModule
+                    ],
+                    exports: [PopoverComponent]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9wb3Zlci5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvYXBwL21vZHVsZXMvcG9wb3Zlci9wb3BvdmVyLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDL0MsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLGdCQUFnQixFQUFDLE1BQU0scUJBQXFCLENBQUM7O0FBVXRELE1BQU0sT0FBTyxxQkFBcUI7dUdBQXJCLHFCQUFxQjt3R0FBckIscUJBQXFCLGlCQVBqQixnQkFBZ0IsYUFFekIsWUFBWTtZQUNaLFVBQVUsYUFFTixnQkFBZ0I7d0dBRWYscUJBQXFCLFlBTDFCLFlBQVk7WUFDWixVQUFVOzsyRkFJTCxxQkFBcUI7a0JBUmpDLFFBQVE7bUJBQUM7b0JBQ1IsWUFBWSxFQUFFLENBQUMsZ0JBQWdCLENBQUM7b0JBQzlCLE9BQU8sRUFBRTt3QkFDTCxZQUFZO3dCQUNaLFVBQVU7cUJBQ2I7b0JBQ0gsT0FBTyxFQUFFLENBQUMsZ0JBQWdCLENBQUM7aUJBQzVCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQTExeU1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2Nkay9hMTF5JztcbmltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgUG9wb3ZlckNvbXBvbmVudH0gZnJvbSAnLi9wb3BvdmVyLmNvbXBvbmVudCc7XG5cbkBOZ01vZHVsZSh7XG4gIGRlY2xhcmF0aW9uczogW1BvcG92ZXJDb21wb25lbnRdLFxuICAgIGltcG9ydHM6IFtcbiAgICAgICAgQ29tbW9uTW9kdWxlLFxuICAgICAgICBBMTF5TW9kdWxlXG4gICAgXSxcbiAgZXhwb3J0czogW1BvcG92ZXJDb21wb25lbnRdXG59KVxuZXhwb3J0IGNsYXNzIFBhcnRpY2xlUG9wb3Zlck1vZHVsZSB7IH1cbiJdfQ==

package/esm2022/app/modules/profile-pic/particle-profile-pic.module.mjs

@@ -0,0 +1,28 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { ProfilePicComponent } from './profile-pic.component';
+import { ParticleTooltipModule } from '../tooltip/tooltip.module';
+import * as i0 from "@angular/core";
+export class ParticleProfilePicModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: ParticleProfilePicModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.2", ngImport: i0, type: ParticleProfilePicModule, declarations: [ProfilePicComponent], imports: [CommonModule,
+            ParticleTooltipModule], exports: [ProfilePicComponent] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: ParticleProfilePicModule, imports: [CommonModule,
+            ParticleTooltipModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: ParticleProfilePicModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        ProfilePicComponent
+                    ],
+                    imports: [
+                        CommonModule,
+                        ParticleTooltipModule
+                    ],
+                    exports: [
+                        ProfilePicComponent
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFydGljbGUtcHJvZmlsZS1waWMubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2FwcC9tb2R1bGVzL3Byb2ZpbGUtcGljL3BhcnRpY2xlLXByb2ZpbGUtcGljLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBQ3ZDLE9BQU8sRUFBQyxZQUFZLEVBQUMsTUFBTSxpQkFBaUIsQ0FBQztBQUM3QyxPQUFPLEVBQUMsbUJBQW1CLEVBQUMsTUFBTSx5QkFBeUIsQ0FBQztBQUM1RCxPQUFPLEVBQUMscUJBQXFCLEVBQUMsTUFBTSwyQkFBMkIsQ0FBQzs7QUFjaEUsTUFBTSxPQUFPLHdCQUF3Qjt1R0FBeEIsd0JBQXdCO3dHQUF4Qix3QkFBd0IsaUJBVmpDLG1CQUFtQixhQUdmLFlBQVk7WUFDWixxQkFBcUIsYUFHekIsbUJBQW1CO3dHQUdWLHdCQUF3QixZQVA3QixZQUFZO1lBQ1oscUJBQXFCOzsyRkFNaEIsd0JBQXdCO2tCQVpwQyxRQUFRO21CQUFDO29CQUNSLFlBQVksRUFBRTt3QkFDWixtQkFBbUI7cUJBQ3BCO29CQUNDLE9BQU8sRUFBRTt3QkFDTCxZQUFZO3dCQUNaLHFCQUFxQjtxQkFDeEI7b0JBQ0gsT0FBTyxFQUFFO3dCQUNQLG1CQUFtQjtxQkFDcEI7aUJBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge05nTW9kdWxlfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHtDb21tb25Nb2R1bGV9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XHJcbmltcG9ydCB7UHJvZmlsZVBpY0NvbXBvbmVudH0gZnJvbSAnLi9wcm9maWxlLXBpYy5jb21wb25lbnQnO1xyXG5pbXBvcnQge1BhcnRpY2xlVG9vbHRpcE1vZHVsZX0gZnJvbSAnLi4vdG9vbHRpcC90b29sdGlwLm1vZHVsZSc7XHJcblxyXG5ATmdNb2R1bGUoe1xyXG4gIGRlY2xhcmF0aW9uczogW1xyXG4gICAgUHJvZmlsZVBpY0NvbXBvbmVudFxyXG4gIF0sXHJcbiAgICBpbXBvcnRzOiBbXHJcbiAgICAgICAgQ29tbW9uTW9kdWxlLFxyXG4gICAgICAgIFBhcnRpY2xlVG9vbHRpcE1vZHVsZVxyXG4gICAgXSxcclxuICBleHBvcnRzOiBbXHJcbiAgICBQcm9maWxlUGljQ29tcG9uZW50XHJcbiAgXVxyXG59KVxyXG5leHBvcnQgY2xhc3MgUGFydGljbGVQcm9maWxlUGljTW9kdWxlIHtcclxufVxyXG4iXX0=