@leanix/components 0.2.229 → 0.2.232

package/esm2020/lib/forms-ui/helpers/key-codes.constants.mjs

@@ -0,0 +1,11 @@
+// We can only use 'keyCode' because 'key' depends on the browser and does not work for IE11
+export const BACKSPACE = 8;
+export const TAB = 9;
+export const ARROW_DOWN = 40;
+export const ARROW_UP = 38;
+export const ARROW_LEFT = 37;
+export const ARROW_RIGHT = 39;
+export const ENTER = 13;
+export const ESCAPE = 27;
+export const SPACE = 32;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia2V5LWNvZGVzLmNvbnN0YW50cy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy9zcmMvbGliL2Zvcm1zLXVpL2hlbHBlcnMva2V5LWNvZGVzLmNvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSw0RkFBNEY7QUFDNUYsTUFBTSxDQUFDLE1BQU0sU0FBUyxHQUFHLENBQUMsQ0FBQztBQUMzQixNQUFNLENBQUMsTUFBTSxHQUFHLEdBQUcsQ0FBQyxDQUFDO0FBQ3JCLE1BQU0sQ0FBQyxNQUFNLFVBQVUsR0FBRyxFQUFFLENBQUM7QUFDN0IsTUFBTSxDQUFDLE1BQU0sUUFBUSxHQUFHLEVBQUUsQ0FBQztBQUMzQixNQUFNLENBQUMsTUFBTSxVQUFVLEdBQUcsRUFBRSxDQUFDO0FBQzdCLE1BQU0sQ0FBQyxNQUFNLFdBQVcsR0FBRyxFQUFFLENBQUM7QUFDOUIsTUFBTSxDQUFDLE1BQU0sS0FBSyxHQUFHLEVBQUUsQ0FBQztBQUN4QixNQUFNLENBQUMsTUFBTSxNQUFNLEdBQUcsRUFBRSxDQUFDO0FBQ3pCLE1BQU0sQ0FBQyxNQUFNLEtBQUssR0FBRyxFQUFFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBXZSBjYW4gb25seSB1c2UgJ2tleUNvZGUnIGJlY2F1c2UgJ2tleScgZGVwZW5kcyBvbiB0aGUgYnJvd3NlciBhbmQgZG9lcyBub3Qgd29yayBmb3IgSUUxMVxuZXhwb3J0IGNvbnN0IEJBQ0tTUEFDRSA9IDg7XG5leHBvcnQgY29uc3QgVEFCID0gOTtcbmV4cG9ydCBjb25zdCBBUlJPV19ET1dOID0gNDA7XG5leHBvcnQgY29uc3QgQVJST1dfVVAgPSAzODtcbmV4cG9ydCBjb25zdCBBUlJPV19MRUZUID0gMzc7XG5leHBvcnQgY29uc3QgQVJST1dfUklHSFQgPSAzOTtcbmV4cG9ydCBjb25zdCBFTlRFUiA9IDEzO1xuZXhwb3J0IGNvbnN0IEVTQ0FQRSA9IDI3O1xuZXhwb3J0IGNvbnN0IFNQQUNFID0gMzI7XG4iXX0=

package/esm2020/lib/forms-ui/helpers/keyboard-navigation.helpers.mjs

@@ -0,0 +1,38 @@
+import { includes } from 'lodash/fp';
+import { fromEvent } from 'rxjs';
+import { filter, map, takeUntil } from 'rxjs/operators';
+import { KeyboardSelectAction } from '../components/keyboard-select.directive';
+import { ARROW_DOWN, ARROW_UP, ENTER, ESCAPE, SPACE, TAB } from './key-codes.constants';
+export function getKeyboardNavigationEvents(sourceElement, destroyed$) {
+    const inputKeyboardEvents$ = fromEvent(sourceElement, 'keydown').pipe(takeUntil(destroyed$));
+    const verticalNavigation$ = inputKeyboardEvents$.pipe(filter((event) => includes(event.keyCode, [ARROW_UP, ARROW_DOWN])));
+    const close$ = inputKeyboardEvents$.pipe(filter((event) => event.keyCode === ESCAPE || event.keyCode === TAB));
+    const dropdownKeyboardEvent$ = inputKeyboardEvents$.pipe(filter((event) => includes(event.keyCode, [ENTER, ARROW_UP, ARROW_DOWN])), map((event) => {
+        switch (event.keyCode) {
+            case ENTER:
+                return KeyboardSelectAction.EXECUTE;
+            case ARROW_UP:
+                return KeyboardSelectAction.PREV;
+            case ARROW_DOWN:
+                return KeyboardSelectAction.NEXT;
+            default:
+                return null;
+        }
+    }));
+    const enter$ = inputKeyboardEvents$.pipe(filter((event) => event.keyCode === ENTER));
+    const space$ = inputKeyboardEvents$.pipe(filter((event) => event.keyCode === SPACE));
+    const openOnArrowDown$ = inputKeyboardEvents$.pipe(filter((event) => event.keyCode === ARROW_DOWN));
+    return {
+        verticalNavigation$,
+        close$,
+        dropdownKeyboardEvent$,
+        enter$,
+        space$,
+        openOnArrowDown$
+    };
+}
+export function stopKeyboardEventPropagation(evt) {
+    evt.preventDefault();
+    evt.stopImmediatePropagation();
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia2V5Ym9hcmQtbmF2aWdhdGlvbi5oZWxwZXJzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jb21wb25lbnRzL3NyYy9saWIvZm9ybXMtdWkvaGVscGVycy9rZXlib2FyZC1uYXZpZ2F0aW9uLmhlbHBlcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLFdBQVcsQ0FBQztBQUNyQyxPQUFPLEVBQUUsU0FBUyxFQUFjLE1BQU0sTUFBTSxDQUFDO0FBQzdDLE9BQU8sRUFBRSxNQUFNLEVBQUUsR0FBRyxFQUFFLFNBQVMsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQ3hELE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLHlDQUF5QyxDQUFDO0FBQy9FLE9BQU8sRUFBRSxVQUFVLEVBQUUsUUFBUSxFQUFFLEtBQUssRUFBRSxNQUFNLEVBQUUsS0FBSyxFQUFFLEdBQUcsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBV3hGLE1BQU0sVUFBVSwyQkFBMkIsQ0FBQyxhQUEwQixFQUFFLFVBQTRCO0lBQ2xHLE1BQU0sb0JBQW9CLEdBQUcsU0FBUyxDQUFnQixhQUFhLEVBQUUsU0FBUyxDQUFDLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxVQUFVLENBQUMsQ0FBQyxDQUFDO0lBRTVHLE1BQU0sbUJBQW1CLEdBQUcsb0JBQW9CLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDLEtBQUssRUFBRSxFQUFFLENBQUMsUUFBUSxDQUFDLEtBQUssQ0FBQyxPQUFPLEVBQUUsQ0FBQyxRQUFRLEVBQUUsVUFBVSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFFMUgsTUFBTSxNQUFNLEdBQUcsb0JBQW9CLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDLEtBQUssRUFBRSxFQUFFLENBQUMsS0FBSyxDQUFDLE9BQU8sS0FBSyxNQUFNLElBQUksS0FBSyxDQUFDLE9BQU8sS0FBSyxHQUFHLENBQUMsQ0FBQyxDQUFDO0lBRS9HLE1BQU0sc0JBQXNCLEdBQUcsb0JBQW9CLENBQUMsSUFBSSxDQUN0RCxNQUFNLENBQUMsQ0FBQyxLQUFLLEVBQUUsRUFBRSxDQUFDLFFBQVEsQ0FBQyxLQUFLLENBQUMsT0FBTyxFQUFFLENBQUMsS0FBSyxFQUFFLFFBQVEsRUFBRSxVQUFVLENBQUMsQ0FBQyxDQUFDLEVBQ3pFLEdBQUcsQ0FBQyxDQUFDLEtBQUssRUFBRSxFQUFFO1FBQ1osUUFBUSxLQUFLLENBQUMsT0FBTyxFQUFFO1lBQ3JCLEtBQUssS0FBSztnQkFDUixPQUFPLG9CQUFvQixDQUFDLE9BQU8sQ0FBQztZQUN0QyxLQUFLLFFBQVE7Z0JBQ1gsT0FBTyxvQkFBb0IsQ0FBQyxJQUFJLENBQUM7WUFDbkMsS0FBSyxVQUFVO2dCQUNiLE9BQU8sb0JBQW9CLENBQUMsSUFBSSxDQUFDO1lBQ25DO2dCQUNFLE9BQU8sSUFBSSxDQUFDO1NBQ2Y7SUFDSCxDQUFDLENBQUMsQ0FDSCxDQUFDO0lBRUYsTUFBTSxNQUFNLEdBQUcsb0JBQW9CLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDLEtBQUssRUFBRSxFQUFFLENBQUMsS0FBSyxDQUFDLE9BQU8sS0FBSyxLQUFLLENBQUMsQ0FBQyxDQUFDO0lBQ3JGLE1BQU0sTUFBTSxHQUFHLG9CQUFvQixDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQyxLQUFLLEVBQUUsRUFBRSxDQUFDLEtBQUssQ0FBQyxPQUFPLEtBQUssS0FBSyxDQUFDLENBQUMsQ0FBQztJQUVyRixNQUFNLGdCQUFnQixHQUFHLG9CQUFvQixDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQyxLQUFLLEVBQUUsRUFBRSxDQUFDLEtBQUssQ0FBQyxPQUFPLEtBQUssVUFBVSxDQUFDLENBQUMsQ0FBQztJQUVwRyxPQUFPO1FBQ0wsbUJBQW1CO1FBQ25CLE1BQU07UUFDTixzQkFBc0I7UUFDdEIsTUFBTTtRQUNOLE1BQU07UUFDTixnQkFBZ0I7S0FDakIsQ0FBQztBQUNKLENBQUM7QUFFRCxNQUFNLFVBQVUsNEJBQTRCLENBQUMsR0FBVTtJQUNyRCxHQUFHLENBQUMsY0FBYyxFQUFFLENBQUM7SUFDckIsR0FBRyxDQUFDLHdCQUF3QixFQUFFLENBQUM7QUFDakMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGluY2x1ZGVzIH0gZnJvbSAnbG9kYXNoL2ZwJztcbmltcG9ydCB7IGZyb21FdmVudCwgT2JzZXJ2YWJsZSB9IGZyb20gJ3J4anMnO1xuaW1wb3J0IHsgZmlsdGVyLCBtYXAsIHRha2VVbnRpbCB9IGZyb20gJ3J4anMvb3BlcmF0b3JzJztcbmltcG9ydCB7IEtleWJvYXJkU2VsZWN0QWN0aW9uIH0gZnJvbSAnLi4vY29tcG9uZW50cy9rZXlib2FyZC1zZWxlY3QuZGlyZWN0aXZlJztcbmltcG9ydCB7IEFSUk9XX0RPV04sIEFSUk9XX1VQLCBFTlRFUiwgRVNDQVBFLCBTUEFDRSwgVEFCIH0gZnJvbSAnLi9rZXktY29kZXMuY29uc3RhbnRzJztcblxuZXhwb3J0IGludGVyZmFjZSBLZXlib2FyZE5hdmlnYXRpb25FdmVudHMge1xuICB2ZXJ0aWNhbE5hdmlnYXRpb24kOiBPYnNlcnZhYmxlPEtleWJvYXJkRXZlbnQ+O1xuICBjbG9zZSQ6IE9ic2VydmFibGU8S2V5Ym9hcmRFdmVudD47XG4gIGRyb3Bkb3duS2V5Ym9hcmRFdmVudCQ6IE9ic2VydmFibGU8S2V5Ym9hcmRTZWxlY3RBY3Rpb24gfCBudWxsPjtcbiAgZW50ZXIkOiBPYnNlcnZhYmxlPEtleWJvYXJkRXZlbnQ+O1xuICBzcGFjZSQ6IE9ic2VydmFibGU8S2V5Ym9hcmRFdmVudD47XG4gIG9wZW5PbkFycm93RG93biQ6IE9ic2VydmFibGU8S2V5Ym9hcmRFdmVudD47XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBnZXRLZXlib2FyZE5hdmlnYXRpb25FdmVudHMoc291cmNlRWxlbWVudDogSFRNTEVsZW1lbnQsIGRlc3Ryb3llZCQ6IE9ic2VydmFibGU8dm9pZD4pOiBLZXlib2FyZE5hdmlnYXRpb25FdmVudHMge1xuICBjb25zdCBpbnB1dEtleWJvYXJkRXZlbnRzJCA9IGZyb21FdmVudDxLZXlib2FyZEV2ZW50Pihzb3VyY2VFbGVtZW50LCAna2V5ZG93bicpLnBpcGUodGFrZVVudGlsKGRlc3Ryb3llZCQpKTtcblxuICBjb25zdCB2ZXJ0aWNhbE5hdmlnYXRpb24kID0gaW5wdXRLZXlib2FyZEV2ZW50cyQucGlwZShmaWx0ZXIoKGV2ZW50KSA9PiBpbmNsdWRlcyhldmVudC5rZXlDb2RlLCBbQVJST1dfVVAsIEFSUk9XX0RPV05dKSkpO1xuXG4gIGNvbnN0IGNsb3NlJCA9IGlucHV0S2V5Ym9hcmRFdmVudHMkLnBpcGUoZmlsdGVyKChldmVudCkgPT4gZXZlbnQua2V5Q29kZSA9PT0gRVNDQVBFIHx8IGV2ZW50LmtleUNvZGUgPT09IFRBQikpO1xuXG4gIGNvbnN0IGRyb3Bkb3duS2V5Ym9hcmRFdmVudCQgPSBpbnB1dEtleWJvYXJkRXZlbnRzJC5waXBlKFxuICAgIGZpbHRlcigoZXZlbnQpID0+IGluY2x1ZGVzKGV2ZW50LmtleUNvZGUsIFtFTlRFUiwgQVJST1dfVVAsIEFSUk9XX0RPV05dKSksXG4gICAgbWFwKChldmVudCkgPT4ge1xuICAgICAgc3dpdGNoIChldmVudC5rZXlDb2RlKSB7XG4gICAgICAgIGNhc2UgRU5URVI6XG4gICAgICAgICAgcmV0dXJuIEtleWJvYXJkU2VsZWN0QWN0aW9uLkVYRUNVVEU7XG4gICAgICAgIGNhc2UgQVJST1dfVVA6XG4gICAgICAgICAgcmV0dXJuIEtleWJvYXJkU2VsZWN0QWN0aW9uLlBSRVY7XG4gICAgICAgIGNhc2UgQVJST1dfRE9XTjpcbiAgICAgICAgICByZXR1cm4gS2V5Ym9hcmRTZWxlY3RBY3Rpb24uTkVYVDtcbiAgICAgICAgZGVmYXVsdDpcbiAgICAgICAgICByZXR1cm4gbnVsbDtcbiAgICAgIH1cbiAgICB9KVxuICApO1xuXG4gIGNvbnN0IGVudGVyJCA9IGlucHV0S2V5Ym9hcmRFdmVudHMkLnBpcGUoZmlsdGVyKChldmVudCkgPT4gZXZlbnQua2V5Q29kZSA9PT0gRU5URVIpKTtcbiAgY29uc3Qgc3BhY2UkID0gaW5wdXRLZXlib2FyZEV2ZW50cyQucGlwZShmaWx0ZXIoKGV2ZW50KSA9PiBldmVudC5rZXlDb2RlID09PSBTUEFDRSkpO1xuXG4gIGNvbnN0IG9wZW5PbkFycm93RG93biQgPSBpbnB1dEtleWJvYXJkRXZlbnRzJC5waXBlKGZpbHRlcigoZXZlbnQpID0+IGV2ZW50LmtleUNvZGUgPT09IEFSUk9XX0RPV04pKTtcblxuICByZXR1cm4ge1xuICAgIHZlcnRpY2FsTmF2aWdhdGlvbiQsXG4gICAgY2xvc2UkLFxuICAgIGRyb3Bkb3duS2V5Ym9hcmRFdmVudCQsXG4gICAgZW50ZXIkLFxuICAgIHNwYWNlJCxcbiAgICBvcGVuT25BcnJvd0Rvd24kXG4gIH07XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBzdG9wS2V5Ym9hcmRFdmVudFByb3BhZ2F0aW9uKGV2dDogRXZlbnQpIHtcbiAgZXZ0LnByZXZlbnREZWZhdWx0KCk7XG4gIGV2dC5zdG9wSW1tZWRpYXRlUHJvcGFnYXRpb24oKTtcbn1cbiJdfQ==

package/esm2020/lib/forms-ui/models/base-select.directive.mjs

@@ -0,0 +1,148 @@
+import { Directive, EventEmitter, Input, Output, ViewChild } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { distinctUntilChanged, filter, takeUntil } from 'rxjs/operators';
+import { KeyboardSelectAction } from '../components/keyboard-select.directive';
+import * as i0 from "@angular/core";
+export class BaseSelectDirective {
+    constructor() {
+        this.disabled = false;
+        this.focusOnInit = false;
+        this.dropdownMaxHeight = 250;
+        this.allowQuery = true;
+        this.query = new EventEmitter();
+        this.close = new EventEmitter();
+        this.open = new EventEmitter();
+        this.query$ = this.query.asObservable();
+        this.dropdownDirection$ = new BehaviorSubject('BOTTOM');
+        this.dropdownOpen = false;
+        // an axis, where the negative range represents the selected item in the selection
+        this.selectionKeyboardSelectAction$ = new Subject();
+        this.optionsKeyboardSelectAction$ = new Subject();
+        this.virtualCursorPosition = 0;
+        this.inputWasFocused = false;
+        this.queryControl = new FormControl();
+        this.isInputFocused = false;
+        this.destroyed$ = new Subject();
+    }
+    ngAfterViewInit() {
+        this.queryControl.valueChanges
+            .pipe(filter(() => this.allowQuery), takeUntil(this.destroyed$))
+            .subscribe((value) => {
+            if (value && value.length > 0) {
+                this.open.next(true);
+            }
+            this.query.emit(value);
+            this.selectFirstOption();
+        });
+        this.open
+            .pipe(filter(() => !this.disabled), distinctUntilChanged(), takeUntil(this.destroyed$))
+            .subscribe((isOpen) => {
+            this.dropdownOpen = isOpen;
+            if (isOpen) {
+                this.setOpenDirection();
+            }
+            else {
+                this.resetSelectState();
+                this.close.emit();
+            }
+        });
+        if (this.focusOnInit) {
+            setTimeout(() => this.focus());
+        }
+    }
+    ngOnChanges(changes) {
+        if ('disabled' in changes) {
+            if (this.disabled) {
+                this.queryControl.disable();
+            }
+            else {
+                this.queryControl.enable();
+            }
+        }
+    }
+    ngOnDestroy() {
+        this.destroyed$.next();
+    }
+    /**
+     * @param toggle is true when the caret to the right in a select component was clicked
+     */
+    handleClick(toggle) {
+        if (toggle || !this.dropdownOpen || !this.allowQuery) {
+            this.open.next(!this.dropdownOpen);
+        }
+        this.focus();
+    }
+    handleBackdropClick(event) {
+        event.stopPropagation();
+        this.closeInput();
+    }
+    closeInput() {
+        this.open.next(false);
+        this.resetInput();
+        this.query.emit('');
+    }
+    setOpenDirection() {
+        const dropdownRect = this.optionsContainer.nativeElement.getBoundingClientRect();
+        const spaceAtTheBottom = document.documentElement.clientHeight - dropdownRect.top - dropdownRect.height - this.dropdownMaxHeight;
+        const spaceAtTheTop = dropdownRect.top - this.dropdownMaxHeight;
+        const isTop = spaceAtTheBottom < 0 && spaceAtTheTop > spaceAtTheBottom;
+        this.dropdownDirection$.next(isTop ? 'TOP' : 'BOTTOM');
+    }
+    resetSelectState() {
+        this.virtualCursorPosition = 0;
+        this.selectionKeyboardSelectAction$.next(KeyboardSelectAction.UNSELECT);
+        this.optionsKeyboardSelectAction$.next(KeyboardSelectAction.UNSELECT);
+        this.resetInput();
+        this.query.emit('');
+    }
+    mapToEventSet(event, input, virtualCursorPosition, selectionLength) {
+        return {
+            event,
+            inputCursorPosition: this.doGetCaretPosition(input),
+            virtualCursorPosition,
+            selectionLength
+        };
+    }
+    /*
+     * Returns the caret (cursor) position of the specified text field.
+     * Return value range is 0-oField.value.length.
+     * https://stackoverflow.com/questions/2897155/get-cursor-position-in-characters-within-a-text-input-field
+     */
+    doGetCaretPosition(oField) {
+        let iCaretPos = 0;
+        if (oField.selectionStart || parseInt(oField.selectionStart, 10) === 0) {
+            // Check when range selection using null we prevent deleting on
+            iCaretPos = oField.selectionStart === oField.selectionEnd ? oField.selectionStart : null;
+        }
+        return iCaretPos;
+    }
+    selectFirstOption() {
+        this.optionsKeyboardSelectAction$.next(KeyboardSelectAction.FIRST);
+    }
+}
+BaseSelectDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: BaseSelectDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+BaseSelectDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.5", type: BaseSelectDirective, inputs: { placeholder: "placeholder", disabled: "disabled", focusOnInit: "focusOnInit", dropdownMaxHeight: "dropdownMaxHeight", allowQuery: "allowQuery" }, outputs: { query: "query", close: "close", open: "open" }, viewQueries: [{ propertyName: "optionsContainer", first: true, predicate: ["optionsContainer"], descendants: true, static: true }], usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: BaseSelectDirective, decorators: [{
+            type: Directive
+        }], propDecorators: { placeholder: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], focusOnInit: [{
+                type: Input
+            }], dropdownMaxHeight: [{
+                type: Input
+            }], allowQuery: [{
+                type: Input
+            }], query: [{
+                type: Output
+            }], close: [{
+                type: Output
+            }], open: [{
+                type: Output
+            }], optionsContainer: [{
+                type: ViewChild,
+                args: ['optionsContainer', { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-select.directive.js","sourceRoot":"","sources":["../../../../../../../libs/components/src/lib/forms-ui/models/base-select.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  Input,\n  OnChanges,\n  OnDestroy,\n  Output,\n  SimpleChanges,\n  ViewChild\n} from '@angular/core';\nimport { FormControl } from '@angular/forms';\nimport { BehaviorSubject, Subject } from 'rxjs';\nimport { distinctUntilChanged, filter, takeUntil } from 'rxjs/operators';\nimport { KeyboardSelectAction } from '../components/keyboard-select.directive';\n\nexport interface EventSet {\n  event: KeyboardEvent;\n  inputCursorPosition: number | undefined;\n  virtualCursorPosition: number;\n  selectionLength?: number;\n}\n\n@Directive()\nexport abstract class BaseSelectDirective implements AfterViewInit, OnChanges, OnDestroy {\n  @Input() placeholder?: string;\n  @Input() disabled: boolean = false;\n  @Input() focusOnInit: boolean = false;\n  @Input() dropdownMaxHeight: number = 250;\n  @Input() allowQuery: boolean = true;\n\n  @Output() query = new EventEmitter<string>();\n  @Output() close = new EventEmitter<void>();\n  @Output() open = new EventEmitter<boolean>();\n\n  @ViewChild('optionsContainer', { static: true }) optionsContainer!: ElementRef<HTMLElement>;\n\n  abstract selection?: any;\n  abstract selectionChange: EventEmitter<any>;\n\n  public readonly query$ = this.query.asObservable();\n  public readonly dropdownDirection$ = new BehaviorSubject<'TOP' | 'BOTTOM'>('BOTTOM');\n  public dropdownOpen = false;\n\n  public activeElement!: Element;\n  // an axis, where the negative range represents the selected item in the selection\n  public readonly selectionKeyboardSelectAction$ = new Subject<KeyboardSelectAction>();\n  public readonly optionsKeyboardSelectAction$ = new Subject<KeyboardSelectAction | null>();\n  public virtualCursorPosition: number = 0;\n\n  public inputWasFocused: boolean = false;\n\n  public readonly queryControl = new FormControl();\n\n  public isInputFocused: boolean = false;\n\n  readonly destroyed$ = new Subject<void>();\n\n  abstract resetInput(): void;\n\n  abstract focus(): void;\n\n  ngAfterViewInit() {\n    this.queryControl.valueChanges\n      .pipe(\n        filter(() => this.allowQuery),\n        takeUntil(this.destroyed$)\n      )\n      .subscribe((value) => {\n        if (value && value.length > 0) {\n          this.open.next(true);\n        }\n        this.query.emit(value);\n        this.selectFirstOption();\n      });\n\n    this.open\n      .pipe(\n        filter(() => !this.disabled),\n        distinctUntilChanged(),\n        takeUntil(this.destroyed$)\n      )\n      .subscribe((isOpen) => {\n        this.dropdownOpen = isOpen;\n\n        if (isOpen) {\n          this.setOpenDirection();\n        } else {\n          this.resetSelectState();\n          this.close.emit();\n        }\n      });\n\n    if (this.focusOnInit) {\n      setTimeout(() => this.focus());\n    }\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    if ('disabled' in changes) {\n      if (this.disabled) {\n        this.queryControl.disable();\n      } else {\n        this.queryControl.enable();\n      }\n    }\n  }\n\n  ngOnDestroy() {\n    this.destroyed$.next();\n  }\n\n  /**\n   * @param toggle is true when the caret to the right in a select component was clicked\n   */\n  public handleClick(toggle: boolean) {\n    if (toggle || !this.dropdownOpen || !this.allowQuery) {\n      this.open.next(!this.dropdownOpen);\n    }\n    this.focus();\n  }\n\n  public handleBackdropClick(event: MouseEvent) {\n    event.stopPropagation();\n    this.closeInput();\n  }\n\n  public closeInput() {\n    this.open.next(false);\n    this.resetInput();\n    this.query.emit('');\n  }\n\n  protected setOpenDirection() {\n    const dropdownRect = this.optionsContainer.nativeElement.getBoundingClientRect();\n    const spaceAtTheBottom = document.documentElement.clientHeight - dropdownRect.top - dropdownRect.height - this.dropdownMaxHeight;\n    const spaceAtTheTop = dropdownRect.top - this.dropdownMaxHeight;\n    const isTop = spaceAtTheBottom < 0 && spaceAtTheTop > spaceAtTheBottom;\n\n    this.dropdownDirection$.next(isTop ? 'TOP' : 'BOTTOM');\n  }\n\n  protected resetSelectState() {\n    this.virtualCursorPosition = 0;\n    this.selectionKeyboardSelectAction$.next(KeyboardSelectAction.UNSELECT);\n    this.optionsKeyboardSelectAction$.next(KeyboardSelectAction.UNSELECT);\n    this.resetInput();\n    this.query.emit('');\n  }\n\n  protected mapToEventSet(\n    event: KeyboardEvent,\n    input: HTMLInputElement,\n    virtualCursorPosition: number,\n    selectionLength?: number\n  ): EventSet {\n    return {\n      event,\n      inputCursorPosition: this.doGetCaretPosition(input),\n      virtualCursorPosition,\n      selectionLength\n    };\n  }\n\n  /*\n   * Returns the caret (cursor) position of the specified text field.\n   * Return value range is 0-oField.value.length.\n   * https://stackoverflow.com/questions/2897155/get-cursor-position-in-characters-within-a-text-input-field\n   */\n  protected doGetCaretPosition(oField: any) {\n    let iCaretPos = 0;\n    if (oField.selectionStart || parseInt(oField.selectionStart, 10) === 0) {\n      // Check when range selection using null we prevent deleting on\n      iCaretPos = oField.selectionStart === oField.selectionEnd ? oField.selectionStart : null;\n    }\n    return iCaretPos;\n  }\n\n  protected selectFirstOption() {\n    this.optionsKeyboardSelectAction$.next(KeyboardSelectAction.FIRST);\n  }\n}\n"]}

package/esm2020/lib/forms-ui/models/dropdown-item.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJvcGRvd24taXRlbS5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NvbXBvbmVudHMvc3JjL2xpYi9mb3Jtcy11aS9tb2RlbHMvZHJvcGRvd24taXRlbS5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEV2ZW50RW1pdHRlciB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5leHBvcnQgaW50ZXJmYWNlIERyb3Bkb3duSXRlbSB7XG4gIHNlbGVjdD86IEV2ZW50RW1pdHRlcjxhbnk+O1xuICBzY3JvbGxUb0l0ZW0oKTogdm9pZDtcbn1cbiJdfQ==

package/esm2020/lib/forms-ui/models/single-select-padding.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2luZ2xlLXNlbGVjdC1wYWRkaW5nLmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy9zcmMvbGliL2Zvcm1zLXVpL21vZGVscy9zaW5nbGUtc2VsZWN0LXBhZGRpbmcuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSBTaW5nbGVTZWxlY3RQYWRkaW5nID0gJ2RlZmF1bHQnIHwgJ25hcnJvdyc7XG4iXX0=

package/esm2020/lib/forms-ui/models/sorting.interface.mjs

@@ -0,0 +1,7 @@
+export class Sorting {
+    constructor() {
+        this.key = '';
+        this.order = 'asc';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic29ydGluZy5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NvbXBvbmVudHMvc3JjL2xpYi9mb3Jtcy11aS9tb2RlbHMvc29ydGluZy5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsTUFBTSxPQUFPLE9BQU87SUFBcEI7UUFDRSxRQUFHLEdBQVcsRUFBRSxDQUFDO1FBQ2pCLFVBQUssR0FBaUIsS0FBSyxDQUFDO0lBQzlCLENBQUM7Q0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB0eXBlIFNvcnRpbmdPcmRlciA9ICdhc2MnIHwgJ2Rlc2MnO1xuZXhwb3J0IGNsYXNzIFNvcnRpbmcge1xuICBrZXk6IHN0cmluZyA9ICcnO1xuICBvcmRlcjogU29ydGluZ09yZGVyID0gJ2FzYyc7XG59XG4iXX0=

package/esm2020/lib/forms-ui/pipes/filter-selection.pipe.mjs

@@ -0,0 +1,30 @@
+import { Pipe } from '@angular/core';
+import { filter, find, includes, isEqual, isObject } from 'lodash/fp';
+import * as i0 from "@angular/core";
+export class FilterSelectionPipe {
+    transform(items, selection, itemKey) {
+        const isArray = Array.isArray(selection);
+        return filter((item) => {
+            if (isArray) {
+                if (isObject(item)) {
+                    return itemKey
+                        ? !find((selectedItem) => selectedItem?.[itemKey] === item?.[itemKey], selection)
+                        : !find(item, selection);
+                }
+                else {
+                    return !includes(item, selection);
+                }
+            }
+            else {
+                return !isEqual(item, selection);
+            }
+        }, items);
+    }
+}
+FilterSelectionPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: FilterSelectionPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+FilterSelectionPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: FilterSelectionPipe, name: "lxFilterBySelection" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: FilterSelectionPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'lxFilterBySelection' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/forms-ui/pipes/filter-term.pipe.mjs

@@ -0,0 +1,26 @@
+import { Pipe } from '@angular/core';
+import { filter, toLower } from 'lodash/fp';
+import * as i0 from "@angular/core";
+export class FilterTermPipe {
+    transform(items, options) {
+        if (items === null) {
+            return [];
+        }
+        if (options.term) {
+            return filter((item) => {
+                const value = options.key ? item[options.key] : item;
+                return toLower(value).indexOf(toLower(options.term)) > -1;
+            }, items);
+        }
+        else {
+            return items;
+        }
+    }
+}
+FilterTermPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: FilterTermPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+FilterTermPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: FilterTermPipe, name: "lxFilterByTerm" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: FilterTermPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'lxFilterByTerm' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsdGVyLXRlcm0ucGlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy9zcmMvbGliL2Zvcm1zLXVpL3BpcGVzL2ZpbHRlci10ZXJtLnBpcGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBaUIsTUFBTSxlQUFlLENBQUM7QUFDcEQsT0FBTyxFQUFFLE1BQU0sRUFBRSxPQUFPLEVBQUUsTUFBTSxXQUFXLENBQUM7O0FBRzVDLE1BQU0sT0FBTyxjQUFjO0lBQ3pCLFNBQVMsQ0FBQyxLQUFtQixFQUFFLE9BQStDO1FBQzVFLElBQUksS0FBSyxLQUFLLElBQUksRUFBRTtZQUNsQixPQUFPLEVBQUUsQ0FBQztTQUNYO1FBQ0QsSUFBSSxPQUFPLENBQUMsSUFBSSxFQUFFO1lBQ2hCLE9BQU8sTUFBTSxDQUFDLENBQUMsSUFBSSxFQUFFLEVBQUU7Z0JBQ3JCLE1BQU0sS0FBSyxHQUFHLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQztnQkFDckQsT0FBTyxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsSUFBSyxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQztZQUM3RCxDQUFDLEVBQUUsS0FBSyxDQUFDLENBQUM7U0FDWDthQUFNO1lBQ0wsT0FBTyxLQUFLLENBQUM7U0FDZDtJQUNILENBQUM7OzJHQWJVLGNBQWM7eUdBQWQsY0FBYzsyRkFBZCxjQUFjO2tCQUQxQixJQUFJO21CQUFDLEVBQUUsSUFBSSxFQUFFLGdCQUFnQixFQUFFIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUGlwZSwgUGlwZVRyYW5zZm9ybSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgZmlsdGVyLCB0b0xvd2VyIH0gZnJvbSAnbG9kYXNoL2ZwJztcblxuQFBpcGUoeyBuYW1lOiAnbHhGaWx0ZXJCeVRlcm0nIH0pXG5leHBvcnQgY2xhc3MgRmlsdGVyVGVybVBpcGUgaW1wbGVtZW50cyBQaXBlVHJhbnNmb3JtIHtcbiAgdHJhbnNmb3JtKGl0ZW1zOiBhbnlbXSB8IG51bGwsIG9wdGlvbnM6IHsgdGVybT86IHN0cmluZyB8IG51bGw7IGtleT86IHN0cmluZyB9KTogYW55W10ge1xuICAgIGlmIChpdGVtcyA9PT0gbnVsbCkge1xuICAgICAgcmV0dXJuIFtdO1xuICAgIH1cbiAgICBpZiAob3B0aW9ucy50ZXJtKSB7XG4gICAgICByZXR1cm4gZmlsdGVyKChpdGVtKSA9PiB7XG4gICAgICAgIGNvbnN0IHZhbHVlID0gb3B0aW9ucy5rZXkgPyBpdGVtW29wdGlvbnMua2V5XSA6IGl0ZW07XG4gICAgICAgIHJldHVybiB0b0xvd2VyKHZhbHVlKS5pbmRleE9mKHRvTG93ZXIob3B0aW9ucy50ZXJtISkpID4gLTE7XG4gICAgICB9LCBpdGVtcyk7XG4gICAgfSBlbHNlIHtcbiAgICAgIHJldHVybiBpdGVtcztcbiAgICB9XG4gIH1cbn1cbiJdfQ==

package/esm2020/lib/forms-ui/pipes/format-number.pipe.mjs

@@ -0,0 +1,65 @@
+import { Inject, Pipe } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { LOCALE_FN } from '../../core-ui/core-ui.constants';
+import { CURRENCY_SYMBOL_MAP } from '../components/currency/currency-symbol-map.constant';
+import * as i0 from "@angular/core";
+/**
+ * Reformats numbers into a short format.
+ * @example {{ 1000 | lxFormatNumber | async }} prints 1K
+ *
+ * If the parameter currency is set, a currency sign is inserted based on the value and the current locale.
+ * In this case, the pipe must be used with an innerHtml attribute.
+ * @example [lxHtml]="1000 | lxFormatNumber: 'USD' | async" prints $1K
+ */
+export class FormatNumberPipe {
+    constructor(getLocale) {
+        this.getLocale = getLocale;
+    }
+    transform(number, currency) {
+        const locale$ = this.getLocale();
+        return locale$.pipe(map((locale) => {
+            if (number === null || number === undefined) {
+                return null;
+            }
+            const options = {
+                notation: 'compact',
+                compactDisplay: 'short'
+            };
+            if (currency) {
+                try {
+                    const currencyOptions = { ...options, currency, style: 'currency' };
+                    const formatedNumberWithCurrency = new Intl.NumberFormat(locale, currencyOptions).format(number);
+                    return this.getFormatedCurrency(formatedNumberWithCurrency, currency);
+                }
+                catch (_error) {
+                    console.warn(`FormatNumberPipe: Invalid currency code: ${currency}`);
+                    return new Intl.NumberFormat(locale, options).format(number);
+                }
+            }
+            return new Intl.NumberFormat(locale, options).format(number);
+        }));
+    }
+    /**
+     * Use custom currency symbol, when the currency in the formated number doesn't match the
+     * symbol in the CURRENCY_SYMBOL_MAP.
+     */
+    getFormatedCurrency(formatedNumberWitCurrency, currency) {
+        const currencyMapping = CURRENCY_SYMBOL_MAP[currency];
+        if (currencyMapping && currencyMapping !== currency && !formatedNumberWitCurrency.includes(currencyMapping)) {
+            return formatedNumberWitCurrency.replace(currency, currencyMapping);
+        }
+        return formatedNumberWitCurrency;
+    }
+}
+FormatNumberPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: FormatNumberPipe, deps: [{ token: LOCALE_FN }], target: i0.ɵɵFactoryTarget.Pipe });
+FormatNumberPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: FormatNumberPipe, name: "lxFormatNumber" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: FormatNumberPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'lxFormatNumber'
+                }]
+        }], ctorParameters: function () { return [{ type: Function, decorators: [{
+                    type: Inject,
+                    args: [LOCALE_FN]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/forms-ui/validators/date-in-foreseeable-future.validator.mjs

@@ -0,0 +1,26 @@
+import { formatDate } from '@angular/common';
+/**
+ * Due to limitations of the native html datepicker this validator is needed:
+ * In the datepicker the min and max values only apply if the date is altered e.g. via scrolling.
+ * It is still possible to manually input a value lower or higher than min and max value.
+ */
+export function ValidateDateInForeseeableFuture(control) {
+    // matches yyyy-mm-dd
+    const dateRegex = /^\d{4}\-(0[1-9]|1[012])\-(0[1-9]|[12][0-9]|3[01])$/;
+    if (control.value && dateRegex.test(control.value)) {
+        const today = formatDate(new Date(), 'yyyy-MM-dd', 'en');
+        const maxDate = '2999-12-31';
+        if (control.value < today || control.value > maxDate) {
+            return {
+                dateInForseeableFuture: {
+                    valid: false
+                }
+            };
+        }
+        else {
+            return null;
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=data:application/json;base64,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