tuain-ng-forms-lib 17.2.21 → 17.2.22

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

@@ -1,4593 +0,0 @@
-import * as i0 from '@angular/core';
-import { signal, computed, Component, Input, model, EventEmitter, Output, ChangeDetectionStrategy, NgModule } from '@angular/core';
-import { Subject, takeUntil, BehaviorSubject, 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';
-
-const CUSTOM_ATTRIBUTES$6 = 'customAttributes';
-class PieceComponent {
-    form;
-    formConfig;
-    visible = signal(false);
-    disabled = signal(false);
-    enabled = computed(() => !this.disabled());
-    customAttributes = signal({});
-    setForm(form) { this.form = form; }
-    propagatedAttributeChange(attribute, value) { }
-    updatePieceAttribute(signaledAttributes, signaledAttribute, value) {
-        if (!signaledAttributes.includes(signaledAttribute)) {
-            return;
-        }
-        this[signaledAttribute]?.set(value);
-        this.propagatedAttributeChange(signaledAttribute, value);
-    }
-    updatePieceAttributes(piece, signaledAttributes) {
-        if (!piece) {
-            return;
-        }
-        // Se recore el conjunto de los atributos propagados desde el piece y se asigna el valor respectivo
-        for (let index = 0; index < signaledAttributes.length; index++) {
-            const signaledAttribute = signaledAttributes[index];
-            try {
-                this[signaledAttribute]?.set(piece?.[signaledAttribute]);
-                this.propagatedAttributeChange(signaledAttribute, piece?.[signaledAttribute]);
-            }
-            catch (e) {
-                console.log(`Señal ${signaledAttribute} invalida en el componente. ${e}`);
-            }
-        }
-    }
-    // Función que las subclases pueden sobrecargar para manejar un comportamiento específico
-    customAttributeChange(subAttribute, value) { }
-    updateCustomAttribute(attrName, attrValue) {
-        this.customAttributes.update(oldCustomAttr => {
-            oldCustomAttr[attrName] = attrValue;
-            return oldCustomAttr;
-        });
-        // Ejecución de función personalizada ante un cambio de atributo personalizado
-        this.customAttributeChange(attrName, attrValue);
-    }
-    replaceCustomAttributes(customAttributes) {
-        this.customAttributes.set(customAttributes ?? {});
-        Object.keys(customAttributes).forEach(attrName => {
-            const attrValue = customAttributes[attrName];
-            // Ejecución de función personalizada ante un cambio de atributo personalizado
-            this.customAttributeChange(attrName, attrValue);
-        });
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PieceComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: PieceComponent, selector: "lib-piece", ngImport: i0, template: `<ng-content></ng-content>`, isInline: true });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PieceComponent, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'lib-piece',
-                    template: `<ng-content></ng-content>`
-                }]
-        }] });
-
-class ElementComponent extends PieceComponent {
-    element;
-    start() {
-        this.setForm(this.element?._form);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ElementComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: ElementComponent, selector: "lib-element", inputs: { element: "element" }, usesInheritance: true, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ElementComponent, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'lib-element',
-                    template: `<ng-content></ng-content>`
-                }]
-        }], propDecorators: { element: [{
-                type: Input
-            }] } });
-
-const CUSTOM_ATTRIBUTES$5 = 'customAttributes';
-const signaledAttributes$5 = [
-    'actionCode', 'actionName', 'iconName', 'inProgress', 'restrictedOnField', 'restrictedOnOperator',
-    'restrictedOnValue', 'visible', 'disabled',
-];
-class ActionComponent extends ElementComponent {
-    destroy$ = new Subject();
-    actionCode = signal(null);
-    actionName = signal(null);
-    iconName = signal(null);
-    inProgress = signal(false);
-    restrictedOnField = signal(null);
-    restrictedOnOperator = signal(null);
-    restrictedOnValue = signal(null);
-    action = null;
-    updatePropagatedAttributes() {
-        this.updatePieceAttributes(this.action, signaledAttributes$5);
-    }
-    ngOnInit() {
-        if (!this.action) {
-            return;
-        }
-        this.action.widget = this;
-        this.formConfig = this.action?._formConfig;
-        this.updatePropagatedAttributes();
-        this.replaceCustomAttributes(this.action?.customAttributes);
-        this.action?.attributeChange
-            .pipe(takeUntil(this.destroy$))
-            .subscribe(event => {
-            const { name: attribute, value = null } = event ?? {};
-            const attributeParts = attribute?.split('.') ?? [];
-            if (signaledAttributes$5.includes(attribute)) {
-                this.updatePieceAttribute(signaledAttributes$5, attribute, value);
-            }
-            else if (attributeParts?.length > 1 && attributeParts?.[0] === CUSTOM_ATTRIBUTES$5) {
-                const subAttribute = attributeParts?.[1] ?? null;
-                this.updateCustomAttribute(subAttribute, value);
-            }
-        });
-        this.start();
-    }
-    start() {
-        this.setForm(this.action?._form);
-    }
-    activate() {
-        if (this.action?.notifyActivation) {
-            this.action.notifyActivation();
-        }
-    }
-    ngOnDestroy() {
-        this.destroy$.next();
-        this.destroy$.complete();
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ActionComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: ActionComponent, selector: "lib-action", inputs: { action: "action" }, usesInheritance: true, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ActionComponent, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'lib-action',
-                    template: `<ng-content></ng-content>`
-                }]
-        }], propDecorators: { action: [{
-                type: Input
-            }] } });
-
-const CUSTOM_ATTRIBUTES$4 = 'customAttributes';
-const signaledAttributes$4 = ['captureType', 'errorCode', 'errorMessage', 'errorType', 'defaultValue',
-    'defaultEditable', 'alignment', 'code', 'info', 'required', 'title', 'type', 'format', 'options',
-    'hasChanged', 'maxLength', 'maxValue', 'minLength', 'minValue', 'onValidation', 'outputOnly',
-    'placeholder', 'tooltip', 'validateOnServer', 'visibleLabel', 'visible', 'disabled', 'value',
-];
-const VALUE = 'value';
-const FOCUS = 'focus';
-class FieldComponent extends ElementComponent {
-    destroy$ = new Subject();
-    // Atributos propagados desde el campo
-    captureType = signal('');
-    errorCode = signal('');
-    errorMessage = signal('');
-    errorType = signal('');
-    defaultValue = signal(null);
-    defaultEditable = signal(false);
-    alignment = signal('');
-    code = signal('');
-    info = signal(null);
-    required = signal(false);
-    title = signal('');
-    type = signal('');
-    format = signal(null);
-    options = signal([]);
-    hasChanged = signal(false);
-    minLength = signal(0);
-    maxLength = signal(0);
-    minValue = signal(null);
-    maxValue = signal(null);
-    onValidation = signal(false);
-    outputOnly = signal(false);
-    placeholder = signal('');
-    tooltip = signal('');
-    validateOnServer = signal(false);
-    visibleLabel = signal(true);
-    // value: any;  // Valor del componente relacionado con el campo (pueden diferir en formato y tipo)
-    value = model(); // Valor del componente relacionado con el campo (pueden diferir en formato y tipo)
-    field = null;
-    // field = input.required<FieldDescriptor>();
-    updatePropagatedAttributes() {
-        this.updatePieceAttributes(this.field, signaledAttributes$4);
-    }
-    ngOnInit() {
-        if (!this.field) {
-            return;
-        }
-        this.field.widget = this;
-        this.formConfig = this.field?._formConfig;
-        this.updatePropagatedAttributes();
-        this.updateValue();
-        this.replaceCustomAttributes(this.field?.customAttributes);
-        this.field?.attributeChange
-            .pipe(takeUntil(this.destroy$))
-            .subscribe(event => {
-            const { name: attribute, value = null } = event ?? {};
-            const attributeParts = attribute?.split('.') ?? [];
-            if (attribute === VALUE) {
-                this.updateValue();
-            }
-            else if (attribute === FOCUS) {
-                this.focus();
-            }
-            else if (signaledAttributes$4.includes(attribute)) {
-                this.updatePieceAttribute(signaledAttributes$4, attribute, value);
-            }
-            else if (attributeParts?.length > 1 && attributeParts?.[0] === CUSTOM_ATTRIBUTES$4) {
-                const subAttribute = attributeParts?.[1] ?? null;
-                this.updateCustomAttribute(subAttribute, value);
-            }
-        });
-        this.start();
-    }
-    updateValue() {
-        try {
-            this.value.set(this.field?.value);
-        }
-        catch (e) {
-            console.log(`Excepción en componente de campo ${e}`);
-        }
-    }
-    onInputChange() { setTimeout(() => this.field?.notifyEditionPartial(), 50); }
-    onChangeContent() { setTimeout(() => this.field?.notifyEditionFinish(), 50); }
-    onShowInfo(detail = null) { setTimeout(() => this.field?.notifyEditionDetailRequest(detail), 50); }
-    focus() { }
-    updateObject(widgetUpdate = true) { this.field?.setValue(this.value(), widgetUpdate); }
-    inputChanged() {
-        this.updateObject();
-        this.onChangeContent();
-    }
-    inputTyped() {
-        this.updateObject(false);
-        this.onInputChange();
-    }
-    ngOnDestroy() {
-        this.destroy$.next();
-        this.destroy$.complete();
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FieldComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "17.3.12", type: FieldComponent, selector: "lib-field", inputs: { value: { classPropertyName: "value", publicName: "value", isSignal: true, isRequired: false, transformFunction: null }, field: { classPropertyName: "field", publicName: "field", isSignal: false, isRequired: false, transformFunction: null } }, outputs: { value: "valueChange" }, usesInheritance: true, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FieldComponent, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'lib-field',
-                    template: `<ng-content></ng-content>`
-                }]
-        }], propDecorators: { field: [{
-                type: Input
-            }] } });
-
-class FormErrorComponent {
-    errorTitle;
-    errorMessage;
-    errorType;
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FormErrorComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", 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: "17.3.12", 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 {
-    form;
-    goBackEvent = new EventEmitter();
-    goBackForm() {
-        this.goBackEvent.emit();
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FormHeaderComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: FormHeaderComponent, selector: "lib-form-header", inputs: { form: "form" }, outputs: { goBackEvent: "goBackEvent" }, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FormHeaderComponent, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'lib-form-header',
-                    template: `<ng-content></ng-content>`
-                }]
-        }], propDecorators: { form: [{
-                type: Input
-            }], goBackEvent: [{
-                type: Output
-            }] } });
-
-const CUSTOM_ATTRIBUTES$3 = 'customAttributes';
-const signaledAttributes$3 = [
-    'visible', 'disabled',
-];
-class SectionComponent extends PieceComponent {
-    destroy$ = new Subject();
-    section;
-    updatePropagatedAttributes() {
-        this.updatePieceAttributes(this.section, signaledAttributes$3);
-    }
-    ngOnInit() {
-        if (!this.section) {
-            return;
-        }
-        this.formConfig = this.section?._formConfig;
-        this.updatePropagatedAttributes();
-        this.replaceCustomAttributes(this.section?.customAttributes);
-        this.section?.attributeChange
-            .pipe(takeUntil(this.destroy$))
-            .subscribe(event => {
-            const { name: attribute, value = null } = event ?? {};
-            const attributeParts = attribute?.split('.') ?? [];
-            if (signaledAttributes$3.includes(attribute)) {
-                this.updatePieceAttribute(signaledAttributes$3, attribute, value);
-            }
-            else if (attributeParts?.length > 1 && attributeParts?.[0] === CUSTOM_ATTRIBUTES$3) {
-                const subAttribute = attributeParts?.[1] ?? null;
-                this.updateCustomAttribute(subAttribute, value);
-            }
-        });
-        this.start();
-    }
-    start() {
-        this.setForm(this.section?._form);
-    }
-    ngOnDestroy() {
-        this.destroy$.next();
-        this.destroy$.complete();
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SectionComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: SectionComponent, selector: "lib-section", inputs: { section: "section" }, usesInheritance: true, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SectionComponent, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'lib-section',
-                    template: `<ng-content></ng-content>`
-                }]
-        }], propDecorators: { section: [{
-                type: Input
-            }] } });
-
-const CUSTOM_ATTRIBUTES$2 = 'customAttributes';
-const signaledAttributes$2 = [
-    'visible', 'disabled',
-];
-class SubSectionComponent extends PieceComponent {
-    destroy$ = new Subject();
-    subSection;
-    updatePropagatedAttributes() {
-        this.updatePieceAttributes(this.subSection, signaledAttributes$2);
-    }
-    ngOnInit() {
-        if (!this.subSection) {
-            return;
-        }
-        this.formConfig = this.subSection?._formConfig;
-        this.updatePropagatedAttributes();
-        this.replaceCustomAttributes(this.subSection?.customAttributes);
-        this.subSection?.attributeChange
-            .pipe(takeUntil(this.destroy$))
-            .subscribe(event => {
-            const { name: attribute, value = null } = event ?? {};
-            const attributeParts = attribute?.split('.') ?? [];
-            if (signaledAttributes$2.includes(attribute)) {
-                this.updatePieceAttribute(signaledAttributes$2, attribute, value);
-            }
-            else if (attributeParts?.length > 1 && attributeParts?.[0] === CUSTOM_ATTRIBUTES$2) {
-                const subAttribute = attributeParts?.[1] ?? null;
-                this.updateCustomAttribute(subAttribute, value);
-            }
-        });
-        this.start();
-    }
-    start() {
-        this.setForm(this.subSection?._form);
-    }
-    ngOnDestroy() {
-        this.destroy$.next();
-        this.destroy$.complete();
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SubSectionComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: SubSectionComponent, selector: "lib-subsection", inputs: { subSection: "subSection" }, usesInheritance: true, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SubSectionComponent, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'lib-subsection',
-                    template: `<ng-content></ng-content>`
-                }]
-        }], propDecorators: { subSection: [{
-                type: Input
-            }] } });
-
-const INLINE_ACTION$1 = 'INLINE';
-const CUSTOM_ATTRIBUTES$1 = 'customAttributes';
-const signaledAttributes$1 = [
-    'visible', 'disabled',
-];
-class LibTableRecordActionComponent extends PieceComponent {
-    recordId;
-    recordData;
-    action;
-    actionSelected = new EventEmitter();
-    updatePropagatedAttributes() {
-        this.updatePieceAttributes(this.action, signaledAttributes$1);
-    }
-    ngOnInit() {
-        if (!this.action) {
-            return;
-        }
-        this.formConfig = this.action?._formConfig;
-        this.updatePropagatedAttributes();
-        this.replaceCustomAttributes(this.action?.customAttributes);
-        this.start();
-    }
-    start() {
-        if (this.action && this.action.restrictedOnField && this.recordData) {
-            const relatedField = this.action.restrictedOnField;
-            if (relatedField) {
-                const relatedFieldValue = this.recordData[relatedField];
-                const restrictionOper = this.action.restrictedOnOperator;
-                const restrictionValue = this.action.restrictedOnValue;
-                let visibility = false;
-                if ((restrictionOper === '==' || restrictionOper === '===') && relatedFieldValue === restrictionValue) {
-                    visibility = true;
-                }
-                else if ((restrictionOper === '!=' || restrictionOper === '!==') && relatedFieldValue !== restrictionValue) {
-                    visibility = true;
-                }
-                this.visible.set(visibility);
-            }
-        }
-    }
-    onActivate() {
-        const tableEvent = {
-            actionCode: this.action?.actionCode ?? '',
-            recordId: this.recordId,
-            recordData: this.recordData,
-        };
-        this.actionSelected.emit(tableEvent);
-    }
-    class() { }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LibTableRecordActionComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: LibTableRecordActionComponent, selector: "lib-table-record-action", inputs: { recordId: "recordId", recordData: "recordData", action: "action" }, outputs: { actionSelected: "actionSelected" }, usesInheritance: true, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LibTableRecordActionComponent, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'lib-table-record-action',
-                    template: `<ng-content></ng-content>`,
-                    changeDetection: ChangeDetectionStrategy.OnPush
-                }]
-        }], propDecorators: { recordId: [{
-                type: Input
-            }], recordData: [{
-                type: Input
-            }], action: [{
-                type: Input
-            }], actionSelected: [{
-                type: Output
-            }] } });
-
-class LibTableRecordFieldComponent {
-    fieldCode;
-    fieldType;
-    fieldValue;
-    column = null;
-    ngOnInit() {
-        this.start();
-    }
-    start() { }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LibTableRecordFieldComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: LibTableRecordFieldComponent, selector: "lib-table-record-field", inputs: { fieldCode: "fieldCode", fieldType: "fieldType", fieldValue: "fieldValue", column: "column" }, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: 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
-            }], column: [{
-                type: Input
-            }] } });
-
-const CUSTOM_ATTRIBUTES = 'customAttributes';
-const signaledAttributes = [
-    'allSelected', 'code', 'globalSearch', 'recordsPerPage', 'layout',
-    'columns', 'selectedRecords', 'currentPage', 'totalRecordsNumber', 'visibleRecords',
-    'waiting', 'visible', 'disabled',
-];
-class LibTableComponent extends ElementComponent {
-    destroy$ = new Subject();
-    // Atributos sincronizados del objeto
-    allSelected = signal(null);
-    code = signal('');
-    globalSearch = signal(null);
-    recordsPerPage = signal(null);
-    layout = signal(null);
-    columns = signal(null);
-    selectedRecords = signal(null);
-    currentPage = signal(null);
-    totalRecordsNumber = signal(null);
-    visibleRecords = signal([]);
-    waiting = signal(false);
-    globalFilterString = '';
-    tableFieldStyles;
-    loaded = false;
-    selectable = false;
-    hasActions = false;
-    inlineActions;
-    globalActions;
-    selectionActions;
-    table = null;
-    ngOnInit() {
-        if (!this.table) {
-            return;
-        }
-        this.table.setWidget(this);
-        this.formConfig = this.table?._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);
-        this.globalFilterString = this.table?.globalFilterString;
-        this.updatePropagatedAttributes();
-        this.replaceCustomAttributes(this.table?.customAttributes);
-        this.table?.attributeChange
-            .pipe(takeUntil(this.destroy$))
-            .subscribe(event => {
-            const { name: attribute, value = null } = event ?? {};
-            const attributeParts = attribute?.split('.') ?? [];
-            if (attribute === 'visibleRecords') {
-                this.visibleRecords.set(value ?? []);
-                this.updateTableData();
-            }
-            else if (attribute === 'globalFilterString') {
-                this.globalFilterString = value;
-            }
-            else if (signaledAttributes.includes(attribute)) {
-                this.updatePieceAttribute(signaledAttributes, attribute, value);
-            }
-            else if (attributeParts?.length > 1 && attributeParts?.[0] === CUSTOM_ATTRIBUTES) {
-                const subAttribute = attributeParts?.[1] ?? null;
-                this.updateCustomAttribute(subAttribute, value);
-            }
-        });
-        this.start();
-    }
-    updatePropagatedAttributes() {
-        this.updatePieceAttributes(this.table, signaledAttributes);
-    }
-    updateTableData() { }
-    tableGlobalAction(actionCode) { this.table?.notifyGlobalAction(actionCode); }
-    tableSelectionAction(actionCode) { this.table?.notifySelectionAction(actionCode); }
-    tableActionSelected(actionEvent) { this.table?.notifyInlineAction(actionEvent); }
-    tableSelectionToggle(recordId) { this.table?.notifyRecordSelection(recordId); }
-    toggleSelectAll() { return (this.table?.allSelected) ? this.table?.unSelectAll() : this.table?.selectAll(); }
-    globalFilterCompleted() { this.changePage(1); }
-    changePage(requestedPage) { this.table?.changePage(requestedPage); }
-    tableColumnSort(columnName, direction = null) { this.table?.sort(columnName, direction ?? 'ascend'); }
-    globalFilterChanged() { this.table?.setGlobalFilterString(this.globalFilterString?.trim() ?? '', false); }
-    filterHasChanged(column, values) {
-        if (!values || values.length === 0) {
-            this.table?.removeColumnFilter(column.fieldCode);
-        }
-        else {
-            this.table?.addColumnFilter(column.fieldCode, values);
-        }
-    }
-    ngOnDestroy() {
-        this.destroy$.next();
-        this.destroy$.complete();
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LibTableComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: LibTableComponent, selector: "lib-table", inputs: { table: "table" }, usesInheritance: true, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LibTableComponent, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'lib-table',
-                    template: `<ng-content></ng-content>`,
-                    changeDetection: ChangeDetectionStrategy.OnPush
-                }]
-        }], propDecorators: { table: [{
-                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 FormPiece {
-    destroy$ = new Subject();
-    _formState = '';
-    _visibleForced;
-    _isForced;
-    _absoluteVisible = true;
-    _absoluteDisabled = false;
-    _widget = null;
-    visibleStates = [];
-    enabledStates = [];
-    _form = null;
-    _formConfig;
-    _visible = true;
-    _disabled = false;
-    customAttributes = {};
-    constructor(pieceDefinition, formConfig) {
-        this._formConfig = formConfig;
-        this._isForced = false;
-        this._visibleForced = false;
-        this.setVisibleStates(pieceDefinition.visibleStates);
-        this.setEnabledStates(pieceDefinition.enabledStates);
-        this.enabled = !pieceDefinition?.disabled ?? false;
-        this.setVisibility(pieceDefinition?.visible ?? true);
-        this.customAttributes = pieceDefinition?.customAttributes ?? {};
-        if (pieceDefinition?.customAttributes) {
-            Object.keys(pieceDefinition?.customAttributes)
-                ?.forEach(attr => this.customAttributes[attr] = pieceDefinition?.customAttributes[attr]);
-        }
-    }
-    getCustomAttribute(name) { return this.customAttributes?.[name] ?? null; }
-    setCustomAttribute(name, value) { if (name) {
-        this.customAttributes[name] = value;
-    } }
-    setCustomAttributes(attributes) {
-        Object.entries(attributes).forEach(([name, value]) => {
-            this.setCustomAttribute(name, value);
-        });
-        return this;
-    }
-    matchAttribute(name, value) { return this.customAttributes?.[name] === value; }
-    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)) ? [...(new Set(visibleStates))] : [];
-    }
-    addVisibleState(state) {
-        if (!this.visibleStates.includes(state)) {
-            this.visibleStates.push(state);
-        }
-    }
-    removeVisibleState(state) {
-        const existStateIdx = this.visibleStates.findIndex(st => st === state);
-        if (existStateIdx >= 0) {
-            this.visibleStates.splice(existStateIdx, 1);
-        }
-    }
-    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)) ? [...(new Set(enabledStates))] : [];
-    }
-    addEnabledState(state) {
-        if (!this.enabledStates.includes(state)) {
-            this.enabledStates.push(state);
-        }
-    }
-    removeEnabledState(state) {
-        const existStateIdx = this.enabledStates.findIndex(st => st === state);
-        if (existStateIdx >= 0) {
-            this.enabledStates.splice(existStateIdx, 1);
-        }
-    }
-    viewOnState(state) { return (this.visibleStates && state) ? this.visibleStates.includes(state) : false; }
-    enabledOnState(state) { return (this.enabledStates && state) ? this.enabledStates.includes(state) : false; }
-    get absoluteVisible() { return this._absoluteVisible; }
-    get absoluteDisabled() { return this._absoluteDisabled; }
-    get visible() { return this._visible; }
-    set visible(visible) { this.setVisibility(visible); }
-    visibleOn(state) {
-        return this._absoluteVisible && this.viewOnState(state);
-    }
-    enabledOn(state) {
-        return !this._absoluteDisabled && this.enabledOnState(state);
-    }
-    setVisibility(visible, forced = null) {
-        this._absoluteVisible = !!visible;
-        if (forced !== null) {
-            this._isForced = forced;
-            this._visibleForced = visible;
-        }
-        this._visible = this._absoluteVisible && this.viewOnState(this._formState);
-    }
-    show(forced = null) {
-        this.setVisibility(true, forced);
-    }
-    hide(forced = null) {
-        this.setVisibility(false, forced);
-    }
-    get enabled() { return !this._disabled; }
-    set enabled(enabled) {
-        this._absoluteDisabled = !enabled;
-        this._disabled = this._absoluteDisabled || !this.enabledOnState(this._formState);
-    }
-    get editable() { return !this._disabled; }
-    get disabled() { return this._disabled; }
-    set disabled(disabled) { this.enabled = !disabled; }
-    enable() { this.enabled = true; }
-    disable() { this.enabled = false; }
-    formStateChangeCustomSubscribe(form, formChangeSubject) { }
-    formStateChange(state) {
-        if (state) {
-            this._formState = state;
-            this._visible = this._absoluteVisible && this.viewOnState(state);
-            this._disabled = this._absoluteDisabled || !this.enabledOnState(state);
-        }
-    }
-    connectWithParentForm(form, formChangeSubject) {
-        this._form = form;
-        this.formStateChangeCustomSubscribe(form, formChangeSubject);
-        formChangeSubject
-            .pipe(takeUntil(this.destroy$))
-            .subscribe(event => this.formStateChange(event?.state));
-    }
-    set widget(widget) { this._widget = widget; }
-    get widget() { return this._widget; }
-    destroy() {
-        this.destroy$.next();
-        this.destroy$.complete();
-    }
-}
-
-const VISIBLE = 'visible';
-const DISABLED = 'disabled';
-class FormPiecePropagate extends FormPiece {
-    propagationCustomAttributes = [];
-    _attributeChange;
-    constructor(pieceDefinition, formConfig) {
-        super(pieceDefinition, formConfig);
-        this._attributeChange = new BehaviorSubject(null);
-    }
-    get attributeChange() { return this._attributeChange.asObservable(); }
-    propagateAttribute(name, value) {
-        this._attributeChange?.next({ name, value });
-    }
-    setCustomAttribute(name, value) {
-        super.setCustomAttribute(name, value);
-        if (this.propagationCustomAttributes?.includes(name)) {
-            const fullName = `customAttributes.${name}`;
-            this.propagateAttribute(fullName, value);
-        }
-    }
-    setVisibility(visible, forced = null) {
-        super.setVisibility(visible, forced);
-        this.propagateAttribute(VISIBLE, this._visible);
-    }
-    set enabled(enabled) {
-        super.enabled = enabled;
-        this.propagateAttribute(DISABLED, this._disabled);
-    }
-    formStateChange(state) {
-        super.formStateChange(state);
-        if (state) {
-            this.propagateAttribute(VISIBLE, this._visible);
-            this.propagateAttribute(DISABLED, this._disabled);
-        }
-    }
-}
-
-class FormElement extends FormPiecePropagate {
-    elementType = null;
-    constructor(elementDefinition, formConfig) {
-        super(elementDefinition, formConfig);
-    }
-    setAttr(attr, value) {
-        const { name: attrName, propagate: name } = attr;
-        try {
-            const currentValue = this[attrName];
-            if (currentValue !== value) {
-                this[attrName] = value;
-                name && this.propagateAttribute(name, value);
-            }
-        }
-        catch (e) {
-            console.log(`Atributo ${attrName} no presente o valor ${value} inconsistente. ${e}`);
-        }
-    }
-    isField() { return this.elementType === elementTypes.field; }
-    isAction() { return this.elementType === elementTypes.action; }
-    isTable() { return this.elementType === elementTypes.table; }
-}
-
-const HEADER = 'HEADER';
-const attrs$2 = {
-    actionCode: { name: '_actionCode', propagate: 'actionCode' },
-    actionName: { name: '_actionName', propagate: 'actionName' },
-    iconName: { name: '_iconName', propagate: 'iconName' },
-    inProgress: { name: '_inProgress', propagate: 'inProgress' },
-    restrictedOnField: { name: '_restrictedOnField', propagate: 'restrictedOnField' },
-    restrictedOnOperator: { name: '_restrictedOnOperator', propagate: 'restrictedOnOperator' },
-    restrictedOnValue: { name: '_restrictedOnValue', propagate: 'restrictedOnValue' },
-};
-class FormAction extends FormElement {
-    _actionActivated = new Subject();
-    _actionCode = '';
-    _actionName = '';
-    _iconName = '';
-    _inProgress = false;
-    _newState;
-    _backend;
-    _restrictedOnField = null;
-    _restrictedOnOperator = null;
-    _restrictedOnValue = null;
-    constructor(actionDefinition, formConfig) {
-        super(actionDefinition, formConfig);
-        this.propagationCustomAttributes = this._formConfig?.propagationCustomAttributes?.actions ?? [];
-        this.elementType = elementTypes.action;
-        this.setAttr(attrs$2.actionCode, actionDefinition.actionCode ? actionDefinition.actionCode.toString() : '');
-        this.setAttr(attrs$2.actionName, actionDefinition.actionTitle);
-        this.setAttr(attrs$2.iconName, actionDefinition.iconName || this._actionCode);
-        this.setAttr(attrs$2.restrictedOnField, actionDefinition.fieldRestrictedCode?.toString() ?? null);
-        if (this._restrictedOnField) {
-            this.setAttr(attrs$2.restrictedOnOperator, actionDefinition.operatorRestricted || '');
-            this.setAttr(attrs$2.restrictedOnValue, actionDefinition.valueRestricted ?? '');
-        }
-        this._backend = actionDefinition?.serverAction ?? false;
-        this._newState = actionDefinition?.newState;
-        this.setCustomAttribute('location', actionDefinition.position || HEADER);
-    }
-    get actionCode() { return this._actionCode; }
-    get actionName() { return this._actionName; }
-    get iconName() { return this._iconName; }
-    get inProgress() { return this._inProgress; }
-    get newState() { return this._newState; }
-    get backend() { return this._backend; }
-    get restrictedOnField() { return this._restrictedOnField; }
-    get restrictedOnOperator() { return this._restrictedOnOperator; }
-    get restrictedOnValue() { return this._restrictedOnValue; }
-    set actionCode(actionCode) { this.setAttr(attrs$2.actionCode, actionCode); }
-    set actionName(actionName) { this.setAttr(attrs$2.actionName, actionName); }
-    set iconName(iconName) { this.setAttr(attrs$2.iconName, iconName); }
-    set inProgress(inProgress) { this.setAttr(attrs$2.inProgress, inProgress); }
-    set newState(newState) { this._newState, newState; }
-    set backend(backend) { this._backend, backend; }
-    set restrictedOnField(restrictedOnField) { this.setAttr(attrs$2.restrictedOnField, restrictedOnField); }
-    set restrictedOnOperator(restrictedOnOperator) { this.setAttr(attrs$2.restrictedOnOperator, restrictedOnOperator); }
-    set restrictedOnValue(restrictedOnValue) { this.setAttr(attrs$2.restrictedOnValue, restrictedOnValue); }
-    start() { this.inProgress = true; }
-    stop() { this.inProgress = false; }
-    connectWithParentForm(form, formChangeSubject) {
-        super.connectWithParentForm(form, formChangeSubject);
-        if (this._restrictedOnField) {
-            const relatedField = this._form.fields?.[this._restrictedOnField];
-            if (relatedField) {
-                relatedField.editionFinish
-                    .subscribe(event => this.updateRestrictedVisibility(event));
-                relatedField.editionPartial
-                    .subscribe(event => this.updateRestrictedVisibility(event));
-            }
-        }
-    }
-    updateRestrictedVisibility(event) {
-        const newVisible = this._absoluteVisible && this.viewOnState(this._formState);
-        (this._visible !== newVisible) && this.setVisibility(newVisible);
-    }
-    viewOnState(state) {
-        const actionVisible = (this.visibleStates && state) ? this.visibleStates.includes(state) : false;
-        if (actionVisible && this._form && this._restrictedOnField) {
-            const relatedField = this._form.fields?.[this._restrictedOnField];
-            if (relatedField) {
-                const fieldValue = relatedField.value;
-                if ((this._restrictedOnOperator === '==' && fieldValue !== this._restrictedOnValue)
-                    || (this._restrictedOnOperator === '!=' && fieldValue === this._restrictedOnValue)) {
-                    return false;
-                }
-            }
-        }
-        return actionVisible;
-    }
-    get actionActivated() { return this._actionActivated.asObservable(); }
-    notifyActivation() { this._actionActivated.next(this._actionCode); }
-    updateFromServer(receivedAction) {
-        for (const propertyName in receivedAction) {
-            if (propertyName !== 'actionCode' && propertyName !== 'actionId') {
-                try {
-                    this[propertyName] = receivedAction[propertyName];
-                }
-                catch (e) {
-                    console.log(`Error actualizando la propiedad ${propertyName} de la acción ${this.actionCode}. ${e}`);
-                }
-            }
-        }
-    }
-}
-
-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 directChanges = [
-    'defaultEditable', 'defaultValue', 'alignment', 'required', 'errorCode', 'errorMessage', 'errorType',
-    'tooltip', 'info', 'format', 'intrinsicErrorMessage', 'outputOnly', 'captureType', 'title', 'type',
-    'maxLength', 'maxValue', 'minLength', 'minValue', 'validateOnServer', 'serverAction', 'visibleLabel',
-    'options', 'placeholder',
-];
-const attrs$1 = {
-    captureType: { name: '_captureType', propagate: 'captureType' },
-    errorCode: { name: '_errorCode', propagate: 'errorCode' },
-    errorMessage: { name: '_errorMessage', propagate: 'errorMessage' },
-    errorType: { name: '_errorType', propagate: 'errorType' },
-    defaultValue: { name: '_defaultValue', propagate: 'defaultValue' },
-    defaultEditable: { name: '_defaultEditable', propagate: 'defaultEditable' },
-    fieldAlignment: { name: '_fieldAlignment', propagate: 'alignment' },
-    fieldCode: { name: '_fieldCode', propagate: 'code' },
-    fieldInfo: { name: '_fieldInfo', propagate: 'info' },
-    fieldRequired: { name: '_fieldRequired', propagate: 'required' },
-    fieldTitle: { name: '_fieldTitle', propagate: 'title' },
-    fieldType: { name: '_fieldType', propagate: 'type' },
-    fieldFormat: { name: '_fieldFormat', propagate: 'format' },
-    fieldOptions: { name: '_fieldOptions', propagate: 'options' },
-    focus: { name: '_focus', propagate: 'focus' },
-    hasChanged: { name: '_hasChanged', propagate: 'hasChanged' },
-    intrinsicErrorMessage: { name: '_intrinsicErrorMessage', propagate: null },
-    maxLength: { name: '_maxLength', propagate: 'maxLength' },
-    maxValue: { name: '_maxValue', propagate: 'maxValue' },
-    minLength: { name: '_minLength', propagate: 'minLength' },
-    minValue: { name: '_minValue', propagate: 'minValue' },
-    onValidation: { name: '_onValidation', propagate: 'onValidation' },
-    outputOnly: { name: '_outputOnly', propagate: 'outputOnly' },
-    placeholder: { name: '_placeholder', propagate: 'placeholder' },
-    tooltipText: { name: '_tooltipText', propagate: 'tooltip' },
-    validateOnServer: { name: '_validateOnServer', propagate: 'validateOnServer' },
-    value: { name: '_value', propagate: 'value' },
-    visibleLabel: { name: '_visibleLabel', propagate: 'visibleLabel' },
-};
-class FieldDescriptor extends FormElement {
-    _customEvent = new Subject();
-    _editionFinish = new Subject();
-    _editionPartial = new Subject();
-    _detailRequest = new Subject();
-    _errorType = '';
-    _errorCode = '';
-    _errorMessage = '';
-    _intrinsicErrorMessage = '';
-    _minValue;
-    _maxValue;
-    _maxLength = 0;
-    _minLength = 0;
-    _focus = false;
-    _onValidation = false;
-    _validateOnServer = false;
-    _value;
-    _visibleLabel = false;
-    _captureType = '';
-    _defaultValue = '';
-    _defaultEditable = false;
-    _externalValue;
-    _fieldAlignment = '';
-    _fieldInfo = '';
-    _fieldRequired = false;
-    _fieldTitle = '';
-    _fieldType = '';
-    _fieldFormat = null;
-    _hasChanged = false;
-    _outputOnly = false;
-    _tooltipText = '';
-    _placeholder = '';
-    _fieldCode = '';
-    _fieldOptions = null;
-    constructor(inputFieldReceived, formConfig) {
-        super(inputFieldReceived, formConfig);
-        this.propagationCustomAttributes = this._formConfig?.propagationCustomAttributes?.fields ?? [];
-        this.elementType = elementTypes.field;
-        const fld = (inputFieldReceived) ? inputFieldReceived : {};
-        this.setAttr(attrs$1.fieldCode, fld.fieldCode);
-        this.title = fld.fieldTitle ?? this._fieldCode;
-        this.placeholder = fld.placeholder ?? this.title;
-        this.type = fld.fieldTypeCode;
-        this.captureType = fld.captureType ?? DEFAULT_CAPTURE_TYPE;
-        const defaultValue = fld.defaultValue ?? null;
-        if (this._fieldType === this._formConfig.fieldTypes.boolean) {
-            this.defaultValue = defaultValue ?? false;
-        }
-        else {
-            this.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.alignment = fieldAlignment;
-        this.info = fld.info || '';
-        let fieldFormat;
-        try {
-            if (fld.format && typeof fld.format === 'string') {
-                fieldFormat = new RegExp(fld.format);
-            }
-            else if (fld.format?.regExp) {
-                fieldFormat = new RegExp(fld.format?.regExp);
-            }
-        }
-        catch (e) {
-            fieldFormat = null;
-        }
-        this.format = fieldFormat;
-        this.validateOnServer = fld.serverAction ?? false;
-        this.tooltip = fld.tooltip || '';
-        this.defaultEditable = this.enabled;
-        this.required = fld.required ?? false;
-        this.outputOnly = fld.outputOnly ?? false;
-        this.minLength = fld.minLength ?? 0;
-        this.maxLength = fld.maxLength || (this._captureType === 'TEXTAREA' ? BIG_MAX_LENGTH : STD_MAX_LENGTH);
-        this.intrinsicErrorMessage = this._formConfig?.fieldValidations?.[this._fieldType]?.message
-            ?? this._formConfig?.fieldValidations?.DEFAULT?.message ?? '';
-        this.setError(fld.errorCode, fld.errorMessage, fld.errorType ?? DEFAULT_ERROR_TYPE);
-        this.setEditable(fld.editable ?? true);
-        this.visibleLabel = fld.visibleLabel ?? true;
-        this.setVisibility(fld.visible);
-        this.options = fld.fieldOptions;
-        this._setValue(fld.fieldValue ?? this._defaultValue ?? '');
-    }
-    get alignment() { return this._fieldAlignment; }
-    set alignment(alignment) { this.setAttr(attrs$1.fieldAlignment, alignment); }
-    get backend() { return this._validateOnServer; }
-    get captureType() { return this._captureType; }
-    set captureType(captureType) { this.setAttr(attrs$1.captureType, captureType); }
-    get placeholder() { return this._placeholder; }
-    set placeholder(placeholder) { this.setAttr(attrs$1.placeholder, placeholder); }
-    get code() { return this._fieldCode; }
-    get defaultValue() { return this._defaultValue; }
-    set defaultValue(defaultValue) { this.setAttr(attrs$1.defaultValue, defaultValue); }
-    get defaultEditable() { return this._defaultEditable; }
-    set defaultEditable(editable) { this.setAttr(attrs$1.defaultEditable, editable); }
-    get detailRequest() { return this._detailRequest.asObservable(); }
-    get customEvent() { return this._customEvent.asObservable(); }
-    get editionFinish() { return this._editionFinish.asObservable(); }
-    get editionPartial() { return this._editionPartial.asObservable(); }
-    get empty() {
-        const fieldCurrentValue = this.value;
-        if (fieldCurrentValue === undefined || fieldCurrentValue === null) {
-            return true;
-        }
-        if (this._fieldType === this._formConfig.fieldTypes.array
-            && Array.isArray(fieldCurrentValue) && fieldCurrentValue.length === 0) {
-            return true;
-        }
-        ;
-        if (this._fieldType === this._formConfig.fieldTypes.phone) {
-            if (!Array.isArray(fieldCurrentValue)) {
-                return true;
-            }
-            if (fieldCurrentValue.length !== 2 || !fieldCurrentValue[0] || !fieldCurrentValue[1]) {
-                return true;
-            }
-            return false;
-        }
-        ;
-        const arrayFieldTypes = this._formConfig.arrayFieldTypes ?? null;
-        if (arrayFieldTypes && Object.keys(arrayFieldTypes).includes(this._fieldType)) {
-            let arraySize = arrayFieldTypes[this._fieldType];
-            arraySize = !Number.isNaN(+arraySize) ? +arraySize : 0;
-            if (arraySize === 0) {
-                return (Array.isArray(fieldCurrentValue) && fieldCurrentValue.length === 0);
-            }
-            return (Array.isArray(fieldCurrentValue) && fieldCurrentValue.length < arraySize);
-        }
-        ;
-        return fieldCurrentValue === '';
-    }
-    get error() { return { type: this._errorType, code: this._errorCode, message: this._errorMessage }; }
-    set error(errorObj) { this.setError(errorObj.code, errorObj.message, errorObj.type ?? DEFAULT_ERROR_TYPE); }
-    get errorCode() { return this._errorCode; }
-    set errorCode(code) { this.setError(code, this._errorMessage); }
-    get errorMessage() { return this._errorMessage; }
-    set errorMessage(msg) { this.setError(this._errorCode, msg); }
-    get errorType() { return this._errorType; }
-    get externalValue() { return this._externalValue; }
-    get format() { return this._fieldFormat; }
-    set format(format) { this.setAttr(attrs$1.fieldFormat, format); }
-    get hasChanged() { return this._hasChanged; }
-    set hasChanged(hasChanged) { this.setAttr(attrs$1.hasChanged, hasChanged); }
-    get info() { return this._fieldInfo; }
-    set info(newInfo) { this.setAttr(attrs$1.fieldInfo, newInfo); }
-    set intrinsicErrorMessage(message) { this.setAttr(attrs$1.intrinsicErrorMessage, message); }
-    get maxLength() { return (this._maxLength > 0) ? this._maxLength.toString() : ''; }
-    set maxLength(requiredMaxLength) { this.setAttr(attrs$1.maxLength, requiredMaxLength ? +requiredMaxLength : null); }
-    get maxValue() { return this._maxValue; }
-    set maxValue(inputMaxValue) {
-        let maxValue = inputMaxValue;
-        if (this._fieldType === this._formConfig.fieldTypes.date) {
-            maxValue = new Date(maxValue);
-        }
-        this.setAttr(attrs$1.maxValue, maxValue);
-    }
-    get minLength() { return this._minLength; }
-    set minLength(requiredMinLength) {
-        this.setAttr(attrs$1.minLength, requiredMinLength ? +requiredMinLength : null);
-    }
-    get minValue() { return this._minValue; }
-    set minValue(inputMinValue) {
-        let minValue = inputMinValue;
-        if (this._fieldType === this._formConfig.fieldTypes.date) {
-            minValue = new Date(minValue);
-        }
-        this.setAttr(attrs$1.minValue, minValue);
-    }
-    get name() { return this._fieldCode; }
-    get options() {
-        return this._fieldOptions?.map(option => {
-            const optionCopy = { ...option };
-            return optionCopy;
-        }) ?? [];
-    }
-    set options(newOptions) {
-        if ((!this._formConfig.captureTypesWithOptions.includes(this._captureType))
-            || typeof newOptions === UNDEFINED || !newOptions
-            || !Array.isArray(newOptions)) {
-            return;
-        }
-        let fieldOptions = newOptions.map((option) => {
-            if (option.text !== undefined && option.text !== null
-                && option.value !== undefined && option.value !== null) {
-                return { fieldOptionValue: option.text, fieldOptionId: option.value };
-            }
-            return option;
-        });
-        fieldOptions = (fieldOptions && Array.isArray(fieldOptions)
-            && fieldOptions.length > 0) ? fieldOptions : [];
-        this.setAttr(attrs$1.fieldOptions, fieldOptions);
-        if (this._value) {
-            if (this._fieldType === this._formConfig.fieldTypes.array && Array.isArray(this._value)) {
-                const fieldValue = this._value?.filter(item => this._fieldOptions?.find(opt => opt.fieldOptionId === item));
-                this.setAttr(attrs$1.value, fieldValue);
-            }
-            else {
-                const valInOptions = this._fieldOptions?.find(item => item.fieldOptionId === this._value);
-                if (!valInOptions) {
-                    this._setValue('');
-                }
-            }
-        }
-        if (this._fieldRequired && this._fieldOptions?.length === 1 && this._value !== this._fieldOptions?.[0].fieldOptionId) {
-            this._setValue(this._fieldOptions?.[0].fieldOptionId);
-            this.notifyEditionFinish();
-        }
-    }
-    get optionText() { return this._fieldOptions?.find(item => item.fieldOptionId === this._value)?.fieldOptionValue ?? null; }
-    get outputOnly() { return this._outputOnly; }
-    set outputOnly(outputOnly) { this.setAttr(attrs$1.outputOnly, outputOnly); }
-    get required() { return this._fieldRequired; }
-    set required(required) { this.setAttr(attrs$1.fieldRequired, required ?? false); }
-    get title() { return this._fieldTitle; }
-    set title(title) { this.setAttr(attrs$1.fieldTitle, title?.toString() ?? ''); }
-    get tooltip() { return this._tooltipText; }
-    set tooltip(tooltip) { this.setAttr(attrs$1.tooltipText, tooltip); }
-    get type() { return this._fieldType; }
-    set type(fieldType) { this.setAttr(attrs$1.fieldType, fieldType); }
-    get onValidation() { return this._onValidation; }
-    get validating() { return this._onValidation; }
-    set validating(isValidating) { this.setAttr(attrs$1.onValidation, isValidating); }
-    get value() {
-        return (this._fieldType === this._formConfig.fieldTypes.boolean
-            || this._fieldType === this._formConfig.fieldTypes.check) ? yn(this._value) : this._value;
-    }
-    get validateOnServer() { return this._validateOnServer; }
-    set validateOnServer(validateOnServer) { this.setAttr(attrs$1.validateOnServer, validateOnServer); }
-    get serverAction() { return this._validateOnServer; }
-    set serverAction(validateOnServer) { this.validateOnServer = validateOnServer; }
-    set value(newValue) { this._setValue(newValue); }
-    get visibleLabel() { return this._visibleLabel; }
-    set visibleLabel(visibleLabel) { this.setAttr(attrs$1.visibleLabel, visibleLabel); }
-    /**
-     * @deprecated Use value
-     */
-    get fieldValue() { return this.value; }
-    /**
-     * @deprecated Use hasChanged
-     */
-    changed(hasChanged = true) { this.hasChanged = hasChanged; }
-    clean() { this._setValue(this._defaultValue || ''); this.resetError(); }
-    focus() { this.setAttr(attrs$1.focus, true); }
-    getErrorCode() { return this.error.code; }
-    setErrorCode(code) { this.setError(code, this._errorMessage); }
-    getErrorMessage() { return this.error.message; }
-    setErrorMessage(msg) { this.setError(this._errorCode, msg); }
-    getRequired() { return this.required; }
-    hasError() { return this._errorCode !== NO_ERROR; }
-    hideLabel() { this.visibleLabel = false; }
-    resetError() { (this._errorCode !== NO_ERROR) && this.setError(NO_ERROR, null); }
-    setEditable(editable = true) { (editable) ? this.enable() : this.disable(); }
-    setValue(newValue, widgetUpdate = true) { this._setValue(newValue, widgetUpdate); }
-    showLabel() { this.visibleLabel = true; }
-    /**
-     * @deprecated Use code
-     */
-    get fieldCode() { return this._fieldCode; }
-    /**
-     * @deprecated Use title
-     */
-    setLabel(label) { this.title = label; }
-    /**
-     * @deprecated Use required
-     */
-    setRequired(required) { this.required = required; }
-    /**
-     * @deprecated Use changed
-     */
-    setChanged(hasChanged) { this.changed(hasChanged); }
-    /**
-     * @deprecated Use value
-     */
-    getValue() { return this.value; }
-    /**
-     * @deprecated Use empty
-     */
-    isEmpty() { return this.empty; }
-    /**
-     * @deprecated Use error
-     */
-    getError() { return this.error; }
-    /**
-     * @deprecated Use optionText
-     */
-    getOptionText() { return this.optionText; }
-    /**
-     * @deprecated Use options
-     */
-    getFieldOptions() { return this.options; }
-    /**
-     * @deprecated Use options
-     */
-    setFieldOptions(newOptions) { return this.options = newOptions; }
-    /**
-     * @deprecated Use intrinsicErrorMessage
-     */
-    setIntrinsicErrorMessage(message) { this.intrinsicErrorMessage = message; }
-    /**
-     * @deprecated Use maxValue
-     */
-    setMaxValue(inputMaxValue) { this.maxValue = inputMaxValue; }
-    /**
-     * @deprecated Use minValue
-     */
-    setMinValue(inputMinValue) { this.minValue = inputMinValue; }
-    /**
-     * @deprecated Use showLabel
-     */
-    setVisibleLabel(visibleLabel) { this.visibleLabel = visibleLabel; }
-    notifyEditionPartial() {
-        this.resetError();
-        this._editionPartial.next({ code: this._fieldCode, intrinsicValidation: true });
-    }
-    triggerCustomEvent(eventName, eventData) {
-        this._customEvent.next({ code: this._fieldCode, eventName, eventData });
-    }
-    notifyEditionFinish() {
-        const fieldValue = this.value;
-        this.resetError();
-        const validationConfig = this._formConfig.fieldValidations?.[this._fieldType] ?? {};
-        const { type, validation } = validationConfig;
-        let message = validationConfig?.message;
-        let intrinsicValidation = true;
-        if (fieldValue && (validation || this._fieldFormat)) {
-            if (type === 'regexp') {
-                intrinsicValidation = (validation?.test(fieldValue) ?? true)
-                    && (this._fieldFormat?.test(fieldValue) ?? true);
-            }
-            else if (type === 'function' && typeof validation === 'function') {
-                const { valid, message: customMessage } = validation(fieldValue, this);
-                intrinsicValidation = valid;
-                message = customMessage;
-            }
-            if (!intrinsicValidation) {
-                this.setError('99', message ?? 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');
-        }
-        if (intrinsicValidation && fieldValue && typeof fieldValue === 'string'
-            && this._minLength && fieldValue?.length < this._minLength) {
-            intrinsicValidation = false;
-            this.setError('99', `Longitud de ${this._fieldTitle} debe ser de al menos ${this._minLength}`);
-        }
-        this._editionFinish.next({ code: this._fieldCode, intrinsicValidation });
-    }
-    notifyEditionDetailRequest(detail) {
-        const detailEvent = { code: this._fieldCode, detail };
-        this._detailRequest.next(detailEvent);
-    }
-    setError(code, message, type = DEFAULT_ERROR_TYPE) {
-        this.setAttr(attrs$1.errorCode, code ?? NO_ERROR);
-        this.setAttr(attrs$1.errorType, (this._errorCode === NO_ERROR) ? '' : type);
-        this.setAttr(attrs$1.errorMessage, message ?? '');
-    }
-    updateFromServer(fld) {
-        const fieldKeys = Object.keys(fld);
-        for (let index = 0; index < fieldKeys.length; index++) {
-            const attrName = fieldKeys[index];
-            const attrValue = fld[attrName];
-            if (directChanges.includes(attrName)) {
-                this[attrName] = attrValue;
-            }
-            else {
-                (attrName === 'label') && (this.title = attrValue);
-                (attrName === 'labelVisible') && (this.visibleLabel = attrValue);
-                (attrName === 'editable') && this.setEditable(attrValue);
-                (attrName === 'visible') && this.setVisibility(attrValue);
-                (attrName === 'value') && (this._setValue(attrValue) && (this.hasChanged = false));
-                (attrName === 'fieldValue') && (this._setValue(attrValue) && (this.hasChanged = false));
-                (attrName === 'fieldOptions') && (this.options = attrValue);
-                (attrName === 'fieldTitle') && (this.title = attrValue);
-                (attrName === 'fieldTypeCode') && (this.type = attrValue);
-                (attrName === 'fieldType') && (this.type = attrValue);
-                (attrName === 'tooltipText') && (this.tooltip = attrValue);
-                (attrName === 'customAttributes') && (this.setCustomAttributes(attrValue));
-            }
-        }
-    }
-    _setValue(newValue, widgetUpdate = true) {
-        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 = yn(newValue) ?? 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._hasChanged = true;
-            if (widgetUpdate) {
-                this.setAttr(attrs$1.value, newFinalValue);
-            }
-            else {
-                this._value = newFinalValue;
-            }
-        }
-        return true;
-    }
-}
-
-class RecordTableColumn extends FormPiece {
-    fieldCode = '';
-    fieldTitle = '';
-    fieldType = '';
-    fieldAlignment = '';
-    fieldFormat = '';
-    sortable = true;
-    searchable = true;
-    sortDirections = [];
-    // Filtros
-    filterVisible = false;
-    filterDef = null;
-    filterSetup = null;
-    constructor(recTableColReceived, formConfig) {
-        super(recTableColReceived, 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._absoluteVisible = recTableColReceived?.visible ?? true;
-            this.sortable = recTableColReceived?.sortable ?? false;
-            this.searchable = recTableColReceived?.searchable ?? true;
-            this.sortDirections = (this.sortable) ? ['ascend', 'descend'] : [];
-            this.fieldFormat = recTableColReceived.format || '';
-            this.customAttributes = recTableColReceived?.customAttributes ?? {};
-        }
-    }
-    setSearchable(searchable = true) { this.searchable = searchable; }
-    hideFilter() {
-        this.filterVisible = false;
-    }
-    addFilterDefinition(filterDefinition) {
-        this.filterDef = {
-            operators: filterDefinition.operators,
-            options: filterDefinition.options ?? null,
-        };
-    }
-    get filterDefinition() {
-        return this.filterDef;
-    }
-    addFilter(columnValues, operator) {
-        this.filterSetup = {
-            fieldCode: this.fieldCode,
-            operator: operator ?? this.filterDef?.operators[0] ?? 'IN',
-            values: columnValues,
-        };
-    }
-    get filter() {
-        return this.filterSetup;
-    }
-    removeFilter() {
-        this.filterSetup = null;
-    }
-    get options() {
-        if (this.filterDef?.operators?.length === 1 && this.filterDef?.operators[0] === 'IN') {
-            return this.filterDef?.options;
-        }
-        return null;
-    }
-    serSortDirections(ascend, descend) {
-        this.sortDirections = [];
-        if (ascend) {
-            this.sortDirections.unshift('ascend');
-        }
-        if (descend) {
-            this.sortDirections.unshift('descend');
-        }
-    }
-}
-
-class TableAction extends FormPiece {
-    actionCode;
-    actionTitle;
-    iconName;
-    actionType;
-    actionClass;
-    stateField;
-    newState;
-    backend;
-    restrictedOnField = null;
-    restrictedOnValue = null;
-    restrictedOnOperator = null;
-    constructor(actionDefinition, formConfig) {
-        super(actionDefinition, formConfig);
-        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.backend = actionDefinition?.serverAction ?? false;
-        this.restrictedOnField = actionDefinition.fieldRestrictedCode ?? null;
-        if (this.restrictedOnField) {
-            this.restrictedOnValue = actionDefinition.valueRestricted ?? null;
-            this.restrictedOnOperator = actionDefinition.operatorRestricted || null;
-        }
-    }
-    formStateChange(state) {
-        if (state) {
-            this._formState = state;
-            this._visible = this._absoluteVisible && this.viewOnState(state);
-            this._disabled = this._absoluteDisabled || !this.enabledOnState(state);
-        }
-    }
-}
-
-class TableRecordData {
-    recordId = null;
-    selected = false;
-    recordData = {};
-    constructor(recordReceived, recordDefinition, selectionFieldName = null) {
-        const { tableRecordId, recordData } = recordReceived;
-        this.recordId = tableRecordId;
-        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 ?? '';
-                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 ?? '';
-            });
-        }
-    }
-    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 word of words) {
-            let wordIsPresent = false;
-            for (const fieldCode in this.recordData) {
-                const columnDef = columnObj?.[fieldCode];
-                if (columnDef?.searchable && this.recordData.hasOwnProperty(fieldCode)) {
-                    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)) {
-                        wordIsPresent = true;
-                        break;
-                    }
-                }
-            }
-            if (!wordIsPresent) {
-                return false;
-            }
-        }
-        return true;
-    }
-    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';
-const attrs = {
-    allSelected: { name: 'allSelected', propagate: 'allSelected' },
-    tableCode: { name: 'tableCode', propagate: 'code' },
-    clientPaging: { name: 'clientPaging', propagate: null },
-    globalSearch: { name: 'globalSearch', propagate: 'globalSearch' },
-    globalFilterString: { name: '_globalFilterString', propagate: 'globalFilterString' },
-    sorting: { name: 'sorting', propagate: null },
-    recordsPerPage: { name: 'recordsPerPage', propagate: 'recordsPerPage' },
-    layout: { name: 'layout', propagate: 'layout' },
-    columns: { name: 'columns', propagate: 'columns' },
-    selectedRecords: { name: 'selectedRecords', propagate: 'selectedRecords' },
-    currentPage: { name: 'currentPage', propagate: 'currentPage' },
-    totalRecordsNumber: { name: 'totalRecordsNumber', propagate: 'totalRecordsNumber' },
-    visibleRecords: { name: '_visibleRecords', propagate: 'visibleRecords' },
-    waiting: { name: '_waiting', propagate: 'waiting' },
-};
-class RecordTable extends FormElement {
-    _inlineActionTrigger = new Subject();
-    _globalActionTrigger = new Subject();
-    _recordSelectionTrigger = new Subject();
-    _selectionActionTrigger = new Subject();
-    _getDataTrigger = new Subject();
-    _tableColumnObj = {};
-    _appendPages;
-    _actions;
-    _actionsObj = {};
-    // Mecanismos de filtrado nueva versión
-    _globalFilterString = '';
-    globalFilterStrings = [];
-    selectedRecords;
-    restrictedId;
-    layout = null;
-    _globalSearch;
-    _tableRecords;
-    _tableRecordObj = {};
-    _visibleRecords = [];
-    _columns;
-    _selectable;
-    _selectionBackend;
-    _selectionField;
-    _allSelected = false;
-    _tableCode = '';
-    _tableTitle;
-    _currentPage;
-    _totalPages;
-    _requestedPage;
-    _recordsPerPage = 10;
-    _totalRecordsNumber = 0;
-    _recordsNumber = 0;
-    _sorting;
-    _waiting;
-    _clientPaging = true;
-    _sortable;
-    constructor(tableReceived, formConfig) {
-        super(tableReceived, formConfig);
-        this.propagationCustomAttributes = this._formConfig?.propagationCustomAttributes?.tables ?? [];
-        this.elementType = elementTypes.table;
-        this._waiting = false;
-        this._currentPage = 1;
-        this._totalPages = 1;
-        this._requestedPage = 1;
-        this._columns = [];
-        this._tableColumnObj = {};
-        this._actions = [];
-        this._actionsObj = {};
-        this._tableRecords = [];
-        this._globalSearch = false;
-        this.restrictedId = null;
-        this._tableTitle = tableReceived.tableTitle;
-        this._appendPages = tableReceived?.append ?? false;
-        this._selectable = tableReceived?.selectable ?? false;
-        this._selectionBackend = tableReceived?.selectionBackend ?? false;
-        this._sortable = tableReceived?.sortable ?? false;
-        this.setAttr(attrs.allSelected, false);
-        this.setAttr(attrs.tableCode, tableReceived.tableCode);
-        this.setAttr(attrs.clientPaging, tableReceived?.clientPaging ?? true);
-        this.setAttr(attrs.globalSearch, tableReceived?.simpleFilter ?? false);
-        this.setAttr(attrs.globalFilterString, '');
-        this.setAttr(attrs.sorting, { columnName: '', direction: '' });
-        this.setAttr(attrs.recordsPerPage, formConfig.defaultRecordsPerPage);
-        this.setAttr(attrs.layout, '');
-        if (tableReceived.fields) {
-            const columns = [];
-            for (const columnReceived of tableReceived.fields) {
-                const columnEnriched = {
-                    ...columnReceived,
-                    visibleStates: this.visibleStates,
-                    enabledStates: this.enabledStates
-                };
-                const columnDefinition = new RecordTableColumn(columnEnriched, this._formConfig);
-                columns.push(columnDefinition);
-                this._tableColumnObj[columnDefinition.fieldCode] = columnDefinition;
-            }
-            this.setAttr(attrs.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 { ...objDef, visibleStates, enabledStates };
-            });
-            for (const actionReceived of tableActions) {
-                const inlineAction = new TableAction(actionReceived, this._formConfig);
-                this._actions.push(inlineAction);
-                this._actionsObj[inlineAction.actionCode] = inlineAction;
-            }
-        }
-        this._selectionField = (this._selectable) ? 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.asObservable(); }
-    get globalActionTrigger() { return this._globalActionTrigger.asObservable(); }
-    get selectionActionTrigger() { return this._selectionActionTrigger.asObservable(); }
-    get recordSelectionTrigger() { return this._recordSelectionTrigger.asObservable(); }
-    get getDataTrigger() { return this._getDataTrigger.asObservable(); }
-    get globalSearch() { return this._globalSearch; }
-    get tableRecords() { return this._tableRecords; }
-    get tableRecordObj() { return this._tableRecordObj; }
-    get visibleRecords() { return this._visibleRecords; }
-    get columns() { return this._columns; }
-    get selectable() { return this._selectable; }
-    get selectionBackend() { return this._selectionBackend; }
-    get selectionField() { return this._selectionField; }
-    get allSelected() { return this._allSelected; }
-    get tableCode() { return this._tableCode; }
-    get tableTitle() { return this._tableTitle; }
-    get currentPage() { return this._currentPage; }
-    get totalPages() { return this._totalPages; }
-    get requestedPage() { return this._requestedPage; }
-    get recordsPerPage() { return this._recordsPerPage; }
-    get totalRecordsNumber() { return this._totalRecordsNumber; }
-    get recordsNumber() { return this._recordsNumber; }
-    get sorting() { return this._sorting; }
-    get waiting() { return this._waiting; }
-    get clientPaging() { return this._clientPaging; }
-    get sortable() { return this._sortable; }
-    get globalFilterString() { return this._globalFilterString; }
-    set globalFilterString(globalFilterString) { this._globalFilterString = globalFilterString; }
-    set globalSearch(globalSearch) { this._globalSearch = globalSearch; }
-    set tableRecords(tableRecords) { this._tableRecords = tableRecords; }
-    set tableRecordObj(tableRecordObj) { this._tableRecordObj = tableRecordObj; }
-    set visibleRecords(visibleRecords) { this._visibleRecords = visibleRecords ?? []; }
-    set columns(columns) { this._columns = columns; }
-    set selectable(selectable) { this._selectable = selectable; }
-    set selectionBackend(selectionBackend) { this._selectionBackend = selectionBackend; }
-    set selectionField(selectionField) { this._selectionField = selectionField; }
-    set allSelected(allSelected) { this._allSelected = allSelected; }
-    set tableCode(tableCode) { this._tableCode = tableCode; }
-    set tableTitle(tableTitle) { this._tableTitle = tableTitle; }
-    set currentPage(currentPage) { this._currentPage = currentPage; }
-    set totalPages(totalPages) { this._totalPages = totalPages; }
-    set requestedPage(requestedPage) { this._requestedPage = requestedPage; }
-    set recordsPerPage(recordsPerPage) { this._recordsPerPage = recordsPerPage; }
-    set totalRecordsNumber(totalRecordsNumber) { this._totalRecordsNumber = totalRecordsNumber; }
-    set recordsNumber(recordsNumber) { this._recordsNumber = recordsNumber; }
-    set sorting(sorting) { this._sorting = sorting; }
-    set waiting(waiting) { this.setAttr(attrs.waiting, waiting); }
-    set clientPaging(clientPaging) { this._clientPaging = clientPaging; }
-    set sortable(sortable) { this._sortable = sortable; }
-    getLayout() { return this.layout; }
-    setLayout(layout) { this.setAttr(attrs.layout, layout); }
-    hasActions() { return (this._actions.length > 0); }
-    getSelectedRecords() { return this._tableRecords.filter(rec => rec.selected).map(rec => rec.recordId); }
-    activateGlobalSearch() { this._globalSearch = true; }
-    inactivateGlobalSearch() { this._globalSearch = false; }
-    columnDefinition(fieldCode) { return this._tableColumnObj[fieldCode]; }
-    putOnWait() { this.waiting = true; }
-    freeWaiting() { this.waiting = false; }
-    setWidget(widget) { this.widget = widget; }
-    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();
-        this._requestedPage = this._currentPage ?? 1;
-        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 || 1;
-        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(attrs.allSelected, true);
-        this._tableRecords.forEach(record => record.select());
-        this.setAttr(attrs.selectedRecords, this.getSelectedRecords());
-        return true;
-    }
-    unSelectAll() {
-        this.setAttr(attrs.allSelected, false);
-        this._tableRecords.forEach(record => record.unselect());
-        this.setAttr(attrs.selectedRecords, this.getSelectedRecords());
-        return true;
-    }
-    setTableRecords(tableRecords, append = false, prepend = false) {
-        if (!append) {
-            this._tableRecords = [];
-            this._tableRecordObj = {};
-            this.setAttr(attrs.allSelected, false);
-            this.setAttr(attrs.selectedRecords, []);
-        }
-        const newRecordsObj = { ...this._tableRecordObj };
-        const newRecords = [...this._tableRecords];
-        for (const tableRecord of tableRecords) {
-            tableRecord.tableRecordId = tableRecord.tableRecordId ?? tableRecord.recordId ?? tableRecord.recordIdKey;
-            const recordReceived = new TableRecordData(tableRecord, this._columns, this._selectionField);
-            const recordIdKey = recordReceived.recordIdKey ?? recordReceived.recordIdKey;
-            if (newRecordsObj[recordIdKey]) {
-                continue;
-            }
-            if (prepend) {
-                newRecords.unshift(recordReceived);
-            }
-            else {
-                newRecords.push(recordReceived);
-            }
-            newRecordsObj[recordIdKey] = recordReceived;
-        }
-        this._tableRecords = newRecords;
-        this._tableRecordObj = newRecordsObj;
-    }
-    appendRecords(records) { this.setTableRecords(records, true); }
-    prependRecords(records) { this.setTableRecords(records, true, true); }
-    replaceRecords(records) { this.setTableRecords(records, false); }
-    setTableAppend(append) { this._appendPages = append; }
-    changePage(requestedPage) {
-        if (this._clientPaging) {
-            this.setAttr(attrs.currentPage, requestedPage);
-            this.updateVisibleRecords();
-        }
-        else {
-            this.notifyGetDataAction(requestedPage);
-        }
-    }
-    updateVisibleRecords() {
-        let visibleRecords;
-        if (this._clientPaging) {
-            visibleRecords = this.getFilteredRecords();
-            // Se valida si la página actual sigue siendo válida
-            const totalRecords = visibleRecords.length;
-            const recordsLastPage = totalRecords % this._recordsPerPage;
-            const totalPages = Math.trunc(totalRecords / this._recordsPerPage + (recordsLastPage ? 1 : 0));
-            if (this._currentPage > totalPages) {
-                this._currentPage = totalPages || 1;
-            }
-            const sliceNumber1 = (this._currentPage - 1) * this._recordsPerPage;
-            const sliceNumber2 = (this._currentPage - 1) * this._recordsPerPage + this._recordsPerPage;
-            visibleRecords = visibleRecords.slice(sliceNumber1, sliceNumber2);
-            this.setAttr(attrs.totalRecordsNumber, totalRecords);
-        }
-        else {
-            visibleRecords = this._tableRecords;
-        }
-        this.setAttr(attrs.visibleRecords, visibleRecords ?? []);
-    }
-    updateFromServer(tableReceived) {
-        this._requestedPage = 1;
-        const { visible = true, totalPages = 1, recordsNumber, currentPage = 1, recordsPerPage, totalRecordsNumber, sortingColumn, sortingDirection, tableRecords, actions, fields, } = tableReceived;
-        this.visible = visible;
-        if (actions) {
-            Object.keys(actions).forEach(actionCode => {
-                const tblAction = this.getAction(actionCode);
-                const actionReceived = actions[actionCode];
-                if (actionReceived.visible === true || actionReceived.visible === false) {
-                    (actionReceived.visible === true) && tblAction.show();
-                    (actionReceived.visible === false) && tblAction.hide();
-                }
-                if (actionReceived.enabled === true || actionReceived.enabled === false) {
-                    (actionReceived.enabled === true) && tblAction.enable();
-                    (actionReceived.enabled === false) && tblAction.disable();
-                }
-                if (actionReceived.showOnStates) {
-                    actionReceived.showOnStates?.forEach(newState => {
-                        tblAction.addVisibleState(newState);
-                    });
-                }
-                if (actionReceived.hideOnStates) {
-                    actionReceived.hideOnStates?.forEach(newState => {
-                        tblAction.removeVisibleState(newState);
-                    });
-                }
-                if (actionReceived.enableOnStates) {
-                    actionReceived.enableOnStates?.forEach(newState => {
-                        tblAction.addEnabledState(newState);
-                    });
-                }
-                if (actionReceived.disableOnStates) {
-                    actionReceived.disableOnStates?.forEach(newState => {
-                        tblAction.removeEnabledState(newState);
-                    });
-                }
-            });
-        }
-        if (fields) {
-            Object.keys(fields).forEach(fieldCode => {
-                const tblField = this.columnDefinition(fieldCode);
-                const fieldReceived = fields[fieldCode];
-                if (fieldReceived.visible === true || fieldReceived.visible === false) {
-                    (fieldReceived.visible === true) && tblField.show();
-                    (fieldReceived.visible === false) && tblField.hide();
-                }
-            });
-        }
-        if (tableRecords) {
-            this._totalPages = totalPages;
-            this._recordsNumber = recordsNumber;
-            this.setAttr(attrs.currentPage, +currentPage);
-            this.setAttr(attrs.recordsPerPage, +recordsPerPage);
-            this.setAttr(attrs.totalRecordsNumber, (this._clientPaging) ? tableRecords.length : +totalRecordsNumber);
-            this.setAttr(attrs.sorting, {
-                columnName: sortingColumn || '',
-                direction: sortingDirection || ''
-            });
-            if (!this._appendPages) {
-                this.replaceRecords(tableRecords);
-            }
-            else {
-                this.appendRecords(tableRecords);
-            }
-        }
-        this.freeWaiting();
-        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, notifyComponent = true) {
-        this.globalFilterStrings = text.split(' ').filter(t => t && t.trim().length > 0).map(t => t.trim()) ?? [];
-        if (this._clientPaging) {
-            this.changePage(1);
-        }
-        if (notifyComponent) {
-            this.setAttr(attrs.globalFilterString, text.trim());
-        }
-    }
-    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) {
-        const tableColumn = this.columnDefinition(columnName);
-        return tableColumn?.filter ?? null;
-    }
-    addColumnFilter(columnName, columnValues, operator = null) {
-        const tableColumn = this.columnDefinition(columnName);
-        const columnFilterDefinition = tableColumn?.filterDefinition ?? null;
-        if (!columnFilterDefinition) {
-            return;
-        }
-        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(attrs.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;
-    }
-    formStateChangeCustomSubscribe(form, formChangeSubject) {
-        this._columns?.forEach(column => {
-            column?.connectWithParentForm(form, formChangeSubject);
-        });
-        this._actions?.forEach(action => {
-            action?.connectWithParentForm(form, formChangeSubject);
-        });
-    }
-}
-
-class RecordFormSubSection extends FormPiecePropagate {
-    _customRender = null;
-    _subsectionId = null;
-    _subsectionCode = null;
-    _subsectionTitle = null;
-    _subSectionElements = [];
-    _subSectionFields = [];
-    _subSectionTables = [];
-    _subSectionActions = [];
-    _elementsArray = {};
-    _active = false;
-    constructor(subsectionReceived, formObject, formConfig) {
-        super(subsectionReceived, formConfig);
-        this.propagationCustomAttributes = this._formConfig?.propagationCustomAttributes?.subsections ?? [];
-        if (!subsectionReceived) {
-            return;
-        }
-        this._subsectionId = (subsectionReceived.subsectionId) ? subsectionReceived.subsectionId.toString() : '';
-        this._subsectionCode = (subsectionReceived.subsectionCode) ? subsectionReceived.subsectionCode : '';
-        this._subsectionTitle = (subsectionReceived.subsectionTitle) ? subsectionReceived.subsectionTitle : '';
-        if (subsectionReceived.elements) {
-            for (const receivedElement of subsectionReceived.elements) {
-                let elementObject = null;
-                let arrayToAdd = [];
-                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;
-                }
-            }
-        }
-    }
-    get customRender() { return this._customRender; }
-    set customRender(customRenderName) { this._customRender = customRenderName; }
-    get subsectionId() { return this._subsectionId; }
-    get subsectionCode() { return this._subsectionCode; }
-    get subsectionTitle() { return this._subsectionTitle; }
-    get subSectionElements() { return this._subSectionElements; }
-    get subSectionFields() { return this._subSectionFields; }
-    get subSectionTables() { return this._subSectionTables; }
-    get subSectionActions() { return this._subSectionActions; }
-    get elementsArray() { return this._elementsArray; }
-    get active() { return this._active; }
-    set subsectionId(subsectionId) { this._subsectionId = subsectionId; }
-    set subsectionCode(subsectionCode) { this._subsectionCode = subsectionCode; }
-    set subsectionTitle(subsectionTitle) { this._subsectionTitle = subsectionTitle; }
-    set subSectionElements(subSectionElements) { this._subSectionElements = subSectionElements; }
-    set subSectionFields(subSectionFields) { this._subSectionFields = subSectionFields; }
-    set subSectionTables(subSectionTables) { this._subSectionTables = subSectionTables; }
-    set subSectionActions(subSectionActions) { this._subSectionActions = subSectionActions; }
-    set elementsArray(elementsArray) { this._elementsArray = elementsArray; }
-    set active(active) { this._active = active; }
-    getField(name) {
-        return this._subSectionFields.find(fld => fld.name === name);
-    }
-    getFields() {
-        return this._subSectionFields;
-    }
-    getFieldNames() {
-        return this._subSectionFields.map(field => field.code);
-    }
-    getActions() {
-        return this._subSectionActions;
-    }
-    getActionNames() {
-        return this._subSectionActions.map(action => action.actionCode);
-    }
-    activate() {
-        if (!this._active) {
-            this._active = true;
-            // this.subsectionCode && this._activation.next(this.subsectionCode);
-        }
-    }
-    inactivate() {
-        if (this._active) {
-            this._active = false;
-            // this.subsectionCode && this._inactivation.next(this.subsectionCode);
-        }
-    }
-}
-
-const ACTIVE$1 = 'active';
-class RecordFormSection extends FormPiecePropagate {
-    _activation = new Subject();
-    _inactivation = new Subject();
-    _active = false;
-    _sectionId = null;
-    _sectionCode = null;
-    _sectionTitle = null;
-    _subSections = [];
-    _subSectionsObj;
-    _exclusiveSubSectionsByAttr = {};
-    constructor(sectionReceived, formObject, formConfig) {
-        super(sectionReceived, formConfig);
-        this.propagationCustomAttributes = this._formConfig?.propagationCustomAttributes?.sections ?? [];
-        if (!sectionReceived) {
-            return;
-        }
-        this._sectionId = (sectionReceived.sectionId) ? sectionReceived.sectionId.toString() : '';
-        this._sectionCode = (sectionReceived.sectionCode) ? sectionReceived.sectionCode : '';
-        this._sectionTitle = (sectionReceived.sectionTitle) ? sectionReceived.sectionTitle : '';
-        this._subSections = [];
-        this._subSectionsObj = {};
-        if (sectionReceived.subsections) {
-            const subsections = sectionReceived.subsections.map(subSecDef => {
-                const visibleStates = subSecDef.visibleStates ?? [];
-                if (subSecDef.elements && Array.isArray(subSecDef.elements)) {
-                    subSecDef.elements = subSecDef.elements.map(elm => ({ code: elm.elementCode, type: elm.elementTypeName }));
-                }
-                return { ...subSecDef, visibleStates };
-            });
-            for (const subsectionReceived of subsections) {
-                const subSectionToAdd = new RecordFormSubSection(subsectionReceived, formObject, formConfig);
-                const subsectionCode = subSectionToAdd.subsectionCode;
-                if (subsectionCode) {
-                    this._subSections.push(subSectionToAdd);
-                    this._subSectionsObj[subsectionCode] = subSectionToAdd;
-                }
-            }
-        }
-    }
-    get code() { return this._sectionCode; }
-    get activation() { return this._activation.asObservable(); }
-    get inactivation() { return this._inactivation.asObservable(); }
-    get active() { return this._active; }
-    get sectionId() { return this._sectionId; }
-    get sectionCode() { return this._sectionCode; }
-    get sectionTitle() { return this._sectionTitle; }
-    get subSections() { return this._subSections; }
-    get subSectionsObj() { return this._subSectionsObj; }
-    set active(active) { this._active = active; }
-    set sectionId(sectionId) { this._sectionId = sectionId; }
-    set sectionCode(sectionCode) { this._sectionCode = sectionCode; }
-    set sectionTitle(sectionTitle) { this._sectionTitle = sectionTitle; }
-    set subSections(subSections) { this._subSections = subSections; }
-    set subSectionsObj(subSectionsObj) { this._subSectionsObj = subSectionsObj; }
-    activate() {
-        if (!this._active) {
-            this._active = true;
-            this._sectionCode && this._activation.next(this._sectionCode);
-        }
-    }
-    inactivate() {
-        if (this._active) {
-            this._active = false;
-            this._sectionCode && this._inactivation.next(this._sectionCode);
-        }
-    }
-    get title() { return this._sectionTitle; }
-    set title(title) { this._sectionTitle = title; }
-    getVisibleSubsections(state) {
-        return this._subSections.filter(subSection => subSection.visible);
-    }
-    getSubsection(subSectionCode) {
-        return (this._subSectionsObj && this._subSectionsObj[subSectionCode])
-            ? this._subSectionsObj[subSectionCode] : null;
-    }
-    activateSubSection(subSectionCode) {
-        if (subSectionCode === this._exclusiveSubSectionsByAttr[ACTIVE$1]) {
-            return;
-        }
-        const subSection = (this._subSectionsObj && this._subSectionsObj[subSectionCode])
-            ? this._subSectionsObj[subSectionCode] : null;
-        if (subSection) {
-            subSection?.activate();
-            this._exclusiveSubSectionsByAttr[ACTIVE$1] = subSectionCode;
-        }
-    }
-    getFields() {
-        let fieldsArray = [];
-        if (this._subSections && this._subSections.length > 0) {
-            for (const subSection of this._subSections) {
-                const subsectionFields = subSection.getFields() ?? [];
-                if (subsectionFields?.length > 0) {
-                    fieldsArray = fieldsArray.concat(subsectionFields);
-                }
-            }
-        }
-        return fieldsArray;
-    }
-    getActions() {
-        let actionArray = [];
-        if (this._subSections && this._subSections.length > 0) {
-            for (const subSection of this._subSections) {
-                const subSectionActions = subSection.getActions() ?? [];
-                if (subSectionActions?.length > 0) {
-                    actionArray = actionArray.concat(subSectionActions);
-                }
-            }
-        }
-        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;
-    }
-    formStateChangeCustomSubscribe(form, formChangeSubject) {
-        this._subSections?.forEach(subsection => {
-            subsection?.connectWithParentForm(form, formChangeSubject);
-        });
-    }
-}
-
-const ACTIVE = 'active';
-const SHOW = 'show';
-const HIDE = 'hide';
-const ENABLE = 'enable';
-const DISABLE = 'disable';
-const CLEAN = 'clean';
-const alwaysVisible = 'ALWAYS';
-const neverVisible = 'NONE';
-const onStatesVisible = 'ONSTATES';
-class FormStructureAndData {
-    _stateChange = new Subject();
-    _immutableData = {};
-    _extraInfo = {};
-    _exclusiveSectionsByAttr = {};
-    loadInitialData = true;
-    subject = null;
-    stateFlow;
-    fields = {};
-    actions = {};
-    tables = {};
-    sections = {};
-    fieldArray;
-    actionArray;
-    tableArray;
-    sectionArray;
-    customAttributes = {};
-    formConfig;
-    state;
-    name = '';
-    title = '';
-    constructor() {
-        this.state = '';
-        this.actionArray = [];
-        this.fieldArray = [];
-        this.tableArray = [];
-        this.sectionArray = [];
-        this.stateFlow = {
-            defaultState: '',
-            states: [],
-            stateDescriptions: [],
-            transitions: [],
-        };
-    }
-    setConfig(formConfig) {
-        this.formConfig = formConfig;
-    }
-    cleanForm() {
-        this.actionArray = [];
-        this.fieldArray = [];
-        this.tableArray = [];
-        this.sectionArray = [];
-        this.stateFlow = {
-            defaultState: '',
-            states: [],
-            stateDescriptions: [],
-            transitions: [],
-        };
-    }
-    loadDefinition(definitionReceived) {
-        this.state = '';
-        let allStates = [];
-        this.cleanForm();
-        if (!definitionReceived) {
-            return;
-        }
-        const { form = {} } = definitionReceived;
-        this.name = this.name ?? form.formCode;
-        this.title = form.formTitle ?? this.name;
-        this.loadInitialData = form.loadInitialData ?? true;
-        allStates = definitionReceived?.states;
-        this.setStateFlow(definitionReceived?.states, definitionReceived?.transitions, definitionReceived?.defaultState, definitionReceived?.stateDescriptions);
-        this.immutableData = definitionReceived.immutableData;
-        this.extraInfo = definitionReceived.extraInfo;
-        this.customAttributes = {};
-        if (definitionReceived?.customAttributes) {
-            this.setCustomAttributes(definitionReceived?.customAttributes);
-        }
-        if (definitionReceived.actions) {
-            const formActions = definitionReceived.actions.map(objDef => {
-                let visibleStates = objDef.visibleStates
-                    ?? (objDef.actionModes?.split(',')?.map(state => state.trim())?.filter(state => state))
-                    ?? [];
-                let enabledStates = objDef.enabledStates ?? objDef.editableStates ?? [];
-                if (!Array.isArray(visibleStates) && typeof visibleStates === 'string') {
-                    visibleStates = (visibleStates === neverVisible) ? [] : allStates;
-                }
-                if (!Array.isArray(enabledStates) && typeof enabledStates === 'string') {
-                    enabledStates = (enabledStates === neverVisible) ? [] : visibleStates;
-                }
-                enabledStates = enabledStates.filter(state => visibleStates.includes(state));
-                return { ...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
-                    ?? (objDef.fieldModes?.split(',')?.map(state => state.trim())?.filter(state => state))
-                    ?? [];
-                let enabledStates = objDef.enabledStates ?? objDef.editableStates ?? [];
-                if (!Array.isArray(visibleStates) && typeof visibleStates === 'string') {
-                    visibleStates = (visibleStates === neverVisible) ? [] : allStates;
-                }
-                if (!Array.isArray(enabledStates) && typeof enabledStates === 'string') {
-                    enabledStates = (enabledStates === neverVisible) ? [] : visibleStates;
-                }
-                enabledStates = enabledStates.filter(state => visibleStates.includes(state));
-                return { ...objDef, visibleStates, enabledStates };
-            });
-            for (const fieldReceived of formFields) {
-                const fieldToAdd = new FieldDescriptor(fieldReceived, this.formConfig);
-                const fieldCode = fieldToAdd.code;
-                if (fieldCode) {
-                    this.fieldArray.push(fieldToAdd);
-                    this.fields[fieldCode] = fieldToAdd;
-                }
-            }
-        }
-        if (definitionReceived.tables) {
-            const tables = definitionReceived.tables.map(objDef => {
-                let visibleStates = objDef.visibleStates
-                    ?? (objDef.tableModes?.split(',')?.map(state => state.trim())?.filter(state => state))
-                    ?? [];
-                let enabledStates = objDef.enabledStates ?? objDef.editableStates ?? [];
-                if (!Array.isArray(visibleStates) && typeof visibleStates === 'string') {
-                    visibleStates = (visibleStates === neverVisible) ? [] : allStates;
-                }
-                if (!Array.isArray(enabledStates) && typeof enabledStates === 'string') {
-                    enabledStates = (enabledStates === neverVisible) ? [] : visibleStates;
-                }
-                enabledStates = enabledStates.filter(state => visibleStates.includes(state));
-                return { ...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
-                    ?? (objDef.sectionModes?.split(',')?.map(state => state.trim())?.filter(state => state))
-                    ?? [];
-                if (!Array.isArray(visibleStates) && typeof visibleStates === 'string') {
-                    visibleStates = (visibleStates === neverVisible) ? [] : allStates;
-                }
-                const subsections = objDef.subsections.map(subSecDef => {
-                    let subSecVisibleStates = subSecDef.visibleStates ?? [];
-                    if (!Array.isArray(subSecVisibleStates) && typeof subSecVisibleStates === 'string') {
-                        subSecVisibleStates = (subSecVisibleStates === neverVisible) ? [] : allStates;
-                    }
-                    return { ...subSecDef, visibleStates: subSecVisibleStates };
-                });
-                return { ...objDef, subsections, visibleStates };
-            });
-            for (const sectionReceived of formSections) {
-                const sectionToAdd = new RecordFormSection(sectionReceived, this, this.formConfig);
-                const sectionCode = sectionToAdd.sectionCode;
-                if (sectionCode) {
-                    this.sectionArray.push(sectionToAdd);
-                    this.sections[sectionCode] = sectionToAdd;
-                }
-            }
-        }
-    }
-    // Estados
-    get defaultState() { return this.stateFlow.defaultState; }
-    get states() { return this.stateFlow.states; }
-    get stateDescriptions() { return this.stateFlow.stateDescriptions; }
-    supportState(state = '') { return (!!state && this.stateFlow.states?.includes(state)); }
-    getNextStates() {
-        return this.stateFlow.transitions.filter(trns => trns.source === this.state)
-            .map(trns => trns.destination);
-    }
-    changeState(newState) {
-        const currentState = this.state;
-        if (!newState || !this.supportState(newState) || currentState === 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;
-            }
-        }
-        this._stateChange.next({ state: this.state });
-        return (this.state === newState);
-    }
-    get stateChange() { return this._stateChange.asObservable(); }
-    setStateFlow(states, transitions, defaultState, stateDescriptions = []) {
-        this.stateFlow.states = states;
-        this.stateFlow.stateDescriptions = stateDescriptions;
-        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) { return this._immutableData?.[name]?.value ?? null; }
-    set immutableData(immutableData) { Object.assign(this._immutableData, immutableData); }
-    get immutableData() { return JSON.parse(JSON.stringify(this._immutableData)); }
-    // extra Info
-    getExtraInfo(name) { return this._extraInfo?.[name]?.value ?? null; }
-    set extraInfo(extraInfo) { Object.assign(this._extraInfo, extraInfo); }
-    get extraInfo() { return JSON.parse(JSON.stringify(this._extraInfo)); }
-    // Custom Attributes
-    getCustomAttribute(name) { return this.customAttributes?.[name] ?? null; }
-    setCustomAttribute(name, value) { if (name) {
-        this.customAttributes[name] = value;
-    } }
-    setCustomAttributes(attributes) {
-        if (attributes && typeof attributes === 'object') {
-            Object.entries(attributes).forEach(([name, value]) => {
-                this.setCustomAttribute(name, value);
-            });
-        }
-        return this;
-    }
-    // Fields
-    get fieldNames() { return this.getFieldNames(); }
-    getFields() { return this.fieldArray; }
-    getFieldNames() { return this.fieldArray.map(field => field.code); }
-    getField(code) { return (code && this.fields?.[code]) ? this.fields[code] : null; }
-    enableField(code) { this.getField(code)?.enable(); }
-    disableField(code) { this.getField(code)?.disable(); }
-    getFieldValue(code) { return this.getField(code)?.value; }
-    getFieldOptionText(code) { return this.getField(code)?.optionText; }
-    getFieldOptions(code) { return this.getField(code)?.options ?? null; }
-    setFieldValue(code, value) { this.getField(code)?.setValue(value); }
-    setFieldError(code, errorCode, message, type = 'error') { this.getField(code)?.setError(errorCode, message, type); }
-    setFieldIntrinsicErrorMessage(code, message) { this.getField(code)?.setIntrinsicErrorMessage(message); }
-    setFieldRequired(inputCodes, required) {
-        const codes = this.getFieldSet(null, inputCodes ?? null);
-        for (const code of codes) {
-            try {
-                const field = this.getField(code) ?? null;
-                field && (field.required = required);
-            }
-            catch (e) {
-                console.log(`Error modificando campo ${code}: ${e}`);
-            }
-        }
-    }
-    setFieldErrorMessage(code, message) { this.getField(code)?.setErrorMessage(message); }
-    setFieldOptions(code, optionsArray, idAttribute, valueAttribute, saparator = '-') {
-        const field = this.getField(code);
-        if (!field) {
-            return;
-        }
-        const newOptions = [];
-        const numSeparators = (Array.isArray(valueAttribute)) ? (valueAttribute.length - 1) : 0;
-        for (let i = 0; i < optionsArray?.length; i++) {
-            const optionItem = optionsArray[i];
-            const fieldOptionId = optionItem?.[idAttribute];
-            let fieldOptionText = '';
-            if (Array.isArray(valueAttribute)) {
-                for (let index = 0; index < valueAttribute.length; index++) {
-                    const textPart = valueAttribute[index];
-                    fieldOptionText += (index < numSeparators)
-                        ? `${optionItem?.[textPart]} ${saparator} ` : optionItem?.[textPart];
-                }
-            }
-            else {
-                fieldOptionText = optionItem?.[valueAttribute];
-            }
-            if (fieldOptionId !== undefined && fieldOptionId !== null
-                && fieldOptionText !== undefined && fieldOptionText !== null) {
-                newOptions.push({ fieldOptionId, fieldOptionValue: fieldOptionText });
-            }
-        }
-        field.options = newOptions;
-    }
-    getFieldSet(filter, inputCodes, secCode, subCode) {
-        let codes = [];
-        if (inputCodes) {
-            if (typeof inputCodes === 'string') {
-                codes = [inputCodes];
-            }
-            else if (Array.isArray(inputCodes) && inputCodes.length > 0) {
-                codes = inputCodes ?? [];
-            }
-        }
-        else if (secCode && !subCode) {
-            codes = this.getSection(secCode)?.getFieldNames() ?? [];
-        }
-        else if (secCode && subCode) {
-            codes = this.getSubSection(secCode, subCode)?.getFieldNames() ?? [];
-        }
-        else {
-            codes = this.getFieldNames() ?? [];
-        }
-        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, 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;
-    }
-    applyProcessToAllFields(processFunc) {
-        return this.applyOnFields(processFunc);
-    }
-    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, secCode, subCode);
-    }
-    getRequiredEmptyFields(codes, secCode, subCode, onlyVisible) {
-        if (onlyVisible) {
-            return this.getFieldSet(fld => fld?.required && fld?.visible && fld?.empty, codes ?? null, secCode, subCode);
-        }
-        return this.getFieldSet(fld => fld?.required && fld?.empty, codes ?? null, secCode, subCode);
-    }
-    getChangedFields(codes, secCode, subCode) {
-        return this.getFieldSet(fld => !fld?.outputOnly && fld?.hasChanged, codes ?? null, secCode, subCode);
-    }
-    getFieldsWithValidationIssues(codes, secCode, subCode, onlyVisible) {
-        if (onlyVisible) {
-            return this.getFieldSet(fld => (fld?.hasError() && fld?.visible), codes ?? null, secCode, subCode);
-        }
-        return this.getFieldSet(fld => fld?.hasError(), codes ?? null, secCode, subCode);
-    }
-    getFieldsValues(inputCodes, secCode, subCode) {
-        const codes = this.getFieldSet(null, inputCodes ?? null, secCode, subCode);
-        const resultObject = {};
-        for (let index = 0; index < codes.length; index++) {
-            const code = codes[index];
-            if (code) {
-                resultObject[code] = this.fields?.[code]?.getValue() ?? null;
-            }
-        }
-        return resultObject;
-    }
-    // Acciones
-    getActions() { return this.actionArray; }
-    getAction(code) { return (code && this.actions?.[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); }
-    enableAction(code) { return this.enableActions(code); }
-    disableAction(code) { return this.disableActions(code); }
-    showAction(code) { return this.showActions(code); }
-    hideAction(code) { return this.hideActions(code); }
-    getHeaderActions() { return this.getActionsByAttribute('location', HEADER$1); }
-    getActionsByAttribute(name, value) {
-        return this.actionArray.filter(actionItem => actionItem.matchAttribute(name, value));
-    }
-    execOnActions(codes, functionName) {
-        const actionCodes = (Array.isArray(codes)) ? codes : (codes ? [codes] : []);
-        if (!functionName || actionCodes.length === 0) {
-            return;
-        }
-        actionCodes.forEach(code => {
-            const action = this.getAction(code);
-            action?.[functionName]?.();
-        });
-    }
-    // Tablas
-    getTables() { return this.tableArray; }
-    getTable(code) { return (code && this.tables?.[code]) ? this.tables[code] : null; }
-    getTableRecord(code, id) { return this.getTable(code)?.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); }
-    showTable(code) { return this.showTables(code); }
-    hideTable(code) { return this.hideTables(code); }
-    cleanTable(code) { return this.getTable(code)?.clean(); }
-    execOnTables(codes, functionName) {
-        const tableCodes = (Array.isArray(codes)) ? codes : (codes ? [codes] : []);
-        if (!functionName || tableCodes.length === 0) {
-            return;
-        }
-        tableCodes.forEach(code => {
-            const table = this.getTable(code);
-            table?.[functionName]?.();
-        });
-    }
-    // Secciones
-    getSections() { return this.sectionArray; }
-    getSectionsTitles() { return this.getSections()?.filter(sec => sec?.title).map(sec => sec?.title ?? ''); }
-    numSections() { return this.sectionArray.length; }
-    getSectionsByAttribute(name, value) { return this.sectionArray.filter(item => item.matchAttribute(name, value)); }
-    get sectionTitles() { return this.getSectionsTitles(); }
-    get visibleSections() { return this.sectionArray.filter(sec => sec.absoluteVisible); }
-    getSection(code) { return (code && this.sections?.[code]) ? this.sections[code] : null; }
-    showSections(codes) { this.execOnSections(codes, SHOW); }
-    hideSections(codes) { this.execOnSections(codes, HIDE); }
-    showSection(code) { return this.showSections(code); }
-    hideSection(code) { return this.hideSections(code); }
-    activeSection() { return this._exclusiveSectionsByAttr[ACTIVE]; }
-    getSubSection(code, subCode) { return this.getSection(code)?.getSubsection(subCode) ?? null; }
-    showSubSections(code, subCodes) { return this.execOnSubSections(code, subCodes, SHOW); }
-    showSubSection(code, subCode) { return this.showSubSections(code, subCode); }
-    hideSubSection(code, subCode) { return this.hideSubSections(code, subCode); }
-    hideSubSections(code, subCodes) { return this.execOnSubSections(code, subCodes, HIDE); }
-    getSectionActions(code) { return this.getSection(code)?.getActions() ?? null; }
-    getSectionActionNames(code) { return this.getSection(code)?.getActionNames() ?? null; }
-    activateSection(code) {
-        if (code === this._exclusiveSectionsByAttr[ACTIVE]) {
-            return;
-        }
-        this.getSection(this.activeSection())?.inactivate();
-        this.getSection(code)?.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 => {
-            const section = this.getSection(code);
-            section?.[functionName]?.();
-        });
-    }
-    execOnSubSections(code, subNames, functionName) {
-        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);
-            subSection?.[functionName]?.();
-        }
-    }
-    /**
-     * 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?.code,
-                fieldValue: fld?.value,
-                editable: !fld?.absoluteDisabled,
-                visible: fld?.absoluteVisible,
-                required: fld?.required,
-                fieldOptions: '',
-            };
-            return fieldPayload;
-        });
-        formData.tables = this.getTables().map(tbl => {
-            const tablePayload = {
-                tableCode: tbl.tableCode,
-                visible: tbl.absoluteVisible,
-                currentPage: tbl.currentPage,
-                requestedPage: tbl.requestedPage,
-                recordsPerPage: tbl.recordsPerPage,
-                currentFilter: tbl.currentFilter,
-                sortingColumn: tbl.sorting.columnName,
-                sortingDirection: tbl.sorting.direction,
-            };
-            return tablePayload;
-        });
-        return formData;
-    }
-    /**
-     * @deprecated Use subject
-     */
-    get formSubject() { return this.subject; }
-    /**
-     * @deprecated Use subject
-     */
-    set formSubject(subject) { this.subject = subject; }
-    /**
-     * @deprecated Use states
-     */
-    getStates() { return this.states; }
-    /**
-     * @deprecated Use state
-     */
-    getCurrentState() { return this.state; }
-    /**
-     * @deprecated Use title
-     */
-    getTitle() { return this.title; }
-    /**
-     * @deprecated Use title
-     */
-    setTitle(title) { this.title = title; }
-    /**
-     * @deprecated Use supportState
-     */
-    supportMode(state) { return this.supportState(state); }
-    /**
-     * @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);
-    }
-    /**
-     * @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() { return this.subject ?? ''; }
-    /**
-     * @deprecated Use subject
-     */
-    getformSubject() { return this.subject ?? ''; }
-}
-
-class LibFormManagerService {
-    pageStack;
-    constructor() {
-        this.cleanStack();
-    }
-    // Métodos virtuales para las aplicaciones
-    getFormDefinition(formCode) { }
-    execServerAction(actionDetail) { }
-    goToForm(formCode, token, subject) { }
-    async loadStack() { }
-    saveStack() { }
-    cleanStack() { this.pageStack = []; }
-    resetPageStack() { this.cleanStack(); }
-    findFormInStack(token) {
-        const index = this.pageStack.findIndex(item => item?.token === token);
-        const data = (index >= 0) ? this.pageStack[index] : null;
-        return { index, data };
-    }
-    replaceItem(token, formInfo) {
-        if (!token || !formInfo) {
-            return;
-        }
-        const { index, data: storedForm } = this.findFormInStack(token);
-        let updatedForm = null;
-        if (index >= 0) {
-            updatedForm = { ...storedForm };
-            updatedForm.subject = formInfo?.subject ?? storedForm.subject;
-            updatedForm.state = formInfo?.state ?? storedForm.state;
-            updatedForm.fields = storedForm?.fields ?? {};
-            updatedForm.extra = storedForm?.extra ?? {};
-            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({ 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) {
-        const { data } = this.findFormInStack(token);
-        return {
-            token: data?.token,
-            subject: data?.subject,
-            state: data?.state,
-            originToken: data?.originToken,
-            fields: data?.fields ?? {},
-            extra: data?.extra ?? {}
-        };
-    }
-    openForm(origin, target) {
-        (!origin) && this.cleanStack();
-        target.originToken = origin?.token ?? 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 {
-    eventSubjects = {};
-    eventSubjectParams = {};
-    constructor(eventSet) {
-        eventSet.forEach((event) => { this.addEventName(event); });
-    }
-    addEventName(event, rebuild = false) {
-        const eventObject = (typeof event === 'string') ? { name: event } : event;
-        const { name, type, initialValue, windowTime, timestampProvider } = eventObject;
-        const currentSubject = this.eventSubjects[name];
-        if (rebuild || !currentSubject) {
-            if (type === 'behaviour') {
-                const newEventSubject = new BehaviorSubject(initialValue);
-                this.eventSubjects[name] = newEventSubject;
-            }
-            else if (type === 'subject') {
-                const newEventSubject = new Subject();
-                this.eventSubjects[name] = newEventSubject;
-            }
-            else {
-                const newEventSubject = new ReplaySubject(initialValue, windowTime, timestampProvider);
-                this.eventSubjects[name] = newEventSubject;
-            }
-            this.eventSubjectParams[name] = { name: name, windowTime, timestampProvider };
-        }
-    }
-    resetSubject(eventClassName) {
-        const { name, windowTime, timestampProvider } = this.eventSubjectParams[eventClassName];
-        return this.addEventName({ name, windowTime, timestampProvider });
-    }
-    getEventNames() { return Object.keys(this.eventSubjects); }
-    getSubject(eventClassName) { return eventClassName ? this.eventSubjects[eventClassName] : null; }
-    subscribe(eventClassName, callback) { return this.getSubject(eventClassName).subscribe(callback); }
-    next(eventClassName, data) {
-        const subject = this.getSubject(eventClassName);
-        if (!subject) {
-            console.log(`No se encontró subject ${eventClassName}`);
-        }
-        subject.next(data);
-    }
-}
-
-class LibFileManagementService {
-    openFile(fileBase64Data, fileName, fileType) { }
-    saveFileFromURL(fileUrl, fileName = null, fileType = null) { }
-    saveFile(fileBase64Data, fileName, fileType) { }
-    printPdfFile(pdfBufferData) { }
-}
-
-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 extends FormStructureAndData {
-    formManagerService;
-    _eventManager;
-    fileMgmtServices;
-    destroy$ = new Subject();
-    _controlToken = null;
-    _originToken = null;
-    _formRoute = null;
-    _definitionObtained = false;
-    _notifyFormActivity = true;
-    // Eventos de acciones y campos
-    _formChangeState = [];
-    _formSectionsCanDeactivate = {};
-    _formSectionsActivate = {};
-    _formSectionsInactivate = {};
-    _formActionsStart = {};
-    _formActionsFinish = {};
-    _fieldCustomeEvent = {};
-    _fieldInputValidation = {};
-    _fieldValidationsStart = {};
-    _fieldValidationsFinish = {};
-    // Callback de acciones de tablas
-    _tableSelectionsStart = {};
-    _tableSelectionsFinish = {};
-    _tableActionsStart = {};
-    _tableActionsFinish = {};
-    _tableGetDataStart = {};
-    _tableGetDataFinish = {};
-    // Errores en procesos
-    _actionServerError = [];
-    _fieldServerError = [];
-    _tableServerError = [];
-    // Acciones en curso dentro del formulario
-    _actionsInProgress = {};
-    // Datos complementarios del formulario
-    inputDataFields = {};
-    extraData = {};
-    _eventEmiter;
-    enabledSections = [];
-    // Gestión de error
-    _errorType = '';
-    errorCode = '';
-    errorFullCode = '';
-    errorName = '';
-    errorMessage = '';
-    errorDetail = '';
-    // Control de estado
-    visible = false;
-    busy = signal(false);
-    constructor(formManagerService, _eventManager, fileMgmtServices) {
-        super();
-        this.formManagerService = formManagerService;
-        this._eventManager = _eventManager;
-        this.fileMgmtServices = fileMgmtServices;
-        this._eventEmiter = this._eventManager;
-        this.cleanStart();
-    }
-    cleanStart() {
-        this._errorType = '';
-        this.errorCode = '';
-        this.errorFullCode = '';
-        this.errorName = '';
-        this.errorMessage = '';
-        this.errorDetail = '';
-        this.cleanForm();
-        this._controlToken = null;
-        this.inputDataFields = {};
-        this._definitionObtained = false;
-        // Se limpian los manejadores de eventos
-        this.visible = false;
-        this.busy.set(false);
-        this._formChangeState = [];
-        this._formSectionsCanDeactivate = {};
-        this._formSectionsActivate = {};
-        this._formSectionsInactivate = {};
-        this._formActionsStart = {};
-        this._formActionsFinish = {};
-        this._fieldCustomeEvent = {};
-        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 form() { return this; }
-    ngOnInit() {
-        this.preStart();
-        this.customPreProcessing();
-    }
-    // Métodos virtuales
-    preStart() { }
-    start() { }
-    /**
-     * @deprecated Use preStart
-     */
-    customPreProcessing() { }
-    /**
-     * @deprecated Overload start
-     */
-    customFormStart() { }
-    displayActionServerError() { }
-    displayValidationServerError() { }
-    displayTableServerError() { }
-    showFieldInfo(code, detail) { }
-    showModalDialog(title, body, options, callback, params) { }
-    openUploadDialog(title, body, options, callback, params) { }
-    subscribeAppEvent(eventName, callback) {
-        this._eventEmiter.subscribe(eventName, callback);
-    }
-    openForm(name, data = null, backData = null, cleanStack = false) {
-        let origin = null;
-        if (!cleanStack) {
-            origin = { ...backData, name: this.name, url: this._formRoute, token: this._controlToken };
-            origin.subject = origin?.subject ?? this.subject;
-            origin.state = origin?.state ?? this.state;
-            origin.fields = origin?.fields ?? {};
-            origin.extra = origin?.extra ?? {};
-        }
-        const target = { ...data, name };
-        target.subject = target?.subject ?? null;
-        target.state = target?.state ?? null;
-        target.fields = target?.fields ?? {};
-        target.extra = target?.extra ?? {};
-        this.formManagerService.openForm(origin, target);
-    }
-    enableActivityNotification() { this._notifyFormActivity = true; }
-    disableActivityNotification() { this._notifyFormActivity = false; }
-    canGoBack() { return this._originToken !== null; }
-    goBack() { return this.formManagerService.backTo(); }
-    goBackForm() { return this.goBack(); }
-    getOriginDetail() { return this.formManagerService?.getFormInfo(this._originToken ?? ''); }
-    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) {
-        return (name) ? (this.extraData?.[name] ?? null) : null;
-    }
-    preocessInputParams(params) {
-        this._controlToken = params?.[TOKEN] ?? null;
-        this.subject = params?.[SUBJECT] ?? null;
-        const tokenInfo = (this._controlToken) ? this.formManagerService.getFormInfo(this._controlToken) : {};
-        const { token, subject, state, fields, extra, originToken } = tokenInfo;
-        if (token && this._controlToken === token) {
-            this.subject = this.subject ?? subject ?? null;
-            this.inputDataFields = fields;
-            this.extraData = extra;
-            this._originToken = originToken;
-            return state;
-        }
-        return null;
-    }
-    subscribeSectionActivation() {
-        const formSections = this.sections;
-        const sectionNames = Object.keys(formSections);
-        for (let index = 0; index < sectionNames.length; index++) {
-            const sectionName = sectionNames[index];
-            const section = formSections[sectionName];
-            section.activation
-                .pipe(takeUntil(this.destroy$))
-                .subscribe((code) => this.launchSectionActivation(code));
-            section.inactivation
-                .pipe(takeUntil(this.destroy$))
-                .subscribe((code) => this.launchSectionInactivation(code));
-            // Adicionalmente se le pide a la sección se subscriba al cambio de estado del formulario
-            section.connectWithParentForm(this, this.stateChange);
-        }
-    }
-    subscribeFieldsSubjects() {
-        const formFields = this.getFields();
-        if (Array.isArray(formFields)) {
-            formFields.forEach(field => {
-                field.customEvent
-                    .pipe(takeUntil(this.destroy$))
-                    .subscribe(event => {
-                    const { code, eventName, eventData } = event;
-                    this.startFieldCustomEvent(code, eventName, eventData);
-                });
-                field.editionFinish
-                    .pipe(takeUntil(this.destroy$))
-                    .subscribe(event => {
-                    const { code, intrinsicValidation } = event;
-                    this.startFieldValidation(code, intrinsicValidation);
-                });
-                field.editionPartial
-                    .pipe(takeUntil(this.destroy$))
-                    .subscribe(event => {
-                    const { code, intrinsicValidation } = event;
-                    this.startFieldInputValidation(code, intrinsicValidation);
-                });
-                field.detailRequest
-                    .pipe(takeUntil(this.destroy$))
-                    .subscribe(event => this.showFieldInfo(event.code, event.detail));
-                // Adicionalmente se le pide al campo se subscriba al cambio de estado del formulario
-                field.connectWithParentForm(this, this.stateChange);
-            });
-        }
-    }
-    subscribeActionSubjects() {
-        const formActions = this.getActions();
-        if (Array.isArray(formActions)) {
-            formActions.forEach(action => {
-                action.actionActivated
-                    .pipe(takeUntil(this.destroy$))
-                    .subscribe(code => this.startAction(code));
-                // Adicionalmente se le pide a la acción se subscriba al cambio de estado del formulario
-                action.connectWithParentForm(this, this.stateChange);
-            });
-        }
-    }
-    subscribeTableSubjects() {
-        const formTables = this.getTables();
-        if (Array.isArray(formTables)) {
-            formTables.forEach(table => {
-                table.inlineActionTrigger
-                    .pipe(takeUntil(this.destroy$))
-                    .subscribe(event => this.startTableAction(event));
-                table.globalActionTrigger
-                    .pipe(takeUntil(this.destroy$))
-                    .subscribe(event => this.startTableGlobalAction(event));
-                table.recordSelectionTrigger
-                    .pipe(takeUntil(this.destroy$))
-                    .subscribe(event => this.startTableRecordSelection(event));
-                table.selectionActionTrigger
-                    .pipe(takeUntil(this.destroy$))
-                    .subscribe(event => this.startTableSelectionAction(event));
-                table.getDataTrigger
-                    .pipe(takeUntil(this.destroy$))
-                    .subscribe(event => this.startTableGetData(event));
-                // Adicionalmente se le pide a la tabla se subscriba al cambio de estado del formulario
-                table.connectWithParentForm(this, this.stateChange);
-            });
-        }
-    }
-    async formInit(params, forceReload = false) {
-        let initialState = this.preocessInputParams(params);
-        if (!this.name) {
-            return;
-        }
-        if (forceReload || !this._definitionObtained) {
-            this.busy.set(true);
-            const formDefinition = await this.formManagerService.getFormDefinition(this.name);
-            this.busy.set(false);
-            this.loadDefinition(formDefinition);
-            this._definitionObtained = true;
-        }
-        else {
-            this.cleanData();
-        }
-        if (!this.supportState(initialState ?? '')) {
-            initialState = this.defaultState ?? null;
-        }
-        const inputFieldNames = Object.keys(this.inputDataFields);
-        for (let index = 0; index < inputFieldNames.length; index++) {
-            const code = inputFieldNames[index];
-            const fieldValue = this.inputDataFields[code];
-            this.setFieldValue(code, fieldValue);
-        }
-        this.subscribeSectionActivation();
-        this.subscribeFieldsSubjects();
-        this.subscribeActionSubjects();
-        this.subscribeTableSubjects();
-        // Se define el estado inicial y se solicita la acción inicial
-        this.changeState(initialState || this.defaultState);
-        if (this.loadInitialData) {
-            const recordResponse = await this.requestFormAction(formActions.getData);
-            this.checkErrorRecordReceived(recordResponse);
-        }
-        this.visible = true;
-        this.enabledSections = this.visibleSections ?? [];
-        this.start();
-        this.customFormStart();
-    }
-    changeState(state) {
-        const stateChanged = super.changeState(state ?? '') ?? false;
-        if (stateChanged) {
-            const clientActionMethods = this._formChangeState;
-            if (clientActionMethods && clientActionMethods.length > 0) {
-                for (const callback of clientActionMethods) {
-                    callback(state);
-                }
-            }
-        }
-        return stateChanged;
-    }
-    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
-     */
-    async requestFormAction(actionCode, actionSubject = {}) {
-        const actionDetail = {
-            formCode: this.name,
-            formSubject: this.subject,
-            currentMode: this.state,
-            actionCode,
-            actionSubject,
-            version: PAYLOAD_VERSION,
-            formData: this.getPayload(),
-            immutableData: this.immutableData,
-        };
-        this.errorCode = NO_ERROR;
-        this.errorFullCode = '';
-        this.errorName = '';
-        this.errorMessage = '';
-        this.errorDetail = '';
-        this.busy.set(true);
-        const formActionResponse = await this.formManagerService.execServerAction(actionDetail);
-        if (!formActionResponse) {
-            return null;
-        }
-        this.busy.set(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.subject = 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);
-        }
-        this.immutableData = immutableData;
-        this.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
-     */
-    onFormChange(callback) {
-        this._formChangeState.push(callback);
-    }
-    onSectionCanDeactivate(codes, callback, properties = null) {
-        const sectionSet = (Array.isArray(codes)) ? codes : (codes ? [codes] : []);
-        sectionSet.forEach((sectionName) => {
-            if (!this._formSectionsCanDeactivate[sectionName]) {
-                this._formSectionsCanDeactivate[sectionName] = [];
-            }
-            this._formSectionsCanDeactivate[sectionName].push({ callback, properties });
-        });
-    }
-    onSectionActivation(codes, callback, properties = null) {
-        const sectionSet = (Array.isArray(codes)) ? codes : (codes ? [codes] : []);
-        sectionSet.forEach((sectionName) => {
-            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 });
-        });
-    }
-    async verifySectionActivation(code) {
-        const sectionObject = this.getSection(code);
-        if (!sectionObject) {
-            return false;
-        }
-        const clientSectionMethods = this._formSectionsCanDeactivate[code];
-        if (clientSectionMethods) {
-            for (const clientSectionMethod of clientSectionMethods) {
-                const { callback, properties } = clientSectionMethod;
-                const canActivate = callback(sectionObject);
-                if (canActivate === false) {
-                    return false;
-                }
-            }
-        }
-        return true;
-    }
-    async launchSectionActivation(code) {
-        this.notifyFormActivity();
-        const sectionObject = this.getSection(code);
-        if (!sectionObject) {
-            return;
-        }
-        const clientSectionMethods = this._formSectionsActivate[code];
-        if (clientSectionMethods) {
-            for (const clientSectionMethod of clientSectionMethods) {
-                const { callback, properties } = clientSectionMethod;
-                callback(sectionObject);
-            }
-        }
-    }
-    async launchSectionInactivation(code) {
-        this.notifyFormActivity();
-        const sectionObject = this.getSection(code);
-        if (!sectionObject) {
-            return;
-        }
-        const clientSectionMethods = this._formSectionsInactivate[code];
-        if (clientSectionMethods) {
-            for (const clientSectionMethod of clientSectionMethods) {
-                const { callback, properties } = clientSectionMethod;
-                callback(sectionObject);
-            }
-        }
-    }
-    async startAction(code) {
-        this.notifyFormActivity();
-        const actionObject = this.getAction(code);
-        if (!actionObject) {
-            return;
-        }
-        if (this._actionsInProgress[code]) {
-            const { sent } = this._actionsInProgress[code];
-            console.log(`Reingreso sobre acción ${code} con ejecución previa ${sent}`);
-            return;
-        }
-        this._actionsInProgress[code] = { sent: new Date() };
-        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 = await Promise.all(clientActionPromises);
-            const continueAction = clientActionResults.reduce((total, curr) => (total && (curr !== false)), true);
-            if (!continueAction) {
-                actionObject.stop();
-                this._actionsInProgress[code] = null;
-                delete this._actionsInProgress[code];
-                return;
-            }
-        }
-        this.startServerAction(actionObject);
-        this._actionsInProgress[code] = null;
-        delete this._actionsInProgress[code];
-    }
-    async startServerAction(actionInput) {
-        const action = (typeof actionInput === 'string')
-            ? this.getAction(actionInput) : actionInput;
-        if (!action) {
-            return;
-        }
-        let serverError = false;
-        let actionResult = null;
-        if (action.backend) {
-            actionResult = await this.requestFormAction(action.actionCode);
-        }
-        await this.finishAction(action, actionResult, serverError);
-        serverError = !!this.errorOccured();
-        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();
-    }
-    async finishAction(action, actionResult, serverError = false) {
-        const finishActionMethods = this._formActionsFinish[action.actionCode];
-        if (finishActionMethods) {
-            const clientActionPromises = [];
-            for (const clientActionMethod of finishActionMethods) {
-                const { callback, properties } = clientActionMethod;
-                const continueOnError = properties?.continueOnError ?? false;
-                if (callback && (!serverError || continueOnError)) {
-                    clientActionPromises.push(callback(action, actionResult));
-                }
-            }
-            await 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((code) => {
-            if (!this._fieldInputValidation[code]) {
-                this._fieldInputValidation[code] = [];
-            }
-            this._fieldInputValidation[code].push({ callback, properties });
-        });
-    }
-    onFieldCustomEvent(codes, callback, properties = null) {
-        const fieldSet = (Array.isArray(codes)) ? codes : (codes ? [codes] : []);
-        fieldSet.forEach((code) => {
-            if (!this._fieldCustomeEvent[code]) {
-                this._fieldCustomeEvent[code] = [];
-            }
-            this._fieldCustomeEvent[code].push({ callback, properties });
-        });
-    }
-    onFieldValidationStart(codes, callback, properties = null) {
-        const fieldSet = (Array.isArray(codes)) ? codes : (codes ? [codes] : []);
-        fieldSet.forEach((code) => {
-            if (!this._fieldValidationsStart[code]) {
-                this._fieldValidationsStart[code] = [];
-            }
-            this._fieldValidationsStart[code].push({ callback, properties });
-        });
-    }
-    onFieldValidationFinish(codes, callback, properties = null) {
-        const fieldSet = (Array.isArray(codes)) ? codes : (codes ? [codes] : []);
-        fieldSet.forEach((code) => {
-            if (!this._fieldValidationsFinish[code]) {
-                this._fieldValidationsFinish[code] = [];
-            }
-            this._fieldValidationsFinish[code].push({ callback, properties });
-        });
-    }
-    async startFieldInputValidation(code, intrinsicValidation = true) {
-        this.notifyFormActivity();
-        const fieldToValidate = this.getField(code);
-        if (!fieldToValidate) {
-            return false;
-        }
-        const validationCallbacks = this._fieldInputValidation[code];
-        if (validationCallbacks) {
-            const clientValidationPromises = [];
-            for (const validationMethod of validationCallbacks) {
-                const { callback, properties } = validationMethod;
-                const continueValidationPromise = callback(fieldToValidate);
-                clientValidationPromises.push(continueValidationPromise);
-            }
-            await Promise.all(clientValidationPromises);
-        }
-        return true;
-    }
-    async startFieldCustomEvent(code, eventName, eventData) {
-        this.notifyFormActivity();
-        const fieldToTrigger = this.getField(code);
-        if (!fieldToTrigger) {
-            return;
-        }
-        const eventHandlerCallbacks = this._fieldCustomeEvent[code];
-        if (eventHandlerCallbacks) {
-            const clientEventPromises = [];
-            for (const eventHandlerMethod of eventHandlerCallbacks) {
-                const { callback, properties } = eventHandlerMethod;
-                const clientEventPromise = callback(eventName, eventData, fieldToTrigger);
-                clientEventPromises.push(clientEventPromise);
-            }
-        }
-    }
-    async startFieldValidation(code, intrinsicValidation = true) {
-        this.notifyFormActivity();
-        const fieldToValidate = this.getField(code);
-        if (!fieldToValidate) {
-            return;
-        }
-        const validationCallbacks = this._fieldValidationsStart[code];
-        if (validationCallbacks) {
-            const clientValidationPromises = [];
-            for (const validationMethod of validationCallbacks) {
-                const { callback, properties } = validationMethod;
-                const clientValidationPromise = callback(fieldToValidate);
-                clientValidationPromises.push(clientValidationPromise);
-            }
-            const clientValidationResults = await Promise.all(clientValidationPromises);
-            const continueValidation = clientValidationResults.reduce((total, curr) => (total && (curr !== false)), true);
-            if (!continueValidation) {
-                return;
-            }
-        }
-        if (intrinsicValidation) {
-            this.startServerFieldValidation(fieldToValidate);
-        }
-    }
-    async startServerFieldValidation(inputField) {
-        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 = await this
-                .requestFormAction(formActions.validate, fieldObj.code);
-            serverError = !!this.errorOccured();
-        }
-        if (serverError) {
-            fieldObj?.setErrorCode(this.errorCode);
-            fieldObj?.setErrorMessage(this.errorMessage);
-            for (let index = 0; index < this._fieldServerError.length; index++) {
-                const { callback, properties } = this._fieldServerError[index];
-                callback(fieldObj);
-            }
-        }
-        await this.finishFieldValidation(fieldObj, validationResult, serverError);
-        fieldObj.validating = false;
-    }
-    async finishFieldValidation(fieldObject, validationResult, serverError = false) {
-        const validationCallbacks = this._fieldValidationsFinish[fieldObject.code];
-        if (validationCallbacks) {
-            const clientActionPromises = [];
-            for (const validationMethod of validationCallbacks) {
-                const { callback, properties } = validationMethod;
-                const continueOnError = properties?.continueOnError ?? false;
-                if (!serverError || continueOnError) {
-                    clientActionPromises.push(callback(fieldObject, validationResult));
-                }
-            }
-            await Promise.all(clientActionPromises);
-        }
-    }
-    async continueFieldValidation(code) {
-        return this.startServerFieldValidation(code);
-    }
-    /**
-     * 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 };
-    }
-    async startTableGlobalAction(tableActionEvent) {
-        this.notifyFormActivity();
-        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 = await Promise.all(clientActionPromises);
-            const continueAction = clientActionResults.reduce((total, curr) => (total && (curr !== false)), true);
-            if (!continueAction) {
-                return;
-            }
-        }
-        this.startTableServerGlobalAction(tableActionDetail);
-    }
-    async startTableServerGlobalAction(tableActionDetail) {
-        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 = await this
-                .requestFormAction(formActions.tableAction, actionSubject);
-            serverError = !!this.errorOccured();
-        }
-        await 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();
-    }
-    async finishTableGlobalAction(tableActionDetail, actionResult, serverError = false) {
-        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 = properties?.continueOnError ?? false;
-                if (!serverError || continueOnError) {
-                    clientActionPromises.push(callback(tableActionDetail, actionResult));
-                }
-            }
-            await Promise.all(clientActionPromises);
-        }
-    }
-    async startTableAction(tableActionEvent) {
-        this.notifyFormActivity();
-        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 = await Promise.all(clientActionPromises);
-            const continueAction = clientActionResults.reduce((total, curr) => (total && (curr !== false)), true);
-            if (!continueAction) {
-                return;
-            }
-        }
-        this.startTableServerAction(tableActionDetail);
-    }
-    async startTableServerAction(tableActionDetail) {
-        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 = await this
-                .requestFormAction(formActions.tableAction, actionSubject);
-            serverError = !!this.errorOccured();
-        }
-        await this.finishTableAction(tableActionDetail, actionResult, serverError);
-        if (!serverError) {
-            action.newState && this.changeState(action.newState);
-        }
-        else {
-            this.displayTableServerError();
-        }
-        tableObject.freeWaiting();
-    }
-    completeInlineAction(tableAction) {
-        return this.startTableServerAction(tableAction);
-    }
-    async finishTableAction(tableActionDetail, actionResult, serverError = false) {
-        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 = properties?.continueOnError ?? false;
-                if (!serverError || continueOnError) {
-                    clientActionPromises.push(callback(tableActionDetail, actionResult));
-                }
-            }
-            await Promise.all(clientActionPromises);
-        }
-    }
-    async startTableRecordSelection(tableActionEvent) {
-        this.notifyFormActivity();
-        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 = await Promise.all(clientActionPromises);
-            const continueAction = clientActionResults.reduce((total, curr) => (total && (curr !== false)), true);
-            if (!continueAction) {
-                return;
-            }
-        }
-        this.startTableServerRecordSelection(tableSelectionDetail);
-    }
-    async startTableServerRecordSelection(tableSelectionDetail) {
-        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 = await this
-                .requestFormAction(formActions.tableAction, actionSubject);
-            serverError = !!this.errorOccured();
-        }
-        await this.finishTableRecordSelection(tableSelectionDetail, actionResult, serverError);
-        if (serverError) {
-            this.displayTableServerError();
-        }
-        tableObject.freeWaiting();
-    }
-    async finishTableRecordSelection(tableSelectionDetail, actionResult, serverError = false) {
-        const { tableCode } = tableSelectionDetail;
-        const tableEventHandlers = this._tableSelectionsFinish[tableCode];
-        if (tableEventHandlers) {
-            const clientActionPromises = [];
-            for (const tableSelectionMethod of tableEventHandlers) {
-                const { callback, properties } = tableSelectionMethod;
-                const continueOnError = properties?.continueOnError ?? false;
-                if (!serverError || continueOnError) {
-                    clientActionPromises.push(callback(tableSelectionDetail, actionResult));
-                }
-            }
-            await Promise.all(clientActionPromises);
-        }
-    }
-    async startTableSelectionAction(tableActionEvent) {
-        this.notifyFormActivity();
-        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 = await Promise.all(clientActionPromises);
-            const continueAction = clientActionResults.reduce((total, curr) => (total && (curr !== false)), true);
-            if (!continueAction) {
-                return;
-            }
-        }
-        this.startTableServerSelectionAction(tableActionDetail);
-    }
-    async startTableServerSelectionAction(tableActionDetail) {
-        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 = await this
-                .requestFormAction(formActions.tableAction, actionSubject);
-            serverError = !!this.errorOccured();
-        }
-        await this.finishTableSelectionAction(tableActionDetail, actionResult, serverError);
-        if (!serverError) {
-            action.newState && this.changeState(action.newState);
-        }
-        else {
-            this.displayTableServerError();
-        }
-        tableObject.freeWaiting();
-    }
-    async finishTableSelectionAction(tableActionDetail, actionResult, serverError = false) {
-        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 = properties?.continueOnError ?? false;
-                if (!serverError || continueOnError) {
-                    clientActionPromises.push(callback(tableActionDetail, actionResult));
-                }
-            }
-            await Promise.all(clientActionPromises);
-        }
-    }
-    async startTableGetData(tableActionEvent) {
-        this.notifyFormActivity();
-        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 = await Promise.all(clientActionPromises);
-            const continueAction = clientActionResults.reduce((total, curr) => (total && (curr !== false)), true);
-            if (!continueAction) {
-                return;
-            }
-        }
-        this.startTableServerGetData(tableActionDetail);
-    }
-    async startTableServerGetData(tableActionDetail) {
-        const { tableObject, tableCode } = tableActionDetail;
-        tableObject.putOnWait();
-        let serverError = false;
-        const actionSubject = { tableCode };
-        const actionResult = await this
-            .requestFormAction(formActions.getTableData, actionSubject);
-        serverError = !!this.errorOccured();
-        await this.finishTableGetData(tableActionDetail, actionResult, serverError);
-        if (serverError) {
-            this.displayTableServerError();
-        }
-        tableObject.freeWaiting();
-    }
-    async finishTableGetData(tableActionDetail, actionResult, serverError = false) {
-        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 = properties?.continueOnError ?? false;
-                if (!serverError || continueOnError) {
-                    clientActionPromises.push(callback(tableActionDetail, actionResult));
-                }
-            }
-            await Promise.all(clientActionPromises);
-        }
-    }
-    checkSectionRequiredFields(sectionCode, reqFieldMessage) {
-        this.cleanErrorFields(null, sectionCode);
-        const requiredFieldMessage = reqFieldMessage ?? this.formConfig?.formStandardErrors.requiredField;
-        const numErrors = this.tagFieldsWithError(requiredFieldMessage, this.getRequiredEmptyFields(null, sectionCode));
-        return (numErrors === 0);
-    }
-    validateSectionConsistency(sectionCode, reqFieldMessage) {
-        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 = this.getRequiredEmptyFields(null, sectionCode) ?? [];
-        if (requiredEmptyFields?.length > 0) {
-            validationError = true;
-            this.setError(this.formConfig?.formStandardErrors.typeWarning, this.formConfig?.formStandardErrors.validationTitle, this.formConfig?.formStandardErrors.requiredFields);
-            this.tagFieldsWithError(this.formConfig?.formStandardErrors.requiredField, requiredEmptyFields);
-            for (const code of requiredEmptyFields) {
-                const requiredEmptyField = this.getField(code);
-                requiredEmptyField?.focus();
-                break;
-            }
-        }
-        const validationIssueFields = this.getFieldsWithValidationIssues(null, sectionCode) ?? [];
-        if (!validationError && validationIssueFields.length > 0) {
-            validationError = true;
-            this.setError(this.formConfig?.formStandardErrors.typeWarning, this.formConfig?.formStandardErrors.validationTitle, this.formConfig?.formStandardErrors.validationFields);
-            for (const code of validationIssueFields) {
-                const validationIssueField = this.getField(code);
-                if (validationIssueField) {
-                    validationIssueField.focus();
-                }
-                break;
-            }
-        }
-        return validationError;
-    }
-    copyTableRecordToFields(tableObj, mappingTable = null) {
-        const tableObject = this.getTable(tableObj.tableCode);
-        const tableRecord = tableObject?.getTableRecord(tableObj.recordId);
-        const columnNames = tableObject?.columnNames;
-        if (tableRecord && columnNames) {
-            for (const columnName of columnNames) {
-                const columnValue = tableRecord.getFieldValue(columnName) ?? '';
-                const code = mappingTable?.[columnName] ?? columnName;
-                const field = code ? this.getField(code) : null;
-                if (field) {
-                    field.setValue(columnValue);
-                    field.hasChanged = false;
-                }
-            }
-            return true;
-        }
-        return false;
-    }
-    notifyFormActivity() {
-        if (this._notifyFormActivity) {
-            this._eventEmiter.next('formActivity', { code: this.formCode });
-        }
-    }
-    /**
-     * Métodos Legacy de compatibilidad hacia atrás
-     */
-    /**
-     * @deprecated Use name
-     */
-    get formCode() { return this.name ?? ''; }
-    /**
-     * @deprecated Use name
-     */
-    set formCode(name) { this.name = name; }
-    /**
-     * @deprecated Use busy signal
-     */
-    get inServerProcess() { return this.busy(); }
-    /**
-     * @deprecated Use state
-     */
-    get currentState() { return this.state ?? ''; }
-    /**
-     * @deprecated Use changeState
-     */
-    set currentState(state) { this?.changeState(state); }
-    /**
-     * @deprecated Use onSectionActivation
-     */
-    get formRoute() { return this._formRoute ?? ''; }
-    /**
-     * @deprecated Use onSectionActivation
-     */
-    set formRoute(route) { this._formRoute = route; }
-    /**
-     * @deprecated Use onSectionActivation
-     */
-    addSectionActivation(codes, callback, properties = null) {
-        return this.onSectionActivation(codes, callback, properties);
-    }
-    /**
-     * @deprecated Use onSectionInactivation
-     */
-    addSectionInactivation(codes, callback, properties = null) {
-        return this.onSectionInactivation(codes, callback, properties);
-    }
-    /**
-     * @deprecated Use onActionStart
-     */
-    addActionMethodStart(codes, callback, properties = null) {
-        return this.onActionStart(codes, callback, properties);
-    }
-    /**
-     * @deprecated Use onActionFinish
-     */
-    addActionMethodFinish(codes, callback, properties = null) {
-        return this.onActionFinish(codes, callback, properties);
-    }
-    /**
-     * @deprecated Use onFieldInput
-     */
-    addFieldInputValidation(codes, callback, properties = null) {
-        return this.onFieldInput(codes, callback, properties);
-    }
-    /**
-     * @deprecated Use onFieldValidationStart
-     */
-    addFieldValidationStart(codes, callback, properties = null) {
-        return this.onFieldValidationStart(codes, callback, properties);
-    }
-    /**
-     * @deprecated Use onFieldValidationFinish
-     */
-    addFieldValidationFinish(codes, callback, properties = null) {
-        return this.onFieldValidationFinish(codes, callback, properties);
-    }
-    /**
-     * @deprecated Use onTableActionStart
-     */
-    addTableActionStart(code, actionCode, callback, properties = null) {
-        return this.onTableActionStart(code, actionCode, callback, properties);
-    }
-    /**
-     * @deprecated Use onTableActionFinish
-     */
-    addTableActionFinish(code, actionCode, callback, properties = null) {
-        return this.onTableActionFinish(code, actionCode, callback, properties);
-    }
-    /**
-     * @deprecated Use onTableSelectionStart
-     */
-    addTableSelectionStart(code, callback, properties = null) {
-        return this.onTableSelectionStart(code, callback, properties);
-    }
-    /**
-     * @deprecated Use onTableSelectionFinish
-     */
-    addTableSelectionFinish(code, callback, properties = null) {
-        return this.onTableSelectionFinish(code, callback, properties);
-    }
-    /**
-     * @deprecated Use onTableGetDataStart
-     */
-    addTableGetDataStart(code, callback, properties = null) {
-        return this.onTableGetDataStart(code, callback, properties);
-    }
-    /**
-     * @deprecated Use onTableGetDataFinish
-     */
-    addTableGetDataFinish(code, callback, properties = null) {
-        return this.onTableGetDataFinish(code, callback, properties);
-    }
-    ngOnDestroy() {
-        this.destroy$.next();
-        this.destroy$.complete();
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BasicFormComponent, deps: [{ token: LibFormManagerService }, { token: LibEventManagerService }, { token: LibFileManagementService }], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: BasicFormComponent, selector: "ng-component", usesInheritance: true, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BasicFormComponent, decorators: [{
-            type: Component,
-            args: [{
-                    template: `<ng-content></ng-content>`
-                }]
-        }], ctorParameters: () => [{ type: LibFormManagerService }, { type: LibEventManagerService }, { type: LibFileManagementService }] });
-
-const COMPONENTS = [
-    BasicFormComponent,
-    ActionComponent,
-    FieldComponent,
-    ElementComponent,
-    FormErrorComponent,
-    FormHeaderComponent,
-    SectionComponent,
-    SubSectionComponent,
-    LibTableRecordActionComponent,
-    LibTableRecordFieldComponent,
-    LibTableComponent
-];
-class TuainNgFormsLibModule {
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TuainNgFormsLibModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.12", 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] });
-    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TuainNgFormsLibModule, imports: [CommonModule,
-            RouterModule,
-            FormsModule] });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", 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