@quadrel-enterprise-ui/framework 1.0.0 → 18.19.2

package/esm2022/lib/core/popover/popover-on-click/popover-on-click.directive.mjs

@@ -0,0 +1,261 @@
+import { Directive, ElementRef, EventEmitter, HostListener, Input, Optional, Output, TemplateRef } from '@angular/core';
+import { Overlay, OverlayPositionBuilder } from '@angular/cdk/overlay';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { distinctUntilChanged, map, startWith } from 'rxjs/operators';
+import { QdPopoverService } from '../popover.service';
+import { QdPopoverSizingService } from '../popover-sizing.service';
+import { QdPopoverParentService } from '../popover-parent.service';
+import { QdPopoverComponent } from '../popover/popover.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+import * as i2 from "../popover.service";
+import * as i3 from "../popover-sizing.service";
+import * as i4 from "../popover-parent.service";
+const DEFAULT_POSITION = {
+    originX: 'end',
+    originY: 'bottom',
+    overlayX: 'end',
+    overlayY: 'top'
+};
+export class QdPopoverOnClickDirective {
+    hostRef;
+    overlayPositionBuilder;
+    overlay;
+    popoverService;
+    sizingService;
+    popoverParentService;
+    qdPopoverOnClick;
+    positionStrategy;
+    qdPopoverCloseStrategy = 'onEveryClick';
+    qdPopoverDisabled = false;
+    qdPopoverStopPropagation = true;
+    qdPopoverBackgroundColor;
+    qdPopoverMaxHeight = 'none';
+    qdPopoverMinWidth = 'none';
+    qdPopoverMaxWidth = 'none';
+    qdPopoverAutoSize = {};
+    qdPopoverEnableKeyControl = false;
+    opened = new EventEmitter();
+    closed = new EventEmitter();
+    handleClick(event) {
+        if (this.qdPopoverStopPropagation)
+            event.stopPropagation();
+        if (this.qdPopoverDisabled)
+            return;
+        this.overlayRef.hasAttached() ? this.close() : this.open();
+    }
+    handleDocumentClick(event) {
+        if (this.overlayRef?.hasAttached() && this.shouldClosePopover(event))
+            this.close();
+    }
+    handleCloseKeys() {
+        if (!this.qdPopoverEnableKeyControl)
+            return;
+        this.close();
+    }
+    handleOpenKey(event) {
+        if (!this.qdPopoverEnableKeyControl)
+            return;
+        if (this.qdPopoverStopPropagation)
+            event.stopPropagation();
+        event.preventDefault();
+        this.open();
+    }
+    overlayRef;
+    _host;
+    _popoverRef = null;
+    _positionStrategyInstance;
+    _subscriptions = [];
+    constructor(hostRef, overlayPositionBuilder, overlay, popoverService, sizingService, popoverParentService) {
+        this.hostRef = hostRef;
+        this.overlayPositionBuilder = overlayPositionBuilder;
+        this.overlay = overlay;
+        this.popoverService = popoverService;
+        this.sizingService = sizingService;
+        this.popoverParentService = popoverParentService;
+        this._host = hostRef.nativeElement;
+    }
+    ngOnInit() {
+        this.initPositionStrategy();
+        this.createOverlay();
+    }
+    ngOnDestroy() {
+        this.close();
+        this.cleanup();
+    }
+    open() {
+        if (this.overlayRef.hasAttached())
+            return;
+        this.popoverService.closeAllOverlays(this.popoverParentService?.parentPopovers);
+        const popoverPortal = new ComponentPortal(QdPopoverComponent);
+        this._popoverRef = this.overlayRef.attach(popoverPortal);
+        const instance = this.popoverInstance();
+        if (!instance)
+            return;
+        this._subscriptions.push(instance.isViewInitialized.subscribe(() => {
+            const popover = instance.getHostElement();
+            if (!popover)
+                return;
+            this.runSizingAndOpen(popover);
+        }));
+    }
+    close() {
+        if (!this.overlayRef?.hasAttached())
+            return;
+        this.overlayRef.detach();
+        this._popoverRef?.destroy();
+        this._popoverRef = null;
+        this.unsubscribeAll();
+        this.closed.emit();
+        this.sizingService.disconnect();
+    }
+    popoverInstance() {
+        return this._popoverRef?.instance ?? null;
+    }
+    initPositionStrategy() {
+        const positions = this.positionStrategy
+            ? Array.isArray(this.positionStrategy)
+                ? this.positionStrategy
+                : [this.positionStrategy]
+            : [DEFAULT_POSITION];
+        this._positionStrategyInstance = this.overlayPositionBuilder
+            .flexibleConnectedTo(this._host)
+            .withPositions(positions);
+    }
+    createOverlay() {
+        this.overlayRef = this.overlay.create({
+            positionStrategy: this._positionStrategyInstance,
+            disposeOnNavigation: true,
+            scrollStrategy: this.overlay.scrollStrategies.reposition()
+        });
+    }
+    runSizingAndOpen(popover) {
+        setTimeout(() => {
+            const constraints = {
+                minWidth: this.qdPopoverMinWidth,
+                maxWidth: this.qdPopoverMaxWidth,
+                maxHeight: this.qdPopoverMaxHeight
+            };
+            const sizingSub = this.sizingService
+                .observe(this._host, popover, this.overlayRef, this.qdPopoverAutoSize, constraints)
+                .subscribe(ready => {
+                if (ready) {
+                    this.setPopoverContent();
+                    this.subscribeToPopoverClose();
+                    this.subscribeToPositionChange();
+                    this.opened.emit();
+                    requestAnimationFrame(() => {
+                        this.overlayRef.updatePosition();
+                    });
+                }
+            });
+            this._subscriptions.push(sizingSub);
+        });
+    }
+    setPopoverContent() {
+        if (!this.popoverInstance())
+            return;
+        const popover = this.popoverInstance();
+        if (!popover)
+            return;
+        popover.content = this.qdPopoverOnClick;
+        if (this.qdPopoverBackgroundColor)
+            popover.backgroundColor = this.qdPopoverBackgroundColor;
+    }
+    subscribeToPopoverClose() {
+        if (!this.popoverInstance())
+            return;
+        this._subscriptions.push(this.popoverService.subscribe(excludedPopovers => {
+            if (!excludedPopovers.includes(this.popoverInstance()))
+                this.close();
+        }));
+    }
+    subscribeToPositionChange() {
+        const popover = this.popoverInstance();
+        if (!popover)
+            return;
+        this._subscriptions.push(this._positionStrategyInstance.positionChanges
+            .pipe(map(c => c.connectionPair.overlayY), startWith(this._positionStrategyInstance['_preferredPositions']?.[0]?.overlayY ?? 'top'), distinctUntilChanged())
+            .subscribe(overlayY => popover.setDirection(overlayY === 'top' ? 'down' : 'up')));
+    }
+    shouldClosePopover(event) {
+        if (event.target === this._host)
+            return false;
+        const target = event.target;
+        switch (this.qdPopoverCloseStrategy) {
+            case 'onEveryClick':
+                return !target.classList.contains('disabled') && !target.hasAttribute('disabled');
+            case 'onOutsideClick': {
+                const hoveredHost = this._host.parentElement?.querySelector(':hover');
+                const hoveredOverlay = this.overlayRef.overlayElement.querySelector(':hover');
+                return !hoveredHost && !hoveredOverlay && !target.closest('qd-popover');
+            }
+            default:
+                return false;
+        }
+    }
+    unsubscribeAll() {
+        this._subscriptions.forEach(sub => sub.unsubscribe());
+        this._subscriptions = [];
+    }
+    cleanup() {
+        this.sizingService.disconnect();
+        this.overlayRef?.dispose();
+        this._popoverRef = null;
+        this.unsubscribeAll();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdPopoverOnClickDirective, deps: [{ token: i0.ElementRef }, { token: i1.OverlayPositionBuilder }, { token: i1.Overlay }, { token: i2.QdPopoverService }, { token: i3.QdPopoverSizingService }, { token: i4.QdPopoverParentService, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.9", type: QdPopoverOnClickDirective, selector: "[qdPopoverOnClick]", inputs: { qdPopoverOnClick: "qdPopoverOnClick", positionStrategy: "positionStrategy", qdPopoverCloseStrategy: "qdPopoverCloseStrategy", qdPopoverDisabled: "qdPopoverDisabled", qdPopoverStopPropagation: "qdPopoverStopPropagation", qdPopoverBackgroundColor: "qdPopoverBackgroundColor", qdPopoverMaxHeight: "qdPopoverMaxHeight", qdPopoverMinWidth: "qdPopoverMinWidth", qdPopoverMaxWidth: "qdPopoverMaxWidth", qdPopoverAutoSize: "qdPopoverAutoSize", qdPopoverEnableKeyControl: "qdPopoverEnableKeyControl" }, outputs: { opened: "opened", closed: "closed" }, host: { listeners: { "click": "handleClick($event)", "document:click": "handleDocumentClick($event)", "keydown.escape": "handleCloseKeys()", "keydown.tab": "handleCloseKeys()", "keydown.space": "handleOpenKey($event)" } }, providers: [QdPopoverSizingService], exportAs: ["qdPopoverOnClick"], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdPopoverOnClickDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[qdPopoverOnClick]',
+                    exportAs: 'qdPopoverOnClick',
+                    providers: [QdPopoverSizingService]
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i1.OverlayPositionBuilder }, { type: i1.Overlay }, { type: i2.QdPopoverService }, { type: i3.QdPopoverSizingService }, { type: i4.QdPopoverParentService, decorators: [{
+                    type: Optional
+                }] }], propDecorators: { qdPopoverOnClick: [{
+                type: Input
+            }], positionStrategy: [{
+                type: Input
+            }], qdPopoverCloseStrategy: [{
+                type: Input
+            }], qdPopoverDisabled: [{
+                type: Input
+            }], qdPopoverStopPropagation: [{
+                type: Input
+            }], qdPopoverBackgroundColor: [{
+                type: Input
+            }], qdPopoverMaxHeight: [{
+                type: Input
+            }], qdPopoverMinWidth: [{
+                type: Input
+            }], qdPopoverMaxWidth: [{
+                type: Input
+            }], qdPopoverAutoSize: [{
+                type: Input
+            }], qdPopoverEnableKeyControl: [{
+                type: Input
+            }], opened: [{
+                type: Output
+            }], closed: [{
+                type: Output
+            }], handleClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }], handleDocumentClick: [{
+                type: HostListener,
+                args: ['document:click', ['$event']]
+            }], handleCloseKeys: [{
+                type: HostListener,
+                args: ['keydown.escape']
+            }, {
+                type: HostListener,
+                args: ['keydown.tab']
+            }], handleOpenKey: [{
+                type: HostListener,
+                args: ['keydown.space', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"popover-on-click.directive.js","sourceRoot":"","sources":["../../../../../../../libs/qd-ui/src/lib/core/popover/popover-on-click/popover-on-click.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ComponentRef,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  HostListener,\n  Input,\n  OnDestroy,\n  OnInit,\n  Optional,\n  Output,\n  TemplateRef\n} from '@angular/core';\nimport {\n  ConnectedPosition,\n  FlexibleConnectedPositionStrategy,\n  Overlay,\n  OverlayPositionBuilder,\n  OverlayRef\n} from '@angular/cdk/overlay';\nimport { ComponentPortal } from '@angular/cdk/portal';\nimport { Subscription } from 'rxjs';\nimport { distinctUntilChanged, map, startWith } from 'rxjs/operators';\n\nimport { QdPopoverService } from '../popover.service';\nimport { QdPopoverAutoSizeConfig, QdPopoverSizingService } from '../popover-sizing.service';\nimport { QdPopoverParentService } from '../popover-parent.service';\nimport { QdPopoverBackgroundColor, QdPopoverComponent } from '../popover/popover.component';\n\nconst DEFAULT_POSITION: ConnectedPosition = {\n  originX: 'end',\n  originY: 'bottom',\n  overlayX: 'end',\n  overlayY: 'top'\n};\n\n@Directive({\n  selector: '[qdPopoverOnClick]',\n  exportAs: 'qdPopoverOnClick',\n  providers: [QdPopoverSizingService]\n})\nexport class QdPopoverOnClickDirective implements OnInit, OnDestroy {\n  @Input() qdPopoverOnClick!: TemplateRef<unknown>;\n  @Input() positionStrategy?: ConnectedPosition | ConnectedPosition[];\n  @Input() qdPopoverCloseStrategy: 'onEveryClick' | 'onOutsideClick' = 'onEveryClick';\n  @Input() qdPopoverDisabled = false;\n  @Input() qdPopoverStopPropagation = true;\n  @Input() qdPopoverBackgroundColor?: QdPopoverBackgroundColor;\n  @Input() qdPopoverMaxHeight: number | 'none' = 'none';\n  @Input() qdPopoverMinWidth: number | 'none' = 'none';\n  @Input() qdPopoverMaxWidth: number | 'none' = 'none';\n  @Input() qdPopoverAutoSize: QdPopoverAutoSizeConfig = {};\n  @Input() qdPopoverEnableKeyControl = false;\n\n  @Output() readonly opened = new EventEmitter();\n  @Output() readonly closed = new EventEmitter();\n\n  @HostListener('click', ['$event'])\n  handleClick(event: MouseEvent): void {\n    if (this.qdPopoverStopPropagation) event.stopPropagation();\n    if (this.qdPopoverDisabled) return;\n\n    this.overlayRef.hasAttached() ? this.close() : this.open();\n  }\n\n  @HostListener('document:click', ['$event'])\n  handleDocumentClick(event: PointerEvent): void {\n    if (this.overlayRef?.hasAttached() && this.shouldClosePopover(event)) this.close();\n  }\n\n  @HostListener('keydown.escape')\n  @HostListener('keydown.tab')\n  handleCloseKeys(): void {\n    if (!this.qdPopoverEnableKeyControl) return;\n    this.close();\n  }\n\n  @HostListener('keydown.space', ['$event'])\n  handleOpenKey(event: KeyboardEvent): void {\n    if (!this.qdPopoverEnableKeyControl) return;\n    if (this.qdPopoverStopPropagation) event.stopPropagation();\n    event.preventDefault();\n    this.open();\n  }\n\n  overlayRef!: OverlayRef;\n\n  private _host: HTMLElement;\n  private _popoverRef: ComponentRef<QdPopoverComponent> | null = null;\n  private _positionStrategyInstance!: FlexibleConnectedPositionStrategy;\n  private _subscriptions: Subscription[] = [];\n\n  constructor(\n    protected hostRef: ElementRef<HTMLElement>,\n    protected overlayPositionBuilder: OverlayPositionBuilder,\n    protected overlay: Overlay,\n    protected popoverService: QdPopoverService,\n    protected sizingService: QdPopoverSizingService,\n    @Optional() protected popoverParentService: QdPopoverParentService\n  ) {\n    this._host = hostRef.nativeElement;\n  }\n\n  ngOnInit(): void {\n    this.initPositionStrategy();\n    this.createOverlay();\n  }\n\n  ngOnDestroy(): void {\n    this.close();\n    this.cleanup();\n  }\n\n  open(): void {\n    if (this.overlayRef.hasAttached()) return;\n\n    this.popoverService.closeAllOverlays(this.popoverParentService?.parentPopovers);\n\n    const popoverPortal = new ComponentPortal(QdPopoverComponent);\n    this._popoverRef = this.overlayRef.attach(popoverPortal);\n\n    const instance = this.popoverInstance();\n    if (!instance) return;\n\n    this._subscriptions.push(\n      instance.isViewInitialized.subscribe(() => {\n        const popover = instance.getHostElement();\n\n        if (!popover) return;\n\n        this.runSizingAndOpen(popover);\n      })\n    );\n  }\n\n  close(): void {\n    if (!this.overlayRef?.hasAttached()) return;\n\n    this.overlayRef.detach();\n    this._popoverRef?.destroy();\n    this._popoverRef = null;\n    this.unsubscribeAll();\n    this.closed.emit();\n    this.sizingService.disconnect();\n  }\n\n  private popoverInstance(): QdPopoverComponent | null {\n    return this._popoverRef?.instance ?? null;\n  }\n\n  private initPositionStrategy(): void {\n    const positions = this.positionStrategy\n      ? Array.isArray(this.positionStrategy)\n        ? this.positionStrategy\n        : [this.positionStrategy]\n      : [DEFAULT_POSITION];\n\n    this._positionStrategyInstance = this.overlayPositionBuilder\n      .flexibleConnectedTo(this._host)\n      .withPositions(positions);\n  }\n\n  private createOverlay(): void {\n    this.overlayRef = this.overlay.create({\n      positionStrategy: this._positionStrategyInstance,\n      disposeOnNavigation: true,\n      scrollStrategy: this.overlay.scrollStrategies.reposition()\n    });\n  }\n\n  private runSizingAndOpen(popover: HTMLElement): void {\n    setTimeout(() => {\n      const constraints = {\n        minWidth: this.qdPopoverMinWidth,\n        maxWidth: this.qdPopoverMaxWidth,\n        maxHeight: this.qdPopoverMaxHeight\n      };\n\n      const sizingSub = this.sizingService\n        .observe(this._host, popover, this.overlayRef, this.qdPopoverAutoSize, constraints)\n        .subscribe(ready => {\n          if (ready) {\n            this.setPopoverContent();\n            this.subscribeToPopoverClose();\n            this.subscribeToPositionChange();\n            this.opened.emit();\n            requestAnimationFrame(() => {\n              this.overlayRef.updatePosition();\n            });\n          }\n        });\n      this._subscriptions.push(sizingSub);\n    });\n  }\n\n  private setPopoverContent(): void {\n    if (!this.popoverInstance()) return;\n\n    const popover = this.popoverInstance();\n    if (!popover) return;\n\n    popover.content = this.qdPopoverOnClick;\n    if (this.qdPopoverBackgroundColor) popover.backgroundColor = this.qdPopoverBackgroundColor;\n  }\n\n  private subscribeToPopoverClose(): void {\n    if (!this.popoverInstance()) return;\n\n    this._subscriptions.push(\n      this.popoverService.subscribe(excludedPopovers => {\n        if (!excludedPopovers.includes(this.popoverInstance()!)) this.close();\n      })\n    );\n  }\n\n  private subscribeToPositionChange(): void {\n    const popover = this.popoverInstance();\n    if (!popover) return;\n\n    this._subscriptions.push(\n      this._positionStrategyInstance.positionChanges\n        .pipe(\n          map(c => c.connectionPair.overlayY),\n          startWith(this._positionStrategyInstance['_preferredPositions']?.[0]?.overlayY ?? 'top'),\n          distinctUntilChanged()\n        )\n        .subscribe(overlayY => popover.setDirection(overlayY === 'top' ? 'down' : 'up'))\n    );\n  }\n\n  private shouldClosePopover(event: PointerEvent): boolean {\n    if (event.target === this._host) return false;\n\n    const target = event.target as HTMLElement;\n\n    switch (this.qdPopoverCloseStrategy) {\n      case 'onEveryClick':\n        return !target.classList.contains('disabled') && !target.hasAttribute('disabled');\n\n      case 'onOutsideClick': {\n        const hoveredHost = this._host.parentElement?.querySelector(':hover');\n        const hoveredOverlay = this.overlayRef.overlayElement.querySelector(':hover');\n        return !hoveredHost && !hoveredOverlay && !target.closest('qd-popover');\n      }\n\n      default:\n        return false;\n    }\n  }\n\n  private unsubscribeAll(): void {\n    this._subscriptions.forEach(sub => sub.unsubscribe());\n    this._subscriptions = [];\n  }\n\n  private cleanup(): void {\n    this.sizingService.disconnect();\n    this.overlayRef?.dispose();\n    this._popoverRef = null;\n    this.unsubscribeAll();\n  }\n}\n"]}

package/esm2022/lib/core/popover/popover-on-hover/popover-on-hover.directive.mjs

@@ -0,0 +1,91 @@
+// @ts-strict-ignore
+import { Overlay, OverlayPositionBuilder } from '@angular/cdk/overlay';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { Directive, ElementRef, EventEmitter, HostListener, Input, Output, TemplateRef } from '@angular/core';
+import { convertPxToRem } from '../../tools/convertPxToRem.tools';
+import { QdPopoverService } from '../popover.service';
+import { QdPopoverComponent } from '../popover/popover.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+import * as i2 from "../popover.service";
+export class QdPopoverOnHoverDirective {
+    hostRef;
+    overlayPositionBuilder;
+    overlay;
+    popoverService;
+    host;
+    overlayRef;
+    closeSubscription;
+    qdPopoverOnHover;
+    qdPopoverWidth = convertPxToRem(204);
+    positionStrategy;
+    opened = new EventEmitter();
+    closed = new EventEmitter();
+    constructor(hostRef, overlayPositionBuilder, overlay, popoverService) {
+        this.hostRef = hostRef;
+        this.overlayPositionBuilder = overlayPositionBuilder;
+        this.overlay = overlay;
+        this.popoverService = popoverService;
+        this.host = this.hostRef.nativeElement;
+    }
+    ngOnInit() {
+        const positionStrategy = this.overlayPositionBuilder.flexibleConnectedTo(this.host).withPositions([
+            ...(this.positionStrategy ? [this.positionStrategy] : []),
+            {
+                originX: 'end',
+                originY: 'bottom',
+                overlayX: 'end',
+                overlayY: 'top'
+            }
+        ]);
+        this.overlayRef = this.overlay.create({ positionStrategy, width: this.qdPopoverWidth, disposeOnNavigation: true });
+    }
+    ngOnDestroy() {
+        this.close();
+    }
+    show(event) {
+        event.stopPropagation();
+        if (!this.overlayRef.hasAttached()) {
+            const popoverPortal = new ComponentPortal(QdPopoverComponent);
+            const popoverRef = this.overlayRef.attach(popoverPortal);
+            popoverRef.instance.content = this.qdPopoverOnHover;
+            this.opened.emit();
+            this.popoverService.closeAllOverlays();
+            this.closeSubscription = this.popoverService.subscribe(() => this.close());
+        }
+    }
+    hoveredOutside() {
+        if (this.overlayRef.hasAttached() && !this.overlayRef.overlayElement.querySelector(':hover'))
+            this.close();
+    }
+    close() {
+        this.overlayRef?.detach();
+        this.closeSubscription?.unsubscribe();
+        this.closed.emit();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdPopoverOnHoverDirective, deps: [{ token: i0.ElementRef }, { token: i1.OverlayPositionBuilder }, { token: i1.Overlay }, { token: i2.QdPopoverService }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.9", type: QdPopoverOnHoverDirective, selector: "[qdPopoverOnHover]", inputs: { qdPopoverOnHover: "qdPopoverOnHover", qdPopoverWidth: "qdPopoverWidth", positionStrategy: "positionStrategy" }, outputs: { opened: "opened", closed: "closed" }, host: { listeners: { "mouseover": "show($event)", "document:mouseout": "hoveredOutside($event)" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdPopoverOnHoverDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[qdPopoverOnHover]'
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i1.OverlayPositionBuilder }, { type: i1.Overlay }, { type: i2.QdPopoverService }], propDecorators: { qdPopoverOnHover: [{
+                type: Input
+            }], qdPopoverWidth: [{
+                type: Input
+            }], positionStrategy: [{
+                type: Input
+            }], opened: [{
+                type: Output
+            }], closed: [{
+                type: Output
+            }], show: [{
+                type: HostListener,
+                args: ['mouseover', ['$event']]
+            }], hoveredOutside: [{
+                type: HostListener,
+                args: ['document:mouseout', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9wb3Zlci1vbi1ob3Zlci5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL3FkLXVpL3NyYy9saWIvY29yZS9wb3BvdmVyL3BvcG92ZXItb24taG92ZXIvcG9wb3Zlci1vbi1ob3Zlci5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE9BQU8sRUFBcUIsT0FBTyxFQUFFLHNCQUFzQixFQUFjLE1BQU0sc0JBQXNCLENBQUM7QUFDdEcsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQ3RELE9BQU8sRUFDTCxTQUFTLEVBQ1QsVUFBVSxFQUNWLFlBQVksRUFDWixZQUFZLEVBQ1osS0FBSyxFQUdMLE1BQU0sRUFDTixXQUFXLEVBQ1osTUFBTSxlQUFlLENBQUM7QUFFdkIsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBQ2xFLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQ3RELE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLDhCQUE4QixDQUFDOzs7O0FBS2xFLE1BQU0sT0FBTyx5QkFBeUI7SUFhMUI7SUFDQTtJQUNBO0lBQ0E7SUFmRixJQUFJLENBQWM7SUFDbEIsVUFBVSxDQUFhO0lBQ3ZCLGlCQUFpQixDQUFlO0lBRS9CLGdCQUFnQixDQUF1QjtJQUN2QyxjQUFjLEdBQW9CLGNBQWMsQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUN0RCxnQkFBZ0IsQ0FBb0I7SUFFMUIsTUFBTSxHQUFHLElBQUksWUFBWSxFQUFFLENBQUM7SUFDNUIsTUFBTSxHQUFHLElBQUksWUFBWSxFQUFFLENBQUM7SUFFL0MsWUFDVSxPQUFnQyxFQUNoQyxzQkFBOEMsRUFDOUMsT0FBZ0IsRUFDaEIsY0FBZ0M7UUFIaEMsWUFBTyxHQUFQLE9BQU8sQ0FBeUI7UUFDaEMsMkJBQXNCLEdBQXRCLHNCQUFzQixDQUF3QjtRQUM5QyxZQUFPLEdBQVAsT0FBTyxDQUFTO1FBQ2hCLG1CQUFjLEdBQWQsY0FBYyxDQUFrQjtRQUV4QyxJQUFJLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQyxPQUFPLENBQUMsYUFBYSxDQUFDO0lBQ3pDLENBQUM7SUFFRCxRQUFRO1FBQ04sTUFBTSxnQkFBZ0IsR0FBRyxJQUFJLENBQUMsc0JBQXNCLENBQUMsbUJBQW1CLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDLGFBQWEsQ0FBQztZQUNoRyxHQUFHLENBQUMsSUFBSSxDQUFDLGdCQUFnQixDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUM7WUFDekQ7Z0JBQ0UsT0FBTyxFQUFFLEtBQUs7Z0JBQ2QsT0FBTyxFQUFFLFFBQVE7Z0JBQ2pCLFFBQVEsRUFBRSxLQUFLO2dCQUNmLFFBQVEsRUFBRSxLQUFLO2FBQ2hCO1NBQ0YsQ0FBQyxDQUFDO1FBRUgsSUFBSSxDQUFDLFVBQVUsR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxFQUFFLGdCQUFnQixFQUFFLEtBQUssRUFBRSxJQUFJLENBQUMsY0FBYyxFQUFFLG1CQUFtQixFQUFFLElBQUksRUFBRSxDQUFDLENBQUM7SUFDckgsQ0FBQztJQUVELFdBQVc7UUFDVCxJQUFJLENBQUMsS0FBSyxFQUFFLENBQUM7SUFDZixDQUFDO0lBR0QsSUFBSSxDQUFDLEtBQVU7UUFDYixLQUFLLENBQUMsZUFBZSxFQUFFLENBQUM7UUFDeEIsSUFBSSxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsV0FBVyxFQUFFLEVBQUUsQ0FBQztZQUNuQyxNQUFNLGFBQWEsR0FBRyxJQUFJLGVBQWUsQ0FBQyxrQkFBa0IsQ0FBQyxDQUFDO1lBQzlELE1BQU0sVUFBVSxHQUFHLElBQUksQ0FBQyxVQUFVLENBQUMsTUFBTSxDQUFDLGFBQWEsQ0FBQyxDQUFDO1lBRXpELFVBQVUsQ0FBQyxRQUFRLENBQUMsT0FBTyxHQUFHLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQztZQUNwRCxJQUFJLENBQUMsTUFBTSxDQUFDLElBQUksRUFBRSxDQUFDO1lBRW5CLElBQUksQ0FBQyxjQUFjLENBQUMsZ0JBQWdCLEVBQUUsQ0FBQztZQUV2QyxJQUFJLENBQUMsaUJBQWlCLEdBQUcsSUFBSSxDQUFDLGNBQWMsQ0FBQyxTQUFTLENBQUMsR0FBRyxFQUFFLENBQUMsSUFBSSxDQUFDLEtBQUssRUFBRSxDQUFDLENBQUM7UUFDN0UsQ0FBQztJQUNILENBQUM7SUFHRCxjQUFjO1FBQ1osSUFBSSxJQUFJLENBQUMsVUFBVSxDQUFDLFdBQVcsRUFBRSxJQUFJLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxjQUFjLENBQUMsYUFBYSxDQUFDLFFBQVEsQ0FBQztZQUFFLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQztJQUM3RyxDQUFDO0lBRUQsS0FBSztRQUNILElBQUksQ0FBQyxVQUFVLEVBQUUsTUFBTSxFQUFFLENBQUM7UUFDMUIsSUFBSSxDQUFDLGlCQUFpQixFQUFFLFdBQVcsRUFBRSxDQUFDO1FBQ3RDLElBQUksQ0FBQyxNQUFNLENBQUMsSUFBSSxFQUFFLENBQUM7SUFDckIsQ0FBQzt1R0FoRVUseUJBQXlCOzJGQUF6Qix5QkFBeUI7OzJGQUF6Qix5QkFBeUI7a0JBSHJDLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLG9CQUFvQjtpQkFDL0I7eUtBTVUsZ0JBQWdCO3NCQUF4QixLQUFLO2dCQUNHLGNBQWM7c0JBQXRCLEtBQUs7Z0JBQ0csZ0JBQWdCO3NCQUF4QixLQUFLO2dCQUVhLE1BQU07c0JBQXhCLE1BQU07Z0JBQ1ksTUFBTTtzQkFBeEIsTUFBTTtnQkE4QlAsSUFBSTtzQkFESCxZQUFZO3VCQUFDLFdBQVcsRUFBRSxDQUFDLFFBQVEsQ0FBQztnQkFpQnJDLGNBQWM7c0JBRGIsWUFBWTt1QkFBQyxtQkFBbUIsRUFBRSxDQUFDLFFBQVEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIEB0cy1zdHJpY3QtaWdub3JlXG5pbXBvcnQgeyBDb25uZWN0ZWRQb3NpdGlvbiwgT3ZlcmxheSwgT3ZlcmxheVBvc2l0aW9uQnVpbGRlciwgT3ZlcmxheVJlZiB9IGZyb20gJ0Bhbmd1bGFyL2Nkay9vdmVybGF5JztcbmltcG9ydCB7IENvbXBvbmVudFBvcnRhbCB9IGZyb20gJ0Bhbmd1bGFyL2Nkay9wb3J0YWwnO1xuaW1wb3J0IHtcbiAgRGlyZWN0aXZlLFxuICBFbGVtZW50UmVmLFxuICBFdmVudEVtaXR0ZXIsXG4gIEhvc3RMaXN0ZW5lcixcbiAgSW5wdXQsXG4gIE9uRGVzdHJveSxcbiAgT25Jbml0LFxuICBPdXRwdXQsXG4gIFRlbXBsYXRlUmVmXG59IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgU3Vic2NyaXB0aW9uIH0gZnJvbSAncnhqcyc7XG5pbXBvcnQgeyBjb252ZXJ0UHhUb1JlbSB9IGZyb20gJy4uLy4uL3Rvb2xzL2NvbnZlcnRQeFRvUmVtLnRvb2xzJztcbmltcG9ydCB7IFFkUG9wb3ZlclNlcnZpY2UgfSBmcm9tICcuLi9wb3BvdmVyLnNlcnZpY2UnO1xuaW1wb3J0IHsgUWRQb3BvdmVyQ29tcG9uZW50IH0gZnJvbSAnLi4vcG9wb3Zlci9wb3BvdmVyLmNvbXBvbmVudCc7XG5cbkBEaXJlY3RpdmUoe1xuICBzZWxlY3RvcjogJ1txZFBvcG92ZXJPbkhvdmVyXSdcbn0pXG5leHBvcnQgY2xhc3MgUWRQb3BvdmVyT25Ib3ZlckRpcmVjdGl2ZSBpbXBsZW1lbnRzIE9uSW5pdCwgT25EZXN0cm95IHtcbiAgcHJpdmF0ZSBob3N0OiBIVE1MRWxlbWVudDtcbiAgcHJpdmF0ZSBvdmVybGF5UmVmOiBPdmVybGF5UmVmO1xuICBwcml2YXRlIGNsb3NlU3Vic2NyaXB0aW9uOiBTdWJzY3JpcHRpb247XG5cbiAgQElucHV0KCkgcWRQb3BvdmVyT25Ib3ZlcjogVGVtcGxhdGVSZWY8dW5rbm93bj47XG4gIEBJbnB1dCgpIHFkUG9wb3ZlcldpZHRoOiBzdHJpbmcgfCAnYXV0bycgPSBjb252ZXJ0UHhUb1JlbSgyMDQpO1xuICBASW5wdXQoKSBwb3NpdGlvblN0cmF0ZWd5OiBDb25uZWN0ZWRQb3NpdGlvbjtcblxuICBAT3V0cHV0KCkgcmVhZG9ubHkgb3BlbmVkID0gbmV3IEV2ZW50RW1pdHRlcigpO1xuICBAT3V0cHV0KCkgcmVhZG9ubHkgY2xvc2VkID0gbmV3IEV2ZW50RW1pdHRlcigpO1xuXG4gIGNvbnN0cnVjdG9yKFxuICAgIHByaXZhdGUgaG9zdFJlZjogRWxlbWVudFJlZjxIVE1MRWxlbWVudD4sXG4gICAgcHJpdmF0ZSBvdmVybGF5UG9zaXRpb25CdWlsZGVyOiBPdmVybGF5UG9zaXRpb25CdWlsZGVyLFxuICAgIHByaXZhdGUgb3ZlcmxheTogT3ZlcmxheSxcbiAgICBwcml2YXRlIHBvcG92ZXJTZXJ2aWNlOiBRZFBvcG92ZXJTZXJ2aWNlXG4gICkge1xuICAgIHRoaXMuaG9zdCA9IHRoaXMuaG9zdFJlZi5uYXRpdmVFbGVtZW50O1xuICB9XG5cbiAgbmdPbkluaXQoKTogdm9pZCB7XG4gICAgY29uc3QgcG9zaXRpb25TdHJhdGVneSA9IHRoaXMub3ZlcmxheVBvc2l0aW9uQnVpbGRlci5mbGV4aWJsZUNvbm5lY3RlZFRvKHRoaXMuaG9zdCkud2l0aFBvc2l0aW9ucyhbXG4gICAgICAuLi4odGhpcy5wb3NpdGlvblN0cmF0ZWd5ID8gW3RoaXMucG9zaXRpb25TdHJhdGVneV0gOiBbXSksXG4gICAgICB7XG4gICAgICAgIG9yaWdpblg6ICdlbmQnLFxuICAgICAgICBvcmlnaW5ZOiAnYm90dG9tJyxcbiAgICAgICAgb3ZlcmxheVg6ICdlbmQnLFxuICAgICAgICBvdmVybGF5WTogJ3RvcCdcbiAgICAgIH1cbiAgICBdKTtcblxuICAgIHRoaXMub3ZlcmxheVJlZiA9IHRoaXMub3ZlcmxheS5jcmVhdGUoeyBwb3NpdGlvblN0cmF0ZWd5LCB3aWR0aDogdGhpcy5xZFBvcG92ZXJXaWR0aCwgZGlzcG9zZU9uTmF2aWdhdGlvbjogdHJ1ZSB9KTtcbiAgfVxuXG4gIG5nT25EZXN0cm95KCk6IHZvaWQge1xuICAgIHRoaXMuY2xvc2UoKTtcbiAgfVxuXG4gIEBIb3N0TGlzdGVuZXIoJ21vdXNlb3ZlcicsIFsnJGV2ZW50J10pXG4gIHNob3coZXZlbnQ6IGFueSk6IHZvaWQge1xuICAgIGV2ZW50LnN0b3BQcm9wYWdhdGlvbigpO1xuICAgIGlmICghdGhpcy5vdmVybGF5UmVmLmhhc0F0dGFjaGVkKCkpIHtcbiAgICAgIGNvbnN0IHBvcG92ZXJQb3J0YWwgPSBuZXcgQ29tcG9uZW50UG9ydGFsKFFkUG9wb3ZlckNvbXBvbmVudCk7XG4gICAgICBjb25zdCBwb3BvdmVyUmVmID0gdGhpcy5vdmVybGF5UmVmLmF0dGFjaChwb3BvdmVyUG9ydGFsKTtcblxuICAgICAgcG9wb3ZlclJlZi5pbnN0YW5jZS5jb250ZW50ID0gdGhpcy5xZFBvcG92ZXJPbkhvdmVyO1xuICAgICAgdGhpcy5vcGVuZWQuZW1pdCgpO1xuXG4gICAgICB0aGlzLnBvcG92ZXJTZXJ2aWNlLmNsb3NlQWxsT3ZlcmxheXMoKTtcblxuICAgICAgdGhpcy5jbG9zZVN1YnNjcmlwdGlvbiA9IHRoaXMucG9wb3ZlclNlcnZpY2Uuc3Vic2NyaWJlKCgpID0+IHRoaXMuY2xvc2UoKSk7XG4gICAgfVxuICB9XG5cbiAgQEhvc3RMaXN0ZW5lcignZG9jdW1lbnQ6bW91c2VvdXQnLCBbJyRldmVudCddKVxuICBob3ZlcmVkT3V0c2lkZSgpOiB2b2lkIHtcbiAgICBpZiAodGhpcy5vdmVybGF5UmVmLmhhc0F0dGFjaGVkKCkgJiYgIXRoaXMub3ZlcmxheVJlZi5vdmVybGF5RWxlbWVudC5xdWVyeVNlbGVjdG9yKCc6aG92ZXInKSkgdGhpcy5jbG9zZSgpO1xuICB9XG5cbiAgY2xvc2UoKTogdm9pZCB7XG4gICAgdGhpcy5vdmVybGF5UmVmPy5kZXRhY2goKTtcbiAgICB0aGlzLmNsb3NlU3Vic2NyaXB0aW9uPy51bnN1YnNjcmliZSgpO1xuICAgIHRoaXMuY2xvc2VkLmVtaXQoKTtcbiAgfVxufVxuIl19

package/esm2022/lib/core/popover/popover-parent.service.mjs

@@ -0,0 +1,11 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class QdPopoverParentService {
+    parentPopovers = [];
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdPopoverParentService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdPopoverParentService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdPopoverParentService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9wb3Zlci1wYXJlbnQuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvcWQtdWkvc3JjL2xpYi9jb3JlL3BvcG92ZXIvcG9wb3Zlci1wYXJlbnQuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUkzQyxNQUFNLE9BQU8sc0JBQXNCO0lBQ2pDLGNBQWMsR0FBeUIsRUFBRSxDQUFDO3VHQUQvQixzQkFBc0I7MkdBQXRCLHNCQUFzQjs7MkZBQXRCLHNCQUFzQjtrQkFEbEMsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFFkUG9wb3ZlckNvbXBvbmVudCB9IGZyb20gJy4vcG9wb3Zlci9wb3BvdmVyLmNvbXBvbmVudCc7XG5cbkBJbmplY3RhYmxlKClcbmV4cG9ydCBjbGFzcyBRZFBvcG92ZXJQYXJlbnRTZXJ2aWNlIHtcbiAgcGFyZW50UG9wb3ZlcnM6IFFkUG9wb3ZlckNvbXBvbmVudFtdID0gW107XG59XG4iXX0=

package/esm2022/lib/core/popover/popover-sizing.service.mjs

@@ -0,0 +1,163 @@
+import { Injectable } from '@angular/core';
+import { Observable, ReplaySubject } from 'rxjs';
+import { convertPxToRem } from '../tools/convertPxToRem.tools';
+import * as i0 from "@angular/core";
+/**
+ * **QdPopoverSizingService**
+ *
+ * A utility service to dynamically size and constrain popover overlays in Angular applications.
+ *
+ * This service is designed for use with popover components created via Angular CDK Overlay. It
+ * ensures that popovers automatically fit their host or content, respect min/max constraints, and
+ * respond to live size changes (e.g. window resize).
+ *
+ * #### Features:
+ * - Dynamically measures popover content width and height, even if hidden.
+ * - Applies minWidth, maxWidth, and maxHeight constraints.
+ * - Optionally auto-sizes popover overlays to match host or content size (width/height).
+ * - Supports smooth, flicker-free opening via overlay opacity control.
+ * - Cleans up all listeners and state on disconnect.
+ * - Exposes latest measured content size for debugging or analytics.
+ *
+ * #### Notes & Best Practices
+ * - Internally, the service uses a hidden DOM clone to measure popover content, following best-practice patterns for measuring off-screen elements.
+ * - Use the `contentWidth` and `contentHeight` getters for debugging or if you need to react to the last measured content size.
+ * - The service will automatically hide the overlay until sizing is complete, preventing layout flicker.
+ * - The returned Observable emits `true` once initial sizing is applied and overlay is visible.
+ * - Even if autosize is turned off, the minimum and maximum width or height constraints are always enforced as hard limits.
+ * - This means the popover can never be smaller or larger than the values you set, no matter what content it contains.
+ *
+ * #### For the hidden-content measuring
+ * @see https://stackoverflow.com/questions/1841124/find-the-potential-width-of-a-hidden-element
+ */
+export class QdPopoverSizingService {
+    _resizeObserver;
+    _host;
+    _popover;
+    _autoSize;
+    _constraints;
+    _overlayRef;
+    _ready$;
+    _contentWidth = 0;
+    _contentHeight = 0;
+    get contentWidth() {
+        return this._contentWidth;
+    }
+    get contentHeight() {
+        return this._contentHeight;
+    }
+    observe(host, popover, overlayRef, autoSize, constraints) {
+        this.disconnect();
+        if (!host || !popover || !overlayRef)
+            return new Observable(subscriber => subscriber.complete());
+        this._host = host;
+        this._popover = popover;
+        this._autoSize = autoSize;
+        this._constraints = constraints;
+        this._overlayRef = overlayRef;
+        this._ready$ = new ReplaySubject(1);
+        this.hideOverlay();
+        if (!autoSize.width && !autoSize.height) {
+            this.applySize();
+            this.showOverlay();
+            this._ready$.next(true);
+            this._ready$.complete();
+            return this._ready$.asObservable();
+        }
+        Promise.resolve().then(() => {
+            this.applySize();
+            this.showOverlay();
+            this._ready$?.next(true);
+            this._ready$?.complete();
+        });
+        this._resizeObserver = new ResizeObserver(() => this.applySize());
+        this._resizeObserver.observe(host);
+        this._resizeObserver.observe(popover);
+        return this._ready$.asObservable();
+    }
+    showOverlay() {
+        if (this._overlayRef)
+            this._overlayRef.overlayElement.style.opacity = '1';
+    }
+    hideOverlay() {
+        if (this._overlayRef)
+            this._overlayRef.overlayElement.style.opacity = '0';
+    }
+    applySize() {
+        if (!this._overlayRef || !this._host || !this._popover || !this._autoSize || !this._constraints)
+            return;
+        const minWidth = this._constraints.minWidth !== 'none' ? this._constraints.minWidth : undefined;
+        const maxWidth = this._constraints.maxWidth !== 'none' ? this._constraints.maxWidth : undefined;
+        const maxHeight = this._constraints.maxHeight !== 'none' ? this._constraints.maxHeight : undefined;
+        this.measureContentSize(this._popover);
+        const contentWidth = this._contentWidth;
+        const contentHeight = this._contentHeight;
+        const hostWidth = this._host.getBoundingClientRect().width;
+        const hostHeight = this._host.getBoundingClientRect().height;
+        let width;
+        let height;
+        if (this._autoSize.width)
+            width = this.clamp(Math.max(hostWidth, contentWidth), minWidth, maxWidth);
+        if (this._autoSize.height)
+            height = this.clamp(Math.max(hostHeight, contentHeight), undefined, maxHeight);
+        const el = this._overlayRef.overlayElement;
+        el.style.width = '';
+        el.style.minWidth = '';
+        el.style.maxWidth = '';
+        el.style.height = '';
+        el.style.maxHeight = '';
+        if (this._autoSize.width && width !== undefined)
+            el.style.width = convertPxToRem(width);
+        if (minWidth !== undefined)
+            el.style.minWidth = convertPxToRem(minWidth);
+        if (maxWidth !== undefined)
+            el.style.maxWidth = convertPxToRem(maxWidth);
+        if (this._autoSize.height && height !== undefined)
+            el.style.height = convertPxToRem(height);
+        if (maxHeight !== undefined)
+            el.style.maxHeight = convertPxToRem(maxHeight);
+    }
+    measureContentSize(element) {
+        const clone = element.cloneNode(true);
+        clone.style.visibility = 'hidden';
+        clone.style.position = 'absolute';
+        clone.style.pointerEvents = 'none';
+        clone.style.width = 'auto';
+        clone.style.minWidth = 'auto';
+        clone.style.maxWidth = 'none';
+        clone.style.height = 'auto';
+        clone.style.minHeight = 'auto';
+        clone.style.maxHeight = 'none';
+        clone.style.left = '-10000px';
+        clone.style.top = '-10000px';
+        document.body.appendChild(clone);
+        this._contentWidth = clone.scrollWidth;
+        this._contentHeight = clone.scrollHeight;
+        document.body.removeChild(clone);
+    }
+    disconnect() {
+        this._resizeObserver?.disconnect();
+        this._resizeObserver = undefined;
+        this._host = undefined;
+        this._popover = undefined;
+        this._autoSize = undefined;
+        this._constraints = undefined;
+        this._overlayRef = undefined;
+        this._ready$ = undefined;
+        this._contentWidth = 0;
+        this._contentHeight = 0;
+    }
+    clamp(value, min, max) {
+        if (min !== undefined)
+            value = Math.max(value, min);
+        if (max !== undefined)
+            value = Math.min(value, max);
+        return value;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdPopoverSizingService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdPopoverSizingService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdPopoverSizingService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"popover-sizing.service.js","sourceRoot":"","sources":["../../../../../../libs/qd-ui/src/lib/core/popover/popover-sizing.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { OverlayRef } from '@angular/cdk/overlay';\nimport { Observable, ReplaySubject } from 'rxjs';\n\nimport { convertPxToRem } from '../tools/convertPxToRem.tools';\n\nexport interface QdPopoverAutoSizeConfig {\n  width?: boolean;\n  height?: boolean;\n}\nexport interface QdPopoverSizeConstraints {\n  minWidth?: number | 'none';\n  maxWidth?: number | 'none';\n  maxHeight?: number | 'none';\n}\n\n/**\n * **QdPopoverSizingService**\n *\n * A utility service to dynamically size and constrain popover overlays in Angular applications.\n *\n * This service is designed for use with popover components created via Angular CDK Overlay. It\n * ensures that popovers automatically fit their host or content, respect min/max constraints, and\n * respond to live size changes (e.g. window resize).\n *\n * #### Features:\n * - Dynamically measures popover content width and height, even if hidden.\n * - Applies minWidth, maxWidth, and maxHeight constraints.\n * - Optionally auto-sizes popover overlays to match host or content size (width/height).\n * - Supports smooth, flicker-free opening via overlay opacity control.\n * - Cleans up all listeners and state on disconnect.\n * - Exposes latest measured content size for debugging or analytics.\n *\n * #### Notes & Best Practices\n * - Internally, the service uses a hidden DOM clone to measure popover content, following best-practice patterns for measuring off-screen elements.\n * - Use the `contentWidth` and `contentHeight` getters for debugging or if you need to react to the last measured content size.\n * - The service will automatically hide the overlay until sizing is complete, preventing layout flicker.\n * - The returned Observable emits `true` once initial sizing is applied and overlay is visible.\n * - Even if autosize is turned off, the minimum and maximum width or height constraints are always enforced as hard limits.\n * - This means the popover can never be smaller or larger than the values you set, no matter what content it contains.\n *\n * #### For the hidden-content measuring\n * @see https://stackoverflow.com/questions/1841124/find-the-potential-width-of-a-hidden-element\n */\n@Injectable()\nexport class QdPopoverSizingService {\n  private _resizeObserver?: ResizeObserver;\n  private _host?: HTMLElement;\n  private _popover?: HTMLElement;\n  private _autoSize?: QdPopoverAutoSizeConfig;\n  private _constraints?: QdPopoverSizeConstraints;\n  private _overlayRef?: OverlayRef;\n  private _ready$?: ReplaySubject<boolean>;\n  private _contentWidth = 0;\n  private _contentHeight = 0;\n\n  get contentWidth(): number {\n    return this._contentWidth;\n  }\n\n  get contentHeight(): number {\n    return this._contentHeight;\n  }\n\n  observe(\n    host: HTMLElement,\n    popover: HTMLElement,\n    overlayRef: OverlayRef,\n    autoSize: QdPopoverAutoSizeConfig,\n    constraints: QdPopoverSizeConstraints\n  ): Observable<boolean> {\n    this.disconnect();\n\n    if (!host || !popover || !overlayRef) return new Observable<boolean>(subscriber => subscriber.complete());\n\n    this._host = host;\n    this._popover = popover;\n    this._autoSize = autoSize;\n    this._constraints = constraints;\n    this._overlayRef = overlayRef;\n    this._ready$ = new ReplaySubject<boolean>(1);\n\n    this.hideOverlay();\n\n    if (!autoSize.width && !autoSize.height) {\n      this.applySize();\n      this.showOverlay();\n      this._ready$.next(true);\n      this._ready$.complete();\n      return this._ready$.asObservable();\n    }\n\n    Promise.resolve().then(() => {\n      this.applySize();\n      this.showOverlay();\n      this._ready$?.next(true);\n      this._ready$?.complete();\n    });\n\n    this._resizeObserver = new ResizeObserver(() => this.applySize());\n    this._resizeObserver.observe(host);\n    this._resizeObserver.observe(popover);\n\n    return this._ready$.asObservable();\n  }\n\n  private showOverlay(): void {\n    if (this._overlayRef) this._overlayRef.overlayElement.style.opacity = '1';\n  }\n\n  private hideOverlay(): void {\n    if (this._overlayRef) this._overlayRef.overlayElement.style.opacity = '0';\n  }\n\n  private applySize(): void {\n    if (!this._overlayRef || !this._host || !this._popover || !this._autoSize || !this._constraints) return;\n\n    const minWidth = this._constraints.minWidth !== 'none' ? this._constraints.minWidth : undefined;\n    const maxWidth = this._constraints.maxWidth !== 'none' ? this._constraints.maxWidth : undefined;\n    const maxHeight = this._constraints.maxHeight !== 'none' ? this._constraints.maxHeight : undefined;\n\n    this.measureContentSize(this._popover);\n\n    const contentWidth = this._contentWidth;\n    const contentHeight = this._contentHeight;\n    const hostWidth = this._host.getBoundingClientRect().width;\n    const hostHeight = this._host.getBoundingClientRect().height;\n\n    let width: number | undefined;\n    let height: number | undefined;\n\n    if (this._autoSize.width) width = this.clamp(Math.max(hostWidth, contentWidth), minWidth, maxWidth);\n    if (this._autoSize.height) height = this.clamp(Math.max(hostHeight, contentHeight), undefined, maxHeight);\n\n    const el = this._overlayRef.overlayElement;\n    el.style.width = '';\n    el.style.minWidth = '';\n    el.style.maxWidth = '';\n    el.style.height = '';\n    el.style.maxHeight = '';\n\n    if (this._autoSize.width && width !== undefined) el.style.width = convertPxToRem(width);\n    if (minWidth !== undefined) el.style.minWidth = convertPxToRem(minWidth);\n    if (maxWidth !== undefined) el.style.maxWidth = convertPxToRem(maxWidth);\n\n    if (this._autoSize.height && height !== undefined) el.style.height = convertPxToRem(height);\n    if (maxHeight !== undefined) el.style.maxHeight = convertPxToRem(maxHeight);\n  }\n\n  private measureContentSize(element: HTMLElement): void {\n    const clone = element.cloneNode(true) as HTMLElement;\n    clone.style.visibility = 'hidden';\n    clone.style.position = 'absolute';\n    clone.style.pointerEvents = 'none';\n    clone.style.width = 'auto';\n    clone.style.minWidth = 'auto';\n    clone.style.maxWidth = 'none';\n    clone.style.height = 'auto';\n    clone.style.minHeight = 'auto';\n    clone.style.maxHeight = 'none';\n    clone.style.left = '-10000px';\n    clone.style.top = '-10000px';\n    document.body.appendChild(clone);\n\n    this._contentWidth = clone.scrollWidth;\n    this._contentHeight = clone.scrollHeight;\n\n    document.body.removeChild(clone);\n  }\n\n  disconnect(): void {\n    this._resizeObserver?.disconnect();\n    this._resizeObserver = undefined;\n    this._host = undefined;\n    this._popover = undefined;\n    this._autoSize = undefined;\n    this._constraints = undefined;\n    this._overlayRef = undefined;\n    this._ready$ = undefined;\n    this._contentWidth = 0;\n    this._contentHeight = 0;\n  }\n\n  private clamp(value: number, min?: number, max?: number): number {\n    if (min !== undefined) value = Math.max(value, min);\n    if (max !== undefined) value = Math.min(value, max);\n\n    return value;\n  }\n}\n"]}

package/esm2022/lib/core/popover/popover-top-first.token.mjs

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+export const QD_POPOVER_TOP_FIRST = new InjectionToken('QD_POPOVER_TOP_FIRST');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9wb3Zlci10b3AtZmlyc3QudG9rZW4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL3FkLXVpL3NyYy9saWIvY29yZS9wb3BvdmVyL3BvcG92ZXItdG9wLWZpcnN0LnRva2VuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFL0MsTUFBTSxDQUFDLE1BQU0sb0JBQW9CLEdBQUcsSUFBSSxjQUFjLENBQVUsc0JBQXNCLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGlvblRva2VuIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmV4cG9ydCBjb25zdCBRRF9QT1BPVkVSX1RPUF9GSVJTVCA9IG5ldyBJbmplY3Rpb25Ub2tlbjxib29sZWFuPignUURfUE9QT1ZFUl9UT1BfRklSU1QnKTtcbiJdfQ==