ng-firebase-table-kxp 1.0.1 → 1.0.2

package/src/lib/components/table/table.component.ts

@@ -1,917 +0,0 @@
-import { Arrange, Condition, Tab, TabData, TableData } from '../../types/Table';
-import { Component, Input, OnInit, ViewChild } from '@angular/core';
-import {
-  AngularFirestore,
-  QueryDocumentSnapshot,
-} from '@angular/fire/compat/firestore';
-import { MatPaginator, PageEvent } from '@angular/material/paginator';
-import { MatSort } from '@angular/material/sort';
-import { MatTableDataSource } from '@angular/material/table';
-import { Router } from '@angular/router';
-import { TableService } from '../../services/table.service';
-import { debounceTime, firstValueFrom, Subject } from 'rxjs';
-import { OrderByDirection } from 'firebase/firestore';
-import firebase from 'firebase/compat';
-import WhereFilterOp = firebase.firestore.WhereFilterOp;
-import firestore = firebase.firestore;
-import { FormControl, FormArray, FormGroup } from '@angular/forms';
-
-@Component({
-  selector: 'lib-table',
-  templateUrl: './table.component.html',
-  styleUrls: ['./table.component.scss'],
-})
-export class TableComponent implements OnInit {
-  // INPUTS
-  @Input() data!: TableData;
-  @Input() downloadTable?: (arrange: Arrange, conditions: Condition[]) => void;
-  arrange: Arrange | null = null;
-  // VARIABLES
-  dataSource!: MatTableDataSource<any>;
-  currentPageNumber = 1;
-  currentClientPageIndex = 0;
-
-  public items: any[] = [];
-  public isLoading = false;
-  private lastDoc: QueryDocumentSnapshot<any> | null = null;
-  private firstDoc: QueryDocumentSnapshot<any> | null = null;
-  private sortBy: { field: string; order: OrderByDirection } = {
-    field: 'createdAt',
-    order: 'desc',
-  };
-  public columnProperties: string[] = [];
-
-  filtersForm: FormArray;
-
-  selectSort: FormControl = new FormControl('');
-  currentArrange = '';
-
-  hasNextPage: boolean = false;
-
-  dropdownItems: any[] = [];
-  sortableDropdownItems: any[] = [];
-  pageSize = 25;
-  totalItems = 0;
-  pageEvent?: PageEvent;
-  filterValue: string | null = null;
-
-  hasFilterableColumn: boolean = false;
-  hasSortableColumn: boolean = false;
-  filterPredicate: ((data: any, filter: string) => boolean) | undefined;
-  private filterSubject = new Subject<string>();
-  private readonly debounceTimeMs = 500;
-
-  selectedTab: number = 0;
-
-  @ViewChild(MatPaginator) paginator!: MatPaginator;
-  @ViewChild(MatSort) sort!: MatSort;
-
-  // Propriedades para controle do tooltip
-  hoveredCell: { row: any; col: any } | null = null;
-  showTooltip: boolean = false;
-  tooltipTimeout: any;
-  tooltipContent: string = '';
-  tooltipPosition: { x: number; y: number } = { x: 0, y: 0 };
-
-  // CONSTRUCTOR
-  constructor(
-    private router: Router,
-    private tableService: TableService,
-    private firestore: AngularFirestore
-  ) {
-    this.filtersForm = new FormArray([this.createFilterGroup()]);
-  }
-
-  createFilterGroup(): FormGroup {
-    return new FormGroup({
-      selectFilter: new FormControl(''),
-      typeFilter: new FormControl(''),
-      selectItem: new FormControl(''),
-      initialDate: new FormControl('', this.tableService.dateFormatValidator()),
-      finalDate: new FormControl('', this.tableService.dateFormatValidator()),
-    });
-  }
-
-  addFilter(filterData?: {
-    selectFilter: any;
-    typeFilter?: string;
-    selectItem?: any[];
-    initialDate?: string;
-    finalDate?: string;
-  }): void {
-    const newFilterGroup = this.createFilterGroup();
-
-    if (filterData) {
-      if (filterData.selectFilter) {
-        newFilterGroup.get('selectFilter')?.setValue(filterData.selectFilter);
-      }
-      if (filterData.typeFilter) {
-        newFilterGroup.get('typeFilter')?.setValue(filterData.typeFilter);
-      }
-      if (filterData.selectItem) {
-        newFilterGroup.get('selectItem')?.setValue(filterData.selectItem);
-      }
-      if (filterData.initialDate) {
-        newFilterGroup.get('initialDate')?.setValue(filterData.initialDate);
-      }
-      if (filterData.finalDate) {
-        newFilterGroup.get('finalDate')?.setValue(filterData.finalDate);
-      }
-    }
-
-    this.filtersForm.push(newFilterGroup);
-  }
-
-  onSelectFilterChange() {
-    const lastIndex = this.filtersForm.length - 1;
-    const lastFilter = this.filtersForm.at(lastIndex);
-    if (lastFilter.get('selectFilter')?.value) {
-      this.addFilter();
-    }
-  }
-
-  removeFilter(index: number): void {
-    this.filtersForm.removeAt(index);
-    if (this.filtersForm.length === 0) {
-      this.addFilter();
-    }
-  }
-
-  removeAllFilters(): void {
-    this.filtersForm.clear();
-    this.addFilter();
-    this.resetFilter();
-  }
-
-  // METHODS
-  public async ngOnInit() {
-    if (!this.data.color)
-      this.data.color = { bg: 'bg-primary', text: 'text-black' };
-    this.columnProperties = this.data.displayedColumns.map((column) => {
-      return column.property;
-    });
-
-    if (this.data.actionButton && !this.data.actionButton.condition) {
-      this.data.actionButton.condition = (_row?: any) => true;
-    }
-
-    if (this.data.pagination) {
-      this.data.displayedColumns.forEach((col) => {
-        if (col.isFilterable) {
-          if (this.hasFilterableColumn === false)
-            this.hasFilterableColumn = true;
-
-          this.dropdownItems.push({
-            ...col,
-            arrange: 'filter',
-            title: col.title,
-          });
-        }
-        if (col.isSortable) {
-          if (this.hasSortableColumn === false) this.hasSortableColumn = true;
-          this.sortableDropdownItems.push({
-            ...col,
-            arrange: 'ascending',
-            title: col.title + ': crescente',
-          });
-          this.sortableDropdownItems.push({
-            ...col,
-            arrange: 'descending',
-            title: col.title + ': decrescente',
-          });
-        }
-        if (col.isFilterableByDate) {
-          this.dropdownItems.push({
-            ...col,
-            arrange: 'filterByDate',
-            title: col.title + ': filtro por data',
-          });
-        }
-      });
-      if (this.data.filterableOptions) {
-        this.data.filterableOptions.forEach((option) =>
-          this.dropdownItems.push({ ...option, arrange: 'equals' })
-        );
-      }
-    }
-
-    // Sem paginação
-    if (this.data.pagination === false) {
-      await this.loadItems();
-    }
-    // Com paginação
-    if (this.data.pagination === true) {
-      if (this.data.sortBy)
-        this.sortBy = {
-          field: this.data.sortBy.field,
-          order: this.data.sortBy.order,
-        };
-      this.filterSubject
-        .pipe(debounceTime(this.debounceTimeMs))
-        .subscribe(() => {
-          this.loadItemsPaginated('forward', true);
-        });
-
-      this.isLoading = true;
-      await this.loadItemsPaginated('forward', true);
-
-      this.sort.active = 'createdAt';
-      this.sort.direction = 'desc';
-      this.dataSource.paginator = this.paginator;
-      this.dataSource.sort = this.sort;
-      this.totalItems = 0;
-      if (this.data.totalRef) {
-        for (const totalRef of this.data.totalRef) {
-          const totalRefDoc = await totalRef.ref.get();
-          const docData = totalRefDoc.data() as any;
-          if (docData && docData[totalRef.field])
-            this.totalItems = (this.totalItems +
-              docData[totalRef.field]) as number;
-        }
-      }
-      this.isLoading = false;
-    }
-  }
-
-  getDisplayValue(col: any, row: any, withinLimit: boolean = false): string {
-    let value: string;
-    if (row[col.property] === null || row[col.property] === undefined) {
-      return '';
-    }
-
-    if (col.calculateValue) {
-      value = String(col.calculateValue(row));
-    } else {
-      value = this.getNestedValue(row, col.property);
-    }
-
-    // Verifica se é um array e tem arrayField definido
-    if (Array.isArray(value) && col.arrayField) {
-      value = this.formatArrayValue(value, col.arrayField);
-    }
-
-    if (col.queryLength && row[col.property]) {
-      value = row[col.property];
-    }
-    value = col.pipe ? col.pipe.transform(value) : value;
-    return withinLimit ? value : value.substring(0, col.charLimit) + '...';
-  }
-
-  getNestedValue(obj: any, path: string): any {
-    if (!path) return undefined;
-    const properties = path.split('.');
-    return properties.reduce(
-      (acc, currentPart) => acc && acc[currentPart],
-      obj
-    );
-  }
-
-  private formatArrayValue(array: any[], field: string): string {
-    if (!Array.isArray(array) || array.length === 0) {
-      return '';
-    }
-
-    const values = array
-      .map((item) => {
-        if (typeof item === 'object' && item !== null) {
-          return item[field] || '';
-        }
-        return String(item);
-      })
-      .filter((value) => value !== '' && value !== null && value !== undefined);
-
-    return values.join(', ');
-  }
-
-  // Métodos sem paginação
-  private async loadItems() {
-    this.items = await this.tableService.getItems(this.data.collectionRef);
-    if (this.data.conditions) {
-      this.filterItems();
-    }
-    await this.loadRelations();
-    await this.loadQueryLengths();
-    this.totalItems = this.items.length;
-    this.dataSource = new MatTableDataSource(this.items);
-    this.dataSource.paginator = this.paginator;
-    this.dataSource.sort = this.sort;
-    if (this.data.sortBy) {
-      this.dataSource.sort.active = this.data.sortBy.field;
-      this.dataSource.sort.direction = this.data.sortBy.order;
-      this.dataSource.sort.sortChange.emit();
-    }
-
-    this.dataSource.filterPredicate = (data, filter: string) => {
-      return this.data.displayedColumns.some((col): boolean => {
-        if (col.filterPredicates) {
-          return col.filterPredicates.some((predicate): boolean => {
-            const propertyValue = data[col.property];
-            if (!propertyValue || typeof propertyValue !== 'object') {
-              return false;
-            }
-
-            const predicateValue = propertyValue[predicate];
-            if (predicateValue === null || predicateValue === undefined) {
-              return false;
-            }
-
-            return String(predicateValue)
-              .trim()
-              .toLocaleLowerCase()
-              .includes(filter);
-          });
-        }
-
-        if (col.property && col.isFilterable) {
-          const propertyValue = data[col.property];
-          if (propertyValue === null || propertyValue === undefined) {
-            return false;
-          }
-
-          return String(propertyValue)
-            .trim()
-            .toLocaleLowerCase()
-            .includes(filter);
-        }
-        return false;
-      });
-    };
-    this.filterPredicate = this.dataSource.filterPredicate;
-  }
-
-  // Métodos com paginação
-  private async loadItemsPaginated(
-    navigation: string = 'reload',
-    reset: boolean = false
-  ) {
-    if (reset && ['forward', 'reload'].includes(navigation)) {
-      this.lastDoc = null;
-    }
-    if (reset && ['backward', 'reload'].includes(navigation)) {
-      this.firstDoc = null;
-    }
-
-    const activeFilters = this.filtersForm.controls
-      .flatMap((control) => {
-        const group = control as FormGroup;
-        const selectedFilter = group.get('selectFilter')?.value;
-        if (!selectedFilter) return [];
-
-        const arrange = selectedFilter.arrange;
-
-        if (arrange === 'filter') {
-          const filterValue = group.get('typeFilter')?.value;
-          if (!filterValue) return [];
-          return {
-            arrange,
-            filter: {
-              property: selectedFilter.property,
-              filtering: filterValue,
-            },
-            dateFilter: undefined,
-          };
-        }
-
-        if (arrange === 'filterByDate') {
-          const initial = group.get('initialDate')?.value;
-          const final = group.get('finalDate')?.value;
-          if (initial && final) {
-            const [dayI, monthI, yearI] = initial.split('/');
-            const initialDate = new Date(`${monthI}/${dayI}/${yearI}`);
-            const [dayF, monthF, yearF] = final.split('/');
-            const finalDate = new Date(`${monthF}/${dayF}/${yearF}`);
-            finalDate.setHours(23, 59, 59);
-            return {
-              arrange,
-              filter: undefined,
-              dateFilter: {
-                initial: initialDate,
-                final: finalDate,
-              },
-            };
-          }
-          return [];
-        }
-
-        if (selectedFilter.hasOwnProperty('items') && arrange === 'equals') {
-          const selectedItems = group.get('selectItem')?.value;
-          if (Array.isArray(selectedItems) && selectedItems.length > 0) {
-            return selectedItems.map((item) => ({
-              arrange,
-              filter: {
-                property: item.property,
-                filtering: item.value,
-              },
-              dateFilter: undefined,
-            }));
-          }
-        }
-
-        return [];
-      })
-      .filter((f) => f && (f.filter?.filtering !== undefined || f.dateFilter));
-
-    this.arrange = {
-      filters: activeFilters,
-      sortBy: this.sortBy,
-    };
-
-    const paginated: any = {
-      batchSize: this.pageSize,
-      collection: this.data.collection,
-      doc: { lastDoc: this.lastDoc, firstDoc: this.firstDoc },
-      navigation,
-      arrange: this.arrange,
-      conditions: this.data.conditions,
-      size: this.totalItems,
-      filterFn: this.data.filterFn,
-      clientPageIndex: this.currentClientPageIndex,
-    };
-
-    const result = await this.tableService.getPaginated(paginated);
-    this.items = result.items;
-    await this.loadRelations();
-    await this.loadQueryLengths();
-    this.lastDoc = result.lastDoc as any;
-    this.firstDoc = result.firstDoc as any;
-
-    // Atualizar currentClientPageIndex se retornado pelo fallback
-    if (result.currentClientPageIndex !== undefined) {
-      this.currentClientPageIndex = result.currentClientPageIndex;
-    }
-
-    let sum = 0;
-    if (this.data.totalRef) {
-      for (const totalRef of this.data.totalRef) {
-        const totalRefDoc = await totalRef.ref.get();
-        const docData = totalRefDoc.data() as any;
-        if (docData || result.filterLength) {
-          sum =
-            result.filterLength ??
-            ((sum + (docData ? docData[totalRef.field] : 0)) as number);
-        }
-      }
-      this.totalItems = sum;
-    }
-
-    this.hasNextPage = result.hasNextPage;
-    this.dataSource = new MatTableDataSource(this.items);
-    this.filterPredicate = this.dataSource.filterPredicate;
-  }
-
-  async onPageChange(event?: PageEvent) {
-    if (this.data.pagination === true && event) {
-      this.isLoading = true;
-
-      const previousPageIndex = event.previousPageIndex ?? 0;
-      const pageIndex = event.pageIndex;
-      const currentComponentPageSize = this.pageSize;
-      const eventPageSize = event.pageSize;
-      const totalItems = this.totalItems;
-
-      let navigationDirection: string;
-      let resetDocs = false;
-      let originalPageSize: number | null = null;
-
-      const lastPageIndex = Math.max(
-        0,
-        Math.ceil(totalItems / eventPageSize) - 1
-      );
-
-      // Atualizar currentClientPageIndex sempre para o fallback
-      this.currentClientPageIndex = pageIndex;
-
-      if (previousPageIndex !== undefined && pageIndex > previousPageIndex) {
-        this.currentPageNumber++;
-      } else if (
-        previousPageIndex !== undefined &&
-        pageIndex < previousPageIndex
-      ) {
-        this.currentPageNumber = Math.max(1, this.currentPageNumber - 1);
-      }
-
-      if (eventPageSize !== currentComponentPageSize) {
-        console.log('Alterou a quantidade de elementos exibidos por página');
-        this.pageSize = eventPageSize;
-        navigationDirection = 'forward';
-        resetDocs = true;
-        this.currentClientPageIndex = 0;
-      } else if (
-        pageIndex === 0 &&
-        previousPageIndex !== undefined &&
-        pageIndex < previousPageIndex
-      ) {
-        console.log('Pulou para a primeira página');
-        navigationDirection = 'forward';
-        this.currentPageNumber = 1;
-        this.currentClientPageIndex = 0;
-        resetDocs = true;
-      } else if (
-        pageIndex === lastPageIndex &&
-        previousPageIndex !== undefined &&
-        pageIndex > previousPageIndex &&
-        pageIndex - previousPageIndex > 1
-      ) {
-        console.log('Pulou para a ultima página');
-        navigationDirection = 'backward';
-        resetDocs = true;
-
-        const itemsExpectedInLastPage =
-          totalItems - lastPageIndex * eventPageSize;
-
-        if (
-          itemsExpectedInLastPage > 0 &&
-          itemsExpectedInLastPage < eventPageSize
-        ) {
-          originalPageSize = this.pageSize;
-          this.pageSize = itemsExpectedInLastPage;
-        }
-      } else if (
-        previousPageIndex !== undefined &&
-        pageIndex > previousPageIndex
-      ) {
-        console.log('Procedendo');
-        navigationDirection = 'forward';
-        resetDocs = false;
-      } else if (
-        previousPageIndex !== undefined &&
-        pageIndex < previousPageIndex
-      ) {
-        console.log('Retrocedendo.');
-        navigationDirection = 'backward';
-        resetDocs = false;
-      } else if (
-        previousPageIndex !== undefined &&
-        pageIndex === previousPageIndex
-      ) {
-        console.log('Recarregando.');
-        navigationDirection = 'reload';
-        resetDocs = false;
-      } else if (previousPageIndex === undefined && pageIndex === 0) {
-        console.log(
-          'Evento inicial do paginador para pág 0. ngOnInit carregou.'
-        );
-        this.isLoading = false;
-        if (event) this.pageEvent = event;
-        return;
-      } else {
-        console.warn('INESPERADO! Condição de navegação não tratada:', event);
-        this.isLoading = false;
-        if (event) this.pageEvent = event;
-        return;
-      }
-
-      if (navigationDirection) {
-        try {
-          await this.loadItemsPaginated(navigationDirection, resetDocs);
-        } catch (error) {
-          console.error('Erro ao carregar itens paginados:', error);
-        } finally {
-          if (originalPageSize !== null) {
-            this.pageSize = originalPageSize;
-          }
-        }
-      }
-
-      if (event) this.pageEvent = event;
-      this.isLoading = false;
-    }
-  }
-
-  // Outros métodos
-
-  applyFilter(value: string) {
-    // Sem paginação
-    if (this.data.pagination === false) {
-      this.dataSource.filter = String(value).trim().toLowerCase();
-    }
-    // Com paginação
-    if (this.data.pagination === true) {
-      this.filterValue = value;
-      this.filterSubject.next(this.filterValue);
-    }
-  }
-
-  goToDetails(row: any): void {
-    if (this.data.isNotClickable) {
-      return;
-    }
-    const urlPath = this.data.url || this.data.name;
-    const url = this.router.serializeUrl(
-      this.router.createUrlTree([`/${urlPath}`, row.id])
-    );
-    window.open(url, '_blank');
-  }
-
-  async getRelation(params: {
-    id: any;
-    collection: string;
-    newProperty: string;
-  }): Promise<string> {
-    try {
-      let snapshot: firestore.DocumentSnapshot<unknown> | undefined;
-      if (
-        params.id !== '' &&
-        params.id !== undefined &&
-        params.collection !== undefined &&
-        params.collection !== ''
-      ) {
-        snapshot = await firstValueFrom(
-          this.firestore.collection(params.collection).doc(params.id).get()
-        );
-      }
-      if (snapshot && snapshot.exists) {
-        const data = snapshot.data() as any;
-        return data?.[params.newProperty] ?? '';
-      }
-      return '';
-    } catch (e) {
-      console.log(e);
-      return '';
-    }
-  }
-
-  private async loadRelations() {
-    const relationPromises = this.data.displayedColumns
-      .filter((col) => col.relation)
-      .flatMap((col) =>
-        this.items.map(async (item) => {
-          if (col.relation) {
-            item[col.property] = await this.getRelation({
-              id: item[col.relation.property],
-              collection: col.relation.collection,
-              newProperty: col.relation.newProperty,
-            });
-          }
-        })
-      );
-
-    await Promise.all(relationPromises);
-  }
-
-  async getQueryLength(params: {
-    item: any;
-    relation: {
-      collection: string;
-      property: string;
-      operator: WhereFilterOp;
-      value: string;
-    };
-  }) {
-    const snapshot = await this.firestore
-      .collection(params.relation.collection)
-      .ref.where(
-        params.relation.property,
-        params.relation.operator,
-        params.item[params.relation.value]
-      )
-      .get();
-    return snapshot.size;
-  }
-
-  private async loadQueryLengths() {
-    const lengthPromises = this.data.displayedColumns
-      .filter((col) => col.queryLength)
-      .flatMap((col) =>
-        this.items.map(async (item) => {
-          if (col.queryLength) {
-            item[col.property] = await this.getQueryLength({
-              item: item,
-              relation: col.queryLength,
-            });
-          }
-        })
-      );
-    await Promise.all(lengthPromises);
-  }
-
-  private filterItems() {
-    if (this.data.conditions) {
-      this.data.conditions.forEach((cond) => {
-        this.items = this.items.filter((item) => {
-          const operatorFunction = (this.tableService.operators as any)[
-            cond.operator
-          ];
-          if (operatorFunction) {
-            return operatorFunction(
-              item[cond.firestoreProperty],
-              cond.dashProperty
-            );
-          }
-          return false;
-        });
-      });
-    }
-  }
-
-  // Filtro de data
-  async search() {
-    if (this.selectSort.value) {
-      if (this.selectSort.value.arrange === 'ascending') {
-        this.sortBy = {
-          field: this.selectSort.value.property,
-          order: 'asc',
-        };
-      }
-      if (this.selectSort.value.arrange === 'descending') {
-        this.sortBy = {
-          field: this.selectSort.value.property,
-          order: 'desc',
-        };
-      }
-    }
-
-    await this.loadItemsPaginated('reload', true);
-    this.currentArrange =
-      this.filtersForm.length > 0
-        ? this.filtersForm.at(0).get('selectFilter')?.value?.arrange ?? ''
-        : '';
-    this.paginator.firstPage();
-  }
-
-  async resetFilter() {
-    if (!this.data.pagination) {
-      this.dataSource.filter = '';
-      if (this.filterPredicate) {
-        this.dataSource.filterPredicate = this.filterPredicate;
-      }
-    } else {
-      this.dataSource.filter = '';
-      if (this.filterPredicate) {
-        this.dataSource.filterPredicate = this.filterPredicate;
-      }
-    }
-    this.filtersForm.clear();
-    this.addFilter();
-    this.selectSort.patchValue('');
-    this.sortBy = {
-      order: this.data.sortBy ? this.data.sortBy.order : 'desc',
-      field: this.data.sortBy ? this.data.sortBy.field : 'createdAt',
-    };
-
-    await this.loadItemsPaginated('reload', true);
-    this.currentArrange = '';
-    this.paginator.firstPage();
-  }
-
-  // Método público para recarregar a tabela
-  async reloadTable() {
-    if (this.data.pagination) {
-      await this.loadItemsPaginated('reload', true);
-      this.paginator.firstPage();
-    } else {
-      await this.loadItems();
-    }
-  }
-
-  updateDisplayedColumns() {
-    if (this.dataSource) {
-      this.dataSource = new MatTableDataSource<any>([]);
-    }
-
-    this.columnProperties = this.data.displayedColumns.map((column) => {
-      return column.property;
-    });
-
-    this.dropdownItems = [];
-    this.sortableDropdownItems = [];
-
-    this.data.displayedColumns.forEach((col) => {
-      if (col.isFilterable) {
-        this.dropdownItems.push({
-          ...col,
-          arrange: 'filter',
-          title: col.title,
-        });
-      }
-      if (col.isSortable) {
-        this.sortableDropdownItems.push({
-          ...col,
-          arrange: 'ascending',
-          title: col.title + ': crescente',
-        });
-        this.sortableDropdownItems.push({
-          ...col,
-          arrange: 'descending',
-          title: col.title + ': decrescente',
-        });
-      }
-      if (col.isFilterableByDate) {
-        this.dropdownItems.push({
-          ...col,
-          arrange: 'filterByDate',
-          title: col.title + ': filtro por data',
-        });
-      }
-    });
-
-    if (this.data.filterableOptions) {
-      this.data.filterableOptions.forEach((option) =>
-        this.dropdownItems.push({ ...option, arrange: 'equals' })
-      );
-    }
-  }
-
-  isString(value: any): boolean {
-    return typeof value === 'string';
-  }
-
-  // Métodos para controle do tooltip
-  onCellMouseEnter(event: MouseEvent, row: any, col: any): void {
-    // Só mostrar tooltip se a coluna tiver charLimit definido
-    if (!col.charLimit) {
-      return;
-    }
-
-    const fullValue = this.getDisplayValue(col, row, true);
-
-    // Só mostrar tooltip se o valor completo for maior que o limite
-    if (fullValue.length <= col.charLimit) {
-      return;
-    }
-
-    this.hoveredCell = { row, col };
-    this.tooltipContent = fullValue;
-
-    // Definir posição do tooltip
-    this.tooltipPosition = {
-      x: event.clientX + 10,
-      y: event.clientY - 10,
-    };
-
-    // Timeout para mostrar o tooltip
-    this.tooltipTimeout = setTimeout(() => {
-      if (
-        this.hoveredCell &&
-        this.hoveredCell.row === row &&
-        this.hoveredCell.col === col
-      ) {
-        this.showTooltip = true;
-      }
-    }, 500);
-  }
-
-  onCellMouseLeave(): void {
-    if (this.tooltipTimeout) {
-      clearTimeout(this.tooltipTimeout);
-      this.tooltipTimeout = null;
-    }
-
-    this.showTooltip = false;
-    this.hoveredCell = null;
-    this.tooltipContent = '';
-  }
-
-  onCellMouseMove(event: MouseEvent): void {
-    if (this.showTooltip) {
-      this.tooltipPosition = {
-        x: event.clientX + 10,
-        y: event.clientY - 10,
-      };
-    }
-  }
-
-  // Métodos para inversão vertical dos tabs
-  getTabGroups(tabs: any[]): number[] {
-    if (!tabs || tabs.length === 0) return [];
-
-    const totalGroups = Math.ceil(tabs.length / 6);
-    const groups: number[] = [];
-
-    // Criar array de índices invertidos (último grupo primeiro)
-    for (let i = totalGroups - 1; i >= 0; i--) {
-      groups.push(i);
-    }
-
-    return groups;
-  }
-
-  getTabGroup(tabs: any[], groupIndex: number): any[] {
-    if (!tabs || tabs.length === 0) return [];
-
-    const startIndex = groupIndex * 6;
-    const endIndex = Math.min(startIndex + 6, tabs.length);
-
-    return tabs.slice(startIndex, endIndex);
-  }
-
-  getRealTabIndex(groupIndex: number, tabIndexInGroup: number): number {
-    if (!this.data.tabs?.tabsData) return 0;
-    const totalGroups = Math.ceil(this.data.tabs.tabsData.length / 6);
-    const realGroupIndex = totalGroups - 1 - groupIndex;
-    return realGroupIndex * 6 + tabIndexInGroup;
-  }
-
-  onTableSelected(i: number, j: number) {
-    if (!this.data.tabs?.tabsData || !this.data.tabs.method) return;
-    this.selectedTab = this.getRealTabIndex(i, j);
-    const tab = this.data.tabs.tabsData[this.selectedTab];
-    if (tab) {
-      this.data.tabs.method(tab, this.selectedTab);
-    }
-  }
-
-  isTabSelected(originalIndex: number): boolean {
-    return this.selectedTab === originalIndex;
-  }
-}