@massimo-cassandro/minimo 1.41.3 → 1.41.5

package/src/web-components/json-table/src/parse-cols.js

@@ -5,8 +5,8 @@
 /** @typedef {import('./defaults.js').DataTypeDefinition} DataTypeDefinition */
 
 /**
- * Column definition after parsing: every property has a value, `condition` is resolved to a
- * boolean, `headerClass`/`cellClass` are the final class strings and `_type` is the data type object.
+ * Definizione della colonna dopo l'analisi: ogni proprietà ha un valore, `condition` è risolto in un
+ * booleano, `headerClass`/`cellClass` sono le stringhe di classi finali e `_type` è l'oggetto del data type.
  * @typedef {Required<Omit<ColDefinition, 'type'|'condition'|'sortValue'|'searchValue'>> & {
  *   condition: boolean,
  *   sortValue: *,
@@ -16,7 +16,7 @@
  */
 
 /**
- * Column defaults.
+ * Default delle colonne.
  * @type {Omit<Required<ColDefinition>, 'type'|'sortValue'|'searchValue'> & { sortValue: *, searchValue: * }}
  */
 export const colDefaults = {
@@ -37,28 +37,28 @@ export const colDefaults = {
 
 
 /**
- * Normalizes the `cols` param: applies the column defaults and the data type `colDefaults`,
- * resolves the `type`/`dataType` alias, the `condition` and the `headerClass`/`cellClass`
- * fallbacks, and drops the columns whose `condition` is false.
+ * Normalizza il parametro `cols`: applica i default delle colonne e i `colDefaults` del data type,
+ * risolve l'alias `type`/`dataType`, `condition` e i fallback di `headerClass`/`cellClass`,
+ * ed elimina le colonne la cui `condition` è false.
  *
- * `cols` is required: an empty or missing definition throws.
+ * `cols` è obbligatorio: una definizione vuota o mancante lancia un errore.
  *
- * Merge order (lowest first): `colDefaults` ← data type `colDefaults` ← column definition.
- * Class resolution: `headerClass` = column `headerClass` ?? column `cellClass` ?? type `headerClass`;
- * `cellClass` = column `cellClass` ?? column `headerClass` ?? type `cellClass`.
+ * Ordine di unione (dal più basso): `colDefaults` ← `colDefaults` del data type ← definizione della colonna.
+ * Risoluzione delle classi: `headerClass` = `headerClass` della colonna ?? `cellClass` della colonna ?? `headerClass` del tipo;
+ * `cellClass` = `cellClass` della colonna ?? `headerClass` della colonna ?? `cellClass` del tipo.
  *
- * @param {ColDefinition[]|null|undefined} cols - Columns definition (`params.cols`)
- * @param {Object<string, DataTypeDefinition>} dataTypes - Data types map (see `buildDataTypes`)
- * @param {JsonTableParams} params - Resolved params (passed to `condition` functions)
- * @returns {ParsedCol[]} Visible columns only
- * @throws {Error} On missing/empty `cols`, missing `key` or unknown data type
+ * @param {ColDefinition[]|null|undefined} cols - Definizione delle colonne (`params.cols`)
+ * @param {Object<string, DataTypeDefinition>} dataTypes - Mappa dei data type (vedi `buildDataTypes`)
+ * @param {JsonTableParams} params - Parametri risolti (passati alle funzioni `condition`)
+ * @returns {ParsedCol[]} Solo le colonne visibili
+ * @throws {Error} In caso di `cols` mancante/vuoto, `key` mancante o data type sconosciuto
  *
  * @example
  * parseCols([
  *   { key: 'id', dataType: 'id' },                       // title: 'id' (default: key)
  *   { key: 'name', title: 'Nome', cellClass: 'fw-bold' }, // headerClass: 'fw-bold' (default: cellClass)
- *   { key: 'amount', type: 'euro', tfootRender: '@sum' }, // `type` alias of `dataType`
- *   { key: 'notes', condition: false }                     // dropped
+ *   { key: 'amount', type: 'euro', tfootRender: '@sum' }, // `type` alias di `dataType`
+ *   { key: 'notes', condition: false }                     // scartata
  * ], dataTypes, params);
  */
 export function parseCols(cols, dataTypes, params) {
@@ -81,7 +81,7 @@ export function parseCols(cols, dataTypes, params) {
         throw new Error(`[json-table] colonna #${idx} (${col.key}): dataType \`${dataType}\` non definito`);
       }
 
-      // `type` is only an alias of `dataType`: dropped from the merged definition
+      // `type` è solo un alias di `dataType`: eliminato dalla definizione unita
       const colProps = { ...col };
       delete colProps.type;
 

package/src/web-components/json-table/src/parse-rows.js

@@ -6,22 +6,22 @@ import { getNestedValue } from './content-utils.js';
 /** @typedef {import('./parse-cols.js').ParsedCol} ParsedCol */
 
 /**
- * A data row with the values precomputed for sorting and searching.
+ * Una riga di dati con i valori precalcolati per ordinamento e ricerca.
  * @typedef {Object} ParsedRow
- * @property {number} idx - Index of the row in the original data set
- * @property {Object} row - The original row object
- * @property {Object<string, *>} sortValues - Sort value of every sortable column, keyed by column key
- * @property {string} searchText - Lowercased concatenation of the search values of the searchable columns
+ * @property {number} idx - Indice della riga nell'insieme di dati originale
+ * @property {Object} row - L'oggetto riga originale
+ * @property {Object<string, *>} sortValues - Valore di ordinamento di ogni colonna ordinabile, indicizzato per chiave della colonna
+ * @property {string} searchText - Concatenazione in minuscolo dei valori di ricerca delle colonne ricercabili
  */
 
 /**
- * Resolves the sort/search value of a cell: column-level value or function `row => value`
- * (when defined) → data type function `(value, row, params) => value` → raw value.
- * @param {*} colValue - Column `sortValue`/`searchValue` (undefined = not set)
- * @param {((value: *, row: Object, params: JsonTableParams) => *)|undefined} typeFn - Data type function
- * @param {*} value - Raw cell value
- * @param {Object} row - Row object
- * @param {JsonTableParams} params - Resolved params
+ * Risolve il valore di ordinamento/ricerca di una cella: valore a livello di colonna o funzione `row => value`
+ * (se definito) → funzione del data type `(value, row, params) => value` → valore grezzo.
+ * @param {*} colValue - `sortValue`/`searchValue` della colonna (undefined = non impostato)
+ * @param {((value: *, row: Object, params: JsonTableParams) => *)|undefined} typeFn - Funzione del data type
+ * @param {*} value - Valore grezzo della cella
+ * @param {Object} row - Oggetto riga
+ * @param {JsonTableParams} params - Parametri risolti
  * @returns {*}
  */
 function resolveValue(colValue, typeFn, value, row, params) {
@@ -36,12 +36,12 @@ function resolveValue(colValue, typeFn, value, row, params) {
 
 
 /**
- * Precomputes, for every row, the values used by sorting and searching, so that they are
- * calculated once and not on every sort/search operation (see `sorting.js` and `search.js`).
+ * Precalcola, per ogni riga, i valori usati da ordinamento e ricerca, così che vengano
+ * calcolati una sola volta e non a ogni operazione di ordinamento/ricerca (vedi `sorting.js` e `search.js`).
  *
- * @param {Array<Object>} rows - Raw data rows
- * @param {ParsedCol[]} cols - Parsed columns (see `parse-cols.js`)
- * @param {JsonTableParams} params - Resolved params
+ * @param {Array<Object>} rows - Righe di dati grezze
+ * @param {ParsedCol[]} cols - Colonne analizzate (vedi `parse-cols.js`)
+ * @param {JsonTableParams} params - Parametri risolti
  * @returns {ParsedRow[]}
  *
  * @example

package/src/web-components/json-table/src/resolve-params.js

@@ -1,11 +1,11 @@
 /*! minimo - json-table: params resolution */
 
-import { defaults, mergedParams } from './defaults.js';
+import { defaults, mergedParams, jqDatatableModeDefaults } from './defaults.js';
 
 /** @typedef {import('./defaults.js').JsonTableParams} JsonTableParams */
 
 /**
- * Whether `value` is a plain object (not null, not an array).
+ * Indica se `value` è un oggetto semplice (non null, non un array).
  * @param {*} value
  * @returns {value is Object<string, *>}
  */
@@ -15,25 +15,25 @@ function isPlainObject(value) {
 
 
 /**
- * Reads and parses an HTML attribute of the `<json-table>` element.
+ * Legge e analizza un attributo HTML dell'elemento `<json-table>`.
  *
- * - booleans are auto-parsed when the built-in default is a boolean
+ * - i booleani vengono convertiti automaticamente quando il default predefinito è un booleano
  *   (`search`, `search="true"`, `search="1"` → true; `search="false"`, `search="0"` → false)
- * - numbers are auto-parsed when the built-in default is a number (`perpage="10"` → 10; a
- *   non-numeric value is reported in the console and treated as a missing attribute)
- * - values starting with `[` or `{` are parsed as JSON (invalid JSON is reported in the
- *   console and treated as a missing attribute)
- * - every other value is returned as a string
+ * - i numeri vengono convertiti automaticamente quando il default predefinito è un numero (`perpage="10"` → 10; un
+ *   valore non numerico viene segnalato in console e trattato come attributo mancante)
+ * - i valori che iniziano con `[` o `{` vengono letti come JSON (un JSON non valido viene segnalato in
+ *   console e trattato come attributo mancante)
+ * - ogni altro valore viene restituito come stringa
  *
- * @param {HTMLElement} el - The `<json-table>` element
- * @param {keyof JsonTableParams} name - Parameter name (attribute names are case-insensitive)
- * @returns {*} The parsed value, or `undefined` when the attribute is missing or invalid
+ * @param {HTMLElement} el - L'elemento `<json-table>`
+ * @param {keyof JsonTableParams} name - Nome del parametro (i nomi degli attributi non distinguono maiuscole e minuscole)
+ * @returns {*} Il valore analizzato, oppure `undefined` quando l'attributo è mancante o non valido
  *
  * @example
  * // <json-table search="false" cols='[{"key":"id"}]'></json-table>
  * readAttr(el, 'search'); // → false
  * readAttr(el, 'cols');   // → [{ key: 'id' }]
- * readAttr(el, 'perPage'); // → 10 (from perpage="10")
+ * readAttr(el, 'perPage'); // → 10 (da perpage="10")
  * readAttr(el, 'caption'); // → undefined
  */
 export function readAttr(el, name) {
@@ -47,7 +47,7 @@ export function readAttr(el, name) {
 
   if (typeof defaults[name] === 'boolean') {
     const lower = trimmed.toLowerCase();
-    // empty string = attribute present without value → true (standard HTML)
+    // stringa vuota = attributo presente senza valore → true (HTML standard)
     return lower !== 'false' && lower !== '0';
   }
 
@@ -76,38 +76,38 @@ export function readAttr(el, name) {
 
 
 /**
- * Resolves a single parameter, merging the four possible sources.
+ * Risolve un singolo parametro, unendo le quattro possibili sorgenti.
  *
- * Precedence (highest first):
- * 1. `config` – value passed via `init()`/`reload()`. Present and `!== undefined` always wins;
- *    pass `null` explicitly to skip the HTML attribute and fall back to the defaults.
- * 2. HTML attribute (see `readAttr`).
- * 3. `projectDefaults` – values set via `JsonTable.setDefaults()`.
- * 4. Built-in default (see `defaults.js`).
+ * Precedenza (dalla più alta):
+ * 1. `config` – valore passato tramite `init()`/`reload()`. Se presente e `!== undefined` vince sempre;
+ *    passare `null` esplicitamente per saltare l'attributo HTML e ripiegare sui default.
+ * 2. Attributo HTML (vedi `readAttr`).
+ * 3. `projectDefaults` – valori impostati con `JsonTable.setDefaults()`.
+ * 4. Default predefinito (vedi `defaults.js`).
  *
- * Object params listed in `mergedParams` (`classes`, `labels`, `dataTypes`, `serverParams`) are shallow-merged
- * across the sources instead of being replaced, so every source only needs the keys to override.
+ * I parametri oggetto elencati in `mergedParams` (`classes`, `labels`, `dataTypes`, `serverParams`) vengono uniti in modo
+ * superficiale tra le sorgenti invece di essere sostituiti, così ogni sorgente deve indicare solo le chiavi da sovrascrivere.
  *
- * @param {HTMLElement} el - The `<json-table>` element (source of the HTML attributes)
- * @param {Partial<JsonTableParams>|null} config - Config passed via `init()` (default: null)
- * @param {Partial<JsonTableParams>} projectDefaults - Project-wide defaults (default: {})
- * @param {keyof JsonTableParams} name - Parameter name
- * @returns {*} The resolved value
+ * @param {HTMLElement} el - L'elemento `<json-table>` (sorgente degli attributi HTML)
+ * @param {Partial<JsonTableParams>|null} config - Configurazione passata tramite `init()` (default: null)
+ * @param {Partial<JsonTableParams>} projectDefaults - Default a livello di progetto (default: {})
+ * @param {keyof JsonTableParams} name - Nome del parametro
+ * @returns {*} Il valore risolto
  *
  * @example
  * // <json-table jsonurl="/api/rows.json" search="false" classes='{"table":"table"}'></json-table>
  * getParam(el, { jsonUrl: '/api/other.json' }, {}, 'jsonUrl'); // → '/api/other.json' (config)
- * getParam(el, null, {}, 'search');                             // → false (attribute)
- * getParam(el, null, { tableId: 'tbl' }, 'tableId');            // → 'tbl' (project defaults)
- * getParam(el, null, {}, 'locale');                             // → 'it-IT' (built-in default)
+ * getParam(el, null, {}, 'search');                             // → false (attributo)
+ * getParam(el, null, { tableId: 'tbl' }, 'tableId');            // → 'tbl' (default di progetto)
+ * getParam(el, null, {}, 'locale');                             // → 'it-IT' (default predefinito)
  * getParam(el, { classes: { sortBtn: 'btn' } }, {}, 'classes');
- * // → { ...defaults.classes, table: 'table', sortBtn: 'btn' } (merged)
+ * // → { ...defaults.classes, table: 'table', sortBtn: 'btn' } (unito)
  */
 export function getParam(el, config = null, projectDefaults = {}, name) {
 
   const configValue = config ? config[name] : undefined;
 
-  // merged object params: built-in ← project ← attribute ← config
+  // parametri oggetto uniti: predefinito ← progetto ← attributo ← config
   if (mergedParams.includes(name)) {
     const builtIn = /** @type {Object<string, *>} */ (defaults[name]);
     const projectValue = projectDefaults[name];
@@ -120,34 +120,37 @@ export function getParam(el, config = null, projectDefaults = {}, name) {
     };
   }
 
-  // 1. config from script (undefined = key not present → go down one level)
+  // 1. config dallo script (undefined = chiave non presente → scende di un livello)
   if (configValue !== undefined) {
     return configValue;
   }
 
-  // 2. HTML attribute
+  // 2. attributo HTML
   const attrValue = readAttr(el, name);
   if (attrValue !== undefined) {
     return attrValue;
   }
 
-  // 3. project defaults
+  // 3. default di progetto
   if (projectDefaults[name] !== undefined) {
     return projectDefaults[name];
   }
 
-  // 4. built-in default
+  // 4. default predefinito
   return defaults[name];
 }
 
 
 /**
- * Resolves every parameter defined in `defaults.js` (see `getParam` for the precedence rules).
+ * Risolve ogni parametro definito in `defaults.js` (vedi `getParam` per le regole di precedenza).
  *
- * @param {HTMLElement} el - The `<json-table>` element
- * @param {Partial<JsonTableParams>|null} [config=null] - Config passed via `init()` (default: null)
+ * Con `jqDatatableMode` true, `jqDatatableModeDefaults` si inserisce tra i default predefiniti e quelli di progetto:
+ * restano quindi prioritari `setDefaults()`, attributi HTML e `init()`.
+ *
+ * @param {HTMLElement} el - L'elemento `<json-table>`
+ * @param {Partial<JsonTableParams>|null} [config=null] - Configurazione passata tramite `init()` (default: null)
  * @param {Partial<JsonTableParams>} [projectDefaults={}] - Project-wide defaults (default: {})
- * @returns {JsonTableParams} The complete params object
+ * @returns {JsonTableParams} L'oggetto completo dei parametri
  *
  * @example
  * const params = resolveParams(el, { jsonUrl: '/api/rows.json', debug: true }, {});
@@ -155,6 +158,15 @@ export function getParam(el, config = null, projectDefaults = {}, name) {
  */
 export function resolveParams(el, config = null, projectDefaults = {}) {
 
+  // con `jqDatatableMode` i default di modalità si inseriscono sotto quelli di progetto (che restano prioritari)
+  if (getParam(el, config, projectDefaults, 'jqDatatableMode') === true) {
+    projectDefaults = {
+      ...jqDatatableModeDefaults,
+      ...projectDefaults,
+      serverParams: { ...jqDatatableModeDefaults.serverParams, ...projectDefaults.serverParams }
+    };
+  }
+
   const params = Object.fromEntries(
     Object.keys(defaults).map(name => [
       name,

package/src/web-components/json-table/src/search.js

@@ -4,7 +4,7 @@
 /** @typedef {import('./parse-rows.js').ParsedRow} ParsedRow */
 
 /**
- * Normalizes a search term: trimmed, lowercased, split into words (whitespace separated).
+ * Normalizza un termine di ricerca: senza spazi ai bordi, in minuscolo, diviso in parole (separate da spazi).
  * @param {string|null|undefined} term
  * @returns {string[]}
  *
@@ -18,16 +18,16 @@ export function searchWords(term) {
 
 
 /**
- * Filters the parsed rows by a search term: every word of the term must be contained in the
- * row `searchText` (precomputed by `parse-rows.js` from the searchable columns; case-insensitive).
- * An empty term returns the original array.
+ * Filtra le righe analizzate per un termine di ricerca: ogni parola del termine deve essere contenuta nel
+ * `searchText` della riga (precalcolato da `parse-rows.js` dalle colonne ricercabili; senza distinzione tra maiuscole e minuscole).
+ * Un termine vuoto restituisce l'array originale.
  *
- * @param {ParsedRow[]} rows - Parsed rows
- * @param {string} term - Search term
+ * @param {ParsedRow[]} rows - Righe analizzate
+ * @param {string} term - Termine di ricerca
  * @returns {ParsedRow[]}
  *
  * @example
- * filterRows(state.rows, 'mario 2024'); // rows whose searchText contains both 'mario' and '2024'
+ * filterRows(state.rows, 'mario 2024'); // righe il cui searchText contiene sia 'mario' sia '2024'
  * filterRows(state.rows, '');           // → state.rows
  */
 export function filterRows(rows, term) {
@@ -43,16 +43,16 @@ export function filterRows(rows, term) {
 
 
 /**
- * Attaches the `input` listener to the search input (`elements.searchInput`, when present):
- * the search is executed through `jt.setSearch()` after `params.searchDebounce` milliseconds
- * from the last keystroke. The pending timer id is stored in `jt._searchTimer` so that
- * `destroy()` can clear it.
+ * Collega il listener `input` all'input di ricerca (`elements.searchInput`, quando presente):
+ * la ricerca viene eseguita tramite `jt.setSearch()` dopo `params.searchDebounce` millisecondi
+ * dall'ultima pressione di un tasto. L'id del timer in sospeso viene memorizzato in `jt._searchTimer` così che
+ * `destroy()` possa cancellarlo.
  *
- * @param {JsonTable} jt - The component instance
+ * @param {JsonTable} jt - L'istanza del componente
  * @returns {void}
  *
  * @example
- * setSearchListener(jt); // after mainBuilder(jt)
+ * setSearchListener(jt); // dopo mainBuilder(jt)
  */
 export function setSearchListener(jt) {
 

package/src/web-components/json-table/src/sorting.js

@@ -4,7 +4,7 @@
 /** @typedef {'asc'|'desc'} SortDir */
 
 /**
- * Whether a sort value counts as "empty" (sorted last in both directions).
+ * Indica se un valore di ordinamento conta come "vuoto" (ordinato per ultimo in entrambe le direzioni).
  * @param {*} value
  * @returns {boolean}
  */
@@ -13,7 +13,7 @@ function isEmpty(value) {
 }
 
 /**
- * Whether a value is a number or a numeric string.
+ * Indica se un valore è un numero o una stringa numerica.
  * @param {*} value
  * @returns {boolean}
  */
@@ -26,20 +26,20 @@ function isNumeric(value) {
 
 
 /**
- * Compares two sort values in ascending order: empty values (`null`, `undefined`, `''`, `NaN`)
- * always last, numbers (and numeric strings, when both are numeric) numerically, booleans as
- * 0/1, everything else as strings via `localeCompare` (numeric collation, accent/case insensitive).
+ * Confronta due valori di ordinamento in ordine crescente: i valori vuoti (`null`, `undefined`, `''`, `NaN`)
+ * sempre per ultimi, i numeri (e le stringhe numeriche, quando entrambi sono numerici) in modo numerico, i booleani come
+ * 0/1, tutto il resto come stringhe tramite `localeCompare` (collazione numerica, senza distinzione di accenti/maiuscole).
  *
  * @param {*} a
  * @param {*} b
- * @param {string} [locale] - Locale used by `localeCompare` (default: browser default)
- * @returns {number} Negative when `a` comes first, positive when `b` comes first, 0 when equal
+ * @param {string} [locale] - Locale usato da `localeCompare` (default: quello del browser)
+ * @returns {number} Negativo quando `a` viene prima, positivo quando `b` viene prima, 0 quando sono uguali
  *
  * @example
- * compareValues(2, 10);                  // → negative
- * compareValues('file10', 'file2');      // → positive (numeric collation)
+ * compareValues(2, 10);                  // → negativo
+ * compareValues('file10', 'file2');      // → positivo (collazione numerica)
  * compareValues('à', 'b', 'it-IT');      // → negative
- * compareValues(null, 'a');              // → positive (empty values last)
+ * compareValues(null, 'a');              // → positivo (valori vuoti per ultimi)
  */
 export function compareValues(a, b, locale) {
 
@@ -63,14 +63,14 @@ export function compareValues(a, b, locale) {
 
 
 /**
- * Returns a sorted copy of the parsed rows, by the precomputed `sortValues[key]` of every row.
- * The sort is stable, so rows with equal values keep their original order.
+ * Restituisce una copia ordinata delle righe analizzate, in base al `sortValues[key]` precalcolato di ogni riga.
+ * L'ordinamento è stabile, quindi le righe con valori uguali mantengono l'ordine originale.
  *
- * @param {ParsedRow[]} rows - Parsed rows (see `parse-rows.js`)
- * @param {string} key - Column key
- * @param {SortDir} dir - Direction
- * @param {string} [locale] - Locale used to compare strings
- * @returns {ParsedRow[]} A new array
+ * @param {ParsedRow[]} rows - Righe analizzate (vedi `parse-rows.js`)
+ * @param {string} key - Chiave della colonna
+ * @param {SortDir} dir - Direzione
+ * @param {string} [locale] - Locale usato per confrontare le stringhe
+ * @returns {ParsedRow[]} Un nuovo array
  *
  * @example
  * sortRows(state.rows, 'amount', 'desc', 'it-IT');
@@ -83,16 +83,16 @@ export function sortRows(rows, key, dir, locale) {
     const va = a.sortValues[key];
     const vb = b.sortValues[key];
     const cmp = compareValues(va, vb, locale);
-    // empty values stay last regardless of the direction
+    // i valori vuoti restano per ultimi indipendentemente dalla direzione
     return (isEmpty(va) || isEmpty(vb)) ? cmp : cmp * sign;
   });
 }
 
 
 /**
- * Next direction in the sort cycle of a column button: none → `asc` → `desc` → none.
+ * Direzione successiva nel ciclo di ordinamento del pulsante di una colonna: nessuna → `asc` → `desc` → nessuna.
  *
- * @param {SortDir|null|undefined} current - Current direction of the column (null = not sorted)
+ * @param {SortDir|null|undefined} current - Direzione corrente della colonna (null = non ordinata)
  * @returns {SortDir|null}
  *
  * @example

package/src/web-components/json-table/src/table-body.js

@@ -10,21 +10,21 @@ import { cellContent } from './cell-content.js';
 /** @typedef {import('./parse-rows.js').ParsedRow} ParsedRow */
 
 /**
- * domBuilder item of a body row.
+ * Elemento domBuilder di una riga del body.
  *
- * Cells are created empty by domBuilder (tag, classes, attributes) and filled in the `<tr>`
- * callback, so that the column `render` functions receive both the `tr` and the `td` elements.
- * `trCallback` is invoked last.
+ * Le celle vengono create vuote da domBuilder (tag, classi, attributi) e riempite nella
+ * callback del `<tr>`, così che le funzioni `render` delle colonne ricevano sia l'elemento `tr` sia `td`.
+ * `trCallback` viene invocata per ultima.
  *
- * Generated structure:
+ * Struttura generata:
  * ```
  * tr[data-jt-idx]
  *   td[data-key][cellClass][internalCellClass]           ← cellContent()
- *   th[scope=row][data-key]…                             ← when col.rowHeading is true
+ *   th[scope=row][data-key]…                             ← quando col.rowHeading è true
  * ```
  *
- * @param {ParsedRow} parsed - Parsed row (see `parse-rows.js`)
- * @param {JsonTable} jt - The component instance (`params`, `cols`)
+ * @param {ParsedRow} parsed - Riga analizzata (vedi `parse-rows.js`)
+ * @param {JsonTable} jt - L'istanza del componente (`params`, `cols`)
  * @returns {DomBuilderItem}
  *
  * @example
@@ -69,15 +69,15 @@ export function rowItem(parsed, jt) {
 
 
 /**
- * Renders the rows of the current page (`state.pageRows`) inside `elements.tbody`, replacing
- * the previous content. When there are no rows, a single cell spanning every column shows
- * `labels.noResults` (search active) or `labels.noRows`.
+ * Renderizza le righe della pagina corrente (`state.pageRows`) dentro `elements.tbody`, sostituendo
+ * il contenuto precedente. Quando non ci sono righe, una singola cella che si estende su tutte le colonne mostra
+ * `labels.noResults` (ricerca attiva) oppure `labels.noRows`.
  *
- * @param {JsonTable} jt - The component instance
+ * @param {JsonTable} jt - L'istanza del componente
  * @returns {void}
  *
  * @example
- * renderTbody(jt); // after `jt.state` has been updated
+ * renderTbody(jt); // dopo l'aggiornamento di `jt.state`
  */
 export function renderTbody(jt) {