monkey-front-components 0.0.384 → 0.0.385

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

@@ -0,0 +1,99 @@
+import { Directive, EventEmitter, Input, Output } from '@angular/core';
+import { Validators } from '@angular/forms';
+import { MonkeyUtils } from 'monkey-style-guide';
+import { BaseComponent } from './base-component';
+import { validators } from './base-validators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+export class BaseDynamic extends BaseComponent {
+    constructor(fb) {
+        super();
+        this.fb = fb;
+        this.onHandleSubmit = new EventEmitter();
+        this.onHandleUpdateForm = new EventEmitter();
+        this.onHandleSubmitFormReady = new EventEmitter();
+        this.fields = [];
+        this.disabled = false;
+        this._form = null;
+    }
+    createControl() {
+        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 } = field;
+            let { value } = field;
+            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;
+    }
+    fillValues() {
+        const { data } = this;
+        if (!data || !this._form)
+            return;
+        Object.entries(data).forEach(([key, value]) => {
+            if (MonkeyUtils.persistNullEmptyUndefined(value) && this._form?.controls[key]) {
+                this._form?.controls[key]?.setValue(value);
+            }
+        });
+    }
+    ngOnInit() {
+        this._form = this.createControl();
+        this.fillValues();
+        this.onHandleUpdateForm.subscribe(() => {
+            this.fillValues();
+        });
+    }
+    ngOnChanges() {
+        if (!this._form) {
+            this._form = this.createControl();
+        }
+        this.fillValues();
+    }
+}
+BaseDynamic.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: BaseDynamic, deps: [{ token: i1.FormBuilder }], target: i0.ɵɵFactoryTarget.Directive });
+BaseDynamic.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.1.1", type: BaseDynamic, selector: "[baseDynamic]", inputs: { onHandleSubmit: "onHandleSubmit", onHandleUpdateForm: "onHandleUpdateForm", self: "self", fields: "fields", data: "data", disabled: "disabled" }, outputs: { onHandleSubmitFormReady: "onHandleSubmitFormReady" }, usesInheritance: true, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: BaseDynamic, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[baseDynamic]'
+                }]
+        }], 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
+            }], disabled: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,55 @@
+import { isPlatformBrowser } from '@angular/common';
+import { Directive } from '@angular/core';
+import { NavigationEnd, NavigationStart } from '@angular/router';
+import { BaseComponent } from './base-component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+export class BaseScrollComponent extends BaseComponent {
+    constructor(_pId, _rt) {
+        super();
+        this._pId = _pId;
+        this._rt = _rt;
+        this.routeScrollPositions = {};
+    }
+    saveScroll(url) {
+        const element = document.getElementById('container-3');
+        this.routeScrollPositions[url] = element.scrollTop;
+    }
+    restoreScroll(url) {
+        const savedScroll = this.routeScrollPositions[url];
+        const element = document.getElementById('container-3');
+        if (!savedScroll) {
+            return;
+        }
+        element.scrollTop = savedScroll;
+    }
+    addScrollTopListeners() {
+        if ('scrollRestoration' in history) {
+            history.scrollRestoration = 'manual';
+        }
+        this._rt.events.subscribe(event => {
+            if (event instanceof NavigationStart) {
+                this.saveScroll(this._rt.url);
+            }
+            else if (event instanceof NavigationEnd) {
+                setTimeout(() => {
+                    this.restoreScroll(event.url);
+                });
+            }
+        });
+    }
+    ngOnInit() {
+        if (isPlatformBrowser(this._pId)) {
+            this.addScrollTopListeners();
+        }
+    }
+}
+BaseScrollComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: BaseScrollComponent, deps: [{ token: Object }, { token: i1.Router }], target: i0.ɵɵFactoryTarget.Directive });
+BaseScrollComponent.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.1.1", type: BaseScrollComponent, selector: "[baseScrollComponent]", usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: BaseScrollComponent, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[baseScrollComponent]'
+                }]
+        }], ctorParameters: function () { return [{ type: Object }, { type: i1.Router }]; } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,19 @@
+import { Validators as Validators_ } from '@angular/forms';
+import { Validators } from 'monkey-front-core';
+export const validators = {
+    required: Validators_.required,
+    email: Validators.email,
+    governmentId: Validators.documentBR,
+    governmentIdRut: Validators.documentCL,
+    documentBR: Validators.documentBR,
+    documentCL: Validators.documentCL,
+    date: Validators.date,
+    zipCode: Validators.zipCode,
+    minLength: (param) => {
+        return Validators_.minLength(param);
+    },
+    maxLength: (param) => {
+        return Validators_.maxLength(param);
+    }
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS12YWxpZGF0b3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbW9ua2V5LWZyb250LWNvbXBvbmVudHMvc3JjL2xpYi9jb21wb25lbnRzL2Jhc2UvYmFzZS12YWxpZGF0b3JzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLElBQUksV0FBVyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDM0QsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBRS9DLE1BQU0sQ0FBQyxNQUFNLFVBQVUsR0FBUTtJQUM3QixRQUFRLEVBQUUsV0FBVyxDQUFDLFFBQVE7SUFDOUIsS0FBSyxFQUFFLFVBQVUsQ0FBQyxLQUFLO0lBQ3ZCLFlBQVksRUFBRSxVQUFVLENBQUMsVUFBVTtJQUNuQyxlQUFlLEVBQUUsVUFBVSxDQUFDLFVBQVU7SUFDdEMsVUFBVSxFQUFFLFVBQVUsQ0FBQyxVQUFVO0lBQ2pDLFVBQVUsRUFBRSxVQUFVLENBQUMsVUFBVTtJQUNqQyxJQUFJLEVBQUUsVUFBVSxDQUFDLElBQUk7SUFDckIsT0FBTyxFQUFFLFVBQVUsQ0FBQyxPQUFPO0lBQzNCLFNBQVMsRUFBRSxDQUFDLEtBQWEsRUFBRSxFQUFFO1FBQzNCLE9BQU8sV0FBVyxDQUFDLFNBQVMsQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUN0QyxDQUFDO0lBQ0QsU0FBUyxFQUFFLENBQUMsS0FBYSxFQUFFLEVBQUU7UUFDM0IsT0FBTyxXQUFXLENBQUMsU0FBUyxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQ3RDLENBQUM7Q0FDRixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVmFsaWRhdG9ycyBhcyBWYWxpZGF0b3JzXyB9IGZyb20gJ0Bhbmd1bGFyL2Zvcm1zJztcbmltcG9ydCB7IFZhbGlkYXRvcnMgfSBmcm9tICdtb25rZXktZnJvbnQtY29yZSc7XG5cbmV4cG9ydCBjb25zdCB2YWxpZGF0b3JzOiBhbnkgPSB7XG4gIHJlcXVpcmVkOiBWYWxpZGF0b3JzXy5yZXF1aXJlZCxcbiAgZW1haWw6IFZhbGlkYXRvcnMuZW1haWwsXG4gIGdvdmVybm1lbnRJZDogVmFsaWRhdG9ycy5kb2N1bWVudEJSLFxuICBnb3Zlcm5tZW50SWRSdXQ6IFZhbGlkYXRvcnMuZG9jdW1lbnRDTCxcbiAgZG9jdW1lbnRCUjogVmFsaWRhdG9ycy5kb2N1bWVudEJSLFxuICBkb2N1bWVudENMOiBWYWxpZGF0b3JzLmRvY3VtZW50Q0wsXG4gIGRhdGU6IFZhbGlkYXRvcnMuZGF0ZSxcbiAgemlwQ29kZTogVmFsaWRhdG9ycy56aXBDb2RlLFxuICBtaW5MZW5ndGg6IChwYXJhbTogbnVtYmVyKSA9PiB7XG4gICAgcmV0dXJuIFZhbGlkYXRvcnNfLm1pbkxlbmd0aChwYXJhbSk7XG4gIH0sXG4gIG1heExlbmd0aDogKHBhcmFtOiBudW1iZXIpID0+IHtcbiAgICByZXR1cm4gVmFsaWRhdG9yc18ubWF4TGVuZ3RoKHBhcmFtKTtcbiAgfVxufTtcbiJdfQ==

package/esm2020/lib/components/base/index.mjs

@@ -0,0 +1,6 @@
+export * from './base-component';
+export * from './base-dynamic-array';
+export * from './base-dynamic';
+export * from './base-scroll-component';
+export * from './base-validators';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tb25rZXktZnJvbnQtY29tcG9uZW50cy9zcmMvbGliL2NvbXBvbmVudHMvYmFzZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsbUJBQW1CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2Jhc2UtY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vYmFzZS1keW5hbWljLWFycmF5JztcbmV4cG9ydCAqIGZyb20gJy4vYmFzZS1keW5hbWljJztcbmV4cG9ydCAqIGZyb20gJy4vYmFzZS1zY3JvbGwtY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vYmFzZS12YWxpZGF0b3JzJztcbiJdfQ==

package/esm2020/lib/components/dynamic/button/button.component.mjs

@@ -0,0 +1,52 @@
+import { Component, HostBinding, Input, ViewEncapsulation } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "monkey-style-guide";
+import * as i2 from "@ngx-translate/core";
+export class MECXDynamicButtonComponent {
+    constructor(cdr) {
+        this.cdr = cdr;
+        this._field = null;
+        this._form = null;
+        // eslint-disable-next-line object-curly-newline
+        this._formErrors = {};
+        // not to do
+    }
+    get className() {
+        return this._field?.style?.class;
+    }
+    ngOnChanges() {
+        this.cdr.detectChanges();
+    }
+    onClick() {
+        const { _form, _field, self } = this;
+        if (_form?.disabled || !_field)
+            return;
+        const { name, value } = _field;
+        const func = _field?.functions?.onClick;
+        if (func) {
+            self[func]({
+                name,
+                value,
+                form: _form
+            });
+        }
+    }
+}
+MECXDynamicButtonComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MECXDynamicButtonComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+MECXDynamicButtonComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.1.1", type: MECXDynamicButtonComponent, selector: "mecx-dynamic-button", inputs: { _field: "_field", _form: "_form", _formErrors: "_formErrors", self: "self" }, host: { properties: { "class": "this.className" } }, usesOnChanges: true, ngImport: i0, template: "<monkey-button [icon]=\"_field?.icon\" [type]=\"_field?.type\" [color]=\"_field?.color\"\n  (click)=\"onClick()\">\n  {{ _field?.label | translate }}\n</monkey-button>", styles: ["mecx-dynamic-button monkey-button button{height:40px}\n"], components: [{ type: i1.MonkeyButtonComponent, selector: "monkey-button", inputs: ["label", "icon", "iconPosition", "type", "color", "disabled", "size"] }], pipes: { "translate": i2.TranslatePipe }, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MECXDynamicButtonComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'mecx-dynamic-button', encapsulation: ViewEncapsulation.None, template: "<monkey-button [icon]=\"_field?.icon\" [type]=\"_field?.type\" [color]=\"_field?.color\"\n  (click)=\"onClick()\">\n  {{ _field?.label | translate }}\n</monkey-button>", styles: ["mecx-dynamic-button monkey-button button{height:40px}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }]; }, propDecorators: { _field: [{
+                type: Input
+            }], _form: [{
+                type: Input
+            }], _formErrors: [{
+                type: Input
+            }], self: [{
+                type: Input
+            }], className: [{
+                type: HostBinding,
+                args: ['class']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/dynamic/button/index.mjs

@@ -0,0 +1,2 @@
+export * from './button.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tb25rZXktZnJvbnQtY29tcG9uZW50cy9zcmMvbGliL2NvbXBvbmVudHMvZHluYW1pYy9idXR0b24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxvQkFBb0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYnV0dG9uLmNvbXBvbmVudCc7XG4iXX0=

package/esm2020/lib/components/dynamic/dynamic-directive.mjs

@@ -0,0 +1,95 @@
+import { Directive, Input } from '@angular/core';
+import { MECXDynamicButtonComponent } from './button';
+import { MECXDynamicFileUploadComponent } from './file-upload';
+import { MECXDynamicInputComponent } from './input';
+import { MECXDynamicInputPhoneComponent } from './input-phone';
+import { MECXDynamicRadioComponent } from './radio';
+import { MECXDynamicSelectComponent } from './select';
+import { MECXDynamicSelectSearchComponent } from './select-search';
+import * as i0 from "@angular/core";
+const componentMapper = {
+    input: MECXDynamicInputComponent,
+    'input-phone': MECXDynamicInputPhoneComponent,
+    radiobutton: MECXDynamicRadioComponent,
+    select: MECXDynamicSelectComponent,
+    'select-search': MECXDynamicSelectSearchComponent,
+    'file-upload': MECXDynamicFileUploadComponent,
+    button: MECXDynamicButtonComponent
+};
+export class MECXDynamicDirective {
+    constructor(resolver, container, cdr) {
+        this.resolver = resolver;
+        this.container = container;
+        this.cdr = cdr;
+        this.field = null;
+        this.form = null;
+        // not to do
+    }
+    handleInternalPlusValidation() {
+        if (!this.field?.alwaysShowPlusValidation)
+            return false;
+        const { operator, value, field } = this.field?.alwaysShowPlusValidation;
+        const validators = {
+            e: (val1, val2) => { return val1 === val2; },
+            lt: (val1, val2) => { return val1 < val2; },
+            gt: (val1, val2) => { return val1 > val2; }
+        };
+        const data = this.form?.controls[field]?.value;
+        return validators[operator](data, value);
+    }
+    buildComponent() {
+        if (this.componentRef?.instance)
+            return;
+        const factory = this.resolver.resolveComponentFactory(componentMapper[this.field?.fieldType]);
+        this.componentRef = this.container.createComponent(factory);
+        this.componentRef.instance._field = this.field;
+        this.componentRef.instance._form = this.form;
+        // eslint-disable-next-line object-curly-newline
+        this.componentRef.instance._formErrors = this.formErrors || {};
+        this.componentRef.instance.self = this.self;
+    }
+    ngOnInit() {
+        if (!this.field?.alwaysShow && !this.handleInternalPlusValidation())
+            return;
+        this.buildComponent();
+    }
+    ngOnChanges() {
+        if (this.plusValidations && this.plusValidations[this.field?.name]) {
+            if (!this.field?.alwaysShow && this.plusValidations[this.field?.name].alwaysShow) {
+                setTimeout(() => {
+                    this.buildComponent();
+                    this.cdr.detectChanges();
+                }, 1);
+            }
+            if (this.componentRef?.instance &&
+                !this.plusValidations[this.field?.name].alwaysShow) {
+                this.componentRef.destroy();
+                this.componentRef = null;
+                this.form?.controls[this.field?.name]?.setValue(null);
+                this.form?.controls[this.field?.name]?.clearValidators();
+            }
+        }
+        if (!this.componentRef?.instance)
+            return;
+        this.componentRef.instance._formErrors = this.formErrors || {};
+    }
+}
+MECXDynamicDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MECXDynamicDirective, deps: [{ token: i0.ComponentFactoryResolver }, { token: i0.ViewContainerRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive });
+MECXDynamicDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.1.1", type: MECXDynamicDirective, selector: "[MECXDynamic]", inputs: { field: "field", form: "form", formErrors: "formErrors", self: "self", plusValidations: "plusValidations" }, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MECXDynamicDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[MECXDynamic]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ComponentFactoryResolver }, { type: i0.ViewContainerRef }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { field: [{
+                type: Input
+            }], form: [{
+                type: Input
+            }], formErrors: [{
+                type: Input
+            }], self: [{
+                type: Input
+            }], plusValidations: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamic-directive.js","sourceRoot":"","sources":["../../../../../../projects/monkey-front-components/src/lib/components/dynamic/dynamic-directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectorRef,\n  ComponentFactoryResolver,\n  Directive,\n  Input,\n  OnChanges,\n  OnInit,\n  ViewContainerRef\n} from '@angular/core';\nimport { FormGroup } from '@angular/forms';\nimport { MECXFieldConfig } from '../../interfaces';\nimport { MECXDynamicButtonComponent } from './button';\nimport { MECXDynamicFileUploadComponent } from './file-upload';\nimport { MECXDynamicInputComponent } from './input';\nimport { MECXDynamicInputPhoneComponent } from './input-phone';\nimport { MECXDynamicRadioComponent } from './radio';\nimport { MECXDynamicSelectComponent } from './select';\nimport { MECXDynamicSelectSearchComponent } from './select-search';\n\nconst componentMapper: any = {\n  input: MECXDynamicInputComponent,\n  'input-phone': MECXDynamicInputPhoneComponent,\n  radiobutton: MECXDynamicRadioComponent,\n  select: MECXDynamicSelectComponent,\n  'select-search': MECXDynamicSelectSearchComponent,\n  'file-upload': MECXDynamicFileUploadComponent,\n  button: MECXDynamicButtonComponent\n};\n\n@Directive({\n  selector: '[MECXDynamic]'\n})\nexport class MECXDynamicDirective implements OnInit, OnChanges {\n  @Input() field: MECXFieldConfig | null = null;\n\n  @Input() form: FormGroup | null = null;\n\n  @Input() formErrors: any;\n\n  @Input() self: any;\n\n  @Input() plusValidations: any;\n\n  componentRef: any;\n\n  constructor(private resolver: ComponentFactoryResolver, private container: ViewContainerRef,\n  private cdr: ChangeDetectorRef) {\n    // not to do\n  }\n\n  private handleInternalPlusValidation() {\n    if (!this.field?.alwaysShowPlusValidation) return false;\n    const { operator, value, field } = this.field?.alwaysShowPlusValidation;\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    const data = this.form?.controls[field as string]?.value;\n\n    return validators[operator as string](data, value);\n  }\n\n  private buildComponent() {\n    if (this.componentRef?.instance) return;\n    const factory = this.resolver.resolveComponentFactory(\n      componentMapper[this.field?.fieldType as string]\n    );\n    this.componentRef = this.container.createComponent(factory);\n    this.componentRef.instance._field = this.field;\n    this.componentRef.instance._form = this.form;\n    // eslint-disable-next-line object-curly-newline\n    this.componentRef.instance._formErrors = this.formErrors || {};\n    this.componentRef.instance.self = this.self;\n  }\n\n  ngOnInit() {\n    if (!this.field?.alwaysShow && !this.handleInternalPlusValidation()) return;\n    this.buildComponent();\n  }\n\n  ngOnChanges() {\n    if (this.plusValidations && this.plusValidations[this.field?.name as string]) {\n      if (!this.field?.alwaysShow && this.plusValidations[this.field?.name as string].alwaysShow) {\n        setTimeout(() => {\n          this.buildComponent();\n          this.cdr.detectChanges();\n        }, 1);\n      }\n      if (this.componentRef?.instance &&\n        !this.plusValidations[this.field?.name as string].alwaysShow) {\n        this.componentRef.destroy();\n        this.componentRef = null;\n        this.form?.controls[this.field?.name as string]?.setValue(null);\n        this.form?.controls[this.field?.name as string]?.clearValidators();\n      }\n    }\n    if (!this.componentRef?.instance) return;\n    this.componentRef.instance._formErrors = this.formErrors || {\n    };\n  }\n}\n"]}

package/esm2020/lib/components/dynamic/dynamic.module.mjs

@@ -0,0 +1,84 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { TranslateModule } from '@ngx-translate/core';
+import { MonkeyButtonModule, MonkeyFileUploadModule, MonkeyInputModule, MonkeyInputPhoneModule, MonkeyOptionModule, MonkeyRadioButtonModule, MonkeySelectModule } from 'monkey-style-guide';
+import { MECXDynamicButtonComponent } from './button';
+import { MECXDynamicDirective } from './dynamic-directive';
+import { MECXDynamicFileUploadComponent } from './file-upload';
+import { MECXDynamicFormComponent, MECXDynamicFormArrayComponent } from './form';
+import { MECXDynamicInputComponent } from './input';
+import { MECXDynamicInputPhoneComponent } from './input-phone';
+import { MECXDynamicRadioComponent } from './radio';
+import { MECXDynamicSelectComponent } from './select';
+import { MECXDynamicSelectSearchComponent } from './select-search';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+export class MECXDynamicModule {
+}
+MECXDynamicModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MECXDynamicModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+MECXDynamicModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MECXDynamicModule, declarations: [MECXDynamicButtonComponent,
+        MECXDynamicFileUploadComponent,
+        MECXDynamicFormComponent,
+        MECXDynamicFormArrayComponent,
+        MECXDynamicInputComponent,
+        MECXDynamicInputPhoneComponent,
+        MECXDynamicRadioComponent,
+        MECXDynamicSelectComponent,
+        MECXDynamicSelectSearchComponent,
+        MECXDynamicDirective], imports: [CommonModule,
+        FormsModule,
+        ReactiveFormsModule,
+        MonkeyInputModule,
+        MonkeySelectModule,
+        MonkeyRadioButtonModule,
+        MonkeyOptionModule,
+        MonkeyFileUploadModule,
+        MonkeyButtonModule,
+        MonkeyInputPhoneModule, i1.TranslateModule], exports: [MECXDynamicDirective, MECXDynamicFormComponent, MECXDynamicFormArrayComponent] });
+MECXDynamicModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MECXDynamicModule, imports: [[
+            CommonModule,
+            FormsModule,
+            ReactiveFormsModule,
+            MonkeyInputModule,
+            MonkeySelectModule,
+            MonkeyRadioButtonModule,
+            MonkeyOptionModule,
+            MonkeyFileUploadModule,
+            MonkeyButtonModule,
+            MonkeyInputPhoneModule,
+            TranslateModule.forChild()
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MECXDynamicModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        MECXDynamicButtonComponent,
+                        MECXDynamicFileUploadComponent,
+                        MECXDynamicFormComponent,
+                        MECXDynamicFormArrayComponent,
+                        MECXDynamicInputComponent,
+                        MECXDynamicInputPhoneComponent,
+                        MECXDynamicRadioComponent,
+                        MECXDynamicSelectComponent,
+                        MECXDynamicSelectSearchComponent,
+                        MECXDynamicDirective
+                    ],
+                    imports: [
+                        CommonModule,
+                        FormsModule,
+                        ReactiveFormsModule,
+                        MonkeyInputModule,
+                        MonkeySelectModule,
+                        MonkeyRadioButtonModule,
+                        MonkeyOptionModule,
+                        MonkeyFileUploadModule,
+                        MonkeyButtonModule,
+                        MonkeyInputPhoneModule,
+                        TranslateModule.forChild()
+                    ],
+                    exports: [MECXDynamicDirective, MECXDynamicFormComponent, MECXDynamicFormArrayComponent],
+                    entryComponents: [MECXDynamicInputComponent]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/dynamic/file-upload/file-upload.component.mjs

@@ -0,0 +1,52 @@
+import { Component, HostBinding, Input, ViewEncapsulation } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "monkey-style-guide";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/forms";
+import * as i4 from "@ngx-translate/core";
+export class MECXDynamicFileUploadComponent {
+    constructor(cdr) {
+        this.cdr = cdr;
+        // eslint-disable-next-line object-curly-newline
+        this._formErrors = {};
+        this._function = (file, callback) => {
+            if (this._form?.disabled)
+                return;
+            if (!this._field?.functions?.onHandleUpload) {
+                console.error('onHandleUpload not declared');
+                return;
+            }
+            const { func, type } = this._field?.functions?.onHandleUpload;
+            if (!func || !this.self[func]) {
+                console.error('onHandleUpload not declared');
+                return;
+            }
+            this.self[func](file, type, callback);
+        };
+        // not to do
+    }
+    get className() {
+        return this._field?.style?.class;
+    }
+    ngOnChanges() {
+        this.cdr.detectChanges();
+    }
+}
+MECXDynamicFileUploadComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MECXDynamicFileUploadComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+MECXDynamicFileUploadComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.1.1", type: MECXDynamicFileUploadComponent, selector: "mecx-dynamic-file-upload", inputs: { _field: "_field", _form: "_form", _formErrors: "_formErrors", self: "self" }, host: { properties: { "class": "this.className" } }, usesOnChanges: true, ngImport: i0, template: "<monkey-file-upload\n  errorMessage=\"{{ _formErrors[_field?.name]?.firstMessage | translate }} {{ _formErrors[_field?.name]?.lastMessage }}\"\n  [icon]=\"_field?.icon\" [formControl]=\"_form.controls[_field?.name]\"\n  [placeholder]=\"_field?.placeholder | translate\"\n  [helperMessage]=\"_field?.helperMessage | translate\" [label]=\"_field?.label | translate\"\n  [maxSize]=\"_field?.maxSize || 5242880\" [fileUpload]=\"_function\"\n  [maxSizeErrorMessage]=\"'FIELD.FILE.MAX-FILE' | translate\"\n  [allowedExtensionErrorMessage]=\"'FIELD.FILE.ALLOWED-EXTENSION' | translate\"\n  [allowedExtensions]=\"_field?.allowedExtensions || []\" *ngIf=\"_field\">\n</monkey-file-upload>", components: [{ type: i1.MonkeyFileUploadComponent, selector: "monkey-file-upload", inputs: ["name", "label", "helperMessage", "placeholder", "icon", "infoMessage", "uploadOngoingMessage", "errorMessage", "listenFiles", "maxSize", "allowedExtensions", "maxSizeErrorMessage", "allowedExtensionErrorMessage", "fileUpload", "value"], outputs: ["onChange", "onHandleFilesReady"] }], directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i3.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }], pipes: { "translate": i4.TranslatePipe }, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: MECXDynamicFileUploadComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'mecx-dynamic-file-upload', encapsulation: ViewEncapsulation.None, template: "<monkey-file-upload\n  errorMessage=\"{{ _formErrors[_field?.name]?.firstMessage | translate }} {{ _formErrors[_field?.name]?.lastMessage }}\"\n  [icon]=\"_field?.icon\" [formControl]=\"_form.controls[_field?.name]\"\n  [placeholder]=\"_field?.placeholder | translate\"\n  [helperMessage]=\"_field?.helperMessage | translate\" [label]=\"_field?.label | translate\"\n  [maxSize]=\"_field?.maxSize || 5242880\" [fileUpload]=\"_function\"\n  [maxSizeErrorMessage]=\"'FIELD.FILE.MAX-FILE' | translate\"\n  [allowedExtensionErrorMessage]=\"'FIELD.FILE.ALLOWED-EXTENSION' | translate\"\n  [allowedExtensions]=\"_field?.allowedExtensions || []\" *ngIf=\"_field\">\n</monkey-file-upload>" }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }]; }, propDecorators: { _field: [{
+                type: Input
+            }], _form: [{
+                type: Input
+            }], _formErrors: [{
+                type: Input
+            }], self: [{
+                type: Input
+            }], className: [{
+                type: HostBinding,
+                args: ['class']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS11cGxvYWQuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbW9ua2V5LWZyb250LWNvbXBvbmVudHMvc3JjL2xpYi9jb21wb25lbnRzL2R5bmFtaWMvZmlsZS11cGxvYWQvZmlsZS11cGxvYWQuY29tcG9uZW50LnRzIiwiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbW9ua2V5LWZyb250LWNvbXBvbmVudHMvc3JjL2xpYi9jb21wb25lbnRzL2R5bmFtaWMvZmlsZS11cGxvYWQvZmlsZS11cGxvYWQuY29tcG9uZW50Lmh0bWwiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFxQixTQUFTLEVBQUUsV0FBVyxFQUFFLEtBQUssRUFBRSxpQkFBaUIsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7Ozs7O0FBU3BHLE1BQU0sT0FBTyw4QkFBOEI7SUF3QnpDLFlBQW9CLEdBQXNCO1FBQXRCLFFBQUcsR0FBSCxHQUFHLENBQW1CO1FBbkIxQyxnREFBZ0Q7UUFDdkMsZ0JBQVcsR0FBZ0IsRUFBRSxDQUFDO1FBSXZDLGNBQVMsR0FBYSxDQUFDLElBQVMsRUFBRSxRQUFtQixFQUFFLEVBQUU7WUFDdkQsSUFBSSxJQUFJLENBQUMsS0FBSyxFQUFFLFFBQVE7Z0JBQUUsT0FBTztZQUNqQyxJQUFJLENBQUMsSUFBSSxDQUFDLE1BQU0sRUFBRSxTQUFTLEVBQUUsY0FBYyxFQUFFO2dCQUMzQyxPQUFPLENBQUMsS0FBSyxDQUFDLDZCQUE2QixDQUFDLENBQUM7Z0JBQzdDLE9BQU87YUFDUjtZQUNELE1BQU0sRUFBRSxJQUFJLEVBQUUsSUFBSSxFQUFFLEdBQUcsSUFBSSxDQUFDLE1BQU0sRUFBRSxTQUFTLEVBQUUsY0FBYyxDQUFDO1lBQzlELElBQUksQ0FBQyxJQUFJLElBQUksQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxFQUFFO2dCQUM3QixPQUFPLENBQUMsS0FBSyxDQUFDLDZCQUE2QixDQUFDLENBQUM7Z0JBQzdDLE9BQU87YUFDUjtZQUNELElBQUksQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUMsSUFBSSxFQUFFLElBQUksRUFBRSxRQUFRLENBQUMsQ0FBQztRQUN4QyxDQUFDLENBQUM7UUFHQSxZQUFZO0lBQ2QsQ0FBQztJQUVELElBQ0ksU0FBUztRQUNYLE9BQU8sSUFBSSxDQUFDLE1BQU0sRUFBRSxLQUFLLEVBQUUsS0FBSyxDQUFDO0lBQ25DLENBQUM7SUFFRCxXQUFXO1FBQ1QsSUFBSSxDQUFDLEdBQUcsQ0FBQyxhQUFhLEVBQUUsQ0FBQztJQUMzQixDQUFDOzsySEFuQ1UsOEJBQThCOytHQUE5Qiw4QkFBOEIsa09DVDNDLHlxQkFTcUI7MkZEQVIsOEJBQThCO2tCQUwxQyxTQUFTOytCQUNFLDBCQUEwQixpQkFFckIsaUJBQWlCLENBQUMsSUFBSTt3R0FHNUIsTUFBTTtzQkFBZCxLQUFLO2dCQUVHLEtBQUs7c0JBQWIsS0FBSztnQkFHRyxXQUFXO3NCQUFuQixLQUFLO2dCQUVHLElBQUk7c0JBQVosS0FBSztnQkFxQkYsU0FBUztzQkFEWixXQUFXO3VCQUFDLE9BQU8iLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDaGFuZ2VEZXRlY3RvclJlZiwgQ29tcG9uZW50LCBIb3N0QmluZGluZywgSW5wdXQsIFZpZXdFbmNhcHN1bGF0aW9uIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBGb3JtR3JvdXAgfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XG5pbXBvcnQgeyBNRUNYRmllbGRDb25maWcgfSBmcm9tICcuLi8uLi8uLi9pbnRlcmZhY2VzJztcblxuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAnbWVjeC1keW5hbWljLWZpbGUtdXBsb2FkJyxcbiAgdGVtcGxhdGVVcmw6ICcuL2ZpbGUtdXBsb2FkLmNvbXBvbmVudC5odG1sJyxcbiAgZW5jYXBzdWxhdGlvbjogVmlld0VuY2Fwc3VsYXRpb24uTm9uZVxufSlcbmV4cG9ydCBjbGFzcyBNRUNYRHluYW1pY0ZpbGVVcGxvYWRDb21wb25lbnQge1xuICBASW5wdXQoKSBfZmllbGQ6IE1FQ1hGaWVsZENvbmZpZztcblxuICBASW5wdXQoKSBfZm9ybTogRm9ybUdyb3VwO1xuXG4gIC8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBvYmplY3QtY3VybHktbmV3bGluZVxuICBASW5wdXQoKSBfZm9ybUVycm9yczogYW55IHwgYW55W10gPSB7fTtcblxuICBASW5wdXQoKSBzZWxmOiBhbnk7XG5cbiAgX2Z1bmN0aW9uOiBGdW5jdGlvbiA9IChmaWxlOiBhbnksIGNhbGxiYWNrPzogRnVuY3Rpb24pID0+IHtcbiAgICBpZiAodGhpcy5fZm9ybT8uZGlzYWJsZWQpIHJldHVybjtcbiAgICBpZiAoIXRoaXMuX2ZpZWxkPy5mdW5jdGlvbnM/Lm9uSGFuZGxlVXBsb2FkKSB7XG4gICAgICBjb25zb2xlLmVycm9yKCdvbkhhbmRsZVVwbG9hZCBub3QgZGVjbGFyZWQnKTtcbiAgICAgIHJldHVybjtcbiAgICB9XG4gICAgY29uc3QgeyBmdW5jLCB0eXBlIH0gPSB0aGlzLl9maWVsZD8uZnVuY3Rpb25zPy5vbkhhbmRsZVVwbG9hZDtcbiAgICBpZiAoIWZ1bmMgfHwgIXRoaXMuc2VsZltmdW5jXSkge1xuICAgICAgY29uc29sZS5lcnJvcignb25IYW5kbGVVcGxvYWQgbm90IGRlY2xhcmVkJyk7XG4gICAgICByZXR1cm47XG4gICAgfVxuICAgIHRoaXMuc2VsZltmdW5jXShmaWxlLCB0eXBlLCBjYWxsYmFjayk7XG4gIH07XG5cbiAgY29uc3RydWN0b3IocHJpdmF0ZSBjZHI6IENoYW5nZURldGVjdG9yUmVmKSB7XG4gICAgLy8gbm90IHRvIGRvXG4gIH1cblxuICBASG9zdEJpbmRpbmcoJ2NsYXNzJylcbiAgZ2V0IGNsYXNzTmFtZSgpIHtcbiAgICByZXR1cm4gdGhpcy5fZmllbGQ/LnN0eWxlPy5jbGFzcztcbiAgfVxuXG4gIG5nT25DaGFuZ2VzKCkge1xuICAgIHRoaXMuY2RyLmRldGVjdENoYW5nZXMoKTtcbiAgfVxufVxuIiwiPG1vbmtleS1maWxlLXVwbG9hZFxuICBlcnJvck1lc3NhZ2U9XCJ7eyBfZm9ybUVycm9yc1tfZmllbGQ/Lm5hbWVdPy5maXJzdE1lc3NhZ2UgfCB0cmFuc2xhdGUgfX0ge3sgX2Zvcm1FcnJvcnNbX2ZpZWxkPy5uYW1lXT8ubGFzdE1lc3NhZ2UgfX1cIlxuICBbaWNvbl09XCJfZmllbGQ/Lmljb25cIiBbZm9ybUNvbnRyb2xdPVwiX2Zvcm0uY29udHJvbHNbX2ZpZWxkPy5uYW1lXVwiXG4gIFtwbGFjZWhvbGRlcl09XCJfZmllbGQ/LnBsYWNlaG9sZGVyIHwgdHJhbnNsYXRlXCJcbiAgW2hlbHBlck1lc3NhZ2VdPVwiX2ZpZWxkPy5oZWxwZXJNZXNzYWdlIHwgdHJhbnNsYXRlXCIgW2xhYmVsXT1cIl9maWVsZD8ubGFiZWwgfCB0cmFuc2xhdGVcIlxuICBbbWF4U2l6ZV09XCJfZmllbGQ/Lm1heFNpemUgfHwgNTI0Mjg4MFwiIFtmaWxlVXBsb2FkXT1cIl9mdW5jdGlvblwiXG4gIFttYXhTaXplRXJyb3JNZXNzYWdlXT1cIidGSUVMRC5GSUxFLk1BWC1GSUxFJyB8IHRyYW5zbGF0ZVwiXG4gIFthbGxvd2VkRXh0ZW5zaW9uRXJyb3JNZXNzYWdlXT1cIidGSUVMRC5GSUxFLkFMTE9XRUQtRVhURU5TSU9OJyB8IHRyYW5zbGF0ZVwiXG4gIFthbGxvd2VkRXh0ZW5zaW9uc109XCJfZmllbGQ/LmFsbG93ZWRFeHRlbnNpb25zIHx8IFtdXCIgKm5nSWY9XCJfZmllbGRcIj5cbjwvbW9ua2V5LWZpbGUtdXBsb2FkPiJdfQ==

package/esm2020/lib/components/dynamic/file-upload/index.mjs

@@ -0,0 +1,2 @@
+export * from './file-upload.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tb25rZXktZnJvbnQtY29tcG9uZW50cy9zcmMvbGliL2NvbXBvbmVudHMvZHluYW1pYy9maWxlLXVwbG9hZC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHlCQUF5QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9maWxlLXVwbG9hZC5jb21wb25lbnQnO1xuIl19