@po-ui/ng-components 5.22.3 → 6.2.0

package/esm2020/lib/components/po-dynamic/po-dynamic-form/po-dynamic-form-validation/po-dynamic-form-validation.service.mjs

@@ -0,0 +1,39 @@
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { PoDynamicFormOperation } from '../po-dynamic-form-operation/po-dynamic-form-operation';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class PoDynamicFormValidationService extends PoDynamicFormOperation {
+    constructor(http) {
+        super(http);
+    }
+    sendFieldChange(field, value) {
+        const changedValue = { property: field.property, value };
+        return this.execute(field.validate, changedValue).pipe(map(validateFields => this.setFieldDefaultIfEmpty(validateFields)));
+    }
+    sendFormChange(validate, field, value) {
+        const changedValue = { property: field.property, value };
+        return this.execute(validate, changedValue).pipe(map(validateFields => this.setFormDefaultIfEmpty(validateFields)));
+    }
+    updateFieldsForm(validatedFields = [], fields = []) {
+        return [...validatedFields].reduce((updatedFields, validatedField) => {
+            const index = updatedFields.findIndex(field => field.property === validatedField.property);
+            const hasProperty = index >= 0;
+            if (hasProperty) {
+                updatedFields[index] = { ...fields[index], ...validatedField };
+            }
+            return updatedFields;
+        }, [...fields]);
+    }
+    setFieldDefaultIfEmpty(validateFields) {
+        return (validateFields || {
+            field: {}
+        });
+    }
+}
+PoDynamicFormValidationService.ɵfac = function PoDynamicFormValidationService_Factory(t) { return new (t || PoDynamicFormValidationService)(i0.ɵɵinject(i1.HttpClient)); };
+PoDynamicFormValidationService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: PoDynamicFormValidationService, factory: PoDynamicFormValidationService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoDynamicFormValidationService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.HttpClient }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,203 @@
+import { Component, ViewChild } from '@angular/core';
+import { Subject } from 'rxjs';
+import { PoDynamicFormBaseComponent } from './po-dynamic-form-base.component';
+import * as i0 from "@angular/core";
+import * as i1 from "./po-dynamic-form-load/po-dynamic-form-load.service";
+import * as i2 from "./po-dynamic-form-validation/po-dynamic-form-validation.service";
+const _c0 = ["fieldsComponent"];
+const _c1 = ["dynamicForm"];
+function PoDynamicFormComponent_ng_container_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementContainer(0);
+} }
+function PoDynamicFormComponent_ng_template_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelement(0, "po-dynamic-form-fields", 3, 4);
+} if (rf & 2) {
+    const ctx_r2 = i0.ɵɵnextContext();
+    i0.ɵɵproperty("p-auto-focus", ctx_r2.autoFocus)("p-fields", ctx_r2.fields)("p-value", ctx_r2.value);
+} }
+function PoDynamicFormComponent_ng_template_3_Template(rf, ctx) { if (rf & 1) {
+    const _r9 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "form", null, 5);
+    i0.ɵɵelementStart(2, "po-dynamic-form-fields", 6, 4);
+    i0.ɵɵlistener("p-fieldsChange", function PoDynamicFormComponent_ng_template_3_Template_po_dynamic_form_fields_p_fieldsChange_2_listener($event) { i0.ɵɵrestoreView(_r9); const ctx_r8 = i0.ɵɵnextContext(); return ctx_r8.fields = $event; })("p-object-value", function PoDynamicFormComponent_ng_template_3_Template_po_dynamic_form_fields_p_object_value_2_listener($event) { i0.ɵɵrestoreView(_r9); const ctx_r10 = i0.ɵɵnextContext(); return ctx_r10.sendObjectValue($event); })("p-form-validate", function PoDynamicFormComponent_ng_template_3_Template_po_dynamic_form_fields_p_form_validate_2_listener($event) { i0.ɵɵrestoreView(_r9); const ctx_r11 = i0.ɵɵnextContext(); return ctx_r11.validateForm($event); });
+    i0.ɵɵelementEnd();
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r4 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(2);
+    i0.ɵɵproperty("p-fields", ctx_r4.fields)("p-auto-focus", ctx_r4.autoFocus)("p-disabled-form", ctx_r4.disabledForm)("p-validate", ctx_r4.validate)("p-validate-fields", ctx_r4.validateFields)("p-value", ctx_r4.value);
+} }
+/**
+ * @docsExtends PoDynamicFormBaseComponent
+ *
+ * @example
+ *
+ * <example name="po-dynamic-form-basic" title="PO Dynamic Form Basic">
+ *  <file name="sample-po-dynamic-form-basic/sample-po-dynamic-form-basic.component.html"> </file>
+ *  <file name="sample-po-dynamic-form-basic/sample-po-dynamic-form-basic.component.ts"> </file>
+ * </example>
+ *
+ * <example name="po-dynamic-form-register" title="PO Dynamic Form - Register">
+ *  <file name="sample-po-dynamic-form-register/sample-po-dynamic-form-register.component.html"> </file>
+ *  <file name="sample-po-dynamic-form-register/sample-po-dynamic-form-register.component.ts"> </file>
+ *  <file name="sample-po-dynamic-form-register/sample-po-dynamic-form-register.service.ts"> </file>
+ * </example>
+ */
+export class PoDynamicFormComponent extends PoDynamicFormBaseComponent {
+    constructor(changes, loadService, validationService) {
+        super();
+        this.changes = changes;
+        this.loadService = loadService;
+        this.validationService = validationService;
+        this.comboOptionSubject = new Subject();
+    }
+    set form(value) {
+        // necessario para nao ocorrer o ExpressionChangedAfterItHasBeenCheckedError
+        setTimeout(() => {
+            this._form = value;
+            this.emitForm();
+        });
+    }
+    get form() {
+        return this._form || {};
+    }
+    ngOnDestroy() {
+        this.removeListeners();
+    }
+    ngOnInit() {
+        if (this.load) {
+            this.loadDataOnInitialize();
+        }
+    }
+    /**
+     * Função que atribui foco ao campo desejado.
+     *
+     * Para utilizá-la é necessário capturar a instância do `dynamic form`, como por exemplo:
+     *
+     * ``` html
+     * <po-dynamic-form #dynamicForm [p-fields]="fields"></po-dynamic-form>
+     * ```
+     *
+     * ``` javascript
+     * import { PoDynamicFormComponent, PoDynamicFormField } from '@po-ui/ng-components';
+     *
+     * ...
+     *
+     * @ViewChild('dynamicForm', { static: true }) dynamicForm: PoDynamicFormComponent;
+     *
+     * fields: Array<PoDynamicFormField> = [
+     *   { property: 'fieldOne' },
+     *   { property: 'fieldTwo' }
+     * ];
+     *
+     * fieldFocus() {
+     *   this.dynamicForm.focus('fieldTwo');
+     * }
+     * ```
+     *
+     * @param {string} property Nome da propriedade atribuída ao `PoDynamicFormField.property`.
+     */
+    focus(property) {
+        this.fieldsComponent.focus(property);
+    }
+    getObjectValue() {
+        return this.comboOptionSubject.asObservable();
+    }
+    sendObjectValue(objectValue) {
+        this.comboOptionSubject.next(objectValue);
+    }
+    validateForm(field) {
+        const previousFocusElement = document.activeElement;
+        this.disableForm(true);
+        const errorOnValidation = () => this.disableForm(false);
+        this.sendFormSubscription = this.validationService
+            .sendFormChange(this.validate, field, this.value)
+            .subscribe(this.applyFormValidation(previousFocusElement), errorOnValidation);
+    }
+    applyFormUpdatesOnLoad(previousFocusElement) {
+        return dynamicFormData => {
+            this.updateModelOnLoad(dynamicFormData);
+            this.disableForm(false);
+            this.setFocusOnFieldByProperty(dynamicFormData.focus, previousFocusElement);
+        };
+    }
+    applyFormValidation(previousFocusElement) {
+        return dynamicFormData => {
+            this.updateModelWithValidation(dynamicFormData);
+            this.disableForm(false);
+            this.setFocusOnFieldByProperty(dynamicFormData.focus, previousFocusElement);
+        };
+    }
+    disableForm(value) {
+        this.disabledForm = value;
+        this.changes.detectChanges();
+    }
+    emitForm() {
+        if (!this.groupForm && this.formOutput.observers.length) {
+            this.formOutput.emit(this.form);
+        }
+    }
+    loadDataOnInitialize() {
+        const previousFocusElement = document.activeElement;
+        this.disabledForm = true;
+        const errorOnLoad = () => (this.disabledForm = false);
+        this.onLoadSubscription = this.loadService
+            .executeLoad(this.load, this.value)
+            .subscribe(this.applyFormUpdatesOnLoad(previousFocusElement), errorOnLoad);
+    }
+    removeListeners() {
+        if (this.onLoadSubscription) {
+            this.onLoadSubscription.unsubscribe();
+        }
+        if (this.sendFormSubscription) {
+            this.sendFormSubscription.unsubscribe();
+        }
+    }
+    setFocusOnFieldByProperty(property, previousFocusElement) {
+        if (property) {
+            // precisa do timeout para que o valor seja atribuido no campo antes de setar o focus,
+            // para nao disparar a mudança posteriormente. Situação ocorre quando retornar campo com valor e focus atribuido a ele.
+            setTimeout(() => this.focus(property));
+        }
+        else {
+            previousFocusElement['focus']();
+        }
+    }
+    updateModelOnLoad(loadedFormData) {
+        Object.assign(this.value, loadedFormData.value);
+        this.fields = this.loadService.createAndUpdateFieldsForm(loadedFormData.fields, this.fields);
+    }
+    updateModelWithValidation(formData) {
+        Object.assign(this.value, formData.value);
+        this.fieldsComponent.updatePreviousValue();
+        this.fields = this.validationService.updateFieldsForm(formData.fields, this.fields);
+    }
+}
+PoDynamicFormComponent.ɵfac = function PoDynamicFormComponent_Factory(t) { return new (t || PoDynamicFormComponent)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef), i0.ɵɵdirectiveInject(i1.PoDynamicFormLoadService), i0.ɵɵdirectiveInject(i2.PoDynamicFormValidationService)); };
+PoDynamicFormComponent.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: PoDynamicFormComponent, selectors: [["po-dynamic-form"]], viewQuery: function PoDynamicFormComponent_Query(rf, ctx) { if (rf & 1) {
+        i0.ɵɵviewQuery(_c0, 5);
+        i0.ɵɵviewQuery(_c1, 5);
+    } if (rf & 2) {
+        let _t;
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.fieldsComponent = _t.first);
+        i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.form = _t.first);
+    } }, features: [i0.ɵɵInheritDefinitionFeature], decls: 5, vars: 3, consts: [[4, "ngIf", "ngIfThen", "ngIfElse"], ["reuseFormTemplate", ""], ["uniqueFormTemplate", ""], [3, "p-auto-focus", "p-fields", "p-value"], ["fieldsComponent", ""], ["dynamicForm", "ngForm"], [3, "p-fields", "p-auto-focus", "p-disabled-form", "p-validate", "p-validate-fields", "p-value", "p-fieldsChange", "p-object-value", "p-form-validate"]], template: function PoDynamicFormComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵtemplate(0, PoDynamicFormComponent_ng_container_0_Template, 1, 0, "ng-container", 0);
+        i0.ɵɵtemplate(1, PoDynamicFormComponent_ng_template_1_Template, 2, 3, "ng-template", null, 1, i0.ɵɵtemplateRefExtractor);
+        i0.ɵɵtemplate(3, PoDynamicFormComponent_ng_template_3_Template, 4, 6, "ng-template", null, 2, i0.ɵɵtemplateRefExtractor);
+    } if (rf & 2) {
+        const _r1 = i0.ɵɵreference(2);
+        const _r3 = i0.ɵɵreference(4);
+        i0.ɵɵproperty("ngIf", ctx.groupForm)("ngIfThen", _r1)("ngIfElse", _r3);
+    } }, encapsulation: 2 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoDynamicFormComponent, [{
+        type: Component,
+        args: [{ selector: 'po-dynamic-form', template: "<ng-container *ngIf=\"groupForm; then reuseFormTemplate; else uniqueFormTemplate\"></ng-container>\n\n<ng-template #reuseFormTemplate>\n  <po-dynamic-form-fields #fieldsComponent [p-auto-focus]=\"autoFocus\" [p-fields]=\"fields\" [p-value]=\"value\">\n  </po-dynamic-form-fields>\n</ng-template>\n\n<ng-template #uniqueFormTemplate>\n  <form #dynamicForm=\"ngForm\">\n    <po-dynamic-form-fields\n      #fieldsComponent\n      [(p-fields)]=\"fields\"\n      [p-auto-focus]=\"autoFocus\"\n      [p-disabled-form]=\"disabledForm\"\n      [p-validate]=\"validate\"\n      [p-validate-fields]=\"validateFields\"\n      [p-value]=\"value\"\n      (p-object-value)=\"sendObjectValue($event)\"\n      (p-form-validate)=\"validateForm($event)\"\n    >\n    </po-dynamic-form-fields>\n  </form>\n</ng-template>\n" }]
+    }], function () { return [{ type: i0.ChangeDetectorRef }, { type: i1.PoDynamicFormLoadService }, { type: i2.PoDynamicFormValidationService }]; }, { fieldsComponent: [{
+            type: ViewChild,
+            args: ['fieldsComponent']
+        }], form: [{
+            type: ViewChild,
+            args: ['dynamicForm']
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-dynamic-form.component.js","sourceRoot":"","sources":["../../../../../../../projects/ui/src/lib/components/po-dynamic/po-dynamic-form/po-dynamic-form.component.ts","../../../../../../../projects/ui/src/lib/components/po-dynamic/po-dynamic-form/po-dynamic-form.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, ChangeDetectorRef, OnDestroy, OnInit, ViewChild } from '@angular/core';\nimport { NgForm } from '@angular/forms';\n\nimport { Observable, Subject, Subscription } from 'rxjs';\n\nimport { PoDynamicFormBaseComponent } from './po-dynamic-form-base.component';\nimport { PoDynamicFormField } from './po-dynamic-form-field.interface';\nimport { PoDynamicFormLoad } from './po-dynamic-form-load/po-dynamic-form-load.interface';\nimport { PoDynamicFormLoadService } from './po-dynamic-form-load/po-dynamic-form-load.service';\nimport { PoDynamicFormValidation } from './po-dynamic-form-validation/po-dynamic-form-validation.interface';\nimport { PoDynamicFormValidationService } from './po-dynamic-form-validation/po-dynamic-form-validation.service';\n\n/**\n * @docsExtends PoDynamicFormBaseComponent\n *\n * @example\n *\n * <example name=\"po-dynamic-form-basic\" title=\"PO Dynamic Form Basic\">\n *  <file name=\"sample-po-dynamic-form-basic/sample-po-dynamic-form-basic.component.html\"> </file>\n *  <file name=\"sample-po-dynamic-form-basic/sample-po-dynamic-form-basic.component.ts\"> </file>\n * </example>\n *\n * <example name=\"po-dynamic-form-register\" title=\"PO Dynamic Form - Register\">\n *  <file name=\"sample-po-dynamic-form-register/sample-po-dynamic-form-register.component.html\"> </file>\n *  <file name=\"sample-po-dynamic-form-register/sample-po-dynamic-form-register.component.ts\"> </file>\n *  <file name=\"sample-po-dynamic-form-register/sample-po-dynamic-form-register.service.ts\"> </file>\n * </example>\n */\n\n@Component({\n  selector: 'po-dynamic-form',\n  templateUrl: './po-dynamic-form.component.html'\n})\nexport class PoDynamicFormComponent extends PoDynamicFormBaseComponent implements OnInit, OnDestroy {\n  @ViewChild('fieldsComponent') fieldsComponent: { focus: (property: string) => void; updatePreviousValue: () => void };\n\n  disabledForm: boolean;\n\n  private _form: NgForm;\n\n  private onLoadSubscription: Subscription;\n  private sendFormSubscription: Subscription;\n  private comboOptionSubject = new Subject<any>();\n\n  @ViewChild('dynamicForm') set form(value: NgForm) {\n    // necessario para nao ocorrer o ExpressionChangedAfterItHasBeenCheckedError\n    setTimeout(() => {\n      this._form = value;\n\n      this.emitForm();\n    });\n  }\n\n  get form() {\n    return this._form || <any>{};\n  }\n\n  constructor(\n    private changes: ChangeDetectorRef,\n    private loadService: PoDynamicFormLoadService,\n    private validationService: PoDynamicFormValidationService\n  ) {\n    super();\n  }\n\n  ngOnDestroy() {\n    this.removeListeners();\n  }\n\n  ngOnInit() {\n    if (this.load) {\n      this.loadDataOnInitialize();\n    }\n  }\n\n  /**\n   * Função que atribui foco ao campo desejado.\n   *\n   * Para utilizá-la é necessário capturar a instância do `dynamic form`, como por exemplo:\n   *\n   * ``` html\n   * <po-dynamic-form #dynamicForm [p-fields]=\"fields\"></po-dynamic-form>\n   * ```\n   *\n   * ``` javascript\n   * import { PoDynamicFormComponent, PoDynamicFormField } from '@po-ui/ng-components';\n   *\n   * ...\n   *\n   * @ViewChild('dynamicForm', { static: true }) dynamicForm: PoDynamicFormComponent;\n   *\n   * fields: Array<PoDynamicFormField> = [\n   *   { property: 'fieldOne' },\n   *   { property: 'fieldTwo' }\n   * ];\n   *\n   * fieldFocus() {\n   *   this.dynamicForm.focus('fieldTwo');\n   * }\n   * ```\n   *\n   * @param {string} property Nome da propriedade atribuída ao `PoDynamicFormField.property`.\n   */\n  focus(property: string) {\n    this.fieldsComponent.focus(property);\n  }\n\n  getObjectValue(): Observable<any> {\n    return this.comboOptionSubject.asObservable();\n  }\n\n  sendObjectValue(objectValue: any) {\n    this.comboOptionSubject.next(objectValue);\n  }\n\n  validateForm(field: PoDynamicFormField) {\n    const previousFocusElement = document.activeElement;\n\n    this.disableForm(true);\n    const errorOnValidation = () => this.disableForm(false);\n\n    this.sendFormSubscription = this.validationService\n      .sendFormChange(this.validate, field, this.value)\n      .subscribe(this.applyFormValidation(previousFocusElement), errorOnValidation);\n  }\n\n  private applyFormUpdatesOnLoad(previousFocusElement: Element): (dynamicFormData: PoDynamicFormLoad) => void {\n    return dynamicFormData => {\n      this.updateModelOnLoad(dynamicFormData);\n      this.disableForm(false);\n      this.setFocusOnFieldByProperty(dynamicFormData.focus, previousFocusElement);\n    };\n  }\n\n  private applyFormValidation(previousFocusElement: Element): (dynamicFormData: PoDynamicFormValidation) => void {\n    return dynamicFormData => {\n      this.updateModelWithValidation(dynamicFormData);\n      this.disableForm(false);\n      this.setFocusOnFieldByProperty(dynamicFormData.focus, previousFocusElement);\n    };\n  }\n\n  private disableForm(value: boolean) {\n    this.disabledForm = value;\n    this.changes.detectChanges();\n  }\n\n  private emitForm() {\n    if (!this.groupForm && this.formOutput.observers.length) {\n      this.formOutput.emit(this.form);\n    }\n  }\n\n  private loadDataOnInitialize() {\n    const previousFocusElement = document.activeElement;\n\n    this.disabledForm = true;\n    const errorOnLoad = () => (this.disabledForm = false);\n\n    this.onLoadSubscription = this.loadService\n      .executeLoad(this.load, this.value)\n      .subscribe(this.applyFormUpdatesOnLoad(previousFocusElement), errorOnLoad);\n  }\n\n  private removeListeners() {\n    if (this.onLoadSubscription) {\n      this.onLoadSubscription.unsubscribe();\n    }\n\n    if (this.sendFormSubscription) {\n      this.sendFormSubscription.unsubscribe();\n    }\n  }\n\n  private setFocusOnFieldByProperty(property: string, previousFocusElement: Element) {\n    if (property) {\n      // precisa do timeout para que o valor seja atribuido no campo antes de setar o focus,\n      // para nao disparar a mudança posteriormente. Situação ocorre quando retornar campo com valor e focus atribuido a ele.\n      setTimeout(() => this.focus(property));\n    } else {\n      previousFocusElement['focus']();\n    }\n  }\n\n  private updateModelOnLoad(loadedFormData: PoDynamicFormLoad) {\n    Object.assign(this.value, loadedFormData.value);\n    this.fields = this.loadService.createAndUpdateFieldsForm(loadedFormData.fields, this.fields);\n  }\n\n  private updateModelWithValidation(formData: PoDynamicFormValidation) {\n    Object.assign(this.value, formData.value);\n    this.fieldsComponent.updatePreviousValue();\n    this.fields = this.validationService.updateFieldsForm(formData.fields, this.fields);\n  }\n}\n","<ng-container *ngIf=\"groupForm; then reuseFormTemplate; else uniqueFormTemplate\"></ng-container>\n\n<ng-template #reuseFormTemplate>\n  <po-dynamic-form-fields #fieldsComponent [p-auto-focus]=\"autoFocus\" [p-fields]=\"fields\" [p-value]=\"value\">\n  </po-dynamic-form-fields>\n</ng-template>\n\n<ng-template #uniqueFormTemplate>\n  <form #dynamicForm=\"ngForm\">\n    <po-dynamic-form-fields\n      #fieldsComponent\n      [(p-fields)]=\"fields\"\n      [p-auto-focus]=\"autoFocus\"\n      [p-disabled-form]=\"disabledForm\"\n      [p-validate]=\"validate\"\n      [p-validate-fields]=\"validateFields\"\n      [p-value]=\"value\"\n      (p-object-value)=\"sendObjectValue($event)\"\n      (p-form-validate)=\"validateForm($event)\"\n    >\n    </po-dynamic-form-fields>\n  </form>\n</ng-template>\n"]}

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

@@ -0,0 +1,169 @@
+import { Input, Directive } from '@angular/core';
+import { convertToBoolean, isTypeof, sortFields } from '../../../utils/util';
+import { getGridColumnsClasses, isVisibleField } from '../po-dynamic.util';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "../../../pipes/po-time/po-time.pipe";
+import * as i3 from "./po-dynamic-view.service";
+/**
+ *
+ * @description
+ *
+ * Componente para listar dados dinamicamente a partir de uma lista de objetos.
+ *
+ * > Por padrão esse componente cria `po-info` para exibição, é possível criar `po-tag` passando a propriedade { tag: true }.
+ *
+ */
+export class PoDynamicViewBaseComponent {
+    constructor(currencyPipe, datePipe, decimalPipe, timePipe, titleCasePipe, dynamicViewService) {
+        this.currencyPipe = currencyPipe;
+        this.datePipe = datePipe;
+        this.decimalPipe = decimalPipe;
+        this.timePipe = timePipe;
+        this.titleCasePipe = titleCasePipe;
+        this.dynamicViewService = dynamicViewService;
+        this.visibleFields = [];
+        this._fields = [];
+        this._showAllValue = false;
+        this._value = {};
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Lista de objetos que implementam a interface `PoDynamicView`.
+     *
+     * > Ex: `[ { property: 'age' } ]`
+     *
+     * Regras de tipagem e formatação dos valores exibidos:
+     *
+     * - Caso o *type* informado seja *currency* e não seja informado o *format* o mesmo recebe "'BRL', 'symbol', '1.2-2'"
+     * como formato padrão.
+     * - Caso o *type* informado seja *date* e não seja informado o *format* o mesmo recebe 'dd/MM/yyyy' como formato padrão.
+     * - Caso o *type* informado seja *dateTime* e não seja informado o *format* o mesmo recebe 'dd/MM/yyyy HH:mm:ss' como formato padrão.
+     * - Caso o *type* informado seja *number* e não seja informado o *format* o mesmo não será formatado.
+     * - Caso o *type* informado seja *time* e não seja informado o *format* o mesmo recebe 'HH:mm:ss.ffffff' como formato padrão.
+     *
+     * > As propriedades informadas serão exibidas mesmo não contendo valor de referência no objeto da propriedade `p-value`.
+     *
+     * @default `[]`
+     */
+    set fields(fields) {
+        this._fields = Array.isArray(fields) ? [...fields] : [];
+    }
+    get fields() {
+        return this._fields;
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Indica se exibirá todas as informações contidas dentro do objeto informado na propriedade `p-value`.
+     *
+     * @default `false`
+     */
+    set showAllValue(value) {
+        this._showAllValue = convertToBoolean(value);
+    }
+    get showAllValue() {
+        return this._showAllValue;
+    }
+    /**
+     * @description
+     *
+     * Objeto que será utilizado para exibir as informações dinâmicas, o valor será recuperado através do atributo *property*
+     * dos objetos contidos na propridade `p-fields`.
+     *
+     * > Ex: `{ age: '35' }`
+     */
+    set value(value) {
+        this._value = value && isTypeof(value, 'object') ? value : {};
+    }
+    get value() {
+        return this._value;
+    }
+    // retorna os fields com os valores recuperados do objeto value.
+    getConfiguredFields() {
+        const newFields = [];
+        this.fields.forEach(field => {
+            if (isVisibleField(field)) {
+                newFields.push(this.createField(field));
+            }
+        });
+        return sortFields(newFields);
+    }
+    // retorna fields ligado ao value mais os atributos do value que não possuiam fields.
+    getMergedFields() {
+        const mergedFields = [...this.getConfiguredFields()];
+        this.getValueFields().forEach(valueField => {
+            const fieldIndex = mergedFields.findIndex(field => field.property === valueField.property);
+            const property = valueField.property;
+            if (fieldIndex === -1) {
+                mergedFields.push(this.createField({ property }));
+            }
+        });
+        return mergedFields;
+    }
+    // retorna o objeto value como fields.
+    getValueFields() {
+        return Object.keys(this.value).map(property => this.createField({ property }));
+    }
+    createField(field) {
+        const property = field.property;
+        const value = this.transformValue(field.type, this.value[property], field.format);
+        const classesGridColumns = getGridColumnsClasses(field.gridSmColumns, field.gridMdColumns, field.gridLgColumns, field.gridXlColumns, field.gridColumns, {
+            smPull: field.gridSmPull,
+            mdPull: field.gridMdPull,
+            lgPull: field.gridLgPull,
+            xlPull: field.gridXlPull
+        });
+        return {
+            property,
+            value,
+            label: this.titleCasePipe.transform(property),
+            cssClass: classesGridColumns,
+            ...field
+        };
+    }
+    transformValue(type, value, format) {
+        let transformedValue = value;
+        switch (type) {
+            case 'currency':
+                transformedValue = this.currencyPipe.transform(value, format || 'BRL', 'symbol', '1.2-2');
+                break;
+            case 'date':
+                transformedValue = this.datePipe.transform(value, format || 'dd/MM/yyyy');
+                break;
+            case 'dateTime':
+                transformedValue = this.datePipe.transform(value, format || 'dd/MM/yyyy HH:mm:ss');
+                break;
+            case 'number':
+                transformedValue = this.decimalPipe.transform(value, format);
+                break;
+            case 'time':
+                transformedValue = this.timePipe.transform(value, format || 'HH:mm:ss.ffffff');
+                break;
+        }
+        return transformedValue;
+    }
+}
+PoDynamicViewBaseComponent.ɵfac = function PoDynamicViewBaseComponent_Factory(t) { return new (t || PoDynamicViewBaseComponent)(i0.ɵɵdirectiveInject(i1.CurrencyPipe), i0.ɵɵdirectiveInject(i1.DatePipe), i0.ɵɵdirectiveInject(i1.DecimalPipe), i0.ɵɵdirectiveInject(i2.PoTimePipe), i0.ɵɵdirectiveInject(i1.TitleCasePipe), i0.ɵɵdirectiveInject(i3.PoDynamicViewService)); };
+PoDynamicViewBaseComponent.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: PoDynamicViewBaseComponent, inputs: { load: ["p-load", "load"], fields: ["p-fields", "fields"], showAllValue: ["p-show-all-value", "showAllValue"], value: ["p-value", "value"] } });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoDynamicViewBaseComponent, [{
+        type: Directive
+    }], function () { return [{ type: i1.CurrencyPipe }, { type: i1.DatePipe }, { type: i1.DecimalPipe }, { type: i2.PoTimePipe }, { type: i1.TitleCasePipe }, { type: i3.PoDynamicViewService }]; }, { load: [{
+            type: Input,
+            args: ['p-load']
+        }], fields: [{
+            type: Input,
+            args: ['p-fields']
+        }], showAllValue: [{
+            type: Input,
+            args: ['p-show-all-value']
+        }], value: [{
+            type: Input,
+            args: ['p-value']
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-dynamic-view-base.component.js","sourceRoot":"","sources":["../../../../../../../projects/ui/src/lib/components/po-dynamic/po-dynamic-view/po-dynamic-view-base.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Input, Directive } from '@angular/core';\nimport { CurrencyPipe, DatePipe, DecimalPipe, TitleCasePipe } from '@angular/common';\n\nimport { convertToBoolean, isTypeof, sortFields } from '../../../utils/util';\nimport { PoTimePipe } from '../../../pipes/po-time/po-time.pipe';\n\nimport { getGridColumnsClasses, isVisibleField } from '../po-dynamic.util';\nimport { PoDynamicViewField } from './po-dynamic-view-field.interface';\nimport { PoDynamicViewService } from './po-dynamic-view.service';\n\n/**\n *\n * @description\n *\n * Componente para listar dados dinamicamente a partir de uma lista de objetos.\n *\n * > Por padrão esse componente cria `po-info` para exibição, é possível criar `po-tag` passando a propriedade { tag: true }.\n *\n */\n@Directive()\nexport class PoDynamicViewBaseComponent {\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Possibilita executar uma função quando o componente é inicializado.\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 na inicialização do componente.\n   *\n   * Para os dois tipos de utilização da propriedade espera-se o seguinte retorno:\n   *\n   * ```\n   * {\n   *   value: {\n   *     cnpj: '**************', // altera valor do campo\n   *     updated: (new Date()).toString() // atribui valor ao campo novo\n   *   },\n   *   fields: [\n   *     { property: 'cnpj', tag: true, inverse: true }, // atribui novas propriedades ao field\n   *     { property: 'updated', tag: true } // inclui campo novo\n   *   ]\n   * }\n   * ```\n   * > **value**: any = atribui novo valor do model.\n   *\n   * > **fields**: `Array<PoDynamicViewField>` = Lista de campos que deseja alterar as propriedades,\n   * caso enviar um campo a mais será criado um novo campo.\n   *\n   * - Para esconder/remover campos precisa informar no field a propriedade `visible = false`.\n   *\n   */\n  @Input('p-load') load: string | Function;\n\n  visibleFields = [];\n\n  private _fields: Array<PoDynamicViewField> = [];\n  private _showAllValue: boolean = false;\n  private _value = {};\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Lista de objetos que implementam a interface `PoDynamicView`.\n   *\n   * > Ex: `[ { property: 'age' } ]`\n   *\n   * Regras de tipagem e formatação dos valores exibidos:\n   *\n   * - Caso o *type* informado seja *currency* e não seja informado o *format* o mesmo recebe \"'BRL', 'symbol', '1.2-2'\"\n   * como formato padrão.\n   * - Caso o *type* informado seja *date* e não seja informado o *format* o mesmo recebe 'dd/MM/yyyy' como formato padrão.\n   * - Caso o *type* informado seja *dateTime* e não seja informado o *format* o mesmo recebe 'dd/MM/yyyy HH:mm:ss' como formato padrão.\n   * - Caso o *type* informado seja *number* e não seja informado o *format* o mesmo não será formatado.\n   * - Caso o *type* informado seja *time* e não seja informado o *format* o mesmo recebe 'HH:mm:ss.ffffff' como formato padrão.\n   *\n   * > As propriedades informadas serão exibidas mesmo não contendo valor de referência no objeto da propriedade `p-value`.\n   *\n   * @default `[]`\n   */\n  @Input('p-fields') set fields(fields: Array<PoDynamicViewField>) {\n    this._fields = Array.isArray(fields) ? [...fields] : [];\n  }\n\n  get fields() {\n    return this._fields;\n  }\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Indica se exibirá todas as informações contidas dentro do objeto informado na propriedade `p-value`.\n   *\n   * @default `false`\n   */\n  @Input('p-show-all-value') set showAllValue(value: boolean) {\n    this._showAllValue = convertToBoolean(value);\n  }\n\n  get showAllValue() {\n    return this._showAllValue;\n  }\n\n  /**\n   * @description\n   *\n   * Objeto que será utilizado para exibir as informações dinâmicas, o valor será recuperado através do atributo *property*\n   * dos objetos contidos na propridade `p-fields`.\n   *\n   * > Ex: `{ age: '35' }`\n   */\n  @Input('p-value') set value(value: object) {\n    this._value = value && isTypeof(value, 'object') ? value : {};\n  }\n\n  get value() {\n    return this._value;\n  }\n\n  constructor(\n    private currencyPipe: CurrencyPipe,\n    private datePipe: DatePipe,\n    private decimalPipe: DecimalPipe,\n    private timePipe: PoTimePipe,\n    private titleCasePipe: TitleCasePipe,\n    protected dynamicViewService: PoDynamicViewService\n  ) {}\n\n  // retorna os fields com os valores recuperados do objeto value.\n  protected getConfiguredFields() {\n    const newFields = [];\n\n    this.fields.forEach(field => {\n      if (isVisibleField(field)) {\n        newFields.push(this.createField(field));\n      }\n    });\n\n    return sortFields(newFields);\n  }\n\n  // retorna fields ligado ao value mais os atributos do value que não possuiam fields.\n  protected getMergedFields() {\n    const mergedFields = [...this.getConfiguredFields()];\n\n    this.getValueFields().forEach(valueField => {\n      const fieldIndex = mergedFields.findIndex(field => field.property === valueField.property);\n      const property = valueField.property;\n\n      if (fieldIndex === -1) {\n        mergedFields.push(this.createField({ property }));\n      }\n    });\n\n    return mergedFields;\n  }\n\n  // retorna o objeto value como fields.\n  protected getValueFields() {\n    return Object.keys(this.value).map(property => this.createField({ property }));\n  }\n\n  private createField(field: PoDynamicViewField) {\n    const property = field.property;\n    const value = this.transformValue(field.type, this.value[property], field.format);\n\n    const classesGridColumns = 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      property,\n      value,\n      label: this.titleCasePipe.transform(property),\n      cssClass: classesGridColumns,\n      ...field\n    };\n  }\n\n  private transformValue(type: string, value, format) {\n    let transformedValue = value;\n\n    switch (type) {\n      case 'currency':\n        transformedValue = this.currencyPipe.transform(value, format || 'BRL', 'symbol', '1.2-2');\n        break;\n      case 'date':\n        transformedValue = this.datePipe.transform(value, format || 'dd/MM/yyyy');\n        break;\n      case 'dateTime':\n        transformedValue = this.datePipe.transform(value, format || 'dd/MM/yyyy HH:mm:ss');\n        break;\n      case 'number':\n        transformedValue = this.decimalPipe.transform(value, format);\n        break;\n      case 'time':\n        transformedValue = this.timePipe.transform(value, format || 'HH:mm:ss.ffffff');\n        break;\n    }\n\n    return transformedValue;\n  }\n}\n"]}

package/esm2020/lib/components/po-dynamic/po-dynamic-view/po-dynamic-view-field.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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