@po-ui/ng-components 17.26.7 → 17.26.9

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

@@ -434,18 +434,24 @@ export class PoDynamicFormFieldsComponent extends PoDynamicFormFieldsBaseCompone
             container: item.container || null,
             property: item.property,
             index,
-            order: item.order
+            order: item.order,
+            visible: item.visible ?? true
         }));
         const currArray = current.map((item, index) => ({
             container: item.container || null,
             property: item.property,
             index,
-            order: item.order
+            order: item.order,
+            visible: item.visible ?? true
         }));
         const prevContainers = prevArray.filter(item => item.container);
         const currContainers = currArray.filter(item => item.container);
         const prevOrder = prevArray.filter(item => item.order);
         const currOrder = currArray.filter(item => item.order);
+        const prevVisibleTrue = prevArray.filter(item => item.visible === true);
+        const currVisibleTrue = currArray.filter(item => item.visible === true);
+        const prevVisibleFalse = prevArray.filter(item => !item.visible);
+        const currVisibleFalse = currArray.filter(item => !item.visible);
         // Verifica mudança na quantidade de containers
         if (prevContainers.length !== currContainers.length) {
             this.setContainerFields();
@@ -456,12 +462,28 @@ export class PoDynamicFormFieldsComponent extends PoDynamicFormFieldsBaseCompone
             this.setContainerFields();
             return;
         }
+        // Verifica mudança na quantidade de visible
+        if (prevVisibleTrue.length !== currVisibleTrue.length) {
+            this.setContainerFields();
+            return;
+        }
+        // Verifica mudança na quantidade de visible
+        if (prevVisibleFalse.length !== currVisibleFalse.length) {
+            this.setContainerFields();
+            return;
+        }
         if (currContainers.length) {
             this.handleChangesContainer(prevContainers, currContainers, 'container');
         }
         if (currOrder.length) {
             this.handleChangesContainer(prevOrder, currOrder, 'order');
         }
+        if (currVisibleTrue.length) {
+            this.handleChangesContainer(prevVisibleTrue, currVisibleTrue, 'visible');
+        }
+        if (currVisibleFalse.length) {
+            this.handleChangesContainer(prevVisibleFalse, currVisibleFalse, 'visible');
+        }
         //atualiza container sem mudança na estrutura da interface
         const result = this.diffObjectsArray(previous, this.getVisibleFields());
         this.containerFields = this.updateFieldContainer(result, this.containerFields);
@@ -555,4 +577,4 @@ export class PoDynamicFormFieldsComponent extends PoDynamicFormFieldsBaseCompone
             args: ['component']
         }] }); })();
 (() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(PoDynamicFormFieldsComponent, { className: "PoDynamicFormFieldsComponent", filePath: "lib/components/po-dynamic/po-dynamic-form/po-dynamic-form-fields/po-dynamic-form-fields.component.ts", lineNumber: 23 }); })();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-dynamic-form-fields.component.js","sourceRoot":"","sources":["../../../../../../../../projects/ui/src/lib/components/po-dynamic/po-dynamic-form/po-dynamic-form-fields/po-dynamic-form-fields.component.ts","../../../../../../../../projects/ui/src/lib/components/po-dynamic/po-dynamic-form/po-dynamic-form-fields/po-dynamic-form-fields.component.html"],"names":[],"mappings":"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","sourcesContent":["import { TitleCasePipe } from '@angular/common';\nimport { ChangeDetectorRef, Component, OnChanges, QueryList, SimpleChanges, ViewChildren } from '@angular/core';\nimport { ControlContainer, NgForm } from '@angular/forms';\n\nimport { PoDynamicFormField } from '../po-dynamic-form-field.interface';\nimport { PoDynamicFormFieldValidation } from '../po-dynamic-form-validation/po-dynamic-form-field-validation.interface';\nimport { PoDynamicFormValidationService } from '../po-dynamic-form-validation/po-dynamic-form-validation.service';\nimport { PoDynamicFormFieldsBaseComponent } from './po-dynamic-form-fields-base.component';\n\n/**\n * @docsPrivate\n *\n * @description\n *\n * Componente de criação dos campos dinâmicos.\n */\n@Component({\n  selector: 'po-dynamic-form-fields',\n  templateUrl: 'po-dynamic-form-fields.component.html',\n  viewProviders: [{ provide: ControlContainer, useExisting: NgForm }],\n  providers: [PoDynamicFormValidationService]\n})\nexport class PoDynamicFormFieldsComponent extends PoDynamicFormFieldsBaseComponent implements OnChanges {\n  @ViewChildren('component') components: QueryList<{ name: string; focus: () => void }>;\n\n  private previousValue = {};\n\n  constructor(\n    titleCasePipe: TitleCasePipe,\n    private validationService: PoDynamicFormValidationService,\n    private changes: ChangeDetectorRef,\n    private form: NgForm\n  ) {\n    super(titleCasePipe);\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    if (changes.fields) {\n      this.visibleFields = this.getVisibleFields();\n\n      if (changes.fields.previousValue && this.hasContainer()) {\n        this.hasChangeContainer(changes.fields.previousValue, changes.fields.currentValue);\n      }\n\n      if (!changes.fields.previousValue || !changes.fields.currentValue) {\n        this.setContainerFields();\n      }\n    }\n  }\n\n  focus(property: string) {\n    const foundComponent = this.components.find(component => component.name === property);\n    if (foundComponent) {\n      foundComponent.focus();\n    }\n  }\n\n  isDisabled(field: PoDynamicFormField): boolean {\n    return field.disabled || this.disabledForm;\n  }\n\n  async onChangeField(visibleField: PoDynamicFormField, objectValue?: any) {\n    const { property } = visibleField;\n    const isBooleanType = visibleField.type === 'boolean';\n    const isChangedValueField = this.previousValue[property] !== this.value[property];\n\n    if (visibleField.optionsService) {\n      this.objectValue.emit(objectValue);\n    }\n\n    // verifica se o formulario esta touched para não disparar o validate ao carregar a tela.\n    if ((this.form.touched || isBooleanType) && isChangedValueField) {\n      const { changedField, changedFieldIndex } = this.getField(property);\n\n      if (changedField.validate) {\n        await this.validateField(changedField, changedFieldIndex, visibleField);\n      }\n\n      this.triggerValidationOnForm(changedFieldIndex);\n    }\n\n    this.updatePreviousValue();\n  }\n\n  //emite o valor a cada caractere digitado no input\n  onChangeFieldModel(visibleField: PoDynamicFormField) {\n    if (this.validateOnInput) {\n      const { property } = visibleField;\n      const { changedFieldIndex } = this.getField(property);\n      this.triggerValidationOnForm(changedFieldIndex);\n    }\n  }\n\n  updatePreviousValue() {\n    this.previousValue = JSON.parse(JSON.stringify(this.value));\n  }\n\n  trackBy(index) {\n    return index;\n  }\n\n  private applyFieldValidation(index: number, validatedField: PoDynamicFormFieldValidation) {\n    const field = this.fields[index];\n\n    this.fields[index] = { ...field, ...validatedField.field };\n    this.updateFields();\n\n    if (validatedField.hasOwnProperty('value')) {\n      this.value[field.property] = validatedField.value;\n    }\n\n    this.changes.detectChanges();\n\n    if (validatedField.focus) {\n      this.focus(field.property);\n    }\n  }\n\n  private getField(property: string) {\n    const changedFieldIndex = this.fields.findIndex(field => field.property === property);\n    const changedField = this.fields[changedFieldIndex];\n\n    return { changedField, changedFieldIndex };\n  }\n\n  private triggerValidationOnForm(changedFieldIndex: number) {\n    const isValidatableField = this.validateFields?.length\n      ? this.validateFieldsChecker(this.validateFields, this.fields[changedFieldIndex].property)\n      : true;\n    const hasValidationForm = this.validate && isValidatableField && this.formValidate.observers.length;\n\n    if (hasValidationForm) {\n      const updatedField = this.fields[changedFieldIndex];\n      this.formValidate.emit(updatedField);\n    }\n  }\n\n  private updateFields() {\n    this.fieldsChange.emit(this.fields);\n    this.visibleFields = this.getVisibleFields();\n    this.setContainerFields();\n  }\n\n  private validateFieldsChecker(validateFields: Array<string>, propertyField: PoDynamicFormField['property']): boolean {\n    return validateFields.some(validateFieldItem => validateFieldItem === propertyField);\n  }\n\n  private async validateField(field: PoDynamicFormField, fieldIndex: number, visibleField: PoDynamicFormField) {\n    const value = this.value[field.property];\n\n    const previousDisabled = visibleField.disabled;\n    visibleField.disabled = true;\n    this.changes.detectChanges();\n\n    try {\n      const validatedField = await this.validationService.sendFieldChange(field, value).toPromise();\n      this.applyFieldValidation(fieldIndex, validatedField);\n    } catch {\n      visibleField.disabled = previousDisabled;\n    }\n  }\n\n  private hasChangeContainer(previous: Array<PoDynamicFormField>, current: Array<PoDynamicFormField>): void {\n    const prevArray = previous.map((item, index) => ({\n      container: item.container || null,\n      property: item.property,\n      index,\n      order: item.order\n    }));\n\n    const currArray = current.map((item, index) => ({\n      container: item.container || null,\n      property: item.property,\n      index,\n      order: item.order\n    }));\n\n    const prevContainers = prevArray.filter(item => item.container);\n    const currContainers = currArray.filter(item => item.container);\n\n    const prevOrder = prevArray.filter(item => item.order);\n    const currOrder = currArray.filter(item => item.order);\n\n    // Verifica mudança na quantidade de containers\n    if (prevContainers.length !== currContainers.length) {\n      this.setContainerFields();\n      return;\n    }\n\n    // Verifica mudança na quantidade de order\n    if (prevOrder.length !== currOrder.length) {\n      this.setContainerFields();\n      return;\n    }\n\n    if (currContainers.length) {\n      this.handleChangesContainer(prevContainers, currContainers, 'container');\n    }\n\n    if (currOrder.length) {\n      this.handleChangesContainer(prevOrder, currOrder, 'order');\n    }\n\n    //atualiza container sem mudança na estrutura da interface\n    const result = this.diffObjectsArray(previous, this.getVisibleFields());\n    this.containerFields = this.updateFieldContainer(result, this.containerFields);\n  }\n\n  private updateFieldContainer(changes, containerFields) {\n    const mapchanges = new Map(changes.map(obj => [obj.property, obj]));\n\n    containerFields.forEach(subArray => {\n      subArray.forEach((subItem, index) => {\n        const item: any = mapchanges.get(subItem.property);\n        if (item) {\n          subArray[index] = { ...subItem, ...item };\n        }\n      });\n    });\n\n    return containerFields;\n  }\n\n  private diffObjectsArray(oldArray, newArray) {\n    const differences = [];\n\n    newArray.forEach(newObj => {\n      const oldObj = oldArray.find(o => o.property === newObj.property);\n\n      if (!oldObj) {\n        // Se o objeto é novo, adiciona todo o objeto com a propriedade \"property\"\n        differences.push({ ...newObj });\n      } else {\n        // Verificar se há diferenças nas propriedades\n        const diff = { property: newObj.property };\n        let hasDifferences = false;\n\n        for (const key in newObj) {\n          if (newObj[key] !== oldObj[key]) {\n            diff[key] = newObj[key];\n            hasDifferences = true;\n          }\n        }\n\n        if (hasDifferences) {\n          differences.push(diff);\n        }\n      }\n    });\n\n    //retorna mudanças nos fields para atualização do containerFields\n    return differences;\n  }\n\n  private hasContainer() {\n    return this.visibleFields && this.visibleFields.some(field => field.container);\n  }\n\n  private handleChangesContainer(prevContainers, currContainers, key) {\n    for (let i = 0; i < prevContainers.length; i++) {\n      const prev = prevContainers[i];\n      const curr = currContainers[i];\n\n      //Verifica se container mudou de posição\n      if (prev[key] === curr[key] && prev.index !== curr.index) {\n        this.setContainerFields();\n        return;\n      }\n      //Verifica se foi apenas mudança da string em caso do container ou valor no order\n      if (prev[key] !== curr[key] && prev.index === curr.index) {\n        if (key === 'order') {\n          this.setContainerFields();\n          return;\n        }\n        this.containerFields.forEach(subItem =>\n          subItem.forEach(item => {\n            if (item.property === curr.property) {\n              item[key] = curr[key];\n            }\n          })\n        );\n      }\n      //verifica se manteve o mesmo número de container, mas alterou property do container\n      if (prev[key] !== curr[key] && prev.property !== curr.property) {\n        this.setContainerFields();\n        return;\n      }\n    }\n  }\n}\n","<div class=\"po-row\" [class.po-dynamic]=\"hasContainers\" *ngIf=\"visibleFields && visibleFields.length > 0\">\n  <ng-container\n    *ngTemplateOutlet=\"\n      hasContainers ? poContentContainer : poContent;\n      context: { $implicit: hasContainers ? containerFields : visibleFields }\n    \"\n  ></ng-container>\n</div>\n\n<ng-template #poContent let-fields>\n  <ng-container *ngFor=\"let field of fields; trackBy: trackBy\">\n    <po-divider *ngIf=\"field?.divider?.trim()\" class=\"po-sm-12\" [p-label]=\"field.divider\"> </po-divider>\n\n    <po-datepicker\n      #component\n      *ngIf=\"compareTo(field.control, 'datepicker')\"\n      [name]=\"field.property\"\n      [(ngModel)]=\"value[field.property]\"\n      [ngClass]=\"field.componentClass\"\n      [p-clean]=\"field.clean\"\n      [p-disabled]=\"isDisabled(field)\"\n      [p-error-pattern]=\"field.errorMessage\"\n      [p-auto-focus]=\"field.focus\"\n      [p-format]=\"field.format\"\n      [p-help]=\"field.help\"\n      [p-iso-format]=\"field.isoFormat\"\n      [p-label]=\"field.label\"\n      [p-locale]=\"field.locale\"\n      [p-max-date]=\"field.maxValue\"\n      [p-min-date]=\"field.minValue\"\n      [p-no-autocomplete]=\"field.noAutocomplete\"\n      [p-optional]=\"field.optional\"\n      [p-readonly]=\"field.readonly\"\n      [p-required]=\"field.required\"\n      [p-show-required]=\"field.showRequired\"\n      (p-change)=\"onChangeField(field)\"\n      [p-placeholder]=\"field.placeholder\"\n    >\n    </po-datepicker>\n\n    <po-datepicker-range\n      #component\n      *ngIf=\"compareTo(field.control, 'datepickerrange')\"\n      [name]=\"field.property\"\n      [(ngModel)]=\"value[field.property]\"\n      [ngClass]=\"field.componentClass\"\n      [p-clean]=\"field.clean\"\n      [p-disabled]=\"isDisabled(field)\"\n      [p-auto-focus]=\"field.focus\"\n      [p-help]=\"field.help\"\n      [p-label]=\"field.label\"\n      [p-literals]=\"field.literals\"\n      [p-max-date]=\"field.maxValue\"\n      [p-min-date]=\"field.minValue\"\n      [p-no-autocomplete]=\"field.noAutocomplete\"\n      [p-optional]=\"field.optional\"\n      [p-readonly]=\"field.readonly\"\n      [p-required]=\"field.required\"\n      [p-show-required]=\"field.showRequired\"\n      (p-change)=\"onChangeField(field)\"\n    >\n    </po-datepicker-range>\n\n    <po-input\n      #component\n      *ngIf=\"compareTo(field.control, 'input')\"\n      [name]=\"field.property\"\n      [(ngModel)]=\"value[field.property]\"\n      [ngClass]=\"field.componentClass\"\n      [p-clean]=\"field.clean\"\n      [p-disabled]=\"isDisabled(field)\"\n      [p-error-pattern]=\"field.errorMessage\"\n      [p-auto-focus]=\"field.focus\"\n      [p-help]=\"field.help\"\n      [p-label]=\"field.label\"\n      [p-mask-format-model]=\"field.maskFormatModel\"\n      [p-mask]=\"field.mask\"\n      [p-maxlength]=\"field.maxLength\"\n      [p-minlength]=\"field.minLength\"\n      [p-no-autocomplete]=\"field.noAutocomplete\"\n      [p-optional]=\"field.optional\"\n      [p-pattern]=\"field.pattern\"\n      [p-required]=\"field.required\"\n      [p-show-required]=\"field.showRequired\"\n      (p-change)=\"onChangeField(field)\"\n      (p-change-model)=\"onChangeFieldModel(field)\"\n      [p-icon]=\"field.icon\"\n      [p-placeholder]=\"field.placeholder\"\n      [p-readonly]=\"field.readonly\"\n    >\n    </po-input>\n\n    <po-number\n      #component\n      *ngIf=\"compareTo(field.control, 'number')\"\n      [name]=\"field.property\"\n      [(ngModel)]=\"value[field.property]\"\n      [ngClass]=\"field.componentClass\"\n      [p-clean]=\"field.clean\"\n      [p-disabled]=\"isDisabled(field)\"\n      [p-error-pattern]=\"field.errorMessage\"\n      [p-auto-focus]=\"field.focus\"\n      [p-help]=\"field.help\"\n      [p-label]=\"field.label\"\n      [p-min]=\"field.minValue\"\n      [p-max]=\"field.maxValue\"\n      [p-maxlength]=\"field.maxLength\"\n      [p-minlength]=\"field.minLength\"\n      [p-no-autocomplete]=\"field.noAutocomplete\"\n      [p-optional]=\"field.optional\"\n      [p-step]=\"field.step\"\n      [p-readonly]=\"field.readonly\"\n      [p-required]=\"field.required\"\n      [p-show-required]=\"field.showRequired\"\n      (p-change)=\"onChangeField(field)\"\n      (p-change-model)=\"onChangeFieldModel(field)\"\n      [p-icon]=\"field.icon\"\n      [p-placeholder]=\"field.placeholder\"\n    >\n    </po-number>\n\n    <po-decimal\n      #component\n      *ngIf=\"compareTo(field.control, 'decimal')\"\n      [name]=\"field.property\"\n      [(ngModel)]=\"value[field.property]\"\n      [ngClass]=\"field.componentClass\"\n      [p-clean]=\"field.clean\"\n      [p-error-pattern]=\"field.errorMessage\"\n      [p-disabled]=\"isDisabled(field)\"\n      [p-decimals-length]=\"field.decimalsLength\"\n      [p-thousand-maxlength]=\"field.thousandMaxlength\"\n      [p-icon]=\"field.icon\"\n      [p-auto-focus]=\"field.focus\"\n      [p-help]=\"field.help\"\n      [p-label]=\"field.label\"\n      [p-locale]=\"field.locale\"\n      [p-min]=\"field.minValue\"\n      [p-max]=\"field.maxValue\"\n      [p-maxlength]=\"field.maxLength\"\n      [p-minlength]=\"field.minLength\"\n      [p-no-autocomplete]=\"field.noAutocomplete\"\n      [p-optional]=\"field.optional\"\n      [p-readonly]=\"field.readonly\"\n      [p-required]=\"field.required\"\n      [p-show-required]=\"field.showRequired\"\n      (p-change)=\"onChangeField(field)\"\n      (p-change-model)=\"onChangeFieldModel(field)\"\n      [p-placeholder]=\"field.placeholder\"\n    >\n    </po-decimal>\n\n    <po-select\n      #component\n      *ngIf=\"compareTo(field.control, 'select')\"\n      [name]=\"field.property\"\n      [(ngModel)]=\"value[field.property]\"\n      [ngClass]=\"field.componentClass\"\n      [p-field-label]=\"field.fieldLabel\"\n      [p-field-value]=\"field.fieldValue\"\n      [p-disabled]=\"isDisabled(field)\"\n      [p-help]=\"field.help\"\n      [p-label]=\"field.label\"\n      [p-optional]=\"field.optional\"\n      [p-options]=\"field.options\"\n      [p-required]=\"field.required\"\n      [p-show-required]=\"field.showRequired\"\n      (p-change)=\"onChangeField(field)\"\n      [p-placeholder]=\"field.placeholder\"\n      [p-readonly]=\"field.readonly\"\n    >\n    </po-select>\n\n    <po-radio-group\n      #component\n      *ngIf=\"compareTo(field.control, 'radioGroup')\"\n      [name]=\"field.property\"\n      [(ngModel)]=\"value[field.property]\"\n      [ngClass]=\"field.componentClass\"\n      [p-columns]=\"field.columns || 3\"\n      [p-auto-focus]=\"field.focus\"\n      [p-disabled]=\"isDisabled(field)\"\n      [p-help]=\"field.help\"\n      [p-label]=\"field.label\"\n      [p-optional]=\"field.optional\"\n      [p-options]=\"field.options\"\n      [p-required]=\"field.required\"\n      [p-show-required]=\"field.showRequired\"\n      (p-change)=\"onChangeField(field)\"\n    >\n    </po-radio-group>\n\n    <po-switch\n      #component\n      *ngIf=\"compareTo(field.control, 'switch')\"\n      [name]=\"field.property\"\n      [(ngModel)]=\"value[field.property]\"\n      [ngClass]=\"field.componentClass\"\n      [p-disabled]=\"isDisabled(field)\"\n      [p-format-model]=\"field.formatModel\"\n      [p-help]=\"field.help\"\n      [p-label]=\"field.label\"\n      [p-label-off]=\"field.booleanFalse\"\n      [p-label-on]=\"field.booleanTrue\"\n      [p-label-position]=\"field.labelPosition\"\n      [p-hide-label-status]=\"field.hideLabelStatus\"\n      (p-change)=\"onChangeField(field)\"\n    >\n    </po-switch>\n\n    <po-checkbox\n      #component\n      *ngIf=\"compareTo(field.control, 'checkbox')\"\n      [name]=\"field.property\"\n      [(ngModel)]=\"value[field.property]\"\n      [ngClass]=\"field.componentClass\"\n      [p-auto-focus]=\"field.focus\"\n      [p-disabled]=\"isDisabled(field)\"\n      [p-label]=\"field.label\"\n      [p-size]=\"field.size\"\n      (p-change)=\"onChangeField(field)\"\n    >\n    </po-checkbox>\n\n    <po-combo\n      #component\n      *ngIf=\"compareTo(field.control, 'combo')\"\n      [name]=\"field.property\"\n      [(ngModel)]=\"value[field.property]\"\n      [ngClass]=\"field.componentClass\"\n      p-emit-object-value\n      [p-auto-focus]=\"field.focus\"\n      [p-clean]=\"field.clean\"\n      [p-disabled]=\"isDisabled(field)\"\n      [p-field-label]=\"field.fieldLabel\"\n      [p-field-value]=\"field.fieldValue\"\n      [p-filter-params]=\"field.params\"\n      [p-filter-service]=\"field.optionsService\"\n      [p-help]=\"field.help\"\n      [p-infinite-scroll]=\"field.infiniteScroll\"\n      [p-infinite-scroll-distance]=\"field.infiniteScrollDistance || 100\"\n      [p-label]=\"field.label\"\n      [p-literals]=\"field.literals\"\n      [p-options]=\"field.options\"\n      [p-optional]=\"field.optional\"\n      [p-sort]=\"field.sort\"\n      [p-required]=\"field.required\"\n      [p-show-required]=\"field.showRequired\"\n      (p-change)=\"onChangeField(field, $event)\"\n      [p-icon]=\"field.icon\"\n      [p-placeholder]=\"field.placeholder\"\n      [p-filter-minlength]=\"field.filterMinlength\"\n      [p-filter-mode]=\"field.filterMode\"\n      [p-disabled-init-filter]=\"field.disabledInitFilter\"\n      [p-disabled-tab-filter]=\"field.disabledTabFilter\"\n      [p-debounce-time]=\"field.debounceTime\"\n      [p-change-on-enter]=\"field.changeOnEnter\"\n    >\n    </po-combo>\n\n    <po-lookup\n      #component\n      *ngIf=\"compareTo(field.control, 'lookup')\"\n      [name]=\"field.property\"\n      [(ngModel)]=\"value[field.property]\"\n      p-field-label=\"label\"\n      p-field-value=\"value\"\n      [ngClass]=\"field.componentClass\"\n      [p-clean]=\"field.clean\"\n      [p-columns]=\"field.columns\"\n      [p-disabled]=\"isDisabled(field)\"\n      [p-field-label]=\"field.fieldLabel || 'label'\"\n      [p-field-value]=\"field.fieldValue || 'value'\"\n      [p-filter-params]=\"field.params\"\n      [p-filter-service]=\"field.searchService\"\n      [p-auto-focus]=\"field.focus\"\n      [p-auto-height]=\"field.autoHeight\"\n      [p-help]=\"field.help\"\n      [p-field-format]=\"field.format\"\n      [p-infinite-scroll]=\"field.infiniteScroll\"\n      [p-label]=\"field.label\"\n      [p-literals]=\"field.literals\"\n      [p-multiple]=\"field.multiple\"\n      [p-no-autocomplete]=\"field.noAutocomplete\"\n      [p-optional]=\"field.optional\"\n      [p-required]=\"field.required\"\n      [p-show-required]=\"field.showRequired\"\n      (p-change)=\"onChangeField(field)\"\n      [p-placeholder]=\"field.placeholder\"\n      [p-advanced-filters]=\"field.advancedFilters\"\n      (p-change-visible-columns)=\"field.changeVisibleColumns?.($event)\"\n      (p-restore-column-manager)=\"field.columnRestoreManager?.($event)\"\n    >\n    </po-lookup>\n\n    <po-checkbox-group\n      #component\n      *ngIf=\"compareTo(field.control, 'checkboxGroup')\"\n      [name]=\"field.property\"\n      [(ngModel)]=\"value[field.property]\"\n      [ngClass]=\"field.componentClass\"\n      [p-columns]=\"field.columns || 3\"\n      [p-auto-focus]=\"field.focus\"\n      [p-disabled]=\"isDisabled(field)\"\n      [p-help]=\"field.help\"\n      [p-label]=\"field.label\"\n      [p-optional]=\"field.optional\"\n      [p-options]=\"field.options\"\n      [p-required]=\"field.required\"\n      [p-show-required]=\"field.showRequired\"\n      (p-change)=\"onChangeField(field)\"\n    >\n    </po-checkbox-group>\n\n    <po-multiselect\n      #component\n      *ngIf=\"compareTo(field.control, 'multiselect')\"\n      [name]=\"field.property\"\n      [(ngModel)]=\"value[field.property]\"\n      [ngClass]=\"field.componentClass\"\n      [p-disabled]=\"isDisabled(field)\"\n      [p-auto-focus]=\"field.focus\"\n      [p-auto-height]=\"field.autoHeight\"\n      [p-help]=\"field.help\"\n      [p-label]=\"field.label\"\n      [p-literals]=\"field.literals\"\n      [p-optional]=\"field.optional\"\n      [p-options]=\"field.options\"\n      [p-required]=\"field.required\"\n      [p-show-required]=\"field.showRequired\"\n      (p-change)=\"onChangeField(field)\"\n      [p-placeholder]=\"field.placeholder\"\n      [p-field-label]=\"field.fieldLabel\"\n      [p-field-value]=\"field.fieldValue\"\n      [p-filter-service]=\"field.optionsService\"\n      [p-filter-mode]=\"field.filterMode\"\n      [p-debounce-time]=\"field.debounceTime\"\n      [p-sort]=\"field.sort\"\n      [p-placeholder-search]=\"field.placeholderSearch\"\n      [p-hide-search]=\"field.hideSearch\"\n      [p-hide-select-all]=\"field.hideSelectAll\"\n    >\n    </po-multiselect>\n\n    <po-textarea\n      #component\n      *ngIf=\"compareTo(field.control, 'textarea')\"\n      [name]=\"field.property\"\n      [(ngModel)]=\"value[field.property]\"\n      [ngClass]=\"field.componentClass\"\n      [p-disabled]=\"isDisabled(field)\"\n      [p-auto-focus]=\"field.focus\"\n      [p-help]=\"field.help\"\n      [p-label]=\"field.label\"\n      [p-maxlength]=\"field.maxLength\"\n      [p-minlength]=\"field.minLength\"\n      [p-optional]=\"field.optional\"\n      [p-readonly]=\"field.readonly\"\n      [p-required]=\"field.required\"\n      [p-show-required]=\"field.showRequired\"\n      [p-rows]=\"field.rows\"\n      (p-change)=\"onChangeField(field)\"\n      (p-change-model)=\"onChangeFieldModel(field)\"\n      [p-placeholder]=\"field.placeholder\"\n    >\n    </po-textarea>\n\n    <po-password\n      #component\n      *ngIf=\"compareTo(field.control, 'password')\"\n      [name]=\"field.property\"\n      [(ngModel)]=\"value[field.property]\"\n      [ngClass]=\"field.componentClass\"\n      [p-clean]=\"field.clean\"\n      [p-disabled]=\"isDisabled(field)\"\n      [p-error-pattern]=\"field.errorMessage\"\n      [p-auto-focus]=\"field.focus\"\n      [p-help]=\"field.help\"\n      [p-hide-password-peek]=\"field.hidePasswordPeek\"\n      [p-icon]=\"field.icon\"\n      [p-label]=\"field.label\"\n      [p-maxlength]=\"field.maxLength\"\n      [p-minlength]=\"field.minLength\"\n      [p-no-autocomplete]=\"field.noAutocomplete\"\n      [p-optional]=\"field.optional\"\n      [p-pattern]=\"field.pattern\"\n      [p-readonly]=\"field.readonly\"\n      [p-required]=\"field.required\"\n      [p-show-required]=\"field.showRequired\"\n      (p-change)=\"onChangeField(field)\"\n      (p-change-model)=\"onChangeFieldModel(field)\"\n      [p-placeholder]=\"field.placeholder\"\n    >\n    </po-password>\n\n    <po-upload\n      #component\n      *ngIf=\"compareTo(field.control, 'upload')\"\n      [(ngModel)]=\"value[field.property]\"\n      [ngClass]=\"field.componentClass\"\n      [p-auto-upload]=\"field.autoUpload\"\n      [p-directory]=\"field.directory\"\n      [p-disabled]=\"isDisabled(field)\"\n      [p-drag-drop]=\"field.dragDrop\"\n      [p-drag-drop-height]=\"field.dragDropHeight\"\n      [p-restrictions]=\"field.restrictions\"\n      [p-form-field]=\"field.formField\"\n      [p-headers]=\"field.headers\"\n      [p-help]=\"field.help\"\n      [p-hide-restrictions-info]=\"field.hideRestrictionsInfo\"\n      [p-hide-select-button]=\"field.hideSelectButton\"\n      [p-hide-send-button]=\"field.hideSendButton\"\n      [p-multiple]=\"field.multiple\"\n      [p-label]=\"field.label\"\n      [p-literals]=\"field.literals\"\n      [name]=\"field.property\"\n      (p-error)=\"field.onError($event)\"\n      (p-success)=\"field.onSuccess($event)\"\n      (p-upload)=\"field.onUpload($event)\"\n      [p-optional]=\"field.optional\"\n      [p-required]=\"field.required\"\n      [p-show-required]=\"field.showRequired\"\n      (p-change)=\"onChangeField(field)\"\n      (p-change-model)=\"onChangeFieldModel(field)\"\n      [p-url]=\"field.url\"\n    >\n    </po-upload>\n  </ng-container>\n</ng-template>\n\n<ng-template #poContentContainer let-fields>\n  <po-dynamic-container [p-fields]=\"fields\" [p-content]=\"poContent\"></po-dynamic-container>\n</ng-template>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-dynamic-form-fields.component.js","sourceRoot":"","sources":["../../../../../../../../projects/ui/src/lib/components/po-dynamic/po-dynamic-form/po-dynamic-form-fields/po-dynamic-form-fields.component.ts","../../../../../../../../projects/ui/src/lib/components/po-dynamic/po-dynamic-form/po-dynamic-form-fields/po-dynamic-form-fields.component.html"],"names":[],"mappings":"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","sourcesContent":["import { TitleCasePipe } from '@angular/common';\nimport { ChangeDetectorRef, Component, OnChanges, QueryList, SimpleChanges, ViewChildren } from '@angular/core';\nimport { ControlContainer, NgForm } from '@angular/forms';\n\nimport { PoDynamicFormField } from '../po-dynamic-form-field.interface';\nimport { PoDynamicFormFieldValidation } from '../po-dynamic-form-validation/po-dynamic-form-field-validation.interface';\nimport { PoDynamicFormValidationService } from '../po-dynamic-form-validation/po-dynamic-form-validation.service';\nimport { PoDynamicFormFieldsBaseComponent } from './po-dynamic-form-fields-base.component';\n\n/**\n * @docsPrivate\n *\n * @description\n *\n * Componente de criação dos campos dinâmicos.\n */\n@Component({\n  selector: 'po-dynamic-form-fields',\n  templateUrl: 'po-dynamic-form-fields.component.html',\n  viewProviders: [{ provide: ControlContainer, useExisting: NgForm }],\n  providers: [PoDynamicFormValidationService]\n})\nexport class PoDynamicFormFieldsComponent extends PoDynamicFormFieldsBaseComponent implements OnChanges {\n  @ViewChildren('component') components: QueryList<{ name: string; focus: () => void }>;\n\n  private previousValue = {};\n\n  constructor(\n    titleCasePipe: TitleCasePipe,\n    private validationService: PoDynamicFormValidationService,\n    private changes: ChangeDetectorRef,\n    private form: NgForm\n  ) {\n    super(titleCasePipe);\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    if (changes.fields) {\n      this.visibleFields = this.getVisibleFields();\n\n      if (changes.fields.previousValue && this.hasContainer()) {\n        this.hasChangeContainer(changes.fields.previousValue, changes.fields.currentValue);\n      }\n\n      if (!changes.fields.previousValue || !changes.fields.currentValue) {\n        this.setContainerFields();\n      }\n    }\n  }\n\n  focus(property: string) {\n    const foundComponent = this.components.find(component => component.name === property);\n    if (foundComponent) {\n      foundComponent.focus();\n    }\n  }\n\n  isDisabled(field: PoDynamicFormField): boolean {\n    return field.disabled || this.disabledForm;\n  }\n\n  async onChangeField(visibleField: PoDynamicFormField, objectValue?: any) {\n    const { property } = visibleField;\n    const isBooleanType = visibleField.type === 'boolean';\n    const isChangedValueField = this.previousValue[property] !== this.value[property];\n\n    if (visibleField.optionsService) {\n      this.objectValue.emit(objectValue);\n    }\n\n    // verifica se o formulario esta touched para não disparar o validate ao carregar a tela.\n    if ((this.form.touched || isBooleanType) && isChangedValueField) {\n      const { changedField, changedFieldIndex } = this.getField(property);\n\n      if (changedField.validate) {\n        await this.validateField(changedField, changedFieldIndex, visibleField);\n      }\n\n      this.triggerValidationOnForm(changedFieldIndex);\n    }\n\n    this.updatePreviousValue();\n  }\n\n  //emite o valor a cada caractere digitado no input\n  onChangeFieldModel(visibleField: PoDynamicFormField) {\n    if (this.validateOnInput) {\n      const { property } = visibleField;\n      const { changedFieldIndex } = this.getField(property);\n      this.triggerValidationOnForm(changedFieldIndex);\n    }\n  }\n\n  updatePreviousValue() {\n    this.previousValue = JSON.parse(JSON.stringify(this.value));\n  }\n\n  trackBy(index) {\n    return index;\n  }\n\n  private applyFieldValidation(index: number, validatedField: PoDynamicFormFieldValidation) {\n    const field = this.fields[index];\n\n    this.fields[index] = { ...field, ...validatedField.field };\n    this.updateFields();\n\n    if (validatedField.hasOwnProperty('value')) {\n      this.value[field.property] = validatedField.value;\n    }\n\n    this.changes.detectChanges();\n\n    if (validatedField.focus) {\n      this.focus(field.property);\n    }\n  }\n\n  private getField(property: string) {\n    const changedFieldIndex = this.fields.findIndex(field => field.property === property);\n    const changedField = this.fields[changedFieldIndex];\n\n    return { changedField, changedFieldIndex };\n  }\n\n  private triggerValidationOnForm(changedFieldIndex: number) {\n    const isValidatableField = this.validateFields?.length\n      ? this.validateFieldsChecker(this.validateFields, this.fields[changedFieldIndex].property)\n      : true;\n    const hasValidationForm = this.validate && isValidatableField && this.formValidate.observers.length;\n\n    if (hasValidationForm) {\n      const updatedField = this.fields[changedFieldIndex];\n      this.formValidate.emit(updatedField);\n    }\n  }\n\n  private updateFields() {\n    this.fieldsChange.emit(this.fields);\n    this.visibleFields = this.getVisibleFields();\n    this.setContainerFields();\n  }\n\n  private validateFieldsChecker(validateFields: Array<string>, propertyField: PoDynamicFormField['property']): boolean {\n    return validateFields.some(validateFieldItem => validateFieldItem === propertyField);\n  }\n\n  private async validateField(field: PoDynamicFormField, fieldIndex: number, visibleField: PoDynamicFormField) {\n    const value = this.value[field.property];\n\n    const previousDisabled = visibleField.disabled;\n    visibleField.disabled = true;\n    this.changes.detectChanges();\n\n    try {\n      const validatedField = await this.validationService.sendFieldChange(field, value).toPromise();\n      this.applyFieldValidation(fieldIndex, validatedField);\n    } catch {\n      visibleField.disabled = previousDisabled;\n    }\n  }\n\n  private hasChangeContainer(previous: Array<PoDynamicFormField>, current: Array<PoDynamicFormField>): void {\n    const prevArray = previous.map((item, index) => ({\n      container: item.container || null,\n      property: item.property,\n      index,\n      order: item.order,\n      visible: item.visible ?? true\n    }));\n\n    const currArray = current.map((item, index) => ({\n      container: item.container || null,\n      property: item.property,\n      index,\n      order: item.order,\n      visible: item.visible ?? true\n    }));\n\n    const prevContainers = prevArray.filter(item => item.container);\n    const currContainers = currArray.filter(item => item.container);\n\n    const prevOrder = prevArray.filter(item => item.order);\n    const currOrder = currArray.filter(item => item.order);\n\n    const prevVisibleTrue = prevArray.filter(item => item.visible === true);\n    const currVisibleTrue = currArray.filter(item => item.visible === true);\n\n    const prevVisibleFalse = prevArray.filter(item => !item.visible);\n    const currVisibleFalse = currArray.filter(item => !item.visible);\n\n    // Verifica mudança na quantidade de containers\n    if (prevContainers.length !== currContainers.length) {\n      this.setContainerFields();\n      return;\n    }\n\n    // Verifica mudança na quantidade de order\n    if (prevOrder.length !== currOrder.length) {\n      this.setContainerFields();\n      return;\n    }\n\n    // Verifica mudança na quantidade de visible\n    if (prevVisibleTrue.length !== currVisibleTrue.length) {\n      this.setContainerFields();\n      return;\n    }\n\n    // Verifica mudança na quantidade de visible\n    if (prevVisibleFalse.length !== currVisibleFalse.length) {\n      this.setContainerFields();\n      return;\n    }\n\n    if (currContainers.length) {\n      this.handleChangesContainer(prevContainers, currContainers, 'container');\n    }\n\n    if (currOrder.length) {\n      this.handleChangesContainer(prevOrder, currOrder, 'order');\n    }\n\n    if (currVisibleTrue.length) {\n      this.handleChangesContainer(prevVisibleTrue, currVisibleTrue, 'visible');\n    }\n\n    if (currVisibleFalse.length) {\n      this.handleChangesContainer(prevVisibleFalse, currVisibleFalse, 'visible');\n    }\n\n    //atualiza container sem mudança na estrutura da interface\n    const result = this.diffObjectsArray(previous, this.getVisibleFields());\n    this.containerFields = this.updateFieldContainer(result, this.containerFields);\n  }\n\n  private updateFieldContainer(changes, containerFields) {\n    const mapchanges = new Map(changes.map(obj => [obj.property, obj]));\n\n    containerFields.forEach(subArray => {\n      subArray.forEach((subItem, index) => {\n        const item: any = mapchanges.get(subItem.property);\n        if (item) {\n          subArray[index] = { ...subItem, ...item };\n        }\n      });\n    });\n\n    return containerFields;\n  }\n\n  private diffObjectsArray(oldArray, newArray) {\n    const differences = [];\n\n    newArray.forEach(newObj => {\n      const oldObj = oldArray.find(o => o.property === newObj.property);\n\n      if (!oldObj) {\n        // Se o objeto é novo, adiciona todo o objeto com a propriedade \"property\"\n        differences.push({ ...newObj });\n      } else {\n        // Verificar se há diferenças nas propriedades\n        const diff = { property: newObj.property };\n        let hasDifferences = false;\n\n        for (const key in newObj) {\n          if (newObj[key] !== oldObj[key]) {\n            diff[key] = newObj[key];\n            hasDifferences = true;\n          }\n        }\n\n        if (hasDifferences) {\n          differences.push(diff);\n        }\n      }\n    });\n\n    //retorna mudanças nos fields para atualização do containerFields\n    return differences;\n  }\n\n  private hasContainer() {\n    return this.visibleFields && this.visibleFields.some(field => field.container);\n  }\n\n  private handleChangesContainer(prevContainers, currContainers, key) {\n    for (let i = 0; i < prevContainers.length; i++) {\n      const prev = prevContainers[i];\n      const curr = currContainers[i];\n\n      //Verifica se container mudou de posição\n      if (prev[key] === curr[key] && prev.index !== curr.index) {\n        this.setContainerFields();\n        return;\n      }\n      //Verifica se foi apenas mudança da string em caso do container ou valor no order\n      if (prev[key] !== curr[key] && prev.index === curr.index) {\n        if (key === 'order') {\n          this.setContainerFields();\n          return;\n        }\n        this.containerFields.forEach(subItem =>\n          subItem.forEach(item => {\n            if (item.property === curr.property) {\n              item[key] = curr[key];\n            }\n          })\n        );\n      }\n      //verifica se manteve o mesmo número de container, mas alterou property do container\n      if (prev[key] !== curr[key] && prev.property !== curr.property) {\n        this.setContainerFields();\n        return;\n      }\n    }\n  }\n}\n","<div class=\"po-row\" [class.po-dynamic]=\"hasContainers\" *ngIf=\"visibleFields && visibleFields.length > 0\">\n  <ng-container\n    *ngTemplateOutlet=\"\n      hasContainers ? poContentContainer : poContent;\n      context: { $implicit: hasContainers ? containerFields : visibleFields }\n    \"\n  ></ng-container>\n</div>\n\n<ng-template #poContent let-fields>\n  <ng-container *ngFor=\"let field of fields; trackBy: trackBy\">\n    <po-divider *ngIf=\"field?.divider?.trim()\" class=\"po-sm-12\" [p-label]=\"field.divider\"> </po-divider>\n\n    <po-datepicker\n      #component\n      *ngIf=\"compareTo(field.control, 'datepicker')\"\n      [name]=\"field.property\"\n      [(ngModel)]=\"value[field.property]\"\n      [ngClass]=\"field.componentClass\"\n      [p-clean]=\"field.clean\"\n      [p-disabled]=\"isDisabled(field)\"\n      [p-error-pattern]=\"field.errorMessage\"\n      [p-auto-focus]=\"field.focus\"\n      [p-format]=\"field.format\"\n      [p-help]=\"field.help\"\n      [p-iso-format]=\"field.isoFormat\"\n      [p-label]=\"field.label\"\n      [p-locale]=\"field.locale\"\n      [p-max-date]=\"field.maxValue\"\n      [p-min-date]=\"field.minValue\"\n      [p-no-autocomplete]=\"field.noAutocomplete\"\n      [p-optional]=\"field.optional\"\n      [p-readonly]=\"field.readonly\"\n      [p-required]=\"field.required\"\n      [p-show-required]=\"field.showRequired\"\n      (p-change)=\"onChangeField(field)\"\n      [p-placeholder]=\"field.placeholder\"\n    >\n    </po-datepicker>\n\n    <po-datepicker-range\n      #component\n      *ngIf=\"compareTo(field.control, 'datepickerrange')\"\n      [name]=\"field.property\"\n      [(ngModel)]=\"value[field.property]\"\n      [ngClass]=\"field.componentClass\"\n      [p-clean]=\"field.clean\"\n      [p-disabled]=\"isDisabled(field)\"\n      [p-auto-focus]=\"field.focus\"\n      [p-help]=\"field.help\"\n      [p-label]=\"field.label\"\n      [p-literals]=\"field.literals\"\n      [p-max-date]=\"field.maxValue\"\n      [p-min-date]=\"field.minValue\"\n      [p-no-autocomplete]=\"field.noAutocomplete\"\n      [p-optional]=\"field.optional\"\n      [p-readonly]=\"field.readonly\"\n      [p-required]=\"field.required\"\n      [p-show-required]=\"field.showRequired\"\n      (p-change)=\"onChangeField(field)\"\n    >\n    </po-datepicker-range>\n\n    <po-input\n      #component\n      *ngIf=\"compareTo(field.control, 'input')\"\n      [name]=\"field.property\"\n      [(ngModel)]=\"value[field.property]\"\n      [ngClass]=\"field.componentClass\"\n      [p-clean]=\"field.clean\"\n      [p-disabled]=\"isDisabled(field)\"\n      [p-error-pattern]=\"field.errorMessage\"\n      [p-auto-focus]=\"field.focus\"\n      [p-help]=\"field.help\"\n      [p-label]=\"field.label\"\n      [p-mask-format-model]=\"field.maskFormatModel\"\n      [p-mask]=\"field.mask\"\n      [p-maxlength]=\"field.maxLength\"\n      [p-minlength]=\"field.minLength\"\n      [p-no-autocomplete]=\"field.noAutocomplete\"\n      [p-optional]=\"field.optional\"\n      [p-pattern]=\"field.pattern\"\n      [p-required]=\"field.required\"\n      [p-show-required]=\"field.showRequired\"\n      (p-change)=\"onChangeField(field)\"\n      (p-change-model)=\"onChangeFieldModel(field)\"\n      [p-icon]=\"field.icon\"\n      [p-placeholder]=\"field.placeholder\"\n      [p-readonly]=\"field.readonly\"\n    >\n    </po-input>\n\n    <po-number\n      #component\n      *ngIf=\"compareTo(field.control, 'number')\"\n      [name]=\"field.property\"\n      [(ngModel)]=\"value[field.property]\"\n      [ngClass]=\"field.componentClass\"\n      [p-clean]=\"field.clean\"\n      [p-disabled]=\"isDisabled(field)\"\n      [p-error-pattern]=\"field.errorMessage\"\n      [p-auto-focus]=\"field.focus\"\n      [p-help]=\"field.help\"\n      [p-label]=\"field.label\"\n      [p-min]=\"field.minValue\"\n      [p-max]=\"field.maxValue\"\n      [p-maxlength]=\"field.maxLength\"\n      [p-minlength]=\"field.minLength\"\n      [p-no-autocomplete]=\"field.noAutocomplete\"\n      [p-optional]=\"field.optional\"\n      [p-step]=\"field.step\"\n      [p-readonly]=\"field.readonly\"\n      [p-required]=\"field.required\"\n      [p-show-required]=\"field.showRequired\"\n      (p-change)=\"onChangeField(field)\"\n      (p-change-model)=\"onChangeFieldModel(field)\"\n      [p-icon]=\"field.icon\"\n      [p-placeholder]=\"field.placeholder\"\n    >\n    </po-number>\n\n    <po-decimal\n      #component\n      *ngIf=\"compareTo(field.control, 'decimal')\"\n      [name]=\"field.property\"\n      [(ngModel)]=\"value[field.property]\"\n      [ngClass]=\"field.componentClass\"\n      [p-clean]=\"field.clean\"\n      [p-error-pattern]=\"field.errorMessage\"\n      [p-disabled]=\"isDisabled(field)\"\n      [p-decimals-length]=\"field.decimalsLength\"\n      [p-thousand-maxlength]=\"field.thousandMaxlength\"\n      [p-icon]=\"field.icon\"\n      [p-auto-focus]=\"field.focus\"\n      [p-help]=\"field.help\"\n      [p-label]=\"field.label\"\n      [p-locale]=\"field.locale\"\n      [p-min]=\"field.minValue\"\n      [p-max]=\"field.maxValue\"\n      [p-maxlength]=\"field.maxLength\"\n      [p-minlength]=\"field.minLength\"\n      [p-no-autocomplete]=\"field.noAutocomplete\"\n      [p-optional]=\"field.optional\"\n      [p-readonly]=\"field.readonly\"\n      [p-required]=\"field.required\"\n      [p-show-required]=\"field.showRequired\"\n      (p-change)=\"onChangeField(field)\"\n      (p-change-model)=\"onChangeFieldModel(field)\"\n      [p-placeholder]=\"field.placeholder\"\n    >\n    </po-decimal>\n\n    <po-select\n      #component\n      *ngIf=\"compareTo(field.control, 'select')\"\n      [name]=\"field.property\"\n      [(ngModel)]=\"value[field.property]\"\n      [ngClass]=\"field.componentClass\"\n      [p-field-label]=\"field.fieldLabel\"\n      [p-field-value]=\"field.fieldValue\"\n      [p-disabled]=\"isDisabled(field)\"\n      [p-help]=\"field.help\"\n      [p-label]=\"field.label\"\n      [p-optional]=\"field.optional\"\n      [p-options]=\"field.options\"\n      [p-required]=\"field.required\"\n      [p-show-required]=\"field.showRequired\"\n      (p-change)=\"onChangeField(field)\"\n      [p-placeholder]=\"field.placeholder\"\n      [p-readonly]=\"field.readonly\"\n    >\n    </po-select>\n\n    <po-radio-group\n      #component\n      *ngIf=\"compareTo(field.control, 'radioGroup')\"\n      [name]=\"field.property\"\n      [(ngModel)]=\"value[field.property]\"\n      [ngClass]=\"field.componentClass\"\n      [p-columns]=\"field.columns || 3\"\n      [p-auto-focus]=\"field.focus\"\n      [p-disabled]=\"isDisabled(field)\"\n      [p-help]=\"field.help\"\n      [p-label]=\"field.label\"\n      [p-optional]=\"field.optional\"\n      [p-options]=\"field.options\"\n      [p-required]=\"field.required\"\n      [p-show-required]=\"field.showRequired\"\n      (p-change)=\"onChangeField(field)\"\n    >\n    </po-radio-group>\n\n    <po-switch\n      #component\n      *ngIf=\"compareTo(field.control, 'switch')\"\n      [name]=\"field.property\"\n      [(ngModel)]=\"value[field.property]\"\n      [ngClass]=\"field.componentClass\"\n      [p-disabled]=\"isDisabled(field)\"\n      [p-format-model]=\"field.formatModel\"\n      [p-help]=\"field.help\"\n      [p-label]=\"field.label\"\n      [p-label-off]=\"field.booleanFalse\"\n      [p-label-on]=\"field.booleanTrue\"\n      [p-label-position]=\"field.labelPosition\"\n      [p-hide-label-status]=\"field.hideLabelStatus\"\n      (p-change)=\"onChangeField(field)\"\n    >\n    </po-switch>\n\n    <po-checkbox\n      #component\n      *ngIf=\"compareTo(field.control, 'checkbox')\"\n      [name]=\"field.property\"\n      [(ngModel)]=\"value[field.property]\"\n      [ngClass]=\"field.componentClass\"\n      [p-auto-focus]=\"field.focus\"\n      [p-disabled]=\"isDisabled(field)\"\n      [p-label]=\"field.label\"\n      [p-size]=\"field.size\"\n      (p-change)=\"onChangeField(field)\"\n    >\n    </po-checkbox>\n\n    <po-combo\n      #component\n      *ngIf=\"compareTo(field.control, 'combo')\"\n      [name]=\"field.property\"\n      [(ngModel)]=\"value[field.property]\"\n      [ngClass]=\"field.componentClass\"\n      p-emit-object-value\n      [p-auto-focus]=\"field.focus\"\n      [p-clean]=\"field.clean\"\n      [p-disabled]=\"isDisabled(field)\"\n      [p-field-label]=\"field.fieldLabel\"\n      [p-field-value]=\"field.fieldValue\"\n      [p-filter-params]=\"field.params\"\n      [p-filter-service]=\"field.optionsService\"\n      [p-help]=\"field.help\"\n      [p-infinite-scroll]=\"field.infiniteScroll\"\n      [p-infinite-scroll-distance]=\"field.infiniteScrollDistance || 100\"\n      [p-label]=\"field.label\"\n      [p-literals]=\"field.literals\"\n      [p-options]=\"field.options\"\n      [p-optional]=\"field.optional\"\n      [p-sort]=\"field.sort\"\n      [p-required]=\"field.required\"\n      [p-show-required]=\"field.showRequired\"\n      (p-change)=\"onChangeField(field, $event)\"\n      [p-icon]=\"field.icon\"\n      [p-placeholder]=\"field.placeholder\"\n      [p-filter-minlength]=\"field.filterMinlength\"\n      [p-filter-mode]=\"field.filterMode\"\n      [p-disabled-init-filter]=\"field.disabledInitFilter\"\n      [p-disabled-tab-filter]=\"field.disabledTabFilter\"\n      [p-debounce-time]=\"field.debounceTime\"\n      [p-change-on-enter]=\"field.changeOnEnter\"\n    >\n    </po-combo>\n\n    <po-lookup\n      #component\n      *ngIf=\"compareTo(field.control, 'lookup')\"\n      [name]=\"field.property\"\n      [(ngModel)]=\"value[field.property]\"\n      p-field-label=\"label\"\n      p-field-value=\"value\"\n      [ngClass]=\"field.componentClass\"\n      [p-clean]=\"field.clean\"\n      [p-columns]=\"field.columns\"\n      [p-disabled]=\"isDisabled(field)\"\n      [p-field-label]=\"field.fieldLabel || 'label'\"\n      [p-field-value]=\"field.fieldValue || 'value'\"\n      [p-filter-params]=\"field.params\"\n      [p-filter-service]=\"field.searchService\"\n      [p-auto-focus]=\"field.focus\"\n      [p-auto-height]=\"field.autoHeight\"\n      [p-help]=\"field.help\"\n      [p-field-format]=\"field.format\"\n      [p-infinite-scroll]=\"field.infiniteScroll\"\n      [p-label]=\"field.label\"\n      [p-literals]=\"field.literals\"\n      [p-multiple]=\"field.multiple\"\n      [p-no-autocomplete]=\"field.noAutocomplete\"\n      [p-optional]=\"field.optional\"\n      [p-required]=\"field.required\"\n      [p-show-required]=\"field.showRequired\"\n      (p-change)=\"onChangeField(field)\"\n      [p-placeholder]=\"field.placeholder\"\n      [p-advanced-filters]=\"field.advancedFilters\"\n      (p-change-visible-columns)=\"field.changeVisibleColumns?.($event)\"\n      (p-restore-column-manager)=\"field.columnRestoreManager?.($event)\"\n    >\n    </po-lookup>\n\n    <po-checkbox-group\n      #component\n      *ngIf=\"compareTo(field.control, 'checkboxGroup')\"\n      [name]=\"field.property\"\n      [(ngModel)]=\"value[field.property]\"\n      [ngClass]=\"field.componentClass\"\n      [p-columns]=\"field.columns || 3\"\n      [p-auto-focus]=\"field.focus\"\n      [p-disabled]=\"isDisabled(field)\"\n      [p-help]=\"field.help\"\n      [p-label]=\"field.label\"\n      [p-optional]=\"field.optional\"\n      [p-options]=\"field.options\"\n      [p-required]=\"field.required\"\n      [p-show-required]=\"field.showRequired\"\n      (p-change)=\"onChangeField(field)\"\n    >\n    </po-checkbox-group>\n\n    <po-multiselect\n      #component\n      *ngIf=\"compareTo(field.control, 'multiselect')\"\n      [name]=\"field.property\"\n      [(ngModel)]=\"value[field.property]\"\n      [ngClass]=\"field.componentClass\"\n      [p-disabled]=\"isDisabled(field)\"\n      [p-auto-focus]=\"field.focus\"\n      [p-auto-height]=\"field.autoHeight\"\n      [p-help]=\"field.help\"\n      [p-label]=\"field.label\"\n      [p-literals]=\"field.literals\"\n      [p-optional]=\"field.optional\"\n      [p-options]=\"field.options\"\n      [p-required]=\"field.required\"\n      [p-show-required]=\"field.showRequired\"\n      (p-change)=\"onChangeField(field)\"\n      [p-placeholder]=\"field.placeholder\"\n      [p-field-label]=\"field.fieldLabel\"\n      [p-field-value]=\"field.fieldValue\"\n      [p-filter-service]=\"field.optionsService\"\n      [p-filter-mode]=\"field.filterMode\"\n      [p-debounce-time]=\"field.debounceTime\"\n      [p-sort]=\"field.sort\"\n      [p-placeholder-search]=\"field.placeholderSearch\"\n      [p-hide-search]=\"field.hideSearch\"\n      [p-hide-select-all]=\"field.hideSelectAll\"\n    >\n    </po-multiselect>\n\n    <po-textarea\n      #component\n      *ngIf=\"compareTo(field.control, 'textarea')\"\n      [name]=\"field.property\"\n      [(ngModel)]=\"value[field.property]\"\n      [ngClass]=\"field.componentClass\"\n      [p-disabled]=\"isDisabled(field)\"\n      [p-auto-focus]=\"field.focus\"\n      [p-help]=\"field.help\"\n      [p-label]=\"field.label\"\n      [p-maxlength]=\"field.maxLength\"\n      [p-minlength]=\"field.minLength\"\n      [p-optional]=\"field.optional\"\n      [p-readonly]=\"field.readonly\"\n      [p-required]=\"field.required\"\n      [p-show-required]=\"field.showRequired\"\n      [p-rows]=\"field.rows\"\n      (p-change)=\"onChangeField(field)\"\n      (p-change-model)=\"onChangeFieldModel(field)\"\n      [p-placeholder]=\"field.placeholder\"\n    >\n    </po-textarea>\n\n    <po-password\n      #component\n      *ngIf=\"compareTo(field.control, 'password')\"\n      [name]=\"field.property\"\n      [(ngModel)]=\"value[field.property]\"\n      [ngClass]=\"field.componentClass\"\n      [p-clean]=\"field.clean\"\n      [p-disabled]=\"isDisabled(field)\"\n      [p-error-pattern]=\"field.errorMessage\"\n      [p-auto-focus]=\"field.focus\"\n      [p-help]=\"field.help\"\n      [p-hide-password-peek]=\"field.hidePasswordPeek\"\n      [p-icon]=\"field.icon\"\n      [p-label]=\"field.label\"\n      [p-maxlength]=\"field.maxLength\"\n      [p-minlength]=\"field.minLength\"\n      [p-no-autocomplete]=\"field.noAutocomplete\"\n      [p-optional]=\"field.optional\"\n      [p-pattern]=\"field.pattern\"\n      [p-readonly]=\"field.readonly\"\n      [p-required]=\"field.required\"\n      [p-show-required]=\"field.showRequired\"\n      (p-change)=\"onChangeField(field)\"\n      (p-change-model)=\"onChangeFieldModel(field)\"\n      [p-placeholder]=\"field.placeholder\"\n    >\n    </po-password>\n\n    <po-upload\n      #component\n      *ngIf=\"compareTo(field.control, 'upload')\"\n      [(ngModel)]=\"value[field.property]\"\n      [ngClass]=\"field.componentClass\"\n      [p-auto-upload]=\"field.autoUpload\"\n      [p-directory]=\"field.directory\"\n      [p-disabled]=\"isDisabled(field)\"\n      [p-drag-drop]=\"field.dragDrop\"\n      [p-drag-drop-height]=\"field.dragDropHeight\"\n      [p-restrictions]=\"field.restrictions\"\n      [p-form-field]=\"field.formField\"\n      [p-headers]=\"field.headers\"\n      [p-help]=\"field.help\"\n      [p-hide-restrictions-info]=\"field.hideRestrictionsInfo\"\n      [p-hide-select-button]=\"field.hideSelectButton\"\n      [p-hide-send-button]=\"field.hideSendButton\"\n      [p-multiple]=\"field.multiple\"\n      [p-label]=\"field.label\"\n      [p-literals]=\"field.literals\"\n      [name]=\"field.property\"\n      (p-error)=\"field.onError($event)\"\n      (p-success)=\"field.onSuccess($event)\"\n      (p-upload)=\"field.onUpload($event)\"\n      [p-optional]=\"field.optional\"\n      [p-required]=\"field.required\"\n      [p-show-required]=\"field.showRequired\"\n      (p-change)=\"onChangeField(field)\"\n      (p-change-model)=\"onChangeFieldModel(field)\"\n      [p-url]=\"field.url\"\n    >\n    </po-upload>\n  </ng-container>\n</ng-template>\n\n<ng-template #poContentContainer let-fields>\n  <po-dynamic-container [p-fields]=\"fields\" [p-content]=\"poContent\"></po-dynamic-container>\n</ng-template>\n"]}

package/esm2022/lib/components/po-dynamic/po-dynamic-view/po-dynamic-view.component.mjs

@@ -135,8 +135,14 @@ export class PoDynamicViewComponent extends PoDynamicViewBaseComponent {
     }
     setFieldValue(field) {
         if (field.options) {
-            const selectedOption = field.options.find(option => option.value === field.value);
-            return selectedOption ? selectedOption.label : field.value;
+            if (field.optionsMulti) {
+                const selectedOptions = field.options.filter(option => Array.isArray(field.value) && field.value.some(value => value === option.value));
+                return selectedOptions.length ? selectedOptions.map(option => option.label) : field.value;
+            }
+            else {
+                const selectedOption = field.options.find(option => option.value === field.value);
+                return selectedOption ? selectedOption.label : field.value;
+            }
         }
         else if (field.type === 'boolean' && 'booleanTrue' in field && 'booleanFalse' in field) {
             return field.value ? field.booleanTrue : field.booleanFalse;
@@ -202,4 +208,4 @@ export class PoDynamicViewComponent extends PoDynamicViewBaseComponent {
         args: [{ selector: 'po-dynamic-view', template: "<div class=\"po-row\" [class.po-dynamic]=\"hasContainers\" *ngIf=\"visibleFields.length\">\n  <ng-container\n    *ngTemplateOutlet=\"\n      hasContainers ? poContentContainer : poContent;\n      context: { $implicit: hasContainers ? containerFields : visibleFields }\n    \"\n  ></ng-container>\n</div>\n\n<ng-template #poContent let-fields>\n  <ng-template ngFor let-field [ngForOf]=\"fields\">\n    <po-divider *ngIf=\"field?.divider?.trim()\" class=\"po-sm-12\" [p-label]=\"field.divider\"> </po-divider>\n    <ng-container\n      *ngTemplateOutlet=\"\n        !field.tag && !field.image ? poInfo : !field.image ? poTag : poImage;\n        context: { $implicit: field }\n      \"\n    >\n    </ng-container>\n  </ng-template>\n</ng-template>\n\n<ng-template #poContentContainer let-fields>\n  <po-dynamic-container [p-fields]=\"fields\" [p-content]=\"poContent\"></po-dynamic-container>\n</ng-template>\n\n<ng-template #poInfo let-field>\n  <po-info\n    [ngClass]=\"field.cssClass\"\n    [class.po-info-value-pre]=\"textWrap && containsLineBreak(setFieldValue(field))\"\n    [p-label]=\"field.label\"\n    [p-value]=\"setFieldValue(field)\"\n  >\n  </po-info\n></ng-template>\n\n<ng-template #poTag let-field>\n  <po-tag\n    [ngClass]=\"field.cssClass\"\n    [p-color]=\"field.color\"\n    [p-icon]=\"field.icon\"\n    [p-inverse]=\"field.inverse\"\n    [p-label]=\"field.label\"\n    [p-value]=\"setFieldValue(field)\"\n  >\n  </po-tag>\n</ng-template>\n\n<ng-template #poImage let-field>\n  <po-image [p-alt]=\"field.alt\" [p-height]=\"field.height\" [p-src]=\"field.value\"> </po-image>\n</ng-template>\n" }]
     }], () => [{ type: i1.CurrencyPipe }, { type: i1.DatePipe }, { type: i1.DecimalPipe }, { type: i2.PoTimePipe }, { type: i1.TitleCasePipe }, { type: i3.PoDynamicViewService }, { type: i4.PoComboFilterService }, { type: i5.PoMultiselectFilterService }], null); })();
 (() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(PoDynamicViewComponent, { className: "PoDynamicViewComponent", filePath: "lib/components/po-dynamic/po-dynamic-view/po-dynamic-view.component.ts", lineNumber: 42 }); })();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-dynamic-view.component.js","sourceRoot":"","sources":["../../../../../../../projects/ui/src/lib/components/po-dynamic/po-dynamic-view/po-dynamic-view.component.ts","../../../../../../../projects/ui/src/lib/components/po-dynamic/po-dynamic-view/po-dynamic-view.component.html"],"names":[],"mappings":"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","sourcesContent":["import { CurrencyPipe, DatePipe, DecimalPipe, TitleCasePipe } from '@angular/common';\nimport { Component, OnChanges, OnInit, SimpleChanges } from '@angular/core';\n\nimport { PoTimePipe } from '../../../pipes/po-time/po-time.pipe';\n\nimport { PoDynamicViewField } from './../po-dynamic-view/po-dynamic-view-field.interface';\nimport { PoDynamicViewBaseComponent } from './po-dynamic-view-base.component';\nimport { PoDynamicViewService } from './services/po-dynamic-view.service';\nimport { PoComboFilterService } from '../../po-field/po-combo/po-combo-filter.service';\nimport { PoMultiselectFilterService } from '../../po-field/po-multiselect/po-multiselect-filter.service';\n\n/**\n * @docsExtends PoDynamicViewBaseComponent\n *\n * @example\n *\n * <example name=\"po-dynamic-view-basic\" title=\"PO Dynamic View Basic\">\n *  <file name=\"sample-po-dynamic-view-basic/sample-po-dynamic-view-basic.component.html\"> </file>\n *  <file name=\"sample-po-dynamic-view-basic/sample-po-dynamic-view-basic.component.ts\"> </file>\n * </example>\n *\n * <example name=\"po-dynamic-view-employee\" title=\"PO Dynamic View - Employee\">\n *  <file name=\"sample-po-dynamic-view-employee/sample-po-dynamic-view-employee.component.html\"> </file>\n *  <file name=\"sample-po-dynamic-view-employee/sample-po-dynamic-view-employee.component.ts\"> </file>\n * </example>\n *\n * <example name=\"po-dynamic-view-employee-on-load\" title=\"PO Dynamic View - Employee on load\">\n *  <file name=\"sample-po-dynamic-view-employee-on-load/sample-po-dynamic-view-employee-on-load.component.html\"> </file>\n *  <file name=\"sample-po-dynamic-view-employee-on-load/sample-po-dynamic-view-employee-on-load.component.ts\"> </file>\n *  <file name=\"sample-po-dynamic-view-employee-on-load/sample-po-dynamic-view-employee-on-load.service.ts\"> </file>\n * </example>\n *\n * <example name=\"po-dynamic-view-container\" title=\"PO Dynamic View - Employee on load\">\n *  <file name=\"sample-po-dynamic-view-container/sample-po-dynamic-view-container.component.html\"> </file>\n *  <file name=\"sample-po-dynamic-view-container/sample-po-dynamic-view-container.component.ts\"> </file>\n * </example>\n */\n@Component({\n  selector: 'po-dynamic-view',\n  templateUrl: './po-dynamic-view.component.html'\n})\nexport class PoDynamicViewComponent extends PoDynamicViewBaseComponent implements OnChanges, OnInit {\n  initChanges;\n  constructor(\n    currencyPipe: CurrencyPipe,\n    datePipe: DatePipe,\n    decimalPipe: DecimalPipe,\n    timePipe: PoTimePipe,\n    titleCasePipe: TitleCasePipe,\n    dynamicViewService: PoDynamicViewService,\n    comboFilterService: PoComboFilterService,\n    multiselectFilterService: PoMultiselectFilterService\n  ) {\n    super(\n      currencyPipe,\n      datePipe,\n      decimalPipe,\n      timePipe,\n      titleCasePipe,\n      dynamicViewService,\n      comboFilterService,\n      multiselectFilterService\n    );\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    if (this.load && !this.initChanges) {\n      this.initChanges = false;\n    } else {\n      this.initChanges = true;\n    }\n    if ((changes.fields || changes.value || changes.showAllValue) && this.initChanges) {\n      this.visibleFields = this.getVisibleFields();\n      this.setContainerFields();\n    }\n  }\n\n  ngOnInit() {\n    if (this.load) {\n      this.updateValuesAndFieldsOnLoad().finally(() => {\n        this.setContainerFields();\n      });\n    }\n  }\n\n  setFieldValue(field) {\n    if (field.options) {\n      const selectedOption = field.options.find(option => option.value === field.value);\n      return selectedOption ? selectedOption.label : field.value;\n    } else if (field.type === 'boolean' && 'booleanTrue' in field && 'booleanFalse' in field) {\n      return field.value ? field.booleanTrue : field.booleanFalse;\n    } else {\n      return field.value;\n    }\n  }\n\n  protected containsLineBreak(value: string): boolean {\n    return value && value.includes('\\n');\n  }\n\n  private async getValuesAndFieldsFromLoad(): Promise<{ value?: any; fields?: Array<PoDynamicViewField> }> {\n    let valueAndFieldsFromLoad;\n\n    if (typeof this.load === 'string') {\n      valueAndFieldsFromLoad = await this.dynamicViewService.onLoad(this.load, this.value);\n    } else if (typeof this.load === 'function') {\n      valueAndFieldsFromLoad = this.load();\n    }\n\n    return valueAndFieldsFromLoad || {};\n  }\n\n  private getVisibleFields() {\n    if (this.showAllValue) {\n      return this.getMergedFields();\n    }\n\n    return this.value && this.fields.length ? this.getConfiguredFields() : this.getValueFields();\n  }\n\n  private setFieldOnLoad(fieldOnLoad: PoDynamicViewField) {\n    const index = this.fields.findIndex(field => field.property === fieldOnLoad.property);\n\n    if (index >= 0) {\n      this.fields[index] = { ...this.fields[index], ...fieldOnLoad };\n    } else {\n      this.fields.push({ ...fieldOnLoad });\n    }\n  }\n\n  private setFieldsOnLoad(fields: Array<PoDynamicViewField>) {\n    if (fields) {\n      fields.forEach(fieldOnLoad => {\n        this.setFieldOnLoad(fieldOnLoad);\n      });\n    }\n  }\n\n  private setValueOnLoad(newValue: any) {\n    Object.assign(this.value, newValue);\n  }\n\n  private async updateValuesAndFieldsOnLoad() {\n    const { value, fields } = await this.getValuesAndFieldsFromLoad();\n\n    this.setValueOnLoad(value);\n    this.setFieldsOnLoad(fields);\n\n    this.visibleFields = this.getVisibleFields();\n    this.initChanges = true;\n  }\n}\n","<div class=\"po-row\" [class.po-dynamic]=\"hasContainers\" *ngIf=\"visibleFields.length\">\n  <ng-container\n    *ngTemplateOutlet=\"\n      hasContainers ? poContentContainer : poContent;\n      context: { $implicit: hasContainers ? containerFields : visibleFields }\n    \"\n  ></ng-container>\n</div>\n\n<ng-template #poContent let-fields>\n  <ng-template ngFor let-field [ngForOf]=\"fields\">\n    <po-divider *ngIf=\"field?.divider?.trim()\" class=\"po-sm-12\" [p-label]=\"field.divider\"> </po-divider>\n    <ng-container\n      *ngTemplateOutlet=\"\n        !field.tag && !field.image ? poInfo : !field.image ? poTag : poImage;\n        context: { $implicit: field }\n      \"\n    >\n    </ng-container>\n  </ng-template>\n</ng-template>\n\n<ng-template #poContentContainer let-fields>\n  <po-dynamic-container [p-fields]=\"fields\" [p-content]=\"poContent\"></po-dynamic-container>\n</ng-template>\n\n<ng-template #poInfo let-field>\n  <po-info\n    [ngClass]=\"field.cssClass\"\n    [class.po-info-value-pre]=\"textWrap && containsLineBreak(setFieldValue(field))\"\n    [p-label]=\"field.label\"\n    [p-value]=\"setFieldValue(field)\"\n  >\n  </po-info\n></ng-template>\n\n<ng-template #poTag let-field>\n  <po-tag\n    [ngClass]=\"field.cssClass\"\n    [p-color]=\"field.color\"\n    [p-icon]=\"field.icon\"\n    [p-inverse]=\"field.inverse\"\n    [p-label]=\"field.label\"\n    [p-value]=\"setFieldValue(field)\"\n  >\n  </po-tag>\n</ng-template>\n\n<ng-template #poImage let-field>\n  <po-image [p-alt]=\"field.alt\" [p-height]=\"field.height\" [p-src]=\"field.value\"> </po-image>\n</ng-template>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-dynamic-view.component.js","sourceRoot":"","sources":["../../../../../../../projects/ui/src/lib/components/po-dynamic/po-dynamic-view/po-dynamic-view.component.ts","../../../../../../../projects/ui/src/lib/components/po-dynamic/po-dynamic-view/po-dynamic-view.component.html"],"names":[],"mappings":"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","sourcesContent":["import { CurrencyPipe, DatePipe, DecimalPipe, TitleCasePipe } from '@angular/common';\nimport { Component, OnChanges, OnInit, SimpleChanges } from '@angular/core';\n\nimport { PoTimePipe } from '../../../pipes/po-time/po-time.pipe';\n\nimport { PoDynamicViewField } from './../po-dynamic-view/po-dynamic-view-field.interface';\nimport { PoDynamicViewBaseComponent } from './po-dynamic-view-base.component';\nimport { PoDynamicViewService } from './services/po-dynamic-view.service';\nimport { PoComboFilterService } from '../../po-field/po-combo/po-combo-filter.service';\nimport { PoMultiselectFilterService } from '../../po-field/po-multiselect/po-multiselect-filter.service';\n\n/**\n * @docsExtends PoDynamicViewBaseComponent\n *\n * @example\n *\n * <example name=\"po-dynamic-view-basic\" title=\"PO Dynamic View Basic\">\n *  <file name=\"sample-po-dynamic-view-basic/sample-po-dynamic-view-basic.component.html\"> </file>\n *  <file name=\"sample-po-dynamic-view-basic/sample-po-dynamic-view-basic.component.ts\"> </file>\n * </example>\n *\n * <example name=\"po-dynamic-view-employee\" title=\"PO Dynamic View - Employee\">\n *  <file name=\"sample-po-dynamic-view-employee/sample-po-dynamic-view-employee.component.html\"> </file>\n *  <file name=\"sample-po-dynamic-view-employee/sample-po-dynamic-view-employee.component.ts\"> </file>\n * </example>\n *\n * <example name=\"po-dynamic-view-employee-on-load\" title=\"PO Dynamic View - Employee on load\">\n *  <file name=\"sample-po-dynamic-view-employee-on-load/sample-po-dynamic-view-employee-on-load.component.html\"> </file>\n *  <file name=\"sample-po-dynamic-view-employee-on-load/sample-po-dynamic-view-employee-on-load.component.ts\"> </file>\n *  <file name=\"sample-po-dynamic-view-employee-on-load/sample-po-dynamic-view-employee-on-load.service.ts\"> </file>\n * </example>\n *\n * <example name=\"po-dynamic-view-container\" title=\"PO Dynamic View - Employee on load\">\n *  <file name=\"sample-po-dynamic-view-container/sample-po-dynamic-view-container.component.html\"> </file>\n *  <file name=\"sample-po-dynamic-view-container/sample-po-dynamic-view-container.component.ts\"> </file>\n * </example>\n */\n@Component({\n  selector: 'po-dynamic-view',\n  templateUrl: './po-dynamic-view.component.html'\n})\nexport class PoDynamicViewComponent extends PoDynamicViewBaseComponent implements OnChanges, OnInit {\n  initChanges;\n  constructor(\n    currencyPipe: CurrencyPipe,\n    datePipe: DatePipe,\n    decimalPipe: DecimalPipe,\n    timePipe: PoTimePipe,\n    titleCasePipe: TitleCasePipe,\n    dynamicViewService: PoDynamicViewService,\n    comboFilterService: PoComboFilterService,\n    multiselectFilterService: PoMultiselectFilterService\n  ) {\n    super(\n      currencyPipe,\n      datePipe,\n      decimalPipe,\n      timePipe,\n      titleCasePipe,\n      dynamicViewService,\n      comboFilterService,\n      multiselectFilterService\n    );\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    if (this.load && !this.initChanges) {\n      this.initChanges = false;\n    } else {\n      this.initChanges = true;\n    }\n    if ((changes.fields || changes.value || changes.showAllValue) && this.initChanges) {\n      this.visibleFields = this.getVisibleFields();\n      this.setContainerFields();\n    }\n  }\n\n  ngOnInit() {\n    if (this.load) {\n      this.updateValuesAndFieldsOnLoad().finally(() => {\n        this.setContainerFields();\n      });\n    }\n  }\n\n  setFieldValue(field) {\n    if (field.options) {\n      if (field.optionsMulti) {\n        const selectedOptions = field.options.filter(\n          option => Array.isArray(field.value) && field.value.some(value => value === option.value)\n        );\n        return selectedOptions.length ? selectedOptions.map(option => option.label) : field.value;\n      } else {\n        const selectedOption = field.options.find(option => option.value === field.value);\n        return selectedOption ? selectedOption.label : field.value;\n      }\n    } else if (field.type === 'boolean' && 'booleanTrue' in field && 'booleanFalse' in field) {\n      return field.value ? field.booleanTrue : field.booleanFalse;\n    } else {\n      return field.value;\n    }\n  }\n\n  protected containsLineBreak(value: string): boolean {\n    return value && value.includes('\\n');\n  }\n\n  private async getValuesAndFieldsFromLoad(): Promise<{ value?: any; fields?: Array<PoDynamicViewField> }> {\n    let valueAndFieldsFromLoad;\n\n    if (typeof this.load === 'string') {\n      valueAndFieldsFromLoad = await this.dynamicViewService.onLoad(this.load, this.value);\n    } else if (typeof this.load === 'function') {\n      valueAndFieldsFromLoad = this.load();\n    }\n\n    return valueAndFieldsFromLoad || {};\n  }\n\n  private getVisibleFields() {\n    if (this.showAllValue) {\n      return this.getMergedFields();\n    }\n\n    return this.value && this.fields.length ? this.getConfiguredFields() : this.getValueFields();\n  }\n\n  private setFieldOnLoad(fieldOnLoad: PoDynamicViewField) {\n    const index = this.fields.findIndex(field => field.property === fieldOnLoad.property);\n\n    if (index >= 0) {\n      this.fields[index] = { ...this.fields[index], ...fieldOnLoad };\n    } else {\n      this.fields.push({ ...fieldOnLoad });\n    }\n  }\n\n  private setFieldsOnLoad(fields: Array<PoDynamicViewField>) {\n    if (fields) {\n      fields.forEach(fieldOnLoad => {\n        this.setFieldOnLoad(fieldOnLoad);\n      });\n    }\n  }\n\n  private setValueOnLoad(newValue: any) {\n    Object.assign(this.value, newValue);\n  }\n\n  private async updateValuesAndFieldsOnLoad() {\n    const { value, fields } = await this.getValuesAndFieldsFromLoad();\n\n    this.setValueOnLoad(value);\n    this.setFieldsOnLoad(fields);\n\n    this.visibleFields = this.getVisibleFields();\n    this.initChanges = true;\n  }\n}\n","<div class=\"po-row\" [class.po-dynamic]=\"hasContainers\" *ngIf=\"visibleFields.length\">\n  <ng-container\n    *ngTemplateOutlet=\"\n      hasContainers ? poContentContainer : poContent;\n      context: { $implicit: hasContainers ? containerFields : visibleFields }\n    \"\n  ></ng-container>\n</div>\n\n<ng-template #poContent let-fields>\n  <ng-template ngFor let-field [ngForOf]=\"fields\">\n    <po-divider *ngIf=\"field?.divider?.trim()\" class=\"po-sm-12\" [p-label]=\"field.divider\"> </po-divider>\n    <ng-container\n      *ngTemplateOutlet=\"\n        !field.tag && !field.image ? poInfo : !field.image ? poTag : poImage;\n        context: { $implicit: field }\n      \"\n    >\n    </ng-container>\n  </ng-template>\n</ng-template>\n\n<ng-template #poContentContainer let-fields>\n  <po-dynamic-container [p-fields]=\"fields\" [p-content]=\"poContent\"></po-dynamic-container>\n</ng-template>\n\n<ng-template #poInfo let-field>\n  <po-info\n    [ngClass]=\"field.cssClass\"\n    [class.po-info-value-pre]=\"textWrap && containsLineBreak(setFieldValue(field))\"\n    [p-label]=\"field.label\"\n    [p-value]=\"setFieldValue(field)\"\n  >\n  </po-info\n></ng-template>\n\n<ng-template #poTag let-field>\n  <po-tag\n    [ngClass]=\"field.cssClass\"\n    [p-color]=\"field.color\"\n    [p-icon]=\"field.icon\"\n    [p-inverse]=\"field.inverse\"\n    [p-label]=\"field.label\"\n    [p-value]=\"setFieldValue(field)\"\n  >\n  </po-tag>\n</ng-template>\n\n<ng-template #poImage let-field>\n  <po-image [p-alt]=\"field.alt\" [p-height]=\"field.height\" [p-src]=\"field.value\"> </po-image>\n</ng-template>\n"]}

package/esm2022/lib/components/po-list-view/po-list-view.module.mjs

@@ -41,6 +41,18 @@ import * as i0 from "@angular/core";
  * })
  * export class AppModule { }
  * ```
+ *
+ * Em aplicações Standalone, utilize a seguinte configuração para o bootstrap:
+ *
+ * ```
+ * import { bootstrapApplication } from '@angular/platform-browser';
+ * import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
+ * import { AppComponent } from './app.component';
+ *
+ * bootstrapApplication(AppComponent, {
+ *   providers: [importProvidersFrom(BrowserAnimationsModule)]
+ * }).catch(err => console.error(err));
+ * ```
  */
 export class PoListViewModule {
     static ɵfac = function PoListViewModule_Factory(t) { return new (t || PoListViewModule)(); };
@@ -81,4 +93,4 @@ export class PoListViewModule {
         PoPopupModule,
         PoCheckboxModule,
         PoContainerModule], exports: [PoListViewComponent, PoListViewContentTemplateDirective, PoListViewDetailTemplateDirective] }); })();
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/po-navbar/po-navbar.module.mjs

@@ -39,6 +39,18 @@ import * as i0 from "@angular/core";
  * })
  * export class AppModule { }
  * ```
+ *
+ * Em aplicações Standalone, utilize a seguinte configuração para o bootstrap:
+ *
+ * ```
+ * import { bootstrapApplication } from '@angular/platform-browser';
+ * import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
+ * import { AppComponent } from './app.component';
+ *
+ * bootstrapApplication(AppComponent, {
+ *   providers: [importProvidersFrom(BrowserAnimationsModule)]
+ * }).catch(err => console.error(err));
+ * ```
  */
 export class PoNavbarModule {
     static ɵfac = function PoNavbarModule_Factory(t) { return new (t || PoNavbarModule)(); };
@@ -74,4 +86,4 @@ export class PoNavbarModule {
         PoNavbarActionsModule,
         PoNavbarItemNavigationModule,
         PoNavbarItemsModule], exports: [PoNavbarComponent] }); })();
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/po-page/po-page-slide/po-page-slide-base.component.mjs

@@ -15,6 +15,41 @@ import * as i0 from "@angular/core";
  * > Para o correto funcionamento do componente `po-page-slide`, deve ser
  * > importado o módulo `BrowserAnimationsModule` no módulo principal da sua
  * > aplicação.
+ *
+ * Módulo da aplicação:
+ * ```
+ * import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
+ * import { PoModule } from '@po-ui/ng-components';
+ * ...
+ *
+ * @NgModule({
+ *   imports: [
+ *     BrowserModule,
+ *     BrowserAnimationsModule,
+ *     ...
+ *     PoModule
+ *   ],
+ *   declarations: [
+ *     AppComponent,
+ *     ...
+ *   ],
+ *   providers: [],
+ *   bootstrap: [AppComponent]
+ * })
+ * export class AppModule { }
+ * ```
+ *
+ * Em aplicações Standalone, utilize a seguinte configuração para o bootstrap:
+ *
+ * ```
+ * import { bootstrapApplication } from '@angular/platform-browser';
+ * import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
+ * import { AppComponent } from './app.component';
+ *
+ * bootstrapApplication(AppComponent, {
+ *   providers: [importProvidersFrom(BrowserAnimationsModule)]
+ * }).catch(err => console.error(err));
+ * ```
  */
 export class PoPageSlideBaseComponent {
     /**
@@ -171,4 +206,4 @@ export class PoPageSlideBaseComponent {
             type: Input,
             args: ['p-size']
         }] }); })();
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-page-slide-base.component.js","sourceRoot":"","sources":["../../../../../../../projects/ui/src/lib/components/po-page/po-page-slide/po-page-slide-base.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAEvE,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;;AAEvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAEH,MAAM,OAAO,wBAAwB;IACnC;;;;OAIG;IACe,KAAK,CAAS;IAEhC;;;;OAIG;IACkB,QAAQ,CAAU;IAEvC;;;;;;;;;;OAUG;IAC4D,SAAS,GAAY,KAAK,CAAC;IAE1F;;;;;;;;OAQG;IAC2D,QAAQ,GAAY,KAAK,CAAC;IAExF;;;;;;;;;OASG;IACgE,aAAa,GAAY,KAAK,CAAC;IAElG;;;;;OAKG;IACgB,cAAc,GAAsB,IAAI,YAAY,EAAO,CAAC;IAE/E,gEAAgE;IACzD,MAAM,GAAG,IAAI,CAAC;IAEb,KAAK,GAAG,IAAI,CAAC;IAErB;;;;;;;;;;;;;;;;;OAiBG;IACH,IAAqB,IAAI,CAAC,KAAa;QACrC,MAAM,KAAK,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;QAC/C,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;IACxD,CAAC;IAED,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACI,IAAI;QACT,qEAAqE;QACrE,IAAI,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;YACpC,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;SACxB;QAED,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;IACtB,CAAC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACI,KAAK;QACV,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;QACnB,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,CAAC;IAC7B,CAAC;kFA3IU,wBAAwB;6DAAxB,wBAAwB,gNA0BQ,gBAAgB,qFAWjB,gBAAgB,oGAYX,gBAAgB;;iFAjDpD,wBAAwB;cADpC,SAAS;gBAOU,KAAK;kBAAtB,KAAK;mBAAC,SAAS;YAOK,QAAQ;kBAA5B,KAAK;mBAAC,YAAY;YAa4C,SAAS;kBAAvE,KAAK;mBAAC,EAAE,KAAK,EAAE,cAAc,EAAE,SAAS,EAAE,gBAAgB,EAAE;YAWC,QAAQ;kBAArE,KAAK;mBAAC,EAAE,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,gBAAgB,EAAE;YAYO,aAAa;kBAA/E,KAAK;mBAAC,EAAE,KAAK,EAAE,kBAAkB,EAAE,SAAS,EAAE,gBAAgB,EAAE;YAQ9C,cAAc;kBAAhC,MAAM;mBAAC,SAAS;YAyBI,IAAI;kBAAxB,KAAK;mBAAC,QAAQ","sourcesContent":["import { Directive, EventEmitter, Input, Output } from '@angular/core';\n\nimport { convertToBoolean } from '../../../utils/util';\n\n/**\n * @description\n *\n * O componente `po-page-slide` é utilizado para incluir conteúdos secundários\n * adicionando controles e navegações adicionais, mas mantendo o usuário na\n * página principal.\n *\n * Este componente é ativado a partir do método `#open()` e pode ser  encerrado\n * através do botão que encontra-se no cabeçalho do mesmo ou através do método\n * `#close()`.\n *\n * > Para o correto funcionamento do componente `po-page-slide`, deve ser\n * > importado o módulo `BrowserAnimationsModule` no módulo principal da sua\n * > aplicação.\n *\n * Módulo da aplicação:\n * ```\n * import { BrowserAnimationsModule } from '@angular/platform-browser/animations';\n * import { PoModule } from '@po-ui/ng-components';\n * ...\n *\n * @NgModule({\n *   imports: [\n *     BrowserModule,\n *     BrowserAnimationsModule,\n *     ...\n *     PoModule\n *   ],\n *   declarations: [\n *     AppComponent,\n *     ...\n *   ],\n *   providers: [],\n *   bootstrap: [AppComponent]\n * })\n * export class AppModule { }\n * ```\n *\n * Em aplicações Standalone, utilize a seguinte configuração para o bootstrap:\n *\n * ```\n * import { bootstrapApplication } from '@angular/platform-browser';\n * import { BrowserAnimationsModule } from '@angular/platform-browser/animations';\n * import { AppComponent } from './app.component';\n *\n * bootstrapApplication(AppComponent, {\n *   providers: [importProvidersFrom(BrowserAnimationsModule)]\n * }).catch(err => console.error(err));\n * ```\n */\n@Directive()\nexport class PoPageSlideBaseComponent {\n  /**\n   * @description\n   *\n   * Título da página.\n   */\n  @Input('p-title') title: string;\n\n  /**\n   * @description\n   *\n   * Subtítulo da página.\n   */\n  @Input('p-subtitle') subtitle?: string;\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Oculta o botão de encerramento da página.\n   *\n   * Esta opção só é possível se a propriedade `p-click-out` estiver habilitada.\n   *\n   * @default `false`\n   */\n  @Input({ alias: 'p-hide-close', transform: convertToBoolean }) hideClose: boolean = false;\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Define se permite o encerramento da página ao clicar fora da mesma.\n   *\n   * @default `false`\n   */\n  @Input({ alias: 'p-click-out', transform: convertToBoolean }) clickOut: boolean = false;\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Permite a expansão dinâmica da largura do `po-page-slide` quando `p-size` for `auto` (automático).\n   * Propriedade necessária para correto funcionamento da `po-table` dentro do `po-page-slide`\n   *\n   * @default `false`\n   */\n  @Input({ alias: 'p-flexible-width', transform: convertToBoolean }) flexibleWidth: boolean = false;\n\n  /**\n   * @optional\n   *\n   * @description\n   * Evento executado ao fechar o page slide.\n   */\n  @Output('p-close') closePageSlide: EventEmitter<any> = new EventEmitter<any>();\n\n  // Controla se a página está ou não oculta, por padrão é oculto.\n  public hidden = true;\n\n  private _size = 'md';\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Define o tamanho da página.\n   *\n   * Valores válidos:\n   *  - `sm` (pequeno)\n   *  - `md` (médio)\n   *  - `lg` (grande)\n   *  - `xl` (extra-grande)\n   *  - `auto` (automático)\n   *\n   * > Todas as opções de tamanho, exceto `auto`, possuem uma largura máxima de **768px**.\n   *\n   * @default `md`\n   */\n  @Input('p-size') set size(value: string) {\n    const sizes = ['sm', 'md', 'lg', 'xl', 'auto'];\n    this._size = sizes.indexOf(value) > -1 ? value : 'md';\n  }\n\n  get size() {\n    return this._size;\n  }\n\n  /**\n   * Ativa a visualização da página.\n   *\n   * Para utilizá-la é necessário ter a instância do componente no DOM, podendo\n   * ser utilizado o `ViewChild` da seguinte forma:\n   *\n   * ```typescript\n   * import { PoPageSlideComponent } from '@po/ng-components';\n   *\n   * ...\n   *\n   * @ViewChild(PoPageSlideComponent, { static: true }) pageSlide: PoPageSlideComponent;\n   *\n   * public openPage() {\n   *   this.pageSlide.open();\n   * }\n   * ```\n   */\n  public open() {\n    // Evita com que a página seja aberta sem que seja possível fechá-la.\n    if (this.hideClose && !this.clickOut) {\n      this.hideClose = false;\n    }\n\n    this.hidden = false;\n  }\n\n  /**\n   * Encerra a visualização da página.\n   *\n   * Para utilizá-la é necessário ter a instância do componente no DOM, podendo\n   * ser utilizado o `ViewChild` da seguinte forma:\n   *\n   * ```typescript\n   * import { PoPageSlideComponent } from '@po-ui/ng-components';\n   *\n   * ...\n   *\n   * @ViewChild(PoPageSlideComponent, { static: true }) pageSlide: PoPageSlideComponent;\n   *\n   * public closePage() {\n   *   this.pageSlide.close();\n   * }\n   * ```\n   */\n  public close(): void {\n    this.hidden = true;\n    this.closePageSlide.emit();\n  }\n}\n"]}