@po-ui/ng-components 5.22.0 → 6.0.0

package/esm2020/lib/components/po-dropdown/po-dropdown.component.mjs

@@ -0,0 +1,130 @@
+import { Component, ElementRef, ViewChild } from '@angular/core';
+import { isKeyCodeEnter } from './../../utils/util';
+import { PoDropdownBaseComponent } from './po-dropdown-base.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "../po-popup/po-popup.component";
+const _c0 = ["dropdownRef"];
+const _c1 = ["popupRef"];
+const _c2 = function (a0) { return { "po-dropdown-button-disabled": a0 }; };
+const _c3 = function () { return ["bottom-left", "top-left"]; };
+/**
+ * @docsExtends PoDropdownBaseComponent
+ *
+ * @example
+ *
+ * <example name="po-dropdown-basic" title="PO Dropdown Basic" >
+ *  <file name="sample-po-dropdown-basic/sample-po-dropdown-basic.component.html"> </file>
+ *  <file name="sample-po-dropdown-basic/sample-po-dropdown-basic.component.ts"> </file>
+ *  <file name="sample-po-dropdown-basic/sample-po-dropdown-basic.component.e2e-spec.ts"> </file>
+ *  <file name="sample-po-dropdown-basic/sample-po-dropdown-basic.component.po.ts"> </file>
+ * </example>
+ *
+ * <example name="po-dropdown-labs" title="PO Dropdown Labs" >
+ *  <file name="sample-po-dropdown-labs/sample-po-dropdown-labs.component.html"> </file>
+ *  <file name="sample-po-dropdown-labs/sample-po-dropdown-labs.component.ts"> </file>
+ * </example>
+ *
+ * <example name="po-dropdown-social-network" title="PO Dropdown - Social Network" >
+ *  <file name="sample-po-dropdown-social-network/sample-po-dropdown-social-network.component.html"> </file>
+ *  <file name="sample-po-dropdown-social-network/sample-po-dropdown-social-network.component.ts"> </file>
+ * </example>
+ */
+export class PoDropdownComponent extends PoDropdownBaseComponent {
+    constructor(renderer) {
+        super();
+        this.renderer = renderer;
+        this.onScroll = ({ target }) => {
+            if (this.open && target.className !== 'po-popup-container') {
+                this.hideDropdown();
+            }
+        };
+    }
+    onKeyDown(event) {
+        if (isKeyCodeEnter(event)) {
+            this.toggleDropdown();
+        }
+    }
+    toggleDropdown() {
+        this.dropdownRef && !this.open && !this.disabled ? this.showDropdown() : this.hideDropdown();
+    }
+    checkClickArea(event) {
+        return this.dropdownRef && this.dropdownRef.nativeElement.contains(event.target);
+    }
+    hideDropdown() {
+        this.icon = 'po-icon-arrow-down';
+        this.removeListeners();
+        this.popupRef.close();
+        this.open = false;
+    }
+    initializeListeners() {
+        this.clickoutListener = this.renderer.listen('document', 'click', (event) => {
+            this.wasClickedOnDropdown(event);
+        });
+        this.resizeListener = this.renderer.listen('window', 'resize', () => {
+            this.hideDropdown();
+        });
+        window.addEventListener('scroll', this.onScroll, true);
+    }
+    removeListeners() {
+        if (this.clickoutListener) {
+            this.clickoutListener();
+        }
+        if (this.resizeListener) {
+            this.resizeListener();
+        }
+        window.removeEventListener('scroll', this.onScroll, true);
+    }
+    showDropdown() {
+        this.icon = 'po-icon-arrow-up';
+        this.initializeListeners();
+        this.popupRef.open();
+        this.open = true;
+    }
+    wasClickedOnDropdown(event) {
+        const clickedOnDropdown = this.checkClickArea(event);
+        if (!clickedOnDropdown) {
+            this.hideDropdown();
+        }
+    }
+}
+PoDropdownComponent.ɵfac = function PoDropdownComponent_Factory(t) { return new (t || PoDropdownComponent)(i0.ɵɵdirectiveInject(i0.Renderer2)); };
+PoDropdownComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: PoDropdownComponent, selectors: [["po-dropdown"]], viewQuery: function PoDropdownComponent_Query(rf, ctx) { if (rf & 1) {
+        i0.ɵɵviewQuery(_c0, 7, ElementRef);
+        i0.ɵɵviewQuery(_c1, 5);
+    } if (rf & 2) {
+        let _t;
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.dropdownRef = _t.first);
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.popupRef = _t.first);
+    } }, features: [i0.ɵɵInheritDefinitionFeature], decls: 7, vars: 12, consts: [[1, "po-dropdown", 3, "tabindex", "click", "keydown"], ["dropdownRef", ""], [1, "po-dropdown-button", 3, "ngClass"], ["p-hide-arrow", "", "p-is-corner-align", "", "p-position", "bottom-left", 3, "p-actions", "p-custom-positions", "p-target"], ["popupRef", ""]], template: function PoDropdownComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵelementStart(0, "div", 0, 1);
+        i0.ɵɵlistener("click", function PoDropdownComponent_Template_div_click_0_listener() { return ctx.toggleDropdown(); })("keydown", function PoDropdownComponent_Template_div_keydown_0_listener($event) { return ctx.onKeyDown($event); });
+        i0.ɵɵelementStart(2, "div", 2);
+        i0.ɵɵtext(3);
+        i0.ɵɵelement(4, "div");
+        i0.ɵɵelementEnd();
+        i0.ɵɵelement(5, "po-popup", 3, 4);
+        i0.ɵɵelementEnd();
+    } if (rf & 2) {
+        const _r0 = i0.ɵɵreference(1);
+        i0.ɵɵpropertyInterpolate("tabindex", ctx.disabled ? -1 : 0);
+        i0.ɵɵadvance(2);
+        i0.ɵɵproperty("ngClass", i0.ɵɵpureFunction1(9, _c2, ctx.disabled));
+        i0.ɵɵadvance(1);
+        i0.ɵɵtextInterpolate1(" ", ctx.label, " ");
+        i0.ɵɵadvance(1);
+        i0.ɵɵclassMapInterpolate1("po-dropdown-icon po-icon ", ctx.icon, "");
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("p-actions", ctx.actions)("p-custom-positions", i0.ɵɵpureFunction0(11, _c3))("p-target", _r0);
+    } }, directives: [i1.NgClass, i2.PoPopupComponent], encapsulation: 2 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoDropdownComponent, [{
+        type: Component,
+        args: [{ selector: 'po-dropdown', template: "<div\n  #dropdownRef\n  class=\"po-dropdown\"\n  tabindex=\"{{ disabled ? -1 : 0 }}\"\n  (click)=\"toggleDropdown()\"\n  (keydown)=\"onKeyDown($event)\"\n>\n  <div class=\"po-dropdown-button\" [ngClass]=\"{ 'po-dropdown-button-disabled': disabled }\">\n    {{ label }}\n    <div class=\"po-dropdown-icon po-icon {{ icon }}\"></div>\n  </div>\n\n  <po-popup\n    #popupRef\n    p-hide-arrow\n    p-is-corner-align\n    p-position=\"bottom-left\"\n    [p-actions]=\"actions\"\n    [p-custom-positions]=\"['bottom-left', 'top-left']\"\n    [p-target]=\"dropdownRef\"\n  >\n  </po-popup>\n</div>\n" }]
+    }], function () { return [{ type: i0.Renderer2 }]; }, { dropdownRef: [{
+            type: ViewChild,
+            args: ['dropdownRef', { read: ElementRef, static: true }]
+        }], popupRef: [{
+            type: ViewChild,
+            args: ['popupRef']
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-dropdown.component.js","sourceRoot":"","sources":["../../../../../../projects/ui/src/lib/components/po-dropdown/po-dropdown.component.ts","../../../../../../projects/ui/src/lib/components/po-dropdown/po-dropdown.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,UAAU,EAAa,SAAS,EAAE,MAAM,eAAe,CAAC;AAE5E,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEpD,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;;;;;;;;AAEvE;;;;;;;;;;;;;;;;;;;;;GAqBG;AAKH,MAAM,OAAO,mBAAoB,SAAQ,uBAAuB;IAO9D,YAAoB,QAAmB;QACrC,KAAK,EAAE,CAAC;QADU,aAAQ,GAAR,QAAQ,CAAW;QAqC/B,aAAQ,GAAG,CAAC,EAAE,MAAM,EAAE,EAAQ,EAAE;YACtC,IAAI,IAAI,CAAC,IAAI,IAAI,MAAM,CAAC,SAAS,KAAK,oBAAoB,EAAE;gBAC1D,IAAI,CAAC,YAAY,EAAE,CAAC;aACrB;QACH,CAAC,CAAC;IAvCF,CAAC;IAED,SAAS,CAAC,KAAU;QAClB,IAAI,cAAc,CAAC,KAAK,CAAC,EAAE;YACzB,IAAI,CAAC,cAAc,EAAE,CAAC;SACvB;IACH,CAAC;IAED,cAAc;QACZ,IAAI,CAAC,WAAW,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;IAC/F,CAAC;IAEO,cAAc,CAAC,KAAiB;QACtC,OAAO,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IACnF,CAAC;IAEO,YAAY;QAClB,IAAI,CAAC,IAAI,GAAG,oBAAoB,CAAC;QACjC,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;QACtB,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC;IACpB,CAAC;IAEO,mBAAmB;QACzB,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,UAAU,EAAE,OAAO,EAAE,CAAC,KAAiB,EAAE,EAAE;YACtF,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC;QACnC,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,QAAQ,EAAE,QAAQ,EAAE,GAAG,EAAE;YAClE,IAAI,CAAC,YAAY,EAAE,CAAC;QACtB,CAAC,CAAC,CAAC;QAEH,MAAM,CAAC,gBAAgB,CAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;IACzD,CAAC;IAQO,eAAe;QACrB,IAAI,IAAI,CAAC,gBAAgB,EAAE;YACzB,IAAI,CAAC,gBAAgB,EAAE,CAAC;SACzB;QAED,IAAI,IAAI,CAAC,cAAc,EAAE;YACvB,IAAI,CAAC,cAAc,EAAE,CAAC;SACvB;QAED,MAAM,CAAC,mBAAmB,CAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;IAC5D,CAAC;IAEO,YAAY;QAClB,IAAI,CAAC,IAAI,GAAG,kBAAkB,CAAC;QAC/B,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC3B,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;QACrB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;IAEO,oBAAoB,CAAC,KAAiB;QAC5C,MAAM,iBAAiB,GAAG,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;QAErD,IAAI,CAAC,iBAAiB,EAAE;YACtB,IAAI,CAAC,YAAY,EAAE,CAAC;SACrB;IACH,CAAC;;sFA3EU,mBAAmB;sEAAnB,mBAAmB;+BACI,UAAU;;;;;;;QCjC9C,iCAMC;QAFC,6FAAS,oBAAgB,IAAC,0FACf,qBAAiB,IADF;QAG1B,8BAAwF;QACtF,YACA;QAAA,sBAAuD;QACzD,iBAAM;QAEN,iCASW;QACb,iBAAM;;;QAnBJ,2DAAkC;QAIF,eAAuD;QAAvD,kEAAuD;QACrF,eACA;QADA,0CACA;QAAK,eAA2C;QAA3C,oEAA2C;QAQhD,eAAqB;QAArB,uCAAqB,mDAAA,iBAAA;;uFDeZ,mBAAmB;cAJ/B,SAAS;2BACE,aAAa;4DAIuC,WAAW;kBAAxE,SAAS;mBAAC,aAAa,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE;YACrC,QAAQ;kBAA9B,SAAS;mBAAC,UAAU","sourcesContent":["import { Component, ElementRef, Renderer2, ViewChild } from '@angular/core';\n\nimport { isKeyCodeEnter } from './../../utils/util';\n\nimport { PoDropdownBaseComponent } from './po-dropdown-base.component';\n\n/**\n * @docsExtends PoDropdownBaseComponent\n *\n * @example\n *\n * <example name=\"po-dropdown-basic\" title=\"PO Dropdown Basic\" >\n *  <file name=\"sample-po-dropdown-basic/sample-po-dropdown-basic.component.html\"> </file>\n *  <file name=\"sample-po-dropdown-basic/sample-po-dropdown-basic.component.ts\"> </file>\n *  <file name=\"sample-po-dropdown-basic/sample-po-dropdown-basic.component.e2e-spec.ts\"> </file>\n *  <file name=\"sample-po-dropdown-basic/sample-po-dropdown-basic.component.po.ts\"> </file>\n * </example>\n *\n * <example name=\"po-dropdown-labs\" title=\"PO Dropdown Labs\" >\n *  <file name=\"sample-po-dropdown-labs/sample-po-dropdown-labs.component.html\"> </file>\n *  <file name=\"sample-po-dropdown-labs/sample-po-dropdown-labs.component.ts\"> </file>\n * </example>\n *\n * <example name=\"po-dropdown-social-network\" title=\"PO Dropdown - Social Network\" >\n *  <file name=\"sample-po-dropdown-social-network/sample-po-dropdown-social-network.component.html\"> </file>\n *  <file name=\"sample-po-dropdown-social-network/sample-po-dropdown-social-network.component.ts\"> </file>\n * </example>\n */\n@Component({\n  selector: 'po-dropdown',\n  templateUrl: './po-dropdown.component.html'\n})\nexport class PoDropdownComponent extends PoDropdownBaseComponent {\n  @ViewChild('dropdownRef', { read: ElementRef, static: true }) dropdownRef: ElementRef;\n  @ViewChild('popupRef') popupRef: any;\n\n  private clickoutListener: () => void;\n  private resizeListener: () => void;\n\n  constructor(private renderer: Renderer2) {\n    super();\n  }\n\n  onKeyDown(event: any) {\n    if (isKeyCodeEnter(event)) {\n      this.toggleDropdown();\n    }\n  }\n\n  toggleDropdown(): void {\n    this.dropdownRef && !this.open && !this.disabled ? this.showDropdown() : this.hideDropdown();\n  }\n\n  private checkClickArea(event: MouseEvent) {\n    return this.dropdownRef && this.dropdownRef.nativeElement.contains(event.target);\n  }\n\n  private hideDropdown() {\n    this.icon = 'po-icon-arrow-down';\n    this.removeListeners();\n    this.popupRef.close();\n    this.open = false;\n  }\n\n  private initializeListeners() {\n    this.clickoutListener = this.renderer.listen('document', 'click', (event: MouseEvent) => {\n      this.wasClickedOnDropdown(event);\n    });\n\n    this.resizeListener = this.renderer.listen('window', 'resize', () => {\n      this.hideDropdown();\n    });\n\n    window.addEventListener('scroll', this.onScroll, true);\n  }\n\n  private onScroll = ({ target }): void => {\n    if (this.open && target.className !== 'po-popup-container') {\n      this.hideDropdown();\n    }\n  };\n\n  private removeListeners() {\n    if (this.clickoutListener) {\n      this.clickoutListener();\n    }\n\n    if (this.resizeListener) {\n      this.resizeListener();\n    }\n\n    window.removeEventListener('scroll', this.onScroll, true);\n  }\n\n  private showDropdown() {\n    this.icon = 'po-icon-arrow-up';\n    this.initializeListeners();\n    this.popupRef.open();\n    this.open = true;\n  }\n\n  private wasClickedOnDropdown(event: MouseEvent) {\n    const clickedOnDropdown = this.checkClickArea(event);\n\n    if (!clickedOnDropdown) {\n      this.hideDropdown();\n    }\n  }\n}\n","<div\n  #dropdownRef\n  class=\"po-dropdown\"\n  tabindex=\"{{ disabled ? -1 : 0 }}\"\n  (click)=\"toggleDropdown()\"\n  (keydown)=\"onKeyDown($event)\"\n>\n  <div class=\"po-dropdown-button\" [ngClass]=\"{ 'po-dropdown-button-disabled': disabled }\">\n    {{ label }}\n    <div class=\"po-dropdown-icon po-icon {{ icon }}\"></div>\n  </div>\n\n  <po-popup\n    #popupRef\n    p-hide-arrow\n    p-is-corner-align\n    p-position=\"bottom-left\"\n    [p-actions]=\"actions\"\n    [p-custom-positions]=\"['bottom-left', 'top-left']\"\n    [p-target]=\"dropdownRef\"\n  >\n  </po-popup>\n</div>\n"]}

package/esm2020/lib/components/po-dropdown/po-dropdown.module.mjs

@@ -0,0 +1,24 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { PoPopupModule } from '../po-popup/po-popup.module';
+import { PoDropdownComponent } from './po-dropdown.component';
+import * as i0 from "@angular/core";
+/**
+ * @description
+ * Módulo do componente po-dropdown.
+ */
+export class PoDropdownModule {
+}
+PoDropdownModule.ɵfac = function PoDropdownModule_Factory(t) { return new (t || PoDropdownModule)(); };
+PoDropdownModule.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: PoDropdownModule });
+PoDropdownModule.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [[CommonModule, PoPopupModule]] });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoDropdownModule, [{
+        type: NgModule,
+        args: [{
+                imports: [CommonModule, PoPopupModule],
+                declarations: [PoDropdownComponent],
+                exports: [PoDropdownComponent]
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(PoDropdownModule, { declarations: [PoDropdownComponent], imports: [CommonModule, PoPopupModule], exports: [PoDropdownComponent] }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG8tZHJvcGRvd24ubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdWkvc3JjL2xpYi9jb21wb25lbnRzL3BvLWRyb3Bkb3duL3BvLWRyb3Bkb3duLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUV6QyxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFFNUQsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0seUJBQXlCLENBQUM7O0FBQzlEOzs7R0FHRztBQU1ILE1BQU0sT0FBTyxnQkFBZ0I7O2dGQUFoQixnQkFBZ0I7a0VBQWhCLGdCQUFnQjtzRUFKbEIsQ0FBQyxZQUFZLEVBQUUsYUFBYSxDQUFDO3VGQUkzQixnQkFBZ0I7Y0FMNUIsUUFBUTtlQUFDO2dCQUNSLE9BQU8sRUFBRSxDQUFDLFlBQVksRUFBRSxhQUFhLENBQUM7Z0JBQ3RDLFlBQVksRUFBRSxDQUFDLG1CQUFtQixDQUFDO2dCQUNuQyxPQUFPLEVBQUUsQ0FBQyxtQkFBbUIsQ0FBQzthQUMvQjs7d0ZBQ1ksZ0JBQWdCLG1CQUhaLG1CQUFtQixhQUR4QixZQUFZLEVBQUUsYUFBYSxhQUUzQixtQkFBbUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgUG9Qb3B1cE1vZHVsZSB9IGZyb20gJy4uL3BvLXBvcHVwL3BvLXBvcHVwLm1vZHVsZSc7XG5cbmltcG9ydCB7IFBvRHJvcGRvd25Db21wb25lbnQgfSBmcm9tICcuL3BvLWRyb3Bkb3duLmNvbXBvbmVudCc7XG4vKipcbiAqIEBkZXNjcmlwdGlvblxuICogTcOzZHVsbyBkbyBjb21wb25lbnRlIHBvLWRyb3Bkb3duLlxuICovXG5ATmdNb2R1bGUoe1xuICBpbXBvcnRzOiBbQ29tbW9uTW9kdWxlLCBQb1BvcHVwTW9kdWxlXSxcbiAgZGVjbGFyYXRpb25zOiBbUG9Ecm9wZG93bkNvbXBvbmVudF0sXG4gIGV4cG9ydHM6IFtQb0Ryb3Bkb3duQ29tcG9uZW50XVxufSlcbmV4cG9ydCBjbGFzcyBQb0Ryb3Bkb3duTW9kdWxlIHt9XG4iXX0=

package/esm2020/lib/components/po-dynamic/po-dynamic-form/po-dynamic-form-base.component.mjs

@@ -0,0 +1,121 @@
+import { EventEmitter, Input, Output, Directive } from '@angular/core';
+import { convertToBoolean } from '../../../utils/util';
+import * as i0 from "@angular/core";
+/**
+ *
+ * @description
+ *
+ * Componente para criação de formulários dinâmicos a partir de uma lista de objetos.
+ *
+ * Também é possível verificar se o formulário está válido e informar valores para a exibição de informações.
+ */
+export class PoDynamicFormBaseComponent {
+    constructor() {
+        /**
+         * @optional
+         *
+         * @description
+         *
+         * Na inicialização do componente será repassado o objeto de formulário utilizado no componente,
+         * podendo ser utilizado para validações e/ou detecção de mudança dos valores.
+         *
+         * Portanto existem duas maneiras de recuperar o formulário,
+         * através de *template reference* e através do *output*, veja os exemplos abaixo:
+         *
+         * > *template reference*
+         *
+         * ```html
+         *  <po-dynamic-form #dynamicForm>
+         *  </po-dynamic-form>
+         *
+         *  <po-button p-label="Adicionar" [p-disabled]="dynamicForm?.form.invalid">
+         *  </po-button>
+         *
+         * ```
+         *
+         * > *Output*
+         *
+         * ```html
+         *  ...
+         *  <po-dynamic-form (p-form)="getForm($event)">
+         *  </po-dynamic-form>
+         *
+         *  <po-button p-label="Adicionar" [p-disabled]="dynamicForm?.invalid">
+         *  </po-button>
+         *  ...
+         *
+         * ```
+         *
+         * ```ts
+         *  ...
+         *
+         *  export class AppComponent {
+         *
+         *    dynamicForm: NgForm;
+         *
+         *    getForm(form: NgForm) {
+         *      this.dynamicForm = form;
+         *    }
+         *
+         *  }
+         * ```
+         *
+         * > Caso a propriedade `p-group-form` for verdadeira não será repassado o formulário, pois o mesmo utilizará
+         * o formulário pai.
+         */
+        this.formOutput = new EventEmitter();
+        this._groupForm = false;
+    }
+    /**
+     * @optional
+     *
+     * @description
+     * Ao informar esta propriedade, o componente passará a utilizar o formulário pai para criar os `FormControl`
+     * e com isso é possível recuperar o valor do formulário e suas validações a partir do formulário pai.
+     *
+     * ```html
+     * <form #parentForm="ngForm">
+     *
+     *   <po-dynamic-form p-group-form [p-fields]="fields"></po-dynamic-form>
+     *
+     *  <po-button p-label="Adicionar" [p-disabled]="parentForm.invalid"></po-button>
+     * </form>
+     * ```
+     */
+    set groupForm(value) {
+        this._groupForm = value === '' ? true : convertToBoolean(value);
+    }
+    get groupForm() {
+        return this._groupForm;
+    }
+}
+PoDynamicFormBaseComponent.ɵfac = function PoDynamicFormBaseComponent_Factory(t) { return new (t || PoDynamicFormBaseComponent)(); };
+PoDynamicFormBaseComponent.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: PoDynamicFormBaseComponent, inputs: { autoFocus: ["p-auto-focus", "autoFocus"], fields: ["p-fields", "fields"], value: ["p-value", "value"], load: ["p-load", "load"], validate: ["p-validate", "validate"], validateFields: ["p-validate-fields", "validateFields"], groupForm: ["p-group-form", "groupForm"] }, outputs: { formOutput: "p-form" } });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoDynamicFormBaseComponent, [{
+        type: Directive
+    }], null, { autoFocus: [{
+            type: Input,
+            args: ['p-auto-focus']
+        }], fields: [{
+            type: Input,
+            args: ['p-fields']
+        }], value: [{
+            type: Input,
+            args: ['p-value']
+        }], formOutput: [{
+            type: Output,
+            args: ['p-form']
+        }], load: [{
+            type: Input,
+            args: ['p-load']
+        }], validate: [{
+            type: Input,
+            args: ['p-validate']
+        }], validateFields: [{
+            type: Input,
+            args: ['p-validate-fields']
+        }], groupForm: [{
+            type: Input,
+            args: ['p-group-form']
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-dynamic-form-base.component.js","sourceRoot":"","sources":["../../../../../../../projects/ui/src/lib/components/po-dynamic/po-dynamic-form/po-dynamic-form-base.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAGvE,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;;AAIvD;;;;;;;GAOG;AAEH,MAAM,OAAO,0BAA0B;IADvC;QAqDE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAmDG;QACe,eAAU,GAAyB,IAAI,YAAY,EAAU,CAAC;QAuFxE,eAAU,GAAa,KAAK,CAAC;KAyBtC;IAvBC;;;;;;;;;;;;;;;OAeG;IACH,IAA2B,SAAS,CAAC,KAAc;QACjD,IAAI,CAAC,UAAU,GAAQ,KAAK,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;IACvE,CAAC;IAED,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;;oGAvNU,0BAA0B;6EAA1B,0BAA0B;uFAA1B,0BAA0B;cADtC,SAAS;gBASe,SAAS;kBAA/B,KAAK;mBAAC,cAAc;YAgCF,MAAM;kBAAxB,KAAK;mBAAC,UAAU;YAUC,KAAK;kBAAtB,KAAK;mBAAC,SAAS;YAsDE,UAAU;kBAA3B,MAAM;mBAAC,QAAQ;YAkCC,IAAI;kBAApB,KAAK;mBAAC,QAAQ;YA0CM,QAAQ;kBAA5B,KAAK;mBAAC,YAAY;YASS,cAAc;kBAAzC,KAAK;mBAAC,mBAAmB;YAoBC,SAAS;kBAAnC,KAAK;mBAAC,cAAc","sourcesContent":["import { EventEmitter, Input, Output, Directive } from '@angular/core';\nimport { NgForm } from '@angular/forms';\n\nimport { convertToBoolean } from '../../../utils/util';\n\nimport { PoDynamicFormField } from './po-dynamic-form-field.interface';\n\n/**\n *\n * @description\n *\n * Componente para criação de formulários dinâmicos a partir de uma lista de objetos.\n *\n * Também é possível verificar se o formulário está válido e informar valores para a exibição de informações.\n */\n@Directive()\nexport class PoDynamicFormBaseComponent {\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Nome da propriedade, atribuída ao `PoDynamicFormField.property`, que iniciará o campo com foco.\n   */\n  @Input('p-auto-focus') autoFocus?: string;\n\n  /**\n   * @description\n   *\n   * Coleção de objetos que implementam a interface `PoDynamicFormField`, para definição dos campos que serão criados\n   * dinamicamente.\n   *\n   * > Ex: `[ { property: 'name' } ]`\n   *\n   * Regras de tipagem e criação dos componentes:\n   *\n   * - Caso o *type* informado seja *boolean* o componente criado será o `po-switch`.\n   * - Caso o *type* informado seja *currency* e não seja informado um *mask* ou *pattern* o componente criado será o `po-decimal`,\n   * caso seja informado um *mask* ou *pattern* o componente criado será o `po-input`.\n   * - Caso o *type* informado seja *number* e não seja informado um *mask* ou *pattern* o componente criado será o `po-number`, caso seja\n   * informado um *mask* ou *pattern* o componente criado será o `po-input`.\n   * - Caso a lista possua a propriedade `options` e a mesma possua até 3 itens o componente criado será o `po-radio-group`\n   * ou `po-checkbox-group` se informar a propriedade `optionsMulti`.\n   * - Caso a mesma possua 3 ou mais itens, será criado o componente `po-select` ou, `po-multiselect` se a propriedade `optionsMulti`\n   * for verdadeira.\n   * - Caso o *type* informado seja *date* ou *datetime* o componente criado será o `po-datepicker`.\n   * - Caso seja informado a propriedade `optionsService` o componente criado será o `po-combo`.\n   * - Caso o *type* informado seja *time* o componente criado será um `po-input` podendo receber um *mask* para formatar\n   * o valor exibido, caso não seja informado um *mask* o componente será criado com a máscara '99:99' por padrão.\n   * - Caso a lista possua a propriedade `rows` e esta seja definida com valor maior ou igual a 3 o componente criado será\n   * o `po-textarea`, caso o valor da propriedade `rows` seja menor que 3 o componente criado será o `po-input`.\n   * - Caso seja informada a propriedade `secret` o componente criado será o `po-password`.\n   * - Caso o *type* informado seja *string* o componente criado será o `po-input`.\n   *\n   * @default `[]`\n   */\n  @Input('p-fields') fields: Array<PoDynamicFormField>;\n\n  /**\n   * Objeto que será utilizado como valor para exibir as informações, será recuperado e preenchido através do atributo *property*\n   * dos objetos contidos na propridade `p-fields`.\n   *\n   * Pode iniciar com valor ou apenas com um objeto vazio que será preenchido conforme descrito acima.\n   *\n   * > Ex: `{ name: 'po' }`\n   */\n  @Input('p-value') value: any;\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Na inicialização do componente será repassado o objeto de formulário utilizado no componente,\n   * podendo ser utilizado para validações e/ou detecção de mudança dos valores.\n   *\n   * Portanto existem duas maneiras de recuperar o formulário,\n   * através de *template reference* e através do *output*, veja os exemplos abaixo:\n   *\n   * > *template reference*\n   *\n   * ```html\n   *  <po-dynamic-form #dynamicForm>\n   *  </po-dynamic-form>\n   *\n   *  <po-button p-label=\"Adicionar\" [p-disabled]=\"dynamicForm?.form.invalid\">\n   *  </po-button>\n   *\n   * ```\n   *\n   * > *Output*\n   *\n   * ```html\n   *  ...\n   *  <po-dynamic-form (p-form)=\"getForm($event)\">\n   *  </po-dynamic-form>\n   *\n   *  <po-button p-label=\"Adicionar\" [p-disabled]=\"dynamicForm?.invalid\">\n   *  </po-button>\n   *  ...\n   *\n   * ```\n   *\n   * ```ts\n   *  ...\n   *\n   *  export class AppComponent {\n   *\n   *    dynamicForm: NgForm;\n   *\n   *    getForm(form: NgForm) {\n   *      this.dynamicForm = form;\n   *    }\n   *\n   *  }\n   * ```\n   *\n   * > Caso a propriedade `p-group-form` for verdadeira não será repassado o formulário, pois o mesmo utilizará\n   * o formulário pai.\n   */\n  @Output('p-form') formOutput: EventEmitter<NgForm> = new EventEmitter<NgForm>();\n\n  /**\n   * Função ou serviço que será executado na inicialização do componente.\n   *\n   * A propriedade aceita os seguintes tipos:\n   * - `string`: *Endpoint* usado pelo componente para requisição via `POST`.\n   * - `function`: Método que será executado.\n   *\n   * Ao ser executado, irá receber como parâmetro o objeto informado no `p-value`.\n   *\n   * O retorno desta função deve ser do tipo [PoDynamicFormLoad](documentation/po-dynamic-form#po-dynamic-form-load),\n   * onde o usuário poderá determinar as novas atualizações dos campos, valores e determinar o campo a ser focado.\n   *\n   * Por exemplo:\n   *\n   * ```\n   * onLoadFields(): PoDynamicFormLoad {\n   *\n   *   return {\n   *     value: { cpf: undefined },\n   *     fields: [\n   *       { property: 'cpf' }\n   *     ],\n   *     focus: 'cpf'\n   *   };\n   * }\n   *\n   * ```\n   * Para referenciar a sua função utilize a propriedade `bind`, por exemplo:\n   * ```\n   *  [p-load]=\"onLoadFields.bind(this)\"\n   * ```\n   */\n  @Input('p-load') load?: string | Function;\n\n  /**\n   * Função ou serviço para validar as **mudanças do formulário**.\n   *\n   * A propriedade aceita os seguintes tipos:\n   * - `string`: *Endpoint* usado pelo componente para requisição via `POST`.\n   * - `function`: Método que será executado.\n   *\n   * Ao ser executado, irá receber como parâmetro um objeto com o nome da propriedade\n   * alterada e o novo valor, conforme a interface `PoDynamicFormFieldChanged`:\n   *\n   * ```\n   * { property: 'property name', value: 'new value' }\n   * ```\n   *\n   * O retorno desta função deve ser do tipo [PoDynamicFormValidation](documentation/po-dynamic-form#po-dynamic-form-validation),\n   * onde o usuário poderá determinar as novas atualizações dos campos.\n   * Por exemplo:\n   *\n   * ```\n   * onChangeFields(changeValue): PoDynamicFormValidation {\n   *\n   * if (changeValue.property === 'state') {\n   *\n   *   return {\n   *     value: { city: undefined },\n   *     fields: [\n   *       { property: 'city', options: this.getCity(changeValue.value.state) }\n   *     ],\n   *     focus: 'city'\n   *   };\n   * }\n   *\n   * ```\n   * Para referenciar a sua função utilize a propriedade `bind`, por exemplo:\n   * ```\n   *  [p-validate]=\"this.myFunction.bind(this)\"\n   * ```\n   *\n   * > Se houver uma lista de campos para validação definida em `p-validate-fields`, a propriedade `validate` só receberá o disparo para os campos equivalentes.\n   */\n  @Input('p-validate') validate?: string | Function;\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Lista que define os campos que irão disparar o validate do form.\n   */\n  @Input('p-validate-fields') validateFields?: Array<string>;\n\n  private _groupForm?: boolean = false;\n\n  /**\n   * @optional\n   *\n   * @description\n   * Ao informar esta propriedade, o componente passará a utilizar o formulário pai para criar os `FormControl`\n   * e com isso é possível recuperar o valor do formulário e suas validações a partir do formulário pai.\n   *\n   * ```html\n   * <form #parentForm=\"ngForm\">\n   *\n   *   <po-dynamic-form p-group-form [p-fields]=\"fields\"></po-dynamic-form>\n   *\n   *  <po-button p-label=\"Adicionar\" [p-disabled]=\"parentForm.invalid\"></po-button>\n   * </form>\n   * ```\n   */\n  @Input('p-group-form') set groupForm(value: boolean) {\n    this._groupForm = <any>value === '' ? true : convertToBoolean(value);\n  }\n\n  get groupForm(): boolean {\n    return this._groupForm;\n  }\n}\n"]}

package/esm2020/lib/components/po-dynamic/po-dynamic-form/po-dynamic-form-fields/po-dynamic-form-fields-base.component.mjs

@@ -0,0 +1,221 @@
+import { Input, EventEmitter, Output, Directive } from '@angular/core';
+import { isTypeof, sortFields } from '../../../../utils/util';
+import { getGridColumnsClasses, isVisibleField } from '../../po-dynamic.util';
+import { PoDynamicFieldType } from '../../po-dynamic-field-type.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class PoDynamicFormFieldsBaseComponent {
+    constructor(titleCasePipe) {
+        this.titleCasePipe = titleCasePipe;
+        this.formValidate = new EventEmitter();
+        this.fieldsChange = new EventEmitter();
+        // Evento disparado se existir optionsService em visibleField. Necessário resgatar referência do objeto selecionado para quando se tratar de recebimento de opções via serviço.
+        this.objectValue = new EventEmitter();
+        this.visibleFields = [];
+        this._value = {};
+    }
+    // array de objetos que implementam a interface PoDynamicFormField, que serão exibidos no componente.
+    set fields(value) {
+        this._fields = Array.isArray(value) ? [...value] : [];
+    }
+    get fields() {
+        return this._fields;
+    }
+    // valor que será utilizado para iniciar valor no componente.
+    set value(value) {
+        this._value = value && isTypeof(value, 'object') ? value : {};
+    }
+    get value() {
+        return this._value;
+    }
+    set validateFields(value) {
+        this._validateFields = Array.isArray(value) ? [...value] : [];
+    }
+    get validateFields() {
+        return this._validateFields;
+    }
+    compareTo(value, compareTo) {
+        return value === compareTo;
+    }
+    // retorna um array com os objetos configurados e visiveis.
+    getVisibleFields() {
+        const visibleFields = [];
+        this.fields.forEach(field => {
+            if (this.existsProperty(visibleFields, field.property)) {
+                this.printError(`"po-dynamic-form" property "${field.property}" está duplicado. Interface: PoDynamicFormField.`);
+                return;
+            }
+            if (!field['property']) {
+                this.printError('"po-dynamic-form" É obrigatório ser especificado um property.');
+                return;
+            }
+            if (isVisibleField(field)) {
+                visibleFields.push(this.createField(field));
+            }
+        });
+        return sortFields(visibleFields);
+    }
+    // converte um array em string para um array de objetos que contem label e value.
+    convertOptions(options) {
+        const everyOptionString = options.every(option => typeof option === 'string');
+        if (everyOptionString) {
+            return options.map(value => ({ label: value, value }));
+        }
+        return options;
+    }
+    // cria um novo objeto com as classes de grid system, com control (tipo do componente) e label default.
+    createField(field) {
+        const control = this.getComponentControl(field);
+        const options = !!field.options ? this.convertOptions(field.options) : undefined;
+        const focus = this.hasFocus(field);
+        const type = field && field.type ? field.type.toLocaleLowerCase() : 'string';
+        const componentClass = getGridColumnsClasses(field.gridSmColumns, field.gridMdColumns, field.gridLgColumns, field.gridXlColumns, field.gridColumns, {
+            smPull: field.gridSmPull,
+            mdPull: field.gridMdPull,
+            lgPull: field.gridLgPull,
+            xlPull: field.gridXlPull
+        });
+        return {
+            label: this.titleCasePipe.transform(field.property),
+            maskFormatModel: this.compareTo(type, PoDynamicFieldType.Time),
+            ...field,
+            componentClass,
+            control,
+            focus,
+            options
+        };
+    }
+    existsProperty(fields, property) {
+        return fields.some(field => field.property === property);
+    }
+    // recupera o componente de acordo com algumas regras do field.
+    getComponentControl(field = {}) {
+        const type = field && field.type ? field.type.toLocaleLowerCase() : 'string';
+        if (this.isNumberType(field, type)) {
+            return 'number';
+        }
+        else if (this.isCurrencyType(field, type)) {
+            return 'decimal';
+        }
+        else if (this.isSelect(field)) {
+            return 'select';
+        }
+        else if (this.isRadioGroup(field)) {
+            return 'radioGroup';
+        }
+        else if (this.isCheckboxGroup(field)) {
+            return 'checkboxGroup';
+        }
+        else if (this.isMultiselect(field)) {
+            return 'multiselect';
+        }
+        else if (this.compareTo(type, PoDynamicFieldType.Boolean)) {
+            return 'switch';
+        }
+        else if (this.compareTo(type, PoDynamicFieldType.Date) || this.compareTo(type, PoDynamicFieldType.DateTime)) {
+            return field.range ? 'datepickerrange' : 'datepicker';
+        }
+        else if (this.compareTo(type, PoDynamicFieldType.Time)) {
+            field.mask = field.mask || '99:99';
+            return 'input';
+        }
+        else if (this.isCombo(field)) {
+            return 'combo';
+        }
+        else if (this.isLookup(field)) {
+            return 'lookup';
+        }
+        else if (this.isTextarea(field)) {
+            return 'textarea';
+        }
+        else if (this.isPassword(field)) {
+            return 'password';
+        }
+        return 'input';
+    }
+    hasFocus(field) {
+        return !!this.autoFocus && this.autoFocus === field.property;
+    }
+    isCheckboxGroup(field) {
+        const { optionsService, optionsMulti, options } = field;
+        return !optionsService && optionsMulti && !!options && options.length <= 3;
+    }
+    isCombo(field) {
+        const { optionsService } = field;
+        return !!optionsService && (isTypeof(optionsService, 'string') || this.isComboFilter(optionsService));
+    }
+    isCurrencyType(field, type) {
+        const { mask, pattern } = field;
+        return this.compareTo(type, PoDynamicFieldType.Currency) && !mask && !pattern;
+    }
+    isLookupFilter(object) {
+        return object && object.getObjectByValue !== undefined;
+    }
+    isComboFilter(object) {
+        return object && object.getFilteredData !== undefined;
+    }
+    isLookup(field) {
+        const { searchService } = field;
+        return !!searchService && (isTypeof(searchService, 'string') || this.isLookupFilter(searchService));
+    }
+    isMultiselect(field) {
+        const { optionsService, optionsMulti, options } = field;
+        return optionsMulti && (!!optionsService || (!!options && options.length > 3));
+    }
+    isNumberType(field, type) {
+        const { mask, pattern } = field;
+        return this.compareTo(type, PoDynamicFieldType.Number) && !mask && !pattern;
+    }
+    isPassword(field) {
+        const { secret } = field;
+        return secret;
+    }
+    isRadioGroup(field) {
+        const { optionsMulti, options } = field;
+        return !optionsMulti && !!options && options.length <= 3;
+    }
+    isSelect(field) {
+        const { optionsMulti, options } = field;
+        return !optionsMulti && !!options && options.length > 3;
+    }
+    isTextarea(field) {
+        const { rows } = field;
+        return rows && rows >= 3;
+    }
+    printError(error) {
+        console.error(error);
+    }
+}
+PoDynamicFormFieldsBaseComponent.ɵfac = function PoDynamicFormFieldsBaseComponent_Factory(t) { return new (t || PoDynamicFormFieldsBaseComponent)(i0.ɵɵdirectiveInject(i1.TitleCasePipe)); };
+PoDynamicFormFieldsBaseComponent.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: PoDynamicFormFieldsBaseComponent, inputs: { autoFocus: ["p-auto-focus", "autoFocus"], disabledForm: ["p-disabled-form", "disabledForm"], validate: ["p-validate", "validate"], fields: ["p-fields", "fields"], value: ["p-value", "value"], validateFields: ["p-validate-fields", "validateFields"] }, outputs: { formValidate: "p-form-validate", fieldsChange: "p-fieldsChange", objectValue: "p-object-value" } });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoDynamicFormFieldsBaseComponent, [{
+        type: Directive
+    }], function () { return [{ type: i1.TitleCasePipe }]; }, { autoFocus: [{
+            type: Input,
+            args: ['p-auto-focus']
+        }], disabledForm: [{
+            type: Input,
+            args: ['p-disabled-form']
+        }], validate: [{
+            type: Input,
+            args: ['p-validate']
+        }], formValidate: [{
+            type: Output,
+            args: ['p-form-validate']
+        }], fieldsChange: [{
+            type: Output,
+            args: ['p-fieldsChange']
+        }], objectValue: [{
+            type: Output,
+            args: ['p-object-value']
+        }], fields: [{
+            type: Input,
+            args: ['p-fields']
+        }], value: [{
+            type: Input,
+            args: ['p-value']
+        }], validateFields: [{
+            type: Input,
+            args: ['p-validate-fields']
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-dynamic-form-fields-base.component.js","sourceRoot":"","sources":["../../../../../../../../projects/ui/src/lib/components/po-dynamic/po-dynamic-form/po-dynamic-form-fields/po-dynamic-form-fields-base.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Input, EventEmitter, Output, Directive } from '@angular/core';\nimport { TitleCasePipe } from '@angular/common';\n\nimport { isTypeof, sortFields } from '../../../../utils/util';\n\nimport { getGridColumnsClasses, isVisibleField } from '../../po-dynamic.util';\nimport { PoDynamicFieldType } from '../../po-dynamic-field-type.enum';\nimport { PoDynamicFormField } from '../po-dynamic-form-field.interface';\nimport { PoDynamicFormFieldInternal } from './po-dynamic-form-field-internal.interface';\nimport { PoComboFilter } from '../../../po-field/po-combo/interfaces/po-combo-filter.interface';\nimport { PoLookupFilter } from '../../../po-field/po-lookup/interfaces/po-lookup-filter.interface';\n\n@Directive()\nexport class PoDynamicFormFieldsBaseComponent {\n  @Input('p-auto-focus') autoFocus?: string;\n\n  @Input('p-disabled-form') disabledForm: boolean;\n\n  @Input('p-validate') validate?: string | Function;\n\n  @Output('p-form-validate') formValidate = new EventEmitter<any>();\n\n  @Output('p-fieldsChange') fieldsChange = new EventEmitter<any>();\n\n  // Evento disparado se existir optionsService em visibleField. Necessário resgatar referência do objeto selecionado para quando se tratar de recebimento de opções via serviço.\n  @Output('p-object-value') objectValue = new EventEmitter<any>();\n\n  visibleFields: Array<PoDynamicFormFieldInternal> = [];\n\n  private _fields: Array<PoDynamicFormField>;\n  private _validateFields: Array<string>;\n  private _value?: any = {};\n\n  // array de objetos que implementam a interface PoDynamicFormField, que serão exibidos no componente.\n  @Input('p-fields') set fields(value: Array<PoDynamicFormField>) {\n    this._fields = Array.isArray(value) ? [...value] : [];\n  }\n\n  get fields() {\n    return this._fields;\n  }\n\n  // valor que será utilizado para iniciar valor no componente.\n  @Input('p-value') set value(value: any) {\n    this._value = value && isTypeof(value, 'object') ? value : {};\n  }\n\n  get value() {\n    return this._value;\n  }\n\n  @Input('p-validate-fields') set validateFields(value: Array<string>) {\n    this._validateFields = Array.isArray(value) ? [...value] : [];\n  }\n\n  get validateFields() {\n    return this._validateFields;\n  }\n\n  constructor(private titleCasePipe: TitleCasePipe) {}\n\n  compareTo(value, compareTo) {\n    return value === compareTo;\n  }\n\n  // retorna um array com os objetos configurados e visiveis.\n  protected getVisibleFields() {\n    const visibleFields = [];\n\n    this.fields.forEach(field => {\n      if (this.existsProperty(visibleFields, field.property)) {\n        this.printError(\n          `\"po-dynamic-form\" property \"${field.property}\" está duplicado. Interface: PoDynamicFormField.`\n        );\n        return;\n      }\n\n      if (!field['property']) {\n        this.printError('\"po-dynamic-form\" É obrigatório ser especificado um property.');\n        return;\n      }\n\n      if (isVisibleField(field)) {\n        visibleFields.push(this.createField(field));\n      }\n    });\n\n    return sortFields(visibleFields);\n  }\n\n  // converte um array em string para um array de objetos que contem label e value.\n  private convertOptions(options: Array<any>): Array<{ label: string; value: string }> {\n    const everyOptionString = options.every(option => typeof option === 'string');\n\n    if (everyOptionString) {\n      return options.map(value => ({ label: value, value }));\n    }\n\n    return options;\n  }\n\n  // cria um novo objeto com as classes de grid system, com control (tipo do componente) e label default.\n  private createField(field: PoDynamicFormField): PoDynamicFormFieldInternal {\n    const control = this.getComponentControl(field);\n    const options = !!field.options ? this.convertOptions(field.options) : undefined;\n    const focus = this.hasFocus(field);\n    const type = field && field.type ? field.type.toLocaleLowerCase() : 'string';\n\n    const componentClass = getGridColumnsClasses(\n      field.gridSmColumns,\n      field.gridMdColumns,\n      field.gridLgColumns,\n      field.gridXlColumns,\n      field.gridColumns,\n      {\n        smPull: field.gridSmPull,\n        mdPull: field.gridMdPull,\n        lgPull: field.gridLgPull,\n        xlPull: field.gridXlPull\n      }\n    );\n\n    return {\n      label: this.titleCasePipe.transform(field.property),\n      maskFormatModel: this.compareTo(type, PoDynamicFieldType.Time),\n      ...field,\n      componentClass,\n      control,\n      focus,\n      options\n    };\n  }\n\n  private existsProperty(fields: Array<PoDynamicFormField>, property: string) {\n    return fields.some(field => field.property === property);\n  }\n\n  // recupera o componente de acordo com algumas regras do field.\n  private getComponentControl(field: PoDynamicFormField = <any>{}) {\n    const type = field && field.type ? field.type.toLocaleLowerCase() : 'string';\n\n    if (this.isNumberType(field, type)) {\n      return 'number';\n    } else if (this.isCurrencyType(field, type)) {\n      return 'decimal';\n    } else if (this.isSelect(field)) {\n      return 'select';\n    } else if (this.isRadioGroup(field)) {\n      return 'radioGroup';\n    } else if (this.isCheckboxGroup(field)) {\n      return 'checkboxGroup';\n    } else if (this.isMultiselect(field)) {\n      return 'multiselect';\n    } else if (this.compareTo(type, PoDynamicFieldType.Boolean)) {\n      return 'switch';\n    } else if (this.compareTo(type, PoDynamicFieldType.Date) || this.compareTo(type, PoDynamicFieldType.DateTime)) {\n      return field.range ? 'datepickerrange' : 'datepicker';\n    } else if (this.compareTo(type, PoDynamicFieldType.Time)) {\n      field.mask = field.mask || '99:99';\n\n      return 'input';\n    } else if (this.isCombo(field)) {\n      return 'combo';\n    } else if (this.isLookup(field)) {\n      return 'lookup';\n    } else if (this.isTextarea(field)) {\n      return 'textarea';\n    } else if (this.isPassword(field)) {\n      return 'password';\n    }\n\n    return 'input';\n  }\n\n  private hasFocus(field: PoDynamicFormField) {\n    return !!this.autoFocus && this.autoFocus === field.property;\n  }\n\n  private isCheckboxGroup(field: PoDynamicFormField) {\n    const { optionsService, optionsMulti, options } = field;\n\n    return !optionsService && optionsMulti && !!options && options.length <= 3;\n  }\n\n  private isCombo(field: PoDynamicFormField) {\n    const { optionsService } = field;\n\n    return !!optionsService && (isTypeof(optionsService, 'string') || this.isComboFilter(optionsService));\n  }\n\n  private isCurrencyType(field: PoDynamicFormField, type: string) {\n    const { mask, pattern } = field;\n\n    return this.compareTo(type, PoDynamicFieldType.Currency) && !mask && !pattern;\n  }\n\n  private isLookupFilter(object: any): object is PoLookupFilter {\n    return object && (<PoLookupFilter>object).getObjectByValue !== undefined;\n  }\n\n  private isComboFilter(object: any): object is PoComboFilter {\n    return object && (<PoComboFilter>object).getFilteredData !== undefined;\n  }\n\n  private isLookup(field: PoDynamicFormField) {\n    const { searchService } = field;\n\n    return !!searchService && (isTypeof(searchService, 'string') || this.isLookupFilter(searchService));\n  }\n\n  private isMultiselect(field: PoDynamicFormField) {\n    const { optionsService, optionsMulti, options } = field;\n\n    return optionsMulti && (!!optionsService || (!!options && options.length > 3));\n  }\n\n  private isNumberType(field: PoDynamicFormField, type: string) {\n    const { mask, pattern } = field;\n\n    return this.compareTo(type, PoDynamicFieldType.Number) && !mask && !pattern;\n  }\n\n  private isPassword(field: PoDynamicFormField) {\n    const { secret } = field;\n\n    return secret;\n  }\n\n  private isRadioGroup(field: PoDynamicFormField) {\n    const { optionsMulti, options } = field;\n\n    return !optionsMulti && !!options && options.length <= 3;\n  }\n\n  private isSelect(field: PoDynamicFormField) {\n    const { optionsMulti, options } = field;\n\n    return !optionsMulti && !!options && options.length > 3;\n  }\n\n  private isTextarea(field: PoDynamicFormField) {\n    const { rows } = field;\n\n    return rows && rows >= 3;\n  }\n\n  private printError(error: string) {\n    console.error(error);\n  }\n}\n"]}