@massimo-cassandro/minimo 1.41.4 → 1.41.5

package/src/web-components/json-table/src/get-data.js

@@ -4,28 +4,30 @@
 /** @typedef {import('./defaults.js').SortDef} SortDef */
 
 /**
- * Result of `getData()`.
+ * Risultato di `getData()`.
  * @typedef {Object} DataResult
- * @property {Array<Object>} rows - The rows array (the requested page only, in server-side mode)
- * @property {number} totRec - Total number of records: the numeric value of `params.totRecField` in the
- *   fetched JSON, `rows.length` otherwise
- * @property {number} filteredRec - Number of records matching the current search: the numeric value of
- *   `params.filteredRecField` in the fetched JSON (server-side mode), `totRec` otherwise
+ * @property {Array<Object>} rows - L'array delle righe (solo la pagina richiesta, in modalità server-side)
+ * @property {number} totRec - Numero totale di record: il valore numerico di `params.totRecField` nel
+ *   JSON recuperato, altrimenti `rows.length`
+ * @property {number} filteredRec - Numero di record che corrispondono alla ricerca corrente: il valore numerico di
+ *   `params.filteredRecField` nel JSON recuperato (modalità server-side), altrimenti `totRec`
  */
 
 /**
- * State of the request in server-side mode.
+ * Stato della richiesta in modalità server-side.
  * @typedef {Object} ServerRequest
- * @property {number} page - Requested page (1-based)
- * @property {number} perPage - Rows per page
- * @property {SortDef|null} sort - Active sort, or null
- * @property {string} search - Search term ('' = none)
+ * @property {number} page - Pagina richiesta (da 1)
+ * @property {number} perPage - Righe per pagina
+ * @property {SortDef|null} sort - Ordinamento attivo, oppure null
+ * @property {string} search - Termine di ricerca ('' = nessuno)
+ * @property {Array<{key: string, searchable: boolean, sortable: boolean}>} [cols] - Colonne visualizzate (già analizzate);
+ *   usate solo con `jqDatatableMode` per inviare `columns[i][...]` e l'indice della colonna ordinata
  */
 
 /**
- * Reads a numeric field of the fetched JSON; `undefined` when missing or not numeric.
- * @param {*} json - Fetched JSON
- * @param {string|null|undefined} field - Key to read
+ * Legge un campo numerico del JSON recuperato; `undefined` se mancante o non numerico.
+ * @param {*} json - JSON recuperato
+ * @param {string|null|undefined} field - Chiave da leggere
  * @returns {number|undefined}
  */
 function numericField(json, field) {
@@ -39,13 +41,16 @@ function numericField(json, field) {
 
 
 /**
- * Builds the URL of a server-side request: `params.jsonUrl` plus the query string parameters
- * named in `params.serverParams` (parameters set to `null` are omitted; `sort`/`dir` are sent
- * only when a sort is active, `search` only when not empty). Existing query string parameters
- * of `jsonUrl` are preserved.
+ * Costruisce l'URL di una richiesta server-side: `params.jsonUrl` più i parametri della query string
+ * indicati in `params.serverParams` (i parametri impostati a `null` vengono omessi; `sort`/`dir` vengono inviati
+ * solo quando è attivo un ordinamento, `search` solo quando non è vuoto). I parametri della query string
+ * già presenti in `jsonUrl` vengono conservati.
  *
- * @param {JsonTableParams} params - Resolved params
- * @param {ServerRequest} request - Request state
+ * Con `params.jqDatatableMode` e `request.cols` vengono inviati anche, come fa jQuery DataTables, `draw=1`,
+ * `columns[i][name|searchable|orderable]` e, per `sort`, l'indice della colonna al posto della sua chiave.
+ *
+ * @param {JsonTableParams} params - Parametri risolti
+ * @param {ServerRequest} request - Stato della richiesta
  * @returns {string}
  *
  * @example
@@ -60,7 +65,7 @@ export function buildServerUrl(params, request) {
   const url = new URL(String(params.jsonUrl), document.baseURI);
   const names = params.serverParams ?? {};
 
-  /** @type {(name: string|null|undefined, value: string|number|null|undefined) => void} */
+  /** @type {(name: string|null|undefined, value: string|number|boolean|null|undefined) => void} */
   const set = (name, value) => {
     if (name && value != null && value !== '') {
       url.searchParams.set(name, String(value));
@@ -70,7 +75,19 @@ export function buildServerUrl(params, request) {
   set(names.page, request.page);
   set(names.start, (request.page - 1) * request.perPage);
   set(names.perPage, request.perPage);
-  set(names.sort, request.sort?.key);
+  const jqCols = params.jqDatatableMode ? request.cols : null;
+  if (jqCols) {
+    set('draw', 1);
+    jqCols.forEach((col, idx) => {
+      set(`columns[${idx}][name]`, col.key);
+      set(`columns[${idx}][searchable]`, col.searchable);
+      set(`columns[${idx}][orderable]`, col.sortable);
+    });
+  }
+
+  set(names.sort, jqCols && request.sort
+    ? jqCols.findIndex(col => col.key === request.sort?.key)
+    : request.sort?.key);
   set(names.dir, request.sort ? request.sort.dir : null);
   set(names.search, request.search);
 
@@ -79,34 +96,34 @@ export function buildServerUrl(params, request) {
 
 
 /**
- * Retrieves the rows array from the configured source.
+ * Recupera l'array delle righe dalla sorgente configurata.
  *
- * `data` takes precedence over `jsonUrl`. With `jsonUrl` the JSON is fetched and the rows are
- * read from the `jsonDataField` key (`null`/`''` = the JSON root is the array itself); when the
- * JSON also holds a numeric `totRecField` key, it is returned as `totRec`, otherwise `totRec` is
- * the rows array length. In server-side mode (`request` given) the URL carries the pagination /
- * sort / search parameters (see `buildServerUrl`) and `filteredRecField` is read too.
- * Returns `null` when no source is configured.
+ * `data` ha la precedenza su `jsonUrl`. Con `jsonUrl` il JSON viene recuperato e le righe vengono
+ * lette dalla chiave `jsonDataField` (`null`/`''` = la radice del JSON è l'array stesso); quando il
+ * JSON contiene anche una chiave numerica `totRecField`, viene restituita come `totRec`, altrimenti `totRec` è
+ * la lunghezza dell'array delle righe. In modalità server-side (`request` indicato) l'URL porta i parametri di paginazione /
+ * ordinamento / ricerca (vedi `buildServerUrl`) e viene letto anche `filteredRecField`.
+ * Restituisce `null` quando non è configurata alcuna sorgente.
  *
- * @param {JsonTableParams} params - Resolved params (see `resolve-params.js`)
- * @param {ServerRequest|null} [request=null] - Server-side request state; `null` for a plain request (default: null)
- * @returns {Promise<DataResult|null>} Rows and totals, or `null` when neither `data` nor `jsonUrl` is set
- * @throws {Error} When `data` is not an array, on HTTP/network errors, or when the fetched JSON
- *   does not contain an array at `jsonDataField`
+ * @param {JsonTableParams} params - Parametri risolti (vedi `resolve-params.js`)
+ * @param {ServerRequest|null} [request=null] - Stato della richiesta server-side; `null` per una richiesta semplice (default: null)
+ * @returns {Promise<DataResult|null>} Righe e totali, oppure `null` quando non sono impostati né `data` né `jsonUrl`
+ * @throws {Error} Quando `data` non è un array, in caso di errori HTTP/di rete, oppure quando il JSON recuperato
+ *   non contiene un array in `jsonDataField`
  *
  * @example
- * // inline data (jsonUrl ignored)
+ * // dati inline (jsonUrl ignorato)
  * await getData({ ...params, data: [{ id: 1 }], jsonUrl: '/ignored.json' });
  * // → { rows: [{ id: 1 }], totRec: 1, filteredRec: 1 }
  *
- * // fetched JSON: { data: [...], totRec: 1500 }  (jsonDataField default: 'data', totRecField default: 'totRec')
+ * // JSON recuperato: { data: [...], totRec: 1500 }  (jsonDataField default: 'data', totRecField default: 'totRec')
  * await getData({ ...params, jsonUrl: '/api/rows.json' });
  *
- * // fetched JSON whose root is the array itself
+ * // JSON recuperato la cui radice è l'array stesso
  * await getData({ ...params, jsonUrl: '/api/rows.json', jsonDataField: null });
  *
  * // server-side: GET /api/rows.json?page=2&start=25&perPage=25&search=mar
- * // expected JSON: { data: [...25 rows], totRec: 1500, filteredRec: 40 }
+ * // JSON atteso: { data: [...25 righe], totRec: 1500, filteredRec: 40 }
  * await getData({ ...params, jsonUrl: '/api/rows.json', serverSide: true }, { page: 2, perPage: 25, sort: null, search: 'mar' });
  */
 export async function getData(params, request = null) {

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

@@ -10,41 +10,41 @@ import caretRight from '../../../icons/caret-right.svg?inline';
 
 /** @typedef {import('./defaults.js').IconDef} IconDef */
 
-/** Default icon of `true` values (minimo `check-bold`, inline SVG markup) */
+/** Icona predefinita dei valori `true` (`check-bold` di minimo, markup SVG inline) */
 export const boolTrueIcon = checkBold;
-/** Default icon of `false` values (minimo `x-bold`) */
+/** Icona predefinita dei valori `false` (`x-bold` di minimo) */
 export const boolFalseIcon = xBold;
-/** Default sort button icon, ascending sort active (minimo `arrow-up`) */
+/** Icona predefinita del pulsante di ordinamento, ordinamento crescente attivo (`arrow-up` di minimo) */
 export const sortAscArrowIcon = arrowUp;
-/** Default sort button icon, descending sort active (minimo `arrow-down`) */
+/** Icona predefinita del pulsante di ordinamento, ordinamento decrescente attivo (`arrow-down` di minimo) */
 export const sortDescArrowIcon = arrowDown;
-/** Default sort button icon, no sort active (minimo `arrows-down-up`) */
+/** Icona predefinita del pulsante di ordinamento, nessun ordinamento attivo (`arrows-down-up` di minimo) */
 export const sortNoneArrowIcon = arrowsDownUp;
-/** Default previous page button icon (minimo `caret-left`) */
+/** Icona predefinita del pulsante pagina precedente (`caret-left` di minimo) */
 export const paginationPrevIcon = caretLeft;
-/** Default next page button icon (minimo `caret-right`) */
+/** Icona predefinita del pulsante pagina successiva (`caret-right` di minimo) */
 export const paginationNextIcon = caretRight;
 
 /**
- * Markup strings already parsed, keyed by the string itself.
+ * Stringhe di markup già analizzate, indicizzate dalla stringa stessa.
  * @type {Map<string, DocumentFragment>}
  */
 const fragmentCache = new Map();
 
 /**
- * Resolves an icon definition to a content usable by domBuilder (`content`) or `setContent()`.
+ * Risolve la definizione di un'icona in un contenuto utilizzabile da domBuilder (`content`) o da `setContent()`.
  *
- * Markup strings are parsed once through an inert `<template>` and cloned on every call, so the
- * same icon can be inserted in many cells without re-parsing and without going through the HTML
- * sanitizer used by domBuilder for markup strings (icons are developer-supplied configuration,
- * not user data). DOM nodes are cloned too, since a node can live in one place only.
+ * Le stringhe di markup vengono analizzate una sola volta tramite un `<template>` inerte e clonate a ogni chiamata, così che la
+ * stessa icona possa essere inserita in molte celle senza nuova analisi e senza passare dal sanitizer HTML
+ * usato da domBuilder per le stringhe di markup (le icone sono configurazione fornita dallo sviluppatore,
+ * non dati dell'utente). Anche i nodi DOM vengono clonati, dato che un nodo può stare in un solo posto.
  *
- * @param {IconDef|null|undefined} icon - Icon definition (see `IconDef`)
- * @returns {Node|DomBuilderItem[]|null} A fresh node (or domBuilder array), `null` when `icon` is nullish
+ * @param {IconDef|null|undefined} icon - Definizione dell'icona (vedi `IconDef`)
+ * @returns {Node|DomBuilderItem[]|null} Un nodo nuovo (o un array domBuilder), `null` quando `icon` è nullish
  *
  * @example
- * iconContent('<svg …></svg>');                  // → DocumentFragment (clone of the parsed markup)
- * iconContent(document.querySelector('svg'));   // → cloned SVGElement
+ * iconContent('<svg …></svg>');                  // → DocumentFragment (clone del markup analizzato)
+ * iconContent(document.querySelector('svg'));   // → SVGElement clonato
  * iconContent({ tag: 'span', content: '✓' });   // → [{ tag: 'span', content: '✓' }] (domBuilder array)
  * iconContent(() => '<svg …></svg>');           // → DocumentFragment
  * iconContent(null);                            // → null

package/src/web-components/json-table/src/info-section.js

@@ -7,13 +7,13 @@ import { classnames } from '../../../utilities/classnames.js';
 /** @typedef {import('./main-builder.js').JsonTableElements} JsonTableElements */
 
 /**
- * domBuilder item of the info text container (template slot `resultInfo`).
+ * Elemento domBuilder del contenitore del testo informativo (slot del template `resultInfo`).
  *
- * Generated structure: `div.resultInfo[classes.resultInfo][aria-live=polite]`; the content is
- * set by `update-info.js`. The element is stored in `elements.resultInfo`.
+ * Struttura generata: `div.resultInfo[classes.resultInfo][aria-live=polite]`; il contenuto è
+ * impostato da `update-info.js`. L'elemento viene memorizzato in `elements.resultInfo`.
  *
- * @param {JsonTableParams} params - Resolved params
- * @param {JsonTableElements} elements - Object collecting the generated elements (mutated)
+ * @param {JsonTableParams} params - Parametri risolti
+ * @param {JsonTableElements} elements - Oggetto che raccoglie gli elementi generati (modificato)
  * @returns {DomBuilderItem}
  *
  * @example
@@ -30,21 +30,21 @@ export function resultInfoPart(params, elements) {
 
 
 /**
- * domBuilder item of the search input (template slot `search`), rendered only when
- * `params.search` is true.
+ * Elemento domBuilder dell'input di ricerca (slot del template `search`), renderizzato solo quando
+ * `params.search` è true.
  *
- * Generated structure: `div.search[classes.search] > input[type=search][classes.searchInput]`.
- * The input is stored in `elements.searchInput`.
+ * Struttura generata: `div.search[classes.search] > input[type=search][classes.searchInput]`.
+ * L'input viene memorizzato in `elements.searchInput`.
  *
  * TODO listener sull'input di ricerca: step 3
  *
- * @param {JsonTableParams} params - Resolved params
- * @param {JsonTableElements} elements - Object collecting the generated elements (mutated)
+ * @param {JsonTableParams} params - Parametri risolti
+ * @param {JsonTableElements} elements - Oggetto che raccoglie gli elementi generati (modificato)
  * @returns {DomBuilderItem}
  *
  * @example
  * domBuilder([searchPart(params, elements)], host);
- * elements.searchInput; // → HTMLInputElement (when params.search is true)
+ * elements.searchInput; // → HTMLInputElement (quando params.search è true)
  */
 export function searchPart(params, elements) {
   return {
@@ -68,21 +68,21 @@ export function searchPart(params, elements) {
 
 
 /**
- * domBuilder item of the whole info section (template slot `infoSection`): info text + search input.
+ * Elemento domBuilder dell'intera sezione informativa (slot del template `infoSection`): testo informativo + input di ricerca.
  *
- * Generated structure:
+ * Struttura generata:
  * ```
  * div.infoOuter[classes.infoOuter]
  *   div.info[classes.info]
  *     div.resultInfo                       ← resultInfoPart()
- *     div.search > input[type=search]      ← searchPart(), only if `params.search` is true
+ *     div.search > input[type=search]      ← searchPart(), solo se `params.search` è true
  * ```
  *
- * References to the generated elements are stored in `elements`
+ * I riferimenti agli elementi generati vengono memorizzati in `elements`
  * (`infoOuter`, `info`, `resultInfo`, `searchInput`).
  *
- * @param {JsonTableParams} params - Resolved params
- * @param {JsonTableElements} elements - Object collecting the generated elements (mutated)
+ * @param {JsonTableParams} params - Parametri risolti
+ * @param {JsonTableElements} elements - Oggetto che raccoglie gli elementi generati (modificato)
  * @returns {DomBuilderItem}
  *
  * @example

package/src/web-components/json-table/src/main-builder.js

@@ -13,25 +13,25 @@ import { paginationPart } from './pagination.js';
 /** @typedef {import('./defaults.js').TemplateSlot} TemplateSlot */
 
 /**
- * Elements generated by the component, collected during the build.
+ * Elementi generati dal componente, raccolti durante la costruzione.
  * @typedef {Object} JsonTableElements
- * @property {HTMLElement} [wrapper] - Main wrapper (`section`), contains the template parts
- * @property {HTMLElement} [infoOuter] - Outer info container
- * @property {HTMLElement} [info] - Info container (flex row: info text + search)
- * @property {HTMLElement} [resultInfo] - Info text container
- * @property {HTMLInputElement} [searchInput] - Search input (only when `search` is true)
- * @property {HTMLElement} [tableWrapper] - Div wrapping the table (`table-responsive` by default)
- * @property {HTMLTableElement} [table] - The `<table>` element
- * @property {HTMLTableSectionElement} [thead] - The `<thead>` element
- * @property {HTMLTableSectionElement} [tbody] - The `<tbody>` element
- * @property {HTMLTableSectionElement} [tfoot] - The `<tfoot>` element (only when `tfoot` is true)
- * @property {HTMLElement} [tableFooter] - Footer bar below the table (caption + pagination), when rendered
- * @property {HTMLElement} [caption] - Caption container (only when `caption` is set)
- * @property {HTMLElement} [pagination] - Pagination `<nav>` (only when `perPage` > 0)
+ * @property {HTMLElement} [wrapper] - Wrapper principale (`section`), contiene le parti del template
+ * @property {HTMLElement} [infoOuter] - Contenitore esterno delle info
+ * @property {HTMLElement} [info] - Contenitore delle info (riga flex: testo informativo + ricerca)
+ * @property {HTMLElement} [resultInfo] - Contenitore del testo informativo
+ * @property {HTMLInputElement} [searchInput] - Input di ricerca (solo quando `search` è true)
+ * @property {HTMLElement} [tableWrapper] - Div che racchiude la tabella (`table-responsive` di default)
+ * @property {HTMLTableElement} [table] - L'elemento `<table>`
+ * @property {HTMLTableSectionElement} [thead] - L'elemento `<thead>`
+ * @property {HTMLTableSectionElement} [tbody] - L'elemento `<tbody>`
+ * @property {HTMLTableSectionElement} [tfoot] - L'elemento `<tfoot>` (solo quando `tfoot` è true)
+ * @property {HTMLElement} [tableFooter] - Barra del footer sotto la tabella (caption + paginazione), quando renderizzata
+ * @property {HTMLElement} [caption] - Contenitore della caption (solo quando `caption` è impostato)
+ * @property {HTMLElement} [pagination] - `<nav>` della paginazione (solo quando `perPage` > 0)
  */
 
 /**
- * Whether a template item is a slot placeholder.
+ * Indica se un elemento del template è un segnaposto di slot.
  * @param {*} item
  * @returns {item is { slot: TemplateSlot }}
  */
@@ -41,10 +41,10 @@ function isSlot(item) {
 
 
 /**
- * Collects, recursively (`children` and array `content`), the names of the slots used by a template.
+ * Raccoglie, ricorsivamente (`children` e `content` array), i nomi degli slot usati da un template.
  *
- * @param {Array<TemplateItem|string|Node>} items - Template items
- * @param {Set<string>} [found=new Set()] - Accumulator (default: new Set())
+ * @param {Array<TemplateItem|string|Node>} items - Elementi del template
+ * @param {Set<string>} [found=new Set()] - Accumulatore (default: new Set())
  * @returns {Set<string>}
  *
  * @example
@@ -70,17 +70,17 @@ export function collectSlots(items, found = new Set()) {
 
 
 /**
- * Replaces, recursively (`children` and array `content`), every `{ slot: 'name' }` item of a
- * template with the corresponding built-in part. Unknown slots are reported in the console
- * and skipped. Non-slot items are shallow-copied, so the original template is never mutated.
+ * Sostituisce, ricorsivamente (`children` e `content` array), ogni elemento `{ slot: 'name' }` di un
+ * template con la corrispondente parte predefinita. Gli slot sconosciuti vengono segnalati in console
+ * e saltati. Gli elementi non slot vengono copiati in modo superficiale, così il template originale non viene mai modificato.
  *
- * @param {Array<TemplateItem|string|Node>} items - Template items
- * @param {Object<string, DomBuilderItem>} parts - Built-in parts, keyed by slot name
+ * @param {Array<TemplateItem|string|Node>} items - Elementi del template
+ * @param {Object<string, DomBuilderItem>} parts - Parti predefinite, indicizzate per nome dello slot
  * @returns {Array<DomBuilderItem|string|Node>}
  *
  * @example
  * expandSlots([{ className: 'row', children: [{ slot: 'search' }, { slot: 'resultInfo' }] }, { slot: 'table' }], parts);
- * // → [{ className: 'row', children: [<search part>, <resultInfo part>] }, <table part>]
+ * // → [{ className: 'row', children: [<parte search>, <parte resultInfo>] }, <parte table>]
  */
 export function expandSlots(items, parts) {
 
@@ -123,43 +123,43 @@ export function expandSlots(items, parts) {
 
 
 /**
- * Builds the whole component structure inside the host element (emptied first) via domBuilder:
- * a fixed main wrapper whose content is defined by `params.template`.
+ * Costruisce l'intera struttura del componente dentro l'elemento host (svuotato prima) tramite domBuilder:
+ * un wrapper principale fisso il cui contenuto è definito da `params.template`.
  *
- * Available template slots (see `TemplateItem`):
- * - `infoSection` → `infoSectionPart()` (info text + search input)
- * - `resultInfo`  → `resultInfoPart()` (info text only)
- * - `search`      → `searchPart()` (search input only)
- * - `table`       → `tablePart()` (table wrapper + table with thead, tbody, tfoot, plus the footer bar)
- * - `caption`     → `captionPart()` (caption container; part of the `table` footer bar unless placed explicitly)
- * - `pagination`  → `paginationPart()` (pagination nav; idem)
+ * Slot del template disponibili (vedi `TemplateItem`):
+ * - `infoSection` → `infoSectionPart()` (testo informativo + input di ricerca)
+ * - `resultInfo`  → `resultInfoPart()` (solo testo informativo)
+ * - `search`      → `searchPart()` (solo input di ricerca)
+ * - `table`       → `tablePart()` (wrapper della tabella + tabella con thead, tbody, tfoot, più la barra del footer)
+ * - `caption`     → `captionPart()` (contenitore della caption; parte della barra del footer di `table` se non collocato esplicitamente)
+ * - `pagination`  → `paginationPart()` (nav della paginazione; idem)
  *
- * Generated structure with the default template (`[{ slot: 'infoSection' }, { slot: 'table' }]`):
+ * Struttura generata con il template predefinito (`[{ slot: 'infoSection' }, { slot: 'table' }]`):
  * ```
  * section.wrapper[classes.wrapper]
  *   div.infoOuter[classes.infoOuter]
  *     div.info[classes.info]
  *       div.resultInfo
- *       div.search > input[type=search]     (if `search`)
+ *       div.search > input[type=search]     (se `search`)
  *   div.tableOuter
  *     div.tableWrapper[classes.tableWrapper]
  *       table#tableId.table[classes.table]
- *         thead / tbody / tfoot             (tfoot if `tfoot`)
- *     div.tableFooter[classes.tableFooter]  (if `caption` or `perPage` > 0)
- *       div.caption                         (if `caption`)
- *       nav.pagination                      (if `perPage` > 0)
+ *         thead / tbody / tfoot             (tfoot se `tfoot`)
+ *     div.tableFooter[classes.tableFooter]  (se `caption` o `perPage` > 0)
+ *       div.caption                         (se `caption`)
+ *       nav.pagination                      (se `perPage` > 0)
  * ```
  *
- * The `<tbody>`, `<tfoot>` and pagination are created empty: see `renderTbody()`, `renderTfoot()`
- * and `renderPagination()`.
+ * `<tbody>`, `<tfoot>` e paginazione vengono creati vuoti: vedi `renderTbody()`, `renderTfoot()`
+ * e `renderPagination()`.
  *
- * @param {JsonTable} jt - The component instance (host element, `params`, `cols`)
- * @returns {JsonTableElements} References to the generated elements
+ * @param {JsonTable} jt - L'istanza del componente (elemento host, `params`, `cols`)
+ * @returns {JsonTableElements} Riferimenti agli elementi generati
  *
  * @example
  * jt.params.template = [
  *   { className: 'flex gap-2', children: [{ slot: 'search' }, { slot: 'pagination' }] },
- *   { slot: 'table' },   // footer bar with the caption only: the pagination is placed above
+ *   { slot: 'table' },   // barra del footer con la sola caption: la paginazione è collocata sopra
  *   { slot: 'resultInfo' }
  * ];
  * const elements = mainBuilder(jt);
@@ -176,7 +176,7 @@ export function mainBuilder(jt) {
   const captionItem = captionPart(jt, elements, capId);
   const paginationItem = paginationPart(jt, elements);
 
-  // footer bar parts: removed below when the template places them elsewhere
+  // parti della barra del footer: rimosse più sotto quando il template le colloca altrove
   /** @type {DomBuilderItem[]} */
   const footerChildren = [captionItem, paginationItem];
   const footerBar = tableFooterPart(jt, elements, footerChildren);

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

@@ -9,10 +9,10 @@ import { iconContent } from './icons.js';
 /** @typedef {import('./main-builder.js').JsonTableElements} JsonTableElements */
 
 /**
- * Number of pages needed to show `count` rows, `perPage` per page (at least 1).
- * `perPage` <= 0 means no pagination: a single page.
+ * Numero di pagine necessarie per mostrare `count` righe, `perPage` per pagina (almeno 1).
+ * `perPage` <= 0 significa nessuna paginazione: una sola pagina.
  *
- * @param {number} count - Number of rows
+ * @param {number} count - Numero di righe
  * @param {number} perPage - Rows per page
  * @returns {number}
  *
@@ -30,21 +30,21 @@ export function calcTotPages(count, perPage) {
 
 
 /**
- * Builds the list of page numbers to show in the navigation: the current page with `delta`
- * pages on each side (the window is widened near the edges so that it keeps a constant size),
- * plus the first and the last page; `null` marks a gap (ellipsis). When the gap would hide a
- * single page, that page is shown instead of the ellipsis.
+ * Costruisce l'elenco dei numeri di pagina da mostrare nella navigazione: la pagina corrente con `delta`
+ * pagine per lato (la finestra viene allargata vicino ai bordi in modo da mantenere una dimensione costante),
+ * più la prima e l'ultima pagina; `null` indica un salto (puntini di sospensione). Quando il salto nasconderebbe una
+ * sola pagina, viene mostrata quella pagina al posto dei puntini.
  *
- * @param {number} current - Current page (1-based)
- * @param {number} totPages - Total number of pages
- * @param {number} [delta=2] - Pages on each side of the current one (default: 2)
+ * @param {number} current - Pagina corrente (da 1)
+ * @param {number} totPages - Numero totale di pagine
+ * @param {number} [delta=2] - Pagine per lato rispetto alla corrente (default: 2)
  * @returns {Array<number|null>}
  *
  * @example
  * pageList(1, 3);       // → [1, 2, 3]
  * pageList(1, 10);      // → [1, 2, 3, 4, 5, null, 10]
  * pageList(6, 12);      // → [1, null, 4, 5, 6, 7, 8, null, 12]
- * pageList(5, 10);      // → [1, 2, 3, 4, 5, 6, 7, null, 10]  (page 2 shown instead of an ellipsis hiding it alone)
+ * pageList(5, 10);      // → [1, 2, 3, 4, 5, 6, 7, null, 10]  (pagina 2 mostrata al posto dei puntini che la nasconderebbero da sola)
  * pageList(10, 10);     // → [1, null, 6, 7, 8, 9, 10]
  * pageList(4, 10, 1);   // → [1, 2, 3, 4, 5, null, 10]
  */
@@ -60,7 +60,7 @@ export function pageList(current, totPages, delta = 2) {
   let min = Math.max(1, current - side);
   let max = Math.min(totPages, current + side);
 
-  // keep the window size constant near the edges
+  // mantiene costante la dimensione della finestra vicino ai bordi
   while (max - min + 1 < width) {
     if (min > 1) {
       min--;
@@ -95,7 +95,7 @@ export function pageList(current, totPages, delta = 2) {
 
 
 /**
- * Replaces the `{page}` placeholder of a pagination label.
+ * Sostituisce il segnaposto `{page}` di un'etichetta di paginazione.
  * @param {string|undefined} label
  * @param {number} page
  * @param {string} locale
@@ -107,29 +107,29 @@ function pageLabel(label, page, locale) {
 
 
 /**
- * domBuilder item of the pagination `<nav>` (template slot `pagination`), rendered only when
- * `params.perPage` is > 0. The `<nav>` is stored in `elements.pagination` and gets a delegated
- * `click` listener on its buttons, which calls `jt.goToPage()`. The content (page list) is
- * rendered by `renderPagination()` and the whole `<nav>` is hidden when there is a single page.
+ * Elemento domBuilder del `<nav>` della paginazione (slot del template `pagination`), renderizzato solo quando
+ * `params.perPage` è > 0. Il `<nav>` viene memorizzato in `elements.pagination` e riceve un listener
+ * `click` delegato sui suoi pulsanti, che chiama `jt.goToPage()`. Il contenuto (elenco delle pagine) viene
+ * renderizzato da `renderPagination()` e l'intero `<nav>` è nascosto quando c'è una sola pagina.
  *
- * Generated structure (see `renderPagination`):
+ * Struttura generata (vedi `renderPagination`):
  * ```
  * nav.pagination[classes.pagination][aria-label=labels.paginationAriaLabel]
  *   ul.paginationList
  *     li.paginationItem > button.paginationBtn[classes.paginationBtn][data-page=prev][aria-label][title] > icon
  *     li.paginationItem > button.paginationBtn[data-page=1][aria-label="Vai a pagina 1"] 1
- *     li.paginationItem > button.paginationBtn[data-page=2][aria-current=page] 2      ← current page
+ *     li.paginationItem > button.paginationBtn[data-page=2][aria-current=page] 2      ← pagina corrente
  *     li.paginationItem > span.paginationEllipsis …
  *     li.paginationItem > button.paginationBtn[data-page=next] > icon
  * ```
  *
- * @param {JsonTable} jt - The component instance
- * @param {JsonTableElements} elements - Object collecting the generated elements (mutated)
+ * @param {JsonTable} jt - L'istanza del componente
+ * @param {JsonTableElements} elements - Oggetto che raccoglie gli elementi generati (modificato)
  * @returns {DomBuilderItem}
  *
  * @example
  * domBuilder([paginationPart(jt, elements)], host);
- * elements.pagination; // → HTMLElement (nav), when params.perPage > 0
+ * elements.pagination; // → HTMLElement (nav), quando params.perPage > 0
  */
 export function paginationPart(jt, elements) {
 
@@ -162,21 +162,21 @@ export function paginationPart(jt, elements) {
 
 
 /**
- * Renders the page list inside `elements.pagination` from the current state (`page`, `totPages`),
- * replacing the previous content; the `<nav>` is hidden when there is a single page.
+ * Renderizza l'elenco delle pagine dentro `elements.pagination` a partire dallo stato corrente (`page`, `totPages`),
+ * sostituendo il contenuto precedente; il `<nav>` è nascosto quando c'è una sola pagina.
  *
- * When `focusTarget` is given (the `data-page` of the button that triggered the change:
- * `'prev'`, `'next'` or a page number) the focus is moved to the corresponding new button, or
- * to the current page button when that one is no longer available, so that keyboard users do
- * not lose their position.
+ * Quando `focusTarget` è indicato (il `data-page` del pulsante che ha causato il cambio:
+ * `'prev'`, `'next'` o un numero di pagina) il focus viene spostato sul corrispondente nuovo pulsante, oppure
+ * sul pulsante della pagina corrente quando quello non è più disponibile, così che gli utenti da tastiera
+ * non perdano la loro posizione.
  *
- * @param {JsonTable} jt - The component instance
- * @param {string|null} [focusTarget=null] - `data-page` of the button to focus after the rendering (default: null)
+ * @param {JsonTable} jt - L'istanza del componente
+ * @param {string|null} [focusTarget=null] - `data-page` del pulsante a cui dare il focus dopo il rendering (default: null)
  * @returns {void}
  *
  * @example
- * renderPagination(jt);         // after `jt.state` has been updated
- * renderPagination(jt, 'next'); // same, moving the focus to the "next" button
+ * renderPagination(jt);         // dopo l'aggiornamento di `jt.state`
+ * renderPagination(jt, 'next'); // come sopra, spostando il focus sul pulsante "avanti"
  */
 export function renderPagination(jt, focusTarget = null) {