@simpleangularcontrols/sac-common 10.0.0-rc.11 → 10.0.0-rc.13

package/esm2015/utilities/popuphelper.js

@@ -0,0 +1,343 @@
+import { TooltipPosition } from './enums';
+export class PopUpHelper {
+    // #region Public Methods
+    getContainerHeight(referenceContainer, referenceIsContainer) {
+        if (referenceContainer) {
+            return referenceIsContainer
+                ? referenceContainer.nativeElement.firstElementChild.clientHeight
+                : referenceContainer.nativeElement.offsetHeight;
+        }
+        else {
+            return 0;
+        }
+    }
+    getContainerWidth(referenceContainer, referenceIsContainer) {
+        if (referenceContainer) {
+            return referenceIsContainer
+                ? referenceContainer.nativeElement.firstElementChild.clientWidth
+                : referenceContainer.nativeElement.offsetWidth;
+        }
+        else {
+            return 0;
+        }
+    }
+    /**
+     * Get Position who the popup would be positioned
+     *
+     * @param referenceContainer Element Reference to HTML Element which is the reference to positioning the popup
+     * @param popupcontentcontainer Element Reference to container of popup
+     * @param popupOffset Offset for popup positioning
+     * @param allowedPositions Allowed Positions for the popup
+     * @returns Returns the position where the popup should be displayed
+     */
+    getDisplayPosition(referenceContainer, popupcontentcontainer, arrowWidth, arrowHeight, allowedPositions, referenceIsContainer) {
+        const validPositions = this.validatePositions(referenceContainer, popupcontentcontainer, arrowWidth, arrowHeight, referenceIsContainer);
+        // tslint:disable-next-line:no-bitwise
+        if (this.hasPosition(allowedPositions, TooltipPosition.right) && validPositions & TooltipPosition.right) {
+            return TooltipPosition.right;
+        }
+        // tslint:disable-next-line:no-bitwise
+        if (this.hasPosition(allowedPositions, TooltipPosition.top) && validPositions & TooltipPosition.top) {
+            return TooltipPosition.top;
+        }
+        // tslint:disable-next-line:no-bitwise
+        if (this.hasPosition(allowedPositions, TooltipPosition.left) && validPositions & TooltipPosition.left) {
+            return TooltipPosition.left;
+        }
+        // tslint:disable-next-line:no-bitwise
+        if (this.hasPosition(allowedPositions, TooltipPosition.bottom) && validPositions & TooltipPosition.bottom) {
+            return TooltipPosition.bottom;
+        }
+        if (this.hasPosition(allowedPositions, TooltipPosition.topend) && validPositions & TooltipPosition.topend) {
+            return TooltipPosition.topend;
+        }
+        if (this.hasPosition(allowedPositions, TooltipPosition.bottomend) &&
+            validPositions & TooltipPosition.bottomend) {
+            return TooltipPosition.bottomend;
+        }
+        // Get Auto Position or Default
+        if (this.isAutoPosition(allowedPositions)) {
+            // tslint:disable-next-line:no-bitwise
+            if (validPositions & TooltipPosition.right) {
+                return TooltipPosition.right;
+            }
+            // tslint:disable-next-line:no-bitwise
+            if (validPositions & TooltipPosition.top) {
+                return TooltipPosition.top;
+            }
+            // tslint:disable-next-line:no-bitwise
+            if (validPositions & TooltipPosition.left) {
+                return TooltipPosition.left;
+            }
+            // tslint:disable-next-line:no-bitwise
+            if (validPositions & TooltipPosition.bottom) {
+                return TooltipPosition.bottom;
+            }
+            return TooltipPosition.right;
+        }
+        else {
+            return this.getPosition(allowedPositions);
+        }
+    }
+    /**
+     * Calculates the height of the popup
+     *
+     * @param container Element Reference to container of popup
+     */
+    getPopupHeight(container) {
+        var _a;
+        if (container) {
+            return (_a = container.nativeElement.firstElementChild.clientHeight) !== null && _a !== void 0 ? _a : 0;
+        }
+        else {
+            return 0;
+        }
+    }
+    /**
+     * Calculates the width of the popup
+     *
+     * @param container Element Reference to container of popup
+     */
+    getPopupWidth(container) {
+        if (container) {
+            return container.nativeElement.firstElementChild.clientWidth;
+        }
+        else {
+            return 0;
+        }
+    }
+    /**
+     * Returns the defined position for the tooltip
+     *
+     * @param allowedPositions Allowed positions defined in markup for popup
+     */
+    getPosition(allowedPositions) {
+        if (this.hasPosition(allowedPositions, TooltipPosition.left)) {
+            return TooltipPosition.left;
+        }
+        if (this.hasPosition(allowedPositions, TooltipPosition.top)) {
+            return TooltipPosition.top;
+        }
+        if (this.hasPosition(allowedPositions, TooltipPosition.right)) {
+            return TooltipPosition.right;
+        }
+        if (this.hasPosition(allowedPositions, TooltipPosition.bottom)) {
+            return TooltipPosition.bottom;
+        }
+        if (this.hasPosition(allowedPositions, TooltipPosition.topend)) {
+            return TooltipPosition.topend;
+        }
+        if (this.hasPosition(allowedPositions, TooltipPosition.bottomend)) {
+            return TooltipPosition.bottomend;
+        }
+        // Default Position if empty
+        return TooltipPosition.right;
+    }
+    /**
+     * Calculates the position of the tooltip from links
+     *
+     * @param controlReference Element Reference to angular component
+     * @param popupContainer Element Reference to container of popup
+     * @param referenceContainer Element Reference to HTML Element which is the reference to positioning the popup
+     * @param popupOffset Offset for popup positioning
+     * @param requestedPosition Requested Position by Control
+     */
+    getPositionLeft(referenceContainer, popupContainer, controlReference, arrowWidth, arrowHeight, requestedPosition, referenceIsContainer) {
+        if (referenceContainer !== null && referenceContainer !== undefined) {
+            const item = referenceContainer.nativeElement;
+            if (item.children.length >= 1) {
+                const childItem = referenceIsContainer ? item.firstElementChild : item;
+                const contentPosition = childItem.getBoundingClientRect();
+                switch (this.getDisplayPosition(referenceContainer, popupContainer, arrowWidth, arrowHeight, requestedPosition, referenceIsContainer)) {
+                    case TooltipPosition.top:
+                    case TooltipPosition.bottom:
+                        return (contentPosition.left + contentPosition.width / 2 - this.getPopupWidth(popupContainer) / 2);
+                    case TooltipPosition.topend:
+                    case TooltipPosition.bottomend:
+                        return contentPosition.left + contentPosition.width - this.getPopupWidth(popupContainer);
+                    case TooltipPosition.right:
+                        return contentPosition.left + contentPosition.width + arrowWidth / 2;
+                    case TooltipPosition.left:
+                        return contentPosition.left - this.getPopupWidth(popupContainer) + (arrowWidth / 2) * -1;
+                }
+                return referenceContainer.nativeElement.offsetTop;
+            }
+            else {
+                return referenceContainer.nativeElement.offsetTop;
+            }
+        }
+        else {
+            return controlReference.nativeElement.offsetLeft;
+        }
+    }
+    /**
+     * Calculates the position of the tooltip from the top
+     *
+     * @param controlReference Element Reference to angular component
+     * @param popupContainer Element Reference to container of popup
+     * @param referenceContainer Element Reference to HTML Element which is the reference to positioning the popup
+     * @param popupOffset Offset for popup positioning
+     * @param requestedPosition Requested Position by Control
+     */
+    getPositionTop(referenceContainer, popupContainer, controlReference, arrowWidth, arrowHeight, requestedPosition, referenceIsContainer) {
+        if (referenceContainer !== null && referenceContainer !== undefined) {
+            const item = referenceContainer.nativeElement;
+            if (item.children.length >= 1) {
+                const childItem = referenceIsContainer ? item.firstElementChild : item;
+                const contentPosition = childItem.getBoundingClientRect();
+                // Get Position with Scroll (Scrollbars inside page should be substracted)
+                const contentPositionTop = childItem.offsetTop +
+                    this.getOffsetTopParent(childItem.offsetParent) +
+                    this.getScrollTopParent(childItem.parentElement);
+                switch (this.getDisplayPosition(referenceContainer, popupContainer, arrowWidth, arrowHeight, requestedPosition, referenceIsContainer)) {
+                    case TooltipPosition.top:
+                    case TooltipPosition.topend:
+                        return contentPositionTop - this.getPopupHeight(popupContainer) + (arrowHeight / 2) * -1;
+                    case TooltipPosition.right:
+                    case TooltipPosition.left:
+                        return (contentPositionTop + contentPosition.height / 2 - this.getPopupHeight(popupContainer) / 2);
+                    case TooltipPosition.bottom:
+                    case TooltipPosition.bottomend:
+                        return contentPositionTop + contentPosition.height + arrowHeight / 2;
+                }
+                return (childItem.clientTop +
+                    childItem.offsetTop -
+                    (this.getPopupHeight(popupContainer) / 2 - childItem.offsetHeight / 2));
+            }
+            else {
+                return referenceContainer.nativeElement.offsetTop;
+            }
+        }
+        else {
+            return controlReference.nativeElement.offsetTop;
+        }
+    }
+    /**
+     * Returns whether the position has been configured
+     *
+     * @param allowedPositions Positions that allowed by control
+     * @param requestedPosition Position to be checked
+     */
+    hasPosition(allowedPositions, requestedPosition) {
+        const positions = allowedPositions.split('|');
+        if (requestedPosition === TooltipPosition.right && positions.indexOf('right') >= 0) {
+            return true;
+        }
+        if (requestedPosition === TooltipPosition.top && positions.indexOf('top') >= 0) {
+            return true;
+        }
+        if (requestedPosition === TooltipPosition.left && positions.indexOf('left') >= 0) {
+            return true;
+        }
+        if (requestedPosition === TooltipPosition.bottom && positions.indexOf('bottom') >= 0) {
+            return true;
+        }
+        if (requestedPosition === TooltipPosition.topend && positions.indexOf('topend') >= 0) {
+            return true;
+        }
+        if (requestedPosition === TooltipPosition.bottomend && positions.indexOf('bottomend') >= 0) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Defines whether AutoPosition is active
+     * @param positionProperty List of allowed positions
+     */
+    isAutoPosition(positionProperty) {
+        const positions = positionProperty.split('|');
+        return positions.indexOf('auto') >= 0;
+    }
+    /**
+     * Checks whether the position is valid or whether the tooltip on the position has space
+     */
+    validatePositions(referenceContainer, popupcontentcontainer, arrowWidth, arrowHeight, referenceIsContainer) {
+        // Check if Container is false
+        if (popupcontentcontainer === undefined) {
+            return TooltipPosition.right;
+        }
+        let allowedPositions = TooltipPosition.none;
+        const basePosition = referenceIsContainer
+            ? referenceContainer.nativeElement.firstElementChild.getBoundingClientRect()
+            : referenceContainer.nativeElement.getBoundingClientRect();
+        const tooltipRect = popupcontentcontainer.nativeElement.firstElementChild.getBoundingClientRect();
+        const leftPosOk = basePosition.left - tooltipRect.width + arrowWidth * -1 > 0;
+        const rightPosOk = basePosition.right + tooltipRect.width + arrowWidth < window.innerWidth;
+        const topPosOk = basePosition.top - tooltipRect.height + arrowHeight > 0;
+        const bottomPosOk = basePosition.bottom + tooltipRect.height + arrowHeight < window.innerHeight;
+        const leftHalfPosOk = basePosition.left - tooltipRect.width / 2 > 0;
+        const rightHalfPosOk = basePosition.right + tooltipRect.width / 2 < window.innerWidth;
+        const topHalfPosOk = basePosition.top - tooltipRect.height / 2 > 0;
+        const bottomHalfPosOk = basePosition.bottom + tooltipRect.height / 2 < window.innerHeight;
+        if (leftPosOk && topPosOk) {
+            // tslint:disable-next-line:no-bitwise
+            allowedPositions = allowedPositions | TooltipPosition.topend;
+        }
+        if (leftPosOk && bottomPosOk) {
+            // tslint:disable-next-line:no-bitwise
+            allowedPositions = allowedPositions | TooltipPosition.bottomend;
+        }
+        if (leftPosOk && topHalfPosOk && bottomHalfPosOk) {
+            // tslint:disable-next-line:no-bitwise
+            allowedPositions = allowedPositions | TooltipPosition.left;
+        }
+        if (rightPosOk && topHalfPosOk && bottomHalfPosOk) {
+            // tslint:disable-next-line:no-bitwise
+            allowedPositions = allowedPositions | TooltipPosition.right;
+        }
+        if (topPosOk && leftHalfPosOk && rightHalfPosOk) {
+            // tslint:disable-next-line:no-bitwise
+            allowedPositions = allowedPositions | TooltipPosition.top;
+        }
+        if (bottomPosOk && leftHalfPosOk && rightHalfPosOk) {
+            // tslint:disable-next-line:no-bitwise
+            allowedPositions = allowedPositions | TooltipPosition.bottom;
+        }
+        return allowedPositions;
+    }
+    // #endregion Public Methods
+    // #region Private Methods
+    /**
+     * Calculates the top of the page inside all elements
+     * @param element HTML Element
+     * @returns summarized top value for absolute position
+     */
+    getOffsetTopParent(element) {
+        if (element === null) {
+            return 0;
+        }
+        if (!element.offsetParent) {
+            return element.offsetTop;
+        }
+        const parentValue = this.getOffsetTopParent(element.offsetParent);
+        let offset = element.offsetTop;
+        return parentValue + offset;
+    }
+    /**
+     * Caclulate Scrollbars inside tree
+     * @param element HTML Element
+     * @param [isFixed=false] Invert Scroll Position value when style is fixed to preserve negative values
+     * @returns Scroll top value of element with all childs
+     */
+    getScrollTopParent(element, isFixed = false) {
+        if (element === null) {
+            return 0;
+        }
+        // Body Scroll should not be calculated
+        if (!element.parentElement) {
+            return isFixed ? element.scrollTop : 0;
+        }
+        let isCurrentFixed = false;
+        if (window.getComputedStyle(element).getPropertyValue('position') === 'fixed') {
+            isCurrentFixed = true;
+        }
+        const parentValue = this.getScrollTopParent(element.parentElement, isFixed || isCurrentFixed);
+        if (isFixed) {
+            return parentValue + element.scrollTop;
+        }
+        else {
+            return parentValue + element.scrollTop * -1;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"popuphelper.js","sourceRoot":"C:/Projekte/simpleangularcontrols-ng10/ch.jnetwork.sac-controls/projects/sac-common/src/","sources":["utilities/popuphelper.ts"],"names":[],"mappings":"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","sourcesContent":["import { TooltipPosition } from './enums';\r\nimport { ElementRef } from '@angular/core';\r\n\r\nexport class PopUpHelper {\r\n    // #region Public Methods\r\n\r\n    public getContainerHeight(referenceContainer: ElementRef<HTMLElement>, referenceIsContainer: boolean): number {\r\n        if (referenceContainer) {\r\n            return referenceIsContainer\r\n                ? referenceContainer.nativeElement.firstElementChild.clientHeight\r\n                : referenceContainer.nativeElement.offsetHeight;\r\n        } else {\r\n            return 0;\r\n        }\r\n    }\r\n\r\n    public getContainerWidth(referenceContainer: ElementRef<HTMLElement>, referenceIsContainer: boolean): number {\r\n        if (referenceContainer) {\r\n            return referenceIsContainer\r\n                ? referenceContainer.nativeElement.firstElementChild.clientWidth\r\n                : referenceContainer.nativeElement.offsetWidth;\r\n        } else {\r\n            return 0;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Get Position who the popup would be positioned\r\n     *\r\n     * @param referenceContainer Element Reference to HTML Element which is the reference to positioning the popup\r\n     * @param popupcontentcontainer Element Reference to container of popup\r\n     * @param popupOffset Offset for popup positioning\r\n     * @param allowedPositions Allowed Positions for the popup\r\n     * @returns Returns the position where the popup should be displayed\r\n     */\r\n    public getDisplayPosition(\r\n        referenceContainer: ElementRef<HTMLElement>,\r\n        popupcontentcontainer: ElementRef<HTMLElement>,\r\n        arrowWidth: number,\r\n        arrowHeight: number,\r\n        allowedPositions: string,\r\n        referenceIsContainer: boolean\r\n    ): TooltipPosition {\r\n        const validPositions: TooltipPosition = this.validatePositions(\r\n            referenceContainer,\r\n            popupcontentcontainer,\r\n            arrowWidth,\r\n            arrowHeight,\r\n            referenceIsContainer\r\n        );\r\n\r\n        // tslint:disable-next-line:no-bitwise\r\n        if (this.hasPosition(allowedPositions, TooltipPosition.right) && validPositions & TooltipPosition.right) {\r\n            return TooltipPosition.right;\r\n        }\r\n\r\n        // tslint:disable-next-line:no-bitwise\r\n        if (this.hasPosition(allowedPositions, TooltipPosition.top) && validPositions & TooltipPosition.top) {\r\n            return TooltipPosition.top;\r\n        }\r\n\r\n        // tslint:disable-next-line:no-bitwise\r\n        if (this.hasPosition(allowedPositions, TooltipPosition.left) && validPositions & TooltipPosition.left) {\r\n            return TooltipPosition.left;\r\n        }\r\n\r\n        // tslint:disable-next-line:no-bitwise\r\n        if (this.hasPosition(allowedPositions, TooltipPosition.bottom) && validPositions & TooltipPosition.bottom) {\r\n            return TooltipPosition.bottom;\r\n        }\r\n\r\n        if (this.hasPosition(allowedPositions, TooltipPosition.topend) && validPositions & TooltipPosition.topend) {\r\n            return TooltipPosition.topend;\r\n        }\r\n\r\n        if (\r\n            this.hasPosition(allowedPositions, TooltipPosition.bottomend) &&\r\n            validPositions & TooltipPosition.bottomend\r\n        ) {\r\n            return TooltipPosition.bottomend;\r\n        }\r\n\r\n        // Get Auto Position or Default\r\n        if (this.isAutoPosition(allowedPositions)) {\r\n            // tslint:disable-next-line:no-bitwise\r\n            if (validPositions & TooltipPosition.right) {\r\n                return TooltipPosition.right;\r\n            }\r\n\r\n            // tslint:disable-next-line:no-bitwise\r\n            if (validPositions & TooltipPosition.top) {\r\n                return TooltipPosition.top;\r\n            }\r\n\r\n            // tslint:disable-next-line:no-bitwise\r\n            if (validPositions & TooltipPosition.left) {\r\n                return TooltipPosition.left;\r\n            }\r\n\r\n            // tslint:disable-next-line:no-bitwise\r\n            if (validPositions & TooltipPosition.bottom) {\r\n                return TooltipPosition.bottom;\r\n            }\r\n\r\n            return TooltipPosition.right;\r\n        } else {\r\n            return this.getPosition(allowedPositions);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Calculates the height of the popup\r\n     *\r\n     * @param container Element Reference to container of popup\r\n     */\r\n    public getPopupHeight(container: ElementRef<HTMLElement>): number {\r\n        if (container) {\r\n            return container.nativeElement.firstElementChild.clientHeight ?? 0;\r\n        } else {\r\n            return 0;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Calculates the width of the popup\r\n     *\r\n     * @param container Element Reference to container of popup\r\n     */\r\n    public getPopupWidth(container: ElementRef<HTMLElement>): number {\r\n        if (container) {\r\n            return container.nativeElement.firstElementChild.clientWidth;\r\n        } else {\r\n            return 0;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Returns the defined position for the tooltip\r\n     *\r\n     * @param allowedPositions Allowed positions defined in markup for popup\r\n     */\r\n    public getPosition(allowedPositions: string): TooltipPosition {\r\n        if (this.hasPosition(allowedPositions, TooltipPosition.left)) {\r\n            return TooltipPosition.left;\r\n        }\r\n\r\n        if (this.hasPosition(allowedPositions, TooltipPosition.top)) {\r\n            return TooltipPosition.top;\r\n        }\r\n\r\n        if (this.hasPosition(allowedPositions, TooltipPosition.right)) {\r\n            return TooltipPosition.right;\r\n        }\r\n\r\n        if (this.hasPosition(allowedPositions, TooltipPosition.bottom)) {\r\n            return TooltipPosition.bottom;\r\n        }\r\n\r\n        if (this.hasPosition(allowedPositions, TooltipPosition.topend)) {\r\n            return TooltipPosition.topend;\r\n        }\r\n\r\n        if (this.hasPosition(allowedPositions, TooltipPosition.bottomend)) {\r\n            return TooltipPosition.bottomend;\r\n        }\r\n\r\n        // Default Position if empty\r\n        return TooltipPosition.right;\r\n    }\r\n\r\n    /**\r\n     * Calculates the position of the tooltip from links\r\n     *\r\n     * @param controlReference Element Reference to angular component\r\n     * @param popupContainer Element Reference to container of popup\r\n     * @param referenceContainer Element Reference to HTML Element which is the reference to positioning the popup\r\n     * @param popupOffset Offset for popup positioning\r\n     * @param requestedPosition Requested Position by Control\r\n     */\r\n    public getPositionLeft(\r\n        referenceContainer: ElementRef<HTMLElement>,\r\n        popupContainer: ElementRef<HTMLElement>,\r\n        controlReference: ElementRef,\r\n        arrowWidth: number,\r\n        arrowHeight: number,\r\n        requestedPosition: string,\r\n        referenceIsContainer: boolean\r\n    ): number {\r\n        if (referenceContainer !== null && referenceContainer !== undefined) {\r\n            const item = referenceContainer.nativeElement;\r\n\r\n            if (item.children.length >= 1) {\r\n                const childItem = referenceIsContainer ? (item.firstElementChild as HTMLElement) : item;\r\n                const contentPosition: DOMRect = childItem.getBoundingClientRect();\r\n\r\n                switch (\r\n                    this.getDisplayPosition(\r\n                        referenceContainer,\r\n                        popupContainer,\r\n                        arrowWidth,\r\n                        arrowHeight,\r\n                        requestedPosition,\r\n                        referenceIsContainer\r\n                    )\r\n                ) {\r\n                    case TooltipPosition.top:\r\n                    case TooltipPosition.bottom:\r\n                        return (\r\n                            contentPosition.left + contentPosition.width / 2 - this.getPopupWidth(popupContainer) / 2\r\n                        );\r\n                    case TooltipPosition.topend:\r\n                    case TooltipPosition.bottomend:\r\n                        return contentPosition.left + contentPosition.width - this.getPopupWidth(popupContainer);\r\n                    case TooltipPosition.right:\r\n                        return contentPosition.left + contentPosition.width + arrowWidth / 2;\r\n                    case TooltipPosition.left:\r\n                        return contentPosition.left - this.getPopupWidth(popupContainer) + (arrowWidth / 2) * -1;\r\n                }\r\n\r\n                return referenceContainer.nativeElement.offsetTop;\r\n            } else {\r\n                return referenceContainer.nativeElement.offsetTop;\r\n            }\r\n        } else {\r\n            return controlReference.nativeElement.offsetLeft;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Calculates the position of the tooltip from the top\r\n     *\r\n     * @param controlReference Element Reference to angular component\r\n     * @param popupContainer Element Reference to container of popup\r\n     * @param referenceContainer Element Reference to HTML Element which is the reference to positioning the popup\r\n     * @param popupOffset Offset for popup positioning\r\n     * @param requestedPosition Requested Position by Control\r\n     */\r\n    public getPositionTop(\r\n        referenceContainer: ElementRef<HTMLElement>,\r\n        popupContainer: ElementRef<HTMLElement>,\r\n        controlReference: ElementRef,\r\n        arrowWidth: number,\r\n        arrowHeight: number,\r\n        requestedPosition: string,\r\n        referenceIsContainer: boolean\r\n    ): number {\r\n        if (referenceContainer !== null && referenceContainer !== undefined) {\r\n            const item = referenceContainer.nativeElement;\r\n            if (item.children.length >= 1) {\r\n                const childItem = referenceIsContainer ? (item.firstElementChild as HTMLElement) : item;\r\n                const contentPosition: DOMRect = childItem.getBoundingClientRect();\r\n\r\n                // Get Position with Scroll (Scrollbars inside page should be substracted)\r\n                const contentPositionTop =\r\n                    childItem.offsetTop +\r\n                    this.getOffsetTopParent(childItem.offsetParent as HTMLElement) +\r\n                    this.getScrollTopParent(childItem.parentElement);\r\n\r\n                switch (\r\n                    this.getDisplayPosition(\r\n                        referenceContainer,\r\n                        popupContainer,\r\n                        arrowWidth,\r\n                        arrowHeight,\r\n                        requestedPosition,\r\n                        referenceIsContainer\r\n                    )\r\n                ) {\r\n                    case TooltipPosition.top:\r\n                    case TooltipPosition.topend:\r\n                        return contentPositionTop - this.getPopupHeight(popupContainer) + (arrowHeight / 2) * -1;\r\n                    case TooltipPosition.right:\r\n                    case TooltipPosition.left:\r\n                        return (\r\n                            contentPositionTop + contentPosition.height / 2 - this.getPopupHeight(popupContainer) / 2\r\n                        );\r\n                    case TooltipPosition.bottom:\r\n                    case TooltipPosition.bottomend:\r\n                        return contentPositionTop + contentPosition.height + arrowHeight / 2;\r\n                }\r\n\r\n                return (\r\n                    childItem.clientTop +\r\n                    childItem.offsetTop -\r\n                    (this.getPopupHeight(popupContainer) / 2 - childItem.offsetHeight / 2)\r\n                );\r\n            } else {\r\n                return referenceContainer.nativeElement.offsetTop;\r\n            }\r\n        } else {\r\n            return controlReference.nativeElement.offsetTop;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Returns whether the position has been configured\r\n     *\r\n     * @param allowedPositions Positions that allowed by control\r\n     * @param requestedPosition Position to be checked\r\n     */\r\n    public hasPosition(allowedPositions: string, requestedPosition: TooltipPosition): boolean {\r\n        const positions = allowedPositions.split('|');\r\n\r\n        if (requestedPosition === TooltipPosition.right && positions.indexOf('right') >= 0) {\r\n            return true;\r\n        }\r\n\r\n        if (requestedPosition === TooltipPosition.top && positions.indexOf('top') >= 0) {\r\n            return true;\r\n        }\r\n\r\n        if (requestedPosition === TooltipPosition.left && positions.indexOf('left') >= 0) {\r\n            return true;\r\n        }\r\n\r\n        if (requestedPosition === TooltipPosition.bottom && positions.indexOf('bottom') >= 0) {\r\n            return true;\r\n        }\r\n\r\n        if (requestedPosition === TooltipPosition.topend && positions.indexOf('topend') >= 0) {\r\n            return true;\r\n        }\r\n        if (requestedPosition === TooltipPosition.bottomend && positions.indexOf('bottomend') >= 0) {\r\n            return true;\r\n        }\r\n\r\n        return false;\r\n    }\r\n\r\n    /**\r\n     * Defines whether AutoPosition is active\r\n     * @param positionProperty List of allowed positions\r\n     */\r\n    public isAutoPosition(positionProperty: string): boolean {\r\n        const positions = positionProperty.split('|');\r\n        return positions.indexOf('auto') >= 0;\r\n    }\r\n\r\n    /**\r\n     * Checks whether the position is valid or whether the tooltip on the position has space\r\n     */\r\n    public validatePositions(\r\n        referenceContainer: ElementRef<HTMLElement>,\r\n        popupcontentcontainer: ElementRef<HTMLElement>,\r\n        arrowWidth: number,\r\n        arrowHeight: number,\r\n        referenceIsContainer: boolean\r\n    ): TooltipPosition {\r\n        // Check if Container is false\r\n        if (popupcontentcontainer === undefined) {\r\n            return TooltipPosition.right;\r\n        }\r\n\r\n        let allowedPositions: TooltipPosition = TooltipPosition.none;\r\n        const basePosition: DOMRect = referenceIsContainer\r\n            ? referenceContainer.nativeElement.firstElementChild.getBoundingClientRect()\r\n            : referenceContainer.nativeElement.getBoundingClientRect();\r\n        const tooltipRect: DOMRect = popupcontentcontainer.nativeElement.firstElementChild.getBoundingClientRect();\r\n\r\n        const leftPosOk: boolean = basePosition.left - tooltipRect.width + arrowWidth * -1 > 0;\r\n        const rightPosOk: boolean = basePosition.right + tooltipRect.width + arrowWidth < window.innerWidth;\r\n        const topPosOk: boolean = basePosition.top - tooltipRect.height + arrowHeight > 0;\r\n        const bottomPosOk: boolean = basePosition.bottom + tooltipRect.height + arrowHeight < window.innerHeight;\r\n\r\n        const leftHalfPosOk: boolean = basePosition.left - tooltipRect.width / 2 > 0;\r\n        const rightHalfPosOk: boolean = basePosition.right + tooltipRect.width / 2 < window.innerWidth;\r\n        const topHalfPosOk: boolean = basePosition.top - tooltipRect.height / 2 > 0;\r\n        const bottomHalfPosOk: boolean = basePosition.bottom + tooltipRect.height / 2 < window.innerHeight;\r\n\r\n        if (leftPosOk && topPosOk) {\r\n            // tslint:disable-next-line:no-bitwise\r\n            allowedPositions = allowedPositions | TooltipPosition.topend;\r\n        }\r\n\r\n        if (leftPosOk && bottomPosOk) {\r\n            // tslint:disable-next-line:no-bitwise\r\n            allowedPositions = allowedPositions | TooltipPosition.bottomend;\r\n        }\r\n\r\n        if (leftPosOk && topHalfPosOk && bottomHalfPosOk) {\r\n            // tslint:disable-next-line:no-bitwise\r\n            allowedPositions = allowedPositions | TooltipPosition.left;\r\n        }\r\n\r\n        if (rightPosOk && topHalfPosOk && bottomHalfPosOk) {\r\n            // tslint:disable-next-line:no-bitwise\r\n            allowedPositions = allowedPositions | TooltipPosition.right;\r\n        }\r\n\r\n        if (topPosOk && leftHalfPosOk && rightHalfPosOk) {\r\n            // tslint:disable-next-line:no-bitwise\r\n            allowedPositions = allowedPositions | TooltipPosition.top;\r\n        }\r\n\r\n        if (bottomPosOk && leftHalfPosOk && rightHalfPosOk) {\r\n            // tslint:disable-next-line:no-bitwise\r\n            allowedPositions = allowedPositions | TooltipPosition.bottom;\r\n        }\r\n\r\n        return allowedPositions;\r\n    }\r\n\r\n    // #endregion Public Methods\r\n\r\n    // #region Private Methods\r\n\r\n    /**\r\n     * Calculates the top of the page inside all elements\r\n     * @param element HTML Element\r\n     * @returns summarized top value for absolute position\r\n     */\r\n    private getOffsetTopParent(element: HTMLElement): number {\r\n        if (element === null) {\r\n            return 0;\r\n        }\r\n\r\n        if (!element.offsetParent) {\r\n            return element.offsetTop;\r\n        }\r\n\r\n        const parentValue = this.getOffsetTopParent(element.offsetParent as HTMLElement);\r\n        let offset = element.offsetTop;\r\n        return parentValue + offset;\r\n    }\r\n\r\n    /**\r\n     * Caclulate Scrollbars inside tree\r\n     * @param element HTML Element\r\n     * @param [isFixed=false] Invert Scroll Position value when style is fixed to preserve negative values\r\n     * @returns Scroll top value of element with all childs\r\n     */\r\n    private getScrollTopParent(element: HTMLElement, isFixed = false): number {\r\n        if (element === null) {\r\n            return 0;\r\n        }\r\n\r\n        // Body Scroll should not be calculated\r\n        if (!element.parentElement) {\r\n            return isFixed ? element.scrollTop : 0;\r\n        }\r\n\r\n        let isCurrentFixed = false;\r\n        if (window.getComputedStyle(element).getPropertyValue('position') === 'fixed') {\r\n            isCurrentFixed = true;\r\n        }\r\n\r\n        const parentValue = this.getScrollTopParent(element.parentElement, isFixed || isCurrentFixed);\r\n\r\n        if (isFixed) {\r\n            return parentValue + element.scrollTop;\r\n        } else {\r\n            return parentValue + element.scrollTop * -1;\r\n        }\r\n    }\r\n\r\n    // #endregion Private Methods\r\n}\r\n"]}

package/esm2015/utilities/popuphelper.ngfactory.js

@@ -0,0 +1,7 @@
+/**
+ * @fileoverview This file was generated by the Angular template compiler. Do not edit.
+ *
+ * @suppress {suspiciousCode,uselessCode,missingProperties,missingOverride,checkTypes,extraRequire}
+ * tslint:disable
+ */
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9wdXBoZWxwZXIubmdmYWN0b3J5LmpzIiwic291cmNlUm9vdCI6IkM6L1Byb2pla3RlL3NpbXBsZWFuZ3VsYXJjb250cm9scy1uZzEwL2NoLmpuZXR3b3JrLnNhYy1jb250cm9scy9wcm9qZWN0cy9zYWMtY29tbW9uL3NyYy8iLCJzb3VyY2VzIjpbInV0aWxpdGllcy9wb3B1cGhlbHBlci5uZ2ZhY3RvcnkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIGkwIGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaTAuQ29tcG9uZW50RmFjdG9yeTtcbiJdfQ==

package/esm2015/validation/equals.validator.js

@@ -0,0 +1,14 @@
+import { CreateValidationError } from './validationerrorcreator';
+export function equalsValueValidator(requiredvalue, validationMessage, validationMessageSummary) {
+    return (control) => {
+        if (control.value !== requiredvalue) {
+            const parameters = new Map();
+            parameters.set('EQUALSVALUE', requiredvalue);
+            return CreateValidationError('equals', validationMessage, validationMessageSummary, parameters);
+        }
+        else {
+            return null;
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXF1YWxzLnZhbGlkYXRvci5qcyIsInNvdXJjZVJvb3QiOiJDOi9Qcm9qZWt0ZS9zaW1wbGVhbmd1bGFyY29udHJvbHMtbmcxMC9jaC5qbmV0d29yay5zYWMtY29udHJvbHMvcHJvamVjdHMvc2FjLWNvbW1vbi9zcmMvIiwic291cmNlcyI6WyJ2YWxpZGF0aW9uL2VxdWFscy52YWxpZGF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFFakUsTUFBTSxVQUFVLG9CQUFvQixDQUNsQyxhQUFrQixFQUNsQixpQkFBeUIsRUFDekIsd0JBQWdDO0lBRWhDLE9BQU8sQ0FBQyxPQUF3QixFQUEyQixFQUFFO1FBQzNELElBQUksT0FBTyxDQUFDLEtBQUssS0FBSyxhQUFhLEVBQUU7WUFDbkMsTUFBTSxVQUFVLEdBQXFCLElBQUksR0FBRyxFQUFlLENBQUM7WUFDNUQsVUFBVSxDQUFDLEdBQUcsQ0FBQyxhQUFhLEVBQUUsYUFBYSxDQUFDLENBQUM7WUFFN0MsT0FBTyxxQkFBcUIsQ0FDMUIsUUFBUSxFQUNSLGlCQUFpQixFQUNqQix3QkFBd0IsRUFDeEIsVUFBVSxDQUNYLENBQUM7U0FDSDthQUFNO1lBQ0wsT0FBTyxJQUFJLENBQUM7U0FDYjtJQUNILENBQUMsQ0FBQztBQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBYnN0cmFjdENvbnRyb2wsIFZhbGlkYXRpb25FcnJvcnMsIFZhbGlkYXRvckZuIH0gZnJvbSAnQGFuZ3VsYXIvZm9ybXMnO1xyXG5pbXBvcnQgeyBDcmVhdGVWYWxpZGF0aW9uRXJyb3IgfSBmcm9tICcuL3ZhbGlkYXRpb25lcnJvcmNyZWF0b3InO1xyXG5cclxuZXhwb3J0IGZ1bmN0aW9uIGVxdWFsc1ZhbHVlVmFsaWRhdG9yKFxyXG4gIHJlcXVpcmVkdmFsdWU6IGFueSxcclxuICB2YWxpZGF0aW9uTWVzc2FnZTogc3RyaW5nLFxyXG4gIHZhbGlkYXRpb25NZXNzYWdlU3VtbWFyeTogc3RyaW5nXHJcbik6IFZhbGlkYXRvckZuIHtcclxuICByZXR1cm4gKGNvbnRyb2w6IEFic3RyYWN0Q29udHJvbCk6IFZhbGlkYXRpb25FcnJvcnMgfCBudWxsID0+IHtcclxuICAgIGlmIChjb250cm9sLnZhbHVlICE9PSByZXF1aXJlZHZhbHVlKSB7XHJcbiAgICAgIGNvbnN0IHBhcmFtZXRlcnM6IE1hcDxzdHJpbmcsIGFueT4gPSBuZXcgTWFwPHN0cmluZywgYW55PigpO1xyXG4gICAgICBwYXJhbWV0ZXJzLnNldCgnRVFVQUxTVkFMVUUnLCByZXF1aXJlZHZhbHVlKTtcclxuXHJcbiAgICAgIHJldHVybiBDcmVhdGVWYWxpZGF0aW9uRXJyb3IoXHJcbiAgICAgICAgJ2VxdWFscycsXHJcbiAgICAgICAgdmFsaWRhdGlvbk1lc3NhZ2UsXHJcbiAgICAgICAgdmFsaWRhdGlvbk1lc3NhZ2VTdW1tYXJ5LFxyXG4gICAgICAgIHBhcmFtZXRlcnNcclxuICAgICAgKTtcclxuICAgIH0gZWxzZSB7XHJcbiAgICAgIHJldHVybiBudWxsO1xyXG4gICAgfVxyXG4gIH07XHJcbn1cclxuIl19

package/esm2015/validation/equals.validator.ngfactory.js

@@ -0,0 +1,7 @@
+/**
+ * @fileoverview This file was generated by the Angular template compiler. Do not edit.
+ *
+ * @suppress {suspiciousCode,uselessCode,missingProperties,missingOverride,checkTypes,extraRequire}
+ * tslint:disable
+ */
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXF1YWxzLnZhbGlkYXRvci5uZ2ZhY3RvcnkuanMiLCJzb3VyY2VSb290IjoiQzovUHJvamVrdGUvc2ltcGxlYW5ndWxhcmNvbnRyb2xzLW5nMTAvY2guam5ldHdvcmsuc2FjLWNvbnRyb2xzL3Byb2plY3RzL3NhYy1jb21tb24vc3JjLyIsInNvdXJjZXMiOlsidmFsaWRhdGlvbi9lcXVhbHMudmFsaWRhdG9yLm5nZmFjdG9yeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0ICogYXMgaTAgZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pMC5Db21wb25lbnRGYWN0b3J5O1xuIl19

package/esm2015/validation/notequals.validator.js

@@ -0,0 +1,14 @@
+import { CreateValidationError } from './validationerrorcreator';
+export function notEqualsValueValidator(invalidValue, validationMessage, validationMessageSummary) {
+    return (control) => {
+        if (control.value === invalidValue) {
+            const parameters = new Map();
+            parameters.set('EQUALSVALUE', invalidValue);
+            return CreateValidationError('notequals', validationMessage, validationMessageSummary, parameters);
+        }
+        else {
+            return null;
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm90ZXF1YWxzLnZhbGlkYXRvci5qcyIsInNvdXJjZVJvb3QiOiJDOi9Qcm9qZWt0ZS9zaW1wbGVhbmd1bGFyY29udHJvbHMtbmcxMC9jaC5qbmV0d29yay5zYWMtY29udHJvbHMvcHJvamVjdHMvc2FjLWNvbW1vbi9zcmMvIiwic291cmNlcyI6WyJ2YWxpZGF0aW9uL25vdGVxdWFscy52YWxpZGF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFFakUsTUFBTSxVQUFVLHVCQUF1QixDQUNyQyxZQUFpQixFQUNqQixpQkFBeUIsRUFDekIsd0JBQWdDO0lBRWhDLE9BQU8sQ0FBQyxPQUF3QixFQUEyQixFQUFFO1FBQzNELElBQUksT0FBTyxDQUFDLEtBQUssS0FBSyxZQUFZLEVBQUU7WUFDbEMsTUFBTSxVQUFVLEdBQXFCLElBQUksR0FBRyxFQUFlLENBQUM7WUFDNUQsVUFBVSxDQUFDLEdBQUcsQ0FBQyxhQUFhLEVBQUUsWUFBWSxDQUFDLENBQUM7WUFFNUMsT0FBTyxxQkFBcUIsQ0FDMUIsV0FBVyxFQUNYLGlCQUFpQixFQUNqQix3QkFBd0IsRUFDeEIsVUFBVSxDQUNYLENBQUM7U0FDSDthQUFNO1lBQ0wsT0FBTyxJQUFJLENBQUM7U0FDYjtJQUNILENBQUMsQ0FBQztBQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBYnN0cmFjdENvbnRyb2wsIFZhbGlkYXRpb25FcnJvcnMsIFZhbGlkYXRvckZuIH0gZnJvbSAnQGFuZ3VsYXIvZm9ybXMnO1xyXG5pbXBvcnQgeyBDcmVhdGVWYWxpZGF0aW9uRXJyb3IgfSBmcm9tICcuL3ZhbGlkYXRpb25lcnJvcmNyZWF0b3InO1xyXG5cclxuZXhwb3J0IGZ1bmN0aW9uIG5vdEVxdWFsc1ZhbHVlVmFsaWRhdG9yKFxyXG4gIGludmFsaWRWYWx1ZTogYW55LFxyXG4gIHZhbGlkYXRpb25NZXNzYWdlOiBzdHJpbmcsXHJcbiAgdmFsaWRhdGlvbk1lc3NhZ2VTdW1tYXJ5OiBzdHJpbmdcclxuKTogVmFsaWRhdG9yRm4ge1xyXG4gIHJldHVybiAoY29udHJvbDogQWJzdHJhY3RDb250cm9sKTogVmFsaWRhdGlvbkVycm9ycyB8IG51bGwgPT4ge1xyXG4gICAgaWYgKGNvbnRyb2wudmFsdWUgPT09IGludmFsaWRWYWx1ZSkge1xyXG4gICAgICBjb25zdCBwYXJhbWV0ZXJzOiBNYXA8c3RyaW5nLCBhbnk+ID0gbmV3IE1hcDxzdHJpbmcsIGFueT4oKTtcclxuICAgICAgcGFyYW1ldGVycy5zZXQoJ0VRVUFMU1ZBTFVFJywgaW52YWxpZFZhbHVlKTtcclxuXHJcbiAgICAgIHJldHVybiBDcmVhdGVWYWxpZGF0aW9uRXJyb3IoXHJcbiAgICAgICAgJ25vdGVxdWFscycsXHJcbiAgICAgICAgdmFsaWRhdGlvbk1lc3NhZ2UsXHJcbiAgICAgICAgdmFsaWRhdGlvbk1lc3NhZ2VTdW1tYXJ5LFxyXG4gICAgICAgIHBhcmFtZXRlcnNcclxuICAgICAgKTtcclxuICAgIH0gZWxzZSB7XHJcbiAgICAgIHJldHVybiBudWxsO1xyXG4gICAgfVxyXG4gIH07XHJcbn1cclxuIl19

package/esm2015/validation/notequals.validator.ngfactory.js

@@ -0,0 +1,7 @@
+/**
+ * @fileoverview This file was generated by the Angular template compiler. Do not edit.
+ *
+ * @suppress {suspiciousCode,uselessCode,missingProperties,missingOverride,checkTypes,extraRequire}
+ * tslint:disable
+ */
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm90ZXF1YWxzLnZhbGlkYXRvci5uZ2ZhY3RvcnkuanMiLCJzb3VyY2VSb290IjoiQzovUHJvamVrdGUvc2ltcGxlYW5ndWxhcmNvbnRyb2xzLW5nMTAvY2guam5ldHdvcmsuc2FjLWNvbnRyb2xzL3Byb2plY3RzL3NhYy1jb21tb24vc3JjLyIsInNvdXJjZXMiOlsidmFsaWRhdGlvbi9ub3RlcXVhbHMudmFsaWRhdG9yLm5nZmFjdG9yeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0ICogYXMgaTAgZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pMC5Db21wb25lbnRGYWN0b3J5O1xuIl19