tuain-ng-forms-lib 12.0.91 → 13.0.3

package/esm2020/lib/classes/forms/action.mjs

@@ -0,0 +1,35 @@
+import { Subject } from 'rxjs';
+import { elementTypes } from './form.constants';
+import { FormElement } from './element';
+const HEADER = 'HEADER';
+export class FormAction extends FormElement {
+    constructor(actionDefinition, formConfig) {
+        super(actionDefinition, formConfig);
+        this._actionActivated = new Subject();
+        this.inProgress = false;
+        this.elementType = elementTypes.action;
+        this.actionCode = actionDefinition.actionCode ? actionDefinition.actionCode.toString() : '';
+        this.actionName = actionDefinition.actionTitle;
+        this.iconName = actionDefinition.iconName || this.actionCode;
+        this.setCustomAttribute('location', actionDefinition.position || HEADER);
+        this.backend = actionDefinition?.serverAction ?? false;
+        this.newState = actionDefinition?.newState;
+        this.restrictedOnField = actionDefinition.fieldRestrictedCode ? actionDefinition.fieldRestrictedCode.toString() : '';
+        this.restrictedOnOperator = actionDefinition.operatorRestricted || '';
+        this.restrictedOnValue = actionDefinition.valueRestricted ?? '';
+        this.customValidation = () => true;
+    }
+    get actionActivated() { return this._actionActivated; }
+    start() { this.inProgress = true; }
+    stop() { this.inProgress = false; }
+    notifyActivation() { this._actionActivated.next(this.actionCode); }
+    updateFromServer(receivedAction) {
+        for (const propertyName in receivedAction) {
+            if (propertyName !== 'actionCode' && propertyName !== 'actionId') {
+                this[propertyName] = receivedAction[propertyName];
+            }
+        }
+    }
+    setCustomValidation(callback) { this.customValidation = () => callback(); }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/classes/forms/element.mjs

@@ -0,0 +1,76 @@
+import { elementTypes } from './form.constants';
+export class FormElement {
+    constructor(elementDefinition, formConfig) {
+        this._formConfig = formConfig;
+        this._isForced = false;
+        this.setVisibleStates(elementDefinition.visibleStates);
+        this.setEnabledStates(elementDefinition.enabledStates);
+        this._visibleForced = false;
+        this.disabled = elementDefinition?.disabled ?? false;
+        this.setVisibility(elementDefinition?.visible ?? true);
+        this.customAttributes = elementDefinition?.customAttributes ?? {};
+    }
+    getCustomAttribute(name) { return this.customAttributes?.[name] ?? null; }
+    setCustomAttribute(name, value) { if (name) {
+        this.customAttributes[name] = value;
+    } }
+    matchAttribute(name, value) { return this.customAttributes?.[name] === value; }
+    isField() { return this.elementType === elementTypes.field; }
+    isAction() { return this.elementType === elementTypes.action; }
+    isTable() { return this.elementType === elementTypes.table; }
+    setVisibleStates(newStates) {
+        const visibleStates = (!Array.isArray(newStates) && typeof newStates === 'string')
+            ? newStates.split(',').map(state => state.trim()).filter(state => state.length > 0)
+            : newStates;
+        this.visibleStates = (Array.isArray(visibleStates)) ? visibleStates : [];
+    }
+    setEnabledStates(newStates) {
+        const enabledStates = (!Array.isArray(newStates) && typeof newStates === 'string')
+            ? newStates.split(',').map(state => state.trim()).filter(state => state.length > 0)
+            : newStates;
+        this.enabledStates = (Array.isArray(enabledStates)) ? enabledStates : [];
+    }
+    viewOnState(state) { return (this.visibleStates && state) ? this.visibleStates.includes(state) : false; }
+    enabledOnState(state) { return (this.enabledStates && state) ? this.enabledStates.includes(state) : false; }
+    /**
+     * @deprecated Utilizar viewOnState
+     */
+    supportState(state) { return this.viewOnState(state); }
+    /**
+     * @deprecated Utilizar viewOnState
+     */
+    supportMode(state) { return this.viewOnState(state); }
+    get visible() { return (this._isForced) ? this._visibleForced : this._visible; }
+    set visible(visible) { this.setVisibility(visible); }
+    visibleOn(state) {
+        return this.visible && this.viewOnState(state);
+    }
+    enabledOn(state) {
+        return !this.disabled && this.enabledOnState(state);
+    }
+    setVisibility(visible, forced = null) {
+        this._visible = visible && true;
+        if (forced != null) {
+            this._isForced = forced;
+        }
+    }
+    show(forced) {
+        this._visible = true;
+        if (forced !== null) {
+            this._isForced = forced;
+            this._visibleForced = true;
+        }
+    }
+    hide(forced) {
+        this._visible = false;
+        if (forced !== null) {
+            this._isForced = forced;
+            this._visibleForced = false;
+        }
+    }
+    enable() { this.disabled = false; }
+    disable() { this.disabled = true; }
+    get enabled() { return !this.disabled; }
+    get editable() { return !this.disabled; }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"element.js","sourceRoot":"","sources":["../../../../../../projects/tuain-ng-forms-lib/src/lib/classes/forms/element.ts"],"names":[],"mappings":"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","sourcesContent":["import { elementTypes } from './form.constants';\nexport class FormElement {\n  protected _visible: boolean;\n  protected _visibleForced: boolean;\n  protected _isForced: boolean;\n  _formConfig: any;\n  disabled: boolean;\n  visibleStates: string[];\n  enabledStates: string[];\n  elementType: string;\n  customAttributes: any;\n\n  constructor(elementDefinition: any, formConfig: any) {\n    this._formConfig = formConfig;\n    this._isForced = false;\n    this.setVisibleStates(elementDefinition.visibleStates);\n    this.setEnabledStates(elementDefinition.enabledStates);\n    this._visibleForced = false;\n    this.disabled = elementDefinition?.disabled ?? false;\n    this.setVisibility(elementDefinition?.visible ?? true);\n    this.customAttributes = elementDefinition?.customAttributes ?? {};\n  }\n\n  getCustomAttribute(name: string): string { return this.customAttributes?.[name] ?? null; }\n  setCustomAttribute(name: string, value: any): void { if (name) { this.customAttributes[name] = value; } }\n  matchAttribute(name: string, value: string): boolean { return this.customAttributes?.[name] === value; }\n\n  isField(): boolean { return this.elementType === elementTypes.field; }\n  isAction(): boolean { return this.elementType === elementTypes.action; }\n  isTable(): boolean { return this.elementType === elementTypes.table; }\n\n  setVisibleStates(newStates: any): void {\n    const visibleStates = (!Array.isArray(newStates) && typeof newStates === 'string')\n      ? newStates.split(',').map(state => state.trim()).filter(state => state.length > 0)\n      : newStates;\n    this.visibleStates = (Array.isArray(visibleStates)) ? visibleStates : [];\n  }\n\n  setEnabledStates(newStates: any): void {\n    const enabledStates = (!Array.isArray(newStates) && typeof newStates === 'string')\n      ? newStates.split(',').map(state => state.trim()).filter(state => state.length > 0)\n      : newStates;\n    this.enabledStates = (Array.isArray(enabledStates)) ? enabledStates : [];\n  }\n\n  viewOnState(state: string): boolean { return (this.visibleStates && state) ? this.visibleStates.includes(state) : false; }\n  enabledOnState(state: string): boolean { return (this.enabledStates && state) ? this.enabledStates.includes(state) : false; }\n\n  /**\n   * @deprecated Utilizar viewOnState\n   */\n  supportState(state: string): boolean { return this.viewOnState(state); }\n\n  /**\n   * @deprecated Utilizar viewOnState\n   */\n  supportMode(state: string): boolean { return this.viewOnState(state); }\n\n  get visible(): boolean { return (this._isForced) ? this._visibleForced : this._visible; }\n  set visible(visible: boolean) { this.setVisibility(visible); }\n\n  visibleOn(state: string): boolean {\n    return this.visible && this.viewOnState(state);\n  }\n\n  enabledOn(state: string): boolean {\n    return !this.disabled && this.enabledOnState(state);\n  }\n\n  setVisibility(visible: boolean, forced: boolean = null): void {\n    this._visible = visible && true;\n    if (forced != null) {\n      this._isForced = forced;\n    }\n  }\n\n  show(forced?: boolean): void {\n    this._visible = true;\n    if (forced !== null) {\n      this._isForced = forced;\n      this._visibleForced = true;\n    }\n  }\n\n  hide(forced?: boolean): void {\n    this._visible = false;\n    if (forced !== null) {\n      this._isForced = forced;\n      this._visibleForced = false;\n    }\n  }\n\n  enable(): void { this.disabled = false; }\n  disable(): void { this.disabled = true; }\n\n  get enabled(): boolean { return !this.disabled; }\n  get editable(): boolean { return !this.disabled; }\n}\n"]}

package/esm2020/lib/classes/forms/field.mjs

@@ -0,0 +1,322 @@
+import { Subject } from 'rxjs';
+import yn from 'yn';
+import { elementTypes, NO_ERROR } from './form.constants';
+import { FormElement } from './element';
+const UNDEFINED = 'undefined';
+const DEFAULT_ERROR_TYPE = 'error';
+const DEFAULT_CAPTURE_TYPE = 'INPUT';
+const DEFAULT_ALIGNMENT = 'left';
+const STD_MAX_LENGTH = 50;
+const BIG_MAX_LENGTH = 500;
+const fldAttr = {
+    validateOnServer: 'validateOnServer',
+    value: '_value',
+    minValue: '_minValue',
+    maxValue: '_maxValue',
+    maxLength: '_maxLength',
+    onValidation: '_onValidation',
+    focus: 'focus',
+    intrinsicErrorMessage: '_intrinsicErrorMessage',
+    code: 'fieldCode',
+    info: 'fieldInfo',
+    defaultValue: 'defaultValue',
+    defaultEditable: 'defaultEditable',
+    visibleLabel: 'visibleLabel',
+    required: 'fieldRequired',
+    hasChanged: 'hasChanged',
+    outputOnly: 'outputOnly',
+    captureType: 'captureType',
+    title: 'fieldTitle',
+    type: 'fieldType',
+    alignment: 'fieldAlignment',
+    format: 'fieldFormat',
+    externalValue: 'externalValue',
+    tooltipText: 'tooltipText',
+    errorType: 'errorType',
+    errorCode: 'errorCode',
+    errorMessage: 'errorMessage',
+    options: 'fieldOptions',
+};
+export class FieldDescriptor extends FormElement {
+    constructor(inputFieldReceived, formConfig) {
+        super(inputFieldReceived, formConfig);
+        this._editionFinish = new Subject();
+        this._editionPartial = new Subject();
+        this._detailRequest = new Subject();
+        this._attributeChange = new Subject();
+        this.elementType = elementTypes.field;
+        const fld = (inputFieldReceived) ? inputFieldReceived : {};
+        this.setAttr(fldAttr.code, fld.fieldCode);
+        this.setAttr(fldAttr.title, fld.fieldTitle ?? this.fieldCode);
+        this.setAttr(fldAttr.type, fld.fieldTypeCode);
+        this.setAttr(fldAttr.captureType, fld.captureType ?? DEFAULT_CAPTURE_TYPE);
+        const defaultValue = fld.defaultValue ?? null;
+        if (this.fieldType === this._formConfig.fieldTypes.boolean) {
+            this.setAttr(fldAttr.defaultValue, defaultValue ?? false);
+        }
+        else {
+            this.setAttr(fldAttr.defaultValue, defaultValue);
+        }
+        const defaultTypeAlignment = (this._formConfig.tableFieldStyles[this.fieldType] != null)
+            ? this._formConfig.tableFieldStyles[this.fieldType]['text-align'] : DEFAULT_ALIGNMENT;
+        const fieldAlignment = (fld.alignment != null) ? fld.alignment.toLowerCase() : defaultTypeAlignment;
+        this.setAttr(fldAttr.alignment, fieldAlignment);
+        this.setAttr(fldAttr.info, fld.info || '');
+        let fieldFormat;
+        try {
+            fieldFormat = (fld.format) ? new RegExp(fld.format) : null;
+        }
+        catch (e) {
+            fieldFormat = null;
+        }
+        this.setAttr(fldAttr.format, fieldFormat);
+        this.setAttr(fldAttr.validateOnServer, fld.serverAction ?? false);
+        this.setAttr(fldAttr.tooltipText, fld.tooltip || '');
+        this.setAttr(fldAttr.defaultEditable, this.enabled);
+        this.setAttr(fldAttr.required, fld.required ?? false);
+        this.setError(fld.errorCode, fld.errorMessage, fld.errorType ?? DEFAULT_ERROR_TYPE);
+        this.setAttr(fldAttr.outputOnly, fld.outputOnly ?? false);
+        const maxLength = fld.maxLength ?? (this.captureType === 'TEXTAREA' ? BIG_MAX_LENGTH : STD_MAX_LENGTH);
+        this.setAttr(fldAttr.maxLength, maxLength);
+        this.setAttr(fldAttr.intrinsicErrorMessage, this._formConfig.fieldTypeErrMsg[this.fieldType] ?? this._formConfig.fieldTypeErrMsg.DEFAULT);
+        this.setEditable(fld.editable ?? true);
+        this.setVisibleLabel(fld.visibleLabel ?? true);
+        this.setVisibility(fld.visible);
+        this.setFieldOptions(fld.fieldOptions);
+        this.setValue(fld.fieldValue ?? this.defaultValue ?? '');
+    }
+    get name() { return this.fieldCode; }
+    get editionFinish() { return this._editionFinish; }
+    get attributeChange() { return this._attributeChange; }
+    get editionPartial() { return this._editionPartial; }
+    get detailRequest() { return this._detailRequest; }
+    get info() { return this.fieldInfo; }
+    get validating() { return this._onValidation; }
+    set validating(isValidating) { this.setAttr(fldAttr.onValidation, isValidating); }
+    focus() { this.setAttr(fldAttr.focus, true); }
+    setIntrinsicErrorMessage(message) { this.setAttr(fldAttr.intrinsicErrorMessage, message); }
+    set intrinsicErrorMessage(message) { this.setIntrinsicErrorMessage(message); }
+    get fieldValue() { return this.getValue(); }
+    getRequired() { return this.required; }
+    setRequired(required) { this.required = required; }
+    get required() { return this.fieldRequired; }
+    set required(required) { this.setAttr(fldAttr.required, required ?? false); }
+    get maxLength() { return (this._maxLength > 0) ? this._maxLength.toString() : ''; }
+    set maxLength(requiredMaxLength) {
+        if (typeof requiredMaxLength === 'string') {
+            this.setAttr(fldAttr.maxLength, parseInt(requiredMaxLength, 10));
+        }
+        else if (typeof requiredMaxLength === 'number') {
+            this.setAttr(fldAttr.maxLength, requiredMaxLength);
+        }
+    }
+    get value() { return this.getValue(); }
+    set value(newValue) { this.setValue(newValue); }
+    notifyEditionPartial() {
+        const intrinsicValidation = true;
+        this._editionPartial.next({ code: this.fieldCode, intrinsicValidation });
+    }
+    notifyEditionFinish() {
+        let intrinsicValidation = true;
+        const fieldDefaultFormat = this._formConfig.fieldTypesPatterns?.[this.fieldType] ?? null;
+        const fieldValue = this.getValue();
+        if (fieldValue && (fieldDefaultFormat || this.fieldFormat)) {
+            intrinsicValidation = (fieldDefaultFormat?.test(fieldValue) ?? true)
+                && (this.fieldFormat?.test(fieldValue) ?? true);
+            if (!intrinsicValidation) {
+                this.setError('99', this._intrinsicErrorMessage);
+            }
+        }
+        if (intrinsicValidation && fieldValue && this._minValue && fieldValue < this._minValue) {
+            intrinsicValidation = false;
+            this.setError('99', 'Campo con valor inferior al mínimo');
+        }
+        if (intrinsicValidation && fieldValue && this._maxValue && fieldValue > this._maxValue) {
+            intrinsicValidation = false;
+            this.setError('99', 'Campo con valor superior al máximo');
+        }
+        this._editionFinish.next({ code: this.fieldCode, intrinsicValidation });
+    }
+    setAttr(name, value) {
+        this[name] = value;
+        if (this._formConfig.monitoredFieldAttributes.includes(name)) {
+            this._attributeChange.next({ name, value });
+        }
+    }
+    notifyEditionDetailRequest(detail) {
+        const detailEvent = {
+            code: this.fieldCode,
+            detail,
+        };
+        this._detailRequest.next(detailEvent);
+    }
+    setVisibleLabel(visibleLabel) { this.setAttr(fldAttr.visibleLabel, visibleLabel); }
+    showLabel() { this.setVisibleLabel(true); }
+    hideLabel() { this.setVisibleLabel(false); }
+    setChanged(hasChanged) { this.setAttr(fldAttr.hasChanged, hasChanged); }
+    changed() { this.setChanged(true); }
+    setLabel(label) { this.setAttr(fldAttr.title, label); }
+    clean() { this.setValue(this.defaultValue || ''); this.resetError(); }
+    get backend() { return this.validateOnServer; }
+    setEditable(editable = true) { (editable) ? this.enable() : this.disable(); }
+    hasError() { return this.errorCode !== NO_ERROR; }
+    resetError() { (this.errorCode !== NO_ERROR) && this.setError(NO_ERROR, null); }
+    setError(code, message, type = DEFAULT_ERROR_TYPE) {
+        this.setAttr(fldAttr.errorCode, code ?? NO_ERROR);
+        this.setAttr(fldAttr.errorType, (this.errorCode === NO_ERROR) ? '' : type);
+        this.setAttr(fldAttr.errorMessage, message ?? '');
+    }
+    getError() { return { type: this.errorType, code: this.errorCode, message: this.errorMessage }; }
+    get error() { return this.getError(); }
+    set error(errorObj) { this.setError(errorObj.code, errorObj.message, errorObj.type ?? DEFAULT_ERROR_TYPE); }
+    getErrorCode() { return this.getError().code; }
+    setErrorCode(code) { this.setError(code, this.errorMessage); }
+    getErrorMessage() { return this.getError().message; }
+    setErrorMessage(msg) { this.setError(this.errorCode, msg); }
+    get empty() { return this.isEmpty(); }
+    isEmpty() {
+        const fieldCurrentValue = this.getValue();
+        if (fieldCurrentValue === undefined || fieldCurrentValue === null) {
+            return true;
+        }
+        if (this.fieldType === this._formConfig.fieldTypes.array
+            && Array.isArray(fieldCurrentValue) && fieldCurrentValue.length === 0) {
+            return true;
+        }
+        ;
+        if (this.fieldType === this._formConfig.fieldTypes.phone) {
+            if (!Array.isArray(fieldCurrentValue)) {
+                return true;
+            }
+            if (fieldCurrentValue.length !== 2 || !fieldCurrentValue[0] || !fieldCurrentValue[1]) {
+                return true;
+            }
+            return false;
+        }
+        ;
+        return fieldCurrentValue === '';
+    }
+    getValue() {
+        if (this.fieldType === this._formConfig.fieldTypes.boolean
+            || this.fieldType === this._formConfig.fieldTypes.check) {
+            return yn(this._value);
+        }
+        return this._value;
+    }
+    getOptionText() {
+        return this.fieldOptions?.find(item => item.fieldOptionId === this._value)?.fieldOptionValue ?? null;
+    }
+    updateFromServer(fld) {
+        const fieldKeys = Object.keys(fld);
+        for (let index = 0; index < fieldKeys.length; index++) {
+            const attrName = fieldKeys[index];
+            const attrValue = fld[attrName];
+            (attrName === this._formConfig.apiFieldAttrs.visible) && this.setVisibility(attrValue);
+            (attrName === this._formConfig.apiFieldAttrs.labelVisible) && this.setVisibleLabel(fld.visibleLabel);
+            (attrName === this._formConfig.apiFieldAttrs.required) && this.setAttr(fldAttr.required, fld.required ?? false);
+            (attrName === this._formConfig.apiFieldAttrs.errorCode) && this.setAttr(fldAttr.errorCode, fld.errorCode);
+            (attrName === this._formConfig.apiFieldAttrs.errorMessage) && this.setAttr(fldAttr.errorMessage, fld.errorMessage);
+            (attrName === this._formConfig.apiFieldAttrs.tooltip) && this.setAttr(fldAttr.tooltipText, fld.tooltip);
+            (attrName === this._formConfig.apiFieldAttrs.info) && this.setAttr(fldAttr.info, fld.info);
+            (attrName === this._formConfig.apiFieldAttrs.editable) && this.setEditable(fld.editable);
+            (attrName === this._formConfig.apiFieldAttrs.title) && this.setLabel(fld.fieldTitle.toString());
+            (attrName === this._formConfig.apiFieldAttrs.value) && (this.setValue(fld.fieldValue) && this.setChanged(false));
+            (attrName === this._formConfig.apiFieldAttrs.options) && this.setFieldOptions(fld.fieldOptions);
+            (attrName === this._formConfig.apiFieldAttrs.captureType) && this.setAttr(fldAttr.captureType, fld.captureType || 'INPUT');
+            (attrName === this._formConfig.apiFieldAttrs.type) && this.setAttr(fldAttr.type, fld.fieldTypeCode);
+            (attrName === this._formConfig.apiFieldAttrs.maxLength) && this.setAttr(fldAttr.maxLength, fld.maxLength);
+        }
+    }
+    setMinValue(inputMinValue) {
+        let minValue = inputMinValue;
+        if (this.fieldType === this._formConfig.fieldTypes.date) {
+            minValue = new Date(minValue);
+        }
+        this.setAttr(fldAttr.minValue, minValue);
+    }
+    setMaxValue(inputMaxValue) {
+        let maxValue = inputMaxValue;
+        if (this.fieldType === this._formConfig.fieldTypes.date) {
+            maxValue = new Date(maxValue);
+        }
+        this.setAttr(fldAttr.maxValue, maxValue);
+    }
+    getFieldOptions() {
+        return this.fieldOptions.map(option => {
+            const optionCopy = { ...option };
+            return optionCopy;
+        });
+    }
+    setFieldOptions(newOptions) {
+        if ((!this._formConfig.captureTypesWithOptions.includes(this.captureType))
+            || typeof newOptions === UNDEFINED || !newOptions
+            || !Array.isArray(newOptions)) {
+            return;
+        }
+        let fieldOptions = newOptions.map(option => {
+            if (option.text !== undefined && option.text !== null
+                && option.value !== undefined && option.value !== null) {
+                return { fieldOptionValue: option.text, fieldOptionId: option.value };
+            }
+            return { ...option };
+        });
+        fieldOptions = (fieldOptions && Array.isArray(fieldOptions)
+            && fieldOptions.length > 0) ? fieldOptions : [];
+        this.setAttr(fldAttr.options, fieldOptions);
+        if (this._value) {
+            if (this.fieldType === this._formConfig.fieldTypes.array && Array.isArray(this._value)) {
+                const fieldValue = this._value?.filter(item => this.fieldOptions.find(opt => opt.fieldOptionId === item));
+                this.setAttr(fldAttr.value, fieldValue);
+            }
+            else {
+                const valInOptions = this.fieldOptions
+                    .find(item => item.fieldOptionId === this._value);
+                if (!valInOptions) {
+                    this.setValue('');
+                }
+            }
+        }
+        if (this.fieldRequired && this.fieldOptions.length === 1) {
+            this.setValue(this.fieldOptions[0].fieldOptionId);
+        }
+    }
+    setValue(newValue, widgetUpdate = true) {
+        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.setChanged(true);
+            if (widgetUpdate) {
+                this.setAttr(fldAttr.value, newFinalValue);
+            }
+            else {
+                this._value = newFinalValue;
+            }
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"field.js","sourceRoot":"","sources":["../../../../../../projects/tuain-ng-forms-lib/src/lib/classes/forms/field.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,EAAE,MAAM,IAAI,CAAC;AACpB,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAGxC,MAAM,SAAS,GAAG,WAAW,CAAC;AAE9B,MAAM,kBAAkB,GAAG,OAAO,CAAC;AACnC,MAAM,oBAAoB,GAAG,OAAO,CAAC;AACrC,MAAM,iBAAiB,GAAG,MAAM,CAAC;AAEjC,MAAM,cAAc,GAAG,EAAE,CAAC;AAC1B,MAAM,cAAc,GAAG,GAAG,CAAC;AAE3B,MAAM,OAAO,GAAG;IACd,gBAAgB,EAAE,kBAAkB;IACpC,KAAK,EAAE,QAAQ;IACf,QAAQ,EAAE,WAAW;IACrB,QAAQ,EAAE,WAAW;IACrB,SAAS,EAAE,YAAY;IACvB,YAAY,EAAE,eAAe;IAC7B,KAAK,EAAE,OAAO;IACd,qBAAqB,EAAE,wBAAwB;IAC/C,IAAI,EAAE,WAAW;IACjB,IAAI,EAAE,WAAW;IACjB,YAAY,EAAE,cAAc;IAC5B,eAAe,EAAE,iBAAiB;IAClC,YAAY,EAAE,cAAc;IAC5B,QAAQ,EAAE,eAAe;IACzB,UAAU,EAAE,YAAY;IACxB,UAAU,EAAE,YAAY;IACxB,WAAW,EAAE,aAAa;IAC1B,KAAK,EAAE,YAAY;IACnB,IAAI,EAAE,WAAW;IACjB,SAAS,EAAE,gBAAgB;IAC3B,MAAM,EAAE,aAAa;IACrB,aAAa,EAAE,eAAe;IAC9B,WAAW,EAAE,aAAa;IAC1B,SAAS,EAAE,WAAW;IACtB,SAAS,EAAE,WAAW;IACtB,YAAY,EAAE,cAAc;IAC5B,OAAO,EAAE,cAAc;CACxB,CAAC;AAYF,MAAM,OAAO,eAAgB,SAAQ,WAAW;IAwC9C,YAAY,kBAAkB,EAAE,UAAU;QACxC,KAAK,CAAC,kBAAkB,EAAE,UAAU,CAAC,CAAC;QAxCvB,mBAAc,GAAG,IAAI,OAAO,EAAO,CAAC;QACpC,oBAAe,GAAG,IAAI,OAAO,EAAO,CAAC;QACrC,mBAAc,GAAG,IAAI,OAAO,EAAe,CAAC;QAC5C,qBAAgB,GAAG,IAAI,OAAO,EAAO,CAAC;QAsCrD,IAAI,CAAC,WAAW,GAAG,YAAY,CAAC,KAAK,CAAC;QACtC,MAAM,GAAG,GAAG,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAC,EAAE,CAAC;QAE3D,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,SAAS,CAAC,CAAC;QAC1C,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,UAAU,IAAI,IAAI,CAAC,SAAS,CAAC,CAAC;QAC9D,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,aAAa,CAAC,CAAA;QAC7C,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,WAAW,EAAE,GAAG,CAAC,WAAW,IAAI,oBAAoB,CAAC,CAAC;QAC3E,MAAM,YAAY,GAAG,GAAG,CAAC,YAAY,IAAI,IAAI,CAAC;QAC9C,IAAI,IAAI,CAAC,SAAS,KAAK,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,OAAO,EAAE;YAC1D,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,YAAY,EAAE,YAAY,IAAI,KAAK,CAAE,CAAC;SAC5D;aAAM;YACL,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC;SAClD;QACD,MAAM,oBAAoB,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,IAAI,CAAC;YACtF,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,iBAAiB,CAAC;QACxF,MAAM,cAAc,GAAG,CAAC,GAAG,CAAC,SAAS,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,oBAAoB,CAAC;QACpG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC;QAChD,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC;QAC3C,IAAI,WAAW,CAAC;QAChB,IAAI;YACF,WAAW,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;SAC5D;QAAC,OAAO,CAAC,EAAE;YACV,WAAW,GAAG,IAAI,CAAC;SACpB;QACD,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;QAE1C,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,gBAAgB,EAAE,GAAG,CAAC,YAAY,IAAI,KAAK,CAAC,CAAC;QAElE,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,WAAW,EAAE,GAAG,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC;QACrD,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,eAAe,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;QACpD,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,QAAQ,EAAE,GAAG,CAAC,QAAQ,IAAI,KAAK,CAAC,CAAC;QACtD,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,EAAE,GAAG,CAAC,YAAY,EAAE,GAAG,CAAC,SAAS,IAAI,kBAAkB,CAAC,CAAC;QACpF,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,GAAG,CAAC,UAAU,IAAI,KAAK,CAAC,CAAC;QAC1D,MAAM,SAAS,GAAG,GAAG,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,WAAW,KAAK,UAAU,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC;QACvG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;QAC3C,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,qBAAqB,EAAE,IAAI,CAAC,WAAW,CAAC,eAAe,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,IAAI,CAAC,WAAW,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;QAE1I,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,QAAQ,IAAI,IAAI,CAAC,CAAC;QACvC,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,YAAY,IAAI,IAAI,CAAC,CAAC;QAC/C,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QAChC,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;QACvC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,IAAI,IAAI,CAAC,YAAY,IAAI,EAAE,CAAC,CAAC;IAC3D,CAAC;IAED,IAAI,IAAI,KAAK,OAAO,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;IACrC,IAAI,aAAa,KAAK,OAAO,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC;IACnD,IAAI,eAAe,KAAK,OAAO,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC;IAEvD,IAAI,cAAc,KAAK,OAAO,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC;IACrD,IAAI,aAAa,KAAK,OAAO,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC;IACnD,IAAI,IAAI,KAAK,OAAO,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;IAErC,IAAI,UAAU,KAAK,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC;IAC/C,IAAI,UAAU,CAAC,YAAqB,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC;IAE3F,KAAK,KAAK,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;IAE9C,wBAAwB,CAAC,OAAe,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,qBAAqB,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IACnG,IAAI,qBAAqB,CAAC,OAAe,IAAI,IAAI,CAAC,wBAAwB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IAEtF,IAAI,UAAU,KAAK,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;IAE5C,WAAW,KAAK,OAAO,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;IACvC,WAAW,CAAC,QAAiB,IAAI,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC,CAAC,CAAC;IAE5D,IAAI,QAAQ,KAAc,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC;IACtD,IAAI,QAAQ,CAAC,QAAiB,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,QAAQ,EAAE,QAAQ,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC;IACtF,IAAI,SAAS,KAAK,OAAO,CAAC,IAAI,CAAC,UAAU,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACnF,IAAI,SAAS,CAAC,iBAAsB;QAClC,IAAI,OAAO,iBAAiB,KAAK,QAAQ,EAAE;YACzC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,SAAS,EAAE,QAAQ,CAAC,iBAAiB,EAAE,EAAE,CAAC,CAAC,CAAC;SAClE;aAAM,IAAI,OAAO,iBAAiB,KAAK,QAAQ,EAAE;YAChD,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,SAAS,EAAE,iBAAiB,CAAC,CAAC;SACpD;IACH,CAAC;IACD,IAAI,KAAK,KAAK,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;IACvC,IAAI,KAAK,CAAC,QAAQ,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IAEhD,oBAAoB;QAClB,MAAM,mBAAmB,GAAG,IAAI,CAAC;QACjC,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,EAAE,mBAAmB,EAAE,CAAC,CAAC;IAC3E,CAAC;IAED,mBAAmB;QACjB,IAAI,mBAAmB,GAAG,IAAI,CAAC;QAC/B,MAAM,kBAAkB,GAAG,IAAI,CAAC,WAAW,CAAC,kBAAkB,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,IAAI,CAAC;QACzF,MAAM,UAAU,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;QACnC,IAAI,UAAU,IAAI,CAAC,kBAAkB,IAAI,IAAI,CAAC,WAAW,CAAC,EAAE;YAC1D,mBAAmB,GAAG,CAAC,kBAAkB,EAAE,IAAI,CAAC,UAAU,CAAC,IAAI,IAAI,CAAC;mBAC/D,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,UAAU,CAAC,IAAI,IAAI,CAAC,CAAC;YAClD,IAAI,CAAC,mBAAmB,EAAE;gBACxB,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,sBAAsB,CAAC,CAAC;aAClD;SACF;QACD,IAAI,mBAAmB,IAAI,UAAU,IAAI,IAAI,CAAC,SAAS,IAAI,UAAU,GAAG,IAAI,CAAC,SAAS,EAAE;YACtF,mBAAmB,GAAG,KAAK,CAAC;YAC5B,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,oCAAoC,CAAC,CAAC;SAC3D;QACD,IAAI,mBAAmB,IAAI,UAAU,IAAI,IAAI,CAAC,SAAS,IAAI,UAAU,GAAG,IAAI,CAAC,SAAS,EAAE;YACtF,mBAAmB,GAAG,KAAK,CAAC;YAC5B,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,oCAAoC,CAAC,CAAC;SAC3D;QACD,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,EAAE,mBAAmB,EAAE,CAAC,CAAC;IAC1E,CAAC;IAED,OAAO,CAAC,IAAY,EAAE,KAAU;QAC9B,IAAI,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC;QACnB,IAAI,IAAI,CAAC,WAAW,CAAC,wBAAwB,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE;YAC5D,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;SAC7C;IACH,CAAC;IAED,0BAA0B,CAAC,MAAW;QACpC,MAAM,WAAW,GAAgB;YAC/B,IAAI,EAAE,IAAI,CAAC,SAAS;YACpB,MAAM;SACP,CAAC;QACF,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IACxC,CAAC;IAED,eAAe,CAAC,YAAqB,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC;IAC5F,SAAS,KAAK,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAC3C,SAAS,KAAK,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAE5C,UAAU,CAAC,UAAmB,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;IACjF,OAAO,KAAK,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAEpC,QAAQ,CAAC,KAAK,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;IACvD,KAAK,KAAK,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,YAAY,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC;IACtE,IAAI,OAAO,KAAK,OAAO,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC;IAE/C,WAAW,CAAC,WAAoB,IAAI,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;IAEtF,QAAQ,KAAK,OAAO,IAAI,CAAC,SAAS,KAAK,QAAQ,CAAC,CAAC,CAAC;IAClD,UAAU,KAAK,CAAC,IAAI,CAAC,SAAS,KAAK,QAAQ,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;IAChF,QAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,GAAG,kBAAkB;QAC/C,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,SAAS,EAAE,IAAI,IAAI,QAAQ,CAAC,CAAC;QAClD,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC,IAAI,CAAC,SAAS,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QAC3E,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,YAAY,EAAE,OAAO,IAAI,EAAE,CAAC,CAAC;IACpD,CAAC;IAED,QAAQ,KAAK,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,EAAE,OAAO,EAAE,IAAI,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC;IACjG,IAAI,KAAK,KAAK,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;IACvC,IAAI,KAAK,CAAC,QAAQ,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,IAAI,IAAI,kBAAkB,CAAC,CAAA,CAAC,CAAC;IAE3G,YAAY,KAAK,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC;IAC/C,YAAY,CAAC,IAAI,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IAC9D,eAAe,KAAK,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;IACrD,eAAe,CAAC,GAAG,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;IAE5D,IAAI,KAAK,KAAc,OAAO,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;IAE/C,OAAO;QACL,MAAM,iBAAiB,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;QAC1C,IAAI,iBAAiB,KAAK,SAAS,IAAI,iBAAiB,KAAK,IAAI,EAAE;YACjE,OAAO,IAAI,CAAC;SACb;QACD,IAAI,IAAI,CAAC,SAAS,KAAK,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,KAAK;eACnD,KAAK,CAAC,OAAO,CAAC,iBAAiB,CAAC,IAAI,iBAAiB,CAAC,MAAM,KAAK,CAAC,EAAE;YACvE,OAAO,IAAI,CAAC;SACb;QAAA,CAAC;QACF,IAAI,IAAI,CAAC,SAAS,KAAK,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,KAAK,EAAE;YACxD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,iBAAiB,CAAC,EAAE;gBACrC,OAAO,IAAI,CAAC;aACb;YACD,IAAI,iBAAiB,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE;gBACpF,OAAO,IAAI,CAAC;aACb;YACD,OAAO,KAAK,CAAC;SACd;QAAA,CAAC;QACF,OAAO,iBAAiB,KAAK,EAAE,CAAC;IAClC,CAAC;IAED,QAAQ;QACN,IAAI,IAAI,CAAC,SAAS,KAAK,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,OAAO;eACrD,IAAI,CAAC,SAAS,KAAK,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,KAAK,EAAE;YACzD,OAAO,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;SACxB;QACD,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED,aAAa;QACX,OAAO,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,aAAa,KAAK,IAAI,CAAC,MAAM,CAAC,EAAE,gBAAgB,IAAI,IAAI,CAAC;IACvG,CAAC;IAED,gBAAgB,CAAC,GAAG;QAClB,MAAM,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACnC,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE;YACrD,MAAM,QAAQ,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;YAClC,MAAM,SAAS,GAAG,GAAG,CAAC,QAAQ,CAAC,CAAC;YAChC,CAAC,QAAQ,KAAK,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC;YACvF,CAAC,QAAQ,KAAK,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,YAAY,CAAC,IAAI,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;YACrG,CAAC,QAAQ,KAAK,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,QAAQ,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,QAAQ,EAAE,GAAG,CAAC,QAAQ,IAAI,KAAK,CAAC,CAAC;YAChH,CAAC,QAAQ,KAAK,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,SAAS,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,SAAS,EAAE,GAAG,CAAC,SAAS,CAAC,CAAC;YAC1G,CAAC,QAAQ,KAAK,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,YAAY,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,YAAY,EAAE,GAAG,CAAC,YAAY,CAAC,CAAC;YACnH,CAAC,QAAQ,KAAK,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,WAAW,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;YACxG,CAAC,QAAQ,KAAK,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,IAAI,CAAC,CAAC;YAC3F,CAAC,QAAQ,KAAK,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,QAAQ,CAAC,IAAI,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;YACzF,CAAC,QAAQ,KAAK,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC,CAAC;YAChG,CAAC,QAAQ,KAAK,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC;YACjH,CAAC,QAAQ,KAAK,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;YAChG,CAAC,QAAQ,KAAK,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,WAAW,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,WAAW,EAAE,GAAG,CAAC,WAAW,IAAI,OAAO,CAAC,CAAC;YAC3H,CAAC,QAAQ,KAAK,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,aAAa,CAAC,CAAC;YACpG,CAAC,QAAQ,KAAK,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,SAAS,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,SAAS,EAAE,GAAG,CAAC,SAAS,CAAC,CAAC;SAC3G;IACH,CAAC;IAED,WAAW,CAAC,aAAa;QACvB,IAAI,QAAQ,GAAG,aAAa,CAAC;QAC7B,IAAI,IAAI,CAAC,SAAS,KAAK,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,IAAI,EAAE;YACvD,QAAQ,GAAG,IAAI,IAAI,CAAC,QAAQ,CAAC,CAAC;SAC/B;QACD,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;IAC3C,CAAC;IAED,WAAW,CAAC,aAAa;QACvB,IAAI,QAAQ,GAAG,aAAa,CAAC;QAC7B,IAAI,IAAI,CAAC,SAAS,KAAK,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,IAAI,EAAE;YACvD,QAAQ,GAAG,IAAI,IAAI,CAAC,QAAQ,CAAC,CAAC;SAC/B;QACD,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;IAC3C,CAAC;IAED,eAAe;QACb,OAAO,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE;YACpC,MAAM,UAAU,GAAgB,EAAE,GAAG,MAAM,EAAE,CAAC;YAC9C,OAAO,UAAU,CAAC;QACpB,CAAC,CAAC,CAAC;IACL,CAAC;IAGD,eAAe,CAAC,UAAU;QACxB,IAAI,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,uBAAuB,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;eACrE,OAAO,UAAU,KAAK,SAAS,IAAI,CAAC,UAAU;eAC9C,CAAC,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE;YAC/B,OAAO;SACR;QACD,IAAI,YAAY,GAAG,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE;YACzC,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS,IAAI,MAAM,CAAC,IAAI,KAAK,IAAI;mBAChD,MAAM,CAAC,KAAK,KAAK,SAAS,IAAI,MAAM,CAAC,KAAK,KAAK,IAAI,EAAE;gBACxD,OAAO,EAAE,gBAAgB,EAAE,MAAM,CAAC,IAAI,EAAE,aAAa,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC;aACvE;YACD,OAAO,EAAE,GAAG,MAAM,EAAE,CAAC;QACvB,CAAC,CAAC,CAAC;QACH,YAAY,GAAG,CAAC,YAAY,IAAI,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC;eACtD,YAAY,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC;QAClD,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;QAC5C,IAAI,IAAI,CAAC,MAAM,EAAE;YACf,IAAI,IAAI,CAAC,SAAS,KAAK,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,KAAK,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE;gBACtF,MAAM,UAAU,GAAG,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,IAAI,CAAC,EAAE,CAC5C,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,aAAa,KAAK,IAAI,CAAC,CAC1D,CAAC;gBACF,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC;aACzC;iBAAM;gBACL,MAAM,YAAY,GAAG,IAAI,CAAC,YAAY;qBACnC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,aAAa,KAAK,IAAI,CAAC,MAAM,CAAC,CAAC;gBACpD,IAAI,CAAC,YAAY,EAAE;oBACjB,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;iBACnB;aACF;SACF;QACD,IAAI,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE;YACxD,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC;SACnD;IACH,CAAC;IAED,QAAQ,CAAC,QAAQ,EAAE,YAAY,GAAG,IAAI;QACpC,IAAI,OAAO,QAAQ,KAAK,SAAS,EAAE;YACjC,OAAO,IAAI,CAAC;SACb;QACD,IAAI,QAAQ,KAAK,IAAI,IAAI,IAAI,CAAC,QAAQ,EAAE;YACtC,OAAO,IAAI,CAAC;SACb;QACD,IAAI,aAAa,CAAC;QAClB,IAAI,IAAI,CAAC,SAAS,KAAK,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,OAAO;eACrD,IAAI,CAAC,SAAS,KAAK,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,KAAK,EAAE;YACzD,aAAa,GAAG,EAAE,CAAC,QAAQ,CAAC,IAAI,KAAK,CAAC;SACvC;aAAM,IAAI,IAAI,CAAC,SAAS,KAAK,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,KAAK;eAC1D,IAAI,CAAC,SAAS,KAAK,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,GAAG,EAAE;YACvD,IAAI,QAAQ,KAAK,IAAI,IAAI,QAAQ,KAAK,EAAE,EAAE;gBACxC,aAAa,GAAG,EAAE,CAAC;aACpB;iBAAM,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE;gBAClC,aAAa,GAAG,QAAQ,CAAC;aAC1B;iBAAM;gBACL,aAAa,GAAG,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;aAChD;SACF;aAAM;YACL,aAAa,GAAG,QAAQ,CAAC;SAC1B;QACD,IAAI,IAAI,CAAC,MAAM,KAAK,aAAa,EAAE;YACjC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;YACtB,IAAI,YAAY,EAAE;gBAChB,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC;aAC5C;iBAAM;gBACL,IAAI,CAAC,MAAM,GAAG,aAAa,CAAC;aAC7B;SACF;QACD,OAAO,IAAI,CAAC;IACd,CAAC;CACF","sourcesContent":["import { Subject } from 'rxjs';\nimport yn from 'yn';\nimport { elementTypes, NO_ERROR } from './form.constants';\nimport { FormElement } from './element';\nimport { isNgTemplate } from '@angular/compiler';\n\nconst UNDEFINED = 'undefined';\n\nconst DEFAULT_ERROR_TYPE = 'error';\nconst DEFAULT_CAPTURE_TYPE = 'INPUT';\nconst DEFAULT_ALIGNMENT = 'left';\n\nconst STD_MAX_LENGTH = 50;\nconst BIG_MAX_LENGTH = 500;\n\nconst fldAttr = {\n  validateOnServer: 'validateOnServer',\n  value: '_value',\n  minValue: '_minValue',\n  maxValue: '_maxValue',\n  maxLength: '_maxLength',\n  onValidation: '_onValidation',\n  focus: 'focus',\n  intrinsicErrorMessage: '_intrinsicErrorMessage',\n  code: 'fieldCode',\n  info: 'fieldInfo',\n  defaultValue: 'defaultValue',\n  defaultEditable: 'defaultEditable',\n  visibleLabel: 'visibleLabel',\n  required: 'fieldRequired',\n  hasChanged: 'hasChanged',\n  outputOnly: 'outputOnly',\n  captureType: 'captureType',\n  title: 'fieldTitle',\n  type: 'fieldType',\n  alignment: 'fieldAlignment',\n  format: 'fieldFormat',\n  externalValue: 'externalValue',\n  tooltipText: 'tooltipText',\n  errorType: 'errorType',\n  errorCode: 'errorCode',\n  errorMessage: 'errorMessage',\n  options: 'fieldOptions',\n};\n\nexport interface DetailEvent {\n  code: string;\n  detail: any;\n}\n\nexport interface FieldOption {\n  fieldOptionValue: string;\n  fieldOptionId: string;\n}\n\nexport class FieldDescriptor extends FormElement {\n  private readonly _editionFinish = new Subject<any>();\n  private readonly _editionPartial = new Subject<any>();\n  private readonly _detailRequest = new Subject<DetailEvent>();\n  private readonly _attributeChange = new Subject<any>();\n\n  private validateOnServer: boolean;\n\n  private _value: any;\n  private _focus: boolean;\n\n  private _minValue: any;\n  private _maxValue: any;\n  private _maxLength: number;\n  _onValidation: boolean;\n  _intrinsicErrorMessage: string;\n\n  fieldCode: string;\n  fieldInfo: string;\n  defaultValue: string;\n  defaultEditable: boolean;\n\n  visibleLabel: boolean;\n  fieldRequired: boolean;\n  hasChanged: boolean;\n  outputOnly: boolean;\n  captureType: string;\n  fieldTitle: string;\n  fieldType: string;\n  fieldAlignment: string;\n  fieldFormat: RegExp;\n  externalValue: any;\n  tooltipText: string;\n\n  errorType: string;\n  errorCode: string;\n  errorMessage: string;\n\n  fieldOptions: FieldOption[];\n\n  constructor(inputFieldReceived, formConfig) {\n    super(inputFieldReceived, formConfig);\n    this.elementType = elementTypes.field;\n    const fld = (inputFieldReceived) ? inputFieldReceived : {};\n\n    this.setAttr(fldAttr.code, fld.fieldCode);\n    this.setAttr(fldAttr.title, fld.fieldTitle ?? this.fieldCode);\n    this.setAttr(fldAttr.type, fld.fieldTypeCode)\n    this.setAttr(fldAttr.captureType, fld.captureType ?? DEFAULT_CAPTURE_TYPE);\n    const defaultValue = fld.defaultValue ?? null;\n    if (this.fieldType === this._formConfig.fieldTypes.boolean) {\n      this.setAttr(fldAttr.defaultValue, defaultValue ?? false );\n    } else {\n      this.setAttr(fldAttr.defaultValue, defaultValue);\n    }\n    const defaultTypeAlignment = (this._formConfig.tableFieldStyles[this.fieldType] != null)\n      ? this._formConfig.tableFieldStyles[this.fieldType]['text-align'] : DEFAULT_ALIGNMENT;\n    const fieldAlignment = (fld.alignment != null) ? fld.alignment.toLowerCase() : defaultTypeAlignment;\n    this.setAttr(fldAttr.alignment, fieldAlignment);\n    this.setAttr(fldAttr.info, fld.info || '');\n    let fieldFormat;\n    try {\n      fieldFormat = (fld.format) ? new RegExp(fld.format) : null;\n    } catch (e) {\n      fieldFormat = null;\n    }\n    this.setAttr(fldAttr.format, fieldFormat);\n\n    this.setAttr(fldAttr.validateOnServer, fld.serverAction ?? false);\n\n    this.setAttr(fldAttr.tooltipText, fld.tooltip || '');\n    this.setAttr(fldAttr.defaultEditable, this.enabled);\n    this.setAttr(fldAttr.required, fld.required ?? false);\n    this.setError(fld.errorCode, fld.errorMessage, fld.errorType ?? DEFAULT_ERROR_TYPE);\n    this.setAttr(fldAttr.outputOnly, fld.outputOnly ?? false);\n    const maxLength = fld.maxLength ?? (this.captureType === 'TEXTAREA' ? BIG_MAX_LENGTH : STD_MAX_LENGTH);\n    this.setAttr(fldAttr.maxLength, maxLength);\n    this.setAttr(fldAttr.intrinsicErrorMessage, this._formConfig.fieldTypeErrMsg[this.fieldType] ?? this._formConfig.fieldTypeErrMsg.DEFAULT);\n\n    this.setEditable(fld.editable ?? true);\n    this.setVisibleLabel(fld.visibleLabel ?? true);\n    this.setVisibility(fld.visible);\n    this.setFieldOptions(fld.fieldOptions);\n    this.setValue(fld.fieldValue ?? this.defaultValue ?? '');\n  }\n\n  get name() { return this.fieldCode; }\n  get editionFinish() { return this._editionFinish; }\n  get attributeChange() { return this._attributeChange; }\n\n  get editionPartial() { return this._editionPartial; }\n  get detailRequest() { return this._detailRequest; }\n  get info() { return this.fieldInfo; }\n\n  get validating() { return this._onValidation; }\n  set validating(isValidating: boolean) { this.setAttr(fldAttr.onValidation, isValidating); }\n\n  focus() { this.setAttr(fldAttr.focus, true); }\n\n  setIntrinsicErrorMessage(message: string) { this.setAttr(fldAttr.intrinsicErrorMessage, message); }\n  set intrinsicErrorMessage(message: string) { this.setIntrinsicErrorMessage(message); }\n\n  get fieldValue() { return this.getValue(); }\n\n  getRequired() { return this.required; }\n  setRequired(required: boolean) { this.required = required; }\n\n  get required(): boolean { return this.fieldRequired; }\n  set required(required: boolean) { this.setAttr(fldAttr.required, required ?? false); }\n  get maxLength() { return (this._maxLength > 0) ? this._maxLength.toString() : ''; }\n  set maxLength(requiredMaxLength: any) {\n    if (typeof requiredMaxLength === 'string') {\n      this.setAttr(fldAttr.maxLength, parseInt(requiredMaxLength, 10));\n    } else if (typeof requiredMaxLength === 'number') {\n      this.setAttr(fldAttr.maxLength, requiredMaxLength);\n    }\n  }\n  get value() { return this.getValue(); }\n  set value(newValue) { this.setValue(newValue); }\n\n  notifyEditionPartial() {\n    const intrinsicValidation = true;\n    this._editionPartial.next({ code: this.fieldCode, intrinsicValidation });\n  }\n\n  notifyEditionFinish() {\n    let intrinsicValidation = true;\n    const fieldDefaultFormat = this._formConfig.fieldTypesPatterns?.[this.fieldType] ?? null;\n    const fieldValue = this.getValue();\n    if (fieldValue && (fieldDefaultFormat || this.fieldFormat)) {\n      intrinsicValidation = (fieldDefaultFormat?.test(fieldValue) ?? true)\n        && (this.fieldFormat?.test(fieldValue) ?? true);\n      if (!intrinsicValidation) {\n        this.setError('99', this._intrinsicErrorMessage);\n      }\n    }\n    if (intrinsicValidation && fieldValue && this._minValue && fieldValue < this._minValue) {\n      intrinsicValidation = false;\n      this.setError('99', 'Campo con valor inferior al mínimo');\n    }\n    if (intrinsicValidation && fieldValue && this._maxValue && fieldValue > this._maxValue) {\n      intrinsicValidation = false;\n      this.setError('99', 'Campo con valor superior al máximo');\n    }\n    this._editionFinish.next({ code: this.fieldCode, intrinsicValidation });\n  }\n\n  setAttr(name: string, value: any) {\n    this[name] = value;\n    if (this._formConfig.monitoredFieldAttributes.includes(name)) {\n      this._attributeChange.next({ name, value });\n    }\n  }\n\n  notifyEditionDetailRequest(detail: any) {\n    const detailEvent: DetailEvent = {\n      code: this.fieldCode,\n      detail,\n    };\n    this._detailRequest.next(detailEvent);\n  }\n\n  setVisibleLabel(visibleLabel: boolean) { this.setAttr(fldAttr.visibleLabel, visibleLabel); }\n  showLabel() { this.setVisibleLabel(true); }\n  hideLabel() { this.setVisibleLabel(false); }\n\n  setChanged(hasChanged: boolean) { this.setAttr(fldAttr.hasChanged, hasChanged); }\n  changed() { this.setChanged(true); }\n\n  setLabel(label) { this.setAttr(fldAttr.title, label); }\n  clean() { this.setValue(this.defaultValue || ''); this.resetError(); }\n  get backend() { return this.validateOnServer; }\n\n  setEditable(editable: boolean = true) { (editable) ? this.enable() : this.disable(); }\n\n  hasError() { return this.errorCode !== NO_ERROR; }\n  resetError() { (this.errorCode !== NO_ERROR) && this.setError(NO_ERROR, null); }\n  setError(code, message, type = DEFAULT_ERROR_TYPE) {\n    this.setAttr(fldAttr.errorCode, code ?? NO_ERROR);\n    this.setAttr(fldAttr.errorType, (this.errorCode === NO_ERROR) ? '' : type);\n    this.setAttr(fldAttr.errorMessage, message ?? '');\n  }\n\n  getError() { return { type: this.errorType, code: this.errorCode, message: this.errorMessage }; }\n  get error() { return this.getError(); }\n  set error(errorObj) { this.setError(errorObj.code, errorObj.message, errorObj.type ?? DEFAULT_ERROR_TYPE) }\n\n  getErrorCode() { return this.getError().code; }\n  setErrorCode(code) { this.setError(code, this.errorMessage); }\n  getErrorMessage() { return this.getError().message; }\n  setErrorMessage(msg) { this.setError(this.errorCode, msg); }\n\n  get empty(): boolean { return this.isEmpty(); }\n\n  isEmpty(): boolean {\n    const fieldCurrentValue = this.getValue();\n    if (fieldCurrentValue === undefined || fieldCurrentValue === null) {\n      return true;\n    }\n    if (this.fieldType === this._formConfig.fieldTypes.array\n      && Array.isArray(fieldCurrentValue) && fieldCurrentValue.length === 0) {\n      return true;\n    };\n    if (this.fieldType === this._formConfig.fieldTypes.phone) {\n      if (!Array.isArray(fieldCurrentValue)) {\n        return true;\n      }\n      if (fieldCurrentValue.length !== 2 || !fieldCurrentValue[0] || !fieldCurrentValue[1]) {\n        return true;\n      }\n      return false;\n    };\n    return fieldCurrentValue === '';\n  }\n\n  getValue(): any {\n    if (this.fieldType === this._formConfig.fieldTypes.boolean\n      || this.fieldType === this._formConfig.fieldTypes.check) {\n      return yn(this._value);\n    }\n    return this._value;\n  }\n\n  getOptionText() {\n    return this.fieldOptions?.find(item => item.fieldOptionId === this._value)?.fieldOptionValue ?? null;\n  }\n\n  updateFromServer(fld) {\n    const fieldKeys = Object.keys(fld);\n    for (let index = 0; index < fieldKeys.length; index++) {\n      const attrName = fieldKeys[index];\n      const attrValue = fld[attrName];\n      (attrName === this._formConfig.apiFieldAttrs.visible) && this.setVisibility(attrValue);\n      (attrName === this._formConfig.apiFieldAttrs.labelVisible) && this.setVisibleLabel(fld.visibleLabel);\n      (attrName === this._formConfig.apiFieldAttrs.required) && this.setAttr(fldAttr.required, fld.required ?? false);\n      (attrName === this._formConfig.apiFieldAttrs.errorCode) && this.setAttr(fldAttr.errorCode, fld.errorCode);\n      (attrName === this._formConfig.apiFieldAttrs.errorMessage) && this.setAttr(fldAttr.errorMessage, fld.errorMessage);\n      (attrName === this._formConfig.apiFieldAttrs.tooltip) && this.setAttr(fldAttr.tooltipText, fld.tooltip);\n      (attrName === this._formConfig.apiFieldAttrs.info) && this.setAttr(fldAttr.info, fld.info);\n      (attrName === this._formConfig.apiFieldAttrs.editable) && this.setEditable(fld.editable);\n      (attrName === this._formConfig.apiFieldAttrs.title) && this.setLabel(fld.fieldTitle.toString());\n      (attrName === this._formConfig.apiFieldAttrs.value) && (this.setValue(fld.fieldValue) && this.setChanged(false));\n      (attrName === this._formConfig.apiFieldAttrs.options) && this.setFieldOptions(fld.fieldOptions);\n      (attrName === this._formConfig.apiFieldAttrs.captureType) && this.setAttr(fldAttr.captureType, fld.captureType || 'INPUT');\n      (attrName === this._formConfig.apiFieldAttrs.type) && this.setAttr(fldAttr.type, fld.fieldTypeCode);\n      (attrName === this._formConfig.apiFieldAttrs.maxLength) && this.setAttr(fldAttr.maxLength, fld.maxLength);\n    }\n  }\n\n  setMinValue(inputMinValue) {\n    let minValue = inputMinValue;\n    if (this.fieldType === this._formConfig.fieldTypes.date) {\n      minValue = new Date(minValue);\n    }\n    this.setAttr(fldAttr.minValue, minValue);\n  }\n\n  setMaxValue(inputMaxValue) {\n    let maxValue = inputMaxValue;\n    if (this.fieldType === this._formConfig.fieldTypes.date) {\n      maxValue = new Date(maxValue);\n    }\n    this.setAttr(fldAttr.maxValue, maxValue);\n  }\n\n  getFieldOptions(): FieldOption[] {\n    return this.fieldOptions.map(option => {\n      const optionCopy: FieldOption = { ...option };\n      return optionCopy;\n    });\n  }\n\n\n  setFieldOptions(newOptions) {\n    if ((!this._formConfig.captureTypesWithOptions.includes(this.captureType))\n      || typeof newOptions === UNDEFINED || !newOptions\n      || !Array.isArray(newOptions)) {\n      return;\n    }\n    let fieldOptions = newOptions.map(option => {\n      if (option.text !== undefined && option.text !== null\n        && option.value !== undefined && option.value !== null) {\n        return { fieldOptionValue: option.text, fieldOptionId: option.value };\n      }\n      return { ...option };\n    });\n    fieldOptions = (fieldOptions && Array.isArray(fieldOptions)\n      && fieldOptions.length > 0) ? fieldOptions : [];\n    this.setAttr(fldAttr.options, fieldOptions);\n    if (this._value) {\n      if (this.fieldType === this._formConfig.fieldTypes.array && Array.isArray(this._value)) {\n        const fieldValue = this._value?.filter(item =>\n          this.fieldOptions.find(opt => opt.fieldOptionId === item)\n        );\n        this.setAttr(fldAttr.value, fieldValue);\n      } else {\n        const valInOptions = this.fieldOptions\n          .find(item => item.fieldOptionId === this._value);\n        if (!valInOptions) {\n          this.setValue('');\n        }\n      }\n    }\n    if (this.fieldRequired && this.fieldOptions.length === 1) {\n      this.setValue(this.fieldOptions[0].fieldOptionId);\n    }\n  }\n\n  setValue(newValue, widgetUpdate = true) {\n    if (typeof newValue === UNDEFINED) {\n      return true;\n    }\n    if (newValue === null && this.required) {\n      return true;\n    }\n    let newFinalValue;\n    if (this.fieldType === this._formConfig.fieldTypes.boolean\n      || this.fieldType === this._formConfig.fieldTypes.check) {\n      newFinalValue = yn(newValue) ?? false;\n    } else if (this.fieldType === this._formConfig.fieldTypes.array\n      || this.fieldType === this._formConfig.fieldTypes.map) {\n      if (newValue === null || newValue === '') {\n        newFinalValue = [];\n      } else if (Array.isArray(newValue)) {\n        newFinalValue = newValue;\n      } else {\n        newFinalValue = newValue.toString().split(',');\n      }\n    } else {\n      newFinalValue = newValue;\n    }\n    if (this._value !== newFinalValue) {\n      this.setChanged(true);\n      if (widgetUpdate) {\n        this.setAttr(fldAttr.value, newFinalValue);\n      } else {\n        this._value = newFinalValue;\n      }\n    }\n    return true;\n  }\n}\n"]}