@sankhyalabs/core 7.2.0 → 7.2.1-dev.2

package/src/dataunit/metadata/UnitMetadata.ts

@@ -23,6 +23,7 @@ export interface FieldDescriptor {
     label: string;
     dataType: DataType;
     userInterface?: UserInterface;
+    aggFunc?: any;
     defaultValue?: any;
     visible?: boolean;
     readOnly?: boolean;

package/src/utils/ColumnFilterManager.ts

@@ -3,6 +3,7 @@ import DataUnit from '../dataunit/DataUnit.js';
 import { Record } from '../dataunit/interfaces/dataUnit.js';
 import { FieldComparator } from '../dataunit/sorting/FieldComparator.js';
 import { LoadDataRequest } from '../dataunit/loading/LoadDataRequest.js';
+import { DataType } from '../dataunit/metadata/DataType.js';
 
 const COLUMN_FILTER_PATTERN = /FILTRO_COLUNA_(.+)/;
 
@@ -46,13 +47,26 @@ export class ColumnFilterManager {
     if (!columnFilter.params || !fieldDescriptor) return false;
 
     const fieldValue = record[columnFilter.columnName];
+    /**
+     * Casa datas pelo valor FORMATADO — a mesma granularidade que o funil exibe/agrupa
+     * (dia p/ data pura, minuto p/ DATETIME). Nem por dia nem por timestamp exato. KB-171175.
+     */
+    const isDate = fieldDescriptor.dataType === DataType.DATE;
 
     for (let param of columnFilter.params) {
       const paramValue = dataUnit.valueFromString(columnFilter.columnName, param.value);
-      if (FieldComparator.compareValues(fieldDescriptor, fieldValue, paramValue) === 0) {
+      let matches: boolean;
+      if (isDate) {
+        matches = (fieldValue == undefined || paramValue == undefined)
+          ? fieldValue == paramValue
+          : dataUnit.getFormattedValue(columnFilter.columnName, fieldValue)
+              === dataUnit.getFormattedValue(columnFilter.columnName, paramValue);
+      } else {
+        matches = FieldComparator.compareValues(fieldDescriptor, fieldValue, paramValue) === 0;
+      }
+      if (matches) {
         return true;
       }
-
     }
     return false;
   }

package/src/utils/MaskFormatter.ts

@@ -60,6 +60,7 @@ export class MaskFormatter {
         "cnpj": "ZZ.ZZZ.ZZZ/ZZZZ-##",
         "cpf": "###.###.###-##",
         "phone": "(##) ####-####",
+        "phone_mobile": "(##) #####-####",
         "cep": "##.###-###",
         "cor_rgb" : "'#AAAAAA"
     };

package/src/utils/OverflowWatcher/index.ts

@@ -9,236 +9,295 @@ export * from "./types/overflow-callback.js";
 export const OVERFLOWED_CLASS_NAME = 'overflowed';
 
 export default class OverflowWatcher {
-    private _onResize:OnOverflowCallBack;
-    private _resizeObserver:ResizeObserver;
-    private _lastContainerSize:number|undefined = undefined;
-    private _lastContainerInstance: HTMLElement | undefined = undefined;
-    private _scrollDirection = OverflowDirection.HORIZONTAL;
-    private _propSize:string;
-    private _hiddenItemsProps:Map<Element, SizeProps> = new Map();
-    private _notOverFlowPros:Map<string, SizeProps> = new Map();
-    private _deltaSize:number;
-    private _notOverFlow: string[] = [];
-
-    readonly DATA_ELEMENT_ID = 'data-element-id';
-
-    /**
-     * Cria uma instancia do OverflowWatcher
-     *
-     * @param element - Elemento HTML que o overflow será observado.
-     * @param callback - Função que sera chamada quando ocorrer overflow no elemento.
-     * @param overFlowDirection - Indica direção que o overflow será monitorado.
-     * @param deltaSize - Variação de tamanho que será considerada como overflow.
-     * @param debounce - Tempo até execução do callback em milissegundos.
-     * @param notOverFlow - Lista de ids ou data-element-ids dos elementos que não devem sofrer overFlow.
-     */
-    constructor({
-                    element,
-                    callback,
-                    overFlowDirection = OverflowDirection.HORIZONTAL,
-                    debounce = 200,
-                    deltaSize = 0,
-                    notOverFlow = []
-    }: OverFlowWatcherParams){
-        this._onResize = callback;
-        this._scrollDirection = overFlowDirection;
-        this._propSize = (OverflowDirection.HORIZONTAL === overFlowDirection) ? "width" : "height";
-        this._resizeObserver = new ResizeObserver(JSUtils.debounce((entries: ResizeObserverEntry[]) => this.handleResize(entries), debounce));
-        this._resizeObserver.observe(element);
-        this._deltaSize = deltaSize;
-        this._notOverFlow = notOverFlow;
+  private _onResize:OnOverflowCallBack;
+  private _resizeObserver:ResizeObserver;
+  private _lastContainerSize:number|undefined = undefined;
+  private _lastContainerInstance: HTMLElement | undefined = undefined;
+  private _scrollDirection = OverflowDirection.HORIZONTAL;
+  private _propSize:string;
+  private _hiddenItemsProps:Map<Element, SizeProps> = new Map();
+  private _notOverFlowPros:Map<string, SizeProps> = new Map();
+  private _deltaSize:number;
+  private _notOverFlow: string[] = [];
+
+  readonly DATA_ELEMENT_ID = 'data-element-id';
+
+  /**
+   * Cria uma instancia do OverflowWatcher
+   *
+   * @param element - Elemento HTML que o overflow será observado.
+   * @param callback - Função que sera chamada quando ocorrer overflow no elemento.
+   * @param overFlowDirection - Indica direção que o overflow será monitorado.
+   * @param deltaSize - Variação de tamanho que será considerada como overflow.
+   * @param debounce - Tempo até execução do callback em milissegundos.
+   * @param notOverFlow - Lista de ids ou data-element-ids dos elementos que não devem sofrer overFlow.
+   */
+  constructor({
+                element,
+                callback,
+                overFlowDirection = OverflowDirection.HORIZONTAL,
+                debounce = 200,
+                deltaSize = 0,
+                notOverFlow = []
+              }: OverFlowWatcherParams){
+    this._onResize = callback;
+    this._scrollDirection = overFlowDirection;
+    this._propSize = (OverflowDirection.HORIZONTAL === overFlowDirection) ? "width" : "height";
+    this._resizeObserver = new ResizeObserver(JSUtils.debounce((entries: ResizeObserverEntry[]) => this.handleResize(entries), debounce));
+    this._resizeObserver.observe(element);
+    this._deltaSize = deltaSize;
+    this._notOverFlow = notOverFlow;
+  }
+
+  public addNotOverFlowElement(elementId: string){
+    if(!this._notOverFlow.includes(elementId)){
+      this._notOverFlow.push(elementId);
     }
+  }
 
-    public addNotOverFlowElement(elementId: string){
-        if(!this._notOverFlow.includes(elementId)){
-            this._notOverFlow.push(elementId);
-        }
-    }
-
-    public destroy(){
-        this._resizeObserver.disconnect();
-    }
+  public destroy(){
+    this._resizeObserver.disconnect();
+  }
 
-    public forceUpdate(){
-        if(this._lastContainerSize && this._lastContainerInstance){
-            this.updateOverFlowedItems(this._lastContainerInstance, this._lastContainerSize);
-        }
+  public forceUpdate(){
+    if(this._lastContainerSize && this._lastContainerInstance){
+      this.updateOverFlowedItems(this._lastContainerInstance, this._lastContainerSize);
     }
+  }
 
-    private handleResize(entries: ResizeObserverEntry[]){
-        if(!entries || entries.length === 0) return;
+  private handleResize(entries: ResizeObserverEntry[]){
+    if(!entries || entries.length === 0) return;
 
-        const container = entries[0];
-        const containerSize:number = (container.contentRect as any)[this._propSize];
-        if(!containerSize) return;
+    const container = entries[0];
+    const containerSize:number = (container.contentRect as any)[this._propSize];
+    if(!containerSize) return;
 
-        if(this.hasChangedSize(containerSize)){
-            this.updateOverFlowedItems(container.target as HTMLElement, containerSize);
-        }
+    if(this.hasChangedSize(containerSize)){
+      this.updateOverFlowedItems(container.target as HTMLElement, containerSize);
     }
-
-    private updateOverFlowedItems(container: HTMLElement, containerSize: number){
-        const children:Element[] = Array.from(container.children);
-        this.registerNotOverflowProps(children);
-        this.proccessElements(containerSize, children);
-        this._lastContainerSize = containerSize;
-        this._lastContainerInstance = container;
+  }
+
+  private updateOverFlowedItems(container: HTMLElement, containerSize: number){
+    const children:Element[] = this.getProcessableElements(container);
+    this.registerNotOverflowProps(children);
+    this.proccessElements(containerSize, children);
+    this._lastContainerSize = containerSize;
+    this._lastContainerInstance = container;
+  }
+
+  private getProcessableElements(container: HTMLElement): Element[] {
+    const directChildren = Array.from(container.children);
+    const processableElements: Element[] = [];
+
+    for (const child of directChildren) {
+      if (child.classList.contains('taskbar-group')) {
+        processableElements.push(...Array.from(child.children));
+      } else {
+        processableElements.push(child);
+      }
     }
 
-    private registerNotOverflowProps(children: Element[]) {
-        children.forEach(childElement => {
-            const id = childElement.id || this.getDataElementId(childElement);
-            if (this.canNotRegisterNotOverFlow(id)) return;
-            this._notOverFlowPros.set(id, this.getElementSizeProps(childElement));
-        });
-    }
+    return processableElements;
+  }
 
-    private canNotRegisterNotOverFlow(id: string) {
-        return !id || !this._notOverFlow.includes(id);
-    }
+  private registerNotOverflowProps(children: Element[]) {
+    children.forEach(childElement => {
+      const id = childElement.id || this.getDataElementId(childElement);
+      if (this.canNotRegisterNotOverFlow(id)) return;
+      this._notOverFlowPros.set(id, this.getElementSizeProps(childElement));
+    });
+  }
 
-    private hasChangedSize(elementSize: number):boolean{
-        if(!this._lastContainerSize) return true;
-        const variation = elementSize - this._lastContainerSize;
+  private canNotRegisterNotOverFlow(id: string) {
+    return !id || !this._notOverFlow.includes(id);
+  }
 
-        if(variation < 0){
-            const absoluteVariation = Math.abs(variation);
-            return (absoluteVariation > this._deltaSize);
-        }
+  private hasChangedSize(elementSize: number):boolean{
+    if(!this._lastContainerSize) return true;
+    const variation = elementSize - this._lastContainerSize;
 
-        return variation > 0;
+    if(variation < 0){
+      const absoluteVariation = Math.abs(variation);
+      return (absoluteVariation > this._deltaSize);
     }
 
-    private proccessElements(elementSize:number, children:Element[]){
-        if(children.length === 0) return;
+    return variation > 0;
+  }
 
-        const childrenSize = this.calcChildrenSize(children);
-        let diff = Number((elementSize - childrenSize).toFixed(4));
+  private proccessElements(elementSize:number, children:Element[]){
+    if(children.length === 0) return;
 
-        if(diff > 0){
-            this.clearOverFlow();
-            return;
-        }
+    const childrenSize = this.calcChildrenSize(children);
+    let diff = Number((elementSize - childrenSize).toFixed(4));
 
-        this.proccessElementsOverFlow(children, elementSize);
+    if(diff > 0){
+      this.clearOverFlow();
+      return;
     }
 
-    private clearOverFlow(){
-        this._hiddenItemsProps = new Map();
-        this._onResize([]);
-    }
-
-    private proccessElementsOverFlow(allElements:Element[], avaliableSize:number){
-        const elementsThatFit: Element[] = [];
-        const avaliableSizeConsideringDelta = (avaliableSize - this._deltaSize);
-
-        let sumElementsSize = 0;
+    this.proccessElementsOverFlow(children, elementSize);
+  }
 
-        for (const element of allElements) {
-            sumElementsSize += this.calcElementSize(element);
-            if(this.exceedsAvaliableSize(sumElementsSize, elementsThatFit, avaliableSizeConsideringDelta)) break;
-            elementsThatFit.push(element);
-        }
+  private clearOverFlow(){
+    this._hiddenItemsProps = new Map();
+    this._onResize([]);
+  }
 
-        const overFlowedElements = allElements.filter(element => this.isElementOverFlowing(elementsThatFit, element));
+  private proccessElementsOverFlow(allElements:Element[], avaliableSize:number){
+    const elementsThatFit: Element[] = [];
+    const avaliableSizeConsideringDelta = (avaliableSize - this._deltaSize);
 
-        overFlowedElements.forEach(overFlowed => {
-            if(!this._hiddenItemsProps.has(overFlowed)){
-                this.registerElementSize(overFlowed);
-            }
-        });
+    let sumElementsSize = 0;
 
-        this._onResize(overFlowedElements);
+    for (const element of allElements) {
+      sumElementsSize += this.calcElementSize(element);
+      if(this.exceedsAvaliableSize(sumElementsSize, elementsThatFit, avaliableSizeConsideringDelta)) break;
+      elementsThatFit.push(element);
     }
 
-    private isElementOverFlowing(elementsThatFit: Element[], element: Element) {
-        return !elementsThatFit.includes(element) && this.canOverFlowElement(element);
+    const overFlowedElements = allElements.filter(element => this.isElementOverFlowing(elementsThatFit, element));
+
+    overFlowedElements.forEach(overFlowed => {
+      if(!this._hiddenItemsProps.has(overFlowed)){
+        this.registerElementSize(overFlowed);
+      }
+    });
+
+    this._onResize(overFlowedElements);
+  }
+
+  private isElementOverFlowing(elementsThatFit: Element[], element: Element) {
+    return !elementsThatFit.includes(element) && this.canOverFlowElement(element);
+  }
+
+  private canOverFlowElement(element: Element) {
+    return !this._notOverFlow.includes(element.id)
+      && !this._notOverFlow.includes(this.getDataElementId(element));
+  }
+
+  private getDataElementId(element: Element): string {
+    return (element as HTMLElement).getAttribute('data-element-id') ?? "";
+  }
+
+  private exceedsAvaliableSize(sumElementsSize: number, elements: Element[], avaliableSize: number): boolean {
+    if(!this._notOverFlow.length) return sumElementsSize > avaliableSize
+
+    const elementIdsToCalculate = this.canNotOverFlowNotIncludedIds(elements);
+    if(!elementIdsToCalculate.length) return sumElementsSize > avaliableSize
+
+    const variation = this.calculateVariation(elementIdsToCalculate);
+    const occupiedSize = sumElementsSize + variation;
+    return occupiedSize > avaliableSize;
+  }
+
+  private calculateVariation(elementIdsToCalculate: string[]) {
+    let variation = 0
+    elementIdsToCalculate.forEach(id => {
+      const sizeProps = this._notOverFlowPros.get(id);
+      variation += sizeProps?.size ?? 0;
+      variation += sizeProps?.margin ?? 0;
+    });
+    return variation;
+  }
+
+  private canNotOverFlowNotIncludedIds(elements: Element[]): string[]{
+    const elementsIdList = elements.map(el =>  el.id || this.getDataElementId(el)).filter(id => !!id);
+    return this._notOverFlow.filter(id => !elementsIdList.includes(id));
+  }
+
+  private registerElementSize(element: Element) {
+    const sizeProps = this.getElementSizeProps(element);
+    this._hiddenItemsProps.set(element, sizeProps);
+  }
+
+  private getElementSizeProps(element: Element) {
+    const sizeProps: SizeProps = {
+      size: (element.getBoundingClientRect() as any)[this._propSize],
+      margin: calcMarginSize(element, this._scrollDirection),
+    };
+    return sizeProps;
+  }
+
+  private calcChildrenSize(children:Element[]):number{
+    let sumChildren = 0;
+    sumChildren += this._deltaSize;
+
+    // Agrupa os elementos por container pai
+    const elementsByContainer = this.groupElementsByContainer(children);
+
+    // Calcula o tamanho considerando os containers
+    for (const [container, elements] of elementsByContainer) {
+      if (container && container.classList.contains('taskbar-group')) {
+        // Se é um grupo da taskbar, adiciona o tamanho do container mais os elementos
+        sumChildren += this.calcContainerSize(container);
+        elements.forEach(el => sumChildren += this.calcElementSize(el));
+      } else {
+        // Se não é um grupo, adiciona apenas o tamanho dos elementos
+        elements.forEach(el => sumChildren += this.calcElementSize(el));
+      }
     }
 
-    private canOverFlowElement(element: Element) {
-        return !this._notOverFlow.includes(element.id)
-            && !this._notOverFlow.includes(this.getDataElementId(element));
-    }
-
-    private getDataElementId(element: Element): string {
-        return (element as HTMLElement).getAttribute('data-element-id') ?? "";
-    }
+    return sumChildren;
+  }
 
-    private exceedsAvaliableSize(sumElementsSize: number, elements: Element[], avaliableSize: number): boolean {
-        if(!this._notOverFlow.length) return sumElementsSize > avaliableSize
+  private groupElementsByContainer(elements: Element[]): Map<Element | null, Element[]> {
+    const grouped = new Map<Element | null, Element[]>();
 
-        const elementIdsToCalculate = this.canNotOverFlowNotIncludedIds(elements);
-        if(!elementIdsToCalculate.length) return sumElementsSize > avaliableSize
-
-        const variation = this.calculateVariation(elementIdsToCalculate);
-        const occupiedSize = sumElementsSize + variation;
-        return occupiedSize > avaliableSize;
-    }
-
-    private calculateVariation(elementIdsToCalculate: string[]) {
-        let variation = 0
-        elementIdsToCalculate.forEach(id => {
-            const sizeProps = this._notOverFlowPros.get(id);
-            variation += sizeProps?.size ?? 0;
-            variation += sizeProps?.margin ?? 0;
-        });
-        return variation;
+    for (const element of elements) {
+      const container = element.parentElement;
+      if (!grouped.has(container)) {
+        grouped.set(container, []);
+      }
+      grouped.get(container)!.push(element);
     }
 
-    private canNotOverFlowNotIncludedIds(elements: Element[]): string[]{
-        const elementsIdList = elements.map(el =>  el.id || this.getDataElementId(el)).filter(id => !!id);
-        return this._notOverFlow.filter(id => !elementsIdList.includes(id));
+    return grouped;
+  }
+
+  private calcContainerSize(container: Element): number {
+    const rect = container.getBoundingClientRect();
+    const elementSize = rect[this._propSize as keyof DOMRect] as number;
+    const marginSize = calcMarginSize(container, this._scrollDirection);
+
+    // Subtrai o tamanho dos filhos para não contar em duplicidade
+    let childrenSize = 0;
+    Array.from(container.children).forEach(child => {
+      const childRect = child.getBoundingClientRect();
+      childrenSize += childRect[this._propSize as keyof DOMRect] as number;
+    });
+
+    return Math.max(0, elementSize - childrenSize) + marginSize;
+  }
+
+  private calcElementSize(el: Element) {
+    let size = 0
+    if (this.isOverFlowed(el)) {
+      const sizeProps = this._hiddenItemsProps.get(el);
+      size += sizeProps?.size ?? 0;
+      size += sizeProps?.margin ?? 0;
+      return size;
     }
 
-    private registerElementSize(element: Element) {
-        const sizeProps = this.getElementSizeProps(element);
-        this._hiddenItemsProps.set(element, sizeProps);
-    }
-
-    private getElementSizeProps(element: Element) {
-        const sizeProps: SizeProps = {
-            size: (element.getBoundingClientRect() as any)[this._propSize],
-            margin: calcMarginSize(element, this._scrollDirection),
-        };
-        return sizeProps;
-    }
+    size += (el.getBoundingClientRect() as any)[this._propSize];
+    size += calcMarginSize(el, this._scrollDirection);
+    return size;
+  }
 
-    private calcChildrenSize(children:Element[]):number{
-        let sumChildren = 0;
-        sumChildren += this._deltaSize;
-        Array.from(children).forEach(el => sumChildren += this.calcElementSize(el));
-        return sumChildren;
-    }
-
-    private calcElementSize(el: Element) {
-        let size = 0
-        if (this.isOverFlowed(el)) {
-            const sizeProps = this._hiddenItemsProps.get(el);
-            size += sizeProps?.size ?? 0;
-            size += sizeProps?.margin ?? 0;
-            return size;
-        }
-
-        size += (el.getBoundingClientRect() as any)[this._propSize];
-        size += calcMarginSize(el, this._scrollDirection);
-        return size;
-    }
-
-    private isOverFlowed(el: Element) {
-        return el.classList.contains(OVERFLOWED_CLASS_NAME);
-    }
+  private isOverFlowed(el: Element) {
+    return el.classList.contains(OVERFLOWED_CLASS_NAME);
+  }
 }
 
 export interface OverFlowWatcherParams {
-    element:HTMLElement,
-    callback:OnOverflowCallBack,
-    overFlowDirection?:OverflowDirection,
-    deltaSize?:number,
-    debounce?: number,
-    notOverFlow?: string[]
+  element:HTMLElement,
+  callback:OnOverflowCallBack,
+  overFlowDirection?:OverflowDirection,
+  deltaSize?:number,
+  debounce?: number,
+  notOverFlow?: string[]
 }
 
 interface SizeProps {
-    size: number,
-    margin: number,
+  size: number,
+  margin: number,
 }

package/test/util/ColumnFilterManager.spec.ts

@@ -1,5 +1,6 @@
 import { ColumnFilterManager, IColumnFilter } from '../../src/utils/ColumnFilterManager.js';
-import { FieldDescriptor, Filter, FilterParam } from '../../src/dataunit/metadata/UnitMetadata.js';
+import { FieldDescriptor, Filter, FilterParam, UserInterface } from '../../src/dataunit/metadata/UnitMetadata.js';
+import { DataType } from '../../src/dataunit/metadata/DataType.js';
 import DataUnit from '../../src/dataunit/DataUnit';
 import { Record } from '../../src/dataunit/interfaces/dataUnit';
 
@@ -82,6 +83,63 @@ describe('ColumnFilterManager', () => {
       const record: Record = { field1: 'test' } as unknown as Record;
       expect(filterFunction!(record)).toBe(false);
     });
+
+    describe('granularidade de data (KB-171175)', () => {
+      // Formata na granularidade EXIBIDA do campo, como o funil faz via getFormattedValue:
+      // DATE -> dia; DATETIME -> minuto. Usa toISOString (sempre UTC) p/ ser estável ao fuso do runner.
+      const formatterFor = (field: FieldDescriptor) => (_col: string, value: any) => {
+        if (value == undefined) return null;
+        const iso = new Date(value).toISOString();
+        return field.userInterface === UserInterface.DATE ? iso.slice(0, 10) : iso.slice(0, 16);
+      };
+
+      const buildDataUnit = (field: FieldDescriptor): DataUnit => ({
+        getField: jest.fn().mockReturnValue(field),
+        // O funil envia a data selecionada; devolvemos como Date, como faz o DataUnit real.
+        valueFromString: jest.fn().mockImplementation((_col: string, value: any) => new Date(value)),
+        getFormattedValue: jest.fn().mockImplementation(formatterFor(field)),
+      } as unknown as DataUnit);
+
+      const buildFilter = (...values: string[]): IColumnFilter[] => ([{
+        columnName: 'dt',
+        name: 'FILTRO_COLUNA_dt',
+        expression: '',
+        params: values.map(value => ({ value } as FilterParam)),
+      }]);
+
+      it('data PURA (DATE): casa por dia (granularidade exibida) — alinhado ao onlydate da exportação', () => {
+        const dataUnit = buildDataUnit({ name: 'dt', dataType: DataType.DATE, userInterface: UserInterface.DATE } as FieldDescriptor);
+        // Seleção do funil no nível de dia (03/08).
+        const filterFunction = ColumnFilterManager.getFilterFunction(dataUnit, buildFilter('2025-08-03T00:00:00Z'));
+
+        // Registros do mesmo dia, com horas diferentes, devem casar.
+        expect(filterFunction!({ dt: new Date('2025-08-03T09:18:00Z') } as unknown as Record)).toBe(true);
+        expect(filterFunction!({ dt: new Date('2025-08-03T09:22:00Z') } as unknown as Record)).toBe(true);
+        // Dia diferente não casa.
+        expect(filterFunction!({ dt: new Date('2025-08-04T09:18:00Z') } as unknown as Record)).toBe(false);
+      });
+
+      it('data+hora (DATETIME): casa pelo minuto exibido — distingue 09:18 de 09:22', () => {
+        const dataUnit = buildDataUnit({ name: 'dt', dataType: DataType.DATE, userInterface: UserInterface.DATETIME } as FieldDescriptor);
+        // Funil com apenas 09:22 marcado; o param carrega o timestamp representativo (09:22:39).
+        const filterFunction = ColumnFilterManager.getFilterFunction(dataUnit, buildFilter('2025-08-03T09:22:39Z'));
+
+        expect(filterFunction!({ dt: new Date('2025-08-03T09:22:00Z') } as unknown as Record)).toBe(true);
+        // O título das 09:18 deve sair da grade.
+        expect(filterFunction!({ dt: new Date('2025-08-03T09:18:49Z') } as unknown as Record)).toBe(false);
+      });
+
+      it('data+hora (DATETIME): mantém registros IRMÃOS do mesmo minuto com segundos diferentes (regressão KB-171175)', () => {
+        const dataUnit = buildDataUnit({ name: 'dt', dataType: DataType.DATE, userInterface: UserInterface.DATETIME } as FieldDescriptor);
+        // A opção "09:22" no funil = 1 param representativo (09:22:39), mas há irmãos :51/:55.
+        const filterFunction = ColumnFilterManager.getFilterFunction(dataUnit, buildFilter('2025-08-03T09:22:39Z'));
+
+        expect(filterFunction!({ dt: new Date('2025-08-03T09:22:39Z') } as unknown as Record)).toBe(true);
+        // Casamento exato descartaria estes; por minuto exibido eles PERMANECEM.
+        expect(filterFunction!({ dt: new Date('2025-08-03T09:22:51Z') } as unknown as Record)).toBe(true);
+        expect(filterFunction!({ dt: new Date('2025-08-03T09:22:55Z') } as unknown as Record)).toBe(true);
+      });
+    });
   });