@massimo-cassandro/minimo 1.41.4 → 1.41.6

package/src/web-components/json-table/src/cell-content.js

@@ -8,21 +8,21 @@ import { toNumber } from './data-types.js';
 /** @typedef {import('./parse-cols.js').ParsedCol} ParsedCol */
 
 /**
- * Computes the content of a body cell.
+ * Calcola il contenuto di una cella del body.
  *
  * Pipeline:
- * 1. column `render`: function `(row, tr, td)` or mustache-like string (`[[key]]`); a function
- *    returning `undefined` lets the pipeline go on (useful to only decorate `td`/`tr`), `null`
- *    gives `renderNullAs`
- * 2. `null`/`undefined` raw value → `renderNullAs`
- * 3. data type `render(value, row, params)`
- * 4. raw value
+ * 1. `render` della colonna: funzione `(row, tr, td)` o stringa in stile mustache (`[[key]]`); una funzione
+ *    che restituisce `undefined` lascia proseguire la pipeline (utile per decorare solo `td`/`tr`), `null`
+ *    dà `renderNullAs`
+ * 2. valore grezzo `null`/`undefined` → `renderNullAs`
+ * 3. `render(value, row, params)` del data type
+ * 4. valore grezzo
  *
- * @param {ParsedCol} col - Parsed column
- * @param {Object} row - Row object
- * @param {JsonTableParams} params - Resolved params
- * @param {HTMLTableRowElement} [tr] - Row element, passed to the column `render`
- * @param {HTMLTableCellElement} [td] - Cell element, passed to the column `render`
+ * @param {ParsedCol} col - Colonna analizzata
+ * @param {Object} row - Oggetto riga
+ * @param {JsonTableParams} params - Parametri risolti
+ * @param {HTMLTableRowElement} [tr] - Elemento riga, passato al `render` della colonna
+ * @param {HTMLTableCellElement} [td] - Elemento cella, passato al `render` della colonna
  * @returns {CellContent}
  *
  * @example
@@ -30,7 +30,7 @@ import { toNumber } from './data-types.js';
  * cellContent({ ...col, key: 'amount', _type: types.euro }, { amount: null }, params); // → '—' (renderNullAs)
  * cellContent({ ...col, render: '<b>[[name]]</b>' }, { name: 'Mario' }, params);      // → '<b>Mario</b>'
  * cellContent({ ...col, render: (row, tr, td) => { td.title = row.name; } }, row, params, tr, td);
- * // → data type / raw value (render returned undefined)
+ * // → data type / valore grezzo (render ha restituito undefined)
  */
 export function cellContent(col, row, params, tr, td) {
 
@@ -61,8 +61,8 @@ export function cellContent(col, row, params, tr, td) {
 
 
 /**
- * Built-in footer aggregates (`tfootRender: '@sum'`, ...), computed on the numeric values
- * of the column (non-numeric values are skipped).
+ * Aggregati predefiniti del footer (`tfootRender: '@sum'`, ...), calcolati sui valori numerici
+ * della colonna (i valori non numerici vengono saltati).
  * @type {Object<string, (nums: number[]) => number>}
  */
 const aggregates = {
@@ -75,17 +75,17 @@ const aggregates = {
 
 
 /**
- * Computes the content of a footer cell from the column `tfootRender`:
- * - function `(rows, td) => content`
- * - built-in aggregate `'@sum'`, `'@avg'`, `'@min'`, `'@max'` (formatted by the column data
- *   type, e.g. as currency for `euro` columns) or `'@count'` (number of numeric values)
- * - any other string: static content (e.g. a "Totale" label)
- * - `null`: empty cell
+ * Calcola il contenuto di una cella del footer dal `tfootRender` della colonna:
+ * - funzione `(rows, td) => content`
+ * - aggregato predefinito `'@sum'`, `'@avg'`, `'@min'`, `'@max'` (formattato dal data
+ *   type della colonna, ad es. come valuta per le colonne `euro`) oppure `'@count'` (numero di valori numerici)
+ * - qualsiasi altra stringa: contenuto statico (ad es. un'etichetta "Totale")
+ * - `null`: cella vuota
  *
- * @param {ParsedCol} col - Parsed column
- * @param {Array<Object>} rows - Rows to aggregate (filtered set or current page, see `updateFooterOnPageChange`)
- * @param {JsonTableParams} params - Resolved params
- * @param {HTMLTableCellElement} [td] - Footer cell element, passed to the `tfootRender` function
+ * @param {ParsedCol} col - Colonna analizzata
+ * @param {Array<Object>} rows - Righe da aggregare (insieme filtrato o pagina corrente, vedi `updateFooterOnPageChange`)
+ * @param {JsonTableParams} params - Parametri risolti
+ * @param {HTMLTableCellElement} [td] - Elemento cella del footer, passato alla funzione `tfootRender`
  * @returns {CellContent}
  *
  * @example

package/src/web-components/json-table/src/content-utils.js

@@ -5,17 +5,17 @@ import { domBuilder } from '../../../utilities/dom-builder/dom-builder.js';
 /** @typedef {import('./defaults.js').CellContent} CellContent */
 
 /**
- * Replaces the content of `el` with `content`, accepting every content form used by the
- * component (see `CellContent`): a Node is appended as-is, a domBuilder array is built inside
- * the element, a string/number is set as text or, when it contains `<`, as sanitized markup
- * (`Element.setHTML` where supported, `innerHTML` otherwise, consistently with domBuilder).
- * The empty sanitizer config passed to `setHTML` keeps `class`, `id`, `style` and `data-*`
- * attributes, which the browser default configuration removes, while unsafe content (scripts,
- * event handlers, `javascript:` URLs) is always stripped.
- * A function is invoked and its result used. `null`/`undefined` empty the element.
+ * Sostituisce il contenuto di `el` con `content`, accettando ogni forma di contenuto usata dal
+ * componente (vedi `CellContent`): un Node viene aggiunto così com'è, un array domBuilder viene costruito dentro
+ * l'elemento, una stringa/numero viene impostato come testo oppure, se contiene `<`, come markup sanificato
+ * (`Element.setHTML` dove supportato, altrimenti `innerHTML`, in modo coerente con domBuilder).
+ * La configurazione vuota del sanitizer passata a `setHTML` mantiene gli attributi `class`, `id`, `style` e `data-*`,
+ * che la configurazione predefinita del browser rimuove, mentre il contenuto non sicuro (script,
+ * gestori di eventi, URL `javascript:`) viene sempre eliminato.
+ * Una funzione viene invocata e il suo risultato usato. `null`/`undefined` svuotano l'elemento.
  *
- * @param {HTMLElement} el - Target element (emptied first)
- * @param {CellContent|(() => CellContent)} content - Content to set
+ * @param {HTMLElement} el - Elemento di destinazione (svuotato prima)
+ * @param {CellContent|(() => CellContent)} content - Contenuto da impostare
  * @returns {void}
  *
  * @example
@@ -24,7 +24,7 @@ import { domBuilder } from '../../../utilities/dom-builder/dom-builder.js';
  * setContent(td, 1234);
  * setContent(td, document.createElement('span'));
  * setContent(td, [{ tag: 'a', attrs: { href: '#' }, content: 'link' }]);
- * setContent(td, null); // → empty cell
+ * setContent(td, null); // → cella vuota
  */
 export function setContent(el, content) {
 
@@ -60,11 +60,11 @@ export function setContent(el, content) {
 
 
 /**
- * Reads a value from an object through a dot-separated key path.
- * Returns `undefined` when an intermediate key does not exist.
+ * Legge un valore da un oggetto tramite un percorso di chiavi separate da punti.
+ * Restituisce `undefined` quando una chiave intermedia non esiste.
  *
- * @param {Object|null|undefined} obj - Source object
- * @param {string} path - Key or dot-separated path
+ * @param {Object|null|undefined} obj - Oggetto sorgente
+ * @param {string} path - Chiave o percorso separato da punti
  * @returns {*}
  *
  * @example
@@ -81,13 +81,13 @@ export function getNestedValue(obj, path) {
 
 
 /**
- * Resolves a mustache-like template: every `[[key]]` placeholder is replaced with the
- * corresponding row value (nested keys allowed); placeholders resolving to `null`/`undefined`
- * are replaced with `nullAs`. Useful for the js-free configuration via HTML attributes.
+ * Risolve un template in stile mustache: ogni segnaposto `[[key]]` viene sostituito con il
+ * corrispondente valore della riga (chiavi annidate ammesse); i segnaposto che risultano `null`/`undefined`
+ * vengono sostituiti con `nullAs`. Utile per la configurazione senza JS tramite attributi HTML.
  *
- * @param {string} tpl - Template string
- * @param {Object} row - Row object
- * @param {string} [nullAs=''] - Replacement of null/undefined values (default: '')
+ * @param {string} tpl - Stringa del template
+ * @param {Object} row - Oggetto riga
+ * @param {string} [nullAs=''] - Sostituto dei valori null/undefined (default: '')
  * @returns {string}
  *
  * @example

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

@@ -8,7 +8,7 @@ import { iconContent } from './icons.js';
 /** @typedef {import('./defaults.js').DataTypeDefinition} DataTypeDefinition */
 
 /**
- * Converts a value to a number; empty strings and nullish values give `NaN`.
+ * Converte un valore in numero; le stringhe vuote e i valori nullish danno `NaN`.
  * @param {*} value
  * @returns {number}
  *
@@ -26,8 +26,8 @@ export function toNumber(value) {
 
 
 /**
- * Converts a boolean-like value (`true`/`false`, `1`/`0`, `'1'`/`'0'`, `'true'`/`'false'`)
- * to a boolean; every other value gives `null`, so that `null` can be told apart from `false`.
+ * Converte un valore simile a un booleano (`true`/`false`, `1`/`0`, `'1'`/`'0'`, `'true'`/`'false'`)
+ * in booleano; ogni altro valore dà `null`, così che `null` si distingua da `false`.
  * @param {*} value
  * @returns {boolean|null}
  *
@@ -49,11 +49,11 @@ export function toBool(value) {
 
 
 /**
- * Parses a date-like value: ISO string, timestamp, `Date` object or a Symfony-like object
+ * Analizza un valore simile a una data: stringa ISO, timestamp, oggetto `Date` o un oggetto in stile Symfony
  * (`{ date: '2022-12-02 06:18:55', timezone_type: 3, timezone: 'Europe/Berlin' }`).
  * TODO fuso orario degli oggetti Symfony non gestito (la stringa `date` è interpretata come ora locale)
  * @param {*} value
- * @returns {Date|null} `null` for empty or invalid values
+ * @returns {Date|null} `null` per i valori vuoti o non validi
  *
  * @example
  * parseDate('2024-01-31');                       // → Date
@@ -77,11 +77,11 @@ export function parseDate(value) {
 
 
 /**
- * Formats a numeric value, applying `renderNaNAs` and `renderZeroAs`.
- * @param {*} value - Raw value
- * @param {JsonTableParams} params - Resolved params
- * @param {Intl.NumberFormatOptions} formatOpts - `toLocaleString` options
- * @param {(formatted: string, num: number) => string} [wrap] - Optional decorator of the formatted string
+ * Formatta un valore numerico, applicando `renderNaNAs` e `renderZeroAs`.
+ * @param {*} value - Valore grezzo
+ * @param {JsonTableParams} params - Parametri risolti
+ * @param {Intl.NumberFormatOptions} formatOpts - Opzioni di `toLocaleString`
+ * @param {(formatted: string, num: number) => string} [wrap] - Decoratore opzionale della stringa formattata
  * @returns {string}
  *
  * @example
@@ -104,23 +104,23 @@ export function formatNumber(value, params, formatOpts, wrap) {
 
 
 /**
- * Built-in data types, built on the resolved params (class names, locale options, icons).
+ * Data type predefiniti, costruiti sui parametri risolti (nomi delle classi, opzioni locale, icone).
  *
- * | key           | description                                                     | cell classes            |
+ * | chiave        | descrizione                                                     | classi della cella      |
  * |---------------|-----------------------------------------------------------------|-------------------------|
- * | `string`      | default type, value as-is                                       | –                       |
- * | `num`         | number formatted with `numbersLocaleOpts`                       | textEnd numeric nowrap  |
- * | `id`          | numeric id: raw value, right aligned, not searchable            | textEnd numeric         |
- * | `perc`        | percentage already in 0–100 scale, `currPercLocaleOpts` + " %"  | textEnd numeric nowrap  |
- * | `percDecimal` | percentage in 0–1 scale (multiplied by 100)                     | textEnd numeric nowrap  |
- * | `currency`    | `Intl` currency format, `params.currency`                       | textEnd numeric nowrap  |
- * | `euro`        | as `currency`, EUR forced                                       | textEnd numeric nowrap  |
- * | `date`        | `<time>` element, `datesLocaleOpts`                             | textEnd nowrap          |
- * | `datetime`    | as `date`, plus time part (`timesLocaleOpts`)                   | textEnd nowrap          |
- * | `bool`        | `boolTrueIcon`/`boolFalseIcon`; not sortable/searchable         | (internal icon styles)  |
- * | `email`       | soft line breaks around `@`                                     | –                       |
+ * | `string`      | tipo predefinito, valore così com'è                             | –                       |
+ * | `num`         | numero formattato con `numbersLocaleOpts`                       | textEnd numeric nowrap  |
+ * | `id`          | id numerico: valore grezzo, allineato a destra, non ricercabile | textEnd numeric         |
+ * | `perc`        | percentuale già in scala 0–100, `currPercLocaleOpts` + " %"     | textEnd numeric nowrap  |
+ * | `percDecimal` | percentuale in scala 0–1 (moltiplicata per 100)                 | textEnd numeric nowrap  |
+ * | `currency`    | formato valuta `Intl`, `params.currency`                        | textEnd numeric nowrap  |
+ * | `euro`        | come `currency`, EUR forzato                                    | textEnd numeric nowrap  |
+ * | `date`        | elemento `<time>`, `datesLocaleOpts`                            | textEnd nowrap          |
+ * | `datetime`    | come `date`, più la parte oraria (`timesLocaleOpts`)            | textEnd nowrap          |
+ * | `bool`        | `boolTrueIcon`/`boolFalseIcon`; non ordinabile/ricercabile      | (stili interni delle icone) |
+ * | `email`       | a capo morbidi attorno a `@`                                    | –                       |
  *
- * @param {JsonTableParams} params - Resolved params
+ * @param {JsonTableParams} params - Parametri risolti
  * @returns {Object<string, DataTypeDefinition>}
  *
  * @example
@@ -237,21 +237,21 @@ export function builtInDataTypes(params) {
 
 
 /**
- * Merges the custom data types (`params.dataTypes`) with the built-in ones.
+ * Unisce i data type personalizzati (`params.dataTypes`) a quelli predefiniti.
  *
- * A custom key matching a built-in type overrides only the given properties; a new key can
- * extend a built-in type via `inheritsFrom`.
+ * Una chiave personalizzata che corrisponde a un tipo predefinito ne sovrascrive solo le proprietà indicate; una nuova chiave può
+ * estendere un tipo predefinito tramite `inheritsFrom`.
  *
- * @param {JsonTableParams} params - Resolved params
- * @returns {Object<string, DataTypeDefinition>} The complete data types map
- * @throws {Error} When `inheritsFrom` refers to an unknown type
+ * @param {JsonTableParams} params - Parametri risolti
+ * @returns {Object<string, DataTypeDefinition>} La mappa completa dei data type
+ * @throws {Error} Quando `inheritsFrom` si riferisce a un tipo sconosciuto
  *
  * @example
  * const types = buildDataTypes({
  *   ...params,
  *   dataTypes: {
- *     num: { cellClass: 'text-end fw-bold' },                 // overrides only `cellClass` of the built-in `num`
- *     km: { inheritsFrom: 'num', render: v => `${v} km` }     // new type based on `num`
+ *     num: { cellClass: 'text-end fw-bold' },                 // sovrascrive solo `cellClass` del `num` predefinito
+ *     km: { inheritsFrom: 'num', render: v => `${v} km` }     // nuovo tipo basato su `num`
  *   }
  * });
  */