laif-ds 1.0.2-app-data-grid.79 → 1.0.2-app-data-grid.80

package/dist/CHANGELOG.md

@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### 🚀 Added
 
+- **AppDataGrid**: **i filtri di colonna ora filtrano anche in CLIENT-MODE.** Fino a oggi i badge della Riga Zero raggiungevano solo il ramo server: `state.query.filters` diventava `computedFilter` nel payload emesso, ma **`columnFilters` non veniva mai passato a `useReactTable`** (`engine/use-grid-engine.ts`). In client-mode l'effetto era un comando **BUGIARDO**, che è peggio di un comando morto: scrivendo in una cella la riga restava a schermo, e intanto la cella dichiarava `data-grid-filter-cell-applied="true"` e l'intestazione portava `data-grid-header-filtered` — un test E2E che aspettasse quegli attributi **sarebbe passato su un filtro che non filtra**. Misurato sull'app viva il 2026-09-22 (scheda Ruoli di un utente: valore inesistente, riga che resta; controesempio: la searchbar, che passa dalla stessa porta come `globalFilter`, filtrava 1 riga → 0). ⚠️ **NON È UNA REGRESSIONE**: `git log -S "columnFilters"` restituisce un solo commit, quello di nascita della corsia — il cablaggio non è mai esistito. ⚠️ **E NON CREDERE A `app-data-grid-emitter.stories.tsx`**, che afferma di aver misurato il filtro client battendo in una cella: è falso per costruzione, e la sua stessa play digita nella searchbar. ⚠️ **QUANDO I FILTRI SONO SOLLEVATI (prop `filters`) LA GRIGLIA NON FILTRA IN LOCALE**, ed è una condizione, non una svista: chi solleva lo stato possiede anche il filtraggio, e senza quel gate un call-site esistente avrebbe subito un **doppio filtraggio** — `app-data-grid-filters-lifted.stories.tsx` monta esattamente quella configurazione ed è rimasta verde **senza essere ri-fixturata**, che è la prova che la condizione è quella giusta. ⚠️ **SI FILTRA SULLA STESSA POPOLAZIONE CHE IL SERVER RICEVE** (`usableBadges`): filtrare su una popolazione diversa è il modo in cui la stessa griglia filtra in due modi secondo la modalità. ⚠️ **LA PARITÀ CON I DICIOTTO BACKEND NON È SORVEGLIATA DA NESSUN GATE** — `check-datatable-grid-parity` confronta il vocabolario degli operatori, non la loro semantica — quindi le sette divergenze note (logica a tre valori sui `NULL`, metacaratteri di `LIKE` che il backend non escapa, case folding della collation, `eq` su testo, float64 contro `NUMERIC`, fuso e strettezza delle date, `array_overlap`) **sono scritte nel TSDoc di `grid-filter-client.ts`**, non in un documento di analisi: una funzione che promette una parità che non ha, senza dirlo nel file, è lo stesso difetto che questa corsia tratta come tale altrove. Due di quelle classi, peraltro, **sono già spedite oggi** dalla searchbar client-vs-server: questa funzione allarga un rischio accettato, non ne apre uno nuovo. Dieci scene nuove in `app-data-grid-filtro-client.stories.tsx`.
 - **AppDataGrid**: Nuovo slot **`toolbar.resetFilters`** (`GridToolbarResetSlot` = `GridToolbarSlot` + `onReset?: () => void`) e nuova chiave i18n **`filters.restoreDefaults`** (inglese `"Restore defaults"`, italiano `"Ripristina i predefiniti"` in `stories/app-data-grid-i18n-it.ts`). La griglia rende un `<button data-grid-toolbar-reset-filters>` con l'icona `RotateCcw` e la veste condivisa `gridToolbarTriggerClass`, **subito dopo la ricerca e prima del grilletto «Filtri»** quando quest'ultimo c'è. ⚠️ **LA VISIBILITÀ È DEL CONSUMER, E NON È UNA COMODITÀ: È L'UNICA FORMA POSSIBILE.** La griglia non può calcolare «i filtri correnti differiscono dai default della pagina», perché i default non le arrivano mai — `initialState` è un SEME letto una volta (il `useMemo` con dipendenze `[]` in `engine/use-grid-engine.ts`, non tenuto in nessun ref e mai confrontato con niente) e `preset` porta la vista **ripristinata dell'utente**, non i default. Quindi la risposta è la **presenza di `onReset`**: senza `onReset` e senza `render` il nodo non si rende, esattamente come per `filters` e `actions`. ⚠️ **E LA GRIGLIA NON AGGIUNGE NESSUN GATE SUL CONTEGGIO DEI FILTRI**, che sarebbe la scorciatoia ovvia e sarebbe **sbagliata in un caso reale**: `gridActiveFilterCount(…) > 0` nasconderebbe il bottone quando l'utente ha **tolto** un filtro dichiarato dalla pagina — cioè proprio quando il ripristino ha lavoro da fare. ⚠️ **AMBITO DICHIARATO: FILTRI E RICERCA.** Ordinamento, taglia di pagina, larghezze, ordine e visibilità delle colonne devono **sopravvivere**, e siccome `query/preset` e `view/preset` **sostituiscono in blocco**, chi implementa `onReset` deve costruire un preset che porta i **default** per `filters`/`search` e i valori **correnti** per tutto il resto — un preset parziale non esiste. Il ritorno a `pagination.pageIndex = 0` è inevitabile e corretto: è ciò che fa qualunque cambio di filtro. ⚠️ **NON SOSTITUISCE «Ripristina vista predefinita»** nel menu azioni, che è la via d'uscita TOTALE da una vista salvata illeggibile: i due comandi coesistono e hanno ambiti diversi. ⚠️ **`render` SI RENDE COMUNQUE**: su quel ramo la condizione «differisce dai default» è per intero del consumer — la presenza di `onReset` governa il SOLO nodo che la griglia disegna. ⚠️ **IL FUOCO È GESTITO, E MISURATO.** Il bottone rimuove la condizione della propria esistenza: premuto, il consumer smette di passare `onReset` e il nodo si smonta. Tenerlo montato e `disabled` sarebbe il comando morto che questa corsia vieta, quindi al clic il fuoco si sposta sul **campo di ricerca** — l'altro comando che restringe i dati, il vicino sinistro, e l'unico bersaglio reso SEMPRE. **Non** è il grilletto «Filtri»: quello esiste solo se lo slot `filters` è dichiarato, e nella configurazione più diffusa (`filterMode: "row"`) non c'è affatto — era la ragione per cui la v1 aveva dichiarato il limite come inevitabile, e la ragione era sbagliata perché il bersaglio c'era. La play `IlRipristinoChiedeENonAgisce` **legge `document.activeElement` dopo il click** e pretende il campo di ricerca. Chi passa `render` gestisce il fuoco del proprio nodo da sé. ⚠️ **NON SI RIUSA `i18n.reset`**: quella stringa nomina il bottone di `GridFilterChips` che **svuota** i filtri applicati, questa nomina il gesto che li riporta a ciò che la pagina ha **dichiarato** — con default non vuoti i due esiti divergono, e in italiano «Azzera» e «Ripristina i predefiniti» non sono la stessa frase. ⚠️ **Il cambiamento è additivo e retrocompatibile**: due chiavi opzionali nuove, nessun consumer esistente compila diversamente e nessun nodo nuovo appare senza che qualcuno lo dichiari. L'unico `tsc` che diventa rosso è interno al repo (`gridI18nIt` è tipato `typeof defaultGridI18n` e il suo `filters` è un literal fresco), ed è il meccanismo voluto: la chiave non si spedisce non tradotta. ⚠️ **`GridToolbarResetSlot` NON è esportato dal barrel**, come i fratelli `GridToolbarSlot` e `GridToolbarDisclosureSlot`: `GridToolbarSlots` — che è esportato — basta per annotare, e nessun nome nuovo entra in `scripts/codemod/rename-map.json`. **Cinque story nuove** in `AppDataGrid/Guscio (C3)`, di cui due sulla POSIZIONE e **una sulla configurazione del consumer reale** (`filterMode="row"` **senza** slot `filters`, dove il grilletto «Filtri» non esiste affatto e l'ordine misurato è ricerca → ripristino → «Mostra la riga filtri»): senza quella, l'ordine sarebbe stato misurato solo rispetto a un nodo che il consumer non rende mai
 
 - **AppDataGrid**: Nuova story `AppDataGrid/Completa → ScenaDipinta` — le **cinque personalizzazioni del chiamante accese nello stesso posto**, che il repo esponeva già una per una e non mostrava mai insieme: **header in HTML custom** (le due intestazioni di gruppo e quella foglia di «Stato», via `header: ReactNode` + `headerLabel`), **celle in HTML custom** (`cell` — avatar con le iniziali derivate dalla ragione sociale, e la barra di avanzamento), **celle colorate** (`cellClassName` a funzione, una tinta per ciascuno dei quattro stati), **righe colorate** (`rowClassName` a funzione, sul settore) e **colonne colorate** (`headerClassName` + `cellClassName` statica sulle due superfici di «Totale»). **Nessuna prop nuova**: sono cinque canali che il contratto ha già, e la story è una dimostrazione, non un allargamento di superficie. ⚠️ **UNA COLONNA PER DIMOSTRAZIONE, e non è pignoleria**: tinta di colonna e tinta per valore sulla stessa colonna sarebbero due `bg-*` nello stesso `cn()` e `tailwind-merge` ne terrebbe **una**, quindi la scena mostrerebbe quattro cose dichiarandone cinque e nessuna play potrebbe dire quale ha vinto — da qui la mappa, che è anche l'ordine delle **sei** colonne: `Commessa` (110) in chiaro con `rowHeader`, `Cliente` (170) cella custom, `Referente` (130) in chiaro, `Stato` (150) header custom **e** celle colorate, `Avanzamento` (150) cella custom, `Totale` (120) colonna colorata. ⚠️ **Header custom e tinta per valore CONVIVONO sulla stessa colonna** e la regola non lo vieta: quella riguarda due `bg-*` nello stesso `cn()`, non un `<th>` e dei `<td>` — sono due elementi, due prop, e due asserzioni separate. ⚠️ **`Referente` non è riempitivo**: è l'unica colonna senza tinta propria, cioè l'**unico** posto da cui si vede il fondo della **riga** — ed è per questo che la play misura lì il colore risolto. ⚠️ **SEI COLONNE PER 830px, E IL NUMERO È MISURATO**: con barra laterale e pannello addon aperti — come la story si apre — il viewport della griglia misura **850px** di `clientWidth`. La prima stesura aveva sette colonne per **1120px** dichiarati, onorati esatti dal `<colgroup>`, e proprio per questo `Totale` e `Consegna` cadevano **fuori**: la dimostrazione della colonna colorata si vedeva solo scorrendo, e una vetrina che chiede di scorrere per vedere una delle cinque cose che dichiara non le sta mostrando. Da qui la somma sotto la misura e `Consegna` — la seconda linea di base, la meno portante — via, verificato in Chrome: nessun contenitore scrollabile in orizzontale e il bordo destro di `Totale` dentro quello della griglia. ⚠️ **«In pausa» è `slate-200` e non `zinc-100`**, per una ragione che sta a schermo e non nei numeri: `zinc-100` è misurabilmente diverso da `amber-50` — l'asserzione sulle quattro stringhe distinte passava — ma accanto alla tinta di riga si legge come la stessa carta crema, cioè due tinte distinte che sembravano una. ⚠️ **NIENTE COLONNE PINNATE E NIENTE `checkable` in questa scena**, per due limiti già misurati e già scritti nel repo: lo sfondo opaco di una cella pinnata copre un `bg-*` che arrivi da `rowClassName` (lacuna dichiarata in `AppDataGrid.md` e nel commento di `parts/grid-row.tsx`), e la tinta della selezione è uno stile **inline** su ogni cella, che vince su qualunque utilità (`adg-r19`) — accendere l'una o l'altra renderebbe ambigua la dimostrazione proprio nel punto che deve dimostrare. ⚠️ **LA PRECEDENZA FRA LE TRE TINTE È MISURATA SUL COLORE RISOLTO**, non dedotta dalla cascata: su una riga tinta la play legge `getComputedStyle().backgroundColor` della cella di `Totale` e di quella di `Referente` e asserisce che sono **diversi**, e che la seconda è `rgba(0, 0, 0, 0)` — cioè che la cella in chiaro lascia passare il fondo della `<tr>` invece di ridipingerlo. La sonda è scritta **nel verso giusto**: se Tailwind non emettesse le classi della story i due colori sarebbero uguali e l'asserzione andrebbe **rossa**, non verde. ⚠️ **SEI FALSIFICAZIONI ESEGUITE**, ognuna riportata al verde subito dopo e ognuna rossa sul criterio suo: togliere `cellClassName` dalla colonna colorata (`expected +0 to be 12`); sostituire la tinta di colonna con una classe che Tailwind **non può emettere** — che lascia **verde** il criterio sulle classi e rossa la sonda del colore (`expected 'rgba(0, 0, 0, 0)' not to be 'rgba(0, 0, 0, 0)'`), cioè prova che quella sonda misura il CSS e non il markup; azzerare `rowClassName`; togliere il marcatore dell'header foglia; togliere quello dell'header di gruppo; e azzerare la tinta per valore (`expected 'truncate px-3 text-left' to contain 'bg-emerald-100 text-emerald-900'`). ⚠️ **La play non scrive numeri a mano**: il conteggio atteso delle celle custom è `dataRows(grid).length` letto dal DOM, e stato e settore di ogni riga si riagganciano ai dati per `data-grid-row` (da qui `getRowId={(riga) => riga.id}`, il codice e non l'indice), con `rigaDipintaDi` che **solleva** se una riga del DOM non si ritrova nei dati invece di misurare la riga sbagliata in silenzio
@@ -29,6 +30,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### 🐛 Fixed
 
+- **AppDataGrid — ⚠️ IN `serverMode` LA PAGINA 2 NON È PIÙ VUOTA: LA GRIGLIA NON RI-TAGLIA LA FETTA CHE IL SERVER HA GIÀ TAGLIATO.** Il motore montava `getPaginationRowModel` e decideva `manualPagination` guardando il solo `paginated`, senza `serverMode`: con `paginated` acceso la griglia ritagliava con il **proprio** `pageIndex` righe che il server aveva già tagliato con lo **stesso** indice — `slice(10, 20)` su dieci righe ricevute, cioè `[]`. ⚠️ **ED ERA UN GUASTO SOLO, NON DUE**: da quel `[]` esce `dataRowCount = 0`, che è lo stesso numero che accende lo stato «Nessun risultato» **e** smonta il paginatore, selettore della taglia di pagina compreso — una pagina vuota senza nessun comando per uscirne, se non un'azione che passa da `restart` o un ricarico. Ogni griglia `serverMode` + `paginated` che rispondesse con la sola pagina richiesta — cioè ogni consumer che manda `limit`/`skip`, il comportamento normale e quello che il contratto documenta — aveva **la pagina 2 e tutte le successive sempre vuote**. Ora vale `tagliaInLocale = paginated && !serverMode` (`engine/use-grid-engine.ts`): la griglia taglia da sé **solo** quando la pagina è sua, ed è la riga che il gemello congelato aveva già giusta (`tables/data-table/data-table.tsx`, `manualPagination: isServerSide`). ⚠️ **NIENTE SI MUOVE PER CHI NON È IN `serverMode`**, e nemmeno il conteggio delle pagine: `getPageCount` usa `options.rowCount`, che l'engine popola da `serverConfig.totalItems`; un consumer server che ometta `totalItems` ricade su `data.length`, identico a prima, perché il taglio avveniva **dopo** quel modello. ⚠️ **QUATTRO BANCHI DI STORY CODIFICAVANO IL COMPORTAMENTO SBAGLIATO** — il loro finto server ritornava l'insieme intero — e sono stati **ri-fixturati, non pinnati**: la scena sbagliata era la fixture, perché un server vero taglia. ⚠️ **E UNA FRASE DI DOCUMENTAZIONE È STATA REVOCATA**: `app-data-grid-completa.stories.tsx` dichiarava la pagina 2 vuota come limite inevitabile («un consumer che rispondesse con la SOLA pagina richiesta vedrebbe la pagina 2 vuota»). Era la descrizione esatta del difetto, scambiata per un contratto. Story di regressione: `LaPaginaDueDelServerNonSiSvuota`, con una sonda sulla pagina **servita** dal finto server, perché senza quella la play era verde per un istante su codice rotto.
 - **AppDataGrid — ⚠️ IL BADGE FANTASMA: SVUOTARE UNA CELLA DELLA RIGA ZERO ORA TOGLIE IL FILTRO, NON SOLO IL
   VALORE.** Con `filterMode="row"`, scrivere in una cella-filtro e poi **cancellare** lasciava il badge vivo in
   `state.query.filters` con `value: ""`. La query ripartiva correttamente senza quel vincolo — `usableBadges`
@@ -296,7 +298,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### 🔧 Changed
 
-- **AppDataGrid**: ⚠️ **BREAKING — il default di `filterMode` passa da `"panel"` a `"row"`** (il destructuring di `AppDataGrid` in `src/components/ui/app-data-grid/app-data-grid.tsx`). Chi non passa `filterMode` ora ottiene la **Riga Zero**: una QUARTA `<tr>` di `<thead>` (`tr[data-grid-filter-row]`), montata **al primo paint** perché il toggle nasce aperto (`useState(true)`), più il bottone **«Mostra/Nascondi la riga filtri»** (`[data-grid-toolbar-filter-row-toggle]`) nel gruppo sinistro della toolbar. **Il `<thead>` cresce di 36px** e chi budgeta l'altezza deve passare `gridViewportHeight({ …, hasFilterRow: filterMode === "row" && open })` leggendo `open` da `onFilterRowOpenChange` — un budget calcolato con `hasFilterRow: false` ora promette 36px che la griglia occupa. ⚠️ **NON È UN CAMBIO DI TIPI: `tsc` resta verde e nessun call-site smette di compilare** — il cambiamento è di COMPORTAMENTO A SCHERMO, quindi si scopre nel DOM e non nel compilatore. ⚠️ **E IL CONTO VERO, MISURATO ESEGUENDO E NON DEDOTTO, È PIÙ ALTO DI QUELLO CHE IL REPO SI ASPETTAVA: 11 scene rosse, non 14 asserzioni in due file.** `yarn run spec` passa da `1 failed | 800 passed (801)` a `12 failed | 789 passed` e torna a `1 failed | 800 passed` — l'unico rosso, prima e dopo, è il preesistente `app-sidebar.stories.tsx > Expand On Hover`. ⚠️ **E QUELLE 11 SONO LE ROSSE *NON* PREVISTE**, perché i tre siti che l'indagine aveva enumerato — gli helper `thead tr` di `app-data-grid-header-levels.stories.tsx` (13 asserzioni) e `app-data-grid-integrazione.stories.tsx` (1), più `ultimaRigaDiThead` in `app-data-grid-grouping.stories.tsx`, il caso che non sarebbe diventato rosso — **sono stati curati nello stesso passo del flip e quindi non hanno mai suonato**: il conto qui sotto è ciò che è emerso ESEGUENDO, oltre a quello. Le rosse si dividono in tre famiglie e **nessuna delle tre era stata prevista**: **(a) un QUARTO helper della stessa classe, che l'inventario statico non aveva trovato** — `intestazioniFoglia` in `app-data-grid-guscio-registro.stories.tsx` (4 scene R16), che prendeva l'ULTIMA `thead tr` per averne le FOGLIE e, trovando la riga zero, **SOLLEVAVA** invece di confrontare due liste vuote: la sua guardia di non-vacuità ha fatto esattamente il mestiere per cui era stata scritta; **(b) chi budgeta la cornice con `hasFilterRow: false`** — `app-data-grid-cornice.stories.tsx` (dieci righe intere diventano nove), `app-data-grid-esiti.stories.tsx` (otto righe sopra il footer diventano sette), `app-data-grid-virtualization.stories.tsx` (i 36px entrano nello `scrollHeight` del viewport e sforano la tolleranza di due righe); **(c) — la famiglia che nessuna previsione conteneva — chi misura il FILO fra le righe di intestazione**, `app-data-grid-header-levels.stories.tsx` e `app-data-grid-density-fullscreen.stories.tsx`, perché `haUnaRigaSotto` (`parts/grid-header.tsx`) conta la Riga Zero come una riga sotto, per una decisione firmata il 2026-09-10, e quindi la riga delle foglie ACQUISTA il filo che quelle scene asserivano assente. Le asserzioni su `[data-grid-header-row]` e su `thead th` restano **immuni per costruzione**: la riga zero porta un marcatore proprio (`parts/grid-filter-row.tsx`) e le sue celle sono `<td>`. **Nessuna scena è stata pinnata in blocco**: 5 siti aggiornati (4 helper portati da `thead tr` a `[data-grid-header-row]` — la cura è una riga per file, perché quei file misurano i LIVELLI di intestazione e non la riga zero — più la scena del filo di `header-levels`, riscritta sulla verità della modalità nuova) e **6 scene pinnate a `filterMode="panel"` esplicito**, una per una e con la ragione scritta accanto al pin: `BordoHeaderConDueLivelli` (density-fullscreen), `AltezzaCorniceMonotona` (cornice), `FooterDeiTotali` (esiti), `CambioDensitaMantieneLeMisure` (virtualization), `ConfineDelBloccoPinnato` (banda-tabella), `FiltriSoloFuori` (completa). ⚠️ **DUE DI QUEI PIN NON SONO RUMORE TOLTO DI MEZZO, SONO COPERTURA CHE SI SAREBBE PERSA**: `BordoHeaderConDueLivelli` è ora l'UNICA scena che pinna il ramo FALSO di `haUnaRigaSotto` («l'ultima riga di intestazione non porta il filo, perché sotto c'è il corpo»), e il ramo VERO — che fino a oggi non aveva **nessuna** copertura eseguibile, perché entrambe le scene del filo montavano in `"panel"` — è pinnato dalla scena aggiornata di `header-levels`. ⚠️ **E DUE ERANO FILI TESI CHE HANNO SUONATO COME SCRITTO**: `ConfineDelBloccoPinnato` dichiarava già nel proprio commento che il conto «regge per quel motivo, non per fortuna», e `FiltriSoloFuori` enumera sette selettori di superfici di filtro «se un giorno una di esse diventasse resa per difetto, la riga che la nomina diventa rossa e dice QUALE» — è successo, e ha detto quale. ⚠️ **REVOCA UNA DECISIONE FIRMATA**, e la revoca sta qui perché chi aveva letto quella va avvisato: il TSDoc di `filterMode` dichiarava «IL DEFAULT E' `"panel"` ED E' UNA DECISIONE, non un ripiego di comodo», con la ragione — le scene esistenti che contano le righe di `<thead>` diventerebbero rosse senza che nessuno le abbia toccate. **La ragione era ed è vera, e la previsione era giusta nel meccanismo e sbagliata nei numeri**: diceva «TRE in nove punti» in header-levels e «altrettanto» in integrazione (sono 13 e 1), ometteva il caso che non diventa rosso (`grouping`) e ometteva del tutto le famiglie (b) e (c). È il **peso** della ragione a essere cambiato: il pannello era la modalità già consegnata quando la Riga Zero era nuova, e oggi la Riga Zero è la modalità che le applicazioni montano. Il prezzo si paga una volta, nelle scene, e non ogni volta in ogni call-site.
+- **AppDataGrid**: ⚠️ **BREAKING — il default di `filterMode` passa da `"panel"` a `"row"`** (il destructuring di `AppDataGrid` in `src/components/ui/app-data-grid/app-data-grid.tsx`). Chi non passa `filterMode` ora ottiene la **Riga Zero**: una QUARTA `<tr>` di `<thead>` (`tr[data-grid-filter-row]`), montata **al primo paint** perché il toggle nasce aperto (`useState(true)`), più il bottone **«Mostra/Nascondi la riga filtri»** (`[data-grid-toolbar-filter-row-toggle]`) nel gruppo sinistro della toolbar. **Il `<thead>` cresce di 36px** e chi budgeta l'altezza deve passare `gridViewportHeight({ …, hasFilterRow: filterMode === "row" && open })` leggendo `open` da `onFilterRowOpenChange` — un budget calcolato con `hasFilterRow: false` ora promette 36px che la griglia occupa. ⚠️ **NON È UN CAMBIO DI TIPI: `tsc` resta verde e nessun call-site smette di compilare** — il cambiamento è di COMPORTAMENTO A SCHERMO, quindi si scopre nel DOM e non nel compilatore. ⚠️ **E IL CONTO VERO, MISURATO ESEGUENDO E NON DEDOTTO, È PIÙ ALTO DI QUELLO CHE IL REPO SI ASPETTAVA: 11 scene rosse, non 14 asserzioni in due file.** `yarn run spec` passa da `1 failed | 800 passed (801)` a `12 failed | 789 passed` e torna a `1 failed | 800 passed` — l'unico rosso, prima e dopo, è il preesistente `app-sidebar.stories.tsx > Expand On Hover`. ⚠️ **E QUELLE 11 SONO LE ROSSE _NON_ PREVISTE**, perché i tre siti che l'indagine aveva enumerato — gli helper `thead tr` di `app-data-grid-header-levels.stories.tsx` (13 asserzioni) e `app-data-grid-integrazione.stories.tsx` (1), più `ultimaRigaDiThead` in `app-data-grid-grouping.stories.tsx`, il caso che non sarebbe diventato rosso — **sono stati curati nello stesso passo del flip e quindi non hanno mai suonato**: il conto qui sotto è ciò che è emerso ESEGUENDO, oltre a quello. Le rosse si dividono in tre famiglie e **nessuna delle tre era stata prevista**: **(a) un QUARTO helper della stessa classe, che l'inventario statico non aveva trovato** — `intestazioniFoglia` in `app-data-grid-guscio-registro.stories.tsx` (4 scene R16), che prendeva l'ULTIMA `thead tr` per averne le FOGLIE e, trovando la riga zero, **SOLLEVAVA** invece di confrontare due liste vuote: la sua guardia di non-vacuità ha fatto esattamente il mestiere per cui era stata scritta; **(b) chi budgeta la cornice con `hasFilterRow: false`** — `app-data-grid-cornice.stories.tsx` (dieci righe intere diventano nove), `app-data-grid-esiti.stories.tsx` (otto righe sopra il footer diventano sette), `app-data-grid-virtualization.stories.tsx` (i 36px entrano nello `scrollHeight` del viewport e sforano la tolleranza di due righe); **(c) — la famiglia che nessuna previsione conteneva — chi misura il FILO fra le righe di intestazione**, `app-data-grid-header-levels.stories.tsx` e `app-data-grid-density-fullscreen.stories.tsx`, perché `haUnaRigaSotto` (`parts/grid-header.tsx`) conta la Riga Zero come una riga sotto, per una decisione firmata il 2026-09-10, e quindi la riga delle foglie ACQUISTA il filo che quelle scene asserivano assente. Le asserzioni su `[data-grid-header-row]` e su `thead th` restano **immuni per costruzione**: la riga zero porta un marcatore proprio (`parts/grid-filter-row.tsx`) e le sue celle sono `<td>`. **Nessuna scena è stata pinnata in blocco**: 5 siti aggiornati (4 helper portati da `thead tr` a `[data-grid-header-row]` — la cura è una riga per file, perché quei file misurano i LIVELLI di intestazione e non la riga zero — più la scena del filo di `header-levels`, riscritta sulla verità della modalità nuova) e **6 scene pinnate a `filterMode="panel"` esplicito**, una per una e con la ragione scritta accanto al pin: `BordoHeaderConDueLivelli` (density-fullscreen), `AltezzaCorniceMonotona` (cornice), `FooterDeiTotali` (esiti), `CambioDensitaMantieneLeMisure` (virtualization), `ConfineDelBloccoPinnato` (banda-tabella), `FiltriSoloFuori` (completa). ⚠️ **DUE DI QUEI PIN NON SONO RUMORE TOLTO DI MEZZO, SONO COPERTURA CHE SI SAREBBE PERSA**: `BordoHeaderConDueLivelli` è ora l'UNICA scena che pinna il ramo FALSO di `haUnaRigaSotto` («l'ultima riga di intestazione non porta il filo, perché sotto c'è il corpo»), e il ramo VERO — che fino a oggi non aveva **nessuna** copertura eseguibile, perché entrambe le scene del filo montavano in `"panel"` — è pinnato dalla scena aggiornata di `header-levels`. ⚠️ **E DUE ERANO FILI TESI CHE HANNO SUONATO COME SCRITTO**: `ConfineDelBloccoPinnato` dichiarava già nel proprio commento che il conto «regge per quel motivo, non per fortuna», e `FiltriSoloFuori` enumera sette selettori di superfici di filtro «se un giorno una di esse diventasse resa per difetto, la riga che la nomina diventa rossa e dice QUALE» — è successo, e ha detto quale. ⚠️ **REVOCA UNA DECISIONE FIRMATA**, e la revoca sta qui perché chi aveva letto quella va avvisato: il TSDoc di `filterMode` dichiarava «IL DEFAULT E' `"panel"` ED E' UNA DECISIONE, non un ripiego di comodo», con la ragione — le scene esistenti che contano le righe di `<thead>` diventerebbero rosse senza che nessuno le abbia toccate. **La ragione era ed è vera, e la previsione era giusta nel meccanismo e sbagliata nei numeri**: diceva «TRE in nove punti» in header-levels e «altrettanto» in integrazione (sono 13 e 1), ometteva il caso che non diventa rosso (`grouping`) e ometteva del tutto le famiglie (b) e (c). È il **peso** della ragione a essere cambiato: il pannello era la modalità già consegnata quando la Riga Zero era nuova, e oggi la Riga Zero è la modalità che le applicazioni montano. Il prezzo si paga una volta, nelle scene, e non ogni volta in ogni call-site.
 - **AppDataGrid**: `filterMode="panel"` è **work in progress**. Il pannello inventario **funziona, resta nell'unione `GridFilterMode` e resta passabile**, e `GridFilterPanel` resta esportato da entrambi i barili: **niente è stato rimosso e nessun call-site smette di compilare**. Quello che cambia è che non ci si arriva più per difetto e che la modalità non riceve lavoro finché la Riga Zero non è chiusa — la stessa distinzione, e la stessa forma, della voce `GridFilterPanel` in `src/components/documents/components-list.md`, dove la nuova voce sta **accanto** alla sua. ⚠️ **LA MARCATURA È DICHIARATIVA E NON ATTIVA, ed è scritta nei tre posti che un consumer legge davvero**: il TSDoc di `filterMode` (`src/components/ui/app-data-grid/app-data-grid.types.ts`), la riga di tabella di `filterMode` in `src/components/documents/components/AppDataGrid.md`, e la voce nuova in `components-list.md`. **Nessun `console.warn` su `filterMode="panel"`, e l'omissione è una scelta misurata**: le scene che montano il pannello per MISURARE il contratto (`app-data-grid-riga-zero.stories.tsx`) sono copertura corretta, e un warn le trasformerebbe in rumore a ogni run — a maggior ragione ora che sei scene lo passano esplicitamente per pinnare la geometria senza riga zero. La porta resta aperta: un warn è additivo. ⚠️ **È REVERSIBILE CON UNA RIGA**: rimettere `filterMode = "panel"` nel destructuring di `AppDataGrid` riporta tutto com'era, perché nessun tipo è cambiato e nessun export si è mosso, e le sei scene pinnate restano corrette in entrambi i versi. ⚠️ **IL TIPO NON È STATO TOCCATO**: `GridFilterMode = "row" | "panel"` è invariato, e `filterMode` resta appesa in coda a `GridShellFields` per non spostare le righe di `onQueryChange?: never` e `paginated?: never`, citate per numero da `scripts/check-grid-coexistence-matrix.mjs`.
 
 - **AppDataGrid**: The **25 «intermediate» story files** — every one except the three showcase files (`AppDataGrid/Mockup`, `AppDataGrid/Completa`, `AppDataGrid/Confronto`) — moved from `title: "AppDataGrid/<name>"` to `title: "CI-CD/AppDataGrid/<name>"`, so the regression specs collect under one `CI-CD` sidebar node and the showcase keeps `AppDataGrid/` to itself. ⚠️ **Each one also pins `id:` in its own meta, and that is the whole point of the change being safe.** A CSF component id is DERIVED from the title (`toId`), so the retitle alone would have moved the URL of every story in those files — and those URLs are cited OUTSIDE the source: 12 files under `.laif/tasks/to-validate` (tasks awaiting human signature, naming the page to open for a criterion not yet signed) and 11 append-only run logs, which are not rewritable, so any id change would leave permanently dead links in the audit trail. `id?: ComponentId` is the documented clause for exactly this (`node_modules/storybook/dist/csf/index.d.ts:876`, «used for URLs. By default is inferred from sanitizing the title»); Storybook in use is 10.0.8. ⚠️ **MEASURED on Storybook's own `/index.json`, before and after — not deduced from the source**: `appdatagrid-*` stories 319 → **319**; ids that disappeared (broken URLs) **0**; unexpected new ids **0**; stories whose title changed at an **unchanged id** **305** (the remaining 14 are the three showcase files); total index 725 → **725**. Citations to intermediate specs that no longer resolve: **2 before, the same 2 after** — `atomo-di-filtro-c7--inventario` and `selezione-c6--barra-di-selezione` were ALREADY dangling before the rename, so the retitle broke nothing. `npm run spec` stays **102 files / 725 tests, 0 failed** (it filters by file path, not by title) and all **14** `scripts/check-*.mjs` gates exit 0 (they read paths and sources; none reads a title). ⚠️ **The id values were COPIED from the index, never retyped**: one of the twenty-five is `appdatagrid-densità-e-schermo-intero-p6`, accent included — retyping it would have normalised the accent and silently broken a URL that works today. ⚠️ **Accepted consequence: title and URL now diverge for good** — a future title rename will silently keep the pinned id, which is why every one of the 25 metas carries the reason inline and points at the «Il nodo CI-CD» section of `docs/analysis/datatable-v2/PIANO-COMPLETAMENTO.md`. ⚠️ **The seven `Manuale` stories move too, and it is stated rather than hidden**: they are the deliberately play-less bench for human task validation, and in CSF a story cannot override its meta's title, so keeping them under `AppDataGrid/` would have meant splitting files — not done. Their URLs are unchanged, so every citation by id still resolves; only their sidebar location moved
@@ -305,6 +307,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **AppDataGrid**: `AppDataGrid.mockup.stories.tsx` stays published in Storybook as `AppDataGrid/Mockup`, frozen: it is the reference the delivery is signed against, and it is not public API — what leaves it is the stale «this mockup is not a component» banner (verifiable by difference: `grep -c 'non è un componente' src/components/stories/AppDataGrid.mockup.stories.tsx` went 1 → 0), not the story, because the delivery is signed by opening the two target scenes — `?path=/story/appdatagrid-completa--modalita-filtri` and `?path=/story/appdatagrid-completa--raggruppata` — next to `?path=/story/appdatagrid-mockup--modalita-filtri` from the Storybook manager, both of them, since groups and pager cannot be represented together and the mockup's single scene therefore has two counterparts
 - **AppDataGrid**: ⚠️ **Known limitation, open** — the two-value operator composer opens from the «Modifica valore…» menu item but **not** from the operator radio path of the filter inventory: the closing `DropdownMenu`'s `DismissableLayer` swallows the `Popover` that mounts in the same frame, and on the radio path the dismissal window outlives a single `requestAnimationFrame` because changing the group's value adds a render before the unmount (tried in four shapes, `modal={false}` included). The only known remedy is a 200ms `setTimeout`, which this lane's «zero setTimeout» convention rejects. Measured and written up in `src/components/documents/components/AppDataGrid.md` and at the `modal={false}` comment in `src/components/ui/app-data-grid/parts/grid-filter-editor.tsx`
 - **Gantt**: Confirmed `react-window` and `@types/react-window` stay as direct dependencies — `VariableSizeList`/`ListOnItemsRenderedProps` are imported directly by `src/components/ui/gantt/types/GanttContext.tsx`, `components/Chart/Chart.tsx`, `components/Chart/Scale/Scale.tsx`, `components/Chart/Tree/Tree.tsx`, `components/Chart/Bars/Bars.tsx` and `components/Gantt/Gantt.tsx`; the only other match in `src/` is a textual mention inside a mock message in `message-list.stories.tsx`, not an import
+
 ## [laif-ds@1.0.2]
 
 ### 🐛 Fixed

package/dist/agent-docs/adoption-report.json

@@ -1,12 +1,12 @@
 {
   "schemaVersion": "1.0.0",
-  "generatedAt": "2026-09-22T15:37:26.856Z",
+  "generatedAt": "2026-09-22T17:28:05.419Z",
   "package": {
     "name": "laif-ds",
-    "version": "1.0.2-app-data-grid.79"
+    "version": "1.0.2-app-data-grid.80"
   },
   "summary": {
-    "scannedFiles": 487,
+    "scannedFiles": 489,
     "deprecatedComponentsCount": 4,
     "deprecatedComponentsUsedCount": 2,
     "componentsWithoutExamplesCount": 5,

package/dist/agent-docs/manifest.json

@@ -1,9 +1,9 @@
 {
   "schemaVersion": "1.1.0",
-  "generatedAt": "2026-09-22T15:37:26.326Z",
+  "generatedAt": "2026-09-22T17:28:04.919Z",
   "package": {
     "name": "laif-ds",
-    "version": "1.0.2-app-data-grid.79"
+    "version": "1.0.2-app-data-grid.80"
   },
   "stats": {
     "documentedComponentCount": 97,
@@ -6549,5 +6549,5 @@
       ]
     }
   ],
-  "checksum": "262fea22430a13fa9c94db3cf32f81a8c65c62268b67c5d9bb9030858b0076bc"
+  "checksum": "92e578a83a1d88b7f6993c0cbf205f625b03f71874b1a3254a5459a68f2d94b0"
 }

package/dist/components/ui/app-data-grid/engine/use-grid-engine.js

@@ -1,45 +1,46 @@
 "use client";
-import { useReactTable as at } from "../../../../node_modules/@tanstack/react-table/build/lib/index.js";
-import { useMemo as n, useReducer as qe, useRef as m, useCallback as o, useState as B, useEffect as ct } from "react";
-import { applyGridAggregate as ut } from "../grid-aggregate.js";
-import { createGridColumnRegistry as dt } from "../grid-column-registry.js";
-import { buildGridGroupTree as gt, gridGroupPaths as pt, gridGroupPathsSignature as ft, seedGridGroupExpansion as mt, flattenGridGroupTree as Fe } from "../grid-grouping.js";
-import { pruneHiddenGridColumns as yt, flattenGridColumns as oe } from "../grid-header-matrix.js";
-import { createInitialGridState as wt, gridQueryReducer as Me, gridViewReducer as ht, toGridServerState as Ee, isAdditiveSort as bt } from "../grid-reducer.js";
-import { gridDefaultDebounceTime as vt } from "../grid-tokens.js";
-import { GRID_VIEW_PRESET_VERSION as Rt } from "../grid-view-preset.js";
-import { getPaginationRowModel as Ct, getSortedRowModel as St, getFilteredRowModel as Gt, getCoreRowModel as It } from "../../../../node_modules/@tanstack/table-core/build/lib/index.js";
-const qt = (i) => i.type === "query/search" || i.type === "query/filters", Wt = ({
+import { useReactTable as ut } from "../../../../node_modules/@tanstack/react-table/build/lib/index.js";
+import { useMemo as n, useReducer as qe, useRef as h, useCallback as s, useState as H, useEffect as dt } from "react";
+import { applyGridAggregate as gt } from "../grid-aggregate.js";
+import { createGridColumnRegistry as pt } from "../grid-column-registry.js";
+import { buildGridClientColumnFilters as mt, gridBadgeMatches as ft } from "../grid-filter-client.js";
+import { buildGridGroupTree as yt, gridGroupPaths as ht, gridGroupPathsSignature as wt, seedGridGroupExpansion as bt, flattenGridGroupTree as Ve } from "../grid-grouping.js";
+import { pruneHiddenGridColumns as vt, flattenGridColumns as oe } from "../grid-header-matrix.js";
+import { createInitialGridState as Rt, gridQueryReducer as Ee, gridViewReducer as Ct, toGridServerState as Me, isAdditiveSort as Ft } from "../grid-reducer.js";
+import { gridDefaultDebounceTime as St } from "../grid-tokens.js";
+import { GRID_VIEW_PRESET_VERSION as Gt } from "../grid-view-preset.js";
+import { getPaginationRowModel as It, getSortedRowModel as qt, getFilteredRowModel as Vt, getCoreRowModel as Et } from "../../../../node_modules/@tanstack/table-core/build/lib/index.js";
+const Mt = (i) => i.type === "query/search" || i.type === "query/filters", kt = ({
   columns: i,
-  data: S,
-  sortMode: b,
-  maxSortedColumns: y,
-  density: E,
-  paginated: L,
-  pageSize: se,
-  onQueryChange: le,
-  debounceTime: Ae,
-  serverMode: ae = !1,
-  serverConfig: H,
+  data: v,
+  sortMode: p,
+  maxSortedColumns: d,
+  density: M,
+  paginated: se,
+  pageSize: le,
+  onQueryChange: ae,
+  debounceTime: Te,
+  serverMode: A = !1,
+  serverConfig: X,
   initialState: w,
-  initialFullscreen: Te,
+  initialFullscreen: Pe,
   groupBy: ce,
-  initialOpenGroups: Pe = "all",
-  rowSelection: X,
+  initialOpenGroups: Ne = "all",
+  rowSelection: k,
   getRowId: ue,
   onRowSelectionChange: de,
   onCheckedRowsChange: ge,
-  rowClassName: A,
-  filters: T,
-  columnVisibility: Ne
+  rowClassName: O,
+  filters: S,
+  columnVisibility: Oe
 }) => {
   const pe = n(
-    () => wt({
-      density: E,
+    () => Rt({
+      density: M,
       // P10: `initialState.pagination.pageSize` vince su `pageSize`, perché un
       // call-site che passa entrambi ha scritto il primo per dire proprio
       // questo. Il gemello congelato si comporta così.
-      pageSize: w?.pagination?.pageSize ?? se,
+      pageSize: w?.pagination?.pageSize ?? le,
       // E la PAGINA dichiarata, per la stessa ragione: `GridPagination` la
       // pretende, quindi scartarla significa farla scrivere per niente.
       pageIndex: w?.pagination?.pageIndex,
@@ -53,7 +54,7 @@ const qt = (i) => i.type === "query/search" || i.type === "query/filters", Wt =
       // seme valeva 5 e la prima richiesta partiva con `pageIndex: 5` su
       // pagine da 50 — le righe 50-249 non le chiedeva nessuno.
       requestCount: Math.ceil(
-        S.length / (w?.pagination?.pageSize ?? se)
+        v.length / (w?.pagination?.pageSize ?? le)
       ),
       // Le tre fette dello stato iniziale che il corpus scrive. Lette UNA
       // VOLTA, al montaggio: cambiarle dopo non fa niente, come nel gemello.
@@ -77,63 +78,63 @@ const qt = (i) => i.type === "query/search" || i.type === "query/filters", Wt =
       })),
       filters: w?.filters?.filterBadges,
       columnVisibility: w?.columnVisibility,
-      fullscreen: Te
+      fullscreen: Pe
     }),
     // Solo al primo render: `density` qui è il valore INIZIALE, e cambiarla poi
     // è un'azione di vista, non un rimontaggio.
     // eslint-disable-next-line react-hooks/exhaustive-deps
     []
-  ), [k, Oe] = qe(
-    Me,
+  ), [J, _e] = qe(
+    Ee,
     pe.query
-  ), [v, J] = qe(ht, pe.view), G = Ne ?? v.columnVisibility, P = n(() => {
+  ), [R, j] = qe(Ct, pe.view), G = Oe ?? R.columnVisibility, _ = n(() => {
     if (!Object.values(G).some(
       (r) => r === !1
     )) return i;
-    const t = yt(i, G);
+    const t = vt(i, G);
     return t.length === 0 ? i : t;
-  }, [i, G]), j = n(() => {
-    const e = v.columnOrder;
-    if (e.length === 0) return P;
-    const t = new Map(e.map((f, d) => [f, d])), r = /* @__PURE__ */ new Map(), a = (f) => {
-      for (const d of f) {
-        if (!("columns" in d) || !Array.isArray(d.columns)) continue;
-        const c = d.columns;
+  }, [i, G]), U = n(() => {
+    const e = R.columnOrder;
+    if (e.length === 0) return _;
+    const t = new Map(e.map((y, g) => [y, g])), r = /* @__PURE__ */ new Map(), a = (y) => {
+      for (const g of y) {
+        if (!("columns" in g) || !Array.isArray(g.columns)) continue;
+        const c = g.columns;
         r.set(
-          d.id,
-          oe([d]).reduce(
-            (M, W) => Math.min(
-              M,
-              t.get(W.id) ?? Number.MAX_SAFE_INTEGER
+          g.id,
+          oe([g]).reduce(
+            (E, Q) => Math.min(
+              E,
+              t.get(Q.id) ?? Number.MAX_SAFE_INTEGER
             ),
             Number.MAX_SAFE_INTEGER
           )
         ), a(c);
       }
     };
-    a(P);
-    const Ge = (f) => {
-      const d = t.get(f.id) ?? Number.MAX_SAFE_INTEGER, c = "columns" in f && Array.isArray(f.columns) ? r.get(f.id) : void 0;
-      return c === void 0 ? d : Math.min(d, c);
-    }, Ie = (f) => [...f].sort((c, M) => Ge(c) - Ge(M)).map((c) => {
+    a(_);
+    const Ge = (y) => {
+      const g = t.get(y.id) ?? Number.MAX_SAFE_INTEGER, c = "columns" in y && Array.isArray(y.columns) ? r.get(y.id) : void 0;
+      return c === void 0 ? g : Math.min(g, c);
+    }, Ie = (y) => [...y].sort((c, E) => Ge(c) - Ge(E)).map((c) => {
       if (!("columns" in c) || !Array.isArray(c.columns)) return c;
-      const M = c.columns, W = Ie(M);
-      return W.every((st, lt) => st === M[lt]) ? c : { ...c, columns: W };
+      const E = c.columns, Q = Ie(E);
+      return Q.every((at, ct) => at === E[ct]) ? c : { ...c, columns: Q };
     });
-    return Ie(P);
-  }, [P, v.columnOrder]), fe = n(
-    () => oe(j),
-    [j]
-  ), s = n(
-    () => dt(fe),
-    [fe]
-  ), U = JSON.stringify(T ?? null), me = m(U), Y = m(!1);
-  me.current !== U && (me.current = U, Y.current = !0);
-  const N = o(
+    return Ie(_);
+  }, [_, R.columnOrder]), me = n(
+    () => oe(U),
+    [U]
+  ), o = n(
+    () => pt(me),
+    [me]
+  ), Y = JSON.stringify(S ?? null), fe = h(Y), Z = h(!1);
+  fe.current !== Y && (fe.current = Y, Z.current = !0);
+  const x = s(
     (e) => {
-      if (T === void 0) return e;
-      const t = { ...e, filters: [...T] };
-      return Y.current ? {
+      if (S === void 0) return e;
+      const t = { ...e, filters: [...S] };
+      return Z.current ? {
         ...t,
         pagination: { ...t.pagination, pageIndex: 0 }
         // ⚠️ RILIEVO motore-1 DELL'AUDIT 2026-09-09: APERTO, E LA SUA CORREZIONE È
@@ -166,13 +167,13 @@ const qt = (i) => i.type === "query/search" || i.type === "query/filters", Wt =
         // filtri sollevati. Appartiene a chi possiede il contratto dell'emettitore.
       } : t;
     },
-    [T]
+    [S]
   ), I = n(
-    () => N(k),
-    [N, k]
-  ), [ye, _e] = B(k), Z = n(
-    () => N(ye),
-    [N, ye]
+    () => x(J),
+    [x, J]
+  ), [ye, xe] = H(J), T = n(
+    () => x(ye),
+    [x, ye]
   ), q = n(
     () => ({
       // LA STESSA slice che il ref porta: una sorgente sola. Innestare i filtri
@@ -188,50 +189,50 @@ const qt = (i) => i.type === "query/search" || i.type === "query/filters", Wt =
       // potatura leggeva il riduttore (`?? `) mentre QUESTA riga metteva `null`
       // dentro `state.view.columnVisibility`, che il pannello del registro
       // dereferenzia. Due espressioni per la stessa cosa sono due cose.
-      view: { ...v, columnVisibility: G }
+      view: { ...R, columnVisibility: G }
     }),
-    [I, v, G]
-  ), O = n(
-    () => s.all().filter((e) => e.searchable).map((e) => ({ id: e.id, columnType: e.columnType })),
-    [s]
-  ), xe = n(() => {
-    const e = Ee(I, O);
+    [I, R, G]
+  ), z = n(
+    () => o.all().filter((e) => e.searchable).map((e) => ({ id: e.id, columnType: e.columnType })),
+    [o]
+  ), ze = n(() => {
+    const e = Me(I, z);
     return JSON.stringify({
       filters: e.filters,
       computedFilter: e.computedFilter,
       computedSorting: e.computedSorting,
       pageSize: e.pagination.pageSize
     });
-  }, [I, O]), g = m(I);
-  g.current = I;
-  const V = m(v);
-  V.current = { ...v, columnVisibility: G };
-  const we = m(le);
-  we.current = le;
-  const he = m(O);
-  he.current = O;
-  const $ = m(0);
-  $.current = Ae ?? H?.serverDebounceTime ?? vt;
-  const R = m(null);
-  ct(
+  }, [I, z]), m = h(I);
+  m.current = I;
+  const P = h(R);
+  P.current = { ...R, columnVisibility: G };
+  const he = h(ae);
+  he.current = ae;
+  const we = h(z);
+  we.current = z;
+  const $ = h(0);
+  $.current = Te ?? X?.serverDebounceTime ?? St;
+  const C = h(null);
+  dt(
     () => () => {
-      R.current !== null && window.clearTimeout(R.current);
+      C.current !== null && window.clearTimeout(C.current);
     },
     []
   );
-  const [ze, De] = B(0), [Ke, We] = B({}), u = X ?? Ke, ee = o(() => {
-    _e(g.current), De((e) => e + 1), we.current?.(
-      Ee(g.current, he.current)
+  const [De, Ke] = H(0), [Be, We] = H({}), u = k ?? Be, ee = s(() => {
+    xe(m.current), Ke((e) => e + 1), he.current?.(
+      Me(m.current, we.current)
     );
-  }, []), te = o(() => {
-    R.current !== null && (window.clearTimeout(R.current), R.current = null);
-  }, []), h = o(
+  }, []), te = s(() => {
+    C.current !== null && (window.clearTimeout(C.current), C.current = null);
+  }, []), b = s(
     (e) => {
-      const t = Me(g.current, e);
-      if (t !== g.current) {
-        if ((e.type === "query/page" || e.type === "query/page-size") && (Y.current = !1), g.current = t, Oe(e), qt(e) && $.current > 0) {
-          te(), R.current = window.setTimeout(() => {
-            R.current = null, ee();
+      const t = Ee(m.current, e);
+      if (t !== m.current) {
+        if ((e.type === "query/page" || e.type === "query/page-size") && (Z.current = !1), m.current = t, _e(e), Mt(e) && $.current > 0) {
+          te(), C.current = window.setTimeout(() => {
+            C.current = null, ee();
           }, $.current);
           return;
         }
@@ -239,15 +240,15 @@ const qt = (i) => i.type === "query/search" || i.type === "query/filters", Wt =
       }
     },
     [te, ee]
-  ), Be = o(
+  ), Le = s(
     (e) => {
-      J({
+      j({
         type: "view/preset",
         density: e.view.density,
         columnWidths: e.view.columnWidths,
         columnVisibility: e.view.columnVisibility,
         columnOrder: e.view.columnOrder
-      }), h({
+      }), b({
         type: "query/preset",
         search: e.query.search,
         sorting: e.query.sorting,
@@ -255,93 +256,105 @@ const qt = (i) => i.type === "query/search" || i.type === "query/filters", Wt =
         pageSize: e.query.pageSize
       });
     },
-    [h]
-  ), Qe = o(
+    [b]
+  ), Qe = s(
     (e, t) => ({
-      version: Rt,
+      version: Gt,
       id: e,
       name: t,
       query: {
-        search: g.current.search,
-        sorting: [...g.current.sorting],
-        filters: [...g.current.filters],
-        pageSize: g.current.pagination.pageSize
+        search: m.current.search,
+        sorting: [...m.current.sorting],
+        filters: [...m.current.filters],
+        pageSize: m.current.pagination.pageSize
       },
       view: {
-        density: V.current.density,
-        columnWidths: { ...V.current.columnWidths },
-        columnVisibility: { ...V.current.columnVisibility },
-        columnOrder: [...V.current.columnOrder]
+        density: P.current.density,
+        columnWidths: { ...P.current.columnWidths },
+        columnVisibility: { ...P.current.columnVisibility },
+        columnOrder: [...P.current.columnOrder]
       }
     }),
     []
-  ), Le = o((e) => {
-    J(e);
-  }, []), He = o(
-    (e, t) => h({
+  ), He = s((e) => {
+    j(e);
+  }, []), Xe = s(
+    (e, t) => b({
       type: "query/sort",
       columnId: e,
-      additive: bt(b, t),
-      maxSortedColumns: y
+      additive: Ft(p, t),
+      maxSortedColumns: d
     }),
-    [h, b, y]
-  ), Xe = o(
-    (e, t) => h({
+    [b, p, d]
+  ), ke = s(
+    (e, t) => b({
       type: "query/sort-set",
       columnId: e,
       desc: t,
       additive: !1,
-      maxSortedColumns: y
+      maxSortedColumns: d
     }),
-    [h, y]
-  ), ke = o(
-    () => h({ type: "query/sort-clear" }),
-    [h]
-  ), be = m([]), ve = m([]), F = o(
+    [b, d]
+  ), Je = s(
+    () => b({ type: "query/sort-clear" }),
+    [b]
+  ), be = h([]), ve = h([]), V = s(
     (e) => {
-      X || We(e), de?.(e), ge?.(
+      k || We(e), de?.(e), ge?.(
         ve.current.filter((t) => e[t.id]).map((t) => t.original)
       );
     },
-    [X, de, ge]
-  ), Je = o(
+    [k, de, ge]
+  ), je = s(
     (e, t) => {
       const r = { ...u };
-      t ? r[e] = !0 : delete r[e], F(r);
+      t ? r[e] = !0 : delete r[e], V(r);
     },
-    [u, F]
-  ), je = o(
+    [u, V]
+  ), Ue = s(
     (e, t) => {
       const r = { ...u };
       for (const a of e)
         t ? r[a] = !0 : delete r[a];
-      F(r);
+      V(r);
     },
-    [u, F]
-  ), Ue = o(
+    [u, V]
+  ), Ye = s(
     (e) => {
       const t = { ...u };
       for (const r of be.current)
         e ? t[r.id] = !0 : delete t[r.id];
-      F(t);
+      V(t);
     },
-    [u, F]
-  ), Ye = n(
-    () => s.all().map((e) => ({
+    [u, V]
+  ), Ze = n(
+    () => o.all().map((e) => ({
       id: e.id,
       // `accessorFn` e non `accessorKey`: la chiave di TanStack interpreta il
       // punto come profondità (`a.b` legge `row.a.b`), e va bene, ma
       // `undefined` per una colonna senza accessor va dichiarato una volta
       // sola invece che come ramo condizionale su ogni proprietà.
-      accessorFn: e.accessorKey ? (t) => Ft(t, e.accessorKey) : () => {
+      accessorFn: e.accessorKey ? (t) => At(t, e.accessorKey) : () => {
       },
       enableSorting: e.sortable,
-      enableGlobalFilter: e.searchable
+      enableGlobalFilter: e.searchable,
+      // ⚠️ NESSUN `enableColumnFilter` ACCANTO, e l'assenza e' una scelta: il
+      // default (`true` per una colonna con `accessorFn`) e' gia' quello
+      // giusto, perche' la popolazione e' ristretta a monte dai badge che
+      // esistono davvero. Un secondo cancello scarterebbe in silenzio un badge
+      // che i chip continuano a mostrare — la classe di difetto che D2 chiude.
+      filterFn: Pt
     })),
-    [s]
-  ), Ze = Z.sorting, _ = at({
-    data: S,
-    columns: Ye,
+    [o]
+  ), $e = T.sorting, et = n(
+    () => A || S !== void 0 ? [] : mt(
+      T.filters,
+      new Set(o.all().map((e) => e.id))
+    ),
+    [A, S, T.filters, o]
+  ), Re = se && !A, D = ut({
+    data: v,
+    columns: Ze,
     // ⚠️ INOLTRATA SOLO SE C'È. `getRowId: undefined` non equivale a non
     // passarla: TanStack distingue la chiave assente dal valore `undefined` in
     // alcune opzioni, e passare esplicitamente `undefined` è il modo di
@@ -350,19 +363,21 @@ const qt = (i) => i.type === "query/search" || i.type === "query/filters", Wt =
     // chi non passa la prop.
     ...ue === void 0 ? {} : { getRowId: ue },
     state: {
-      sorting: Ze,
-      globalFilter: Z.search,
+      sorting: $e,
+      globalFilter: T.search,
+      columnFilters: et,
       columnVisibility: q.view.columnVisibility,
-      pagination: Z.pagination
+      pagination: T.pagination
     },
     // La griglia guida lo stato, quindi TanStack non deve tenerne una copia:
     // senza questi la libreria costruisce il proprio stato interno e i due
     // divergono al primo click.
-    onSortingChange: Q,
-    onGlobalFilterChange: Q,
-    onColumnVisibilityChange: Q,
-    onPaginationChange: Q,
-    globalFilterFn: Mt,
+    onSortingChange: N,
+    onGlobalFilterChange: N,
+    onColumnFiltersChange: N,
+    onColumnVisibilityChange: N,
+    onPaginationChange: N,
+    globalFilterFn: Tt,
     // ⚠️ LA RIGA CHE MANCAVA, e senza la quale il filtro globale SALTAVA
     // colonne dichiarate ricercabili. Riprodotto contro il TanStack vero.
     //
@@ -378,35 +393,38 @@ const qt = (i) => i.type === "query/search" || i.type === "query/filters", Wt =
     // correttamente: non veniva mai raggiunto, perché la colonna era già stata
     // scartata a monte. Il registro sa quali colonne sono ricercabili — è la
     // sua ragione di esistere — quindi decide lui.
-    getColumnCanGlobalFilter: (e) => s.get(e.id)?.searchable ?? !1,
+    getColumnCanGlobalFilter: (e) => o.get(e.id)?.searchable ?? !1,
     // `enableMultiSort` / `enableMultiRemove` NON sono qui, e la loro assenza è
     // deliberata: TanStack le legge solo da `column.toggleSorting` e
     // `table.setSorting`, che questa griglia non chiama mai — l'ordinamento
     // arriva dal riduttore e `getSortedRowModel` onora l'array che riceve
     // qualunque cosa dicano quei flag. Dichiararle sembrerebbe un vincolo e non
     // vincolerebbe niente; il tetto vero è `maxSortedColumns` nel riduttore.
-    getCoreRowModel: It(),
-    getFilteredRowModel: Gt(),
-    getSortedRowModel: St(),
+    getCoreRowModel: Et(),
+    getFilteredRowModel: Vt(),
+    getSortedRowModel: qt(),
     // La paginazione è OPZIONALE e spenta per default: P1 rendeva tutte le
     // righe, e continuare a farlo è ciò che tiene onesto il criterio «filtrare
     // riduce le righe e cancellare le ripristina esatte» — con una paginazione
     // di mezzo quel conteggio misura la pagina, non l'insieme.
-    ...L ? { getPaginationRowModel: Ct() } : {},
-    // `manualPagination` quando NON siamo paginati: dice a TanStack di non
-    // tagliare niente. In modalità paginata è il row model qui sopra a tagliare.
-    manualPagination: !L,
+    //
+    // E in `serverMode` non si taglia affatto: vedi `tagliaInLocale`.
+    ...Re ? { getPaginationRowModel: It() } : {},
+    // `manualPagination` quando NON tagliamo qui: dice a TanStack di non
+    // tagliare niente — o perché non siamo paginati, o perché ha già tagliato il
+    // server. In modalità paginata CLIENT è il row model qui sopra a tagliare.
+    manualPagination: !Re,
     // ⚠️ IN MODALITA' SERVER LA GRIGLIA NON RIFILTRA NE' RIORDINA IN LOCALE — P10.
     // Il server ha gia' fatto entrambe le cose: rifarle qui significa applicare
     // due volte criteri che non coincidono mai del tutto, e mostrare MENO righe
     // di quelle che il server ha mandato — righe che l'utente ha chiesto e che
     // spariscono senza spiegazione.
-    manualFiltering: ae,
-    manualSorting: ae,
+    manualFiltering: A,
+    manualSorting: A,
     // Quante righe esistono in TUTTO, quando lo sa solo il server.
-    ...H?.totalItems === void 0 ? {} : { rowCount: H.totalItems }
-  }), $e = n(
-    () => s.all().map((e) => {
+    ...X?.totalItems === void 0 ? {} : { rowCount: X.totalItems }
+  }), tt = n(
+    () => o.all().map((e) => {
       const t = q.query.sorting.findIndex(
         (a) => a.id === e.id
       ), r = t === -1 ? void 0 : q.query.sorting[t];
@@ -424,21 +442,21 @@ const qt = (i) => i.type === "query/search" || i.type === "query/filters", Wt =
         headerClassName: e.headerClassName
       };
     }),
-    [s, q.query.sorting]
-  ), l = _.getRowModel();
-  be.current = l.rows, ve.current = _.getPrePaginationRowModel().rows;
-  const x = n(
+    [o, q.query.sorting]
+  ), l = D.getRowModel();
+  be.current = l.rows, ve.current = D.getPrePaginationRowModel().rows;
+  const K = n(
     () => l.rows.map((e) => e.original),
     [l]
-  ), C = n(
+  ), F = n(
     () => l.rows.map((e) => ({
       id: e.id,
-      className: typeof A == "function" ? A(Ve(e)) : A,
-      cells: s.all().map((t) => {
+      className: typeof O == "function" ? O(Ae(e)) : O,
+      cells: o.all().map((t) => {
         const r = t.accessorKey ? e.getValue(t.id) : void 0, a = t.rowMenu?.(e.original);
         return {
           columnId: t.id,
-          content: t.cell ? t.cell(r, e.original, Ve(e)) : Et(r),
+          content: t.cell ? t.cell(r, e.original, Ae(e)) : Nt(r),
           // Le voci si calcolano QUI, per riga: `rowMenu` è una funzione della
           // riga perché le voci dipendono dalla riga — una commessa chiusa non
           // si elimina. `undefined` per ogni colonna che non è quella del menu.
@@ -447,17 +465,17 @@ const qt = (i) => i.type === "query/search" || i.type === "query/filters", Wt =
         };
       })
     })),
-    [s, l, A]
-  ), z = n(
+    [o, l, O]
+  ), B = n(
     () => new Map(
       oe(i).filter((e) => e.accessorKey !== void 0).map((e) => [e.id, e.accessorKey])
     ),
     [i]
-  ), D = n(
-    () => (ce ?? []).filter((e) => z.has(e)),
-    [ce, z]
-  ), p = n(() => D.length === 0 ? [] : gt({
-    rows: C,
+  ), W = n(
+    () => (ce ?? []).filter((e) => B.has(e)),
+    [ce, B]
+  ), f = n(() => W.length === 0 ? [] : yt({
+    rows: F,
     // ⚠️ PARALLELE A `rows`, ed è il motivo per cui si passa il row model e non
     // `data`: `rows` è già filtrato e ordinato, mentre `data` è la prop grezza.
     // Raggruppare la prop grezza vorrebbe dire gruppi che contengono righe che
@@ -467,30 +485,30 @@ const qt = (i) => i.type === "query/search" || i.type === "query/filters", Wt =
     // seconda copia della stessa espressione: i gruppi e i totali devono
     // parlare delle stesse righe, o il totale del footer e la somma dei totali
     // di gruppo divergono per una ragione che nessuno vedrebbe.
-    data: x,
-    groupBy: D,
+    data: K,
+    groupBy: W,
     // Il VALORE raggruppante, letto dal row model per non ridurre a stringa
     // qualcosa che la cella rende in un altro modo.
     valueOf: (e, t) => {
-      const r = z.get(t);
+      const r = B.get(t);
       if (r !== void 0)
         return l.rows[e]?.original?.[r];
     }
-  }), [C, l, x, z, D]), re = n(() => pt(p), [p]), Re = n(
-    () => ft(re),
+  }), [F, l, K, B, W]), re = n(() => ht(f), [f]), Ce = n(
+    () => wt(re),
     [re]
-  ), [et, tt] = B(null);
-  et !== Re && (tt(Re), p.length > 0 && J({
+  ), [rt, nt] = H(null);
+  rt !== Ce && (nt(Ce), f.length > 0 && j({
     type: "view/group-expansion-seed",
-    seeded: mt(p, Pe),
+    seeded: bt(f, Ne),
     // I percorsi che esistono ADESSO. Servono al riduttore per due cose che
     // solo lui può fare: tenere le voci dei gruppi sopravvissuti e potare
     // quelle dei gruppi spariti. La specifica da sola non basta — dice cosa
     // fare di un albero vergine, non cosa è già stato deciso.
     paths: re
   }));
-  const Ce = v.groupExpansion, Se = o(
-    (e) => s.all().map((t) => ({
+  const Fe = R.groupExpansion, Se = s(
+    (e) => o.all().map((t) => ({
       columnId: t.id,
       // ⚠️ VUOTA quando la colonna non dichiara un aggregato — criterio 2. Il
       // default sbagliato sarebbe il valore della prima figlia: su una colonna
@@ -498,41 +516,41 @@ const qt = (i) => i.type === "query/search" || i.type === "query/filters", Wt =
       // presentato come proprietà del gruppo.
       content: t.aggregatedCell ? t.aggregatedCell(e.data) : null
     })),
-    [s]
-  ), K = o(
-    (e) => s.all().map((t) => ({
+    [o]
+  ), L = s(
+    (e) => o.all().map((t) => ({
       columnId: t.id,
-      content: ut(t, e)
+      content: gt(t, e)
     })),
-    [s]
-  ), rt = n(
-    () => K(x),
-    [K, x]
-  ), ne = o(
+    [o]
+  ), it = n(
+    () => L(K),
+    [L, K]
+  ), ne = s(
     (e) => {
       const t = [];
       for (const r of e) {
         const a = l.rowsById[r];
         a !== void 0 && t.push(a.original);
       }
-      return K(t);
+      return L(t);
     },
-    [K, l]
+    [L, l]
   ), ie = n(
     () => l.rows.filter((e) => u[e.id]).map((e) => e.id),
     [l, u]
-  ), nt = n(
+  ), ot = n(
     () => ne(ie),
     [ne, ie]
-  ), it = n(() => p.length === 0 ? C.map((e) => ({ kind: "row", row: e })) : Fe({
-    tree: p,
-    expansion: Ce,
+  ), st = n(() => f.length === 0 ? F.map((e) => ({ kind: "row", row: e })) : Ve({
+    tree: f,
+    expansion: Fe,
     // LE CELLE DELLA RIGA DI GRUPPO: una per colonna VISIBILE, come una riga di
     // dati, mai una che ne occupa molte. Vedi il commento in `grid-grouping.ts`.
     cellsFor: Se
-  }), [p, Ce, Se, C]), ot = o(
-    (e) => p.length === 0 ? C.length : Fe({
-      tree: p,
+  }), [f, Fe, Se, F]), lt = s(
+    (e) => f.length === 0 ? F.length : Ve({
+      tree: f,
       expansion: e
       // ⚠️ SENZA `cellsFor`: qui si conta, non si rende. Passandola, ogni
       // `aggregatedCell` girava su tutte le righe del proprio gruppo —
@@ -540,59 +558,61 @@ const qt = (i) => i.type === "query/search" || i.type === "query/filters", Wt =
       // La sequenza delle righe non dipende dalle celle, quindi il numero
       // è lo stesso.
     }).length,
-    [p, C]
+    [f, F]
   );
   return {
-    headers: $e,
-    rows: C,
-    leafCount: s.all().length,
-    rowHeaderColumnId: s.rowHeaderId(),
+    headers: tt,
+    rows: F,
+    leafCount: o.all().length,
+    rowHeaderColumnId: o.rowHeaderId(),
     // L'albero, per il `<thead>`. È la sola cosa che P5 aggiunge alla superficie
     // dell'engine: la STRUTTURA delle intestazioni sta qui, lo STATO di
     // ordinamento in `headers`, e `parts/grid-table.tsx` li unisce per id.
     // L'albero POTATO: il `<thead>` deve vedere le stesse colonne del corpo.
-    columnTree: j,
-    bodyRows: it,
-    footerCells: rt,
+    columnTree: U,
+    bodyRows: st,
+    footerCells: it,
     aggregateCells: ne,
-    selectionCells: nt,
+    selectionCells: ot,
     // La DICHIARAZIONE e non il contenuto: un aggregato che rende `null` non è
     // una colonna senza aggregato, e chi decide se il `<tfoot>` esiste deve
     // poter distinguere «nessuna colonna dichiara un totale» da «i totali sono
     // vuoti».
-    hasAggregates: s.all().some((e) => e.aggregate !== void 0),
-    groupByColumnIds: D,
-    bodyRowCountWith: ot,
-    applyPreset: Be,
+    hasAggregates: o.all().some((e) => e.aggregate !== void 0),
+    groupByColumnIds: W,
+    bodyRowCountWith: lt,
+    applyPreset: Le,
     readPreset: Qe,
     state: q,
-    emissions: ze,
-    querySignature: xe,
-    pageCount: L ? _.getPageCount() : 1,
-    filteredRowCount: _.getPrePaginationRowModel().rows.length,
+    emissions: De,
+    querySignature: ze,
+    pageCount: se ? D.getPageCount() : 1,
+    filteredRowCount: D.getPrePaginationRowModel().rows.length,
     selection: u,
-    toggleRow: Je,
-    toggleRows: je,
-    toggleAllRows: Ue,
+    toggleRow: je,
+    toggleRows: Ue,
+    toggleAllRows: Ye,
     selectedPageRowIds: ie,
     allRowsSelected: l.rows.length > 0 && l.rows.every((e) => u[e.id]),
     someRowsSelected: l.rows.some((e) => u[e.id]) && !l.rows.every((e) => u[e.id]),
-    applyAndEmit: h,
-    applyView: Le,
-    sort: He,
-    setSortDirection: Xe,
-    clearSort: ke
+    applyAndEmit: b,
+    applyView: He,
+    sort: Xe,
+    setSortDirection: ke,
+    clearSort: Je
   };
-}, Q = () => {
-}, Ft = (i, S) => S.split(".").reduce(
-  (b, y) => b?.[y],
+}, N = () => {
+}, At = (i, v) => v.split(".").reduce(
+  (p, d) => p?.[d],
   i
-), Mt = (i, S, b) => {
-  const y = String(b ?? "").toLowerCase();
-  if (y === "") return !0;
-  const E = i.getValue(S);
-  return E == null ? !1 : String(E).toLowerCase().includes(y);
-}, Et = (i) => i == null ? "" : String(i), Ve = (i) => i;
+), Tt = (i, v, p) => {
+  const d = String(p ?? "").toLowerCase();
+  if (d === "") return !0;
+  const M = i.getValue(v);
+  return M == null ? !1 : String(M).toLowerCase().includes(d);
+}, Pt = (i, v, p) => p.every(
+  (d) => ft(d, i.getValue(v))
+), Nt = (i) => i == null ? "" : String(i), Ae = (i) => i;
 export {
-  Wt as useGridEngine
+  kt as useGridEngine
 };

package/dist/components/ui/app-data-grid/grid-filter-client.js

@@ -0,0 +1,73 @@
+"use client";
+import { usableBadges as b } from "./grid-filter-compile.js";
+import { gridBadgeFilterType as p } from "./grid-filter-operators.js";
+const A = (t, r) => {
+  const e = /* @__PURE__ */ new Map();
+  for (const n of b(t)) {
+    if (!r.has(n.columnId)) continue;
+    const o = e.get(n.columnId);
+    o === void 0 ? e.set(n.columnId, [n]) : o.push(n);
+  }
+  return [...e].map(([n, o]) => ({ id: n, value: o }));
+}, _ = /[.*+?^${}()|[\]\\]/g, c = (t) => new RegExp(
+  `^${t.replace(_, "\\$&").replace(/%/g, ".*").replace(/_/g, ".")}$`,
+  "iu"
+), g = /^(\d{4})-(\d{2})-(\d{2})(?:T(\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,6}))?)?$/, i = (t) => {
+  if (t == null) return Number.NaN;
+  let r = String(t).replace(/Z+$/, "");
+  const e = r.indexOf("+");
+  e !== -1 && r.includes("T") && (r = r.slice(0, e));
+  const n = g.exec(r);
+  return n === null ? Number.NaN : Date.UTC(
+    Number(n[1]),
+    Number(n[2]) - 1,
+    Number(n[3]),
+    Number(n[4] ?? "0"),
+    Number(n[5] ?? "0"),
+    Number(n[6] ?? "0"),
+    Number(`${n[7] ?? ""}000`.slice(0, 3))
+  );
+}, u = (t) => Array.isArray(t) ? t : [t], d = (t, r) => Array.isArray(t) ? t.some((e) => u(r).includes(e)) : u(r).includes(t), a = (t) => t == null || Array.isArray(t) && t.length === 0, f = (t, r) => {
+  const e = i(t);
+  return Number.isFinite(e) && e === i(r);
+}, m = (t, r) => {
+  const e = i(t);
+  return Number.isFinite(e) && e < i(r);
+}, N = (t, r) => {
+  const e = i(t);
+  return Number.isFinite(e) && e > i(r);
+}, s = (t, r, e) => t != null && c(e(String(r ?? ""))).test(String(t)), v = {
+  // `eq` su una data e' `col = parse_datetime(v)`, su tutto il resto `col = v`.
+  // Divergenze D ed E.
+  eq: (t, r, e) => e === "date" || e === "datetime" ? f(t, r) : t != null && t === r,
+  // ⚠️ IL GUARD `!= null` E' LA DIVERGENZA A, RICONCILIATA. Toglierlo fa passare
+  // le righe con la cella vuota, che in SQL non passano.
+  ne: (t, r) => t != null && t !== r,
+  lt: (t, r) => t != null && Number(t) < Number(r),
+  le: (t, r) => t != null && Number(t) <= Number(r),
+  gt: (t, r) => t != null && Number(t) > Number(r),
+  ge: (t, r) => t != null && Number(t) >= Number(r),
+  like: (t, r) => s(t, r, (e) => `%${e}%`),
+  // Divergenza A, di nuovo: la negazione NON vale su una cella vuota.
+  n_like: (t, r) => t != null && !s(t, r, (e) => `%${e}%`),
+  starts_with: (t, r) => s(t, r, (e) => `${e}%`),
+  ends_with: (t, r) => s(t, r, (e) => `%${e}`),
+  date_before: m,
+  date_time_before: m,
+  date_after: N,
+  date_time_after: N,
+  array_overlap: (t, r) => t != null && d(t, r),
+  n_array_overlap: (t, r) => t != null && !d(t, r),
+  eq_null: (t) => a(t),
+  n_eq_null: (t) => !a(t),
+  checked: (t) => t === !0,
+  unchecked: (t) => t === !1
+}, E = (t, r) => v[t.operator](
+  r,
+  t.value,
+  p(t)
+);
+export {
+  A as buildGridClientColumnFilters,
+  E as gridBadgeMatches
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "laif-ds",
   "private": false,
-  "version": "1.0.2-app-data-grid.79",
+  "version": "1.0.2-app-data-grid.80",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",