ng-firebase-table-kxp 1.2.4 → 1.2.6

package/esm2020/lib/services/table.service.mjs

@@ -0,0 +1,1140 @@
+import { Injectable, Optional } from '@angular/core';
+import firebase from 'firebase/compat/app';
+import { firstValueFrom } from 'rxjs';
+import * as moment from 'moment';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/fire/compat/firestore";
+import * as i2 from "@angular/material/dialog";
+import * as i3 from "ngx-toastr";
+export class TableService {
+    constructor(ngFire, dialog, toastr) {
+        this.ngFire = ngFire;
+        this.dialog = dialog;
+        this.toastr = toastr;
+        this.operators = {
+            '==': (a, b) => a === b,
+            '!=': (a, b) => a !== b,
+            '>': (a, b) => a > b,
+            '<': (a, b) => a < b,
+            '>=': (a, b) => a >= b,
+            '<=': (a, b) => a <= b,
+            in: (a, b) => Array.isArray(b) && b.includes(a),
+            'not-in': (a, b) => Array.isArray(b) && !b.includes(a),
+            'array-contains': (a, b) => Array.isArray(a) && a.includes(b),
+            'array-contains-any': (a, b) => Array.isArray(a) &&
+                Array.isArray(b) &&
+                b.some((item) => a.includes(item)),
+            includes: (a, b) => {
+                if (typeof a === 'string' && typeof b === 'string') {
+                    return a.includes(b);
+                }
+                if (Array.isArray(a)) {
+                    return a.includes(b);
+                }
+                return false;
+            },
+        };
+    }
+    async getItems(collection) {
+        try {
+            const querySnapshot = await collection.get();
+            return querySnapshot.docs.map((doc) => {
+                const data = doc.data();
+                return { ...(data ?? {}), id: doc.id };
+            });
+        }
+        catch (error) {
+            console.warn('Collection não encontrada:', error);
+            return [];
+        }
+    }
+    async executeQuery(params) {
+        if (params.filterFn) {
+            // Lógica com filtro no cliente (filterFn)
+            const BATCH_FETCH_SIZE = params.batchSize;
+            const GOAL_SIZE = params.batchSize + 1;
+            if (params.navigation === 'forward' || params.navigation === 'reload') {
+                if (params.navigation === 'reload' && params.doc) {
+                    params.doc.lastDoc = null;
+                }
+                let lastDocCursor = params.doc ? params.doc.lastDoc : null;
+                let pageResults = [];
+                let allFetchedDocs = [];
+                let hasMoreDocsInDb = true;
+                while (pageResults.length < GOAL_SIZE && hasMoreDocsInDb) {
+                    let query = this.ngFire.collection(params.collection).ref;
+                    query = this.applyFilters(query, params.arrange, params.conditions);
+                    if (lastDocCursor) {
+                        query = query.startAfter(lastDocCursor);
+                    }
+                    query = query.limit(BATCH_FETCH_SIZE);
+                    const snapshot = await query.get();
+                    if (snapshot.empty) {
+                        hasMoreDocsInDb = false;
+                        break;
+                    }
+                    lastDocCursor = snapshot.docs[snapshot.docs.length - 1];
+                    allFetchedDocs.push(...snapshot.docs);
+                    const batchUsers = snapshot.docs
+                        .map((doc) => {
+                        const data = doc.data();
+                        return { id: doc.id, ...(data ?? {}) };
+                    })
+                        .filter(params.filterFn);
+                    pageResults.push(...batchUsers);
+                    if (snapshot.size < BATCH_FETCH_SIZE) {
+                        hasMoreDocsInDb = false;
+                    }
+                }
+                const hasNextPage = pageResults.length > params.batchSize;
+                const finalItems = pageResults.slice(0, params.batchSize);
+                const firstDocOfPage = allFetchedDocs.find((doc) => doc.id === finalItems[0]?.id) || null;
+                const lastDocOfPage = allFetchedDocs.find((doc) => doc.id === finalItems[finalItems.length - 1]?.id) || null;
+                return {
+                    items: finalItems,
+                    filterLength: null,
+                    firstDoc: firstDocOfPage,
+                    lastDoc: lastDocOfPage,
+                    hasNextPage: hasNextPage,
+                    hasPreviousPage: !!(params.doc && params.doc.lastDoc) &&
+                        params.navigation !== 'reload',
+                    currentClientPageIndex: undefined,
+                };
+            }
+            // Lógica para trás (backward)
+            else if (params.navigation === 'backward') {
+                if (!params.doc || !params.doc.firstDoc) {
+                    return {
+                        items: [],
+                        filterLength: null,
+                        firstDoc: null,
+                        lastDoc: null,
+                        hasNextPage: true,
+                        hasPreviousPage: false,
+                        currentClientPageIndex: undefined,
+                    };
+                }
+                let pageResults = [];
+                let allFetchedDocs = [];
+                let hasMoreDocsInDb = true;
+                let boundaryDoc = params.doc.firstDoc;
+                while (pageResults.length < GOAL_SIZE && hasMoreDocsInDb) {
+                    if (!boundaryDoc)
+                        break;
+                    let query = this.ngFire.collection(params.collection).ref;
+                    query = this.applyFilters(query, params.arrange, params.conditions);
+                    query = query.endBefore(boundaryDoc);
+                    query = query.limitToLast(BATCH_FETCH_SIZE);
+                    const snapshot = await query.get();
+                    if (snapshot.empty) {
+                        hasMoreDocsInDb = false;
+                        break;
+                    }
+                    boundaryDoc = snapshot
+                        .docs[0];
+                    allFetchedDocs = [...snapshot.docs, ...allFetchedDocs];
+                    const batchUsers = snapshot.docs
+                        .map((doc) => {
+                        const data = doc.data();
+                        return { id: doc.id, ...(data ?? {}) };
+                    })
+                        .filter(params.filterFn);
+                    pageResults = [...batchUsers, ...pageResults];
+                    if (snapshot.size < BATCH_FETCH_SIZE) {
+                        hasMoreDocsInDb = false;
+                    }
+                }
+                const finalItems = pageResults.slice(0, params.batchSize);
+                const firstDocOfPage = allFetchedDocs.find((doc) => doc.id === finalItems[0]?.id) || null;
+                const lastDocOfPage = allFetchedDocs.find((doc) => doc.id === finalItems[finalItems.length - 1]?.id) || null;
+                return {
+                    items: finalItems,
+                    filterLength: null,
+                    firstDoc: firstDocOfPage,
+                    lastDoc: lastDocOfPage,
+                    hasNextPage: true,
+                    currentClientPageIndex: undefined,
+                };
+            }
+        }
+        else {
+            let items = [];
+            let docs = [];
+            let hasNextPage = false;
+            let filterLength = null;
+            let query = this.ngFire.collection(params.collection).ref;
+            if (params.conditions) {
+                params.conditions.forEach((c) => {
+                    if (c.operator === '!=') {
+                        query = query.orderBy(c.firestoreProperty);
+                    }
+                });
+            }
+            query = this.applyFilters(query, params.arrange, params.conditions);
+            if (params.navigation === 'reload') {
+                query = query.limit(params.batchSize + 1);
+                if (params.doc && params.doc.firstDoc) {
+                    query = query.startAt(params.doc.firstDoc);
+                }
+            }
+            else if (params.navigation === 'forward') {
+                query = query.limit(params.batchSize + 1);
+                if (params.doc && params.doc.lastDoc) {
+                    query = query.startAfter(params.doc.lastDoc);
+                }
+            }
+            else {
+                // backward
+                query = query.limitToLast(params.batchSize + 1);
+                if (params.doc && params.doc.firstDoc) {
+                    query = query.endBefore(params.doc.firstDoc);
+                }
+            }
+            const itemCol = await query.get();
+            itemCol.docs.forEach((doc) => docs.push(doc));
+            const itemPromises = docs.map(async (item) => {
+                const itemData = item.data();
+                items.push({ id: item.id, ...(itemData ?? {}) });
+            });
+            let lastDoc = docs[docs.length - 1] || null;
+            let firstDoc = docs[0];
+            if ((items.length > params.batchSize && params.navigation === 'forward') ||
+                (params.navigation === 'reload' && items.length > params.batchSize)) {
+                lastDoc = docs[docs.length - 2] || null;
+                items.pop();
+                hasNextPage = true;
+            }
+            if (items.length > params.batchSize && params.navigation === 'backward') {
+                firstDoc = docs[1];
+                items.shift();
+                hasNextPage = true;
+            }
+            await Promise.all(itemPromises);
+            return {
+                items,
+                filterLength,
+                lastDoc,
+                firstDoc,
+                hasNextPage,
+                currentClientPageIndex: undefined,
+            };
+        }
+        // Fallback para garantir que sempre retornamos algo
+        return {
+            items: [],
+            filterLength: null,
+            firstDoc: null,
+            lastDoc: null,
+            hasNextPage: false,
+            currentClientPageIndex: undefined,
+        };
+    }
+    applyFilters(query, arrange, conditions) {
+        if (conditions) {
+            conditions.map((cond) => {
+                query = query.where(cond.firestoreProperty, cond.operator, cond.dashProperty);
+            });
+        }
+        let hasFilterSpecificOrderBy = false;
+        let appliedOrderByField = null;
+        const equalsFilters = arrange.filters.filter((f) => f.arrange === 'equals' && !!f.filter);
+        const otherFilters = arrange.filters.filter((f) => f.arrange !== 'equals');
+        const equalsGroupedByProperty = equalsFilters.reduce((acc, current) => {
+            const prop = current.filter.property;
+            if (!acc[prop]) {
+                acc[prop] = [];
+            }
+            acc[prop].push(current.filter.filtering);
+            return acc;
+        }, {});
+        for (const prop in equalsGroupedByProperty) {
+            const values = equalsGroupedByProperty[prop];
+            if (values.length > 0) {
+                query = query.where(prop, 'in', values);
+            }
+        }
+        otherFilters.forEach((filterItem) => {
+            // Aplicar filtragem por busca
+            if (filterItem.filter?.filtering &&
+                filterItem.filter?.property !== '' &&
+                filterItem.arrange === 'filter') {
+                query = query
+                    .where(filterItem.filter.property, '>=', filterItem.filter.filtering.trim().toUpperCase())
+                    .where(filterItem.filter.property, '<=', filterItem.filter.filtering.trim().toUpperCase() + '\uf8ff');
+                if (!hasFilterSpecificOrderBy) {
+                    query = query.orderBy(filterItem.filter.property);
+                    hasFilterSpecificOrderBy = true;
+                    appliedOrderByField = filterItem.filter.property;
+                }
+            }
+            // Aplicar filtro do tipo "filterByDate"
+            if (filterItem.dateFilter && filterItem.arrange === 'filterByDate') {
+                query = query
+                    .where(arrange.sortBy.field, '>=', filterItem.dateFilter.initial)
+                    .where(arrange.sortBy.field, '<=', filterItem.dateFilter.final);
+                if (!hasFilterSpecificOrderBy) {
+                    query = query.orderBy(arrange.sortBy.field);
+                    hasFilterSpecificOrderBy = true;
+                    appliedOrderByField = arrange.sortBy.field;
+                }
+            }
+        });
+        // Aplicar sortBy
+        if (arrange.sortBy && arrange.sortBy.field && arrange.sortBy.order) {
+            if (appliedOrderByField !== arrange.sortBy.field) {
+                query = query.orderBy(arrange.sortBy.field, arrange.sortBy.order);
+            }
+        }
+        return query;
+    }
+    getIdFilter(params) {
+        if (!params.arrange?.filters)
+            return null;
+        const idFilter = params.arrange.filters.find((f) => f.arrange === 'filter' &&
+            !!f.filter &&
+            f.filter.property === 'id' &&
+            !!f.filter.filtering);
+        return idFilter?.filter?.filtering?.trim() || null;
+    }
+    async getDocumentById(collection, docId) {
+        try {
+            const docRef = this.ngFire.collection(collection).doc(docId);
+            const docSnapshot = await docRef.get().toPromise();
+            if (docSnapshot && docSnapshot.exists) {
+                const data = docSnapshot.data();
+                return {
+                    id: docSnapshot.id,
+                    ...(data ?? {}),
+                };
+            }
+            return null;
+        }
+        catch (error) {
+            console.warn('Erro ao buscar documento por ID:', error);
+            return null;
+        }
+    }
+    async searchByIdPartial(params, searchTerm) {
+        const exactMatch = await this.getDocumentById(params.collection, searchTerm);
+        if (exactMatch) {
+            if (params.conditions) {
+                const operators = this.operators;
+                const passesConditions = params.conditions.every((cond) => {
+                    const operatorFn = operators[cond.operator];
+                    return operatorFn
+                        ? operatorFn(exactMatch[cond.firestoreProperty], cond.dashProperty)
+                        : false;
+                });
+                if (!passesConditions) {
+                    return {
+                        items: [],
+                        filterLength: 0,
+                        firstDoc: null,
+                        lastDoc: null,
+                        hasNextPage: false,
+                        hasPreviousPage: false,
+                        currentClientPageIndex: 0,
+                        totalPages: 0,
+                    };
+                }
+            }
+            if (params.filterFn && !params.filterFn(exactMatch)) {
+                return {
+                    items: [],
+                    filterLength: 0,
+                    firstDoc: null,
+                    lastDoc: null,
+                    hasNextPage: false,
+                    hasPreviousPage: false,
+                    currentClientPageIndex: 0,
+                    totalPages: 0,
+                };
+            }
+            return {
+                items: [exactMatch],
+                filterLength: 1,
+                firstDoc: null,
+                lastDoc: null,
+                hasNextPage: false,
+                hasPreviousPage: false,
+                currentClientPageIndex: 0,
+                totalPages: 1,
+            };
+        }
+        const searchTermLower = searchTerm.toLowerCase();
+        const paramsWithoutIdFilter = {
+            ...params,
+            arrange: {
+                ...params.arrange,
+                filters: params.arrange.filters.filter((f) => !(f.arrange === 'filter' && f.filter?.property === 'id')),
+            },
+        };
+        let query = this.ngFire.collection(params.collection).ref;
+        // Aplicar conditions
+        if (params.conditions) {
+            params.conditions.forEach((cond) => {
+                query = query.where(cond.firestoreProperty, cond.operator, cond.dashProperty);
+            });
+        }
+        // Aplicar sortBy
+        if (params.arrange?.sortBy?.field && params.arrange?.sortBy?.order) {
+            query = query.orderBy(params.arrange.sortBy.field, params.arrange.sortBy.order);
+        }
+        const snapshot = await query.get();
+        let items = snapshot.docs
+            .map((doc) => {
+            const data = doc.data();
+            return { id: doc.id, ...(data ?? {}) };
+        })
+            .filter((item) => item.id.toLowerCase().includes(searchTermLower));
+        // Separar equals filters e outros filtros
+        const equalsFilters = paramsWithoutIdFilter.arrange.filters.filter((f) => f.arrange === 'equals' && !!f.filter);
+        const otherFilters = paramsWithoutIdFilter.arrange.filters.filter((f) => f.arrange !== 'equals' &&
+            (f.arrange !== 'filter' || f.filter?.property !== 'id'));
+        // Aplicar equals filters com lógica OR dentro de cada propriedade
+        if (equalsFilters.length > 0) {
+            // Agrupar por propriedade para aplicar OR
+            const groupedByProperty = equalsFilters.reduce((acc, f) => {
+                const prop = f.filter.property;
+                if (!acc[prop]) {
+                    acc[prop] = [];
+                }
+                acc[prop].push(f.filter.filtering);
+                return acc;
+            }, {});
+            // Filtrar: item deve ter pelo menos um valor de CADA propriedade
+            items = items.filter((item) => {
+                return Object.entries(groupedByProperty).every(([prop, values]) => {
+                    const itemValue = item[prop];
+                    return values.includes(itemValue);
+                });
+            });
+        }
+        // Aplicar outros filtros
+        otherFilters.forEach((filterItem) => {
+            if (filterItem.arrange === 'filter' &&
+                filterItem.filter?.filtering &&
+                filterItem.filter?.property) {
+                const filterValue = String(filterItem.filter.filtering)
+                    .trim()
+                    .toLowerCase();
+                items = items.filter((item) => {
+                    const itemValue = String(item[filterItem.filter.property] ?? '').toLowerCase();
+                    return itemValue.includes(filterValue);
+                });
+            }
+        });
+        // Aplicar filterFn se existir
+        if (params.filterFn) {
+            items = items.filter(params.filterFn);
+        }
+        // Paginação
+        const pageSize = params.batchSize;
+        let currentClientPageIndex = 0;
+        if (params.navigation === 'reload') {
+            currentClientPageIndex = 0;
+        }
+        else {
+            // Usar o índice passado pelo componente sem incrementar/decrementar
+            currentClientPageIndex = params.clientPageIndex || 0;
+        }
+        const startIndex = currentClientPageIndex * pageSize;
+        const endIndex = startIndex + pageSize;
+        const paginatedItems = items.slice(startIndex, endIndex);
+        const totalPages = Math.ceil(items.length / pageSize);
+        const hasNextPage = currentClientPageIndex < totalPages - 1;
+        const hasPreviousPage = currentClientPageIndex > 0;
+        return {
+            items: paginatedItems,
+            filterLength: items.length,
+            firstDoc: null,
+            lastDoc: null,
+            hasNextPage,
+            hasPreviousPage,
+            currentClientPageIndex,
+            totalPages,
+        };
+    }
+    shouldUseClientSideFallback(params) {
+        const hasConditions = params.conditions && params.conditions.length > 0;
+        const hasArrangeFilters = params.arrange?.filters && params.arrange.filters.length > 0;
+        const hasSortBy = params.arrange?.sortBy?.field;
+        if (params.filterFn) {
+            return false;
+        }
+        if (hasArrangeFilters) {
+            const equalsFilters = params.arrange.filters.filter((f) => f.arrange === 'equals' && !!f.filter);
+            if (equalsFilters.length > 0) {
+                const propertiesSet = new Set(equalsFilters.map((f) => f.filter.property));
+                if (propertiesSet.size > 1) {
+                    return true;
+                }
+            }
+        }
+        if (hasConditions && hasArrangeFilters && hasSortBy) {
+            return true;
+        }
+        if (hasConditions && hasArrangeFilters) {
+            return true;
+        }
+        if (hasArrangeFilters && params.arrange.filters.length > 1 && hasSortBy) {
+            const equalsFilters = params.arrange.filters.filter((f) => f.arrange === 'equals' && !!f.filter);
+            if (equalsFilters.length > 0) {
+                const propertiesSet = new Set(equalsFilters.map((f) => f.filter.property));
+                if (propertiesSet.size === 1 &&
+                    equalsFilters.length === params.arrange.filters.length) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    async getPaginated(params) {
+        const idFilterValue = this.getIdFilter(params);
+        if (idFilterValue) {
+            const result = await this.searchByIdPartial(params, idFilterValue);
+            return result;
+        }
+        // Detectar preventivamente se deve usar fallback
+        if (this.shouldUseClientSideFallback(params)) {
+            await this.trackMissingIndexPreventive(params.collection, params.arrange, params.conditions);
+            const result = await this.executeClientSideQuery(params);
+            return result;
+        }
+        try {
+            const result = await this.executeQuery(params);
+            return result;
+        }
+        catch (error) {
+            if (error &&
+                typeof error === 'object' &&
+                'code' in error &&
+                error.code === 'failed-precondition') {
+                await this.trackMissingIndex(error, params.collection, params.arrange, params.conditions);
+                const result = await this.executeClientSideQuery(params);
+                return result;
+            }
+            else if (error &&
+                typeof error === 'object' &&
+                'code' in error &&
+                error.code === 'invalid-argument') {
+                await this.trackMissingIndex(error, params.collection, params.arrange, params.conditions);
+                const result = await this.executeClientSideQuery(params);
+                return result;
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    async executeClientSideQuery(params) {
+        // Otimizar usando pelo menos uma cláusula .where() quando possível
+        let query = this.ngFire.collection(params.collection).ref;
+        let appliedCondition = null;
+        let hasAppliedWhereClause = false;
+        // Primeiro, tenta aplicar condições simples
+        if (params.conditions && params.conditions.length > 0) {
+            const simpleCondition = params.conditions.find((cond) => ['==', '>', '<', '>=', '<=', 'in', 'array-contains'].includes(cond.operator));
+            if (simpleCondition) {
+                query = query.where(simpleCondition.firestoreProperty, simpleCondition.operator, simpleCondition.dashProperty);
+                appliedCondition = simpleCondition;
+                hasAppliedWhereClause = true;
+            }
+        }
+        // Se não há condições disponíveis, tenta aplicar filtros do arrange
+        let appliedFirestoreFilter = null;
+        if (!hasAppliedWhereClause && params.arrange?.filters) {
+            // Agrupar equals filters por propriedade
+            const equalsFilters = params.arrange.filters.filter((f) => f.arrange === 'equals' && !!f.filter);
+            const equalsGroupedByProperty = equalsFilters.reduce((acc, current) => {
+                const prop = current.filter.property;
+                if (!acc[prop]) {
+                    acc[prop] = [];
+                }
+                acc[prop].push(current.filter.filtering);
+                return acc;
+            }, {});
+            // Se há apenas UMA propriedade com múltiplos valores, aplicar no Firestore com 'in'
+            const properties = Object.keys(equalsGroupedByProperty);
+            if (properties.length === 1 && equalsFilters.length > 0) {
+                const prop = properties[0];
+                const values = equalsGroupedByProperty[prop];
+                query = query.where(prop, 'in', values);
+                hasAppliedWhereClause = true;
+                // Marcar TODOS os equals filters dessa propriedade como aplicados
+                appliedFirestoreFilter = 'all-equals';
+            }
+            else if (properties.length === 0) {
+                const otherFilter = params.arrange.filters.find((f) => (f.arrange === 'filter' &&
+                    !!f.filter?.filtering &&
+                    !!f.filter?.property) ||
+                    (f.arrange === 'filterByDate' &&
+                        !!f.dateFilter?.initial &&
+                        !!f.dateFilter?.final));
+                if (otherFilter) {
+                    if (otherFilter.arrange === 'filter' && otherFilter.filter) {
+                        const filterValue = otherFilter.filter.filtering
+                            .trim()
+                            .toUpperCase();
+                        query = query
+                            .where(otherFilter.filter.property, '>=', filterValue)
+                            .where(otherFilter.filter.property, '<=', filterValue + '\uf8ff');
+                        hasAppliedWhereClause = true;
+                        appliedFirestoreFilter = otherFilter;
+                    }
+                    else if (otherFilter.arrange === 'filterByDate' &&
+                        otherFilter.dateFilter &&
+                        params.arrange.sortBy?.field) {
+                        query = query
+                            .where(params.arrange.sortBy.field, '>=', otherFilter.dateFilter.initial)
+                            .where(params.arrange.sortBy.field, '<=', otherFilter.dateFilter.final);
+                        hasAppliedWhereClause = true;
+                        appliedFirestoreFilter = otherFilter;
+                    }
+                }
+            }
+        }
+        const allDocsSnapshot = await query.get();
+        let items = allDocsSnapshot.docs.map((doc) => {
+            const data = doc.data();
+            return { id: doc.id, ...(data ?? {}) };
+        });
+        // Aplicar condições restantes
+        if (params.conditions) {
+            const remainingConditions = params.conditions.filter((cond) => cond !== appliedCondition);
+            if (remainingConditions.length > 0) {
+                const operators = this.operators;
+                items = items.filter((item) => {
+                    return remainingConditions.every((cond) => {
+                        const operatorFn = operators[cond.operator];
+                        return operatorFn
+                            ? operatorFn(item[cond.firestoreProperty], cond.dashProperty)
+                            : false;
+                    });
+                });
+            }
+        }
+        const { filters, sortBy } = params.arrange;
+        // Track which filter was already applied in Firestore to avoid double filtering
+        if (hasAppliedWhereClause && !appliedCondition && params.arrange?.filters) {
+            const equalsFilter = params.arrange.filters.find((f) => f.arrange === 'equals' && !!f.filter?.filtering);
+            if (equalsFilter) {
+                appliedFirestoreFilter = equalsFilter;
+            }
+            else {
+                const foundFilter = params.arrange.filters.find((f) => (f.arrange === 'filter' &&
+                    !!f.filter?.filtering &&
+                    !!f.filter?.property) ||
+                    (f.arrange === 'filterByDate' &&
+                        !!f.dateFilter?.initial &&
+                        !!f.dateFilter?.final));
+                if (foundFilter) {
+                    appliedFirestoreFilter = foundFilter;
+                }
+            }
+        }
+        const equalsFilters = filters.filter((f) => f.arrange === 'equals');
+        const otherFilters = filters.filter((f) => f.arrange !== 'equals');
+        // Aplicar equals filters no client-side apenas se não foram aplicados no Firestore
+        if (appliedFirestoreFilter !== 'all-equals' && equalsFilters.length > 0) {
+            // Agrupar por propriedade para aplicar OR dentro de cada propriedade
+            const groupedByProperty = equalsFilters.reduce((acc, f) => {
+                if (f.filter) {
+                    const prop = f.filter.property;
+                    if (!acc[prop]) {
+                        acc[prop] = [];
+                    }
+                    acc[prop].push(f.filter.filtering);
+                }
+                return acc;
+            }, {});
+            // Filtrar: item deve ter pelo menos um valor de CADA propriedade
+            // (AND entre propriedades, OR dentro de cada propriedade)
+            items = items.filter((item) => {
+                return Object.entries(groupedByProperty).every(([prop, values]) => {
+                    const itemValue = item[prop];
+                    return values.includes(itemValue);
+                });
+            });
+        }
+        otherFilters.forEach((filterItem) => {
+            if (appliedFirestoreFilter === filterItem) {
+                return;
+            }
+            if (filterItem.arrange === 'filter' &&
+                filterItem.filter?.filtering &&
+                filterItem.filter?.property) {
+                const filterValue = String(filterItem.filter.filtering)
+                    .trim()
+                    .toLowerCase();
+                items = items.filter((item) => {
+                    const itemValue = String(item[filterItem.filter.property] ?? '').toLowerCase();
+                    return itemValue.includes(filterValue);
+                });
+            }
+            if (filterItem.arrange === 'filterByDate' &&
+                filterItem.dateFilter?.initial &&
+                filterItem.dateFilter?.final &&
+                sortBy.field) {
+                items = items.filter((item) => {
+                    try {
+                        const fieldValue = item[sortBy.field];
+                        if (!fieldValue) {
+                            return false;
+                        }
+                        let itemDate;
+                        const fieldValueObj = fieldValue;
+                        if (fieldValueObj &&
+                            typeof fieldValueObj === 'object' &&
+                            'toDate' in fieldValueObj &&
+                            typeof fieldValueObj.toDate === 'function') {
+                            itemDate = fieldValueObj.toDate();
+                        }
+                        else if (fieldValueObj instanceof Date) {
+                            itemDate = fieldValueObj;
+                        }
+                        else if (typeof fieldValueObj === 'string') {
+                            itemDate = new Date(fieldValueObj);
+                            if (isNaN(itemDate.getTime())) {
+                                return false;
+                            }
+                        }
+                        else if (typeof fieldValueObj === 'number') {
+                            itemDate = new Date(fieldValueObj);
+                        }
+                        else {
+                            return false;
+                        }
+                        if (!filterItem.dateFilter) {
+                            return false;
+                        }
+                        return (itemDate >= filterItem.dateFilter.initial &&
+                            itemDate <= filterItem.dateFilter.final);
+                    }
+                    catch (error) {
+                        console.warn('Erro ao processar filtro de data para o item:', item.id, error);
+                        return false;
+                    }
+                });
+            }
+        });
+        // Aplicar filterFn se existir
+        if (params.filterFn) {
+            items = items.filter(params.filterFn);
+        }
+        if (sortBy && sortBy.field && sortBy.order) {
+            items.sort((a, b) => {
+                const valA = a[sortBy.field];
+                const valB = b[sortBy.field];
+                if (valA === null || valA === undefined)
+                    return 1;
+                if (valB === null || valB === undefined)
+                    return -1;
+                if (valA < valB) {
+                    return sortBy.order === 'asc' ? -1 : 1;
+                }
+                if (valA > valB) {
+                    return sortBy.order === 'asc' ? 1 : -1;
+                }
+                return 0;
+            });
+        }
+        // Implementação adequada da paginação
+        let currentClientPageIndex = 0;
+        // Determinar a página atual baseada na navegação
+        if (params.navigation === 'reload') {
+            currentClientPageIndex = 0;
+        }
+        else {
+            currentClientPageIndex = params.clientPageIndex || 0;
+        }
+        const pageSize = params.batchSize;
+        const startIndex = currentClientPageIndex * pageSize;
+        const endIndex = startIndex + pageSize;
+        const paginatedItems = items.slice(startIndex, endIndex);
+        const totalPages = Math.ceil(items.length / pageSize);
+        const hasNextPage = currentClientPageIndex < totalPages - 1;
+        const hasPreviousPage = currentClientPageIndex > 0;
+        return {
+            items: paginatedItems,
+            filterLength: items.length,
+            lastDoc: null,
+            firstDoc: null,
+            hasNextPage: hasNextPage,
+            hasPreviousPage: hasPreviousPage,
+            currentClientPageIndex: currentClientPageIndex,
+            totalPages: totalPages,
+        };
+    }
+    async getItemsData(collection, arrange, conditions = undefined) {
+        try {
+            let query = this.ngFire.collection(collection).ref;
+            query = this.applyFilters(query, arrange, conditions);
+            const snapshot = await query.get();
+            return await Promise.all(snapshot.docs.map(async (doc) => {
+                const data = doc.data();
+                const id = doc.id;
+                return {
+                    id,
+                    ...(data ?? {}),
+                };
+            }));
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    async deleteIndex(id, col) {
+        try {
+            const batch = this.ngFire.firestore.batch();
+            const docRef = this.ngFire.collection(col).doc(id);
+            const docSnapshot = (await firstValueFrom(docRef.get()));
+            const doc = docSnapshot.data();
+            batch.delete(docRef.ref);
+            if (doc && typeof doc['index'] === 'number') {
+                await this.reindex(doc['index'], col, batch);
+            }
+            await batch.commit();
+            this.toastr.success('Item excluído com sucesso!');
+            return true;
+        }
+        catch (e) {
+            const error = e;
+            console.error('Erro ao deletar item:', error);
+            this.toastr.error('Erro ao deletar item.');
+            return false;
+        }
+    }
+    async reindex(index, col, batch) {
+        try {
+            const snapshot = (await firstValueFrom(this.ngFire.collection(col).get()));
+            const docs = snapshot.docs;
+            for (let doc of docs) {
+                const data = doc.data();
+                if (data &&
+                    typeof data['index'] === 'number' &&
+                    data['index'] > index) {
+                    data['index'] = (data['index'] - 1);
+                    const docRef = this.ngFire.collection(col).doc(doc.id).ref;
+                    batch.update(docRef, data);
+                }
+            }
+        }
+        catch (error) {
+            console.error('Erro ao reindexar:', error);
+        }
+        return;
+    }
+    dateFormatValidator() {
+        return (control) => {
+            if (!control.value) {
+                return null;
+            }
+            const dateStr = control.value.trim();
+            const datePattern = /^(\d{1,2})\/(\d{1,2})\/(\d{4})$/;
+            if (!datePattern.test(dateStr)) {
+                return { invalidFormat: true };
+            }
+            const parts = dateStr.split('/');
+            const day = parts[0].padStart(2, '0');
+            const month = parts[1].padStart(2, '0');
+            const year = parts[2];
+            const normalizedDate = `${day}/${month}/${year}`;
+            const date = moment(normalizedDate, 'DD/MM/YYYY', true);
+            if (!date.isValid()) {
+                return { invalidDate: true };
+            }
+            return null;
+        };
+    }
+    async updateIndex(index, id, col) {
+        await this.ngFire.collection(col).doc(id).update({ index });
+    }
+    /**
+     * Extrai o link de criação de índice da mensagem de erro do Firestore
+     */
+    extractIndexLink(error) {
+        if (!error ||
+            typeof error !== 'object' ||
+            !('message' in error) ||
+            typeof error.message !== 'string')
+            return null;
+        const linkMatch = error.message.match(/(https:\/\/console\.firebase\.google\.com\/[^\s]+)/);
+        return linkMatch ? linkMatch[1] : null;
+    }
+    /**
+     * Rastreia índices ausentes ao usar fallback preventivo
+     */
+    async trackMissingIndexPreventive(collection, arrange, conditions = undefined) {
+        try {
+            const querySignature = this.generateQuerySignature(collection, arrange, conditions);
+            const docId = `${collection}_${querySignature}`;
+            const indexLink = this.generateIndexLink(collection, arrange, conditions);
+            const indexInstructions = this.generateIndexInstructions(collection, arrange, conditions);
+            const trackingData = {
+                collection,
+                indexLink,
+                indexInstructions,
+                arrange: {
+                    sortBy: arrange.sortBy,
+                    filters: arrange.filters?.map((f) => ({
+                        arrange: f.arrange,
+                        property: f.filter?.property || null,
+                        dateField: f.arrange === 'filterByDate' ? arrange.sortBy?.field : null,
+                    })) || [],
+                },
+                conditions: conditions?.map((c) => ({
+                    property: c.firestoreProperty,
+                    operator: c.operator,
+                })) || [],
+                errorMessage: `Fallback preventivo usado para a collection ${collection}. A query exigiria índice composto.`,
+                updatedAt: firebase.firestore.FieldValue.serverTimestamp(),
+            };
+            const docRef = this.ngFire.collection('missingIndexes').doc(docId);
+            const doc = await docRef.get().toPromise();
+            if (doc && doc.exists) {
+                await docRef.update({
+                    count: firebase.firestore.FieldValue.increment(1),
+                    updatedAt: firebase.firestore.FieldValue.serverTimestamp(),
+                    lastError: trackingData['errorMessage'],
+                });
+            }
+            else {
+                await docRef.set({
+                    ...trackingData,
+                    count: 1,
+                    createdAt: firebase.firestore.FieldValue.serverTimestamp(),
+                });
+            }
+        }
+        catch (trackingError) {
+            console.warn('Falha ao rastrear fallback preventivo:', trackingError);
+        }
+    }
+    /**
+     * Gera uma assinatura única para uma query
+     */
+    generateQuerySignature(collection, arrange, conditions = undefined) {
+        const signature = {
+            collection,
+            sortBy: arrange.sortBy,
+            filters: arrange.filters?.map((f) => ({
+                arrange: f.arrange,
+                property: f.filter?.property || null,
+            })) || [],
+            conditions: conditions?.map((c) => ({
+                property: c.firestoreProperty,
+                operator: c.operator,
+            })) || [],
+        };
+        return btoa(JSON.stringify(signature))
+            .replace(/[^a-zA-Z0-9]/g, '')
+            .substring(0, 20);
+    }
+    /**
+     * Gera instruções claras para criar o índice manualmente
+     */
+    generateIndexInstructions(collection, arrange, conditions = undefined) {
+        const instructions = {
+            summary: '',
+            collection: collection,
+            fields: [],
+            queryExample: '',
+            stepByStep: [],
+            notes: [],
+        };
+        const fields = [];
+        if (conditions && conditions.length > 0) {
+            conditions.forEach((condition) => {
+                if (condition.firestoreProperty) {
+                    fields.push({
+                        field: condition.firestoreProperty,
+                        order: 'Ascending',
+                        type: 'WHERE clause',
+                        operator: condition.operator,
+                        description: `Filtrar por ${condition.firestoreProperty} usando operador ${condition.operator}`,
+                    });
+                }
+            });
+        }
+        if (arrange.filters && arrange.filters.length > 0) {
+            arrange.filters.forEach((filter) => {
+                if (filter.filter?.property) {
+                    fields.push({
+                        field: filter.filter.property,
+                        order: 'Ascending',
+                        type: 'WHERE clause (filter)',
+                        operator: filter.arrange === 'filter' ? 'CONTAINS' : 'RANGE',
+                        description: `Filtrar por ${filter.filter.property} usando filtro ${filter.arrange}`,
+                    });
+                }
+            });
+        }
+        if (arrange.sortBy?.field) {
+            fields.push({
+                field: arrange.sortBy.field,
+                order: arrange.sortBy.order === 'desc' ? 'Descending' : 'Ascending',
+                type: 'ORDER BY clause',
+                operator: 'N/A',
+                description: `Ordenar resultados por ${arrange.sortBy.field} em ordem ${arrange.sortBy.order}`,
+            });
+        }
+        instructions.fields = fields;
+        const fieldNames = fields.map((f) => f.field).join(' + ');
+        instructions.summary = `Criar índice composto para ${collection}: ${fieldNames}`;
+        let queryExample = `db.collection('${collection}')`;
+        fields.forEach((field, index) => {
+            if (field.type.includes('WHERE')) {
+                if (field.operator === '==') {
+                    queryExample += `\n  .where('${field.field}', '==', 'value')`;
+                }
+                else if (field.operator === 'CONTAINS') {
+                    queryExample += `\n  .where('${field.field}', '>=', 'searchText')`;
+                }
+                else {
+                    queryExample += `\n  .where('${field.field}', '${field.operator}', 'value')`;
+                }
+            }
+        });
+        const orderByField = fields.find((f) => f.type.includes('ORDER BY'));
+        if (orderByField) {
+            queryExample += `\n  .orderBy('${orderByField.field}', '${orderByField.order.toLowerCase()}')`;
+        }
+        instructions.queryExample = queryExample;
+        instructions.stepByStep = [
+            '1. Ir para Firebase Console → Firestore → Indexes',
+            '2. Clicar em "Create Index"',
+            `3. Definir Collection ID: ${collection}`,
+            '4. Configurar campos nesta ORDEM EXATA:',
+            ...fields.map((field, index) => `   ${index + 1}. Campo: ${field.field}, Order: ${field.order}, Array: No`),
+            '5. Definir Query scopes: Collection',
+            '6. Clicar em "Create" e aguardar conclusão',
+        ];
+        instructions.notes = [
+            '⚠️ A ordem dos campos é CRÍTICA - deve corresponder exatamente à ordem da query',
+            '⚠️ As cláusulas WHERE devem vir ANTES do campo ORDER BY',
+            '⚠️ Este índice só funcionará para queries com esta combinação EXATA de campos',
+            '⚠️ A criação do índice pode levar vários minutos',
+        ];
+        return instructions;
+    }
+    /**
+     * Gera um link de índice baseado na estrutura da query
+     */
+    generateIndexLink(collection, arrange, conditions = undefined) {
+        try {
+            const indexFields = [];
+            if (conditions && conditions.length > 0) {
+                conditions.forEach((condition) => {
+                    if (condition.firestoreProperty) {
+                        indexFields.push(condition.firestoreProperty);
+                    }
+                });
+            }
+            if (arrange.filters && arrange.filters.length > 0) {
+                arrange.filters.forEach((filter) => {
+                    if (filter.filter?.property) {
+                        indexFields.push(filter.filter.property);
+                    }
+                });
+            }
+            if (arrange.sortBy?.field) {
+                indexFields.push(arrange.sortBy.field);
+            }
+            if (indexFields.length > 1) {
+                // Obter o projectId dinamicamente do Firebase
+                const options = this.ngFire?.firestore?.app?.options;
+                const projectId = options?.['projectId'];
+                if (!projectId) {
+                    console.warn('Não foi possível obter o projectId do Firebase');
+                    return null;
+                }
+                const baseUrl = `https://console.firebase.google.com/project/${projectId}/firestore/indexes`;
+                const queryParams = new URLSearchParams({
+                    create_composite: `collection=${collection}&fields=${indexFields.join(',')}`,
+                });
+                const finalLink = `${baseUrl}?${queryParams.toString()}`;
+                return finalLink;
+            }
+            return null;
+        }
+        catch (error) {
+            console.warn('Falha ao gerar link de índice:', error);
+            return null;
+        }
+    }
+    async trackMissingIndex(error, collection, arrange, conditions = undefined) {
+        try {
+            const indexLink = this.extractIndexLink(error);
+            if (!indexLink)
+                return;
+            const linkHash = btoa(indexLink)
+                .replace(/[^a-zA-Z0-9]/g, '')
+                .substring(0, 20);
+            const docId = `${collection}_${linkHash}`;
+            const indexInstructions = this.generateIndexInstructions(collection, arrange, conditions);
+            const trackingData = {
+                collection,
+                indexLink,
+                indexInstructions,
+                arrange: {
+                    sortBy: arrange.sortBy,
+                    filters: arrange.filters?.map((f) => ({
+                        arrange: f.arrange,
+                        property: f.filter?.property || null,
+                        dateField: f.arrange === 'filterByDate' ? arrange.sortBy?.field : null,
+                    })) || [],
+                },
+                conditions: conditions?.map((c) => ({
+                    property: c.firestoreProperty,
+                    operator: c.operator,
+                })) || [],
+                errorMessage: error &&
+                    typeof error === 'object' &&
+                    'message' in error &&
+                    typeof error.message === 'string'
+                    ? error.message
+                    : String(error),
+                updatedAt: firebase.firestore.FieldValue.serverTimestamp(),
+            };
+            const docRef = this.ngFire.collection('missingIndexes').doc(docId);
+            const doc = await docRef.get().toPromise();
+            const errorMessage = error &&
+                typeof error === 'object' &&
+                'message' in error &&
+                typeof error.message === 'string'
+                ? error.message
+                : String(error);
+            if (doc && doc.exists) {
+                await docRef.update({
+                    count: firebase.firestore.FieldValue.increment(1),
+                    updatedAt: firebase.firestore.FieldValue.serverTimestamp(),
+                    lastError: errorMessage,
+                });
+            }
+            else {
+                await docRef.set({
+                    ...trackingData,
+                    count: 1,
+                    createdAt: firebase.firestore.FieldValue.serverTimestamp(),
+                });
+            }
+        }
+        catch (trackingError) {
+            console.warn('Falha ao rastrear índice ausente:', trackingError);
+        }
+    }
+}
+TableService.ɵfac = function TableService_Factory(t) { return new (t || TableService)(i0.ɵɵinject(i1.AngularFirestore, 8), i0.ɵɵinject(i2.MatDialog, 8), i0.ɵɵinject(i3.ToastrService, 8)); };
+TableService.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: TableService, factory: TableService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TableService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.AngularFirestore, decorators: [{
+                type: Optional
+            }] }, { type: i2.MatDialog, decorators: [{
+                type: Optional
+            }] }, { type: i3.ToastrService, decorators: [{
+                type: Optional
+            }] }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table.service.js","sourceRoot":"","sources":["../../../../../projects/ng-firebase-table-kxp/src/lib/services/table.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Optional } from '@angular/core';\r\nimport {\r\n  AngularFirestore,\r\n  CollectionReference,\r\n  QueryDocumentSnapshot,\r\n} from '@angular/fire/compat/firestore';\r\nimport firebase from 'firebase/compat/app';\r\nimport { Arrange, Condition, Pagination } from '../types/Table';\r\nimport { firstValueFrom } from 'rxjs';\r\nimport { MatDialog } from '@angular/material/dialog';\r\nimport { ToastrService } from 'ngx-toastr';\r\nimport { AbstractControl, ValidatorFn } from '@angular/forms';\r\nimport * as moment from 'moment';\r\n\r\ninterface ErrorWithCode extends Error {\r\n  code: string;\r\n}\r\n\r\ninterface ErrorWithMessage {\r\n  message: string;\r\n}\r\n\r\ninterface PaginationResult {\r\n  items: Array<Record<string, unknown> & { id: string }>;\r\n  filterLength: number | null;\r\n  firstDoc: firebase.firestore.QueryDocumentSnapshot<unknown> | null;\r\n  lastDoc: firebase.firestore.QueryDocumentSnapshot<unknown> | null;\r\n  hasNextPage: boolean;\r\n  hasPreviousPage?: boolean;\r\n  currentClientPageIndex?: number;\r\n  totalPages?: number;\r\n}\r\n\r\n@Injectable()\r\nexport class TableService {\r\n  constructor(\r\n    @Optional() private ngFire: AngularFirestore,\r\n    @Optional() private dialog: MatDialog,\r\n    @Optional() private toastr: ToastrService\r\n  ) {}\r\n\r\n  async getItems(\r\n    collection: CollectionReference<unknown>\r\n  ): Promise<Array<Record<string, unknown> & { id: string }>> {\r\n    try {\r\n      const querySnapshot = await collection.get();\r\n      return querySnapshot.docs.map(\r\n        (doc: firebase.firestore.QueryDocumentSnapshot<unknown>) => {\r\n          const data = doc.data() as Record<string, unknown> | undefined;\r\n          return { ...(data ?? {}), id: doc.id } as Record<string, unknown> & {\r\n            id: string;\r\n          };\r\n        }\r\n      );\r\n    } catch (error) {\r\n      console.warn('Collection não encontrada:', error);\r\n      return [];\r\n    }\r\n  }\r\n\r\n  private async executeQuery(params: Pagination): Promise<PaginationResult> {\r\n    if (params.filterFn) {\r\n      // Lógica com filtro no cliente (filterFn)\r\n      const BATCH_FETCH_SIZE = params.batchSize;\r\n      const GOAL_SIZE = params.batchSize + 1;\r\n\r\n      if (params.navigation === 'forward' || params.navigation === 'reload') {\r\n        if (params.navigation === 'reload' && params.doc) {\r\n          params.doc.lastDoc = null;\r\n        }\r\n\r\n        let lastDocCursor: firebase.firestore.QueryDocumentSnapshot<unknown> | null =\r\n          params.doc ? params.doc.lastDoc : null;\r\n        let pageResults: Array<Record<string, unknown> & { id: string }> = [];\r\n        let allFetchedDocs: firebase.firestore.QueryDocumentSnapshot<unknown>[] =\r\n          [];\r\n        let hasMoreDocsInDb = true;\r\n\r\n        while (pageResults.length < GOAL_SIZE && hasMoreDocsInDb) {\r\n          let query: firebase.firestore.Query<unknown> = this.ngFire.collection(\r\n            params.collection\r\n          ).ref;\r\n          query = this.applyFilters(query, params.arrange, params.conditions);\r\n\r\n          if (lastDocCursor) {\r\n            query = query.startAfter(lastDocCursor);\r\n          }\r\n          query = query.limit(BATCH_FETCH_SIZE);\r\n\r\n          const snapshot = await query.get();\r\n\r\n          if (snapshot.empty) {\r\n            hasMoreDocsInDb = false;\r\n            break;\r\n          }\r\n\r\n          lastDocCursor = snapshot.docs[snapshot.docs.length - 1];\r\n          allFetchedDocs.push(...snapshot.docs);\r\n\r\n          const batchUsers = snapshot.docs\r\n            .map((doc: firebase.firestore.QueryDocumentSnapshot<unknown>) => {\r\n              const data = doc.data() as Record<string, unknown> | undefined;\r\n              return { id: doc.id, ...(data ?? {}) } as Record<\r\n                string,\r\n                unknown\r\n              > & { id: string };\r\n            })\r\n            .filter(params.filterFn);\r\n\r\n          pageResults.push(...batchUsers);\r\n\r\n          if (snapshot.size < BATCH_FETCH_SIZE) {\r\n            hasMoreDocsInDb = false;\r\n          }\r\n        }\r\n\r\n        const hasNextPage = pageResults.length > params.batchSize;\r\n        const finalItems = pageResults.slice(0, params.batchSize);\r\n\r\n        const firstDocOfPage =\r\n          allFetchedDocs.find(\r\n            (doc: firebase.firestore.QueryDocumentSnapshot<unknown>) =>\r\n              doc.id === finalItems[0]?.id\r\n          ) || null;\r\n        const lastDocOfPage =\r\n          allFetchedDocs.find(\r\n            (doc: firebase.firestore.QueryDocumentSnapshot<unknown>) =>\r\n              doc.id === finalItems[finalItems.length - 1]?.id\r\n          ) || null;\r\n\r\n        return {\r\n          items: finalItems,\r\n          filterLength: null,\r\n          firstDoc: firstDocOfPage,\r\n          lastDoc: lastDocOfPage,\r\n          hasNextPage: hasNextPage,\r\n          hasPreviousPage:\r\n            !!(params.doc && params.doc.lastDoc) &&\r\n            params.navigation !== 'reload',\r\n          currentClientPageIndex: undefined,\r\n        };\r\n      }\r\n      // Lógica para trás (backward)\r\n      else if (params.navigation === 'backward') {\r\n        if (!params.doc || !params.doc.firstDoc) {\r\n          return {\r\n            items: [],\r\n            filterLength: null,\r\n            firstDoc: null,\r\n            lastDoc: null,\r\n            hasNextPage: true,\r\n            hasPreviousPage: false,\r\n            currentClientPageIndex: undefined,\r\n          };\r\n        }\r\n\r\n        let pageResults: Array<Record<string, unknown> & { id: string }> = [];\r\n        let allFetchedDocs: firebase.firestore.QueryDocumentSnapshot<unknown>[] =\r\n          [];\r\n        let hasMoreDocsInDb = true;\r\n\r\n        let boundaryDoc: firebase.firestore.QueryDocumentSnapshot<unknown> | null =\r\n          params.doc.firstDoc;\r\n\r\n        while (pageResults.length < GOAL_SIZE && hasMoreDocsInDb) {\r\n          if (!boundaryDoc) break;\r\n\r\n          let query: firebase.firestore.Query<unknown> = this.ngFire.collection(\r\n            params.collection\r\n          ).ref;\r\n\r\n          query = this.applyFilters(query, params.arrange, params.conditions);\r\n\r\n          query = query.endBefore(boundaryDoc);\r\n          query = query.limitToLast(BATCH_FETCH_SIZE);\r\n\r\n          const snapshot = await query.get();\r\n\r\n          if (snapshot.empty) {\r\n            hasMoreDocsInDb = false;\r\n            break;\r\n          }\r\n\r\n          boundaryDoc = snapshot\r\n            .docs[0] as firebase.firestore.QueryDocumentSnapshot<unknown>;\r\n\r\n          allFetchedDocs = [...snapshot.docs, ...allFetchedDocs];\r\n\r\n          const batchUsers = snapshot.docs\r\n            .map((doc: firebase.firestore.QueryDocumentSnapshot<unknown>) => {\r\n              const data = doc.data() as Record<string, unknown> | undefined;\r\n              return { id: doc.id, ...(data ?? {}) } as Record<\r\n                string,\r\n                unknown\r\n              > & { id: string };\r\n            })\r\n            .filter(params.filterFn);\r\n\r\n          pageResults = [...batchUsers, ...pageResults];\r\n\r\n          if (snapshot.size < BATCH_FETCH_SIZE) {\r\n            hasMoreDocsInDb = false;\r\n          }\r\n        }\r\n\r\n        const finalItems = pageResults.slice(0, params.batchSize);\r\n\r\n        const firstDocOfPage =\r\n          allFetchedDocs.find(\r\n            (doc: firebase.firestore.QueryDocumentSnapshot<unknown>) =>\r\n              doc.id === finalItems[0]?.id\r\n          ) || null;\r\n        const lastDocOfPage =\r\n          allFetchedDocs.find(\r\n            (doc: firebase.firestore.QueryDocumentSnapshot<unknown>) =>\r\n              doc.id === finalItems[finalItems.length - 1]?.id\r\n          ) || null;\r\n\r\n        return {\r\n          items: finalItems,\r\n          filterLength: null,\r\n          firstDoc: firstDocOfPage,\r\n          lastDoc: lastDocOfPage,\r\n          hasNextPage: true,\r\n          currentClientPageIndex: undefined,\r\n        };\r\n      }\r\n    } else {\r\n      let items: Array<Record<string, unknown> & { id: string }> = [];\r\n      let docs: firebase.firestore.QueryDocumentSnapshot<unknown>[] = [];\r\n      let hasNextPage = false;\r\n      let filterLength: null | number = null;\r\n\r\n      let query: firebase.firestore.Query<unknown> = this.ngFire.collection(\r\n        params.collection\r\n      ).ref;\r\n\r\n      if (params.conditions) {\r\n        params.conditions.forEach((c: Condition) => {\r\n          if (c.operator === '!=') {\r\n            query = query.orderBy(c.firestoreProperty);\r\n          }\r\n        });\r\n      }\r\n\r\n      query = this.applyFilters(query, params.arrange, params.conditions);\r\n\r\n      if (params.navigation === 'reload') {\r\n        query = query.limit(params.batchSize + 1);\r\n        if (params.doc && params.doc.firstDoc) {\r\n          query = query.startAt(params.doc.firstDoc);\r\n        }\r\n      } else if (params.navigation === 'forward') {\r\n        query = query.limit(params.batchSize + 1);\r\n\r\n        if (params.doc && params.doc.lastDoc) {\r\n          query = query.startAfter(params.doc.lastDoc);\r\n        }\r\n      } else {\r\n        // backward\r\n        query = query.limitToLast(params.batchSize + 1);\r\n        if (params.doc && params.doc.firstDoc) {\r\n          query = query.endBefore(params.doc.firstDoc);\r\n        }\r\n      }\r\n\r\n      const itemCol = await query.get();\r\n      itemCol.docs.forEach(\r\n        (doc: firebase.firestore.QueryDocumentSnapshot<unknown>) =>\r\n          docs.push(doc)\r\n      );\r\n      const itemPromises = docs.map(\r\n        async (item: firebase.firestore.QueryDocumentSnapshot<unknown>) => {\r\n          const itemData = item.data() as Record<string, unknown> | undefined;\r\n          items.push({ id: item.id, ...(itemData ?? {}) } as Record<\r\n            string,\r\n            unknown\r\n          > & { id: string });\r\n        }\r\n      );\r\n\r\n      let lastDoc: firebase.firestore.QueryDocumentSnapshot<unknown> | null =\r\n        docs[docs.length - 1] || null;\r\n      let firstDoc: firebase.firestore.QueryDocumentSnapshot<unknown> | null =\r\n        docs[0];\r\n\r\n      if (\r\n        (items.length > params.batchSize && params.navigation === 'forward') ||\r\n        (params.navigation === 'reload' && items.length > params.batchSize)\r\n      ) {\r\n        lastDoc = docs[docs.length - 2] || null;\r\n        items.pop();\r\n        hasNextPage = true;\r\n      }\r\n      if (items.length > params.batchSize && params.navigation === 'backward') {\r\n        firstDoc = docs[1];\r\n        items.shift();\r\n        hasNextPage = true;\r\n      }\r\n\r\n      await Promise.all(itemPromises);\r\n      return {\r\n        items,\r\n        filterLength,\r\n        lastDoc,\r\n        firstDoc,\r\n        hasNextPage,\r\n        currentClientPageIndex: undefined,\r\n      };\r\n    }\r\n\r\n    // Fallback para garantir que sempre retornamos algo\r\n    return {\r\n      items: [],\r\n      filterLength: null,\r\n      firstDoc: null,\r\n      lastDoc: null,\r\n      hasNextPage: false,\r\n      currentClientPageIndex: undefined,\r\n    };\r\n  }\r\n\r\n  applyFilters(\r\n    query: firebase.firestore.Query<unknown>,\r\n    arrange: Arrange,\r\n    conditions: Condition[] | undefined\r\n  ): firebase.firestore.Query<unknown> {\r\n    if (conditions) {\r\n      conditions.map((cond: Condition) => {\r\n        query = query.where(\r\n          cond.firestoreProperty,\r\n          cond.operator,\r\n          cond.dashProperty\r\n        );\r\n      });\r\n    }\r\n\r\n    let hasFilterSpecificOrderBy = false;\r\n    let appliedOrderByField: string | null = null;\r\n\r\n    const equalsFilters = arrange.filters.filter(\r\n      (\r\n        f\r\n      ): f is Arrange['filters'][0] & {\r\n        arrange: 'equals';\r\n        filter: { property: string; filtering: string };\r\n      } => f.arrange === 'equals' && !!f.filter\r\n    );\r\n    const otherFilters = arrange.filters.filter(\r\n      (f): f is Arrange['filters'][0] => f.arrange !== 'equals'\r\n    );\r\n\r\n    const equalsGroupedByProperty = equalsFilters.reduce(\r\n      (acc: Record<string, string[]>, current) => {\r\n        const prop = current.filter!.property;\r\n        if (!acc[prop]) {\r\n          acc[prop] = [];\r\n        }\r\n        acc[prop].push(current.filter!.filtering);\r\n        return acc;\r\n      },\r\n      {} as Record<string, string[]>\r\n    );\r\n\r\n    for (const prop in equalsGroupedByProperty) {\r\n      const values = equalsGroupedByProperty[prop];\r\n      if (values.length > 0) {\r\n        query = query.where(prop, 'in', values);\r\n      }\r\n    }\r\n\r\n    otherFilters.forEach((filterItem: Arrange['filters'][0]) => {\r\n      // Aplicar filtragem por busca\r\n      if (\r\n        filterItem.filter?.filtering &&\r\n        filterItem.filter?.property !== '' &&\r\n        filterItem.arrange === 'filter'\r\n      ) {\r\n        query = query\r\n          .where(\r\n            filterItem.filter.property,\r\n            '>=',\r\n            filterItem.filter.filtering.trim().toUpperCase()\r\n          )\r\n          .where(\r\n            filterItem.filter.property,\r\n            '<=',\r\n            filterItem.filter.filtering.trim().toUpperCase() + '\\uf8ff'\r\n          );\r\n        if (!hasFilterSpecificOrderBy) {\r\n          query = query.orderBy(filterItem.filter.property);\r\n          hasFilterSpecificOrderBy = true;\r\n          appliedOrderByField = filterItem.filter.property;\r\n        }\r\n      }\r\n\r\n      // Aplicar filtro do tipo \"filterByDate\"\r\n      if (filterItem.dateFilter && filterItem.arrange === 'filterByDate') {\r\n        query = query\r\n          .where(arrange.sortBy.field, '>=', filterItem.dateFilter.initial)\r\n          .where(arrange.sortBy.field, '<=', filterItem.dateFilter.final);\r\n        if (!hasFilterSpecificOrderBy) {\r\n          query = query.orderBy(arrange.sortBy.field);\r\n          hasFilterSpecificOrderBy = true;\r\n          appliedOrderByField = arrange.sortBy.field;\r\n        }\r\n      }\r\n    });\r\n\r\n    // Aplicar sortBy\r\n    if (arrange.sortBy && arrange.sortBy.field && arrange.sortBy.order) {\r\n      if (appliedOrderByField !== arrange.sortBy.field) {\r\n        query = query.orderBy(arrange.sortBy.field, arrange.sortBy.order);\r\n      }\r\n    }\r\n    return query;\r\n  }\r\n\r\n  private getIdFilter(params: Pagination): string | null {\r\n    if (!params.arrange?.filters) return null;\r\n\r\n    const idFilter = params.arrange.filters.find(\r\n      (\r\n        f\r\n      ): f is Arrange['filters'][0] & {\r\n        arrange: 'filter';\r\n        filter: { property: string; filtering: string };\r\n      } =>\r\n        f.arrange === 'filter' &&\r\n        !!f.filter &&\r\n        f.filter.property === 'id' &&\r\n        !!f.filter.filtering\r\n    );\r\n\r\n    return idFilter?.filter?.filtering?.trim() || null;\r\n  }\r\n\r\n  private async getDocumentById(\r\n    collection: string,\r\n    docId: string\r\n  ): Promise<(Record<string, unknown> & { id: string }) | null> {\r\n    try {\r\n      const docRef = this.ngFire.collection(collection).doc(docId);\r\n      const docSnapshot = await docRef.get().toPromise();\r\n\r\n      if (docSnapshot && docSnapshot.exists) {\r\n        const data = docSnapshot.data() as Record<string, unknown> | undefined;\r\n        return {\r\n          id: docSnapshot.id,\r\n          ...(data ?? {}),\r\n        } as Record<string, unknown> & { id: string };\r\n      }\r\n      return null;\r\n    } catch (error) {\r\n      console.warn('Erro ao buscar documento por ID:', error);\r\n      return null;\r\n    }\r\n  }\r\n\r\n  private async searchByIdPartial(\r\n    params: Pagination,\r\n    searchTerm: string\r\n  ): Promise<PaginationResult> {\r\n    const exactMatch = await this.getDocumentById(\r\n      params.collection,\r\n      searchTerm\r\n    );\r\n\r\n    if (exactMatch) {\r\n      if (params.conditions) {\r\n        const operators = this.operators;\r\n        const passesConditions = params.conditions.every((cond) => {\r\n          const operatorFn = operators[cond.operator as keyof typeof operators];\r\n          return operatorFn\r\n            ? operatorFn(exactMatch[cond.firestoreProperty], cond.dashProperty)\r\n            : false;\r\n        });\r\n\r\n        if (!passesConditions) {\r\n          return {\r\n            items: [],\r\n            filterLength: 0,\r\n            firstDoc: null,\r\n            lastDoc: null,\r\n            hasNextPage: false,\r\n            hasPreviousPage: false,\r\n            currentClientPageIndex: 0,\r\n            totalPages: 0,\r\n          };\r\n        }\r\n      }\r\n\r\n      if (params.filterFn && !params.filterFn(exactMatch)) {\r\n        return {\r\n          items: [],\r\n          filterLength: 0,\r\n          firstDoc: null,\r\n          lastDoc: null,\r\n          hasNextPage: false,\r\n          hasPreviousPage: false,\r\n          currentClientPageIndex: 0,\r\n          totalPages: 0,\r\n        };\r\n      }\r\n\r\n      return {\r\n        items: [exactMatch],\r\n        filterLength: 1,\r\n        firstDoc: null,\r\n        lastDoc: null,\r\n        hasNextPage: false,\r\n        hasPreviousPage: false,\r\n        currentClientPageIndex: 0,\r\n        totalPages: 1,\r\n      };\r\n    }\r\n\r\n    const searchTermLower = searchTerm.toLowerCase();\r\n\r\n    const paramsWithoutIdFilter = {\r\n      ...params,\r\n      arrange: {\r\n        ...params.arrange,\r\n        filters: params.arrange.filters.filter(\r\n          (f) => !(f.arrange === 'filter' && f.filter?.property === 'id')\r\n        ),\r\n      },\r\n    };\r\n\r\n    let query: firebase.firestore.Query<unknown> = this.ngFire.collection(\r\n      params.collection\r\n    ).ref;\r\n\r\n    // Aplicar conditions\r\n    if (params.conditions) {\r\n      params.conditions.forEach((cond) => {\r\n        query = query.where(\r\n          cond.firestoreProperty,\r\n          cond.operator,\r\n          cond.dashProperty\r\n        );\r\n      });\r\n    }\r\n\r\n    // Aplicar sortBy\r\n    if (params.arrange?.sortBy?.field && params.arrange?.sortBy?.order) {\r\n      query = query.orderBy(\r\n        params.arrange.sortBy.field,\r\n        params.arrange.sortBy.order\r\n      );\r\n    }\r\n\r\n    const snapshot = await query.get();\r\n    let items: Array<Record<string, unknown> & { id: string }> = snapshot.docs\r\n      .map((doc) => {\r\n        const data = doc.data() as Record<string, unknown> | undefined;\r\n        return { id: doc.id, ...(data ?? {}) } as Record<string, unknown> & {\r\n          id: string;\r\n        };\r\n      })\r\n      .filter((item) => item.id.toLowerCase().includes(searchTermLower));\r\n\r\n    // Separar equals filters e outros filtros\r\n    const equalsFilters = paramsWithoutIdFilter.arrange.filters.filter(\r\n      (\r\n        f\r\n      ): f is Arrange['filters'][0] & {\r\n        arrange: 'equals';\r\n        filter: { property: string; filtering: string };\r\n      } => f.arrange === 'equals' && !!f.filter\r\n    );\r\n    const otherFilters = paramsWithoutIdFilter.arrange.filters.filter(\r\n      (f): f is Arrange['filters'][0] =>\r\n        f.arrange !== 'equals' &&\r\n        (f.arrange !== 'filter' || f.filter?.property !== 'id')\r\n    );\r\n\r\n    // Aplicar equals filters com lógica OR dentro de cada propriedade\r\n    if (equalsFilters.length > 0) {\r\n      // Agrupar por propriedade para aplicar OR\r\n      const groupedByProperty = equalsFilters.reduce(\r\n        (acc: Record<string, (string | boolean)[]>, f) => {\r\n          const prop = f.filter.property;\r\n          if (!acc[prop]) {\r\n            acc[prop] = [];\r\n          }\r\n          acc[prop].push(f.filter.filtering);\r\n          return acc;\r\n        },\r\n        {} as Record<string, (string | boolean)[]>\r\n      );\r\n\r\n      // Filtrar: item deve ter pelo menos um valor de CADA propriedade\r\n      items = items.filter((item) => {\r\n        return Object.entries(groupedByProperty).every(([prop, values]) => {\r\n          const itemValue = item[prop];\r\n          return values.includes(itemValue as string | boolean);\r\n        });\r\n      });\r\n    }\r\n\r\n    // Aplicar outros filtros\r\n    otherFilters.forEach((filterItem) => {\r\n      if (\r\n        filterItem.arrange === 'filter' &&\r\n        filterItem.filter?.filtering &&\r\n        filterItem.filter?.property\r\n      ) {\r\n        const filterValue = String(filterItem.filter.filtering)\r\n          .trim()\r\n          .toLowerCase();\r\n        items = items.filter((item) => {\r\n          const itemValue = String(\r\n            item[filterItem.filter!.property] ?? ''\r\n          ).toLowerCase();\r\n          return itemValue.includes(filterValue);\r\n        });\r\n      }\r\n    });\r\n\r\n    // Aplicar filterFn se existir\r\n    if (params.filterFn) {\r\n      items = items.filter(params.filterFn);\r\n    }\r\n\r\n    // Paginação\r\n    const pageSize = params.batchSize;\r\n    let currentClientPageIndex = 0;\r\n\r\n    if (params.navigation === 'reload') {\r\n      currentClientPageIndex = 0;\r\n    } else {\r\n      // Usar o índice passado pelo componente sem incrementar/decrementar\r\n      currentClientPageIndex = params.clientPageIndex || 0;\r\n    }\r\n\r\n    const startIndex = currentClientPageIndex * pageSize;\r\n    const endIndex = startIndex + pageSize;\r\n    const paginatedItems = items.slice(startIndex, endIndex);\r\n\r\n    const totalPages = Math.ceil(items.length / pageSize);\r\n    const hasNextPage = currentClientPageIndex < totalPages - 1;\r\n    const hasPreviousPage = currentClientPageIndex > 0;\r\n\r\n    return {\r\n      items: paginatedItems,\r\n      filterLength: items.length,\r\n      firstDoc: null,\r\n      lastDoc: null,\r\n      hasNextPage,\r\n      hasPreviousPage,\r\n      currentClientPageIndex,\r\n      totalPages,\r\n    };\r\n  }\r\n\r\n  private shouldUseClientSideFallback(params: Pagination): boolean {\r\n    const hasConditions = params.conditions && params.conditions.length > 0;\r\n    const hasArrangeFilters =\r\n      params.arrange?.filters && params.arrange.filters.length > 0;\r\n    const hasSortBy = params.arrange?.sortBy?.field;\r\n\r\n    if (params.filterFn) {\r\n      return false;\r\n    }\r\n\r\n    if (hasArrangeFilters) {\r\n      const equalsFilters = params.arrange.filters.filter(\r\n        (\r\n          f\r\n        ): f is Arrange['filters'][0] & {\r\n          arrange: 'equals';\r\n          filter: { property: string; filtering: string };\r\n        } => f.arrange === 'equals' && !!f.filter\r\n      );\r\n\r\n      if (equalsFilters.length > 0) {\r\n        const propertiesSet = new Set(\r\n          equalsFilters.map((f) => f.filter.property)\r\n        );\r\n\r\n        if (propertiesSet.size > 1) {\r\n          return true;\r\n        }\r\n      }\r\n    }\r\n\r\n    if (hasConditions && hasArrangeFilters && hasSortBy) {\r\n      return true;\r\n    }\r\n\r\n    if (hasConditions && hasArrangeFilters) {\r\n      return true;\r\n    }\r\n\r\n    if (hasArrangeFilters && params.arrange.filters.length > 1 && hasSortBy) {\r\n      const equalsFilters = params.arrange.filters.filter(\r\n        (\r\n          f\r\n        ): f is Arrange['filters'][0] & {\r\n          arrange: 'equals';\r\n          filter: { property: string; filtering: string };\r\n        } => f.arrange === 'equals' && !!f.filter\r\n      );\r\n\r\n      if (equalsFilters.length > 0) {\r\n        const propertiesSet = new Set(\r\n          equalsFilters.map((f) => f.filter.property)\r\n        );\r\n        if (\r\n          propertiesSet.size === 1 &&\r\n          equalsFilters.length === params.arrange.filters.length\r\n        ) {\r\n          return false;\r\n        }\r\n      }\r\n\r\n      return true;\r\n    }\r\n\r\n    return false;\r\n  }\r\n\r\n  async getPaginated(params: Pagination): Promise<PaginationResult> {\r\n    const idFilterValue = this.getIdFilter(params);\r\n    if (idFilterValue) {\r\n      const result = await this.searchByIdPartial(params, idFilterValue);\r\n      return result;\r\n    }\r\n\r\n    // Detectar preventivamente se deve usar fallback\r\n    if (this.shouldUseClientSideFallback(params)) {\r\n      await this.trackMissingIndexPreventive(\r\n        params.collection,\r\n        params.arrange,\r\n        params.conditions\r\n      );\r\n\r\n      const result = await this.executeClientSideQuery(params);\r\n      return result;\r\n    }\r\n\r\n    try {\r\n      const result = await this.executeQuery(params);\r\n      return result;\r\n    } catch (error: unknown) {\r\n      if (\r\n        error &&\r\n        typeof error === 'object' &&\r\n        'code' in error &&\r\n        (error as ErrorWithCode).code === 'failed-precondition'\r\n      ) {\r\n        await this.trackMissingIndex(\r\n          error,\r\n          params.collection,\r\n          params.arrange,\r\n          params.conditions\r\n        );\r\n\r\n        const result = await this.executeClientSideQuery(params);\r\n        return result;\r\n      } else if (\r\n        error &&\r\n        typeof error === 'object' &&\r\n        'code' in error &&\r\n        (error as ErrorWithCode).code === 'invalid-argument'\r\n      ) {\r\n        await this.trackMissingIndex(\r\n          error,\r\n          params.collection,\r\n          params.arrange,\r\n          params.conditions\r\n        );\r\n\r\n        const result = await this.executeClientSideQuery(params);\r\n        return result;\r\n      } else {\r\n        throw error;\r\n      }\r\n    }\r\n  }\r\n\r\n  async executeClientSideQuery(params: Pagination): Promise<PaginationResult> {\r\n    // Otimizar usando pelo menos uma cláusula .where() quando possível\r\n    let query: firebase.firestore.Query<unknown> = this.ngFire.collection(\r\n      params.collection\r\n    ).ref;\r\n\r\n    let appliedCondition: Condition | null = null;\r\n    let hasAppliedWhereClause = false;\r\n\r\n    // Primeiro, tenta aplicar condições simples\r\n    if (params.conditions && params.conditions.length > 0) {\r\n      const simpleCondition = params.conditions.find((cond: Condition) =>\r\n        ['==', '>', '<', '>=', '<=', 'in', 'array-contains'].includes(\r\n          cond.operator\r\n        )\r\n      );\r\n\r\n      if (simpleCondition) {\r\n        query = query.where(\r\n          simpleCondition.firestoreProperty,\r\n          simpleCondition.operator,\r\n          simpleCondition.dashProperty\r\n        );\r\n        appliedCondition = simpleCondition;\r\n        hasAppliedWhereClause = true;\r\n      }\r\n    }\r\n\r\n    // Se não há condições disponíveis, tenta aplicar filtros do arrange\r\n    let appliedFirestoreFilter: Arrange['filters'][0] | 'all-equals' | null =\r\n      null;\r\n    if (!hasAppliedWhereClause && params.arrange?.filters) {\r\n      // Agrupar equals filters por propriedade\r\n      const equalsFilters = params.arrange.filters.filter(\r\n        (\r\n          f\r\n        ): f is Arrange['filters'][0] & {\r\n          arrange: 'equals';\r\n          filter: { property: string; filtering: string };\r\n        } => f.arrange === 'equals' && !!f.filter\r\n      );\r\n\r\n      const equalsGroupedByProperty = equalsFilters.reduce(\r\n        (acc: Record<string, (string | boolean)[]>, current) => {\r\n          const prop = current.filter.property;\r\n          if (!acc[prop]) {\r\n            acc[prop] = [];\r\n          }\r\n          acc[prop].push(current.filter.filtering);\r\n          return acc;\r\n        },\r\n        {} as Record<string, (string | boolean)[]>\r\n      );\r\n\r\n      // Se há apenas UMA propriedade com múltiplos valores, aplicar no Firestore com 'in'\r\n      const properties = Object.keys(equalsGroupedByProperty);\r\n      if (properties.length === 1 && equalsFilters.length > 0) {\r\n        const prop = properties[0];\r\n        const values = equalsGroupedByProperty[prop];\r\n        query = query.where(prop, 'in', values);\r\n        hasAppliedWhereClause = true;\r\n        // Marcar TODOS os equals filters dessa propriedade como aplicados\r\n        appliedFirestoreFilter = 'all-equals';\r\n      } else if (properties.length === 0) {\r\n        const otherFilter = params.arrange.filters.find(\r\n          (\r\n            f\r\n          ): f is Arrange['filters'][0] &\r\n            (\r\n              | {\r\n                  arrange: 'filter';\r\n                  filter: { property: string; filtering: string };\r\n                }\r\n              | {\r\n                  arrange: 'filterByDate';\r\n                  dateFilter: { initial: Date; final: Date };\r\n                }\r\n            ) =>\r\n            (f.arrange === 'filter' &&\r\n              !!f.filter?.filtering &&\r\n              !!f.filter?.property) ||\r\n            (f.arrange === 'filterByDate' &&\r\n              !!f.dateFilter?.initial &&\r\n              !!f.dateFilter?.final)\r\n        );\r\n\r\n        if (otherFilter) {\r\n          if (otherFilter.arrange === 'filter' && otherFilter.filter) {\r\n            const filterValue = otherFilter.filter.filtering\r\n              .trim()\r\n              .toUpperCase();\r\n            query = query\r\n              .where(otherFilter.filter.property, '>=', filterValue)\r\n              .where(otherFilter.filter.property, '<=', filterValue + '\\uf8ff');\r\n            hasAppliedWhereClause = true;\r\n            appliedFirestoreFilter = otherFilter;\r\n          } else if (\r\n            otherFilter.arrange === 'filterByDate' &&\r\n            otherFilter.dateFilter &&\r\n            params.arrange.sortBy?.field\r\n          ) {\r\n            query = query\r\n              .where(\r\n                params.arrange.sortBy.field,\r\n                '>=',\r\n                otherFilter.dateFilter.initial\r\n              )\r\n              .where(\r\n                params.arrange.sortBy.field,\r\n                '<=',\r\n                otherFilter.dateFilter.final\r\n              );\r\n            hasAppliedWhereClause = true;\r\n            appliedFirestoreFilter = otherFilter;\r\n          }\r\n        }\r\n      }\r\n    }\r\n\r\n    const allDocsSnapshot = await query.get();\r\n    let items: Array<Record<string, unknown> & { id: string }> =\r\n      allDocsSnapshot.docs.map(\r\n        (doc: firebase.firestore.QueryDocumentSnapshot<unknown>) => {\r\n          const data = doc.data() as Record<string, unknown> | undefined;\r\n          return { id: doc.id, ...(data ?? {}) } as Record<string, unknown> & {\r\n            id: string;\r\n          };\r\n        }\r\n      );\r\n\r\n    // Aplicar condições restantes\r\n    if (params.conditions) {\r\n      const remainingConditions = params.conditions.filter(\r\n        (cond: Condition) => cond !== appliedCondition\r\n      );\r\n      if (remainingConditions.length > 0) {\r\n        const operators = this.operators;\r\n        items = items.filter((item) => {\r\n          return remainingConditions.every((cond: Condition) => {\r\n            const operatorFn =\r\n              operators[cond.operator as keyof typeof operators];\r\n            return operatorFn\r\n              ? operatorFn(item[cond.firestoreProperty], cond.dashProperty)\r\n              : false;\r\n          });\r\n        });\r\n      }\r\n    }\r\n\r\n    const { filters, sortBy } = params.arrange;\r\n\r\n    // Track which filter was already applied in Firestore to avoid double filtering\r\n    if (hasAppliedWhereClause && !appliedCondition && params.arrange?.filters) {\r\n      const equalsFilter = params.arrange.filters.find(\r\n        (\r\n          f\r\n        ): f is Arrange['filters'][0] & {\r\n          arrange: 'equals';\r\n          filter: { property: string; filtering: string };\r\n        } => f.arrange === 'equals' && !!f.filter?.filtering\r\n      );\r\n      if (equalsFilter) {\r\n        appliedFirestoreFilter = equalsFilter;\r\n      } else {\r\n        const foundFilter = params.arrange.filters.find(\r\n          (\r\n            f\r\n          ): f is Arrange['filters'][0] &\r\n            (\r\n              | {\r\n                  arrange: 'filter';\r\n                  filter: { property: string; filtering: string };\r\n                }\r\n              | {\r\n                  arrange: 'filterByDate';\r\n                  dateFilter: { initial: Date; final: Date };\r\n                }\r\n            ) =>\r\n            (f.arrange === 'filter' &&\r\n              !!f.filter?.filtering &&\r\n              !!f.filter?.property) ||\r\n            (f.arrange === 'filterByDate' &&\r\n              !!f.dateFilter?.initial &&\r\n              !!f.dateFilter?.final)\r\n        );\r\n        if (foundFilter) {\r\n          appliedFirestoreFilter = foundFilter;\r\n        }\r\n      }\r\n    }\r\n\r\n    const equalsFilters = filters.filter(\r\n      (f): f is Arrange['filters'][0] & { arrange: 'equals' } =>\r\n        f.arrange === 'equals'\r\n    );\r\n    const otherFilters = filters.filter(\r\n      (f): f is Arrange['filters'][0] => f.arrange !== 'equals'\r\n    );\r\n\r\n    // Aplicar equals filters no client-side apenas se não foram aplicados no Firestore\r\n    if (appliedFirestoreFilter !== 'all-equals' && equalsFilters.length > 0) {\r\n      // Agrupar por propriedade para aplicar OR dentro de cada propriedade\r\n      const groupedByProperty = equalsFilters.reduce(\r\n        (acc: Record<string, (string | boolean)[]>, f) => {\r\n          if (f.filter) {\r\n            const prop = f.filter.property;\r\n            if (!acc[prop]) {\r\n              acc[prop] = [];\r\n            }\r\n            acc[prop].push(f.filter.filtering);\r\n          }\r\n          return acc;\r\n        },\r\n        {} as Record<string, (string | boolean)[]>\r\n      );\r\n\r\n      // Filtrar: item deve ter pelo menos um valor de CADA propriedade\r\n      // (AND entre propriedades, OR dentro de cada propriedade)\r\n      items = items.filter((item) => {\r\n        return Object.entries(groupedByProperty).every(([prop, values]) => {\r\n          const itemValue = item[prop];\r\n          return values.includes(itemValue as string | boolean);\r\n        });\r\n      });\r\n    }\r\n\r\n    otherFilters.forEach((filterItem) => {\r\n      if (appliedFirestoreFilter === filterItem) {\r\n        return;\r\n      }\r\n\r\n      if (\r\n        filterItem.arrange === 'filter' &&\r\n        filterItem.filter?.filtering &&\r\n        filterItem.filter?.property\r\n      ) {\r\n        const filterValue = String(filterItem.filter.filtering)\r\n          .trim()\r\n          .toLowerCase();\r\n        items = items.filter((item) => {\r\n          const itemValue = String(\r\n            item[filterItem.filter!.property] ?? ''\r\n          ).toLowerCase();\r\n          return itemValue.includes(filterValue);\r\n        });\r\n      }\r\n\r\n      if (\r\n        filterItem.arrange === 'filterByDate' &&\r\n        filterItem.dateFilter?.initial &&\r\n        filterItem.dateFilter?.final &&\r\n        sortBy.field\r\n      ) {\r\n        items = items.filter((item) => {\r\n          try {\r\n            const fieldValue = item[sortBy.field];\r\n\r\n            if (!fieldValue) {\r\n              return false;\r\n            }\r\n\r\n            let itemDate: Date;\r\n            const fieldValueObj = fieldValue as\r\n              | { toDate?: () => Date }\r\n              | Date\r\n              | string\r\n              | number\r\n              | null\r\n              | undefined;\r\n            if (\r\n              fieldValueObj &&\r\n              typeof fieldValueObj === 'object' &&\r\n              'toDate' in fieldValueObj &&\r\n              typeof fieldValueObj.toDate === 'function'\r\n            ) {\r\n              itemDate = fieldValueObj.toDate();\r\n            } else if (fieldValueObj instanceof Date) {\r\n              itemDate = fieldValueObj;\r\n            } else if (typeof fieldValueObj === 'string') {\r\n              itemDate = new Date(fieldValueObj);\r\n              if (isNaN(itemDate.getTime())) {\r\n                return false;\r\n              }\r\n            } else if (typeof fieldValueObj === 'number') {\r\n              itemDate = new Date(fieldValueObj);\r\n            } else {\r\n              return false;\r\n            }\r\n\r\n            if (!filterItem.dateFilter) {\r\n              return false;\r\n            }\r\n\r\n            return (\r\n              itemDate >= filterItem.dateFilter.initial &&\r\n              itemDate <= filterItem.dateFilter.final\r\n            );\r\n          } catch (error) {\r\n            console.warn(\r\n              'Erro ao processar filtro de data para o item:',\r\n              item.id,\r\n              error\r\n            );\r\n            return false;\r\n          }\r\n        });\r\n      }\r\n    });\r\n\r\n    // Aplicar filterFn se existir\r\n    if (params.filterFn) {\r\n      items = items.filter(params.filterFn);\r\n    }\r\n\r\n    if (sortBy && sortBy.field && sortBy.order) {\r\n      items.sort((a, b) => {\r\n        const valA = a[sortBy.field] as unknown;\r\n        const valB = b[sortBy.field] as unknown;\r\n\r\n        if (valA === null || valA === undefined) return 1;\r\n        if (valB === null || valB === undefined) return -1;\r\n\r\n        if (valA < valB) {\r\n          return sortBy.order === 'asc' ? -1 : 1;\r\n        }\r\n        if (valA > valB) {\r\n          return sortBy.order === 'asc' ? 1 : -1;\r\n        }\r\n        return 0;\r\n      });\r\n    }\r\n\r\n    // Implementação adequada da paginação\r\n    let currentClientPageIndex = 0;\r\n\r\n    // Determinar a página atual baseada na navegação\r\n    if (params.navigation === 'reload') {\r\n      currentClientPageIndex = 0;\r\n    } else {\r\n      currentClientPageIndex = params.clientPageIndex || 0;\r\n    }\r\n\r\n    const pageSize = params.batchSize;\r\n    const startIndex = currentClientPageIndex * pageSize;\r\n    const endIndex = startIndex + pageSize;\r\n    const paginatedItems = items.slice(startIndex, endIndex);\r\n\r\n    const totalPages = Math.ceil(items.length / pageSize);\r\n    const hasNextPage = currentClientPageIndex < totalPages - 1;\r\n    const hasPreviousPage = currentClientPageIndex > 0;\r\n\r\n    return {\r\n      items: paginatedItems,\r\n      filterLength: items.length,\r\n      lastDoc: null,\r\n      firstDoc: null,\r\n      hasNextPage: hasNextPage,\r\n      hasPreviousPage: hasPreviousPage,\r\n      currentClientPageIndex: currentClientPageIndex,\r\n      totalPages: totalPages,\r\n    };\r\n  }\r\n\r\n  async getItemsData(\r\n    collection: string,\r\n    arrange: Arrange,\r\n    conditions: Condition[] | undefined = undefined\r\n  ): Promise<Array<Record<string, unknown> & { id: string }>> {\r\n    try {\r\n      let query: firebase.firestore.Query<unknown> =\r\n        this.ngFire.collection(collection).ref;\r\n\r\n      query = this.applyFilters(query, arrange, conditions);\r\n      const snapshot = await query.get();\r\n      return await Promise.all(\r\n        snapshot.docs.map(\r\n          async (doc: firebase.firestore.QueryDocumentSnapshot<unknown>) => {\r\n            const data = doc.data() as Record<string, unknown> | undefined;\r\n            const id = doc.id;\r\n            return {\r\n              id,\r\n              ...(data ?? {}),\r\n            } as Record<string, unknown> & { id: string };\r\n          }\r\n        )\r\n      );\r\n    } catch (e) {\r\n      throw e;\r\n    }\r\n  }\r\n\r\n  public operators = {\r\n    '==': (a: unknown, b: unknown): boolean => a === b,\r\n    '!=': (a: unknown, b: unknown): boolean => a !== b,\r\n    '>': (a: unknown, b: unknown): boolean => (a as number) > (b as number),\r\n    '<': (a: unknown, b: unknown): boolean => (a as number) < (b as number),\r\n    '>=': (a: unknown, b: unknown): boolean => (a as number) >= (b as number),\r\n    '<=': (a: unknown, b: unknown): boolean => (a as number) <= (b as number),\r\n    in: (a: unknown, b: unknown): boolean => Array.isArray(b) && b.includes(a),\r\n    'not-in': (a: unknown, b: unknown): boolean =>\r\n      Array.isArray(b) && !b.includes(a),\r\n    'array-contains': (a: unknown, b: unknown): boolean =>\r\n      Array.isArray(a) && a.includes(b),\r\n    'array-contains-any': (a: unknown, b: unknown): boolean =>\r\n      Array.isArray(a) &&\r\n      Array.isArray(b) &&\r\n      b.some((item: unknown) => a.includes(item)),\r\n    includes: (a: unknown, b: unknown): boolean => {\r\n      if (typeof a === 'string' && typeof b === 'string') {\r\n        return a.includes(b);\r\n      }\r\n      if (Array.isArray(a)) {\r\n        return a.includes(b);\r\n      }\r\n      return false;\r\n    },\r\n  };\r\n\r\n  async deleteIndex(id: string, col: string): Promise<boolean> {\r\n    try {\r\n      const batch = this.ngFire.firestore.batch();\r\n\r\n      const docRef = this.ngFire.collection(col).doc(id);\r\n      const docSnapshot = (await firstValueFrom(\r\n        docRef.get()\r\n      )) as firebase.firestore.DocumentSnapshot<unknown>;\r\n      const doc = docSnapshot.data() as Record<string, unknown> | undefined;\r\n      batch.delete(docRef.ref);\r\n      if (doc && typeof doc['index'] === 'number') {\r\n        await this.reindex(doc['index'] as number, col, batch);\r\n      }\r\n      await batch.commit();\r\n\r\n      this.toastr.success('Item excluído com sucesso!');\r\n      return true;\r\n    } catch (e) {\r\n      const error = e as unknown;\r\n      console.error('Erro ao deletar item:', error);\r\n      this.toastr.error('Erro ao deletar item.');\r\n      return false;\r\n    }\r\n  }\r\n\r\n  async reindex(\r\n    index: number,\r\n    col: string,\r\n    batch: firebase.firestore.WriteBatch\r\n  ): Promise<void> {\r\n    try {\r\n      const snapshot = (await firstValueFrom(\r\n        this.ngFire.collection(col).get()\r\n      )) as firebase.firestore.QuerySnapshot<unknown>;\r\n      const docs = snapshot.docs;\r\n      for (let doc of docs) {\r\n        const data = doc.data() as Record<string, unknown> | undefined;\r\n        if (\r\n          data &&\r\n          typeof data['index'] === 'number' &&\r\n          (data['index'] as number) > index\r\n        ) {\r\n          data['index'] = ((data['index'] as number) - 1) as unknown;\r\n          const docRef = this.ngFire.collection(col).doc(doc.id).ref;\r\n          batch.update(docRef, data);\r\n        }\r\n      }\r\n    } catch (error) {\r\n      console.error('Erro ao reindexar:', error);\r\n    }\r\n    return;\r\n  }\r\n\r\n  dateFormatValidator(): ValidatorFn {\r\n    return (control: AbstractControl): { [key: string]: unknown } | null => {\r\n      if (!control.value) {\r\n        return null;\r\n      }\r\n\r\n      const dateStr = control.value.trim();\r\n      const datePattern = /^(\\d{1,2})\\/(\\d{1,2})\\/(\\d{4})$/;\r\n\r\n      if (!datePattern.test(dateStr)) {\r\n        return { invalidFormat: true };\r\n      }\r\n\r\n      const parts = dateStr.split('/');\r\n      const day = parts[0].padStart(2, '0');\r\n      const month = parts[1].padStart(2, '0');\r\n      const year = parts[2];\r\n      const normalizedDate = `${day}/${month}/${year}`;\r\n\r\n      const date = moment(normalizedDate, 'DD/MM/YYYY', true);\r\n\r\n      if (!date.isValid()) {\r\n        return { invalidDate: true };\r\n      }\r\n\r\n      return null;\r\n    };\r\n  }\r\n\r\n  async updateIndex(index: number, id: string, col: string): Promise<void> {\r\n    await this.ngFire.collection(col).doc(id).update({ index });\r\n  }\r\n\r\n  /**\r\n   * Extrai o link de criação de índice da mensagem de erro do Firestore\r\n   */\r\n  private extractIndexLink(error: unknown): string | null {\r\n    if (\r\n      !error ||\r\n      typeof error !== 'object' ||\r\n      !('message' in error) ||\r\n      typeof (error as ErrorWithMessage).message !== 'string'\r\n    )\r\n      return null;\r\n\r\n    const linkMatch = (error as ErrorWithMessage).message.match(\r\n      /(https:\\/\\/console\\.firebase\\.google\\.com\\/[^\\s]+)/\r\n    );\r\n    return linkMatch ? linkMatch[1] : null;\r\n  }\r\n\r\n  /**\r\n   * Rastreia índices ausentes ao usar fallback preventivo\r\n   */\r\n  private async trackMissingIndexPreventive(\r\n    collection: string,\r\n    arrange: Arrange,\r\n    conditions: Condition[] | undefined = undefined\r\n  ): Promise<void> {\r\n    try {\r\n      const querySignature = this.generateQuerySignature(\r\n        collection,\r\n        arrange,\r\n        conditions\r\n      );\r\n      const docId = `${collection}_${querySignature}`;\r\n\r\n      const indexLink = this.generateIndexLink(collection, arrange, conditions);\r\n\r\n      const indexInstructions = this.generateIndexInstructions(\r\n        collection,\r\n        arrange,\r\n        conditions\r\n      );\r\n\r\n      const trackingData: Record<string, unknown> = {\r\n        collection,\r\n        indexLink,\r\n        indexInstructions,\r\n        arrange: {\r\n          sortBy: arrange.sortBy,\r\n          filters:\r\n            arrange.filters?.map((f) => ({\r\n              arrange: f.arrange,\r\n              property: f.filter?.property || null,\r\n              dateField:\r\n                f.arrange === 'filterByDate' ? arrange.sortBy?.field : null,\r\n            })) || [],\r\n        },\r\n        conditions:\r\n          conditions?.map((c: Condition) => ({\r\n            property: c.firestoreProperty,\r\n            operator: c.operator,\r\n          })) || [],\r\n        errorMessage: `Fallback preventivo usado para a collection ${collection}. A query exigiria índice composto.`,\r\n        updatedAt: firebase.firestore.FieldValue.serverTimestamp(),\r\n      };\r\n\r\n      const docRef = this.ngFire.collection('missingIndexes').doc(docId);\r\n      const doc = await docRef.get().toPromise();\r\n\r\n      if (doc && doc.exists) {\r\n        await docRef.update({\r\n          count: firebase.firestore.FieldValue.increment(1),\r\n          updatedAt: firebase.firestore.FieldValue.serverTimestamp(),\r\n          lastError: trackingData['errorMessage'],\r\n        });\r\n      } else {\r\n        await docRef.set({\r\n          ...trackingData,\r\n          count: 1,\r\n          createdAt: firebase.firestore.FieldValue.serverTimestamp(),\r\n        });\r\n      }\r\n    } catch (trackingError) {\r\n      console.warn('Falha ao rastrear fallback preventivo:', trackingError);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Gera uma assinatura única para uma query\r\n   */\r\n  private generateQuerySignature(\r\n    collection: string,\r\n    arrange: Arrange,\r\n    conditions: Condition[] | undefined = undefined\r\n  ): string {\r\n    const signature = {\r\n      collection,\r\n      sortBy: arrange.sortBy,\r\n      filters:\r\n        arrange.filters?.map((f: Arrange['filters'][0]) => ({\r\n          arrange: f.arrange,\r\n          property: f.filter?.property || null,\r\n        })) || [],\r\n      conditions:\r\n        conditions?.map((c: Condition) => ({\r\n          property: c.firestoreProperty,\r\n          operator: c.operator,\r\n        })) || [],\r\n    };\r\n\r\n    return btoa(JSON.stringify(signature))\r\n      .replace(/[^a-zA-Z0-9]/g, '')\r\n      .substring(0, 20);\r\n  }\r\n\r\n  /**\r\n   * Gera instruções claras para criar o índice manualmente\r\n   */\r\n  private generateIndexInstructions(\r\n    collection: string,\r\n    arrange: Arrange,\r\n    conditions: Condition[] | undefined = undefined\r\n  ): {\r\n    summary: string;\r\n    collection: string;\r\n    fields: Array<{\r\n      field: string;\r\n      order: string;\r\n      type: string;\r\n      operator: string;\r\n      description: string;\r\n    }>;\r\n    queryExample: string;\r\n    stepByStep: string[];\r\n    notes: string[];\r\n  } {\r\n    const instructions: {\r\n      summary: string;\r\n      collection: string;\r\n      fields: Array<{\r\n        field: string;\r\n        order: string;\r\n        type: string;\r\n        operator: string;\r\n        description: string;\r\n      }>;\r\n      queryExample: string;\r\n      stepByStep: string[];\r\n      notes: string[];\r\n    } = {\r\n      summary: '',\r\n      collection: collection,\r\n      fields: [],\r\n      queryExample: '',\r\n      stepByStep: [],\r\n      notes: [],\r\n    };\r\n\r\n    const fields: Array<{\r\n      field: string;\r\n      order: string;\r\n      type: string;\r\n      operator: string;\r\n      description: string;\r\n    }> = [];\r\n\r\n    if (conditions && conditions.length > 0) {\r\n      conditions.forEach((condition: Condition) => {\r\n        if (condition.firestoreProperty) {\r\n          fields.push({\r\n            field: condition.firestoreProperty,\r\n            order: 'Ascending',\r\n            type: 'WHERE clause',\r\n            operator: condition.operator,\r\n            description: `Filtrar por ${condition.firestoreProperty} usando operador ${condition.operator}`,\r\n          });\r\n        }\r\n      });\r\n    }\r\n\r\n    if (arrange.filters && arrange.filters.length > 0) {\r\n      arrange.filters.forEach((filter) => {\r\n        if (filter.filter?.property) {\r\n          fields.push({\r\n            field: filter.filter.property,\r\n            order: 'Ascending',\r\n            type: 'WHERE clause (filter)',\r\n            operator: filter.arrange === 'filter' ? 'CONTAINS' : 'RANGE',\r\n            description: `Filtrar por ${filter.filter.property} usando filtro ${filter.arrange}`,\r\n          });\r\n        }\r\n      });\r\n    }\r\n\r\n    if (arrange.sortBy?.field) {\r\n      fields.push({\r\n        field: arrange.sortBy.field,\r\n        order: arrange.sortBy.order === 'desc' ? 'Descending' : 'Ascending',\r\n        type: 'ORDER BY clause',\r\n        operator: 'N/A',\r\n        description: `Ordenar resultados por ${arrange.sortBy.field} em ordem ${arrange.sortBy.order}`,\r\n      });\r\n    }\r\n\r\n    instructions.fields = fields;\r\n\r\n    const fieldNames = fields.map((f) => f.field).join(' + ');\r\n    instructions.summary = `Criar índice composto para ${collection}: ${fieldNames}`;\r\n\r\n    let queryExample = `db.collection('${collection}')`;\r\n\r\n    fields.forEach((field, index: number) => {\r\n      if (field.type.includes('WHERE')) {\r\n        if (field.operator === '==') {\r\n          queryExample += `\\n  .where('${field.field}', '==', 'value')`;\r\n        } else if (field.operator === 'CONTAINS') {\r\n          queryExample += `\\n  .where('${field.field}', '>=', 'searchText')`;\r\n        } else {\r\n          queryExample += `\\n  .where('${field.field}', '${field.operator}', 'value')`;\r\n        }\r\n      }\r\n    });\r\n\r\n    const orderByField = fields.find((f) => f.type.includes('ORDER BY'));\r\n    if (orderByField) {\r\n      queryExample += `\\n  .orderBy('${\r\n        orderByField.field\r\n      }', '${orderByField.order.toLowerCase()}')`;\r\n    }\r\n\r\n    instructions.queryExample = queryExample;\r\n\r\n    instructions.stepByStep = [\r\n      '1. Ir para Firebase Console → Firestore → Indexes',\r\n      '2. Clicar em \"Create Index\"',\r\n      `3. Definir Collection ID: ${collection}`,\r\n      '4. Configurar campos nesta ORDEM EXATA:',\r\n      ...fields.map(\r\n        (field, index: number) =>\r\n          `   ${index + 1}. Campo: ${field.field}, Order: ${\r\n            field.order\r\n          }, Array: No`\r\n      ),\r\n      '5. Definir Query scopes: Collection',\r\n      '6. Clicar em \"Create\" e aguardar conclusão',\r\n    ];\r\n\r\n    instructions.notes = [\r\n      '⚠️ A ordem dos campos é CRÍTICA - deve corresponder exatamente à ordem da query',\r\n      '⚠️ As cláusulas WHERE devem vir ANTES do campo ORDER BY',\r\n      '⚠️ Este índice só funcionará para queries com esta combinação EXATA de campos',\r\n      '⚠️ A criação do índice pode levar vários minutos',\r\n    ];\r\n\r\n    return instructions;\r\n  }\r\n\r\n  /**\r\n   * Gera um link de índice baseado na estrutura da query\r\n   */\r\n  private generateIndexLink(\r\n    collection: string,\r\n    arrange: Arrange,\r\n    conditions: Condition[] | undefined = undefined\r\n  ): string | null {\r\n    try {\r\n      const indexFields: string[] = [];\r\n\r\n      if (conditions && conditions.length > 0) {\r\n        conditions.forEach((condition: Condition) => {\r\n          if (condition.firestoreProperty) {\r\n            indexFields.push(condition.firestoreProperty);\r\n          }\r\n        });\r\n      }\r\n\r\n      if (arrange.filters && arrange.filters.length > 0) {\r\n        arrange.filters.forEach((filter: Arrange['filters'][0]) => {\r\n          if (filter.filter?.property) {\r\n            indexFields.push(filter.filter.property);\r\n          }\r\n        });\r\n      }\r\n\r\n      if (arrange.sortBy?.field) {\r\n        indexFields.push(arrange.sortBy.field);\r\n      }\r\n\r\n      if (indexFields.length > 1) {\r\n        // Obter o projectId dinamicamente do Firebase\r\n        const options = this.ngFire?.firestore?.app?.options as\r\n          | Record<string, unknown>\r\n          | undefined;\r\n        const projectId = options?.['projectId'] as string | undefined;\r\n\r\n        if (!projectId) {\r\n          console.warn('Não foi possível obter o projectId do Firebase');\r\n          return null;\r\n        }\r\n\r\n        const baseUrl = `https://console.firebase.google.com/project/${projectId}/firestore/indexes`;\r\n        const queryParams = new URLSearchParams({\r\n          create_composite: `collection=${collection}&fields=${indexFields.join(\r\n            ','\r\n          )}`,\r\n        });\r\n\r\n        const finalLink = `${baseUrl}?${queryParams.toString()}`;\r\n        return finalLink;\r\n      }\r\n\r\n      return null;\r\n    } catch (error) {\r\n      console.warn('Falha ao gerar link de índice:', error);\r\n      return null;\r\n    }\r\n  }\r\n\r\n  private async trackMissingIndex(\r\n    error: unknown,\r\n    collection: string,\r\n    arrange: Arrange,\r\n    conditions: Condition[] | undefined = undefined\r\n  ): Promise<void> {\r\n    try {\r\n      const indexLink = this.extractIndexLink(error);\r\n      if (!indexLink) return;\r\n\r\n      const linkHash = btoa(indexLink)\r\n        .replace(/[^a-zA-Z0-9]/g, '')\r\n        .substring(0, 20);\r\n      const docId = `${collection}_${linkHash}`;\r\n\r\n      const indexInstructions = this.generateIndexInstructions(\r\n        collection,\r\n        arrange,\r\n        conditions\r\n      );\r\n\r\n      const trackingData: Record<string, unknown> = {\r\n        collection,\r\n        indexLink,\r\n        indexInstructions,\r\n        arrange: {\r\n          sortBy: arrange.sortBy,\r\n          filters:\r\n            arrange.filters?.map((f) => ({\r\n              arrange: f.arrange,\r\n              property: f.filter?.property || null,\r\n              dateField:\r\n                f.arrange === 'filterByDate' ? arrange.sortBy?.field : null,\r\n            })) || [],\r\n        },\r\n        conditions:\r\n          conditions?.map((c: Condition) => ({\r\n            property: c.firestoreProperty,\r\n            operator: c.operator,\r\n          })) || [],\r\n        errorMessage:\r\n          error &&\r\n          typeof error === 'object' &&\r\n          'message' in error &&\r\n          typeof (error as ErrorWithMessage).message === 'string'\r\n            ? (error as ErrorWithMessage).message\r\n            : String(error),\r\n        updatedAt: firebase.firestore.FieldValue.serverTimestamp(),\r\n      };\r\n\r\n      const docRef = this.ngFire.collection('missingIndexes').doc(docId);\r\n      const doc = await docRef.get().toPromise();\r\n\r\n      const errorMessage =\r\n        error &&\r\n        typeof error === 'object' &&\r\n        'message' in error &&\r\n        typeof (error as ErrorWithMessage).message === 'string'\r\n          ? (error as ErrorWithMessage).message\r\n          : String(error);\r\n\r\n      if (doc && doc.exists) {\r\n        await docRef.update({\r\n          count: firebase.firestore.FieldValue.increment(1),\r\n          updatedAt: firebase.firestore.FieldValue.serverTimestamp(),\r\n          lastError: errorMessage,\r\n        });\r\n      } else {\r\n        await docRef.set({\r\n          ...trackingData,\r\n          count: 1,\r\n          createdAt: firebase.firestore.FieldValue.serverTimestamp(),\r\n        });\r\n      }\r\n    } catch (trackingError) {\r\n      console.warn('Falha ao rastrear índice ausente:', trackingError);\r\n    }\r\n  }\r\n}\r\n"]}