@netgrif/components-core 6.0.1

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

@@ -0,0 +1,63 @@
+import { __extends } from "tslib";
+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';
+var DynamicEnumerationField = /** @class */ (function (_super) {
+    __extends(DynamicEnumerationField, _super);
+    function DynamicEnumerationField(stringId, title, value, _choices, behavior, placeholder, description, layout, _view, _fieldType, validations, component, parentTaskId) {
+        if (_view === void 0) { _view = EnumerationFieldView.DEFAULT; }
+        if (_fieldType === void 0) { _fieldType = FieldTypeResource.ENUMERATION; }
+        var _this = _super.call(this, stringId, title, value, _choices, behavior, placeholder, description, layout, _view, _fieldType, validations, component, parentTaskId) || this;
+        _this._choices = _choices;
+        _this._view = _view;
+        _this._fieldType = _fieldType;
+        _this.REQUEST_DEBOUNCE_TIME = 600;
+        _this._choicesChange$ = new Subject();
+        _this._loading = new LoadingEmitter();
+        return _this;
+    }
+    Object.defineProperty(DynamicEnumerationField.prototype, "choices", {
+        get: function () {
+            return this._choices;
+        },
+        set: function (choices) {
+            this._choices = choices;
+            this._choicesChange$.next();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DynamicEnumerationField.prototype, "loading", {
+        get: function () {
+            return this._loading.isActive;
+        },
+        set: function (bool) {
+            bool ? this._loading.on() : this._loading.off();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DynamicEnumerationField.prototype, "choicesChange$", {
+        get: function () {
+            return this._choicesChange$.asObservable();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DynamicEnumerationField.prototype.valueChanges = function () {
+        return this._value.pipe(debounceTime(this.REQUEST_DEBOUNCE_TIME));
+    };
+    DynamicEnumerationField.prototype.resolveFormControlValidators = function () {
+        var result = [];
+        if (this.behavior.required) {
+            result.push(Validators.required);
+        }
+        return result;
+    };
+    return DynamicEnumerationField;
+}(EnumerationField));
+export { DynamicEnumerationField };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,79 @@
+import { __extends } from "tslib";
+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 = {}));
+var EnumerationField = /** @class */ (function (_super) {
+    __extends(EnumerationField, _super);
+    function EnumerationField(stringId, title, value, _choices, behavior, placeholder, description, layout, _view, _fieldType, validations, component, parentTaskId) {
+        if (_view === void 0) { _view = EnumerationFieldView.DEFAULT; }
+        if (_fieldType === void 0) { _fieldType = FieldTypeResource.ENUMERATION; }
+        var _this = _super.call(this, stringId, title, value, behavior, placeholder, description, layout, validations, component, parentTaskId) || this;
+        _this._choices = _choices;
+        _this._view = _view;
+        _this._fieldType = _fieldType;
+        return _this;
+    }
+    Object.defineProperty(EnumerationField.prototype, "choices", {
+        get: function () {
+            return this._choices;
+        },
+        set: function (choices) {
+            this._choices = choices;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(EnumerationField.prototype, "view", {
+        /*@deprecated in 4.3.0*/
+        get: function () {
+            return this._view;
+        },
+        /*@deprecated in 4.3.0*/
+        set: function (view) {
+            this._view = view;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(EnumerationField.prototype, "fieldType", {
+        get: function () {
+            return this._fieldType;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    EnumerationField.prototype.resolveFormControlValidators = function () {
+        var _this = this;
+        var result = [];
+        if (this.behavior.required) {
+            result.push(Validators.required);
+        }
+        result.push(function (control) { return _this.checkKey(control); });
+        return result;
+    };
+    EnumerationField.prototype.checkKey = function (control) {
+        if (this._choices === undefined || this._choices.length === 0 || control.value === '' || control.value === undefined) {
+            return null;
+        }
+        return this._choices.find(function (choice) { return choice.key === control.value; }) ? null : { wrongValue: true };
+    };
+    EnumerationField.prototype.getType = function () {
+        return !!this.component && !!this.component.name ? this.component.name : this.view;
+    };
+    return EnumerationField;
+}(DataField));
+export { EnumerationField };
+//# sourceMappingURL=data:application/json;base64,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