@leanix/components 0.2.227 → 0.2.230

package/esm2020/lib/forms-ui/components/drag-and-drop-list/drag-and-drop-list.component.mjs

@@ -0,0 +1,102 @@
+import { moveItemInArray } from '@angular/cdk/drag-drop';
+import { Component, ContentChildren, EventEmitter, HostBinding, Input, Output, ViewChildren } from '@angular/core';
+import { map, startWith } from 'rxjs/operators';
+import { DRAG_AND_DROP_LIST_TRANSLATION_NAME } from './constants';
+import { DragAndDropListItemComponent } from './drag-and-drop-list-item/drag-and-drop-list-item.component';
+import { KeyboardSortableItemDirective } from './keyboard-sortable-item/keyboard-sortable-item.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "./drag-and-drop-list-item/drag-and-drop-list-item.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/cdk/drag-drop";
+import * as i4 from "./keyboard-sortable-list/keyboard-sortable-list.directive";
+import * as i5 from "./keyboard-sortable-item/keyboard-sortable-item.directive";
+import * as i6 from "@ngx-translate/core";
+export class DragAndDropListComponent {
+    constructor() {
+        this.NAME = DRAG_AND_DROP_LIST_TRANSLATION_NAME;
+        /**
+         * Override the global label font weight of 700
+         */
+        this.labelFontWeight = 700;
+        this.color = 'light';
+        this.fontSize = 'normal';
+        /**
+         * Use the moveToIndex Output in favor of moveItem,
+         * when moving is restricted to one item through this.draggableItem.
+         */
+        this.moveToIndex = new EventEmitter();
+        this.moveItem = new EventEmitter();
+        /**
+         * TODO: extract state about keyboard sorting into KeyboardSortableListDirective
+         */
+        this.isSortingByKeyboard = false;
+        this.keyboardItemBeingSorted = undefined;
+        this.allItemsData = [];
+    }
+    ngAfterContentInit() {
+        this.items$ = this._items.changes.pipe(startWith(this._items), map((items) => items.toArray()));
+        this.allItemsData$ = this.items$.pipe(map((itemComponents) => itemComponents.map((itemComponent) => itemComponent.item)));
+    }
+    ngAfterViewInit() {
+        this.keyboardSortableItems$ = this._keyboardSortableItems.changes.pipe(startWith(this._keyboardSortableItems), map((items) => items.toArray()));
+    }
+    emitContentChildAction(action) {
+        this._items.find((itemComponent) => itemComponent.item === action.item)?.action.emit(action);
+    }
+    /**
+     * From the Angular cdk drag and drop documentation:
+     * Note that this will not update your data model;
+     * you can listen to the cdkDropListDropped event to update the data model
+     * once the user finishes dragging.
+     * https://material.angular.io/cdk/drag-drop/overview
+     *
+     * You're supposed to update the data in the parent and pass the new items as input.
+     */
+    drop(event) {
+        this.sortItems(event.container.data, event.item.data, event.previousIndex, event.currentIndex);
+    }
+    dropToIndexAfterArrowKey(item, previousIndex, currentIndex) {
+        if (this.isSortingByKeyboard) {
+            this.sortItems(this._items, item, previousIndex, currentIndex);
+        }
+    }
+    sortItems(items, item, previousIndex, currentIndex) {
+        moveItemInArray(items, previousIndex, currentIndex);
+        this.moveToIndex.emit({ index: currentIndex, previous: previousIndex });
+        this.moveItem.emit({ item, index: currentIndex });
+    }
+    trackByItem(_index, item) {
+        return item.item;
+    }
+}
+DragAndDropListComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: DragAndDropListComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+DragAndDropListComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.5", type: DragAndDropListComponent, selector: "lx-drag-and-drop-list", inputs: { label: "label", labelFontWeight: "labelFontWeight", color: "color", fontSize: "fontSize" }, outputs: { moveToIndex: "moveToIndex", moveItem: "moveItem" }, host: { properties: { "attr.color": "this.color", "attr.fontSize": "this.fontSize" } }, queries: [{ propertyName: "_items", predicate: DragAndDropListItemComponent }], viewQueries: [{ propertyName: "_keyboardSortableItems", predicate: KeyboardSortableItemDirective, descendants: true }], ngImport: i0, template: "<label *ngIf=\"label\" [style.font-weight]=\"labelFontWeight\">{{ label }}</label>\n<p class=\"sr-only\">{{ NAME + '.helpTooltip' | translate }}</p>\n<ul\n  cdkDropList\n  class=\"list\"\n  role=\"listbox\"\n  lxKeyboardSortableList\n  [keyboardSortableItems]=\"keyboardSortableItems$ | async\"\n  [cdkDropListData]=\"items$ | async\"\n  (cdkDropListDropped)=\"drop($event)\"\n>\n  <li\n    *ngFor=\"let itemComponent of items$ | async; trackBy: trackByItem\"\n    #listItemParent\n    class=\"item\"\n    cdkDrag\n    cdkDragLockAxis=\"y\"\n    [cdkDragData]=\"itemComponent.item\"\n    [cdkDragDisabled]=\"!itemComponent.draggable\"\n    [class.dark]=\"color === 'dark'\"\n    [class.big]=\"fontSize === 'big'\"\n    [tabIndex]=\"itemComponent.draggable === false ? -1 : 0\"\n    [lxKeyboardSortableItem]=\"allItemsData$ | async\"\n    [lxKeyboardItemData]=\"itemComponent.item\"\n    [(isSortingByKeyboard)]=\"isSortingByKeyboard\"\n    [(lxKeyboardItemBeingSorted)]=\"keyboardItemBeingSorted\"\n    (sortItemsWithKeyboard)=\"dropToIndexAfterArrowKey(itemComponent.item, $event.previousIndex, $event.currentIndex)\"\n  >\n    <lx-drag-and-drop-list-item\n      class=\"dragAndDropItem\"\n      [item]=\"itemComponent.item\"\n      [draggable]=\"itemComponent.draggable\"\n      [actions]=\"itemComponent.actions\"\n      (action)=\"emitContentChildAction($event)\"\n    >\n      <ng-template *ngIf=\"itemComponent.customTemplateRef\" #customTemplate>\n        <ng-container *ngTemplateOutlet=\"itemComponent.customTemplateRef\"></ng-container>\n      </ng-template>\n    </lx-drag-and-drop-list-item>\n  </li>\n</ul>\n", styles: ["@keyframes subtleScaleUpKeyFrames{0%{transform:scale(.95);opacity:0}}:host{display:block}.list{list-style-type:none;width:100%;display:block;padding:0;color:#526179}.item.cdk-drag-disabled{background:#eaedf1;cursor:default}.item{position:relative;cursor:move;border:solid 1px #99a5bb;margin-bottom:4px;border-radius:3px}.item:focus{outline:1px auto #1666ee}.cdk-drag-preview{box-sizing:border-box;border-radius:3px;list-style:none;border:solid 1px #99a5bb!important;box-shadow:0 3px 4px #7474744d}.cdk-drag-placeholder{opacity:.5}.cdk-drag-placeholder i{opacity:0}.cdk-drag-animating{transition:transform .18s;transition-delay:0s;transition-timing-function:ease}.list.cdk-drop-list-dragging .item:not(.cdk-drag-placeholder){transition:transform .18s;transition-delay:0s;transition-timing-function:ease}:host[color=dark] lx-drag-and-drop-list-item{background-color:#f0f2f5;color:#526179;border-radius:3px}:host[color=dark] .list,:host[color=dark] .item{border:0}:host[color=dark] .item.cdk-drag-disabled lx-drag-and-drop-list-item{background:#fff;color:#99a5bb;border:1px solid #99a5bb}:host[fontSize=big] .item{text-transform:uppercase;font-weight:700}.cdk-drag-preview.dark{border:0!important}.cdk-drag-preview.dark lx-drag-and-drop-list-item{background-color:#f0f2f5;color:#526179;border-radius:3px}.cdk-drag-preview.big{text-transform:uppercase;font-weight:700}.isBeingSortedByKeyboard{box-shadow:0 6px 24px #b2bccc;z-index:1}\n"], components: [{ type: i1.DragAndDropListItemComponent, selector: "lx-drag-and-drop-list-item", inputs: ["item", "draggable", "actions"], outputs: ["action"] }], directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i3.CdkDropList, selector: "[cdkDropList], cdk-drop-list", inputs: ["cdkDropListConnectedTo", "cdkDropListData", "cdkDropListOrientation", "id", "cdkDropListLockAxis", "cdkDropListDisabled", "cdkDropListSortingDisabled", "cdkDropListEnterPredicate", "cdkDropListSortPredicate", "cdkDropListAutoScrollDisabled", "cdkDropListAutoScrollStep"], outputs: ["cdkDropListDropped", "cdkDropListEntered", "cdkDropListExited", "cdkDropListSorted"], exportAs: ["cdkDropList"] }, { type: i4.KeyboardSortableListDirective, selector: "[lxKeyboardSortableList]", inputs: ["keyboardSortableItems"] }, { type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i3.CdkDrag, selector: "[cdkDrag]", inputs: ["cdkDragData", "cdkDragLockAxis", "cdkDragRootElement", "cdkDragBoundary", "cdkDragStartDelay", "cdkDragFreeDragPosition", "cdkDragDisabled", "cdkDragConstrainPosition", "cdkDragPreviewClass", "cdkDragPreviewContainer"], outputs: ["cdkDragStarted", "cdkDragReleased", "cdkDragEnded", "cdkDragEntered", "cdkDragExited", "cdkDragDropped", "cdkDragMoved"], exportAs: ["cdkDrag"] }, { type: i5.KeyboardSortableItemDirective, selector: "[lxKeyboardSortableItem]", inputs: ["lxKeyboardSortableItem", "lxKeyboardItemData", "isSortingByKeyboard", "lxKeyboardItemBeingSorted"], outputs: ["isSortingByKeyboardChange", "lxKeyboardItemBeingSortedChange", "sortItemsWithKeyboard", "focusWithKeyboard"] }, { type: i2.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }], pipes: { "translate": i6.TranslatePipe, "async": i2.AsyncPipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: DragAndDropListComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lx-drag-and-drop-list', template: "<label *ngIf=\"label\" [style.font-weight]=\"labelFontWeight\">{{ label }}</label>\n<p class=\"sr-only\">{{ NAME + '.helpTooltip' | translate }}</p>\n<ul\n  cdkDropList\n  class=\"list\"\n  role=\"listbox\"\n  lxKeyboardSortableList\n  [keyboardSortableItems]=\"keyboardSortableItems$ | async\"\n  [cdkDropListData]=\"items$ | async\"\n  (cdkDropListDropped)=\"drop($event)\"\n>\n  <li\n    *ngFor=\"let itemComponent of items$ | async; trackBy: trackByItem\"\n    #listItemParent\n    class=\"item\"\n    cdkDrag\n    cdkDragLockAxis=\"y\"\n    [cdkDragData]=\"itemComponent.item\"\n    [cdkDragDisabled]=\"!itemComponent.draggable\"\n    [class.dark]=\"color === 'dark'\"\n    [class.big]=\"fontSize === 'big'\"\n    [tabIndex]=\"itemComponent.draggable === false ? -1 : 0\"\n    [lxKeyboardSortableItem]=\"allItemsData$ | async\"\n    [lxKeyboardItemData]=\"itemComponent.item\"\n    [(isSortingByKeyboard)]=\"isSortingByKeyboard\"\n    [(lxKeyboardItemBeingSorted)]=\"keyboardItemBeingSorted\"\n    (sortItemsWithKeyboard)=\"dropToIndexAfterArrowKey(itemComponent.item, $event.previousIndex, $event.currentIndex)\"\n  >\n    <lx-drag-and-drop-list-item\n      class=\"dragAndDropItem\"\n      [item]=\"itemComponent.item\"\n      [draggable]=\"itemComponent.draggable\"\n      [actions]=\"itemComponent.actions\"\n      (action)=\"emitContentChildAction($event)\"\n    >\n      <ng-template *ngIf=\"itemComponent.customTemplateRef\" #customTemplate>\n        <ng-container *ngTemplateOutlet=\"itemComponent.customTemplateRef\"></ng-container>\n      </ng-template>\n    </lx-drag-and-drop-list-item>\n  </li>\n</ul>\n", styles: ["@keyframes subtleScaleUpKeyFrames{0%{transform:scale(.95);opacity:0}}:host{display:block}.list{list-style-type:none;width:100%;display:block;padding:0;color:#526179}.item.cdk-drag-disabled{background:#eaedf1;cursor:default}.item{position:relative;cursor:move;border:solid 1px #99a5bb;margin-bottom:4px;border-radius:3px}.item:focus{outline:1px auto #1666ee}.cdk-drag-preview{box-sizing:border-box;border-radius:3px;list-style:none;border:solid 1px #99a5bb!important;box-shadow:0 3px 4px #7474744d}.cdk-drag-placeholder{opacity:.5}.cdk-drag-placeholder i{opacity:0}.cdk-drag-animating{transition:transform .18s;transition-delay:0s;transition-timing-function:ease}.list.cdk-drop-list-dragging .item:not(.cdk-drag-placeholder){transition:transform .18s;transition-delay:0s;transition-timing-function:ease}:host[color=dark] lx-drag-and-drop-list-item{background-color:#f0f2f5;color:#526179;border-radius:3px}:host[color=dark] .list,:host[color=dark] .item{border:0}:host[color=dark] .item.cdk-drag-disabled lx-drag-and-drop-list-item{background:#fff;color:#99a5bb;border:1px solid #99a5bb}:host[fontSize=big] .item{text-transform:uppercase;font-weight:700}.cdk-drag-preview.dark{border:0!important}.cdk-drag-preview.dark lx-drag-and-drop-list-item{background-color:#f0f2f5;color:#526179;border-radius:3px}.cdk-drag-preview.big{text-transform:uppercase;font-weight:700}.isBeingSortedByKeyboard{box-shadow:0 6px 24px #b2bccc;z-index:1}\n"] }]
+        }], propDecorators: { label: [{
+                type: Input
+            }], labelFontWeight: [{
+                type: Input
+            }], color: [{
+                type: Input
+            }, {
+                type: HostBinding,
+                args: ['attr.color']
+            }], fontSize: [{
+                type: Input
+            }, {
+                type: HostBinding,
+                args: ['attr.fontSize']
+            }], moveToIndex: [{
+                type: Output
+            }], moveItem: [{
+                type: Output
+            }], _items: [{
+                type: ContentChildren,
+                args: [DragAndDropListItemComponent]
+            }], _keyboardSortableItems: [{
+                type: ViewChildren,
+                args: [KeyboardSortableItemDirective]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drag-and-drop-list.component.js","sourceRoot":"","sources":["../../../../../../../../libs/components/src/lib/forms-ui/components/drag-and-drop-list/drag-and-drop-list.component.ts","../../../../../../../../libs/components/src/lib/forms-ui/components/drag-and-drop-list/drag-and-drop-list.component.html"],"names":[],"mappings":"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","sourcesContent":["import { CdkDragDrop, moveItemInArray } from '@angular/cdk/drag-drop';\nimport {\n  AfterContentInit,\n  AfterViewInit,\n  Component,\n  ContentChildren,\n  EventEmitter,\n  HostBinding,\n  Input,\n  Output,\n  QueryList,\n  ViewChildren\n} from '@angular/core';\nimport { Observable } from 'rxjs';\nimport { map, startWith } from 'rxjs/operators';\nimport { DRAG_AND_DROP_LIST_TRANSLATION_NAME } from './constants';\nimport { DragAndDropListActionEvent, DragAndDropListItemComponent } from './drag-and-drop-list-item/drag-and-drop-list-item.component';\nimport { KeyboardSortableItemDirective } from './keyboard-sortable-item/keyboard-sortable-item.directive';\n\nexport interface DragAndDropListMoveEvent {\n  item: string;\n  index: number;\n}\n\nexport interface DragAndDropListMoveIndexEvent {\n  index: number;\n  previous: number;\n}\n\n@Component({\n  selector: 'lx-drag-and-drop-list',\n  templateUrl: 'drag-and-drop-list.component.html',\n  styleUrls: ['drag-and-drop-list.component.scss']\n})\nexport class DragAndDropListComponent implements AfterContentInit, AfterViewInit {\n  readonly NAME = DRAG_AND_DROP_LIST_TRANSLATION_NAME;\n\n  items$!: Observable<DragAndDropListItemComponent[]>;\n  keyboardSortableItems$!: Observable<KeyboardSortableItemDirective[]>;\n\n  /**\n   * A label for describing this list.\n   */\n  @Input() label?: string | undefined;\n  /**\n   * Override the global label font weight of 700\n   */\n  @Input() labelFontWeight?: number = 700;\n\n  @Input() @HostBinding('attr.color') color?: 'light' | 'dark' = 'light';\n  @Input() @HostBinding('attr.fontSize') fontSize?: 'normal' | 'big' = 'normal';\n\n  /**\n   * Use the moveToIndex Output in favor of moveItem,\n   * when moving is restricted to one item through this.draggableItem.\n   */\n  @Output() moveToIndex = new EventEmitter<DragAndDropListMoveIndexEvent>();\n  @Output() moveItem = new EventEmitter<DragAndDropListMoveEvent>();\n\n  @ContentChildren(DragAndDropListItemComponent) private _items!: QueryList<DragAndDropListItemComponent>;\n\n  @ViewChildren(KeyboardSortableItemDirective)\n  private _keyboardSortableItems!: QueryList<KeyboardSortableItemDirective>;\n\n  /**\n   * TODO: extract state about keyboard sorting into KeyboardSortableListDirective\n   */\n  isSortingByKeyboard: boolean = false;\n  keyboardItemBeingSorted: string | undefined = undefined;\n\n  allItemsData: string[] = [];\n  allItemsData$!: Observable<string[]>;\n\n  ngAfterContentInit() {\n    this.items$ = this._items.changes.pipe(\n      startWith(this._items),\n      map((items: QueryList<DragAndDropListItemComponent>) => items.toArray())\n    );\n    this.allItemsData$ = this.items$.pipe(map((itemComponents) => itemComponents.map((itemComponent) => itemComponent.item)));\n  }\n\n  ngAfterViewInit(): void {\n    this.keyboardSortableItems$ = this._keyboardSortableItems.changes.pipe(\n      startWith(this._keyboardSortableItems),\n      map((items: QueryList<KeyboardSortableItemDirective>) => items.toArray())\n    );\n  }\n\n  emitContentChildAction(action: DragAndDropListActionEvent) {\n    this._items.find((itemComponent) => itemComponent.item === action.item)?.action.emit(action);\n  }\n\n  /**\n   * From the Angular cdk drag and drop documentation:\n   * Note that this will not update your data model;\n   * you can listen to the cdkDropListDropped event to update the data model\n   * once the user finishes dragging.\n   * https://material.angular.io/cdk/drag-drop/overview\n   *\n   * You're supposed to update the data in the parent and pass the new items as input.\n   */\n  drop(event: CdkDragDrop<DragAndDropListItemComponent[] | null, string[]>) {\n    this.sortItems(event.container.data!, event.item.data, event.previousIndex, event.currentIndex);\n  }\n\n  dropToIndexAfterArrowKey(item: any, previousIndex: number, currentIndex: number) {\n    if (this.isSortingByKeyboard) {\n      this.sortItems(this._items, item, previousIndex, currentIndex);\n    }\n  }\n\n  private sortItems(items: any, item: string, previousIndex: number, currentIndex: number): void {\n    moveItemInArray(items, previousIndex, currentIndex);\n    this.moveToIndex.emit({ index: currentIndex, previous: previousIndex });\n    this.moveItem.emit({ item, index: currentIndex });\n  }\n\n  trackByItem(_index: number, item: DragAndDropListItemComponent) {\n    return item.item;\n  }\n}\n","<label *ngIf=\"label\" [style.font-weight]=\"labelFontWeight\">{{ label }}</label>\n<p class=\"sr-only\">{{ NAME + '.helpTooltip' | translate }}</p>\n<ul\n  cdkDropList\n  class=\"list\"\n  role=\"listbox\"\n  lxKeyboardSortableList\n  [keyboardSortableItems]=\"keyboardSortableItems$ | async\"\n  [cdkDropListData]=\"items$ | async\"\n  (cdkDropListDropped)=\"drop($event)\"\n>\n  <li\n    *ngFor=\"let itemComponent of items$ | async; trackBy: trackByItem\"\n    #listItemParent\n    class=\"item\"\n    cdkDrag\n    cdkDragLockAxis=\"y\"\n    [cdkDragData]=\"itemComponent.item\"\n    [cdkDragDisabled]=\"!itemComponent.draggable\"\n    [class.dark]=\"color === 'dark'\"\n    [class.big]=\"fontSize === 'big'\"\n    [tabIndex]=\"itemComponent.draggable === false ? -1 : 0\"\n    [lxKeyboardSortableItem]=\"allItemsData$ | async\"\n    [lxKeyboardItemData]=\"itemComponent.item\"\n    [(isSortingByKeyboard)]=\"isSortingByKeyboard\"\n    [(lxKeyboardItemBeingSorted)]=\"keyboardItemBeingSorted\"\n    (sortItemsWithKeyboard)=\"dropToIndexAfterArrowKey(itemComponent.item, $event.previousIndex, $event.currentIndex)\"\n  >\n    <lx-drag-and-drop-list-item\n      class=\"dragAndDropItem\"\n      [item]=\"itemComponent.item\"\n      [draggable]=\"itemComponent.draggable\"\n      [actions]=\"itemComponent.actions\"\n      (action)=\"emitContentChildAction($event)\"\n    >\n      <ng-template *ngIf=\"itemComponent.customTemplateRef\" #customTemplate>\n        <ng-container *ngTemplateOutlet=\"itemComponent.customTemplateRef\"></ng-container>\n      </ng-template>\n    </lx-drag-and-drop-list-item>\n  </li>\n</ul>\n"]}

package/esm2020/lib/forms-ui/components/drag-and-drop-list/drag-and-drop-list.module.mjs

@@ -0,0 +1,25 @@
+import { DragDropModule } from '@angular/cdk/drag-drop';
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { TranslateModule } from '@ngx-translate/core';
+import { LxCoreUiModule } from '../../../core-ui/core-ui.module';
+import { DragAndDropListItemComponent } from './drag-and-drop-list-item/drag-and-drop-list-item.component';
+import { DragAndDropListComponent } from './drag-and-drop-list.component';
+import { KeyboardSortableItemDirective } from './keyboard-sortable-item/keyboard-sortable-item.directive';
+import { KeyboardSortableListDirective } from './keyboard-sortable-list/keyboard-sortable-list.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+export class LxDragAndDropListModule {
+}
+LxDragAndDropListModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: LxDragAndDropListModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+LxDragAndDropListModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: LxDragAndDropListModule, declarations: [KeyboardSortableItemDirective, KeyboardSortableListDirective, DragAndDropListComponent, DragAndDropListItemComponent], imports: [CommonModule, DragDropModule, LxCoreUiModule, i1.TranslateModule], exports: [DragAndDropListComponent, DragAndDropListItemComponent] });
+LxDragAndDropListModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: LxDragAndDropListModule, imports: [[CommonModule, DragDropModule, LxCoreUiModule, TranslateModule.forChild()]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: LxDragAndDropListModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [KeyboardSortableItemDirective, KeyboardSortableListDirective, DragAndDropListComponent, DragAndDropListItemComponent],
+                    imports: [CommonModule, DragDropModule, LxCoreUiModule, TranslateModule.forChild()],
+                    exports: [DragAndDropListComponent, DragAndDropListItemComponent]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/forms-ui/components/drag-and-drop-list/keyboard-sortable-item/keyboard-sortable-item.directive.mjs

@@ -0,0 +1,133 @@
+import { Directive, EventEmitter, HostBinding, HostListener, Input, Output } from '@angular/core';
+import { ReplaySubject } from 'rxjs';
+import { TooltipDirective } from '../../../../core-ui/tooltip/tooltip.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/drag-drop";
+import * as i2 from "@angular/cdk/overlay";
+export class KeyboardSortableItemDirective {
+    constructor(draggableItem, overlayPositionBuilder, element, overlay) {
+        this.draggableItem = draggableItem;
+        this.overlayPositionBuilder = overlayPositionBuilder;
+        this.element = element;
+        this.overlay = overlay;
+        this.isSortingByKeyboardChange = new EventEmitter();
+        this.itemBeingSortedChange = new EventEmitter();
+        this.sortItemsWithKeyboard = new EventEmitter();
+        this.tooltipDirective = new TooltipDirective(this.overlayPositionBuilder, this.element, this.overlay);
+        this.isBeingSorted = false;
+        this.preventBlur = false;
+        this.focusWithKeyboardReplaySubject$ = new ReplaySubject(1);
+        /**
+         * Using a ReplaySubject here so that the KeyboardSortableListDirective will also know
+         * about a focusWithKeyboard event when its copy of the KeyboardSortableItemDirective ContentChildren
+         * was just initialised after the event fired.
+         */
+        this.focusWithKeyboard = this.focusWithKeyboardReplaySubject$.asObservable();
+    }
+    get isSortable() {
+        return !this.draggableItem.disabled;
+    }
+    ngOnChanges() {
+        this.isBeingSorted = this.itemData === this.itemBeingSorted;
+        if (this.isBeingSorted) {
+            // focus always the pressed element
+            this.element.nativeElement.focus();
+        }
+    }
+    focusViaKeyboard() {
+        this.focusWithKeyboardReplaySubject$.next(this);
+    }
+    enterSortingModeEnabledByKeyboard($event) {
+        if ($event.target === this.element.nativeElement) {
+            if ($event.code === 'Enter' || $event.code === 'Space') {
+                $event.preventDefault();
+                this.tooltipDirective.hide();
+                this.itemBeingSortedChange.emit(!this.isSortingByKeyboard ? this.itemData : undefined);
+                this.isSortingByKeyboardChange.emit(!this.isSortingByKeyboard);
+            }
+        }
+    }
+    leaveSortingModeEnabledByKeyboard($event) {
+        if ($event.target === this.element.nativeElement) {
+            this.tooltipDirective.hide();
+            if (!this.preventBlur) {
+                this.isSortingByKeyboardChange.emit(false);
+                this.itemBeingSortedChange.emit(undefined);
+            }
+        }
+    }
+    sort($event) {
+        if ($event.target === this.element.nativeElement) {
+            this.tooltipDirective.hide();
+            if (this.isSortingByKeyboard) {
+                $event.preventDefault();
+                const previousIndex = this.allItemsData.findIndex((item) => item === this.itemData);
+                const currentIndex = $event.code === 'ArrowUp' ? previousIndex - 1 : previousIndex + 1;
+                if (currentIndex >= 0 && currentIndex <= this.allItemsData.length - 1) {
+                    this.sortItemsWithKeyboard.emit({ previousIndex, currentIndex });
+                    // When triggering a keyboard event, the DOM would "removeChildren" on the HTML element
+                    // which specially for "ArrowUp" events would trigger a "blur" event since the element
+                    // has been moved aboved the DOM tree and loses the focus state.
+                    this.preventBlur = true;
+                    setTimeout(() => (this.preventBlur = false), 0);
+                }
+            }
+        }
+    }
+}
+KeyboardSortableItemDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: KeyboardSortableItemDirective, deps: [{ token: i1.CdkDrag }, { token: i2.OverlayPositionBuilder }, { token: i0.ElementRef }, { token: i2.Overlay }], target: i0.ɵɵFactoryTarget.Directive });
+KeyboardSortableItemDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.5", type: KeyboardSortableItemDirective, selector: "[lxKeyboardSortableItem]", inputs: { allItemsData: ["lxKeyboardSortableItem", "allItemsData"], itemData: ["lxKeyboardItemData", "itemData"], isSortingByKeyboard: "isSortingByKeyboard", itemBeingSorted: ["lxKeyboardItemBeingSorted", "itemBeingSorted"] }, outputs: { isSortingByKeyboardChange: "isSortingByKeyboardChange", itemBeingSortedChange: "lxKeyboardItemBeingSortedChange", sortItemsWithKeyboard: "sortItemsWithKeyboard", focusWithKeyboard: "focusWithKeyboard" }, host: { listeners: { "keyup.tab": "focusViaKeyboard()", "keydown.enter": "enterSortingModeEnabledByKeyboard($event)", "keydown.space": "enterSortingModeEnabledByKeyboard($event)", "blur": "leaveSortingModeEnabledByKeyboard($event)", "keydown.esc": "leaveSortingModeEnabledByKeyboard($event)", "keydown.arrowUp": "sort($event)", "keydown.arrowDown": "sort($event)" }, properties: { "attr.lxTooltip": "this.tooltipDirective", "class.isBeingSortedByKeyboard": "this.isBeingSorted" } }, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: KeyboardSortableItemDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[lxKeyboardSortableItem]'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.CdkDrag }, { type: i2.OverlayPositionBuilder }, { type: i0.ElementRef }, { type: i2.Overlay }]; }, propDecorators: { allItemsData: [{
+                type: Input,
+                args: ['lxKeyboardSortableItem']
+            }], itemData: [{
+                type: Input,
+                args: ['lxKeyboardItemData']
+            }], isSortingByKeyboard: [{
+                type: Input
+            }], itemBeingSorted: [{
+                type: Input,
+                args: ['lxKeyboardItemBeingSorted']
+            }], isSortingByKeyboardChange: [{
+                type: Output
+            }], itemBeingSortedChange: [{
+                type: Output,
+                args: ['lxKeyboardItemBeingSortedChange']
+            }], sortItemsWithKeyboard: [{
+                type: Output
+            }], focusWithKeyboard: [{
+                type: Output
+            }], tooltipDirective: [{
+                type: HostBinding,
+                args: ['attr.lxTooltip']
+            }], isBeingSorted: [{
+                type: HostBinding,
+                args: ['class.isBeingSortedByKeyboard']
+            }], focusViaKeyboard: [{
+                type: HostListener,
+                args: ['keyup.tab']
+            }], enterSortingModeEnabledByKeyboard: [{
+                type: HostListener,
+                args: ['keydown.enter', ['$event']]
+            }, {
+                type: HostListener,
+                args: ['keydown.space', ['$event']]
+            }], leaveSortingModeEnabledByKeyboard: [{
+                type: HostListener,
+                args: ['blur', ['$event']]
+            }, {
+                type: HostListener,
+                args: ['keydown.esc', ['$event']]
+            }], sort: [{
+                type: HostListener,
+                args: ['keydown.arrowUp', ['$event']]
+            }, {
+                type: HostListener,
+                args: ['keydown.arrowDown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"keyboard-sortable-item.directive.js","sourceRoot":"","sources":["../../../../../../../../../libs/components/src/lib/forms-ui/components/drag-and-drop-list/keyboard-sortable-item/keyboard-sortable-item.directive.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @angular-eslint/no-output-rename */\n/* eslint-disable @angular-eslint/no-input-rename */\nimport { CdkDrag } from '@angular/cdk/drag-drop';\nimport { Overlay, OverlayPositionBuilder } from '@angular/cdk/overlay';\nimport { Directive, ElementRef, EventEmitter, HostBinding, HostListener, Input, OnChanges, Output } from '@angular/core';\nimport { Observable, ReplaySubject } from 'rxjs';\nimport { TooltipDirective } from '../../../../core-ui/tooltip/tooltip.directive';\n\n@Directive({\n  selector: '[lxKeyboardSortableItem]'\n})\nexport class KeyboardSortableItemDirective implements OnChanges {\n  @Input('lxKeyboardSortableItem') allItemsData!: string[];\n  @Input('lxKeyboardItemData') itemData!: string;\n  @Input() isSortingByKeyboard!: boolean;\n  @Input('lxKeyboardItemBeingSorted') itemBeingSorted!: string;\n\n  @Output() readonly isSortingByKeyboardChange = new EventEmitter<boolean>();\n  @Output('lxKeyboardItemBeingSortedChange') readonly itemBeingSortedChange = new EventEmitter<string>();\n  @Output() sortItemsWithKeyboard = new EventEmitter<{ previousIndex: number; currentIndex: number }>();\n  @Output() focusWithKeyboard!: Observable<KeyboardSortableItemDirective>;\n\n  @HostBinding('attr.lxTooltip') tooltipDirective = new TooltipDirective(this.overlayPositionBuilder, this.element, this.overlay);\n  @HostBinding('class.isBeingSortedByKeyboard') isBeingSorted: boolean = false;\n\n  get isSortable() {\n    return !this.draggableItem.disabled;\n  }\n\n  private preventBlur = false;\n  private focusWithKeyboardReplaySubject$ = new ReplaySubject<KeyboardSortableItemDirective>(1);\n\n  constructor(\n    private draggableItem: CdkDrag,\n    private overlayPositionBuilder: OverlayPositionBuilder,\n    private element: ElementRef<HTMLElement>,\n    private overlay: Overlay\n  ) {\n    /**\n     * Using a ReplaySubject here so that the KeyboardSortableListDirective will also know\n     * about a focusWithKeyboard event when its copy of the KeyboardSortableItemDirective ContentChildren\n     * was just initialised after the event fired.\n     */\n    this.focusWithKeyboard = this.focusWithKeyboardReplaySubject$.asObservable();\n  }\n\n  ngOnChanges(): void {\n    this.isBeingSorted = this.itemData === this.itemBeingSorted;\n    if (this.isBeingSorted) {\n      // focus always the pressed element\n      this.element.nativeElement.focus();\n    }\n  }\n\n  @HostListener('keyup.tab')\n  focusViaKeyboard(): void {\n    this.focusWithKeyboardReplaySubject$.next(this);\n  }\n\n  @HostListener('keydown.enter', ['$event'])\n  @HostListener('keydown.space', ['$event'])\n  enterSortingModeEnabledByKeyboard($event: KeyboardEvent) {\n    if ($event.target === this.element.nativeElement) {\n      if ($event.code === 'Enter' || $event.code === 'Space') {\n        $event.preventDefault();\n        this.tooltipDirective.hide();\n\n        this.itemBeingSortedChange.emit(!this.isSortingByKeyboard ? this.itemData : undefined);\n        this.isSortingByKeyboardChange.emit(!this.isSortingByKeyboard);\n      }\n    }\n  }\n\n  @HostListener('blur', ['$event'])\n  @HostListener('keydown.esc', ['$event'])\n  leaveSortingModeEnabledByKeyboard($event: KeyboardEvent | FocusEvent): void {\n    if ($event.target === this.element.nativeElement) {\n      this.tooltipDirective.hide();\n      if (!this.preventBlur) {\n        this.isSortingByKeyboardChange.emit(false);\n        this.itemBeingSortedChange.emit(undefined);\n      }\n    }\n  }\n\n  @HostListener('keydown.arrowUp', ['$event'])\n  @HostListener('keydown.arrowDown', ['$event'])\n  sort($event: KeyboardEvent) {\n    if ($event.target === this.element.nativeElement) {\n      this.tooltipDirective.hide();\n      if (this.isSortingByKeyboard) {\n        $event.preventDefault();\n\n        const previousIndex = this.allItemsData.findIndex((item) => item === this.itemData);\n        const currentIndex = $event.code === 'ArrowUp' ? previousIndex - 1 : previousIndex + 1;\n\n        if (currentIndex >= 0 && currentIndex <= this.allItemsData.length - 1) {\n          this.sortItemsWithKeyboard.emit({ previousIndex, currentIndex });\n\n          // When triggering a keyboard event, the DOM would \"removeChildren\" on the HTML element\n          // which specially for \"ArrowUp\" events would trigger a \"blur\" event since the element\n          // has been moved aboved the DOM tree and loses the focus state.\n          this.preventBlur = true;\n\n          setTimeout(() => (this.preventBlur = false), 0);\n        }\n      }\n    }\n  }\n}\n"]}

package/esm2020/lib/forms-ui/components/drag-and-drop-list/keyboard-sortable-list/keyboard-sortable-list.directive.mjs

@@ -0,0 +1,37 @@
+import { __decorate } from "tslib";
+import { Directive, Input } from '@angular/core';
+import { merge } from 'rxjs';
+import { filter, switchMap, take } from 'rxjs/operators';
+import { Observe } from '../../../../shared/observe';
+import { DRAG_AND_DROP_LIST_TRANSLATION_NAME } from '../constants';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+export class KeyboardSortableListDirective {
+    constructor(translateService) {
+        this.translateService = translateService;
+    }
+    ngAfterViewInit() {
+        this.setupControlsTooltipToBeShownOnFirstFocusedItem();
+    }
+    setupControlsTooltipToBeShownOnFirstFocusedItem() {
+        const firstFocusEventOnADraggableItem$ = this.keyboardSortableItems$.pipe(filter((items) => items && items.length > 0), switchMap((items) => merge(...items.filter((item) => item.isSortable).map((item) => item.focusWithKeyboard))), take(1));
+        firstFocusEventOnADraggableItem$.subscribe((item) => {
+            item.tooltipDirective.content = this.translateService.instant(`${DRAG_AND_DROP_LIST_TRANSLATION_NAME}.helpTooltip`);
+            item.tooltipDirective.show();
+        });
+    }
+}
+KeyboardSortableListDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: KeyboardSortableListDirective, deps: [{ token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Directive });
+KeyboardSortableListDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.5", type: KeyboardSortableListDirective, selector: "[lxKeyboardSortableList]", inputs: { keyboardSortableItems: "keyboardSortableItems" }, ngImport: i0 });
+__decorate([
+    Observe('keyboardSortableItems')
+], KeyboardSortableListDirective.prototype, "keyboardSortableItems$", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: KeyboardSortableListDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[lxKeyboardSortableList]'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TranslateService }]; }, propDecorators: { keyboardSortableItems$: [], keyboardSortableItems: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/forms-ui/components/error-message/error-message.component.mjs

@@ -0,0 +1,24 @@
+import { ChangeDetectionStrategy, Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@ngx-translate/core";
+export class ErrorMessageComponent {
+    constructor(cd) {
+        this.cd = cd;
+    }
+    set key(value) {
+        if (value !== this._key) {
+            this._key = value;
+            this.cd.detectChanges();
+        }
+    }
+}
+ErrorMessageComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: ErrorMessageComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+ErrorMessageComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.5", type: ErrorMessageComponent, selector: "lx-error-message", inputs: { key: "key" }, ngImport: i0, template: `<div class="error" *ngIf="_key">{{ _key | translate }}</div>`, isInline: true, styles: [".error{color:#f96464;padding:4px}\n"], directives: [{ type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], pipes: { "translate": i2.TranslatePipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: ErrorMessageComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lx-error-message', template: `<div class="error" *ngIf="_key">{{ _key | translate }}</div>`, changeDetection: ChangeDetectionStrategy.OnPush, styles: [".error{color:#f96464;padding:4px}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }]; }, propDecorators: { key: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3ItbWVzc2FnZS5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NvbXBvbmVudHMvc3JjL2xpYi9mb3Jtcy11aS9jb21wb25lbnRzL2Vycm9yLW1lc3NhZ2UvZXJyb3ItbWVzc2FnZS5jb21wb25lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLHVCQUF1QixFQUFxQixTQUFTLEVBQUUsS0FBSyxFQUFFLE1BQU0sZUFBZSxDQUFDOzs7O0FBUTdGLE1BQU0sT0FBTyxxQkFBcUI7SUFVaEMsWUFBb0IsRUFBcUI7UUFBckIsT0FBRSxHQUFGLEVBQUUsQ0FBbUI7SUFBRyxDQUFDO0lBUDdDLElBQWEsR0FBRyxDQUFDLEtBQXlCO1FBQ3hDLElBQUksS0FBSyxLQUFLLElBQUksQ0FBQyxJQUFJLEVBQUU7WUFDdkIsSUFBSSxDQUFDLElBQUksR0FBRyxLQUFLLENBQUM7WUFDbEIsSUFBSSxDQUFDLEVBQUUsQ0FBQyxhQUFhLEVBQUUsQ0FBQztTQUN6QjtJQUNILENBQUM7O2tIQVJVLHFCQUFxQjtzR0FBckIscUJBQXFCLGdGQUp0Qiw4REFBOEQ7MkZBSTdELHFCQUFxQjtrQkFOakMsU0FBUzsrQkFDRSxrQkFBa0IsWUFDbEIsOERBQThELG1CQUV2RCx1QkFBdUIsQ0FBQyxNQUFNO3dHQUtsQyxHQUFHO3NCQUFmLEtBQUsiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneSwgQ2hhbmdlRGV0ZWN0b3JSZWYsIENvbXBvbmVudCwgSW5wdXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAnbHgtZXJyb3ItbWVzc2FnZScsXG4gIHRlbXBsYXRlOiBgPGRpdiBjbGFzcz1cImVycm9yXCIgKm5nSWY9XCJfa2V5XCI+e3sgX2tleSB8IHRyYW5zbGF0ZSB9fTwvZGl2PmAsXG4gIHN0eWxlVXJsczogWycuL2Vycm9yLW1lc3NhZ2UuY29tcG9uZW50LnNjc3MnXSxcbiAgY2hhbmdlRGV0ZWN0aW9uOiBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneS5PblB1c2hcbn0pXG5leHBvcnQgY2xhc3MgRXJyb3JNZXNzYWdlQ29tcG9uZW50IHtcbiAgX2tleT86IHN0cmluZztcblxuICBASW5wdXQoKSBzZXQga2V5KHZhbHVlOiBzdHJpbmcgfCB1bmRlZmluZWQpIHtcbiAgICBpZiAodmFsdWUgIT09IHRoaXMuX2tleSkge1xuICAgICAgdGhpcy5fa2V5ID0gdmFsdWU7XG4gICAgICB0aGlzLmNkLmRldGVjdENoYW5nZXMoKTtcbiAgICB9XG4gIH1cblxuICBjb25zdHJ1Y3Rvcihwcml2YXRlIGNkOiBDaGFuZ2VEZXRlY3RvclJlZikge31cbn1cbiJdfQ==

package/esm2020/lib/forms-ui/components/form-error/form-error.component.mjs

@@ -0,0 +1,40 @@
+import { Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@ngx-translate/core";
+export class FormErrorComponent {
+    constructor() {
+        this.translationKeys = [];
+    }
+    ngOnInit() {
+        this.formSubscription = this.form.valueChanges.subscribe(() => {
+            this.translationKeys = this.getTranslationKeys();
+        });
+    }
+    ngOnChanges(_changes) {
+        this.translationKeys = this.getTranslationKeys();
+    }
+    ngOnDestroy() {
+        this.formSubscription.unsubscribe();
+    }
+    getTranslationKeys() {
+        const formControl = this.form.controls[this.controlName];
+        if (formControl && formControl.errors) {
+            return Object.keys(formControl.errors).map((errorKey) => `${this.namespace}.errors.${this.controlName}.${errorKey}`);
+        }
+        return [];
+    }
+}
+FormErrorComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: FormErrorComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+FormErrorComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.5", type: FormErrorComponent, selector: "lx-form-error", inputs: { namespace: "namespace", form: "form", controlName: "controlName" }, usesOnChanges: true, ngImport: i0, template: "<div class=\"error\" *ngFor=\"let key of translationKeys\">\n  {{ key | translate }}\n</div>\n", styles: [".error{color:#f96464;padding:4px}\n"], directives: [{ type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], pipes: { "translate": i2.TranslatePipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: FormErrorComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lx-form-error', template: "<div class=\"error\" *ngFor=\"let key of translationKeys\">\n  {{ key | translate }}\n</div>\n", styles: [".error{color:#f96464;padding:4px}\n"] }]
+        }], propDecorators: { namespace: [{
+                type: Input
+            }], form: [{
+                type: Input
+            }], controlName: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,44 @@
+import { ChangeDetectionStrategy, Component, HostBinding, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Displays Font Awesome icons.
+ */
+export class IconComponent {
+    constructor() {
+        this.NAME = 'IconComponent';
+        this.color = '#000';
+        this.fontAwsomeStyle = 'regular';
+        this.size = '14px';
+        this.iconStyleMap = {
+            solid: 'fas',
+            regular: 'far',
+            light: 'fal'
+        };
+        this.iconStyle = 'far';
+    }
+    ngOnChanges(changes) {
+        if ('fontAwsomeStyle' in changes) {
+            this.iconStyle = this.iconStyleMap[this.fontAwsomeStyle];
+        }
+    }
+}
+IconComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: IconComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+IconComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.5", type: IconComponent, selector: "lx-icon", inputs: { name: "name", color: "color", fontAwsomeStyle: "fontAwsomeStyle", size: "size", title: "title" }, host: { properties: { "style.height": "this.size" } }, usesOnChanges: true, ngImport: i0, template: "<i [attr.title]=\"title\" [class]=\"iconStyle + ' fa-' + name\" [style.color]=\"color\" [style.fontSize]=\"size\"></i>\n", styles: [":host{display:inline-block}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: IconComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'lx-icon', changeDetection: ChangeDetectionStrategy.OnPush, template: "<i [attr.title]=\"title\" [class]=\"iconStyle + ' fa-' + name\" [style.color]=\"color\" [style.fontSize]=\"size\"></i>\n", styles: [":host{display:inline-block}\n"] }]
+        }], propDecorators: { name: [{
+                type: Input
+            }], color: [{
+                type: Input
+            }], fontAwsomeStyle: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }, {
+                type: HostBinding,
+                args: ['style.height']
+            }], title: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,44 @@
+import { Component, HostBinding, Input, Optional } from '@angular/core';
+import { Subject } from 'rxjs';
+import { startWith, takeUntil } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+export class InputComponent {
+    constructor(ngControl) {
+        this.ngControl = ngControl;
+        this.error = false;
+        this.disabled = false;
+        this.destory$ = new Subject();
+    }
+    ngOnInit() {
+        if (this.ngControl) {
+            this.ngControl.statusChanges?.pipe(startWith(null), takeUntil(this.destory$)).subscribe(() => this.updateStatus());
+        }
+    }
+    updateStatus() {
+        this.error = !!this.ngControl?.errors;
+        this.disabled = !!this.ngControl?.disabled;
+    }
+    ngOnDestroy() {
+        this.destory$.next();
+    }
+}
+InputComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: InputComponent, deps: [{ token: i1.NgControl, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+InputComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.5", type: InputComponent, selector: "input[lx-input]", inputs: { error: "error", disabled: "disabled" }, host: { properties: { "class.error": "this.error", "class.disabled": "this.disabled" } }, ngImport: i0, template: ``, isInline: true, styles: [":host{height:32px;padding:8px;border-radius:3px;border:solid 1px #99a5bb;outline:0;color:#2a303d}:host:focus{border-color:#59f}:host.error{border-color:#f96464}:host.disabled{background-color:#f0f2f5;color:#677a9a}\n"] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.5", ngImport: i0, type: InputComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'input[lx-input]', template: ``, styles: [":host{height:32px;padding:8px;border-radius:3px;border:solid 1px #99a5bb;outline:0;color:#2a303d}:host:focus{border-color:#59f}:host.error{border-color:#f96464}:host.disabled{background-color:#f0f2f5;color:#677a9a}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.NgControl, decorators: [{
+                    type: Optional
+                }] }]; }, propDecorators: { error: [{
+                type: Input
+            }, {
+                type: HostBinding,
+                args: ['class.error']
+            }], disabled: [{
+                type: Input
+            }, {
+                type: HostBinding,
+                args: ['class.disabled']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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