@leanix/components 0.2.229 → 0.2.232

package/esm2020/lib/forms-ui/components/picker/picker.component.mjs

@@ -0,0 +1,201 @@
+import { ActiveDescendantKeyManager } from '@angular/cdk/a11y';
+import { ChangeDetectionStrategy, Component, ContentChild, ContentChildren, forwardRef, HostListener, Input } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { PickerOptionComponent } from '../picker-option/picker-option.component';
+import { PickerTriggerDirective } from './picker-trigger.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/bidi";
+import * as i2 from "@angular/common";
+import * as i3 from "../../../core-ui/directives/autoclose.directive";
+/**
+ * How to use:
+ * Provide the lx-picker with two kinds of ContentChildren:
+ * 1. A lxPickerTrigger, preferably a button element, which we use to open the dropdown on click or enter.
+ * 2. A list of <li> elements with an lx-picker-option attribute that own the option template as content children.
+ *
+ * You can use this component as part of a FormGroup or wire it up yourself by listening on the (select) output of the options.
+ *
+ * Example usage (non FormGroup style):
+ * <lx-picker listBoxAriaLabel="Awesome picker">
+ *   <button lxPickerTrigger lx-button mode="outline" size="large" [square]="true" aria-label="Awesome picker" title="Awesome picker">
+ *       <lx-icon [name]="selection.label" [color]="selection.value" fontAwsomeStyle="solid"></lx-icon>
+ *    </button>
+ *    <li *ngFor="let option of options" lx-picker-option [value]="option.value" [selected]="selection === option" (select)="selection = option" [optionId]="option.id">
+ *       <lx-icon lx-picker-option [name]="option.label" [color]="option.value" fontAwsomeStyle="solid"></lx-icon>
+ *    </li>
+ * </lx-picker>
+ */
+export class PickerComponent {
+    constructor(dir, cdRef) {
+        this.dir = dir;
+        this.cdRef = cdRef;
+        this.openDirection = 'right';
+        this._isFormControl = false;
+        this._open = false;
+        this._lastSelectWasByKeyManager = false;
+        this.destroyed$ = new Subject();
+    }
+    get activeDescendantsId() {
+        return this._activeDescendantsId;
+    }
+    set activeDescendantsId(value) {
+        this._activeDescendantsId = value;
+        this.cdRef.markForCheck();
+    }
+    get open() {
+        return this._open;
+    }
+    set open(value) {
+        this._open = value;
+        this.cdRef.markForCheck();
+    }
+    /**
+     * Returns a negative margin, that is used to move the picker dropdown to the left side of the picker trigger.
+     */
+    get leftOffset() {
+        const dropdownWidth = 185;
+        return this.openDirection === 'left' ? `-${dropdownWidth - this._trigger.width}px` : '0px';
+    }
+    manageKeyboardEvents(event) {
+        if (this.open) {
+            const activeIndex = this.keyManager.activeItemIndex || 0;
+            switch (event.key) {
+                case 'Enter':
+                    setTimeout(() => {
+                        this.closePicker();
+                    });
+                    break;
+                case 'Escape':
+                case 'Tab':
+                    this.setActivePickerOption(-1);
+                    this.closePicker();
+                    break;
+                case 'ArrowDown':
+                    event.preventDefault();
+                    const newDownIndex = this.keyManager.activeItemIndex === -1 ? 0 : activeIndex + 5;
+                    this.setActivePickerOption(newDownIndex < this.options.length ? newDownIndex : activeIndex);
+                    break;
+                case 'ArrowUp':
+                    event.preventDefault();
+                    const newUpIndex = this.keyManager.activeItemIndex === -1 ? this.options.length - 1 : activeIndex - 5;
+                    this.setActivePickerOption(newUpIndex >= 0 ? newUpIndex : activeIndex);
+                    break;
+                case 'ArrowLeft':
+                    if (this.keyManager.activeItemIndex === -1) {
+                        this.setActivePickerOption(this.options.length - 1);
+                    }
+                    else {
+                        this.keyManager.onKeydown(event);
+                        this.activeDescendantsId = this.keyManager.activeItem?.optionId;
+                    }
+                    break;
+                case 'Home':
+                    event.preventDefault();
+                    this.setActivePickerOption(0);
+                    break;
+                case 'End':
+                    event.preventDefault();
+                    this.setActivePickerOption(this.options.length - 1);
+                    break;
+                default:
+                    // matches ArrowRight
+                    this.keyManager.onKeydown(event);
+                    this.activeDescendantsId = this.keyManager.activeItem?.optionId;
+            }
+            if (this.keyManager.activeItem) {
+                this._lastSelectWasByKeyManager = true;
+                this.propagateChange(this.keyManager.activeItem.value);
+                if (!this._isFormControl) {
+                    this.keyManager.activeItem.selectOption();
+                }
+            }
+        }
+    }
+    ngAfterViewInit() {
+        this.keyManager = new ActiveDescendantKeyManager(this.options).withHorizontalOrientation(this.dir.value).withVerticalOrientation(true);
+        this.options.map((item) => {
+            item.select.pipe(takeUntil(this.destroyed$)).subscribe((value) => {
+                this.propagateChange(value);
+                if (value !== this.keyManager.activeItem?.value || !this._lastSelectWasByKeyManager) {
+                    this.closePicker();
+                }
+                this._lastSelectWasByKeyManager = false;
+            });
+        });
+        this._trigger.clickEvent$.pipe(takeUntil(this.destroyed$)).subscribe(() => {
+            this.toggleOpen();
+        });
+    }
+    ngOnDestroy() {
+        this.destroyed$.next();
+    }
+    closePicker() {
+        this.setActivePickerOption(-1);
+        this.open = false;
+    }
+    toggleOpen() {
+        this.open = !this.open;
+        if (this.open) {
+            this.onTouched();
+        }
+        this.setActivePickerOption(this.open === false ? -1 : this.options.toArray().findIndex((option) => option.selected));
+    }
+    setActivePickerOption(index) {
+        this.keyManager.setActiveItem(index);
+        if (this.keyManager.activeItem) {
+            this.activeDescendantsId = this.keyManager.activeItem.optionId;
+        }
+        else {
+            this.activeDescendantsId = undefined;
+        }
+    }
+    //#region Angular Forms API. This is only used when using the Picker inside a FormGroup
+    writeValue(value) {
+        this.options?.toArray().forEach((option) => (option.selected = option.value === value));
+    }
+    registerOnChange(fn) {
+        this.propagateChange = fn;
+        this._isFormControl = true;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    propagateChange(_value) { }
+    onTouched() { }
+}
+PickerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: PickerComponent, deps: [{ token: i1.Directionality }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+PickerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.5", type: PickerComponent, selector: "lx-picker", inputs: { listBoxAriaLabel: "listBoxAriaLabel", listBoxAriaLabelledBy: "listBoxAriaLabelledBy", openDirection: "openDirection" }, host: { listeners: { "document:keydown": "manageKeyboardEvents($event)" } }, providers: [
+        {
+            provide: NG_VALUE_ACCESSOR,
+            multi: true,
+            useExisting: forwardRef(() => PickerComponent)
+        }
+    ], queries: [{ propertyName: "_trigger", first: true, predicate: PickerTriggerDirective, descendants: true }, { propertyName: "options", predicate: PickerOptionComponent }], ngImport: i0, template: "<div class=\"pickerContainer\">\n  <ng-content select=\"[lxPickerTrigger]\"></ng-content>\n  <ul\n    class=\"pickerOptions\"\n    *ngIf=\"open\"\n    lxAutoclose\n    (autoclose)=\"closePicker()\"\n    role=\"listbox\"\n    [style.margin-left]=\"leftOffset\"\n    [attr.aria-activedescendant]=\"activeDescendantsId\"\n    [attr.aria-label]=\"listBoxAriaLabel\"\n    [attr.aria-labelledby]=\"listBoxAriaLabelledBy\"\n  >\n    <ng-content></ng-content>\n  </ul>\n</div>\n", styles: [":host{display:inline-block;width:100%;position:relative}.pickerOptions{position:absolute;background-color:#fff;border-radius:3px;box-shadow:0 8px 12px 2px #00000026;border:solid 1px #e1e5eb;padding:4px;z-index:20;width:185px}\n"], directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i3.AutocloseDirective, selector: "[lxAutoclose]", inputs: ["autocloseGroup"], outputs: ["autoclose"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: PickerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lx-picker', providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            multi: true,
+                            useExisting: forwardRef(() => PickerComponent)
+                        }
+                    ], changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"pickerContainer\">\n  <ng-content select=\"[lxPickerTrigger]\"></ng-content>\n  <ul\n    class=\"pickerOptions\"\n    *ngIf=\"open\"\n    lxAutoclose\n    (autoclose)=\"closePicker()\"\n    role=\"listbox\"\n    [style.margin-left]=\"leftOffset\"\n    [attr.aria-activedescendant]=\"activeDescendantsId\"\n    [attr.aria-label]=\"listBoxAriaLabel\"\n    [attr.aria-labelledby]=\"listBoxAriaLabelledBy\"\n  >\n    <ng-content></ng-content>\n  </ul>\n</div>\n", styles: [":host{display:inline-block;width:100%;position:relative}.pickerOptions{position:absolute;background-color:#fff;border-radius:3px;box-shadow:0 8px 12px 2px #00000026;border:solid 1px #e1e5eb;padding:4px;z-index:20;width:185px}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.Directionality }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { listBoxAriaLabel: [{
+                type: Input
+            }], listBoxAriaLabelledBy: [{
+                type: Input
+            }], openDirection: [{
+                type: Input
+            }], options: [{
+                type: ContentChildren,
+                args: [PickerOptionComponent]
+            }], _trigger: [{
+                type: ContentChild,
+                args: [PickerTriggerDirective]
+            }], manageKeyboardEvents: [{
+                type: HostListener,
+                args: ['document:keydown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"picker.component.js","sourceRoot":"","sources":["../../../../../../../../libs/components/src/lib/forms-ui/components/picker/picker.component.ts","../../../../../../../../libs/components/src/lib/forms-ui/components/picker/picker.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ActiveDescendantKeyManager } from '@angular/cdk/a11y';\nimport { Directionality } from '@angular/cdk/bidi';\nimport {\n  AfterViewInit,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ContentChild,\n  ContentChildren,\n  forwardRef,\n  HostListener,\n  Input,\n  OnDestroy,\n  QueryList\n} from '@angular/core';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { Subject } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\nimport { PickerOptionComponent } from '../picker-option/picker-option.component';\nimport { PickerTriggerDirective } from './picker-trigger.directive';\n\n/**\n * How to use:\n * Provide the lx-picker with two kinds of ContentChildren:\n * 1. A lxPickerTrigger, preferably a button element, which we use to open the dropdown on click or enter.\n * 2. A list of <li> elements with an lx-picker-option attribute that own the option template as content children.\n *\n * You can use this component as part of a FormGroup or wire it up yourself by listening on the (select) output of the options.\n *\n * Example usage (non FormGroup style):\n * <lx-picker listBoxAriaLabel=\"Awesome picker\">\n *   <button lxPickerTrigger lx-button mode=\"outline\" size=\"large\" [square]=\"true\" aria-label=\"Awesome picker\" title=\"Awesome picker\">\n *       <lx-icon [name]=\"selection.label\" [color]=\"selection.value\" fontAwsomeStyle=\"solid\"></lx-icon>\n *    </button>\n *    <li *ngFor=\"let option of options\" lx-picker-option [value]=\"option.value\" [selected]=\"selection === option\" (select)=\"selection = option\" [optionId]=\"option.id\">\n *       <lx-icon lx-picker-option [name]=\"option.label\" [color]=\"option.value\" fontAwsomeStyle=\"solid\"></lx-icon>\n *    </li>\n * </lx-picker>\n */\n@Component({\n  selector: 'lx-picker',\n  templateUrl: 'picker.component.html',\n  styleUrls: ['picker.component.scss'],\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      multi: true,\n      useExisting: forwardRef(() => PickerComponent)\n    }\n  ],\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class PickerComponent implements AfterViewInit, ControlValueAccessor, OnDestroy {\n  /**\n   * A human-readable string value which identifies the listbox.\n   * If there's a visible label, then aria-labelledby should be used instead to refer to that label.\n   */\n  @Input() listBoxAriaLabel?: string;\n  /**\n   * Identifies the visible element which identifies the listbox.\n   * If there's no visible label, then aria-label should be used instead to include a label.\n   */\n  @Input() listBoxAriaLabelledBy?: string;\n  @Input() openDirection: 'left' | 'right' = 'right';\n\n  get activeDescendantsId() {\n    return this._activeDescendantsId;\n  }\n  set activeDescendantsId(value: string | undefined) {\n    this._activeDescendantsId = value;\n    this.cdRef.markForCheck();\n  }\n\n  get open() {\n    return this._open;\n  }\n  set open(value: boolean) {\n    this._open = value;\n    this.cdRef.markForCheck();\n  }\n\n  /**\n   * Returns a negative margin, that is used to move the picker dropdown to the left side of the picker trigger.\n   */\n  get leftOffset() {\n    const dropdownWidth = 185;\n    return this.openDirection === 'left' ? `-${dropdownWidth - this._trigger.width}px` : '0px';\n  }\n\n  @ContentChildren(PickerOptionComponent)\n  private options!: QueryList<PickerOptionComponent>;\n  keyManager!: ActiveDescendantKeyManager<PickerOptionComponent>;\n\n  @ContentChild(PickerTriggerDirective)\n  private _trigger!: PickerTriggerDirective;\n  private _isFormControl = false;\n  private _open = false;\n  private _activeDescendantsId?: string;\n  private _lastSelectWasByKeyManager = false;\n\n  readonly destroyed$ = new Subject<void>();\n\n  constructor(private dir: Directionality, private cdRef: ChangeDetectorRef) {}\n\n  @HostListener('document:keydown', ['$event'])\n  manageKeyboardEvents(event: KeyboardEvent) {\n    if (this.open) {\n      const activeIndex = this.keyManager.activeItemIndex || 0;\n      switch (event.key) {\n        case 'Enter':\n          setTimeout(() => {\n            this.closePicker();\n          });\n          break;\n        case 'Escape':\n        case 'Tab':\n          this.setActivePickerOption(-1);\n          this.closePicker();\n          break;\n        case 'ArrowDown':\n          event.preventDefault();\n          const newDownIndex = this.keyManager.activeItemIndex === -1 ? 0 : activeIndex + 5;\n          this.setActivePickerOption(newDownIndex < this.options.length ? newDownIndex : activeIndex);\n          break;\n        case 'ArrowUp':\n          event.preventDefault();\n          const newUpIndex = this.keyManager.activeItemIndex === -1 ? this.options.length - 1 : activeIndex - 5;\n          this.setActivePickerOption(newUpIndex >= 0 ? newUpIndex : activeIndex);\n          break;\n        case 'ArrowLeft':\n          if (this.keyManager.activeItemIndex === -1) {\n            this.setActivePickerOption(this.options.length - 1);\n          } else {\n            this.keyManager.onKeydown(event);\n            this.activeDescendantsId = this.keyManager.activeItem?.optionId;\n          }\n          break;\n        case 'Home':\n          event.preventDefault();\n          this.setActivePickerOption(0);\n          break;\n        case 'End':\n          event.preventDefault();\n          this.setActivePickerOption(this.options.length - 1);\n          break;\n        default:\n          // matches ArrowRight\n          this.keyManager.onKeydown(event);\n          this.activeDescendantsId = this.keyManager.activeItem?.optionId;\n      }\n      if (this.keyManager.activeItem) {\n        this._lastSelectWasByKeyManager = true;\n        this.propagateChange(this.keyManager.activeItem.value);\n        if (!this._isFormControl) {\n          this.keyManager.activeItem.selectOption();\n        }\n      }\n    }\n  }\n\n  ngAfterViewInit(): void {\n    this.keyManager = new ActiveDescendantKeyManager(this.options).withHorizontalOrientation(this.dir.value).withVerticalOrientation(true);\n\n    this.options.map((item: PickerOptionComponent) => {\n      item.select.pipe(takeUntil(this.destroyed$)).subscribe((value: any) => {\n        this.propagateChange(value);\n        if (value !== this.keyManager.activeItem?.value || !this._lastSelectWasByKeyManager) {\n          this.closePicker();\n        }\n        this._lastSelectWasByKeyManager = false;\n      });\n    });\n\n    this._trigger.clickEvent$.pipe(takeUntil(this.destroyed$)).subscribe(() => {\n      this.toggleOpen();\n    });\n  }\n\n  ngOnDestroy() {\n    this.destroyed$.next();\n  }\n\n  closePicker() {\n    this.setActivePickerOption(-1);\n    this.open = false;\n  }\n\n  toggleOpen() {\n    this.open = !this.open;\n    if (this.open) {\n      this.onTouched();\n    }\n    this.setActivePickerOption(this.open === false ? -1 : this.options.toArray().findIndex((option) => option.selected));\n  }\n\n  private setActivePickerOption(index: number) {\n    this.keyManager.setActiveItem(index);\n    if (this.keyManager.activeItem) {\n      this.activeDescendantsId = this.keyManager.activeItem.optionId;\n    } else {\n      this.activeDescendantsId = undefined;\n    }\n  }\n\n  //#region Angular Forms API. This is only used when using the Picker inside a FormGroup\n\n  writeValue(value: any) {\n    this.options?.toArray().forEach((option) => (option.selected = option.value === value));\n  }\n\n  registerOnChange(fn: any): void {\n    this.propagateChange = fn;\n    this._isFormControl = true;\n  }\n\n  registerOnTouched(fn: any): void {\n    this.onTouched = fn;\n  }\n\n  private propagateChange(_value: any) {}\n  private onTouched() {}\n\n  //#endregion\n}\n","<div class=\"pickerContainer\">\n  <ng-content select=\"[lxPickerTrigger]\"></ng-content>\n  <ul\n    class=\"pickerOptions\"\n    *ngIf=\"open\"\n    lxAutoclose\n    (autoclose)=\"closePicker()\"\n    role=\"listbox\"\n    [style.margin-left]=\"leftOffset\"\n    [attr.aria-activedescendant]=\"activeDescendantsId\"\n    [attr.aria-label]=\"listBoxAriaLabel\"\n    [attr.aria-labelledby]=\"listBoxAriaLabelledBy\"\n  >\n    <ng-content></ng-content>\n  </ul>\n</div>\n"]}

package/esm2020/lib/forms-ui/components/picker-option/picker-option.component.mjs

@@ -0,0 +1,118 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, HostBinding, HostListener, Input, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+import * as i2 from "../icon/icon.component";
+import * as i3 from "@angular/common";
+export class PickerOptionComponent {
+    constructor(cdRef, translateService) {
+        this.cdRef = cdRef;
+        this.translateService = translateService;
+        this.NAME = 'PickerOptionComponent';
+        this.role = 'option';
+        this.ariaSelected = false;
+        this.selected = false;
+        this.isClearOption = false;
+        /**
+         * Emits the value.
+         */
+        this.select = new EventEmitter();
+        this._highlighted = false;
+    }
+    get ariaLabelValue() {
+        if (this.isClearOption) {
+            return this.translateService.instant(`${this.NAME}.clearOption.label`);
+        }
+        return this.ariaLabel;
+    }
+    get titleValue() {
+        if (this.isClearOption) {
+            return this.translateService.instant(`${this.NAME}.clearOption.label`);
+        }
+        return this.ariaLabel;
+    }
+    get id() {
+        return this.optionId;
+    }
+    /**
+     * This property is true, when the option was selected by mouse click or by the
+     * ActiveDescendantKeyManager calling setActiveStyles().
+     * It's false when the ActiveDescendantKeyManager calls setInactiveStyles().
+     * Is used by the PickerComponent to find the current active option.
+     */
+    get highlighted() {
+        return this._highlighted;
+    }
+    set highlighted(value) {
+        this._highlighted = value;
+        this.cdRef.markForCheck();
+    }
+    ngOnInit() {
+        if (this.selected) {
+            this.ariaSelected = true;
+        }
+    }
+    manageClickEvents() {
+        this.selectOption();
+    }
+    setActiveStyles() {
+        this.ariaSelected = true;
+        this.highlighted = true;
+    }
+    setInactiveStyles() {
+        this.ariaSelected = false;
+        this.highlighted = false;
+    }
+    /**
+     * Triggers the EventEmitter select() that should emit, when an option was selected.
+     * This function is used in the PickerComponent when an option was selected.
+     */
+    selectOption() {
+        this.select.emit(this.value);
+    }
+}
+PickerOptionComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: PickerOptionComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Component });
+PickerOptionComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.5", type: PickerOptionComponent, selector: "li[lx-picker-option]", inputs: { optionId: "optionId", ariaLabel: "ariaLabel", value: "value", selected: "selected", isClearOption: "isClearOption" }, outputs: { select: "select" }, host: { listeners: { "click": "manageClickEvents()" }, properties: { "attr.role": "this.role", "attr.aria-selected": "this.ariaSelected", "attr.aria-label": "this.ariaLabelValue", "attr.title": "this.titleValue", "id": "this.id", "class.selected": "this.selected", "class.clearOption": "this.isClearOption", "class.highlighted": "this.highlighted" } }, ngImport: i0, template: "<lx-icon *ngIf=\"isClearOption\" name=\"slash\" color=\"#d8d8d8\"></lx-icon>\n<ng-content *ngIf=\"!isClearOption\"></ng-content>\n", styles: [":host{display:inline-block;cursor:pointer;width:35px;height:35px;line-height:35px;text-align:center;border:1px solid transparent;border-radius:3px}:host.clearOption{border:1px solid #cfd5df}:host.highlighted,:host.selected{border:1px solid #b2bccc;cursor:default}:host:hover{border:1px solid #b2bccc}:host:focus{outline:0}\n"], components: [{ type: i2.IconComponent, selector: "lx-icon", inputs: ["name", "color", "fontAwsomeStyle", "size", "title"] }], directives: [{ type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: PickerOptionComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'li[lx-picker-option]', changeDetection: ChangeDetectionStrategy.OnPush, template: "<lx-icon *ngIf=\"isClearOption\" name=\"slash\" color=\"#d8d8d8\"></lx-icon>\n<ng-content *ngIf=\"!isClearOption\"></ng-content>\n", styles: [":host{display:inline-block;cursor:pointer;width:35px;height:35px;line-height:35px;text-align:center;border:1px solid transparent;border-radius:3px}:host.clearOption{border:1px solid #cfd5df}:host.highlighted,:host.selected{border:1px solid #b2bccc;cursor:default}:host:hover{border:1px solid #b2bccc}:host:focus{outline:0}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i1.TranslateService }]; }, propDecorators: { role: [{
+                type: HostBinding,
+                args: ['attr.role']
+            }], ariaSelected: [{
+                type: HostBinding,
+                args: ['attr.aria-selected']
+            }], ariaLabelValue: [{
+                type: HostBinding,
+                args: ['attr.aria-label']
+            }], titleValue: [{
+                type: HostBinding,
+                args: ['attr.title']
+            }], id: [{
+                type: HostBinding,
+                args: ['id']
+            }], optionId: [{
+                type: Input
+            }], ariaLabel: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], selected: [{
+                type: HostBinding,
+                args: ['class.selected']
+            }, {
+                type: Input
+            }], isClearOption: [{
+                type: HostBinding,
+                args: ['class.clearOption']
+            }, {
+                type: Input
+            }], select: [{
+                type: Output
+            }], highlighted: [{
+                type: HostBinding,
+                args: ['class.highlighted']
+            }], manageClickEvents: [{
+                type: HostListener,
+                args: ['click']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGlja2VyLW9wdGlvbi5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NvbXBvbmVudHMvc3JjL2xpYi9mb3Jtcy11aS9jb21wb25lbnRzL3BpY2tlci1vcHRpb24vcGlja2VyLW9wdGlvbi5jb21wb25lbnQudHMiLCIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NvbXBvbmVudHMvc3JjL2xpYi9mb3Jtcy11aS9jb21wb25lbnRzL3BpY2tlci1vcHRpb24vcGlja2VyLW9wdGlvbi5jb21wb25lbnQuaHRtbCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQ0wsdUJBQXVCLEVBRXZCLFNBQVMsRUFDVCxZQUFZLEVBQ1osV0FBVyxFQUNYLFlBQVksRUFDWixLQUFLLEVBRUwsTUFBTSxFQUNQLE1BQU0sZUFBZSxDQUFDOzs7OztBQVN2QixNQUFNLE9BQU8scUJBQXFCO0lBb0RoQyxZQUFvQixLQUF3QixFQUFVLGdCQUFrQztRQUFwRSxVQUFLLEdBQUwsS0FBSyxDQUFtQjtRQUFVLHFCQUFnQixHQUFoQixnQkFBZ0IsQ0FBa0I7UUFuRC9FLFNBQUksR0FBRyx1QkFBdUIsQ0FBQztRQUNkLFNBQUksR0FBRyxRQUFRLENBQUM7UUFDUCxpQkFBWSxHQUFHLEtBQUssQ0FBQztRQTJCaEIsYUFBUSxHQUFHLEtBQUssQ0FBQztRQUNkLGtCQUFhLEdBQUcsS0FBSyxDQUFDO1FBQ2pFOztXQUVHO1FBQ08sV0FBTSxHQUFHLElBQUksWUFBWSxFQUFPLENBQUM7UUFlbkMsaUJBQVksR0FBRyxLQUFLLENBQUM7SUFFOEQsQ0FBQztJQWhENUYsSUFDVyxjQUFjO1FBQ3ZCLElBQUksSUFBSSxDQUFDLGFBQWEsRUFBRTtZQUN0QixPQUFPLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxPQUFPLENBQUMsR0FBRyxJQUFJLENBQUMsSUFBSSxvQkFBb0IsQ0FBQyxDQUFDO1NBQ3hFO1FBQ0QsT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDO0lBQ3hCLENBQUM7SUFDRCxJQUNXLFVBQVU7UUFDbkIsSUFBSSxJQUFJLENBQUMsYUFBYSxFQUFFO1lBQ3RCLE9BQU8sSUFBSSxDQUFDLGdCQUFnQixDQUFDLE9BQU8sQ0FBQyxHQUFHLElBQUksQ0FBQyxJQUFJLG9CQUFvQixDQUFDLENBQUM7U0FDeEU7UUFDRCxPQUFPLElBQUksQ0FBQyxTQUFTLENBQUM7SUFDeEIsQ0FBQztJQUNELElBQ1csRUFBRTtRQUNYLE9BQU8sSUFBSSxDQUFDLFFBQVEsQ0FBQztJQUN2QixDQUFDO0lBZUQ7Ozs7O09BS0c7SUFDSCxJQUNJLFdBQVc7UUFDYixPQUFPLElBQUksQ0FBQyxZQUFZLENBQUM7SUFDM0IsQ0FBQztJQUNELElBQUksV0FBVyxDQUFDLEtBQWM7UUFDNUIsSUFBSSxDQUFDLFlBQVksR0FBRyxLQUFLLENBQUM7UUFDMUIsSUFBSSxDQUFDLEtBQUssQ0FBQyxZQUFZLEVBQUUsQ0FBQztJQUM1QixDQUFDO0lBS0QsUUFBUTtRQUNOLElBQUksSUFBSSxDQUFDLFFBQVEsRUFBRTtZQUNqQixJQUFJLENBQUMsWUFBWSxHQUFHLElBQUksQ0FBQztTQUMxQjtJQUNILENBQUM7SUFHRCxpQkFBaUI7UUFDZixJQUFJLENBQUMsWUFBWSxFQUFFLENBQUM7SUFDdEIsQ0FBQztJQUVELGVBQWU7UUFDYixJQUFJLENBQUMsWUFBWSxHQUFHLElBQUksQ0FBQztRQUN6QixJQUFJLENBQUMsV0FBVyxHQUFHLElBQUksQ0FBQztJQUMxQixDQUFDO0lBRUQsaUJBQWlCO1FBQ2YsSUFBSSxDQUFDLFlBQVksR0FBRyxLQUFLLENBQUM7UUFDMUIsSUFBSSxDQUFDLFdBQVcsR0FBRyxLQUFLLENBQUM7SUFDM0IsQ0FBQztJQUVEOzs7T0FHRztJQUNILFlBQVk7UUFDVixJQUFJLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDL0IsQ0FBQzs7a0hBakZVLHFCQUFxQjtzR0FBckIscUJBQXFCLDRqQkNwQmxDLG9JQUVBOzJGRGtCYSxxQkFBcUI7a0JBUGpDLFNBQVM7K0JBRUUsc0JBQXNCLG1CQUdmLHVCQUF1QixDQUFDLE1BQU07dUlBSXJCLElBQUk7c0JBQTdCLFdBQVc7dUJBQUMsV0FBVztnQkFDVyxZQUFZO3NCQUE5QyxXQUFXO3VCQUFDLG9CQUFvQjtnQkFFdEIsY0FBYztzQkFEeEIsV0FBVzt1QkFBQyxpQkFBaUI7Z0JBUW5CLFVBQVU7c0JBRHBCLFdBQVc7dUJBQUMsWUFBWTtnQkFRZCxFQUFFO3NCQURaLFdBQVc7dUJBQUMsSUFBSTtnQkFTUixRQUFRO3NCQUFoQixLQUFLO2dCQUNHLFNBQVM7c0JBQWpCLEtBQUs7Z0JBQ0csS0FBSztzQkFBYixLQUFLO2dCQUNrQyxRQUFRO3NCQUEvQyxXQUFXO3VCQUFDLGdCQUFnQjs7c0JBQUcsS0FBSztnQkFDTSxhQUFhO3NCQUF2RCxXQUFXO3VCQUFDLG1CQUFtQjs7c0JBQUcsS0FBSztnQkFJOUIsTUFBTTtzQkFBZixNQUFNO2dCQVFILFdBQVc7c0JBRGQsV0FBVzt1QkFBQyxtQkFBbUI7Z0JBbUJoQyxpQkFBaUI7c0JBRGhCLFlBQVk7dUJBQUMsT0FBTyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEhpZ2hsaWdodGFibGUgfSBmcm9tICdAYW5ndWxhci9jZGsvYTExeSc7XG5pbXBvcnQge1xuICBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneSxcbiAgQ2hhbmdlRGV0ZWN0b3JSZWYsXG4gIENvbXBvbmVudCxcbiAgRXZlbnRFbWl0dGVyLFxuICBIb3N0QmluZGluZyxcbiAgSG9zdExpc3RlbmVyLFxuICBJbnB1dCxcbiAgT25Jbml0LFxuICBPdXRwdXRcbn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBUcmFuc2xhdGVTZXJ2aWNlIH0gZnJvbSAnQG5neC10cmFuc2xhdGUvY29yZSc7XG5AQ29tcG9uZW50KHtcbiAgLy8gZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIEBhbmd1bGFyLWVzbGludC9jb21wb25lbnQtc2VsZWN0b3JcbiAgc2VsZWN0b3I6ICdsaVtseC1waWNrZXItb3B0aW9uXScsXG4gIHRlbXBsYXRlVXJsOiAncGlja2VyLW9wdGlvbi5jb21wb25lbnQuaHRtbCcsXG4gIHN0eWxlVXJsczogWydwaWNrZXItb3B0aW9uLmNvbXBvbmVudC5zY3NzJ10sXG4gIGNoYW5nZURldGVjdGlvbjogQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3kuT25QdXNoXG59KVxuZXhwb3J0IGNsYXNzIFBpY2tlck9wdGlvbkNvbXBvbmVudCBpbXBsZW1lbnRzIEhpZ2hsaWdodGFibGUsIE9uSW5pdCB7XG4gIHJlYWRvbmx5IE5BTUUgPSAnUGlja2VyT3B0aW9uQ29tcG9uZW50JztcbiAgQEhvc3RCaW5kaW5nKCdhdHRyLnJvbGUnKSByb2xlID0gJ29wdGlvbic7XG4gIEBIb3N0QmluZGluZygnYXR0ci5hcmlhLXNlbGVjdGVkJykgYXJpYVNlbGVjdGVkID0gZmFsc2U7XG4gIEBIb3N0QmluZGluZygnYXR0ci5hcmlhLWxhYmVsJylcbiAgcHVibGljIGdldCBhcmlhTGFiZWxWYWx1ZSgpOiBzdHJpbmcgfCB1bmRlZmluZWQge1xuICAgIGlmICh0aGlzLmlzQ2xlYXJPcHRpb24pIHtcbiAgICAgIHJldHVybiB0aGlzLnRyYW5zbGF0ZVNlcnZpY2UuaW5zdGFudChgJHt0aGlzLk5BTUV9LmNsZWFyT3B0aW9uLmxhYmVsYCk7XG4gICAgfVxuICAgIHJldHVybiB0aGlzLmFyaWFMYWJlbDtcbiAgfVxuICBASG9zdEJpbmRpbmcoJ2F0dHIudGl0bGUnKVxuICBwdWJsaWMgZ2V0IHRpdGxlVmFsdWUoKTogc3RyaW5nIHwgdW5kZWZpbmVkIHtcbiAgICBpZiAodGhpcy5pc0NsZWFyT3B0aW9uKSB7XG4gICAgICByZXR1cm4gdGhpcy50cmFuc2xhdGVTZXJ2aWNlLmluc3RhbnQoYCR7dGhpcy5OQU1FfS5jbGVhck9wdGlvbi5sYWJlbGApO1xuICAgIH1cbiAgICByZXR1cm4gdGhpcy5hcmlhTGFiZWw7XG4gIH1cbiAgQEhvc3RCaW5kaW5nKCdpZCcpXG4gIHB1YmxpYyBnZXQgaWQoKTogc3RyaW5nIHtcbiAgICByZXR1cm4gdGhpcy5vcHRpb25JZDtcbiAgfVxuICAvKipcbiAgICogVGhlIG9wdGlvbklkIG11c3QgYmUgc2V0IHRvIGEgdW5pcXVlIHZhbHVlLiBJdCdzIHVzZWQgYXMgdmFsdWUgZm9yIHRoZSBpZCBwcm9wZXJ0eSBvZiBhbiBvcHRpb24uXG4gICAqIEFzIHRoZSB1c2VyIG5hdmlnYXRlcyB0aHJvdWdoIHRoZSBsaXN0IHZpYSBhcnJvdyBrZXlzLCB0aGUgYXJpYS1hY3RpdmVkZXNjZW5kYW50IHByb3BlcnR5IGZvciB0aGVcbiAgICogYnV0dG9uIGluIHRoZSBQaWNrZXJDb21wb25lbnQgaXMgYWRqdXN0ZWQgdG8gcmVmbGVjdCB0aGUgaWQgYXR0cmlidXRlIG9mIHRoZSBhY3RpdmUgb3B0aW9uLlxuICAgKi9cbiAgQElucHV0KCkgb3B0aW9uSWQhOiBzdHJpbmc7XG4gIEBJbnB1dCgpIGFyaWFMYWJlbD86IHN0cmluZztcbiAgQElucHV0KCkgdmFsdWUhOiBhbnk7XG4gIEBIb3N0QmluZGluZygnY2xhc3Muc2VsZWN0ZWQnKSBASW5wdXQoKSBzZWxlY3RlZCA9IGZhbHNlO1xuICBASG9zdEJpbmRpbmcoJ2NsYXNzLmNsZWFyT3B0aW9uJykgQElucHV0KCkgaXNDbGVhck9wdGlvbiA9IGZhbHNlO1xuICAvKipcbiAgICogRW1pdHMgdGhlIHZhbHVlLlxuICAgKi9cbiAgQE91dHB1dCgpIHNlbGVjdCA9IG5ldyBFdmVudEVtaXR0ZXI8YW55PigpO1xuICAvKipcbiAgICogVGhpcyBwcm9wZXJ0eSBpcyB0cnVlLCB3aGVuIHRoZSBvcHRpb24gd2FzIHNlbGVjdGVkIGJ5IG1vdXNlIGNsaWNrIG9yIGJ5IHRoZVxuICAgKiBBY3RpdmVEZXNjZW5kYW50S2V5TWFuYWdlciBjYWxsaW5nIHNldEFjdGl2ZVN0eWxlcygpLlxuICAgKiBJdCdzIGZhbHNlIHdoZW4gdGhlIEFjdGl2ZURlc2NlbmRhbnRLZXlNYW5hZ2VyIGNhbGxzIHNldEluYWN0aXZlU3R5bGVzKCkuXG4gICAqIElzIHVzZWQgYnkgdGhlIFBpY2tlckNvbXBvbmVudCB0byBmaW5kIHRoZSBjdXJyZW50IGFjdGl2ZSBvcHRpb24uXG4gICAqL1xuICBASG9zdEJpbmRpbmcoJ2NsYXNzLmhpZ2hsaWdodGVkJylcbiAgZ2V0IGhpZ2hsaWdodGVkKCkge1xuICAgIHJldHVybiB0aGlzLl9oaWdobGlnaHRlZDtcbiAgfVxuICBzZXQgaGlnaGxpZ2h0ZWQodmFsdWU6IGJvb2xlYW4pIHtcbiAgICB0aGlzLl9oaWdobGlnaHRlZCA9IHZhbHVlO1xuICAgIHRoaXMuY2RSZWYubWFya0ZvckNoZWNrKCk7XG4gIH1cbiAgcHJpdmF0ZSBfaGlnaGxpZ2h0ZWQgPSBmYWxzZTtcblxuICBjb25zdHJ1Y3Rvcihwcml2YXRlIGNkUmVmOiBDaGFuZ2VEZXRlY3RvclJlZiwgcHJpdmF0ZSB0cmFuc2xhdGVTZXJ2aWNlOiBUcmFuc2xhdGVTZXJ2aWNlKSB7fVxuXG4gIG5nT25Jbml0KCkge1xuICAgIGlmICh0aGlzLnNlbGVjdGVkKSB7XG4gICAgICB0aGlzLmFyaWFTZWxlY3RlZCA9IHRydWU7XG4gICAgfVxuICB9XG5cbiAgQEhvc3RMaXN0ZW5lcignY2xpY2snKVxuICBtYW5hZ2VDbGlja0V2ZW50cygpIHtcbiAgICB0aGlzLnNlbGVjdE9wdGlvbigpO1xuICB9XG5cbiAgc2V0QWN0aXZlU3R5bGVzKCkge1xuICAgIHRoaXMuYXJpYVNlbGVjdGVkID0gdHJ1ZTtcbiAgICB0aGlzLmhpZ2hsaWdodGVkID0gdHJ1ZTtcbiAgfVxuXG4gIHNldEluYWN0aXZlU3R5bGVzKCkge1xuICAgIHRoaXMuYXJpYVNlbGVjdGVkID0gZmFsc2U7XG4gICAgdGhpcy5oaWdobGlnaHRlZCA9IGZhbHNlO1xuICB9XG5cbiAgLyoqXG4gICAqIFRyaWdnZXJzIHRoZSBFdmVudEVtaXR0ZXIgc2VsZWN0KCkgdGhhdCBzaG91bGQgZW1pdCwgd2hlbiBhbiBvcHRpb24gd2FzIHNlbGVjdGVkLlxuICAgKiBUaGlzIGZ1bmN0aW9uIGlzIHVzZWQgaW4gdGhlIFBpY2tlckNvbXBvbmVudCB3aGVuIGFuIG9wdGlvbiB3YXMgc2VsZWN0ZWQuXG4gICAqL1xuICBzZWxlY3RPcHRpb24oKSB7XG4gICAgdGhpcy5zZWxlY3QuZW1pdCh0aGlzLnZhbHVlKTtcbiAgfVxufVxuIiwiPGx4LWljb24gKm5nSWY9XCJpc0NsZWFyT3B0aW9uXCIgbmFtZT1cInNsYXNoXCIgY29sb3I9XCIjZDhkOGQ4XCI+PC9seC1pY29uPlxuPG5nLWNvbnRlbnQgKm5nSWY9XCIhaXNDbGVhck9wdGlvblwiPjwvbmctY29udGVudD5cbiJdfQ==

package/esm2020/lib/forms-ui/components/pill-item/pill-item.component.mjs

@@ -0,0 +1,33 @@
+import { Component, EventEmitter, HostBinding, Input, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class PillItemComponent {
+    constructor() {
+        this.NAME = 'PillItemComponent';
+        this.disabled = false;
+        this.remove = new EventEmitter();
+    }
+    removePill(item, isMouse = false) {
+        if (!this.disabled) {
+            this.remove.emit({ item, isMouse });
+        }
+    }
+}
+PillItemComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: PillItemComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+PillItemComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.5", type: PillItemComponent, selector: "lx-pill-item", inputs: { item: "item", label: "label", disabled: "disabled" }, outputs: { remove: "remove" }, host: { properties: { "class.disabled": "this.disabled" } }, ngImport: i0, template: "<span data-testid=\"pill-label\" class=\"pillLabel\">{{ label }}</span>\n<span *ngIf=\"!disabled\" data-testid=\"remove-pill-item\" (click)=\"removePill(item, true)\" class=\"remove far fa-times\"></span>\n", styles: [":host{margin:2px;border-radius:1px;border:solid 1px #e1e5eb;background-color:#e1e5eb;display:inline-block;padding:4px}:host:hover{background-color:#cfd5df;border:solid 1px #cfd5df;color:#526179}:host-context(.selected){background-color:#c2c9d6}.pillLabel{margin-left:4px;margin-right:4px;font-weight:400;font-style:normal;font-stretch:normal;line-height:normal;letter-spacing:normal;color:#526179;vertical-align:middle}.remove{vertical-align:middle;color:#8594ad;margin:0 4px}.remove:hover{cursor:pointer;color:#526179}\n"], directives: [{ type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: PillItemComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lx-pill-item', template: "<span data-testid=\"pill-label\" class=\"pillLabel\">{{ label }}</span>\n<span *ngIf=\"!disabled\" data-testid=\"remove-pill-item\" (click)=\"removePill(item, true)\" class=\"remove far fa-times\"></span>\n", styles: [":host{margin:2px;border-radius:1px;border:solid 1px #e1e5eb;background-color:#e1e5eb;display:inline-block;padding:4px}:host:hover{background-color:#cfd5df;border:solid 1px #cfd5df;color:#526179}:host-context(.selected){background-color:#c2c9d6}.pillLabel{margin-left:4px;margin-right:4px;font-weight:400;font-style:normal;font-stretch:normal;line-height:normal;letter-spacing:normal;color:#526179;vertical-align:middle}.remove{vertical-align:middle;color:#8594ad;margin:0 4px}.remove:hover{cursor:pointer;color:#526179}\n"] }]
+        }], propDecorators: { item: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], disabled: [{
+                type: HostBinding,
+                args: ['class.disabled']
+            }, {
+                type: Input
+            }], remove: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/forms-ui/components/pill-list/pill-list.component.mjs

@@ -0,0 +1,59 @@
+import { ChangeDetectionStrategy, Component, ContentChild, ContentChildren, EventEmitter, HostBinding, Input, Output, TemplateRef } from '@angular/core';
+import { merge } from 'rxjs';
+import { delay, startWith, switchMap, takeUntil } from 'rxjs/operators';
+import { KeyboardSelectDirective } from '../keyboard-select.directive';
+import { PillItemComponent } from '../pill-item/pill-item.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../pill-item/pill-item.component";
+import * as i2 from "@angular/common";
+import * as i3 from "../../directives/selectable-item.directive";
+export class PillListComponent extends KeyboardSelectDirective {
+    constructor() {
+        super(...arguments);
+        this.pills = [];
+        this.disabled = false;
+        this.remove = new EventEmitter();
+    }
+    ngAfterViewInit() {
+        super.ngAfterViewInit();
+        if (this.pillTemplate) {
+            const removePillEvents = this.contentItems.changes.pipe(startWith(this.contentItems), switchMap(() => merge(...this.contentItems.map((item) => item.remove))), delay(0), takeUntil(this.destroyed$));
+            removePillEvents.subscribe(this.removePill.bind(this));
+        }
+    }
+    removePill(event) {
+        this.remove.emit(event);
+    }
+    removePillViaKeyboard(pill) {
+        this.remove.emit({ item: pill, isMouse: false });
+    }
+    trackByProp(prop) {
+        return (index, pill) => (prop ? pill[prop] : index);
+    }
+}
+PillListComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: PillListComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+PillListComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.5", type: PillListComponent, selector: "lx-pill-list", inputs: { pills: "pills", labelKey: "labelKey", itemKey: "itemKey", disabled: "disabled" }, outputs: { remove: "remove" }, host: { properties: { "class.disabled": "this.disabled" } }, queries: [{ propertyName: "pillTemplate", first: true, predicate: ["pillTemplate"], descendants: true, read: TemplateRef, static: true }, { propertyName: "contentItems", predicate: PillItemComponent }], usesInheritance: true, ngImport: i0, template: "<ul class=\"pills\" #keyboardSelectContainer>\n  <li\n    *ngFor=\"let pill of pills; let index = index; trackBy: trackByProp(itemKey)\"\n    lxSelectableItem\n    [scrollInContainer]=\"keyboardSelectContainer\"\n    #item\n    (select)=\"removePillViaKeyboard(pill)\"\n    class=\"pill\"\n    [class.selected]=\"isItemSelected(item, (selectedItem$ | async)?.element)\"\n  >\n    <ng-container *ngIf=\"pillTemplate; else defaultTemplate\">\n      <ng-container *ngTemplateOutlet=\"pillTemplate; context: { $implicit: pill, index: index }\"></ng-container>\n    </ng-container>\n    <ng-template #defaultTemplate>\n      <lx-pill-item\n        [item]=\"pill\"\n        [label]=\"labelKey ? pill[labelKey] : pill\"\n        [disabled]=\"disabled\"\n        (remove)=\"removePill($event)\"\n      ></lx-pill-item>\n    </ng-template>\n  </li>\n</ul>\n", styles: [":host .pill{display:inline}:host.disabled{cursor:not-allowed}:host .pills{display:inline;margin:0!important;padding:0!important}\n"], components: [{ type: i1.PillItemComponent, selector: "lx-pill-item", inputs: ["item", "label", "disabled"], outputs: ["remove"] }], directives: [{ type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i3.SelectableItemDirective, selector: "[lxSelectableItem]", inputs: ["scrollInContainer", "lxSelectableItem"], outputs: ["select"] }, { type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i2.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }], pipes: { "async": i2.AsyncPipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: PillListComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lx-pill-list', changeDetection: ChangeDetectionStrategy.OnPush, template: "<ul class=\"pills\" #keyboardSelectContainer>\n  <li\n    *ngFor=\"let pill of pills; let index = index; trackBy: trackByProp(itemKey)\"\n    lxSelectableItem\n    [scrollInContainer]=\"keyboardSelectContainer\"\n    #item\n    (select)=\"removePillViaKeyboard(pill)\"\n    class=\"pill\"\n    [class.selected]=\"isItemSelected(item, (selectedItem$ | async)?.element)\"\n  >\n    <ng-container *ngIf=\"pillTemplate; else defaultTemplate\">\n      <ng-container *ngTemplateOutlet=\"pillTemplate; context: { $implicit: pill, index: index }\"></ng-container>\n    </ng-container>\n    <ng-template #defaultTemplate>\n      <lx-pill-item\n        [item]=\"pill\"\n        [label]=\"labelKey ? pill[labelKey] : pill\"\n        [disabled]=\"disabled\"\n        (remove)=\"removePill($event)\"\n      ></lx-pill-item>\n    </ng-template>\n  </li>\n</ul>\n", styles: [":host .pill{display:inline}:host.disabled{cursor:not-allowed}:host .pills{display:inline;margin:0!important;padding:0!important}\n"] }]
+        }], propDecorators: { pills: [{
+                type: Input
+            }], labelKey: [{
+                type: Input
+            }], itemKey: [{
+                type: Input
+            }], disabled: [{
+                type: HostBinding,
+                args: ['class.disabled']
+            }, {
+                type: Input
+            }], remove: [{
+                type: Output
+            }], pillTemplate: [{
+                type: ContentChild,
+                args: ['pillTemplate', { read: TemplateRef, static: true }]
+            }], contentItems: [{
+                type: ContentChildren,
+                args: [PillItemComponent, { emitDistinctChangesOnly: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/forms-ui/components/responsive-input/responsive-input.component.mjs

@@ -0,0 +1,97 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, forwardRef, Output, ViewChild } from '@angular/core';
+import { FormControl, NG_VALUE_ACCESSOR } from '@angular/forms';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "@angular/common";
+export class ResponsiveInputComponent {
+    constructor() {
+        this.focus = new EventEmitter();
+        this.blur = new EventEmitter();
+        this.inputWidth$ = new Subject();
+        this.inputControl = new FormControl();
+        this.destroyed$ = new Subject();
+    }
+    ngAfterViewInit() {
+        // calculate size of input dynamic
+        this.inputControl.valueChanges.pipe(takeUntil(this.destroyed$)).subscribe((value) => {
+            this.propagateChange(value);
+            try {
+                const width = this.computeSearchInputWidth(this.inputWidth.nativeElement, value) + 1 + 'px';
+                this.inputWidth$.next(width);
+            }
+            catch (_e) {
+                /* empty catch */
+            }
+        });
+    }
+    ngOnDestroy() {
+        this.destroyed$.next();
+    }
+    focusInput() {
+        this.responsiveInput.nativeElement.focus();
+    }
+    resetInput() {
+        if (this.inputControl.value?.length > 0) {
+            this.inputControl.reset('', { emitEvent: false });
+            const width = this.computeSearchInputWidth(this.inputWidth.nativeElement, ' ') + 1 + 'px';
+            this.inputWidth$.next(width);
+        }
+    }
+    /**
+     * Based on https://github.com/Semantic-Org/Semantic-UI-React/
+     * blob/25e382e40bb3102bb39944612643c0289cd1956b/src/modules/Dropdown/Dropdown.js#L1035
+     */
+    computeSearchInputWidth(sizerRef, searchQuery) {
+        if (sizerRef && searchQuery) {
+            sizerRef.style.display = 'inline-block';
+            sizerRef.textContent = searchQuery;
+            const searchWidth = Math.ceil(sizerRef.getBoundingClientRect().width);
+            sizerRef.style.removeProperty('display');
+            return searchWidth;
+        }
+        return 0;
+    }
+    //#region Angular Forms
+    propagateChange(_value) { }
+    writeValue(newValue) {
+        if (newValue) {
+            this.value = newValue;
+            this.propagateChange(this.value);
+        }
+    }
+    registerOnChange(fn) {
+        this.propagateChange = fn;
+    }
+    registerOnTouched(_fn) { }
+}
+ResponsiveInputComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: ResponsiveInputComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+ResponsiveInputComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.5", type: ResponsiveInputComponent, selector: "lx-responsive-input", outputs: { focus: "focus", blur: "blur" }, providers: [
+        {
+            provide: NG_VALUE_ACCESSOR,
+            multi: true,
+            useExisting: forwardRef(() => ResponsiveInputComponent)
+        }
+    ], viewQueries: [{ propertyName: "responsiveInput", first: true, predicate: ["responsiveInput"], descendants: true, static: true }, { propertyName: "inputWidth", first: true, predicate: ["inputWidth"], descendants: true, static: true }], ngImport: i0, template: "<span #inputWidth class=\"inputWidth\"></span>\n<input\n  type=\"text\"\n  class=\"responsiveInput\"\n  (focus)=\"focus.emit()\"\n  (blur)=\"blur.emit()\"\n  [formControl]=\"inputControl\"\n  #responsiveInput\n  [style.width]=\"inputWidth$ | async\"\n/>\n", styles: [":host{display:inline-block}.inputWidth{display:none;height:0;overflow:hidden;position:absolute;white-space:pre;max-width:100%}.responsiveInput{border:0;padding:0;height:100%;max-width:100%}.responsiveInput::-ms-clear{display:none}.responsiveInput:focus{outline:0}\n"], directives: [{ type: i1.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { type: i1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i1.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }], pipes: { "async": i2.AsyncPipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: ResponsiveInputComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lx-responsive-input', changeDetection: ChangeDetectionStrategy.OnPush, providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            multi: true,
+                            useExisting: forwardRef(() => ResponsiveInputComponent)
+                        }
+                    ], template: "<span #inputWidth class=\"inputWidth\"></span>\n<input\n  type=\"text\"\n  class=\"responsiveInput\"\n  (focus)=\"focus.emit()\"\n  (blur)=\"blur.emit()\"\n  [formControl]=\"inputControl\"\n  #responsiveInput\n  [style.width]=\"inputWidth$ | async\"\n/>\n", styles: [":host{display:inline-block}.inputWidth{display:none;height:0;overflow:hidden;position:absolute;white-space:pre;max-width:100%}.responsiveInput{border:0;padding:0;height:100%;max-width:100%}.responsiveInput::-ms-clear{display:none}.responsiveInput:focus{outline:0}\n"] }]
+        }], propDecorators: { focus: [{
+                type: Output
+            }], blur: [{
+                type: Output
+            }], responsiveInput: [{
+                type: ViewChild,
+                args: ['responsiveInput', { static: true }]
+            }], inputWidth: [{
+                type: ViewChild,
+                args: ['inputWidth', { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"responsive-input.component.js","sourceRoot":"","sources":["../../../../../../../../libs/components/src/lib/forms-ui/components/responsive-input/responsive-input.component.ts","../../../../../../../../libs/components/src/lib/forms-ui/components/responsive-input/responsive-input.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  ChangeDetectionStrategy,\n  Component,\n  ElementRef,\n  EventEmitter,\n  forwardRef,\n  OnDestroy,\n  Output,\n  ViewChild\n} from '@angular/core';\nimport { ControlValueAccessor, FormControl, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { Subject } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\n\n@Component({\n  selector: 'lx-responsive-input',\n  templateUrl: 'responsive-input.component.html',\n  styleUrls: ['responsive-input.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      multi: true,\n      useExisting: forwardRef(() => ResponsiveInputComponent)\n    }\n  ]\n})\nexport class ResponsiveInputComponent implements AfterViewInit, OnDestroy, ControlValueAccessor {\n  @Output() focus = new EventEmitter<void>();\n  @Output() blur = new EventEmitter<void>();\n  @ViewChild('responsiveInput', { static: true }) responsiveInput!: ElementRef<HTMLInputElement>;\n  @ViewChild('inputWidth', { static: true }) inputWidth!: ElementRef<HTMLSpanElement>;\n\n  readonly inputWidth$ = new Subject<string>();\n  readonly inputControl = new FormControl();\n  readonly destroyed$ = new Subject<void>();\n\n  value: any;\n\n  ngAfterViewInit() {\n    // calculate size of input dynamic\n    this.inputControl.valueChanges.pipe(takeUntil(this.destroyed$)).subscribe((value) => {\n      this.propagateChange(value);\n      try {\n        const width = this.computeSearchInputWidth(this.inputWidth.nativeElement, value) + 1 + 'px';\n        this.inputWidth$.next(width);\n      } catch (_e) {\n        /* empty catch */\n      }\n    });\n  }\n\n  ngOnDestroy() {\n    this.destroyed$.next();\n  }\n\n  public focusInput() {\n    this.responsiveInput.nativeElement.focus();\n  }\n\n  resetInput() {\n    if (this.inputControl.value?.length > 0) {\n      this.inputControl.reset('', { emitEvent: false });\n      const width = this.computeSearchInputWidth(this.inputWidth.nativeElement, ' ') + 1 + 'px';\n      this.inputWidth$.next(width);\n    }\n  }\n\n  /**\n   * Based on https://github.com/Semantic-Org/Semantic-UI-React/\n   * blob/25e382e40bb3102bb39944612643c0289cd1956b/src/modules/Dropdown/Dropdown.js#L1035\n   */\n  private computeSearchInputWidth(sizerRef: HTMLSpanElement, searchQuery: string): number {\n    if (sizerRef && searchQuery) {\n      sizerRef.style.display = 'inline-block';\n      sizerRef.textContent = searchQuery;\n      const searchWidth = Math.ceil(sizerRef.getBoundingClientRect().width);\n      sizerRef.style.removeProperty('display');\n      return searchWidth;\n    }\n    return 0;\n  }\n\n  //#region Angular Forms\n  propagateChange(_value: any) {}\n\n  writeValue(newValue: any) {\n    if (newValue) {\n      this.value = newValue;\n      this.propagateChange(this.value);\n    }\n  }\n\n  registerOnChange(fn: any) {\n    this.propagateChange = fn;\n  }\n\n  registerOnTouched(_fn: any) {}\n  //#endregion\n}\n","<span #inputWidth class=\"inputWidth\"></span>\n<input\n  type=\"text\"\n  class=\"responsiveInput\"\n  (focus)=\"focus.emit()\"\n  (blur)=\"blur.emit()\"\n  [formControl]=\"inputControl\"\n  #responsiveInput\n  [style.width]=\"inputWidth$ | async\"\n/>\n"]}