@aemforms/af-core 0.22.18 → 0.22.20

package/lib/{Field.js → esm/Field.js}

@@ -1,57 +1,33 @@
-"use strict";
-/*
- * Copyright 2022 Adobe, Inc.
- *
- * Your access and use of this software is governed by the Adobe Customer Feedback Program Terms and Conditions or other Beta License Agreement signed by your employer and Adobe, Inc.. This software is NOT open source and may not be used without one of the foregoing licenses. Even with a foregoing license, your access and use of this file is limited to the earlier of (a) 180 days, (b) general availability of the product(s) which utilize this software (i.e. AEM Forms), (c) January 1, 2023, (d) Adobe providing notice to you that you may no longer use the software or that your beta trial has otherwise ended.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL ADOBE NOR ITS THIRD PARTY PROVIDERS AND PARTNERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const types_1 = require("./types");
-const ValidationUtils_1 = require("./utils/ValidationUtils");
-const controller_1 = require("./controller");
-const Scriptable_1 = __importDefault(require("./Scriptable"));
-const SchemaUtils_1 = require("./utils/SchemaUtils");
-const DataValue_1 = __importDefault(require("./data/DataValue"));
-const BaseNode_1 = require("./BaseNode");
-const EmptyDataValue_1 = __importDefault(require("./data/EmptyDataValue"));
-const af_formatters_1 = require("@aemforms/af-formatters");
-/**
- * Defines a form object field which implements {@link FieldModel | field model} interface
- */
+import { ValidationError } from './types/index.js';
+import { coerceType, Constraints, ValidConstraints } from './utils/ValidationUtils.js';
+import { Change, ExecuteRule, Initialize, Invalid, propertyChange, Valid } from './controller/Events.js';
+import Scriptable from './Scriptable.js';
+import { defaultFieldTypes } from './utils/SchemaUtils.js';
+import DataValue from './data/DataValue.js';
+import { dependencyTracked, include, exclude, target, staticFields } from './BaseNode.js';
+import NullDataValue from './data/EmptyDataValue.js';
+import { format } from '@aemforms/af-formatters';
 const validTypes = ['string', 'number', 'boolean', 'file', 'string[]', 'number[]', 'boolean[]', 'file[]', 'array', 'object'];
-class Field extends Scriptable_1.default {
-    /**
-     * @param params
-     * @param _options
-     * @private
-     */
+class Field extends Scriptable {
     constructor(params, _options) {
         super(params, _options);
-        this._ruleNodeReference = [];
         this._applyDefaults();
-        this.queueEvent(new controller_1.Initialize());
-        this.queueEvent(new controller_1.ExecuteRule());
+        this.queueEvent(new Initialize());
+        this.queueEvent(new ExecuteRule());
     }
-    /**
-     * @private
-     */
+    _ruleNodeReference = [];
     _initialize() {
         super._initialize();
         this.setupRuleNode();
     }
     ruleNodeReference() {
-        var _a;
-        if ((_a = this.type) === null || _a === void 0 ? void 0 : _a.endsWith('[]')) {
+        if (this.type?.endsWith('[]')) {
             this._ruleNodeReference = [];
         }
         else {
@@ -67,17 +43,12 @@ class Field extends Scriptable_1.default {
             type: this._getFallbackType()
         };
     }
-    /**
-     * Returns the fallback type to be used for this field, in case type is not defined. Otherwise returns
-     * undefined
-     * @protected
-     */
     _getFallbackType() {
         const type = this._jsonModel.type;
         let finalType = type;
         if (typeof type !== 'string' || validTypes.indexOf(type) === -1) {
             const _enum = this.enum;
-            finalType = typeof (_enum === null || _enum === void 0 ? void 0 : _enum[0]);
+            finalType = typeof (_enum?.[0]);
             if (finalType === 'undefined' && typeof this._jsonModel.default !== 'undefined') {
                 if (this._jsonModel.default instanceof Array && this._jsonModel.default.length > 0) {
                     finalType = `${typeof (this._jsonModel.default[0])}[]`;
@@ -89,6 +60,7 @@ class Field extends Scriptable_1.default {
             if (finalType.indexOf('undefined') === 0) {
                 const typeMappings = {
                     'text-input': 'string',
+                    'multiline-input': 'string',
                     'number-input': 'number',
                     'date-input': 'string',
                     'plain-text': 'string',
@@ -102,12 +74,13 @@ class Field extends Scriptable_1.default {
     }
     _applyDefaults() {
         Object.entries(this._getDefaults()).map(([key, value]) => {
-            //@ts-ignore
             if (this._jsonModel[key] === undefined && value !== undefined) {
-                //@ts-ignore
                 this._jsonModel[key] = value;
             }
         });
+        this.coerceParam('required', 'boolean');
+        this.coerceParam('readOnly', 'boolean');
+        this.coerceParam('enabled', 'boolean');
         const type = this._jsonModel.type;
         if (typeof type !== 'string' || validTypes.indexOf(type) === -1) {
             this._jsonModel.type = this._getFallbackType();
@@ -117,28 +90,25 @@ class Field extends Scriptable_1.default {
         }
         const value = this._jsonModel.value;
         if (value === undefined) {
-            const typedRes = ValidationUtils_1.Constraints.type(this.getInternalType() || 'string', this._jsonModel.default);
+            const typedRes = Constraints.type(this.getInternalType() || 'string', this._jsonModel.default);
             this._jsonModel.value = typedRes.value;
         }
         if (this._jsonModel.type !== 'string') {
-            this._jsonModel.emptyValue = undefined;
+            this.unset('emptyValue');
         }
         if (this._jsonModel.fieldType === undefined) {
             this.form.logger.error('fieldType property is mandatory. Please ensure all the fields have a fieldType');
-            //@ts-ignore
             if (this._jsonModel.viewType) {
-                //@ts-ignore
                 if (this._jsonModel.viewType.startsWith('custom:')) {
                     this.form.logger.error('viewType property has been removed. For custom types, use :type property');
                 }
                 else {
                     this.form.logger.error('viewType property has been removed. Use fieldType property');
                 }
-                //@ts-ignore
                 this._jsonModel.fieldType = this._jsonModel.viewType;
             }
             else {
-                this._jsonModel.fieldType = (0, SchemaUtils_1.defaultFieldTypes)(this._jsonModel);
+                this._jsonModel.fieldType = defaultFieldTypes(this._jsonModel);
             }
         }
         if (this._jsonModel.enum === undefined) {
@@ -152,35 +122,42 @@ class Field extends Scriptable_1.default {
                 this._jsonModel.enumNames = this._jsonModel.enum.map(_ => _.toString());
             }
             while (this._jsonModel.enumNames.length < this._jsonModel.enum.length) {
-                //@ts-ignore
                 this._jsonModel.enumNames.push(this._jsonModel.enum[this._jsonModel.enumNames.length].toString());
             }
         }
+        const props = ['minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum'];
         if (this._jsonModel.type !== 'string') {
-            this._jsonModel.format = undefined;
-            this._jsonModel.pattern = undefined;
-            this._jsonModel.minLength = undefined;
-            this._jsonModel.maxLength = undefined;
+            this.unset('format', 'pattern', 'minLength', 'maxLength');
         }
         else if (this._jsonModel.fieldType === 'date-input') {
             this._jsonModel.format = 'date';
         }
+        this.coerceParam('minLength', 'number');
+        this.coerceParam('maxLength', 'number');
         if (this._jsonModel.type !== 'number' && this._jsonModel.format !== 'date') {
-            this._jsonModel.step = undefined;
-            this._jsonModel.minimum = undefined;
-            this._jsonModel.maximum = undefined;
-            this._jsonModel.exclusiveMinimum = undefined;
-            this._jsonModel.exclusiveMaximum = undefined;
-        }
-        ['minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum'].forEach(c => {
-            //@ts-ignore
-            if (typeof this._jsonModel[c] !== this._jsonModel.type) {
-                //@ts-ignore
-                this._jsonModel[c] = undefined;
-            }
+            this.unset('step', ...props);
+        }
+        props.forEach(c => {
+            this.coerceParam(c, this._jsonModel.type);
         });
         if (typeof this._jsonModel.step !== 'number') {
-            this._jsonModel.step = undefined;
+            this.coerceParam('step', 'number');
+        }
+    }
+    unset(...props) {
+        props.forEach(p => this._jsonModel[p] = undefined);
+    }
+    coerceParam(param, type) {
+        const val = this._jsonModel[param];
+        if (typeof val !== 'undefined' && typeof val !== type) {
+            this.form.logger.info(`${param} is not of type ${type}. Trying to coerce.`);
+            try {
+                this._jsonModel[param] = coerceType(val, type);
+            }
+            catch (e) {
+                this.form.logger.warn(e);
+                this.unset(param);
+            }
         }
     }
     get editFormat() {
@@ -198,10 +175,6 @@ class Field extends Scriptable_1.default {
     set readOnly(e) {
         this._setProperty('readOnly', e);
     }
-    get language() {
-        //todo: add this in the specification and take it as a property
-        return Intl.DateTimeFormat().resolvedOptions().locale;
-    }
     get enabled() {
         return this._jsonModel.enabled;
     }
@@ -260,26 +233,35 @@ class Field extends Scriptable_1.default {
             this._setProperty('minimum', m);
         }
     }
-    /**
-     * returns whether the value is empty. Empty value is either a '', undefined or null
-     * @private
-     */
     isEmpty() {
         return this._jsonModel.value === undefined || this._jsonModel.value === null || this._jsonModel.value === '';
     }
+    withCategory(df) {
+        const hasCategory = df?.match(/^(?:date|num)\|/);
+        if (hasCategory == null) {
+            if (this.format === 'date') {
+                df = `date|${df}`;
+            }
+            else if (this.type === 'number') {
+                df = `num|${df}`;
+            }
+            return df;
+        }
+        return df;
+    }
     get editValue() {
-        const format = this.editFormat;
-        if (this.format == 'date' && this.value != null && this.valid !== false) {
-            return (0, af_formatters_1.formatDate)(new Date(this.value), this.language, format);
+        const df = this.withCategory(this.editFormat);
+        if (df && this.isNotEmpty(this.value) && this.valid !== false) {
+            return format(this.value, this.language, df);
         }
         else {
             return this.value;
         }
     }
     get displayValue() {
-        const format = this.displayFormat;
-        if (this.format == 'date' && this.value != null && this.valid !== false) {
-            return (0, af_formatters_1.formatDate)(new Date(this.value), this.language, format);
+        const df = this.withCategory(this.displayFormat);
+        if (df && this.isNotEmpty(this.value) && this.valid !== false) {
+            return format(this.value, this.language, df);
         }
         else {
             return this.value;
@@ -288,34 +270,39 @@ class Field extends Scriptable_1.default {
     getDataNodeValue(typedValue) {
         return this.isEmpty() ? this.emptyValue : typedValue;
     }
-    get value() {
-        if (this._jsonModel.value === undefined) {
-            return null;
-        }
-        else {
-            return this._jsonModel.value;
-        }
-    }
-    set value(v) {
+    updateDataNodeAndTypedValue(val) {
         const dataNode = this.getDataNode();
-        if (BaseNode_1.staticFields.indexOf(this.fieldType) > -1 && typeof dataNode !== 'undefined') {
-            // if a static field is bound to data node it can not be updated.
+        if (staticFields.indexOf(this.fieldType) > -1 && typeof dataNode !== 'undefined') {
             return;
         }
         const Constraints = this._getConstraintObject();
-        const typeRes = Constraints.type(this.getInternalType() || 'string', v);
+        const typeRes = Constraints.type(this.getInternalType() || 'string', val);
         const changes = this._setProperty('value', typeRes.value, false);
-        let uniqueRes = { valid: true };
         if (changes.length > 0) {
             this._updateRuleNodeReference(typeRes.value);
             if (typeof dataNode !== 'undefined') {
                 dataNode.setValue(this.getDataNodeValue(this._jsonModel.value), this._jsonModel.value, this);
             }
+        }
+        return changes;
+    }
+    get value() {
+        if (this._jsonModel.value === undefined) {
+            return null;
+        }
+        else {
+            return this._jsonModel.value;
+        }
+    }
+    set value(v) {
+        const changes = this.updateDataNodeAndTypedValue(v);
+        let uniqueRes = { valid: true };
+        if (changes?.length > 0) {
+            let updates = {};
+            const typeRes = Constraints.type(this.getInternalType() || 'string', v);
             if (this.parent.uniqueItems && this.parent.type === 'array') {
-                // @ts-ignore
                 uniqueRes = Constraints.uniqueItems(this.parent.uniqueItems, this.parent.getDataNode().$value);
             }
-            let updates;
             if (typeRes.valid && uniqueRes.valid) {
                 updates = this.evaluateConstraints();
             }
@@ -329,13 +316,24 @@ class Field extends Scriptable_1.default {
             if (updates.valid) {
                 this.triggerValidationEvent(updates);
             }
-            const changeAction = new controller_1.Change({ changes: changes.concat(Object.values(updates)) });
+            const changeAction = new Change({ changes: changes.concat(Object.values(updates)) });
+            this.dispatch(changeAction);
+        }
+    }
+    reset() {
+        const changes = this.updateDataNodeAndTypedValue(this.default);
+        if (changes.length > 0) {
+            const validationStateChanges = {
+                'valid': undefined,
+                'errorMessage': ''
+            };
+            const updates = this._applyUpdates(['valid', 'errorMessage'], validationStateChanges);
+            const changeAction = new Change({ changes: changes.concat(Object.values(updates)) });
             this.dispatch(changeAction);
         }
     }
     _updateRuleNodeReference(value) {
-        var _a;
-        if ((_a = this.type) === null || _a === void 0 ? void 0 : _a.endsWith('[]')) {
+        if (this.type?.endsWith('[]')) {
             if (value != null) {
                 value.forEach((val, index) => {
                     this._ruleNodeReference[index] = val;
@@ -355,26 +353,18 @@ class Field extends Scriptable_1.default {
         return this.type;
     }
     valueOf() {
-        // @ts-ignore
-        const obj = this[BaseNode_1.target];
+        const obj = this[target];
         const actualField = obj === undefined ? this : obj;
         actualField.ruleEngine.trackDependency(actualField);
         return actualField._jsonModel.value || null;
     }
     toString() {
-        var _a;
-        // @ts-ignore
-        const obj = this[BaseNode_1.target];
+        const obj = this[target];
         const actualField = obj === undefined ? this : obj;
-        return ((_a = actualField._jsonModel.value) === null || _a === void 0 ? void 0 : _a.toString()) || '';
+        return actualField._jsonModel.value?.toString() || '';
     }
-    /**
-     * Returns the error message for a given constraint
-     * @param constraint
-     */
     getErrorMessage(constraint) {
-        var _a;
-        return ((_a = this._jsonModel.constraintMessages) === null || _a === void 0 ? void 0 : _a[constraint]) || '';
+        return this._jsonModel.constraintMessages?.[constraint] || '';
     }
     get errorMessage() {
         return this._jsonModel.errorMessage;
@@ -382,26 +372,12 @@ class Field extends Scriptable_1.default {
     get screenReaderText() {
         return this._jsonModel.screenReaderText;
     }
-    /**
-     *
-     * @private
-     */
     _getConstraintObject() {
-        return ValidationUtils_1.Constraints;
+        return Constraints;
     }
-    /**
-     * returns whether the field is array type or not
-     * @private
-     */
     isArrayType() {
         return this.type ? this.type.indexOf('[]') > -1 : false;
     }
-    /**
-     *
-     * @param value
-     * @param constraints
-     * @private
-     */
     checkEnum(value, constraints) {
         if (this._jsonModel.enforceEnum === true && value != null) {
             const fn = constraints.enum;
@@ -414,62 +390,63 @@ class Field extends Scriptable_1.default {
         }
         return true;
     }
-    /**
-     * checks whether the value can be achieved by stepping the min/default value by the step constraint.
-     * Basically to find a integer solution for n in the equation
-     * initialValue + n * step = value
-     * @param constraints
-     * @private
-     */
     checkStep() {
         const value = this._jsonModel.value;
-        if (typeof this._jsonModel.step === 'number') {
-            const initialValue = this._jsonModel.minimum || this._jsonModel.default || 0;
-            return (value - initialValue) % this._jsonModel.step === 0;
+        const step = this._jsonModel.step;
+        if (typeof step === 'number') {
+            const prec = step.toString().split('.')?.[1]?.length || 0;
+            const factor = Math.pow(10, prec);
+            const fStep = step * factor;
+            const fVal = value * factor;
+            const iv = this._jsonModel.minimum || this._jsonModel.default || 0;
+            const fIVal = iv * factor;
+            const qt = (fVal - fIVal) / fStep;
+            const valid = (fVal - fIVal) % fStep < .001;
+            let next, prev;
+            if (!valid) {
+                next = (Math.ceil(qt) * fStep + fIVal) / factor;
+                prev = (next - fStep) / factor;
+            }
+            return {
+                valid,
+                next,
+                prev
+            };
         }
-        return true;
+        return {
+            valid: true
+        };
     }
-    /**
-     * checks whether the validation expression returns a boolean value or not
-     * @private
-     */
     checkValidationExpression() {
         if (typeof this._jsonModel.validationExpression === 'string') {
             return this.executeExpression(this._jsonModel.validationExpression);
         }
         return true;
     }
-    /**
-     * Returns the applicable constraints for a given type
-     * @private
-     */
     getConstraints() {
         switch (this.type) {
             case 'string':
                 switch (this.format) {
                     case 'date':
-                        return ValidationUtils_1.ValidConstraints.date;
+                        return ValidConstraints.date;
                     case 'binary':
-                        return ValidationUtils_1.ValidConstraints.file;
+                        return ValidConstraints.file;
                     case 'data-url':
-                        return ValidationUtils_1.ValidConstraints.file;
+                        return ValidConstraints.file;
                     default:
-                        return ValidationUtils_1.ValidConstraints.string;
+                        return ValidConstraints.string;
                 }
             case 'file':
-                return ValidationUtils_1.ValidConstraints.file;
+                return ValidConstraints.file;
             case 'number':
             case 'integer':
-                return ValidationUtils_1.ValidConstraints.number;
+                return ValidConstraints.number;
         }
         if (this.isArrayType()) {
-            return ValidationUtils_1.ValidConstraints.array;
+            return ValidConstraints.array;
         }
         return [];
     }
-    /**
-     * returns the format constraint
-     */
     get format() {
         if (typeof this._jsonModel.format === 'undefined') {
             if (this.type === 'string') {
@@ -528,9 +505,9 @@ class Field extends Scriptable_1.default {
     get default() {
         return this._jsonModel.default;
     }
-    /**
-     * @private
-     */
+    isNotEmpty(value) {
+        return value != null && value !== '';
+    }
     evaluateConstraints() {
         let constraint = 'type';
         const elem = this._jsonModel;
@@ -543,16 +520,13 @@ class Field extends Scriptable_1.default {
                 (this.isArrayType() && this.required ? value.length > 0 : true);
             constraint = 'required';
         }
-        if (valid && value != this.emptyValue) {
+        if (valid && this.isNotEmpty(value)) {
             const invalidConstraint = supportedConstraints.find(key => {
-                // @ts-ignore
                 if (key in elem && elem[key] !== undefined) {
-                    // @ts-ignore
                     const restriction = elem[key];
-                    // @ts-ignore
                     const fn = Constraints[key];
                     if (value instanceof Array && this.isArrayType()) {
-                        if (ValidationUtils_1.ValidConstraints.array.indexOf(key) !== -1) {
+                        if (ValidConstraints.array.indexOf(key) !== -1) {
                             return !fn(restriction, value).valid;
                         }
                         else {
@@ -578,7 +552,7 @@ class Field extends Scriptable_1.default {
                 valid = this.checkEnum(value, Constraints);
                 constraint = 'enum';
                 if (valid && this.type === 'number') {
-                    valid = this.checkStep();
+                    valid = this.checkStep().valid;
                     constraint = 'step';
                 }
                 if (valid) {
@@ -588,8 +562,7 @@ class Field extends Scriptable_1.default {
             }
         }
         if (!valid) {
-            //@ts-ignore
-            this.form.logger.log(`${constraint} constraint evaluation failed ${this[constraint]}. Received ${this._jsonModel.value}`);
+            this.form.logger.info(`${constraint} constraint evaluation failed ${this._jsonModel[constraint]}. Received ${this._jsonModel.value}`);
         }
         const changes = {
             'valid': valid,
@@ -600,91 +573,84 @@ class Field extends Scriptable_1.default {
     triggerValidationEvent(changes) {
         if (changes.valid) {
             if (this.valid) {
-                this.dispatch(new controller_1.Valid());
+                this.dispatch(new Valid());
             }
             else {
-                this.dispatch(new controller_1.Invalid());
+                this.dispatch(new Invalid());
             }
         }
     }
-    /**
-     * Validates the current form object
-     */
     validate() {
         const changes = this.evaluateConstraints();
         if (changes.valid) {
             this.triggerValidationEvent(changes);
-            this.notifyDependents(new controller_1.Change({ changes: Object.values(changes) }));
+            this.notifyDependents(new Change({ changes: Object.values(changes) }));
         }
-        return this.valid ? [] : [new types_1.ValidationError(this.id, [this._jsonModel.errorMessage])];
+        return this.valid ? [] : [new ValidationError(this.id, [this._jsonModel.errorMessage])];
     }
     importData(contextualDataModel) {
         this._bindToDataModel(contextualDataModel);
         const dataNode = this.getDataNode();
-        // only if the value has changed, queue change event
-        if (dataNode !== undefined && dataNode !== EmptyDataValue_1.default && dataNode.$value !== this._jsonModel.value) {
-            const changeAction = (0, controller_1.propertyChange)('value', dataNode.$value, this._jsonModel.value);
+        if (dataNode !== undefined && dataNode !== NullDataValue && dataNode.$value !== this._jsonModel.value) {
+            const changeAction = propertyChange('value', dataNode.$value, this._jsonModel.value);
             this._jsonModel.value = dataNode.$value;
             this.queueEvent(changeAction);
         }
     }
-    /**
-     * @param name
-     * @private
-     */
     defaultDataModel(name) {
-        const value = BaseNode_1.staticFields.indexOf(this.fieldType) > -1 ? undefined : this.getDataNodeValue(this._jsonModel.value);
-        return new DataValue_1.default(name, value, this.type || 'string');
+        const value = staticFields.indexOf(this.fieldType) > -1 ? undefined : this.getDataNodeValue(this._jsonModel.value);
+        return new DataValue(name, value, this.type || 'string');
     }
     getState() {
-        return Object.assign(Object.assign({}, super.getState()), { editValue: this.editValue, displayValue: this.displayValue });
+        return {
+            ...super.getState(),
+            editValue: this.editValue,
+            displayValue: this.displayValue
+        };
     }
 }
 __decorate([
-    (0, BaseNode_1.dependencyTracked)(),
-    (0, BaseNode_1.exclude)('button', 'image', 'plain-text')
+    dependencyTracked(),
+    exclude('button', 'image', 'plain-text')
 ], Field.prototype, "readOnly", null);
 __decorate([
-    (0, BaseNode_1.dependencyTracked)(),
-    (0, BaseNode_1.exclude)('button', 'image', 'plain-text')
+    dependencyTracked(),
+    exclude('image', 'plain-text')
 ], Field.prototype, "enabled", null);
 __decorate([
-    (0, BaseNode_1.dependencyTracked)()
+    dependencyTracked()
 ], Field.prototype, "valid", null);
 __decorate([
-    (0, BaseNode_1.dependencyTracked)()
+    dependencyTracked()
 ], Field.prototype, "enum", null);
 __decorate([
-    (0, BaseNode_1.dependencyTracked)()
+    dependencyTracked()
 ], Field.prototype, "enumNames", null);
 __decorate([
-    (0, BaseNode_1.dependencyTracked)()
+    dependencyTracked()
 ], Field.prototype, "required", null);
 __decorate([
-    (0, BaseNode_1.include)('date-input', 'number-input')
+    include('date-input', 'number-input')
 ], Field.prototype, "editValue", null);
 __decorate([
-    (0, BaseNode_1.include)('date-input', 'number-input')
-], Field.prototype, "displayValue", null);
-__decorate([
-    (0, BaseNode_1.dependencyTracked)()
+    dependencyTracked()
 ], Field.prototype, "value", null);
 __decorate([
-    (0, BaseNode_1.include)('text-input', 'date-input', 'file-input')
+    include('text-input', 'date-input', 'file-input')
 ], Field.prototype, "format", null);
 __decorate([
-    (0, BaseNode_1.include)('text-input')
+    include('text-input')
 ], Field.prototype, "maxLength", null);
 __decorate([
-    (0, BaseNode_1.include)('text-input')
+    include('text-input')
 ], Field.prototype, "minLength", null);
 __decorate([
-    (0, BaseNode_1.include)('text-input')
+    include('text-input')
 ], Field.prototype, "pattern", null);
 __decorate([
-    (0, BaseNode_1.dependencyTracked)()
+    dependencyTracked()
 ], Field.prototype, "exclusiveMinimum", null);
 __decorate([
-    (0, BaseNode_1.dependencyTracked)()
+    dependencyTracked()
 ], Field.prototype, "exclusiveMaximum", null);
-exports.default = Field;
+export default Field;