tuain-ng-forms-lib 14.1.2 → 14.2.14

package/fesm2020/tuain-ng-forms-lib.mjs

@@ -41,9 +41,9 @@ class ActionComponent {
         return !(this.action?.enabledOn(this.state));
     }
 }
-ActionComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: ActionComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-ActionComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.1", type: ActionComponent, selector: "lib-action", inputs: { action: "action", busy: "busy", relatedField: "relatedField", state: "state", style: "style", showLabel: "showLabel" }, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: ActionComponent, decorators: [{
+ActionComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: ActionComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+ActionComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.6", type: ActionComponent, selector: "lib-action", inputs: { action: "action", busy: "busy", relatedField: "relatedField", state: "state", style: "style", showLabel: "showLabel" }, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: ActionComponent, decorators: [{
             type: Component,
             args: [{
                     selector: 'lib-action',
@@ -66,25 +66,30 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImpor
 const VALUE = 'value';
 const FOCUS = 'focus';
 class FieldComponent {
+    constructor() {
+        // Atributos obtenidos estáticamente
+        this.code = '';
+        this.info = '';
+        this.alignment = '';
+        this.tooltip = '';
+        this.field = null;
+    }
     ngOnInit() {
         if (this.field) {
             this.formConfig = this.field?._formConfig;
             // Inicialización
-            const mapping = Object.entries(this.formConfig.componentFieldAttrMap);
+            const mapping = this.formConfig.fieldPropagateAttributes;
             for (let index = 0; index < mapping.length; index++) {
-                const [fieldAttr1, compAttr1] = mapping[index];
-                const compAttr = compAttr1.toString();
-                const fieldAttr = fieldAttr1.toString();
-                const attributeValue = this.field?.[fieldAttr];
-                this.dafaultProcessFieldChange(compAttr, attributeValue);
-                this.processFieldChange(compAttr, attributeValue);
+                const attrName = mapping[index].toString();
+                const attributeValue = this.field?.[attrName];
+                this.dafaultProcessFieldChange(attrName, attributeValue);
+                this.processFieldChange(attrName, attributeValue);
             }
             // Subscripción a cambios en atributos
             this.field.attributeChange.subscribe(event => {
-                const { name: fieldAttr, value } = event;
-                const compAttr = this.formConfig.componentFieldAttrMap[fieldAttr];
-                this.dafaultProcessFieldChange(compAttr, value);
-                this.processFieldChange(compAttr, value);
+                const { name: attrName, value } = event;
+                this.dafaultProcessFieldChange(attrName, value);
+                this.processFieldChange(attrName, value);
             });
         }
         this.start();
@@ -137,9 +142,9 @@ class FieldComponent {
         return !this.field?.enabledOn(this.state);
     }
 }
-FieldComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: FieldComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-FieldComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.1", type: FieldComponent, selector: "lib-field", inputs: { field: "field", state: "state" }, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: FieldComponent, decorators: [{
+FieldComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: FieldComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+FieldComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.6", type: FieldComponent, selector: "lib-field", inputs: { field: "field", state: "state" }, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: FieldComponent, decorators: [{
             type: Component,
             args: [{
                     selector: 'lib-field',
@@ -164,9 +169,9 @@ class ElementComponent {
         return !this.element?.enabledOn(this.state);
     }
 }
-ElementComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: ElementComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-ElementComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.1", type: ElementComponent, selector: "lib-element", inputs: { element: "element", form: "form", state: "state" }, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: ElementComponent, decorators: [{
+ElementComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: ElementComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+ElementComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.6", type: ElementComponent, selector: "lib-element", inputs: { element: "element", form: "form", state: "state" }, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: ElementComponent, decorators: [{
             type: Component,
             args: [{
                     selector: 'lib-element',
@@ -182,9 +187,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImpor
 
 class FormErrorComponent {
 }
-FormErrorComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: FormErrorComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-FormErrorComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.1", type: FormErrorComponent, selector: "lib-form-error", inputs: { errorTitle: "errorTitle", errorMessage: "errorMessage", errorType: "errorType" }, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: FormErrorComponent, decorators: [{
+FormErrorComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: FormErrorComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+FormErrorComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.6", type: FormErrorComponent, selector: "lib-form-error", inputs: { errorTitle: "errorTitle", errorMessage: "errorMessage", errorType: "errorType" }, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: FormErrorComponent, decorators: [{
             type: Component,
             args: [{
                     selector: 'lib-form-error',
@@ -207,9 +212,9 @@ class FormHeaderComponent {
         this.goBackEvent.emit();
     }
 }
-FormHeaderComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: FormHeaderComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-FormHeaderComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.1", type: FormHeaderComponent, selector: "lib-form-header", inputs: { formManager: "formManager", goBackAction: "goBackAction", showTitle: "showTitle", headerActions: "headerActions" }, outputs: { goBackEvent: "goBackEvent" }, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: FormHeaderComponent, decorators: [{
+FormHeaderComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: FormHeaderComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+FormHeaderComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.6", type: FormHeaderComponent, selector: "lib-form-header", inputs: { formManager: "formManager", goBackAction: "goBackAction", showTitle: "showTitle", headerActions: "headerActions" }, outputs: { goBackEvent: "goBackEvent" }, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: FormHeaderComponent, decorators: [{
             type: Component,
             args: [{
                     selector: 'lib-form-header',
@@ -233,9 +238,9 @@ class SectionComponent {
     }
     start() { }
 }
-SectionComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: SectionComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-SectionComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.1", type: SectionComponent, selector: "lib-section", inputs: { section: "section", formManager: "formManager" }, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: SectionComponent, decorators: [{
+SectionComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: SectionComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+SectionComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.6", type: SectionComponent, selector: "lib-section", inputs: { section: "section", formManager: "formManager" }, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: SectionComponent, decorators: [{
             type: Component,
             args: [{
                     selector: 'lib-section',
@@ -253,9 +258,9 @@ class SubSectionComponent {
     }
     start() { }
 }
-SubSectionComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: SubSectionComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-SubSectionComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.1", type: SubSectionComponent, selector: "lib-subsection", inputs: { subSection: "subSection", showHeader: "showHeader", formManager: "formManager" }, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: SubSectionComponent, decorators: [{
+SubSectionComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: SubSectionComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+SubSectionComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.6", type: SubSectionComponent, selector: "lib-subsection", inputs: { subSection: "subSection", showHeader: "showHeader", formManager: "formManager" }, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: SubSectionComponent, decorators: [{
             type: Component,
             args: [{
                     selector: 'lib-subsection',
@@ -288,9 +293,9 @@ class LibTableRecordActionComponent {
     }
     class() { }
 }
-LibTableRecordActionComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: LibTableRecordActionComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-LibTableRecordActionComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.1", type: LibTableRecordActionComponent, selector: "lib-table-record-action", inputs: { recordId: "recordId", recordData: "recordData", action: "action" }, outputs: { actionSelected: "actionSelected" }, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: LibTableRecordActionComponent, decorators: [{
+LibTableRecordActionComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: LibTableRecordActionComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+LibTableRecordActionComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.6", type: LibTableRecordActionComponent, selector: "lib-table-record-action", inputs: { recordId: "recordId", recordData: "recordData", action: "action" }, outputs: { actionSelected: "actionSelected" }, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: LibTableRecordActionComponent, decorators: [{
             type: Component,
             args: [{
                     selector: 'lib-table-record-action',
@@ -313,9 +318,9 @@ class LibTableRecordFieldComponent {
     }
     start() { }
 }
-LibTableRecordFieldComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: LibTableRecordFieldComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-LibTableRecordFieldComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.1", type: LibTableRecordFieldComponent, selector: "lib-table-record-field", inputs: { fieldCode: "fieldCode", fieldType: "fieldType", fieldValue: "fieldValue" }, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: LibTableRecordFieldComponent, decorators: [{
+LibTableRecordFieldComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: LibTableRecordFieldComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+LibTableRecordFieldComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.6", type: LibTableRecordFieldComponent, selector: "lib-table-record-field", inputs: { fieldCode: "fieldCode", fieldType: "fieldType", fieldValue: "fieldValue" }, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: LibTableRecordFieldComponent, decorators: [{
             type: Component,
             args: [{
                     selector: 'lib-table-record-field',
@@ -404,9 +409,9 @@ class LibTableComponent {
         }
     }
 }
-LibTableComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: LibTableComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-LibTableComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.1", type: LibTableComponent, selector: "lib-table", inputs: { table: "table", tableRecords: "tableRecords", disabled: "disabled", state: "state", waiting: "waiting" }, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: LibTableComponent, decorators: [{
+LibTableComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: LibTableComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+LibTableComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.6", type: LibTableComponent, selector: "lib-table", inputs: { table: "table", tableRecords: "tableRecords", disabled: "disabled", state: "state", waiting: "waiting" }, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: LibTableComponent, decorators: [{
             type: Component,
             args: [{
                     selector: 'lib-table',
@@ -453,6 +458,10 @@ const operators = {
 
 class FormElement {
     constructor(elementDefinition, formConfig) {
+        this._visible = true;
+        this.visibleStates = null;
+        this.enabledStates = null;
+        this.elementType = null;
         this._formConfig = formConfig;
         this._isForced = false;
         this.setVisibleStates(elementDefinition.visibleStates);
@@ -462,6 +471,7 @@ class FormElement {
         this.setVisibility(elementDefinition?.visible ?? true);
         this.customAttributes = elementDefinition?.customAttributes ?? {};
     }
+    ;
     getCustomAttribute(name) { return this.customAttributes?.[name] ?? null; }
     setCustomAttribute(name, value) { if (name) {
         this.customAttributes[name] = value;
@@ -506,14 +516,14 @@ class FormElement {
             this._isForced = forced;
         }
     }
-    show(forced) {
+    show(forced = null) {
         this._visible = true;
         if (forced !== null) {
             this._isForced = forced;
             this._visibleForced = true;
         }
     }
-    hide(forced) {
+    hide(forced = null) {
         this._visible = false;
         if (forced !== null) {
             this._isForced = forced;
@@ -524,6 +534,7 @@ class FormElement {
     disable() { this.disabled = true; }
     get enabled() { return !this.disabled; }
     get editable() { return !this.disabled; }
+    set editable(editable) { this.disabled = !editable; }
 }
 
 const HEADER = 'HEADER';
@@ -564,35 +575,40 @@ const DEFAULT_CAPTURE_TYPE = 'INPUT';
 const DEFAULT_ALIGNMENT = 'left';
 const STD_MAX_LENGTH = 50;
 const BIG_MAX_LENGTH = 500;
-const fldAttr = {
-    validateOnServer: 'validateOnServer',
-    value: '_value',
-    minValue: '_minValue',
-    maxValue: '_maxValue',
-    maxLength: '_maxLength',
-    minLength: '_minLength',
-    onValidation: '_onValidation',
-    focus: 'focus',
-    intrinsicErrorMessage: '_intrinsicErrorMessage',
-    code: 'fieldCode',
-    info: 'fieldInfo',
-    defaultValue: 'defaultValue',
-    defaultEditable: 'defaultEditable',
-    visibleLabel: 'visibleLabel',
-    required: 'fieldRequired',
-    hasChanged: 'hasChanged',
-    outputOnly: 'outputOnly',
-    captureType: 'captureType',
-    title: 'fieldTitle',
-    type: 'fieldType',
-    alignment: 'fieldAlignment',
-    format: 'fieldFormat',
-    externalValue: 'externalValue',
-    tooltipText: 'tooltipText',
-    errorType: 'errorType',
-    errorCode: 'errorCode',
-    errorMessage: 'errorMessage',
-    options: 'fieldOptions',
+const directChanges = [
+    'defaultEditable', 'defaultValue', 'alignment', 'required', 'errorCode', 'errorMessage', 'errorType',
+    'tooltip', 'info', 'format', 'intrinsicErrorMessage', 'outputOnly', 'captureType', 'title', 'type',
+    'maxLength', 'maxValue', 'minLength', 'minValue', 'validateOnServer', 'serverAction', 'visibleLabel',
+    'options',
+];
+const attrs = {
+    _captureType: { name: '_captureType', propagate: 'captureType' },
+    _errorCode: { name: '_errorCode', propagate: 'errorCode' },
+    _errorMessage: { name: '_errorMessage', propagate: 'errorMessage' },
+    _errorType: { name: '_errorType', propagate: 'errorType' },
+    _defaultValue: { name: '_defaultValue', propagate: 'defaultValue' },
+    _defaultEditable: { name: '_defaultEditable', propagate: 'defaultEditable' },
+    _fieldAlignment: { name: '_fieldAlignment', propagate: 'alignment' },
+    _fieldCode: { name: '_fieldCode', propagate: 'code' },
+    _fieldInfo: { name: '_fieldInfo', propagate: 'info' },
+    _fieldRequired: { name: '_fieldRequired', propagate: 'required' },
+    _fieldTitle: { name: '_fieldTitle', propagate: 'title' },
+    _fieldType: { name: '_fieldType', propagate: 'type' },
+    _fieldFormat: { name: '_fieldFormat', propagate: 'format' },
+    _fieldOptions: { name: '_fieldOptions', propagate: 'options' },
+    _focus: { name: '_focus', propagate: 'focus' },
+    _hasChanged: { name: '_hasChanged', propagate: 'hasChanged' },
+    _intrinsicErrorMessage: { name: '_intrinsicErrorMessage', propagate: null },
+    _maxLength: { name: '_maxLength', propagate: 'maxLength' },
+    _maxValue: { name: '_maxValue', propagate: 'maxValue' },
+    _minLength: { name: '_minLength', propagate: 'minLength' },
+    _minValue: { name: '_minValue', propagate: 'minValue' },
+    _onValidation: { name: '_onValidation', propagate: 'onValidation' },
+    _outputOnly: { name: '_outputOnly', propagate: 'outputOnly' },
+    _tooltipText: { name: '_tooltipText', propagate: 'tooltip' },
+    _validateOnServer: { name: '_validateOnServer', propagate: 'validateOnServer' },
+    _value: { name: '_value', propagate: 'value' },
+    _visibleLabel: { name: '_visibleLabel', propagate: 'visibleLabel' },
 };
 class FieldDescriptor extends FormElement {
     constructor(inputFieldReceived, formConfig) {
@@ -601,48 +617,48 @@ class FieldDescriptor extends FormElement {
         this._editionPartial = new Subject();
         this._detailRequest = new Subject();
         this._attributeChange = new Subject();
-        this.validateOnServer = false;
-        this._focus = false;
+        this._errorType = '';
+        this._errorCode = '';
+        this._errorMessage = '';
+        this._fieldCode = '';
+        this._intrinsicErrorMessage = '';
         this._maxLength = 0;
         this._minLength = 0;
+        this._focus = false;
         this._onValidation = false;
-        this._intrinsicErrorMessage = '';
-        this.fieldCode = '';
-        this.fieldInfo = '';
-        this.defaultValue = '';
-        this.defaultEditable = false;
-        this.visibleLabel = false;
-        this.fieldRequired = false;
-        this.hasChanged = false;
-        this.outputOnly = false;
-        this.captureType = '';
-        this.fieldTitle = '';
-        this.fieldType = '';
-        this.fieldAlignment = '';
-        this.fieldFormat = null;
-        this.tooltipText = '';
-        this.errorType = '';
-        this.errorCode = '';
-        this.errorMessage = '';
-        this.fieldOptions = null;
+        this._validateOnServer = false;
+        this._visibleLabel = false;
+        this._captureType = '';
+        this._defaultValue = '';
+        this._defaultEditable = false;
+        this._fieldAlignment = '';
+        this._fieldInfo = '';
+        this._fieldRequired = false;
+        this._fieldTitle = '';
+        this._fieldType = '';
+        this._fieldFormat = null;
+        this._fieldOptions = null;
+        this._hasChanged = false;
+        this._outputOnly = false;
+        this._tooltipText = '';
         this.elementType = elementTypes.field;
         const fld = (inputFieldReceived) ? inputFieldReceived : {};
-        this.setAttr(fldAttr.code, fld.fieldCode);
-        this.setAttr(fldAttr.title, fld.fieldTitle ?? this.fieldCode);
-        this.setAttr(fldAttr.type, fld.fieldTypeCode);
-        this.setAttr(fldAttr.captureType, fld.captureType ?? DEFAULT_CAPTURE_TYPE);
+        this.setAttr(attrs._fieldCode, fld.fieldCode);
+        this.title = fld.fieldTitle ?? this._fieldCode;
+        this.type = fld.fieldTypeCode;
+        this.captureType = fld.captureType ?? DEFAULT_CAPTURE_TYPE;
         const defaultValue = fld.defaultValue ?? null;
-        if (this.fieldType === this._formConfig.fieldTypes.boolean) {
-            this.setAttr(fldAttr.defaultValue, defaultValue ?? false);
+        if (this._fieldType === this._formConfig.fieldTypes.boolean) {
+            this.defaultValue = defaultValue ?? false;
         }
         else {
-            this.setAttr(fldAttr.defaultValue, defaultValue);
+            this.defaultValue = defaultValue;
         }
-        const defaultTypeAlignment = (this._formConfig.tableFieldStyles[this.fieldType] != null)
-            ? this._formConfig.tableFieldStyles[this.fieldType]['text-align'] : DEFAULT_ALIGNMENT;
+        const defaultTypeAlignment = (this._formConfig.tableFieldStyles[this._fieldType] != null)
+            ? this._formConfig.tableFieldStyles[this._fieldType]['text-align'] : DEFAULT_ALIGNMENT;
         const fieldAlignment = (fld.alignment != null) ? fld.alignment.toLowerCase() : defaultTypeAlignment;
-        this.setAttr(fldAttr.alignment, fieldAlignment);
-        this.setAttr(fldAttr.info, fld.info || '');
+        this.alignment = fieldAlignment;
+        this.info = fld.info || '';
         let fieldFormat;
         try {
             fieldFormat = (fld.format) ? new RegExp(fld.format) : null;
@@ -650,70 +666,254 @@ class FieldDescriptor extends FormElement {
         catch (e) {
             fieldFormat = null;
         }
-        this.setAttr(fldAttr.format, fieldFormat);
-        this.setAttr(fldAttr.validateOnServer, fld.serverAction ?? false);
-        this.setAttr(fldAttr.tooltipText, fld.tooltip || '');
-        this.setAttr(fldAttr.defaultEditable, this.enabled);
-        this.setAttr(fldAttr.required, fld.required ?? false);
-        this.setError(fld.errorCode, fld.errorMessage, fld.errorType ?? DEFAULT_ERROR_TYPE);
-        this.setAttr(fldAttr.outputOnly, fld.outputOnly ?? false);
-        const maxLength = fld.maxLength ?? (this.captureType === 'TEXTAREA' ? BIG_MAX_LENGTH : STD_MAX_LENGTH);
-        this.setAttr(fldAttr.maxLength, maxLength);
-        const intrinsicErrorMessage = this._formConfig?.fieldValidations?.[this.fieldType]?.message
+        this.format = fieldFormat;
+        this.validateOnServer = fld.serverAction ?? false;
+        this.tooltip = fld.tooltip || '';
+        this.defaultEditable = this.enabled;
+        this.required = fld.required ?? false;
+        this.outputOnly = fld.outputOnly ?? false;
+        this.maxLength = fld.maxLength ?? (this._captureType === 'TEXTAREA' ? BIG_MAX_LENGTH : STD_MAX_LENGTH);
+        this.intrinsicErrorMessage = this._formConfig?.fieldValidations?.[this._fieldType]?.message
             ?? this._formConfig?.fieldValidations?.DEFAULT?.message ?? '';
-        this.setAttr(fldAttr.intrinsicErrorMessage, intrinsicErrorMessage);
+        this.setError(fld.errorCode, fld.errorMessage, fld.errorType ?? DEFAULT_ERROR_TYPE);
         this.setEditable(fld.editable ?? true);
-        this.setVisibleLabel(fld.visibleLabel ?? true);
+        this.visibleLabel = fld.visibleLabel ?? true;
         this.setVisibility(fld.visible);
-        this.setFieldOptions(fld.fieldOptions);
-        this.setValue(fld.fieldValue ?? this.defaultValue ?? '');
+        this.options = fld.fieldOptions;
+        this._setValue(fld.fieldValue ?? this._defaultValue ?? '');
     }
-    get name() { return this.fieldCode; }
-    get editionFinish() { return this._editionFinish; }
+    get alignment() { return this._fieldAlignment; }
+    set alignment(alignment) { this.setAttr(attrs._fieldAlignment, alignment); }
     get attributeChange() { return this._attributeChange; }
-    get editionPartial() { return this._editionPartial; }
+    get backend() { return this._validateOnServer; }
+    get captureType() { return this._captureType; }
+    set captureType(captureType) { this.setAttr(attrs._captureType, captureType); }
+    get code() { return this._fieldCode; }
+    get fieldCode() { return this._fieldCode; }
+    get defaultValue() { return this._defaultValue; }
+    set defaultValue(defaultValue) { this.setAttr(attrs._defaultValue, defaultValue); }
+    get defaultEditable() { return this._defaultEditable; }
+    set defaultEditable(editable) { this.setAttr(attrs._defaultEditable, editable); }
     get detailRequest() { return this._detailRequest; }
-    get info() { return this.fieldInfo; }
-    get validating() { return this._onValidation; }
-    set validating(isValidating) { this.setAttr(fldAttr.onValidation, isValidating); }
-    focus() { this.setAttr(fldAttr.focus, true); }
-    setIntrinsicErrorMessage(message) { this.setAttr(fldAttr.intrinsicErrorMessage, message); }
-    set intrinsicErrorMessage(message) { this.setIntrinsicErrorMessage(message); }
-    get fieldValue() { return this.getValue(); }
-    getRequired() { return this.required; }
-    setRequired(required) { this.required = required; }
-    get required() { return this.fieldRequired; }
-    set required(required) { this.setAttr(fldAttr.required, required ?? false); }
-    get minLength() { return this._minLength; }
-    set minLength(requiredMinLength) {
-        this.setAttr(fldAttr.minLength, requiredMinLength);
+    get editionFinish() { return this._editionFinish; }
+    get editionPartial() { return this._editionPartial; }
+    get empty() {
+        const fieldCurrentValue = this.value;
+        if (fieldCurrentValue === undefined || fieldCurrentValue === null) {
+            return true;
+        }
+        if (this._fieldType === this._formConfig.fieldTypes.array
+            && Array.isArray(fieldCurrentValue) && fieldCurrentValue.length === 0) {
+            return true;
+        }
+        ;
+        if (this._fieldType === this._formConfig.fieldTypes.phone) {
+            if (!Array.isArray(fieldCurrentValue)) {
+                return true;
+            }
+            if (fieldCurrentValue.length !== 2 || !fieldCurrentValue[0] || !fieldCurrentValue[1]) {
+                return true;
+            }
+            return false;
+        }
+        ;
+        return fieldCurrentValue === '';
     }
+    get error() { return { type: this._errorType, code: this._errorCode, message: this._errorMessage }; }
+    set error(errorObj) { this.setError(errorObj.code, errorObj.message, errorObj.type ?? DEFAULT_ERROR_TYPE); }
+    get errorCode() { return this._errorCode; }
+    set errorCode(code) { this.setError(code, this._errorMessage); }
+    get errorMessage() { return this._errorMessage; }
+    set errorMessage(msg) { this.setError(this._errorCode, msg); }
+    get errorType() { return this._errorType; }
+    get externalValue() { return this._externalValue; }
+    get format() { return this._fieldFormat; }
+    set format(format) { this.setAttr(attrs._fieldFormat, format); }
+    get hasChanged() { return this._hasChanged; }
+    set hasChanged(hasChanged) { this.setAttr(attrs._hasChanged, hasChanged); }
+    get info() { return this._fieldInfo; }
+    set info(newInfo) { this.setAttr(attrs._fieldInfo, newInfo); }
+    set intrinsicErrorMessage(message) { this.setAttr(attrs._intrinsicErrorMessage, message); }
     get maxLength() { return (this._maxLength > 0) ? this._maxLength.toString() : ''; }
-    set maxLength(requiredMaxLength) {
-        if (typeof requiredMaxLength === 'string') {
-            this.setAttr(fldAttr.maxLength, parseInt(requiredMaxLength, 10));
+    set maxLength(requiredMaxLength) { this.setAttr(attrs._maxLength, +requiredMaxLength); }
+    get maxValue() { return this._maxValue; }
+    set maxValue(inputMaxValue) {
+        let maxValue = inputMaxValue;
+        if (this._fieldType === this._formConfig.fieldTypes.date) {
+            maxValue = new Date(maxValue);
+        }
+        this.setAttr(attrs._maxValue, maxValue);
+    }
+    get minLength() { return this._minLength; }
+    set minLength(requiredMinLength) { this.setAttr(attrs._minLength, +requiredMinLength); }
+    get minValue() { return this._minValue; }
+    set minValue(inputMinValue) {
+        let minValue = inputMinValue;
+        if (this._fieldType === this._formConfig.fieldTypes.date) {
+            minValue = new Date(minValue);
+        }
+        this.setAttr(attrs._minValue, minValue);
+    }
+    get name() { return this._fieldCode; }
+    get options() {
+        return this._fieldOptions?.map(option => {
+            const optionCopy = { ...option };
+            return optionCopy;
+        }) ?? null;
+    }
+    set options(newOptions) {
+        if ((!this._formConfig.captureTypesWithOptions.includes(this._captureType))
+            || typeof newOptions === UNDEFINED || !newOptions
+            || !Array.isArray(newOptions)) {
+            return;
+        }
+        let fieldOptions = newOptions.map((option) => {
+            if (option.text !== undefined && option.text !== null
+                && option.value !== undefined && option.value !== null) {
+                return { fieldOptionValue: option.text, fieldOptionId: option.value };
+            }
+            return option;
+        });
+        fieldOptions = (fieldOptions && Array.isArray(fieldOptions)
+            && fieldOptions.length > 0) ? fieldOptions : [];
+        this.setAttr(attrs._fieldOptions, fieldOptions);
+        if (this._value) {
+            if (this._fieldType === this._formConfig.fieldTypes.array && Array.isArray(this._value)) {
+                const fieldValue = this._value?.filter(item => this._fieldOptions?.find(opt => opt.fieldOptionId === item));
+                this.setAttr(attrs._value, fieldValue);
+            }
+            else {
+                const valInOptions = this._fieldOptions?.find(item => item.fieldOptionId === this._value);
+                if (!valInOptions) {
+                    this._setValue('');
+                }
+            }
         }
-        else if (typeof requiredMaxLength === 'number') {
-            this.setAttr(fldAttr.maxLength, requiredMaxLength);
+        if (this._fieldRequired && this._fieldOptions?.length === 1) {
+            this._setValue(this._fieldOptions?.[0].fieldOptionId);
+            this.notifyEditionFinish();
         }
     }
-    get value() { return this.getValue(); }
-    set value(newValue) { this.setValue(newValue); }
+    get optionText() { return this._fieldOptions?.find(item => item.fieldOptionId === this._value)?.fieldOptionValue ?? null; }
+    get outputOnly() { return this._outputOnly; }
+    set outputOnly(outputOnly) { this.setAttr(attrs._outputOnly, outputOnly); }
+    get required() { return this._fieldRequired; }
+    set required(required) { this.setAttr(attrs._fieldRequired, required ?? false); }
+    get title() { return this._fieldTitle; }
+    set title(title) { this.setAttr(attrs._fieldTitle, title.toString()); }
+    get tooltip() { return this._tooltipText; }
+    set tooltip(tooltip) { this.setAttr(attrs._tooltipText, tooltip); }
+    get type() { return this._fieldType; }
+    set type(fieldType) { this.setAttr(attrs._fieldType, fieldType); }
+    get validating() { return this._onValidation; }
+    set validating(isValidating) { this.setAttr(attrs._onValidation, isValidating); }
+    get value() {
+        return (this._fieldType === this._formConfig.fieldTypes.boolean
+            || this._fieldType === this._formConfig.fieldTypes.check) ? yn(this._value) : this._value;
+    }
+    get validateOnServer() { return this._validateOnServer; }
+    set validateOnServer(validateOnServer) { this.setAttr(attrs._validateOnServer, validateOnServer); }
+    get serverAction() { return this._validateOnServer; }
+    set serverAction(validateOnServer) { this.validateOnServer = validateOnServer; }
+    set value(newValue) { this._setValue(newValue); }
+    get visibleLabel() { return this._visibleLabel; }
+    set visibleLabel(visibleLabel) { this.setAttr(attrs._visibleLabel, visibleLabel); }
+    /**
+     * @deprecated Use options
+     */
+    get fieldOptions() { return this._fieldOptions; }
+    /**
+     * @deprecated Use options
+     */
+    set fieldOptions(options) { this.options = options; }
+    /**
+     * @deprecated Use value
+     */
+    get fieldValue() { return this.value; }
+    /**
+     * @deprecated Use hasChanged
+     */
+    changed(hasChanged = true) { this.hasChanged = hasChanged; }
+    clean() { this._setValue(this._defaultValue || ''); this.resetError(); }
+    focus() { this.setAttr(attrs._focus, true); }
+    getErrorCode() { return this.error.code; }
+    setErrorCode(code) { this.setError(code, this._errorMessage); }
+    getErrorMessage() { return this.error.message; }
+    setErrorMessage(msg) { this.setError(this._errorCode, msg); }
+    getRequired() { return this.required; }
+    hasError() { return this._errorCode !== NO_ERROR; }
+    hideLabel() { this.visibleLabel = false; }
+    resetError() { (this._errorCode !== NO_ERROR) && this.setError(NO_ERROR, null); }
+    setEditable(editable = true) { (editable) ? this.enable() : this.disable(); }
+    setValue(newValue, widgetUpdate = true) { this._setValue(newValue, widgetUpdate); }
+    showLabel() { this.visibleLabel = true; }
+    /**
+     * @deprecated Use title
+     */
+    setLabel(label) { this.title = label; }
+    /**
+     * @deprecated Use required
+     */
+    setRequired(required) { this.required = required; }
+    /**
+     * @deprecated Use changed
+     */
+    setChanged(hasChanged) { this.changed(hasChanged); }
+    /**
+     * @deprecated Use value
+     */
+    getValue() { return this.value; }
+    /**
+     * @deprecated Use empty
+     */
+    isEmpty() { return this.empty; }
+    /**
+     * @deprecated Use error
+     */
+    getError() { return this.error; }
+    /**
+     * @deprecated Use optionText
+     */
+    getOptionText() { return this.optionText; }
+    /**
+     * @deprecated Use options
+     */
+    getFieldOptions() { return this.options; }
+    /**
+     * @deprecated Use options
+     */
+    setFieldOptions(newOptions) { return this.options = newOptions; }
+    /**
+     * @deprecated Use intrinsicErrorMessage
+     */
+    setIntrinsicErrorMessage(message) { this.intrinsicErrorMessage = message; }
+    /**
+     * @deprecated Use maxValue
+     */
+    setMaxValue(inputMaxValue) { this.maxValue = inputMaxValue; }
+    /**
+     * @deprecated Use minValue
+     */
+    setMinValue(inputMinValue) { this.minValue = inputMinValue; }
+    /**
+     * @deprecated Use showLabel
+     */
+    setVisibleLabel(visibleLabel) { this.visibleLabel = visibleLabel; }
     notifyEditionPartial() {
         this.resetError();
-        this._editionPartial.next({ code: this.fieldCode, intrinsicValidation: true });
+        this._editionPartial.next({ code: this._fieldCode, intrinsicValidation: true });
     }
     notifyEditionFinish() {
-        const fieldValue = this.getValue();
+        const fieldValue = this.value;
         this.resetError();
-        const validationConfig = this._formConfig.fieldValidations?.[this.fieldType] ?? {};
+        const validationConfig = this._formConfig.fieldValidations?.[this._fieldType] ?? {};
         const { type, validation } = validationConfig;
         let message = validationConfig?.message;
         let intrinsicValidation = true;
-        if (fieldValue && (validation || this.fieldFormat)) {
+        if (fieldValue && (validation || this._fieldFormat)) {
             if (type === 'regexp') {
                 intrinsicValidation = (validation?.test(fieldValue) ?? true)
-                    && (this.fieldFormat?.test(fieldValue) ?? true);
+                    && (this._fieldFormat?.test(fieldValue) ?? true);
             }
             else if (type === 'function' && typeof validation === 'function') {
                 const { valid, message: customMessage } = validation(fieldValue, this);
@@ -735,155 +935,48 @@ class FieldDescriptor extends FormElement {
         if (intrinsicValidation && fieldValue && typeof fieldValue === 'string'
             && this._minLength && fieldValue?.length < this._minLength) {
             intrinsicValidation = false;
-            this.setError('99', `Longitud de ${this.fieldTitle} debe ser de al menos ${this._minLength}`);
-        }
-        this._editionFinish.next({ code: this.fieldCode, intrinsicValidation });
-    }
-    setAttr(name, value) {
-        this[name] = value;
-        if (this._formConfig.monitoredFieldAttributes.includes(name)) {
-            this._attributeChange.next({ name, value });
+            this.setError('99', `Longitud de ${this._fieldTitle} debe ser de al menos ${this._minLength}`);
         }
+        this._editionFinish.next({ code: this._fieldCode, intrinsicValidation });
     }
     notifyEditionDetailRequest(detail) {
-        const detailEvent = {
-            code: this.fieldCode,
-            detail,
-        };
+        const detailEvent = { code: this._fieldCode, detail };
         this._detailRequest.next(detailEvent);
     }
-    setVisibleLabel(visibleLabel) { this.setAttr(fldAttr.visibleLabel, visibleLabel); }
-    showLabel() { this.setVisibleLabel(true); }
-    hideLabel() { this.setVisibleLabel(false); }
-    setChanged(hasChanged) { this.setAttr(fldAttr.hasChanged, hasChanged); }
-    changed() { this.setChanged(true); }
-    setLabel(label) { this.setAttr(fldAttr.title, label); }
-    clean() { this.setValue(this.defaultValue || ''); this.resetError(); }
-    get backend() { return this.validateOnServer; }
-    setEditable(editable = true) { (editable) ? this.enable() : this.disable(); }
-    hasError() { return this.errorCode !== NO_ERROR; }
-    resetError() { (this.errorCode !== NO_ERROR) && this.setError(NO_ERROR, null); }
-    setError(code, message, type = DEFAULT_ERROR_TYPE) {
-        this.setAttr(fldAttr.errorCode, code ?? NO_ERROR);
-        this.setAttr(fldAttr.errorType, (this.errorCode === NO_ERROR) ? '' : type);
-        this.setAttr(fldAttr.errorMessage, message ?? '');
+    setAttr(attr, value) {
+        const { name: attrName, propagate: name } = attr;
+        this[attrName] = value;
+        name && this._attributeChange.next({ name, value });
     }
-    getError() { return { type: this.errorType, code: this.errorCode, message: this.errorMessage }; }
-    get error() { return this.getError(); }
-    set error(errorObj) { this.setError(errorObj.code, errorObj.message, errorObj.type ?? DEFAULT_ERROR_TYPE); }
-    getErrorCode() { return this.getError().code; }
-    setErrorCode(code) { this.setError(code, this.errorMessage); }
-    getErrorMessage() { return this.getError().message; }
-    setErrorMessage(msg) { this.setError(this.errorCode, msg); }
-    get empty() { return this.isEmpty(); }
-    isEmpty() {
-        const fieldCurrentValue = this.getValue();
-        if (fieldCurrentValue === undefined || fieldCurrentValue === null) {
-            return true;
-        }
-        if (this.fieldType === this._formConfig.fieldTypes.array
-            && Array.isArray(fieldCurrentValue) && fieldCurrentValue.length === 0) {
-            return true;
-        }
-        ;
-        if (this.fieldType === this._formConfig.fieldTypes.phone) {
-            if (!Array.isArray(fieldCurrentValue)) {
-                return true;
-            }
-            if (fieldCurrentValue.length !== 2 || !fieldCurrentValue[0] || !fieldCurrentValue[1]) {
-                return true;
-            }
-            return false;
-        }
-        ;
-        return fieldCurrentValue === '';
-    }
-    getValue() {
-        if (this.fieldType === this._formConfig.fieldTypes.boolean
-            || this.fieldType === this._formConfig.fieldTypes.check) {
-            return yn(this._value);
-        }
-        return this._value;
-    }
-    getOptionText() {
-        return this.fieldOptions?.find(item => item.fieldOptionId === this._value)?.fieldOptionValue ?? null;
+    setError(code, message, type = DEFAULT_ERROR_TYPE) {
+        this.setAttr(attrs._errorCode, code ?? NO_ERROR);
+        this.setAttr(attrs._errorType, (this._errorCode === NO_ERROR) ? '' : type);
+        this.setAttr(attrs._errorMessage, message ?? '');
     }
     updateFromServer(fld) {
         const fieldKeys = Object.keys(fld);
         for (let index = 0; index < fieldKeys.length; index++) {
             const attrName = fieldKeys[index];
             const attrValue = fld[attrName];
-            (attrName === this._formConfig.apiFieldAttrs.visible) && this.setVisibility(attrValue);
-            (attrName === this._formConfig.apiFieldAttrs.labelVisible) && this.setVisibleLabel(fld.visibleLabel);
-            (attrName === this._formConfig.apiFieldAttrs.required) && this.setAttr(fldAttr.required, fld.required ?? false);
-            (attrName === this._formConfig.apiFieldAttrs.errorCode) && this.setAttr(fldAttr.errorCode, fld.errorCode);
-            (attrName === this._formConfig.apiFieldAttrs.errorMessage) && this.setAttr(fldAttr.errorMessage, fld.errorMessage);
-            (attrName === this._formConfig.apiFieldAttrs.tooltip) && this.setAttr(fldAttr.tooltipText, fld.tooltip);
-            (attrName === this._formConfig.apiFieldAttrs.info) && this.setAttr(fldAttr.info, fld.info);
-            (attrName === this._formConfig.apiFieldAttrs.editable) && this.setEditable(fld.editable);
-            (attrName === this._formConfig.apiFieldAttrs.title) && this.setLabel(fld.fieldTitle.toString());
-            (attrName === this._formConfig.apiFieldAttrs.value) && (this.setValue(fld.fieldValue) && this.setChanged(false));
-            (attrName === this._formConfig.apiFieldAttrs.options) && this.setFieldOptions(fld.fieldOptions);
-            (attrName === this._formConfig.apiFieldAttrs.captureType) && this.setAttr(fldAttr.captureType, fld.captureType || 'INPUT');
-            (attrName === this._formConfig.apiFieldAttrs.type) && this.setAttr(fldAttr.type, fld.fieldTypeCode);
-            (attrName === this._formConfig.apiFieldAttrs.maxLength) && this.setAttr(fldAttr.maxLength, fld.maxLength);
-        }
-    }
-    setMinValue(inputMinValue) {
-        let minValue = inputMinValue;
-        if (this.fieldType === this._formConfig.fieldTypes.date) {
-            minValue = new Date(minValue);
-        }
-        this.setAttr(fldAttr.minValue, minValue);
-    }
-    setMaxValue(inputMaxValue) {
-        let maxValue = inputMaxValue;
-        if (this.fieldType === this._formConfig.fieldTypes.date) {
-            maxValue = new Date(maxValue);
-        }
-        this.setAttr(fldAttr.maxValue, maxValue);
-    }
-    getFieldOptions() {
-        return this.fieldOptions.map(option => {
-            const optionCopy = { ...option };
-            return optionCopy;
-        });
-    }
-    setFieldOptions(newOptions) {
-        if ((!this._formConfig.captureTypesWithOptions.includes(this.captureType))
-            || typeof newOptions === UNDEFINED || !newOptions
-            || !Array.isArray(newOptions)) {
-            return;
-        }
-        let fieldOptions = newOptions.map(option => {
-            if (option.text !== undefined && option.text !== null
-                && option.value !== undefined && option.value !== null) {
-                return { fieldOptionValue: option.text, fieldOptionId: option.value };
-            }
-            return { ...option };
-        });
-        fieldOptions = (fieldOptions && Array.isArray(fieldOptions)
-            && fieldOptions.length > 0) ? fieldOptions : [];
-        this.setAttr(fldAttr.options, fieldOptions);
-        if (this._value) {
-            if (this.fieldType === this._formConfig.fieldTypes.array && Array.isArray(this._value)) {
-                const fieldValue = this._value?.filter(item => this.fieldOptions.find(opt => opt.fieldOptionId === item));
-                this.setAttr(fldAttr.value, fieldValue);
+            if (directChanges.includes(attrName)) {
+                this[attrName] = attrValue;
             }
             else {
-                const valInOptions = this.fieldOptions
-                    .find(item => item.fieldOptionId === this._value);
-                if (!valInOptions) {
-                    this.setValue('');
-                }
+                (attrName === 'label') && (this.title = attrValue);
+                (attrName === 'labelVisible') && (this.visibleLabel = attrValue);
+                (attrName === 'editable') && this.setEditable(attrValue);
+                (attrName === 'visible') && this.setVisibility(attrValue);
+                (attrName === 'value') && (this._setValue(attrValue) && (this.hasChanged = false));
+                (attrName === 'fieldValue') && (this._setValue(attrValue) && (this.hasChanged = false));
+                (attrName === 'fieldOptions') && (this.options = attrValue);
+                (attrName === 'fieldTitle') && (this.title = attrValue);
+                (attrName === 'fieldTypeCode') && (this.type = attrValue);
+                (attrName === 'fieldType') && (this.type = attrValue);
+                (attrName === 'tooltipText') && (this.tooltip = attrValue);
             }
         }
-        if (this.fieldRequired && this.fieldOptions.length === 1) {
-            this.setValue(this.fieldOptions[0].fieldOptionId);
-            this.notifyEditionFinish();
-        }
     }
-    setValue(newValue, widgetUpdate = true) {
+    _setValue(newValue, widgetUpdate = true) {
         if (typeof newValue === UNDEFINED) {
             return true;
         }
@@ -891,12 +984,12 @@ class FieldDescriptor extends FormElement {
             return true;
         }
         let newFinalValue;
-        if (this.fieldType === this._formConfig.fieldTypes.boolean
-            || this.fieldType === this._formConfig.fieldTypes.check) {
+        if (this._fieldType === this._formConfig.fieldTypes.boolean
+            || this._fieldType === this._formConfig.fieldTypes.check) {
             newFinalValue = yn(newValue) ?? false;
         }
-        else if (this.fieldType === this._formConfig.fieldTypes.array
-            || this.fieldType === this._formConfig.fieldTypes.map) {
+        else if (this._fieldType === this._formConfig.fieldTypes.array
+            || this._fieldType === this._formConfig.fieldTypes.map) {
             if (newValue === null || newValue === '') {
                 newFinalValue = [];
             }
@@ -911,9 +1004,9 @@ class FieldDescriptor extends FormElement {
             newFinalValue = newValue;
         }
         if (this._value !== newFinalValue) {
-            this.setChanged(true);
+            this.hasChanged = true;
             if (widgetUpdate) {
-                this.setAttr(fldAttr.value, newFinalValue);
+                this.setAttr(attrs._value, newFinalValue);
             }
             else {
                 this._value = newFinalValue;
@@ -1553,7 +1646,7 @@ class RecordFormSubSection {
         return this.subSectionFields;
     }
     getFieldNames() {
-        return this.subSectionFields.map(field => field.fieldCode);
+        return this.subSectionFields.map(field => field.code);
     }
     getActions() {
         return this.subSectionActions;
@@ -1770,7 +1863,7 @@ class FormStructureAndData {
             });
             for (const fieldReceived of formFields) {
                 const fieldToAdd = new FieldDescriptor(fieldReceived, this._formConfig);
-                const fieldCode = fieldToAdd.fieldCode;
+                const fieldCode = fieldToAdd.code;
                 if (fieldCode) {
                     this._fieldArray.push(fieldToAdd);
                     this._fields[fieldCode] = fieldToAdd;
@@ -1865,13 +1958,13 @@ class FormStructureAndData {
     get fields() { return this._fields; }
     get fieldNames() { return this.getFieldNames(); }
     getFields() { return this._fieldArray; }
-    getFieldNames() { return this._fieldArray.map(field => field.fieldCode); }
+    getFieldNames() { return this._fieldArray.map(field => field.code); }
     getField(code) { return (code && this._fields?.[code]) ? this._fields[code] : null; }
     enableField(code) { this.getField(code)?.enable(); }
     disableField(code) { this.getField(code)?.disable(); }
-    getFieldValue(code) { return this.getField(code)?.getValue(); }
-    getFieldOptionText(code) { return this.getField(code)?.getOptionText(); }
-    getFieldOptions(code) { return this.getField(code)?.getFieldOptions() ?? null; }
+    getFieldValue(code) { return this.getField(code)?.value; }
+    getFieldOptionText(code) { return this.getField(code)?.optionText; }
+    getFieldOptions(code) { return this.getField(code)?.options ?? null; }
     setFieldValue(code, value) { this.getField(code)?.setValue(value); }
     setFieldError(code, errorCode, message, type = 'error') { this.getField(code)?.setError(errorCode, message, type); }
     setFieldIntrinsicErrorMessage(code, message) { this.getField(code)?.setIntrinsicErrorMessage(message); }
@@ -1879,7 +1972,8 @@ class FormStructureAndData {
         const codes = this.getFieldSet(null, inputCodes ?? null);
         for (const code of codes) {
             try {
-                this.getField(code)?.setRequired(required);
+                const field = this.getField(code) ?? null;
+                field && (field.required = required);
             }
             catch (e) {
                 console.log(`Error modificando campo ${code}: ${e}`);
@@ -1939,28 +2033,28 @@ class FormStructureAndData {
         return processedFields;
     }
     enableFields(codes, secCode, subCode) {
-        return this.applyOnFields(fld => fld.enable(), codes, secCode, subCode);
+        return this.applyOnFields(fld => fld?.enable(), codes, secCode, subCode);
     }
     showFields(codes, secCode, subCode) {
-        return this.applyOnFields(fld => fld.show(), codes, secCode, subCode);
+        return this.applyOnFields(fld => fld?.show(), codes, secCode, subCode);
     }
     hideFields(codes, secCode, subCode) {
-        return this.applyOnFields(fld => fld.hide(), codes, secCode, subCode);
+        return this.applyOnFields(fld => fld?.hide(), codes, secCode, subCode);
     }
     showLabelFields(codes, secCode, subCode) {
-        return this.applyOnFields(fld => fld.showLablel(), codes, secCode, subCode);
+        return this.applyOnFields(fld => fld?.showLablel(), codes, secCode, subCode);
     }
     hideLabelFields(codes, secCode, subCode) {
-        return this.applyOnFields(fld => fld.hideLabel(), codes, secCode, subCode);
+        return this.applyOnFields(fld => fld?.hideLabel(), codes, secCode, subCode);
     }
     disableFields(codes, secCode, subCode) {
-        return this.applyOnFields(fld => fld.disable(), codes, secCode, subCode);
+        return this.applyOnFields(fld => fld?.disable(), codes, secCode, subCode);
     }
     cleanFields(codes, secCode, subCode) {
-        return this.applyOnFields(fld => fld.clean(), codes, secCode, subCode);
+        return this.applyOnFields(fld => fld?.clean(), codes, secCode, subCode);
     }
     tagFieldsWithError(message, codes, secCode, subCode) {
-        return this.applyOnFields(fld => fld.setErrorMessage(message), codes, secCode, subCode);
+        return this.applyOnFields(fld => fld?.setErrorMessage(message), codes, secCode, subCode);
     }
     cleanErrorFields(codes, secCode, subCode) {
         return this.tagFieldsWithError('', codes, secCode, subCode);
@@ -1969,16 +2063,16 @@ class FormStructureAndData {
         return this.tagFieldsWithError(message, this.getRequiredEmptyFields(codes, secCode, subCode)) > 0;
     }
     getRequiredFields(codes, secCode, subCode) {
-        return this.getFieldSet(fld => fld.required, codes ?? null, secCode, subCode);
+        return this.getFieldSet(fld => fld?.required, codes ?? null, secCode, subCode);
     }
     getRequiredEmptyFields(codes, secCode, subCode) {
-        return this.getFieldSet(fld => fld.required && fld.empty, codes ?? null, secCode, subCode);
+        return this.getFieldSet(fld => fld?.required && fld?.empty, codes ?? null, secCode, subCode);
     }
     getChangedFields(codes, secCode, subCode) {
-        return this.getFieldSet(fld => !fld.outputOnly && fld.hasChanged(), codes ?? null, secCode, subCode);
+        return this.getFieldSet(fld => !fld?.outputOnly && fld?.hasChanged(), codes ?? null, secCode, subCode);
     }
     getFieldsWithValidationIssues(codes, secCode, subCode) {
-        return this.getFieldSet(fld => fld.errorCode !== NO_ERROR, codes ?? null, secCode, subCode);
+        return this.getFieldSet(fld => fld?.hasError(), codes ?? null, secCode, subCode);
     }
     getFieldsValues(inputCodes, secCode, subCode) {
         const codes = this.getFieldSet(null, inputCodes ?? null, secCode, subCode);
@@ -2090,14 +2184,14 @@ class FormStructureAndData {
             fields: [],
             tables: [],
         };
-        formData.fields = this.getFields().filter(fld => !fld.outputOnly)
+        formData.fields = this.getFields().filter(fld => !fld?.outputOnly)
             .map(fld => {
             const fieldPayload = {
-                fieldCode: fld.fieldCode,
-                fieldValue: fld.getValue(),
-                editable: !fld.disabled,
-                visible: fld.visible,
-                required: fld.required,
+                fieldCode: fld?.code,
+                fieldValue: fld?.value,
+                editable: !fld?.disabled,
+                visible: fld?.visible,
+                required: fld?.required,
                 fieldOptions: '',
             };
             return fieldPayload;
@@ -2238,6 +2332,7 @@ class BasicFormComponent {
         this._formRoute = null;
         this._definitionObtained = false;
         // Eventos de acciones y campos
+        this._formSectionsCanDeactivate = {};
         this._formSectionsActivate = {};
         this._formSectionsInactivate = {};
         this._formActionsStart = {};
@@ -2485,6 +2580,7 @@ class BasicFormComponent {
         // Se limpian los manejadores de eventos
         this.visible = false;
         this.busy = false;
+        this._formSectionsCanDeactivate = {};
         this._formSectionsActivate = {};
         this._formSectionsInactivate = {};
         this._formActionsStart = {};
@@ -2527,7 +2623,7 @@ class BasicFormComponent {
     displayActionServerError() { }
     displayValidationServerError() { }
     displayTableServerError() { }
-    showFieldInfo(fieldCode, detail) { }
+    showFieldInfo(code, detail) { }
     showModalDialog(title, body, options, callback, params) { }
     openUploadDialog(title, body, options, callback, params) { }
     /**
@@ -2695,9 +2791,9 @@ class BasicFormComponent {
         this._formStructure?.changeState(initialState || this._formStructure?.defaultState);
         const inputFieldNames = Object.keys(this.inputDataFields);
         for (let index = 0; index < inputFieldNames.length; index++) {
-            const fieldCode = inputFieldNames[index];
-            const fieldValue = this.inputDataFields[fieldCode];
-            this.setFieldValue(fieldCode, fieldValue);
+            const code = inputFieldNames[index];
+            const fieldValue = this.inputDataFields[code];
+            this.setFieldValue(code, fieldValue);
         }
         const recordResponse = await this.requestFormAction(formActions.getData);
         this.checkErrorRecordReceived(recordResponse);
@@ -2821,6 +2917,15 @@ class BasicFormComponent {
     /**
      * Manejo de event handlers para acciones sobre el formulario
      */
+    onSectionCanDeactivate(codes, callback, properties = null) {
+        const sectionSet = (Array.isArray(codes)) ? codes : (codes ? [codes] : []);
+        sectionSet.forEach((sectionName) => {
+            if (!this._formSectionsCanDeactivate[sectionName]) {
+                this._formSectionsCanDeactivate[sectionName] = [];
+            }
+            this._formSectionsCanDeactivate[sectionName].push({ callback, properties });
+        });
+    }
     onSectionActivation(codes, callback, properties = null) {
         const sectionSet = (Array.isArray(codes)) ? codes : (codes ? [codes] : []);
         sectionSet.forEach((sectionName) => {
@@ -2857,6 +2962,23 @@ class BasicFormComponent {
             this._formActionsFinish[actionName].push({ callback, properties });
         });
     }
+    async verifySectionActivation(code) {
+        const sectionObject = this._formStructure?.getSection(code);
+        if (!sectionObject) {
+            return false;
+        }
+        const clientSectionMethods = this._formSectionsCanDeactivate[code];
+        if (clientSectionMethods) {
+            for (const clientSectionMethod of clientSectionMethods) {
+                const { callback, properties } = clientSectionMethod;
+                const canActivate = callback(sectionObject);
+                if (canActivate === false) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
     async launchSectionActivation(code) {
         const sectionObject = this._formStructure?.getSection(code);
         if (!sectionObject) {
@@ -2950,37 +3072,37 @@ class BasicFormComponent {
      */
     onFieldInput(codes, callback, properties = null) {
         const fieldSet = (Array.isArray(codes)) ? codes : (codes ? [codes] : []);
-        fieldSet.forEach((fieldCode) => {
-            if (!this._fieldInputValidation[fieldCode]) {
-                this._fieldInputValidation[fieldCode] = [];
+        fieldSet.forEach((code) => {
+            if (!this._fieldInputValidation[code]) {
+                this._fieldInputValidation[code] = [];
             }
-            this._fieldInputValidation[fieldCode].push({ callback, properties });
+            this._fieldInputValidation[code].push({ callback, properties });
         });
     }
     onFieldValidationStart(codes, callback, properties = null) {
         const fieldSet = (Array.isArray(codes)) ? codes : (codes ? [codes] : []);
-        fieldSet.forEach((fieldCode) => {
-            if (!this._fieldValidationsStart[fieldCode]) {
-                this._fieldValidationsStart[fieldCode] = [];
+        fieldSet.forEach((code) => {
+            if (!this._fieldValidationsStart[code]) {
+                this._fieldValidationsStart[code] = [];
             }
-            this._fieldValidationsStart[fieldCode].push({ callback, properties });
+            this._fieldValidationsStart[code].push({ callback, properties });
         });
     }
     onFieldValidationFinish(codes, callback, properties = null) {
         const fieldSet = (Array.isArray(codes)) ? codes : (codes ? [codes] : []);
-        fieldSet.forEach((fieldCode) => {
-            if (!this._fieldValidationsFinish[fieldCode]) {
-                this._fieldValidationsFinish[fieldCode] = [];
+        fieldSet.forEach((code) => {
+            if (!this._fieldValidationsFinish[code]) {
+                this._fieldValidationsFinish[code] = [];
             }
-            this._fieldValidationsFinish[fieldCode].push({ callback, properties });
+            this._fieldValidationsFinish[code].push({ callback, properties });
         });
     }
-    async startFieldInputValidation(fieldCode, intrinsicValidation = true) {
-        const fieldToValidate = this.getField(fieldCode);
+    async startFieldInputValidation(code, intrinsicValidation = true) {
+        const fieldToValidate = this.getField(code);
         if (!fieldToValidate) {
             return false;
         }
-        const validationCallbacks = this._fieldInputValidation[fieldCode];
+        const validationCallbacks = this._fieldInputValidation[code];
         if (validationCallbacks) {
             const clientValidationPromises = [];
             for (const validationMethod of validationCallbacks) {
@@ -2992,12 +3114,12 @@ class BasicFormComponent {
         }
         return true;
     }
-    async startFieldValidation(fieldCode, intrinsicValidation = true) {
-        const fieldToValidate = this.getField(fieldCode);
+    async startFieldValidation(code, intrinsicValidation = true) {
+        const fieldToValidate = this.getField(code);
         if (!fieldToValidate) {
             return;
         }
-        const validationCallbacks = this._fieldValidationsStart[fieldCode];
+        const validationCallbacks = this._fieldValidationsStart[code];
         if (validationCallbacks) {
             const clientValidationPromises = [];
             for (const validationMethod of validationCallbacks) {
@@ -3026,10 +3148,9 @@ class BasicFormComponent {
         if (fieldObj.backend) {
             fieldObj.validating = true;
             validationResult = await this
-                .requestFormAction(formActions.validate, fieldObj.fieldCode);
+                .requestFormAction(formActions.validate, fieldObj.code);
             serverError = !!this.errorOccured();
         }
-        await this.finishFieldValidation(fieldObj, validationResult, serverError);
         if (serverError) {
             fieldObj?.setErrorCode(this.errorCode);
             fieldObj?.setErrorMessage(this.errorMessage);
@@ -3038,10 +3159,11 @@ class BasicFormComponent {
                 callback(fieldObj);
             }
         }
+        await this.finishFieldValidation(fieldObj, validationResult, serverError);
         fieldObj.validating = false;
     }
     async finishFieldValidation(fieldObject, validationResult, serverError = false) {
-        const validationCallbacks = this._fieldValidationsFinish[fieldObject.fieldCode];
+        const validationCallbacks = this._fieldValidationsFinish[fieldObject.code];
         if (validationCallbacks) {
             const clientActionPromises = [];
             for (const validationMethod of validationCallbacks) {
@@ -3054,8 +3176,8 @@ class BasicFormComponent {
             await Promise.all(clientActionPromises);
         }
     }
-    async continueFieldValidation(fieldCode) {
-        return this.startServerFieldValidation(fieldCode);
+    async continueFieldValidation(code) {
+        return this.startServerFieldValidation(code);
     }
     /**
      * Manejadores de eventos para acciones sobre Tablas
@@ -3553,8 +3675,8 @@ class BasicFormComponent {
             validationError = true;
             this.setError(this.formConfig.formStandardErrors.typeWarning, this.formConfig.formStandardErrors.validationTitle, this.formConfig.formStandardErrors.requiredFields);
             this.tagFieldsWithError(this.formConfig.formStandardErrors.requiredField, requiredEmptyFields);
-            for (const fieldCode of requiredEmptyFields) {
-                const requiredEmptyField = this.getField(fieldCode);
+            for (const code of requiredEmptyFields) {
+                const requiredEmptyField = this.getField(code);
                 requiredEmptyField?.focus();
                 break;
             }
@@ -3563,8 +3685,8 @@ class BasicFormComponent {
         if (!validationError && validationIssueFields.length > 0) {
             validationError = true;
             this.setError(this.formConfig.formStandardErrors.typeWarning, this.formConfig.formStandardErrors.validationTitle, this.formConfig.formStandardErrors.validationFields);
-            for (const fieldCode of validationIssueFields) {
-                const validationIssueField = this.getField(fieldCode);
+            for (const code of validationIssueFields) {
+                const validationIssueField = this.getField(code);
                 if (validationIssueField) {
                     validationIssueField.focus();
                 }
@@ -3580,8 +3702,8 @@ class BasicFormComponent {
         if (tableRecord && columnNames) {
             for (const columnName of columnNames) {
                 const columnValue = tableRecord.getFieldValue(columnName) ?? '';
-                const fieldCode = mappingTable?.[columnName] ?? columnName;
-                this.setFieldValue(fieldCode, columnValue);
+                const code = mappingTable?.[columnName] ?? columnName;
+                this.setFieldValue(code, columnValue);
             }
             return true;
         }
@@ -3669,9 +3791,9 @@ class BasicFormComponent {
         return this.onTableGetDataFinish(code, callback, properties);
     }
 }
-BasicFormComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: BasicFormComponent, deps: [{ token: LibFormManagerService }, { token: LibEventManagerService }, { token: LibFileManagementService }], target: i0.ɵɵFactoryTarget.Component });
-BasicFormComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.1", type: BasicFormComponent, selector: "ng-component", ngImport: i0, template: `<ng-content></ng-content>`, isInline: true });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: BasicFormComponent, decorators: [{
+BasicFormComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: BasicFormComponent, deps: [{ token: LibFormManagerService }, { token: LibEventManagerService }, { token: LibFileManagementService }], target: i0.ɵɵFactoryTarget.Component });
+BasicFormComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.6", type: BasicFormComponent, selector: "ng-component", ngImport: i0, template: `<ng-content></ng-content>`, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: BasicFormComponent, decorators: [{
             type: Component,
             args: [{
                     template: `<ng-content></ng-content>`
@@ -3693,8 +3815,8 @@ const COMPONENTS = [
 ];
 class TuainNgFormsLibModule {
 }
-TuainNgFormsLibModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: TuainNgFormsLibModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-TuainNgFormsLibModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: TuainNgFormsLibModule, declarations: [BasicFormComponent,
+TuainNgFormsLibModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: TuainNgFormsLibModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+TuainNgFormsLibModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.2.6", ngImport: i0, type: TuainNgFormsLibModule, declarations: [BasicFormComponent,
         ActionComponent,
         FieldComponent,
         ElementComponent,
@@ -3717,12 +3839,10 @@ TuainNgFormsLibModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", v
         LibTableRecordActionComponent,
         LibTableRecordFieldComponent,
         LibTableComponent] });
-TuainNgFormsLibModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: TuainNgFormsLibModule, imports: [[
-            CommonModule,
-            RouterModule,
-            FormsModule,
-        ]] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.1", ngImport: i0, type: TuainNgFormsLibModule, decorators: [{
+TuainNgFormsLibModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: TuainNgFormsLibModule, imports: [CommonModule,
+        RouterModule,
+        FormsModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: TuainNgFormsLibModule, decorators: [{
             type: NgModule,
             args: [{
                     declarations: COMPONENTS,