@netgrif/components-core 6.0.1

package/esm2015/lib/data-fields/enumeration-field/enumeration-stepper-field/abstract-enumeration-stepper-field.component.js

@@ -0,0 +1,40 @@
+import { Input, ViewChildren } from '@angular/core';
+export class AbstractEnumerationStepperFieldComponent {
+    constructor(ref) {
+        this.ref = ref;
+        this.arrowStepper = false;
+    }
+    ngOnInit() {
+        if (this.enumerationField && this.enumerationField.component && this.enumerationField.component.properties &&
+            this.enumerationField.component.properties.arrowStepper) {
+            this.arrowStepper = this.enumerationField.component.properties.arrowStepper === 'true';
+        }
+    }
+    canShowDoneIcon(index) {
+        return index <= this.enumerationField.choices.findIndex(choice => choice.key === this.enumerationField.value);
+    }
+    isSelected(key) {
+        return key === this.enumerationField.value;
+    }
+    ngAfterViewChecked() {
+        if (!!this.steps && !!this.steps.toArray()) {
+            const width = this.ref.nativeElement.parentElement.offsetWidth;
+            const maxWidth = (width + (this.enumerationField.choices.length - 1) * 20) / this.enumerationField.choices.length;
+            this.steps.toArray().forEach(step => {
+                step.nativeElement.style.maxWidth = maxWidth >= 72 ? maxWidth + 'px' : '72px';
+            });
+        }
+    }
+    setStepperValue(key) {
+        if (!this.enumerationField.disabled) {
+            this.formControlRef.setValue(key);
+        }
+    }
+}
+AbstractEnumerationStepperFieldComponent.propDecorators = {
+    enumerationField: [{ type: Input }],
+    formControlRef: [{ type: Input }],
+    showLargeLayout: [{ type: Input }],
+    steps: [{ type: ViewChildren, args: ['oneStep',] }]
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWJzdHJhY3QtZW51bWVyYXRpb24tc3RlcHBlci1maWVsZC5jb21wb25lbnQuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AbmV0Z3JpZi9jb21wb25lbnRzLWNvcmUvIiwic291cmNlcyI6WyJsaWIvZGF0YS1maWVsZHMvZW51bWVyYXRpb24tZmllbGQvZW51bWVyYXRpb24tc3RlcHBlci1maWVsZC9hYnN0cmFjdC1lbnVtZXJhdGlvbi1zdGVwcGVyLWZpZWxkLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQStCLEtBQUssRUFBcUIsWUFBWSxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBS25HLE1BQU0sT0FBTyx3Q0FBd0M7SUFRakQsWUFBc0IsR0FBZTtRQUFmLFFBQUcsR0FBSCxHQUFHLENBQVk7UUFDakMsSUFBSSxDQUFDLFlBQVksR0FBRyxLQUFLLENBQUM7SUFDOUIsQ0FBQztJQUVELFFBQVE7UUFDSixJQUFJLElBQUksQ0FBQyxnQkFBZ0IsSUFBSSxJQUFJLENBQUMsZ0JBQWdCLENBQUMsU0FBUyxJQUFJLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxTQUFTLENBQUMsVUFBVTtZQUN0RyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsU0FBUyxDQUFDLFVBQVUsQ0FBQyxZQUFZLEVBQUU7WUFDekQsSUFBSSxDQUFDLFlBQVksR0FBRyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsU0FBUyxDQUFDLFVBQVUsQ0FBQyxZQUFZLEtBQUssTUFBTSxDQUFDO1NBQzFGO0lBQ0wsQ0FBQztJQUVELGVBQWUsQ0FBQyxLQUFhO1FBQ3pCLE9BQU8sS0FBSyxJQUFJLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxPQUFPLENBQUMsU0FBUyxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUMsTUFBTSxDQUFDLEdBQUcsS0FBSyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDbEgsQ0FBQztJQUVELFVBQVUsQ0FBQyxHQUFXO1FBQ2xCLE9BQU8sR0FBRyxLQUFLLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxLQUFLLENBQUM7SUFDL0MsQ0FBQztJQUVELGtCQUFrQjtRQUNkLElBQUksQ0FBQyxDQUFDLElBQUksQ0FBQyxLQUFLLElBQUksQ0FBQyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsT0FBTyxFQUFFLEVBQUU7WUFDeEMsTUFBTSxLQUFLLEdBQUcsSUFBSSxDQUFDLEdBQUcsQ0FBQyxhQUFhLENBQUMsYUFBYSxDQUFDLFdBQVcsQ0FBQztZQUMvRCxNQUFNLFFBQVEsR0FBRyxDQUFDLEtBQUssR0FBRyxDQUFDLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxPQUFPLENBQUMsTUFBTSxHQUFHLENBQUMsQ0FBQyxHQUFHLEVBQUUsQ0FBQyxHQUFHLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDO1lBQ2xILElBQUksQ0FBQyxLQUFLLENBQUMsT0FBTyxFQUFFLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxFQUFFO2dCQUNoQyxJQUFJLENBQUMsYUFBYSxDQUFDLEtBQUssQ0FBQyxRQUFRLEdBQUcsUUFBUSxJQUFJLEVBQUUsQ0FBQyxDQUFDLENBQUMsUUFBUSxHQUFHLElBQUksQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDO1lBQ2xGLENBQUMsQ0FBQyxDQUFDO1NBQ047SUFDTCxDQUFDO0lBRUQsZUFBZSxDQUFDLEdBQVc7UUFDdkIsSUFBSSxDQUFDLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxRQUFRLEVBQUU7WUFDakMsSUFBSSxDQUFDLGNBQWMsQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLENBQUM7U0FDckM7SUFDTCxDQUFDOzs7K0JBdkNBLEtBQUs7NkJBQ0wsS0FBSzs4QkFDTCxLQUFLO29CQUNMLFlBQVksU0FBQyxTQUFTIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtBZnRlclZpZXdDaGVja2VkLCBFbGVtZW50UmVmLCBJbnB1dCwgT25Jbml0LCBRdWVyeUxpc3QsIFZpZXdDaGlsZHJlbn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge0VudW1lcmF0aW9uRmllbGR9IGZyb20gJy4uL21vZGVscy9lbnVtZXJhdGlvbi1maWVsZCc7XG5pbXBvcnQge0Zvcm1Db250cm9sfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XG5pbXBvcnQge1dyYXBwZWRCb29sZWFufSBmcm9tICcuLi8uLi9kYXRhLWZpZWxkLXRlbXBsYXRlL21vZGVscy93cmFwcGVkLWJvb2xlYW4nO1xuXG5leHBvcnQgY2xhc3MgQWJzdHJhY3RFbnVtZXJhdGlvblN0ZXBwZXJGaWVsZENvbXBvbmVudCBpbXBsZW1lbnRzIE9uSW5pdCwgQWZ0ZXJWaWV3Q2hlY2tlZCB7XG5cbiAgICBASW5wdXQoKSBlbnVtZXJhdGlvbkZpZWxkOiBFbnVtZXJhdGlvbkZpZWxkO1xuICAgIEBJbnB1dCgpIGZvcm1Db250cm9sUmVmOiBGb3JtQ29udHJvbDtcbiAgICBASW5wdXQoKSBzaG93TGFyZ2VMYXlvdXQ6IFdyYXBwZWRCb29sZWFuO1xuICAgIEBWaWV3Q2hpbGRyZW4oJ29uZVN0ZXAnKSBzdGVwczogUXVlcnlMaXN0PEVsZW1lbnRSZWY+O1xuICAgIHB1YmxpYyBhcnJvd1N0ZXBwZXI6IGJvb2xlYW47XG5cbiAgICBjb25zdHJ1Y3Rvcihwcm90ZWN0ZWQgcmVmOiBFbGVtZW50UmVmKSB7XG4gICAgICAgIHRoaXMuYXJyb3dTdGVwcGVyID0gZmFsc2U7XG4gICAgfVxuXG4gICAgbmdPbkluaXQoKSB7XG4gICAgICAgIGlmICh0aGlzLmVudW1lcmF0aW9uRmllbGQgJiYgdGhpcy5lbnVtZXJhdGlvbkZpZWxkLmNvbXBvbmVudCAmJiB0aGlzLmVudW1lcmF0aW9uRmllbGQuY29tcG9uZW50LnByb3BlcnRpZXMgJiZcbiAgICAgICAgICAgIHRoaXMuZW51bWVyYXRpb25GaWVsZC5jb21wb25lbnQucHJvcGVydGllcy5hcnJvd1N0ZXBwZXIpIHtcbiAgICAgICAgICAgIHRoaXMuYXJyb3dTdGVwcGVyID0gdGhpcy5lbnVtZXJhdGlvbkZpZWxkLmNvbXBvbmVudC5wcm9wZXJ0aWVzLmFycm93U3RlcHBlciA9PT0gJ3RydWUnO1xuICAgICAgICB9XG4gICAgfVxuXG4gICAgY2FuU2hvd0RvbmVJY29uKGluZGV4OiBudW1iZXIpOiBib29sZWFuIHtcbiAgICAgICAgcmV0dXJuIGluZGV4IDw9IHRoaXMuZW51bWVyYXRpb25GaWVsZC5jaG9pY2VzLmZpbmRJbmRleChjaG9pY2UgPT4gY2hvaWNlLmtleSA9PT0gdGhpcy5lbnVtZXJhdGlvbkZpZWxkLnZhbHVlKTtcbiAgICB9XG5cbiAgICBpc1NlbGVjdGVkKGtleTogc3RyaW5nKTogYm9vbGVhbiB7XG4gICAgICAgIHJldHVybiBrZXkgPT09IHRoaXMuZW51bWVyYXRpb25GaWVsZC52YWx1ZTtcbiAgICB9XG5cbiAgICBuZ0FmdGVyVmlld0NoZWNrZWQoKSB7XG4gICAgICAgIGlmICghIXRoaXMuc3RlcHMgJiYgISF0aGlzLnN0ZXBzLnRvQXJyYXkoKSkge1xuICAgICAgICAgICAgY29uc3Qgd2lkdGggPSB0aGlzLnJlZi5uYXRpdmVFbGVtZW50LnBhcmVudEVsZW1lbnQub2Zmc2V0V2lkdGg7XG4gICAgICAgICAgICBjb25zdCBtYXhXaWR0aCA9ICh3aWR0aCArICh0aGlzLmVudW1lcmF0aW9uRmllbGQuY2hvaWNlcy5sZW5ndGggLSAxKSAqIDIwKSAvIHRoaXMuZW51bWVyYXRpb25GaWVsZC5jaG9pY2VzLmxlbmd0aDtcbiAgICAgICAgICAgIHRoaXMuc3RlcHMudG9BcnJheSgpLmZvckVhY2goc3RlcCA9PiB7XG4gICAgICAgICAgICAgICAgc3RlcC5uYXRpdmVFbGVtZW50LnN0eWxlLm1heFdpZHRoID0gbWF4V2lkdGggPj0gNzIgPyBtYXhXaWR0aCArICdweCcgOiAnNzJweCc7XG4gICAgICAgICAgICB9KTtcbiAgICAgICAgfVxuICAgIH1cblxuICAgIHNldFN0ZXBwZXJWYWx1ZShrZXk6IHN0cmluZykge1xuICAgICAgICBpZiAoIXRoaXMuZW51bWVyYXRpb25GaWVsZC5kaXNhYmxlZCkge1xuICAgICAgICAgICAgdGhpcy5mb3JtQ29udHJvbFJlZi5zZXRWYWx1ZShrZXkpO1xuICAgICAgICB9XG4gICAgfVxufVxuIl19

package/esm2015/lib/data-fields/enumeration-field/models/dynamic-enumeration-field.js

@@ -0,0 +1,44 @@
+import { EnumerationField, EnumerationFieldView } from './enumeration-field';
+import { FieldTypeResource } from '../../../task-content/model/field-type-resource';
+import { Validators } from '@angular/forms';
+import { Subject } from 'rxjs';
+import { debounceTime } from 'rxjs/operators';
+import { LoadingEmitter } from '../../../utility/loading-emitter';
+export class DynamicEnumerationField extends EnumerationField {
+    constructor(stringId, title, value, _choices, behavior, placeholder, description, layout, _view = EnumerationFieldView.DEFAULT, _fieldType = FieldTypeResource.ENUMERATION, validations, component, parentTaskId) {
+        super(stringId, title, value, _choices, behavior, placeholder, description, layout, _view, _fieldType, validations, component, parentTaskId);
+        this._choices = _choices;
+        this._view = _view;
+        this._fieldType = _fieldType;
+        this.REQUEST_DEBOUNCE_TIME = 600;
+        this._choicesChange$ = new Subject();
+        this._loading = new LoadingEmitter();
+    }
+    set choices(choices) {
+        this._choices = choices;
+        this._choicesChange$.next();
+    }
+    get choices() {
+        return this._choices;
+    }
+    set loading(bool) {
+        bool ? this._loading.on() : this._loading.off();
+    }
+    get loading() {
+        return this._loading.isActive;
+    }
+    get choicesChange$() {
+        return this._choicesChange$.asObservable();
+    }
+    valueChanges() {
+        return this._value.pipe(debounceTime(this.REQUEST_DEBOUNCE_TIME));
+    }
+    resolveFormControlValidators() {
+        const result = [];
+        if (this.behavior.required) {
+            result.push(Validators.required);
+        }
+        return result;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/data-fields/enumeration-field/models/enumeration-field.js

@@ -0,0 +1,59 @@
+import { DataField } from '../../models/abstract-data-field';
+import { Validators } from '@angular/forms';
+import { FieldTypeResource } from '../../../task-content/model/field-type-resource';
+/*@deprecated in 4.3.0*/
+export var EnumerationFieldView;
+(function (EnumerationFieldView) {
+    EnumerationFieldView["DEFAULT"] = "default";
+    EnumerationFieldView["LIST"] = "list";
+    EnumerationFieldView["AUTOCOMPLETE"] = "autocomplete";
+    EnumerationFieldView["STEPPER"] = "stepper";
+})(EnumerationFieldView || (EnumerationFieldView = {}));
+export var EnumerationFieldValidation;
+(function (EnumerationFieldValidation) {
+    EnumerationFieldValidation["WRONG_VALUE"] = "wrongValue";
+    EnumerationFieldValidation["REQUIRED"] = "required";
+})(EnumerationFieldValidation || (EnumerationFieldValidation = {}));
+export class EnumerationField extends DataField {
+    constructor(stringId, title, value, _choices, behavior, placeholder, description, layout, _view = EnumerationFieldView.DEFAULT, _fieldType = FieldTypeResource.ENUMERATION, validations, component, parentTaskId) {
+        super(stringId, title, value, behavior, placeholder, description, layout, validations, component, parentTaskId);
+        this._choices = _choices;
+        this._view = _view;
+        this._fieldType = _fieldType;
+    }
+    set choices(choices) {
+        this._choices = choices;
+    }
+    get choices() {
+        return this._choices;
+    }
+    /*@deprecated in 4.3.0*/
+    set view(view) {
+        this._view = view;
+    }
+    /*@deprecated in 4.3.0*/
+    get view() {
+        return this._view;
+    }
+    get fieldType() {
+        return this._fieldType;
+    }
+    resolveFormControlValidators() {
+        const result = [];
+        if (this.behavior.required) {
+            result.push(Validators.required);
+        }
+        result.push((control) => this.checkKey(control));
+        return result;
+    }
+    checkKey(control) {
+        if (this._choices === undefined || this._choices.length === 0 || control.value === '' || control.value === undefined) {
+            return null;
+        }
+        return this._choices.find(choice => choice.key === control.value) ? null : { wrongValue: true };
+    }
+    getType() {
+        return !!this.component && !!this.component.name ? this.component.name : this.view;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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