tuain-ng-forms-lib 0.12.32 → 0.12.36

package/fesm2015/tuain-ng-forms-lib.js

@@ -12,8 +12,6 @@ class ActionComponent {
         this.showLabel = true;
     }
     ngOnInit() {
-        var _a;
-        this.formConfig = (_a = this.actionObject) === null || _a === void 0 ? void 0 : _a._formConfig;
         this.start();
     }
     start() { }
@@ -51,52 +49,106 @@ ActionComponent.propDecorators = {
     showLabel: [{ type: Input }]
 };
 
-const MONITORED_ATTRIBUTES = {
-    _maxLength: 'maxLength',
-    _onValidation: 'onValidation',
-    _fieldValue: 'value',
-    captureType: 'captureType',
-    fieldTitle: 'title',
-    fieldType: 'type',
-    errorMessage: 'errorMessage',
-    errorType: 'errorType',
-    errorCode: 'errorCode',
-    visibleLabel: 'visibleLabel',
-    fieldRequired: 'required',
-    fieldOptions: 'options',
+const componentConstants = {
+    recordsPerPage: 10,
+    // Constantes para el despliegue de formularios
+    ELEMENTTYPE_ACTION: 'ACTION',
+    ELEMENTTYPE_FIELD: 'FIELD',
+    ELEMENTTYPE_TABLE: 'TABLE',
+    // Acciones de formularios
+    FORMACTION_TABLEACTION: 'TABLEACTION',
+    FORMACTION_GETDATA: 'GETDATA',
+    FORMACTION_GETTABLEDATA: 'GETTABLEDATA',
+    FORMACTION_VALIDATE: 'VALIDATE',
+    // Errores etándar de formularios
+    FORMERROR_VALIDATION_CODE: '13',
+    FORMERROR_TYPE_WARNING: 'WARNING',
+    FORMERROR_REQUIRED_FIELDS: 'Todos los campos requeridos deben ser diligenciados',
+    FORMERROR_VALIDATION_TITLE: 'Advertencia',
+    FORMERROR_VALIDATION_FIELDS: 'Existen campos con problemas de validación',
+    // Valores para los controles de navegació
+    FORMNAVIGATION_FIRST: 'first',
+    FORMNAVIGATION_PREVGROUP: 'prevgroup',
+    FORMNAVIGATION_NEXTGROUP: 'nextgroup',
+    FORMNAVIGATION_LAST: 'last',
+    FIELDTYPE_ARRAY: 'ARRAY',
+    FIELDTYPE_CHECK: 'CHECK',
+    FIELDTYPE_DATE: 'DATE',
+    FIELDTYPE_MAP: 'MAP',
+    FIELDTYPE_CURRENCY: 'CURRENCY',
+    FIELDTYPE_SELECT: 'SELECT',
+    FIELDTYPE_TEXT: 'TEXT',
+    FIELD_REQUIRED_MESSAGE: 'Campo requerido',
+    FORMTABLEACTION_SORT: 'SORT',
+    FORMTABLEACTION_REFRESH: 'REFRESH',
+    FORMTABLEACTION_NAVIGATE: 'NAVIGATE',
+    FORMTABLEACTION_INLINE: 'INLINE',
+    FORMTABLEACTION_GLOBAL: 'GLOBAL',
+    FORMTABLEACTION_ROWSELECTION: 'ROWSELECTION',
+    FORMTABLEACTION_SELECTION: 'SELECTION',
+    TABLE_SORT_ASCENDING: 'asc',
+    TABLE_SORT_DESCENDING: 'desc',
+    SERVICE_ERRORCODE_NOERROR: '00',
 };
+const operators = {
+    G: '>',
+    L: '<',
+    GE: '>=',
+    LE: '<=',
+    EQ: '==',
+    NOT_EQ: '!=',
+    CONTENT: 'Contiene',
+    NOT_CONTENT: 'No Contiene',
+    BETWEEN: 'Entre',
+};
+const tableFieldStyles = {
+    TEXT: {
+        'text-align': 'left'
+    },
+    TITLE: {
+        'text-align': 'left'
+    },
+    LABEL: {
+        'text-align': 'left'
+    },
+    MESSAGE: {
+        'text-align': 'left'
+    },
+    NUMBER: {
+        'text-align': 'right'
+    },
+    DATE: {
+        'text-align': 'right'
+    },
+    CHECK: {
+        'text-align': 'center'
+    },
+    ARRAY: {
+        'text-align': 'left'
+    },
+    SELECT: {
+        'text-align': 'left'
+    }
+};
+const DEFAULT_STATE_FLOW = {
+    defaultState: 'CREATE',
+    states: ['CREATE', 'EDIT', 'VIEW'],
+    transitions: [
+        { name: 'VIEW1', origin: 'CREATE', destination: 'VIEW' },
+        { name: 'VIEW2', origin: 'EDIT', destination: 'VIEW' },
+        { name: 'EDIT1', origin: 'CREATE', destination: 'EDIT' },
+        { name: 'EDIT2', origin: 'VIEW', destination: 'EDIT' },
+        { name: 'CREATE1', origin: 'EDIT', destination: 'CREATE' },
+        { name: 'CREATE2', origin: 'VIEW', destination: 'CREATE' },
+    ]
+};
+
 class FieldComponent {
+    constructor() {
+        this.componentConstants = Object.assign({}, componentConstants);
+    }
     ngOnInit() {
-        var _a;
-        if (this.fieldObject) {
-            this.formConfig = (_a = this.fieldObject) === null || _a === void 0 ? void 0 : _a._formConfig;
-            // Atributos estáticos
-            this.code = this.fieldObject.fieldCode;
-            this.fieldInfo = this.fieldObject.fieldInfo;
-            this.fieldAlignment = this.fieldObject.fieldAlignment;
-            this.tooltipText = this.fieldObject.tooltipText;
-            // Cargue inicial
-            this.maxLength = this.fieldObject._maxLength;
-            this.onValidation = this.fieldObject._onValidation;
-            this.value = this.fieldObject._fieldValue;
-            this.captureType = this.fieldObject.captureType;
-            this.title = this.fieldObject.fieldTitle;
-            this.type = this.fieldObject.fieldType;
-            this.errorMessage = this.fieldObject.errorMessage;
-            this.errorType = this.fieldObject.errorType;
-            this.errorCode = this.fieldObject.errorCode;
-            this.visibleLabel = this.fieldObject.visibleLabel;
-            this.required = this.fieldObject.fieldRequired;
-            this.options = this.fieldObject.fieldOptions;
-            this.fieldObject.widget = this;
-            // Atributos dinámicos
-            this.fieldObject.attributeChange.subscribe(event => {
-                const { name, value } = event;
-                if (this[MONITORED_ATTRIBUTES[name]]) {
-                    this[MONITORED_ATTRIBUTES[name]] = value;
-                }
-            });
-        }
+        this.fieldObject.widget = this;
         this.start();
     }
     start() { }
@@ -121,15 +173,17 @@ FieldComponent.decorators = [
                 template: `<ng-content></ng-content>`
             },] }
 ];
+FieldComponent.ctorParameters = () => [];
 FieldComponent.propDecorators = {
     fieldObject: [{ type: Input }],
     disabled: [{ type: Input }]
 };
 
 class ElementComponent {
+    constructor() {
+        this.componentConstants = Object.assign({}, componentConstants);
+    }
     ngOnInit() {
-        var _a;
-        this.formConfig = (_a = this.formElement) === null || _a === void 0 ? void 0 : _a._formConfig;
         this.start();
     }
     start() { }
@@ -150,6 +204,7 @@ ElementComponent.decorators = [
                 template: `<ng-content></ng-content>`
             },] }
 ];
+ElementComponent.ctorParameters = () => [];
 ElementComponent.propDecorators = {
     formElement: [{ type: Input }],
     formManager: [{ type: Input }]
@@ -245,33 +300,9 @@ class Filter {
     }
 }
 
-const elementTypes = {
-    action: 'ACTION',
-    field: 'FIELD',
-    table: 'TABLE',
-};
-const formActions = {
-    tableAction: 'TABLEACTION',
-    getData: 'GETDATA',
-    getTableData: 'GETTABLEDATA',
-    validate: 'VALIDATE',
-};
-const operators = {
-    G: '>',
-    L: '<',
-    GE: '>=',
-    LE: '<=',
-    EQ: '==',
-    NOT_EQ: '!=',
-    CONTENT: 'Contiene',
-    NOT_CONTENT: 'No Contiene',
-    BETWEEN: 'Entre',
-};
-
 class FormElement {
-    constructor(elementDefinition, formConfig) {
+    constructor(elementDefinition) {
         var _a, _b;
-        this._formConfig = formConfig;
         this._isForced = false;
         this.setVisibleStates(elementDefinition.visibleStates);
         this.setEnabledStates(elementDefinition.enabledStates);
@@ -280,9 +311,9 @@ class FormElement {
         this.setVisibility((_b = elementDefinition === null || elementDefinition === void 0 ? void 0 : elementDefinition.visible) !== null && _b !== void 0 ? _b : true);
         this.widget = null;
     }
-    isField() { return this.elementType === elementTypes.field; }
-    isAction() { return this.elementType === elementTypes.action; }
-    isTable() { return this.elementType === elementTypes.table; }
+    isField() { return this.type === componentConstants.ELEMENTTYPE_FIELD; }
+    isAction() { return this.type === componentConstants.ELEMENTTYPE_ACTION; }
+    isTable() { return this.type === componentConstants.ELEMENTTYPE_TABLE; }
     setVisibleStates(newStates) {
         const visibleStates = (!Array.isArray(newStates) && typeof newStates === 'string')
             ? newStates.split(',').map(state => state.trim()).filter(state => state.length > 0)
@@ -328,14 +359,13 @@ class FormElement {
 }
 
 class RecordTableColumn {
-    constructor(recTableColReceived, formConfig) {
+    constructor(recTableColReceived) {
         var _a, _b, _c;
-        this._formConfig = formConfig;
         if (recTableColReceived) {
             this.fieldCode = recTableColReceived.fieldCode;
             this.fieldTitle = recTableColReceived.fieldTitle;
-            this.fieldType = recTableColReceived.fieldTypeCode || this._formConfig.fieldTypes.text;
-            const defaultTypeAlignment = (this._formConfig.tableFieldStyles[this.fieldType] != null) ? this._formConfig.tableFieldStyles[this.fieldType]['text-align'] : 'left';
+            this.fieldType = recTableColReceived.fieldTypeCode || componentConstants.FIELDTYPE_TEXT;
+            const defaultTypeAlignment = (tableFieldStyles[this.fieldType] != null) ? tableFieldStyles[this.fieldType]['text-align'] : 'left';
             this.fieldAlignment = (recTableColReceived.alignment != null) ? recTableColReceived.alignment.toLowerCase() : defaultTypeAlignment;
             this.visible = (_a = recTableColReceived === null || recTableColReceived === void 0 ? void 0 : recTableColReceived.visible) !== null && _a !== void 0 ? _a : true;
             this.sortable = (_b = recTableColReceived === null || recTableColReceived === void 0 ? void 0 : recTableColReceived.sortable) !== null && _b !== void 0 ? _b : false;
@@ -422,8 +452,6 @@ function formatCurrency(inputValue) {
     return outputValue;
 }
 
-const DATE_TYPE = 'DATE';
-const CURRENCY_TYPE = 'CURRENCY';
 class TableRecordData {
     constructor(recordReceived, recordDefinition, selectionFieldName = null) {
         this.recordData = {};
@@ -458,10 +486,10 @@ class TableRecordData {
         }
     }
     formatFieldValue(fieldType, fieldValue) {
-        if (fieldType === CURRENCY_TYPE) {
+        if (fieldType === componentConstants.FIELDTYPE_CURRENCY) {
             return formatCurrency(fieldValue);
         }
-        else if (fieldType === DATE_TYPE && fieldValue) {
+        else if (fieldType === componentConstants.FIELDTYPE_DATE && fieldValue) {
             return new Date(fieldValue).toISOString().split('T')[0];
         }
         return fieldValue || '';
@@ -545,8 +573,6 @@ class TableRecordData {
     }
 }
 
-const TABLE_SORT_ASCENDING = 'asc';
-const TABLE_SORT_DESCENDING = 'desc';
 const TABLE_FILTER_TYPES = {
     simpleFilterChange: 'SIMPLE_CHANGE',
     simpleFilterFinish: 'SIMPLE_FINISH',
@@ -554,9 +580,9 @@ const TABLE_FILTER_TYPES = {
     complexFilterRemove: 'COMPLEX_REMOVE',
 };
 class RecordTable extends FormElement {
-    constructor(tableReceived, formConfig) {
+    constructor(tableReceived) {
         var _a, _b, _c, _d, _e, _f, _g;
-        super(tableReceived, formConfig);
+        super(tableReceived);
         this._inlineActionTrigger = new Subject();
         this._globalActionTrigger = new Subject();
         this._recordSelectionTrigger = new Subject();
@@ -566,7 +592,7 @@ class RecordTable extends FormElement {
         this._tableColumnObj = {};
         this._actionsObj = {};
         this.allSelected = false;
-        this.elementType = elementTypes.table;
+        this.type = componentConstants.ELEMENTTYPE_TABLE;
         this.waiting = false;
         this.complexFilter = false;
         this.currentPage = 1;
@@ -589,10 +615,10 @@ class RecordTable extends FormElement {
         this.customAttributes = (_f = tableReceived === null || tableReceived === void 0 ? void 0 : tableReceived.customAttributes) !== null && _f !== void 0 ? _f : {};
         this.sortable = (_g = tableReceived === null || tableReceived === void 0 ? void 0 : tableReceived.sortable) !== null && _g !== void 0 ? _g : false;
         this.sorting = { columnName: '', direction: '' };
-        this.recordsPerPage = formConfig.defaultRecordsPerPage;
+        this.recordsPerPage = componentConstants.recordsPerPage;
         if (tableReceived.fields) {
             for (const columnReceived of tableReceived.fields) {
-                const columnDefinition = new RecordTableColumn(columnReceived, this._formConfig);
+                const columnDefinition = new RecordTableColumn(columnReceived);
                 this.columns.push(columnDefinition);
                 this._tableColumnObj[columnDefinition.fieldCode] = columnDefinition;
             }
@@ -769,7 +795,7 @@ class RecordTable extends FormElement {
         return (this._actionsObj && actionCode && this._actionsObj[actionCode])
             ? this._actionsObj[actionCode] : null;
     }
-    getActions(actionClass = this._formConfig.tableActions.inline, actionTypes = null) {
+    getActions(actionClass = componentConstants.FORMTABLEACTION_INLINE, actionTypes = null) {
         return this._actions.filter(actionDef => {
             const typeIncluded = (actionTypes) ? actionTypes.includes(actionDef.actionType) : true;
             return actionDef.actionClass === actionClass && typeIncluded;
@@ -830,14 +856,14 @@ class RecordTable extends FormElement {
     setRequiredOrder(columnField) {
         if (columnField !== this.sorting.columnName) {
             this.sorting.columnName = columnField;
-            this.sorting.direction = TABLE_SORT_ASCENDING;
+            this.sorting.direction = componentConstants.TABLE_SORT_ASCENDING;
         }
         else {
-            if (this.sorting.direction === TABLE_SORT_ASCENDING) {
-                this.sorting.direction = TABLE_SORT_DESCENDING;
+            if (this.sorting.direction === componentConstants.TABLE_SORT_ASCENDING) {
+                this.sorting.direction = componentConstants.TABLE_SORT_DESCENDING;
             }
             else {
-                this.sorting.direction = TABLE_SORT_ASCENDING;
+                this.sorting.direction = componentConstants.TABLE_SORT_ASCENDING;
             }
         }
     }
@@ -858,7 +884,7 @@ class RecordTable extends FormElement {
         else if (recordAColumn > recordBColumn) {
             result = 1;
         }
-        return direction === TABLE_SORT_ASCENDING ? result : -result;
+        return direction === componentConstants.TABLE_SORT_ASCENDING ? result : -result;
     }
 }
 
@@ -1014,15 +1040,13 @@ class LibTableComponent {
         this.hasActions = false;
     }
     ngOnInit() {
-        var _a;
-        this.formConfig = (_a = this.tableObject) === null || _a === void 0 ? void 0 : _a._formConfig;
-        this.tableFieldStyles = this.formConfig.tableFieldStyles;
+        this.tableFieldStyles = tableFieldStyles;
         this.selectable = this.tableObject.selectable;
         this.hasActions = this.tableObject.hasActions;
         this.tableObject.widget = this;
-        this.inlineActions = this.tableObject.getActions(this.formConfig.tableActions.inline);
-        this.globalActions = this.tableObject.getActions(this.formConfig.tableActions.global);
-        this.selectionActions = this.tableObject.getActions(this.formConfig.tableActions.selection);
+        this.inlineActions = this.tableObject.getActions(componentConstants.FORMTABLEACTION_INLINE);
+        this.globalActions = this.tableObject.getActions(componentConstants.FORMTABLEACTION_GLOBAL);
+        this.selectionActions = this.tableObject.getActions(componentConstants.FORMTABLEACTION_SELECTION);
         this.start();
     }
     start() { }
@@ -1132,21 +1156,21 @@ class RecordFormSubSection {
                 let arrayToAdd = null;
                 const { type, code } = receivedElement;
                 switch (type) {
-                    case elementTypes.field:
+                    case componentConstants.ELEMENTTYPE_FIELD:
                         elementObject = formObject.getFieldObject(code);
                         arrayToAdd = this.subSectionFields;
                         break;
-                    case elementTypes.table:
+                    case componentConstants.ELEMENTTYPE_TABLE:
                         elementObject = formObject.getTableObject(code);
                         arrayToAdd = this.subSectionTables;
                         break;
-                    case elementTypes.action:
+                    case componentConstants.ELEMENTTYPE_ACTION:
                         elementObject = formObject.getActionObject(code);
                         arrayToAdd = this.subSectionActions;
                         break;
                 }
                 if (elementObject) {
-                    elementObject.elementType = type;
+                    elementObject.type = type;
                     arrayToAdd.push(elementObject);
                     this.subSectionElements.push(elementObject);
                     this.elementsArray[code] = elementObject;
@@ -1278,12 +1302,12 @@ class RecordFormSection {
 
 const HEADER$1 = 'HEADER';
 class FormAction extends FormElement {
-    constructor(actionDefinition, formConfig) {
+    constructor(actionDefinition) {
         var _a, _b;
-        super(actionDefinition, formConfig);
+        super(actionDefinition);
         this._actionActivated = new Subject();
         this.inProgress = false;
-        this.elementType = elementTypes.action;
+        this.type = componentConstants.ELEMENTTYPE_ACTION;
         this.actionCode = actionDefinition.actionCode ? actionDefinition.actionCode.toString() : '';
         this.actionName = actionDefinition.actionTitle;
         this.iconName = actionDefinition.iconName || this.actionCode;
@@ -1311,103 +1335,104 @@ class FormAction extends FormElement {
 }
 
 const UNDEFINED = 'undefined';
-const DEFAULT_ERROR_TYPE = 'error';
-const DEFAULT_CAPTURE_TYPE = 'INPUT';
-const DEFAULT_ALIGNMENT = 'left';
+const FIELD_VALUE = 'fieldValue';
+const FIELD_OPTIONS = 'fieldOptions';
+const FIELD_TITLE = 'fieldTitle';
+const FIELD_CAPTURE_TYPE = 'captureType';
+const FIELD_TYPE = 'fieldTypeCode';
+const FIELD_MAX_LENGTH = 'maxLength';
+const FIELD_VISIBLE = 'visible';
+const FIELD_LABEL_VISIBLE = 'visibleLabel';
+const FIELD_REQUIRED = 'required';
+const FIELD_ERR_CODE = 'errorCode';
+const FIELD_ERR_MSG = 'errorMessage';
+const FIELD_TOOLTIP = 'tooltipText';
+const FIELD_INFO = 'info';
+const FIELD_EDITABLE = 'editable';
+const FIELD_TYPES = {
+    array: 'ARRAY',
+    check: 'CHECK',
+    date: 'DATE',
+    daterange: 'DATERANGE',
+    time: 'TIME',
+    timerange: 'TIMERANGE',
+    map: 'MAP',
+    number: 'NUMBER',
+    decimal: 'DECIMAL',
+    currency: 'CURRENCY',
+    select: 'SELECT',
+    typeahead: 'TYPEAHEAD',
+    text: 'TEXT',
+    password: 'PASSWORD',
+    label: 'LABEL',
+    html: 'HTML',
+    title: 'TITLE',
+    message: 'MESSAGE',
+    link: 'LINK',
+    warning: 'WARNING',
+    avatar: 'AVATAR',
+    email: 'EMAIL',
+    phone: 'PHONE',
+};
+const FIELD_TYPES_FORMATS = {
+    EMAIL: '^\\w+([\\.-]?\\w+)*@\\w+([\\.-]?\\w+)(\\.\\w{2,3})+$',
+};
 const STD_MAX_LENGTH = 50;
 const BIG_MAX_LENGTH = 500;
-const fldAttr = {
-    validateOnServer: 'validateOnServer',
-    value: '_fieldValue',
-    minValue: '_minValue',
-    maxValue: '_maxValue',
-    maxLength: '_maxLength',
-    onValidation: '_onValidation',
-    intrinsicErrorMessage: '_intrinsicErrorMessage',
-    code: 'fieldCode',
-    info: 'fieldInfo',
-    defaultValue: 'defaultValue',
-    defaultEditable: 'defaultEditable',
-    customAttributes: 'customAttributes',
-    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',
-};
 class FieldDescriptor extends FormElement {
-    constructor(inputFieldReceived, formConfig) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
-        super(inputFieldReceived, formConfig);
+    constructor(inputFieldReceived) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        super(inputFieldReceived);
         this._editionFinish = new Subject();
         this._editionPartial = new Subject();
         this._detailRequest = new Subject();
-        this._attributeChange = new Subject();
-        this.elementType = elementTypes.field;
-        const fld = (inputFieldReceived) ? inputFieldReceived : {};
-        this.setAttr(fldAttr.code, fld.fieldCode);
-        this.setAttr(fldAttr.title, (_a = fld.fieldTitle) !== null && _a !== void 0 ? _a : this.fieldCode);
-        this.setAttr(fldAttr.captureType, (_b = fld.captureType) !== null && _b !== void 0 ? _b : DEFAULT_CAPTURE_TYPE);
-        this.setAttr(fldAttr.defaultValue, (_c = fld.defaultValue) !== null && _c !== void 0 ? _c : null);
-        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 || '');
-        let fieldFormat;
-        try {
-            fieldFormat = (fld.format) ? new RegExp(fld.format) : null;
-        }
-        catch (e) {
-            fieldFormat = null;
-        }
-        this.setAttr(fldAttr.format, fieldFormat);
-        this.setAttr(fldAttr.validateOnServer, (_d = fld.serverAction) !== null && _d !== void 0 ? _d : false);
-        this.setAttr(fldAttr.customAttributes, (_e = fld.customAttributes) !== null && _e !== void 0 ? _e : {});
-        this.setAttr(fldAttr.tooltipText, fld.tooltip || '');
-        this.setAttr(fldAttr.defaultEditable, this.enabled);
-        this.setAttr(fldAttr.required, (_f = fld.required) !== null && _f !== void 0 ? _f : false);
-        this.setError(fld.errorCode, fld.errorMessage, (_g = fld.errorType) !== null && _g !== void 0 ? _g : DEFAULT_ERROR_TYPE);
-        this.setAttr(fldAttr.outputOnly, (_h = fld.outputOnly) !== null && _h !== void 0 ? _h : false);
-        const maxLength = (_j = fld.maxLength) !== null && _j !== void 0 ? _j : (this.captureType === 'TEXTAREA' ? BIG_MAX_LENGTH : STD_MAX_LENGTH);
-        this.setAttr(fldAttr.maxLength, maxLength);
-        this.setAttr(fldAttr.intrinsicErrorMessage, (_k = this._formConfig.fieldTypeErrMsg[this.fieldType]) !== null && _k !== void 0 ? _k : this._formConfig.fieldTypeErrMsg.DEFAULT);
-        this.setFieldType(fld.fieldTypeCode);
-        this.setEditable((_l = fld.editable) !== null && _l !== void 0 ? _l : true);
-        this.setVisibleLabel((_m = fld.visibleLabel) !== null && _m !== void 0 ? _m : true);
-        this.setVisibility(fld.visible);
-        this.setFieldOptions(fld.fieldOptions);
-        this.setValue(fld.fieldValue || this.defaultValue || '');
+        this.type = componentConstants.ELEMENTTYPE_FIELD;
+        const fieldReceived = (inputFieldReceived) ? inputFieldReceived : {};
+        this.setEditable((_a = fieldReceived === null || fieldReceived === void 0 ? void 0 : fieldReceived.editable) !== null && _a !== void 0 ? _a : true);
+        this.fieldCode = fieldReceived.fieldCode;
+        this.fieldTitle = fieldReceived.fieldTitle || this.fieldCode;
+        this.captureType = fieldReceived.captureType || 'INPUT';
+        this.setFieldType(fieldReceived.fieldTypeCode);
+        this.defaultValue = fieldReceived.defaultValue || null;
+        this._maxLength = (_b = fieldReceived.maxLength) !== null && _b !== void 0 ? _b : (this.captureType === 'TEXTAREA' ? BIG_MAX_LENGTH : STD_MAX_LENGTH);
+        this.setValue(fieldReceived.fieldValue || this.defaultValue || '');
+        const defaultTypeAlignment = (tableFieldStyles[this.fieldType] != null) ? tableFieldStyles[this.fieldType]['text-align'] : 'left';
+        this.fieldAlignment = (fieldReceived.alignment != null) ? fieldReceived.alignment.toLowerCase() : defaultTypeAlignment;
+        this.fieldInfo = fieldReceived.info || '';
+        this.fieldFormat = fieldReceived.format || null;
+        this.validateOnServer = (_c = fieldReceived === null || fieldReceived === void 0 ? void 0 : fieldReceived.serverAction) !== null && _c !== void 0 ? _c : false;
+        this.customAttributes = (_d = fieldReceived === null || fieldReceived === void 0 ? void 0 : fieldReceived.customAttributes) !== null && _d !== void 0 ? _d : null;
+        this.setVisibility(fieldReceived.visible);
+        this.visibleLabel = (_e = fieldReceived === null || fieldReceived === void 0 ? void 0 : fieldReceived.visibleLabel) !== null && _e !== void 0 ? _e : true;
+        this.tooltipText = fieldReceived.tooltip || '';
+        this.defaultEditable = this.enabled;
+        this.fieldRequired = (_f = fieldReceived === null || fieldReceived === void 0 ? void 0 : fieldReceived.required) !== null && _f !== void 0 ? _f : false;
+        this.errorMessage = fieldReceived.errorMessage || '';
+        this.errorCode = (_g = fieldReceived.errorCode) !== null && _g !== void 0 ? _g : '00';
+        this.outputOnly = (_h = fieldReceived === null || fieldReceived === void 0 ? void 0 : fieldReceived.outputOnly) !== null && _h !== void 0 ? _h : false;
+        this.setFieldOptions(fieldReceived.fieldOptions);
+        this._intrinsicErrorMessage = (this.fieldType === FIELD_TYPES.email)
+            ? `El valor de ${this.fieldTitle} no corresponde a un correo válido`
+            : `El valor de ${this.fieldTitle} no se ajusta al formato establecido`;
     }
     get name() { return this.fieldCode; }
     get editionFinish() { return this._editionFinish; }
-    get attributeChange() { return this._attributeChange; }
     get editionPartial() { return this._editionPartial; }
     get detailRequest() { return this._detailRequest; }
     get validating() { return this._onValidation; }
-    set validating(isValidating) { this.setAttr(fldAttr.onValidation, isValidating); }
-    setIntrinsicErrorMessage(message) { this.setAttr(fldAttr.intrinsicErrorMessage, message); }
+    set validating(isValidating) { this._onValidation = isValidating; }
+    setIntrinsicErrorMessage(message) { this._intrinsicErrorMessage = message; }
     set intrinsicErrorMessage(message) { this.setIntrinsicErrorMessage(message); }
     get fieldValue() { return this.getValue(); }
     get required() { return this.fieldRequired; }
-    set required(required) { this.setAttr(fldAttr.required, required !== null && required !== void 0 ? required : false); }
+    set required(required) { this.fieldRequired = required !== null && required !== void 0 ? required : false; }
     get maxLength() { return (this._maxLength > 0) ? this._maxLength.toString() : ''; }
     set maxLength(requiredMaxLength) {
         if (typeof requiredMaxLength === 'string') {
-            this.setAttr(fldAttr.maxLength, parseInt(requiredMaxLength, 10));
+            this._maxLength = parseInt(requiredMaxLength, 10);
         }
         else if (typeof requiredMaxLength === 'number') {
-            this.setAttr(fldAttr.maxLength, requiredMaxLength);
+            this._maxLength = requiredMaxLength;
         }
     }
     get value() { return this.getValue(); }
@@ -1417,48 +1442,41 @@ class FieldDescriptor extends FormElement {
         this._editionPartial.next({ code: this.fieldCode, intrinsicValidation });
     }
     notifyEditionFinish() {
-        var _a, _b, _c, _d, _e;
+        var _a, _b;
         let intrinsicValidation = true;
-        const fieldDefaultFormat = (_b = (_a = this._formConfig.fieldTypesPatterns) === null || _a === void 0 ? void 0 : _a[this.fieldType]) !== null && _b !== void 0 ? _b : null;
+        const fieldDefaultFormat = (FIELD_TYPES_FORMATS === null || FIELD_TYPES_FORMATS === void 0 ? void 0 : FIELD_TYPES_FORMATS[this.fieldType])
+            ? new RegExp(FIELD_TYPES_FORMATS === null || FIELD_TYPES_FORMATS === void 0 ? void 0 : FIELD_TYPES_FORMATS[this.fieldType]) : null;
+        const fieldFormat = (this.fieldFormat) ? new RegExp(this.fieldFormat) : null;
         const fieldValue = this.getValue();
-        if (fieldValue && (fieldDefaultFormat || this.fieldFormat)) {
-            intrinsicValidation = ((_c = fieldDefaultFormat === null || fieldDefaultFormat === void 0 ? void 0 : fieldDefaultFormat.test(fieldValue)) !== null && _c !== void 0 ? _c : true)
-                && ((_e = (_d = this.fieldFormat) === null || _d === void 0 ? void 0 : _d.test(fieldValue)) !== null && _e !== void 0 ? _e : true);
+        if (fieldValue && (fieldDefaultFormat || fieldFormat)) {
+            intrinsicValidation = ((_a = fieldDefaultFormat === null || fieldDefaultFormat === void 0 ? void 0 : fieldDefaultFormat.test(fieldValue)) !== null && _a !== void 0 ? _a : true)
+                && ((_b = fieldFormat === null || fieldFormat === void 0 ? void 0 : fieldFormat.test(fieldValue)) !== null && _b !== void 0 ? _b : true);
             if (!intrinsicValidation) {
                 this.setError('99', this._intrinsicErrorMessage);
             }
         }
         this._editionFinish.next({ code: this.fieldCode, intrinsicValidation });
     }
-    setAttr(name, value) {
-        this[name] = value;
-        if (this._formConfig.monitoredFieldAttributes.includes(name)) {
-            this._attributeChange.next({ name, value });
-        }
-    }
     notifyEditionDetailRequest() {
         this._detailRequest.next(this.fieldCode);
     }
-    getCustomAttribute(name) { var _a, _b; return (_b = (_a = this.customAttributes) === null || _a === void 0 ? void 0 : _a[name]) !== null && _b !== void 0 ? _b : null; }
-    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); }
+    showLabel() { this.visibleLabel = true; }
+    hideLabel() { this.visibleLabel = false; }
+    changed() { this.hasChanged = true; }
     getRawValue() { return this._fieldValue; }
-    setLabel(label) { this.setAttr(fldAttr.title, label); }
+    setLabel(label) { this.fieldTitle = label; }
     clean() { this.setValue(this.defaultValue || ''); }
     get backend() { return this.validateOnServer; }
+    setVisibleLabel(visibleLabel) { this.visibleLabel = visibleLabel; }
     setEditable(editable = true) { (editable) ? this.enable() : this.disable(); }
-    hasError() { return this.errorCode !== '00'; }
-    setError(code, message, type = DEFAULT_ERROR_TYPE) {
-        this.setAttr(fldAttr.errorCode, code !== null && code !== void 0 ? code : '00');
-        this.setAttr(fldAttr.errorType, (this.errorCode === '00') ? '' : type);
-        this.setAttr(fldAttr.errorMessage, message !== null && message !== void 0 ? message : '');
+    setError(code, message, type = 'error') {
+        this.errorType = (code === '00') ? '' : type;
+        this.errorCode = code;
+        this.errorMessage = message;
     }
     getError() { return { type: this.errorType, code: this.errorCode, message: this.errorMessage }; }
     get error() { return this.getError(); }
-    set error(errorObj) { var _a; this.setError(errorObj.code, errorObj.message, (_a = errorObj.type) !== null && _a !== void 0 ? _a : DEFAULT_ERROR_TYPE); }
+    set error(errorObj) { this.setError(errorObj.code, errorObj.message, errorObj.type); }
     getErrorCode() { return this.getError().code; }
     setErrorCode(code) { this.setError(code, this.errorMessage); }
     getErrorMessage() { return this.getError().message; }
@@ -1468,7 +1486,7 @@ class FieldDescriptor extends FormElement {
         if (fieldCurrentValue === undefined || fieldCurrentValue === null) {
             return true;
         }
-        if ((this.fieldType === this._formConfig.fieldTypes.array || this.fieldType === this._formConfig.fieldTypes.phone)
+        if ((this.fieldType === FIELD_TYPES.array || this.fieldType === FIELD_TYPES.phone)
             && Array.isArray(fieldCurrentValue) && fieldCurrentValue.length === 0) {
             return true;
         }
@@ -1478,10 +1496,10 @@ class FieldDescriptor extends FormElement {
     getValue() {
         var _a;
         switch (this.fieldType) {
-            case this._formConfig.fieldTypes.check:
+            case componentConstants.FIELDTYPE_CHECK:
                 return (_a = this._fieldValue) !== null && _a !== void 0 ? _a : false;
                 break;
-            case this._formConfig.fieldTypes.currency:
+            case componentConstants.FIELDTYPE_CURRENCY:
                 return this._fieldValue.replace(',', '');
                 break;
             default:
@@ -1491,39 +1509,68 @@ class FieldDescriptor extends FormElement {
     }
     updateFromServer(fld) {
         var _a;
-        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, (_a = fld.required) !== null && _a !== void 0 ? _a : 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.setFieldType(fld.fieldTypeCode);
-            (attrName === this._formConfig.apifieldattrs.maxLength) && this.setAttr(fldAttr.maxLength, fld.maxLength);
+        if (FIELD_VISIBLE in fld) {
+            this.setVisibility(fld.visible);
+        }
+        if (FIELD_LABEL_VISIBLE in fld) {
+            this.setVisibleLabel(fld.visibleLabel);
+        }
+        if (FIELD_REQUIRED in fld) {
+            this.fieldRequired = (_a = fld.required) !== null && _a !== void 0 ? _a : false;
+        }
+        if (FIELD_ERR_CODE in fld) {
+            (this.errorCode = fld.errorCode);
+        }
+        if (FIELD_ERR_MSG in fld) {
+            (this.errorMessage = fld.errorMessage);
+        }
+        if (FIELD_TOOLTIP in fld) {
+            (this.tooltipText = fld.tooltip);
+        }
+        if (FIELD_INFO in fld) {
+            (this.fieldInfo = fld.info);
+        }
+        if (FIELD_EDITABLE in fld) {
+            this.setEditable(fld.editable);
+        }
+        if (FIELD_TITLE in fld) {
+            this.setLabel(fld.fieldTitle.toString());
+        }
+        if (FIELD_VALUE in fld) {
+            this.hasChanged = false;
+            this.setValue(fld.fieldValue);
+        }
+        if (FIELD_OPTIONS in fld) {
+            this.setFieldOptions(fld.fieldOptions);
+        }
+        if (FIELD_CAPTURE_TYPE in fld) {
+            this.captureType = fld.captureType || 'INPUT';
+        }
+        if (FIELD_TYPE in fld) {
+            this.setFieldType(fld.fieldTypeCode);
+        }
+        if (FIELD_MAX_LENGTH in fld) {
+            this.maxLength = fld.maxLength;
         }
     }
     setFieldType(inputFieldType) {
-        this.setAttr(fldAttr.type, inputFieldType);
+        this.fieldType = inputFieldType;
+        /**
+         *  Se elimina la validación de que sea un tipo conocido
+         *  this.fieldType = (inputFieldType && FIELDTYPES.includes(inputFieldType))
+         *   ? inputFieldType : componentConstants.FIELDTYPE_TEXT;
+         */
     }
     format() {
-        if (this.fieldType === this._formConfig.fieldTypes.currency) {
-            this.setAttr(fldAttr.value, formatCurrency(this._fieldValue));
+        if (this.fieldType === componentConstants.FIELDTYPE_CURRENCY) {
+            this._fieldValue = formatCurrency(this._fieldValue);
         }
     }
     setMinValue(minValue) {
         var _a, _b, _c;
-        if (this.fieldType === this._formConfig.fieldTypes.date
+        if (this.fieldType === componentConstants.FIELDTYPE_DATE
             && ((_a = this.widget) === null || _a === void 0 ? void 0 : _a.setMinValue)) {
-            this.setAttr(fldAttr.minValue, minValue);
+            this._minValue = minValue;
             if (!minValue) {
                 (_b = this.widget) === null || _b === void 0 ? void 0 : _b.setMinValue(false);
             }
@@ -1535,9 +1582,9 @@ class FieldDescriptor extends FormElement {
     }
     setMaxValue(maxValue) {
         var _a, _b, _c;
-        if (this.fieldType === this._formConfig.fieldTypes.date
+        if (this.fieldType === componentConstants.FIELDTYPE_DATE
             && ((_a = this.widget) === null || _a === void 0 ? void 0 : _a.setMaxValue)) {
-            this.setAttr(fldAttr.maxValue, maxValue);
+            this._maxValue = maxValue;
             if (!maxValue) {
                 (_b = this.widget) === null || _b === void 0 ? void 0 : _b.setMaxValue(false);
             }
@@ -1557,23 +1604,21 @@ class FieldDescriptor extends FormElement {
             || !Array.isArray(newOptions)) {
             return;
         }
-        let fieldOptions = newOptions.map(option => {
+        const 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 Object.assign({}, option);
         });
-        fieldOptions = (fieldOptions && Array.isArray(fieldOptions)
+        this.fieldOptions = (fieldOptions && Array.isArray(fieldOptions)
             && fieldOptions.length > 0) ? fieldOptions : [];
-        this.setAttr(fldAttr.options, fieldOptions);
-        if (this.fieldType === this._formConfig.fieldTypes.array && this.widget) {
+        if (this.fieldType === componentConstants.FIELDTYPE_ARRAY && this.widget) {
             return (_a = this.widget) === null || _a === void 0 ? void 0 : _a.refereshContent();
         }
         if (this._fieldValue) {
-            if (this.fieldType === this._formConfig.fieldTypes.array && Array.isArray(this._fieldValue)) {
-                const fieldValue = (_b = this._fieldValue) === null || _b === void 0 ? void 0 : _b.filter(item => this.fieldOptions.find(opt => opt.fieldOptionId === item));
-                this.setAttr(fldAttr.value, fieldValue);
+            if (this.fieldType === componentConstants.FIELDTYPE_ARRAY && Array.isArray(this._fieldValue)) {
+                this._fieldValue = (_b = this._fieldValue) === null || _b === void 0 ? void 0 : _b.filter(item => this.fieldOptions.find(opt => opt.fieldOptionId === item));
             }
             else {
                 const valInOptions = this.fieldOptions
@@ -1593,17 +1638,17 @@ class FieldDescriptor extends FormElement {
     setValue(newValue, widgetUpdate = true) {
         var _a;
         if (typeof newValue === UNDEFINED || newValue === null) {
-            return true;
+            return;
         }
         let newFinalValue;
         switch (this.fieldType) {
             case 'BOOLEAN':
                 newFinalValue = !!newValue;
                 break;
-            case this._formConfig.fieldTypes.check:
+            case componentConstants.FIELDTYPE_CHECK:
                 newFinalValue = !!newValue;
                 break;
-            case this._formConfig.fieldTypes.array:
+            case componentConstants.FIELDTYPE_ARRAY:
                 if (newValue === null || newValue === '') {
                     newFinalValue = [];
                 }
@@ -1617,7 +1662,7 @@ class FieldDescriptor extends FormElement {
                     newFinalValue = newValue;
                 }
                 break;
-            case this._formConfig.fieldTypes.map:
+            case componentConstants.FIELDTYPE_MAP:
                 newFinalValue = newValue;
                 if (newFinalValue && this.widget && widgetUpdate) {
                     const latitude = parseFloat(newFinalValue[0]);
@@ -1625,7 +1670,7 @@ class FieldDescriptor extends FormElement {
                     (_a = this.widget) === null || _a === void 0 ? void 0 : _a.setLocation(latitude, longitude);
                 }
                 break;
-            case this._formConfig.fieldTypes.currency:
+            case componentConstants.FIELDTYPE_CURRENCY:
                 newFinalValue = formatCurrency(this._fieldValue);
                 break;
             default:
@@ -1633,24 +1678,22 @@ class FieldDescriptor extends FormElement {
                 break;
         }
         if (this._fieldValue !== newFinalValue) {
-            this.setChanged(true);
-            this.setAttr(fldAttr.value, newFinalValue);
+            this.hasChanged = true;
+            this._fieldValue = newFinalValue;
         }
-        return true;
     }
 }
 
 const HEADER = 'HEADER';
 const NO_ERROR = '00';
 class FormStructureAndData {
-    constructor(definitionReceived, formConfig) {
+    constructor(definitionReceived) {
         this._fieldsObj = {};
         this._actionsObj = {};
         this._tableObj = {};
         this._sectionsObj = {};
         this._immutableData = {};
         this._extraInfo = {};
-        this._formConfig = formConfig;
         this.state = '';
         this._actions = [];
         this._fields = [];
@@ -1684,7 +1727,7 @@ class FormStructureAndData {
                 return Object.assign(Object.assign({}, objDef), { visibleStates, enabledStates });
             });
             for (const actionReceived of formActions) {
-                const globalAction = new FormAction(actionReceived, this._formConfig);
+                const globalAction = new FormAction(actionReceived);
                 const globalActionCode = globalAction.actionCode;
                 if (globalActionCode) {
                     this._actions.push(globalAction);
@@ -1705,7 +1748,7 @@ class FormStructureAndData {
                 return Object.assign(Object.assign({}, objDef), { visibleStates, enabledStates });
             });
             for (const fieldReceived of formFields) {
-                const fieldToAdd = new FieldDescriptor(fieldReceived, this._formConfig);
+                const fieldToAdd = new FieldDescriptor(fieldReceived);
                 const fieldCode = fieldToAdd.fieldCode;
                 if (fieldCode) {
                     this._fields.push(fieldToAdd);
@@ -1724,12 +1767,12 @@ class FormStructureAndData {
                     enabledStates = [...visibleStates];
                 }
                 if (!visibleStates || visibleStates.length === 0) {
-                    visibleStates = this._formConfig.defaultStateFlow.states;
+                    visibleStates = DEFAULT_STATE_FLOW.states;
                 }
                 return Object.assign(Object.assign({}, objDef), { visibleStates, enabledStates });
             });
             for (const tableReceived of tables) {
-                const tableToAdd = new RecordTable(tableReceived, this._formConfig);
+                const tableToAdd = new RecordTable(tableReceived);
                 const tableCode = tableToAdd.tableCode;
                 if (tableCode) {
                     this._tables.push(tableToAdd);
@@ -1781,7 +1824,7 @@ class FormStructureAndData {
     }
     setStateFlow(states, transitions, defaultState) {
         if (!states || !transitions) {
-            this._stateFlow = JSON.parse(JSON.stringify(this._formConfig.defaultStateFlow));
+            this._stateFlow = JSON.parse(JSON.stringify(DEFAULT_STATE_FLOW));
             return;
         }
         this._stateFlow.states = states;
@@ -2007,8 +2050,8 @@ class FormStructureAndData {
         const fieldObject = this.getFieldObject(fieldCode);
         return (fieldObject) ? fieldObject.setValue(fieldValue) : null;
     }
-    setFieldError(code, message, type = 'error') {
-        const fieldObject = this.getFieldObject(code);
+    setFieldError(fieldCode, code, message, type = 'error') {
+        const fieldObject = this.getFieldObject(fieldCode);
         return (fieldObject) ? fieldObject.setError(code, message, type) : null;
     }
     setFieldIntrinsicErrorMessage(code, message) {
@@ -2322,6 +2365,7 @@ class BasicFormComponent {
         this.transitionToken = null;
         this.inputDataFields = [];
         this.extraData = null;
+        this.componentConstants = componentConstants;
         this.definitionObtained = false;
         this.formVisible = false;
         this.inServerProcess = false;
@@ -2343,9 +2387,6 @@ class BasicFormComponent {
         this.cleanStart();
         this.customPreProcessing();
     }
-    setConfig(formConfig) {
-        this.formConfig = formConfig;
-    }
     cleanStart() {
         this._errorType = '';
         this.errorCode = '';
@@ -2397,7 +2438,7 @@ class BasicFormComponent {
     setFieldValue(fieldCode, fieldValue) { return this.formStructure.setFieldValue(fieldCode, fieldValue); }
     setFieldRequired(fieldCode, required) { return this.formStructure.setFieldRequired(fieldCode, required); }
     setFieldErrorMessage(fieldCode, errorMessage) { return this.formStructure.setFieldErrorMessage(fieldCode, errorMessage); }
-    setFieldError(code, message, type = 'error') { return this.formStructure.setFieldError(code, message, type); }
+    setFieldError(fieldCode, code, message, type = 'error') { return this.formStructure.setFieldError(fieldCode, code, message, type); }
     setFieldIntrinsicErrorMessage(code, message) { return this.formStructure.setFieldIntrinsicErrorMessage(code, message); }
     setFieldOptions(fieldCode, optionsArray, idAttribute, nameAttribute) {
         return this.formStructure.setFieldOptions(fieldCode, optionsArray, idAttribute, nameAttribute);
@@ -2634,7 +2675,7 @@ class BasicFormComponent {
                 this.inServerProcess = true;
                 const formDefinition = yield this.formManagerService.getFormDefinition(this.name);
                 this.inServerProcess = false;
-                this.formStructure = new FormStructureAndData(formDefinition, this.formConfig);
+                this.formStructure = new FormStructureAndData(formDefinition);
                 this.definitionObtained = true;
             }
             else {
@@ -2660,7 +2701,7 @@ class BasicFormComponent {
                     this.setFieldValue(fieldCode, fieldValue);
                 }
             }
-            const recordResponse = yield this.requestFormAction(formActions.getData);
+            const recordResponse = yield this.requestFormAction(componentConstants.FORMACTION_GETDATA);
             this.checkErrorRecordReceived(recordResponse);
             this.formVisible = true;
             this.subscribeSectionActivation();
@@ -2680,7 +2721,7 @@ class BasicFormComponent {
         this.errorDetail = recordResponse.errorDetail;
     }
     errorOccured() {
-        return (this.errorCode !== '00');
+        return (this.errorCode !== componentConstants.SERVICE_ERRORCODE_NOERROR);
     }
     changeState(state) { return this.formStructure.changeState(state); }
     changeFormMode(state) { return this.changeState(state); }
@@ -2961,7 +3002,7 @@ class BasicFormComponent {
             if (fieldObj.backend) {
                 fieldObj.validating = true;
                 validationResult = yield this
-                    .requestFormAction(formActions.validate, fieldObj.fieldCode);
+                    .requestFormAction(componentConstants.FORMACTION_VALIDATE, fieldObj.fieldCode);
                 finish = !this.errorOccured();
             }
             if (finish) {
@@ -3150,7 +3191,7 @@ class BasicFormComponent {
                     actionCode
                 };
                 actionResult = yield this
-                    .requestFormAction(formActions.tableAction, actionSubject);
+                    .requestFormAction(componentConstants.FORMACTION_TABLEACTION, actionSubject);
                 finish = !this.errorOccured();
             }
             if (finish) {
@@ -3227,13 +3268,13 @@ class BasicFormComponent {
             if (action.backend) {
                 const actionSubject = {
                     tableCode,
-                    actionType: this.formConfig.tableActions.inline,
+                    actionType: componentConstants.FORMTABLEACTION_INLINE,
                     actionCode,
                     tableRecordId: recordId,
                     tableRecordData: recordData
                 };
                 actionResult = yield this
-                    .requestFormAction(formActions.tableAction, actionSubject);
+                    .requestFormAction(componentConstants.FORMACTION_TABLEACTION, actionSubject);
                 finish = !this.errorOccured();
             }
             if (finish) {
@@ -3306,13 +3347,13 @@ class BasicFormComponent {
             if (tableObject.selectionBackend) {
                 const actionSubject = {
                     tableCode,
-                    actionType: this.formConfig.tableActions.rowSelection,
+                    actionType: componentConstants.FORMTABLEACTION_ROWSELECTION,
                     actionCode: null,
                     tableRecordId: recordId,
                     tableRecordData: recordData
                 };
                 actionResult = yield this
-                    .requestFormAction(formActions.tableAction, actionSubject);
+                    .requestFormAction(componentConstants.FORMACTION_TABLEACTION, actionSubject);
                 finish = !this.errorOccured();
             }
             if (finish) {
@@ -3386,12 +3427,12 @@ class BasicFormComponent {
             if (action.backend) {
                 const actionSubject = {
                     tableCode,
-                    actionType: this.formConfig.tableActions.selection,
+                    actionType: componentConstants.FORMTABLEACTION_SELECTION,
                     actionCode,
                     selectedRecords
                 };
                 actionResult = yield this
-                    .requestFormAction(formActions.tableAction, actionSubject);
+                    .requestFormAction(componentConstants.FORMACTION_TABLEACTION, actionSubject);
                 finish = !this.errorOccured();
             }
             if (finish) {
@@ -3449,7 +3490,7 @@ class BasicFormComponent {
             tableObject.putOnWait();
             const actionSubject = { tableCode };
             const actionResult = yield this
-                .requestFormAction(formActions.getTableData, actionSubject);
+                .requestFormAction(componentConstants.FORMACTION_GETTABLEDATA, actionSubject);
             if (this.errorOccured()) {
                 this.displayTableServerError();
             }
@@ -3483,15 +3524,15 @@ class BasicFormComponent {
         this.resetError();
         const completeFields = this.checkSectionRequiredFields(sectionCode, reqFieldMessage);
         if (!completeFields) {
-            this.setError(this.formConfig.formStandardErrors.typeWarning, this.formConfig.formStandardErrors.validationTitle, this.formConfig.formStandardErrors.requiredFields);
+            this.setError(componentConstants.FORMERROR_TYPE_WARNING, componentConstants.FORMERROR_VALIDATION_TITLE, componentConstants.FORMERROR_REQUIRED_FIELDS);
             return;
         }
         let validationError = false;
         const requiredEmptyFields = this.getRequiredEmptyFields(null, sectionCode);
         if (requiredEmptyFields.length > 0) {
             validationError = true;
-            this.setError(this.formConfig.formStandardErrors.typeWarning, this.formConfig.formStandardErrors.validationTitle, this.formConfig.formStandardErrors.requiredFields);
-            this.tagFieldsWithError(requiredEmptyFields, null, this.formConfig.formStandardErrors.requiredField);
+            this.setError(componentConstants.FORMERROR_TYPE_WARNING, componentConstants.FORMERROR_VALIDATION_TITLE, componentConstants.FORMERROR_REQUIRED_FIELDS);
+            this.tagFieldsWithError(requiredEmptyFields, null, componentConstants.FIELD_REQUIRED_MESSAGE);
             for (const fieldCode of requiredEmptyFields) {
                 const requiredEmptyField = this.getField(fieldCode);
                 if (requiredEmptyField && requiredEmptyField.widget
@@ -3504,7 +3545,7 @@ class BasicFormComponent {
         const validationIssueFields = this.getFieldsWithValidationIssues(null, sectionCode);
         if (!validationError && validationIssueFields.length > 0) {
             validationError = true;
-            this.setError(this.formConfig.formStandardErrors.typeWarning, this.formConfig.formStandardErrors.validationTitle, this.formConfig.formStandardErrors.validationFields);
+            this.setError(componentConstants.FORMERROR_TYPE_WARNING, componentConstants.FORMERROR_VALIDATION_TITLE, componentConstants.FORMERROR_VALIDATION_FIELDS);
             for (const fieldCode of validationIssueFields) {
                 const validationIssueField = this.getField(fieldCode);
                 if (validationIssueField && validationIssueField.widget
@@ -3620,13 +3661,13 @@ class BasicFormComponent {
         const requiredEmptyFields = this.getRequiredEmptyFields(recordCaptureFields, null);
         if (requiredEmptyFields.length > 0) {
             validationOk = false;
-            this.setError(this.formConfig.formStandardErrors.typeWarning, this.formConfig.formStandardErrors.validationTitle, this.formConfig.formStandardErrors.requiredFields);
-            this.tagFieldsWithError(requiredEmptyFields, null, this.formConfig.formStandardErrors.requiredField);
+            this.setError(componentConstants.FORMERROR_TYPE_WARNING, componentConstants.FORMERROR_VALIDATION_TITLE, componentConstants.FORMERROR_REQUIRED_FIELDS);
+            this.tagFieldsWithError(requiredEmptyFields, null, componentConstants.FIELD_REQUIRED_MESSAGE);
         }
         const validationIssueFields = this.getFieldsWithValidationIssues(recordCaptureFields, null);
         if (validationIssueFields.length > 0) {
             validationOk = false;
-            this.setError(this.formConfig.formStandardErrors.typeWarning, this.formConfig.formStandardErrors.validationTitle, this.formConfig.formStandardErrors.validationFields);
+            this.setError(componentConstants.FORMERROR_TYPE_WARNING, componentConstants.FORMERROR_VALIDATION_TITLE, componentConstants.FORMERROR_VALIDATION_FIELDS);
         }
         return validationOk;
     }