tuain-ng-forms-lib 14.0.1 → 14.0.3

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

@@ -0,0 +1,3803 @@
+import * as i0 from '@angular/core';
+import { Component, Input, EventEmitter, Output, ChangeDetectionStrategy, NgModule } from '@angular/core';
+import { __awaiter } from 'tslib';
+import { Subject, ReplaySubject } from 'rxjs';
+import yn from 'yn';
+import { nanoid } from 'nanoid';
+import { CommonModule } from '@angular/common';
+import { RouterModule } from '@angular/router';
+import { FormsModule } from '@angular/forms';
+
+class ActionComponent {
+    constructor() {
+        this.style = 'primary';
+        this.showLabel = true;
+    }
+    ngOnInit() {
+        var _a;
+        this.formConfig = (_a = this.action) === null || _a === void 0 ? void 0 : _a._formConfig;
+        this.start();
+    }
+    start() { }
+    activate() {
+        var _a;
+        if ((_a = this.action) === null || _a === void 0 ? void 0 : _a.notifyActivation) {
+            this.action.notifyActivation();
+        }
+    }
+    visibleOnRestriction() {
+        var _a, _b, _c, _d, _e;
+        if (!((_a = this.action) === null || _a === void 0 ? void 0 : _a.restrictedOnField)) {
+            return true;
+        }
+        if ((((_b = this.action) === null || _b === void 0 ? void 0 : _b.restrictedOnOperator) === '=='
+            && this.relatedField === ((_c = this.action) === null || _c === void 0 ? void 0 : _c.restrictedOnValue))
+            || (((_d = this.action) === null || _d === void 0 ? void 0 : _d.restrictedOnOperator) === '!='
+                && this.relatedField !== ((_e = this.action) === null || _e === void 0 ? void 0 : _e.restrictedOnValue))) {
+            return true;
+        }
+        return false;
+    }
+    get visible() {
+        var _a;
+        return ((_a = this.action) === null || _a === void 0 ? void 0 : _a.visibleOn(this.state)) && this.visibleOnRestriction();
+    }
+    get disabled() {
+        var _a;
+        return !((_a = this.action) === null || _a === void 0 ? void 0 : _a.enabledOn(this.state));
+    }
+}
+ActionComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: ActionComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+ActionComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.6", type: ActionComponent, selector: "lib-action", inputs: { action: "action", busy: "busy", relatedField: "relatedField", state: "state", style: "style", showLabel: "showLabel" }, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: ActionComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'lib-action',
+                    template: `<ng-content></ng-content>`
+                }]
+        }], propDecorators: { action: [{
+                type: Input
+            }], busy: [{
+                type: Input
+            }], relatedField: [{
+                type: Input
+            }], state: [{
+                type: Input
+            }], style: [{
+                type: Input
+            }], showLabel: [{
+                type: Input
+            }] } });
+
+const VALUE = 'value';
+const FOCUS = 'focus';
+class FieldComponent {
+    ngOnInit() {
+        var _a, _b;
+        if (this.field) {
+            this.formConfig = (_a = this.field) === null || _a === void 0 ? void 0 : _a._formConfig;
+            // Inicialización
+            const mapping = Object.entries(this.formConfig.componentFieldAttrMap);
+            for (let index = 0; index < mapping.length; index++) {
+                const [fieldAttr1, compAttr1] = mapping[index];
+                const compAttr = compAttr1.toString();
+                const fieldAttr = fieldAttr1.toString();
+                const attributeValue = (_b = this.field) === null || _b === void 0 ? void 0 : _b[fieldAttr];
+                this.dafaultProcessFieldChange(compAttr, attributeValue);
+                this.processFieldChange(compAttr, attributeValue);
+            }
+            // Subscripción a cambios en atributos
+            this.field.attributeChange.subscribe(event => {
+                const { name: fieldAttr, value } = event;
+                const compAttr = this.formConfig.componentFieldAttrMap[fieldAttr];
+                this.dafaultProcessFieldChange(compAttr, value);
+                this.processFieldChange(compAttr, value);
+            });
+        }
+        this.start();
+    }
+    dafaultProcessFieldChange(attribute, value) {
+        if (attribute === VALUE) {
+            this.updateValue();
+        }
+        else if (attribute === FOCUS) {
+            this.focus();
+        }
+        else {
+            this[attribute] = value;
+        }
+    }
+    processFieldChange(attribute, value) { }
+    start() { }
+    focus() { }
+    updateObject() {
+        this.field.setValue(this.value);
+    }
+    inputChanged() {
+        this.field.setValue(this.value);
+        this.onChangeContent();
+    }
+    inputTyped() {
+        this.field.setValue(this.value);
+        this.onInputChange();
+    }
+    updateValue() {
+        this.value = this.field.getValue();
+    }
+    onInputChange() {
+        setTimeout(() => this.field.notifyEditionPartial(), 50);
+    }
+    onChangeContent() {
+        setTimeout(() => this.field.notifyEditionFinish(), 50);
+    }
+    onShowInfo(detail = null) {
+        setTimeout(() => this.field.notifyEditionDetailRequest(detail), 50);
+    }
+    numberInputValidation(event) {
+        const k = event.charCode;
+        return (k > 47 && k < 58);
+    }
+    get visible() {
+        var _a;
+        return (_a = this.field) === null || _a === void 0 ? void 0 : _a.visibleOn(this.state);
+    }
+    get disabled() {
+        var _a;
+        return !((_a = this.field) === null || _a === void 0 ? void 0 : _a.enabledOn(this.state));
+    }
+}
+FieldComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: FieldComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+FieldComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.6", type: FieldComponent, selector: "lib-field", inputs: { field: "field", state: "state" }, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: FieldComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'lib-field',
+                    template: `<ng-content></ng-content>`
+                }]
+        }], propDecorators: { field: [{
+                type: Input
+            }], state: [{
+                type: Input
+            }] } });
+
+class ElementComponent {
+    ngOnInit() {
+        var _a;
+        this.formConfig = (_a = this.element) === null || _a === void 0 ? void 0 : _a._formConfig;
+        this.start();
+    }
+    start() { }
+    get visible() {
+        var _a;
+        return (_a = this.element) === null || _a === void 0 ? void 0 : _a.visibleOn(this.state);
+    }
+    get disabled() {
+        var _a;
+        return !((_a = this.element) === null || _a === void 0 ? void 0 : _a.enabledOn(this.state));
+    }
+}
+ElementComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: ElementComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+ElementComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.6", type: ElementComponent, selector: "lib-element", inputs: { element: "element", form: "form", state: "state" }, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: ElementComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'lib-element',
+                    template: `<ng-content></ng-content>`
+                }]
+        }], propDecorators: { element: [{
+                type: Input
+            }], form: [{
+                type: Input
+            }], state: [{
+                type: Input
+            }] } });
+
+class FormErrorComponent {
+}
+FormErrorComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: FormErrorComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+FormErrorComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.6", type: FormErrorComponent, selector: "lib-form-error", inputs: { errorTitle: "errorTitle", errorMessage: "errorMessage", errorType: "errorType" }, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: FormErrorComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'lib-form-error',
+                    template: `<ng-content></ng-content>`
+                }]
+        }], propDecorators: { errorTitle: [{
+                type: Input
+            }], errorMessage: [{
+                type: Input
+            }], errorType: [{
+                type: Input
+            }] } });
+
+class FormHeaderComponent {
+    constructor() {
+        this.goBackEvent = new EventEmitter();
+    }
+    goBackForm() {
+        this.goBackEvent.emit();
+    }
+}
+FormHeaderComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: FormHeaderComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+FormHeaderComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.6", type: FormHeaderComponent, selector: "lib-form-header", inputs: { formManager: "formManager", goBackAction: "goBackAction", showTitle: "showTitle", headerActions: "headerActions" }, outputs: { goBackEvent: "goBackEvent" }, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: FormHeaderComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'lib-form-header',
+                    template: `<ng-content></ng-content>`
+                }]
+        }], propDecorators: { formManager: [{
+                type: Input
+            }], goBackAction: [{
+                type: Input
+            }], showTitle: [{
+                type: Input
+            }], headerActions: [{
+                type: Input
+            }], goBackEvent: [{
+                type: Output
+            }] } });
+
+class SectionComponent {
+    ngOnInit() {
+        this.start();
+    }
+    start() { }
+}
+SectionComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: SectionComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+SectionComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.6", type: SectionComponent, selector: "lib-section", inputs: { section: "section", formManager: "formManager" }, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: SectionComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'lib-section',
+                    template: `<ng-content></ng-content>`
+                }]
+        }], propDecorators: { section: [{
+                type: Input
+            }], formManager: [{
+                type: Input
+            }] } });
+
+class SubSectionComponent {
+    ngOnInit() {
+        this.start();
+    }
+    start() { }
+}
+SubSectionComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: SubSectionComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+SubSectionComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.6", type: SubSectionComponent, selector: "lib-subsection", inputs: { subSection: "subSection", showHeader: "showHeader", formManager: "formManager" }, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: SubSectionComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'lib-subsection',
+                    template: `<ng-content></ng-content>`
+                }]
+        }], propDecorators: { subSection: [{
+                type: Input
+            }], showHeader: [{
+                type: Input
+            }], formManager: [{
+                type: Input
+            }] } });
+
+const INLINE_ACTION$1 = 'INLINE';
+class LibTableRecordActionComponent {
+    constructor() {
+        this.actionSelected = new EventEmitter();
+    }
+    ngOnInit() {
+        this.start();
+    }
+    start() { }
+    onActivate() {
+        const tableEvent = {
+            actionCode: this.action.actionCode,
+            recordId: this.recordId,
+            recordData: this.recordData,
+        };
+        this.actionSelected.emit(tableEvent);
+    }
+    class() { }
+}
+LibTableRecordActionComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: LibTableRecordActionComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+LibTableRecordActionComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.6", type: LibTableRecordActionComponent, selector: "lib-table-record-action", inputs: { recordId: "recordId", recordData: "recordData", action: "action" }, outputs: { actionSelected: "actionSelected" }, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: LibTableRecordActionComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'lib-table-record-action',
+                    template: `<ng-content></ng-content>`,
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { recordId: [{
+                type: Input
+            }], recordData: [{
+                type: Input
+            }], action: [{
+                type: Input
+            }], actionSelected: [{
+                type: Output
+            }] } });
+
+class LibTableRecordFieldComponent {
+    ngOnInit() {
+        this.start();
+    }
+    start() { }
+}
+LibTableRecordFieldComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: LibTableRecordFieldComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+LibTableRecordFieldComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.6", type: LibTableRecordFieldComponent, selector: "lib-table-record-field", inputs: { fieldCode: "fieldCode", fieldType: "fieldType", fieldValue: "fieldValue" }, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: LibTableRecordFieldComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'lib-table-record-field',
+                    template: `<ng-content></ng-content>`,
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], propDecorators: { fieldCode: [{
+                type: Input
+            }], fieldType: [{
+                type: Input
+            }], fieldValue: [{
+                type: Input
+            }] } });
+
+const changeViewAttributes = ['visibleRecords', 'currentPage', 'recordsPerPage'];
+class LibTableComponent {
+    constructor() {
+        this.globalFilterString = '';
+        this.currentPage = 1;
+        this.globalSearch = false;
+        this.selectedRecords = [];
+        this.totalRecordsNumber = 0;
+        this.allSelected = false;
+        this.loaded = false;
+        this.selectable = false;
+        this.hasActions = false;
+        this.disabled = false;
+    }
+    ngOnInit() {
+        var _a;
+        if (this.table) {
+            this.formConfig = (_a = this.table) === null || _a === void 0 ? void 0 : _a._formConfig;
+            this.tableFieldStyles = this.formConfig.tableFieldStyles;
+            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.componentTableAttrMap);
+            for (let index = 0; index < mapping.length; index++) {
+                const [tableAttrRaw, compAttrRaw] = mapping[index];
+                const tableAttr = tableAttrRaw.toString();
+                const compAttr = compAttrRaw.toString();
+                this.syncAttribute(compAttr, this.table[tableAttr]);
+            }
+            // Subscripción a cambios en atributos
+            this.table.attributeChange.subscribe(event => {
+                const { name: tableAttr, value } = event;
+                const compAttr = this.formConfig.componentTableAttrMap[tableAttr];
+                this.syncAttribute(compAttr, value);
+            });
+        }
+        this.start();
+    }
+    start() { }
+    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.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 !== null && direction !== void 0 ? direction : 'ascend'); }
+    globalFilterChanged() { var _a, _b; this.table.setGlobalFilterString((_b = (_a = this.globalFilterString) === null || _a === void 0 ? void 0 : _a.trim()) !== null && _b !== void 0 ? _b : ''); }
+    syncAttribute(name, value) {
+        try {
+            if (name === 'visibleRecords') {
+                this.updateTableData();
+            }
+            this[name] = value;
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    filterHasChanged(column, values) {
+        if (!values || values.length === 0) {
+            this.table.removeColumnFilter(column.fieldCode);
+        }
+        else {
+            this.table.addColumnFilter(column.fieldCode, values);
+        }
+    }
+}
+LibTableComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: LibTableComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+LibTableComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.6", type: LibTableComponent, selector: "lib-table", inputs: { table: "table", tableRecords: "tableRecords", disabled: "disabled", state: "state", waiting: "waiting" }, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: LibTableComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'lib-table',
+                    template: `<ng-content></ng-content>`,
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], propDecorators: { table: [{
+                type: Input
+            }], tableRecords: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], state: [{
+                type: Input
+            }], waiting: [{
+                type: Input
+            }] } });
+
+const NO_ERROR = '00';
+const HEADER$1 = 'HEADER';
+const elementTypes = {
+    action: 'ACTION',
+    field: 'FIELD',
+    table: 'TABLE',
+};
+const formActions = {
+    tableAction: 'TABLEACTION',
+    getData: 'GETDATA',
+    getTableData: 'GETTABLEDATA',
+    validate: 'VALIDATE',
+};
+const operators = {
+    G: 'G',
+    L: 'L',
+    GE: 'GE',
+    LE: 'LE',
+    EQ: 'EQ',
+    NEQ: 'NEQ',
+    HAS: 'HAS',
+    NOTHAS: 'NOTHAS',
+    BETWEEN: 'BETWEEN',
+    IN: 'IN',
+};
+
+class FormElement {
+    constructor(elementDefinition, formConfig) {
+        var _a, _b, _c;
+        this._formConfig = formConfig;
+        this._isForced = false;
+        this.setVisibleStates(elementDefinition.visibleStates);
+        this.setEnabledStates(elementDefinition.enabledStates);
+        this._visibleForced = false;
+        this.disabled = (_a = elementDefinition === null || elementDefinition === void 0 ? void 0 : elementDefinition.disabled) !== null && _a !== void 0 ? _a : false;
+        this.setVisibility((_b = elementDefinition === null || elementDefinition === void 0 ? void 0 : elementDefinition.visible) !== null && _b !== void 0 ? _b : true);
+        this.customAttributes = (_c = elementDefinition === null || elementDefinition === void 0 ? void 0 : elementDefinition.customAttributes) !== null && _c !== void 0 ? _c : {};
+    }
+    getCustomAttribute(name) { var _a, _b; return (_b = (_a = this.customAttributes) === null || _a === void 0 ? void 0 : _a[name]) !== null && _b !== void 0 ? _b : null; }
+    setCustomAttribute(name, value) {
+        if (name) {
+            this.customAttributes[name] = value;
+        }
+    }
+    matchAttribute(name, value) { var _a; return ((_a = this.customAttributes) === null || _a === void 0 ? void 0 : _a[name]) === value; }
+    isField() { return this.elementType === elementTypes.field; }
+    isAction() { return this.elementType === elementTypes.action; }
+    isTable() { return this.elementType === elementTypes.table; }
+    setVisibleStates(newStates) {
+        const visibleStates = (!Array.isArray(newStates) && typeof newStates === 'string')
+            ? newStates.split(',').map(state => state.trim()).filter(state => state.length > 0)
+            : newStates;
+        this.visibleStates = (Array.isArray(visibleStates)) ? visibleStates : [];
+    }
+    setEnabledStates(newStates) {
+        const enabledStates = (!Array.isArray(newStates) && typeof newStates === 'string')
+            ? newStates.split(',').map(state => state.trim()).filter(state => state.length > 0)
+            : newStates;
+        this.enabledStates = (Array.isArray(enabledStates)) ? enabledStates : [];
+    }
+    viewOnState(state) { return (this.visibleStates && state) ? this.visibleStates.includes(state) : false; }
+    enabledOnState(state) { return (this.enabledStates && state) ? this.enabledStates.includes(state) : false; }
+    /**
+     * @deprecated Utilizar viewOnState
+     */
+    supportState(state) { return this.viewOnState(state); }
+    /**
+     * @deprecated Utilizar viewOnState
+     */
+    supportMode(state) { return this.viewOnState(state); }
+    get visible() { return (this._isForced) ? this._visibleForced : this._visible; }
+    set visible(visible) { this.setVisibility(visible); }
+    visibleOn(state) {
+        return this.visible && this.viewOnState(state);
+    }
+    enabledOn(state) {
+        return !this.disabled && this.enabledOnState(state);
+    }
+    setVisibility(visible, forced = null) {
+        this._visible = visible && true;
+        if (forced != null) {
+            this._isForced = forced;
+        }
+    }
+    show(forced) {
+        this._visible = true;
+        if (forced !== null) {
+            this._isForced = forced;
+            this._visibleForced = true;
+        }
+    }
+    hide(forced) {
+        this._visible = false;
+        if (forced !== null) {
+            this._isForced = forced;
+            this._visibleForced = false;
+        }
+    }
+    enable() { this.disabled = false; }
+    disable() { this.disabled = true; }
+    get enabled() { return !this.disabled; }
+    get editable() { return !this.disabled; }
+}
+
+const HEADER = 'HEADER';
+class FormAction extends FormElement {
+    constructor(actionDefinition, formConfig) {
+        var _a, _b;
+        super(actionDefinition, formConfig);
+        this._actionActivated = new Subject();
+        this.inProgress = false;
+        this.elementType = elementTypes.action;
+        this.actionCode = actionDefinition.actionCode ? actionDefinition.actionCode.toString() : '';
+        this.actionName = actionDefinition.actionTitle;
+        this.iconName = actionDefinition.iconName || this.actionCode;
+        this.setCustomAttribute('location', actionDefinition.position || HEADER);
+        this.backend = (_a = actionDefinition === null || actionDefinition === void 0 ? void 0 : actionDefinition.serverAction) !== null && _a !== void 0 ? _a : false;
+        this.newState = actionDefinition === null || actionDefinition === void 0 ? void 0 : actionDefinition.newState;
+        this.restrictedOnField = actionDefinition.fieldRestrictedCode ? actionDefinition.fieldRestrictedCode.toString() : '';
+        this.restrictedOnOperator = actionDefinition.operatorRestricted || '';
+        this.restrictedOnValue = (_b = actionDefinition.valueRestricted) !== null && _b !== void 0 ? _b : '';
+        this.customValidation = () => true;
+    }
+    get actionActivated() { return this._actionActivated; }
+    start() { this.inProgress = true; }
+    stop() { this.inProgress = false; }
+    notifyActivation() { this._actionActivated.next(this.actionCode); }
+    updateFromServer(receivedAction) {
+        for (const propertyName in receivedAction) {
+            if (propertyName !== 'actionCode' && propertyName !== 'actionId') {
+                this[propertyName] = receivedAction[propertyName];
+            }
+        }
+    }
+    setCustomValidation(callback) { this.customValidation = () => callback(); }
+}
+
+const UNDEFINED = 'undefined';
+const DEFAULT_ERROR_TYPE = 'error';
+const DEFAULT_CAPTURE_TYPE = 'INPUT';
+const DEFAULT_ALIGNMENT = 'left';
+const STD_MAX_LENGTH = 50;
+const BIG_MAX_LENGTH = 500;
+const fldAttr = {
+    validateOnServer: 'validateOnServer',
+    value: '_value',
+    minValue: '_minValue',
+    maxValue: '_maxValue',
+    maxLength: '_maxLength',
+    onValidation: '_onValidation',
+    focus: 'focus',
+    intrinsicErrorMessage: '_intrinsicErrorMessage',
+    code: 'fieldCode',
+    info: 'fieldInfo',
+    defaultValue: 'defaultValue',
+    defaultEditable: 'defaultEditable',
+    visibleLabel: 'visibleLabel',
+    required: 'fieldRequired',
+    hasChanged: 'hasChanged',
+    outputOnly: 'outputOnly',
+    captureType: 'captureType',
+    title: 'fieldTitle',
+    type: 'fieldType',
+    alignment: 'fieldAlignment',
+    format: 'fieldFormat',
+    externalValue: 'externalValue',
+    tooltipText: 'tooltipText',
+    errorType: 'errorType',
+    errorCode: 'errorCode',
+    errorMessage: 'errorMessage',
+    options: 'fieldOptions',
+};
+class FieldDescriptor extends FormElement {
+    constructor(inputFieldReceived, formConfig) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+        super(inputFieldReceived, formConfig);
+        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.type, fld.fieldTypeCode);
+        this.setAttr(fldAttr.captureType, (_b = fld.captureType) !== null && _b !== void 0 ? _b : DEFAULT_CAPTURE_TYPE);
+        const defaultValue = (_c = fld.defaultValue) !== null && _c !== void 0 ? _c : null;
+        if (this.fieldType === this._formConfig.fieldTypes.boolean) {
+            this.setAttr(fldAttr.defaultValue, defaultValue !== null && defaultValue !== void 0 ? defaultValue : false);
+        }
+        else {
+            this.setAttr(fldAttr.defaultValue, defaultValue);
+        }
+        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.tooltipText, fld.tooltip || '');
+        this.setAttr(fldAttr.defaultEditable, this.enabled);
+        this.setAttr(fldAttr.required, (_e = fld.required) !== null && _e !== void 0 ? _e : false);
+        this.setError(fld.errorCode, fld.errorMessage, (_f = fld.errorType) !== null && _f !== void 0 ? _f : DEFAULT_ERROR_TYPE);
+        this.setAttr(fldAttr.outputOnly, (_g = fld.outputOnly) !== null && _g !== void 0 ? _g : false);
+        const maxLength = (_h = fld.maxLength) !== null && _h !== void 0 ? _h : (this.captureType === 'TEXTAREA' ? BIG_MAX_LENGTH : STD_MAX_LENGTH);
+        this.setAttr(fldAttr.maxLength, maxLength);
+        this.setAttr(fldAttr.intrinsicErrorMessage, (_j = this._formConfig.fieldTypeErrMsg[this.fieldType]) !== null && _j !== void 0 ? _j : this._formConfig.fieldTypeErrMsg.DEFAULT);
+        this.setEditable((_k = fld.editable) !== null && _k !== void 0 ? _k : true);
+        this.setVisibleLabel((_l = fld.visibleLabel) !== null && _l !== void 0 ? _l : true);
+        this.setVisibility(fld.visible);
+        this.setFieldOptions(fld.fieldOptions);
+        this.setValue((_o = (_m = fld.fieldValue) !== null && _m !== void 0 ? _m : this.defaultValue) !== null && _o !== void 0 ? _o : '');
+    }
+    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 info() { return this.fieldInfo; }
+    get validating() { return this._onValidation; }
+    set validating(isValidating) { this.setAttr(fldAttr.onValidation, isValidating); }
+    focus() { this.setAttr(fldAttr.focus, true); }
+    setIntrinsicErrorMessage(message) { this.setAttr(fldAttr.intrinsicErrorMessage, message); }
+    set intrinsicErrorMessage(message) { this.setIntrinsicErrorMessage(message); }
+    get fieldValue() { return this.getValue(); }
+    getRequired() { return this.required; }
+    setRequired(required) { this.required = required; }
+    get required() { return this.fieldRequired; }
+    set required(required) { this.setAttr(fldAttr.required, required !== 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));
+        }
+        else if (typeof requiredMaxLength === 'number') {
+            this.setAttr(fldAttr.maxLength, requiredMaxLength);
+        }
+    }
+    get value() { return this.getValue(); }
+    set value(newValue) { this.setValue(newValue); }
+    notifyEditionPartial() {
+        this._editionPartial.next({ code: this.fieldCode, intrinsicValidation: true });
+    }
+    notifyEditionFinish() {
+        var _a, _b, _c, _d, _e;
+        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 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 (!intrinsicValidation) {
+                this.setError('99', this._intrinsicErrorMessage);
+            }
+        }
+        if (intrinsicValidation && fieldValue && this._minValue && fieldValue < this._minValue) {
+            intrinsicValidation = false;
+            this.setError('99', 'Campo con valor inferior al mínimo');
+        }
+        if (intrinsicValidation && fieldValue && this._maxValue && fieldValue > this._maxValue) {
+            intrinsicValidation = false;
+            this.setError('99', 'Campo con valor superior al máximo');
+        }
+        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(detail) {
+        const detailEvent = {
+            code: this.fieldCode,
+            detail,
+        };
+        this._detailRequest.next(detailEvent);
+    }
+    setVisibleLabel(visibleLabel) { this.setAttr(fldAttr.visibleLabel, visibleLabel); }
+    showLabel() { this.setVisibleLabel(true); }
+    hideLabel() { this.setVisibleLabel(false); }
+    setChanged(hasChanged) { this.setAttr(fldAttr.hasChanged, hasChanged); }
+    changed() { this.setChanged(true); }
+    setLabel(label) { this.setAttr(fldAttr.title, label); }
+    clean() { this.setValue(this.defaultValue || ''); this.resetError(); }
+    get backend() { return this.validateOnServer; }
+    setEditable(editable = true) { (editable) ? this.enable() : this.disable(); }
+    hasError() { return this.errorCode !== NO_ERROR; }
+    resetError() { (this.errorCode !== NO_ERROR) && this.setError(NO_ERROR, null); }
+    setError(code, message, type = DEFAULT_ERROR_TYPE) {
+        this.setAttr(fldAttr.errorCode, code !== null && code !== void 0 ? code : NO_ERROR);
+        this.setAttr(fldAttr.errorType, (this.errorCode === NO_ERROR) ? '' : type);
+        this.setAttr(fldAttr.errorMessage, message !== null && message !== void 0 ? 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); }
+    getErrorCode() { return this.getError().code; }
+    setErrorCode(code) { this.setError(code, this.errorMessage); }
+    getErrorMessage() { return this.getError().message; }
+    setErrorMessage(msg) { this.setError(this.errorCode, msg); }
+    get empty() { return this.isEmpty(); }
+    isEmpty() {
+        const fieldCurrentValue = this.getValue();
+        if (fieldCurrentValue === undefined || fieldCurrentValue === null) {
+            return true;
+        }
+        if (this.fieldType === this._formConfig.fieldTypes.array
+            && Array.isArray(fieldCurrentValue) && fieldCurrentValue.length === 0) {
+            return true;
+        }
+        ;
+        if (this.fieldType === this._formConfig.fieldTypes.phone) {
+            if (!Array.isArray(fieldCurrentValue)) {
+                return true;
+            }
+            if (fieldCurrentValue.length !== 2 || !fieldCurrentValue[0] || !fieldCurrentValue[1]) {
+                return true;
+            }
+            return false;
+        }
+        ;
+        return fieldCurrentValue === '';
+    }
+    getValue() {
+        if (this.fieldType === this._formConfig.fieldTypes.boolean
+            || this.fieldType === this._formConfig.fieldTypes.check) {
+            return yn(this._value);
+        }
+        return this._value;
+    }
+    getOptionText() {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.fieldOptions) === null || _a === void 0 ? void 0 : _a.find(item => item.fieldOptionId === this._value)) === null || _b === void 0 ? void 0 : _b.fieldOptionValue) !== null && _c !== void 0 ? _c : null;
+    }
+    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.setAttr(fldAttr.type, fld.fieldTypeCode);
+            (attrName === this._formConfig.apiFieldAttrs.maxLength) && this.setAttr(fldAttr.maxLength, fld.maxLength);
+        }
+    }
+    setMinValue(inputMinValue) {
+        let minValue = inputMinValue;
+        if (this.fieldType === this._formConfig.fieldTypes.date) {
+            minValue = new Date(minValue);
+        }
+        this.setAttr(fldAttr.minValue, minValue);
+    }
+    setMaxValue(inputMaxValue) {
+        let maxValue = inputMaxValue;
+        if (this.fieldType === this._formConfig.fieldTypes.date) {
+            maxValue = new Date(maxValue);
+        }
+        this.setAttr(fldAttr.maxValue, maxValue);
+    }
+    getFieldOptions() {
+        return this.fieldOptions.map(option => {
+            const optionCopy = Object.assign({}, option);
+            return optionCopy;
+        });
+    }
+    setFieldOptions(newOptions) {
+        var _a;
+        if ((!this._formConfig.captureTypesWithOptions.includes(this.captureType))
+            || typeof newOptions === UNDEFINED || !newOptions
+            || !Array.isArray(newOptions)) {
+            return;
+        }
+        let fieldOptions = newOptions.map(option => {
+            if (option.text !== undefined && option.text !== null
+                && option.value !== undefined && option.value !== null) {
+                return { fieldOptionValue: option.text, fieldOptionId: option.value };
+            }
+            return Object.assign({}, option);
+        });
+        fieldOptions = (fieldOptions && Array.isArray(fieldOptions)
+            && fieldOptions.length > 0) ? fieldOptions : [];
+        this.setAttr(fldAttr.options, fieldOptions);
+        if (this._value) {
+            if (this.fieldType === this._formConfig.fieldTypes.array && Array.isArray(this._value)) {
+                const fieldValue = (_a = this._value) === null || _a === void 0 ? void 0 : _a.filter(item => this.fieldOptions.find(opt => opt.fieldOptionId === item));
+                this.setAttr(fldAttr.value, fieldValue);
+            }
+            else {
+                const valInOptions = this.fieldOptions
+                    .find(item => item.fieldOptionId === this._value);
+                if (!valInOptions) {
+                    this.setValue('');
+                }
+            }
+        }
+        if (this.fieldRequired && this.fieldOptions.length === 1) {
+            this.setValue(this.fieldOptions[0].fieldOptionId);
+        }
+    }
+    setValue(newValue, widgetUpdate = true) {
+        var _a;
+        if (typeof newValue === UNDEFINED) {
+            return true;
+        }
+        if (newValue === null && this.required) {
+            return true;
+        }
+        let newFinalValue;
+        if (this.fieldType === this._formConfig.fieldTypes.boolean
+            || this.fieldType === this._formConfig.fieldTypes.check) {
+            newFinalValue = (_a = yn(newValue)) !== null && _a !== void 0 ? _a : false;
+        }
+        else if (this.fieldType === this._formConfig.fieldTypes.array
+            || this.fieldType === this._formConfig.fieldTypes.map) {
+            if (newValue === null || newValue === '') {
+                newFinalValue = [];
+            }
+            else if (Array.isArray(newValue)) {
+                newFinalValue = newValue;
+            }
+            else {
+                newFinalValue = newValue.toString().split(',');
+            }
+        }
+        else {
+            newFinalValue = newValue;
+        }
+        if (this._value !== newFinalValue) {
+            this.setChanged(true);
+            if (widgetUpdate) {
+                this.setAttr(fldAttr.value, newFinalValue);
+            }
+            else {
+                this._value = newFinalValue;
+            }
+        }
+        return true;
+    }
+}
+
+class RecordTableColumn {
+    constructor(recTableColReceived, formConfig) {
+        var _a, _b, _c;
+        // Filtros
+        this.filterVisible = false;
+        this._formConfig = formConfig;
+        this.filterDef = null;
+        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.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;
+            this.sortDirections = (this.sortable) ? ['ascend', 'descend'] : [null];
+            this.fieldFormat = recTableColReceived.format || '';
+            this.customAttributes = (_c = recTableColReceived === null || recTableColReceived === void 0 ? void 0 : recTableColReceived.customAttributes) !== null && _c !== void 0 ? _c : {};
+        }
+    }
+    hideFilter() {
+        this.filterVisible = false;
+    }
+    addFilterDefinition(filterDefinition) {
+        var _a;
+        this.filterDef = {
+            operators: filterDefinition.operators,
+            options: (_a = filterDefinition.options) !== null && _a !== void 0 ? _a : null,
+        };
+    }
+    get filterDefinition() {
+        return this.filterDef;
+    }
+    addFilter(columnValues, operator) {
+        this.filterSetup = {
+            fieldCode: this.fieldCode,
+            operator: operator !== null && operator !== void 0 ? operator : this.filterDef.operators[0],
+            values: columnValues,
+        };
+    }
+    get filter() {
+        return this.filterSetup;
+    }
+    removeFilter() {
+        this.filterSetup = null;
+    }
+    get options() {
+        var _a, _b, _c, _d;
+        if (((_b = (_a = this.filterDef) === null || _a === void 0 ? void 0 : _a.operators) === null || _b === void 0 ? void 0 : _b.length) === 1 && ((_c = this.filterDef) === null || _c === void 0 ? void 0 : _c.operators[0]) === 'IN') {
+            return (_d = this.filterDef) === null || _d === void 0 ? void 0 : _d.options;
+        }
+        return null;
+    }
+    serSortDirections(ascend, descend) {
+        this.sortDirections = [];
+        if (ascend) {
+            this.sortDirections.unshift('ascend');
+        }
+        if (descend) {
+            this.sortDirections.unshift('descend');
+        }
+    }
+}
+
+class TableAction {
+    constructor(actionDefinition) {
+        var _a, _b, _c;
+        this.actionCode = actionDefinition.actionCode;
+        this.actionTitle = actionDefinition.actionTitle;
+        this.iconName = actionDefinition.iconName || this.actionCode;
+        this.actionType = actionDefinition.actionType || 'STANDARD';
+        this.actionClass = actionDefinition.actionClass || 'INLINE';
+        this.newState = actionDefinition.newState;
+        this.stateField = actionDefinition.stateField || '';
+        this.visibleStates = actionDefinition.visibleStates || [];
+        this.enabledStates = actionDefinition.enabledStates || [];
+        this.backend = (_a = actionDefinition === null || actionDefinition === void 0 ? void 0 : actionDefinition.serverAction) !== null && _a !== void 0 ? _a : false;
+        this.restrictedOnField = actionDefinition.fieldRestrictedCode || '';
+        this.restrictedOnValue = (_b = actionDefinition.valueRestricted) !== null && _b !== void 0 ? _b : '';
+        this.restrictedOnOperator = actionDefinition.operatorRestricted || '';
+        this.customAttributes = (_c = actionDefinition === null || actionDefinition === void 0 ? void 0 : actionDefinition.customAttributes) !== null && _c !== void 0 ? _c : {};
+    }
+    supportMode(state) { return this.viewOnState(state); }
+    viewOnState(state) { return this.visibleStates.includes(state); }
+    enabledOnState(state) { return this.enabledStates.includes(state); }
+}
+
+class TableRecordData {
+    constructor(recordReceived, recordDefinition, selectionFieldName = null) {
+        this.recordData = {};
+        const { tableRecordId, recordData } = recordReceived;
+        this.recordId = tableRecordId;
+        this.selected = false;
+        this.recordData = {};
+        if (!recordDefinition || recordDefinition.length === 0 || !recordData || recordData.length === 0) {
+            return;
+        }
+        const fieldNames = recordDefinition.map(column => column.fieldCode);
+        if (Array.isArray(recordData)) {
+            const rawRecordData = recordData.filter(fieldData => fieldData.fieldCode && fieldNames.includes(fieldData.fieldCode));
+            rawRecordData.forEach(fieldData => {
+                const { fieldCode, fieldValue } = fieldData;
+                const fieldDef = recordDefinition.find(column => column.fieldCode === fieldCode);
+                this.recordData[fieldCode] = fieldValue !== null && fieldValue !== void 0 ? fieldValue : '';
+                if (fieldCode === selectionFieldName) {
+                    this.selected = fieldValue;
+                }
+            });
+        }
+        else {
+            const fields = Object.keys(recordData);
+            fields.forEach(fieldCode => {
+                const fieldValue = recordData[fieldCode];
+                const fieldDef = recordDefinition.find(column => column.fieldCode === fieldCode);
+                this.recordData[fieldCode] = fieldValue !== null && fieldValue !== void 0 ? fieldValue : '';
+            });
+        }
+    }
+    toggleSelect() { this.selected = !this.selected; }
+    select() { this.selected = true; }
+    unselect() { this.selected = false; }
+    get recordIdKey() {
+        return (typeof this.recordId === 'object')
+            ? JSON.stringify(this.recordId) : this.recordId;
+    }
+    getFieldValue(fieldCode) {
+        return (fieldCode && this.recordData) ? this.recordData[fieldCode] : null;
+    }
+    hasPattern(words, columnObj) {
+        if (!words || words.length === 0) {
+            return true;
+        }
+        for (const fieldCode in this.recordData) {
+            const columnDef = columnObj === null || columnObj === void 0 ? void 0 : columnObj[fieldCode];
+            if (columnDef && (columnDef === null || columnDef === void 0 ? void 0 : columnDef.visible) && this.recordData.hasOwnProperty(fieldCode)) {
+                for (const word of words) {
+                    const term = word.toUpperCase();
+                    let fieldValue;
+                    if (columnDef.fieldType.toUpperCase().includes('DATE')) {
+                        fieldValue = this.recordData[fieldCode].substring(0, 16);
+                    }
+                    else {
+                        fieldValue = this.recordData[fieldCode];
+                    }
+                    if (fieldValue.toString().toUpperCase().includes(term)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    hasCondition(columnFilters) {
+        if (!columnFilters || columnFilters.length === 0) {
+            return true;
+        }
+        for (const condition of columnFilters) {
+            const { fieldCode, operator, values } = condition;
+            if (this.recordData.hasOwnProperty(fieldCode)) {
+                const fieldValue = this.recordData[fieldCode];
+                const stringValue = fieldValue.toString().toUpperCase();
+                if (operator === operators.G && fieldValue <= values[0]) {
+                    return false;
+                }
+                if (operator === operators.L && fieldValue >= values[0]) {
+                    return false;
+                }
+                if (operator === operators.GE && fieldValue < values[0]) {
+                    return false;
+                }
+                if (operator === operators.LE && fieldValue > values[0]) {
+                    return false;
+                }
+                if (operator === operators.IN && !values.includes(fieldValue)) {
+                    return false;
+                }
+                if (operator === operators.EQ) {
+                    return fieldValue === values[0];
+                }
+                if (operator === operators.NEQ && fieldValue === values[0]) {
+                    return false;
+                }
+                if (operator === operators.HAS && !stringValue.includes(values[0].toString().toUpperCase())) {
+                    return false;
+                }
+                if (operator === operators.NOTHAS && stringValue.includes(values[0].toString().toUpperCase())) {
+                    return false;
+                }
+                if (operator === operators.BETWEEN && (fieldValue < values[0] || fieldValue > values[1])) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}
+
+const TABLE_SORT_ASCENDING = 'asc';
+const TABLE_SORT_DESCENDING = 'desc';
+class RecordTable extends FormElement {
+    constructor(tableReceived, formConfig) {
+        var _a, _b, _c, _d, _e, _f;
+        super(tableReceived, formConfig);
+        this._inlineActionTrigger = new Subject();
+        this._globalActionTrigger = new Subject();
+        this._recordSelectionTrigger = new Subject();
+        this._selectionActionTrigger = new Subject();
+        this._getDataTrigger = new Subject();
+        this._attributeChange = new Subject();
+        this._tableColumnObj = {};
+        this._actionsObj = {};
+        // Mecanismos de filtrado nueva versión
+        this.globalFilterStrings = [];
+        this.tableRecordObj = {};
+        this.allSelected = false;
+        this.elementType = elementTypes.table;
+        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.restrictedId = null;
+        this.tableTitle = tableReceived.tableTitle;
+        this._appendPages = (_a = tableReceived === null || tableReceived === void 0 ? void 0 : tableReceived.append) !== null && _a !== void 0 ? _a : false;
+        this.selectable = (_b = tableReceived === null || tableReceived === void 0 ? void 0 : tableReceived.selectable) !== null && _b !== void 0 ? _b : false;
+        this.selectionBackend = (_c = tableReceived === null || tableReceived === void 0 ? void 0 : tableReceived.selectionBackend) !== null && _c !== void 0 ? _c : false;
+        this.sortable = (_d = tableReceived === null || tableReceived === void 0 ? void 0 : tableReceived.sortable) !== null && _d !== void 0 ? _d : false;
+        this.setAttr('allSelected', false);
+        this.setAttr('tableCode', tableReceived.tableCode);
+        this.setAttr('clientPaging', (_e = tableReceived === null || tableReceived === void 0 ? void 0 : tableReceived.clientPaging) !== null && _e !== void 0 ? _e : true);
+        this.setAttr('globalSearch', (_f = tableReceived === null || tableReceived === void 0 ? void 0 : tableReceived.simpleFilter) !== null && _f !== void 0 ? _f : false);
+        this.setAttr('sorting', { columnName: '', direction: '' });
+        this.setAttr('recordsPerPage', formConfig.defaultRecordsPerPage);
+        this.setAttr('layout', '');
+        if (tableReceived.fields) {
+            const columns = [];
+            for (const columnReceived of tableReceived.fields) {
+                const columnDefinition = new RecordTableColumn(columnReceived, this._formConfig);
+                columns.push(columnDefinition);
+                this._tableColumnObj[columnDefinition.fieldCode] = columnDefinition;
+            }
+            this.setAttr('columns', columns);
+        }
+        if (tableReceived.actions) {
+            const tableActions = tableReceived.actions.map(objDef => {
+                let visibleStates = objDef.visibleStates;
+                let enabledStates = objDef.enabledStates;
+                if (!visibleStates) {
+                    visibleStates = (objDef.actionModes || '').split(',')
+                        .map(state => state.trim())
+                        .filter(state => state.length > 0);
+                    enabledStates = (objDef.actionModes || '').split(',')
+                        .map(state => state.trim())
+                        .filter(state => state.length > 0);
+                }
+                return Object.assign(Object.assign({}, objDef), { visibleStates, enabledStates });
+            });
+            for (const actionReceived of tableActions) {
+                const inlineAction = new TableAction(actionReceived);
+                this._actions.push(inlineAction);
+                this._actionsObj[inlineAction.actionCode] = inlineAction;
+            }
+        }
+        this.selectionField = (this.selectable) ? tableReceived === null || tableReceived === void 0 ? void 0 : tableReceived.selectionField : null;
+        // Filtros predefinidos en el formulario
+        if (tableReceived.filters) {
+            for (let index = 0; index < tableReceived.filters.length; index++) {
+                this.addFilterDefinition(tableReceived.filters[index].fieldCode, tableReceived.filters[index]);
+            }
+        }
+    }
+    get columnNames() { return Object.keys(this._tableColumnObj); }
+    get inlineActionTrigger() { return this._inlineActionTrigger; }
+    get globalActionTrigger() { return this._globalActionTrigger; }
+    get selectionActionTrigger() { return this._selectionActionTrigger; }
+    get recordSelectionTrigger() { return this._recordSelectionTrigger; }
+    get getDataTrigger() { return this._getDataTrigger; }
+    get attributeChange() { return this._attributeChange; }
+    getLayout() { return this.layout; }
+    setLayout(layout) { this.setAttr('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; }
+    columnDefinition(fieldCode) { return this._tableColumnObj[fieldCode]; }
+    putOnWait() { this.waiting = true; }
+    freeWaiting() { this.waiting = false; }
+    setAttr(name, value) {
+        this[name] = value;
+        if (this._formConfig.monitoredTableAttributes.includes(name)) {
+            this._attributeChange.next({ name, value });
+        }
+    }
+    notifyGlobalAction(actionCode) {
+        const tableEvent = {
+            tableCode: this.tableCode,
+            actionCode,
+            actionDetail: null
+        };
+        this._globalActionTrigger.next(tableEvent);
+    }
+    notifyInlineAction(tableActionEvent) {
+        const tableEvent = {
+            tableCode: this.tableCode,
+            actionCode: tableActionEvent.actionCode,
+            actionDetail: {
+                recordId: tableActionEvent.recordId,
+                recordData: tableActionEvent.recordData
+            }
+        };
+        this._inlineActionTrigger.next(tableEvent);
+    }
+    notifyRecordSelection(recordId) {
+        const record = this.getTableRecord(recordId);
+        if (!record) {
+            return;
+        }
+        record.toggleSelect();
+        const tableEvent = {
+            tableCode: this.tableCode,
+            actionCode: null,
+            actionDetail: {
+                recordId: record.recordId,
+                recordData: record.recordData
+            }
+        };
+        this.recordSelectionTrigger.next(tableEvent);
+    }
+    notifySelectionAction(actionCode) {
+        const tableEvent = {
+            tableCode: this.tableCode,
+            actionCode,
+            actionDetail: {
+                selectedRecords: this.selectedRecords
+            }
+        };
+        this._selectionActionTrigger.next(tableEvent);
+    }
+    notifyGetDataAction(requestedPage = null) {
+        this.updateVisibleRecords();
+        this.requestedPage = requestedPage || this.currentPage;
+        const tableEvent = {
+            tableCode: this.tableCode,
+            actionCode: null,
+            actionDetail: null,
+        };
+        this._getDataTrigger.next(tableEvent);
+        return null;
+    }
+    clean() {
+        this.tableRecords = [];
+        this.unSelectAll();
+        this.tableRecordObj = {};
+        this.updateVisibleRecords();
+    }
+    selectAll() {
+        this.setAttr('allSelected', true);
+        this.tableRecords.forEach(record => record.select());
+        this.setAttr('selectedRecords', this.getSelectedRecords());
+        return true;
+    }
+    unSelectAll() {
+        this.setAttr('allSelected', false);
+        this.tableRecords.forEach(record => record.unselect());
+        this.setAttr('selectedRecords', this.getSelectedRecords());
+        return true;
+    }
+    setTableRecords(tableRecords, append) {
+        if (!append) {
+            this.clean();
+        }
+        const newRecordsObj = Object.assign({}, this.tableRecordObj);
+        const newRecords = [...this.tableRecords];
+        for (const tableRecord of tableRecords) {
+            const recordReceived = new TableRecordData(tableRecord, this.columns, this.selectionField);
+            const recordIdKey = recordReceived.recordIdKey;
+            newRecords.push(recordReceived);
+            newRecordsObj[recordIdKey] = recordReceived;
+        }
+        this.tableRecords = newRecords;
+        this.setAttr('selectedRecords', this.getSelectedRecords());
+        this.tableRecordObj = newRecordsObj;
+        this.updateVisibleRecords();
+    }
+    appendRecords(records) { this.setTableRecords(records, true); }
+    replaceRecords(records) { this.setTableRecords(records, false); }
+    changePage(requestedPage) {
+        if (this.clientPaging) {
+            this.setAttr('currentPage', requestedPage);
+            this.updateVisibleRecords();
+        }
+        else {
+            this.notifyGetDataAction(requestedPage);
+        }
+    }
+    updateVisibleRecords() {
+        // updateView const changeViewAttributes = ['currentPage', 'recordsPerPage', 'sorting'];
+        let visibleRecords;
+        if (this.clientPaging) {
+            let filteredRecords = this.getFilteredRecords();
+            this.setAttr('totalRecordsNumber', filteredRecords.length);
+            visibleRecords = filteredRecords.slice((this.currentPage - 1) * this.recordsPerPage, (this.currentPage - 1) * this.recordsPerPage + this.recordsPerPage);
+        }
+        else {
+            visibleRecords = this.tableRecords;
+        }
+        this.setAttr('visibleRecords', visibleRecords);
+    }
+    updateFromServer(tableReceived) {
+        var _a;
+        this.requestedPage = 1;
+        this.clean();
+        this.visible = (tableReceived === null || tableReceived === void 0 ? void 0 : tableReceived.visible) || true;
+        this.totalPages = tableReceived.totalPages || 1;
+        this.recordsNumber = tableReceived.recordsNumber;
+        this.setAttr('currentPage', (_a = +(tableReceived === null || tableReceived === void 0 ? void 0 : tableReceived.currentPage)) !== null && _a !== void 0 ? _a : 1);
+        this.setAttr('recordsPerPage', +tableReceived.recordsPerPage);
+        this.setAttr('totalRecordsNumber', (this.clientPaging) ? tableReceived.tableRecords.length : +tableReceived.totalRecordsNumber);
+        this.setAttr('sorting', {
+            columnName: tableReceived.sortingColumn || '',
+            direction: tableReceived.sortingDirection || ''
+        });
+        this.waiting = false;
+        if (this._appendPages) {
+            this.replaceRecords(tableReceived.tableRecords);
+        }
+        else {
+            this.appendRecords(tableReceived.tableRecords);
+        }
+        this.updateVisibleRecords();
+    }
+    getTableRecord(recordId) {
+        const recordIdKey = (typeof recordId === 'object') ? JSON.stringify(recordId) : recordId;
+        return (this.tableRecordObj && recordId && this.tableRecordObj[recordId])
+            ? this.tableRecordObj[recordId] : null;
+    }
+    getAction(actionCode) {
+        return (this._actionsObj && actionCode && this._actionsObj[actionCode])
+            ? this._actionsObj[actionCode] : null;
+    }
+    getActions(actionClass = this._formConfig.tableActions.inline, actionTypes = null) {
+        return this._actions.filter(actionDef => {
+            const typeIncluded = (actionTypes) ? actionTypes.includes(actionDef.actionType) : true;
+            return actionDef.actionClass === actionClass && typeIncluded;
+        });
+    }
+    // Filtros
+    setFilterById(id) {
+        if (this.restrictedId === id) {
+            return;
+        }
+        this.restrictedId = id;
+        this.updateVisibleRecords();
+    }
+    cleanIdFilter() {
+        if (this.restrictedId === null) {
+            return;
+        }
+        this.restrictedId = null;
+        this.updateVisibleRecords();
+    }
+    setGlobalFilterString(text) {
+        var _a;
+        this.globalFilterStrings = (_a = text.split(' ').filter(t => t && t.trim().length > 0).map(t => t.trim())) !== null && _a !== void 0 ? _a : [];
+        if (this.clientPaging) {
+            this.changePage(1);
+        }
+    }
+    addFilterDefinition(columnName, filterDefinition) {
+        const tableColumn = this.columnDefinition(columnName);
+        tableColumn && tableColumn.addFilterDefinition(filterDefinition);
+    }
+    getFilteredRecords() {
+        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);
+        if (columnFilters.length > 0) {
+            filteredRecords = filteredRecords.filter(record => record.hasCondition(columnFilters));
+        }
+        return filteredRecords;
+    }
+    getColumnFilter(columnName) {
+        var _a;
+        const tableColumn = this.columnDefinition(columnName);
+        return (_a = tableColumn === null || tableColumn === void 0 ? void 0 : tableColumn.filter) !== null && _a !== void 0 ? _a : null;
+    }
+    addColumnFilter(columnName, columnValues, operator = null) {
+        var _a;
+        const tableColumn = this.columnDefinition(columnName);
+        const columnFilterDefinition = (_a = tableColumn === null || tableColumn === void 0 ? void 0 : tableColumn.filterDefinition) !== null && _a !== void 0 ? _a : null;
+        if (!columnFilterDefinition) {
+            return null;
+        }
+        tableColumn && tableColumn.addFilter(columnValues, operator);
+        this.updateVisibleRecords();
+    }
+    removeColumnFilter(columnName) {
+        const tableColumn = this.columnDefinition(columnName);
+        tableColumn && tableColumn.removeFilter();
+        this.updateVisibleRecords();
+    }
+    get currentFilter() {
+        const compactFilter = {
+            simpleFilterWords: this.globalFilterStrings,
+            advancedFilter: [],
+        };
+        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({
+                fieldCode: columnFilter.fieldCode,
+                operator: columnFilter.operator,
+                fieldValue1: columnFilter.values[0],
+                fieldValue2: columnFilter.values[1],
+            });
+        }
+        return compactFilter;
+    }
+    // Ordenamiento de registros local
+    sort(columnName, direction) {
+        this.setRequiredOrder(columnName, direction);
+        if (this.clientPaging) {
+            this.localSortData();
+        }
+        else {
+            this.notifyGetDataAction();
+        }
+    }
+    setRequiredOrder(columnField, direction = null) {
+        this.setAttr('sorting', {
+            columnName: columnField,
+            direction: (direction === 'ascend') ? TABLE_SORT_ASCENDING : TABLE_SORT_DESCENDING,
+        });
+    }
+    localSortData() {
+        if (!this.sorting.columnName || !this.sorting.direction) {
+            return;
+        }
+        this.tableRecords.sort((a, b) => this.recordCompare(a, b, this.sorting.columnName, this.sorting.direction));
+        //this.unSelectAll();
+        this.updateVisibleRecords();
+    }
+    recordCompare(recordA, recordB, columnCompare, direction) {
+        const recordAValue = recordA.getFieldValue(columnCompare);
+        const recordBValue = recordB.getFieldValue(columnCompare);
+        const recordAColumn = isNaN(recordAValue) ? recordAValue.toLocaleLowerCase() : recordAValue;
+        const recordBColumn = isNaN(recordBValue) ? recordBValue.toLocaleLowerCase() : recordBValue;
+        let result = 0;
+        if (recordAColumn < recordBColumn) {
+            result = -1;
+        }
+        else if (recordAColumn > recordBColumn) {
+            result = 1;
+        }
+        return direction === TABLE_SORT_ASCENDING ? result : -result;
+    }
+}
+
+class RecordFormSubSection {
+    constructor(subsectionReceived, formObject) {
+        if (!subsectionReceived) {
+            return;
+        }
+        this._customRender = null;
+        this.visible = true;
+        this.subSectionElements = [];
+        this.subSectionFields = [];
+        this.subSectionTables = [];
+        this.subSectionActions = [];
+        this.elementsArray = {};
+        this.subsectionId = (subsectionReceived.subsectionId) ? subsectionReceived.subsectionId.toString() : '';
+        this.subsectionCode = (subsectionReceived.subsectionCode) ? subsectionReceived.subsectionCode : '';
+        this.subsectionTitle = (subsectionReceived.subsectionTitle) ? subsectionReceived.subsectionTitle : '';
+        this.visibleStates = subsectionReceived.visibleStates || [];
+        if (subsectionReceived.elements) {
+            for (const receivedElement of subsectionReceived.elements) {
+                let elementObject = null;
+                let arrayToAdd = null;
+                const { type, code } = receivedElement;
+                switch (type) {
+                    case elementTypes.field:
+                        elementObject = formObject.getField(code);
+                        arrayToAdd = this.subSectionFields;
+                        break;
+                    case elementTypes.table:
+                        elementObject = formObject.getTable(code);
+                        arrayToAdd = this.subSectionTables;
+                        break;
+                    case elementTypes.action:
+                        elementObject = formObject.getAction(code);
+                        arrayToAdd = this.subSectionActions;
+                        break;
+                }
+                if (elementObject) {
+                    elementObject.elementType = type;
+                    arrayToAdd.push(elementObject);
+                    this.subSectionElements.push(elementObject);
+                    this.elementsArray[code] = elementObject;
+                }
+            }
+        }
+    }
+    show() { this.visible = true; }
+    hide() { this.visible = false; }
+    get customRender() { return this._customRender; }
+    set customRender(customRenderName) { this._customRender = customRenderName; }
+    getField(name) {
+        return this.subSectionFields.find(fld => fld.name === name);
+    }
+    getFields() {
+        return this.subSectionFields;
+    }
+    getFieldNames() {
+        return this.subSectionFields.map(field => field.fieldCode);
+    }
+    getActions() {
+        return this.subSectionActions;
+    }
+    getActionNames() {
+        return this.subSectionActions.map(action => action.actionCode);
+    }
+    viewOnState(state) {
+        return this.visibleStates.includes(state);
+    }
+    supportMode(state) { return this.viewOnState(state); }
+}
+
+class RecordFormSection {
+    constructor(sectionReceived, formObject) {
+        var _a;
+        this._activation = new Subject();
+        this._inactivation = new Subject();
+        this.active = false;
+        this.customAttributes = {};
+        if (!sectionReceived) {
+            return;
+        }
+        this.visible = true;
+        this.sectionId = (sectionReceived.sectionId) ? sectionReceived.sectionId.toString() : '';
+        this.sectionCode = (sectionReceived.sectionCode) ? sectionReceived.sectionCode : '';
+        this.sectionTitle = (sectionReceived.sectionTitle) ? sectionReceived.sectionTitle : '';
+        this.visibleStates = sectionReceived.visibleStates || [];
+        this.subSections = [];
+        this.subSectionsObj = {};
+        if (sectionReceived.subsections) {
+            const subsections = sectionReceived.subsections.map(objDef => {
+                let visibleStates = objDef.visibleStates;
+                if (!visibleStates) {
+                    visibleStates = (objDef.subsectionModes || '').split(',')
+                        .map(state => state.trim())
+                        .filter(state => state.length > 0);
+                }
+                if (!visibleStates || visibleStates.length === 0) {
+                    visibleStates = this.visibleStates;
+                }
+                if (objDef.elements && Array.isArray(objDef.elements)) {
+                    objDef.elements = objDef.elements.map(elm => ({ code: elm.elementCode, type: elm.elementTypeName }));
+                }
+                return Object.assign(Object.assign({}, objDef), { visibleStates });
+            });
+            for (const subsectionReceived of subsections) {
+                const subSectionToAdd = new RecordFormSubSection(subsectionReceived, formObject);
+                const subsectionCode = subSectionToAdd.subsectionCode;
+                if (subsectionCode) {
+                    this.subSections.push(subSectionToAdd);
+                    this.subSectionsObj[subsectionCode] = subSectionToAdd;
+                }
+            }
+        }
+        if (sectionReceived === null || sectionReceived === void 0 ? void 0 : sectionReceived.customAttributes) {
+            (_a = Object.keys(sectionReceived === null || sectionReceived === void 0 ? void 0 : sectionReceived.customAttributes)) === null || _a === void 0 ? void 0 : _a.forEach(attr => this.customAttributes[attr] = sectionReceived === null || sectionReceived === void 0 ? void 0 : sectionReceived.customAttributes[attr]);
+        }
+    }
+    getCustomAttribute(name) { var _a, _b; return (_b = (_a = this.customAttributes) === null || _a === void 0 ? void 0 : _a[name]) !== null && _b !== void 0 ? _b : null; }
+    setCustomAttribute(name, value) { return name && (this.customAttributes[name] = value); }
+    matchAttribute(name, value) { var _a; return ((_a = this.customAttributes) === null || _a === void 0 ? void 0 : _a[name]) === value; }
+    get code() { return this.sectionCode; }
+    get activation() { return this._activation; }
+    get inactivation() { return this._inactivation; }
+    activate() {
+        if (!this.active) {
+            this.active = true;
+            this._activation.next(this.sectionCode);
+        }
+    }
+    inactivate() {
+        if (this.active) {
+            this.active = false;
+            this._inactivation.next(this.sectionCode);
+        }
+    }
+    show() { this.visible = true; }
+    hide() { this.visible = false; }
+    get title() { return this.sectionTitle; }
+    set title(title) { this.sectionTitle = title; }
+    getVisibleSubsections(state) {
+        return this.subSections.filter(subSection => {
+            return subSection.visible && subSection.viewOnState(state);
+        });
+    }
+    getSubsection(subSectionCode) {
+        return (this.subSectionsObj && this.subSectionsObj[subSectionCode])
+            ? this.subSectionsObj[subSectionCode] : null;
+    }
+    getFields() {
+        let fieldsArray = [];
+        if (this.subSections && this.subSections.length > 0) {
+            for (const subSection of this.subSections) {
+                fieldsArray = fieldsArray.concat(subSection.getFields());
+            }
+        }
+        return fieldsArray;
+    }
+    getActions() {
+        let actionArray = [];
+        if (this.subSections && this.subSections.length > 0) {
+            for (const subSection of this.subSections) {
+                actionArray = actionArray.concat(subSection.getActions());
+            }
+        }
+        return actionArray;
+    }
+    getActionNames() {
+        let actionArray = [];
+        if (this.subSections && this.subSections.length > 0) {
+            for (const subSection of this.subSections) {
+                actionArray = actionArray.concat(subSection.getActionNames());
+            }
+        }
+        return actionArray;
+    }
+    getFieldNames() {
+        let fieldsArray = [];
+        if (this.subSections && this.subSections.length > 0) {
+            for (const subSection of this.subSections) {
+                fieldsArray = fieldsArray.concat(subSection.getFieldNames());
+            }
+        }
+        return fieldsArray;
+    }
+    getField(name) {
+        let field = null;
+        if (this.subSections && this.subSections.length > 0) {
+            for (const subSection of this.subSections) {
+                field = subSection.getField(name);
+                if (field) {
+                    return field;
+                }
+            }
+        }
+        return null;
+    }
+    supportState(state) { return this.viewOnState(state); }
+    viewOnState(state) { return this.visibleStates.includes(state); }
+    supportMode(state) { return this.viewOnState(state); }
+}
+
+const ACTIVE = 'active';
+const SHOW = 'show';
+const HIDE = 'hide';
+const ENABLE = 'enable';
+const DISABLE = 'disable';
+const CLEAN = 'clean';
+class FormStructureAndData {
+    constructor(definitionReceived, formConfig) {
+        this._name = '';
+        this._title = '';
+        this._fields = {};
+        this._actions = {};
+        this._tables = {};
+        this._sections = {};
+        this._immutableData = {};
+        this._extraInfo = {};
+        this._exclusiveSectionsByAttr = {};
+        this._formConfig = formConfig;
+        this.state = '';
+        this._actionArray = [];
+        this._fieldArray = [];
+        this._tableArray = [];
+        this._sectionArray = [];
+        this._stateFlow = {
+            defaultState: '',
+            states: [],
+            transitions: [],
+        };
+        if (!definitionReceived) {
+            return;
+        }
+        this._name = (definitionReceived.form && definitionReceived.form.formCode)
+            ? definitionReceived.form.formCode : this._name;
+        this._title = (definitionReceived.form && definitionReceived.form.formTitle)
+            ? definitionReceived.form.formTitle : '';
+        this.setStateFlow(definitionReceived === null || definitionReceived === void 0 ? void 0 : definitionReceived.states, definitionReceived === null || definitionReceived === void 0 ? void 0 : definitionReceived.transitions, definitionReceived === null || definitionReceived === void 0 ? void 0 : definitionReceived.defaultState);
+        this.immutableData = definitionReceived.immutableData;
+        this.extraInfo = definitionReceived.extraInfo;
+        if (definitionReceived.actions) {
+            const formActions = definitionReceived.actions.map(objDef => {
+                let visibleStates = objDef.visibleStates;
+                let enabledStates = objDef.enabledStates;
+                if (!visibleStates) {
+                    visibleStates = (objDef.actionModes || '').split(',')
+                        .map(state => state.trim())
+                        .filter(state => state.length > 0) || [];
+                    enabledStates = [...visibleStates];
+                }
+                return Object.assign(Object.assign({}, objDef), { visibleStates, enabledStates });
+            });
+            for (const actionReceived of formActions) {
+                const globalAction = new FormAction(actionReceived, this._formConfig);
+                const globalActionCode = globalAction.actionCode;
+                if (globalActionCode) {
+                    this._actionArray.push(globalAction);
+                    this._actions[globalActionCode] = globalAction;
+                }
+            }
+        }
+        if (definitionReceived.fields) {
+            const formFields = definitionReceived.fields.map(objDef => {
+                let visibleStates = objDef.visibleStates;
+                let enabledStates = objDef.enabledStates || objDef.editableStates;
+                if (!visibleStates) {
+                    visibleStates = (objDef.fieldModes || '').split(',')
+                        .map(state => state.trim())
+                        .filter(state => state.length > 0) || [];
+                    enabledStates = [...visibleStates];
+                }
+                return Object.assign(Object.assign({}, objDef), { visibleStates, enabledStates });
+            });
+            for (const fieldReceived of formFields) {
+                const fieldToAdd = new FieldDescriptor(fieldReceived, this._formConfig);
+                const fieldCode = fieldToAdd.fieldCode;
+                if (fieldCode) {
+                    this._fieldArray.push(fieldToAdd);
+                    this._fields[fieldCode] = fieldToAdd;
+                }
+            }
+        }
+        if (definitionReceived.tables) {
+            const tables = definitionReceived.tables.map(objDef => {
+                let visibleStates = objDef.visibleStates;
+                let enabledStates = objDef.enabledStates || objDef.editableStates;
+                if (!visibleStates) {
+                    visibleStates = (objDef.tableModes || '').split(',')
+                        .map(state => state.trim())
+                        .filter(state => state.length > 0) || [];
+                    enabledStates = [...visibleStates];
+                }
+                if (!visibleStates || visibleStates.length === 0) {
+                    visibleStates = this._formConfig.defaultStateFlow.states;
+                }
+                return Object.assign(Object.assign({}, objDef), { visibleStates, enabledStates });
+            });
+            for (const tableReceived of tables) {
+                const tableToAdd = new RecordTable(tableReceived, this._formConfig);
+                const tableCode = tableToAdd.tableCode;
+                if (tableCode) {
+                    this._tableArray.push(tableToAdd);
+                    this._tables[tableCode] = tableToAdd;
+                }
+            }
+        }
+        if (definitionReceived.sections) {
+            const formSections = definitionReceived.sections.map(objDef => {
+                let visibleStates = objDef.visibleStates;
+                if (!visibleStates) {
+                    visibleStates = (objDef.sectionModes || '').split(',')
+                        .map(state => state.trim())
+                        .filter(state => state.length > 0) || [];
+                }
+                return Object.assign(Object.assign({}, objDef), { visibleStates });
+            });
+            for (const sectionReceived of formSections) {
+                const sectionToAdd = new RecordFormSection(sectionReceived, this);
+                const sectionCode = sectionToAdd.sectionCode;
+                if (sectionCode) {
+                    this._sectionArray.push(sectionToAdd);
+                    this._sections[sectionCode] = sectionToAdd;
+                }
+            }
+        }
+    }
+    getTitle() { return this._title; }
+    setTitle(title) { this._title = title; }
+    get name() { return this._name; }
+    set name(name) { this._name = name; }
+    // Estados
+    get defaultState() { return this._stateFlow.defaultState; }
+    supportState(state) { var _a; return (_a = this._stateFlow.states) === null || _a === void 0 ? void 0 : _a.includes(state); }
+    supportMode(state) { return this.supportState(state); }
+    get states() { return this._stateFlow.states; }
+    getCurrentState() { return this.state; }
+    changeState(newState) {
+        if (!newState || !this.supportState(newState)) {
+            return false;
+        }
+        if (!this.state) {
+            this.state = newState;
+        }
+        else {
+            const transitionToChange = this._stateFlow.transitions.find(trns => trns.source === this.state && trns.destination === newState);
+            if (transitionToChange) {
+                this.state = newState;
+            }
+        }
+        return (this.state === newState);
+    }
+    setStateFlow(states, transitions, defaultState) {
+        if (!states || !transitions) {
+            this._stateFlow = JSON.parse(JSON.stringify(this._formConfig.defaultStateFlow));
+            return;
+        }
+        this._stateFlow.states = states;
+        this._stateFlow.defaultState = defaultState || this._stateFlow.states[0];
+        this._stateFlow.transitions = transitions.map(transition => {
+            const name = transition.name;
+            const source = (this._stateFlow.states.includes(transition.source)) ? transition.source : '';
+            const destination = (this._stateFlow.states.includes(transition.destination)) ? transition.destination : '';
+            return { name, source, destination };
+        }).filter(item => item.name && item.source && item.destination);
+    }
+    // immutable Data
+    getImmutableElement(name) { var _a, _b, _c; return (_c = (_b = (_a = this._immutableData) === null || _a === void 0 ? void 0 : _a[name]) === null || _b === void 0 ? void 0 : _b.value) !== null && _c !== void 0 ? _c : null; }
+    set immutableData(immutableData) { Object.assign(this._immutableData, immutableData); }
+    get immutableData() { return JSON.parse(JSON.stringify(this._immutableData)); }
+    // extra Info
+    getExtraInfo(name) { var _a, _b, _c; return (_c = (_b = (_a = this._extraInfo) === null || _a === void 0 ? void 0 : _a[name]) === null || _b === void 0 ? void 0 : _b.value) !== null && _c !== void 0 ? _c : null; }
+    set extraInfo(extraInfo) { Object.assign(this._extraInfo, extraInfo); }
+    get extraInfo() { return JSON.parse(JSON.stringify(this._extraInfo)); }
+    // Fields
+    get fields() { return this._fields; }
+    get fieldNames() { return this.getFieldNames(); }
+    getFields() { return this._fieldArray; }
+    getFieldNames() { return this._fieldArray.map(field => field.fieldCode); }
+    getField(code) { var _a; return (code && ((_a = this._fields) === null || _a === void 0 ? void 0 : _a[code])) ? this._fields[code] : null; }
+    enableField(code) { var _a; (_a = this.getField(code)) === null || _a === void 0 ? void 0 : _a.enable(); }
+    disableField(code) { var _a; (_a = this.getField(code)) === null || _a === void 0 ? void 0 : _a.disable(); }
+    getFieldValue(code) { var _a; return (_a = this.getField(code)) === null || _a === void 0 ? void 0 : _a.getValue(); }
+    getFieldOptionText(code) { var _a; return (_a = this.getField(code)) === null || _a === void 0 ? void 0 : _a.getOptionText(); }
+    getFieldOptions(code) { var _a, _b; return (_b = (_a = this.getField(code)) === null || _a === void 0 ? void 0 : _a.getFieldOptions()) !== null && _b !== void 0 ? _b : null; }
+    setFieldValue(code, value) { var _a; (_a = this.getField(code)) === null || _a === void 0 ? void 0 : _a.setValue(value); }
+    setFieldError(code, errorCode, message, type = 'error') { var _a; (_a = this.getField(code)) === null || _a === void 0 ? void 0 : _a.setError(errorCode, message, type); }
+    setFieldIntrinsicErrorMessage(code, message) { var _a; (_a = this.getField(code)) === null || _a === void 0 ? void 0 : _a.setIntrinsicErrorMessage(message); }
+    setFieldRequired(code, required) { var _a; (_a = this.getField(code)) === null || _a === void 0 ? void 0 : _a.setRequired(required); }
+    setFieldErrorMessage(code, message) { var _a; (_a = this.getField(code)) === null || _a === void 0 ? void 0 : _a.setErrorMessage(message); }
+    setFieldOptions(code, optionsArray, idAttribute, nameAttribute) {
+        const field = this.getField(code);
+        if (field && (optionsArray === null || optionsArray === void 0 ? void 0 : optionsArray.length) > 0) {
+            const fieldOptions = optionsArray.map(item => ({
+                fieldOptionId: item[idAttribute],
+                fieldOptionValue: item[nameAttribute]
+            }));
+            field.setFieldOptions(fieldOptions);
+        }
+    }
+    getFieldSet(filter, inputCodes, secCode, subCode) {
+        var _a, _b, _c, _d, _e;
+        let codes = [];
+        if (typeof inputCodes === 'string' && inputCodes) {
+            codes = [inputCodes];
+        }
+        else if (Array.isArray(inputCodes) && inputCodes.length > 0) {
+            codes = inputCodes !== null && inputCodes !== void 0 ? inputCodes : [];
+        }
+        else if (secCode && !subCode) {
+            codes = (_b = (_a = this.getSection(secCode)) === null || _a === void 0 ? void 0 : _a.getFieldNames()) !== null && _b !== void 0 ? _b : [];
+        }
+        else if (secCode && subCode) {
+            codes = (_d = (_c = this.getSubSection(secCode, subCode)) === null || _c === void 0 ? void 0 : _c.getFieldNames()) !== null && _d !== void 0 ? _d : [];
+        }
+        else {
+            codes = (_e = this.getFieldNames()) !== null && _e !== void 0 ? _e : [];
+        }
+        return (filter) ? codes.filter(fld => filter(this.getField(fld))) : codes;
+    }
+    applyOnFields(processFunc, inputCodes, secCode, subCode) {
+        if (!processFunc) {
+            return 0;
+        }
+        const codes = this.getFieldSet(null, inputCodes !== null && inputCodes !== void 0 ? inputCodes : null, secCode, subCode);
+        let processedFields = 0;
+        for (const code of codes) {
+            const field = this.getField(code);
+            if (field) {
+                try {
+                    processFunc(field);
+                    processedFields += 1;
+                }
+                catch (e) {
+                    console.log(`Error procesando funcion en campo ${field}: ${e}`);
+                }
+            }
+        }
+        return processedFields;
+    }
+    enableFields(codes, secCode, subCode) {
+        return this.applyOnFields(fld => fld.enable(), codes, secCode, subCode);
+    }
+    showFields(codes, secCode, subCode) {
+        return this.applyOnFields(fld => fld.show(), codes, secCode, subCode);
+    }
+    hideFields(codes, secCode, subCode) {
+        return this.applyOnFields(fld => fld.hide(), codes, secCode, subCode);
+    }
+    showLabelFields(codes, secCode, subCode) {
+        return this.applyOnFields(fld => fld.showLablel(), codes, secCode, subCode);
+    }
+    hideLabelFields(codes, secCode, subCode) {
+        return this.applyOnFields(fld => fld.hideLabel(), codes, secCode, subCode);
+    }
+    disableFields(codes, secCode, subCode) {
+        return this.applyOnFields(fld => fld.disable(), codes, secCode, subCode);
+    }
+    cleanFields(codes, secCode, subCode) {
+        return this.applyOnFields(fld => fld.clean(), codes, secCode, subCode);
+    }
+    tagFieldsWithError(message, codes, secCode, subCode) {
+        return this.applyOnFields(fld => fld.setErrorMessage(message), codes, secCode, subCode);
+    }
+    cleanErrorFields(codes, secCode, subCode) {
+        return this.tagFieldsWithError('', codes, secCode, subCode);
+    }
+    tagEmptyRequiredFields(message, codes = null, secCode, subCode) {
+        return this.tagFieldsWithError(message, this.getRequiredEmptyFields(codes, secCode, subCode)) > 0;
+    }
+    getRequiredFields(codes, secCode, subCode) {
+        return this.getFieldSet(fld => fld.required, codes !== null && codes !== void 0 ? codes : null, secCode, subCode);
+    }
+    getRequiredEmptyFields(codes, secCode, subCode) {
+        return this.getFieldSet(fld => fld.required && fld.empty, codes !== null && codes !== void 0 ? codes : null, secCode, subCode);
+    }
+    getChangedFields(codes, secCode, subCode) {
+        return this.getFieldSet(fld => !fld.outputOnly && fld.hasChanged(), codes !== null && codes !== void 0 ? codes : null, secCode, subCode);
+    }
+    getFieldsWithValidationIssues(codes, secCode, subCode) {
+        return this.getFieldSet(fld => fld.errorCode !== NO_ERROR, codes !== null && codes !== void 0 ? codes : null, secCode, subCode);
+    }
+    getFieldsValues(inputCodes, secCode, subCode) {
+        var _a, _b, _c;
+        const codes = this.getFieldSet(null, inputCodes !== null && inputCodes !== void 0 ? inputCodes : null, secCode, subCode);
+        const resultObject = {};
+        for (let index = 0; index < codes.length; index++) {
+            const code = codes[index];
+            if (code) {
+                resultObject[code] = (_c = (_b = (_a = this._fields) === null || _a === void 0 ? void 0 : _a[code]) === null || _b === void 0 ? void 0 : _b.getValue()) !== null && _c !== void 0 ? _c : null;
+            }
+        }
+        return resultObject;
+    }
+    // Acciones
+    get actions() { return this._actions; }
+    getActionsByAttribute(name, value) { return this._actionArray.filter(actionItem => actionItem.matchAttribute(name, value)); }
+    getActions() { return this._actionArray; }
+    getAction(code) { var _a; return (code && ((_a = this._actions) === null || _a === void 0 ? void 0 : _a[code])) ? this._actions[code] : null; }
+    showActions(codes) { return this.execOnActions(codes, SHOW); }
+    hideActions(codes) { return this.execOnActions(codes, HIDE); }
+    enableActions(codes) { return this.execOnActions(codes, ENABLE); }
+    disableActions(codes) { return this.execOnActions(codes, DISABLE); }
+    execOnActions(codes, functionName) {
+        const actionCodes = (Array.isArray(codes)) ? codes : (codes ? [codes] : []);
+        if (!functionName || actionCodes.length === 0) {
+            return;
+        }
+        actionCodes.forEach(code => {
+            var _a;
+            const action = this.getAction(code);
+            (_a = action === null || action === void 0 ? void 0 : action[functionName]) === null || _a === void 0 ? void 0 : _a.call(action);
+        });
+    }
+    // Tablas
+    get tables() { return this.tables; }
+    getTables() { return this._tableArray; }
+    getTable(code) { var _a; return (code && ((_a = this._tables) === null || _a === void 0 ? void 0 : _a[code])) ? this._tables[code] : null; }
+    getTableRecord(code, id) { var _a; return (_a = this.getTable(code)) === null || _a === void 0 ? void 0 : _a.getTableRecord(id); }
+    enableTables(codes) { return this.execOnTables(codes, ENABLE); }
+    disableTables(codes) { return this.execOnTables(codes, DISABLE); }
+    showTables(codes) { return this.execOnTables(codes, SHOW); }
+    hideTables(codes) { return this.execOnTables(codes, HIDE); }
+    cleanTables(codes) { return this.execOnTables(codes, CLEAN); }
+    execOnTables(codes, functionName) {
+        const tableCodes = (Array.isArray(codes)) ? codes : (codes ? [codes] : []);
+        if (!functionName || tableCodes.length === 0) {
+            return;
+        }
+        tableCodes.forEach(code => {
+            var _a;
+            const table = this.getTable(code);
+            (_a = table === null || table === void 0 ? void 0 : table[functionName]) === null || _a === void 0 ? void 0 : _a.call(table);
+        });
+    }
+    // Secciones
+    get sections() { return this._sections; }
+    getSections() { return this._sectionArray; }
+    getSectionsByAttribute(name, value) { return this._sectionArray.filter(item => item.matchAttribute(name, value)); }
+    get sectionTitles() { return this._sectionArray.map(formSection => formSection.sectionTitle); }
+    get visibleSections() { return this._sectionArray.filter(sec => sec.visible); }
+    getSection(code) { var _a; return (code && ((_a = this._sections) === null || _a === void 0 ? void 0 : _a[code])) ? this._sections[code] : null; }
+    showSections(codes) { this.execOnSections(codes, SHOW); }
+    hideSections(codes) { this.execOnSections(codes, HIDE); }
+    activeSection() { return this._exclusiveSectionsByAttr[ACTIVE]; }
+    getSubSection(code, subCode) { var _a, _b; return (_b = (_a = this.getSection(code)) === null || _a === void 0 ? void 0 : _a.getSubsection(subCode)) !== null && _b !== void 0 ? _b : null; }
+    showSubSections(code, subCodes) { return this.execOnSubSections(code, subCodes, SHOW); }
+    hideSubSections(code, subCodes) { return this.execOnSubSections(code, subCodes, HIDE); }
+    getSectionActions(code) { var _a, _b; return (_b = (_a = this.getSection(code)) === null || _a === void 0 ? void 0 : _a.getActions()) !== null && _b !== void 0 ? _b : null; }
+    getSectionActionNames(code) { var _a, _b; return (_b = (_a = this.getSection(code)) === null || _a === void 0 ? void 0 : _a.getActionNames()) !== null && _b !== void 0 ? _b : null; }
+    activateSection(code) {
+        var _a, _b;
+        if (code === this._exclusiveSectionsByAttr[ACTIVE]) {
+            return;
+        }
+        (_a = this.getSection(this.activeSection())) === null || _a === void 0 ? void 0 : _a.inactivate();
+        (_b = this.getSection(code)) === null || _b === void 0 ? void 0 : _b.activate();
+        this._exclusiveSectionsByAttr[ACTIVE] = code;
+    }
+    execOnSections(codes, functionName) {
+        const sectionCodes = (Array.isArray(codes)) ? codes : (codes ? [codes] : []);
+        if (!functionName || sectionCodes.length === 0) {
+            return;
+        }
+        sectionCodes.forEach(code => {
+            var _a;
+            const section = this.getSection(code);
+            (_a = section === null || section === void 0 ? void 0 : section[functionName]) === null || _a === void 0 ? void 0 : _a.call(section);
+        });
+    }
+    execOnSubSections(code, subNames, functionName) {
+        var _a;
+        const subCodes = (Array.isArray(subNames)) ? subNames : (subNames ? [subNames] : []);
+        const section = this.getSection(code);
+        if (!functionName || !section || subCodes.length === 0) {
+            return;
+        }
+        for (const subCode of subCodes) {
+            const subSection = this.getSubSection(code, subCode);
+            (_a = subSection === null || subSection === void 0 ? void 0 : subSection[functionName]) === null || _a === void 0 ? void 0 : _a.call(subSection);
+        }
+    }
+    /**
+     * Métodos propios de gestión del formulario
+     */
+    cleanData() {
+        for (const field of this._fieldArray) {
+            field.setValue(field.defaultValue);
+        }
+        for (const table of this._tableArray) {
+            table.clean();
+        }
+    }
+    getPayload() {
+        const formData = {
+            fields: [],
+            tables: [],
+        };
+        formData.fields = this.getFields().filter(fld => !fld.outputOnly)
+            .map(fld => {
+            const fieldPayload = {
+                fieldCode: fld.fieldCode,
+                fieldValue: fld.getValue(),
+                editable: !fld.disabled,
+                visible: fld.visible,
+                required: fld.required,
+                fieldOptions: '',
+            };
+            return fieldPayload;
+        });
+        formData.tables = this.getTables().map(tbl => {
+            const tablePayload = {
+                tableCode: tbl.tableCode,
+                visible: tbl.visible,
+                currentPage: tbl.currentPage,
+                requestedPage: tbl.requestedPage,
+                recordsPerPage: tbl.recordsPerPage,
+                currentFilter: tbl.currentFilter,
+                sortingColumn: tbl.sorting.columnName,
+                sortingDirection: tbl.sorting.direction,
+            };
+            return tablePayload;
+        });
+        return formData;
+    }
+}
+
+class LibFormManagerService {
+    constructor() {
+        this.cleanStack();
+    }
+    // Métodos virtuales para las aplicaciones
+    getFormDefinition(formCode) { }
+    execServerAction(actionDetail) { }
+    goToForm(formCode, token, subject) { }
+    loadStack() { }
+    saveStack() { }
+    cleanStack() { this.pageStack = []; }
+    resetPageStack() { this.cleanStack(); }
+    findFormInStack(token) {
+        const index = this.pageStack.findIndex(item => (item === null || item === void 0 ? void 0 : item.token) === token);
+        const data = (index >= 0) ? this.pageStack[index] : null;
+        return { index, data };
+    }
+    replaceItem(token, formInfo) {
+        var _a, _b, _c, _d;
+        if (!token || !formInfo) {
+            return;
+        }
+        const { index, data: storedForm } = this.findFormInStack(token);
+        let updatedForm = null;
+        if (index >= 0) {
+            updatedForm = Object.assign({}, storedForm);
+            updatedForm.subject = (_a = formInfo === null || formInfo === void 0 ? void 0 : formInfo.subject) !== null && _a !== void 0 ? _a : storedForm.subject;
+            updatedForm.state = (_b = formInfo === null || formInfo === void 0 ? void 0 : formInfo.state) !== null && _b !== void 0 ? _b : storedForm.state;
+            updatedForm.fields = (_c = storedForm === null || storedForm === void 0 ? void 0 : storedForm.fields) !== null && _c !== void 0 ? _c : {};
+            updatedForm.extra = (_d = storedForm === null || storedForm === void 0 ? void 0 : storedForm.extra) !== null && _d !== void 0 ? _d : {};
+            if (formInfo.fields) {
+                Object.assign(updatedForm.fields, formInfo.fields);
+            }
+            if (formInfo.extra) {
+                Object.assign(updatedForm.extra, formInfo.extra);
+            }
+            this.pageStack[index] = updatedForm;
+            this.saveStack();
+        }
+    }
+    stack(origin, target) {
+        const token = nanoid(6);
+        this.replaceItem(target.originToken, origin);
+        this.pageStack.push(Object.assign({ token }, target));
+        this.saveStack();
+        return token;
+    }
+    unstack(token = null) {
+        let index = (token) ? this.findFormInStack(token).index : this.pageStack.length - 2;
+        let formInfo = null;
+        if (index >= 0) {
+            formInfo = this.pageStack[index];
+            this.pageStack.splice(index + 1);
+            this.saveStack();
+        }
+        return formInfo;
+    }
+    getFormInfo(token) {
+        var _a, _b;
+        const { data } = this.findFormInStack(token);
+        return {
+            token: data === null || data === void 0 ? void 0 : data.token,
+            subject: data === null || data === void 0 ? void 0 : data.subject,
+            state: data === null || data === void 0 ? void 0 : data.state,
+            originToken: data === null || data === void 0 ? void 0 : data.originToken,
+            fields: (_a = data === null || data === void 0 ? void 0 : data.fields) !== null && _a !== void 0 ? _a : {},
+            extra: (_b = data === null || data === void 0 ? void 0 : data.extra) !== null && _b !== void 0 ? _b : {}
+        };
+    }
+    openForm(origin, target) {
+        var _a;
+        (!origin) && this.cleanStack();
+        target.originToken = (_a = origin === null || origin === void 0 ? void 0 : origin.token) !== null && _a !== void 0 ? _a : null;
+        const token = this.stack(origin, target);
+        this.goToForm(target.name, token, target.subject);
+    }
+    backTo(targetToken = null) {
+        const formInfo = this.unstack(targetToken);
+        formInfo && formInfo.name && this.goToForm(formInfo.name, formInfo.token, formInfo.subject);
+    }
+}
+
+class LibEventManagerService {
+    constructor(eventNames) {
+        this.eventSubjects = {};
+        eventNames.forEach((name) => { this.addEventName(name); });
+    }
+    addEventName(name) {
+        if (!this.eventSubjects[name]) {
+            const newEventSubject = new ReplaySubject(1);
+            this.eventSubjects[name] = newEventSubject;
+        }
+    }
+    getEventNames() { return Object.keys(this.eventSubjects); }
+    getSubject(eventClassName) { return eventClassName ? this.eventSubjects[eventClassName] : null; }
+    subscribe(eventClassName, callback) { this.getSubject(eventClassName).subscribe(callback); }
+    next(eventClassName, data) { this.getSubject(eventClassName).next(data); }
+}
+
+class LibFileManagementService {
+    openFile(fileBase64Data, fileName, fileType) { }
+    saveFileFromURL(fileUrl, fullFileName = null) { }
+    saveFile(fileBase64Data, fileName, fileType) { }
+}
+
+const PAYLOAD_VERSION = 'TUAINEXCHANGE_1.0';
+const INLINE_ACTION = 'INLINE';
+const GLOBAL_ACTION = 'GLOBAL';
+const GET_DATA_ACTION = 'GETDATA';
+const SUBJECT = 'subject';
+const TOKEN = 'token';
+class BasicFormComponent {
+    constructor(formManagerService, _eventManager, fileMgmtServices) {
+        this.formManagerService = formManagerService;
+        this._eventManager = _eventManager;
+        this.fileMgmtServices = fileMgmtServices;
+        this._formStructure = null;
+        this._controlToken = null;
+        this._originToken = null;
+        this._formRoute = null;
+        this._definitionObtained = false;
+        // Eventos de acciones y campos
+        this._formSectionsActivate = {};
+        this._formSectionsInactivate = {};
+        this._formActionsStart = {};
+        this._formActionsFinish = {};
+        this._fieldInputValidation = {};
+        this._fieldValidationsStart = {};
+        this._fieldValidationsFinish = {};
+        // Callback de acciones de tablas
+        this._tableSelectionsStart = {};
+        this._tableSelectionsFinish = {};
+        this._tableActionsStart = {};
+        this._tableActionsFinish = {};
+        this._tableGetDataStart = {};
+        this._tableGetDataFinish = {};
+        this._actionServerError = [];
+        this._fieldServerError = [];
+        this._tableServerError = [];
+        this.inputDataFields = {};
+        this.extraData = {};
+        this.enabledSections = [];
+        this.name = null;
+        this.formSubject = null;
+        this._errorType = '';
+        this.errorCode = '';
+        this.errorFullCode = '';
+        this.errorName = '';
+        this.errorMessage = '';
+        this.errorDetail = '';
+        this.visible = false;
+        this.busy = false;
+        this._eventEmiter = this._eventManager;
+        this.cleanStart();
+        this.customPreProcessing();
+    }
+    getTitle() { var _a; return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.getTitle(); }
+    setTitle(title) { var _a; return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.setTitle(title); }
+    cleanData() { var _a; return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.cleanData(); }
+    getCurrentState() { var _a; return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.getCurrentState(); }
+    supportState(state) { var _a, _b; return (_b = (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.supportState(state !== null && state !== void 0 ? state : '')) !== null && _b !== void 0 ? _b : false; }
+    changeState(state) { var _a, _b; return (_b = (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.changeState(state)) !== null && _b !== void 0 ? _b : false; }
+    getStates() { var _a; return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.states; }
+    getImmutableElement(name) { var _a; return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.getImmutableElement(name); }
+    getExtraInfo(name) { var _a; return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.getExtraInfo(name); }
+    getFields() { var _a, _b; return (_b = (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.getFields()) !== null && _b !== void 0 ? _b : null; }
+    getFieldNames() { var _a, _b; return (_b = (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.getFieldNames()) !== null && _b !== void 0 ? _b : null; }
+    getField(code) { var _a, _b; return (_b = (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.getField(code)) !== null && _b !== void 0 ? _b : null; }
+    enableField(code) { var _a; return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.enableField(code); }
+    disableField(code) { var _a; return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.disableField(code); }
+    getFieldValue(code) { var _a, _b; return (_b = (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.getFieldValue(code)) !== null && _b !== void 0 ? _b : null; }
+    getFieldOptionText(code) { var _a; return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.getFieldOptionText(code); }
+    getFieldsValues(codes) { var _a, _b; return (_b = (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.getFieldsValues(codes)) !== null && _b !== void 0 ? _b : null; }
+    getFieldOptions(code) { var _a, _b; return (_b = (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.getFieldOptions(code)) !== null && _b !== void 0 ? _b : null; }
+    setFieldValue(code, value) { var _a; return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.setFieldValue(code, value); }
+    setFieldRequired(code, required) { var _a; return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.setFieldRequired(code, required); }
+    setFieldErrorMessage(code, errorMessage) { var _a; return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.setFieldErrorMessage(code, errorMessage); }
+    setFieldError(code, errorCode, message, type) { var _a; return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.setFieldError(code, errorCode, message, type); }
+    setFieldIntrinsicErrorMessage(code, message) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.setFieldIntrinsicErrorMessage(code, message);
+    }
+    setFieldOptions(code, optionsArray, idAttribute, nameAttribute) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.setFieldOptions(code, optionsArray, idAttribute, nameAttribute);
+    }
+    getFieldSet(filterFunc, codes, secCode, subCode) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.getFieldSet(filterFunc, codes !== null && codes !== void 0 ? codes : null, secCode !== null && secCode !== void 0 ? secCode : null, subCode !== null && subCode !== void 0 ? subCode : null);
+    }
+    applyOnFields(processFunc, codes, secCode, subCode) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.applyOnFields(processFunc, codes, secCode, subCode);
+    }
+    applyProcessToAllFields(processFunc) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.applyOnFields(processFunc);
+    }
+    cleanFields(codes, secCode, subCode) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.cleanFields(codes, secCode, subCode);
+    }
+    getRequiredFields(codes, secCode, subCode) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.getRequiredFields(codes, secCode, subCode);
+    }
+    getRequiredEmptyFields(codes, secCode, subCode) {
+        var _a, _b;
+        return (_b = (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.getRequiredEmptyFields(codes, secCode, subCode)) !== null && _b !== void 0 ? _b : null;
+    }
+    getChangedFields(codes, secCode, subCode) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.getChangedFields(codes, secCode, subCode);
+    }
+    getFieldsWithValidationIssues(codes, secCode, subCode) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.getFieldsWithValidationIssues(codes, secCode, subCode);
+    }
+    tagFieldsWithError(errorMessage, codes, secCode, subCode) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.tagFieldsWithError(errorMessage, codes, secCode, subCode);
+    }
+    cleanErrorFields(codes, secCode, subCode) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.cleanErrorFields(codes, secCode, subCode);
+    }
+    showLabelFields(codes, secCode, subCode) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.showLabelFields(codes, secCode, subCode);
+    }
+    hideLabelFields(codes, secCode, subCode) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.hideLabelFields(codes, secCode, subCode);
+    }
+    enableFields(codes, secCode, subCode) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.enableFields(codes, secCode, subCode);
+    }
+    disableFields(codes, secCode, subCode) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.disableFields(codes, secCode, subCode);
+    }
+    /**
+     * @deprecated Use enableFields
+     */
+    enableEditFields(codes, secCode, subCode) {
+        return this.enableFields(codes, secCode, subCode);
+    }
+    /**
+     * @deprecated Use disableFields
+     */
+    disableEditFields(codes, secCode, subCode) {
+        return this.disableFields(codes, secCode, subCode);
+    }
+    showFields(codes, secCode, subCode) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.showFields(codes, secCode, subCode);
+    }
+    hideFields(codes, secCode, subCode) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.hideFields(codes, secCode, subCode);
+    }
+    getActionsByAttribute(name, value) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.getActionsByAttribute(name, value);
+    }
+    getHeaderActions() {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.getActionsByAttribute('location', HEADER$1);
+    }
+    getAction(actionCode) {
+        var _a, _b;
+        return (_b = (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.getAction(actionCode)) !== null && _b !== void 0 ? _b : null;
+    }
+    showActions(actionArray) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.showActions(actionArray);
+    }
+    hideActions(actionArray) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.hideActions(actionArray);
+    }
+    enableActions(actionArray) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.enableActions(actionArray);
+    }
+    disableActions(actionArray) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.disableActions(actionArray);
+    }
+    showAction(code) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.showActions(code);
+    }
+    hideAction(code) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.hideActions(code);
+    }
+    enableAction(code) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.enableActions(code);
+    }
+    disableAction(code) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.disableActions(code);
+    }
+    getSections() {
+        var _a, _b;
+        return (_b = (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.getSections()) !== null && _b !== void 0 ? _b : null;
+    }
+    activateSection(code) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.activateSection(code);
+    }
+    getSectionsTitles() {
+        var _a, _b;
+        return (_b = (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.getSections().map(sec => sec.title)) !== null && _b !== void 0 ? _b : null;
+    }
+    getSection(code) {
+        var _a, _b;
+        return (_b = (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.getSection(code)) !== null && _b !== void 0 ? _b : null;
+    }
+    showSection(code) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.showSections(code);
+    }
+    hideSection(code) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.hideSections(code);
+    }
+    showSections(codes) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.showSections(codes);
+    }
+    hideSections(codes) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.hideSections(codes);
+    }
+    getSubSection(code, subCode) {
+        var _a, _b;
+        return (_b = (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.getSubSection(code, subCode)) !== null && _b !== void 0 ? _b : null;
+    }
+    showSubSection(code, subCode) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.showSubSections(code, subCode);
+    }
+    hideSubSection(code, subCode) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.hideSubSections(code, subCode);
+    }
+    showSubSections(code, subCodes) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.showSubSections(code, subCodes);
+    }
+    hideSubSections(code, subCodes) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.hideSubSections(code, subCodes);
+    }
+    getSectionActions(code) {
+        var _a, _b;
+        return (_b = (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.getSectionActions(code)) !== null && _b !== void 0 ? _b : null;
+    }
+    getSectionActionNames(code) {
+        var _a, _b;
+        return (_b = (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.getSectionActionNames(code)) !== null && _b !== void 0 ? _b : null;
+    }
+    getTables() {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.getTables();
+    }
+    showTables(codes) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.showTables(codes);
+    }
+    hideTables(codes) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.hideTables(codes);
+    }
+    cleanTables(codes) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.cleanTables(codes);
+    }
+    getTable(code) {
+        var _a, _b;
+        return (_b = (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.getTable(code)) !== null && _b !== void 0 ? _b : null;
+    }
+    showTable(code) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.showTables(code);
+    }
+    hideTable(code) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.hideTables(code);
+    }
+    cleanTable(code) {
+        var _a, _b;
+        return (_b = (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.getTable(code)) === null || _b === void 0 ? void 0 : _b.clean();
+    }
+    getTableRecord(code, recordId) {
+        var _a;
+        return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.getTableRecord(code, recordId);
+    }
+    setConfig(formConfig) {
+        this.formConfig = formConfig;
+    }
+    cleanStart() {
+        this._errorType = '';
+        this.errorCode = '';
+        this.errorFullCode = '';
+        this.errorName = '';
+        this.errorMessage = '';
+        this.errorDetail = '';
+        this._formStructure = null;
+        this.fields = null;
+        this.actions = null;
+        this.sections = null;
+        this._controlToken = null;
+        this.inputDataFields = {};
+        this._definitionObtained = false;
+        // Se limpian los manejadores de eventos
+        this.visible = false;
+        this.busy = false;
+        this._formSectionsActivate = {};
+        this._formSectionsInactivate = {};
+        this._formActionsStart = {};
+        this._formActionsFinish = {};
+        this._fieldInputValidation = {};
+        this._fieldValidationsStart = {};
+        this._fieldValidationsFinish = {};
+        this._tableSelectionsStart = {};
+        this._tableSelectionsFinish = {};
+        this._tableActionsStart = {};
+        this._tableActionsFinish = {};
+        this._tableGetDataStart = {};
+        this._tableGetDataFinish = {};
+        this._actionServerError = [];
+        this._fieldServerError = [];
+        this._tableServerError = [];
+        this.onActionServerError(() => this.displayActionServerError());
+        this.onValidationServerError(() => this.displayValidationServerError());
+        this.onTableServerError(() => this.displayTableServerError());
+    }
+    get formVisible() { return this.visible; }
+    get formManager() { return this; }
+    get formCode() { var _a; return (_a = this.name) !== null && _a !== void 0 ? _a : ''; }
+    set formCode(name) { this.name = name; }
+    get inServerProcess() { return this.busy; }
+    get form() { return this._formStructure; }
+    get state() { var _a, _b; return (_b = (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.state) !== null && _b !== void 0 ? _b : null; }
+    get currentState() { var _a, _b; return (_b = (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.state) !== null && _b !== void 0 ? _b : ''; }
+    set currentState(state) { var _a; (_a = this === null || this === void 0 ? void 0 : this._formStructure) === null || _a === void 0 ? void 0 : _a.changeState(state); }
+    get immutableData() { var _a; return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.immutableData; }
+    get extraInfo() { var _a; return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.extraInfo; }
+    get visibleSections() { var _a, _b; return (_b = (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.visibleSections) !== null && _b !== void 0 ? _b : null; }
+    get formRoute() { var _a; return (_a = this._formRoute) !== null && _a !== void 0 ? _a : ''; }
+    set formRoute(route) { this._formRoute = route; }
+    get subject() { var _a; return (_a = this.formSubject) !== null && _a !== void 0 ? _a : ''; }
+    // Métodos virtuales
+    customPreProcessing() { }
+    customFormStart() { }
+    displayActionServerError() { }
+    displayValidationServerError() { }
+    displayTableServerError() { }
+    showFieldInfo(fieldCode, detail) { }
+    showModalDialog(title, body, options, callback, params) { }
+    openUploadDialog(title, body, options, callback, params) { }
+    /**
+     * @deprecated Use supportState
+     */
+    supportMode(state) { return this.supportState(state); }
+    /**
+     * @deprecated Use getField
+     */
+    getFieldObject(code) { return this.getField(code); }
+    /**
+     * @deprecated Use getAction
+     */
+    getActionObject(code) { return this.getAction(code); }
+    /**
+     * @deprecated Use getTable
+     */
+    getTableObject(code) { return this.getTable(code); }
+    /**
+     * @deprecated Use getSection
+     */
+    getSectionObject(code) { return this.getSection(code); }
+    /**
+     * @deprecated Use changeState
+     */
+    changeFormMode(state) { return this.changeState(state); }
+    /**
+     * @deprecated Use subject
+     */
+    getFormSubject() { return this.subject; }
+    /**
+     * @deprecated Use subject
+     */
+    getSubject() { var _a; return (_a = this.formSubject) !== null && _a !== void 0 ? _a : ''; }
+    /**
+     * @deprecated Use subject
+     */
+    getformSubject() { var _a; return (_a = this.formSubject) !== null && _a !== void 0 ? _a : ''; }
+    numSections() { var _a; return (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.sections.length; }
+    subscribeAppEvent(eventName, callback) {
+        this._eventEmiter.subscribe(eventName, callback);
+    }
+    openForm(name, data = null, backData = null, cleanStack = false) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        let origin = null;
+        if (!cleanStack) {
+            origin = Object.assign(Object.assign({}, backData), { name: this.name, url: this._formRoute, token: this._controlToken });
+            origin.subject = (_a = origin === null || origin === void 0 ? void 0 : origin.subject) !== null && _a !== void 0 ? _a : this.formSubject;
+            origin.state = (_b = origin === null || origin === void 0 ? void 0 : origin.state) !== null && _b !== void 0 ? _b : this.state;
+            origin.fields = (_c = origin === null || origin === void 0 ? void 0 : origin.fields) !== null && _c !== void 0 ? _c : {};
+            origin.extra = (_d = origin === null || origin === void 0 ? void 0 : origin.extra) !== null && _d !== void 0 ? _d : {};
+        }
+        const target = Object.assign(Object.assign({}, data), { name });
+        target.subject = (_e = target === null || target === void 0 ? void 0 : target.subject) !== null && _e !== void 0 ? _e : null;
+        target.state = (_f = target === null || target === void 0 ? void 0 : target.state) !== null && _f !== void 0 ? _f : null;
+        target.fields = (_g = target === null || target === void 0 ? void 0 : target.fields) !== null && _g !== void 0 ? _g : {};
+        target.extra = (_h = target === null || target === void 0 ? void 0 : target.extra) !== null && _h !== void 0 ? _h : {};
+        this.formManagerService.openForm(origin, target);
+    }
+    canGoBack() { return this._originToken !== null; }
+    goBack() { return this.formManagerService.backTo(); }
+    goBackForm() { return this.goBack(); }
+    getOriginDetail() { var _a, _b; return (_a = this.formManagerService) === null || _a === void 0 ? void 0 : _a.getFormInfo((_b = this._originToken) !== null && _b !== void 0 ? _b : ''); }
+    setError(errorType, errorMessage, errorDetail) {
+        this._errorType = errorType || '';
+        this.errorMessage = errorMessage || '';
+        this.errorDetail = errorDetail || '';
+    }
+    resetError() {
+        this.errorCode = NO_ERROR;
+        this.errorFullCode = '';
+        this.errorName = '';
+        this.errorMessage = '';
+        this.errorDetail = '';
+    }
+    getErrorType() { return this._errorType; }
+    getErrorMessage() { return this.errorMessage; }
+    getErrorDetail() { return this.errorDetail; }
+    getErrorName() { return this.errorName; }
+    getErrorFullCode() { return this.errorFullCode; }
+    getErrorCode() { return this.errorCode; }
+    getFormParameter(name) {
+        var _a, _b;
+        return (name) ? ((_b = (_a = this.extraData) === null || _a === void 0 ? void 0 : _a[name]) !== null && _b !== void 0 ? _b : null) : null;
+    }
+    preocessInputParams(params) {
+        var _a, _b, _c, _d;
+        this._controlToken = (_a = params === null || params === void 0 ? void 0 : params[TOKEN]) !== null && _a !== void 0 ? _a : null;
+        this.formSubject = (_b = params === null || params === void 0 ? void 0 : params[SUBJECT]) !== null && _b !== void 0 ? _b : null;
+        const tokenInfo = (this._controlToken) ? this.formManagerService.getFormInfo(this._controlToken) : {};
+        const { token, subject, state, fields, extra, originToken } = tokenInfo;
+        if (token && this._controlToken === token) {
+            this.formSubject = (_d = (_c = this.formSubject) !== null && _c !== void 0 ? _c : subject) !== null && _d !== void 0 ? _d : null;
+            this.inputDataFields = fields;
+            this.extraData = extra;
+            this._originToken = originToken;
+            return state;
+        }
+        return null;
+    }
+    subscribeSectionActivation() {
+        var _a;
+        const formSections = (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.sections;
+        const sectionNames = Object.keys(formSections);
+        for (let index = 0; index < sectionNames.length; index++) {
+            const sectionName = sectionNames[index];
+            const section = formSections[sectionName];
+            section.activation.subscribe((code) => this.launchSectionActivation(code));
+            section.inactivation.subscribe((code) => this.launchSectionInactivation(code));
+        }
+    }
+    subscribeFieldsSubjects() {
+        var _a;
+        const formFields = (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.getFields();
+        if (Array.isArray(formFields)) {
+            formFields.forEach(field => {
+                field.editionFinish.subscribe(event => {
+                    const { code, intrinsicValidation } = event;
+                    this.startFieldValidation(code, intrinsicValidation);
+                });
+                field.editionPartial.subscribe(event => {
+                    const { code, intrinsicValidation } = event;
+                    this.startFieldInputValidation(code, intrinsicValidation);
+                });
+                field.detailRequest.subscribe(event => this.showFieldInfo(event.code, event.detail));
+            });
+        }
+    }
+    subscribeActionSubjects() {
+        var _a;
+        const formActions = (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.getActions();
+        if (Array.isArray(formActions)) {
+            formActions.forEach(action => {
+                action.actionActivated.subscribe(code => this.startAction(code));
+            });
+        }
+    }
+    subscribeTableSubjects() {
+        var _a;
+        const formTables = (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.getTables();
+        if (Array.isArray(formTables)) {
+            formTables.forEach(table => {
+                table.inlineActionTrigger.subscribe(event => this.startTableAction(event));
+                table.globalActionTrigger.subscribe(event => this.startTableGlobalAction(event));
+                table.recordSelectionTrigger.subscribe(event => this.startTableRecordSelection(event));
+                table.selectionActionTrigger.subscribe(event => this.startTableSelectionAction(event));
+                table.getDataTrigger.subscribe(event => this.startTableGetData(event));
+            });
+        }
+    }
+    formInit(params) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        return __awaiter(this, void 0, void 0, function* () {
+            let initialState = this.preocessInputParams(params);
+            if (!this.name) {
+                return;
+            }
+            if (!this._definitionObtained) {
+                this.busy = true;
+                const formDefinition = yield this.formManagerService.getFormDefinition(this.name);
+                this.busy = false;
+                this._formStructure = new FormStructureAndData(formDefinition, this.formConfig);
+                this.fields = (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.fields;
+                this.actions = (_b = this._formStructure) === null || _b === void 0 ? void 0 : _b.actions;
+                this.sections = (_c = this._formStructure) === null || _c === void 0 ? void 0 : _c.sections;
+                this._definitionObtained = true;
+            }
+            else {
+                this.cleanData();
+            }
+            if (!this.supportState(initialState)) {
+                initialState = (_e = (_d = this._formStructure) === null || _d === void 0 ? void 0 : _d.defaultState) !== null && _e !== void 0 ? _e : null;
+            }
+            (_f = this._formStructure) === null || _f === void 0 ? void 0 : _f.changeState(initialState || ((_g = this._formStructure) === null || _g === void 0 ? void 0 : _g.defaultState));
+            const inputFieldNames = Object.keys(this.inputDataFields);
+            for (let index = 0; index < inputFieldNames.length; index++) {
+                const fieldCode = inputFieldNames[index];
+                const fieldValue = this.inputDataFields[fieldCode];
+                this.setFieldValue(fieldCode, fieldValue);
+            }
+            const recordResponse = yield this.requestFormAction(formActions.getData);
+            this.checkErrorRecordReceived(recordResponse);
+            this.visible = true;
+            this.enabledSections = (_j = (_h = this._formStructure) === null || _h === void 0 ? void 0 : _h.visibleSections) !== null && _j !== void 0 ? _j : [];
+            this.subscribeSectionActivation();
+            this.subscribeFieldsSubjects();
+            this.subscribeActionSubjects();
+            this.subscribeTableSubjects();
+            this.customFormStart();
+        });
+    }
+    checkErrorRecordReceived(recordResponse) {
+        const { error } = recordResponse;
+        if (!error) {
+            return false;
+        }
+        this.errorCode = recordResponse.errorCode;
+        this.errorFullCode = recordResponse.errorFullCode;
+        this.errorName = recordResponse.errorName;
+        this.errorMessage = recordResponse.errorMessage;
+        this.errorDetail = recordResponse.errorDetail;
+        return true;
+    }
+    errorOccured() {
+        return (this.errorCode !== NO_ERROR);
+    }
+    /**
+     * Soporte manejo de eventos de formulario
+     */
+    requestFormAction(actionCode, actionSubject = {}) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            const actionDetail = {
+                formCode: this.name,
+                formSubject: this.formSubject,
+                currentMode: (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.state,
+                actionCode,
+                actionSubject,
+                version: PAYLOAD_VERSION,
+                formData: (_b = this._formStructure) === null || _b === void 0 ? void 0 : _b.getPayload(),
+                immutableData: (_c = this._formStructure) === null || _c === void 0 ? void 0 : _c.immutableData,
+            };
+            this.errorCode = NO_ERROR;
+            this.errorFullCode = '';
+            this.errorName = '';
+            this.errorMessage = '';
+            this.errorDetail = '';
+            this.busy = true;
+            const formActionResponse = yield this.formManagerService.execServerAction(actionDetail);
+            this.busy = false;
+            if (formActionResponse.hasError()) {
+                const error = formActionResponse.error;
+                this.errorCode = error.errorCode;
+                this.errorFullCode = error.errorFullCode;
+                this.errorName = error.errorName;
+                this.errorMessage = error.errorMessage;
+                this.errorDetail = error.errorDetail;
+            }
+            const formResponseData = formActionResponse.getData();
+            this.updateFormWithServerData(formResponseData);
+            return formResponseData;
+        });
+    }
+    updateFormWithServerData(formContent) {
+        const { currentMode, formSubject, actions, fields, recordTables, returnedFile, immutableData, extraInfo, } = formContent;
+        currentMode && this.changeState(currentMode);
+        if (formSubject) {
+            this.formSubject = formSubject;
+        }
+        if (actions && actions.length > 0) {
+            for (const changedAction of actions) {
+                const actionObject = this.getAction(changedAction.actionCode);
+                if (actionObject) {
+                    actionObject.updateFromServer(changedAction);
+                }
+            }
+        }
+        if (fields && fields.length > 0) {
+            for (const changedField of fields) {
+                const fieldObject = this.getField(changedField.fieldCode);
+                if (fieldObject) {
+                    fieldObject.updateFromServer(changedField);
+                }
+            }
+        }
+        if (recordTables && recordTables.length > 0) {
+            for (const changedTable of recordTables) {
+                const tableObject = this.getTable(changedTable.tableCode);
+                if (tableObject) {
+                    tableObject.updateFromServer(changedTable);
+                }
+            }
+        }
+        if (returnedFile && returnedFile.file) {
+            this.fileMgmtServices.saveFile(returnedFile.file, returnedFile.name, returnedFile.type);
+        }
+        if (this._formStructure) {
+            this._formStructure.immutableData = immutableData;
+            this._formStructure.extraInfo = extraInfo;
+        }
+    }
+    /**
+     * Manejo de event handlers para errores Server del formulario
+     */
+    cleanActionServerError() {
+        this._actionServerError = [];
+    }
+    cleanFieldServerError() {
+        this._fieldServerError = [];
+    }
+    cleanTableServerError() {
+        this._tableServerError = [];
+    }
+    onActionServerError(callback, properties = null) {
+        this._actionServerError.push({ callback, properties });
+    }
+    onValidationServerError(callback, properties = null) {
+        this._fieldServerError.push({ callback, properties });
+    }
+    onTableServerError(callback, properties = null) {
+        this._tableServerError.push({ callback, properties });
+    }
+    /**
+     * Manejo de event handlers para acciones sobre el formulario
+     */
+    onSectionActivation(codes, callback, properties = null) {
+        const sectionSet = (Array.isArray(codes)) ? codes : (codes ? [codes] : []);
+        sectionSet.forEach((sectionName) => {
+            if (!this._formSectionsActivate[sectionName]) {
+                this._formSectionsActivate[sectionName] = [];
+            }
+            this._formSectionsActivate[sectionName].push({ callback, properties });
+        });
+    }
+    onSectionInactivation(codes, callback, properties = null) {
+        const sectionSet = (Array.isArray(codes)) ? codes : (codes ? [codes] : []);
+        sectionSet.forEach((sectionName) => {
+            if (!this._formSectionsInactivate[sectionName]) {
+                this._formSectionsInactivate[sectionName] = [];
+            }
+            this._formSectionsInactivate[sectionName].push({ callback, properties });
+        });
+    }
+    onActionStart(codes, callback, properties = null) {
+        const actionSet = (Array.isArray(codes)) ? codes : (codes ? [codes] : []);
+        actionSet.forEach((actionName) => {
+            if (!this._formActionsStart[actionName]) {
+                this._formActionsStart[actionName] = [];
+            }
+            this._formActionsStart[actionName].push({ callback, properties });
+        });
+    }
+    onActionFinish(codes, callback, properties = null) {
+        const actionSet = (Array.isArray(codes)) ? codes : (codes ? [codes] : []);
+        actionSet.forEach((actionName) => {
+            if (!this._formActionsFinish[actionName]) {
+                this._formActionsFinish[actionName] = [];
+            }
+            this._formActionsFinish[actionName].push({ callback, properties });
+        });
+    }
+    launchSectionActivation(code) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const sectionObject = (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.getSection(code);
+            if (!sectionObject) {
+                return;
+            }
+            const clientSectionMethods = this._formSectionsActivate[code];
+            if (clientSectionMethods) {
+                for (const clientSectionMethod of clientSectionMethods) {
+                    const { callback, properties } = clientSectionMethod;
+                    callback(sectionObject);
+                }
+            }
+        });
+    }
+    launchSectionInactivation(code) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const sectionObject = (_a = this._formStructure) === null || _a === void 0 ? void 0 : _a.getSection(code);
+            if (!sectionObject) {
+                return;
+            }
+            const clientSectionMethods = this._formSectionsInactivate[code];
+            if (clientSectionMethods) {
+                for (const clientSectionMethod of clientSectionMethods) {
+                    const { callback, properties } = clientSectionMethod;
+                    callback(sectionObject);
+                }
+            }
+        });
+    }
+    startAction(code) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const actionObject = this.getAction(code);
+            if (!actionObject) {
+                return;
+            }
+            this.resetError();
+            actionObject.start();
+            const clientActionMethods = this._formActionsStart[code];
+            if (clientActionMethods) {
+                const clientActionPromises = [];
+                for (const clientActionMethod of clientActionMethods) {
+                    const { callback, properties } = clientActionMethod;
+                    const continueActionPromise = callback(actionObject);
+                    clientActionPromises.push(continueActionPromise);
+                }
+                const clientActionResults = yield Promise.all(clientActionPromises);
+                const continueAction = clientActionResults.reduce((total, curr) => (total && (curr !== false)), true);
+                if (!continueAction) {
+                    actionObject.stop();
+                    return;
+                }
+            }
+            this.startServerAction(actionObject);
+        });
+    }
+    startServerAction(actionInput) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const action = (typeof actionInput === 'string')
+                ? this.getAction(actionInput) : actionInput;
+            let serverError = false;
+            let actionResult = null;
+            if (action.backend) {
+                actionResult = yield this.requestFormAction(action.actionCode);
+                serverError = !!this.errorOccured();
+            }
+            yield this.finishAction(action, actionResult, serverError);
+            if (!serverError) {
+                action.newState && this.changeState(action.newState);
+            }
+            else {
+                for (let index = 0; index < this._actionServerError.length; index++) {
+                    const { callback, properties } = this._actionServerError[index];
+                    callback(action);
+                }
+            }
+            action.stop();
+        });
+    }
+    finishAction(action, actionResult, serverError = false) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const finishActionMethods = this._formActionsFinish[action.actionCode];
+            if (finishActionMethods) {
+                const clientActionPromises = [];
+                for (const clientActionMethod of finishActionMethods) {
+                    const { callback, properties } = clientActionMethod;
+                    const continueOnError = (_a = properties === null || properties === void 0 ? void 0 : properties.continueOnError) !== null && _a !== void 0 ? _a : false;
+                    if (!serverError || continueOnError) {
+                        clientActionPromises.push(callback(action, actionResult));
+                    }
+                }
+                yield Promise.all(clientActionPromises);
+            }
+        });
+    }
+    completeGlobalAction(action) {
+        return this.startServerAction(action);
+    }
+    /**
+     * Manejadores de eventos para validaciones sobre campos
+     */
+    onFieldInput(codes, callback, properties = null) {
+        const fieldSet = (Array.isArray(codes)) ? codes : (codes ? [codes] : []);
+        fieldSet.forEach((fieldCode) => {
+            if (!this._fieldInputValidation[fieldCode]) {
+                this._fieldInputValidation[fieldCode] = [];
+            }
+            this._fieldInputValidation[fieldCode].push({ callback, properties });
+        });
+    }
+    onFieldValidationStart(codes, callback, properties = null) {
+        const fieldSet = (Array.isArray(codes)) ? codes : (codes ? [codes] : []);
+        fieldSet.forEach((fieldCode) => {
+            if (!this._fieldValidationsStart[fieldCode]) {
+                this._fieldValidationsStart[fieldCode] = [];
+            }
+            this._fieldValidationsStart[fieldCode].push({ callback, properties });
+        });
+    }
+    onFieldValidationFinish(codes, callback, properties = null) {
+        const fieldSet = (Array.isArray(codes)) ? codes : (codes ? [codes] : []);
+        fieldSet.forEach((fieldCode) => {
+            if (!this._fieldValidationsFinish[fieldCode]) {
+                this._fieldValidationsFinish[fieldCode] = [];
+            }
+            this._fieldValidationsFinish[fieldCode].push({ callback, properties });
+        });
+    }
+    startFieldInputValidation(fieldCode, intrinsicValidation = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fieldToValidate = this.getField(fieldCode);
+            if (!fieldToValidate) {
+                return false;
+            }
+            fieldToValidate.resetError();
+            const validationCallbacks = this._fieldInputValidation[fieldCode];
+            if (validationCallbacks) {
+                const clientValidationPromises = [];
+                for (const validationMethod of validationCallbacks) {
+                    const { callback, properties } = validationMethod;
+                    const continueValidationPromise = callback(fieldToValidate);
+                    clientValidationPromises.push(continueValidationPromise);
+                }
+                yield Promise.all(clientValidationPromises);
+            }
+            return true;
+        });
+    }
+    startFieldValidation(fieldCode, intrinsicValidation = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fieldToValidate = this.getField(fieldCode);
+            if (!fieldToValidate) {
+                return;
+            }
+            fieldToValidate.resetError();
+            const validationCallbacks = this._fieldValidationsStart[fieldCode];
+            if (validationCallbacks) {
+                const clientValidationPromises = [];
+                for (const validationMethod of validationCallbacks) {
+                    const { callback, properties } = validationMethod;
+                    const clientValidationPromise = callback(fieldToValidate);
+                    clientValidationPromises.push(clientValidationPromise);
+                }
+                const clientValidationResults = yield Promise.all(clientValidationPromises);
+                const continueValidation = clientValidationResults.reduce((total, curr) => (total && (curr !== false)), true);
+                if (!continueValidation) {
+                    return;
+                }
+            }
+            if (intrinsicValidation) {
+                this.startServerFieldValidation(fieldToValidate);
+            }
+        });
+    }
+    startServerFieldValidation(inputField) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fieldObj = (typeof inputField === 'string')
+                ? this.getField(inputField) : inputField;
+            let serverError = false;
+            let validationResult = true;
+            if (!fieldObj) {
+                return;
+            }
+            if (fieldObj.backend) {
+                fieldObj.validating = true;
+                validationResult = yield this
+                    .requestFormAction(formActions.validate, fieldObj.fieldCode);
+                serverError = !!this.errorOccured();
+            }
+            yield this.finishFieldValidation(fieldObj, validationResult, serverError);
+            if (serverError) {
+                fieldObj === null || fieldObj === void 0 ? void 0 : fieldObj.setErrorCode(this.errorCode);
+                fieldObj === null || fieldObj === void 0 ? void 0 : fieldObj.setErrorMessage(this.errorMessage);
+                for (let index = 0; index < this._fieldServerError.length; index++) {
+                    const { callback, properties } = this._fieldServerError[index];
+                    callback(fieldObj);
+                }
+            }
+            fieldObj.validating = false;
+        });
+    }
+    finishFieldValidation(fieldObject, validationResult, serverError = false) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const validationCallbacks = this._fieldValidationsFinish[fieldObject.fieldCode];
+            if (validationCallbacks) {
+                const clientActionPromises = [];
+                for (const validationMethod of validationCallbacks) {
+                    const { callback, properties } = validationMethod;
+                    const continueOnError = (_a = properties === null || properties === void 0 ? void 0 : properties.continueOnError) !== null && _a !== void 0 ? _a : false;
+                    if (!serverError || continueOnError) {
+                        clientActionPromises.push(callback(fieldObject, validationResult));
+                    }
+                }
+                yield Promise.all(clientActionPromises);
+            }
+        });
+    }
+    continueFieldValidation(fieldCode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.startServerFieldValidation(fieldCode);
+        });
+    }
+    /**
+     * Manejadores de eventos para acciones sobre Tablas
+     */
+    onTableActionStart(code, actionCode, callback, properties = null) {
+        const tableObject = this.getTable(code);
+        if (!tableObject) {
+            return;
+        }
+        const inlineActionObject = tableObject.getAction(actionCode);
+        if (!inlineActionObject) {
+            return;
+        }
+        let tableEventHandlers;
+        if (this._tableActionsStart[code]) {
+            tableEventHandlers = this._tableActionsStart[code];
+        }
+        else {
+            tableEventHandlers = {};
+            this._tableActionsStart[code] = tableEventHandlers;
+        }
+        if (!tableEventHandlers[actionCode]) {
+            tableEventHandlers[actionCode] = [];
+        }
+        tableEventHandlers[actionCode].push({ callback, properties });
+    }
+    onTableActionFinish(code, actionCode, callback, properties = null) {
+        const tableObject = this.getTable(code);
+        if (!tableObject) {
+            return;
+        }
+        const inlineActionObject = tableObject.getAction(actionCode);
+        if (!inlineActionObject) {
+            return;
+        }
+        let tableEventHandlers;
+        if (this._tableActionsFinish[code]) {
+            tableEventHandlers = this._tableActionsFinish[code];
+        }
+        else {
+            tableEventHandlers = {};
+            this._tableActionsFinish[code] = tableEventHandlers;
+        }
+        if (!tableEventHandlers[actionCode]) {
+            tableEventHandlers[actionCode] = [];
+        }
+        tableEventHandlers[actionCode].push({ callback, properties });
+    }
+    onTableSelectionStart(code, callback, properties = null) {
+        const tableObject = this.getTable(code);
+        if (!tableObject) {
+            return;
+        }
+        let tableEventHandlers;
+        if (this._tableSelectionsStart[code]) {
+            tableEventHandlers = this._tableSelectionsStart[code];
+        }
+        else {
+            tableEventHandlers = [];
+            this._tableSelectionsStart[code] = tableEventHandlers;
+        }
+        tableEventHandlers.push({ callback, properties });
+    }
+    onTableSelectionFinish(code, callback, properties = null) {
+        const tableObject = this.getTable(code);
+        if (!tableObject) {
+            return;
+        }
+        let tableEventHandlers;
+        if (this._tableSelectionsFinish[code]) {
+            tableEventHandlers = this._tableSelectionsFinish[code];
+        }
+        else {
+            tableEventHandlers = [];
+            this._tableSelectionsFinish[code] = tableEventHandlers;
+        }
+        tableEventHandlers.push({ callback, properties });
+    }
+    onTableGetDataStart(code, callback, properties = null) {
+        const tableObject = this.getTable(code);
+        if (!tableObject) {
+            return;
+        }
+        let tableEventHandlers;
+        if (this._tableGetDataStart[code]) {
+            tableEventHandlers = this._tableGetDataStart[code];
+        }
+        else {
+            tableEventHandlers = [];
+            this._tableGetDataStart[code] = tableEventHandlers;
+        }
+        tableEventHandlers.push({ callback, properties });
+    }
+    onTableGetDataFinish(code, callback, properties = null) {
+        const tableObject = this.getTable(code);
+        if (!tableObject) {
+            return;
+        }
+        let tableEventHandlers;
+        if (this._tableGetDataFinish[code]) {
+            tableEventHandlers = this._tableGetDataFinish[code];
+        }
+        else {
+            tableEventHandlers = {};
+            this._tableGetDataFinish[code] = tableEventHandlers;
+        }
+        tableEventHandlers[GET_DATA_ACTION] = { callback, properties };
+    }
+    startTableGlobalAction(tableActionEvent) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { tableCode, actionCode } = tableActionEvent;
+            const tableObject = this.getTable(tableCode);
+            if (!tableObject || !actionCode) {
+                return;
+            }
+            this.resetError();
+            const action = tableObject.getAction(actionCode);
+            if (!action) {
+                return;
+            }
+            const tableActionDetail = {
+                tableObject,
+                action,
+                tableCode,
+                actionCode,
+            };
+            const tableEventHandlers = this._tableActionsStart[tableCode];
+            const tableActionMethods = (tableEventHandlers) ? tableEventHandlers[actionCode] : null;
+            if (tableActionMethods) {
+                const clientActionPromises = [];
+                for (const tableActionMethod of tableActionMethods) {
+                    const { callback, properties } = tableActionMethod;
+                    const clientActionPromise = callback(tableActionDetail);
+                    clientActionPromises.push(clientActionPromise);
+                }
+                const clientActionResults = yield Promise.all(clientActionPromises);
+                const continueAction = clientActionResults.reduce((total, curr) => (total && (curr !== false)), true);
+                if (!continueAction) {
+                    return;
+                }
+            }
+            this.startTableServerGlobalAction(tableActionDetail);
+        });
+    }
+    startTableServerGlobalAction(tableActionDetail) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { tableObject, action, tableCode, actionCode } = tableActionDetail;
+            if (!tableObject || !action) {
+                return;
+            }
+            tableObject.putOnWait();
+            let serverError = false;
+            let actionResult = null;
+            if (action.backend) {
+                const actionSubject = {
+                    tableCode,
+                    actionType: GLOBAL_ACTION,
+                    actionCode
+                };
+                actionResult = yield this
+                    .requestFormAction(formActions.tableAction, actionSubject);
+                serverError = !!this.errorOccured();
+            }
+            yield this.finishTableGlobalAction(tableActionDetail, actionResult, serverError);
+            if (!serverError) {
+                action.newState && this.changeState(action.newState);
+            }
+            else {
+                for (let index = 0; index < this._tableServerError.length; index++) {
+                    const { callback, properties } = this._tableServerError[index];
+                    callback(tableObject);
+                }
+            }
+            tableObject.freeWaiting();
+        });
+    }
+    finishTableGlobalAction(tableActionDetail, actionResult, serverError = false) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { tableCode, actionCode } = tableActionDetail;
+            const tableEventHandlers = this._tableActionsFinish[tableCode];
+            const tableActionMethods = (tableEventHandlers) ? tableEventHandlers[actionCode] : null;
+            if (tableActionMethods) {
+                const clientActionPromises = [];
+                for (const tableActionMethod of tableActionMethods) {
+                    const { callback, properties } = tableActionMethod;
+                    const continueOnError = (_a = properties === null || properties === void 0 ? void 0 : properties.continueOnError) !== null && _a !== void 0 ? _a : false;
+                    if (!serverError || continueOnError) {
+                        clientActionPromises.push(callback(tableActionDetail, actionResult));
+                    }
+                }
+                yield Promise.all(clientActionPromises);
+            }
+        });
+    }
+    startTableAction(tableActionEvent) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { tableCode, actionCode, actionDetail } = tableActionEvent;
+            const tableObject = this.getTable(tableCode);
+            if (!tableObject || !actionCode) {
+                return;
+            }
+            this.resetError();
+            const { recordId, recordData } = actionDetail;
+            const action = tableObject.getAction(actionCode);
+            if (!action) {
+                return;
+            }
+            const tableActionDetail = {
+                tableObject,
+                action,
+                tableCode,
+                actionCode,
+                recordId,
+                recordData
+            };
+            const tableEventHandlers = this._tableActionsStart[tableCode];
+            const tableActionMethods = (tableEventHandlers) ? tableEventHandlers[actionCode] : null;
+            if (tableActionMethods) {
+                const clientActionPromises = [];
+                for (const tableActionMethod of tableActionMethods) {
+                    const { callback, properties } = tableActionMethod;
+                    const clientActionPromise = callback(tableActionDetail);
+                    clientActionPromises.push(clientActionPromise);
+                }
+                const clientActionResults = yield Promise.all(clientActionPromises);
+                const continueAction = clientActionResults.reduce((total, curr) => (total && (curr !== false)), true);
+                if (!continueAction) {
+                    return;
+                }
+            }
+            this.startTableServerAction(tableActionDetail);
+        });
+    }
+    startTableServerAction(tableActionDetail) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { tableObject, action, tableCode, actionCode, recordId, recordData } = tableActionDetail;
+            if (!tableObject || !action) {
+                return;
+            }
+            tableObject.putOnWait();
+            let serverError = false;
+            let actionResult = null;
+            if (action.backend) {
+                const actionSubject = {
+                    tableCode,
+                    actionType: this.formConfig.tableActions.inline,
+                    actionCode,
+                    tableRecordId: recordId,
+                    tableRecordData: recordData
+                };
+                actionResult = yield this
+                    .requestFormAction(formActions.tableAction, actionSubject);
+                serverError = !!this.errorOccured();
+            }
+            yield this.finishTableAction(tableActionDetail, actionResult, serverError);
+            if (!serverError) {
+                action.newState && this.changeState(action.newState);
+            }
+            else {
+                this.displayTableServerError();
+            }
+            tableObject.freeWaiting();
+        });
+    }
+    completeInlineAction(tableAction) {
+        return this.startTableServerAction(tableAction);
+    }
+    finishTableAction(tableActionDetail, actionResult, serverError = false) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { tableCode, actionCode } = tableActionDetail;
+            const tableEventHandlers = this._tableActionsFinish[tableCode];
+            const tableActionMethods = (tableEventHandlers) ? tableEventHandlers[actionCode] : null;
+            if (tableActionMethods) {
+                const clientActionPromises = [];
+                for (const tableActionMethod of tableActionMethods) {
+                    const { callback, properties } = tableActionMethod;
+                    const continueOnError = (_a = properties === null || properties === void 0 ? void 0 : properties.continueOnError) !== null && _a !== void 0 ? _a : false;
+                    if (!serverError || continueOnError) {
+                        clientActionPromises.push(callback(tableActionDetail, actionResult));
+                    }
+                }
+                yield Promise.all(clientActionPromises);
+            }
+        });
+    }
+    startTableRecordSelection(tableActionEvent) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { tableCode, actionDetail } = tableActionEvent;
+            const tableObject = this.getTable(tableCode);
+            if (!tableObject) {
+                return;
+            }
+            this.resetError();
+            const { recordId, recordData } = actionDetail;
+            const tableSelectionDetail = {
+                tableObject,
+                tableCode,
+                recordId,
+                recordData
+            };
+            const tableEventHandlers = this._tableSelectionsStart[tableCode];
+            if (tableEventHandlers) {
+                const clientActionPromises = [];
+                for (const tableSelectionMethod of tableEventHandlers) {
+                    const { callback, properties } = tableSelectionMethod;
+                    const clientActionPromise = callback(tableSelectionDetail);
+                    clientActionPromises.push(clientActionPromise);
+                }
+                const clientActionResults = yield Promise.all(clientActionPromises);
+                const continueAction = clientActionResults.reduce((total, curr) => (total && (curr !== false)), true);
+                if (!continueAction) {
+                    return;
+                }
+            }
+            this.startTableServerRecordSelection(tableSelectionDetail);
+        });
+    }
+    startTableServerRecordSelection(tableSelectionDetail) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { tableObject, tableCode, recordId, recordData } = tableSelectionDetail;
+            if (!tableObject) {
+                return;
+            }
+            tableObject.putOnWait();
+            let serverError = false;
+            let actionResult = null;
+            if (tableObject.selectionBackend) {
+                const actionSubject = {
+                    tableCode,
+                    actionType: this.formConfig.tableActions.rowSelection,
+                    actionCode: null,
+                    tableRecordId: recordId,
+                    tableRecordData: recordData
+                };
+                actionResult = yield this
+                    .requestFormAction(formActions.tableAction, actionSubject);
+                serverError = !!this.errorOccured();
+            }
+            yield this.finishTableRecordSelection(tableSelectionDetail, actionResult, serverError);
+            if (serverError) {
+                this.displayTableServerError();
+            }
+            tableObject.freeWaiting();
+        });
+    }
+    finishTableRecordSelection(tableSelectionDetail, actionResult, serverError = false) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { tableCode } = tableSelectionDetail;
+            const tableEventHandlers = this._tableSelectionsFinish[tableCode];
+            if (tableEventHandlers) {
+                const clientActionPromises = [];
+                for (const tableSelectionMethod of tableEventHandlers) {
+                    const { callback, properties } = tableSelectionMethod;
+                    const continueOnError = (_a = properties === null || properties === void 0 ? void 0 : properties.continueOnError) !== null && _a !== void 0 ? _a : false;
+                    if (!serverError || continueOnError) {
+                        clientActionPromises.push(callback(tableSelectionDetail, actionResult));
+                    }
+                }
+                yield Promise.all(clientActionPromises);
+            }
+        });
+    }
+    startTableSelectionAction(tableActionEvent) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { tableCode, actionCode, actionDetail } = tableActionEvent;
+            const tableObject = this.getTable(tableCode);
+            if (!tableObject || !actionCode) {
+                return;
+            }
+            this.resetError();
+            const { selectedRecords } = actionDetail;
+            const action = tableObject.getAction(actionCode);
+            if (!action) {
+                return;
+            }
+            const tableActionDetail = {
+                tableObject,
+                action,
+                tableCode,
+                actionCode,
+                selectedRecords
+            };
+            const tableEventHandlers = this._tableActionsStart[tableCode];
+            const tableActionMethods = (tableEventHandlers) ? tableEventHandlers[actionCode] : null;
+            if (tableActionMethods) {
+                const clientActionPromises = [];
+                for (const tableActionMethod of tableActionMethods) {
+                    const { callback, properties } = tableActionMethod;
+                    const clientActionPromise = callback(tableActionDetail);
+                    clientActionPromises.push(clientActionPromise);
+                }
+                const clientActionResults = yield Promise.all(clientActionPromises);
+                const continueAction = clientActionResults.reduce((total, curr) => (total && (curr !== false)), true);
+                if (!continueAction) {
+                    return;
+                }
+            }
+            this.startTableServerSelectionAction(tableActionDetail);
+        });
+    }
+    startTableServerSelectionAction(tableActionDetail) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { tableObject, action, tableCode, actionCode, selectedRecords } = tableActionDetail;
+            if (!tableObject || !action) {
+                return;
+            }
+            tableObject.putOnWait();
+            let serverError = false;
+            let actionResult = null;
+            if (action.backend) {
+                const actionSubject = {
+                    tableCode,
+                    actionType: this.formConfig.tableActions.selection,
+                    actionCode,
+                    selectedRecords
+                };
+                actionResult = yield this
+                    .requestFormAction(formActions.tableAction, actionSubject);
+                serverError = !!this.errorOccured();
+            }
+            yield this.finishTableSelectionAction(tableActionDetail, actionResult, serverError);
+            if (!serverError) {
+                action.newState && this.changeState(action.newState);
+            }
+            else {
+                this.displayTableServerError();
+            }
+            tableObject.freeWaiting();
+        });
+    }
+    finishTableSelectionAction(tableActionDetail, actionResult, serverError = false) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { tableCode, actionCode } = tableActionDetail;
+            const tableEventHandlers = this._tableActionsFinish[tableCode];
+            const tableActionMethods = (tableEventHandlers) ? tableEventHandlers[actionCode] : null;
+            if (tableActionMethods) {
+                const clientActionPromises = [];
+                for (const tableActionMethod of tableActionMethods) {
+                    const { callback, properties } = tableActionMethod;
+                    const continueOnError = (_a = properties === null || properties === void 0 ? void 0 : properties.continueOnError) !== null && _a !== void 0 ? _a : false;
+                    if (!serverError || continueOnError) {
+                        clientActionPromises.push(callback(tableActionDetail, actionResult));
+                    }
+                }
+                yield Promise.all(clientActionPromises);
+            }
+        });
+    }
+    startTableGetData(tableActionEvent) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { tableCode } = tableActionEvent;
+            const tableObject = this.getTable(tableCode);
+            const tableActionDetail = {
+                tableObject,
+                tableCode
+            };
+            this.resetError();
+            const tableEventHandlers = this._tableGetDataStart[tableCode];
+            if (tableEventHandlers) {
+                const clientActionPromises = [];
+                for (const tableActionMethod of tableEventHandlers) {
+                    const { callback, properties } = tableActionMethod;
+                    const clientActionPromise = callback(tableActionDetail);
+                    clientActionPromises.push(clientActionPromise);
+                }
+                const clientActionResults = yield Promise.all(clientActionPromises);
+                const continueAction = clientActionResults.reduce((total, curr) => (total && (curr !== false)), true);
+                if (!continueAction) {
+                    return;
+                }
+            }
+            this.startTableServerGetData(tableActionDetail);
+        });
+    }
+    startTableServerGetData(tableActionDetail) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { tableObject, tableCode } = tableActionDetail;
+            tableObject.putOnWait();
+            let serverError = false;
+            const actionSubject = { tableCode };
+            const actionResult = yield this
+                .requestFormAction(formActions.getTableData, actionSubject);
+            serverError = !!this.errorOccured();
+            yield this.finishTableGetData(tableActionDetail, actionResult, serverError);
+            if (serverError) {
+                this.displayTableServerError();
+            }
+            tableObject.freeWaiting();
+        });
+    }
+    finishTableGetData(tableActionDetail, actionResult, serverError = false) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { tableCode, tableActionCode } = tableActionDetail;
+            const tableEventHandlers = this._tableActionsFinish[tableCode];
+            const tableActionMethods = (tableEventHandlers) ? tableEventHandlers[tableActionCode] : null;
+            if (tableActionMethods) {
+                const clientActionPromises = [];
+                for (const tableActionMethod of tableActionMethods) {
+                    const { callback, properties } = tableActionMethod;
+                    const continueOnError = (_a = properties === null || properties === void 0 ? void 0 : properties.continueOnError) !== null && _a !== void 0 ? _a : false;
+                    if (!serverError || continueOnError) {
+                        clientActionPromises.push(callback(tableActionDetail, actionResult));
+                    }
+                }
+                yield Promise.all(clientActionPromises);
+            }
+        });
+    }
+    checkSectionRequiredFields(sectionCode, reqFieldMessage) {
+        this.cleanErrorFields(null, sectionCode);
+        const requiredFieldMessage = reqFieldMessage !== null && reqFieldMessage !== void 0 ? reqFieldMessage : this.formConfig.formStandardErrors.requiredField;
+        const numErrors = this.tagFieldsWithError(requiredFieldMessage, this.getRequiredEmptyFields(null, sectionCode));
+        return (numErrors === 0);
+    }
+    validateSectionConsistency(sectionCode, reqFieldMessage) {
+        var _a, _b;
+        this.resetError();
+        const completeFields = this.checkSectionRequiredFields(sectionCode, reqFieldMessage);
+        if (!completeFields) {
+            this.setError(this.formConfig.formStandardErrors.typeWarning, this.formConfig.formStandardErrors.validationTitle, this.formConfig.formStandardErrors.requiredFields);
+            return false;
+        }
+        let validationError = false;
+        const requiredEmptyFields = (_a = this.getRequiredEmptyFields(null, sectionCode)) !== null && _a !== void 0 ? _a : [];
+        if ((requiredEmptyFields === null || requiredEmptyFields === void 0 ? void 0 : requiredEmptyFields.length) > 0) {
+            validationError = true;
+            this.setError(this.formConfig.formStandardErrors.typeWarning, this.formConfig.formStandardErrors.validationTitle, this.formConfig.formStandardErrors.requiredFields);
+            this.tagFieldsWithError(this.formConfig.formStandardErrors.requiredField, requiredEmptyFields);
+            for (const fieldCode of requiredEmptyFields) {
+                const requiredEmptyField = this.getField(fieldCode);
+                requiredEmptyField === null || requiredEmptyField === void 0 ? void 0 : requiredEmptyField.focus();
+                break;
+            }
+        }
+        const validationIssueFields = (_b = this.getFieldsWithValidationIssues(null, sectionCode)) !== null && _b !== void 0 ? _b : [];
+        if (!validationError && validationIssueFields.length > 0) {
+            validationError = true;
+            this.setError(this.formConfig.formStandardErrors.typeWarning, this.formConfig.formStandardErrors.validationTitle, this.formConfig.formStandardErrors.validationFields);
+            for (const fieldCode of validationIssueFields) {
+                const validationIssueField = this.getField(fieldCode);
+                if (validationIssueField) {
+                    validationIssueField.focus();
+                }
+                break;
+            }
+        }
+        return validationError;
+    }
+    copyTableRecordToFields(tableObj, mappingTable = null) {
+        var _a, _b;
+        const tableObject = this.getTable(tableObj.tableCode);
+        const tableRecord = tableObject === null || tableObject === void 0 ? void 0 : tableObject.getTableRecord(tableObj.recordId);
+        const columnNames = tableObject === null || tableObject === void 0 ? void 0 : tableObject.columnNames;
+        if (tableRecord && columnNames) {
+            for (const columnName of columnNames) {
+                const columnValue = (_a = tableRecord.getFieldValue(columnName)) !== null && _a !== void 0 ? _a : '';
+                const fieldCode = (_b = mappingTable === null || mappingTable === void 0 ? void 0 : mappingTable[columnName]) !== null && _b !== void 0 ? _b : columnName;
+                this.setFieldValue(fieldCode, columnValue);
+            }
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Métodos Legacy de compatibilidad hacia atrás
+     */
+    addSectionActivation(codes, callback, properties = null) {
+        return this.onSectionActivation(codes, callback, properties);
+    }
+    addSectionInactivation(codes, callback, properties = null) {
+        return this.onSectionInactivation(codes, callback, properties);
+    }
+    addActionMethodStart(codes, callback, properties = null) {
+        return this.onActionStart(codes, callback, properties);
+    }
+    addActionMethodFinish(codes, callback, properties = null) {
+        return this.onActionFinish(codes, callback, properties);
+    }
+    addFieldInputValidation(codes, callback, properties = null) {
+        return this.onFieldInput(codes, callback, properties);
+    }
+    addFieldValidationStart(codes, callback, properties = null) {
+        return this.onFieldValidationStart(codes, callback, properties);
+    }
+    addFieldValidationFinish(codes, callback, properties = null) {
+        return this.onFieldValidationFinish(codes, callback, properties);
+    }
+    addTableActionStart(code, actionCode, callback, properties = null) {
+        return this.onTableActionStart(code, actionCode, callback, properties);
+    }
+    addTableActionFinish(code, actionCode, callback, properties = null) {
+        return this.onTableActionFinish(code, actionCode, callback, properties);
+    }
+    addTableSelectionStart(code, callback, properties = null) {
+        return this.onTableSelectionStart(code, callback, properties);
+    }
+    addTableSelectionFinish(code, callback, properties = null) {
+        return this.onTableSelectionFinish(code, callback, properties);
+    }
+    addTableGetDataStart(code, callback, properties = null) {
+        return this.onTableGetDataStart(code, callback, properties);
+    }
+    addTableGetDataFinish(code, callback, properties = null) {
+        return this.onTableGetDataFinish(code, callback, properties);
+    }
+}
+BasicFormComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: BasicFormComponent, deps: [{ token: LibFormManagerService }, { token: LibEventManagerService }, { token: LibFileManagementService }], target: i0.ɵɵFactoryTarget.Component });
+BasicFormComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.6", type: BasicFormComponent, selector: "ng-component", ngImport: i0, template: `<ng-content></ng-content>`, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: BasicFormComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: `<ng-content></ng-content>`
+                }]
+        }], ctorParameters: function () { return [{ type: LibFormManagerService }, { type: LibEventManagerService }, { type: LibFileManagementService }]; } });
+
+const COMPONENTS = [
+    BasicFormComponent,
+    ActionComponent,
+    FieldComponent,
+    ElementComponent,
+    FormErrorComponent,
+    FormHeaderComponent,
+    SectionComponent,
+    SubSectionComponent,
+    LibTableRecordActionComponent,
+    LibTableRecordFieldComponent,
+    LibTableComponent
+];
+class TuainNgFormsLibModule {
+}
+TuainNgFormsLibModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: TuainNgFormsLibModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+TuainNgFormsLibModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.2.6", ngImport: i0, type: TuainNgFormsLibModule, declarations: [BasicFormComponent,
+        ActionComponent,
+        FieldComponent,
+        ElementComponent,
+        FormErrorComponent,
+        FormHeaderComponent,
+        SectionComponent,
+        SubSectionComponent,
+        LibTableRecordActionComponent,
+        LibTableRecordFieldComponent,
+        LibTableComponent], imports: [CommonModule,
+        RouterModule,
+        FormsModule], exports: [BasicFormComponent,
+        ActionComponent,
+        FieldComponent,
+        ElementComponent,
+        FormErrorComponent,
+        FormHeaderComponent,
+        SectionComponent,
+        SubSectionComponent,
+        LibTableRecordActionComponent,
+        LibTableRecordFieldComponent,
+        LibTableComponent] });
+TuainNgFormsLibModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: TuainNgFormsLibModule, imports: [CommonModule,
+        RouterModule,
+        FormsModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.6", ngImport: i0, type: TuainNgFormsLibModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: COMPONENTS,
+                    imports: [
+                        CommonModule,
+                        RouterModule,
+                        FormsModule,
+                    ],
+                    exports: COMPONENTS
+                }]
+        }] });
+
+/*
+ * Public API Surface of tuain-ng-forms-lib
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { ActionComponent, BasicFormComponent, ElementComponent, FieldComponent, FormErrorComponent, FormHeaderComponent, LibEventManagerService, LibFileManagementService, LibFormManagerService, LibTableComponent, LibTableRecordActionComponent, LibTableRecordFieldComponent, SectionComponent, SubSectionComponent, TuainNgFormsLibModule };
+//# sourceMappingURL=tuain-ng-forms-lib.mjs.map