ngx-ode-ui 4.6.0-dev-produit.2 → 4.6.0-dev-integration.2

package/esm2015/lib/components/datepicker/datepicker.component.js

@@ -0,0 +1,261 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/components/datepicker/datepicker.component.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { OdeComponent } from 'ngx-ode-core';
+import { Component, ElementRef, EventEmitter, forwardRef, Input, Output, Renderer2, ViewChild, Injector } from '@angular/core';
+import { NG_VALUE_ACCESSOR, NgModel } from '@angular/forms';
+import { LabelsService } from '../../services/labels.service';
+import Flatpickr from 'flatpickr';
+import French from 'flatpickr/dist/l10n/fr.js';
+// access ngmodel
+/** @type {?} */
+const NOOP = (/**
+ * @return {?}
+ */
+() => {
+});
+const ɵ0 = NOOP;
+/** @type {?} */
+export const CUSTOM_INPUT_CONTROL_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: forwardRef((/**
+     * @return {?}
+     */
+    () => DatepickerComponent)),
+    multi: true
+};
+export class DatepickerComponent extends OdeComponent {
+    /**
+     * @param {?} renderer
+     * @param {?} labelsService
+     * @param {?} injector
+     */
+    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;
+    }
+    /**
+     * @return {?}
+     */
+    get value() {
+        return this.innerValue;
+    }
+    /**
+     * @param {?} v
+     * @return {?}
+     */
+    set value(v) {
+        /** @type {?} */
+        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);
+            }
+        }
+    }
+    /**
+     * @param {?} val
+     * @return {?}
+     */
+    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');
+        }
+    }
+    /**
+     * @return {?}
+     */
+    get readonly() {
+        return this._readonly;
+    }
+    /**
+     * @return {?}
+     */
+    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();
+        }
+        /** @type {?} */
+        const navigatorLanguage = navigator.language.split('-')[0];
+        /** @type {?} */
+        let datePickerLocale = {};
+        if (navigatorLanguage === 'fr') {
+            datePickerLocale = French.fr;
+        }
+        // options for the flatpickr instance
+        /** @type {?} */
+        const options = {
+            altInput: !this.disabled,
+            altFormat: 'd/m/Y',
+            // date format displayed to user
+            dateFormat: 'Y-m-d',
+            // date format sent to server
+            allowInput: false,
+            enableTime: this.enableTime,
+            minDate: this.minDate,
+            maxDate: this.maxDate,
+            clickOpens: false,
+            wrap: true,
+            // to add input decoration (calendar icon and delete icon)
+            locale: datePickerLocale
+        };
+        this.datePickerInst = new Flatpickr(this.datePickerElement.nativeElement, options);
+        if (!this.disabled) {
+            this.datePickerInst.altInput.addEventListener('click', (/**
+             * @param {?} e
+             * @return {?}
+             */
+            e => {
+                if (!this.readonly) {
+                    this.datePickerInst.toggle();
+                }
+            }));
+        }
+        // Force updating the date input readonly attribute :
+        this.readonly = this._readonly;
+    }
+    /**
+     * @return {?}
+     */
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this.datePickerInst.destroy();
+    }
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    writeValue(value) {
+        if (value !== this.innerValue && this.datePickerInst) {
+            this.innerValue = value;
+            this.datePickerInst.setDate(value);
+            this.onChangeCallback(value);
+        }
+    }
+    /**
+     * @param {?} fn
+     * @return {?}
+     */
+    registerOnChange(fn) {
+        this.onChangeCallback = fn;
+    }
+    /**
+     * @param {?} fn
+     * @return {?}
+     */
+    registerOnTouched(fn) {
+        this.onTouchedCallback = fn;
+    }
+    /**
+     * @param {?} label
+     * @return {?}
+     */
+    labels(label) {
+        return this.labelsService.getLabel(label);
+    }
+}
+DatepickerComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'ode-date-picker',
+                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",
+                providers: [CUSTOM_INPUT_CONTROL_VALUE_ACCESSOR],
+                styles: [".hidden{visibility:hidden}"]
+            }] }
+];
+/** @nocollapse */
+DatepickerComponent.ctorParameters = () => [
+    { type: Renderer2 },
+    { type: LabelsService },
+    { type: Injector }
+];
+DatepickerComponent.propDecorators = {
+    datePickerElement: [{ type: ViewChild, args: ['datePickerElement', { static: false },] }],
+    inputElement: [{ type: ViewChild, args: ['inputRef', { static: false },] }],
+    model: [{ type: ViewChild, args: [NgModel, { static: false },] }],
+    disabled: [{ type: Input }],
+    readonly: [{ type: Input }],
+    enableTime: [{ type: Input }],
+    placeholder: [{ type: Input }],
+    minDate: [{ type: Input }],
+    maxDate: [{ type: Input }],
+    changeDate: [{ type: Output }]
+};
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    DatepickerComponent.prototype.innerValue;
+    /** @type {?} */
+    DatepickerComponent.prototype.datePickerElement;
+    /** @type {?} */
+    DatepickerComponent.prototype.inputElement;
+    /**
+     * @type {?}
+     * @private
+     */
+    DatepickerComponent.prototype.datePickerInst;
+    /** @type {?} */
+    DatepickerComponent.prototype.model;
+    /** @type {?} */
+    DatepickerComponent.prototype.disabled;
+    /** @type {?} */
+    DatepickerComponent.prototype._readonly;
+    /** @type {?} */
+    DatepickerComponent.prototype.enableTime;
+    /** @type {?} */
+    DatepickerComponent.prototype.placeholder;
+    /** @type {?} */
+    DatepickerComponent.prototype.minDate;
+    /** @type {?} */
+    DatepickerComponent.prototype.maxDate;
+    /** @type {?} */
+    DatepickerComponent.prototype.changeDate;
+    /**
+     * @type {?}
+     * @private
+     */
+    DatepickerComponent.prototype.onChangeCallback;
+    /**
+     * @type {?}
+     * @private
+     */
+    DatepickerComponent.prototype.onTouchedCallback;
+    /**
+     * @type {?}
+     * @private
+     */
+    DatepickerComponent.prototype.renderer;
+    /**
+     * @type {?}
+     * @private
+     */
+    DatepickerComponent.prototype.labelsService;
+}
+export { ɵ0 };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datepicker.component.js","sourceRoot":"ng://ngx-ode-ui/","sources":["lib/components/datepicker/datepicker.component.ts"],"names":[],"mappings":";;;;;AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,EAAiB,SAAS,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,EACrE,KAAK,EAAa,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAElF,OAAO,EAAwB,iBAAiB,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAElF,OAAO,EAAC,aAAa,EAAC,MAAM,+BAA+B,CAAC;AAC5D,OAAO,SAAS,MAAM,WAAW,CAAC;AAClC,OAAO,MAAM,MAAM,2BAA2B,CAAC;;;MAGzC,IAAI;;;AAAG,GAAG,EAAE;AAClB,CAAC,CAAA;;;AACD,MAAM,OAAO,mCAAmC,GAAQ;IACpD,OAAO,EAAE,iBAAiB;IAC1B,WAAW,EAAE,UAAU;;;IAAC,GAAG,EAAE,CAAC,mBAAmB,EAAC;IAClD,KAAK,EAAE,IAAI;CACd;AAQD,MAAM,OAAO,mBAAoB,SAAQ,YAAY;;;;;;IAEjD,YAAoB,QAAmB,EACnB,aAA4B,EACpC,QAAkB;QACd,KAAK,CAAC,QAAQ,CAAC,CAAC;QAHZ,aAAQ,GAAR,QAAQ,CAAW;QACnB,kBAAa,GAAb,aAAa,CAAe;QAwBxC,eAAU,GAAQ,EAAE,CAAC;QAe7B,aAAQ,GAAG,KAAK,CAAC;QAcjB,cAAS,GAAG,KAAK,CAAC;QAGlB,eAAU,GAAG,KAAK,CAAC;QAGnB,gBAAW,GAAG,EAAE,CAAC;QASjB,eAAU,GAAyB,IAAI,YAAY,EAAU,CAAC;QAEtD,qBAAgB,GAAqB,IAAI,CAAC;QAC1C,sBAAiB,GAAe,IAAI,CAAC;IApEjC,CAAC;;;;IAEb,IAAI,KAAK;QACL,OAAO,IAAI,CAAC,UAAU,CAAC;IAC3B,CAAC;;;;;IAED,IAAI,KAAK,CAAC,CAAM;;YACR,IAAI,GAAG,KAAK;QAChB,IAAI,IAAI,CAAC,UAAU,KAAK,SAAS,EAAE;YAC/B,IAAI,GAAG,IAAI,CAAC;SACf;QACD,IAAI,CAAC,KAAK,IAAI,CAAC,UAAU,EAAE;YACvB,IAAI,CAAC,UAAU,GAAG,CAAC,CAAC;YACpB,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC;YACzB,IAAI,CAAC,IAAI,EAAE;gBACP,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;aAC3B;SAEJ;IACL,CAAC;;;;;IAmBD,IACI,QAAQ,CAAE,GAAW;QACrB,IAAI,CAAC,SAAS,GAAG,GAAG,CAAC;QACrB,IAAI,IAAI,CAAC,cAAc,IAAI,IAAI,CAAC,cAAc,CAAC,QAAQ,EAAG;YACtD,+EAA+E;YAC/E,IAAI,GAAG;gBAAG,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,YAAY,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC;;gBAC1D,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC;SACtE;IACL,CAAC;;;;IACD,IAAI,QAAQ;QACR,OAAO,IAAI,CAAC,SAAS,CAAC;IAC1B,CAAC;;;;IAqBD,eAAe;QACX,KAAK,CAAC,eAAe,EAAE,CAAC;QACxB,qEAAqE;QACrE,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC,aAAa,EAAE,YAAY,EAAE,EAAE,CAAC,CAAC;QAE9E,gBAAgB;QAChB,IAAI,IAAI,CAAC,QAAQ,KAAK,IAAI,EAAE;YACxB,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;SAChC;;cAEK,iBAAiB,GAAG,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;;YACtD,gBAAgB,GAAG,EAAE;QACzB,IAAI,iBAAiB,KAAK,IAAI,EAAE;YAC5B,gBAAgB,GAAG,MAAM,CAAC,EAAE,CAAC;SAChC;;;cAGK,OAAO,GAAG;YACZ,QAAQ,EAAE,CAAC,IAAI,CAAC,QAAQ;YACxB,SAAS,EAAE,OAAO;;YAClB,UAAU,EAAE,OAAO;;YACnB,UAAU,EAAE,KAAK;YACjB,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,UAAU,EAAE,KAAK;YACjB,IAAI,EAAE,IAAI;;YACV,MAAM,EAAE,gBAAgB;SAC3B;QAED,IAAI,CAAC,cAAc,GAAG,IAAI,SAAS,CAAC,IAAI,CAAC,iBAAiB,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;QACnF,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAG;YACjB,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,gBAAgB,CAAC,OAAO;;;;YAAE,CAAC,CAAC,EAAE;gBACvD,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAG;oBACjB,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC;iBAChC;YACL,CAAC,EAAC,CAAC;SACN;QAED,qDAAqD;QACrD,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC;IACnC,CAAC;;;;IAED,WAAW;QACP,KAAK,CAAC,WAAW,EAAE,CAAC;QACpB,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,CAAC;IAClC,CAAC;;;;;IAED,UAAU,CAAC,KAAU;QACjB,IAAI,KAAK,KAAK,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,cAAc,EAAE;YAClD,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;YACxB,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YACnC,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;SAChC;IACL,CAAC;;;;;IAED,gBAAgB,CAAC,EAAO;QACpB,IAAI,CAAC,gBAAgB,GAAG,EAAE,CAAC;IAC/B,CAAC;;;;;IAED,iBAAiB,CAAC,EAAO;QACrB,IAAI,CAAC,iBAAiB,GAAG,EAAE,CAAC;IAChC,CAAC;;;;;IAED,MAAM,CAAC,KAAK;QACR,OAAO,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC9C,CAAC;;;YApJJ,SAAS,SAAC;gBACP,QAAQ,EAAE,iBAAiB;gBAC3B,gjBAA0C;gBAE1C,SAAS,EAAE,CAAE,mCAAmC,CAAE;;aACrD;;;;YAtB2B,SAAS;YAI7B,aAAa;YAJ6B,QAAQ;;;gCAoDrD,SAAS,SAAC,mBAAmB,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE;2BAGhD,SAAS,SAAC,UAAU,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE;oBAMvC,SAAS,SAAC,OAAO,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE;uBAGpC,KAAK;uBAGL,KAAK;yBAcL,KAAK;0BAGL,KAAK;sBAGL,KAAK;sBAGL,KAAK;yBAGL,MAAM;;;;;;;IA3CP,yCAA6B;;IAE7B,gDAC8B;;IAE9B,2CACyB;;;;;IAGzB,6CAAkC;;IAElC,oCACe;;IAEf,uCACiB;;IAcjB,wCAAkB;;IAElB,yCACmB;;IAEnB,0CACiB;;IAEjB,sCACQ;;IAER,sCACQ;;IAER,yCAC8D;;;;;IAE9D,+CAAkD;;;;;IAClD,gDAA6C;;;;;IAxEjC,uCAA2B;;;;;IAC3B,4CAAoC","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', { static: false })\n    datePickerElement: ElementRef;\n\n    @ViewChild('inputRef', { static: false })\n    inputElement: ElementRef;\n\n    // instance flatpickr\n    private datePickerInst: Flatpickr;\n\n    @ViewChild(NgModel, { static: false })\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"]}

package/esm2015/lib/components/dropdown/dropdown.component.js

@@ -0,0 +1,76 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/components/dropdown/dropdown.component.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Component, Input, Output, EventEmitter, Injector } from '@angular/core';
+import { OdeComponent } from 'ngx-ode-core';
+/**
+ * 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 {
+    /**
+     * @param {?} injector
+     */
+    constructor(injector) {
+        super(injector);
+        this.name = '';
+        this.isDropdownOpened = false;
+        this.onDropdown = new EventEmitter();
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() {
+        super.ngOnInit();
+    }
+}
+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 0 rgba(0,0,0,.15);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)}"]
+            }] }
+];
+/** @nocollapse */
+DropdownComponent.ctorParameters = () => [
+    { type: Injector }
+];
+DropdownComponent.propDecorators = {
+    name: [{ type: Input }],
+    isDropdownOpened: [{ type: Input }],
+    onDropdown: [{ type: Output }]
+};
+if (false) {
+    /** @type {?} */
+    DropdownComponent.prototype.name;
+    /** @type {?} */
+    DropdownComponent.prototype.isDropdownOpened;
+    /** @type {?} */
+    DropdownComponent.prototype.onDropdown;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/ellipsis/ellipsis.component.js

@@ -0,0 +1,98 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/components/ellipsis/ellipsis.component.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { OdeComponent } from 'ngx-ode-core';
+import { Component, ElementRef, Input, Injector } 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 {
+    /**
+     * @param {?} eltRef
+     * @param {?} injector
+     */
+    constructor(eltRef, injector) {
+        super(injector);
+        this.eltRef = eltRef;
+        this._ellipsis = 'hide';
+        this.isExpanded = false;
+        this.initialStyle = Object.assign({}, this.eltRef.nativeElement.style);
+    }
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    set ellipsis(value) {
+        if (!!value) {
+            this._ellipsis = value;
+            if (this._ellipsis == 'expand') {
+                this.eltRef.nativeElement.className = 'expand';
+            }
+        }
+    }
+    /**
+     * @return {?}
+     */
+    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.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}"]
+            }] }
+];
+/** @nocollapse */
+EllipsisComponent.ctorParameters = () => [
+    { type: ElementRef },
+    { type: Injector }
+];
+EllipsisComponent.propDecorators = {
+    ellipsis: [{ type: Input }]
+};
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    EllipsisComponent.prototype._ellipsis;
+    /**
+     * @type {?}
+     * @private
+     */
+    EllipsisComponent.prototype.isExpanded;
+    /**
+     * @type {?}
+     * @private
+     */
+    EllipsisComponent.prototype.initialStyle;
+    /**
+     * @type {?}
+     * @private
+     */
+    EllipsisComponent.prototype.eltRef;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/form-errors/form-errors.component.js

@@ -0,0 +1,65 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/components/form-errors/form-errors.component.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { OdeComponent } from 'ngx-ode-core';
+import { Component, Input, Injector } from '@angular/core';
+import { AbstractControl } from '@angular/forms';
+import { LabelsService } from '../../services/labels.service';
+export class FormErrorsComponent extends OdeComponent {
+    /**
+     * @param {?} labelsService
+     * @param {?} injector
+     */
+    constructor(labelsService, injector) {
+        super(injector);
+        this.labelsService = labelsService;
+    }
+    /**
+     * @return {?}
+     */
+    getErrorsArray() {
+        /** @type {?} */
+        const errorsArray = [];
+        for (const prop in this.ref.errors) {
+            errorsArray.push({ name: prop, value: this.ref.errors[prop] });
+        }
+        return errorsArray;
+    }
+    /**
+     * @param {?} label
+     * @return {?}
+     */
+    labels(label) {
+        return this.labelsService.getLabel(label);
+    }
+}
+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}"]
+            }] }
+];
+/** @nocollapse */
+FormErrorsComponent.ctorParameters = () => [
+    { type: LabelsService },
+    { type: Injector }
+];
+FormErrorsComponent.propDecorators = {
+    ref: [{ type: Input, args: ['control',] }],
+    expectedPatternMsg: [{ type: Input, args: ['expectedPatternMsg',] }]
+};
+if (false) {
+    /** @type {?} */
+    FormErrorsComponent.prototype.ref;
+    /** @type {?} */
+    FormErrorsComponent.prototype.expectedPatternMsg;
+    /**
+     * @type {?}
+     * @private
+     */
+    FormErrorsComponent.prototype.labelsService;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybS1lcnJvcnMuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6Im5nOi8vbmd4LW9kZS11aS8iLCJzb3VyY2VzIjpbImxpYi9jb21wb25lbnRzL2Zvcm0tZXJyb3JzL2Zvcm0tZXJyb3JzLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFDNUMsT0FBTyxFQUFFLFNBQVMsRUFBRSxLQUFLLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNELE9BQU8sRUFBQyxlQUFlLEVBQUMsTUFBTSxnQkFBZ0IsQ0FBQztBQUUvQyxPQUFPLEVBQUMsYUFBYSxFQUFDLE1BQU0sK0JBQStCLENBQUM7QUFPNUQsTUFBTSxPQUFPLG1CQUFvQixTQUFRLFlBQVk7Ozs7O0lBQ2pELFlBQW9CLGFBQTRCLEVBQUUsUUFBa0I7UUFDaEUsS0FBSyxDQUFDLFFBQVEsQ0FBQyxDQUFDO1FBREEsa0JBQWEsR0FBYixhQUFhLENBQWU7SUFFaEQsQ0FBQzs7OztJQVNELGNBQWM7O2NBQ0osV0FBVyxHQUFHLEVBQUU7UUFDdEIsS0FBSyxNQUFNLElBQUksSUFBSSxJQUFJLENBQUMsR0FBRyxDQUFDLE1BQU0sRUFBRTtZQUNoQyxXQUFXLENBQUMsSUFBSSxDQUFDLEVBQUUsSUFBSSxFQUFFLElBQUksRUFBRSxLQUFLLEVBQUUsSUFBSSxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEVBQUMsQ0FBQyxDQUFDO1NBQ2pFO1FBQ0QsT0FBTyxXQUFXLENBQUM7SUFDdkIsQ0FBQzs7Ozs7SUFFRCxNQUFNLENBQUMsS0FBSztRQUNSLE9BQU8sSUFBSSxDQUFDLGFBQWEsQ0FBQyxRQUFRLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDOUMsQ0FBQzs7O1lBM0JKLFNBQVMsU0FBQztnQkFDUCxRQUFRLEVBQUUsaUJBQWlCO2dCQUMzQiw4VEFBMkM7O2FBRTlDOzs7O1lBTk8sYUFBYTtZQUhNLFFBQVE7OztrQkFlOUIsS0FBSyxTQUFDLFNBQVM7aUNBR2YsS0FBSyxTQUFDLG9CQUFvQjs7OztJQUgzQixrQ0FDcUI7O0lBRXJCLGlEQUMyQjs7Ozs7SUFSZiw0Q0FBb0MiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBPZGVDb21wb25lbnQgfSBmcm9tICduZ3gtb2RlLWNvcmUnO1xuaW1wb3J0IHsgQ29tcG9uZW50LCBJbnB1dCwgSW5qZWN0b3IgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7QWJzdHJhY3RDb250cm9sfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XG5cbmltcG9ydCB7TGFiZWxzU2VydmljZX0gZnJvbSAnLi4vLi4vc2VydmljZXMvbGFiZWxzLnNlcnZpY2UnO1xuXG5AQ29tcG9uZW50KHtcbiAgICBzZWxlY3RvcjogJ29kZS1mb3JtLWVycm9ycycsXG4gICAgdGVtcGxhdGVVcmw6ICcuL2Zvcm0tZXJyb3JzLmNvbXBvbmVudC5odG1sJyxcbiAgICBzdHlsZVVybHM6IFsnLi9mb3JtLWVycm9ycy5jb21wb25lbnQuc2NzcyddXG59KVxuZXhwb3J0IGNsYXNzIEZvcm1FcnJvcnNDb21wb25lbnQgZXh0ZW5kcyBPZGVDb21wb25lbnQge1xuICAgIGNvbnN0cnVjdG9yKHByaXZhdGUgbGFiZWxzU2VydmljZTogTGFiZWxzU2VydmljZSwgaW5qZWN0b3I6IEluamVjdG9yKSB7XG4gICAgICAgIHN1cGVyKGluamVjdG9yKTtcbiAgICB9XG5cbiAgICBASW5wdXQoJ2NvbnRyb2wnKVxuICAgIHJlZjogQWJzdHJhY3RDb250cm9sO1xuXG4gICAgQElucHV0KCdleHBlY3RlZFBhdHRlcm5Nc2cnKVxuICAgIGV4cGVjdGVkUGF0dGVybk1zZzogc3RyaW5nO1xuXG5cbiAgICBnZXRFcnJvcnNBcnJheSgpIHtcbiAgICAgICAgY29uc3QgZXJyb3JzQXJyYXkgPSBbXTtcbiAgICAgICAgZm9yIChjb25zdCBwcm9wIGluIHRoaXMucmVmLmVycm9ycykge1xuICAgICAgICAgICAgZXJyb3JzQXJyYXkucHVzaCh7IG5hbWU6IHByb3AsIHZhbHVlOiB0aGlzLnJlZi5lcnJvcnNbcHJvcF19KTtcbiAgICAgICAgfVxuICAgICAgICByZXR1cm4gZXJyb3JzQXJyYXk7XG4gICAgfVxuXG4gICAgbGFiZWxzKGxhYmVsKSB7XG4gICAgICAgIHJldHVybiB0aGlzLmxhYmVsc1NlcnZpY2UuZ2V0TGFiZWwobGFiZWwpO1xuICAgIH1cbn1cbiJdfQ==

package/esm2015/lib/components/form-field/form-field.component.js

@@ -0,0 +1,40 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/components/form-field/form-field.component.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Component, Input, Injector } from '@angular/core';
+import { OdeComponent } from 'ngx-ode-core';
+export class FormFieldComponent extends OdeComponent {
+    /**
+     * @param {?} injector
+     */
+    constructor(injector) {
+        super(injector);
+    }
+}
+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}"]
+            }] }
+];
+/** @nocollapse */
+FormFieldComponent.ctorParameters = () => [
+    { type: Injector }
+];
+FormFieldComponent.propDecorators = {
+    label: [{ type: Input }],
+    help: [{ type: Input }],
+    required: [{ type: Input }]
+};
+if (false) {
+    /** @type {?} */
+    FormFieldComponent.prototype.label;
+    /** @type {?} */
+    FormFieldComponent.prototype.help;
+    /** @type {?} */
+    FormFieldComponent.prototype.required;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybS1maWVsZC5jb21wb25lbnQuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9uZ3gtb2RlLXVpLyIsInNvdXJjZXMiOlsibGliL2NvbXBvbmVudHMvZm9ybS1maWVsZC9mb3JtLWZpZWxkLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzRCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sY0FBYyxDQUFDO0FBTzVDLE1BQU0sT0FBTyxrQkFBbUIsU0FBUSxZQUFZOzs7O0lBS2xELFlBQVksUUFBa0I7UUFDNUIsS0FBSyxDQUFDLFFBQVEsQ0FBQyxDQUFDO0lBQ2xCLENBQUM7OztZQVpGLFNBQVMsU0FBQztnQkFDVCxRQUFRLEVBQUUsZ0JBQWdCO2dCQUMxQix1VkFBMEM7O2FBRTNDOzs7O1lBUDBCLFFBQVE7OztvQkFTaEMsS0FBSzttQkFDTCxLQUFLO3VCQUNMLEtBQUs7Ozs7SUFGTixtQ0FBdUI7O0lBQ3ZCLGtDQUFzQjs7SUFDdEIsc0NBQTJCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50LCBJbnB1dCwgSW5qZWN0b3IgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IE9kZUNvbXBvbmVudCB9IGZyb20gJ25neC1vZGUtY29yZSc7XG5cbkBDb21wb25lbnQoe1xuICBzZWxlY3RvcjogJ29kZS1mb3JtLWZpZWxkJyxcbiAgdGVtcGxhdGVVcmw6ICcuL2Zvcm0tZmllbGQuY29tcG9uZW50Lmh0bWwnLFxuICBzdHlsZVVybHM6IFsnLi9mb3JtLWZpZWxkLmNvbXBvbmVudC5zY3NzJ11cbn0pXG5leHBvcnQgY2xhc3MgRm9ybUZpZWxkQ29tcG9uZW50IGV4dGVuZHMgT2RlQ29tcG9uZW50IHtcbiAgQElucHV0KCkgbGFiZWw6IHN0cmluZztcbiAgQElucHV0KCkgaGVscDogc3RyaW5nO1xuICBASW5wdXQoKSByZXF1aXJlZDogYm9vbGVhbjtcblxuICBjb25zdHJ1Y3RvcihpbmplY3RvcjogSW5qZWN0b3IpIHtcbiAgICBzdXBlcihpbmplY3Rvcik7XG4gIH1cbn1cbiJdfQ==