monkey-front-components 0.0.180 → 0.0.181

package/esm2020/lib/components/base/base-component.mjs

@@ -0,0 +1,297 @@
+import { Subject } from 'rxjs';
+import { Directive } from '@angular/core';
+import { takeUntil } from 'rxjs/operators';
+import { MonkeyUtils } from 'monkey-style-guide';
+import { MonkeyEcxCommonsService, ValidateUtils } from 'monkey-front-core';
+import * as i0 from "@angular/core";
+export class BaseComponent {
+    constructor() {
+        this.__paginationOptions = null;
+        this.__isMobile = this.isMobile();
+        this.__locales = ['pt-BR', 'es-CL'];
+        this.__unsubscribeAll = new Subject();
+    }
+    isMobile() {
+        const isMobileWidth = (window.screen.width <= 640) ||
+            (window.matchMedia &&
+                window.matchMedia('only screen and (max-width: 640px)').matches);
+        return (/Android|webOS|iPhone|iPad|iPod|BlackBerry|Mobile/i.test(navigator.userAgent)) || isMobileWidth;
+    }
+    handlePagination(create = true) {
+        const { __paginationOptions } = this;
+        if (__paginationOptions) {
+            const { mainElement, service } = __paginationOptions;
+            setTimeout(() => {
+                const element = document.getElementById(mainElement);
+                if (element) {
+                    element.scroll = null;
+                    element.onscroll = null;
+                    if (create) {
+                        this.paginationFunc = () => {
+                            const { scrollTop, scrollHeight, offsetHeight } = element;
+                            const contentHeight = scrollHeight - offsetHeight;
+                            if (contentHeight <= scrollTop) {
+                                service.__onDoPagination$.next(null);
+                            }
+                        };
+                        element.addEventListener('scroll', this.paginationFunc);
+                    }
+                    else {
+                        element.removeEventListener('scroll', this.paginationFunc);
+                    }
+                }
+            }, 200);
+        }
+    }
+    handleSupport(supportControls) {
+        const { service, show } = supportControls;
+        const method = show ? 'show' : 'hide';
+        service[method.toLowerCase()]();
+    }
+    handleTranslate(translateOptions) {
+        const { service } = translateOptions;
+        service.__oni18nDataChanged$
+            .pipe(takeUntil(this.__unsubscribeAll))
+            .subscribe(() => {
+            const data = service.__i18n;
+            if (data) {
+                this.__i18n = data;
+            }
+        });
+    }
+    getErrorFirstMessageTranslated(formControl = null) {
+        if (formControl?.hasError('required'))
+            return 'FIELD-REQUIRED';
+        if (formControl?.hasError('invalid'))
+            return 'FIELD-INVALID';
+        if (formControl?.hasError('email'))
+            return 'INVALID-EMAIL';
+        if (formControl?.hasError('minlength'))
+            return 'MIN-LENGTH';
+        if (formControl?.hasError('maxlength'))
+            return 'MAX-LENGTH';
+        if (formControl?.hasError('max'))
+            return 'MAX';
+        if (formControl?.hasError('min'))
+            return 'MIN';
+        if (formControl?.hasError('passwordsNotMatching'))
+            return 'MATCH-PASSWORD';
+        if (formControl?.hasError('invalidDate'))
+            return 'INVALID-DATE';
+        if (formControl?.hasError('invalidTrue'))
+            return 'INVALID-TRUE';
+        if (formControl?.hasError('invalidCpfCnpj'))
+            return 'INVALID-DOCUMENT';
+        if (formControl?.hasError('invalidZipCode'))
+            return 'INVALID-ZIPCODE';
+        if (formControl?.hasError('invalidCombo'))
+            return 'INVALID-COMBO';
+        if (formControl?.hasError('invalidUrl'))
+            return 'INVALID-URL';
+        if (formControl?.hasError('invalidUnlockRegister')) {
+            return 'INVALID-UNLOCK-REGISTER';
+        }
+        if (formControl?.hasError('dateStartMustBeLessThanAnd')) {
+            return 'DATE-START-MUST-BE-LESS-THAN-AND';
+        }
+        if (formControl?.hasError('dateEndMustBeGreaterThanStart')) {
+            return 'DATE-END-MUST-BE-GREATER-THAN-SART';
+        }
+        if (formControl?.hasError('phone'))
+            return 'INVALID-PHONE';
+        return 'FIELD-INVALID';
+    }
+    getErrorLastMessageNotTranslated(formControl = null) {
+        if (formControl?.hasError('minlength')) {
+            return `${formControl?.getError('minlength').requiredLength} caracteres.`;
+        }
+        if (formControl?.hasError('maxlength')) {
+            return `${formControl?.getError('maxlength').requiredLength} caracteres.`;
+        }
+        if (formControl?.hasError('max')) {
+            return `${formControl?.getError('max').max}`;
+        }
+        if (formControl?.hasError('min')) {
+            return `${formControl?.getError('min').min}`;
+        }
+        return '';
+    }
+    validateFormWithTranslate(f, index) {
+        const formErrors = f.value;
+        if (f.status === 'VALID')
+            return true;
+        if (!formErrors)
+            return true;
+        Object.entries(formErrors).forEach(([key, value]) => {
+            const control = f.get(key);
+            formErrors[key] = '';
+            if (control && !control.valid) {
+                const msg = {
+                    first: `ERRORS.${this.getErrorFirstMessageTranslated(f.get(key))}`,
+                    last: this.getErrorLastMessageNotTranslated(f.get(key))
+                };
+                formErrors[key] = msg;
+            }
+        });
+        if (MonkeyUtils.persistNullEmptyUndefined(index)) {
+            this.__monkeyecxFormErrors[index || 0] = formErrors;
+        }
+        else {
+            this.__monkeyecxFormErrors = formErrors;
+        }
+        return false;
+    }
+    copyToClipboard(val) {
+        const selBox = document.createElement('textarea');
+        selBox.style.position = 'fixed';
+        selBox.style.left = '0';
+        selBox.style.top = '0';
+        selBox.style.opacity = '0';
+        selBox.value = val;
+        document.body.appendChild(selBox);
+        selBox.focus();
+        selBox.select();
+        document.execCommand('copy');
+        document.body.removeChild(selBox);
+    }
+    validateForm(f, index, alias) {
+        const formErrors = f.value;
+        if (f.status === 'VALID')
+            return true;
+        if (!formErrors)
+            return true;
+        Object.entries(formErrors).forEach(([key, value]) => {
+            const control = f.get(key);
+            formErrors[key] = '';
+            if (control && !control.valid) {
+                const msg = {
+                    firstMessage: `ERRORS.${this.getErrorFirstMessageTranslated(f.get(key))}`,
+                    lastMessage: this.getErrorLastMessageNotTranslated(f.get(key))
+                };
+                formErrors[key] = msg;
+            }
+        });
+        if (MonkeyUtils.persistNullEmptyUndefined(index)) {
+            this.__monkeyecxFormErrors[index || 0] = formErrors;
+        }
+        else {
+            let obj;
+            if (alias) {
+                obj = {
+                    [alias]: {
+                        ...formErrors
+                    }
+                };
+            }
+            else {
+                obj = formErrors;
+            }
+            this.__monkeyecxFormErrors = {
+                ...this.__monkeyecxFormErrors,
+                ...obj
+            };
+        }
+        f.markAllAsTouched();
+        return false;
+    }
+    clearAllServiceData(clearData) {
+        const context = this;
+        Object.values(context).forEach((ctx) => {
+            if (ctx instanceof MonkeyEcxCommonsService) {
+                ctx.clear(clearData);
+            }
+        });
+    }
+    ngOnInit(args) {
+        if (args?.paginationOptions) {
+            this.__paginationOptions = args?.paginationOptions;
+            this.handlePagination();
+        }
+        if (args?.supportControls) {
+            this.handleSupport(args?.supportControls);
+        }
+        if (args?.translateOptions) {
+            this.handleTranslate(args?.translateOptions);
+        }
+    }
+    ngOnDestroy(clearData = true) {
+        this.__unsubscribeAll.next();
+        this.__unsubscribeAll.complete();
+        this.clearAllServiceData(clearData);
+        this.handlePagination(false);
+    }
+    handleErrorFromServices(error, f) {
+        this.__monkeyecxFormErrors = null;
+        if (error.type === 'Parameter_Error') {
+            Object.entries(f.value).forEach(([key, value]) => {
+                error.notifications.forEach((_) => {
+                    const field = _.split(':')[0];
+                    const description = _.split(':')[1];
+                    if (field === key) {
+                        const msg = {
+                            firstMessage: '',
+                            lastMessage: description
+                        };
+                        this.__monkeyecxFormErrors = {
+                            ...this.__monkeyecxFormErrors,
+                            [key]: msg
+                        };
+                        f.controls[key].setErrors({
+                            incorrect: true
+                        });
+                    }
+                });
+            });
+        }
+        f.markAllAsTouched();
+    }
+    goBack() {
+        window.history.back();
+    }
+    goScroll(id) {
+        const element = document.getElementById(id);
+        if (element)
+            element.scrollIntoView();
+    }
+    getEmbeddedData(data, field) {
+        const { _embedded } = data;
+        return _embedded ? _embedded[field] : null;
+    }
+    openWindow(url) {
+        window.open(`${url}`, '_blank');
+    }
+    fillI18n(data) {
+        this.__i18n = data;
+    }
+    getCountryPrefix(country) {
+        return {
+            br: 55,
+            cl: 56
+        }[country];
+    }
+    getCountryCurrencyChartFormat(country) {
+        return {
+            br: 'R$ #,###,##0.00',
+            cl: 'CLP #,###,##0'
+        }[country];
+    }
+    getCountryValidators(country) {
+        return {
+            br: {
+                governmentId: ValidateUtils.DocumentValidator
+            },
+            cl: {
+                governmentId: ValidateUtils.DocumentRutValidator
+            }
+        }[country];
+    }
+}
+BaseComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: BaseComponent, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+BaseComponent.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.1.1", type: BaseComponent, selector: "[baseComponent]", ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: BaseComponent, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[baseComponent]'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-component.js","sourceRoot":"","sources":["../../../../../../projects/monkey-front-components/src/lib/components/base/base-component.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable max-len */\nimport { AbstractControl, FormGroup } from '@angular/forms';\nimport { Subject } from 'rxjs';\nimport { OnDestroy, Directive } from '@angular/core';\nimport { takeUntil } from 'rxjs/operators';\nimport { MonkeyUtils } from 'monkey-style-guide';\nimport {\n  MonkeyEcxCommonsService,\n  MonkeyEcxErrorResponse,\n  MonkeyEcxPaginationOptions,\n  MonkeyEcxSupportOptions,\n  MonkeyEcxTranslateOptions,\n  ValidateUtils\n} from 'monkey-front-core';\n\n@Directive({\n  selector: '[baseComponent]'\n})\nexport abstract class BaseComponent implements OnDestroy {\n  __monkeyecxFormErrors: any | any[];\n\n  __unsubscribeAll: Subject<any>;\n\n  __paginationOptions: MonkeyEcxPaginationOptions | null = null;\n\n  __i18n: any;\n\n  __isMobile = this.isMobile();\n\n  __locales = ['pt-BR', 'es-CL'];\n\n  private paginationFunc: any;\n\n  protected constructor() {\n    this.__unsubscribeAll = new Subject();\n  }\n\n  private isMobile() {\n    const isMobileWidth = (window.screen.width <= 640) ||\n      (window.matchMedia &&\n        window.matchMedia('only screen and (max-width: 640px)').matches\n      );\n    return (/Android|webOS|iPhone|iPad|iPod|BlackBerry|Mobile/i.test(\n      navigator.userAgent\n    )) || isMobileWidth;\n  }\n\n  private handlePagination(create = true) {\n    const { __paginationOptions } = this;\n    if (__paginationOptions) {\n      const { mainElement, service } = __paginationOptions;\n      setTimeout(() => {\n        const element: any = document.getElementById(mainElement as string);\n        if (element) {\n          element.scroll = null;\n          element.onscroll = null;\n          if (create) {\n            this.paginationFunc = () => {\n              const { scrollTop, scrollHeight, offsetHeight } = element;\n              const contentHeight = scrollHeight - offsetHeight;\n              if (contentHeight <= scrollTop) {\n                service.__onDoPagination$.next(null);\n              }\n            };\n            element.addEventListener('scroll', this.paginationFunc);\n          } else {\n            element.removeEventListener('scroll', this.paginationFunc);\n          }\n        }\n      }, 200);\n    }\n  }\n\n  private handleSupport(supportControls: MonkeyEcxSupportOptions) {\n    const { service, show } = supportControls;\n    const method = show ? 'show' : 'hide';\n    service[method.toLowerCase()]();\n  }\n\n  private handleTranslate(translateOptions: MonkeyEcxTranslateOptions) {\n    const { service } = translateOptions;\n    service.__oni18nDataChanged$\n      .pipe(takeUntil(this.__unsubscribeAll))\n      .subscribe(() => {\n        const data = service.__i18n;\n        if (data) {\n          this.__i18n = data;\n        }\n      });\n  }\n\n  private getErrorFirstMessageTranslated(formControl: AbstractControl | null = null) {\n    if (formControl?.hasError('required')) return 'FIELD-REQUIRED';\n    if (formControl?.hasError('invalid')) return 'FIELD-INVALID';\n    if (formControl?.hasError('email')) return 'INVALID-EMAIL';\n    if (formControl?.hasError('minlength')) return 'MIN-LENGTH';\n    if (formControl?.hasError('maxlength')) return 'MAX-LENGTH';\n    if (formControl?.hasError('max')) return 'MAX';\n    if (formControl?.hasError('min')) return 'MIN';\n    if (formControl?.hasError('passwordsNotMatching')) return 'MATCH-PASSWORD';\n    if (formControl?.hasError('invalidDate')) return 'INVALID-DATE';\n    if (formControl?.hasError('invalidTrue')) return 'INVALID-TRUE';\n    if (formControl?.hasError('invalidCpfCnpj')) return 'INVALID-DOCUMENT';\n    if (formControl?.hasError('invalidZipCode')) return 'INVALID-ZIPCODE';\n    if (formControl?.hasError('invalidCombo')) return 'INVALID-COMBO';\n    if (formControl?.hasError('invalidUrl')) return 'INVALID-URL';\n    if (formControl?.hasError('invalidUnlockRegister')) { return 'INVALID-UNLOCK-REGISTER'; }\n    if (formControl?.hasError('dateStartMustBeLessThanAnd')) {\n      return 'DATE-START-MUST-BE-LESS-THAN-AND';\n    }\n    if (formControl?.hasError('dateEndMustBeGreaterThanStart')) {\n      return 'DATE-END-MUST-BE-GREATER-THAN-SART';\n    }\n    if (formControl?.hasError('phone')) return 'INVALID-PHONE';\n\n    return 'FIELD-INVALID';\n  }\n\n  private getErrorLastMessageNotTranslated(formControl: AbstractControl | null = null) {\n    if (formControl?.hasError('minlength')) {\n      return `${formControl?.getError('minlength').requiredLength} caracteres.`;\n    }\n    if (formControl?.hasError('maxlength')) {\n      return `${formControl?.getError('maxlength').requiredLength} caracteres.`;\n    }\n    if (formControl?.hasError('max')) { return `${formControl?.getError('max').max}`; }\n    if (formControl?.hasError('min')) { return `${formControl?.getError('min').min}`; }\n\n    return '';\n  }\n\n  public validateFormWithTranslate(f: FormGroup, index?: number): boolean {\n    const formErrors: any = f.value;\n\n    if (f.status === 'VALID') return true;\n\n    if (!formErrors) return true;\n    Object.entries(formErrors).forEach(([key, value]) => {\n      const control = f.get(key);\n      formErrors[key] = '';\n      if (control && !control.valid) {\n        const msg = {\n          first: `ERRORS.${this.getErrorFirstMessageTranslated(f.get(key))}`,\n          last: this.getErrorLastMessageNotTranslated(f.get(key))\n        };\n        formErrors[key] = msg;\n      }\n    });\n\n    if (MonkeyUtils.persistNullEmptyUndefined(index)) { this.__monkeyecxFormErrors[index || 0] = formErrors; } else {\n      this.__monkeyecxFormErrors = formErrors;\n    }\n\n    return false;\n  }\n\n  public copyToClipboard(val: string) {\n    const selBox = document.createElement('textarea');\n    selBox.style.position = 'fixed';\n    selBox.style.left = '0';\n    selBox.style.top = '0';\n    selBox.style.opacity = '0';\n    selBox.value = val;\n    document.body.appendChild(selBox);\n    selBox.focus();\n    selBox.select();\n    document.execCommand('copy');\n    document.body.removeChild(selBox);\n  }\n\n  public validateForm(f: FormGroup, index?: number, alias?: string): boolean {\n    const formErrors: any = f.value;\n    if (f.status === 'VALID') return true;\n\n    if (!formErrors) return true;\n    Object.entries(formErrors).forEach(([key, value]) => {\n      const control = f.get(key);\n      formErrors[key] = '';\n      if (control && !control.valid) {\n        const msg = {\n          firstMessage: `ERRORS.${this.getErrorFirstMessageTranslated(\n            f.get(key)\n          )}`,\n          lastMessage: this.getErrorLastMessageNotTranslated(f.get(key))\n        };\n        formErrors[key] = msg;\n      }\n    });\n\n    if (MonkeyUtils.persistNullEmptyUndefined(index)) {\n      this.__monkeyecxFormErrors[index || 0] = formErrors;\n    } else {\n      let obj: any;\n\n      if (alias) {\n        obj = {\n          [alias]: {\n            ...formErrors\n          }\n        };\n      } else {\n        obj = formErrors;\n      }\n\n      this.__monkeyecxFormErrors = {\n        ...this.__monkeyecxFormErrors,\n        ...obj\n      };\n    }\n    f.markAllAsTouched();\n    return false;\n  }\n\n  public clearAllServiceData(clearData: boolean) {\n    const context = this;\n    Object.values(context).forEach((ctx: any) => {\n      if (ctx instanceof MonkeyEcxCommonsService) {\n        ctx.clear(clearData);\n      }\n    });\n  }\n\n  public ngOnInit(args: {\n    paginationOptions?: MonkeyEcxPaginationOptions;\n    supportControls?: MonkeyEcxSupportOptions;\n    translateOptions?: MonkeyEcxTranslateOptions;\n  }) {\n    if (args?.paginationOptions) {\n      this.__paginationOptions = args?.paginationOptions;\n      this.handlePagination();\n    }\n    if (args?.supportControls) {\n      this.handleSupport(args?.supportControls);\n    }\n    if (args?.translateOptions) {\n      this.handleTranslate(args?.translateOptions);\n    }\n  }\n\n  public ngOnDestroy(clearData: boolean = true) {\n    this.__unsubscribeAll.next();\n    this.__unsubscribeAll.complete();\n    this.clearAllServiceData(clearData);\n    this.handlePagination(false);\n  }\n\n  public handleErrorFromServices(error: MonkeyEcxErrorResponse, f: FormGroup) {\n    this.__monkeyecxFormErrors = null;\n    if (error.type === 'Parameter_Error') {\n      Object.entries(f.value).forEach(([key, value]) => {\n        error.notifications.forEach((_: any) => {\n          const field = _.split(':')[0];\n          const description = _.split(':')[1];\n          if (field === key) {\n            const msg = {\n              firstMessage: '',\n              lastMessage: description\n            };\n            this.__monkeyecxFormErrors = {\n              ...this.__monkeyecxFormErrors,\n              [key]: msg\n            };\n            f.controls[key].setErrors({\n              incorrect: true\n            });\n          }\n        });\n      });\n    }\n\n    f.markAllAsTouched();\n  }\n\n  public goBack() {\n    window.history.back();\n  }\n\n  public goScroll(id: string) {\n    const element = document.getElementById(id);\n    if (element) element.scrollIntoView();\n  }\n\n  public getEmbeddedData(data: any, field: string): any[] | any {\n    const { _embedded } = data;\n    return _embedded ? _embedded[field] : null;\n  }\n\n  public openWindow(url: string) {\n    window.open(`${url}`, '_blank');\n  }\n\n  public fillI18n(data: any) {\n    this.__i18n = data;\n  }\n\n  public getCountryPrefix(country: string) {\n    return {\n      br: 55,\n      cl: 56\n    }[country];\n  }\n\n  public getCountryCurrencyChartFormat(country: string) {\n    return {\n      br: 'R$ #,###,##0.00',\n      cl: 'CLP #,###,##0'\n    }[country];\n  }\n\n  public getCountryValidators(country: string) {\n    return {\n      br: {\n        governmentId: ValidateUtils.DocumentValidator\n      },\n      cl: {\n        governmentId: ValidateUtils.DocumentRutValidator\n      }\n    }[country];\n  }\n}\n"]}

package/esm2020/lib/components/base/base-dynamic-array.mjs

@@ -0,0 +1,221 @@
+import { Directive, EventEmitter, Input, Output } from '@angular/core';
+import { Validators } from '@angular/forms';
+import { MonkeyUtils } from 'monkey-style-guide';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { BaseComponent } from './base-component';
+import { validators } from './base-validators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+export class BaseDynamicArray extends BaseComponent {
+    constructor(fb) {
+        super();
+        this.fb = fb;
+        this.onHandleSubmit = new EventEmitter();
+        this.onHandleUpdateForm = new EventEmitter();
+        this.onHandleSubmitFormReady = new EventEmitter();
+        this.fields = [];
+        this.qtd = 1;
+        this.disabled = false;
+        this._form = null;
+        // eslint-disable-next-line object-curly-newline
+        this._plusValidations = [];
+        this.changesUnsubscribe = new Subject();
+        this.formBase = () => {
+            // return this.fb.group(this.createControl());
+            return this.createControl();
+        };
+    }
+    handleInternalPlusValidation(mainField, data) {
+        const { operator, field, value } = mainField;
+        const validators = {
+            e: (val1, val2) => { return val1 === val2; },
+            lt: (val1, val2) => { return val1 < val2; },
+            gt: (val1, val2) => { return val1 > val2; }
+        };
+        return validators[operator](data?.[field] || data, value);
+    }
+    makeInternalPlusValidation(data, sourceField, settings, rowIndex) {
+        const changeFields = (show) => {
+            const saved = [...this.fields];
+            saved.map((val) => {
+                const valSaved = {
+                    ...val
+                };
+                if (val.name === sourceField) {
+                    this._plusValidations[rowIndex] = {
+                        [sourceField]: {
+                            ...valSaved,
+                            alwaysShow: show
+                        }
+                    };
+                    this.createOneControl(val.name, this.formValues?.controls[rowIndex], show);
+                }
+                else {
+                    this._plusValidations[rowIndex] = {
+                        ...valSaved
+                    };
+                }
+                return null;
+            });
+        };
+        const validated = this.handleInternalPlusValidation(settings, data);
+        changeFields(validated);
+    }
+    createOneControl(fieldName, ctrl, create = true) {
+        const { fields } = this;
+        if (!fields)
+            return;
+        fields.forEach((field) => {
+            const { fieldType, validations, name, disabled } = field;
+            if (name !== fieldName)
+                return;
+            let { value } = field;
+            if (fieldType === 'button')
+                return;
+            if (fieldType === 'radiobutton' || fieldType === 'checkbox' || fieldType === 'select') {
+                value = '';
+            }
+            if (create) {
+                const control = this.fb.control(value, this.bindValidations(validations || []));
+                if (disabled || this.disabled)
+                    control.disable();
+                ctrl.addControl(name, control);
+            }
+            else {
+                ctrl.removeControl(name);
+            }
+        });
+    }
+    createControl(data) {
+        const { fields } = this;
+        if (!fields)
+            return null;
+        // eslint-disable-next-line object-curly-newline
+        const group = this.fb.group({});
+        fields.forEach((field) => {
+            const { fieldType, validations, name, disabled, alwaysShow } = field;
+            let { value } = field;
+            if (field.alwaysShowPlusValidation) {
+                if (!this.handleInternalPlusValidation(field.alwaysShowPlusValidation, data))
+                    return;
+            }
+            else if (!alwaysShow)
+                return;
+            if (fieldType === 'button')
+                return;
+            if (fieldType === 'radiobutton' || fieldType === 'checkbox' || fieldType === 'select') {
+                value = '';
+            }
+            const control = this.fb.control(value, this.bindValidations(validations || []));
+            if (disabled || this.disabled)
+                control.disable();
+            group.addControl(name, control);
+        });
+        return group;
+    }
+    bindValidations(validations) {
+        if (validations.length > 0) {
+            const validList = [];
+            validations.forEach((valid) => {
+                const validated = valid.param
+                    ? validators[valid.name](valid.param)
+                    : validators[valid.name];
+                validList.push(validated);
+            });
+            return Validators.compose(validList);
+        }
+        return null;
+    }
+    buildForm() {
+        const form = this.fb.group({
+            fields: this.fb.array([])
+        });
+        form?.controls.fields?.valueChanges.subscribe((_) => {
+            this.watchForChanges();
+        });
+        return form;
+    }
+    watchForChanges() {
+        const { fields, changesUnsubscribe } = this;
+        changesUnsubscribe.next();
+        this.formValues?.controls?.map((control, index) => {
+            fields.forEach((fieldConfig) => {
+                const { name, alwaysShowPlusValidation } = fieldConfig;
+                if (!alwaysShowPlusValidation)
+                    return;
+                const { field } = alwaysShowPlusValidation;
+                if (field) {
+                    control.controls[field]?.valueChanges.pipe(takeUntil(changesUnsubscribe)).subscribe((_) => {
+                        this.makeInternalPlusValidation(_, name, alwaysShowPlusValidation, index);
+                    });
+                }
+            });
+            return null;
+        });
+    }
+    get formValues() {
+        return this._form ? this._form.get('fields') : null;
+    }
+    fillValues() {
+        const { data, qtd } = this;
+        if ((!this._form) && qtd)
+            return;
+        if (qtd > 0) {
+            Array(qtd)
+                .fill(null)
+                .map((_, index) => {
+                let form = this.createControl();
+                if (data && data[index]) {
+                    form = this.createControl(data[index]);
+                    const handledData = data[index];
+                    Object.entries(handledData).forEach(([key, value]) => {
+                        if (MonkeyUtils.persistNullEmptyUndefined(value) && form?.controls[key]) {
+                            form?.controls[key].setValue(value);
+                        }
+                    });
+                }
+                this.formValues?.push(form);
+                return null;
+            });
+        }
+    }
+    ngOnInit() {
+        this._form = this.buildForm();
+        this.fillValues();
+        this.onHandleUpdateForm.subscribe(() => {
+            this.fillValues();
+        });
+    }
+    ngOnChanges() {
+        if (!this._form) {
+            this._form = this.buildForm();
+        }
+        this.fillValues();
+    }
+}
+BaseDynamicArray.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: BaseDynamicArray, deps: [{ token: i1.FormBuilder }], target: i0.ɵɵFactoryTarget.Directive });
+BaseDynamicArray.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.1.1", type: BaseDynamicArray, selector: "[baseDynamicArray]", inputs: { onHandleSubmit: "onHandleSubmit", onHandleUpdateForm: "onHandleUpdateForm", self: "self", fields: "fields", data: "data", qtd: "qtd", disabled: "disabled" }, outputs: { onHandleSubmitFormReady: "onHandleSubmitFormReady" }, usesInheritance: true, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: BaseDynamicArray, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[baseDynamicArray]'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.FormBuilder }]; }, propDecorators: { onHandleSubmit: [{
+                type: Input
+            }], onHandleUpdateForm: [{
+                type: Input
+            }], onHandleSubmitFormReady: [{
+                type: Output
+            }], self: [{
+                type: Input
+            }], fields: [{
+                type: Input
+            }], data: [{
+                type: Input
+            }], qtd: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-dynamic-array.js","sourceRoot":"","sources":["../../../../../../projects/monkey-front-components/src/lib/components/base/base-dynamic-array.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, EventEmitter, Input, OnInit, OnChanges, Output } from '@angular/core';\nimport { FormArray, FormBuilder, FormGroup, Validators } from '@angular/forms';\nimport { MonkeyUtils } from 'monkey-style-guide';\nimport { Subject } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\nimport { MECXFieldConfig, MECXFieldConfigValidator } from '../../interfaces';\nimport { BaseComponent } from './base-component';\nimport { validators } from './base-validators';\n\n@Directive({\n  selector: '[baseDynamicArray]'\n})\nexport abstract class BaseDynamicArray extends BaseComponent implements OnInit, OnChanges {\n  @Input() onHandleSubmit = new EventEmitter<any>();\n\n  @Input() onHandleUpdateForm = new EventEmitter<any>();\n\n  @Output() onHandleSubmitFormReady: EventEmitter<any> = new EventEmitter<any>();\n\n  @Input() self: any;\n\n  @Input() fields: MECXFieldConfig[] = [];\n\n  @Input() data: any;\n\n  @Input() qtd: number = 1;\n\n  @Input() disabled: boolean = false;\n\n  _form: FormGroup | null = null;\n\n  // eslint-disable-next-line object-curly-newline\n  _plusValidations: any[] = [];\n\n  private changesUnsubscribe = new Subject();\n\n  constructor(private fb: FormBuilder) {\n    super();\n  }\n\n  private handleInternalPlusValidation(\n    mainField: any,\n    data: any\n  ) {\n    const { operator, field, value } = mainField;\n    const validators: any = {\n      e: (val1: any, val2: string) => { return val1 === val2; },\n      lt: (val1: any, val2: string) => { return val1 < val2; },\n      gt: (val1: any, val2: string) => { return val1 > val2; }\n    };\n\n    return validators[operator](data?.[field] || data, value);\n  }\n\n  private makeInternalPlusValidation(\n    data: any,\n    sourceField: string,\n    settings: any,\n    rowIndex: number\n  ) {\n    const changeFields = (show: boolean) => {\n      const saved = [...this.fields];\n\n      saved.map((val) => {\n        const valSaved = {\n          ...val\n        };\n        if (val.name === sourceField) {\n          this._plusValidations[rowIndex] = {\n            [sourceField]: {\n              ...valSaved,\n              alwaysShow: show\n            }\n          };\n          this.createOneControl(val.name, this.formValues?.controls[rowIndex], show);\n        } else {\n          this._plusValidations[rowIndex] = {\n            ...valSaved\n          };\n        }\n        return null;\n      });\n    };\n\n    const validated = this.handleInternalPlusValidation(settings, data);\n    changeFields(validated);\n  }\n\n  private createOneControl(fieldName: string, ctrl: any, create = true) {\n    const { fields } = this;\n    if (!fields) return;\n\n    fields.forEach((field: MECXFieldConfig) => {\n      const { fieldType, validations, name, disabled } = field;\n      if (name !== fieldName) return;\n      let { value } = field;\n      if (fieldType === 'button') return;\n      if (fieldType === 'radiobutton' || fieldType === 'checkbox' || fieldType === 'select') {\n        value = '';\n      }\n      if (create) {\n        const control = this.fb.control(value, this.bindValidations(validations || []));\n        if (disabled || this.disabled) control.disable();\n        ctrl.addControl(name, control);\n      } else {\n        ctrl.removeControl(name);\n      }\n    });\n  }\n\n  private createControl(data?: any) {\n    const { fields } = this;\n    if (!fields) return null;\n    // eslint-disable-next-line object-curly-newline\n    const group = this.fb.group({});\n    fields.forEach((field: MECXFieldConfig) => {\n      const { fieldType, validations, name, disabled, alwaysShow } = field;\n      let { value } = field;\n      if (field.alwaysShowPlusValidation) {\n        if (!this.handleInternalPlusValidation(field.alwaysShowPlusValidation, data)) return;\n      } else if (!alwaysShow) return;\n      if (fieldType === 'button') return;\n      if (fieldType === 'radiobutton' || fieldType === 'checkbox' || fieldType === 'select') {\n        value = '';\n      }\n      const control = this.fb.control(value, this.bindValidations(validations || []));\n      if (disabled || this.disabled) control.disable();\n      group.addControl(name as string, control);\n    });\n\n    return group;\n  }\n\n  private bindValidations(validations: MECXFieldConfigValidator[]) {\n    if (validations.length > 0) {\n      const validList: any[] = [];\n      validations.forEach((valid: MECXFieldConfigValidator) => {\n        const validated = valid.param\n          ? validators[valid.name](valid.param)\n          : validators[valid.name];\n        validList.push(validated);\n      });\n      return Validators.compose(validList);\n    }\n    return null;\n  }\n\n  private buildForm(): FormGroup {\n    const form = this.fb.group({\n      fields: this.fb.array([])\n    });\n\n    form?.controls.fields?.valueChanges.subscribe((_) => {\n      this.watchForChanges();\n    });\n\n    return form;\n  }\n\n  private watchForChanges() {\n    const { fields, changesUnsubscribe } = this;\n    changesUnsubscribe.next();\n\n    this.formValues?.controls?.map((control: any, index: number) => {\n      fields.forEach((fieldConfig: MECXFieldConfig) => {\n        const { name, alwaysShowPlusValidation } = fieldConfig;\n        if (!alwaysShowPlusValidation) return;\n        const { field } = alwaysShowPlusValidation;\n        if (field) {\n          control.controls[field]?.valueChanges.pipe(\n            takeUntil(changesUnsubscribe)).subscribe((_: any) => {\n            this.makeInternalPlusValidation(\n              _,\n              name as string,\n              alwaysShowPlusValidation,\n              index\n            );\n          });\n        }\n      });\n      return null;\n    });\n  }\n\n  public formBase = () => {\n    // return this.fb.group(this.createControl());\n    return this.createControl();\n  };\n\n  public get formValues() {\n    return this._form ? (this._form.get('fields') as FormArray) : null;\n  }\n\n  public fillValues() {\n    const { data, qtd } = this;\n    if ((!this._form) && qtd) return;\n    if (qtd > 0) {\n      Array<any>(qtd)\n        .fill(null)\n        .map((_, index) => {\n          let form = this.createControl();\n          if (data && data[index]) {\n            form = this.createControl(data[index]);\n            const handledData = data[index];\n            Object.entries(handledData).forEach(([key, value]) => {\n              if (MonkeyUtils.persistNullEmptyUndefined(value) && form?.controls[key]) {\n                form?.controls[key].setValue(value);\n              }\n            });\n          }\n          this.formValues?.push(form as any);\n\n          return null;\n        });\n    }\n  }\n\n  ngOnInit() {\n    this._form = this.buildForm();\n    this.fillValues();\n\n    this.onHandleUpdateForm.subscribe(() => {\n      this.fillValues();\n    });\n  }\n\n  ngOnChanges() {\n    if (!this._form) {\n      this._form = this.buildForm();\n    }\n    this.fillValues();\n  }\n}\n"]}