@po-ui/ng-components 5.22.3 → 6.2.0

package/esm2020/lib/components/po-table/po-table-base.component.mjs

@@ -0,0 +1,937 @@
+import { __decorate } from "tslib";
+import { EventEmitter, Input, Output, Directive } from '@angular/core';
+import { capitalizeFirstLetter, convertToBoolean, isTypeof, sortValues } from '../../utils/util';
+import { poLocaleDefault } from '../../services/po-language/po-language.constant';
+import { PoTableColumnSortType } from './enums/po-table-column-sort-type.enum';
+import { InputBoolean } from '../../decorators';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/po-date/po-date.service";
+import * as i2 from "../../services/po-language/po-language.service";
+import * as i3 from "./services/po-table.service";
+export const poTableContainer = ['border', 'shadow'];
+export const poTableContainerDefault = 'border';
+export const poTableLiteralsDefault = {
+    en: {
+        noColumns: 'Columns are not defined',
+        noData: 'No data found',
+        noVisibleColumn: 'No visible column',
+        loadingData: 'Loading',
+        loadMoreData: 'Load more data',
+        seeCompleteSubtitle: 'See complete subtitle',
+        completeSubtitle: 'Complete subtitle',
+        columnsManager: 'Columns manager'
+    },
+    es: {
+        noColumns: 'Columnas no definidas',
+        noData: 'Datos no encontrados',
+        noVisibleColumn: 'Sin columnas visibles',
+        loadingData: 'Cargando datos',
+        loadMoreData: 'Cargar más resultados',
+        seeCompleteSubtitle: 'Ver subtitulo completo',
+        completeSubtitle: 'Subtitulo completo',
+        columnsManager: 'Gerente de columna'
+    },
+    pt: {
+        noColumns: 'Nenhuma definição de colunas',
+        noData: 'Nenhum dado encontrado',
+        noVisibleColumn: 'Nenhuma coluna visível',
+        loadingData: 'Carregando',
+        loadMoreData: 'Carregar mais resultados',
+        seeCompleteSubtitle: 'Ver legenda completa',
+        completeSubtitle: 'Legenda completa',
+        columnsManager: 'Gerenciador de colunas'
+    },
+    ru: {
+        noColumns: 'Нет определения столбца',
+        noData: 'Данные не найдены',
+        noVisibleColumn: 'нет видимых столбцов',
+        loadingData: 'погрузка',
+        loadMoreData: 'загрузка',
+        seeCompleteSubtitle: 'Посмотреть полный субтитр',
+        completeSubtitle: 'Полный заголовок',
+        columnsManager: 'менеджер колонок'
+    }
+};
+/**
+ * @description
+ *
+ * Este componente de tabela é utilizado para exibição de dados com diferentes tipos como por exemplo textos, data, horas e números com
+ * formato personalizado.
+ *
+ * Também é possivel criar tabelas com ordenação de dados, linhas com detalhes, coluna para seleção de linhas, coluna com ações e também
+ * carregamento por demanda através do botão **Carregar mais resultados**.
+ *
+ * > As linhas de detalhes podem também ser customizadas através do [`p-table-row-template`](/documentation/po-table-row-template).
+ *
+ * > As colunas podem ser customizadas através dos templates [`p-table-column-template`](/documentation/po-table-column-template)
+ * e [`p-table-cell-template`](/documentation/po-table-cell-template).
+ *
+ * O componente permite gerenciar a exibição das colunas dinamicamente. Esta funcionalidade pode ser acessada através do ícone de engrenagem
+ * no canto superior direito do cabeçalho da tabela.
+ *
+ * Caso a largura de todas as colunas forem definidas e o total ultrapassar o tamanho tabela, será exibido um *scroll* na horizontal para a
+ * completa visualização dos dados.
+ */
+export class PoTableBaseComponent {
+    constructor(poDate, languageService, poTableService) {
+        this.poDate = poDate;
+        this.poTableService = poTableService;
+        /**
+         * @optional
+         *
+         * @description
+         *
+         * Se verdadeiro, habilita a quebra de texto ao transborda-lo dentro de qualquer coluna.
+         * > Quando ocorrer a quebra de texto, ao passar o mouse no conteúdo da célula,
+         * o mesmo será exibido através do [`po-tooltip`](/documentation/po-tooltip).
+         */
+        this.hideTextOverflow = false;
+        /**
+         * @optional
+         *
+         * @description
+         *
+         * Permite que o gerenciador de colunas, responsável pela definição de quais colunas serão exibidas, seja escondido.
+         *
+         * @default `false`
+         */
+        this.hideColumnsManager = false;
+        /**
+         * @optional
+         *
+         * @description
+         *
+         * Permite fechar um detalhe ou row template automaticamente, ao abrir outro item.
+         *
+         * @default `false`
+         */
+        this.autoCollapse = false;
+        /**
+         * @optional
+         *
+         * @description
+         *
+         * Permite que seja adicionado o estado de carregamento no botão "Carregar mais resultados".
+         *
+         * @default `false`
+         */
+        this.loadingShowMore = false;
+        /**
+         * @optional
+         *
+         * @description
+         *
+         * Habilita em todas as colunas a opção de ordenação de dados. Caso a coluna seja do tipo 'data' ou 'dateTime' a
+         * mesma deve respeitar os tipos de entrada definidos para que sejam ordenadas.
+         *
+         * @default `false`
+         */
+        this.sort = false;
+        /**
+         * @description
+         *
+         * Se verdadeiro, torna habilitado o botão "Carregar mais resultados".
+         *
+         * @default `false`
+         */
+        this.showMoreDisabled = false;
+        /**
+         * @description
+         *
+         * Habilita ou desabilita o estilo listrado da tabela (`striped`).
+         * > Recomendado para tabelas com maior número de dados, facilitando a sua visualização na tabela.
+         *
+         * @default `false`
+         */
+        this.striped = false;
+        /**
+         * @description
+         *
+         * Esconde o *checkbox* para seleção de todas as linhas.
+         *
+         * > Sempre receberá *true* caso a seleção de apenas uma linha esteja ativa.
+         *
+         * @default `false`
+         */
+        this.hideSelectAll = false;
+        /**
+         * @description
+         *
+         * Define que somente uma linha da tabela pode ser selecionada.
+         *
+         * > Esta definição não se aplica aos itens filhos, os mesmos possuem comportamento independente do item pai.
+         */
+        this.singleSelect = false;
+        /**
+         * @optional
+         *
+         * @description
+         *
+         * Define que a coluna de ações ficará no lado direito da tabela.
+         *
+         * @default `false`
+         */
+        this.actionRight = false;
+        /**
+         * @optional
+         *
+         * @description
+         * Evento executado quando todas as linhas são selecionadas por meio do *checkbox* que seleciona todas as linhas.
+         */
+        this.allSelected = new EventEmitter();
+        /**
+         * @optional
+         *
+         * @description
+         * Evento executado quando a seleção das linhas é desmarcada por meio do *checkbox* que seleciona todas as linhas.
+         */
+        this.allUnselected = new EventEmitter();
+        /**
+         * @optional
+         *
+         * @description
+         *
+         * Evento executado ao colapsar uma linha do `po-table`.
+         *
+         * > Como parâmetro o componente envia o item colapsado.
+         */
+        this.collapsed = new EventEmitter();
+        /**
+         * @optional
+         *
+         * @description
+         *
+         * Evento executado ao expandir uma linha do `po-table`.
+         *
+         * > Como parâmetro o componente envia o item expandido.
+         */
+        this.expanded = new EventEmitter();
+        /**
+         * @optional
+         *
+         * @description
+         *
+         * Evento executado ao selecionar uma linha do `po-table`.
+         */
+        this.selected = new EventEmitter();
+        /**
+         * @optional
+         *
+         * @description
+         *
+         * Recebe uma ação de clique para o botão "Carregar mais resultados", caso nenhuma ação for definida o mesmo
+         * não é visível.
+         *
+         * Recebe um objeto `{ column, type }` onde:
+         *
+         * - column (`PoTableColumn`): objeto da coluna que está ordenada.
+         * - type (`PoTableColumnSortType`): tipo da ordenação.
+         */
+        this.showMore = new EventEmitter();
+        /**
+         * @optional
+         *
+         * @description
+         *
+         * Evento executado ao ordenar colunas da tabela.
+         *
+         * Recebe um objeto `{ column, type }` onde:
+         *
+         * - column (`PoTableColumn`): objeto da coluna que foi clicada/ordenada.
+         * - type (`PoTableColumnSortType`): tipo da ordenação.
+         */
+        this.sortBy = new EventEmitter();
+        /**
+         * @optional
+         *
+         * @description
+         * Evento executado ao desmarcar a seleção de uma linha do `po-table`.
+         */
+        this.unselected = new EventEmitter();
+        /**
+         * @optional
+         *
+         * @description
+         * Evento disparado ao fechar o popover do gerenciador de colunas após alterar as colunas visíveis.
+         *
+         * O componente envia como parâmetro um array de string com as colunas visíveis atualizadas.
+         * Por exemplo: ["idCard", "name", "hireStatus", "age"].
+         */
+        this.changeVisibleColumns = new EventEmitter();
+        this.hasMainColumns = false;
+        this.mainColumns = [];
+        this.selectAll = false;
+        this.sortedColumn = { property: null, ascending: true };
+        this.subtitleColumns = [];
+        this.page = 1;
+        this.pageSize = 10;
+        this.hasService = false;
+        this._actions = [];
+        this._columns = [];
+        this._hideDetail = false;
+        this._loading = false;
+        this.language = poLocaleDefault;
+        this._infiniteScrollDistance = 100;
+        this._infiniteScroll = false;
+        this.language = languageService.getShortLanguage();
+    }
+    /**
+     * @description
+     *
+     * Lista de itens da tabela.
+     * > Se falso, será inicializado como um *array* vazio.
+     */
+    set items(items) {
+        this._items = Array.isArray(items) ? items : [];
+        // when haven't items, selectAll should be unchecked.
+        if (!this.hasItems) {
+            this.selectAll = false;
+        }
+        else if (!this.hasColumns) {
+            this.columns = this.getDefaultColumns(items[0]);
+        }
+        // timeout necessario para os itens serem refletidos na tabela
+        setTimeout(() => this.checkInfiniteScroll());
+    }
+    get items() {
+        return this._items;
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Lista das colunas da tabela, deve receber um *array* de objetos que implementam a interface `PoTableColumn`.
+     * Por padrão receberá como valor a primeira coluna da lista de itens da tabela.
+     * > Caso não encontre valor, a mensagem 'Nenhuma definição de colunas' será exibida.
+     *
+     */
+    set columns(columns) {
+        this._columns = columns || [];
+        if (this._columns.length) {
+            this.setColumnLink();
+            this.calculateWidthHeaders();
+        }
+        else if (this.hasItems) {
+            this._columns = this.getDefaultColumns(this.items[0]);
+        }
+        this.onChangeColumns();
+    }
+    get columns() {
+        return this._columns;
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Adiciona um contorno arredondado ao `po-table`, as opções são:
+     * - `border`: com bordas/linhas.
+     * - `shadow`: com sombras.
+     *
+     * @default `border`
+     */
+    set container(value) {
+        this._container = poTableContainer.includes(value) ? value : poTableContainerDefault;
+    }
+    get container() {
+        return this._container;
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Define a altura da tabela em *pixels* e fixa o cabeçalho.
+     */
+    set height(height) {
+        this._height = height;
+        this.calculateWidthHeaders();
+    }
+    get height() {
+        return this._height;
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Habilita a visualização da lista de detalhes de cada linha da coluna.
+     *
+     * @default `false`
+     */
+    set hideDetail(hideDetail) {
+        this._hideDetail = hideDetail != null && hideDetail.toString() === '' ? true : convertToBoolean(hideDetail);
+        this.calculateWidthHeaders();
+    }
+    get hideDetail() {
+        return this._hideDetail;
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Objeto com as literais usadas no `po-table`.
+     *
+     * Existem duas maneiras de customizar o componente, passando um objeto com todas as literais disponíveis:
+     *
+     * ```
+     *  const customLiterals: PoTableLiterals = {
+     *    loadMoreData: 'Buscar mais dados',
+     *    loadingData: 'Processando',
+     *    noColumns: 'Sem colunas',
+     *    noData: 'Sem dados',
+     *    seeCompleteSubtitle: 'Mostrar legenda completa',
+     *    completeSubtitle: 'Todas legendas'
+     *  };
+     * ```
+     *
+     * Ou passando apenas as literais que deseja customizar:
+     *
+     * ```
+     *  const customLiterals: PoTableLiterals = {
+     *    noData: 'Sem dados'
+     *  };
+     * ```
+     *
+     * E para carregar as literais customizadas, basta apenas passar o objeto para o componente.
+     *
+     * ```
+     * <po-table
+     *   [p-literals]="customLiterals">
+     * </po-table>
+     * ```
+     *
+     * > O objeto padrão de literais será traduzido de acordo com o idioma do
+     * [`PoI18nService`](/documentation/po-i18n) ou do browser.
+     */
+    set literals(value) {
+        if (value instanceof Object && !(value instanceof Array)) {
+            this._literals = {
+                ...poTableLiteralsDefault[poLocaleDefault],
+                ...poTableLiteralsDefault[this.language],
+                ...value
+            };
+        }
+        else {
+            this._literals = poTableLiteralsDefault[this.language];
+        }
+    }
+    get literals() {
+        return this._literals || poTableLiteralsDefault[this.language];
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Bloqueia a interação do usuário com os dados da _table_.
+     *
+     * @default `false`
+     */
+    set loading(loading) {
+        this._loading = convertToBoolean(loading);
+        this.calculateWidthHeaders();
+    }
+    get loading() {
+        return this._loading;
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Define uma lista de ações.
+     *
+     * Quando houver apenas uma ação definida ela será exibida diretamente na coluna, caso contrário, o componente
+     * se encarrega de agrupá-las exibindo o ícone [**po-icon-more**](/guides/icons) que listará as ações ao ser clicado.
+     *
+     * **A coluna de ações não será exibida quando:**
+     *  - a lista conter valores inválidos ou indefinidos.
+     *  - tenha uma única ação e a mesma não for visível.
+     */
+    set actions(actions) {
+        this._actions = actions;
+        this.calculateWidthHeaders();
+    }
+    get actions() {
+        return this._actions;
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Permite a seleção de linhas na tabela e, caso a propriedade `p-single-select` esteja definida será possível
+     * selecionar apenas uma única linha.
+     *
+     * **Importante:**
+     *  - As linhas de detalhe definidas em `PoTableDetail` possuem comportamento independente da linha mestre;
+     *  - Cada linha possui por padrão a propriedade dinâmica `$selected`, na qual é possível validar se a linha
+     * está selecionada, por exemplo: `item.$selected` ou `item['$selected']`.
+     *
+     * @default `false`
+     */
+    set selectable(value) {
+        this._selectable = value === '' ? true : convertToBoolean(value);
+        this.calculateWidthHeaders();
+    }
+    get selectable() {
+        return this._selectable;
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Se verdadeiro, ativa a funcionalidade de scroll infinito para a tabela e o botão "Carregar Mais" deixará de ser exibido. Ao chegar no fim da tabela
+     * executará a função `p-show-more`.
+     *
+     * **Regras de utilização:**
+     *  - O scroll infinito só funciona para tabelas que utilizam a propriedade `p-height` e que possuem o scroll já na carga inicial dos dados.
+     *
+     * @default `false`
+     */
+    set infiniteScroll(value) {
+        this._infiniteScroll = convertToBoolean(value && this.height > 0);
+    }
+    get infiniteScroll() {
+        return this._infiniteScroll;
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * Define o percentual necessário para disparar o evento `p-show-more`, que é responsável por carregar mais dados na tabela. Caso o valor informado seja maior que 100 ou menor
+     * que 0, o valor padrão será 100%
+     *
+     * **Exemplos:**
+     *  - p-infinite-scroll-distance = 80: Quando atingir 80%  do scroll da tabela, o `p-show-more` será disparado.
+     */
+    set infiniteScrollDistance(value) {
+        this._infiniteScrollDistance = value > 100 || value < 0 ? 100 : value;
+    }
+    get infiniteScrollDistance() {
+        return this._infiniteScrollDistance;
+    }
+    /**
+     * @optional
+     *
+     * @description
+     *
+     * URL da API responsável por retornar os registros.
+     *
+     * Ao realizar a busca de mais registros via paginação (Carregar mais resultados), será enviado os parâmetros `page` e `pageSize`, conforme abaixo:
+     *
+     * ```
+     * url + ?page=1&pageSize=10
+     * ```
+     *
+     * Caso utilizar ordenação, a coluna ordenada será enviada através do parâmetro `order`, por exemplo:
+     * - Coluna decrescente:
+     * ```
+     *  url + ?page=1&pageSize=10&order=-name
+     * ```
+     *
+     * - Coluna ascendente:
+     * ```
+     *  url + ?page=1&pageSize=10&order=name
+     * ```
+     *
+     * > Esta URL deve retornar e receber os dados no padrão de [API do PO UI](https://po-ui.io/guides/api).
+     */
+    set serviceApi(service) {
+        this._serviceApi = service;
+        this.setService(this.serviceApi);
+        this.hasService = !!service;
+        this.showMoreDisabled = !this.hasService;
+        this.page = 1;
+        this.initializeData();
+    }
+    get serviceApi() {
+        return this._serviceApi;
+    }
+    get hasColumns() {
+        return this.columns && this.columns.length > 0;
+    }
+    get hasItems() {
+        return !!(this.items && this.items.length);
+    }
+    get nameColumnDetail() {
+        return this.columnMasterDetail ? this.columnMasterDetail.property : null;
+    }
+    get validColumns() {
+        const typesValid = [
+            'string',
+            'number',
+            'boolean',
+            'date',
+            'time',
+            'dateTime',
+            'currency',
+            'subtitle',
+            'link',
+            'label',
+            'icon',
+            'cellTemplate',
+            'columnTemplate'
+        ];
+        return this.columns.filter(col => !col.type || typesValid.includes(col.type));
+    }
+    get sortType() {
+        return this.sortedColumn.ascending ? PoTableColumnSortType.Ascending : PoTableColumnSortType.Descending;
+    }
+    ngOnDestroy() {
+        this.poTableServiceSubscription?.unsubscribe();
+    }
+    ngOnChanges(changes) {
+        if (this.singleSelect || this.hideSelectAll) {
+            this.selectAll = false;
+            this.hideSelectAll = true;
+        }
+        if (changes.height) {
+            this.calculateHeightTableContainer(this.height);
+        }
+    }
+    selectAllRows() {
+        if (!this.hideSelectAll) {
+            this.selectAll = !this.selectAll;
+            this.items.forEach(item => {
+                item.$selected = this.selectAll;
+            });
+            this.emitSelectAllEvents(this.selectAll, [...this.items]);
+        }
+    }
+    selectRow(row) {
+        row.$selected = !row.$selected;
+        this.emitSelectEvents(row);
+        this.configAfterSelectRow(this.items, row);
+    }
+    selectDetailRow(row) {
+        this.emitSelectEvents(row);
+    }
+    getClassColor(row, column) {
+        return column.color ? `po-text-${this.getColumnColor(row, column)}` : '';
+    }
+    toggleDetail(row) {
+        const rowShowDetail = row.$showDetail;
+        if (this.autoCollapse) {
+            this.collapseAllItems(this.items);
+        }
+        this.setShowDetail(row, !rowShowDetail);
+        this.emitExpandEvents(row);
+    }
+    toggleRowAction(row) {
+        const toggleShowAction = row.$showAction;
+        this.items.forEach(item => {
+            if (item.$showAction) {
+                item.$showAction = false;
+            }
+        });
+        row.$showAction = !toggleShowAction;
+    }
+    sortColumn(column) {
+        if (!this.sort || column.type === 'detail' || column.sortable === false) {
+            return;
+        }
+        this.sortedColumn.ascending = this.sortedColumn.property === column ? !this.sortedColumn.ascending : true;
+        this.sortArray(column, this.sortedColumn.ascending);
+        this.sortBy.emit({ column, type: this.sortType });
+        if (this.hasService && this.sort) {
+            this.sortStore = { column, type: this.sortType };
+        }
+        this.sortedColumn.property = column;
+    }
+    onShowMore() {
+        const sort = this.sortedColumn.property ? { column: this.sortedColumn.property, type: this.sortType } : undefined;
+        if (this.hasService) {
+            this.page++;
+            this.loading = true;
+            this.loadingShowMore = true;
+            this.poTableServiceSubscription = this.getFilteredItems().subscribe(data => {
+                this.items = [...this.items, ...data.items];
+                this.showMoreDisabled = !data.hasNext;
+                this.loading = false;
+                this.loadingShowMore = false;
+            });
+        }
+        this.showMore.emit(sort);
+    }
+    getFilteredItems(queryParams) {
+        const filteredParams = this.getFilteredParams(queryParams);
+        return this.poTableService.getFilteredItems(filteredParams);
+    }
+    setTableResponseProperties(data) {
+        this.items = data.items || [];
+        this.showMoreDisabled = !data.hasNext;
+        this.loading = false;
+    }
+    initializeData(params) {
+        if (this.hasService) {
+            this.loading = true;
+            this.getFilteredItems(params).subscribe(data => {
+                this.setTableResponseProperties(data);
+            });
+        }
+    }
+    getDefaultColumns(item) {
+        const keys = Object.keys(item);
+        return keys
+            .filter(key => typeof item[key] !== 'object')
+            .map(key => ({ label: capitalizeFirstLetter(key), property: key }));
+    }
+    setShowDetail(rowIdentifier, isShowDetail) {
+        const isRowIndex = typeof rowIdentifier === 'number' && this.items[rowIdentifier];
+        const row = isRowIndex ? this.items[rowIdentifier] : rowIdentifier;
+        row.$showDetail = isShowDetail;
+    }
+    collapseAllItems(items) {
+        for (const item of items) {
+            if (item.$showDetail) {
+                this.setShowDetail(item, false);
+                this.emitExpandEvents(item);
+            }
+        }
+    }
+    configAfterSelectRow(rows, row) {
+        if (this.singleSelect) {
+            this.unselectOtherRows(rows, row);
+        }
+        else if (!this.hideSelectAll) {
+            this.selectAll = this.isEverySelected(rows);
+        }
+    }
+    emitExpandEvents(row) {
+        row.$showDetail ? this.expanded.emit(row) : this.collapsed.emit(row);
+    }
+    emitSelectAllEvents(selectAll, rows) {
+        selectAll ? this.allSelected.emit(rows) : this.allUnselected.emit(rows);
+    }
+    emitSelectEvents(row) {
+        row.$selected ? this.selected.emit(row) : this.unselected.emit(row);
+    }
+    getColumnColor(row, column) {
+        const columnColor = column.color;
+        return isTypeof(columnColor, 'function') ? columnColor(row, column.property) : columnColor;
+    }
+    // Retorna a coluna da lista de colunas que é do tipo detail
+    getColumnMasterDetail() {
+        return this.columns.find(col => col.type === 'detail');
+    }
+    // Colunas que são inseridas no <head> da tabela
+    getMainColumns() {
+        return this.validColumns.filter(col => col.visible !== false);
+    }
+    // Retorna as colunas com status
+    getSubtitleColumns() {
+        return this.columns.filter(col => col.type === 'subtitle');
+    }
+    isEverySelected(items) {
+        const someCheckedOrIndeterminate = item => item.$selected || item.$selected === null;
+        const everyChecked = item => item.$selected;
+        if (items.every(everyChecked)) {
+            return true;
+        }
+        if (items.some(someCheckedOrIndeterminate)) {
+            return null;
+        }
+        return false;
+    }
+    onChangeColumns() {
+        this.setMainColumns();
+        this.setColumnMasterDetail();
+        this.setSubtitleColumns();
+    }
+    setColumnLink() {
+        this.columns.forEach(column => {
+            if (column['type'] === 'link' && !column['link']) {
+                column['link'] = 'link';
+            }
+        });
+    }
+    setColumnMasterDetail() {
+        this.columnMasterDetail = this.getColumnMasterDetail();
+    }
+    setMainColumns() {
+        this.mainColumns = this.getMainColumns();
+        this.hasMainColumns = !!this.mainColumns.length;
+        this.allColumnsWidthPixels = this.verifyWidthColumnsPixels();
+    }
+    setSubtitleColumns() {
+        this.subtitleColumns = this.getSubtitleColumns();
+    }
+    sortArray(column, ascending) {
+        this.items.sort((leftSide, rightSide) => sortValues(leftSide[column.property], rightSide[column.property], ascending));
+    }
+    unselectOtherRows(rows, row) {
+        rows.forEach(item => {
+            if (item !== row) {
+                item.$selected = false;
+            }
+        });
+    }
+    verifyWidthColumnsPixels() {
+        return this.hasMainColumns ? this.mainColumns.every(column => column.width && column.width.includes('px')) : false;
+    }
+    setService(service) {
+        if (service && isTypeof(service, 'string')) {
+            this.poTableService.setUrl(service);
+        }
+    }
+    getFilteredParams(queryParams) {
+        const { page, pageSize, sortStore } = this;
+        const filteredParams = {};
+        const order = this.getOrderParam(sortStore);
+        const params = { page, pageSize, order, ...queryParams };
+        for (const key in params) {
+            if (params.hasOwnProperty(key) && params[key] !== undefined) {
+                filteredParams[key] = params[key];
+            }
+        }
+        return filteredParams;
+    }
+    getOrderParam(sort = { type: undefined }) {
+        const { column, type } = sort;
+        if (!column) {
+            return;
+        }
+        if (type === PoTableColumnSortType.Descending) {
+            return `-${column.property}`;
+        }
+        return `${column.property}`;
+    }
+}
+PoTableBaseComponent.ɵfac = function PoTableBaseComponent_Factory(t) { return new (t || PoTableBaseComponent)(i0.ɵɵdirectiveInject(i1.PoDateService), i0.ɵɵdirectiveInject(i2.PoLanguageService), i0.ɵɵdirectiveInject(i3.PoTableService)); };
+PoTableBaseComponent.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: PoTableBaseComponent, inputs: { hideTextOverflow: ["p-hide-text-overflow", "hideTextOverflow"], hideColumnsManager: ["p-hide-columns-manager", "hideColumnsManager"], autoCollapse: ["p-auto-collapse", "autoCollapse"], loadingShowMore: ["p-loading-show-more", "loadingShowMore"], sort: ["p-sort", "sort"], showMoreDisabled: ["p-show-more-disabled", "showMoreDisabled"], striped: ["p-striped", "striped"], hideSelectAll: ["p-hide-select-all", "hideSelectAll"], singleSelect: ["p-single-select", "singleSelect"], actionRight: ["p-actions-right", "actionRight"], maxColumns: ["p-max-columns", "maxColumns"], items: ["p-items", "items"], columns: ["p-columns", "columns"], container: ["p-container", "container"], height: ["p-height", "height"], hideDetail: ["p-hide-detail", "hideDetail"], literals: ["p-literals", "literals"], loading: ["p-loading", "loading"], actions: ["p-actions", "actions"], selectable: ["p-selectable", "selectable"], infiniteScroll: ["p-infinite-scroll", "infiniteScroll"], infiniteScrollDistance: ["p-infinite-scroll-distance", "infiniteScrollDistance"], serviceApi: ["p-service-api", "serviceApi"] }, outputs: { allSelected: "p-all-selected", allUnselected: "p-all-unselected", collapsed: "p-collapsed", expanded: "p-expanded", selected: "p-selected", showMore: "p-show-more", sortBy: "p-sort-by", unselected: "p-unselected", changeVisibleColumns: "p-change-visible-columns" }, features: [i0.ɵɵNgOnChangesFeature] });
+__decorate([
+    InputBoolean()
+], PoTableBaseComponent.prototype, "hideTextOverflow", void 0);
+__decorate([
+    InputBoolean()
+], PoTableBaseComponent.prototype, "hideColumnsManager", void 0);
+__decorate([
+    InputBoolean()
+], PoTableBaseComponent.prototype, "autoCollapse", void 0);
+__decorate([
+    InputBoolean()
+], PoTableBaseComponent.prototype, "loadingShowMore", void 0);
+__decorate([
+    InputBoolean()
+], PoTableBaseComponent.prototype, "sort", void 0);
+__decorate([
+    InputBoolean()
+], PoTableBaseComponent.prototype, "showMoreDisabled", void 0);
+__decorate([
+    InputBoolean()
+], PoTableBaseComponent.prototype, "striped", void 0);
+__decorate([
+    InputBoolean()
+], PoTableBaseComponent.prototype, "hideSelectAll", void 0);
+__decorate([
+    InputBoolean()
+], PoTableBaseComponent.prototype, "singleSelect", void 0);
+__decorate([
+    InputBoolean()
+], PoTableBaseComponent.prototype, "actionRight", void 0);
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PoTableBaseComponent, [{
+        type: Directive
+    }], function () { return [{ type: i1.PoDateService }, { type: i2.PoLanguageService }, { type: i3.PoTableService }]; }, { hideTextOverflow: [{
+            type: Input,
+            args: ['p-hide-text-overflow']
+        }], hideColumnsManager: [{
+            type: Input,
+            args: ['p-hide-columns-manager']
+        }], autoCollapse: [{
+            type: Input,
+            args: ['p-auto-collapse']
+        }], loadingShowMore: [{
+            type: Input,
+            args: ['p-loading-show-more']
+        }], sort: [{
+            type: Input,
+            args: ['p-sort']
+        }], showMoreDisabled: [{
+            type: Input,
+            args: ['p-show-more-disabled']
+        }], striped: [{
+            type: Input,
+            args: ['p-striped']
+        }], hideSelectAll: [{
+            type: Input,
+            args: ['p-hide-select-all']
+        }], singleSelect: [{
+            type: Input,
+            args: ['p-single-select']
+        }], actionRight: [{
+            type: Input,
+            args: ['p-actions-right']
+        }], maxColumns: [{
+            type: Input,
+            args: ['p-max-columns']
+        }], allSelected: [{
+            type: Output,
+            args: ['p-all-selected']
+        }], allUnselected: [{
+            type: Output,
+            args: ['p-all-unselected']
+        }], collapsed: [{
+            type: Output,
+            args: ['p-collapsed']
+        }], expanded: [{
+            type: Output,
+            args: ['p-expanded']
+        }], selected: [{
+            type: Output,
+            args: ['p-selected']
+        }], showMore: [{
+            type: Output,
+            args: ['p-show-more']
+        }], sortBy: [{
+            type: Output,
+            args: ['p-sort-by']
+        }], unselected: [{
+            type: Output,
+            args: ['p-unselected']
+        }], changeVisibleColumns: [{
+            type: Output,
+            args: ['p-change-visible-columns']
+        }], items: [{
+            type: Input,
+            args: ['p-items']
+        }], columns: [{
+            type: Input,
+            args: ['p-columns']
+        }], container: [{
+            type: Input,
+            args: ['p-container']
+        }], height: [{
+            type: Input,
+            args: ['p-height']
+        }], hideDetail: [{
+            type: Input,
+            args: ['p-hide-detail']
+        }], literals: [{
+            type: Input,
+            args: ['p-literals']
+        }], loading: [{
+            type: Input,
+            args: ['p-loading']
+        }], actions: [{
+            type: Input,
+            args: ['p-actions']
+        }], selectable: [{
+            type: Input,
+            args: ['p-selectable']
+        }], infiniteScroll: [{
+            type: Input,
+            args: ['p-infinite-scroll']
+        }], infiniteScrollDistance: [{
+            type: Input,
+            args: ['p-infinite-scroll-distance']
+        }], serviceApi: [{
+            type: Input,
+            args: ['p-service-api']
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-table-base.component.js","sourceRoot":"","sources":["../../../../../../projects/ui/src/lib/components/po-table/po-table-base.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  EventEmitter,\n  Input,\n  OnChanges,\n  Output,\n  Directive,\n  SimpleChanges,\n  OnDestroy,\n  ViewChild,\n  ElementRef\n} from '@angular/core';\nimport { Observable, Subscription } from 'rxjs';\n\nimport { capitalizeFirstLetter, convertToBoolean, isTypeof, sortValues } from '../../utils/util';\nimport { PoDateService } from '../../services/po-date/po-date.service';\nimport { PoLanguageService } from '../../services/po-language/po-language.service';\nimport { poLocaleDefault } from '../../services/po-language/po-language.constant';\n\nimport { PoTableAction } from './interfaces/po-table-action.interface';\nimport { PoTableColumn } from './interfaces/po-table-column.interface';\nimport { PoTableColumnSort } from './interfaces/po-table-column-sort.interface';\nimport { PoTableColumnSortType } from './enums/po-table-column-sort-type.enum';\nimport { PoTableLiterals } from './interfaces/po-table-literals.interface';\nimport { InputBoolean } from '../../decorators';\nimport { PoTableService } from './services/po-table.service';\nimport { PoTableResponseApi } from './interfaces/po-table-response-api.interface';\nimport { PoTableFilteredItemsParams } from './interfaces/po-table-filtered-items-params.interface';\n\nexport type QueryParamsType = string | number | boolean;\n\nexport const poTableContainer = ['border', 'shadow'];\nexport const poTableContainerDefault = 'border';\n\nexport const poTableLiteralsDefault = {\n  en: <PoTableLiterals>{\n    noColumns: 'Columns are not defined',\n    noData: 'No data found',\n    noVisibleColumn: 'No visible column',\n    loadingData: 'Loading',\n    loadMoreData: 'Load more data',\n    seeCompleteSubtitle: 'See complete subtitle',\n    completeSubtitle: 'Complete subtitle',\n    columnsManager: 'Columns manager'\n  },\n  es: <PoTableLiterals>{\n    noColumns: 'Columnas no definidas',\n    noData: 'Datos no encontrados',\n    noVisibleColumn: 'Sin columnas visibles',\n    loadingData: 'Cargando datos',\n    loadMoreData: 'Cargar más resultados',\n    seeCompleteSubtitle: 'Ver subtitulo completo',\n    completeSubtitle: 'Subtitulo completo',\n    columnsManager: 'Gerente de columna'\n  },\n  pt: <PoTableLiterals>{\n    noColumns: 'Nenhuma definição de colunas',\n    noData: 'Nenhum dado encontrado',\n    noVisibleColumn: 'Nenhuma coluna visível',\n    loadingData: 'Carregando',\n    loadMoreData: 'Carregar mais resultados',\n    seeCompleteSubtitle: 'Ver legenda completa',\n    completeSubtitle: 'Legenda completa',\n    columnsManager: 'Gerenciador de colunas'\n  },\n  ru: <PoTableLiterals>{\n    noColumns: 'Нет определения столбца',\n    noData: 'Данные не найдены',\n    noVisibleColumn: 'нет видимых столбцов',\n    loadingData: 'погрузка',\n    loadMoreData: 'загрузка',\n    seeCompleteSubtitle: 'Посмотреть полный субтитр',\n    completeSubtitle: 'Полный заголовок',\n    columnsManager: 'менеджер колонок'\n  }\n};\n\n/**\n * @description\n *\n * Este componente de tabela é utilizado para exibição de dados com diferentes tipos como por exemplo textos, data, horas e números com\n * formato personalizado.\n *\n * Também é possivel criar tabelas com ordenação de dados, linhas com detalhes, coluna para seleção de linhas, coluna com ações e também\n * carregamento por demanda através do botão **Carregar mais resultados**.\n *\n * > As linhas de detalhes podem também ser customizadas através do [`p-table-row-template`](/documentation/po-table-row-template).\n *\n * > As colunas podem ser customizadas através dos templates [`p-table-column-template`](/documentation/po-table-column-template)\n * e [`p-table-cell-template`](/documentation/po-table-cell-template).\n *\n * O componente permite gerenciar a exibição das colunas dinamicamente. Esta funcionalidade pode ser acessada através do ícone de engrenagem\n * no canto superior direito do cabeçalho da tabela.\n *\n * Caso a largura de todas as colunas forem definidas e o total ultrapassar o tamanho tabela, será exibido um *scroll* na horizontal para a\n * completa visualização dos dados.\n */\n@Directive()\nexport abstract class PoTableBaseComponent implements OnChanges, OnDestroy {\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Se verdadeiro, habilita a quebra de texto ao transborda-lo dentro de qualquer coluna.\n   * > Quando ocorrer a quebra de texto, ao passar o mouse no conteúdo da célula,\n   * o mesmo será exibido através do [`po-tooltip`](/documentation/po-tooltip).\n   */\n  @Input('p-hide-text-overflow') @InputBoolean() hideTextOverflow: boolean = false;\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Permite que o gerenciador de colunas, responsável pela definição de quais colunas serão exibidas, seja escondido.\n   *\n   * @default `false`\n   */\n  @Input('p-hide-columns-manager') @InputBoolean() hideColumnsManager?: boolean = false;\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Permite fechar um detalhe ou row template automaticamente, ao abrir outro item.\n   *\n   * @default `false`\n   */\n  @Input('p-auto-collapse') @InputBoolean() autoCollapse?: boolean = false;\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Permite que seja adicionado o estado de carregamento no botão \"Carregar mais resultados\".\n   *\n   * @default `false`\n   */\n  @Input('p-loading-show-more') @InputBoolean() loadingShowMore?: boolean = false;\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Habilita em todas as colunas a opção de ordenação de dados. Caso a coluna seja do tipo 'data' ou 'dateTime' a\n   * mesma deve respeitar os tipos de entrada definidos para que sejam ordenadas.\n   *\n   * @default `false`\n   */\n  @Input('p-sort') @InputBoolean() sort: boolean = false;\n\n  /**\n   * @description\n   *\n   * Se verdadeiro, torna habilitado o botão \"Carregar mais resultados\".\n   *\n   * @default `false`\n   */\n  @Input('p-show-more-disabled') @InputBoolean() showMoreDisabled?: boolean = false;\n\n  /**\n   * @description\n   *\n   * Habilita ou desabilita o estilo listrado da tabela (`striped`).\n   * > Recomendado para tabelas com maior número de dados, facilitando a sua visualização na tabela.\n   *\n   * @default `false`\n   */\n  @Input('p-striped') @InputBoolean() striped?: boolean = false;\n\n  /**\n   * @description\n   *\n   * Esconde o *checkbox* para seleção de todas as linhas.\n   *\n   * > Sempre receberá *true* caso a seleção de apenas uma linha esteja ativa.\n   *\n   * @default `false`\n   */\n  @Input('p-hide-select-all') @InputBoolean() hideSelectAll: boolean = false;\n\n  /**\n   * @description\n   *\n   * Define que somente uma linha da tabela pode ser selecionada.\n   *\n   * > Esta definição não se aplica aos itens filhos, os mesmos possuem comportamento independente do item pai.\n   */\n  @Input('p-single-select') @InputBoolean() singleSelect?: boolean = false;\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Define que a coluna de ações ficará no lado direito da tabela.\n   *\n   * @default `false`\n   */\n  @Input('p-actions-right') @InputBoolean() actionRight?: boolean = false;\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Define uma quantidade máxima de colunas que serão exibidas na tabela.\n   *\n   * Quando chegar no valor informado, as colunas que não estiverem selecionadas ficarão\n   * desabilitadas e caso houver mais colunas visíveis do que o permitido, as excedentes\n   * serão ignoradas por ordem de posição.\n   */\n  @Input('p-max-columns') maxColumns?: number;\n\n  /**\n   * @optional\n   *\n   * @description\n   * Evento executado quando todas as linhas são selecionadas por meio do *checkbox* que seleciona todas as linhas.\n   */\n  @Output('p-all-selected') allSelected: EventEmitter<any> = new EventEmitter<any>();\n\n  /**\n   * @optional\n   *\n   * @description\n   * Evento executado quando a seleção das linhas é desmarcada por meio do *checkbox* que seleciona todas as linhas.\n   */\n  @Output('p-all-unselected') allUnselected: EventEmitter<any> = new EventEmitter<any>();\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Evento executado ao colapsar uma linha do `po-table`.\n   *\n   * > Como parâmetro o componente envia o item colapsado.\n   */\n  @Output('p-collapsed') collapsed: EventEmitter<any> = new EventEmitter<any>();\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Evento executado ao expandir uma linha do `po-table`.\n   *\n   * > Como parâmetro o componente envia o item expandido.\n   */\n  @Output('p-expanded') expanded: EventEmitter<any> = new EventEmitter<any>();\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Evento executado ao selecionar uma linha do `po-table`.\n   */\n  @Output('p-selected') selected: EventEmitter<any> = new EventEmitter<any>();\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Recebe uma ação de clique para o botão \"Carregar mais resultados\", caso nenhuma ação for definida o mesmo\n   * não é visível.\n   *\n   * Recebe um objeto `{ column, type }` onde:\n   *\n   * - column (`PoTableColumn`): objeto da coluna que está ordenada.\n   * - type (`PoTableColumnSortType`): tipo da ordenação.\n   */\n  @Output('p-show-more') showMore: EventEmitter<PoTableColumnSort> = new EventEmitter<PoTableColumnSort>();\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Evento executado ao ordenar colunas da tabela.\n   *\n   * Recebe um objeto `{ column, type }` onde:\n   *\n   * - column (`PoTableColumn`): objeto da coluna que foi clicada/ordenada.\n   * - type (`PoTableColumnSortType`): tipo da ordenação.\n   */\n  @Output('p-sort-by') sortBy: EventEmitter<PoTableColumnSort> = new EventEmitter<PoTableColumnSort>();\n\n  /**\n   * @optional\n   *\n   * @description\n   * Evento executado ao desmarcar a seleção de uma linha do `po-table`.\n   */\n  @Output('p-unselected') unselected: EventEmitter<any> = new EventEmitter<any>();\n\n  /**\n   * @optional\n   *\n   * @description\n   * Evento disparado ao fechar o popover do gerenciador de colunas após alterar as colunas visíveis.\n   *\n   * O componente envia como parâmetro um array de string com as colunas visíveis atualizadas.\n   * Por exemplo: [\"idCard\", \"name\", \"hireStatus\", \"age\"].\n   */\n  @Output('p-change-visible-columns') changeVisibleColumns = new EventEmitter<Array<string>>();\n\n  allColumnsWidthPixels: boolean;\n  columnMasterDetail: PoTableColumn;\n  hasMainColumns: boolean = false;\n  mainColumns: Array<PoTableColumn> = [];\n  selectAll = false;\n  sortedColumn = { property: <PoTableColumn>null, ascending: true };\n  subtitleColumns: Array<PoTableColumn> = [];\n  page = 1;\n  pageSize = 10;\n  hasService?: boolean = false;\n\n  private _actions?: Array<PoTableAction> = [];\n  private _columns: Array<PoTableColumn> = [];\n  private _container?: string;\n  private _height?: number;\n  private _hideDetail?: boolean = false;\n  private _items: Array<PoTableColumn>;\n  private _literals: PoTableLiterals;\n  private _loading?: boolean = false;\n  private _selectable?: boolean;\n  private language: string = poLocaleDefault;\n  private _serviceApi: string;\n  private poTableServiceSubscription: Subscription;\n  private sortStore: PoTableColumnSort;\n  private _infiniteScrollDistance?: number = 100;\n  private _infiniteScroll?: boolean = false;\n\n  /**\n   * @description\n   *\n   * Lista de itens da tabela.\n   * > Se falso, será inicializado como um *array* vazio.\n   */\n  @Input('p-items') set items(items: Array<any>) {\n    this._items = Array.isArray(items) ? items : [];\n\n    // when haven't items, selectAll should be unchecked.\n    if (!this.hasItems) {\n      this.selectAll = false;\n    } else if (!this.hasColumns) {\n      this.columns = this.getDefaultColumns(items[0]);\n    }\n\n    // timeout necessario para os itens serem refletidos na tabela\n    setTimeout(() => this.checkInfiniteScroll());\n  }\n\n  get items() {\n    return this._items;\n  }\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Lista das colunas da tabela, deve receber um *array* de objetos que implementam a interface `PoTableColumn`.\n   * Por padrão receberá como valor a primeira coluna da lista de itens da tabela.\n   * > Caso não encontre valor, a mensagem 'Nenhuma definição de colunas' será exibida.\n   *\n   */\n  @Input('p-columns') set columns(columns: Array<PoTableColumn>) {\n    this._columns = columns || [];\n\n    if (this._columns.length) {\n      this.setColumnLink();\n      this.calculateWidthHeaders();\n    } else if (this.hasItems) {\n      this._columns = this.getDefaultColumns(this.items[0]);\n    }\n\n    this.onChangeColumns();\n  }\n\n  get columns() {\n    return this._columns;\n  }\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Adiciona um contorno arredondado ao `po-table`, as opções são:\n   * - `border`: com bordas/linhas.\n   * - `shadow`: com sombras.\n   *\n   * @default `border`\n   */\n  @Input('p-container') set container(value: string) {\n    this._container = poTableContainer.includes(value) ? value : poTableContainerDefault;\n  }\n\n  get container(): string {\n    return this._container;\n  }\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Define a altura da tabela em *pixels* e fixa o cabeçalho.\n   */\n  @Input('p-height') set height(height: number) {\n    this._height = height;\n    this.calculateWidthHeaders();\n  }\n\n  get height() {\n    return this._height;\n  }\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Habilita a visualização da lista de detalhes de cada linha da coluna.\n   *\n   * @default `false`\n   */\n  @Input('p-hide-detail') set hideDetail(hideDetail: boolean) {\n    this._hideDetail = hideDetail != null && hideDetail.toString() === '' ? true : convertToBoolean(hideDetail);\n    this.calculateWidthHeaders();\n  }\n\n  get hideDetail() {\n    return this._hideDetail;\n  }\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Objeto com as literais usadas no `po-table`.\n   *\n   * Existem duas maneiras de customizar o componente, passando um objeto com todas as literais disponíveis:\n   *\n   * ```\n   *  const customLiterals: PoTableLiterals = {\n   *    loadMoreData: 'Buscar mais dados',\n   *    loadingData: 'Processando',\n   *    noColumns: 'Sem colunas',\n   *    noData: 'Sem dados',\n   *    seeCompleteSubtitle: 'Mostrar legenda completa',\n   *    completeSubtitle: 'Todas legendas'\n   *  };\n   * ```\n   *\n   * Ou passando apenas as literais que deseja customizar:\n   *\n   * ```\n   *  const customLiterals: PoTableLiterals = {\n   *    noData: 'Sem dados'\n   *  };\n   * ```\n   *\n   * E para carregar as literais customizadas, basta apenas passar o objeto para o componente.\n   *\n   * ```\n   * <po-table\n   *   [p-literals]=\"customLiterals\">\n   * </po-table>\n   * ```\n   *\n   * > O objeto padrão de literais será traduzido de acordo com o idioma do\n   * [`PoI18nService`](/documentation/po-i18n) ou do browser.\n   */\n  @Input('p-literals') set literals(value: PoTableLiterals) {\n    if (value instanceof Object && !(value instanceof Array)) {\n      this._literals = {\n        ...poTableLiteralsDefault[poLocaleDefault],\n        ...poTableLiteralsDefault[this.language],\n        ...value\n      };\n    } else {\n      this._literals = poTableLiteralsDefault[this.language];\n    }\n  }\n  get literals() {\n    return this._literals || poTableLiteralsDefault[this.language];\n  }\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Bloqueia a interação do usuário com os dados da _table_.\n   *\n   * @default `false`\n   */\n  @Input('p-loading') set loading(loading: boolean) {\n    this._loading = convertToBoolean(loading);\n    this.calculateWidthHeaders();\n  }\n\n  get loading() {\n    return this._loading;\n  }\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Define uma lista de ações.\n   *\n   * Quando houver apenas uma ação definida ela será exibida diretamente na coluna, caso contrário, o componente\n   * se encarrega de agrupá-las exibindo o ícone [**po-icon-more**](/guides/icons) que listará as ações ao ser clicado.\n   *\n   * **A coluna de ações não será exibida quando:**\n   *  - a lista conter valores inválidos ou indefinidos.\n   *  - tenha uma única ação e a mesma não for visível.\n   */\n  @Input('p-actions') set actions(actions: Array<PoTableAction>) {\n    this._actions = actions;\n    this.calculateWidthHeaders();\n  }\n\n  get actions() {\n    return this._actions;\n  }\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Permite a seleção de linhas na tabela e, caso a propriedade `p-single-select` esteja definida será possível\n   * selecionar apenas uma única linha.\n   *\n   * **Importante:**\n   *  - As linhas de detalhe definidas em `PoTableDetail` possuem comportamento independente da linha mestre;\n   *  - Cada linha possui por padrão a propriedade dinâmica `$selected`, na qual é possível validar se a linha\n   * está selecionada, por exemplo: `item.$selected` ou `item['$selected']`.\n   *\n   * @default `false`\n   */\n  @Input('p-selectable') set selectable(value: boolean) {\n    this._selectable = <any>value === '' ? true : convertToBoolean(value);\n    this.calculateWidthHeaders();\n  }\n\n  get selectable() {\n    return this._selectable;\n  }\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Se verdadeiro, ativa a funcionalidade de scroll infinito para a tabela e o botão \"Carregar Mais\" deixará de ser exibido. Ao chegar no fim da tabela\n   * executará a função `p-show-more`.\n   *\n   * **Regras de utilização:**\n   *  - O scroll infinito só funciona para tabelas que utilizam a propriedade `p-height` e que possuem o scroll já na carga inicial dos dados.\n   *\n   * @default `false`\n   */\n  @Input('p-infinite-scroll') set infiniteScroll(value: boolean) {\n    this._infiniteScroll = convertToBoolean(value && this.height > 0);\n  }\n\n  get infiniteScroll() {\n    return this._infiniteScroll;\n  }\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * Define o percentual necessário para disparar o evento `p-show-more`, que é responsável por carregar mais dados na tabela. Caso o valor informado seja maior que 100 ou menor\n   * que 0, o valor padrão será 100%\n   *\n   * **Exemplos:**\n   *  - p-infinite-scroll-distance = 80: Quando atingir 80%  do scroll da tabela, o `p-show-more` será disparado.\n   */\n  @Input('p-infinite-scroll-distance') set infiniteScrollDistance(value: number) {\n    this._infiniteScrollDistance = value > 100 || value < 0 ? 100 : value;\n  }\n\n  get infiniteScrollDistance() {\n    return this._infiniteScrollDistance;\n  }\n\n  /**\n   * @optional\n   *\n   * @description\n   *\n   * URL da API responsável por retornar os registros.\n   *\n   * Ao realizar a busca de mais registros via paginação (Carregar mais resultados), será enviado os parâmetros `page` e `pageSize`, conforme abaixo:\n   *\n   * ```\n   * url + ?page=1&pageSize=10\n   * ```\n   *\n   * Caso utilizar ordenação, a coluna ordenada será enviada através do parâmetro `order`, por exemplo:\n   * - Coluna decrescente:\n   * ```\n   *  url + ?page=1&pageSize=10&order=-name\n   * ```\n   *\n   * - Coluna ascendente:\n   * ```\n   *  url + ?page=1&pageSize=10&order=name\n   * ```\n   *\n   * > Esta URL deve retornar e receber os dados no padrão de [API do PO UI](https://po-ui.io/guides/api).\n   */\n  @Input('p-service-api') set serviceApi(service: string) {\n    this._serviceApi = service;\n    this.setService(this.serviceApi);\n    this.hasService = !!service;\n    this.showMoreDisabled = !this.hasService;\n    this.page = 1;\n    this.initializeData();\n  }\n\n  get serviceApi() {\n    return this._serviceApi;\n  }\n\n  get hasColumns(): boolean {\n    return this.columns && this.columns.length > 0;\n  }\n\n  get hasItems(): boolean {\n    return !!(this.items && this.items.length);\n  }\n\n  get nameColumnDetail() {\n    return this.columnMasterDetail ? this.columnMasterDetail.property : null;\n  }\n\n  get validColumns() {\n    const typesValid = [\n      'string',\n      'number',\n      'boolean',\n      'date',\n      'time',\n      'dateTime',\n      'currency',\n      'subtitle',\n      'link',\n      'label',\n      'icon',\n      'cellTemplate',\n      'columnTemplate'\n    ];\n    return this.columns.filter(col => !col.type || typesValid.includes(col.type));\n  }\n\n  private get sortType(): PoTableColumnSortType {\n    return this.sortedColumn.ascending ? PoTableColumnSortType.Ascending : PoTableColumnSortType.Descending;\n  }\n\n  constructor(\n    private poDate: PoDateService,\n    languageService: PoLanguageService,\n    private poTableService: PoTableService\n  ) {\n    this.language = languageService.getShortLanguage();\n  }\n\n  ngOnDestroy() {\n    this.poTableServiceSubscription?.unsubscribe();\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (this.singleSelect || this.hideSelectAll) {\n      this.selectAll = false;\n      this.hideSelectAll = true;\n    }\n\n    if (changes.height) {\n      this.calculateHeightTableContainer(this.height);\n    }\n  }\n\n  selectAllRows() {\n    if (!this.hideSelectAll) {\n      this.selectAll = !this.selectAll;\n\n      this.items.forEach(item => {\n        item.$selected = this.selectAll;\n      });\n\n      this.emitSelectAllEvents(this.selectAll, [...this.items]);\n    }\n  }\n\n  selectRow(row: any) {\n    row.$selected = !row.$selected;\n\n    this.emitSelectEvents(row);\n\n    this.configAfterSelectRow(this.items, row);\n  }\n\n  selectDetailRow(row: any) {\n    this.emitSelectEvents(row);\n  }\n\n  getClassColor(row, column) {\n    return column.color ? `po-text-${this.getColumnColor(row, column)}` : '';\n  }\n\n  toggleDetail(row: any) {\n    const rowShowDetail = row.$showDetail;\n    if (this.autoCollapse) {\n      this.collapseAllItems(this.items);\n    }\n\n    this.setShowDetail(row, !rowShowDetail);\n    this.emitExpandEvents(row);\n  }\n\n  toggleRowAction(row: any) {\n    const toggleShowAction = row.$showAction;\n\n    this.items.forEach(item => {\n      if (item.$showAction) {\n        item.$showAction = false;\n      }\n    });\n    row.$showAction = !toggleShowAction;\n  }\n\n  sortColumn(column: PoTableColumn) {\n    if (!this.sort || column.type === 'detail' || column.sortable === false) {\n      return;\n    }\n\n    this.sortedColumn.ascending = this.sortedColumn.property === column ? !this.sortedColumn.ascending : true;\n\n    this.sortArray(column, this.sortedColumn.ascending);\n    this.sortBy.emit({ column, type: this.sortType });\n    if (this.hasService && this.sort) {\n      this.sortStore = { column, type: this.sortType };\n    }\n\n    this.sortedColumn.property = column;\n  }\n\n  onShowMore(): void {\n    const sort = this.sortedColumn.property ? { column: this.sortedColumn.property, type: this.sortType } : undefined;\n\n    if (this.hasService) {\n      this.page++;\n      this.loading = true;\n      this.loadingShowMore = true;\n\n      this.poTableServiceSubscription = this.getFilteredItems().subscribe(data => {\n        this.items = [...this.items, ...data.items];\n        this.showMoreDisabled = !data.hasNext;\n        this.loading = false;\n        this.loadingShowMore = false;\n      });\n    }\n\n    this.showMore.emit(sort);\n  }\n\n  getFilteredItems(queryParams?: { [key: string]: QueryParamsType }): Observable<PoTableResponseApi> {\n    const filteredParams: PoTableFilteredItemsParams = this.getFilteredParams(queryParams);\n\n    return this.poTableService.getFilteredItems(filteredParams);\n  }\n\n  setTableResponseProperties(data: PoTableResponseApi) {\n    this.items = data.items || [];\n    this.showMoreDisabled = !data.hasNext;\n    this.loading = false;\n  }\n\n  initializeData(params?: { [key: string]: QueryParamsType }): void {\n    if (this.hasService) {\n      this.loading = true;\n      this.getFilteredItems(params).subscribe(data => {\n        this.setTableResponseProperties(data);\n      });\n    }\n  }\n\n  protected getDefaultColumns(item: any) {\n    const keys = Object.keys(item);\n\n    return keys\n      .filter(key => typeof item[key] !== 'object')\n      .map(key => ({ label: capitalizeFirstLetter(key), property: key }));\n  }\n\n  protected setShowDetail(rowIdentifier: any | number, isShowDetail: boolean) {\n    const isRowIndex = typeof rowIdentifier === 'number' && this.items[rowIdentifier];\n\n    const row = isRowIndex ? this.items[rowIdentifier] : rowIdentifier;\n\n    row.$showDetail = isShowDetail;\n  }\n\n  private collapseAllItems(items: Array<{ [key: string]: any }>) {\n    for (const item of items) {\n      if (item.$showDetail) {\n        this.setShowDetail(item, false);\n        this.emitExpandEvents(item);\n      }\n    }\n  }\n\n  private configAfterSelectRow(rows: Array<any>, row) {\n    if (this.singleSelect) {\n      this.unselectOtherRows(rows, row);\n    } else if (!this.hideSelectAll) {\n      this.selectAll = this.isEverySelected(rows);\n    }\n  }\n\n  private emitExpandEvents(row: any) {\n    row.$showDetail ? this.expanded.emit(row) : this.collapsed.emit(row);\n  }\n\n  private emitSelectAllEvents(selectAll: boolean, rows: any) {\n    selectAll ? this.allSelected.emit(rows) : this.allUnselected.emit(rows);\n  }\n\n  private emitSelectEvents(row: any) {\n    row.$selected ? this.selected.emit(row) : this.unselected.emit(row);\n  }\n\n  private getColumnColor(row, column) {\n    const columnColor = column.color;\n\n    return isTypeof(columnColor, 'function') ? columnColor(row, column.property) : columnColor;\n  }\n\n  // Retorna a coluna da lista de colunas que é do tipo detail\n  private getColumnMasterDetail() {\n    return this.columns.find(col => col.type === 'detail');\n  }\n\n  // Colunas que são inseridas no <head> da tabela\n  private getMainColumns() {\n    return this.validColumns.filter(col => col.visible !== false);\n  }\n\n  // Retorna as colunas com status\n  private getSubtitleColumns() {\n    return this.columns.filter(col => col.type === 'subtitle');\n  }\n\n  private isEverySelected(items: Array<any>): boolean {\n    const someCheckedOrIndeterminate = item => item.$selected || item.$selected === null;\n    const everyChecked = item => item.$selected;\n\n    if (items.every(everyChecked)) {\n      return true;\n    }\n\n    if (items.some(someCheckedOrIndeterminate)) {\n      return null;\n    }\n\n    return false;\n  }\n\n  private onChangeColumns() {\n    this.setMainColumns();\n    this.setColumnMasterDetail();\n    this.setSubtitleColumns();\n  }\n\n  private setColumnLink() {\n    this.columns.forEach(column => {\n      if (column['type'] === 'link' && !column['link']) {\n        column['link'] = 'link';\n      }\n    });\n  }\n\n  private setColumnMasterDetail() {\n    this.columnMasterDetail = this.getColumnMasterDetail();\n  }\n\n  private setMainColumns() {\n    this.mainColumns = this.getMainColumns();\n\n    this.hasMainColumns = !!this.mainColumns.length;\n\n    this.allColumnsWidthPixels = this.verifyWidthColumnsPixels();\n  }\n\n  private setSubtitleColumns() {\n    this.subtitleColumns = this.getSubtitleColumns();\n  }\n\n  private sortArray(column: PoTableColumn, ascending: boolean) {\n    this.items.sort((leftSide, rightSide): number =>\n      sortValues(leftSide[column.property], rightSide[column.property], ascending)\n    );\n  }\n\n  private unselectOtherRows(rows: Array<any>, row) {\n    rows.forEach(item => {\n      if (item !== row) {\n        item.$selected = false;\n      }\n    });\n  }\n\n  private verifyWidthColumnsPixels() {\n    return this.hasMainColumns ? this.mainColumns.every(column => column.width && column.width.includes('px')) : false;\n  }\n\n  private setService(service: string) {\n    if (service && isTypeof(service, 'string')) {\n      this.poTableService.setUrl(service);\n    }\n  }\n\n  private getFilteredParams(queryParams?: { [key: string]: QueryParamsType }) {\n    const { page, pageSize, sortStore } = this;\n\n    const filteredParams = {};\n    const order = this.getOrderParam(sortStore);\n    const params = { page, pageSize, order, ...queryParams };\n\n    for (const key in params) {\n      if (params.hasOwnProperty(key) && params[key] !== undefined) {\n        filteredParams[key] = params[key];\n      }\n    }\n    return filteredParams;\n  }\n\n  private getOrderParam(sort: PoTableColumnSort = { type: undefined }) {\n    const { column, type } = sort;\n\n    if (!column) {\n      return;\n    }\n\n    if (type === PoTableColumnSortType.Descending) {\n      return `-${column.property}`;\n    }\n\n    return `${column.property}`;\n  }\n\n  protected abstract calculateHeightTableContainer(height);\n\n  protected abstract calculateWidthHeaders();\n\n  protected abstract checkInfiniteScroll();\n}\n"]}