@simpleangularcontrols/sac-common 13.0.0-rc.2

package/esm2020/controls/tooltip/tooltip.mjs

@@ -0,0 +1,365 @@
+import { Directive, Input, ViewChild } from '@angular/core';
+import { convertToBoolean } from '../../utilities/convertion';
+import { TooltipPosition } from '../../utilities/enums';
+import * as i0 from "@angular/core";
+/**
+ * Tooltip Component
+ *
+ * Benötigt im HTML Markup folgende Identifier
+ * - container: Container für ng-content in welchem das Element angezeigt wird, wo der Tooltip angehängt wird.
+ * - tooltip: Container für Tooltip
+ *
+ * Tooltip muss in 2 Schritten angezeigt werden. In einem ersten Schritt wird der Tooltip Markup erzeugt mit (ngIf). In einem 2. Schritt
+ * kann der Tooltip dann über die CSS visibility angezeigt werden. Wird dies nicht so gemacht, kann es bei gewissen Browsern zu einem Flacker Effekt führen.
+ *
+ */
+export class SacTooltipCommon {
+    /**
+     * Konstruktor
+     * @param ref Element Referenz
+     */
+    constructor(cdRef, ref) {
+        this.cdRef = cdRef;
+        this.ref = ref;
+        /**
+         * Property für Enum in Angular HTML Template
+         */
+        this.TooltipPosition = TooltipPosition;
+        /**
+         * Definiert ob der Tooltip sichtbar ist
+         */
+        this._isTooltipVisible = false;
+        /**
+         * Position des Tooltips oben
+         */
+        this.TopPos = 0;
+        /**
+         * Position des Tooltips links
+         */
+        this.LeftPos = 0;
+        /**
+         * Position des Tooltips. Werte: left|top|right|bottom|auto
+         *
+         * Wert 'auto' kann mit einem anderen Wert kombiniert werden.
+         */
+        this.position = 'right|auto';
+        /**
+         * Definiert ob der Tooltip sichtbar sein soll
+         */
+        this.IsTooltipContentVisible = false;
+        /**
+         * Methode wenn Content geändert hat und Proporties im UI neu gesetzt werden müssen.
+         */
+        this.onContentChange = () => {
+            setTimeout(() => {
+                this.getLeftPosition();
+                this.getTopPosition();
+            });
+        };
+    }
+    /**
+     * Setter für Inline Mode für Tooltip
+     */
+    set inlinemode(value) {
+        this._inlinemode = convertToBoolean(value);
+    }
+    /**
+     * Getter für Inline Mode für Tooltip
+     */
+    get inlinemode() {
+        return this._inlinemode;
+    }
+    /**
+     * Setter für Name des Containers für den Tooltip. Wird benötigt, da Tooltip via NGIF ausgeblendet werden kann.
+     */
+    set tooltip(content) {
+        if (content !== undefined) {
+            document.body.appendChild(content.nativeElement);
+        }
+        this.tooltipcontainer = content;
+        this.onContentChange();
+        this.cdRef.detectChanges();
+    }
+    /**
+     * Ervent wenn das Control initialisert wird
+     */
+    ngOnInit() {
+        // Register Event Listener
+        window.addEventListener('scroll', this.onContentChange, true);
+        window.addEventListener('resize', this.onContentChange, true);
+        if (this.tooltipcontainer !== undefined) {
+            document.body.appendChild(this.tooltipcontainer.nativeElement);
+        }
+    }
+    /**
+     * Event wenn das Control zerstört wird.
+     */
+    ngOnDestroy() {
+        // Unregister Event Listener
+        window.removeEventListener('scroll', this.onContentChange, true);
+        window.removeEventListener('resize', this.onContentChange, true);
+        if (this.tooltipcontainer !== undefined) {
+            document.body.removeChild(this.tooltipcontainer.nativeElement);
+        }
+    }
+    /**
+     * Berechnet die Position des Tooltips von Oben
+     */
+    getTopPosition() {
+        if (this.content !== null && this.content !== undefined) {
+            const item = this.content.nativeElement;
+            if (item.children.length >= 1) {
+                const childItem = item.firstElementChild;
+                const contentPosition = childItem.getBoundingClientRect();
+                switch (this.GetTooltipPosition()) {
+                    case TooltipPosition.top:
+                        this.TopPos = contentPosition.top - this.getToolTipHeight();
+                        return contentPosition.top - this.getToolTipHeight();
+                    case TooltipPosition.right:
+                        this.TopPos = contentPosition.top + (contentPosition.height / 2) - (this.getToolTipHeight() / 2);
+                        return contentPosition.top + (contentPosition.height / 2) - (this.getToolTipHeight() / 2);
+                    case TooltipPosition.bottom:
+                        this.TopPos = contentPosition.top + contentPosition.height;
+                        return contentPosition.top + contentPosition.height;
+                    case TooltipPosition.left:
+                        this.TopPos = contentPosition.top + (contentPosition.height / 2) - (this.getToolTipHeight() / 2);
+                        return contentPosition.top + (contentPosition.height / 2) - (this.getToolTipHeight() / 2);
+                }
+                return childItem.clientTop + childItem.offsetTop - ((this.getToolTipHeight() / 2) - (childItem.clientHeight / 2));
+            }
+            else {
+                return this.content.nativeElement.offsetTop;
+            }
+        }
+        else {
+            return this.ref.nativeElement.offsetTop;
+        }
+    }
+    /**
+     * Berechnet die Position des Tooltips von Links
+     */
+    getLeftPosition() {
+        if (this.content !== null && this.content !== undefined) {
+            const item = this.content.nativeElement;
+            if (item.children.length >= 1) {
+                const childItem = item.firstElementChild;
+                const contentPosition = childItem.getBoundingClientRect();
+                switch (this.GetTooltipPosition()) {
+                    case TooltipPosition.top:
+                        this.LeftPos = contentPosition.left + (contentPosition.width / 2) - (this.getToolTipWidth() / 2);
+                        return contentPosition.left + (contentPosition.width / 2) - (this.getToolTipWidth() / 2);
+                    case TooltipPosition.right:
+                        this.LeftPos = contentPosition.left + contentPosition.width;
+                        return contentPosition.left + contentPosition.width;
+                    case TooltipPosition.bottom:
+                        this.LeftPos = contentPosition.left + (childItem.clientWidth / 2) - (this.getToolTipWidth() / 2);
+                        return contentPosition.left + (childItem.clientWidth / 2) - (this.getToolTipWidth() / 2);
+                    case TooltipPosition.left:
+                        this.LeftPos = contentPosition.left - this.getToolTipWidth();
+                        return contentPosition.left - this.getToolTipWidth();
+                }
+                return this.content.nativeElement.offsetTop;
+            }
+            else {
+                return this.content.nativeElement.offsetTop;
+            }
+        }
+        else {
+            return this.ref.nativeElement.offsetLeft;
+        }
+    }
+    /**
+     * Berechnet die Höhe des Tooltips
+     */
+    getToolTipHeight() {
+        if (this.tooltipcontainer) {
+            return this.tooltipcontainer.nativeElement.clientHeight;
+        }
+        else {
+            return 0;
+        }
+    }
+    /**
+     * Berechnet die Breite die Tooltips
+     */
+    getToolTipWidth() {
+        if (this.tooltipcontainer) {
+            return this.tooltipcontainer.nativeElement.clientWidth;
+        }
+        else {
+            return 0;
+        }
+    }
+    /**
+     * Definiert ob der Tooltip im Markup vorhanden ist
+     */
+    IsTooltipVisible() {
+        return this._isTooltipVisible;
+    }
+    /**
+     * Tooltip anzeigen
+     */
+    ShowTooltip() {
+        this._isTooltipVisible = true;
+        setTimeout(() => {
+            this.getLeftPosition();
+            this.getTopPosition();
+            this.IsTooltipContentVisible = true;
+        });
+    }
+    /**
+     * Tooltip ausblenden
+     */
+    HideTooltip() {
+        this._isTooltipVisible = false;
+        this.IsTooltipContentVisible = false;
+    }
+    /**
+     * Gibt die Position des Tooltips zurück
+     */
+    GetTooltipPosition() {
+        const validPositions = this.ValidatePositions();
+        // tslint:disable-next-line:no-bitwise
+        if (this.HasPosition(TooltipPosition.right) && (validPositions & TooltipPosition.right)) {
+            return TooltipPosition.right;
+        }
+        // tslint:disable-next-line:no-bitwise
+        if (this.HasPosition(TooltipPosition.top) && (validPositions & TooltipPosition.top)) {
+            return TooltipPosition.top;
+        }
+        // tslint:disable-next-line:no-bitwise
+        if (this.HasPosition(TooltipPosition.left) && (validPositions & TooltipPosition.left)) {
+            return TooltipPosition.left;
+        }
+        // tslint:disable-next-line:no-bitwise
+        if (this.HasPosition(TooltipPosition.bottom) && (validPositions & TooltipPosition.bottom)) {
+            return TooltipPosition.bottom;
+        }
+        // Get Auto Position or Default
+        if (this.IsAutoPosition()) {
+            // 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();
+        }
+    }
+    /**
+     * Definiert ob AutoPosition aktiv ist
+     */
+    IsAutoPosition() {
+        const positions = this.position.split('|');
+        return positions.indexOf('auto') >= 0;
+    }
+    /**
+     * Gibt die definierte Position für den Tooltip zurück
+     */
+    GetPosition() {
+        const positions = this.position.split('|');
+        if (this.HasPosition(TooltipPosition.left)) {
+            return TooltipPosition.left;
+        }
+        if (this.HasPosition(TooltipPosition.top)) {
+            return TooltipPosition.top;
+        }
+        if (this.HasPosition(TooltipPosition.right)) {
+            return TooltipPosition.right;
+        }
+        if (this.HasPosition(TooltipPosition.bottom)) {
+            return TooltipPosition.bottom;
+        }
+        // Default Position if empty
+        return TooltipPosition.right;
+    }
+    /**
+     * Gibt zurück, ob die Position konfiguriert wurde
+     *
+     * @param position Position auf welche geprüft wird
+     */
+    HasPosition(position) {
+        const positions = this.position.split('|');
+        if (position === TooltipPosition.right && positions.indexOf('right') >= 0) {
+            return true;
+        }
+        if (position === TooltipPosition.top && positions.indexOf('top') >= 0) {
+            return true;
+        }
+        if (position === TooltipPosition.left && positions.indexOf('left') >= 0) {
+            return true;
+        }
+        if (position === TooltipPosition.bottom && positions.indexOf('bottom') >= 0) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Prüft ob die Position gültig ist, resp. der Tooltip auf die Position platz hat
+     */
+    ValidatePositions() {
+        // Check if Container is false
+        if (this.tooltipcontainer === undefined) {
+            return TooltipPosition.right;
+        }
+        let allowedPositions = TooltipPosition.none;
+        const basePosition = this.content.nativeElement.firstElementChild.getBoundingClientRect();
+        const tooltipRect = this.tooltipcontainer.nativeElement.getBoundingClientRect();
+        const leftPosOk = basePosition.left - tooltipRect.width > 0;
+        const rightPosOk = basePosition.right + tooltipRect.width < window.innerWidth;
+        const topPosOk = basePosition.top - tooltipRect.height > 0;
+        const bottomPosOk = basePosition.bottom + tooltipRect.height < 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 && 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;
+    }
+}
+SacTooltipCommon.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SacTooltipCommon, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+SacTooltipCommon.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.7", type: SacTooltipCommon, inputs: { position: "position", tooltiptext: "tooltiptext", inlinemode: "inlinemode" }, viewQueries: [{ propertyName: "content", first: true, predicate: ["container"], descendants: true, static: true }, { propertyName: "tooltip", first: true, predicate: ["tooltip"], descendants: true, static: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SacTooltipCommon, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i0.ElementRef }]; }, propDecorators: { position: [{
+                type: Input
+            }], tooltiptext: [{
+                type: Input
+            }], inlinemode: [{
+                type: Input
+            }], content: [{
+                type: ViewChild,
+                args: ['container', { static: true }]
+            }], tooltip: [{
+                type: ViewChild,
+                args: ['tooltip', { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tooltip.js","sourceRoot":"","sources":["../../../../../projects/sac-common/src/controls/tooltip/tooltip.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectorRef, Directive, ElementRef, Input, OnDestroy, OnInit, ViewChild } from '@angular/core';\r\nimport { convertToBoolean } from '../../utilities/convertion';\r\nimport { TooltipPosition } from '../../utilities/enums';\r\n\r\n/**\r\n * Tooltip Component\r\n *\r\n * Benötigt im HTML Markup folgende Identifier\r\n * - container: Container für ng-content in welchem das Element angezeigt wird, wo der Tooltip angehängt wird.\r\n * - tooltip: Container für Tooltip\r\n *\r\n * Tooltip muss in 2 Schritten angezeigt werden. In einem ersten Schritt wird der Tooltip Markup erzeugt mit (ngIf). In einem 2. Schritt\r\n * kann der Tooltip dann über die CSS visibility angezeigt werden. Wird dies nicht so gemacht, kann es bei gewissen Browsern zu einem Flacker Effekt führen.\r\n *\r\n */\r\n@Directive()\r\nexport class SacTooltipCommon implements OnInit, OnDestroy {\r\n  /**\r\n   * Property für Enum in Angular HTML Template\r\n   */\r\n  TooltipPosition = TooltipPosition;\r\n\r\n  /**\r\n   * Definiert ob der Tooltip sichtbar ist\r\n   */\r\n  private _isTooltipVisible: boolean = false;\r\n\r\n  /**\r\n   * Position des Tooltips oben\r\n   */\r\n  TopPos: number = 0;\r\n\r\n  /**\r\n   * Position des Tooltips links\r\n   */\r\n  LeftPos: number = 0;\r\n\r\n  /**\r\n   * Position des Tooltips. Werte: left|top|right|bottom|auto\r\n   *\r\n   * Wert 'auto' kann mit einem anderen Wert kombiniert werden.\r\n   */\r\n  @Input()\r\n  position: string = 'right|auto';\r\n\r\n  /**\r\n   * Text für ToolTip\r\n   */\r\n  @Input()\r\n  tooltiptext: string;\r\n\r\n  /**\r\n   * Inline Mode für Tooltip\r\n   */\r\n  private _inlinemode: boolean;\r\n\r\n  /**\r\n   * Definiert ob der Tooltip sichtbar sein soll\r\n   */\r\n  IsTooltipContentVisible: boolean = false;\r\n\r\n  /**\r\n   * Setter für Inline Mode für Tooltip\r\n   */\r\n  @Input()\r\n  set inlinemode(value: boolean) {\r\n    this._inlinemode = convertToBoolean(value);\r\n  }\r\n  /**\r\n   * Getter für Inline Mode für Tooltip\r\n   */\r\n  get inlinemode(): boolean {\r\n    return this._inlinemode;\r\n  }\r\n\r\n  /**\r\n   * Name des Containers für Content (z.B. Icon) auf welchem der Tooltip angezeigt wird.\r\n   */\r\n  @ViewChild('container', { static: true }) content: ElementRef<HTMLElement>;\r\n\r\n  /**\r\n   * Name des Containers für den Tooltip\r\n   */\r\n  private tooltipcontainer: ElementRef<HTMLElement>;\r\n\r\n  /**\r\n   * Setter für Name des Containers für den Tooltip. Wird benötigt, da Tooltip via NGIF ausgeblendet werden kann.\r\n   */\r\n  @ViewChild('tooltip', { static: true })\r\n  set tooltip(content: ElementRef) {\r\n    if (content !== undefined) {\r\n      document.body.appendChild(content.nativeElement);\r\n    }\r\n\r\n    this.tooltipcontainer = content;\r\n    this.onContentChange();\r\n    this.cdRef.detectChanges();\r\n  }\r\n\r\n  /**\r\n   * Konstruktor\r\n   * @param ref Element Referenz\r\n   */\r\n  constructor(private cdRef: ChangeDetectorRef, private ref: ElementRef) { }\r\n\r\n  /**\r\n   * Ervent wenn das Control initialisert wird\r\n   */\r\n  ngOnInit() {\r\n    // Register Event Listener\r\n    window.addEventListener('scroll', this.onContentChange, true);\r\n    window.addEventListener('resize', this.onContentChange, true);\r\n\r\n    if (this.tooltipcontainer !== undefined) {\r\n      document.body.appendChild(this.tooltipcontainer.nativeElement);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Event wenn das Control zerstört wird.\r\n   */\r\n  ngOnDestroy() {\r\n    // Unregister Event Listener\r\n    window.removeEventListener('scroll', this.onContentChange, true);\r\n    window.removeEventListener('resize', this.onContentChange, true);\r\n\r\n    if (this.tooltipcontainer !== undefined) {\r\n      document.body.removeChild(this.tooltipcontainer.nativeElement);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Berechnet die Position des Tooltips von Oben\r\n   */\r\n  private getTopPosition(): number {\r\n    if (this.content !== null && this.content !== undefined) {\r\n      const item = this.content.nativeElement;\r\n\r\n      if (item.children.length >= 1) {\r\n        const childItem = item.firstElementChild as HTMLElement;\r\n        const contentPosition: ClientRect = childItem.getBoundingClientRect();\r\n\r\n        switch (this.GetTooltipPosition()) {\r\n          case TooltipPosition.top:\r\n            this.TopPos = contentPosition.top - this.getToolTipHeight();\r\n            return contentPosition.top - this.getToolTipHeight();\r\n          case TooltipPosition.right:\r\n            this.TopPos = contentPosition.top + (contentPosition.height / 2) - (this.getToolTipHeight() / 2);\r\n            return contentPosition.top + (contentPosition.height / 2) - (this.getToolTipHeight() / 2);\r\n          case TooltipPosition.bottom:\r\n            this.TopPos = contentPosition.top + contentPosition.height;\r\n            return contentPosition.top + contentPosition.height;\r\n          case TooltipPosition.left:\r\n            this.TopPos = contentPosition.top + (contentPosition.height / 2) - (this.getToolTipHeight() / 2);\r\n            return contentPosition.top + (contentPosition.height / 2) - (this.getToolTipHeight() / 2);\r\n        }\r\n\r\n        return childItem.clientTop + childItem.offsetTop - ((this.getToolTipHeight() / 2) - (childItem.clientHeight / 2));\r\n      } else {\r\n        return this.content.nativeElement.offsetTop;\r\n      }\r\n    } else {\r\n      return this.ref.nativeElement.offsetTop;\r\n    }\r\n\r\n  }\r\n\r\n  /**\r\n   * Berechnet die Position des Tooltips von Links\r\n   */\r\n  private getLeftPosition(): number {\r\n\r\n    if (this.content !== null && this.content !== undefined) {\r\n      const item = this.content.nativeElement;\r\n\r\n      if (item.children.length >= 1) {\r\n        const childItem = item.firstElementChild as HTMLElement;\r\n        const contentPosition: ClientRect = childItem.getBoundingClientRect();\r\n\r\n        switch (this.GetTooltipPosition()) {\r\n          case TooltipPosition.top:\r\n            this.LeftPos = contentPosition.left + (contentPosition.width / 2) - (this.getToolTipWidth() / 2);\r\n            return contentPosition.left + (contentPosition.width / 2) - (this.getToolTipWidth() / 2);\r\n          case TooltipPosition.right:\r\n            this.LeftPos = contentPosition.left + contentPosition.width;\r\n            return contentPosition.left + contentPosition.width;\r\n          case TooltipPosition.bottom:\r\n            this.LeftPos = contentPosition.left + (childItem.clientWidth / 2) - (this.getToolTipWidth() / 2);\r\n            return contentPosition.left + (childItem.clientWidth / 2) - (this.getToolTipWidth() / 2);\r\n          case TooltipPosition.left:\r\n            this.LeftPos = contentPosition.left - this.getToolTipWidth();\r\n            return contentPosition.left - this.getToolTipWidth();\r\n        }\r\n\r\n        return this.content.nativeElement.offsetTop;\r\n      } else {\r\n        return this.content.nativeElement.offsetTop;\r\n      }\r\n    } else {\r\n      return this.ref.nativeElement.offsetLeft;\r\n    }\r\n  }\r\n\r\n\r\n  /**\r\n   * Berechnet die Höhe des Tooltips\r\n   */\r\n  private getToolTipHeight(): number {\r\n    if (this.tooltipcontainer) {\r\n      return this.tooltipcontainer.nativeElement.clientHeight;\r\n    } else {\r\n      return 0;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Berechnet die Breite die Tooltips\r\n   */\r\n  private getToolTipWidth(): number {\r\n    if (this.tooltipcontainer) {\r\n      return this.tooltipcontainer.nativeElement.clientWidth;\r\n    } else {\r\n      return 0;\r\n    }\r\n  }\r\n\r\n\r\n  /**\r\n   * Definiert ob der Tooltip im Markup vorhanden ist\r\n   */\r\n  IsTooltipVisible(): boolean {\r\n    return this._isTooltipVisible;\r\n  }\r\n\r\n  /**\r\n   * Tooltip anzeigen\r\n   */\r\n  ShowTooltip(): void {\r\n    this._isTooltipVisible = true;\r\n    setTimeout(() => {\r\n      this.getLeftPosition();\r\n      this.getTopPosition();\r\n      this.IsTooltipContentVisible = true;\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Tooltip ausblenden\r\n   */\r\n  HideTooltip(): void {\r\n    this._isTooltipVisible = false;\r\n    this.IsTooltipContentVisible = false;\r\n  }\r\n\r\n  /**\r\n   * Methode wenn Content geändert hat und Proporties im UI neu gesetzt werden müssen.\r\n   */\r\n  private onContentChange = (): void => {\r\n    setTimeout(() => {\r\n      this.getLeftPosition();\r\n      this.getTopPosition();\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Gibt die Position des Tooltips zurück\r\n   */\r\n  public GetTooltipPosition(): TooltipPosition {\r\n    const validPositions: TooltipPosition = this.ValidatePositions();\r\n\r\n    // tslint:disable-next-line:no-bitwise\r\n    if (this.HasPosition(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(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(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(TooltipPosition.bottom) && (validPositions & TooltipPosition.bottom)) {\r\n      return TooltipPosition.bottom;\r\n    }\r\n\r\n    // Get Auto Position or Default\r\n    if (this.IsAutoPosition()) {\r\n\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();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Definiert ob AutoPosition aktiv ist\r\n   */\r\n  private IsAutoPosition(): boolean {\r\n    const positions = this.position.split('|');\r\n    return positions.indexOf('auto') >= 0;\r\n  }\r\n\r\n  /**\r\n   * Gibt die definierte Position für den Tooltip zurück\r\n   */\r\n  private GetPosition(): TooltipPosition {\r\n    const positions = this.position.split('|');\r\n\r\n    if (this.HasPosition(TooltipPosition.left)) {\r\n      return TooltipPosition.left;\r\n    }\r\n\r\n    if (this.HasPosition(TooltipPosition.top)) {\r\n      return TooltipPosition.top;\r\n    }\r\n\r\n    if (this.HasPosition(TooltipPosition.right)) {\r\n      return TooltipPosition.right;\r\n    }\r\n\r\n    if (this.HasPosition(TooltipPosition.bottom)) {\r\n      return TooltipPosition.bottom;\r\n    }\r\n\r\n    // Default Position if empty\r\n    return TooltipPosition.right;\r\n  }\r\n\r\n  /**\r\n   * Gibt zurück, ob die Position konfiguriert wurde\r\n   *\r\n   * @param position Position auf welche geprüft wird\r\n   */\r\n  private HasPosition(position: TooltipPosition): boolean {\r\n    const positions = this.position.split('|');\r\n\r\n    if (position === TooltipPosition.right && positions.indexOf('right') >= 0) {\r\n      return true;\r\n    }\r\n\r\n    if (position === TooltipPosition.top && positions.indexOf('top') >= 0) {\r\n      return true;\r\n    }\r\n\r\n    if (position === TooltipPosition.left && positions.indexOf('left') >= 0) {\r\n      return true;\r\n    }\r\n\r\n    if (position === TooltipPosition.bottom && positions.indexOf('bottom') >= 0) {\r\n      return true;\r\n    }\r\n\r\n    return false;\r\n  }\r\n\r\n  /**\r\n   * Prüft ob die Position gültig ist, resp. der Tooltip auf die Position platz hat\r\n   */\r\n  private ValidatePositions(): TooltipPosition {\r\n    // Check if Container is false\r\n    if (this.tooltipcontainer === undefined) {\r\n      return TooltipPosition.right;\r\n    }\r\n\r\n    let allowedPositions: TooltipPosition = TooltipPosition.none;\r\n    const basePosition: ClientRect = this.content.nativeElement.firstElementChild.getBoundingClientRect();\r\n    const tooltipRect: ClientRect = this.tooltipcontainer.nativeElement.getBoundingClientRect();\r\n\r\n    const leftPosOk: boolean = basePosition.left - tooltipRect.width > 0;\r\n    const rightPosOk: boolean = basePosition.right + tooltipRect.width < window.innerWidth;\r\n    const topPosOk: boolean = basePosition.top - tooltipRect.height > 0;\r\n    const bottomPosOk: boolean = basePosition.bottom + tooltipRect.height < 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 && 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"]}

package/esm2020/controls/tooltip/tooltip.ngfactory.mjs

@@ -0,0 +1,4 @@
+import * as i0 from '@angular/core';
+import { SacTooltipCommon } from './tooltip';
+export const ɵNonEmptyModule = true;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9vbHRpcC5uZ2ZhY3RvcnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zYWMtY29tbW9uL3NyYy9jb250cm9scy90b29sdGlwL3Rvb2x0aXAubmdmYWN0b3J5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3BDLE9BQU8sRUFBQyxnQkFBZ0IsRUFBQyxNQUFNLFdBQVcsQ0FBQztBQUUzQyxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsSUFBSSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0ICogYXMgaTAgZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge1NhY1Rvb2x0aXBDb21tb259IGZyb20gJy4vdG9vbHRpcCc7XG5leHBvcnQgY29uc3QgU2FjVG9vbHRpcENvbW1vbk5nRmFjdG9yeTogaTAuybVOZ01vZHVsZUZhY3Rvcnk8YW55PiA9IG5ldyBpMC7JtU5nTW9kdWxlRmFjdG9yeShTYWNUb29sdGlwQ29tbW9uKTtcbmV4cG9ydCBjb25zdCDJtU5vbkVtcHR5TW9kdWxlID0gdHJ1ZTsiXX0=

package/esm2020/controls/tooltip/tooltip.ngsummary.mjs

@@ -0,0 +1,2 @@
+export const SacTooltipCommonNgSummary = null;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9vbHRpcC5uZ3N1bW1hcnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zYWMtY29tbW9uL3NyYy9jb250cm9scy90b29sdGlwL3Rvb2x0aXAubmdzdW1tYXJ5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBQyxNQUFNLHlCQUF5QixHQUFRLElBQUksQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjb25zdCBTYWNUb29sdGlwQ29tbW9uTmdTdW1tYXJ5OiBhbnkgPSBudWxsOyJdfQ==

package/esm2020/controls/treeview/ngtreeitemaction.mjs

@@ -0,0 +1,62 @@
+import { Directive, EventEmitter, Input, Output, } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ *Basis Komponente für SacTreeItemAction
+ */
+export class SacTreeItemActionCommon {
+    /**
+     * Konstruktor
+     * @param el Element Referenz
+     */
+    constructor(el) {
+        this.el = el;
+        /**
+         * Event wenn auf das Icon geclickt wird
+         */
+        this.clicked = new EventEmitter();
+    }
+    /**
+     * lifecycle OnInit hook. Wird aufgeruren sobald das Komponent initialisiert ist.
+     */
+    ngOnInit() {
+        let rootElement = this.el.nativeElement;
+        let parentElement = rootElement.parentElement;
+        while (rootElement.firstChild) {
+            parentElement.insertBefore(rootElement.firstChild, rootElement);
+        }
+        parentElement.removeChild(rootElement);
+    }
+    /**
+     * Die Methode erstellt die CSS Klasse des Icon. Akzeptiert ein Key-word und baut ein vollständige CSS Klasse.
+     */
+    transformClass(initialClass) {
+        switch (initialClass) {
+            case 'add':
+                return 'jstree-icon icon icon-base-add jstree-add';
+            case 'delete':
+                return 'jstree-icon icon icon-base-delete jstree-delete';
+            default:
+                return initialClass;
+        }
+    }
+    /**
+     * Die Methode wird das cklickaction Emitter aktivieren.
+     */
+    iconaction() {
+        this.clicked.emit();
+    }
+}
+SacTreeItemActionCommon.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SacTreeItemActionCommon, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+SacTreeItemActionCommon.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.7", type: SacTreeItemActionCommon, inputs: { item: "item", title: "title", iconstyle: "iconstyle" }, outputs: { clicked: "clicked" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SacTreeItemActionCommon, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { item: [{
+                type: Input
+            }], title: [{
+                type: Input
+            }], iconstyle: [{
+                type: Input
+            }], clicked: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/controls/treeview/ngtreeitemaction.ngfactory.mjs

@@ -0,0 +1,4 @@
+import * as i0 from '@angular/core';
+import { SacTreeItemActionCommon } from './ngtreeitemaction';
+export const ɵNonEmptyModule = true;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmd0cmVlaXRlbWFjdGlvbi5uZ2ZhY3RvcnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zYWMtY29tbW9uL3NyYy9jb250cm9scy90cmVldmlldy9uZ3RyZWVpdGVtYWN0aW9uLm5nZmFjdG9yeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUNwQyxPQUFPLEVBQUMsdUJBQXVCLEVBQUMsTUFBTSxvQkFBb0IsQ0FBQztBQUUzRCxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsSUFBSSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0ICogYXMgaTAgZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge1NhY1RyZWVJdGVtQWN0aW9uQ29tbW9ufSBmcm9tICcuL25ndHJlZWl0ZW1hY3Rpb24nO1xuZXhwb3J0IGNvbnN0IFNhY1RyZWVJdGVtQWN0aW9uQ29tbW9uTmdGYWN0b3J5OiBpMC7JtU5nTW9kdWxlRmFjdG9yeTxhbnk+ID0gbmV3IGkwLsm1TmdNb2R1bGVGYWN0b3J5KFNhY1RyZWVJdGVtQWN0aW9uQ29tbW9uKTtcbmV4cG9ydCBjb25zdCDJtU5vbkVtcHR5TW9kdWxlID0gdHJ1ZTsiXX0=

package/esm2020/controls/treeview/ngtreeitemaction.ngsummary.mjs

@@ -0,0 +1,2 @@
+export const SacTreeItemActionCommonNgSummary = null;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmd0cmVlaXRlbWFjdGlvbi5uZ3N1bW1hcnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zYWMtY29tbW9uL3NyYy9jb250cm9scy90cmVldmlldy9uZ3RyZWVpdGVtYWN0aW9uLm5nc3VtbWFyeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsTUFBTSxnQ0FBZ0MsR0FBUSxJQUFJLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY29uc3QgU2FjVHJlZUl0ZW1BY3Rpb25Db21tb25OZ1N1bW1hcnk6IGFueSA9IG51bGw7Il19