@po-ui/ng-components 5.22.5 → 5.22.6

package/esm2015/lib/components/po-dynamic/po-dynamic-view/po-dynamic-view-base.component.js

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

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