tuain-ng-forms-lib 17.0.0 → 17.1.1

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

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { Component, Input, EventEmitter, Output, ChangeDetectionStrategy, NgModule } from '@angular/core';
+import { signal, computed, Component, Input, EventEmitter, Output, ChangeDetectionStrategy, NgModule } from '@angular/core';
 import { BehaviorSubject, Subject, ReplaySubject } from 'rxjs';
 import yn from 'yn';
 import { nanoid } from 'nanoid';
@@ -7,33 +7,57 @@ import { CommonModule } from '@angular/common';
 import { RouterModule } from '@angular/router';
 import { FormsModule } from '@angular/forms';
 
-const CUSTOM_ATTRIBUTES = 'customAttributes';
+const CUSTOM_ATTRIBUTES$6 = 'customAttributes';
 class PieceComponent {
     form;
     formConfig;
-    visible = true;
-    disabled = false;
-    customAttributes = {};
+    visible = signal(false);
+    disabled = signal(false);
+    enabled = computed(() => !this.disabled());
+    customAttributes = signal({});
     setForm(form) { this.form = form; }
-    defaultProcessAttributeChange(attribute, value) {
-        if (!attribute || attribute.trim() === '') {
-            return false;
+    propagatedAttributeChange(attribute, value) { }
+    updatePieceAttribute(signaledAttributes, signaledAttribute, value) {
+        if (!signaledAttributes.includes(signaledAttribute)) {
+            return;
         }
-        const attributeParts = attribute.split('.');
-        if (attributeParts?.length > 1) {
-            const [attributeType, subAttribute] = attributeParts;
-            if (attributeType === CUSTOM_ATTRIBUTES) {
-                this.customAttributes[subAttribute] = value;
-                this.customAttributeChange(subAttribute, value);
-            }
+        this[signaledAttribute]?.set(value);
+        this.propagatedAttributeChange(signaledAttribute, value);
+    }
+    updatePieceAttributes(piece, signaledAttributes) {
+        if (!piece) {
+            return;
         }
-        else {
-            this[attribute] = value;
+        // Se recore el conjunto de los atributos propagados desde el piece y se asigna el valor respectivo
+        for (let index = 0; index < signaledAttributes.length; index++) {
+            const signaledAttribute = signaledAttributes[index];
+            try {
+                this[signaledAttribute]?.set(piece?.[signaledAttribute]);
+                this.propagatedAttributeChange(signaledAttribute, piece?.[signaledAttribute]);
+            }
+            catch (e) {
+                console.log(`Señal ${signaledAttribute} invalida en el componente. ${e}`);
+            }
         }
-        return true;
     }
-    customProcessAttributeChange(attribute, value) { }
+    // Función que las subclases pueden sobrecargar para manejar un comportamiento específico
     customAttributeChange(subAttribute, value) { }
+    updateCustomAttribute(attrName, attrValue) {
+        this.customAttributes.update(oldCustomAttr => {
+            oldCustomAttr[attrName] = attrValue;
+            return oldCustomAttr;
+        });
+        // Ejecución de función personalizada ante un cambio de atributo personalizado
+        this.customAttributeChange(attrName, attrValue);
+    }
+    replaceCustomAttributes(customAttributes) {
+        this.customAttributes.set(customAttributes ?? {});
+        Object.keys(customAttributes).forEach(attrName => {
+            const attrValue = customAttributes[attrName];
+            // Ejecución de función personalizada ante un cambio de atributo personalizado
+            this.customAttributeChange(attrName, attrValue);
+        });
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PieceComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
     static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: PieceComponent, selector: "lib-piece", ngImport: i0, template: `<ng-content></ng-content>`, isInline: true });
 }
@@ -63,32 +87,42 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                 type: Input
             }] } });
 
+const CUSTOM_ATTRIBUTES$5 = 'customAttributes';
+const signaledAttributes$5 = [
+    'actionCode', 'actionName', 'iconName', 'inProgress', 'restrictedOnField', 'restrictedOnOperator',
+    'restrictedOnValue', 'visible', 'disabled',
+];
 class ActionComponent extends ElementComponent {
-    inProgress = false;
+    actionCode = signal(null);
+    actionName = signal(null);
+    iconName = signal(null);
+    inProgress = signal(false);
+    restrictedOnField = signal(null);
+    restrictedOnOperator = signal(null);
+    restrictedOnValue = signal(null);
     action = null;
+    updatePropagatedAttributes() {
+        this.updatePieceAttributes(this.action, signaledAttributes$5);
+    }
     ngOnInit() {
         if (!this.action) {
             return;
         }
+        this.action.widget = this;
         this.formConfig = this.action?._formConfig;
-        const mapping = Object.entries(this.formConfig?.actionPropagateAttributes);
-        for (let index = 0; index < mapping.length; index++) {
-            const actionAttr = mapping[index]?.[0];
-            const componentAttr = mapping[index]?.[1]?.toString() ?? '';
-            if (componentAttr) {
-                const value = this.action?.[actionAttr];
-                this.defaultProcessAttributeChange(componentAttr, value);
-                this.customProcessAttributeChange(componentAttr, value);
+        this.updatePropagatedAttributes();
+        this.replaceCustomAttributes(this.action?.customAttributes);
+        this.action?.attributeChange.subscribe(event => {
+            const { name: attribute, value = null } = event ?? {};
+            const attributeParts = attribute?.split('.') ?? [];
+            if (signaledAttributes$5.includes(attribute)) {
+                this.updatePieceAttribute(signaledAttributes$5, attribute, value);
+            }
+            else if (attributeParts?.length > 1 && attributeParts?.[0] === CUSTOM_ATTRIBUTES$5) {
+                const subAttribute = attributeParts?.[1] ?? null;
+                this.updateCustomAttribute(subAttribute, value);
             }
-        }
-        this.action?.attributeChange?.subscribe(event => {
-            const { name: componentAttr, value } = event;
-            this.defaultProcessAttributeChange(componentAttr, value);
-            this.customProcessAttributeChange(componentAttr, value);
         });
-        if (this.action) {
-            this.action.widget = this;
-        }
         this.start();
     }
     start() {
@@ -112,85 +146,76 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                 type: Input
             }] } });
 
+const CUSTOM_ATTRIBUTES$4 = 'customAttributes';
+const signaledAttributes$4 = ['captureType', 'errorCode', 'errorMessage', 'errorType', 'defaultValue',
+    'defaultEditable', 'alignment', 'code', 'info', 'required', 'title', 'type', 'format', 'options',
+    'hasChanged', 'maxLength', 'maxValue', 'minLength', 'minValue', 'onValidation', 'outputOnly',
+    'placeholder', 'tooltip', 'validateOnServer', 'visibleLabel', 'visible', 'disabled', 'value',
+];
 const VALUE = 'value';
 const FOCUS = 'focus';
 class FieldComponent extends ElementComponent {
-    // Atributos obtenidos estáticamente
-    code = '';
-    value;
-    info = '';
-    alignment = '';
-    tooltip = '';
-    // Atributos actualizados por subscripción
-    minLength;
-    maxLength;
-    minValue;
-    maxValue;
-    onValidation;
-    captureType;
-    title;
-    type;
-    visibleLabel;
-    required;
-    options;
-    errorType;
-    errorCode;
-    errorMessage;
+    // Atributos propagados desde el campo
+    captureType = signal('');
+    errorCode = signal('');
+    errorMessage = signal('');
+    errorType = signal('');
+    defaultValue = signal(null);
+    defaultEditable = signal(false);
+    alignment = signal('');
+    code = signal('');
+    info = signal(null);
+    required = signal(false);
+    title = signal('');
+    type = signal('');
+    format = signal(null);
+    options = signal(null);
+    hasChanged = signal(false);
+    minLength = signal(0);
+    maxLength = signal(0);
+    minValue = signal(null);
+    maxValue = signal(null);
+    onValidation = signal(false);
+    outputOnly = signal(false);
+    placeholder = signal('');
+    tooltip = signal('');
+    validateOnServer = signal(false);
+    visibleLabel = signal(true);
+    value; // Valor del componente relacionado con el campo (pueden diferir en formato y tipo)
     field = null;
+    updatePropagatedAttributes() {
+        this.updatePieceAttributes(this.field, signaledAttributes$4);
+    }
     ngOnInit() {
         if (!this.field) {
             return;
         }
+        this.field.widget = this;
         this.formConfig = this.field?._formConfig;
-        const mapping = Object.entries(this.formConfig?.fieldPropagateAttributes);
-        const customAttributesMapping = this.formConfig?.propagationCustomAttributes.fields ?? [];
-        for (let index = 0; index < mapping.length; index++) {
-            const fieldAttr = mapping[index]?.[0];
-            const componentAttr = mapping[index]?.[1]?.toString() ?? '';
-            if (componentAttr) {
-                const value = this.field?.[fieldAttr];
-                this.defaultProcessAttributeChange(componentAttr, value);
-                this.customProcessAttributeChange(componentAttr, value);
+        this.updatePropagatedAttributes();
+        this.replaceCustomAttributes(this.field?.customAttributes);
+        this.field?.attributeChange.subscribe(event => {
+            const { name: attribute, value = null } = event ?? {};
+            const attributeParts = attribute?.split('.') ?? [];
+            if (attribute === VALUE) {
+                this.updateValue();
             }
-        }
-        // Atributos personalizados
-        for (let index = 0; index < customAttributesMapping.length; index++) {
-            const customAttribute = customAttributesMapping[index];
-            if (customAttribute) {
-                const value = this.field?.getCustomAttribute(customAttribute);
-                const fullName = `customAttributes.${customAttribute}`;
-                if (value) {
-                    this.defaultProcessAttributeChange(fullName, value);
-                    this.customProcessAttributeChange(fullName, value);
-                }
+            else if (attribute === FOCUS) {
+                this.focus();
             }
-        }
-        // Subscripción a cambios en atributos
-        this.field?.attributeChange.subscribe(event => {
-            const { name: componentAttr, value = null } = event ?? {};
-            if (componentAttr) {
-                this.defaultProcessAttributeChange(componentAttr, value);
-                this.customProcessAttributeChange(componentAttr, value);
+            else if (signaledAttributes$4.includes(attribute)) {
+                this.updatePieceAttribute(signaledAttributes$4, attribute, value);
+            }
+            else if (attributeParts?.length > 1 && attributeParts?.[0] === CUSTOM_ATTRIBUTES$4) {
+                const subAttribute = attributeParts?.[1] ?? null;
+                this.updateCustomAttribute(subAttribute, value);
             }
         });
-        if (this.field) {
-            this.field.widget = this;
-        }
         this.start();
     }
-    defaultProcessAttributeChange(attribute, value) {
-        if (attribute === VALUE) {
-            this.updateValue();
-        }
-        else if (attribute === FOCUS) {
-            this.focus();
-        }
-        else {
-            return super.defaultProcessAttributeChange(attribute, value);
-        }
-        return true;
+    updateValue() {
+        this.value = this.field?.value;
     }
-    updateValue() { this.value = this.field?.value; }
     onInputChange() { setTimeout(() => this.field?.notifyEditionPartial(), 50); }
     onChangeContent() { setTimeout(() => this.field?.notifyEditionFinish(), 50); }
     onShowInfo(detail = null) { setTimeout(() => this.field?.notifyEditionDetailRequest(detail), 50); }
@@ -204,10 +229,6 @@ class FieldComponent extends ElementComponent {
         this.updateObject(false);
         this.onInputChange();
     }
-    numberInputValidation(event) {
-        const k = event.charCode;
-        return (k > 47 && k < 58);
-    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FieldComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
     static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: FieldComponent, selector: "lib-field", inputs: { field: "field" }, usesInheritance: true, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true });
 }
@@ -263,23 +284,31 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                 type: Output
             }] } });
 
+const CUSTOM_ATTRIBUTES$3 = 'customAttributes';
+const signaledAttributes$3 = [
+    'visible', 'disabled',
+];
 class SectionComponent extends PieceComponent {
     section;
+    updatePropagatedAttributes() {
+        this.updatePieceAttributes(this.section, signaledAttributes$3);
+    }
     ngOnInit() {
+        if (!this.section) {
+            return;
+        }
         this.formConfig = this.section?._formConfig;
-        const mapping = this.formConfig?.sectionPropagateAttributes;
-        for (let index = 0; index < mapping.length; index++) {
-            const attrName = mapping[index].toString();
-            const attributeValue = this.section?.[attrName];
-            this.defaultProcessAttributeChange(attrName, attributeValue);
-            this.customProcessAttributeChange(attrName, attributeValue);
-        }
-        // Subscripción a cambios en atributos
+        this.updatePropagatedAttributes();
+        this.replaceCustomAttributes(this.section?.customAttributes);
         this.section?.attributeChange.subscribe(event => {
-            const { name: attrName, value = null } = event ?? {};
-            if (attrName) {
-                this.defaultProcessAttributeChange(attrName, value);
-                this.customProcessAttributeChange(attrName, value);
+            const { name: attribute, value = null } = event ?? {};
+            const attributeParts = attribute?.split('.') ?? [];
+            if (signaledAttributes$3.includes(attribute)) {
+                this.updatePieceAttribute(signaledAttributes$3, attribute, value);
+            }
+            else if (attributeParts?.length > 1 && attributeParts?.[0] === CUSTOM_ATTRIBUTES$3) {
+                const subAttribute = attributeParts?.[1] ?? null;
+                this.updateCustomAttribute(subAttribute, value);
             }
         });
         this.start();
@@ -300,23 +329,31 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                 type: Input
             }] } });
 
+const CUSTOM_ATTRIBUTES$2 = 'customAttributes';
+const signaledAttributes$2 = [
+    'visible', 'disabled',
+];
 class SubSectionComponent extends PieceComponent {
     subSection;
+    updatePropagatedAttributes() {
+        this.updatePieceAttributes(this.subSection, signaledAttributes$2);
+    }
     ngOnInit() {
+        if (!this.subSection) {
+            return;
+        }
         this.formConfig = this.subSection?._formConfig;
-        const mapping = this.formConfig?.subSectionPropagateAttributes;
-        for (let index = 0; index < mapping.length; index++) {
-            const attrName = mapping[index].toString();
-            const attributeValue = this.subSection?.[attrName];
-            this.defaultProcessAttributeChange(attrName, attributeValue);
-            this.customProcessAttributeChange(attrName, attributeValue);
-        }
-        // Subscripción a cambios en atributos
+        this.updatePropagatedAttributes();
+        this.replaceCustomAttributes(this.subSection?.customAttributes);
         this.subSection?.attributeChange.subscribe(event => {
-            const { name: attrName, value = null } = event ?? {};
-            if (attrName) {
-                this.defaultProcessAttributeChange(attrName, value);
-                this.customProcessAttributeChange(attrName, value);
+            const { name: attribute, value = null } = event ?? {};
+            const attributeParts = attribute?.split('.') ?? [];
+            if (signaledAttributes$2.includes(attribute)) {
+                this.updatePieceAttribute(signaledAttributes$2, attribute, value);
+            }
+            else if (attributeParts?.length > 1 && attributeParts?.[0] === CUSTOM_ATTRIBUTES$2) {
+                const subAttribute = attributeParts?.[1] ?? null;
+                this.updateCustomAttribute(subAttribute, value);
             }
         });
         this.start();
@@ -338,21 +375,25 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
             }] } });
 
 const INLINE_ACTION$1 = 'INLINE';
+const CUSTOM_ATTRIBUTES$1 = 'customAttributes';
+const signaledAttributes$1 = [
+    'visible', 'disabled',
+];
 class LibTableRecordActionComponent extends PieceComponent {
-    isVisible = true;
     recordId;
     recordData;
     action;
     actionSelected = new EventEmitter();
+    updatePropagatedAttributes() {
+        this.updatePieceAttributes(this.action, signaledAttributes$1);
+    }
     ngOnInit() {
-        this.formConfig = this.action?._formConfig;
-        const mapping = this.formConfig?.actionPropagateAttributes;
-        for (let index = 0; index < mapping.length; index++) {
-            const attrName = mapping[index].toString();
-            const attributeValue = this.action?.[attrName];
-            this.defaultProcessAttributeChange(attrName, attributeValue);
-            this.customProcessAttributeChange(attrName, attributeValue);
+        if (!this.action) {
+            return;
         }
+        this.formConfig = this.action?._formConfig;
+        this.updatePropagatedAttributes();
+        this.replaceCustomAttributes(this.action?.customAttributes);
         this.start();
     }
     start() {
@@ -364,10 +405,10 @@ class LibTableRecordActionComponent extends PieceComponent {
                 const restrictionValue = this.action.restrictedOnValue;
                 if ((restrictionOper === '==' && relatedFieldValue !== restrictionValue)
                     || (restrictionOper === '!=' && relatedFieldValue === restrictionValue)) {
-                    this.isVisible = false;
+                    this.visible.set(false);
                 }
                 else {
-                    this.isVisible = true;
+                    this.visible.set(true);
                 }
             }
         }
@@ -430,10 +471,25 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                 type: Input
             }] } });
 
+const CUSTOM_ATTRIBUTES = 'customAttributes';
+const signaledAttributes = [
+    'allSelected', 'code', 'globalSearch', 'globalFilterString', 'recordsPerPage', 'layout',
+    'columns', 'selectedRecords', 'currentPage', 'totalRecordsNumber', 'visibleRecords',
+    'visible', 'disabled',
+];
 class LibTableComponent extends ElementComponent {
     // Atributos sincronizados del objeto
-    code;
-    globalFilterString = '';
+    allSelected = signal(null);
+    code = signal('');
+    globalSearch = signal(null);
+    globalFilterString = signal('');
+    recordsPerPage = signal(null);
+    layout = signal(null);
+    columns = signal(null);
+    selectedRecords = signal(null);
+    currentPage = signal(null);
+    totalRecordsNumber = signal(null);
+    visibleRecords = signal(null);
     tableFieldStyles;
     loaded = false;
     selectable = false;
@@ -442,7 +498,6 @@ class LibTableComponent extends ElementComponent {
     globalActions;
     selectionActions;
     table = null;
-    visibleRecords = [];
     waiting = false;
     ngOnInit() {
         if (!this.table) {
@@ -451,51 +506,42 @@ class LibTableComponent extends ElementComponent {
         this.table.setWidget(this);
         this.formConfig = this.table?._formConfig;
         this.tableFieldStyles = this.formConfig?.tableFieldStyles;
-        this.selectable = this.table?.selectable;
+        this.selectable = this.table?._selectable;
         this.hasActions = this.table?.hasActions();
         this.inlineActions = this.table?.getActions(this.formConfig?.tableActions.inline);
         this.globalActions = this.table?.getActions(this.formConfig?.tableActions.global);
         this.selectionActions = this.table?.getActions(this.formConfig?.tableActions.selection);
-        // Inicialización de campos mapeados del objeto
-        const mapping = Object.entries(this.formConfig?.tablePropagationAttributes);
-        for (let index = 0; index < mapping.length; index++) {
-            const tableAttr = mapping[index]?.[0];
-            const componentAttr = mapping[index]?.[1]?.toString() ?? '';
-            const attributeValue = this.table?.[tableAttr];
-            this.defaultProcessAttributeChange(componentAttr, attributeValue);
-            this.customProcessAttributeChange(componentAttr, attributeValue);
-        }
-        // Subscripción a cambios en atributos
+        this.updatePropagatedAttributes();
+        this.replaceCustomAttributes(this.table?.customAttributes);
         this.table?.attributeChange.subscribe(event => {
-            const { name: attrName, value = null } = event ?? {};
-            if (attrName) {
-                this.defaultProcessAttributeChange(attrName, value);
-                this.customProcessAttributeChange(attrName, value);
+            const { name: attribute, value = null } = event ?? {};
+            const attributeParts = attribute?.split('.') ?? [];
+            if (attribute === 'visibleRecords') {
+                this.updateTableData();
+            }
+            else if (signaledAttributes.includes(attribute)) {
+                this.updatePieceAttribute(signaledAttributes, attribute, value);
+            }
+            else if (attributeParts?.length > 1 && attributeParts?.[0] === CUSTOM_ATTRIBUTES) {
+                const subAttribute = attributeParts?.[1] ?? null;
+                this.updateCustomAttribute(subAttribute, value);
             }
         });
         this.start();
     }
+    updatePropagatedAttributes() {
+        this.updatePieceAttributes(this.table, signaledAttributes);
+    }
     updateTableData() { }
     tableGlobalAction(actionCode) { this.table?.notifyGlobalAction(actionCode); }
     tableSelectionAction(actionCode) { this.table?.notifySelectionAction(actionCode); }
     tableActionSelected(actionEvent) { this.table?.notifyInlineAction(actionEvent); }
     tableSelectionToggle(recordId) { this.table?.notifyRecordSelection(recordId); }
-    toggleSelectAll() { return (this.table?.allSelected) ? this.table?.unSelectAll() : this.table?.selectAll(); }
+    toggleSelectAll() { return (this.table?._allSelected) ? this.table?.unSelectAll() : this.table?.selectAll(); }
     globalFilterCompleted() { this.changePage(1); }
     changePage(requestedPage) { this.table?.changePage(requestedPage); }
     tableColumnSort(columnName, direction = null) { this.table?.sort(columnName, direction ?? 'ascend'); }
     globalFilterChanged() { this.table?.setGlobalFilterString(this.globalFilterString?.trim() ?? '', false); }
-    defaultProcessAttributeChange(attribute, value) {
-        try {
-            if (attribute === 'visibleRecords') {
-                this.updateTableData();
-            }
-            return super.defaultProcessAttributeChange(attribute, value);
-        }
-        catch {
-            return false;
-        }
-    }
     filterHasChanged(column, values) {
         if (!values || values.length === 0) {
             this.table?.removeColumnFilter(column.fieldCode);
@@ -505,7 +551,7 @@ class LibTableComponent extends ElementComponent {
         }
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LibTableComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: LibTableComponent, selector: "lib-table", inputs: { table: "table", visibleRecords: "visibleRecords", waiting: "waiting" }, usesInheritance: true, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: LibTableComponent, selector: "lib-table", inputs: { table: "table", waiting: "waiting" }, usesInheritance: true, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LibTableComponent, decorators: [{
             type: Component,
@@ -516,8 +562,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                 }]
         }], propDecorators: { table: [{
                 type: Input
-            }], visibleRecords: [{
-                type: Input
             }], waiting: [{
                 type: Input
             }] } });
@@ -719,8 +763,13 @@ class FormElement extends FormPiecePropagate {
     }
     setAttr(attr, value) {
         const { name: attrName, propagate: name } = attr;
-        this[attrName] = value;
-        name && this.propagateAttribute(name, value);
+        try {
+            this[attrName] = value;
+            name && this.propagateAttribute(name, value);
+        }
+        catch (e) {
+            console.log(`Atributo ${attrName} no presente o valor ${value} inconsistente. ${e}`);
+        }
     }
     isField() { return this.elementType === elementTypes.field; }
     isAction() { return this.elementType === elementTypes.action; }
@@ -728,60 +777,84 @@ class FormElement extends FormPiecePropagate {
 }
 
 const HEADER = 'HEADER';
+const attrs$2 = {
+    actionCode: { name: '_actionCode', propagate: 'actionCode' },
+    actionName: { name: '_actionName', propagate: 'actionName' },
+    iconName: { name: '_iconName', propagate: 'iconName' },
+    inProgress: { name: '_inProgress', propagate: 'inProgress' },
+    restrictedOnField: { name: '_restrictedOnField', propagate: 'restrictedOnField' },
+    restrictedOnOperator: { name: '_restrictedOnOperator', propagate: 'restrictedOnOperator' },
+    restrictedOnValue: { name: '_restrictedOnValue', propagate: 'restrictedOnValue' },
+};
 class FormAction extends FormElement {
     _actionActivated = new Subject();
-    actionCode;
-    actionName;
-    iconName;
-    inProgress = false;
-    newState;
-    backend;
-    restrictedOnField = null;
-    restrictedOnOperator = null;
-    restrictedOnValue = null;
-    customValidation;
+    _actionCode = '';
+    _actionName = '';
+    _iconName = '';
+    _inProgress = false;
+    _newState;
+    _backend;
+    _restrictedOnField = null;
+    _restrictedOnOperator = null;
+    _restrictedOnValue = null;
     constructor(actionDefinition, formConfig) {
         super(actionDefinition, formConfig);
         this.propagationCustomAttributes = this._formConfig?.propagationCustomAttributes?.actions ?? [];
         this.elementType = elementTypes.action;
-        this.actionCode = actionDefinition.actionCode ? actionDefinition.actionCode.toString() : '';
-        this.actionName = actionDefinition.actionTitle;
-        this.iconName = actionDefinition.iconName || this.actionCode;
+        this.setAttr(attrs$2.actionCode, actionDefinition.actionCode ? actionDefinition.actionCode.toString() : '');
+        this.setAttr(attrs$2.actionName, actionDefinition.actionTitle);
+        this.setAttr(attrs$2.iconName, actionDefinition.iconName || this._actionCode);
+        this.setAttr(attrs$2.restrictedOnField, actionDefinition.fieldRestrictedCode?.toString() ?? null);
+        if (this._restrictedOnField) {
+            this.setAttr(attrs$2.restrictedOnOperator, actionDefinition.operatorRestricted || '');
+            this.setAttr(attrs$2.restrictedOnValue, actionDefinition.valueRestricted ?? '');
+        }
+        this._backend = actionDefinition?.serverAction ?? false;
+        this._newState = actionDefinition?.newState;
         this.setCustomAttribute('location', actionDefinition.position || HEADER);
-        this.backend = actionDefinition?.serverAction ?? false;
-        this.newState = actionDefinition?.newState;
-        this.restrictedOnField = actionDefinition.fieldRestrictedCode?.toString() ?? null;
-        if (this.restrictedOnField) {
-            this.restrictedOnOperator = actionDefinition.operatorRestricted || '';
-            this.restrictedOnValue = actionDefinition.valueRestricted ?? '';
-        }
-        this.customValidation = () => true;
     }
+    get actionCode() { return this._actionCode; }
+    get actionName() { return this._actionName; }
+    get iconName() { return this._iconName; }
+    get inProgress() { return this._inProgress; }
+    get newState() { return this._newState; }
+    get backend() { return this._backend; }
+    get restrictedOnField() { return this._restrictedOnField; }
+    get restrictedOnOperator() { return this._restrictedOnOperator; }
+    get restrictedOnValue() { return this._restrictedOnValue; }
+    set actionCode(actionCode) { this.setAttr(attrs$2.actionCode, actionCode); }
+    set actionName(actionName) { this.setAttr(attrs$2.actionName, actionName); }
+    set iconName(iconName) { this.setAttr(attrs$2.iconName, iconName); }
+    set inProgress(inProgress) { this.setAttr(attrs$2.inProgress, inProgress); }
+    set newState(newState) { this._newState, newState; }
+    set backend(backend) { this._backend, backend; }
+    set restrictedOnField(restrictedOnField) { this.setAttr(attrs$2.restrictedOnField, restrictedOnField); }
+    set restrictedOnOperator(restrictedOnOperator) { this.setAttr(attrs$2.restrictedOnOperator, restrictedOnOperator); }
+    set restrictedOnValue(restrictedOnValue) { this.setAttr(attrs$2.restrictedOnValue, restrictedOnValue); }
+    start() { this.inProgress = true; }
+    stop() { this.inProgress = false; }
     connectWithParentForm(form, formChangeSubject) {
         super.connectWithParentForm(form, formChangeSubject);
-        if (this.restrictedOnField) {
-            const relatedField = this._form.fields?.[this.restrictedOnField];
+        if (this._restrictedOnField) {
+            const relatedField = this._form.fields?.[this._restrictedOnField];
             if (relatedField) {
-                relatedField.editionFinish.subscribe(event => this.updateRestrictedVisibility());
-                relatedField.editionPartial.subscribe(event => this.updateRestrictedVisibility());
+                relatedField.editionFinish.subscribe(event => this.updateRestrictedVisibility(event));
+                relatedField.editionPartial.subscribe(event => this.updateRestrictedVisibility(event));
             }
         }
     }
-    updateRestrictedVisibility() {
-        const lastVisible = this._visible;
+    updateRestrictedVisibility(event) {
         const newVisible = this._absoluteVisible && this.viewOnState(this._formState);
-        if (lastVisible !== newVisible) {
-            this.setVisibility(newVisible);
-        }
+        (this._visible !== newVisible) && this.setVisibility(newVisible);
     }
     viewOnState(state) {
         const actionVisible = (this.visibleStates && state) ? this.visibleStates.includes(state) : false;
-        if (actionVisible && this._form && this.restrictedOnField) {
-            const relatedField = this._form.fields?.[this.restrictedOnField];
+        if (actionVisible && this._form && this._restrictedOnField) {
+            const relatedField = this._form.fields?.[this._restrictedOnField];
             if (relatedField) {
                 const fieldValue = relatedField.value;
-                if ((this.restrictedOnOperator === '==' && fieldValue !== this.restrictedOnValue)
-                    || (this.restrictedOnOperator === '!=' && fieldValue === this.restrictedOnValue)) {
+                if ((this._restrictedOnOperator === '==' && fieldValue !== this._restrictedOnValue)
+                    || (this._restrictedOnOperator === '!=' && fieldValue === this._restrictedOnValue)) {
                     return false;
                 }
             }
@@ -789,17 +862,19 @@ class FormAction extends FormElement {
         return actionVisible;
     }
     get actionActivated() { return this._actionActivated; }
-    start() { this.inProgress = true; }
-    stop() { this.inProgress = false; }
-    notifyActivation() { this._actionActivated.next(this.actionCode); }
+    notifyActivation() { this._actionActivated.next(this._actionCode); }
     updateFromServer(receivedAction) {
         for (const propertyName in receivedAction) {
             if (propertyName !== 'actionCode' && propertyName !== 'actionId') {
-                this[propertyName] = receivedAction[propertyName];
+                try {
+                    this[propertyName] = receivedAction[propertyName];
+                }
+                catch (e) {
+                    console.log(`Error actualizando la propiedad ${propertyName} de la acción ${this.actionCode}. ${e}`);
+                }
             }
         }
     }
-    setCustomValidation(callback) { this.customValidation = () => callback(); }
 }
 
 const UNDEFINED = 'undefined';
@@ -815,34 +890,34 @@ const directChanges = [
     'options', 'placeholder',
 ];
 const attrs$1 = {
-    _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' },
-    _placeholder: { name: '_placeholder', propagate: 'placeholder' },
-    _tooltipText: { name: '_tooltipText', propagate: 'tooltip' },
-    _validateOnServer: { name: '_validateOnServer', propagate: 'validateOnServer' },
-    _value: { name: '_value', propagate: 'value' },
-    _visibleLabel: { name: '_visibleLabel', propagate: 'visibleLabel' },
+    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' },
+    placeholder: { name: '_placeholder', propagate: 'placeholder' },
+    tooltipText: { name: '_tooltipText', propagate: 'tooltip' },
+    validateOnServer: { name: '_validateOnServer', propagate: 'validateOnServer' },
+    value: { name: '_value', propagate: 'value' },
+    visibleLabel: { name: '_visibleLabel', propagate: 'visibleLabel' },
 };
 class FieldDescriptor extends FormElement {
     _editionFinish = new Subject();
@@ -875,15 +950,15 @@ class FieldDescriptor extends FormElement {
     _outputOnly = false;
     _tooltipText = '';
     _placeholder = '';
-    fieldCode = '';
-    fieldOptions = null;
+    _fieldCode = '';
+    _fieldOptions = null;
     constructor(inputFieldReceived, formConfig) {
         super(inputFieldReceived, formConfig);
         this.propagationCustomAttributes = this._formConfig?.propagationCustomAttributes?.fields ?? [];
         this.elementType = elementTypes.field;
         const fld = (inputFieldReceived) ? inputFieldReceived : {};
         this.setAttr(attrs$1.fieldCode, fld.fieldCode);
-        this.title = fld.fieldTitle ?? this.fieldCode;
+        this.title = fld.fieldTitle ?? this._fieldCode;
         this.placeholder = fld.placeholder ?? this.title;
         this.type = fld.fieldTypeCode;
         this.captureType = fld.captureType ?? DEFAULT_CAPTURE_TYPE;
@@ -901,7 +976,12 @@ class FieldDescriptor extends FormElement {
         this.info = fld.info || '';
         let fieldFormat;
         try {
-            fieldFormat = (fld.format) ? new RegExp(fld.format) : null;
+            if (fld.format && typeof fld.format === 'string') {
+                fieldFormat = new RegExp(fld.format);
+            }
+            else if (fld.format?.regExp) {
+                fieldFormat = new RegExp(fld.format?.regExp);
+            }
         }
         catch (e) {
             fieldFormat = null;
@@ -924,17 +1004,17 @@ class FieldDescriptor extends FormElement {
         this._setValue(fld.fieldValue ?? this._defaultValue ?? '');
     }
     get alignment() { return this._fieldAlignment; }
-    set alignment(alignment) { this.setAttr(attrs$1._fieldAlignment, alignment); }
+    set alignment(alignment) { this.setAttr(attrs$1.fieldAlignment, alignment); }
     get backend() { return this._validateOnServer; }
     get captureType() { return this._captureType; }
-    set captureType(captureType) { this.setAttr(attrs$1._captureType, captureType); }
+    set captureType(captureType) { this.setAttr(attrs$1.captureType, captureType); }
     get placeholder() { return this._placeholder; }
-    set placeholder(placeholder) { this.setAttr(attrs$1._placeholder, placeholder); }
-    get code() { return this.fieldCode; }
+    set placeholder(placeholder) { this.setAttr(attrs$1.placeholder, placeholder); }
+    get code() { return this._fieldCode; }
     get defaultValue() { return this._defaultValue; }
-    set defaultValue(defaultValue) { this.setAttr(attrs$1._defaultValue, defaultValue); }
+    set defaultValue(defaultValue) { this.setAttr(attrs$1.defaultValue, defaultValue); }
     get defaultEditable() { return this._defaultEditable; }
-    set defaultEditable(editable) { this.setAttr(attrs$1._defaultEditable, editable); }
+    set defaultEditable(editable) { this.setAttr(attrs$1.defaultEditable, editable); }
     get detailRequest() { return this._detailRequest; }
     get editionFinish() { return this._editionFinish; }
     get editionPartial() { return this._editionPartial; }
@@ -979,25 +1059,25 @@ class FieldDescriptor extends FormElement {
     get errorType() { return this._errorType; }
     get externalValue() { return this._externalValue; }
     get format() { return this._fieldFormat; }
-    set format(format) { this.setAttr(attrs$1._fieldFormat, format); }
+    set format(format) { this.setAttr(attrs$1.fieldFormat, format); }
     get hasChanged() { return this._hasChanged; }
-    set hasChanged(hasChanged) { this.setAttr(attrs$1._hasChanged, hasChanged); }
+    set hasChanged(hasChanged) { this.setAttr(attrs$1.hasChanged, hasChanged); }
     get info() { return this._fieldInfo; }
-    set info(newInfo) { this.setAttr(attrs$1._fieldInfo, newInfo); }
-    set intrinsicErrorMessage(message) { this.setAttr(attrs$1._intrinsicErrorMessage, message); }
+    set info(newInfo) { this.setAttr(attrs$1.fieldInfo, newInfo); }
+    set intrinsicErrorMessage(message) { this.setAttr(attrs$1.intrinsicErrorMessage, message); }
     get maxLength() { return (this._maxLength > 0) ? this._maxLength.toString() : ''; }
-    set maxLength(requiredMaxLength) { this.setAttr(attrs$1._maxLength, requiredMaxLength ? +requiredMaxLength : null); }
+    set maxLength(requiredMaxLength) { this.setAttr(attrs$1.maxLength, requiredMaxLength ? +requiredMaxLength : null); }
     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$1._maxValue, maxValue);
+        this.setAttr(attrs$1.maxValue, maxValue);
     }
     get minLength() { return this._minLength; }
     set minLength(requiredMinLength) {
-        this.setAttr(attrs$1._minLength, requiredMinLength ? +requiredMinLength : null);
+        this.setAttr(attrs$1.minLength, requiredMinLength ? +requiredMinLength : null);
     }
     get minValue() { return this._minValue; }
     set minValue(inputMinValue) {
@@ -1005,11 +1085,11 @@ class FieldDescriptor extends FormElement {
         if (this._fieldType === this._formConfig.fieldTypes.date) {
             minValue = new Date(minValue);
         }
-        this.setAttr(attrs$1._minValue, minValue);
+        this.setAttr(attrs$1.minValue, minValue);
     }
-    get name() { return this.fieldCode; }
+    get name() { return this._fieldCode; }
     get options() {
-        return this.fieldOptions?.map(option => {
+        return this._fieldOptions?.map(option => {
             const optionCopy = { ...option };
             return optionCopy;
         }) ?? null;
@@ -1032,45 +1112,46 @@ class FieldDescriptor extends FormElement {
         this.setAttr(attrs$1.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$1._value, fieldValue);
+                const fieldValue = this._value?.filter(item => this._fieldOptions?.find(opt => opt.fieldOptionId === item));
+                this.setAttr(attrs$1.value, fieldValue);
             }
             else {
-                const valInOptions = this.fieldOptions?.find(item => item.fieldOptionId === this._value);
+                const valInOptions = this._fieldOptions?.find(item => item.fieldOptionId === this._value);
                 if (!valInOptions) {
                     this._setValue('');
                 }
             }
         }
-        if (this._fieldRequired && this.fieldOptions?.length === 1 && this._value !== this.fieldOptions?.[0].fieldOptionId) {
-            this._setValue(this.fieldOptions?.[0].fieldOptionId);
+        if (this._fieldRequired && this._fieldOptions?.length === 1 && this._value !== this._fieldOptions?.[0].fieldOptionId) {
+            this._setValue(this._fieldOptions?.[0].fieldOptionId);
             this.notifyEditionFinish();
         }
     }
-    get optionText() { return this.fieldOptions?.find(item => item.fieldOptionId === this._value)?.fieldOptionValue ?? null; }
+    get optionText() { return this._fieldOptions?.find(item => item.fieldOptionId === this._value)?.fieldOptionValue ?? null; }
     get outputOnly() { return this._outputOnly; }
-    set outputOnly(outputOnly) { this.setAttr(attrs$1._outputOnly, outputOnly); }
+    set outputOnly(outputOnly) { this.setAttr(attrs$1.outputOnly, outputOnly); }
     get required() { return this._fieldRequired; }
-    set required(required) { this.setAttr(attrs$1._fieldRequired, required ?? false); }
+    set required(required) { this.setAttr(attrs$1.fieldRequired, required ?? false); }
     get title() { return this._fieldTitle; }
-    set title(title) { this.setAttr(attrs$1._fieldTitle, title?.toString() ?? ''); }
+    set title(title) { this.setAttr(attrs$1.fieldTitle, title?.toString() ?? ''); }
     get tooltip() { return this._tooltipText; }
-    set tooltip(tooltip) { this.setAttr(attrs$1._tooltipText, tooltip); }
+    set tooltip(tooltip) { this.setAttr(attrs$1.tooltipText, tooltip); }
     get type() { return this._fieldType; }
-    set type(fieldType) { this.setAttr(attrs$1._fieldType, fieldType); }
+    set type(fieldType) { this.setAttr(attrs$1.fieldType, fieldType); }
+    get onValidation() { return this._onValidation; }
     get validating() { return this._onValidation; }
-    set validating(isValidating) { this.setAttr(attrs$1._onValidation, isValidating); }
+    set validating(isValidating) { this.setAttr(attrs$1.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$1._validateOnServer, validateOnServer); }
+    set validateOnServer(validateOnServer) { this.setAttr(attrs$1.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$1._visibleLabel, visibleLabel); }
+    set visibleLabel(visibleLabel) { this.setAttr(attrs$1.visibleLabel, visibleLabel); }
     /**
      * @deprecated Use value
      */
@@ -1080,7 +1161,7 @@ class FieldDescriptor extends FormElement {
      */
     changed(hasChanged = true) { this.hasChanged = hasChanged; }
     clean() { this._setValue(this._defaultValue || ''); this.resetError(); }
-    focus() { this.setAttr(attrs$1._focus, true); }
+    focus() { this.setAttr(attrs$1.focus, true); }
     getErrorCode() { return this.error.code; }
     setErrorCode(code) { this.setError(code, this._errorMessage); }
     getErrorMessage() { return this.error.message; }
@@ -1092,6 +1173,10 @@ class FieldDescriptor extends FormElement {
     setEditable(editable = true) { (editable) ? this.enable() : this.disable(); }
     setValue(newValue, widgetUpdate = true) { this._setValue(newValue, widgetUpdate); }
     showLabel() { this.visibleLabel = true; }
+    /**
+     * @deprecated Use code
+     */
+    get fieldCode() { return this._fieldCode; }
     /**
      * @deprecated Use title
      */
@@ -1146,7 +1231,7 @@ class FieldDescriptor extends FormElement {
     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.value;
@@ -1182,16 +1267,16 @@ class FieldDescriptor extends FormElement {
             intrinsicValidation = false;
             this.setError('99', `Longitud de ${this._fieldTitle} debe ser de al menos ${this._minLength}`);
         }
-        this._editionFinish.next({ code: this.fieldCode, intrinsicValidation });
+        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);
     }
     setError(code, message, type = DEFAULT_ERROR_TYPE) {
-        this.setAttr(attrs$1._errorCode, code ?? NO_ERROR);
-        this.setAttr(attrs$1._errorType, (this._errorCode === NO_ERROR) ? '' : type);
-        this.setAttr(attrs$1._errorMessage, message ?? '');
+        this.setAttr(attrs$1.errorCode, code ?? NO_ERROR);
+        this.setAttr(attrs$1.errorType, (this._errorCode === NO_ERROR) ? '' : type);
+        this.setAttr(attrs$1.errorMessage, message ?? '');
     }
     updateFromServer(fld) {
         const fieldKeys = Object.keys(fld);
@@ -1246,7 +1331,7 @@ class FieldDescriptor extends FormElement {
         if (this._value !== newFinalValue) {
             this.hasChanged = true;
             if (widgetUpdate) {
-                this.setAttr(attrs$1._value, newFinalValue);
+                this.setAttr(attrs$1.value, newFinalValue);
             }
             else {
                 this._value = newFinalValue;
@@ -1514,47 +1599,47 @@ class RecordTable extends FormElement {
     selectedRecords;
     restrictedId;
     layout = null;
-    globalSearch;
-    tableRecords;
-    tableRecordObj = {};
-    visibleRecords = null;
-    columns;
-    selectable;
-    selectionBackend;
-    selectionField;
-    allSelected = false;
-    tableCode = '';
-    tableTitle;
-    currentPage;
-    totalPages;
-    requestedPage;
-    recordsPerPage = 10;
-    totalRecordsNumber = 0;
-    recordsNumber = 0;
-    sorting;
-    waiting;
-    clientPaging = true;
-    sortable;
+    _globalSearch;
+    _tableRecords;
+    _tableRecordObj = {};
+    _visibleRecords = null;
+    _columns;
+    _selectable;
+    _selectionBackend;
+    _selectionField;
+    _allSelected = false;
+    _tableCode = '';
+    _tableTitle;
+    _currentPage;
+    _totalPages;
+    _requestedPage;
+    _recordsPerPage = 10;
+    _totalRecordsNumber = 0;
+    _recordsNumber = 0;
+    _sorting;
+    _waiting;
+    _clientPaging = true;
+    _sortable;
     constructor(tableReceived, formConfig) {
         super(tableReceived, formConfig);
         this.propagationCustomAttributes = this._formConfig?.propagationCustomAttributes?.tables ?? [];
         this.elementType = elementTypes.table;
-        this.waiting = false;
-        this.currentPage = 1;
-        this.totalPages = 1;
-        this.requestedPage = 1;
-        this.columns = [];
+        this._waiting = false;
+        this._currentPage = 1;
+        this._totalPages = 1;
+        this._requestedPage = 1;
+        this._columns = [];
         this._tableColumnObj = {};
         this._actions = [];
         this._actionsObj = {};
-        this.tableRecords = [];
-        this.globalSearch = false;
+        this._tableRecords = [];
+        this._globalSearch = false;
         this.restrictedId = null;
-        this.tableTitle = tableReceived.tableTitle;
+        this._tableTitle = tableReceived.tableTitle;
         this._appendPages = tableReceived?.append ?? false;
-        this.selectable = tableReceived?.selectable ?? false;
-        this.selectionBackend = tableReceived?.selectionBackend ?? false;
-        this.sortable = tableReceived?.sortable ?? false;
+        this._selectable = tableReceived?.selectable ?? false;
+        this._selectionBackend = tableReceived?.selectionBackend ?? false;
+        this._sortable = tableReceived?.sortable ?? false;
         this.setAttr(attrs.allSelected, false);
         this.setAttr(attrs.tableCode, tableReceived.tableCode);
         this.setAttr(attrs.clientPaging, tableReceived?.clientPaging ?? true);
@@ -1597,7 +1682,7 @@ class RecordTable extends FormElement {
                 this._actionsObj[inlineAction.actionCode] = inlineAction;
             }
         }
-        this.selectionField = (this.selectable) ? tableReceived?.selectionField : null;
+        this._selectionField = (this._selectable) ? tableReceived?.selectionField : null;
         // Filtros predefinidos en el formulario
         if (tableReceived.filters) {
             for (let index = 0; index < tableReceived.filters.length; index++) {
@@ -1611,19 +1696,61 @@ class RecordTable extends FormElement {
     get selectionActionTrigger() { return this._selectionActionTrigger; }
     get recordSelectionTrigger() { return this._recordSelectionTrigger; }
     get getDataTrigger() { return this._getDataTrigger; }
+    get globalSearch() { return this._globalSearch; }
+    get tableRecords() { return this._tableRecords; }
+    get tableRecordObj() { return this._tableRecordObj; }
+    get visibleRecords() { return this._visibleRecords; }
+    get columns() { return this._columns; }
+    get selectable() { return this._selectable; }
+    get selectionBackend() { return this._selectionBackend; }
+    get selectionField() { return this._selectionField; }
+    get allSelected() { return this._allSelected; }
+    get tableCode() { return this._tableCode; }
+    get tableTitle() { return this._tableTitle; }
+    get currentPage() { return this._currentPage; }
+    get totalPages() { return this._totalPages; }
+    get requestedPage() { return this._requestedPage; }
+    get recordsPerPage() { return this._recordsPerPage; }
+    get totalRecordsNumber() { return this._totalRecordsNumber; }
+    get recordsNumber() { return this._recordsNumber; }
+    get sorting() { return this._sorting; }
+    get waiting() { return this._waiting; }
+    get clientPaging() { return this._clientPaging; }
+    get sortable() { return this._sortable; }
+    set globalSearch(globalSearch) { this._globalSearch = globalSearch; }
+    set tableRecords(tableRecords) { this._tableRecords = tableRecords; }
+    set tableRecordObj(tableRecordObj) { this._tableRecordObj = tableRecordObj; }
+    set visibleRecords(visibleRecords) { this._visibleRecords = visibleRecords; }
+    set columns(columns) { this._columns = columns; }
+    set selectable(selectable) { this._selectable = selectable; }
+    set selectionBackend(selectionBackend) { this._selectionBackend = selectionBackend; }
+    set selectionField(selectionField) { this._selectionField = selectionField; }
+    set allSelected(allSelected) { this._allSelected = allSelected; }
+    set tableCode(tableCode) { this._tableCode = tableCode; }
+    set tableTitle(tableTitle) { this._tableTitle = tableTitle; }
+    set currentPage(currentPage) { this._currentPage = currentPage; }
+    set totalPages(totalPages) { this._totalPages = totalPages; }
+    set requestedPage(requestedPage) { this._requestedPage = requestedPage; }
+    set recordsPerPage(recordsPerPage) { this._recordsPerPage = recordsPerPage; }
+    set totalRecordsNumber(totalRecordsNumber) { this._totalRecordsNumber = totalRecordsNumber; }
+    set recordsNumber(recordsNumber) { this._recordsNumber = recordsNumber; }
+    set sorting(sorting) { this._sorting = sorting; }
+    set waiting(waiting) { this._waiting = waiting; }
+    set clientPaging(clientPaging) { this._clientPaging = clientPaging; }
+    set sortable(sortable) { this._sortable = sortable; }
     getLayout() { return this.layout; }
     setLayout(layout) { this.setAttr(attrs.layout, layout); }
     hasActions() { return (this._actions.length > 0); }
-    getSelectedRecords() { return this.tableRecords.filter(rec => rec.selected).map(rec => rec.recordId); }
-    activateGlobalSearch() { this.globalSearch = true; }
-    inactivateGlobalSearch() { this.globalSearch = false; }
+    getSelectedRecords() { return this._tableRecords.filter(rec => rec.selected).map(rec => rec.recordId); }
+    activateGlobalSearch() { this._globalSearch = true; }
+    inactivateGlobalSearch() { this._globalSearch = false; }
     columnDefinition(fieldCode) { return this._tableColumnObj[fieldCode]; }
-    putOnWait() { this.waiting = true; }
-    freeWaiting() { this.waiting = false; }
+    putOnWait() { this._waiting = true; }
+    freeWaiting() { this._waiting = false; }
     setWidget(widget) { this.widget = widget; }
     notifyGlobalAction(actionCode) {
         const tableEvent = {
-            tableCode: this.tableCode,
+            tableCode: this._tableCode,
             actionCode,
             actionDetail: null
         };
@@ -1631,7 +1758,7 @@ class RecordTable extends FormElement {
     }
     notifyInlineAction(tableActionEvent) {
         const tableEvent = {
-            tableCode: this.tableCode,
+            tableCode: this._tableCode,
             actionCode: tableActionEvent.actionCode,
             actionDetail: {
                 recordId: tableActionEvent.recordId,
@@ -1646,9 +1773,9 @@ class RecordTable extends FormElement {
             return;
         }
         record.toggleSelect();
-        this.requestedPage = this.currentPage ?? 1;
+        this._requestedPage = this._currentPage ?? 1;
         const tableEvent = {
-            tableCode: this.tableCode,
+            tableCode: this._tableCode,
             actionCode: null,
             actionDetail: {
                 recordId: record.recordId,
@@ -1659,7 +1786,7 @@ class RecordTable extends FormElement {
     }
     notifySelectionAction(actionCode) {
         const tableEvent = {
-            tableCode: this.tableCode,
+            tableCode: this._tableCode,
             actionCode,
             actionDetail: {
                 selectedRecords: this.selectedRecords
@@ -1669,9 +1796,9 @@ class RecordTable extends FormElement {
     }
     notifyGetDataAction(requestedPage = null) {
         this.updateVisibleRecords();
-        this.requestedPage = requestedPage || this.currentPage || 1;
+        this._requestedPage = requestedPage || this._currentPage || 1;
         const tableEvent = {
-            tableCode: this.tableCode,
+            tableCode: this._tableCode,
             actionCode: null,
             actionDetail: null,
         };
@@ -1679,49 +1806,49 @@ class RecordTable extends FormElement {
         return null;
     }
     clean() {
-        this.tableRecords = [];
+        this._tableRecords = [];
         this.unSelectAll();
-        this.tableRecordObj = {};
+        this._tableRecordObj = {};
         this.updateVisibleRecords();
     }
     selectAll() {
         this.setAttr(attrs.allSelected, true);
-        this.tableRecords.forEach(record => record.select());
+        this._tableRecords.forEach(record => record.select());
         this.setAttr(attrs.selectedRecords, this.getSelectedRecords());
         return true;
     }
     unSelectAll() {
         this.setAttr(attrs.allSelected, false);
-        this.tableRecords.forEach(record => record.unselect());
+        this._tableRecords.forEach(record => record.unselect());
         this.setAttr(attrs.selectedRecords, this.getSelectedRecords());
         return true;
     }
     setTableRecords(tableRecords, append) {
         if (!append) {
-            this.tableRecords = [];
+            this._tableRecords = [];
             this.setAttr(attrs.allSelected, false);
-            this.tableRecords.forEach(record => record.unselect());
+            this._tableRecords.forEach(record => record.unselect());
             this.setAttr(attrs.selectedRecords, []);
-            this.tableRecordObj = {};
+            this._tableRecordObj = {};
         }
-        const newRecordsObj = { ...this.tableRecordObj };
-        const newRecords = [...this.tableRecords];
+        const newRecordsObj = { ...this._tableRecordObj };
+        const newRecords = [...this._tableRecords];
         for (const tableRecord of tableRecords) {
-            const recordReceived = new TableRecordData(tableRecord, this.columns, this.selectionField);
+            const recordReceived = new TableRecordData(tableRecord, this._columns, this._selectionField);
             const recordIdKey = recordReceived.recordIdKey;
             newRecords.push(recordReceived);
             newRecordsObj[recordIdKey] = recordReceived;
         }
-        this.tableRecords = newRecords;
+        this._tableRecords = newRecords;
         this.setAttr(attrs.selectedRecords, this.getSelectedRecords());
-        this.tableRecordObj = newRecordsObj;
+        this._tableRecordObj = newRecordsObj;
         this.updateVisibleRecords();
     }
     appendRecords(records) { this.setTableRecords(records, true); }
     replaceRecords(records) { this.setTableRecords(records, false); }
     setTableAppend(append) { this._appendPages = append; }
     changePage(requestedPage) {
-        if (this.clientPaging) {
+        if (this._clientPaging) {
             this.setAttr(attrs.currentPage, requestedPage);
             this.updateVisibleRecords();
         }
@@ -1731,25 +1858,25 @@ class RecordTable extends FormElement {
     }
     updateVisibleRecords() {
         let visibleRecords;
-        if (this.clientPaging) {
+        if (this._clientPaging) {
             let filteredRecords = this.getFilteredRecords();
             this.setAttr(attrs.totalRecordsNumber, filteredRecords.length);
-            const sliceNumber1 = (this.currentPage - 1) * this.recordsPerPage;
-            const sliceNumber2 = (this.currentPage - 1) * this.recordsPerPage + this.recordsPerPage;
+            const sliceNumber1 = (this._currentPage - 1) * this._recordsPerPage;
+            const sliceNumber2 = (this._currentPage - 1) * this._recordsPerPage + this._recordsPerPage;
             visibleRecords = filteredRecords.slice(sliceNumber1, sliceNumber2);
-            const recordsLastPage = this.totalRecordsNumber % this.recordsPerPage;
-            const totalPages = Math.trunc(this.totalRecordsNumber / this.recordsPerPage + (recordsLastPage ? 1 : 0));
-            if (this.currentPage > totalPages) {
-                this.currentPage = totalPages || 1;
+            const recordsLastPage = this._totalRecordsNumber % this._recordsPerPage;
+            const totalPages = Math.trunc(this._totalRecordsNumber / this._recordsPerPage + (recordsLastPage ? 1 : 0));
+            if (this._currentPage > totalPages) {
+                this._currentPage = totalPages || 1;
             }
         }
         else {
-            visibleRecords = this.tableRecords;
+            visibleRecords = this._tableRecords;
         }
         this.setAttr(attrs.visibleRecords, visibleRecords);
     }
     updateFromServer(tableReceived) {
-        this.requestedPage = 1;
+        this._requestedPage = 1;
         const { visible = true, totalPages = 1, recordsNumber, currentPage = 1, recordsPerPage, totalRecordsNumber, sortingColumn, sortingDirection, tableRecords, actions, fields, } = tableReceived;
         this.visible = visible;
         if (actions) {
@@ -1797,11 +1924,11 @@ class RecordTable extends FormElement {
             });
         }
         if (tableRecords) {
-            this.totalPages = totalPages;
-            this.recordsNumber = recordsNumber;
+            this._totalPages = totalPages;
+            this._recordsNumber = recordsNumber;
             this.setAttr(attrs.currentPage, +currentPage);
             this.setAttr(attrs.recordsPerPage, +recordsPerPage);
-            this.setAttr(attrs.totalRecordsNumber, (this.clientPaging) ? tableRecords.length : +totalRecordsNumber);
+            this.setAttr(attrs.totalRecordsNumber, (this._clientPaging) ? tableRecords.length : +totalRecordsNumber);
             this.setAttr(attrs.sorting, {
                 columnName: sortingColumn || '',
                 direction: sortingDirection || ''
@@ -1813,13 +1940,13 @@ class RecordTable extends FormElement {
                 this.appendRecords(tableRecords);
             }
         }
-        this.waiting = false;
+        this._waiting = false;
         this.updateVisibleRecords();
     }
     getTableRecord(recordId) {
         const recordIdKey = (typeof recordId === 'object') ? JSON.stringify(recordId) : recordId;
-        return (this.tableRecordObj && recordId && this.tableRecordObj[recordId])
-            ? this.tableRecordObj[recordId] : null;
+        return (this._tableRecordObj && recordId && this._tableRecordObj[recordId])
+            ? this._tableRecordObj[recordId] : null;
     }
     getAction(actionCode) {
         return (this._actionsObj && actionCode && this._actionsObj[actionCode])
@@ -1848,7 +1975,7 @@ class RecordTable extends FormElement {
     }
     setGlobalFilterString(text, notifyComponent = true) {
         this.globalFilterStrings = text.split(' ').filter(t => t && t.trim().length > 0).map(t => t.trim()) ?? [];
-        if (this.clientPaging) {
+        if (this._clientPaging) {
             this.changePage(1);
         }
         if (notifyComponent) {
@@ -1860,14 +1987,14 @@ class RecordTable extends FormElement {
         tableColumn && tableColumn.addFilterDefinition(filterDefinition);
     }
     getFilteredRecords() {
-        let filteredRecords = this.tableRecords;
+        let filteredRecords = this._tableRecords;
         if (this.restrictedId) {
             filteredRecords = filteredRecords.filter(record => record.recordId === this.restrictedId);
         }
         if (this.globalFilterStrings.length > 0) {
             filteredRecords = filteredRecords.filter(record => record.hasPattern(this.globalFilterStrings, this._tableColumnObj));
         }
-        const columnFilters = this.columns.filter(column => column.filter).map(column => column.filter);
+        const columnFilters = this._columns.filter(column => column.filter).map(column => column.filter);
         if (columnFilters.length > 0) {
             filteredRecords = filteredRecords.filter(record => record.hasCondition(columnFilters));
         }
@@ -1896,7 +2023,7 @@ class RecordTable extends FormElement {
             simpleFilterWords: this.globalFilterStrings,
             advancedFilter: [],
         };
-        const columnFilters = this.columns.filter(column => column.filter).map(column => column.filter);
+        const columnFilters = this._columns.filter(column => column.filter).map(column => column.filter);
         for (let index = 0; index < columnFilters.length; index++) {
             const columnFilter = columnFilters[index];
             compactFilter.advancedFilter.push({
@@ -1911,7 +2038,7 @@ class RecordTable extends FormElement {
     // Ordenamiento de registros local
     sort(columnName, direction) {
         this.setRequiredOrder(columnName, direction);
-        if (this.clientPaging) {
+        if (this._clientPaging) {
             this.localSortData();
         }
         else {
@@ -1925,10 +2052,10 @@ class RecordTable extends FormElement {
         });
     }
     localSortData() {
-        if (!this.sorting.columnName || !this.sorting.direction) {
+        if (!this._sorting.columnName || !this._sorting.direction) {
             return;
         }
-        this.tableRecords.sort((a, b) => this.recordCompare(a, b, this.sorting.columnName, this.sorting.direction));
+        this._tableRecords.sort((a, b) => this.recordCompare(a, b, this._sorting.columnName, this._sorting.direction));
         //this.unSelectAll();
         this.updateVisibleRecords();
     }
@@ -1947,7 +2074,7 @@ class RecordTable extends FormElement {
         return direction === TABLE_SORT_ASCENDING ? result : -result;
     }
     formStateChangeCustomSubscribe(form, formChangeSubject) {
-        this.columns?.forEach(column => {
+        this._columns?.forEach(column => {
             column?.connectWithParentForm(form, formChangeSubject);
         });
         this._actions?.forEach(action => {
@@ -1958,24 +2085,24 @@ class RecordTable extends FormElement {
 
 class RecordFormSubSection extends FormPiecePropagate {
     _customRender = null;
-    subsectionId = null;
-    subsectionCode = null;
-    subsectionTitle = null;
-    subSectionElements = [];
-    subSectionFields = [];
-    subSectionTables = [];
-    subSectionActions = [];
-    elementsArray = {};
-    active = false;
+    _subsectionId = null;
+    _subsectionCode = null;
+    _subsectionTitle = null;
+    _subSectionElements = [];
+    _subSectionFields = [];
+    _subSectionTables = [];
+    _subSectionActions = [];
+    _elementsArray = {};
+    _active = false;
     constructor(subsectionReceived, formObject, formConfig) {
         super(subsectionReceived, formConfig);
         this.propagationCustomAttributes = this._formConfig?.propagationCustomAttributes?.subsections ?? [];
         if (!subsectionReceived) {
             return;
         }
-        this.subsectionId = (subsectionReceived.subsectionId) ? subsectionReceived.subsectionId.toString() : '';
-        this.subsectionCode = (subsectionReceived.subsectionCode) ? subsectionReceived.subsectionCode : '';
-        this.subsectionTitle = (subsectionReceived.subsectionTitle) ? subsectionReceived.subsectionTitle : '';
+        this._subsectionId = (subsectionReceived.subsectionId) ? subsectionReceived.subsectionId.toString() : '';
+        this._subsectionCode = (subsectionReceived.subsectionCode) ? subsectionReceived.subsectionCode : '';
+        this._subsectionTitle = (subsectionReceived.subsectionTitle) ? subsectionReceived.subsectionTitle : '';
         if (subsectionReceived.elements) {
             for (const receivedElement of subsectionReceived.elements) {
                 let elementObject = null;
@@ -1984,52 +2111,70 @@ class RecordFormSubSection extends FormPiecePropagate {
                 switch (type) {
                     case elementTypes.field:
                         elementObject = formObject.getField(code);
-                        arrayToAdd = this.subSectionFields;
+                        arrayToAdd = this._subSectionFields;
                         break;
                     case elementTypes.table:
                         elementObject = formObject.getTable(code);
-                        arrayToAdd = this.subSectionTables;
+                        arrayToAdd = this._subSectionTables;
                         break;
                     case elementTypes.action:
                         elementObject = formObject.getAction(code);
-                        arrayToAdd = this.subSectionActions;
+                        arrayToAdd = this._subSectionActions;
                         break;
                 }
                 if (elementObject) {
                     elementObject.elementType = type;
                     arrayToAdd.push(elementObject);
-                    this.subSectionElements.push(elementObject);
-                    this.elementsArray[code] = elementObject;
+                    this._subSectionElements.push(elementObject);
+                    this._elementsArray[code] = elementObject;
                 }
             }
         }
     }
     get customRender() { return this._customRender; }
     set customRender(customRenderName) { this._customRender = customRenderName; }
+    get subsectionId() { return this._subsectionId; }
+    get subsectionCode() { return this._subsectionCode; }
+    get subsectionTitle() { return this._subsectionTitle; }
+    get subSectionElements() { return this._subSectionElements; }
+    get subSectionFields() { return this._subSectionFields; }
+    get subSectionTables() { return this._subSectionTables; }
+    get subSectionActions() { return this._subSectionActions; }
+    get elementsArray() { return this._elementsArray; }
+    get active() { return this._active; }
+    set subsectionId(subsectionId) { this._subsectionId = subsectionId; }
+    set subsectionCode(subsectionCode) { this._subsectionCode = subsectionCode; }
+    set subsectionTitle(subsectionTitle) { this._subsectionTitle = subsectionTitle; }
+    set subSectionElements(subSectionElements) { this._subSectionElements = subSectionElements; }
+    set subSectionFields(subSectionFields) { this._subSectionFields = subSectionFields; }
+    set subSectionTables(subSectionTables) { this._subSectionTables = subSectionTables; }
+    set subSectionActions(subSectionActions) { this._subSectionActions = subSectionActions; }
+    set elementsArray(elementsArray) { this._elementsArray = elementsArray; }
+    set active(active) { this._active = active; }
     getField(name) {
-        return this.subSectionFields.find(fld => fld.name === name);
+        return this._subSectionFields.find(fld => fld.name === name);
     }
     getFields() {
-        return this.subSectionFields;
+        return this._subSectionFields;
     }
     getFieldNames() {
-        return this.subSectionFields.map(field => field.code);
+        return this._subSectionFields.map(field => field.code);
     }
     getActions() {
-        return this.subSectionActions;
+        return this._subSectionActions;
     }
     getActionNames() {
-        return this.subSectionActions.map(action => action.actionCode);
+        return this._subSectionActions.map(action => action.actionCode);
     }
     activate() {
-        if (!this.active) {
-            this.active = true;
+        if (!this._active) {
+            this._active = true;
             // this.subsectionCode && this._activation.next(this.subsectionCode);
         }
     }
     inactivate() {
-        if (this.active) {
-            this.active = false;
+        if (this._active) {
+            this._active = false;
             // this.subsectionCode && this._inactivation.next(this.subsectionCode);
         }
     }
@@ -2039,12 +2184,12 @@ const ACTIVE$1 = 'active';
 class RecordFormSection extends FormPiecePropagate {
     _activation = new Subject();
     _inactivation = new Subject();
-    active = false;
-    sectionId = null;
-    sectionCode = null;
-    sectionTitle = null;
-    subSections = [];
-    subSectionsObj;
+    _active = false;
+    _sectionId = null;
+    _sectionCode = null;
+    _sectionTitle = null;
+    _subSections = [];
+    _subSectionsObj;
     _exclusiveSubSectionsByAttr = {};
     constructor(sectionReceived, formObject, formConfig) {
         super(sectionReceived, formConfig);
@@ -2052,11 +2197,11 @@ class RecordFormSection extends FormPiecePropagate {
         if (!sectionReceived) {
             return;
         }
-        this.sectionId = (sectionReceived.sectionId) ? sectionReceived.sectionId.toString() : '';
-        this.sectionCode = (sectionReceived.sectionCode) ? sectionReceived.sectionCode : '';
-        this.sectionTitle = (sectionReceived.sectionTitle) ? sectionReceived.sectionTitle : '';
-        this.subSections = [];
-        this.subSectionsObj = {};
+        this._sectionId = (sectionReceived.sectionId) ? sectionReceived.sectionId.toString() : '';
+        this._sectionCode = (sectionReceived.sectionCode) ? sectionReceived.sectionCode : '';
+        this._sectionTitle = (sectionReceived.sectionTitle) ? sectionReceived.sectionTitle : '';
+        this._subSections = [];
+        this._subSectionsObj = {};
         if (sectionReceived.subsections) {
             const subsections = sectionReceived.subsections.map(subSecDef => {
                 const visibleStates = subSecDef.visibleStates ?? [];
@@ -2069,42 +2214,54 @@ class RecordFormSection extends FormPiecePropagate {
                 const subSectionToAdd = new RecordFormSubSection(subsectionReceived, formObject, formConfig);
                 const subsectionCode = subSectionToAdd.subsectionCode;
                 if (subsectionCode) {
-                    this.subSections.push(subSectionToAdd);
-                    this.subSectionsObj[subsectionCode] = subSectionToAdd;
+                    this._subSections.push(subSectionToAdd);
+                    this._subSectionsObj[subsectionCode] = subSectionToAdd;
                 }
             }
         }
     }
-    get code() { return this.sectionCode; }
+    get code() { return this._sectionCode; }
     get activation() { return this._activation; }
     get inactivation() { return this._inactivation; }
+    get active() { return this._active; }
+    get sectionId() { return this._sectionId; }
+    get sectionCode() { return this._sectionCode; }
+    get sectionTitle() { return this._sectionTitle; }
+    get subSections() { return this._subSections; }
+    get subSectionsObj() { return this._subSectionsObj; }
+    set active(active) { this._active = active; }
+    set sectionId(sectionId) { this._sectionId = sectionId; }
+    set sectionCode(sectionCode) { this._sectionCode = sectionCode; }
+    set sectionTitle(sectionTitle) { this._sectionTitle = sectionTitle; }
+    set subSections(subSections) { this._subSections = subSections; }
+    set subSectionsObj(subSectionsObj) { this._subSectionsObj = subSectionsObj; }
     activate() {
-        if (!this.active) {
-            this.active = true;
-            this.sectionCode && this._activation.next(this.sectionCode);
+        if (!this._active) {
+            this._active = true;
+            this._sectionCode && this._activation.next(this._sectionCode);
         }
     }
     inactivate() {
-        if (this.active) {
-            this.active = false;
-            this.sectionCode && this._inactivation.next(this.sectionCode);
+        if (this._active) {
+            this._active = false;
+            this._sectionCode && this._inactivation.next(this._sectionCode);
         }
     }
-    get title() { return this.sectionTitle; }
-    set title(title) { this.sectionTitle = title; }
+    get title() { return this._sectionTitle; }
+    set title(title) { this._sectionTitle = title; }
     getVisibleSubsections(state) {
-        return this.subSections.filter(subSection => subSection.visible);
+        return this._subSections.filter(subSection => subSection.visible);
     }
     getSubsection(subSectionCode) {
-        return (this.subSectionsObj && this.subSectionsObj[subSectionCode])
-            ? this.subSectionsObj[subSectionCode] : null;
+        return (this._subSectionsObj && this._subSectionsObj[subSectionCode])
+            ? this._subSectionsObj[subSectionCode] : null;
     }
     activateSubSection(subSectionCode) {
         if (subSectionCode === this._exclusiveSubSectionsByAttr[ACTIVE$1]) {
             return;
         }
-        const subSection = (this.subSectionsObj && this.subSectionsObj[subSectionCode])
-            ? this.subSectionsObj[subSectionCode] : null;
+        const subSection = (this._subSectionsObj && this._subSectionsObj[subSectionCode])
+            ? this._subSectionsObj[subSectionCode] : null;
         if (subSection) {
             subSection?.activate();
             this._exclusiveSubSectionsByAttr[ACTIVE$1] = subSectionCode;
@@ -2112,8 +2269,8 @@ class RecordFormSection extends FormPiecePropagate {
     }
     getFields() {
         let fieldsArray = [];
-        if (this.subSections && this.subSections.length > 0) {
-            for (const subSection of this.subSections) {
+        if (this._subSections && this._subSections.length > 0) {
+            for (const subSection of this._subSections) {
                 const subsectionFields = subSection.getFields() ?? [];
                 if (subsectionFields?.length > 0) {
                     fieldsArray = fieldsArray.concat(subsectionFields);
@@ -2124,8 +2281,8 @@ class RecordFormSection extends FormPiecePropagate {
     }
     getActions() {
         let actionArray = [];
-        if (this.subSections && this.subSections.length > 0) {
-            for (const subSection of this.subSections) {
+        if (this._subSections && this._subSections.length > 0) {
+            for (const subSection of this._subSections) {
                 const subSectionActions = subSection.getActions() ?? [];
                 if (subSectionActions?.length > 0) {
                     actionArray = actionArray.concat(subSectionActions);
@@ -2136,8 +2293,8 @@ class RecordFormSection extends FormPiecePropagate {
     }
     getActionNames() {
         let actionArray = [];
-        if (this.subSections && this.subSections.length > 0) {
-            for (const subSection of this.subSections) {
+        if (this._subSections && this._subSections.length > 0) {
+            for (const subSection of this._subSections) {
                 actionArray = actionArray.concat(subSection.getActionNames());
             }
         }
@@ -2145,8 +2302,8 @@ class RecordFormSection extends FormPiecePropagate {
     }
     getFieldNames() {
         let fieldsArray = [];
-        if (this.subSections && this.subSections.length > 0) {
-            for (const subSection of this.subSections) {
+        if (this._subSections && this._subSections.length > 0) {
+            for (const subSection of this._subSections) {
                 fieldsArray = fieldsArray.concat(subSection.getFieldNames());
             }
         }
@@ -2154,8 +2311,8 @@ class RecordFormSection extends FormPiecePropagate {
     }
     getField(name) {
         let field = null;
-        if (this.subSections && this.subSections.length > 0) {
-            for (const subSection of this.subSections) {
+        if (this._subSections && this._subSections.length > 0) {
+            for (const subSection of this._subSections) {
                 field = subSection.getField(name);
                 if (field) {
                     return field;
@@ -2165,7 +2322,7 @@ class RecordFormSection extends FormPiecePropagate {
         return null;
     }
     formStateChangeCustomSubscribe(form, formChangeSubject) {
-        this.subSections?.forEach(subsection => {
+        this._subSections?.forEach(subsection => {
             subsection?.connectWithParentForm(form, formChangeSubject);
         });
     }