@gipisistemas/ng-core 1.1.0 → 1.1.1

package/esm5/shared/gipi-components/popover/shared/popover-trigger.js

@@ -0,0 +1,529 @@
+import { __decorate, __metadata, __param, __read } from "tslib";
+import { isFakeMousedownFromScreenReader } from '@angular/cdk/a11y';
+import { Direction, Directionality } from '@angular/cdk/bidi';
+import { FlexibleConnectedPositionStrategy, HorizontalConnectionPos, Overlay, OverlayConfig, OverlayRef, ScrollStrategy, VerticalConnectionPos } from '@angular/cdk/overlay';
+import { TemplatePortal } from '@angular/cdk/portal';
+import { AfterViewInit, ChangeDetectorRef, Directive, ElementRef, EventEmitter, HostBinding, HostListener, Input, OnDestroy, Optional, Output, ViewContainerRef, } from '@angular/core';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { ObjectUtil } from '../../../../core/utils/object.util';
+import { StringUtil } from '../../../../core/utils/string.util';
+import { GIPIDomHandler } from '../../dom/dom-handler';
+import { throwPopoverMissingError } from './popover-errors';
+/**
+ * Esta diretiva destina-se a ser usada em conjunto com uma tag gipi-popover.
+ * Ele é responsável por alternar a exibição da instância popover fornecida.
+ */
+var GIPIPopoverTrigger = /** @class */ (function () {
+    function GIPIPopoverTrigger(_overlay, _elementRef, _viewContainerRef, _dir, _changeDetectorRef) {
+        this._overlay = _overlay;
+        this._elementRef = _elementRef;
+        this._viewContainerRef = _viewContainerRef;
+        this._dir = _dir;
+        this._changeDetectorRef = _changeDetectorRef;
+        this.ariaHaspopup = true;
+        this.popoverOpened = new Subject();
+        this.popoverClosed = new Subject();
+        this._overlayRef = null;
+        this._popoverOpen = false;
+        this._halt = false;
+        // 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._onDestroy = new Subject();
+        /** Popover backdrop close on click */
+        this.backdropCloseOnClick = true;
+        /** Event emitted when the associated popover is opened. */
+        this.opened = new EventEmitter();
+        /** Event emitted when the associated popover is closed. */
+        this.closed = new EventEmitter();
+    }
+    GIPIPopoverTrigger.prototype.ngAfterViewInit = function () {
+        var _this = this;
+        this._checkPopover();
+        this._setCurrentConfig();
+        this.popover.close.subscribe(function () { return _this.closePopover(); });
+    };
+    GIPIPopoverTrigger.prototype.ngOnDestroy = function () {
+        this.destroyPopover();
+    };
+    GIPIPopoverTrigger.prototype._setCurrentConfig = function () {
+        if (this.positionX === 'before' || this.positionX === 'after') {
+            this.popover.positionX = this.positionX;
+        }
+        if (this.positionY === 'above' || this.positionY === 'below') {
+            this.popover.positionY = this.positionY;
+        }
+        if (this.triggerEvent) {
+            this.popover.triggerEvent = this.triggerEvent;
+        }
+        if (this.enterDelay) {
+            this.popover.enterDelay = this.enterDelay;
+        }
+        if (this.leaveDelay) {
+            this.popover.leaveDelay = this.leaveDelay;
+        }
+        if (this.overlapTrigger === true || this.overlapTrigger === false) {
+            this.popover.overlapTrigger = this.overlapTrigger;
+        }
+        if (this.targetOffsetX) {
+            this.popover.targetOffsetX = this.targetOffsetX;
+        }
+        if (this.targetOffsetY) {
+            this.popover.targetOffsetY = this.targetOffsetY;
+        }
+        if (this.arrowOffsetX) {
+            this.popover.arrowOffsetX = this.arrowOffsetX;
+        }
+        if (this.arrowWidth) {
+            this.popover.arrowWidth = this.arrowWidth;
+        }
+        if (this.arrowColor) {
+            this.popover.arrowColor = this.arrowColor;
+        }
+        if (this.closeOnClick === true || this.closeOnClick === false) {
+            this.popover.closeOnClick = this.closeOnClick;
+        }
+        this.popover.setCurrentStyles();
+    };
+    Object.defineProperty(GIPIPopoverTrigger.prototype, "popoverOpen", {
+        /** Whether the popover is open. */
+        get: function () { return this._popoverOpen; },
+        enumerable: false,
+        configurable: true
+    });
+    GIPIPopoverTrigger.prototype.onClick = function (event) {
+        if (this.popover.triggerEvent === 'click') {
+            this.togglePopover();
+        }
+    };
+    GIPIPopoverTrigger.prototype.onMouseEnter = function (event) {
+        var _this = this;
+        this._halt = false;
+        if (this.popover.triggerEvent === 'hover') {
+            this._mouseoverTimer = setTimeout(function () {
+                _this.openPopover();
+            }, this.popover.enterDelay);
+        }
+    };
+    GIPIPopoverTrigger.prototype.onMouseLeave = function (event) {
+        var _this = this;
+        if (this.popover.triggerEvent === 'hover') {
+            if (this._mouseoverTimer) {
+                clearTimeout(this._mouseoverTimer);
+                this._mouseoverTimer = null;
+            }
+            if (this._popoverOpen) {
+                setTimeout(function () {
+                    if (!_this.popover.closeDisabled) {
+                        _this.closePopover();
+                    }
+                }, this.popover.leaveDelay);
+            }
+            else {
+                this._halt = true;
+            }
+        }
+    };
+    /** Toggles the popover between the open and closed states. */
+    GIPIPopoverTrigger.prototype.togglePopover = function () {
+        return this._popoverOpen ? this.closePopover() : this.openPopover();
+    };
+    /** Opens the popover. */
+    GIPIPopoverTrigger.prototype.openPopover = function () {
+        if (!this._popoverOpen && !this._halt) {
+            this._createOverlay().attach(this._portal);
+            if (!ObjectUtil.isNull(this._viewContainerRef) && !ObjectUtil.isNull(this._viewContainerRef.element)) {
+                var width = GIPIDomHandler.getWidth(this._viewContainerRef.element.nativeElement);
+                if (StringUtil.isEmpty(this.popover.popoverWidth) || (this.popover.popoverWidth === 'auto')) {
+                    this.popover.popoverWidth = width + "px";
+                }
+            }
+            this._subscribeToBackdrop();
+            this._subscribeToDetachments();
+            this._initPopover();
+        }
+    };
+    /** Closes the popover. */
+    GIPIPopoverTrigger.prototype.closePopover = function () {
+        if (this._overlayRef) {
+            this._overlayRef.detach();
+            this._resetPopover();
+        }
+    };
+    /** Removes the popover from the DOM. */
+    GIPIPopoverTrigger.prototype.destroyPopover = function () {
+        if (this._mouseoverTimer) {
+            clearTimeout(this._mouseoverTimer);
+            this._mouseoverTimer = null;
+        }
+        if (this._overlayRef) {
+            this._overlayRef.dispose();
+            this._overlayRef = null;
+            this._cleanUpSubscriptions();
+        }
+        this._onDestroy.next();
+        this._onDestroy.complete();
+    };
+    /** Focuses the popover trigger. */
+    GIPIPopoverTrigger.prototype.focus = function () {
+        this._elementRef.nativeElement.focus();
+    };
+    Object.defineProperty(GIPIPopoverTrigger.prototype, "dir", {
+        /** The text direction of the containing app. */
+        get: function () {
+            return this._dir && this._dir.value === 'rtl' ? 'rtl' : 'ltr';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+    * 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.
+    */
+    GIPIPopoverTrigger.prototype._subscribeToBackdrop = function () {
+        var _this = this;
+        if (this._overlayRef) {
+            /** Only subscribe to backdrop if trigger event is click */
+            if (this.triggerEvent === 'click' && this.backdropCloseOnClick === true) {
+                this._overlayRef.backdropClick()
+                    .pipe(takeUntil(this.popoverClosed), takeUntil(this._onDestroy))
+                    .subscribe(function () {
+                    _this.popover._emitCloseEvent();
+                });
+            }
+        }
+    };
+    GIPIPopoverTrigger.prototype._subscribeToDetachments = function () {
+        var _this = this;
+        if (this._overlayRef) {
+            this._overlayRef.detachments()
+                .pipe(takeUntil(this.popoverClosed), takeUntil(this._onDestroy))
+                .subscribe(function () {
+                _this._setPopoverClosed();
+            });
+        }
+    };
+    /**
+    * This method sets the popover state to open and focuses the first item if
+    * the popover was opened via the keyboard.
+    */
+    GIPIPopoverTrigger.prototype._initPopover = function () {
+        this._setPopoverOpened();
+    };
+    /**
+    * 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.
+    */
+    GIPIPopoverTrigger.prototype._resetPopover = function () {
+        this._setPopoverClosed();
+        // 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.focus();
+        }
+        this._openedByMouse = false;
+    };
+    /** set state rather than toggle to support triggers sharing a popover */
+    GIPIPopoverTrigger.prototype._setPopoverOpened = function () {
+        if (!this._popoverOpen) {
+            this._popoverOpen = true;
+            this.popoverOpened.next();
+            this.opened.emit();
+        }
+    };
+    /** set state rather than toggle to support triggers sharing a popover */
+    GIPIPopoverTrigger.prototype._setPopoverClosed = function () {
+        if (this._popoverOpen) {
+            this._popoverOpen = false;
+            this.popoverClosed.next();
+            this.closed.emit();
+        }
+    };
+    /**
+    *  This method checks that a valid instance of MdPopover has been passed into
+    *  mdPopoverTriggerFor. If not, an exception is thrown.
+    */
+    GIPIPopoverTrigger.prototype._checkPopover = function () {
+        if (!this.popover) {
+            throwPopoverMissingError();
+        }
+    };
+    /**
+    *  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.
+    */
+    GIPIPopoverTrigger.prototype._createOverlay = function () {
+        if (!this._overlayRef) {
+            this._portal = new TemplatePortal(this.popover.templateRef, this._viewContainerRef);
+            var 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
+    */
+    GIPIPopoverTrigger.prototype._getOverlayConfig = function () {
+        var 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;
+        overlayState.scrollStrategy = this._getOverlayScrollStrategy(this.popover.scrollStrategy);
+        return overlayState;
+    };
+    /**
+     * This method returns the scroll strategy used by the cdk/overlay.
+     */
+    GIPIPopoverTrigger.prototype._getOverlayScrollStrategy = function (strategy) {
+        switch (strategy) {
+            case 'noop':
+                return this._overlay.scrollStrategies.noop();
+            case 'close':
+                return this._overlay.scrollStrategies.close();
+            case 'block':
+                return this._overlay.scrollStrategies.block();
+            case 'reposition':
+            default:
+                return this._overlay.scrollStrategies.reposition();
+        }
+    };
+    /**
+    * 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.
+    */
+    GIPIPopoverTrigger.prototype._subscribeToPositions = function (position) {
+        var _this = this;
+        this._positionSubscription = position.positionChanges.subscribe(function (change) {
+            var posisionX = change.connectionPair.overlayX === 'start' ? 'after' : 'before';
+            var posisionY = change.connectionPair.overlayY === 'top' ? 'below' : 'above';
+            if (!_this.popover.overlapTrigger) {
+                posisionY = posisionY === 'below' ? 'above' : 'below';
+            }
+            // required for ChangeDetectionStrategy.OnPush
+            _this._changeDetectorRef.markForCheck();
+            _this.popover.zone.run(function () {
+                _this.popover.positionX = posisionX;
+                _this.popover.positionY = posisionY;
+                _this.popover.setCurrentStyles();
+                _this.popover.setPositionClasses(posisionX, posisionY);
+            });
+        });
+    };
+    /**
+    * This method builds the position strategy for the overlay, so the popover is properly connected
+    * to the trigger.
+    * @returns ConnectedPositionStrategy
+    */
+    GIPIPopoverTrigger.prototype._getPosition = function () {
+        var _a = __read(this.popover.positionX === 'before' ? ['end', 'start'] : ['start', 'end'], 2), originX = _a[0], originFallbackX = _a[1];
+        var _b = __read(this.popover.positionY === 'above' ? ['bottom', 'top'] : ['top', 'bottom'], 2), overlayY = _b[0], overlayFallbackY = _b[1];
+        // let originY = overlayY;
+        // let fallbackOriginY = overlayFallbackY;
+        var originY = overlayY;
+        var originFallbackY = overlayFallbackY;
+        var overlayX = originX;
+        var overlayFallbackX = originFallbackX;
+        /** Reverse overlayY and fallbackOverlayY when overlapTrigger is false */
+        if (!this.popover.overlapTrigger) {
+            originY = overlayY === 'top' ? 'bottom' : 'top';
+            originFallbackY = overlayFallbackY === 'top' ? 'bottom' : 'top';
+        }
+        var offsetX = 0;
+        var offsetY = 0;
+        if (this.popover.targetOffsetX && !isNaN(Number(this.popover.targetOffsetX))) {
+            offsetX = Number(this.popover.targetOffsetX);
+        }
+        if (this.popover.targetOffsetY && !isNaN(Number(this.popover.targetOffsetY))) {
+            offsetY = Number(this.popover.targetOffsetY);
+        }
+        /**
+         * For overriding position element, when popoverTargetAt 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.
+         */
+        var element = this._elementRef;
+        if (typeof this.targetElement !== 'undefined') {
+            this.popover.containerPositioning = true;
+            element = this.targetElement._elementRef;
+        }
+        return this._overlay.position()
+            .flexibleConnectedTo(element)
+            .withLockedPosition(true)
+            .withPositions([
+            {
+                originX: originX,
+                originY: originY,
+                overlayX: overlayX,
+                overlayY: overlayY,
+                offsetY: offsetY
+            },
+            {
+                originX: originFallbackX,
+                originY: originY,
+                overlayX: overlayFallbackX,
+                overlayY: overlayY,
+                offsetY: offsetY
+            },
+            {
+                originX: originX,
+                originY: originFallbackY,
+                overlayX: overlayX,
+                overlayY: overlayFallbackY,
+                offsetY: -offsetY
+            },
+            {
+                originX: originFallbackX,
+                originY: originFallbackY,
+                overlayX: overlayFallbackX,
+                overlayY: overlayFallbackY,
+                offsetY: -offsetY
+            }
+        ])
+            .withDefaultOffsetX(offsetX)
+            .withDefaultOffsetY(offsetY);
+    };
+    GIPIPopoverTrigger.prototype._cleanUpSubscriptions = function () {
+        if (this._backdropSubscription) {
+            this._backdropSubscription.unsubscribe();
+        }
+        if (this._positionSubscription) {
+            this._positionSubscription.unsubscribe();
+        }
+        if (this._detachmentsSubscription) {
+            this._detachmentsSubscription.unsubscribe();
+        }
+    };
+    GIPIPopoverTrigger.prototype._handleMousedown = function (event) {
+        if (event && !isFakeMousedownFromScreenReader(event)) {
+            this._openedByMouse = true;
+        }
+    };
+    GIPIPopoverTrigger.ctorParameters = function () { return [
+        { type: Overlay },
+        { type: ElementRef },
+        { type: ViewContainerRef },
+        { type: Directionality, decorators: [{ type: Optional }] },
+        { type: ChangeDetectorRef }
+    ]; };
+    __decorate([
+        HostBinding('attr.aria-haspopup'),
+        __metadata("design:type", Boolean)
+    ], GIPIPopoverTrigger.prototype, "ariaHaspopup", void 0);
+    __decorate([
+        Input('popoverTriggerFor'),
+        __metadata("design:type", Object)
+    ], GIPIPopoverTrigger.prototype, "popover", void 0);
+    __decorate([
+        Input('popoverTargetAt'),
+        __metadata("design:type", Object)
+    ], GIPIPopoverTrigger.prototype, "targetElement", void 0);
+    __decorate([
+        Input('popoverPositionX'),
+        __metadata("design:type", String)
+    ], GIPIPopoverTrigger.prototype, "positionX", void 0);
+    __decorate([
+        Input('popoverPositionY'),
+        __metadata("design:type", String)
+    ], GIPIPopoverTrigger.prototype, "positionY", void 0);
+    __decorate([
+        Input('popoverTriggerOn'),
+        __metadata("design:type", String)
+    ], GIPIPopoverTrigger.prototype, "triggerEvent", void 0);
+    __decorate([
+        Input('popoverEnterDelay'),
+        __metadata("design:type", Number)
+    ], GIPIPopoverTrigger.prototype, "enterDelay", void 0);
+    __decorate([
+        Input('popoverLeaveDelay'),
+        __metadata("design:type", Number)
+    ], GIPIPopoverTrigger.prototype, "leaveDelay", void 0);
+    __decorate([
+        Input('popoverOverlapTrigger'),
+        __metadata("design:type", Boolean)
+    ], GIPIPopoverTrigger.prototype, "overlapTrigger", void 0);
+    __decorate([
+        Input('popoverOffsetX'),
+        __metadata("design:type", Number)
+    ], GIPIPopoverTrigger.prototype, "targetOffsetX", void 0);
+    __decorate([
+        Input('popoverOffsetY'),
+        __metadata("design:type", Number)
+    ], GIPIPopoverTrigger.prototype, "targetOffsetY", void 0);
+    __decorate([
+        Input('popoverArrowOffsetX'),
+        __metadata("design:type", Number)
+    ], GIPIPopoverTrigger.prototype, "arrowOffsetX", void 0);
+    __decorate([
+        Input('popoverArrowWidth'),
+        __metadata("design:type", Number)
+    ], GIPIPopoverTrigger.prototype, "arrowWidth", void 0);
+    __decorate([
+        Input('popoverArrowColor'),
+        __metadata("design:type", String)
+    ], GIPIPopoverTrigger.prototype, "arrowColor", void 0);
+    __decorate([
+        Input('popoverCloseOnClick'),
+        __metadata("design:type", Boolean)
+    ], GIPIPopoverTrigger.prototype, "closeOnClick", void 0);
+    __decorate([
+        Input('popoverBackdropCloseOnClick'),
+        __metadata("design:type", Boolean)
+    ], GIPIPopoverTrigger.prototype, "backdropCloseOnClick", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], GIPIPopoverTrigger.prototype, "opened", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", EventEmitter)
+    ], GIPIPopoverTrigger.prototype, "closed", void 0);
+    __decorate([
+        HostListener('click', ['$event']),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [MouseEvent]),
+        __metadata("design:returntype", void 0)
+    ], GIPIPopoverTrigger.prototype, "onClick", null);
+    __decorate([
+        HostListener('mouseenter', ['$event']),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [MouseEvent]),
+        __metadata("design:returntype", void 0)
+    ], GIPIPopoverTrigger.prototype, "onMouseEnter", null);
+    __decorate([
+        HostListener('mouseleave', ['$event']),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [MouseEvent]),
+        __metadata("design:returntype", void 0)
+    ], GIPIPopoverTrigger.prototype, "onMouseLeave", null);
+    __decorate([
+        HostListener('mousedown', ['$event']),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [MouseEvent]),
+        __metadata("design:returntype", void 0)
+    ], GIPIPopoverTrigger.prototype, "_handleMousedown", null);
+    GIPIPopoverTrigger = __decorate([
+        Directive({
+            selector: '[popoverTriggerFor]',
+            exportAs: 'popoverTrigger'
+        }),
+        __param(3, Optional()),
+        __metadata("design:paramtypes", [Overlay,
+            ElementRef,
+            ViewContainerRef,
+            Directionality,
+            ChangeDetectorRef])
+    ], GIPIPopoverTrigger);
+    return GIPIPopoverTrigger;
+}());
+export { GIPIPopoverTrigger };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"popover-trigger.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/popover/shared/popover-trigger.ts"],"names":[],"mappings":"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","sourcesContent":["import { isFakeMousedownFromScreenReader } from '@angular/cdk/a11y';\nimport { Direction, Directionality } from '@angular/cdk/bidi';\nimport { FlexibleConnectedPositionStrategy, HorizontalConnectionPos, Overlay, OverlayConfig, OverlayRef, ScrollStrategy, VerticalConnectionPos } from '@angular/cdk/overlay';\nimport { TemplatePortal } from '@angular/cdk/portal';\nimport { AfterViewInit, ChangeDetectorRef, Directive, ElementRef, EventEmitter, HostBinding, HostListener, Input, OnDestroy, Optional, Output, ViewContainerRef, } from '@angular/core';\nimport { Subject, Subscription } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\n\nimport { ObjectUtil } from '../../../../core/utils/object.util';\nimport { StringUtil } from '../../../../core/utils/string.util';\nimport { GIPIDomHandler } from '../../dom/dom-handler';\nimport { throwPopoverMissingError } from './popover-errors';\nimport { PopoverPanel, Target } from './popover-interfaces';\nimport { PopoverPositionX, PopoverPositionY, PopoverScrollStrategy, PopoverTriggerEvent } from './popover-types';\n\n/**\n * Esta diretiva destina-se a ser usada em conjunto com uma tag gipi-popover.\n * Ele é responsável por alternar a exibição da instância popover fornecida.\n */\n\n@Directive({\n    selector: '[popoverTriggerFor]',\n    exportAs: 'popoverTrigger'\n})\nexport class GIPIPopoverTrigger implements AfterViewInit, OnDestroy { // tslint:disable-line:directive-class-suffix\n\n    @HostBinding('attr.aria-haspopup') ariaHaspopup: boolean = true;\n\n    popoverOpened: Subject<void> = new Subject<void>();\n    popoverClosed: Subject<void> = new Subject<void>();\n\n    private _portal: TemplatePortal<any>;\n    private _overlayRef: OverlayRef | null = null;\n    private _popoverOpen: boolean = false;\n    private _halt: boolean = false;\n    private _backdropSubscription: Subscription;\n    private _positionSubscription: Subscription;\n    private _detachmentsSubscription: Subscription;\n\n    private _mouseoverTimer: any;\n\n    // tracking input type is necessary so it's possible to only auto-focus\n    // the first item of the list when the popover is opened via the keyboard\n    private _openedByMouse: boolean = false;\n\n    private _onDestroy: Subject<void> = new Subject<void>();\n\n    /** References the popover instance that the trigger is associated with. */\n    @Input('popoverTriggerFor') popover: PopoverPanel;\n\n    /** References the popover target instance that the trigger is associated with. */\n    @Input('popoverTargetAt') targetElement: Target;\n\n    /** Position of the popover in the X axis */\n    @Input('popoverPositionX') positionX: PopoverPositionX;\n\n    /** Position of the popover in the Y axis */\n    @Input('popoverPositionY') positionY: PopoverPositionY;\n\n    /** Popover trigger event */\n    @Input('popoverTriggerOn') triggerEvent: PopoverTriggerEvent;\n\n    /** Popover delay */\n    @Input('popoverEnterDelay') enterDelay: number;\n\n    /** Popover delay */\n    @Input('popoverLeaveDelay') leaveDelay: number;\n\n    /** Popover overlap trigger */\n    @Input('popoverOverlapTrigger') overlapTrigger: boolean;\n\n    /** Popover target offset x */\n    @Input('popoverOffsetX') targetOffsetX: number;\n\n    /** Popover target offset y */\n    @Input('popoverOffsetY') targetOffsetY: number;\n\n    /** Popover arrow offset x */\n    @Input('popoverArrowOffsetX') arrowOffsetX: number;\n\n    /** Popover arrow width */\n    @Input('popoverArrowWidth') arrowWidth: number;\n\n    /** Popover arrow color */\n    @Input('popoverArrowColor') arrowColor: string;\n\n    /** Popover container close on click */\n    @Input('popoverCloseOnClick') closeOnClick: boolean;\n\n    /** Popover backdrop close on click */\n    @Input('popoverBackdropCloseOnClick') backdropCloseOnClick: boolean = true;\n\n    /** Event emitted when the associated popover is opened. */\n    @Output() opened: EventEmitter<void> = new EventEmitter<void>();\n\n    /** Event emitted when the associated popover is closed. */\n    @Output() closed: EventEmitter<void> = new EventEmitter<void>();\n\n    constructor(\n        private _overlay: Overlay,\n        public _elementRef: ElementRef,\n        private _viewContainerRef: ViewContainerRef,\n        @Optional() private _dir: Directionality,\n        private _changeDetectorRef: ChangeDetectorRef\n    ) { }\n\n    ngAfterViewInit(): void {\n        this._checkPopover();\n        this._setCurrentConfig();\n        this.popover.close.subscribe(() => this.closePopover());\n    }\n\n    ngOnDestroy(): void {\n        this.destroyPopover();\n    }\n\n    private _setCurrentConfig(): void {\n        if (this.positionX === 'before' || this.positionX === 'after') {\n            this.popover.positionX = this.positionX;\n        }\n\n        if (this.positionY === 'above' || this.positionY === 'below') {\n            this.popover.positionY = this.positionY;\n        }\n\n        if (this.triggerEvent) {\n            this.popover.triggerEvent = this.triggerEvent;\n        }\n\n        if (this.enterDelay) {\n            this.popover.enterDelay = this.enterDelay;\n        }\n\n        if (this.leaveDelay) {\n            this.popover.leaveDelay = this.leaveDelay;\n        }\n\n        if (this.overlapTrigger === true || this.overlapTrigger === false) {\n            this.popover.overlapTrigger = this.overlapTrigger;\n        }\n\n        if (this.targetOffsetX) {\n            this.popover.targetOffsetX = this.targetOffsetX;\n        }\n\n        if (this.targetOffsetY) {\n            this.popover.targetOffsetY = this.targetOffsetY;\n        }\n\n        if (this.arrowOffsetX) {\n            this.popover.arrowOffsetX = this.arrowOffsetX;\n        }\n\n        if (this.arrowWidth) {\n            this.popover.arrowWidth = this.arrowWidth;\n        }\n\n        if (this.arrowColor) {\n            this.popover.arrowColor = this.arrowColor;\n        }\n\n        if (this.closeOnClick === true || this.closeOnClick === false) {\n            this.popover.closeOnClick = this.closeOnClick;\n        }\n\n        this.popover.setCurrentStyles();\n    }\n\n    /** Whether the popover is open. */\n    get popoverOpen(): boolean { return this._popoverOpen; }\n\n    @HostListener('click', ['$event'])\n    onClick(event: MouseEvent): void {\n        if (this.popover.triggerEvent === 'click') {\n            this.togglePopover();\n        }\n    }\n\n    @HostListener('mouseenter', ['$event'])\n    onMouseEnter(event: MouseEvent): void {\n        this._halt = false;\n        if (this.popover.triggerEvent === 'hover') {\n            this._mouseoverTimer = setTimeout(() => {\n                this.openPopover();\n            }, this.popover.enterDelay);\n        }\n    }\n\n    @HostListener('mouseleave', ['$event'])\n    onMouseLeave(event: MouseEvent): void {\n        if (this.popover.triggerEvent === 'hover') {\n            if (this._mouseoverTimer) {\n                clearTimeout(this._mouseoverTimer);\n                this._mouseoverTimer = null;\n            }\n            if (this._popoverOpen) {\n                setTimeout(() => {\n                    if (!this.popover.closeDisabled) {\n                        this.closePopover();\n                    }\n                }, this.popover.leaveDelay);\n            } else {\n                this._halt = true;\n            }\n        }\n    }\n\n    /** Toggles the popover between the open and closed states. */\n    togglePopover(): void {\n        return this._popoverOpen ? this.closePopover() : this.openPopover();\n    }\n\n    /** Opens the popover. */\n    openPopover(): void {\n        if (!this._popoverOpen && !this._halt) {\n            this._createOverlay().attach(this._portal);\n\n            if (!ObjectUtil.isNull(this._viewContainerRef) && !ObjectUtil.isNull(this._viewContainerRef.element)) {\n                const width: number = GIPIDomHandler.getWidth((this._viewContainerRef.element.nativeElement as HTMLElement));\n                if (StringUtil.isEmpty(this.popover.popoverWidth) || (this.popover.popoverWidth === 'auto')) {\n                    this.popover.popoverWidth = `${width}px`;\n                }\n            }\n\n            this._subscribeToBackdrop();\n            this._subscribeToDetachments();\n\n            this._initPopover();\n        }\n    }\n\n    /** Closes the popover. */\n    closePopover(): void {\n        if (this._overlayRef) {\n            this._overlayRef.detach();\n            this._resetPopover();\n        }\n    }\n\n    /** Removes the popover from the DOM. */\n    destroyPopover(): void {\n        if (this._mouseoverTimer) {\n            clearTimeout(this._mouseoverTimer);\n            this._mouseoverTimer = null;\n        }\n        if (this._overlayRef) {\n            this._overlayRef.dispose();\n            this._overlayRef = null;\n            this._cleanUpSubscriptions();\n        }\n\n        this._onDestroy.next();\n        this._onDestroy.complete();\n    }\n\n    /** Focuses the popover trigger. */\n    focus(): void {\n        this._elementRef.nativeElement.focus();\n    }\n\n    /** The text direction of the containing app. */\n    get dir(): Direction {\n        return this._dir && this._dir.value === 'rtl' ? 'rtl' : 'ltr';\n    }\n\n    /**\n    * This method ensures that the popover closes when the overlay backdrop is clicked.\n    * We do not use first() here because doing so would not catch clicks from within\n    * the popover, and it would fail to unsubscribe properly. Instead, we unsubscribe\n    * explicitly when the popover is closed or destroyed.\n    */\n    private _subscribeToBackdrop(): void {\n        if (this._overlayRef) {\n            /** Only subscribe to backdrop if trigger event is click */\n            if (this.triggerEvent === 'click' && this.backdropCloseOnClick === true) {\n                this._overlayRef.backdropClick()\n                    .pipe(\n                        takeUntil(this.popoverClosed),\n                        takeUntil(this._onDestroy),\n                    )\n                    .subscribe(() => {\n                        this.popover._emitCloseEvent();\n                    });\n            }\n        }\n    }\n\n    private _subscribeToDetachments(): void {\n        if (this._overlayRef) {\n            this._overlayRef.detachments()\n                .pipe(\n                    takeUntil(this.popoverClosed),\n                    takeUntil(this._onDestroy),\n                )\n                .subscribe(() => {\n                    this._setPopoverClosed();\n                });\n        }\n    }\n\n    /**\n    * This method sets the popover state to open and focuses the first item if\n    * the popover was opened via the keyboard.\n    */\n    private _initPopover(): void {\n        this._setPopoverOpened();\n    }\n\n    /**\n    * This method resets the popover when it's closed, most importantly restoring\n    * focus to the popover trigger if the popover was opened via the keyboard.\n    */\n    private _resetPopover(): void {\n        this._setPopoverClosed();\n\n        // Focus only needs to be reset to the host element if the popover was opened\n        // by the keyboard and manually shifted to the first popover item.\n        if (!this._openedByMouse) {\n            this.focus();\n        }\n        this._openedByMouse = false;\n    }\n\n    /** set state rather than toggle to support triggers sharing a popover */\n    private _setPopoverOpened(): void {\n        if (!this._popoverOpen) {\n            this._popoverOpen = true;\n\n            this.popoverOpened.next();\n            this.opened.emit();\n        }\n    }\n\n    /** set state rather than toggle to support triggers sharing a popover */\n    private _setPopoverClosed(): void {\n        if (this._popoverOpen) {\n            this._popoverOpen = false;\n\n            this.popoverClosed.next();\n            this.closed.emit();\n        }\n    }\n\n    /**\n    *  This method checks that a valid instance of MdPopover has been passed into\n    *  mdPopoverTriggerFor. If not, an exception is thrown.\n    */\n    private _checkPopover(): void {\n        if (!this.popover) {\n            throwPopoverMissingError();\n        }\n    }\n\n    /**\n    *  This method creates the overlay from the provided popover's template and saves its\n    *  OverlayRef so that it can be attached to the DOM when openPopover is called.\n    */\n    private _createOverlay(): OverlayRef {\n        if (!this._overlayRef) {\n            this._portal = new TemplatePortal(this.popover.templateRef, this._viewContainerRef);\n            const config = this._getOverlayConfig();\n            this._subscribeToPositions(config.positionStrategy as FlexibleConnectedPositionStrategy);\n            this._overlayRef = this._overlay.create(config);\n        }\n\n        return this._overlayRef;\n    }\n\n    /**\n    * This method builds the configuration object needed to create the overlay, the OverlayConfig.\n    * @returns OverlayConfig\n    */\n    private _getOverlayConfig(): OverlayConfig {\n        const overlayState = new OverlayConfig();\n        overlayState.positionStrategy = this._getPosition();\n\n        /** Display overlay backdrop if trigger event is click */\n        if (this.triggerEvent === 'click') {\n            overlayState.hasBackdrop = true;\n            overlayState.backdropClass = 'cdk-overlay-transparent-backdrop';\n        }\n\n        overlayState.direction = this.dir;\n        overlayState.scrollStrategy = this._getOverlayScrollStrategy(this.popover.scrollStrategy);\n\n        return overlayState;\n    }\n\n    /**\n     * This method returns the scroll strategy used by the cdk/overlay.\n     */\n    private _getOverlayScrollStrategy(strategy: PopoverScrollStrategy): ScrollStrategy {\n        switch (strategy) {\n            case 'noop':\n                return this._overlay.scrollStrategies.noop();\n            case 'close':\n                return this._overlay.scrollStrategies.close();\n            case 'block':\n                return this._overlay.scrollStrategies.block();\n            case 'reposition':\n            default:\n                return this._overlay.scrollStrategies.reposition();\n        }\n    }\n\n    /**\n    * Listens to changes in the position of the overlay and sets the correct classes\n    * on the popover based on the new position. This ensures the animation origin is always\n    * correct, even if a fallback position is used for the overlay.\n    */\n    private _subscribeToPositions(position: FlexibleConnectedPositionStrategy): void {\n        this._positionSubscription = position.positionChanges.subscribe(change => {\n            const posisionX: PopoverPositionX = change.connectionPair.overlayX === 'start' ? 'after' : 'before';\n            let posisionY: PopoverPositionY = change.connectionPair.overlayY === 'top' ? 'below' : 'above';\n\n            if (!this.popover.overlapTrigger) {\n                posisionY = posisionY === 'below' ? 'above' : 'below';\n            }\n\n            // required for ChangeDetectionStrategy.OnPush\n            this._changeDetectorRef.markForCheck();\n\n            this.popover.zone.run(() => {\n                this.popover.positionX = posisionX;\n                this.popover.positionY = posisionY;\n                this.popover.setCurrentStyles();\n\n                this.popover.setPositionClasses(posisionX, posisionY);\n            });\n        });\n    }\n\n    /**\n    * This method builds the position strategy for the overlay, so the popover is properly connected\n    * to the trigger.\n    * @returns ConnectedPositionStrategy\n    */\n    private _getPosition(): FlexibleConnectedPositionStrategy {\n        const [originX, originFallbackX]: HorizontalConnectionPos[] =\n            this.popover.positionX === 'before' ? ['end', 'start'] : ['start', 'end'];\n\n        const [overlayY, overlayFallbackY]: VerticalConnectionPos[] =\n            this.popover.positionY === 'above' ? ['bottom', 'top'] : ['top', 'bottom'];\n\n        // let originY = overlayY;\n        // let fallbackOriginY = overlayFallbackY;\n\n        let originY: 'top' | 'bottom' = overlayY;\n        let originFallbackY: 'top' | 'bottom' = overlayFallbackY;\n\n        const overlayX: 'start' | 'end' = originX;\n        const overlayFallbackX: 'start' | 'end' = originFallbackX;\n\n        /** Reverse overlayY and fallbackOverlayY when overlapTrigger is false */\n        if (!this.popover.overlapTrigger) {\n            originY = overlayY === 'top' ? 'bottom' : 'top';\n            originFallbackY = overlayFallbackY === 'top' ? 'bottom' : 'top';\n        }\n\n        let offsetX: number = 0;\n        let offsetY: number = 0;\n\n        if (this.popover.targetOffsetX && !isNaN(Number(this.popover.targetOffsetX))) {\n            offsetX = Number(this.popover.targetOffsetX);\n        }\n\n        if (this.popover.targetOffsetY && !isNaN(Number(this.popover.targetOffsetY))) {\n            offsetY = Number(this.popover.targetOffsetY);\n        }\n\n        /**\n         * For overriding position element, when popoverTargetAt has a valid element reference.\n         * Useful for sticking popover to parent element and offsetting arrow to trigger element.\n         * If undefined defaults to the trigger element reference.\n         */\n        let element: ElementRef<any> = this._elementRef;\n        if (typeof this.targetElement !== 'undefined') {\n            this.popover.containerPositioning = true;\n            element = this.targetElement._elementRef;\n        }\n\n        return this._overlay.position()\n            .flexibleConnectedTo(element)\n            .withLockedPosition(true)\n            .withPositions([\n                {\n                    originX,\n                    originY,\n                    overlayX,\n                    overlayY,\n                    offsetY\n                },\n                {\n                    originX: originFallbackX,\n                    originY,\n                    overlayX: overlayFallbackX,\n                    overlayY,\n                    offsetY\n                },\n                {\n                    originX,\n                    originY: originFallbackY,\n                    overlayX,\n                    overlayY: overlayFallbackY,\n                    offsetY: -offsetY\n                },\n                {\n                    originX: originFallbackX,\n                    originY: originFallbackY,\n                    overlayX: overlayFallbackX,\n                    overlayY: overlayFallbackY,\n                    offsetY: -offsetY\n                }\n            ])\n            .withDefaultOffsetX(offsetX)\n            .withDefaultOffsetY(offsetY);\n    }\n\n    private _cleanUpSubscriptions(): void {\n        if (this._backdropSubscription) {\n            this._backdropSubscription.unsubscribe();\n        }\n        if (this._positionSubscription) {\n            this._positionSubscription.unsubscribe();\n        }\n        if (this._detachmentsSubscription) {\n            this._detachmentsSubscription.unsubscribe();\n        }\n    }\n\n    @HostListener('mousedown', ['$event']) _handleMousedown(event: MouseEvent): void {\n        if (event && !isFakeMousedownFromScreenReader(event)) {\n            this._openedByMouse = true;\n        }\n    }\n}\n"]}

package/esm5/shared/gipi-components/popover/shared/popover-types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9wb3Zlci10eXBlcy5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BnaXBpc2lzdGVtYXMvbmctY29yZS8iLCJzb3VyY2VzIjpbInNoYXJlZC9naXBpLWNvbXBvbmVudHMvcG9wb3Zlci9zaGFyZWQvcG9wb3Zlci10eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHR5cGUgUG9wb3ZlclBvc2l0aW9uWCA9ICdiZWZvcmUnIHwgJ2FmdGVyJztcblxuZXhwb3J0IHR5cGUgUG9wb3ZlclBvc2l0aW9uWSA9ICdhYm92ZScgfCAnYmVsb3cnO1xuXG5leHBvcnQgdHlwZSBQb3BvdmVyVHJpZ2dlckV2ZW50ID0gJ2NsaWNrJyB8ICdob3ZlcicgfCAnbm9uZSc7XG5cbmV4cG9ydCB0eXBlIFBvcG92ZXJTY3JvbGxTdHJhdGVneSA9ICdub29wJyB8ICdjbG9zZScgfCAnYmxvY2snIHwgJ3JlcG9zaXRpb24nO1xuIl19