ngx-ode-ui 4.6.0-dev.1 → 4.6.0

package/esm2020/lib/components/datepicker/datepicker.component.mjs

@@ -0,0 +1,148 @@
+import { OdeComponent } from 'ngx-ode-core';
+import { Component, EventEmitter, forwardRef, Input, Output, ViewChild } from '@angular/core';
+import { NG_VALUE_ACCESSOR, NgModel } from '@angular/forms';
+import Flatpickr from 'flatpickr';
+import French from 'flatpickr/dist/l10n/fr.js';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/labels.service";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/forms";
+// access ngmodel
+const NOOP = () => {
+};
+export const CUSTOM_INPUT_CONTROL_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: forwardRef(() => DatepickerComponent),
+    multi: true
+};
+export class DatepickerComponent extends OdeComponent {
+    constructor(renderer, labelsService, injector) {
+        super(injector);
+        this.renderer = renderer;
+        this.labelsService = labelsService;
+        this.innerValue = '';
+        this.disabled = false;
+        this._readonly = false;
+        this.enableTime = false;
+        this.placeholder = '';
+        this.changeDate = new EventEmitter();
+        this.onChangeCallback = NOOP;
+        this.onTouchedCallback = NOOP;
+    }
+    get value() {
+        return this.innerValue;
+    }
+    set value(v) {
+        let init = false;
+        if (this.innerValue === undefined) {
+            init = true;
+        }
+        if (v !== this.innerValue) {
+            this.innerValue = v;
+            this.onChangeCallback(v);
+            if (!init) {
+                this.changeDate.emit(v);
+            }
+        }
+    }
+    set readonly(val) {
+        this._readonly = val;
+        if (this.datePickerInst && this.datePickerInst.altInput) {
+            // Apply the readonly attribute addition/removal to the visible input (wrapped)
+            if (val)
+                this.datePickerInst.altInput.setAttribute('readonly', "");
+            else
+                this.datePickerInst.altInput.removeAttribute('readonly');
+        }
+    }
+    get readonly() {
+        return this._readonly;
+    }
+    ngAfterViewInit() {
+        super.ngAfterViewInit();
+        // add attr data-input, mandatory for the picker to work in wrap mode
+        this.renderer.setAttribute(this.inputElement.nativeElement, 'data-input', '');
+        // disabled case
+        if (this.disabled === true) {
+            this.model.control.disable();
+        }
+        const navigatorLanguage = navigator.language.split('-')[0];
+        let datePickerLocale = {};
+        if (navigatorLanguage === 'fr') {
+            datePickerLocale = French.fr;
+        }
+        // options for the flatpickr instance
+        const options = {
+            altInput: !this.disabled,
+            altFormat: 'd/m/Y',
+            dateFormat: 'Y-m-d',
+            allowInput: false,
+            enableTime: this.enableTime,
+            minDate: this.minDate,
+            maxDate: this.maxDate,
+            clickOpens: false,
+            wrap: true,
+            locale: datePickerLocale
+        };
+        this.datePickerInst = new Flatpickr(this.datePickerElement.nativeElement, options);
+        if (!this.disabled) {
+            this.datePickerInst.altInput.addEventListener('click', e => {
+                if (!this.readonly) {
+                    this.datePickerInst.toggle();
+                }
+            });
+        }
+        // Force updating the date input readonly attribute :
+        this.readonly = this._readonly;
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this.datePickerInst.destroy();
+    }
+    writeValue(value) {
+        if (value !== this.innerValue && this.datePickerInst) {
+            this.innerValue = value;
+            this.datePickerInst.setDate(value);
+            this.onChangeCallback(value);
+        }
+    }
+    registerOnChange(fn) {
+        this.onChangeCallback = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouchedCallback = fn;
+    }
+    labels(label) {
+        return this.labelsService.getLabel(label);
+    }
+}
+DatepickerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.1", ngImport: i0, type: DatepickerComponent, deps: [{ token: i0.Renderer2 }, { token: i1.LabelsService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Component });
+DatepickerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.1", type: DatepickerComponent, selector: "ode-date-picker", inputs: { disabled: "disabled", readonly: "readonly", enableTime: "enableTime", placeholder: "placeholder", minDate: "minDate", maxDate: "maxDate" }, outputs: { changeDate: "changeDate" }, providers: [CUSTOM_INPUT_CONTROL_VALUE_ACCESSOR], viewQueries: [{ propertyName: "datePickerElement", first: true, predicate: ["datePickerElement"], descendants: true }, { propertyName: "inputElement", first: true, predicate: ["inputRef"], descendants: true }, { propertyName: "model", first: true, predicate: NgModel, descendants: true }], usesInheritance: true, ngImport: i0, template: "<div class=\"flatpickr\" #datePickerElement>\n  <input type=\"date\" [(ngModel)]=\"value\" [disabled]=\"disabled\" [ngClass]=\"{ 'cursor-default': disabled }\" placeholder=\"{{ placeholder }}\" #inputRef>\n  <a *ngIf=\"!disabled\" [class.hidden]=\"readonly\" data-toggle [title]=\"labels('datepicker.open')\"><i class=\"fa fa-calendar open\" aria-hidden=\"true\"></i></a>\n  <a *ngIf=\"!disabled\" [class.hidden]=\"readonly\" data-clear [title]=\"labels('datepicker.delete')\"><i class=\"fa fa-times delete\" aria-hidden=\"true\"></i></a>\n</div>\n", styles: [".hidden{visibility:hidden}\n"], dependencies: [{ kind: "directive", type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i3.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i3.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.1", ngImport: i0, type: DatepickerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ode-date-picker', providers: [CUSTOM_INPUT_CONTROL_VALUE_ACCESSOR], template: "<div class=\"flatpickr\" #datePickerElement>\n  <input type=\"date\" [(ngModel)]=\"value\" [disabled]=\"disabled\" [ngClass]=\"{ 'cursor-default': disabled }\" placeholder=\"{{ placeholder }}\" #inputRef>\n  <a *ngIf=\"!disabled\" [class.hidden]=\"readonly\" data-toggle [title]=\"labels('datepicker.open')\"><i class=\"fa fa-calendar open\" aria-hidden=\"true\"></i></a>\n  <a *ngIf=\"!disabled\" [class.hidden]=\"readonly\" data-clear [title]=\"labels('datepicker.delete')\"><i class=\"fa fa-times delete\" aria-hidden=\"true\"></i></a>\n</div>\n", styles: [".hidden{visibility:hidden}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.Renderer2 }, { type: i1.LabelsService }, { type: i0.Injector }]; }, propDecorators: { datePickerElement: [{
+                type: ViewChild,
+                args: ['datePickerElement']
+            }], inputElement: [{
+                type: ViewChild,
+                args: ['inputRef']
+            }], model: [{
+                type: ViewChild,
+                args: [NgModel]
+            }], disabled: [{
+                type: Input
+            }], readonly: [{
+                type: Input
+            }], enableTime: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], minDate: [{
+                type: Input
+            }], maxDate: [{
+                type: Input
+            }], changeDate: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datepicker.component.js","sourceRoot":"","sources":["../../../../../../projects/ngx-ode-ui/src/lib/components/datepicker/datepicker.component.ts","../../../../../../projects/ngx-ode-ui/src/lib/components/datepicker/datepicker.component.html"],"names":[],"mappings":"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","sourcesContent":["import { OdeComponent } from 'ngx-ode-core';\nimport { AfterViewInit, Component, ElementRef, EventEmitter, forwardRef,\n  Input, OnDestroy, Output, Renderer2, ViewChild, Injector } from '@angular/core';\n\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR, NgModel } from '@angular/forms';\n\nimport {LabelsService} from '../../services/labels.service';\nimport Flatpickr from 'flatpickr';\nimport French from 'flatpickr/dist/l10n/fr.js';\n\n// access ngmodel\nconst NOOP = () => {\n};\nexport const CUSTOM_INPUT_CONTROL_VALUE_ACCESSOR: any = {\n    provide: NG_VALUE_ACCESSOR,\n    useExisting: forwardRef(() => DatepickerComponent),\n    multi: true\n};\n\n@Component({\n    selector: 'ode-date-picker',\n    templateUrl: './datepicker.component.html',\n    styleUrls: ['./datepicker.component.scss'],\n    providers: [ CUSTOM_INPUT_CONTROL_VALUE_ACCESSOR ]\n})\nexport class DatepickerComponent extends OdeComponent implements OnDestroy, AfterViewInit, ControlValueAccessor {\n\n    constructor(private renderer: Renderer2,\n                private labelsService: LabelsService,\n                injector: Injector) {\n                    super(injector);\n                }\n\n    get value(): any {\n        return this.innerValue;\n    }\n\n    set value(v: any) {\n        let init = false;\n        if (this.innerValue === undefined) {\n            init = true;\n        }\n        if (v !== this.innerValue) {\n            this.innerValue = v;\n            this.onChangeCallback(v);\n            if (!init) {\n                this.changeDate.emit(v);\n            }\n\n        }\n    }\n\n    private innerValue: any = '';\n\n    @ViewChild('datePickerElement')\n    datePickerElement: ElementRef;\n\n    @ViewChild('inputRef')\n    inputElement: ElementRef;\n\n    // instance flatpickr\n    private datePickerInst: Flatpickr;\n\n    @ViewChild(NgModel)\n    model: NgModel;\n\n    @Input()\n    disabled = false;\n\n    @Input()\n    set readonly( val:boolean ) {\n        this._readonly = val;\n        if( this.datePickerInst && this.datePickerInst.altInput ) {\n            // Apply the readonly attribute addition/removal to the visible input (wrapped)\n            if( val ) this.datePickerInst.altInput.setAttribute('readonly', \"\");\n            else      this.datePickerInst.altInput.removeAttribute('readonly');\n        }\n    }\n    get readonly():boolean {\n        return this._readonly;\n    }\n    _readonly = false;\n\n    @Input()\n    enableTime = false;\n\n    @Input()\n    placeholder = '';\n\n    @Input()\n    minDate;\n\n    @Input()\n    maxDate;\n\n    @Output()\n    changeDate: EventEmitter<string> = new EventEmitter<string>();\n\n    private onChangeCallback: (_: any) => void = NOOP;\n    private onTouchedCallback: () => void = NOOP;\n\n    ngAfterViewInit(): void {\n        super.ngAfterViewInit();\n        // add attr data-input, mandatory for the picker to work in wrap mode\n        this.renderer.setAttribute(this.inputElement.nativeElement, 'data-input', '');\n\n        // disabled case\n        if (this.disabled === true) {\n            this.model.control.disable();\n        }\n\n        const navigatorLanguage = navigator.language.split('-')[0];\n        let datePickerLocale = {};\n        if (navigatorLanguage === 'fr') {\n            datePickerLocale = French.fr;\n        }\n\n        // options for the flatpickr instance\n        const options = {\n            altInput: !this.disabled,\n            altFormat: 'd/m/Y', // date format displayed to user\n            dateFormat: 'Y-m-d', // date format sent to server\n            allowInput: false,\n            enableTime: this.enableTime,\n            minDate: this.minDate,\n            maxDate: this.maxDate,\n            clickOpens: false,\n            wrap: true, // to add input decoration (calendar icon and delete icon)\n            locale: datePickerLocale\n        };\n\n        this.datePickerInst = new Flatpickr(this.datePickerElement.nativeElement, options);\n        if( !this.disabled ) {\n            this.datePickerInst.altInput.addEventListener('click', e => {\n                if( !this.readonly ) {\n                    this.datePickerInst.toggle();\n                }\n            });\n        }\n\n        // Force updating the date input readonly attribute :\n        this.readonly = this._readonly;\n    }\n\n    ngOnDestroy(): void {\n        super.ngOnDestroy();\n        this.datePickerInst.destroy();\n    }\n\n    writeValue(value: any): void {\n        if (value !== this.innerValue && this.datePickerInst) {\n            this.innerValue = value;\n            this.datePickerInst.setDate(value);\n            this.onChangeCallback(value);\n        }\n    }\n\n    registerOnChange(fn: any): void {\n        this.onChangeCallback = fn;\n    }\n\n    registerOnTouched(fn: any): void {\n        this.onTouchedCallback = fn;\n    }\n\n    labels(label) {\n        return this.labelsService.getLabel(label);\n    }\n}\n","<div class=\"flatpickr\" #datePickerElement>\n  <input type=\"date\" [(ngModel)]=\"value\" [disabled]=\"disabled\" [ngClass]=\"{ 'cursor-default': disabled }\" placeholder=\"{{ placeholder }}\" #inputRef>\n  <a *ngIf=\"!disabled\" [class.hidden]=\"readonly\" data-toggle [title]=\"labels('datepicker.open')\"><i class=\"fa fa-calendar open\" aria-hidden=\"true\"></i></a>\n  <a *ngIf=\"!disabled\" [class.hidden]=\"readonly\" data-clear [title]=\"labels('datepicker.delete')\"><i class=\"fa fa-times delete\" aria-hidden=\"true\"></i></a>\n</div>\n"]}

package/esm2020/lib/components/dropdown/dropdown.component.mjs

@@ -0,0 +1,55 @@
+import { Component, Input, Output, EventEmitter } from '@angular/core';
+import { OdeComponent } from 'ngx-ode-core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+/**
+ * DropdownComponent is an alternative to the MonoSelectComponent.
+ * Accept everything inside <ng-content> but should work with <ode-list> component
+ *
+ * Simple Dropdown Component without search:
+ * [isSearchActive] can be set to false to disable search input in <ode-list>
+```
+<ode-dropdown
+    [name]="option_name"
+    [isDropdownOpened]="a_boolean"
+    (onDropdown)="toggle_func"
+  >
+  <ode-list
+    [model]="model"
+    [filters]="filters"
+    (onSelect)="func_to_select_elem($event)"
+    (inputChange)="a_string_for_input_value = $event"
+    noResultsLabel="text_to_display"
+    searchPlaceholder="default_placeholder_text"
+    >
+      <ng-template let-item>
+        <div>{{ item.name }}</div>
+      </ng-template>
+    </ode-list>
+  </ode-dropdown>
+`̀``
+ */
+export class DropdownComponent extends OdeComponent {
+    constructor(injector) {
+        super(injector);
+        this.name = '';
+        this.isDropdownOpened = false;
+        this.onDropdown = new EventEmitter();
+    }
+    ngOnInit() {
+        super.ngOnInit();
+    }
+}
+DropdownComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.1", ngImport: i0, type: DropdownComponent, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Component });
+DropdownComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.1", type: DropdownComponent, selector: "ode-dropdown", inputs: { name: "name", isDropdownOpened: "isDropdownOpened" }, outputs: { onDropdown: "onDropdown" }, usesInheritance: true, ngImport: i0, template: "<div class=\"dropdown\" [ngClass]=\"isDropdownOpened ? 'open' : ''\">\n  <button (click)=\"onDropdown.emit()\" class=\"dropdown-trigger\">\n    <span class=\"cell-ellipsis\">{{ name }}</span> <i class=\"fonticon arrow-select\"></i>\n  </button>\n  <div class=\"dropdown-list\">\n    <ng-content></ng-content>\n  </div>\n</div>\n", styles: [".dropdown{position:relative;width:230px;box-sizing:border-box}.dropdown *{box-sizing:border-box}.dropdown-trigger{cursor:pointer;display:inline-flex;align-items:center;justify-content:space-between;padding:12px 16px;font-size:14px;color:#4a4a4a;text-transform:uppercase;text-align:left;width:100%;border-radius:8px;border:1px solid #7a7a7a;background-color:#fff}.dropdown-trigger>span{display:inline-block;max-width:100%;text-overflow:ellipsis;white-space:nowrap;overflow:hidden}.dropdown-trigger i.arrow-select{display:inline-block;float:none!important;padding-left:0;transform:rotate(180deg);transform-origin:center center}.dropdown-trigger:hover{color:#4a4a4a;border-color:#7a7a7a;background-color:#fff}.dropdown-trigger:hover i.arrow-select{color:#4a4a4a!important}.dropdown-list{display:none;position:absolute;overflow:hidden;z-index:2;top:100%;left:0;right:0;width:316px;box-shadow:0 4px 12px #00000026;border-radius:8px;background-color:#fff}.dropdown::ng-deep ode-list li{justify-content:flex-start}.dropdown::ng-deep ode-list input[type=search]{padding:12px 16px}.dropdown.open .dropdown-list{display:block}.dropdown.open i.arrow-select{transform:rotate(0)}\n"], dependencies: [{ kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.1", ngImport: i0, type: DropdownComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ode-dropdown', template: "<div class=\"dropdown\" [ngClass]=\"isDropdownOpened ? 'open' : ''\">\n  <button (click)=\"onDropdown.emit()\" class=\"dropdown-trigger\">\n    <span class=\"cell-ellipsis\">{{ name }}</span> <i class=\"fonticon arrow-select\"></i>\n  </button>\n  <div class=\"dropdown-list\">\n    <ng-content></ng-content>\n  </div>\n</div>\n", styles: [".dropdown{position:relative;width:230px;box-sizing:border-box}.dropdown *{box-sizing:border-box}.dropdown-trigger{cursor:pointer;display:inline-flex;align-items:center;justify-content:space-between;padding:12px 16px;font-size:14px;color:#4a4a4a;text-transform:uppercase;text-align:left;width:100%;border-radius:8px;border:1px solid #7a7a7a;background-color:#fff}.dropdown-trigger>span{display:inline-block;max-width:100%;text-overflow:ellipsis;white-space:nowrap;overflow:hidden}.dropdown-trigger i.arrow-select{display:inline-block;float:none!important;padding-left:0;transform:rotate(180deg);transform-origin:center center}.dropdown-trigger:hover{color:#4a4a4a;border-color:#7a7a7a;background-color:#fff}.dropdown-trigger:hover i.arrow-select{color:#4a4a4a!important}.dropdown-list{display:none;position:absolute;overflow:hidden;z-index:2;top:100%;left:0;right:0;width:316px;box-shadow:0 4px 12px #00000026;border-radius:8px;background-color:#fff}.dropdown::ng-deep ode-list li{justify-content:flex-start}.dropdown::ng-deep ode-list input[type=search]{padding:12px 16px}.dropdown.open .dropdown-list{display:block}.dropdown.open i.arrow-select{transform:rotate(0)}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; }, propDecorators: { name: [{
+                type: Input
+            }], isDropdownOpened: [{
+                type: Input
+            }], onDropdown: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJvcGRvd24uY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LW9kZS11aS9zcmMvbGliL2NvbXBvbmVudHMvZHJvcGRvd24vZHJvcGRvd24uY29tcG9uZW50LnRzIiwiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LW9kZS11aS9zcmMvbGliL2NvbXBvbmVudHMvZHJvcGRvd24vZHJvcGRvd24uY29tcG9uZW50Lmh0bWwiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBVSxLQUFLLEVBQUUsTUFBTSxFQUFFLFlBQVksRUFBWSxNQUFNLGVBQWUsQ0FBQztBQUN6RixPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sY0FBYyxDQUFDOzs7QUFFNUM7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBMEJHO0FBT0gsTUFBTSxPQUFPLGlCQUFrQixTQUFRLFlBQVk7SUFFakQsWUFBWSxRQUFrQjtRQUM1QixLQUFLLENBQUMsUUFBUSxDQUFDLENBQUM7UUFHVCxTQUFJLEdBQVcsRUFBRSxDQUFDO1FBQ2xCLHFCQUFnQixHQUFZLEtBQUssQ0FBQztRQUVqQyxlQUFVLEdBQXdCLElBQUksWUFBWSxFQUFRLENBQUM7SUFMckUsQ0FBQztJQU9ELFFBQVE7UUFDTixLQUFLLENBQUMsUUFBUSxFQUFFLENBQUM7SUFDbkIsQ0FBQzs7OEdBYlUsaUJBQWlCO2tHQUFqQixpQkFBaUIsa0xDcEM5QiwwVUFRQTsyRkQ0QmEsaUJBQWlCO2tCQUw3QixTQUFTOytCQUNFLGNBQWM7K0ZBVWYsSUFBSTtzQkFBWixLQUFLO2dCQUNHLGdCQUFnQjtzQkFBeEIsS0FBSztnQkFFSSxVQUFVO3NCQUFuQixNQUFNIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50LCBPbkluaXQsIElucHV0LCBPdXRwdXQsIEV2ZW50RW1pdHRlciwgSW5qZWN0b3IgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IE9kZUNvbXBvbmVudCB9IGZyb20gJ25neC1vZGUtY29yZSc7XG5cbi8qKlxuICogRHJvcGRvd25Db21wb25lbnQgaXMgYW4gYWx0ZXJuYXRpdmUgdG8gdGhlIE1vbm9TZWxlY3RDb21wb25lbnQuXG4gKiBBY2NlcHQgZXZlcnl0aGluZyBpbnNpZGUgPG5nLWNvbnRlbnQ+IGJ1dCBzaG91bGQgd29yayB3aXRoIDxvZGUtbGlzdD4gY29tcG9uZW50XG4gKiBcbiAqIFNpbXBsZSBEcm9wZG93biBDb21wb25lbnQgd2l0aG91dCBzZWFyY2g6XG4gKiBbaXNTZWFyY2hBY3RpdmVdIGNhbiBiZSBzZXQgdG8gZmFsc2UgdG8gZGlzYWJsZSBzZWFyY2ggaW5wdXQgaW4gPG9kZS1saXN0PlxuYGBgXG48b2RlLWRyb3Bkb3duXG4gICAgW25hbWVdPVwib3B0aW9uX25hbWVcIlxuICAgIFtpc0Ryb3Bkb3duT3BlbmVkXT1cImFfYm9vbGVhblwiXG4gICAgKG9uRHJvcGRvd24pPVwidG9nZ2xlX2Z1bmNcIlxuICA+XG4gIDxvZGUtbGlzdFxuICAgIFttb2RlbF09XCJtb2RlbFwiXG4gICAgW2ZpbHRlcnNdPVwiZmlsdGVyc1wiXG4gICAgKG9uU2VsZWN0KT1cImZ1bmNfdG9fc2VsZWN0X2VsZW0oJGV2ZW50KVwiXG4gICAgKGlucHV0Q2hhbmdlKT1cImFfc3RyaW5nX2Zvcl9pbnB1dF92YWx1ZSA9ICRldmVudFwiXG4gICAgbm9SZXN1bHRzTGFiZWw9XCJ0ZXh0X3RvX2Rpc3BsYXlcIlxuICAgIHNlYXJjaFBsYWNlaG9sZGVyPVwiZGVmYXVsdF9wbGFjZWhvbGRlcl90ZXh0XCJcbiAgICA+XG4gICAgICA8bmctdGVtcGxhdGUgbGV0LWl0ZW0+XG4gICAgICAgIDxkaXY+e3sgaXRlbS5uYW1lIH19PC9kaXY+XG4gICAgICA8L25nLXRlbXBsYXRlPlxuICAgIDwvb2RlLWxpc3Q+XG4gIDwvb2RlLWRyb3Bkb3duPlxuYMyAYGBcbiAqL1xuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdvZGUtZHJvcGRvd24nLFxuICB0ZW1wbGF0ZVVybDogJy4vZHJvcGRvd24uY29tcG9uZW50Lmh0bWwnLFxuICBzdHlsZVVybHM6IFsnLi9kcm9wZG93bi5jb21wb25lbnQuc2NzcyddXG59KVxuZXhwb3J0IGNsYXNzIERyb3Bkb3duQ29tcG9uZW50IGV4dGVuZHMgT2RlQ29tcG9uZW50IGltcGxlbWVudHMgT25Jbml0IHtcblxuICBjb25zdHJ1Y3RvcihpbmplY3RvcjogSW5qZWN0b3IpIHtcbiAgICBzdXBlcihpbmplY3Rvcik7XG4gIH1cblxuICBASW5wdXQoKSBuYW1lOiBzdHJpbmcgPSAnJztcbiAgQElucHV0KCkgaXNEcm9wZG93bk9wZW5lZDogYm9vbGVhbiA9IGZhbHNlO1xuXG4gIEBPdXRwdXQoKSBvbkRyb3Bkb3duOiBFdmVudEVtaXR0ZXI8dm9pZD4gPSAgbmV3IEV2ZW50RW1pdHRlcjx2b2lkPigpO1xuXG4gIG5nT25Jbml0KCk6IHZvaWQge1xuICAgIHN1cGVyLm5nT25Jbml0KCk7XG4gIH1cblxufVxuIiwiPGRpdiBjbGFzcz1cImRyb3Bkb3duXCIgW25nQ2xhc3NdPVwiaXNEcm9wZG93bk9wZW5lZCA/ICdvcGVuJyA6ICcnXCI+XG4gIDxidXR0b24gKGNsaWNrKT1cIm9uRHJvcGRvd24uZW1pdCgpXCIgY2xhc3M9XCJkcm9wZG93bi10cmlnZ2VyXCI+XG4gICAgPHNwYW4gY2xhc3M9XCJjZWxsLWVsbGlwc2lzXCI+e3sgbmFtZSB9fTwvc3Bhbj4gPGkgY2xhc3M9XCJmb250aWNvbiBhcnJvdy1zZWxlY3RcIj48L2k+XG4gIDwvYnV0dG9uPlxuICA8ZGl2IGNsYXNzPVwiZHJvcGRvd24tbGlzdFwiPlxuICAgIDxuZy1jb250ZW50PjwvbmctY29udGVudD5cbiAgPC9kaXY+XG48L2Rpdj5cbiJdfQ==

package/esm2020/lib/components/ellipsis/ellipsis.component.mjs

@@ -0,0 +1,53 @@
+import { OdeComponent } from 'ngx-ode-core';
+import { Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * A simple ellipsis component that switches text-overflow on click.
+ * Add an ellipsis={'hide'| 'expand'} attirubute on your element.
+ * Default behavior is 'hide', so that it's the same than the raw CSS
+ */
+export class EllipsisComponent extends OdeComponent {
+    constructor(eltRef, injector) {
+        super(injector);
+        this.eltRef = eltRef;
+        this._ellipsis = 'hide';
+        this.isExpanded = false;
+        this.initialStyle = Object.assign({}, this.eltRef.nativeElement.style);
+    }
+    set ellipsis(value) {
+        if (!!value) {
+            this._ellipsis = value;
+            if (this._ellipsis == 'expand') {
+                this.eltRef.nativeElement.className = 'expand';
+            }
+        }
+    }
+    onClick() {
+        if (this._ellipsis == 'hide') {
+            return;
+        }
+        if (!this.isExpanded) {
+            this.isExpanded = true;
+            Object.assign(this.eltRef.nativeElement.style, {
+                textOverflow: 'clip',
+                overflow: 'auto',
+                whiteSpace: 'normal',
+            });
+        }
+        else {
+            this.isExpanded = false;
+            this.eltRef.nativeElement.style = this.initialStyle;
+        }
+    }
+}
+EllipsisComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.1", ngImport: i0, type: EllipsisComponent, deps: [{ token: i0.ElementRef }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Component });
+EllipsisComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.1", type: EllipsisComponent, selector: "[ellipsis]", inputs: { ellipsis: "ellipsis" }, host: { listeners: { "click": "onClick()" } }, usesInheritance: true, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true, styles: [":host{display:block;width:8em;overflow:hidden;white-space:nowrap;text-overflow:ellipsis}:host.expand{cursor:pointer}\n"] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.1", ngImport: i0, type: EllipsisComponent, decorators: [{
+            type: Component,
+            args: [{ selector: '[ellipsis]', template: `<ng-content></ng-content>`, host: {
+                        '(click)': 'onClick()',
+                    }, styles: [":host{display:block;width:8em;overflow:hidden;white-space:nowrap;text-overflow:ellipsis}:host.expand{cursor:pointer}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Injector }]; }, propDecorators: { ellipsis: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/form-errors/form-errors.component.mjs

@@ -0,0 +1,35 @@
+import { OdeComponent } from 'ngx-ode-core';
+import { Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/labels.service";
+import * as i2 from "@angular/common";
+import * as i3 from "ngx-ode-sijil";
+export class FormErrorsComponent extends OdeComponent {
+    constructor(labelsService, injector) {
+        super(injector);
+        this.labelsService = labelsService;
+    }
+    getErrorsArray() {
+        const errorsArray = [];
+        for (const prop in this.ref.errors) {
+            errorsArray.push({ name: prop, value: this.ref.errors[prop] });
+        }
+        return errorsArray;
+    }
+    labels(label) {
+        return this.labelsService.getLabel(label);
+    }
+}
+FormErrorsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.1", ngImport: i0, type: FormErrorsComponent, deps: [{ token: i1.LabelsService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Component });
+FormErrorsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.1", type: FormErrorsComponent, selector: "ode-form-errors", inputs: { ref: ["control", "ref"], expectedPatternMsg: "expectedPatternMsg" }, usesInheritance: true, ngImport: i0, template: "<div *ngIf=\"ref && ref.errors && (ref.dirty || ref.touched)\" class=\"form-errors\">\n  <div *ngFor=\"let error of getErrorsArray()\">\n    <span>{{ 'form.error.' + error.name | translate: error.value }}</span>\n    <span *ngIf=\"error.name == 'pattern'\">{{expectedPatternMsg}}</span>\n  </div>\n</div>\n", styles: [".form-errors{font-size:.8em;color:#dc143c;font-style:italic}\n"], dependencies: [{ kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i3.TranslatePipe, name: "translate" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.1", ngImport: i0, type: FormErrorsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ode-form-errors', template: "<div *ngIf=\"ref && ref.errors && (ref.dirty || ref.touched)\" class=\"form-errors\">\n  <div *ngFor=\"let error of getErrorsArray()\">\n    <span>{{ 'form.error.' + error.name | translate: error.value }}</span>\n    <span *ngIf=\"error.name == 'pattern'\">{{expectedPatternMsg}}</span>\n  </div>\n</div>\n", styles: [".form-errors{font-size:.8em;color:#dc143c;font-style:italic}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.LabelsService }, { type: i0.Injector }]; }, propDecorators: { ref: [{
+                type: Input,
+                args: ['control']
+            }], expectedPatternMsg: [{
+                type: Input,
+                args: ['expectedPatternMsg']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/form-field/form-field.component.mjs

@@ -0,0 +1,24 @@
+import { Component, Input } from '@angular/core';
+import { OdeComponent } from 'ngx-ode-core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "../message-sticker/message-sticker.component";
+import * as i3 from "ngx-ode-sijil";
+export class FormFieldComponent extends OdeComponent {
+    constructor(injector) {
+        super(injector);
+    }
+}
+FormFieldComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.1", ngImport: i0, type: FormFieldComponent, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Component });
+FormFieldComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.1", type: FormFieldComponent, selector: "ode-form-field", inputs: { label: "label", help: "help", required: "required" }, usesInheritance: true, ngImport: i0, template: "<div class=\"form-field\">\n  <label>\n    {{ label | translate }}\n    <span *ngIf=\"required\" class=\"asterisque\">*</span>\n    <ode-message-sticker *ngIf=\"help\"\n                     [type]=\"'info'\"\n                     [messages]=\"[help]\">\n    </ode-message-sticker>\n  </label>\n  <ng-content></ng-content>\n</div>\n", styles: ["div.form-field{display:flex;align-items:center}div.form-field > > > > *{flex:1;margin-left:5px}div.form-field>*:first-child{flex:0 0 200px;margin-left:0}div.form-field message-sticker{font-size:1.3em}div.form-field .asterisque{color:#dc143c}\n"], dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i2.MessageStickerComponent, selector: "ode-message-sticker", inputs: ["type", "header", "messages", "gravity"] }, { kind: "pipe", type: i3.TranslatePipe, name: "translate" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.1", ngImport: i0, type: FormFieldComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ode-form-field', template: "<div class=\"form-field\">\n  <label>\n    {{ label | translate }}\n    <span *ngIf=\"required\" class=\"asterisque\">*</span>\n    <ode-message-sticker *ngIf=\"help\"\n                     [type]=\"'info'\"\n                     [messages]=\"[help]\">\n    </ode-message-sticker>\n  </label>\n  <ng-content></ng-content>\n</div>\n", styles: ["div.form-field{display:flex;align-items:center}div.form-field > > > > *{flex:1;margin-left:5px}div.form-field>*:first-child{flex:0 0 200px;margin-left:0}div.form-field message-sticker{font-size:1.3em}div.form-field .asterisque{color:#dc143c}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; }, propDecorators: { label: [{
+                type: Input
+            }], help: [{
+                type: Input
+            }], required: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybS1maWVsZC5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtb2RlLXVpL3NyYy9saWIvY29tcG9uZW50cy9mb3JtLWZpZWxkL2Zvcm0tZmllbGQuY29tcG9uZW50LnRzIiwiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LW9kZS11aS9zcmMvbGliL2NvbXBvbmVudHMvZm9ybS1maWVsZC9mb3JtLWZpZWxkLmNvbXBvbmVudC5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFZLE1BQU0sZUFBZSxDQUFDO0FBQzNELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxjQUFjLENBQUM7Ozs7O0FBTzVDLE1BQU0sT0FBTyxrQkFBbUIsU0FBUSxZQUFZO0lBS2xELFlBQVksUUFBa0I7UUFDNUIsS0FBSyxDQUFDLFFBQVEsQ0FBQyxDQUFDO0lBQ2xCLENBQUM7OytHQVBVLGtCQUFrQjttR0FBbEIsa0JBQWtCLDZJQ1IvQiw2VUFXQTsyRkRIYSxrQkFBa0I7a0JBTDlCLFNBQVM7K0JBQ0UsZ0JBQWdCOytGQUtqQixLQUFLO3NCQUFiLEtBQUs7Z0JBQ0csSUFBSTtzQkFBWixLQUFLO2dCQUNHLFFBQVE7c0JBQWhCLEtBQUsiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnQsIElucHV0LCBJbmplY3RvciB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgT2RlQ29tcG9uZW50IH0gZnJvbSAnbmd4LW9kZS1jb3JlJztcblxuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAnb2RlLWZvcm0tZmllbGQnLFxuICB0ZW1wbGF0ZVVybDogJy4vZm9ybS1maWVsZC5jb21wb25lbnQuaHRtbCcsXG4gIHN0eWxlVXJsczogWycuL2Zvcm0tZmllbGQuY29tcG9uZW50LnNjc3MnXVxufSlcbmV4cG9ydCBjbGFzcyBGb3JtRmllbGRDb21wb25lbnQgZXh0ZW5kcyBPZGVDb21wb25lbnQge1xuICBASW5wdXQoKSBsYWJlbDogc3RyaW5nO1xuICBASW5wdXQoKSBoZWxwOiBzdHJpbmc7XG4gIEBJbnB1dCgpIHJlcXVpcmVkOiBib29sZWFuO1xuXG4gIGNvbnN0cnVjdG9yKGluamVjdG9yOiBJbmplY3Rvcikge1xuICAgIHN1cGVyKGluamVjdG9yKTtcbiAgfVxufVxuIiwiPGRpdiBjbGFzcz1cImZvcm0tZmllbGRcIj5cbiAgPGxhYmVsPlxuICAgIHt7IGxhYmVsIHwgdHJhbnNsYXRlIH19XG4gICAgPHNwYW4gKm5nSWY9XCJyZXF1aXJlZFwiIGNsYXNzPVwiYXN0ZXJpc3F1ZVwiPio8L3NwYW4+XG4gICAgPG9kZS1tZXNzYWdlLXN0aWNrZXIgKm5nSWY9XCJoZWxwXCJcbiAgICAgICAgICAgICAgICAgICAgIFt0eXBlXT1cIidpbmZvJ1wiXG4gICAgICAgICAgICAgICAgICAgICBbbWVzc2FnZXNdPVwiW2hlbHBdXCI+XG4gICAgPC9vZGUtbWVzc2FnZS1zdGlja2VyPlxuICA8L2xhYmVsPlxuICA8bmctY29udGVudD48L25nLWNvbnRlbnQ+XG48L2Rpdj5cbiJdfQ==

package/esm2020/lib/components/item-tree/item-tree.component.mjs

@@ -0,0 +1,170 @@
+import { OdeComponent } from 'ngx-ode-core';
+import { Component, EventEmitter, Input, Output, ViewChild } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/forms";
+import * as i3 from "../../pipes/filter.pipe";
+import * as i4 from "../../pipes/flattenObjArray.pipe";
+import * as i5 from "../../pipes/orderBy.pipe";
+export class ItemTreeComponent extends OdeComponent {
+    constructor(injector) {
+        super(injector);
+        /**** Inputs ****/
+        // Items
+        this.items = [];
+        // Property containing the list of child objects.
+        this.childrenProperty = 'children';
+        // Property to display in the list
+        this.displayProperty = 'label';
+        // Filter pipe argument
+        this.filter = '';
+        // OrderBy pipe argument
+        this.order = [];
+        // Reverse the order pipe
+        this.reverse = false;
+        this._flattenProps = [];
+        // Disable the opener icon
+        this.disableOpener = false;
+        // Use checkboxes instead of selecting items
+        this.checkboxMode = false;
+        /**** Outputs ****/
+        this.onSelect = new EventEmitter();
+        this.onCheck = new EventEmitter();
+        this._depth = 0;
+        this.unfolded = [];
+    }
+    // Flatten the tree on the specified properties
+    set flatten(flattenProps) {
+        if (!this.isFlattened() && flattenProps.length > 0) {
+            this._selectedItem = this._lastSelectedItem;
+        }
+        else if (this.isFlattened && flattenProps.length < 1) {
+            this.flagIfParent();
+        }
+        this._flattenProps = flattenProps;
+    }
+    get flatten() {
+        return this._flattenProps;
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        this.flagIfParent();
+    }
+    selectItem(item) {
+        this._selectedItem = item;
+        if (this.childItemTree) {
+            delete this.childItemTree._selectedItem;
+        }
+        const idx = this.unfolded.indexOf(item);
+        if (!this.disableOpener && idx < 0) {
+            this.unfolded.push(item);
+        }
+        else {
+            this.unfolded.splice(idx, 1);
+        }
+        this.bubbleSelect(item);
+    }
+    checkItem(item) {
+        this.onCheck.emit(item);
+    }
+    bubbleSelect(item) {
+        this._lastSelectedItem = item;
+        this.onSelect.emit(item);
+    }
+    isSelected(item) {
+        return (this.disableOpener ? this._selectedItem : this._lastSelectedItem) === item;
+    }
+    toggleFold(event, item) {
+        event.stopPropagation();
+        const idx = this.unfolded.indexOf(item);
+        if (idx < 0) {
+            this.unfolded.push(item);
+        }
+        else {
+            this.unfolded.splice(idx, 1);
+        }
+    }
+    isFolded(item) {
+        return this.disableOpener ? !this.isSelected(item) : this.unfolded.indexOf(item) < 0;
+    }
+    display(item) {
+        return this.displayProperty && item[this.displayProperty];
+    }
+    getChildren(item) {
+        return item[this.childrenProperty] || [];
+    }
+    hasChildren(item) {
+        return this.getChildren(item).length > 0;
+    }
+    isFlattened() {
+        return this._flattenProps.length;
+    }
+    flagIfParent() {
+        if (!this._lastSelectedItem) {
+            return;
+        }
+        const findSubItem = (item, target) => {
+            if (item === target) {
+                return true;
+            }
+            if (this.hasChildren(item)) {
+                return this.getChildren(item).find(subItem => {
+                    return findSubItem(subItem, target);
+                });
+            }
+            return false;
+        };
+        for (const i in this.items) {
+            const item = this.items[i];
+            if (item === this._lastSelectedItem ||
+                findSubItem(item, this._lastSelectedItem)) {
+                this._selectedItem = item;
+                this.unfolded = [item];
+                break;
+            }
+        }
+        this.changeDetector.markForCheck();
+    }
+}
+ItemTreeComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.1.1", ngImport: i0, type: ItemTreeComponent, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Component });
+ItemTreeComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.1.1", type: ItemTreeComponent, selector: "ode-item-tree", inputs: { items: "items", childrenProperty: ["children", "childrenProperty"], displayProperty: ["display", "displayProperty"], displayTemplate: "displayTemplate", filter: "filter", order: "order", reverse: "reverse", flatten: "flatten", disableOpener: "disableOpener", checkboxMode: "checkboxMode", _lastSelectedItem: ["lastSelected", "_lastSelectedItem"], _depth: ["depth", "_depth"] }, outputs: { onSelect: "onSelect", onCheck: "onCheck" }, viewQueries: [{ propertyName: "childItemTree", first: true, predicate: ItemTreeComponent, descendants: true }], usesInheritance: true, ngImport: i0, template: "<ul [ngClass]=\"{ flattened: isFlattened() }\">\n  <li *ngFor=\"let item of (items | flattenObjArray: flatten | filter: filter | orderBy: order:reverse)\"\n      [ngClass]=\"{ selected: isSelected(item), unfolded: !isFolded(item), parent: hasChildren(item), root: _depth === 0 }\">\n    <a href=\"javascript:void(0)\" (click)=\"selectItem(item)\" *ngIf=\"!checkboxMode\">\n      <i class=\"opener\" (click)=\"toggleFold($event, item)\"\n         *ngIf=\"!isFlattened() && hasChildren(item) && !disableOpener\"></i>\n      <span *ngIf=\"displayProperty\">{{ display(item) }}</span>\n      <span *ngIf=\"displayTemplate\">\n        <ng-template [ngTemplateOutlet]=\"displayTemplate\" [ngTemplateOutletContext]=\"{$implicit: item}\"></ng-template>\n      </span>\n    </a>\n    <div class=\"checkbox__item\" *ngIf=\"checkboxMode\">\n      <input id=\"all\" type=\"checkbox\" [(ngModel)]=\"item.check\" ngDefaultControl>\n      <label *ngIf=\"displayProperty\" for=\"all\" (click)=\"checkItem(item)\">{{display(item)}}</label>\n      <span *ngIf=\"displayTemplate\">\n        <ng-template [ngTemplateOutlet]=\"displayTemplate\" [ngTemplateOutletContext]=\"{$implicit: item}\"></ng-template>\n      </span>\n    </div>\n    <ode-item-tree\n      [items]=\"getChildren(item)\"\n      [children]=\"childrenProperty\"\n      [display]=\"displayProperty\"\n      [displayTemplate]=\"displayTemplate\"\n      [filter]=\"filter\"\n      [order]=\"order\"\n      [reverse]=\"reverse\"\n      [lastSelected]=\"_lastSelectedItem\"\n      [depth]=\"_depth + 1\"\n      [disableOpener]=\"disableOpener\"\n      [checkboxMode]=\"checkboxMode\"\n      (onSelect)=\"bubbleSelect($event)\"\n      (onCheck)=\"checkItem($event)\"\n      *ngIf=\"(checkboxMode && hasChildren(item)) || (!isFlattened() && hasChildren(item) && !isFolded(item))\">\n    </ode-item-tree>\n  </li>\n</ul>\n", dependencies: [{ kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: i2.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i2.CheckboxControlValueAccessor, selector: "input[type=checkbox][formControlName],input[type=checkbox][formControl],input[type=checkbox][ngModel]" }, { kind: "directive", type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "component", type: ItemTreeComponent, selector: "ode-item-tree", inputs: ["items", "children", "display", "displayTemplate", "filter", "order", "reverse", "flatten", "disableOpener", "checkboxMode", "lastSelected", "depth"], outputs: ["onSelect", "onCheck"] }, { kind: "pipe", type: i3.FilterPipe, name: "filter" }, { kind: "pipe", type: i4.FlattenObjectArrayPipe, name: "flattenObjArray" }, { kind: "pipe", type: i5.OrderPipe, name: "orderBy" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.1.1", ngImport: i0, type: ItemTreeComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ode-item-tree', template: "<ul [ngClass]=\"{ flattened: isFlattened() }\">\n  <li *ngFor=\"let item of (items | flattenObjArray: flatten | filter: filter | orderBy: order:reverse)\"\n      [ngClass]=\"{ selected: isSelected(item), unfolded: !isFolded(item), parent: hasChildren(item), root: _depth === 0 }\">\n    <a href=\"javascript:void(0)\" (click)=\"selectItem(item)\" *ngIf=\"!checkboxMode\">\n      <i class=\"opener\" (click)=\"toggleFold($event, item)\"\n         *ngIf=\"!isFlattened() && hasChildren(item) && !disableOpener\"></i>\n      <span *ngIf=\"displayProperty\">{{ display(item) }}</span>\n      <span *ngIf=\"displayTemplate\">\n        <ng-template [ngTemplateOutlet]=\"displayTemplate\" [ngTemplateOutletContext]=\"{$implicit: item}\"></ng-template>\n      </span>\n    </a>\n    <div class=\"checkbox__item\" *ngIf=\"checkboxMode\">\n      <input id=\"all\" type=\"checkbox\" [(ngModel)]=\"item.check\" ngDefaultControl>\n      <label *ngIf=\"displayProperty\" for=\"all\" (click)=\"checkItem(item)\">{{display(item)}}</label>\n      <span *ngIf=\"displayTemplate\">\n        <ng-template [ngTemplateOutlet]=\"displayTemplate\" [ngTemplateOutletContext]=\"{$implicit: item}\"></ng-template>\n      </span>\n    </div>\n    <ode-item-tree\n      [items]=\"getChildren(item)\"\n      [children]=\"childrenProperty\"\n      [display]=\"displayProperty\"\n      [displayTemplate]=\"displayTemplate\"\n      [filter]=\"filter\"\n      [order]=\"order\"\n      [reverse]=\"reverse\"\n      [lastSelected]=\"_lastSelectedItem\"\n      [depth]=\"_depth + 1\"\n      [disableOpener]=\"disableOpener\"\n      [checkboxMode]=\"checkboxMode\"\n      (onSelect)=\"bubbleSelect($event)\"\n      (onCheck)=\"checkItem($event)\"\n      *ngIf=\"(checkboxMode && hasChildren(item)) || (!isFlattened() && hasChildren(item) && !isFolded(item))\">\n    </ode-item-tree>\n  </li>\n</ul>\n" }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; }, propDecorators: { items: [{
+                type: Input
+            }], childrenProperty: [{
+                type: Input,
+                args: ['children']
+            }], displayProperty: [{
+                type: Input,
+                args: ['display']
+            }], displayTemplate: [{
+                type: Input
+            }], filter: [{
+                type: Input
+            }], order: [{
+                type: Input
+            }], reverse: [{
+                type: Input
+            }], flatten: [{
+                type: Input
+            }], disableOpener: [{
+                type: Input
+            }], checkboxMode: [{
+                type: Input
+            }], onSelect: [{
+                type: Output
+            }], onCheck: [{
+                type: Output
+            }], childItemTree: [{
+                type: ViewChild,
+                args: [ItemTreeComponent]
+            }], _lastSelectedItem: [{
+                type: Input,
+                args: ['lastSelected']
+            }], _depth: [{
+                type: Input,
+                args: ['depth']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"item-tree.component.js","sourceRoot":"","sources":["../../../../../../projects/ngx-ode-ui/src/lib/components/item-tree/item-tree.component.ts","../../../../../../projects/ngx-ode-ui/src/lib/components/item-tree/item-tree.component.html"],"names":[],"mappings":"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","sourcesContent":["import { OdeComponent } from 'ngx-ode-core';\nimport { Component, EventEmitter, Input, OnInit, Output, ViewChild, ContentChild, TemplateRef, Injector } from '@angular/core';\n\n@Component({\n    selector: 'ode-item-tree',\n    templateUrl: './item-tree.component.html'\n})\nexport class ItemTreeComponent<T> extends OdeComponent implements OnInit {\n\n    constructor(injector: Injector) {\n        super(injector);\n    }\n\n    /**** Inputs ****/\n\n    // Items\n    @Input() items: Array<any> = [];\n\n    // Property containing the list of child objects.\n    @Input('children') childrenProperty = 'children';\n    // Property to display in the list\n    @Input('display') displayProperty = 'label';\n    @Input() displayTemplate: TemplateRef<any>;\n    // Filter pipe argument\n    @Input() filter: (Object | string | Function) = '';\n    // OrderBy pipe argument\n    @Input() order: (Array<any> | string | Function) = [];\n    // Reverse the order pipe\n    @Input() reverse: any = false;\n    // Flatten the tree on the specified properties\n    @Input()\n    set flatten(flattenProps: Array<string>) {\n        if (!this.isFlattened() && flattenProps.length > 0) {\n            this._selectedItem = this._lastSelectedItem;\n        } else if (this.isFlattened && flattenProps.length < 1) {\n            this.flagIfParent();\n        }\n        this._flattenProps = flattenProps;\n    }\n    get flatten(): Array<string> {\n        return this._flattenProps;\n    }\n    private _flattenProps: Array<string> = [];\n\n    // Disable the opener icon\n    @Input() disableOpener = false;\n\n    // Use checkboxes instead of selecting items\n    @Input() checkboxMode = false;\n\n    /**** Outputs ****/\n\n    @Output() onSelect: EventEmitter<T> = new EventEmitter<T>();\n\n    @Output() onCheck: EventEmitter<T> = new EventEmitter<T>();\n\n    /**** View ****/\n\n    @ViewChild(ItemTreeComponent) childItemTree: ItemTreeComponent<T>;\n\n    /**** Internal Logic ****/\n\n    @Input('lastSelected') _lastSelectedItem: T;\n    private _selectedItem: T;\n    @Input('depth') _depth = 0;\n    private unfolded: T[] = [];\n\n    ngOnInit() {\n        super.ngOnInit();\n        this.flagIfParent();\n    }\n\n    public selectItem(item: T) {\n        this._selectedItem = item;\n        if (this.childItemTree) {\n            delete this.childItemTree._selectedItem;\n        }\n        const idx = this.unfolded.indexOf(item);\n        if (!this.disableOpener && idx < 0) {\n            this.unfolded.push(item);\n        } else {\n          this.unfolded.splice(idx, 1);\n        }\n        this.bubbleSelect(item);\n    }\n\n    public checkItem(item: T) {\n        this.onCheck.emit(item);\n    }\n\n    public bubbleSelect(item: T) {\n        this._lastSelectedItem = item;\n        this.onSelect.emit(item);\n    }\n\n    public isSelected(item) {\n        return (this.disableOpener ? this._selectedItem : this._lastSelectedItem) === item;\n    }\n\n    public toggleFold(event: Event, item: T) {\n        event.stopPropagation();\n        const idx = this.unfolded.indexOf(item);\n        if (idx < 0) {\n            this.unfolded.push(item);\n        } else {\n            this.unfolded.splice(idx, 1);\n        }\n    }\n\n    public isFolded(item: T) {\n        return this.disableOpener ? !this.isSelected(item) : this.unfolded.indexOf(item) < 0;\n    }\n\n    public display(item: T) {\n        return this.displayProperty && item[this.displayProperty];\n    }\n\n    public getChildren(item) {\n        return item[this.childrenProperty] || [];\n    }\n\n    public hasChildren(item) {\n        return this.getChildren(item).length > 0;\n    }\n\n    isFlattened() {\n        return this._flattenProps.length;\n    }\n\n    private flagIfParent() {\n        if (!this._lastSelectedItem) {\n            return;\n        }\n\n        const findSubItem = (item, target) => {\n            if (item === target) {\n                return true;\n            }\n            if (this.hasChildren(item)) {\n                return this.getChildren(item).find(subItem => {\n                    return findSubItem(subItem, target);\n                });\n            }\n            return false;\n        };\n\n        for (const i in this.items) {\n            const item = this.items[i];\n\n            if (item === this._lastSelectedItem ||\n                    findSubItem(item, this._lastSelectedItem)) {\n                this._selectedItem = item;\n                this.unfolded = [item];\n                break;\n            }\n        }\n\n        this.changeDetector.markForCheck();\n    }\n\n}\n","<ul [ngClass]=\"{ flattened: isFlattened() }\">\n  <li *ngFor=\"let item of (items | flattenObjArray: flatten | filter: filter | orderBy: order:reverse)\"\n      [ngClass]=\"{ selected: isSelected(item), unfolded: !isFolded(item), parent: hasChildren(item), root: _depth === 0 }\">\n    <a href=\"javascript:void(0)\" (click)=\"selectItem(item)\" *ngIf=\"!checkboxMode\">\n      <i class=\"opener\" (click)=\"toggleFold($event, item)\"\n         *ngIf=\"!isFlattened() && hasChildren(item) && !disableOpener\"></i>\n      <span *ngIf=\"displayProperty\">{{ display(item) }}</span>\n      <span *ngIf=\"displayTemplate\">\n        <ng-template [ngTemplateOutlet]=\"displayTemplate\" [ngTemplateOutletContext]=\"{$implicit: item}\"></ng-template>\n      </span>\n    </a>\n    <div class=\"checkbox__item\" *ngIf=\"checkboxMode\">\n      <input id=\"all\" type=\"checkbox\" [(ngModel)]=\"item.check\" ngDefaultControl>\n      <label *ngIf=\"displayProperty\" for=\"all\" (click)=\"checkItem(item)\">{{display(item)}}</label>\n      <span *ngIf=\"displayTemplate\">\n        <ng-template [ngTemplateOutlet]=\"displayTemplate\" [ngTemplateOutletContext]=\"{$implicit: item}\"></ng-template>\n      </span>\n    </div>\n    <ode-item-tree\n      [items]=\"getChildren(item)\"\n      [children]=\"childrenProperty\"\n      [display]=\"displayProperty\"\n      [displayTemplate]=\"displayTemplate\"\n      [filter]=\"filter\"\n      [order]=\"order\"\n      [reverse]=\"reverse\"\n      [lastSelected]=\"_lastSelectedItem\"\n      [depth]=\"_depth + 1\"\n      [disableOpener]=\"disableOpener\"\n      [checkboxMode]=\"checkboxMode\"\n      (onSelect)=\"bubbleSelect($event)\"\n      (onCheck)=\"checkItem($event)\"\n      *ngIf=\"(checkboxMode && hasChildren(item)) || (!isFlattened() && hasChildren(item) && !isFolded(item))\">\n    </ode-item-tree>\n  </li>\n</ul>\n"]}