@kms-ngx-ui/presentational 16.15.0 → 16.15.2

package/esm2022/assets/icons.json

@@ -0,0 +1 @@
+["alert-outline", "arrow-down", "arrow-left", "arrow-right-left", "arrow-right", "arrow-top", "arrows-left", "calendar", "camera", "cardealer", "checkbox_active", "checkbox_inactive", "checkbox_inner", "checkmark-circle", "checkmark-filled", "chevron-down", "chevron-left", "chevron-right", "chevron-top", "circle", "clock", "close-circle", "close", "cog", "collapse-right", "create", "credit", "diamond", "download", "drag1", "edit-circle", "efficiency", "electro-cable", "ellipse", "end", "export-all", "facebook", "file-download", "file-upload", "floating_button", "floating_button_clear", "ic-invoice", "ic-policy", "ic_GEZ", "ic_abbrechen-filled", "ic_abbrechen", "ic_back", "ic_bereifung", "ic_bezeichnung", "ic_bill", "ic_booking", "ic_cancel_form", "ic_car", "ic_check", "ic_check_form", "ic_co2", "ic_credit-card", "ic_edit", "ic_equipment", "ic_extras", "ic_eye", "ic_eye_active", "ic_filter", "ic_form_error", "ic_form_finished", "ic_gkm", "ic_heart", "ic_heart_filled", "ic_historie", "ic_home", "ic_home_new", "ic_inclusivekm", "ic_info", "ic_kraftstoff", "ic_language", "ic_last", "ic_laufleistung", "ic_left", "ic_lkm-dark", "ic_lkm-gray", "ic_lkm-red", "ic_lkm", "ic_lock", "ic_menu", "ic_minus", "ic_new-car", "ic_pickup", "ic_pin", "ic_plus-circle", "ic_plus", "ic_radiobutton_active", "ic_radiobutton_inactive", "ic_redirect", "ic_return", "ic_schaltung", "ic_settings", "ic_shops", "ic_side_front", "ic_side_front_left", "ic_side_front_left_tire", "ic_side_front_right", "ic_side_front_right_tire", "ic_side_front_zoomed", "ic_side_rear", "ic_side_rear_left", "ic_side_rear_left_tire", "ic_side_rear_right", "ic_side_rear_right_tire", "ic_slider", "ic_spezification", "ic_steuer_versicherung", "ic_tool", "ic_tooltip_drag", "ic_used-car", "ic_vertrag", "ic_wartung_verschleiss", "ic_zulassung", "image", "instagram", "kms-logo-white", "kms-logo", "linkedin", "mail", "map", "mileage", "move-list-left", "move-list-right", "palette", "pdf", "polestar", "position", "price-tag", "profile-filled", "profile", "profile2", "question-circle", "question-filled", "question", "rent", "search", "security", "special_entry", "star-outline", "star", "start", "submenu-dots", "subscription", "support", "trash", "tumblr", "twitter", "tyre", "upload", "user-circle", "users", "water", "whatsapp", "width", "xing", "youtube", "zahlung_active", "zahlungsanforderung"]

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 { SizeDirective } from './size.directive';
+import { GetMaxHeightDirective } from './sum-of-height.directive';
+import { SwipeDirective } from './swipe.directive';
+import { TimeDirective } from './time.directive';
+import { TooltipDirective } from './tooltip.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,
+            GetMaxHeightDirective,
+            SizeDirective,
+            TooltipDirective,
+            TimeDirective], imports: [CommonModule], exports: [SwipeDirective,
+            GetMaxHeightDirective,
+            SizeDirective,
+            TooltipDirective,
+            TimeDirective] }); }
+    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,
+                        GetMaxHeightDirective,
+                        SizeDirective,
+                        TooltipDirective,
+                        TimeDirective,
+                    ],
+                    imports: [CommonModule],
+                    exports: [
+                        SwipeDirective,
+                        GetMaxHeightDirective,
+                        SizeDirective,
+                        TooltipDirective,
+                        TimeDirective,
+                    ],
+                }]
+        }] });
+//# 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 KMS GmbH
+ */
+// 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,194 @@
+/**
+ * @copyright KMS GmbH
+ */
+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 KMS GmbH\n */\n\nimport {\n  Directive,\n  EventEmitter,\n  HostListener,\n  Input,\n  Output,\n} 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 =\n      this._swipeOptions && this._swipeOptions.swipeThresholdType === '%';\n\n    if (\n      !percentage &&\n      this._swipeOptions &&\n      moveEvent.swipeDistanceTotal < this._swipeOptions.swipeThreshold\n    ) {\n      return;\n    } else if (\n      percentage &&\n      this._swipeOptions &&\n      moveEvent.swipeDistancePercentage <\n        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\n          ? touch.clientX\n          : touch.pageX;\n      } else {\n        this._startPosition = this._swipeOptions.swipeLocalPosition\n          ? event.offsetX\n          : 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\n          ? touch.clientX\n          : touch.pageX;\n      } else {\n        posX = this._swipeOptions.swipeLocalPosition\n          ? event.offsetX\n          : 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(\n      swipeDistanceTotal / event.target.clientWidth\n    );\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 KMS GmbH
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,46 @@
+import { Directive, HostListener } from '@angular/core';
+import * as i0 from "@angular/core";
+export class TimeDirective {
+    constructor(el) {
+        this.el = el;
+    }
+    onInputChange(event) {
+        this.handleInput(event);
+    }
+    onBeforeInput(event) {
+        if (event.inputType === 'insertFromPaste' ||
+            event.inputType === 'insertText') {
+            const isAllTextHighlighted = event.target.selectionStart === 0 &&
+                event.target.selectionEnd === 5;
+            const textReachedMax = event.target.value.length > 4;
+            const isNotANumber = isNaN(+event.data);
+            if (isNotANumber || (textReachedMax && !isAllTextHighlighted)) {
+                event.preventDefault();
+            }
+            this.handleInput(event);
+        }
+    }
+    handleInput(event) {
+        const inputElement = this.el.nativeElement;
+        const originalValue = inputElement.value;
+        if (originalValue.length === 2 && event.inputType === 'insertText') {
+            inputElement.value += ':';
+            inputElement.dispatchEvent(new Event('input'));
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TimeDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: TimeDirective, selector: "[kmsTime]", host: { listeners: { "input": "onInputChange($event)", "beforeinput": "onBeforeInput($event)" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TimeDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[kmsTime]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { onInputChange: [{
+                type: HostListener,
+                args: ['input', ['$event']]
+            }], onBeforeInput: [{
+                type: HostListener,
+                args: ['beforeinput', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,118 @@
+import { Directive, HostListener, Input, } from '@angular/core';
+import { computePosition, arrow, autoUpdate, offset, shift, flip, } from '@floating-ui/dom';
+import * as i0 from "@angular/core";
+export class TooltipDirective {
+    onMouseOver() {
+        if (this.alwaysVisible)
+            return;
+        this.showTimeout = setTimeout(() => {
+            this.renderer.addClass(this.kmsTooltip, 'kms-tooltip--show');
+        }, this.delay);
+    }
+    onMouseOut() {
+        if (this.alwaysVisible)
+            return;
+        clearTimeout(this.showTimeout);
+        this.renderer.removeClass(this.kmsTooltip, 'kms-tooltip--show');
+    }
+    constructor(elementRef, renderer) {
+        this.elementRef = elementRef;
+        this.renderer = renderer;
+        this.placement = 'bottom';
+        this.delay = 0;
+        this.alwaysVisible = false;
+    }
+    ngAfterViewInit() {
+        this.renderer.addClass(this.kmsTooltip, 'kms-tooltip');
+        this.addArrow();
+        this.initTooltip();
+    }
+    ngOnChanges(changes) {
+        if (changes.alwaysVisible.currentValue) {
+            this.renderer.addClass(this.kmsTooltip, 'kms-tooltip--show');
+        }
+        else {
+            this.renderer.removeClass(this.kmsTooltip, 'kms-tooltip--show');
+        }
+    }
+    initTooltip() {
+        autoUpdate(this.elementRef.nativeElement, this.kmsTooltip, () => {
+            const arrowLength = this.arrow.offsetWidth;
+            // Get half the arrow box's hypotenuse length
+            const floatingOffset = Math.sqrt(2 * arrowLength ** 2) / 2;
+            computePosition(this.elementRef.nativeElement, this.kmsTooltip, {
+                placement: this.placement,
+                middleware: [
+                    shift(),
+                    offset(floatingOffset),
+                    arrow({ element: this.arrow }),
+                    flip(),
+                ],
+            }).then(({ x, y, middlewareData, placement }) => {
+                this.positionTooltip(x, y);
+                if (middlewareData.arrow) {
+                    this.positionTooltipArrow(middlewareData.arrow.x, middlewareData.arrow.y, placement, arrowLength);
+                }
+            });
+        });
+    }
+    positionTooltip(x, y) {
+        Object.assign(this.kmsTooltip.style, {
+            left: `${x}px`,
+            top: `${y}px`,
+        });
+    }
+    positionTooltipArrow(x, y, placement, arrowLength) {
+        const side = placement.split('-')[0];
+        const staticSide = {
+            top: 'bottom',
+            right: 'left',
+            bottom: 'top',
+            left: 'right',
+        }[side];
+        this.addArrowClass(staticSide);
+        Object.assign(this.arrow.style, {
+            left: x != null ? `${x}px` : '',
+            top: y != null ? `${y}px` : '',
+            // Ensure the static side gets unset when
+            // flipping to other placements' axes.
+            right: '',
+            bottom: '',
+            [staticSide]: `${-arrowLength / 2}px`,
+            transform: 'rotate(45deg)',
+        });
+    }
+    addArrow() {
+        this.arrow = this.renderer.createElement('div');
+        this.renderer.addClass(this.arrow, 'kms-tooltip__arrow');
+        this.renderer.appendChild(this.kmsTooltip, this.arrow);
+    }
+    addArrowClass(side) {
+        this.renderer.removeClass(this.arrow, 'kms-tooltip__arrow--left');
+        this.renderer.removeClass(this.arrow, 'kms-tooltip__arrow--right');
+        this.renderer.removeClass(this.arrow, 'kms-tooltip__arrow--bottom');
+        this.renderer.removeClass(this.arrow, 'kms-tooltip__arrow--top');
+        this.renderer.addClass(this.arrow, 'kms-tooltip__arrow--' + side);
+    }
+    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: { kmsTooltip: "kmsTooltip", placement: "placement", delay: "delay", alwaysVisible: "alwaysVisible" }, host: { listeners: { "mouseover": "onMouseOver()", "mouseout": "onMouseOut()" } }, usesOnChanges: true, 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: { kmsTooltip: [{
+                type: Input
+            }], placement: [{
+                type: Input
+            }], delay: [{
+                type: Input
+            }], alwaysVisible: [{
+                type: Input
+            }], onMouseOver: [{
+                type: HostListener,
+                args: ['mouseover']
+            }], onMouseOut: [{
+                type: HostListener,
+                args: ['mouseout']
+            }] } });
+//# 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 {\n  AfterViewInit,\n  Directive,\n  ElementRef,\n  HostListener,\n  Input,\n  OnChanges,\n  Renderer2,\n  SimpleChanges,\n} from '@angular/core';\nimport {\n  computePosition,\n  Placement,\n  arrow,\n  autoUpdate,\n  offset,\n  shift,\n  flip,\n} from '@floating-ui/dom';\n\n@Directive({ selector: '[kmsTooltip]' })\nexport class TooltipDirective implements AfterViewInit, OnChanges {\n  @Input() kmsTooltip: HTMLElement;\n  @Input() placement: Placement = 'bottom';\n  @Input() delay: number = 0;\n  @Input() alwaysVisible = false;\n\n  arrow: HTMLElement;\n  showTimeout: NodeJS.Timeout;\n\n  @HostListener('mouseover')\n  onMouseOver() {\n    if (this.alwaysVisible) return;\n\n    this.showTimeout = setTimeout(() => {\n      this.renderer.addClass(this.kmsTooltip, 'kms-tooltip--show');\n    }, this.delay);\n  }\n\n  @HostListener('mouseout')\n  onMouseOut() {\n    if (this.alwaysVisible) return;\n\n    clearTimeout(this.showTimeout);\n    this.renderer.removeClass(this.kmsTooltip, 'kms-tooltip--show');\n  }\n\n  constructor(private elementRef: ElementRef, private renderer: Renderer2) {}\n\n  ngAfterViewInit() {\n    this.renderer.addClass(this.kmsTooltip, 'kms-tooltip');\n    this.addArrow();\n    this.initTooltip();\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes.alwaysVisible.currentValue) {\n      this.renderer.addClass(this.kmsTooltip, 'kms-tooltip--show');\n    } else {\n      this.renderer.removeClass(this.kmsTooltip, 'kms-tooltip--show');\n    }\n  }\n\n  initTooltip() {\n    autoUpdate(this.elementRef.nativeElement, this.kmsTooltip, () => {\n      const arrowLength = this.arrow.offsetWidth;\n      // Get half the arrow box's hypotenuse length\n      const floatingOffset = Math.sqrt(2 * arrowLength ** 2) / 2;\n\n      computePosition(this.elementRef.nativeElement, this.kmsTooltip, {\n        placement: this.placement,\n        middleware: [\n          shift(),\n          offset(floatingOffset),\n          arrow({ element: this.arrow }),\n          flip(),\n        ],\n      }).then(({ x, y, middlewareData, placement }) => {\n        this.positionTooltip(x, y);\n\n        if (middlewareData.arrow) {\n          this.positionTooltipArrow(\n            middlewareData.arrow.x,\n            middlewareData.arrow.y,\n            placement,\n            arrowLength\n          );\n        }\n      });\n    });\n  }\n\n  positionTooltip(x: number, y: number) {\n    Object.assign(this.kmsTooltip.style, {\n      left: `${x}px`,\n      top: `${y}px`,\n    });\n  }\n\n  positionTooltipArrow(\n    x: number,\n    y: number,\n    placement: Placement,\n    arrowLength: number\n  ) {\n    const side = placement.split('-')[0];\n\n    const staticSide = {\n      top: 'bottom',\n      right: 'left',\n      bottom: 'top',\n      left: 'right',\n    }[side];\n\n    this.addArrowClass(staticSide);\n\n    Object.assign(this.arrow.style, {\n      left: x != null ? `${x}px` : '',\n      top: y != null ? `${y}px` : '',\n      // Ensure the static side gets unset when\n      // flipping to other placements' axes.\n      right: '',\n      bottom: '',\n      [staticSide]: `${-arrowLength / 2}px`,\n      transform: 'rotate(45deg)',\n    });\n  }\n\n  addArrow() {\n    this.arrow = this.renderer.createElement('div');\n    this.renderer.addClass(this.arrow, 'kms-tooltip__arrow');\n    this.renderer.appendChild(this.kmsTooltip, this.arrow);\n  }\n\n  addArrowClass(side: string) {\n    this.renderer.removeClass(this.arrow, 'kms-tooltip__arrow--left');\n    this.renderer.removeClass(this.arrow, 'kms-tooltip__arrow--right');\n    this.renderer.removeClass(this.arrow, 'kms-tooltip__arrow--bottom');\n    this.renderer.removeClass(this.arrow, 'kms-tooltip__arrow--top');\n\n    this.renderer.addClass(this.arrow, 'kms-tooltip__arrow--' + side);\n  }\n}\n"]}

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

@@ -0,0 +1,21 @@
+import { Component } from '@angular/core';
+import * as i0 from "@angular/core";
+export class KmsUiPresentationalComponent {
+    constructor() { }
+    ngOnInit() { }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: KmsUiPresentationalComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: KmsUiPresentationalComponent, selector: "lib-kms-ngx-ui-presentational", ngImport: i0, template: `
+    <p>
+      kms-ngx-ui-presentational works!
+    </p>
+  `, isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: KmsUiPresentationalComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lib-kms-ngx-ui-presentational', template: `
+    <p>
+      kms-ngx-ui-presentational works!
+    </p>
+  ` }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia21zLW5neC11aS1wcmVzZW50YXRpb25hbC5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9rbXMtbmd4LXVpLXByZXNlbnRhdGlvbmFsL3NyYy9saWIva21zLW5neC11aS1wcmVzZW50YXRpb25hbC5jb21wb25lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBVSxNQUFNLGVBQWUsQ0FBQzs7QUFZbEQsTUFBTSxPQUFPLDRCQUE0QjtJQUV2QyxnQkFBZ0IsQ0FBQztJQUVqQixRQUFRLEtBQVcsQ0FBQzsrR0FKVCw0QkFBNEI7bUdBQTVCLDRCQUE0QixxRUFSN0I7Ozs7R0FJVDs7NEZBSVUsNEJBQTRCO2tCQVZ4QyxTQUFTOytCQUNFLCtCQUErQixZQUMvQjs7OztHQUlUIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50LCBPbkluaXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAnbGliLWttcy1uZ3gtdWktcHJlc2VudGF0aW9uYWwnLFxuICB0ZW1wbGF0ZTogYFxuICAgIDxwPlxuICAgICAga21zLW5neC11aS1wcmVzZW50YXRpb25hbCB3b3JrcyFcbiAgICA8L3A+XG4gIGAsXG4gIHN0eWxlczogW1xuICBdXG59KVxuZXhwb3J0IGNsYXNzIEttc1VpUHJlc2VudGF0aW9uYWxDb21wb25lbnQgaW1wbGVtZW50cyBPbkluaXQge1xuXG4gIGNvbnN0cnVjdG9yKCkgeyB9XG5cbiAgbmdPbkluaXQoKTogdm9pZCB7IH1cblxufVxuIl19