@ascentgl/ads-ui 21.76.1 → 21.78.0

package/fesm2022/ascentgl-ads-ui.mjs

@@ -7720,10 +7720,9 @@ class AdsTableComponent {
                 // For columns without explicit config (like supplier, destination),
                 // always apply the filter based on selectedValues
                 const cellValue = node.data[field];
-                // For objects, use JSON.stringify to match the format used in filterOptions
-                const cellValueStr = cellValue != null
-                    ? (typeof cellValue === 'object' ? JSON.stringify(cellValue) : String(cellValue))
-                    : '';
+                // Use formatter if available to produce a consistent key for comparison
+                const formatter = this.getFilterValueFormatterForField(field);
+                const cellValueStr = this.serializeCellValueForFilter(cellValue, formatter);
                 if (!selectedValues.includes(cellValueStr)) {
                     return false;
                 }
@@ -8096,25 +8095,50 @@ class AdsTableComponent {
         }
     }
     // ============ Custom Sort/Filter Menu Methods ============
+    /** @ignore - Get the filterValueFormatter for a given column field */
+    getFilterValueFormatterForField(field) {
+        const config = this.columnSortFilterConfigs.find(c => c.field === field);
+        return config?.filterValueFormatter;
+    }
+    /**
+     * @ignore - Serialize a cell value for filter key purposes.
+     * When a filterValueFormatter exists, uses the formatted value as the key
+     * so that values with the same display (e.g. same date, different time) are deduplicated.
+     */
+    serializeCellValueForFilter(value, formatter) {
+        if (formatter) {
+            return formatter(value);
+        }
+        return this.serializeCellValue(value);
+    }
     /** @ignore - Extract unique RAW values from a column in rowData (with caching) */
     getUniqueColumnValues(field) {
         if (!this.rowData || this.rowData.length === 0) {
             return [];
         }
-        // Check cache first
-        const cacheKey = `${field}_v${this.dataVersion}`;
-        const cached = this.uniqueColumnValuesCache.get(cacheKey);
-        if (cached) {
-            return cached;
+        const formatter = this.getFilterValueFormatterForField(field);
+        // Don't cache results when a filterValueFormatter is configured,
+        // because the formatter output may change over time (e.g., timezone service
+        // becoming ready, user changing timezone). Caching could cause stale values
+        // that mismatch with doesExternalFilterPass comparisons.
+        if (!formatter) {
+            // Check cache first (only for fields without formatter)
+            const cacheKey = `${field}_v${this.dataVersion}`;
+            const cached = this.uniqueColumnValuesCache.get(cacheKey);
+            if (cached) {
+                return cached;
+            }
         }
         // Use a Map to dedupe by serialized key while preserving raw values
         const byKey = new Map();
         this.rowData.forEach(row => {
             const value = row[field];
             if (value !== null && value !== undefined) {
-                const key = this.serializeCellValue(value);
+                const key = this.serializeCellValueForFilter(value, formatter);
                 if (!byKey.has(key)) {
-                    byKey.set(key, value);
+                    // When a formatter exists, store the formatted string as the value
+                    // so downstream consumers (menu, filter matching) use a consistent key
+                    byKey.set(key, formatter ? key : value);
                 }
             }
         });
@@ -8122,8 +8146,11 @@ class AdsTableComponent {
         const result = Array.from(byKey.entries())
             .sort(([a], [b]) => a.localeCompare(b))
             .map(([, v]) => v);
-        // Cache the result
-        this.uniqueColumnValuesCache.set(cacheKey, result);
+        // Cache the result only for fields without formatter
+        if (!formatter) {
+            const cacheKey = `${field}_v${this.dataVersion}`;
+            this.uniqueColumnValuesCache.set(cacheKey, result);
+        }
         return result;
     }
     /**
@@ -8136,18 +8163,25 @@ class AdsTableComponent {
         if (!this.rowData || this.rowData.length === 0) {
             return [];
         }
-        // Check cache first
-        const cacheKey = `${field}_v${this.filterCacheVersion}`;
-        const cached = this.filteredColumnValuesCache.get(cacheKey);
-        if (cached) {
-            return cached;
+        const formatter = this.getFilterValueFormatterForField(field);
+        // Don't cache results when a filterValueFormatter is configured (same reason as getUniqueColumnValues)
+        if (!formatter) {
+            // Check cache first (only for fields without formatter)
+            const cacheKey = `${field}_v${this.filterCacheVersion}`;
+            const cached = this.filteredColumnValuesCache.get(cacheKey);
+            if (cached) {
+                return cached;
+            }
         }
         // Check if any filter is active (excluding the current field)
         const hasOtherActiveFilters = this.hasActiveFiltersExcluding(field);
         // If no other filters are active, return all unique values
         if (!hasOtherActiveFilters) {
             const values = this.getUniqueColumnValues(field);
-            this.filteredColumnValuesCache.set(cacheKey, values);
+            if (!formatter) {
+                const cacheKey = `${field}_v${this.filterCacheVersion}`;
+                this.filteredColumnValuesCache.set(cacheKey, values);
+            }
             return values;
         }
         // Use a Map to dedupe by serialized key while preserving raw values
@@ -8157,9 +8191,9 @@ class AdsTableComponent {
             if (this.doesRowPassFiltersExcluding(row, field)) {
                 const value = row[field];
                 if (value !== null && value !== undefined) {
-                    const key = this.serializeCellValue(value);
+                    const key = this.serializeCellValueForFilter(value, formatter);
                     if (!byKey.has(key)) {
-                        byKey.set(key, value);
+                        byKey.set(key, formatter ? key : value);
                     }
                 }
             }
@@ -8175,8 +8209,11 @@ class AdsTableComponent {
                 .sort(([a], [b]) => a.localeCompare(b))
                 .map(([, v]) => v);
         }
-        // Cache the result
-        this.filteredColumnValuesCache.set(cacheKey, result);
+        // Cache the result only for fields without formatter
+        if (!formatter) {
+            const cacheKey = `${field}_v${this.filterCacheVersion}`;
+            this.filteredColumnValuesCache.set(cacheKey, result);
+        }
         return result;
     }
     /** @ignore - Invalidate the filtered column values cache */
@@ -8223,10 +8260,9 @@ class AdsTableComponent {
                 return false;
             }
             const cellValue = row[field];
-            // For objects, use JSON.stringify to match the format used in filterOptions
-            const cellValueStr = cellValue != null
-                ? (typeof cellValue === 'object' ? JSON.stringify(cellValue) : String(cellValue))
-                : '';
+            // Use formatter if available to produce a consistent key for comparison
+            const formatter = this.getFilterValueFormatterForField(field);
+            const cellValueStr = this.serializeCellValueForFilter(cellValue, formatter);
             if (!selectedValues.includes(cellValueStr)) {
                 return false;
             }