@lucca-front/ng 15.3.0 → 16.0.0

package/esm2022/popover/lib/trigger/popover-trigger.model.mjs

@@ -0,0 +1,469 @@
+import { isFakeMousedownFromScreenReader } from '@angular/cdk/a11y';
+import { OverlayConfig, } from '@angular/cdk/overlay';
+import { TemplatePortal } from '@angular/cdk/portal';
+import { generateId } from '@lucca-front/ng/core';
+import { Subject, Subscription, timer } from 'rxjs';
+import { debounce, distinctUntilChanged, map } from 'rxjs/operators';
+// tslint:disable-next-line: max-line-length
+export class ALuPopoverTrigger {
+    /** References the popover instance that the trigger is associated with. */
+    get panel() {
+        return this._panel;
+    }
+    set panel(p) {
+        this._panel = p;
+    }
+    /** References the popover target instance that the trigger is associated with. */
+    get target() {
+        return this._target;
+    }
+    set target(t) {
+        this._target = t;
+    }
+    get triggerEvent() {
+        return this._triggerEvent;
+    }
+    set triggerEvent(te) {
+        this._triggerEvent = te;
+        if (te === 'hover' || te === 'focus') {
+            if (this._hoveredSubscription) {
+                this._hoveredSubscription.unsubscribe();
+            }
+            this._hoveredSubscription = this._hovered$
+                .pipe(distinctUntilChanged(), debounce((h) => (h ? timer(this.enterDelay) : timer(this.leaveDelay))))
+                .subscribe((h) => (h ? this.openPopover() : this.closePopover()));
+        }
+    }
+    get enterDelay() {
+        return this._enterDelay;
+    }
+    set enterDelay(d) {
+        this._enterDelay = d;
+    }
+    get leaveDelay() {
+        return this._leaveDelay;
+    }
+    set leaveDelay(d) {
+        this._leaveDelay = d;
+    }
+    get disabled() {
+        return this._disabled;
+    }
+    set disabled(d) {
+        this._disabled = d;
+    }
+    get whenEllipsis() {
+        return this._whenEllipsis;
+    }
+    set whenEllipsis(we) {
+        this._whenEllipsis = we;
+    }
+    constructor(_overlay, _elementRef, _viewContainerRef) {
+        this._overlay = _overlay;
+        this._elementRef = _elementRef;
+        this._viewContainerRef = _viewContainerRef;
+        this._overlayRef = null;
+        this._popoverOpen = false;
+        this._hovered$ = new Subject();
+        // tracking input type is necessary so it's possible to only auto-focus
+        // the first item of the list when the popover is opened via the keyboard
+        this._openedByMouse = false;
+        this._triggerEvent = 'click';
+        this._enterDelay = 50;
+        this._leaveDelay = 50;
+        this._disabled = false;
+        this._whenEllipsis = false;
+        this._triggerId = `popoverTrigger_${generateId()}`;
+        this._panelId = `popoverPanel_${generateId()}`;
+    }
+    onClick() {
+        if (this.triggerEvent === 'click' && !this.disabled) {
+            this.togglePopover();
+        }
+    }
+    onMouseEnter() {
+        if (this.triggerEvent === 'hover' || this.triggerEvent === 'focus') {
+            this._hovered$.next(true);
+        }
+    }
+    onMouseLeave() {
+        if (this.triggerEvent === 'hover' || this.triggerEvent === 'focus') {
+            this._hovered$.next(false);
+        }
+    }
+    onFocus() {
+        if (this.triggerEvent === 'hover' || this.triggerEvent === 'focus') {
+            this.openPopover();
+        }
+    }
+    onBlur() {
+        if (this.triggerEvent === 'hover' || this.triggerEvent === 'focus') {
+            this.closePopover();
+        }
+    }
+    /** Toggles the popover between the open and closed states. */
+    togglePopover() {
+        return this._popoverOpen ? this.closePopover() : this.openPopover();
+    }
+    /** Opens the popover. */
+    openPopover() {
+        if (!this._popoverOpen && !this._disabled && (!this._whenEllipsis || this._hasEllipsis())) {
+            this._createOverlay();
+            this._attachPortalToOverlay();
+            /** Only subscribe to overlay detachments if trigger event is hover or focus */
+            if (this.triggerEvent === 'hover' || this.triggerEvent === 'focus') {
+                this._subscribeToOverlayDetachments();
+            }
+            /** Only subscribe to backdrop if trigger event is click */
+            if (this.triggerEvent === 'click') {
+                this._subscribeToBackdrop();
+            }
+            /** Only subscribe to mouse enter/leave of the panel if trigger = hover */
+            this._initPopover();
+            this._emitOpen();
+        }
+    }
+    /** Closes the popover. */
+    closePopover() {
+        if (this._overlayRef) {
+            /** Overlay can still be attached if close has been triggered by mouse leave. */
+            if (this._overlayRef.hasAttached()) {
+                this._overlayRef.detach();
+            }
+            /** unsubscribe to backdrop click if it was defined */
+            if (this._backdropSubscription) {
+                // if (this.popover.triggerEvent === 'click') {
+                this._backdropSubscription.unsubscribe();
+            }
+            this._resetPopover();
+            this._emitClose();
+        }
+    }
+    /** Removes the popover from the DOM. */
+    destroyPopover() {
+        if (this._overlayRef) {
+            this._overlayRef.dispose();
+            this._overlayRef = null;
+            this._cleanUpSubscriptions();
+        }
+    }
+    /** Focuses the popover trigger. */
+    focus() {
+        this._elementRef.nativeElement.focus();
+    }
+    _handleMousedown(event) {
+        if (!isFakeMousedownFromScreenReader(event)) {
+            this._openedByMouse = true;
+        }
+    }
+    /** The text direction of the containing app. */
+    get dir() {
+        // return this._dir && this._dir.value === 'rtl' ? 'rtl' : 'ltr';
+        return 'ltr';
+    }
+    /** Return if the popover main positionning is vertical */
+    get isVerticallyPositionned() {
+        const position = this.target.position;
+        return position === 'below' || position === 'above';
+    }
+    _attachPortalToOverlay() {
+        this._overlayRef.attach(this._portal);
+    }
+    _getPanelScrollStrategy() {
+        return this.panel.scrollStrategy;
+    }
+    /**
+     * This method ensures that the popover
+     */
+    _subscribeToPanelEvents() {
+        if (this._overlayRef) {
+            this._panelEventsSubscriptions = new Subscription();
+            if (this.triggerEvent === 'hover' || this.triggerEvent === 'focus') {
+                this._panelEventsSubscriptions.add(this.panel.hovered.subscribe((hovered) => {
+                    this._hovered$.next(hovered);
+                }));
+            }
+            this._panelEventsSubscriptions.add(this.panel.close.subscribe(() => {
+                this.closePopover();
+            }));
+            this._panelEventsSubscriptions.add(this.panel.open.subscribe(() => {
+                this.openPopover();
+            }));
+        }
+    }
+    /**
+     * This method ensures that the popover closes when the overlay has been detached
+     * Detach can occur if we scroll while popover is opened
+     */
+    _subscribeToOverlayDetachments() {
+        if (this._overlayRef) {
+            this._overlayDetachmentsSubscription = this._overlayRef.detachments().subscribe(() => {
+                this._hovered$.next(false);
+            });
+        }
+    }
+    /**
+     * This method ensures that the popover closes when the overlay backdrop is clicked.
+     * We do not use first() here because doing so would not catch clicks from within
+     * the popover, and it would fail to unsubscribe properly. Instead, we unsubscribe
+     * explicitly when the popover is closed or destroyed.
+     */
+    _subscribeToBackdrop() {
+        if (this._overlayRef) {
+            this._backdropSubscription = this._overlayRef.backdropClick().subscribe(() => {
+                this.closePopover();
+            });
+        }
+    }
+    /**
+     * This method sets the popover state to open and focuses the first item if
+     * the popover was opened via the keyboard.
+     */
+    _initPopover() {
+        this._setIsPopoverOpen(true);
+        this.panel.panelId = this._panelId;
+        this.panel.triggerId = this._triggerId;
+        this.panel.keydownEvents$ = this._overlayRef.keydownEvents();
+        this._subscribeToPanelEvents();
+    }
+    /**
+     * This method resets the popover when it's closed, most importantly restoring
+     * focus to the popover trigger if the popover was opened via the keyboard.
+     */
+    _resetPopover() {
+        this._setIsPopoverOpen(false);
+        // Focus only needs to be reset to the host element if the popover was opened
+        // by the keyboard and manually shifted to the first popover item.
+        if (!this._openedByMouse && this.triggerEvent === 'click') {
+            this.focus();
+        }
+        this._openedByMouse = false;
+    }
+    /** set state rather than toggle to support triggers sharing a popover */
+    _setIsPopoverOpen(isOpen) {
+        this._popoverOpen = isOpen;
+        // tell the panel it's opening/closing
+        isOpen ? this.panel.onOpen() : this.panel.onClose();
+    }
+    /**
+     *  This method checks that a valid instance of MdPopover has been passed into
+     *  mdPopoverTriggerFor. If not, an exception is thrown.
+     */
+    _checkPanel() {
+        if (!this.panel) {
+            throw Error(`lu-popover-trigger: must pass in a lu-popover instance.
+      Example:
+      <lu-popover #popover="LuPopover"></lu-popover>
+      <button type="button" [luPopover]="popover"></button>`);
+        }
+    }
+    _checkTarget() {
+        if (!this.target) {
+            throw Error(`lu-popover-trigger: must pass in a popover target instance.`);
+        }
+    }
+    /**
+     *  This method creates the overlay from the provided popover's template and saves its
+     *  OverlayRef so that it can be attached to the DOM when openPopover is called.
+     */
+    _createOverlay() {
+        if (!this._overlayRef) {
+            this._portal = new TemplatePortal(this.panel.templateRef, this._viewContainerRef);
+            const config = this._getOverlayConfig();
+            this._subscribeToPositions(config.positionStrategy);
+            this._overlayRef = this._overlay.create(config);
+        }
+        return this._overlayRef;
+    }
+    /**
+     * This method builds the configuration object needed to create the overlay, the OverlayConfig.
+     * @returns OverlayConfig
+     */
+    _getOverlayConfig() {
+        const overlayState = new OverlayConfig();
+        overlayState.positionStrategy = this._getPosition();
+        /** Display overlay backdrop if trigger event is click */
+        if (this.triggerEvent === 'click') {
+            overlayState.hasBackdrop = true;
+            overlayState.backdropClass = 'cdk-overlay-transparent-backdrop';
+        }
+        overlayState.direction = this.dir;
+        const scrollStrategy = this._getPanelScrollStrategy();
+        switch (scrollStrategy) {
+            case 'block':
+                overlayState.scrollStrategy = this._overlay.scrollStrategies.block();
+                break;
+            case 'close':
+                overlayState.scrollStrategy = this._overlay.scrollStrategies.close();
+                break;
+            default:
+                overlayState.scrollStrategy = this._overlay.scrollStrategies.reposition();
+                break;
+        }
+        return overlayState;
+    }
+    /**
+     * Listens to changes in the position of the overlay and sets the correct classes
+     * on the popover based on the new position. This ensures the animation origin is always
+     * correct, even if a fallback position is used for the overlay.
+     */
+    _subscribeToPositions(position) {
+        this._positionSubscription = position.positionChanges
+            .pipe(map((c) => c.connectionPair), distinctUntilChanged())
+            .subscribe((connectionPair) => {
+            this.panel.setPositionClasses(connectionPair.overlayX, connectionPair.overlayY);
+        });
+    }
+    /**
+     * This method builds the position strategy for the overlay, so the popover is properly connected
+     * to the trigger.
+     * @returns FlexibleConnectedPositionStrategy
+     */
+    _getPosition() {
+        /**
+         * For overriding position element, when LuPopoverTargetAt has a valid element reference.
+         * Useful for sticking popover to parent element and offsetting arrow to trigger element.
+         * If undefined defaults to the trigger element reference.
+         */
+        const element = this.target.elementRef;
+        // if (typeof this.targetElement !== 'undefined' && this.popover) {
+        // 	this.popover.containerPositioning = true;
+        // 	element = this.targetElement._elementRef;
+        // }
+        const connectionPosition = {
+            originX: 'start',
+            originY: 'top',
+        };
+        // Position
+        const position = this.target.position;
+        const overlap = this.target.overlap;
+        if (position === 'above') {
+            connectionPosition.originY = overlap ? 'bottom' : 'top';
+        }
+        else if (position === 'below') {
+            connectionPosition.originY = overlap ? 'top' : 'bottom';
+        }
+        else if (position === 'before') {
+            connectionPosition.originX = overlap ? 'end' : 'start';
+        }
+        else if (position === 'after') {
+            connectionPosition.originX = overlap ? 'start' : 'end';
+        }
+        // Alignment
+        const alignment = this.target.alignment;
+        if (this.isVerticallyPositionned) {
+            if (alignment === 'left') {
+                connectionPosition.originX = 'start';
+            }
+            else if (alignment === 'right') {
+                connectionPosition.originX = 'end';
+            }
+            else {
+                connectionPosition.originX = 'center';
+            }
+        }
+        else {
+            if (alignment === 'top') {
+                connectionPosition.originY = 'top';
+            }
+            else if (alignment === 'bottom') {
+                connectionPosition.originY = 'bottom';
+            }
+            else {
+                connectionPosition.originY = 'center';
+            }
+        }
+        const overlayPosition = {
+            overlayX: 'start',
+            overlayY: 'top',
+        };
+        if (overlap) {
+            overlayPosition.overlayX = connectionPosition.originX;
+            overlayPosition.overlayY = connectionPosition.originY;
+        }
+        else if (this.isVerticallyPositionned) {
+            overlayPosition.overlayX = connectionPosition.originX;
+            overlayPosition.overlayY = position === 'above' ? 'bottom' : 'top';
+        }
+        else {
+            overlayPosition.overlayX = position === 'before' ? 'end' : 'start';
+            overlayPosition.overlayY = connectionPosition.originY;
+        }
+        return this._overlay
+            .position()
+            .flexibleConnectedTo(element)
+            .withPositions([
+            {
+                originX: connectionPosition.originX,
+                originY: connectionPosition.originY,
+                overlayX: overlayPosition.overlayX,
+                overlayY: overlayPosition.overlayY,
+            },
+            {
+                originX: connectionPosition.originX,
+                originY: this._invertVerticalPos(connectionPosition.originY),
+                overlayX: overlayPosition.overlayX,
+                overlayY: this._invertVerticalPos(overlayPosition.overlayY),
+            },
+            {
+                originX: this._invertHorizontalPos(connectionPosition.originX),
+                originY: connectionPosition.originY,
+                overlayX: this._invertHorizontalPos(overlayPosition.overlayX),
+                overlayY: overlayPosition.overlayY,
+            },
+            {
+                originX: this._invertHorizontalPos(connectionPosition.originX),
+                originY: this._invertVerticalPos(connectionPosition.originY),
+                overlayX: this._invertHorizontalPos(overlayPosition.overlayX),
+                overlayY: this._invertVerticalPos(overlayPosition.overlayY),
+            },
+        ])
+            .withDefaultOffsetX(this.target.offsetX)
+            .withDefaultOffsetY(this.target.offsetY);
+    }
+    _invertVerticalPos(y) {
+        if (y === 'top') {
+            y = 'bottom';
+        }
+        else if (y === 'bottom') {
+            y = 'top';
+        }
+        return y;
+    }
+    _invertHorizontalPos(x) {
+        if (x === 'end') {
+            x = 'start';
+        }
+        else if (x === 'start') {
+            x = 'end';
+        }
+        return x;
+    }
+    _cleanUpSubscriptions() {
+        if (this._backdropSubscription) {
+            this._backdropSubscription.unsubscribe();
+        }
+        if (this._positionSubscription) {
+            this._positionSubscription.unsubscribe();
+        }
+        if (this._hoveredSubscription) {
+            this._hoveredSubscription.unsubscribe();
+        }
+        if (this._panelEventsSubscriptions) {
+            this._panelEventsSubscriptions.unsubscribe();
+        }
+        if (this._overlayDetachmentsSubscription) {
+            this._overlayDetachmentsSubscription.unsubscribe();
+        }
+    }
+    _hasEllipsis() {
+        if (!(this._elementRef.nativeElement instanceof HTMLElement)) {
+            return false;
+        }
+        const { scrollWidth, scrollHeight, clientWidth, clientHeight } = this._elementRef.nativeElement;
+        const textClampedByWidth = scrollWidth > clientWidth;
+        const textClampedByHeight = scrollHeight > clientHeight;
+        return textClampedByWidth || textClampedByHeight;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"popover-trigger.model.js","sourceRoot":"","sources":["../../../../../../packages/ng/popover/src/lib/trigger/popover-trigger.model.ts"],"names":[],"mappings":"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","sourcesContent":["import { isFakeMousedownFromScreenReader } from '@angular/cdk/a11y';\r\nimport { Direction } from '@angular/cdk/bidi';\r\nimport {\r\n\tFlexibleConnectedPositionStrategy,\r\n\tHorizontalConnectionPos,\r\n\tOriginConnectionPosition,\r\n\tOverlay,\r\n\tOverlayConfig,\r\n\tOverlayConnectionPosition,\r\n\tOverlayRef,\r\n\tVerticalConnectionPos,\r\n} from '@angular/cdk/overlay';\r\nimport { ComponentPortal, TemplatePortal } from '@angular/cdk/portal';\r\nimport { ElementRef, ViewContainerRef } from '@angular/core';\r\nimport { generateId } from '@lucca-front/ng/core';\r\nimport { Observable, Subject, Subscription, timer } from 'rxjs';\r\nimport { debounce, distinctUntilChanged, map } from 'rxjs/operators';\r\nimport { ILuPopoverPanel, LuPopoverScrollStrategy } from '../panel/index';\r\nimport { ILuPopoverTarget } from '../target/index';\r\n\r\nexport type LuPopoverTriggerEvent = 'click' | 'hover' | 'none' | 'focus';\r\n\r\n/**\r\n * component that will decide when to show the popover and attach it to the target\r\n */\r\nexport declare interface ILuPopoverTrigger<TPanel extends ILuPopoverPanel = ILuPopoverPanel, TTarget extends ILuPopoverTarget = ILuPopoverTarget> {\r\n\t/** the popover panel to display */\r\n\tpanel: TPanel;\r\n\t/** the popover target to attach the panel */\r\n\ttarget: TTarget;\r\n\r\n\t/** when to display the popover */\r\n\ttriggerEvent: LuPopoverTriggerEvent;\r\n\t/** delay before popover apparition when trigger is 'hover' */\r\n\tenterDelay: number;\r\n\t/** delay before popover disparition when trigger is 'hover' */\r\n\tleaveDelay: number;\r\n\r\n\t/** disable popover apparition */\r\n\tdisabled: boolean;\r\n\t/** Event emitted when the associated popover is opened. */\r\n\tonOpen: Observable<void>;\r\n\t/** Event emitted when the associated popover is closed. */\r\n\tonClose: Observable<void>;\r\n\r\n\topenPopover();\r\n\tclosePopover();\r\n\ttogglePopover();\r\n\tdestroyPopover();\r\n}\r\n\r\n// tslint:disable-next-line: max-line-length\r\nexport abstract class ALuPopoverTrigger<TPanel extends ILuPopoverPanel = ILuPopoverPanel, TTarget extends ILuPopoverTarget = ILuPopoverTarget> implements ILuPopoverTrigger<TPanel, TTarget> {\r\n\tprotected _portal: TemplatePortal<unknown> | ComponentPortal<TPanel>;\r\n\tprotected _overlayRef: OverlayRef | null = null;\r\n\tprotected _popoverOpen = false;\r\n\t// protected _halt = false;\r\n\tprotected _backdropSubscription: Subscription;\r\n\tprotected _positionSubscription: Subscription;\r\n\r\n\tprotected _mouseoverTimer: unknown;\r\n\r\n\tprotected _hovered$ = new Subject();\r\n\tprotected _hoveredSubscription: Subscription;\r\n\tprotected _panelEventsSubscriptions: Subscription;\r\n\tprotected _overlayDetachmentsSubscription: Subscription;\r\n\r\n\t// tracking input type is necessary so it's possible to only auto-focus\r\n\t// the first item of the list when the popover is opened via the keyboard\r\n\tprotected _openedByMouse = false;\r\n\r\n\tprotected _panel: TPanel;\r\n\t/** References the popover instance that the trigger is associated with. */\r\n\tget panel() {\r\n\t\treturn this._panel;\r\n\t}\r\n\tset panel(p: TPanel) {\r\n\t\tthis._panel = p;\r\n\t}\r\n\r\n\tprotected _target: TTarget;\r\n\t/** References the popover target instance that the trigger is associated with. */\r\n\tget target() {\r\n\t\treturn this._target;\r\n\t}\r\n\tset target(t: TTarget) {\r\n\t\tthis._target = t;\r\n\t}\r\n\r\n\tprotected _triggerEvent: LuPopoverTriggerEvent = 'click';\r\n\tget triggerEvent() {\r\n\t\treturn this._triggerEvent;\r\n\t}\r\n\tset triggerEvent(te: LuPopoverTriggerEvent) {\r\n\t\tthis._triggerEvent = te;\r\n\t\tif (te === 'hover' || te === 'focus') {\r\n\t\t\tif (this._hoveredSubscription) {\r\n\t\t\t\tthis._hoveredSubscription.unsubscribe();\r\n\t\t\t}\r\n\t\t\tthis._hoveredSubscription = this._hovered$\r\n\t\t\t\t.pipe(\r\n\t\t\t\t\tdistinctUntilChanged(),\r\n\t\t\t\t\tdebounce((h) => (h ? timer(this.enterDelay) : timer(this.leaveDelay))),\r\n\t\t\t\t)\r\n\t\t\t\t.subscribe((h) => (h ? this.openPopover() : this.closePopover()));\r\n\t\t}\r\n\t}\r\n\tprotected _enterDelay = 50;\r\n\tget enterDelay() {\r\n\t\treturn this._enterDelay;\r\n\t}\r\n\tset enterDelay(d: number) {\r\n\t\tthis._enterDelay = d;\r\n\t}\r\n\tprotected _leaveDelay = 50;\r\n\tget leaveDelay() {\r\n\t\treturn this._leaveDelay;\r\n\t}\r\n\tset leaveDelay(d: number) {\r\n\t\tthis._leaveDelay = d;\r\n\t}\r\n\r\n\tprotected _disabled = false;\r\n\tget disabled() {\r\n\t\treturn this._disabled;\r\n\t}\r\n\tset disabled(d: boolean) {\r\n\t\tthis._disabled = d;\r\n\t}\r\n\r\n\tprotected _whenEllipsis = false;\r\n\tget whenEllipsis() {\r\n\t\treturn this._whenEllipsis;\r\n\t}\r\n\tset whenEllipsis(we: boolean) {\r\n\t\tthis._whenEllipsis = we;\r\n\t}\r\n\r\n\tprotected _triggerId: string;\r\n\tprotected _panelId: string;\r\n\r\n\t/** Event emitted when the associated popover is opened. */\r\n\tabstract onOpen: Observable<void>;\r\n\t/** Event emitted when the associated popover is closed. */\r\n\tabstract onClose: Observable<void>;\r\n\r\n\tprotected abstract _emitOpen(): void;\r\n\tprotected abstract _emitClose(): void;\r\n\r\n\tconstructor(protected _overlay: Overlay, protected _elementRef: ElementRef<HTMLElement>, protected _viewContainerRef: ViewContainerRef) {\r\n\t\tthis._triggerId = `popoverTrigger_${generateId()}`;\r\n\t\tthis._panelId = `popoverPanel_${generateId()}`;\r\n\t}\r\n\r\n\tonClick() {\r\n\t\tif (this.triggerEvent === 'click' && !this.disabled) {\r\n\t\t\tthis.togglePopover();\r\n\t\t}\r\n\t}\r\n\r\n\tonMouseEnter() {\r\n\t\tif (this.triggerEvent === 'hover' || this.triggerEvent === 'focus') {\r\n\t\t\tthis._hovered$.next(true);\r\n\t\t}\r\n\t}\r\n\r\n\tonMouseLeave() {\r\n\t\tif (this.triggerEvent === 'hover' || this.triggerEvent === 'focus') {\r\n\t\t\tthis._hovered$.next(false);\r\n\t\t}\r\n\t}\r\n\tonFocus() {\r\n\t\tif (this.triggerEvent === 'hover' || this.triggerEvent === 'focus') {\r\n\t\t\tthis.openPopover();\r\n\t\t}\r\n\t}\r\n\tonBlur() {\r\n\t\tif (this.triggerEvent === 'hover' || this.triggerEvent === 'focus') {\r\n\t\t\tthis.closePopover();\r\n\t\t}\r\n\t}\r\n\r\n\t/** Toggles the popover between the open and closed states. */\r\n\ttogglePopover(): void {\r\n\t\treturn this._popoverOpen ? this.closePopover() : this.openPopover();\r\n\t}\r\n\r\n\t/** Opens the popover. */\r\n\topenPopover(): void {\r\n\t\tif (!this._popoverOpen && !this._disabled && (!this._whenEllipsis || this._hasEllipsis())) {\r\n\t\t\tthis._createOverlay();\r\n\t\t\tthis._attachPortalToOverlay();\r\n\r\n\t\t\t/** Only subscribe to overlay detachments if trigger event is hover or focus */\r\n\t\t\tif (this.triggerEvent === 'hover' || this.triggerEvent === 'focus') {\r\n\t\t\t\tthis._subscribeToOverlayDetachments();\r\n\t\t\t}\r\n\r\n\t\t\t/** Only subscribe to backdrop if trigger event is click */\r\n\t\t\tif (this.triggerEvent === 'click') {\r\n\t\t\t\tthis._subscribeToBackdrop();\r\n\t\t\t}\r\n\r\n\t\t\t/** Only subscribe to mouse enter/leave of the panel if trigger = hover */\r\n\r\n\t\t\tthis._initPopover();\r\n\t\t\tthis._emitOpen();\r\n\t\t}\r\n\t}\r\n\r\n\t/** Closes the popover. */\r\n\tclosePopover(): void {\r\n\t\tif (this._overlayRef) {\r\n\t\t\t/** Overlay can still be attached if close has been triggered by mouse leave. */\r\n\t\t\tif (this._overlayRef.hasAttached()) {\r\n\t\t\t\tthis._overlayRef.detach();\r\n\t\t\t}\r\n\r\n\t\t\t/** unsubscribe to backdrop click if it was defined */\r\n\t\t\tif (this._backdropSubscription) {\r\n\t\t\t\t// if (this.popover.triggerEvent === 'click') {\r\n\t\t\t\tthis._backdropSubscription.unsubscribe();\r\n\t\t\t}\r\n\r\n\t\t\tthis._resetPopover();\r\n\t\t\tthis._emitClose();\r\n\t\t}\r\n\t}\r\n\r\n\t/** Removes the popover from the DOM. */\r\n\tdestroyPopover(): void {\r\n\t\tif (this._overlayRef) {\r\n\t\t\tthis._overlayRef.dispose();\r\n\t\t\tthis._overlayRef = null;\r\n\t\t\tthis._cleanUpSubscriptions();\r\n\t\t}\r\n\t}\r\n\r\n\t/** Focuses the popover trigger. */\r\n\tfocus() {\r\n\t\tthis._elementRef.nativeElement.focus();\r\n\t}\r\n\r\n\t_handleMousedown(event: MouseEvent): void {\r\n\t\tif (!isFakeMousedownFromScreenReader(event)) {\r\n\t\t\tthis._openedByMouse = true;\r\n\t\t}\r\n\t}\r\n\r\n\t/** The text direction of the containing app. */\r\n\tget dir(): Direction {\r\n\t\t// return this._dir && this._dir.value === 'rtl' ? 'rtl' : 'ltr';\r\n\t\treturn 'ltr';\r\n\t}\r\n\r\n\t/** Return if the popover main positionning is vertical */\r\n\tget isVerticallyPositionned(): boolean {\r\n\t\tconst position = this.target.position;\r\n\t\treturn position === 'below' || position === 'above';\r\n\t}\r\n\r\n\tprotected _attachPortalToOverlay(): void {\r\n\t\tthis._overlayRef.attach(this._portal);\r\n\t}\r\n\r\n\tprotected _getPanelScrollStrategy(): LuPopoverScrollStrategy {\r\n\t\treturn this.panel.scrollStrategy;\r\n\t}\r\n\r\n\t/**\r\n\t * This method ensures that the popover\r\n\t */\r\n\tprotected _subscribeToPanelEvents(): void {\r\n\t\tif (this._overlayRef) {\r\n\t\t\tthis._panelEventsSubscriptions = new Subscription();\r\n\t\t\tif (this.triggerEvent === 'hover' || this.triggerEvent === 'focus') {\r\n\t\t\t\tthis._panelEventsSubscriptions.add(\r\n\t\t\t\t\tthis.panel.hovered.subscribe((hovered) => {\r\n\t\t\t\t\t\tthis._hovered$.next(hovered);\r\n\t\t\t\t\t}),\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t\tthis._panelEventsSubscriptions.add(\r\n\t\t\t\tthis.panel.close.subscribe(() => {\r\n\t\t\t\t\tthis.closePopover();\r\n\t\t\t\t}),\r\n\t\t\t);\r\n\t\t\tthis._panelEventsSubscriptions.add(\r\n\t\t\t\tthis.panel.open.subscribe(() => {\r\n\t\t\t\t\tthis.openPopover();\r\n\t\t\t\t}),\r\n\t\t\t);\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * This method ensures that the popover closes when the overlay has been detached\r\n\t * Detach can occur if we scroll while popover is opened\r\n\t */\r\n\tprotected _subscribeToOverlayDetachments(): void {\r\n\t\tif (this._overlayRef) {\r\n\t\t\tthis._overlayDetachmentsSubscription = this._overlayRef.detachments().subscribe(() => {\r\n\t\t\t\tthis._hovered$.next(false);\r\n\t\t\t});\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * This method ensures that the popover closes when the overlay backdrop is clicked.\r\n\t * We do not use first() here because doing so would not catch clicks from within\r\n\t * the popover, and it would fail to unsubscribe properly. Instead, we unsubscribe\r\n\t * explicitly when the popover is closed or destroyed.\r\n\t */\r\n\tprotected _subscribeToBackdrop(): void {\r\n\t\tif (this._overlayRef) {\r\n\t\t\tthis._backdropSubscription = this._overlayRef.backdropClick().subscribe(() => {\r\n\t\t\t\tthis.closePopover();\r\n\t\t\t});\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * This method sets the popover state to open and focuses the first item if\r\n\t * the popover was opened via the keyboard.\r\n\t */\r\n\tprotected _initPopover(): void {\r\n\t\tthis._setIsPopoverOpen(true);\r\n\t\tthis.panel.panelId = this._panelId;\r\n\t\tthis.panel.triggerId = this._triggerId;\r\n\t\tthis.panel.keydownEvents$ = this._overlayRef.keydownEvents();\r\n\t\tthis._subscribeToPanelEvents();\r\n\t}\r\n\r\n\t/**\r\n\t * This method resets the popover when it's closed, most importantly restoring\r\n\t * focus to the popover trigger if the popover was opened via the keyboard.\r\n\t */\r\n\tprotected _resetPopover(): void {\r\n\t\tthis._setIsPopoverOpen(false);\r\n\r\n\t\t// Focus only needs to be reset to the host element if the popover was opened\r\n\t\t// by the keyboard and manually shifted to the first popover item.\r\n\t\tif (!this._openedByMouse && this.triggerEvent === 'click') {\r\n\t\t\tthis.focus();\r\n\t\t}\r\n\t\tthis._openedByMouse = false;\r\n\t}\r\n\r\n\t/** set state rather than toggle to support triggers sharing a popover */\r\n\tprotected _setIsPopoverOpen(isOpen: boolean): void {\r\n\t\tthis._popoverOpen = isOpen;\r\n\t\t// tell the panel it's opening/closing\r\n\t\tisOpen ? this.panel.onOpen() : this.panel.onClose();\r\n\t}\r\n\r\n\t/**\r\n\t *  This method checks that a valid instance of MdPopover has been passed into\r\n\t *  mdPopoverTriggerFor. If not, an exception is thrown.\r\n\t */\r\n\tprotected _checkPanel() {\r\n\t\tif (!this.panel) {\r\n\t\t\tthrow Error(`lu-popover-trigger: must pass in a lu-popover instance.\r\n      Example:\r\n      <lu-popover #popover=\"LuPopover\"></lu-popover>\r\n      <button type=\"button\" [luPopover]=\"popover\"></button>`);\r\n\t\t}\r\n\t}\r\n\tprotected _checkTarget() {\r\n\t\tif (!this.target) {\r\n\t\t\tthrow Error(`lu-popover-trigger: must pass in a popover target instance.`);\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t *  This method creates the overlay from the provided popover's template and saves its\r\n\t *  OverlayRef so that it can be attached to the DOM when openPopover is called.\r\n\t */\r\n\tprotected _createOverlay(): OverlayRef {\r\n\t\tif (!this._overlayRef) {\r\n\t\t\tthis._portal = new TemplatePortal(this.panel.templateRef, this._viewContainerRef);\r\n\t\t\tconst config = this._getOverlayConfig();\r\n\t\t\tthis._subscribeToPositions(config.positionStrategy as FlexibleConnectedPositionStrategy);\r\n\t\t\tthis._overlayRef = this._overlay.create(config);\r\n\t\t}\r\n\r\n\t\treturn this._overlayRef;\r\n\t}\r\n\r\n\t/**\r\n\t * This method builds the configuration object needed to create the overlay, the OverlayConfig.\r\n\t * @returns OverlayConfig\r\n\t */\r\n\tprotected _getOverlayConfig(): OverlayConfig {\r\n\t\tconst overlayState = new OverlayConfig();\r\n\t\toverlayState.positionStrategy = this._getPosition();\r\n\t\t/** Display overlay backdrop if trigger event is click */\r\n\t\tif (this.triggerEvent === 'click') {\r\n\t\t\toverlayState.hasBackdrop = true;\r\n\t\t\toverlayState.backdropClass = 'cdk-overlay-transparent-backdrop';\r\n\t\t}\r\n\r\n\t\toverlayState.direction = this.dir;\r\n\t\tconst scrollStrategy = this._getPanelScrollStrategy();\r\n\t\tswitch (scrollStrategy) {\r\n\t\t\tcase 'block':\r\n\t\t\t\toverlayState.scrollStrategy = this._overlay.scrollStrategies.block();\r\n\t\t\t\tbreak;\r\n\r\n\t\t\tcase 'close':\r\n\t\t\t\toverlayState.scrollStrategy = this._overlay.scrollStrategies.close();\r\n\t\t\t\tbreak;\r\n\r\n\t\t\tdefault:\r\n\t\t\t\toverlayState.scrollStrategy = this._overlay.scrollStrategies.reposition();\r\n\t\t\t\tbreak;\r\n\t\t}\r\n\t\treturn overlayState;\r\n\t}\r\n\r\n\t/**\r\n\t * Listens to changes in the position of the overlay and sets the correct classes\r\n\t * on the popover based on the new position. This ensures the animation origin is always\r\n\t * correct, even if a fallback position is used for the overlay.\r\n\t */\r\n\tprotected _subscribeToPositions(position: FlexibleConnectedPositionStrategy): void {\r\n\t\tthis._positionSubscription = position.positionChanges\r\n\t\t\t.pipe(\r\n\t\t\t\tmap((c) => c.connectionPair),\r\n\t\t\t\tdistinctUntilChanged(),\r\n\t\t\t)\r\n\t\t\t.subscribe((connectionPair) => {\r\n\t\t\t\tthis.panel.setPositionClasses(connectionPair.overlayX, connectionPair.overlayY);\r\n\t\t\t});\r\n\t}\r\n\r\n\t/**\r\n\t * This method builds the position strategy for the overlay, so the popover is properly connected\r\n\t * to the trigger.\r\n\t * @returns FlexibleConnectedPositionStrategy\r\n\t */\r\n\tprotected _getPosition(): FlexibleConnectedPositionStrategy {\r\n\t\t/**\r\n\t\t * For overriding position element, when LuPopoverTargetAt has a valid element reference.\r\n\t\t * Useful for sticking popover to parent element and offsetting arrow to trigger element.\r\n\t\t * If undefined defaults to the trigger element reference.\r\n\t\t */\r\n\t\tconst element = this.target.elementRef;\r\n\t\t// if (typeof this.targetElement !== 'undefined' && this.popover) {\r\n\t\t// \tthis.popover.containerPositioning = true;\r\n\t\t// \telement = this.targetElement._elementRef;\r\n\t\t// }\r\n\r\n\t\tconst connectionPosition: OriginConnectionPosition = {\r\n\t\t\toriginX: 'start',\r\n\t\t\toriginY: 'top',\r\n\t\t};\r\n\r\n\t\t// Position\r\n\t\tconst position = this.target.position;\r\n\t\tconst overlap = this.target.overlap;\r\n\t\tif (position === 'above') {\r\n\t\t\tconnectionPosition.originY = overlap ? 'bottom' : 'top';\r\n\t\t} else if (position === 'below') {\r\n\t\t\tconnectionPosition.originY = overlap ? 'top' : 'bottom';\r\n\t\t} else if (position === 'before') {\r\n\t\t\tconnectionPosition.originX = overlap ? 'end' : 'start';\r\n\t\t} else if (position === 'after') {\r\n\t\t\tconnectionPosition.originX = overlap ? 'start' : 'end';\r\n\t\t}\r\n\r\n\t\t// Alignment\r\n\t\tconst alignment = this.target.alignment;\r\n\t\tif (this.isVerticallyPositionned) {\r\n\t\t\tif (alignment === 'left') {\r\n\t\t\t\tconnectionPosition.originX = 'start';\r\n\t\t\t} else if (alignment === 'right') {\r\n\t\t\t\tconnectionPosition.originX = 'end';\r\n\t\t\t} else {\r\n\t\t\t\tconnectionPosition.originX = 'center';\r\n\t\t\t}\r\n\t\t} else {\r\n\t\t\tif (alignment === 'top') {\r\n\t\t\t\tconnectionPosition.originY = 'top';\r\n\t\t\t} else if (alignment === 'bottom') {\r\n\t\t\t\tconnectionPosition.originY = 'bottom';\r\n\t\t\t} else {\r\n\t\t\t\tconnectionPosition.originY = 'center';\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tconst overlayPosition: OverlayConnectionPosition = {\r\n\t\t\toverlayX: 'start',\r\n\t\t\toverlayY: 'top',\r\n\t\t};\r\n\r\n\t\tif (overlap) {\r\n\t\t\toverlayPosition.overlayX = connectionPosition.originX;\r\n\t\t\toverlayPosition.overlayY = connectionPosition.originY;\r\n\t\t} else if (this.isVerticallyPositionned) {\r\n\t\t\toverlayPosition.overlayX = connectionPosition.originX;\r\n\t\t\toverlayPosition.overlayY = position === 'above' ? 'bottom' : 'top';\r\n\t\t} else {\r\n\t\t\toverlayPosition.overlayX = position === 'before' ? 'end' : 'start';\r\n\t\t\toverlayPosition.overlayY = connectionPosition.originY;\r\n\t\t}\r\n\r\n\t\treturn this._overlay\r\n\t\t\t.position()\r\n\t\t\t.flexibleConnectedTo(element)\r\n\t\t\t.withPositions([\r\n\t\t\t\t{\r\n\t\t\t\t\toriginX: connectionPosition.originX,\r\n\t\t\t\t\toriginY: connectionPosition.originY,\r\n\t\t\t\t\toverlayX: overlayPosition.overlayX,\r\n\t\t\t\t\toverlayY: overlayPosition.overlayY,\r\n\t\t\t\t},\r\n\t\t\t\t{\r\n\t\t\t\t\toriginX: connectionPosition.originX,\r\n\t\t\t\t\toriginY: this._invertVerticalPos(connectionPosition.originY),\r\n\t\t\t\t\toverlayX: overlayPosition.overlayX,\r\n\t\t\t\t\toverlayY: this._invertVerticalPos(overlayPosition.overlayY),\r\n\t\t\t\t},\r\n\t\t\t\t{\r\n\t\t\t\t\toriginX: this._invertHorizontalPos(connectionPosition.originX),\r\n\t\t\t\t\toriginY: connectionPosition.originY,\r\n\t\t\t\t\toverlayX: this._invertHorizontalPos(overlayPosition.overlayX),\r\n\t\t\t\t\toverlayY: overlayPosition.overlayY,\r\n\t\t\t\t},\r\n\t\t\t\t{\r\n\t\t\t\t\toriginX: this._invertHorizontalPos(connectionPosition.originX),\r\n\t\t\t\t\toriginY: this._invertVerticalPos(connectionPosition.originY),\r\n\t\t\t\t\toverlayX: this._invertHorizontalPos(overlayPosition.overlayX),\r\n\t\t\t\t\toverlayY: this._invertVerticalPos(overlayPosition.overlayY),\r\n\t\t\t\t},\r\n\t\t\t])\r\n\t\t\t.withDefaultOffsetX(this.target.offsetX)\r\n\t\t\t.withDefaultOffsetY(this.target.offsetY);\r\n\t}\r\n\r\n\tprotected _invertVerticalPos(y: VerticalConnectionPos) {\r\n\t\tif (y === 'top') {\r\n\t\t\ty = 'bottom';\r\n\t\t} else if (y === 'bottom') {\r\n\t\t\ty = 'top';\r\n\t\t}\r\n\t\treturn y;\r\n\t}\r\n\r\n\tprotected _invertHorizontalPos(x: HorizontalConnectionPos) {\r\n\t\tif (x === 'end') {\r\n\t\t\tx = 'start';\r\n\t\t} else if (x === 'start') {\r\n\t\t\tx = 'end';\r\n\t\t}\r\n\r\n\t\treturn x;\r\n\t}\r\n\r\n\tprotected _cleanUpSubscriptions(): void {\r\n\t\tif (this._backdropSubscription) {\r\n\t\t\tthis._backdropSubscription.unsubscribe();\r\n\t\t}\r\n\t\tif (this._positionSubscription) {\r\n\t\t\tthis._positionSubscription.unsubscribe();\r\n\t\t}\r\n\t\tif (this._hoveredSubscription) {\r\n\t\t\tthis._hoveredSubscription.unsubscribe();\r\n\t\t}\r\n\t\tif (this._panelEventsSubscriptions) {\r\n\t\t\tthis._panelEventsSubscriptions.unsubscribe();\r\n\t\t}\r\n\t\tif (this._overlayDetachmentsSubscription) {\r\n\t\t\tthis._overlayDetachmentsSubscription.unsubscribe();\r\n\t\t}\r\n\t}\r\n\r\n\tprotected _hasEllipsis(): boolean {\r\n\t\tif (!(this._elementRef.nativeElement instanceof HTMLElement)) {\r\n\t\t\treturn false;\r\n\t\t}\r\n\r\n\t\tconst { scrollWidth, scrollHeight, clientWidth, clientHeight } = this._elementRef.nativeElement;\r\n\r\n\t\tconst textClampedByWidth = scrollWidth > clientWidth;\r\n\t\tconst textClampedByHeight = scrollHeight > clientHeight;\r\n\r\n\t\treturn textClampedByWidth || textClampedByHeight;\r\n\t}\r\n}\r\n"]}

package/esm2022/popover/lib/trigger/popover-trigger.module.mjs

@@ -0,0 +1,18 @@
+import { NgModule } from '@angular/core';
+import { LuPopoverTriggerDirective } from './popover-trigger.directive';
+import { OverlayModule } from '@angular/cdk/overlay';
+import * as i0 from "@angular/core";
+class LuPopoverTriggerModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: LuPopoverTriggerModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.0.0", ngImport: i0, type: LuPopoverTriggerModule, imports: [LuPopoverTriggerDirective, OverlayModule], exports: [LuPopoverTriggerDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: LuPopoverTriggerModule, imports: [OverlayModule] }); }
+}
+export { LuPopoverTriggerModule };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: LuPopoverTriggerModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [LuPopoverTriggerDirective, OverlayModule],
+                    exports: [LuPopoverTriggerDirective],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9wb3Zlci10cmlnZ2VyLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL25nL3BvcG92ZXIvc3JjL2xpYi90cmlnZ2VyL3BvcG92ZXItdHJpZ2dlci5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUseUJBQXlCLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUN4RSxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sc0JBQXNCLENBQUM7O0FBRXJELE1BSWEsc0JBQXNCOzhHQUF0QixzQkFBc0I7K0dBQXRCLHNCQUFzQixZQUh4Qix5QkFBeUIsRUFBRSxhQUFhLGFBQ3hDLHlCQUF5QjsrR0FFdkIsc0JBQXNCLFlBSEcsYUFBYTs7U0FHdEMsc0JBQXNCOzJGQUF0QixzQkFBc0I7a0JBSmxDLFFBQVE7bUJBQUM7b0JBQ1QsT0FBTyxFQUFFLENBQUMseUJBQXlCLEVBQUUsYUFBYSxDQUFDO29CQUNuRCxPQUFPLEVBQUUsQ0FBQyx5QkFBeUIsQ0FBQztpQkFDcEMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBMdVBvcG92ZXJUcmlnZ2VyRGlyZWN0aXZlIH0gZnJvbSAnLi9wb3BvdmVyLXRyaWdnZXIuZGlyZWN0aXZlJztcclxuaW1wb3J0IHsgT3ZlcmxheU1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2Nkay9vdmVybGF5JztcclxuXHJcbkBOZ01vZHVsZSh7XHJcblx0aW1wb3J0czogW0x1UG9wb3ZlclRyaWdnZXJEaXJlY3RpdmUsIE92ZXJsYXlNb2R1bGVdLFxyXG5cdGV4cG9ydHM6IFtMdVBvcG92ZXJUcmlnZ2VyRGlyZWN0aXZlXSxcclxufSlcclxuZXhwb3J0IGNsYXNzIEx1UG9wb3ZlclRyaWdnZXJNb2R1bGUge31cclxuIl19

package/esm2022/popover/lucca-front-ng-popover.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibHVjY2EtZnJvbnQtbmctcG9wb3Zlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL25nL3BvcG92ZXIvc3JjL2x1Y2NhLWZyb250LW5nLXBvcG92ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2022/popover/public-api.mjs

@@ -0,0 +1,5 @@
+/*
+ * Public API Surface of safe-content
+ */
+export * from './lib/index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL25nL3BvcG92ZXIvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGFBQWEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXHJcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBzYWZlLWNvbnRlbnRcclxuICovXHJcblxyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9pbmRleCc7XHJcbiJdfQ==

package/esm2022/popup/lib/index.mjs

@@ -0,0 +1,8 @@
+export * from './popup-config.default';
+export * from './popup-config.model';
+export * from './popup-ref.factory';
+export * from './popup-ref.model';
+export * from './popup.module';
+export * from './popup.service';
+export * from './popup.token';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9uZy9wb3B1cC9zcmMvbGliL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsZUFBZSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9wb3B1cC1jb25maWcuZGVmYXVsdCc7XHJcbmV4cG9ydCAqIGZyb20gJy4vcG9wdXAtY29uZmlnLm1vZGVsJztcclxuZXhwb3J0ICogZnJvbSAnLi9wb3B1cC1yZWYuZmFjdG9yeSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vcG9wdXAtcmVmLm1vZGVsJztcclxuZXhwb3J0ICogZnJvbSAnLi9wb3B1cC5tb2R1bGUnO1xyXG5leHBvcnQgKiBmcm9tICcuL3BvcHVwLnNlcnZpY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL3BvcHVwLnRva2VuJztcclxuIl19

package/esm2022/popup/lib/popup-config.default.mjs

@@ -0,0 +1,9 @@
+export const luDefaultPopupConfig = {
+    position: 'center',
+    noBackdrop: false,
+    undismissable: false,
+    backdropClass: ['cdk-overlay-dark-backdrop', 'lu-popup-backdrop'],
+    panelClass: 'lu-popup-panel',
+    size: 'M',
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9wdXAtY29uZmlnLmRlZmF1bHQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9uZy9wb3B1cC9zcmMvbGliL3BvcHVwLWNvbmZpZy5kZWZhdWx0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sQ0FBQyxNQUFNLG9CQUFvQixHQUFtQjtJQUNuRCxRQUFRLEVBQUUsUUFBUTtJQUNsQixVQUFVLEVBQUUsS0FBSztJQUNqQixhQUFhLEVBQUUsS0FBSztJQUNwQixhQUFhLEVBQUUsQ0FBQywyQkFBMkIsRUFBRSxtQkFBbUIsQ0FBQztJQUNqRSxVQUFVLEVBQUUsZ0JBQWdCO0lBQzVCLElBQUksRUFBRSxHQUFHO0NBQ1QsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IElMdVBvcHVwQ29uZmlnIH0gZnJvbSAnLi9wb3B1cC1jb25maWcubW9kZWwnO1xyXG5cclxuZXhwb3J0IGNvbnN0IGx1RGVmYXVsdFBvcHVwQ29uZmlnOiBJTHVQb3B1cENvbmZpZyA9IHtcclxuXHRwb3NpdGlvbjogJ2NlbnRlcicsXHJcblx0bm9CYWNrZHJvcDogZmFsc2UsXHJcblx0dW5kaXNtaXNzYWJsZTogZmFsc2UsXHJcblx0YmFja2Ryb3BDbGFzczogWydjZGstb3ZlcmxheS1kYXJrLWJhY2tkcm9wJywgJ2x1LXBvcHVwLWJhY2tkcm9wJ10sXHJcblx0cGFuZWxDbGFzczogJ2x1LXBvcHVwLXBhbmVsJyxcclxuXHRzaXplOiAnTScsXHJcbn07XHJcbiJdfQ==

package/esm2022/popup/lib/popup-config.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9wdXAtY29uZmlnLm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvbmcvcG9wdXAvc3JjL2xpYi9wb3B1cC1jb25maWcubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgSUx1UG9wdXBDb25maWcge1xyXG5cdHBvc2l0aW9uPzogJ2NlbnRlcicgfCAndG9wJyB8ICdib3R0b20nIHwgJ2xlZnQnIHwgJ3JpZ2h0JztcclxuXHRub0JhY2tkcm9wPzogYm9vbGVhbjtcclxuXHQvKiogcG9wdXAgZGlzbWlzc2VzIGlmIGBlc2NgIGlzIHByZXNzZWQgb3IgYmFja2Ryb3AgaXMgY2xpY2tlZCwgc2V0IGl0IHRvIHRydWUgaWYgeW91IHdhbnQgdG8gcHJldmVudCBpdCBidXQgYmUgYXdhcmUgdGhhdCB5b3VyIHBvcHVwIG1pZ2h0IGJlY29tZSB1bmNsb3NhYmxlICovXHJcblx0dW5kaXNtaXNzYWJsZT86IGJvb2xlYW47XHJcblx0YmFja2Ryb3BDbGFzcz86IHN0cmluZyB8IHN0cmluZ1tdO1xyXG5cdHBhbmVsQ2xhc3M/OiBzdHJpbmcgfCBzdHJpbmdbXTtcclxuXHRzaXplPzogc3RyaW5nO1xyXG59XHJcbiJdfQ==

package/esm2022/popup/lib/popup-ref.factory.mjs

@@ -0,0 +1,29 @@
+import { Injectable } from '@angular/core';
+import { ALuPopupRef } from './popup-ref.model';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+export class LuPopupRef extends ALuPopupRef {
+    constructor(_overlay, _injector, _component, _config) {
+        super(_overlay, _injector, _component, _config);
+        this._overlay = _overlay;
+        this._injector = _injector;
+        this._component = _component;
+        this._config = _config;
+    }
+}
+class LuPopupRefFactory {
+    constructor(_overlay, _injector) {
+        this._overlay = _overlay;
+        this._injector = _injector;
+    }
+    forge(component, config) {
+        return new LuPopupRef(this._overlay, this._injector, component, config);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: LuPopupRefFactory, deps: [{ token: i1.Overlay }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: LuPopupRefFactory }); }
+}
+export { LuPopupRefFactory };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: LuPopupRefFactory, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Overlay }, { type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,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