@massimo-cassandro/minimo 1.21.6 → 1.21.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@massimo-cassandro/minimo",
-  "version": "1.21.6",
+  "version": "1.21.8",
   "description": "Light css framework & utilities",
   "type": "module",
   "main": "./index.js",
@@ -74,6 +74,7 @@
   "peerDependencies": {
     "@svgdotjs/svg.js": "^3.2.7",
     "blurhash": "^2.0.5",
+    "simple-datatables": "^10.3.0",
     "style-dictionary": "^5.0.0"
   },
   "peerDependenciesMeta": {
@@ -83,6 +84,9 @@
     "blurhash": {
       "optional": true
     },
+    "simple-datatables": {
+      "optional": true
+    },
     "style-dictionary": {
       "optional": true
     }

package/src/web-components/s-datatable-component/docs.md

@@ -2,6 +2,14 @@
 
 <https://fiduswriter.github.io/simple-datatables/documentation/>
 
+## Installazione
+
+`simple-datatables` è una **peer dependency opzionale** di minimo: va installata
+solo nei progetti che usano questo componente.
+
+```bash
+npm i simple-datatables
+```
 
 ## Utilizzo da markup
 
@@ -211,13 +219,29 @@ cols: [
                    //   _sortValue: 'owner.cognome'  → ordina per cognome
 
     _searchValue,  // Percorso/i del campo da usare per la RICERCA al posto del contenuto
-                   // visualizzato. Accetta uno o più percorsi separati da spazio.
+                   // visualizzato. Accetta uno o più percorsi separati da spazio,
+                   // oppure una funzione (row) => string|number|boolean.
                    // Supporta notazione punto.
-                   // Implementato tramite searchMethod di colonna (API simple-datatables)
-                   // e attributo data-search sulla cella.
+                   // Implementato tramite searchMethod di colonna (API simple-datatables):
+                   // il valore viene scritto in attributes['data-search'] della cella e
+                   // la searchMethod lo legge dall'OGGETTO DATI INTERNO di
+                   // simple-datatables (cellType: { data, text?, order?, attributes? }),
+                   // NON dal nodo DOM <td> (la libreria passa alla callback
+                   // `searchRow[index]`, non l'elemento renderizzato).
+                   // Ordine di lettura: attributes['data-search'] → text → data.
+                   // Il valore viene convertito con String(), quindi sono ammessi
+                   // numeri e booleani (es. `_searchValue: row => row.id`).
                    // La ricerca è di tipo AND: tutti i termini digitati devono essere
                    // presenti nel valore del campo (o dei campi) indicati.
                    //
+                   // Normalizzazione: simple-datatables normalizza solo i termini
+                   // digitati (default `sensitivity: 'base'`, `ignorePunctuation: true`).
+                   // La searchMethod applica la stessa catena anche al contenuto della
+                   // cella (minuscole + NFD senza diacritici + rimozione punteggiatura),
+                   // così "citta" trova "Città" e "spa" trova "S.p.A.".
+                   // Se sulla colonna sono impostate `sensitivity` / `ignorePunctuation`,
+                   // vengono rispettate.
+                   //
                    // Esempio: _searchValue: 'owner.cognome owner.nome'
                    //   cerca su entrambi i campi concatenati; "rossi mario" trova solo
                    //   le righe che contengono entrambe le parole, in qualsiasi ordine.

package/src/web-components/s-datatable-component/s-datatable-component.js

@@ -5,6 +5,7 @@
 import { DataTable } from 'simple-datatables';
 
 import { parseCols } from './src/parse-cols.js';
+import { makeSearchMethod } from './src/search-method.js';
 
 import * as styles from './s-datatable-component.module.css';
 
@@ -640,10 +641,13 @@ class SimpleDatatableAdapter extends HTMLElement {
             value = nullAs;
           }
 
-          // _searchValue: valore alternativo per la ricerca
-          // Viene scritto come testo nascosto nella cella così la funzione
-          // search personalizzata della colonna può leggerlo direttamente
-          // dal contenuto, senza dipendere da attributi non supportati.
+          // _searchValue: valore alternativo per la ricerca.
+          // Viene scritto in `attributes['data-search']` della cella: la
+          // searchMethod di colonna lo legge dall'oggetto dati interno di
+          // simple-datatables (cellType), non dal DOM.
+          // Accetta un percorso (o più percorsi separati da spazio) oppure una
+          // funzione (row) => string|number: il valore viene normalizzato con
+          // String() al momento del confronto.
           const searchValue = col_item._searchValue
             ? typeof col_item._searchValue === 'function'
               ? (col_item._searchValue(row) ?? '')
@@ -702,20 +706,14 @@ class SimpleDatatableAdapter extends HTMLElement {
         // data-search invece che sul testo visualizzato.
         // L'API simple-datatables prevede: (terms, cell, row, colIdx, source)
         // - terms: array di stringhe (uno per parola cercata)
-        // - cell:  nodo DOM <td> della riga renderizzata
+        // - cell:  oggetto dati interno `cellType` ({ data, text?, order?, attributes? }),
+        //          NON il nodo DOM <td>: la libreria passa `searchRow[index]`
+        //          (vedi `multiSearch` in src/datatable.ts).
         // La funzione deve restituire true se la riga è da includere.
-        // NOTA: `cell` è un nodo DOM, quindi va usato cell.getAttribute()
-        // e NON cell.attributes?.['data-search'] (che leggerebbe la NamedNodeMap
-        // come plain object, restituendo sempre undefined).
-        // Comportamento AND: tutti i termini devono essere presenti (come
-        // nella demo https://fiduswriter.github.io/simple-datatables/demos/22-and-search/).
+        // Vedi ./src/search-method.js per la lettura del valore e la
+        // normalizzazione (allineata a quella che la libreria applica ai termini).
         if (col_settings._searchValue) {
-          colObj.searchMethod = (terms, cell) => {
-            const haystack = (
-              cell.getAttribute?.('data-search') ?? cell.textContent ?? ''
-            ).toLowerCase();
-            return terms.every(term => haystack.includes(term.toLowerCase()));
-          };
+          colObj.searchMethod = makeSearchMethod(col_settings);
         }
 
         return colObj;

package/src/web-components/s-datatable-component/src/parse-cols.js

@@ -121,13 +121,15 @@ export function parseCols(col_obj){
 
     } else if(col_obj._renderMode === 'numeric') {
       return {
-// TODO implementare merge con classi presenti nei parametri definiti dall'utente
-        cellClass: 'text-end text-numeric',
-        headerClass: 'text-end text-numeric', // NB: usata anche per il footer
+        ...col_obj,
+        // le classi definite dall'utente vengono unite, non sostituite
+        cellClass: classnames('text-end text-numeric', col_obj.cellClass),
+        headerClass: classnames('text-end text-numeric', col_obj.headerClass), // NB: usata anche per il footer
       };
 
     } else if(col_obj._renderMode === 'euro_no_dec') {
       return {
+        ...col_obj,
         render: (value, cell) => {
           // console.log(value);
           if(value == null || isNaN(value)) {
@@ -143,8 +145,9 @@ export function parseCols(col_obj){
             });
           }
         },
-        cellClass: 'text-nowrap text-end text-numeric',
-        headerClass: 'text-nowrap text-end text-numeric', // NB: usata anche per il footer
+        // le classi definite dall'utente vengono unite, non sostituite
+        cellClass: classnames('text-nowrap text-end text-numeric', col_obj.cellClass),
+        headerClass: classnames('text-nowrap text-end text-numeric', col_obj.headerClass), // NB: usata anche per il footer
         type: 'number'
       };
 

package/src/web-components/s-datatable-component/src/search-method.js

@@ -0,0 +1,84 @@
+// @ts-nocheck
+
+// Generazione della `searchMethod` di colonna usata da `_searchValue`.
+//
+// simple-datatables NON passa alla searchMethod il nodo DOM della cella, ma
+// l'oggetto dati interno `cellType` ({ data, text?, order?, attributes? }):
+// vedi `multiSearch` in `src/datatable.ts` (`customSearchMethod(queryColumnWord,
+// searchRow[index], row, index, source)`). Gli `attributes` sono conservati
+// nell'oggetto dati (`readDataCell` in `src/read_data.ts` ammette le chiavi
+// "text", "order", "data", "attributes"), quindi `data-search` va letto da
+// `cell.attributes['data-search']`, non con `cell.getAttribute()`.
+
+// Punteggiatura rimossa quando `ignorePunctuation` è attivo
+const PUNCTUATION_RX = /[.,/#!$%^&*;:{}=\-_`~()]/g;
+
+/**
+ * Normalizza una stringa replicando il trattamento che simple-datatables
+ * applica ai termini di ricerca quando è attiva una `searchMethod` personalizzata.
+ *
+ * La libreria normalizza solo i termini digitati (non il contenuto della cella),
+ * con i default `sensitivity: 'base'` e `ignorePunctuation: true`: se l'haystack
+ * non riceve lo stesso trattamento, "citta" non troverebbe "Città" e "spa" non
+ * troverebbe "S.p.A.".
+ *
+ * @param {*} str Valore da normalizzare (convertito con String()).
+ * @param {object} [opts]
+ * @param {'base'|'accent'|'case'|'variant'} [opts.sensitivity='base']
+ *        'base'    → ignora maiuscole/minuscole e diacritici
+ *        'accent'  → ignora maiuscole/minuscole, mantiene i diacritici
+ *        'case'    → distingue maiuscole/minuscole, ignora i diacritici
+ *        'variant' → distingue tutto
+ * @param {boolean} [opts.ignorePunctuation=true]
+ * @returns {string}
+ */
+export function normalizeSearchString(str, opts = {}) {
+  const sensitivity       = opts.sensitivity       ?? 'base';
+  const ignorePunctuation = opts.ignorePunctuation ?? true;
+
+  // String() anche su numeri/booleani: `_searchValue` come funzione può
+  // restituire un id numerico o un flag
+  let out = String(str ?? '');
+
+  if (sensitivity === 'base' || sensitivity === 'accent') {
+    out = out.toLowerCase();
+  }
+  if (sensitivity === 'base' || sensitivity === 'case') {
+    out = out.normalize('NFD').replace(/\p{Diacritic}/gu, '');
+  }
+  if (ignorePunctuation) {
+    out = out.replace(PUNCTUATION_RX, '');
+  }
+
+  return out;
+}
+
+/**
+ * Restituisce la `searchMethod` di colonna per le colonne con `_searchValue`.
+ *
+ * API simple-datatables: (terms, cell, row, colIdx, source) => boolean
+ * - `terms` array di stringhe (una per parola cercata), già normalizzate dalla libreria
+ * - `cell`  oggetto dati `cellType` ({ data, text?, order?, attributes? })
+ *
+ * Comportamento AND: tutti i termini devono essere presenti
+ * (come nella demo https://fiduswriter.github.io/simple-datatables/demos/22-and-search/).
+ *
+ * @param {object} [colSettings] Definizione della colonna (per `sensitivity` / `ignorePunctuation`).
+ * @returns {(terms: string[], cell: object) => boolean}
+ */
+export function makeSearchMethod(colSettings = {}) {
+  const opts = {
+    sensitivity:       colSettings.sensitivity,
+    ignorePunctuation: colSettings.ignorePunctuation,
+  };
+
+  return (terms, cell) => {
+    const raw = cell?.attributes?.['data-search']
+      ?? cell?.text
+      ?? (typeof cell?.data === 'string' || typeof cell?.data === 'number' ? cell.data : '');
+
+    const haystack = normalizeSearchString(raw, opts);
+
+    return terms.every(term => haystack.includes(normalizeSearchString(term, opts)));
+  };
+}