@intlayer/docs 9.5.6 → 9.5.8

package/docs/it/cli/infra.md

@@ -0,0 +1,162 @@
+---
+createdAt: 2026-09-21
+updatedAt: 2026-09-21
+title: CLI - Init Infra
+description: Scopri come utilizzare il comando init infra della CLI di Intlayer per installare l'applicazione desktop o auto-ospitare il CMS Intlayer con Docker (contenitore all-in-one o stack Docker Compose).
+keywords:
+  - CLI
+  - Infrastruttura
+  - Auto-hosting
+  - Applicazione desktop
+  - Docker
+  - Docker Compose
+  - CMS
+  - Intlayer
+slugs:
+  - doc
+  - concept
+  - cli
+  - infra
+history:
+  - version: 9.5.6
+    date: 2026-09-21
+    changes: "Aggiungi il comando init infra"
+author: aymericzip
+---
+
+# Comando Intlayer CLI Init Infra
+
+## Descrizione
+
+Il comando `init infra` configura l'infrastruttura Intlayer sul tuo computer. Scarica il programma di installazione ospitato per la tua piattaforma (`https://intlayer.org/install.sh` su macOS / Linux, `https://intlayer.org/install.ps1` su Windows) e lo esegue con il terminale collegato, in modo che il menu e l'avanzamento siano mostrati senza modifiche.
+
+Il programma di installazione chiede come desideri eseguire Intlayer:
+
+- **Applicazione desktop**: scarica la dashboard nativa per il tuo sistema operativo e CPU e la apre o la installa. La versione desktop comunica con il backend Intlayer Cloud.
+- **Docker all-in-one**: dashboard + API + MongoDB + Redis + MinIO in un unico contenitore supportato da un volume. Scrive `./intlayer.env` con i segreti generati e scarica l'immagine `intlayer/cms-all`.
+- **Docker Compose**: un contenitore per servizio, per un auto-hosting scalabile. Scrive `docker-compose.yml` e `.env` in `./intlayer/` e scarica le immagini.
+
+Il programma di installazione ospitato è l'unica fonte di verità per il flusso di configurazione: la CLI lo esegue invece di reimplementare gli stessi passaggi, quindi `npx intlayer init infra` e `curl -fsSL https://intlayer.org/install.sh | sh` fanno esattamente la stessa cosa.
+
+## Utilizzo
+
+```bash packageManager="npm"
+npx intlayer init infra [options]
+```
+
+```bash packageManager="yarn"
+yarn intlayer init infra [options]
+```
+
+```bash packageManager="pnpm"
+pnpm intlayer init infra [options]
+```
+
+```bash packageManager="bun"
+bun x intlayer init infra [options]
+```
+
+Lo stesso passaggio è offerto nell'elenco di controllo di `npx intlayer init --interactive`, sotto **Infrastruttura (applicazione desktop / auto-hosting)**.
+
+## Opzioni
+
+- `-m, --mode <mode>` - Opzionale. Salta il menu del programma di installazione ed esegue direttamente una modalità. Valori accettati: `desktop`, `docker` (all-in-one) o `compose`. Qualsiasi altro valore genera un errore elencando le modalità accettate.
+
+## Esempi
+
+### Scegli la modalità in modo interattivo
+
+```bash
+npx intlayer init infra
+```
+
+### Installa l'applicazione desktop
+
+```bash
+npx intlayer init infra --mode desktop
+```
+
+### Auto-ospita con il contenitore all-in-one
+
+```bash
+npx intlayer init infra --mode docker
+```
+
+### Auto-ospita con Docker Compose
+
+```bash
+npx intlayer init infra --mode compose
+```
+
+## Esempio di output
+
+```bash
+npx intlayer init infra --mode compose
+◇  Installer downloaded
+▸ Fetching docker-compose.yml into ./intlayer
+▸ Writing ./intlayer/.env
+▸ Pulling images
+
+  Everything is installed. Two steps left.
+
+  1. Configure a mailer in:
+
+       ./intlayer/.env
+
+     Either RESEND_API_KEY (resend.com) or the MAIL_SMTP_* block — the first
+     account cannot be verified without a working mailer.
+  2. Start the stack:
+
+       cd ./intlayer && docker compose up -d
+
+  Then open http://localhost:3000 — first boot initialises the
+  datastores, so give it a minute. The first account you create becomes the
+  super admin.
+
+    Logs      docker compose logs -f
+    Stop      docker compose down
+    Upgrade   docker compose pull && docker compose up -d
+```
+
+## Impostazioni del programma di installazione
+
+Il programma di installazione legge alcune variabili di ambiente, che la CLI trasmette senza modifiche. Impostale nella tua shell prima di eseguire il comando:
+
+```bash
+INTLAYER_COMPOSE_DIR=./cms npx intlayer init infra --mode compose
+```
+
+| Variabile                 | Predefinito               | Si applica a | Descrizione                                                        |
+| ------------------------- | ------------------------- | ------------ | ------------------------------------------------------------------ |
+| `INTLAYER_MODE`           | _(richiesto)_             | tutte        | `desktop`, `docker` o `compose`, uguale a `--mode`                 |
+| `INTLAYER_DOWNLOAD_DIR`   | `~/Downloads`             | desktop      | Dove viene salvato il programma di installazione dell'app          |
+| `INTLAYER_IMAGE`          | `intlayer/cms-all:latest` | docker       | Immagine all-in-one da scaricare                                   |
+| `INTLAYER_ENV_FILE`       | `./intlayer.env`          | docker       | Dove scrivere il file di ambiente                                  |
+| `INTLAYER_CONTAINER_NAME` | `intlayer`                | docker       | Nome del contenitore                                               |
+| `INTLAYER_DATA_VOLUME`    | `intlayer-data`           | docker       | Volume con nome montato in `/data`                                 |
+| `INTLAYER_APP_PORT`       | `3000`                    | docker       | Porta host per la dashboard                                        |
+| `INTLAYER_API_PORT`       | `3100`                    | docker       | Porta host per l'API                                               |
+| `INTLAYER_S3_PORT`        | `9000`                    | docker       | Porta host per l'API S3 MinIO                                      |
+| `INTLAYER_CONSOLE_PORT`   | `9001`                    | docker       | Porta host per la console MinIO                                    |
+| `INTLAYER_COMPOSE_DIR`    | `./intlayer`              | compose      | Dove vengono scritti `docker-compose.yml` e `.env`                 |
+| `INTLAYER_SELFHOST_REF`   | `main`                    | entrambe     | Rif Git da cui vengono recuperati il file compose e il modello env |
+
+> Le variabili di porta modificano solo il lato **host** della mappatura. Le immagini pubblicate includono `http://localhost:3000`, `http://localhost:3100` e `http://localhost:9000` compilati nel pacchetto della dashboard, quindi mantieni i valori predefiniti a meno che non crei le tue immagini: consulta la [guida all'auto-hosting](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/self_hosting.md#limitations).
+
+## Requisiti
+
+- **L'applicazione desktop** richiede [Node.js](https://nodejs.org): l'app incorpora il server della dashboard e lo avvia con il binario `node` del computer.
+- **Le modalità Docker** richiedono [Docker](https://docs.docker.com/get-docker/) (Docker Desktop con backend WSL 2 su Windows). La modalità Compose richiede inoltre il plug-in `docker compose`.
+
+## Note
+
+- La riesecuzione del comando è sicura: un file di ambiente esistente non viene mai sovrascritto, fungendo anche da percorso di aggiornamento (il programma di installazione scarica le immagini più recenti e mantiene i segreti).
+- Il programma di installazione viene scaricato in una directory temporanea ed eliminato al termine, qualunque sia il risultato.
+- Il codice di uscita del comando corrisponde a quello del programma di installazione. Se il download fallisce, la CLI stampa il comando equivalente `curl … | sh` (o `irm … | iex`) in modo da poter eseguire direttamente il programma di installazione.
+- Le modalità Docker richiedono comunque un gestore di posta elettronica per l'invio delle email di accesso. Al termine dell'installazione, configura Resend o SMTP nel file di ambiente generato: consulta [Mailer globale](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/self_hosting.md#global-mailer).
+
+## Correlati
+
+- [Guida all'auto-hosting](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/self_hosting.md) - Architettura, primi passi e limitazioni di ciascuna modalità
+- [Inizializza Intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/cli/init.md) - Il comando principale `init` e il suo elenco di controllo interattivo
+- [CMS Intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/intlayer_CMS.md) - Funzionalità della dashboard appena installata

package/docs/it/cli/init.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2025-12-30
-updatedAt: 2025-12-30
+updatedAt: 2026-09-21
 title: Inizializza Intlayer
 description: Scopri come inizializzare Intlayer nel tuo progetto.
 keywords:
@@ -14,6 +14,9 @@ slugs:
   - cli
   - init
 history:
+  - version: 9.5.6
+    date: 2026-09-21
+    changes: "Aggiunta del sottocomando init infra"
   - version: 8.6.4
     date: 2026-03-31
     changes: "Aggiunta opzione --no-gitignore"
@@ -125,6 +128,26 @@ bun x intlayer init --no-gitignore
 
 Questo configurerà tutti i file di configurazione ma non modificherà il tuo `.gitignore`.
 
+### Configura l'infrastruttura (applicazione desktop o auto-hosting):
+
+```bash
+npx intlayer init infra
+```
+
+Scarica ed esegue il programma di installazione ospitato (`https://intlayer.org/install.sh`, o `install.ps1` su Windows), che chiede come desideri eseguire Intlayer:
+
+- **Applicazione desktop** - installa la dashboard nativa sul tuo computer, connessa a Intlayer Cloud.
+- **Docker all-in-one** - dashboard + API + MongoDB + Redis + MinIO in un unico contenitore.
+- **Docker Compose** - un contenitore per servizio, per un auto-hosting scalabile.
+
+Salta il menu con `--mode`:
+
+```bash
+npx intlayer init infra --mode compose
+```
+
+Lo stesso passaggio è offerto da `npx intlayer init --interactive`. Consulta il [riferimento `init infra`](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/cli/infra.md) per le impostazioni del programma di installazione e la [guida all'auto-hosting](https://github.com/aymericzip/intlayer/blob/main/docs/docs/it/self_hosting.md) per informazioni sulla configurazione di ciascuna modalità.
+
 ## Esempio di output:
 
 ```bash

package/docs/it/cli/upgrade.md

@@ -0,0 +1,125 @@
+---
+createdAt: 2026-09-23
+updatedAt: 2026-09-23
+title: CLI - Aggiorna i pacchetti Intlayer
+description: Scopri come utilizzare il comando upgrade della CLI di Intlayer per elencare ogni pacchetto Intlayer del tuo progetto o monorepo e aggiornarli alla versione più recente.
+keywords:
+  - CLI
+  - Upgrade
+  - Aggiornamento
+  - Pacchetti
+  - Monorepo
+  - Intlayer
+slugs:
+  - doc
+  - concept
+  - cli
+  - upgrade
+history:
+  - version: 9.5.8
+    date: 2026-09-23
+    changes: "Aggiungi il comando upgrade"
+author: aymericzip
+---
+
+# Aggiorna i pacchetti Intlayer
+
+```bash packageManager="npm"
+npx intlayer upgrade
+```
+
+```bash packageManager="yarn"
+yarn intlayer upgrade
+```
+
+```bash packageManager="pnpm"
+pnpm intlayer upgrade
+```
+
+```bash packageManager="bun"
+bun x intlayer upgrade
+```
+
+Il comando `upgrade` elenca i pacchetti Intlayer dichiarati in ogni `package.json` del tuo progetto, compresi i workspace del monorepo, e li aggiorna all'ultima versione pubblicata. Esegue autonomamente lo stesso passaggio di aggiornamento dei pacchetti di `intlayer init`.
+
+## Argomenti:
+
+- `--project-root [projectRoot]` - Opzionale. La directory principale del progetto. Per impostazione predefinita, il comando parte dal `package.json` più vicino sopra la directory di lavoro corrente.
+- `--dry-run` - Opzionale. Elenca i pacchetti e la loro versione di destinazione senza modificare alcun file.
+- `--tag <tag>` - Opzionale. Il dist-tag npm a cui aggiornare (ad esempio `canary`). Il valore predefinito è `latest`.
+
+## Cosa fa:
+
+1. **Elenca i pacchetti Intlayer** - Esegue la scansione di ogni `package.json` del progetto (ignorando `node_modules` e gli output di build) alla ricerca di dipendenze e devDependencies `intlayer`, `@intlayer/*`, `*-intlayer` e `intlayer-*`.
+2. **Recupera la versione di destinazione** - Legge dal registro npm la versione del dist-tag selezionato (`latest` per impostazione predefinita) di ciascun pacchetto.
+3. **Riscrive i range** - Aggiorna ogni intervallo obsoleto direttamente nel file, mantenendo il relativo operatore (`^`, `~` o nessuno) e l'indentazione del file.
+4. **Installa una sola volta** - Esegue una singola installazione dalla root del workspace (la directory più vicina con un lock file), utilizzando il gestore di pacchetti proprietario del lock file:
+
+| Lock file                     | Comando        |
+| ----------------------------- | -------------- |
+| `bun.lock` / `bun.lockb`      | `bun install`  |
+| `pnpm-lock.yaml`              | `pnpm install` |
+| `yarn.lock`                   | `yarn install` |
+| `package-lock.json` o no lock | `npm install`  |
+
+Se non è presente alcun lock file, viene utilizzato il campo `packageManager` di `package.json` (ad esempio `"bun@1.2.0"`) prima di ricorrere a npm.
+
+Gli intervalli che non puntano al registro, come `workspace:*`, `file:`, `link:`, `catalog:` o URL git, non vengono mai modificati.
+
+## Esempi:
+
+### Elenca gli aggiornamenti disponibili senza applicarli:
+
+```bash packageManager="npm"
+npx intlayer upgrade --dry-run
+```
+
+```bash packageManager="yarn"
+yarn intlayer upgrade --dry-run
+```
+
+```bash packageManager="pnpm"
+pnpm intlayer upgrade --dry-run
+```
+
+```bash packageManager="bun"
+bun x intlayer upgrade --dry-run
+```
+
+### Aggiorna alla versione canary:
+
+```bash packageManager="npm"
+npx intlayer upgrade --tag canary
+```
+
+```bash packageManager="yarn"
+yarn intlayer upgrade --tag canary
+```
+
+```bash packageManager="pnpm"
+pnpm intlayer upgrade --tag canary
+```
+
+```bash packageManager="bun"
+bun x intlayer upgrade --tag canary
+```
+
+## Output di esempio:
+
+```bash
+npx intlayer upgrade
+Intlayer packages:
+  package.json
+    intlayer ^9.0.0 → ^9.5.7
+  apps/web/package.json
+    next-intlayer ^9.5.7 (latest)
+    vite-intlayer ~9.2.0 → ~9.5.7
+Running bun install...
+✓ Upgraded 2 Intlayer dependencies to latest
+```
+
+## Note:
+
+- Esegui il comando dalla directory principale del repository per aggiornare ogni workspace. Eseguilo da un workspace per aggiornare solo quel workspace.
+- I pacchetti la cui versione non può essere recuperata (offline, pacchetto privato o non pubblicato) vengono elencati e lasciati invariati.
+- Se l'installazione fallisce, gli intervalli aggiornati vengono conservati in `package.json`. Esegui manualmente il comando di installazione del tuo gestore di pacchetti.

package/docs/it/dictionary/html.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2026-01-20
-updatedAt: 2026-03-24
+updatedAt: 2026-09-21
 title: Contenuto HTML
 description: Scopri come dichiarare e usare contenuti HTML con componenti personalizzati in Intlayer. Segui questa documentazione per incorporare contenuti ricchi in stile HTML con sostituzione dinamica dei componenti nel tuo progetto internazionalizzato.
 keywords:
@@ -13,6 +13,8 @@ keywords:
   - React
   - Vue
   - Svelte
+  - Remix
+  - Astro
   - Solid
   - Angular
 slugs:
@@ -238,6 +240,83 @@ Quando accedi al contenuto tramite `useIntlayer`, i nodi HTML sono già pronti p
     ```
 
   </Tab>
+  <Tab label="Remix" value="remix">
+    In Remix 3, i nodi HTML si risolvono in una stringa HTML. Inseriscila con la prop `innerHTML` di Remix JSX o con `html.raw` in una vista `html-template`.
+
+    ```tsx fileName="src/views/home.tsx"
+    import { useIntlayer } from "remix-intlayer";
+
+    export const HomePage = () => () => {
+      const { myHtmlContent } = useIntlayer("app");
+
+      return <div innerHTML={myHtmlContent.value} />;
+    };
+    ```
+
+    ```ts fileName="src/views/home.ts"
+    import { html } from "remix/html-template";
+    import { useIntlayer } from "remix-intlayer";
+
+    export const renderHomePage = () => {
+      const { myHtmlContent } = useIntlayer("app");
+
+      return html.raw`<div>${myHtmlContent.value}</div>`;
+    };
+    ```
+
+    > Remix esegue l'escape dei valori interpolati per impostazione predefinita. `innerHTML` e `html.raw` sono i due meccanismi di esclusione, che è ciò di cui ha bisogno una stringa HTML.
+
+    Usa il metodo `.use()` per sovrascrivere i tag o mappare componenti personalizzati. Le sovrascritture sono funzioni che restituiscono una stringa HTML:
+
+    ```tsx
+    <div
+      innerHTML={myHtmlContent.use({
+        p: ({ children }) => `<p class="prose">${children}</p>`,
+        CustomLink: ({ children }) => `<a href="/details">${children}</a>`,
+      })}
+    />
+    ```
+
+  </Tab>
+  <Tab label="Astro" value="astro">
+    In Astro, i nodi HTML si risolvono in una stringa HTML. Inseriscila con la direttiva `set:html` nel template o con `innerHTML` in uno `<script>` client.
+
+    ```astro fileName="src/pages/index.astro"
+    ---
+    import { useIntlayer } from "astro-intlayer";
+
+    const { myHtmlContent } = useIntlayer("app");
+    ---
+
+    <div set:html={myHtmlContent.value} />
+    ```
+
+    ```astro fileName="src/components/Content.astro"
+    <div id="content"></div>
+
+    <script>
+      import { useIntlayer } from "astro-intlayer";
+
+      const { myHtmlContent } = useIntlayer("app");
+
+      document.querySelector("#content")!.innerHTML = myHtmlContent.value;
+    </script>
+    ```
+
+    > Astro esegue l'escape di `{espressioni}` per impostazione predefinita. `set:html` è il meccanismo di esclusione, che è ciò di cui ha bisogno una stringa HTML.
+
+    Usa il metodo `.use()` per sovrascrivere i tag o mappare componenti personalizzati. Le sovrascritture sono funzioni che restituiscono una stringa HTML:
+
+    ```astro
+    <div
+      set:html={myHtmlContent.use({
+        p: ({ children }) => `<p class="prose">${children}</p>`,
+        CustomLink: ({ children }) => `<a href="/details">${children}</a>`,
+      })}
+    />
+    ```
+
+  </Tab>
 </Tabs>
 
 ## Configurazione globale con `HTMLProvider`
@@ -473,6 +552,41 @@ Puoi configurare il rendering HTML a livello globale per l'intera applicazione.
     > Importare dinamicamente il tuo renderer HTML è un ottimo modo per ridurre le dimensioni del bundle della tua applicazione.
 
   </Tab>
+  <Tab label="Remix" value="remix">
+
+    Remix non ha un albero dei componenti per contenere un provider, quindi la configurazione viene installata una sola volta, come singleton, all'avvio del server. Configura il renderer restituito da `useHTMLRenderer()`. I nodi `html` restituiti da `useIntlayer` vengono renderizzati così come sono; sovrascrivi i loro tag per nodo con `.use()`.
+
+    ```typescript fileName="src/router.ts"
+    import { installIntlayerHTML } from "remix-intlayer/html";
+
+    installIntlayerHTML({
+      renderHTML: (html) => html.replaceAll("<p>", '<p class="prose">'),
+    });
+    ```
+
+    > Usa `installIntlayerHTMLDynamic(async () => …)` per caricare il renderer in modo lazy; il loader viene eseguito solo alla prima chiamata.
+
+  </Tab>
+  <Tab label="Astro" value="astro">
+
+    Astro non ha un albero dei componenti per contenere un provider, quindi la configurazione viene installata una sola volta, come singleton, nel middleware (server) e in uno `<script>` client (browser). Configura il renderer restituito da `useHTMLRenderer()`. I nodi `html` restituiti da `useIntlayer` vengono renderizzati così come sono; sovrascrivi i loro tag per nodo con `.use()`.
+
+    ```typescript fileName="src/middleware.ts"
+    import { installIntlayerHTML } from "astro-intlayer/html";
+    import { defineMiddleware } from "astro:middleware";
+
+    // Viene eseguito una sola volta all'avvio del server; il middleware Intlayer stesso è
+    // registrato dall'integrazione, prima di questo file.
+    installIntlayerHTML({
+      renderHTML: (html) => html.replaceAll("<p>", '<p class="prose">'),
+    });
+
+    export const onRequest = defineMiddleware((_context, next) => next());
+    ```
+
+    > Usa `installIntlayerHTMLDynamic(async () => …)` per caricare il renderer in modo lazy; il loader viene eseguito solo alla prima chiamata.
+
+  </Tab>
 </Tabs>
 
 ### Rendering manuale e strumenti avanzati
@@ -645,15 +759,69 @@ Se hai bisogno di renderizzare stringhe HTML grezze o di avere un controllo magg
     ```
 
   </Tab>
+  <Tab label="Remix" value="remix">
+    #### Hook `useHTMLRenderer()`
+
+    Ottieni una funzione di rendering preconfigurata da `installIntlayerHTML()`. Restituisce una stringa HTML.
+
+    ```tsx
+    import { useHTMLRenderer } from "remix-intlayer/html";
+
+    const renderHTML = useHTMLRenderer();
+
+    return <div innerHTML={renderHTML("<p>Hello <strong>World</strong></p>")} />;
+    ```
+
+    #### Utility `renderHTML()`
+
+    Utility autonoma che ignora la configurazione globale.
+
+    ```tsx
+    import { renderHTML } from "remix-intlayer/html";
+
+    const html = renderHTML("<p>Hello</p>");
+    ```
+
+  </Tab>
+  <Tab label="Astro" value="astro">
+    #### Hook `useHTMLRenderer()`
+
+    Ottieni una funzione di rendering preconfigurata da `installIntlayerHTML()`. Restituisce una stringa HTML.
+
+    ```astro
+    ---
+    import { useHTMLRenderer } from "astro-intlayer/html";
+
+    const renderHTML = useHTMLRenderer();
+    ---
+
+    <div set:html={renderHTML("<p>Hello <strong>World</strong></p>")} />
+    ```
+
+    #### Utility `renderHTML()`
+
+    Utility autonoma che ignora la configurazione globale.
+
+    ```astro
+    ---
+    import { renderHTML } from "astro-intlayer/html";
+
+    const html = renderHTML("<p>Hello</p>");
+    ---
+
+    <div set:html={html} />
+    ```
+
+  </Tab>
 </Tabs>
 
 ## Riferimento delle opzioni
 
 Queste opzioni possono essere passate a `HTMLProvider`, `HTMLRenderer`, `useHTMLRenderer`, e `renderHTML`.
 
-| Opzione      | Tipo                  | Predefinito | Descrizione                                                                                                                        |
-| :----------- | :-------------------- | :---------- | :--------------------------------------------------------------------------------------------------------------------------------- |
-| `components` | `Record<string, any>` | `{}`        | Una mappa che associa tag HTML o nomi di componenti personalizzati ai componenti.                                                  |
-| `renderHTML` | `Function`            | `null`      | Una funzione di rendering personalizzata per sostituire completamente il parser HTML predefinito (solo per i provider Vue/Svelte). |
+| Opzione      | Tipo                  | Predefinito | Descrizione                                                                                                                             |
+| :----------- | :-------------------- | :---------- | :-------------------------------------------------------------------------------------------------------------------------------------- |
+| `components` | `Record<string, any>` | `{}`        | Una mappa che associa tag HTML o nomi di componenti personalizzati ai componenti.                                                       |
+| `renderHTML` | `Function`            | `null`      | Una funzione di rendering personalizzata per sostituire completamente il parser HTML predefinito (provider Vue, Svelte, Remix e Astro). |
 
 > Nota: per React e Preact, i tag HTML standard sono forniti automaticamente. È necessario passare la prop `components` solo se si desidera sovrascriverli o aggiungere componenti personalizzati.