@massimo-cassandro/minimo 1.41.4 → 1.41.6

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

@@ -1,4 +1,4 @@
-/*! minimo - json-table: table part (table, caption and footer bar) */
+/*! minimo - json-table: parte tabella (tabella, caption e barra del footer) */
 
 import * as styles from '../json-table-component.module.css';
 import { classnames } from '../../../utilities/classnames.js';
@@ -8,14 +8,14 @@ import { theadPart } from './table-thead.js';
 /** @typedef {import('../json-table-component.js').JsonTable} JsonTable */
 /** @typedef {import('./main-builder.js').JsonTableElements} JsonTableElements */
 
-/** Counter used to generate unique caption ids */
+/** Contatore usato per generare id univoci delle caption */
 let captionUid = 0;
 
 /**
- * Id of the caption element of a table (used by `aria-labelledby`): `<tableId>-caption`, or a
- * generated unique id when `tableId` is not set.
+ * Id dell'elemento caption di una tabella (usato da `aria-labelledby`): `<tableId>-caption`, oppure un
+ * id univoco generato quando `tableId` non è impostato.
  *
- * @param {JsonTableParams} params - Resolved params
+ * @param {JsonTableParams} params - Parametri risolti
  * @returns {string}
  *
  * @example
@@ -28,21 +28,21 @@ export function captionId(params) {
 
 
 /**
- * domBuilder item of the caption (template slot `caption`), rendered only when `params.caption`
- * is set. It is a plain container placed below the table (footer bar) instead of a `<caption>`
- * element: the table is linked to it through `aria-labelledby`, which gives the table the same
- * accessible name a `<caption>` would.
+ * Elemento domBuilder della caption (slot del template `caption`), renderizzato solo quando `params.caption`
+ * è impostato. È un semplice contenitore collocato sotto la tabella (barra del footer) invece di un elemento
+ * `<caption>`: la tabella è collegata a esso tramite `aria-labelledby`, che dà alla tabella lo stesso
+ * nome accessibile che avrebbe con un `<caption>`.
  *
- * Generated structure: `div.caption[classes.caption]#<id>`; the element is stored in `elements.caption`.
+ * Struttura generata: `div.caption[classes.caption]#<id>`; l'elemento viene memorizzato in `elements.caption`.
  *
- * @param {JsonTable} jt - The component instance
- * @param {JsonTableElements} elements - Object collecting the generated elements (mutated)
- * @param {string} id - Id of the element (see `captionId`)
+ * @param {JsonTable} jt - L'istanza del componente
+ * @param {JsonTableElements} elements - Oggetto che raccoglie gli elementi generati (modificato)
+ * @param {string} id - Id dell'elemento (vedi `captionId`)
  * @returns {DomBuilderItem}
  *
  * @example
  * domBuilder([captionPart(jt, elements, 'users-caption')], host);
- * elements.caption; // → HTMLElement (when params.caption is set)
+ * elements.caption; // → HTMLElement (quando params.caption è impostato)
  */
 export function captionPart(jt, elements, id) {
 
@@ -59,16 +59,16 @@ export function captionPart(jt, elements, id) {
 
 
 /**
- * domBuilder item of the footer bar below the table: caption (start side) and pagination (end
- * side). Rendered only when `children` is not empty (see `mainBuilder`, which removes the parts
- * placed elsewhere by the template).
+ * Elemento domBuilder della barra del footer sotto la tabella: caption (lato iniziale) e paginazione (lato
+ * finale). Renderizzato solo quando `children` non è vuoto (vedi `mainBuilder`, che rimuove le parti
+ * collocate altrove dal template).
  *
- * Generated structure: `div.tableFooter[classes.tableFooter] > [caption] [pagination]`; the element
- * is stored in `elements.tableFooter`.
+ * Struttura generata: `div.tableFooter[classes.tableFooter] > [caption] [pagination]`; l'elemento
+ * viene memorizzato in `elements.tableFooter`.
  *
- * @param {JsonTable} jt - The component instance
- * @param {JsonTableElements} elements - Object collecting the generated elements (mutated)
- * @param {DomBuilderItem[]} children - Footer parts (caption and/or pagination items)
+ * @param {JsonTable} jt - L'istanza del componente
+ * @param {JsonTableElements} elements - Oggetto che raccoglie gli elementi generati (modificato)
+ * @param {DomBuilderItem[]} children - Parti del footer (elementi caption e/o paginazione)
  * @returns {DomBuilderItem}
  *
  * @example
@@ -89,30 +89,30 @@ export function tableFooterPart(jt, elements, children) {
 
 
 /**
- * domBuilder item of the table (template slot `table`).
+ * Elemento domBuilder della tabella (slot del template `table`).
  *
  * Generated structure:
  * ```
  * div.tableWrapper[classes.tableWrapper]
- *   table#tableId.table[classes.table][aria-labelledby=<caption id>]   (aria-labelledby if `caption`)
+ *   table#tableId.table[classes.table][aria-labelledby=<caption id>]   (aria-labelledby se `caption`)
  *     thead                     ← theadPart()
- *     tbody                     ← filled by `renderTbody()`
- *     tfoot                     (if `tfoot`) ← filled by `renderTfoot()`
- * div.tableFooter               ← footerBar (caption + pagination), if given
+ *     tbody                     ← riempito da `renderTbody()`
+ *     tfoot                     (se `tfoot`) ← riempito da `renderTfoot()`
+ * div.tableFooter               ← footerBar (caption + paginazione), se indicata
  * ```
  *
- * References to the generated elements are stored in `elements`
+ * I riferimenti agli elementi generati vengono memorizzati in `elements`
  * (`tableWrapper`, `table`, `thead`, `tbody`, `tfoot`).
  *
- * @param {JsonTable} jt - The component instance (`params`, `cols`)
- * @param {JsonTableElements} elements - Object collecting the generated elements (mutated)
- * @param {DomBuilderItem|null} [footerBar=null] - Footer bar item (see `tableFooterPart`) (default: null)
- * @param {string|null} [captionElId=null] - Id of the caption element, for `aria-labelledby` (default: null)
- * @returns {DomBuilderItem} A `div` wrapping the table wrapper and the footer bar
+ * @param {JsonTable} jt - L'istanza del componente (`params`, `cols`)
+ * @param {JsonTableElements} elements - Oggetto che raccoglie gli elementi generati (modificato)
+ * @param {DomBuilderItem|null} [footerBar=null] - Elemento della barra del footer (vedi `tableFooterPart`) (default: null)
+ * @param {string|null} [captionElId=null] - Id dell'elemento caption, per `aria-labelledby` (default: null)
+ * @returns {DomBuilderItem} Un `div` che racchiude il wrapper della tabella e la barra del footer
  *
  * @example
  * domBuilder([tablePart(jt, elements, footerBar, 'users-caption')], host);
- * elements.tbody; // → HTMLTableSectionElement (empty until renderTbody() is called)
+ * elements.tbody; // → HTMLTableSectionElement (vuoto finché non viene chiamato renderTbody())
  */
 export function tablePart(jt, elements, footerBar = null, captionElId = null) {
 

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

@@ -8,20 +8,20 @@ import { tfootContent } from './cell-content.js';
 /** @typedef {import('../json-table-component.js').JsonTable} JsonTable */
 
 /**
- * Renders the footer row inside `elements.tfoot` (present only when `params.tfoot` is true),
- * replacing the previous content. Every column produces a cell whose content comes from
- * `tfootContent()` (column `tfootRender`); the footer is emptied when there are no rows.
+ * Renderizza la riga del footer dentro `elements.tfoot` (presente solo quando `params.tfoot` è true),
+ * sostituendo il contenuto precedente. Ogni colonna produce una cella il cui contenuto proviene da
+ * `tfootContent()` (`tfootRender` della colonna); il footer viene svuotato quando non ci sono righe.
  *
- * The rows passed to `tfootRender` are the whole filtered set, or the current page only when
- * `updateFooterOnPageChange` is true.
+ * Le righe passate a `tfootRender` sono l'intero insieme filtrato, oppure solo la pagina corrente quando
+ * `updateFooterOnPageChange` è true.
  *
- * Generated structure: `tr > td[data-key][cellClass]…`
+ * Struttura generata: `tr > td[data-key][cellClass]…`
  *
- * @param {JsonTable} jt - The component instance
+ * @param {JsonTable} jt - L'istanza del componente
  * @returns {void}
  *
  * @example
- * renderTfoot(jt); // after `jt.state` has been updated
+ * renderTfoot(jt); // dopo l'aggiornamento di `jt.state`
  */
 export function renderTfoot(jt) {
 

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

@@ -13,13 +13,13 @@ import { nextSortDir } from './sorting.js';
 /** @typedef {'none'|'ascending'|'descending'} SortState */
 
 /**
- * Updates the sort state of a sortable `<th>`: `aria-sort` attribute (removed when `none`),
- * icon and `title`/`aria-label` of the sort button (both describing the action of the next
- * click, e.g. "sort descending" when the ascending sort is active).
+ * Aggiorna lo stato di ordinamento di un `<th>` ordinabile: attributo `aria-sort` (rimosso quando `none`),
+ * icona e `title`/`aria-label` del pulsante di ordinamento (entrambi descrivono l'azione del prossimo
+ * click, ad es. "ordina in modo decrescente" quando è attivo l'ordinamento crescente).
  *
- * @param {HTMLTableCellElement} th - The `<th>` generated by `theadPart()`
- * @param {SortState} state - Sort state to apply
- * @param {JsonTableParams} params - Resolved params (icons and labels)
+ * @param {HTMLTableCellElement} th - Il `<th>` generato da `theadPart()`
+ * @param {SortState} state - Stato di ordinamento da applicare
+ * @param {JsonTableParams} params - Parametri risolti (icone e label)
  * @returns {void}
  *
  * @example
@@ -57,15 +57,15 @@ export function setSortState(th, state, params) {
 
 
 /**
- * Applies the current sort (`jt.state.sort`) to every sortable `<th>` of the thead: the sorted
- * column gets `aria-sort` and the matching icon, the others are reset to `none`.
+ * Applica l'ordinamento corrente (`jt.state.sort`) a ogni `<th>` ordinabile del thead: la colonna
+ * ordinata riceve `aria-sort` e l'icona corrispondente, le altre vengono riportate a `none`.
  *
- * @param {JsonTable} jt - The component instance
+ * @param {JsonTable} jt - L'istanza del componente
  * @returns {void}
  *
  * @example
  * jt.state.sort = { key: 'name', dir: 'desc' };
- * applySortState(jt); // th[data-key=name][aria-sort=descending], the other th without aria-sort
+ * applySortState(jt); // th[data-key=name][aria-sort=descending], gli altri th senza aria-sort
  */
 export function applySortState(jt) {
 
@@ -84,11 +84,11 @@ export function applySortState(jt) {
 
 
 /**
- * Attaches the delegated `click` listener to the thead: a click on a sort button cycles the
- * column sort (none → asc → desc → none, see `nextSortDir`) through `jt.setSort()`.
- * The thead is not rebuilt on sort, so the focus stays on the clicked button.
+ * Collega il listener `click` delegato al thead: un click su un pulsante di ordinamento fa scorrere
+ * l'ordinamento della colonna (nessuno → asc → desc → nessuno, vedi `nextSortDir`) tramite `jt.setSort()`.
+ * Il thead non viene ricostruito all'ordinamento, quindi il focus resta sul pulsante cliccato.
  *
- * @param {JsonTable} jt - The component instance
+ * @param {JsonTable} jt - L'istanza del componente
  * @returns {void}
  *
  * @example
@@ -117,22 +117,22 @@ export function setSortListener(jt) {
 
 
 /**
- * domBuilder item of the `<thead>`.
+ * Elemento domBuilder del `<thead>`.
  *
  * Generated structure:
  * ```
  * thead > tr
- *   th[scope=col][data-key][headerClass]                                   ← not sortable: content = col.title
- *   th.sortable[scope=col][data-key][data-sortable=true][headerClass]      ← sortable
+ *   th[scope=col][data-key][headerClass]                                   ← non ordinabile: contenuto = col.title
+ *   th.sortable[scope=col][data-key][data-sortable=true][headerClass]      ← ordinabile
  *     button.sortBtn[classes.sortBtn][type=button][data-key][title][aria-label]
  *       span.sortTitle[data-jt-sort-title]  ← col.title
- *       span.sortIcon[data-jt-sort-icon]    ← sort icon (see `setSortState`)
+ *       span.sortIcon[data-jt-sort-icon]    ← icona di ordinamento (vedi `setSortState`)
  * ```
  *
- * The `<thead>` is stored in `elements.thead`; the sort listener is attached by `setSortListener()`.
+ * Il `<thead>` viene memorizzato in `elements.thead`; il listener di ordinamento è collegato da `setSortListener()`.
  *
- * @param {JsonTable} jt - The component instance (`params`, `cols`)
- * @param {JsonTableElements} elements - Object collecting the generated elements (mutated)
+ * @param {JsonTable} jt - L'istanza del componente (`params`, `cols`)
+ * @param {JsonTableElements} elements - Oggetto che raccoglie gli elementi generati (modificato)
  * @returns {DomBuilderItem}
  *
  * @example

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

@@ -5,24 +5,24 @@ import { setContent } from './content-utils.js';
 /** @typedef {import('../json-table-component.js').JsonTable} JsonTable */
 
 /**
- * Updates the info text (`elements.resultInfo`) from the current state.
+ * Aggiorna il testo informativo (`elements.resultInfo`) a partire dallo stato corrente.
  *
- * Content resolution:
- * - `params.infoText` function → `infoText(start, end, totRec, filteredRec, page, totPages)`
- * - no rows → `labels.noResults` (search active) or `labels.noRows`
- * - otherwise the mustache-like template `params.infoText` (string) or `labels.info`, with the
- *   placeholders `{start}`, `{end}`, `{totRec}`, `{filteredRec}`, `{page}`, `{totPages}` replaced
- *   by the locale-formatted numbers
+ * Risoluzione del contenuto:
+ * - funzione `params.infoText` → `infoText(start, end, totRec, filteredRec, page, totPages)`
+ * - nessuna riga → `labels.noResults` (ricerca attiva) oppure `labels.noRows`
+ * - altrimenti il template in stile mustache `params.infoText` (stringa) o `labels.info`, con i
+ *   segnaposto `{start}`, `{end}`, `{totRec}`, `{filteredRec}`, `{page}`, `{totPages}` sostituiti
+ *   dai numeri formattati secondo il locale
  *
- * `start`/`end` are the 1-based indexes of the first/last row of the current page within the
- * filtered set (0 when there are no rows).
+ * `start`/`end` sono gli indici (da 1) della prima/ultima riga della pagina corrente all'interno
+ * dell'insieme filtrato (0 quando non ci sono righe).
  *
- * @param {JsonTable} jt - The component instance
+ * @param {JsonTable} jt - L'istanza del componente
  * @returns {void}
  *
  * @example
  * updateInfo(jt);
- * // default `labels.info`, page 2 of 25 rows per page, 60 rows → "Stai visualizzando le righe da 26 a 50, su un totale di 60 record trovati"
+ * // `labels.info` di default, pagina 2 con 25 righe per pagina, 60 righe → "Stai visualizzando le righe da 26 a 50, su un totale di 60 record trovati"
  */
 export function updateInfo(jt) {
 

package/types/classes.d.ts

@@ -1,5 +1,5 @@
-// Auto-generated file, do not edit manually.
-// Run `npm run generate:types` to regenerate.
+// File generato automaticamente, non modificare a mano.
+// Eseguire `npm run generate:types` per rigenerarlo.
 
 export type MinimoClass =
   | 'ac-autocomplete-wrapper'

package/types/global.d.ts

@@ -1,23 +1,29 @@
-// Global alias for domBuilder's config-object type, so JSDoc across the codebase can
-// reference `DomBuilderItem` directly instead of repeating an `import(...)` type query.
-// The canonical definition lives in dom-builder.js — this only re-exports it.
+/*
+  Alias globale del tipo dell'oggetto di configurazione di domBuilder, così che il JSDoc in tutto il codice possa
+  referenziare direttamente `DomBuilderItem` invece di ripetere una type query `import(...)`.
+  La definizione canonica si trova in dom-builder.js — qui viene solo riesportata.
+*/
 type DomBuilderItem = import('../src/utilities/dom-builder/dom-builder.js').DomBuilderItem;
 
-// Global alias for the `<json-table>` web component class, so consumer scripts can write
-// `/** @type {JsonTable} */` without importing the type. The tag name map augmentation makes
-// `document.querySelector('json-table')` / `document.createElement('json-table')` return a
-// `JsonTable` instance without casts. Consumers get both by adding this file to their
-// jsconfig/tsconfig `include` (e.g. "node_modules/@massimo-cassandro/minimo/types/global.d.ts").
+/*
+  Alias globale della classe del web component `<json-table>`, così che gli script dei consumer possano scrivere
+  un'annotazione JSDoc `@type {JsonTable}` senza importare il tipo. L'augmentation della tag name map fa sì che
+  `document.querySelector('json-table')` / `document.createElement('json-table')` restituiscano un'istanza
+  `JsonTable` senza cast. I consumer ottengono entrambi aggiungendo questo file all'`include` del proprio
+  jsconfig/tsconfig (es. "node_modules/@massimo-cassandro/minimo/types/global.d.ts").
+*/
 type JsonTable = import('../src/web-components/json-table/json-table-component.js').JsonTable;
 
 interface HTMLElementTagNameMap {
   'json-table': JsonTable;
 }
 
-// Sanitizer API (Element.setHTML / getHTML). Declared as required members (not optional) so
-// the augmentation stays compatible with the lib.dom versions that already include them
-// (overload signatures must all be optional or all required); the runtime code still checks
-// `typeof el.setHTML === 'function'` before using it.
+/*
+  Sanitizer API (Element.setHTML / getHTML). Dichiarate come membri obbligatori (non opzionali) così che
+  l'augmentation resti compatibile con le versioni di lib.dom che già le includono
+  (le firme in overload devono essere tutte opzionali o tutte obbligatorie); il codice a runtime controlla comunque
+  `typeof el.setHTML === 'function'` prima di usarle.
+*/
 // https://developer.mozilla.org/en-US/docs/Web/API/Element/setHTML
 interface Element {
   setHTML(input: string, options?: { sanitizer?: unknown }): void;