@simpleangularcontrols/sac-common 10.0.0-rc.3 → 10.0.0-rc.30

package/esm2015/utilities/popuphelper.js

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