@kms-ngx-ui/presentational 16.3.2 → 16.3.3

package/esm2022/kms-ngx-ui-presentational.mjs

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

package/esm2022/lib/directives/directives.module.mjs

@@ -0,0 +1,45 @@
+/**
+ * @copyright KMS GmbH
+ */
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { MouseWheelDirective } from './mousewheel.directive';
+import { GetMaxHeightDirective } from './sum-of-height.directive';
+import { SwipeDirective } from './swipe.directive';
+import { TooltipDirective } from './tooltip.directive';
+import { SizeDirective } from './size.directive';
+import * as i0 from "@angular/core";
+export class DirectivesModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DirectivesModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: DirectivesModule, declarations: [SwipeDirective,
+            MouseWheelDirective,
+            GetMaxHeightDirective,
+            TooltipDirective,
+            SizeDirective], imports: [CommonModule], exports: [SwipeDirective,
+            MouseWheelDirective,
+            GetMaxHeightDirective,
+            TooltipDirective,
+            SizeDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DirectivesModule, imports: [CommonModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DirectivesModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        SwipeDirective,
+                        MouseWheelDirective,
+                        GetMaxHeightDirective,
+                        TooltipDirective,
+                        SizeDirective,
+                    ],
+                    imports: [CommonModule],
+                    exports: [
+                        SwipeDirective,
+                        MouseWheelDirective,
+                        GetMaxHeightDirective,
+                        TooltipDirective,
+                        SizeDirective,
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/directives/mousewheel.directive.mjs

@@ -0,0 +1,56 @@
+/*!
+ * @copyright FLYACTS GmbH 2019
+ */
+import { Directive, EventEmitter, HostListener, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+export class MouseWheelDirective {
+    constructor() {
+        this.mouseWheelUp = new EventEmitter();
+        this.mouseWheelDown = new EventEmitter();
+    }
+    onMouseWheelChrome(event) {
+        this.mouseWheelFunc(event);
+    }
+    onMouseWheelFirefox(event) {
+        this.mouseWheelFunc(event);
+    }
+    onMouseWheelIE(event) {
+        this.mouseWheelFunc(event);
+    }
+    mouseWheelFunc(event) {
+        event = window.event || event; // old IE support
+        const delta = Math.max(-1, Math.min(1, (event.wheelDelta || -event.detail)));
+        if (delta > 0) {
+            this.mouseWheelUp.emit(event);
+        }
+        else if (delta < 0) {
+            this.mouseWheelDown.emit(event);
+        }
+        // for IE
+        event.returnValue = false;
+        // for Chrome and Firefox
+        if (event.preventDefault) {
+            event.preventDefault();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MouseWheelDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: MouseWheelDirective, selector: "[mouseWheel]", outputs: { mouseWheelUp: "mouseWheelUp", mouseWheelDown: "mouseWheelDown" }, host: { listeners: { "mousewheel": "onMouseWheelChrome($event)", "DOMMouseScroll": "onMouseWheelFirefox($event)", "onmousewheel": "onMouseWheelIE($event)" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MouseWheelDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[mouseWheel]' }]
+        }], propDecorators: { mouseWheelUp: [{
+                type: Output
+            }], mouseWheelDown: [{
+                type: Output
+            }], onMouseWheelChrome: [{
+                type: HostListener,
+                args: ['mousewheel', ['$event']]
+            }], onMouseWheelFirefox: [{
+                type: HostListener,
+                args: ['DOMMouseScroll', ['$event']]
+            }], onMouseWheelIE: [{
+                type: HostListener,
+                args: ['onmousewheel', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/directives/size.directive.mjs

@@ -0,0 +1,21 @@
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class SizeDirective {
+    constructor(elementRef) {
+        this.elementRef = elementRef;
+        this.size = '';
+    }
+    ngOnInit() {
+        this.elementRef.nativeElement.style.width = this.size + 'px';
+        this.elementRef.nativeElement.style.height = this.size + 'px';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SizeDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: SizeDirective, selector: "[size]", inputs: { size: "size" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SizeDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[size]' }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { size: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2l6ZS5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9rbXMtbmd4LXVpLXByZXNlbnRhdGlvbmFsL3NyYy9saWIvZGlyZWN0aXZlcy9zaXplLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFjLEtBQUssRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFHN0QsTUFBTSxPQUFPLGFBQWE7SUFHdEIsWUFBb0IsVUFBc0I7UUFBdEIsZUFBVSxHQUFWLFVBQVUsQ0FBWTtRQUZqQyxTQUFJLEdBQVcsRUFBRSxDQUFDO0lBRW1CLENBQUM7SUFFL0MsUUFBUTtRQUNKLElBQUksQ0FBQyxVQUFVLENBQUMsYUFBYSxDQUFDLEtBQUssQ0FBQyxLQUFLLEdBQUcsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUM7UUFDN0QsSUFBSSxDQUFDLFVBQVUsQ0FBQyxhQUFhLENBQUMsS0FBSyxDQUFDLE1BQU0sR0FBRyxJQUFJLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQztJQUNsRSxDQUFDOytHQVJRLGFBQWE7bUdBQWIsYUFBYTs7NEZBQWIsYUFBYTtrQkFEekIsU0FBUzttQkFBQyxFQUFFLFFBQVEsRUFBRSxRQUFRLEVBQUU7aUdBRXBCLElBQUk7c0JBQVosS0FBSyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgRWxlbWVudFJlZiwgSW5wdXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQERpcmVjdGl2ZSh7IHNlbGVjdG9yOiAnW3NpemVdJyB9KVxuZXhwb3J0IGNsYXNzIFNpemVEaXJlY3RpdmUge1xuICAgIEBJbnB1dCgpIHNpemU6IHN0cmluZyA9ICcnO1xuXG4gICAgY29uc3RydWN0b3IocHJpdmF0ZSBlbGVtZW50UmVmOiBFbGVtZW50UmVmKSB7IH1cblxuICAgIG5nT25Jbml0KCkge1xuICAgICAgICB0aGlzLmVsZW1lbnRSZWYubmF0aXZlRWxlbWVudC5zdHlsZS53aWR0aCA9IHRoaXMuc2l6ZSArICdweCc7XG4gICAgICAgIHRoaXMuZWxlbWVudFJlZi5uYXRpdmVFbGVtZW50LnN0eWxlLmhlaWdodCA9IHRoaXMuc2l6ZSArICdweCc7XG4gICAgfVxufVxuIl19

package/esm2022/lib/directives/sum-of-height.directive.mjs

@@ -0,0 +1,74 @@
+/*!
+ * @copyright FLYACTS GmbH 2019
+ */
+// ng
+import { Directive, EventEmitter, Input, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Directive to calc the height of all inner elements
+ */
+export class GetMaxHeightDirective {
+    constructor(el) {
+        this.el = el;
+        /**
+         * CSS class name of the child items (markup elements) that should be checked for their height.
+         * This is mandatory.
+         */
+        this.cssClassName = '';
+        /**
+         * Event that will pass the height of the tallest child inside the container.
+         * Useful to calculate the target height of containers with different content (like accordion) for animations.
+         */
+        this.maxHeightChanged = new EventEmitter();
+        /**
+         * Event that will pass the complete sum of all height values from each child.
+         * Useful to calculate the full target height of a container (like dropdown) for animations.
+         */
+        this.sumOfHeight = new EventEmitter();
+    }
+    ngAfterContentChecked() {
+        this.checkHeightOfChildren(this.el.nativeElement, this.cssClassName);
+    }
+    checkHeightOfChildren(parent, cssClassName) {
+        if (!parent) {
+            return;
+        }
+        // find all the child elements with the selected class name
+        const children = parent.getElementsByClassName(cssClassName);
+        // failsafe
+        if (!children) {
+            return;
+        }
+        // get all the child elements heights
+        const itemHeights = Array.from(children).map((x) => x.getBoundingClientRect().height);
+        // failsafe
+        if (itemHeights.length === 0) {
+            return;
+        }
+        // find out the tallest element
+        const maxHeight = itemHeights.reduce((prev, curr) => {
+            return curr > prev ? curr : prev;
+        }, 0);
+        // get sum of heights
+        const sumOfHeight = itemHeights.reduce((pv, cv) => pv + cv, 0);
+        // inform
+        this.maxHeightChanged.emit(maxHeight);
+        this.sumOfHeight.emit(sumOfHeight);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: GetMaxHeightDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: GetMaxHeightDirective, selector: "[getMaxHeight]", inputs: { cssClassName: ["getMaxHeight", "cssClassName"] }, outputs: { maxHeightChanged: "maxHeightChanged", sumOfHeight: "sumOfHeight" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: GetMaxHeightDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[getMaxHeight]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { cssClassName: [{
+                type: Input,
+                args: ['getMaxHeight']
+            }], maxHeightChanged: [{
+                type: Output
+            }], sumOfHeight: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/directives/swipe.directive.mjs

@@ -0,0 +1,183 @@
+/*!
+ * @copyright FLYACTS GmbH 2019
+ */
+import { Directive, EventEmitter, HostListener, Input, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+export class SwipeDirective {
+    constructor() {
+        /**
+         * Output Event that is emitted during swipe process (mouse move or touch move event).
+         * Can be used for calculation purposes.
+         */
+        this.moveEvent = new EventEmitter();
+        /**
+         * Output Event that is emitted when swipe process end (mouse up or touch end event).
+         * Can be used for calculation purposes.
+         */
+        this.releaseEvent = new EventEmitter();
+        this._startPosition = -1;
+        this._lastPosX = 0;
+        this._thresholdWasReached = false;
+        this._timeStart = 0;
+    }
+    /**
+     * Needed config that defines swipe behaviour.
+     * @param options SwipeOptions
+     */
+    set config(options) {
+        if (options) {
+            this._swipeOptions = options;
+        }
+    }
+    onMouseDown(event) {
+        this.calculateStartPosition(event);
+    }
+    onMove(event) {
+        this.move(event);
+    }
+    onRelease(event) {
+        this.release(event);
+        this.reset();
+    }
+    // ** PRIVATE ** //
+    /**
+     * Function checks if the current moving delta is inside the defined threshold.
+     * Sets the flag to true if the threshold was reached once.
+     */
+    checkThreshold(moveEvent) {
+        const percentage = this._swipeOptions && this._swipeOptions.swipeThresholdType === '%';
+        if (!percentage && this._swipeOptions && moveEvent.swipeDistanceTotal < this._swipeOptions.swipeThreshold) {
+            return;
+        }
+        else if (percentage &&
+            this._swipeOptions &&
+            moveEvent.swipeDistancePercentage < this._swipeOptions.swipeThreshold / 100) {
+            return;
+        }
+        else {
+            this._thresholdWasReached = true;
+        }
+    }
+    calculateStartPosition(event) {
+        // detect if touch or click
+        this._isMobile = event.type === 'touchstart';
+        // save start position
+        if (this._swipeOptions && this._swipeOptions.swipeLocalPosition) {
+            if (this._isMobile) {
+                const touch = event.touches[0];
+                this._startPosition = this._swipeOptions.swipeLocalPosition ? touch.clientX : touch.pageX;
+            }
+            else {
+                this._startPosition = this._swipeOptions.swipeLocalPosition ? event.offsetX : event.pageX;
+            }
+        }
+        this._lastPosX = this._startPosition;
+        this._timeStart = event.timeStamp;
+        this._thresholdWasReached = false;
+    }
+    move(event) {
+        // failsafe
+        if (typeof event === 'undefined') {
+            return;
+        }
+        let posX = 0;
+        if (this._swipeOptions) {
+            if (this._isMobile && event.type === 'touchmove') {
+                const touch = event.touches[0];
+                posX = this._swipeOptions.swipeLocalPosition ? touch.clientX : touch.pageX;
+            }
+            else {
+                posX = this._swipeOptions.swipeLocalPosition ? event.offsetX : event.pageX;
+            }
+        }
+        const offsetPerFrame = posX - this._lastPosX;
+        const swipeDistanceTotal = Math.abs(posX - this._startPosition);
+        const swipeDistancePercentage = Math.abs(swipeDistanceTotal / event.target.clientWidth);
+        const timeDuration = Math.abs(event.timeStamp - this._timeStart);
+        let direction;
+        let speed = 1 - swipeDistanceTotal / timeDuration;
+        speed = Math.max(0.1, speed);
+        if (posX - this._startPosition > 0) {
+            direction = 1; // a.k.a LTR
+        }
+        else {
+            direction = -1; // a.k.a RTL
+        }
+        this._moveEventData = {
+            position: posX,
+            offsetPerFrame: offsetPerFrame,
+            swipeDistanceTotal: swipeDistanceTotal,
+            swipeDistancePercentage: swipeDistancePercentage,
+            direction: direction,
+            speed: speed,
+            thresholdWasReached: this._thresholdWasReached,
+        };
+        this.checkThreshold(this._moveEventData);
+        // update move delta
+        this._lastPosX = posX;
+        // inform
+        this.moveEvent.emit(this._moveEventData);
+    }
+    release(event) {
+        // case: just a click/touch
+        if (!this._moveEventData) {
+            return;
+        }
+        const releaseEventData = {
+            thresholdWasReached: this._thresholdWasReached,
+            direction: this._moveEventData.direction,
+            speed: this._moveEventData.speed,
+            easingType: this.getEasingCurve(this._moveEventData.speed),
+            target: event.currentTarget,
+        };
+        // inform
+        this.releaseEvent.emit(releaseEventData);
+    }
+    getEasingCurve(speed) {
+        return speed > 0.5 ? 'ease-in' : 'ease-out';
+    }
+    reset() {
+        this._startPosition = -1;
+        this._thresholdWasReached = false;
+        if (this._moveEventData) {
+            this._moveEventData = undefined;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SwipeDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: SwipeDirective, selector: "[swipeDirective]", inputs: { config: ["swipeDirective", "config"] }, outputs: { moveEvent: "moveEvent", releaseEvent: "releaseEvent" }, host: { listeners: { "mousedown": "onMouseDown($event)", "touchstart": "onMouseDown($event)", "mousemove": "onMove($event)", "touchmove": "onMove($event)", "mouseup": "onRelease($event)", "mouseleave": "onRelease($event)", "touchend": "onRelease($event)" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SwipeDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[swipeDirective]',
+                }]
+        }], propDecorators: { moveEvent: [{
+                type: Output
+            }], releaseEvent: [{
+                type: Output
+            }], config: [{
+                type: Input,
+                args: ['swipeDirective']
+            }], onMouseDown: [{
+                type: HostListener,
+                args: ['mousedown', ['$event']]
+            }, {
+                type: HostListener,
+                args: ['touchstart', ['$event']]
+            }], onMove: [{
+                type: HostListener,
+                args: ['mousemove', ['$event']]
+            }, {
+                type: HostListener,
+                args: ['touchmove', ['$event']]
+            }], onRelease: [{
+                type: HostListener,
+                args: ['mouseup', ['$event']]
+            }, {
+                type: HostListener,
+                args: ['mouseleave', ['$event']]
+            }, {
+                type: HostListener,
+                args: ['touchend', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"swipe.directive.js","sourceRoot":"","sources":["../../../../../../projects/kms-ngx-ui-presentational/src/lib/directives/swipe.directive.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @copyright FLYACTS GmbH 2019\n */\n\nimport { Directive, EventEmitter, HostListener, Input, Output } from '@angular/core';\n\nimport { SwipeMoveEvent, SwipeOptions, SwipeReleaseEvent } from './swipe.model';\n\n@Directive({\n    selector: '[swipeDirective]',\n})\nexport class SwipeDirective {\n    /**\n     * Output Event that is emitted during swipe process (mouse move or touch move event).\n     * Can be used for calculation purposes.\n     */\n    @Output() public moveEvent = new EventEmitter<SwipeMoveEvent>();\n\n    /**\n     * Output Event that is emitted when swipe process end (mouse up or touch end event).\n     * Can be used for calculation purposes.\n     */\n    @Output() public releaseEvent = new EventEmitter<SwipeReleaseEvent>();\n\n    private _swipeOptions: SwipeOptions | undefined;\n\n    private _moveEventData: SwipeMoveEvent | undefined;\n    private _startPosition = -1;\n\n    private _lastPosX = 0;\n\n    private _thresholdWasReached = false;\n\n    private _isMobile: boolean | undefined;\n\n    private _timeStart = 0;\n\n    /**\n     * Needed config that defines swipe behaviour.\n     * @param options SwipeOptions\n     */\n    @Input('swipeDirective')\n    set config(options: SwipeOptions) {\n        if (options) {\n            this._swipeOptions = options;\n        }\n    }\n\n    @HostListener('mousedown', ['$event'])\n    @HostListener('touchstart', ['$event'])\n    onMouseDown(event: any) {\n        this.calculateStartPosition(event);\n    }\n\n    @HostListener('mousemove', ['$event'])\n    @HostListener('touchmove', ['$event'])\n    onMove(event: any) {\n        this.move(event);\n    }\n\n    @HostListener('mouseup', ['$event'])\n    @HostListener('mouseleave', ['$event'])\n    @HostListener('touchend', ['$event'])\n    onRelease(event: any) {\n        this.release(event);\n        this.reset();\n    }\n\n    // ** PRIVATE ** //\n\n    /**\n     * Function checks if the current moving delta is inside the defined threshold.\n     * Sets the flag to true if the threshold was reached once.\n     */\n    private checkThreshold(moveEvent: SwipeMoveEvent) {\n        const percentage = this._swipeOptions && this._swipeOptions.swipeThresholdType === '%';\n\n        if (!percentage && this._swipeOptions && moveEvent.swipeDistanceTotal < this._swipeOptions.swipeThreshold) {\n            return;\n        } else if (\n            percentage &&\n            this._swipeOptions &&\n            moveEvent.swipeDistancePercentage < this._swipeOptions.swipeThreshold / 100\n        ) {\n            return;\n        } else {\n            this._thresholdWasReached = true;\n        }\n    }\n\n    private calculateStartPosition(event?: any) {\n        // detect if touch or click\n        this._isMobile = event.type === 'touchstart';\n\n        // save start position\n\n        if (this._swipeOptions && this._swipeOptions.swipeLocalPosition) {\n            if (this._isMobile) {\n                const touch: Touch = event.touches[0];\n                this._startPosition = this._swipeOptions.swipeLocalPosition ? touch.clientX : touch.pageX;\n            } else {\n                this._startPosition = this._swipeOptions.swipeLocalPosition ? event.offsetX : event.pageX;\n            }\n        }\n\n        this._lastPosX = this._startPosition;\n        this._timeStart = event.timeStamp;\n        this._thresholdWasReached = false;\n    }\n\n    private move(event: any) {\n        // failsafe\n        if (typeof event === 'undefined') {\n            return;\n        }\n\n        let posX = 0;\n\n        if (this._swipeOptions) {\n            if (this._isMobile && event.type === 'touchmove') {\n                const touch: Touch = event.touches[0];\n                posX = this._swipeOptions.swipeLocalPosition ? touch.clientX : touch.pageX;\n            } else {\n                posX = this._swipeOptions.swipeLocalPosition ? event.offsetX : event.pageX;\n            }\n        }\n\n        const offsetPerFrame: number = posX - this._lastPosX;\n        const swipeDistanceTotal: number = Math.abs(posX - this._startPosition);\n        const swipeDistancePercentage: number = Math.abs(swipeDistanceTotal / event.target.clientWidth);\n        const timeDuration: number = Math.abs(event.timeStamp - this._timeStart);\n\n        let direction: number;\n        let speed: number = 1 - swipeDistanceTotal / timeDuration;\n        speed = Math.max(0.1, speed);\n\n        if (posX - this._startPosition > 0) {\n            direction = 1; // a.k.a LTR\n        } else {\n            direction = -1; // a.k.a RTL\n        }\n\n        this._moveEventData = {\n            position: posX,\n            offsetPerFrame: offsetPerFrame,\n            swipeDistanceTotal: swipeDistanceTotal,\n            swipeDistancePercentage: swipeDistancePercentage,\n            direction: direction,\n            speed: speed,\n            thresholdWasReached: this._thresholdWasReached,\n        };\n\n        this.checkThreshold(this._moveEventData);\n\n        // update move delta\n        this._lastPosX = posX;\n\n        // inform\n        this.moveEvent.emit(this._moveEventData);\n    }\n\n    private release(event: any) {\n        // case: just a click/touch\n\n        if (!this._moveEventData) {\n            return;\n        }\n\n        const releaseEventData: SwipeReleaseEvent = {\n            thresholdWasReached: this._thresholdWasReached,\n            direction: this._moveEventData.direction,\n            speed: this._moveEventData.speed,\n            easingType: this.getEasingCurve(this._moveEventData.speed),\n            target: event.currentTarget,\n        };\n\n        // inform\n        this.releaseEvent.emit(releaseEventData);\n    }\n\n    private getEasingCurve(speed: number): string {\n        return speed > 0.5 ? 'ease-in' : 'ease-out';\n    }\n\n    private reset() {\n        this._startPosition = -1;\n        this._thresholdWasReached = false;\n\n        if (this._moveEventData) {\n            this._moveEventData = undefined;\n        }\n    }\n}\n"]}

package/esm2022/lib/directives/swipe.model.mjs

@@ -0,0 +1,5 @@
+/*!
+ * @copyright FLYACTS GmbH 2019
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/directives/tooltip.directive.mjs

@@ -0,0 +1,144 @@
+import { Directive, Input, HostListener } from '@angular/core';
+import * as i0 from "@angular/core";
+export class TooltipDirective {
+    constructor(el, renderer) {
+        this.el = el;
+        this.renderer = renderer;
+        this.tooltipTitle = "";
+        this.tooltipText = "";
+        this.tooltipLinkText = "";
+        this.tooltipLinkUrl = "";
+        this.tooltipPlacement = "bottom";
+        this.tooltipDelay = 1000;
+        this.tooltipPlaceIntoHost = false;
+        this.tooltipOnlyonclick = false;
+        this.offset = 0;
+    }
+    onMouseEnter() {
+        if (!this.tooltipOnlyonclick) {
+            this.show();
+        }
+    }
+    onClick() {
+        if (this.tooltipOnlyonclick) {
+            this.show();
+        }
+    }
+    onMouseLeave() {
+        if (this.tooltipElem) {
+            this.hide();
+        }
+    }
+    show() {
+        if (!this.tooltipElem) {
+            this.create();
+            this.setPosition();
+        }
+        this.renderer.addClass(this.tooltipElem, 'tooltip-show');
+    }
+    hide() {
+        this.renderer.removeClass(this.tooltipElem, 'tooltip-show');
+        window.setTimeout(() => {
+        }, this.tooltipDelay);
+    }
+    create() {
+        this.tooltipElem = this.renderer.createElement('kms-tooltip-element');
+        this.tooltipTitleElem = this.renderer.createElement('b');
+        this.renderer.appendChild(this.tooltipTitleElem, this.renderer.createText(this.tooltipTitle));
+        this.renderer.appendChild(this.tooltipElem, this.tooltipTitleElem);
+        this.tooltipTextElem = this.renderer.createElement('div');
+        this.renderer.appendChild(this.tooltipTextElem, this.renderer.createText(this.tooltipText));
+        this.renderer.appendChild(this.tooltipElem, this.tooltipTextElem);
+        this.tooltipLinkElem = this.renderer.createElement('a');
+        this.renderer.setAttribute(this.tooltipLinkElem, 'href', this.tooltipLinkUrl);
+        this.renderer.appendChild(this.tooltipLinkElem, this.renderer.createText(this.tooltipLinkText));
+        this.renderer.appendChild(this.tooltipElem, this.tooltipLinkElem);
+        if (this.tooltipPlaceIntoHost) {
+            this.renderer.appendChild(this.el.nativeElement, this.tooltipElem);
+        }
+        else {
+            this.renderer.appendChild(document.body, this.tooltipElem);
+        }
+        this.renderer.addClass(this.tooltipElem, 'tooltip');
+        this.renderer.addClass(this.tooltipElem, `tooltip-${this.tooltipPlacement}`);
+        this.renderer.setStyle(this.tooltipElem, '-webkit-transition', `opacity ${this.tooltipDelay}ms`);
+        this.renderer.setStyle(this.tooltipElem, '-moz-transition', `opacity ${this.tooltipDelay}ms`);
+        this.renderer.setStyle(this.tooltipElem, '-o-transition', `opacity ${this.tooltipDelay}ms`);
+        this.renderer.setStyle(this.tooltipElem, 'transition', `opacity ${this.tooltipDelay}ms`);
+    }
+    setPosition() {
+        if (this.tooltipElem) {
+            const hostPos = this.el.nativeElement.getBoundingClientRect();
+            const tooltipPos = this.tooltipElem.getBoundingClientRect();
+            let top, left;
+            if (this.tooltipPlaceIntoHost) {
+                left = 0;
+                top = hostPos.height;
+            }
+            else {
+                const scrollPos = window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0;
+                if (this.tooltipPlacement === 'top') {
+                    top = hostPos.top - tooltipPos.height - this.offset;
+                    left = hostPos.left + (hostPos.width - tooltipPos.width) / 2;
+                }
+                if (!this.tooltipPlacement || this.tooltipPlacement === 'bottom') {
+                    top = hostPos.bottom + this.offset;
+                    left = hostPos.left + (hostPos.width - tooltipPos.width) / 2;
+                }
+                if (this.tooltipPlacement === 'left') {
+                    top = hostPos.top + (hostPos.height - tooltipPos.height) / 2;
+                    left = hostPos.left - tooltipPos.width - this.offset;
+                }
+                if (this.tooltipPlacement === 'right') {
+                    top = hostPos.top + (hostPos.height - tooltipPos.height) / 2;
+                    left = hostPos.right + this.offset;
+                }
+                top += scrollPos;
+            }
+            this.renderer.setStyle(this.tooltipElem, 'top', `${top}px`);
+            this.renderer.setStyle(this.tooltipElem, 'left', `${left}px`);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TooltipDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: TooltipDirective, selector: "[kmsTooltip]", inputs: { tooltipTitle: "tooltipTitle", tooltipText: "tooltipText", tooltipLinkText: "tooltipLinkText", tooltipLinkUrl: "tooltipLinkUrl", tooltipPlacement: "tooltipPlacement", tooltipDelay: "tooltipDelay", tooltipPlaceIntoHost: "tooltipPlaceIntoHost", tooltipOnlyonclick: "tooltipOnlyonclick" }, host: { listeners: { "mouseenter": "onMouseEnter()", "click": "onClick()", "mouseleave": "onMouseLeave()" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TooltipDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[kmsTooltip]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }]; }, propDecorators: { tooltipTitle: [{
+                type: Input,
+                args: ['tooltipTitle']
+            }], tooltipText: [{
+                type: Input,
+                args: ['tooltipText']
+            }], tooltipLinkText: [{
+                type: Input,
+                args: ['tooltipLinkText']
+            }], tooltipLinkUrl: [{
+                type: Input,
+                args: ['tooltipLinkUrl']
+            }], tooltipPlacement: [{
+                type: Input,
+                args: ['tooltipPlacement']
+            }], tooltipDelay: [{
+                type: Input,
+                args: ['tooltipDelay']
+            }], tooltipPlaceIntoHost: [{
+                type: Input,
+                args: ['tooltipPlaceIntoHost']
+            }], tooltipOnlyonclick: [{
+                type: Input,
+                args: ['tooltipOnlyonclick']
+            }], onMouseEnter: [{
+                type: HostListener,
+                args: ['mouseenter']
+            }], onClick: [{
+                type: HostListener,
+                args: ['click']
+            }], onMouseLeave: [{
+                type: HostListener,
+                args: ['mouseleave']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tooltip.directive.js","sourceRoot":"","sources":["../../../../../../projects/kms-ngx-ui-presentational/src/lib/directives/tooltip.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, Input, ElementRef, HostListener, Renderer2 } from '@angular/core';\n\n@Directive({\n    selector: '[kmsTooltip]'\n})\nexport class TooltipDirective {\n    @Input('tooltipTitle') tooltipTitle = \"\";\n    @Input('tooltipText') tooltipText = \"\";\n    @Input('tooltipLinkText') tooltipLinkText = \"\";\n    @Input('tooltipLinkUrl') tooltipLinkUrl = \"\";\n    @Input('tooltipPlacement') tooltipPlacement = \"bottom\";\n    @Input('tooltipDelay') tooltipDelay = 1000;\n    @Input('tooltipPlaceIntoHost') tooltipPlaceIntoHost = false;\n    @Input('tooltipOnlyonclick') tooltipOnlyonclick = false;\n\n    tooltipElem?: HTMLElement | undefined;\n    tooltipLinkElem?: HTMLElement | undefined;\n    tooltipTitleElem?: HTMLElement | undefined;\n    tooltipTextElem?: HTMLElement | undefined;\n    offset = 0;\n\n    constructor(private el: ElementRef, private renderer: Renderer2) {\n\n    }\n\n    @HostListener('mouseenter') onMouseEnter() {\n        if (!this.tooltipOnlyonclick) { this.show(); }\n    }\n\n    @HostListener('click') onClick() {\n        if (this.tooltipOnlyonclick) { this.show(); }\n    }\n\n    @HostListener('mouseleave') onMouseLeave() {\n        if (this.tooltipElem) { this.hide(); }\n    }\n\n    show() {\n        if (!this.tooltipElem){\n            this.create();\n            this.setPosition();\n        }\n        this.renderer.addClass(this.tooltipElem, 'tooltip-show');\n    }\n\n    hide() {\n        this.renderer.removeClass(this.tooltipElem, 'tooltip-show');\n        window.setTimeout(() => {\n        }, this.tooltipDelay);\n    }\n\n    create() {\n        this.tooltipElem = this.renderer.createElement('kms-tooltip-element');\n\n        this.tooltipTitleElem = this.renderer.createElement('b');\n        this.renderer.appendChild(this.tooltipTitleElem, this.renderer.createText(this.tooltipTitle));\n        this.renderer.appendChild(this.tooltipElem, this.tooltipTitleElem);\n        \n        this.tooltipTextElem = this.renderer.createElement('div');\n        this.renderer.appendChild(this.tooltipTextElem, this.renderer.createText(this.tooltipText));\n        this.renderer.appendChild(this.tooltipElem, this.tooltipTextElem);\n        \n        this.tooltipLinkElem = this.renderer.createElement('a');\n        this.renderer.setAttribute(this.tooltipLinkElem, 'href', this.tooltipLinkUrl);\n        this.renderer.appendChild(this.tooltipLinkElem, this.renderer.createText(this.tooltipLinkText));\n        this.renderer.appendChild(this.tooltipElem, this.tooltipLinkElem);\n\n        if(this.tooltipPlaceIntoHost){\n            this.renderer.appendChild(this.el.nativeElement, this.tooltipElem);\n        }else{\n            this.renderer.appendChild(document.body, this.tooltipElem);\n        }\n\n        this.renderer.addClass(this.tooltipElem, 'tooltip');\n        this.renderer.addClass(this.tooltipElem, `tooltip-${this.tooltipPlacement}`);\n        this.renderer.setStyle(this.tooltipElem, '-webkit-transition', `opacity ${this.tooltipDelay}ms`);\n        this.renderer.setStyle(this.tooltipElem, '-moz-transition', `opacity ${this.tooltipDelay}ms`);\n        this.renderer.setStyle(this.tooltipElem, '-o-transition', `opacity ${this.tooltipDelay}ms`);\n        this.renderer.setStyle(this.tooltipElem, 'transition', `opacity ${this.tooltipDelay}ms`);\n    }\n\n    setPosition() {\n        if(this.tooltipElem){\n            const hostPos = this.el.nativeElement.getBoundingClientRect();\n            const tooltipPos = this.tooltipElem.getBoundingClientRect();\n\n            let top, left;\n\n            if(this.tooltipPlaceIntoHost){\n                left = 0;\n                top = hostPos.height; \n            } else {\n                const scrollPos = window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0;\n\n                if (this.tooltipPlacement === 'top') {\n                    top = hostPos.top - tooltipPos.height - this.offset;\n                    left = hostPos.left + (hostPos.width - tooltipPos.width) / 2;\n                }\n\n                if (!this.tooltipPlacement || this.tooltipPlacement === 'bottom') {\n                    top = hostPos.bottom + this.offset;\n                    left = hostPos.left + (hostPos.width - tooltipPos.width) / 2;\n                }\n\n                if (this.tooltipPlacement === 'left') {\n                    top = hostPos.top + (hostPos.height - tooltipPos.height) / 2;\n                    left = hostPos.left - tooltipPos.width - this.offset;\n                }\n\n                if (this.tooltipPlacement === 'right') {\n                    top = hostPos.top + (hostPos.height - tooltipPos.height) / 2;\n                    left = hostPos.right + this.offset;\n                }\n                top += scrollPos;\n            }\n\n            this.renderer.setStyle(this.tooltipElem, 'top', `${top}px`);\n            this.renderer.setStyle(this.tooltipElem, 'left', `${left}px`);\n        }\n    }\n}"]}