> ## Documentation Index
> Fetch the complete documentation index at: https://docs.aftersell.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Configure

> Tutte le opzioni di configure dell'SDK di Aftersell Cart: apertura del drawer, intercettazione dell'add-to-cart, validazione dei form e formattazione degli importi.

`configure(config)` imposta come si comporta il carrello. È una **chiamata di set-up**, quindi è sicura in cima al tuo script, prima che il carrello si sia caricato.

```js theme={"theme":{"light":"snazzy-light","dark":"github-dark"}}
window.aftersell.cart.configure({
  open_on_add_to_cart: 'always',
  money_format: '${{amount}} USD',
});
```

Puoi chiamarla più di una volta e i valori si fondono. Una chiamata successiva sovrascrive solo le chiavi che nomina, lasciando intatto il resto.

<Warning>
  **Passare `undefined` cancella una chiave invece di saltarla.** `configure({ open_on_add_to_cart: undefined })` reimposta quell'opzione al suo valore predefinito, scartando ciò che una chiamata precedente aveva impostato. Per lasciare in pace un'opzione, ometti completamente la chiave.
</Warning>

<div id="options">
  ## Opzioni
</div>

| Opzione                                                         | Valori                             | Predefinito         | Scopo                                                                          |
| --------------------------------------------------------------- | ---------------------------------- | ------------------- | ------------------------------------------------------------------------------ |
| [`open_on_add_to_cart`](#open_on_add_to_cart)                   | `'always'`, `'never'`, `'default'` | `'default'`         | Se il drawer si apre quando viene aggiunto un articolo.                        |
| [`open_on_background_add`](#open_on_background_add)             | `boolean`                          | `false`             | Apri anche quando qualcos'*altro* aggiunge al carrello.                        |
| [`validate_form_on_add_to_cart`](#validate_form_on_add_to_cart) | `boolean`                          | `false`             | Blocca l'aggiunta se il form prodotto non è valido.                            |
| [`skip_add_to_cart_interceptor`](#skip_add_to_cart_interceptor) | `boolean`                          | `false`             | Disattiva completamente l'intercettazione dell'add-to-cart di Aftersell.       |
| [`skip_open_cart_interceptor`](#skip_open_cart_interceptor)     | `boolean`                          | `false`             | Consenti a un clic sull'icona del carrello di raggiungere i tuoi altri script. |
| [`money_format`](#money_format)                                 | string                             | formato dello store | Sovrascrive il formato usato da `formatMoney`.                                 |

***

<div id="open_on_add_to_cart">
  ## open\_on\_add\_to\_cart
</div>

Controlla se il drawer si apre quando un acquirente aggiunge un prodotto.

| Valore      | Comportamento                                                                     |
| ----------- | --------------------------------------------------------------------------------- |
| `'always'`  | Apri sempre il drawer all'aggiunta.                                               |
| `'never'`   | Non aprirlo mai; l'articolo viene aggiunto silenziosamente.                       |
| `'default'` | Segui l'impostazione **Open cart when an item is added** nell'editor di carrello. |

```js theme={"theme":{"light":"snazzy-light","dark":"github-dark"}}
// Always open, regardless of the merchant's cart setting.
window.aftersell.cart.configure({ open_on_add_to_cart: 'always' });
```

Un uso comune è tenere il drawer chiuso su una pagina specifica lasciando invariata l'impostazione del merchant ovunque altrove:

```js theme={"theme":{"light":"snazzy-light","dark":"github-dark"}}
if (window.location.pathname.startsWith('/collections/')) {
  window.aftersell.cart.configure({ open_on_add_to_cart: 'never' });
}
```

<Note>
  Se vuoi semplicemente attivarlo per tutto lo store, è già un'impostazione: **Cart settings → Content → Behavior → Open cart when an item is added**. Usa `configure` quando la risposta dipende dalla pagina, dall'acquirente o da qualcosa che solo il tuo codice conosce.
</Note>

<div id="open_on_background_add">
  ## open\_on\_background\_add
</div>

Impostalo a `true` per aprire il drawer anche per le aggiunte in **background** — quelle che Aftersell ha rilevato ma non ha gestito direttamente.

Un'aggiunta conta come background quando:

* è arrivata tramite gli [eventi standard del carrello di Shopify](https://shopify.dev/docs/storefronts/themes/best-practices/standard-events) (sempre trattati come background, qualunque cosa li abbia attivati), oppure
* Aftersell ha visto la richiesta al carrello sulla rete **senza** alcun clic o pressione di tasto attendibile nei \~3 secondi precedenti — per esempio un'altra app o script che scrive nel carrello.

Un'aggiunta che Aftersell ha visto sulla rete e che *ha* seguito un clic dell'acquirente non è un'aggiunta in background: apre già il drawer secondo `open_on_add_to_cart`, senza bisogno di questa opzione.

```js theme={"theme":{"light":"snazzy-light","dark":"github-dark"}}
window.aftersell.cart.configure({ open_on_background_add: true });
```

Questo è un **gate aggiuntivo, non un override**: un'aggiunta in background apre il drawer solo se anche `open_on_add_to_cart` lo avrebbe consentito. Con `open_on_add_to_cart: 'never'`, questa opzione non fa nulla.

<Tip>
  Ricorri a questa opzione quando un pulsante di aggiunta di terze parti aggiunge correttamente l'articolo ma lascia il drawer chiuso. Se l'articolo non raggiunge mai il carrello, è un problema di intercettazione. Vedi [`skip_add_to_cart_interceptor`](#skip_add_to_cart_interceptor) e il [caso d'uso del page builder](/it/aftersell/cart/sdk-use-case-page-builder).
</Tip>

<div id="validate_form_on_add_to_cart">
  ## validate\_form\_on\_add\_to\_cart
</div>

Esegue la validazione nativa dei form del browser (`reportValidity()`) prima di aggiungere, e annulla l'aggiunta se il form non è valido. Usalo quando il tuo form prodotto ha campi obbligatori (un messaggio di incisione, una nota regalo, una checkbox obbligatoria) che gli acquirenti attualmente possono saltare.

```js theme={"theme":{"light":"snazzy-light","dark":"github-dark"}}
window.aftersell.cart.configure({ validate_form_on_add_to_cart: true });
```

Il browser mostra il proprio messaggio di validazione sul campo problematico. Disattivato per impostazione predefinita, perché un tema con un attributo `required` fuori posto da qualche parte nel form prodotto inizierebbe altrimenti a bloccare silenziosamente l'add-to-cart.

<div id="skip_add_to_cart_interceptor">
  ## skip\_add\_to\_cart\_interceptor
</div>

Disattiva completamente l'intercettazione dell'add-to-cart di Aftersell. Per cosa fa l'intercettazione e ogni modo per uscirne, vedi [Intercettazione dell'add-to-cart](/it/aftersell/cart/add-to-cart-interception).

Il tema esegue quindi l'aggiunta da solo, e ogni script in ascolto su quel submit viene eseguito di nuovo. Aftersell continua a osservare la richiesta al carrello sulla rete, quindi il drawer si apre come al solito. Non lo perdi disattivando l'intercettazione. Sui temi che Aftersell riconosce, il carrello del tema resta inerte, quindi non ottieni due carrelli. Su un tema che non riconosce, il tema potrebbe aprire il proprio carrello accanto al tuo; vedi [Si aprirà anche il carrello del tema?](/it/aftersell/cart/add-to-cart-interception#will-the-themes-cart-open-too).

```js theme={"theme":{"light":"snazzy-light","dark":"github-dark"}}
window.aftersell.cart.configure({ skip_add_to_cart_interceptor: true });
```

<Warning>
  Questa opzione viene letta **una sola volta, al boot**. Funziona solo da una chiamata di set-up eseguita prima del caricamento del carrello: lo script di **Initialization** del tuo carrello. Impostarla più tardi (dentro `ready()`, o da un handler di evento) non ha alcun effetto e fallisce silenziosamente.
</Warning>

Questo è uno strumento drastico che disabilita l'intercettazione per ogni form della pagina. Per esentare un solo form, usa invece l'hook [`registerSkipAddToCartRule`](/it/aftersell/cart/sdk-hooks#registerskipaddtocartrule):

```js theme={"theme":{"light":"snazzy-light","dark":"github-dark"}}
// Preferred: exempt only the forms you own.
window.aftersell.cart.hooks.registerSkipAddToCartRule((form) =>
  form.hasAttribute('data-skip-aftersell')
);
```

<div id="skip_open_cart_interceptor">
  ## skip\_open\_cart\_interceptor
</div>

Cliccare sull'icona del carrello apre il drawer di Aftersell. Per farlo in modo affidabile, Aftersell blocca il clic in modo che nulla altro sulla pagina lo gestisca, cosa che blocca anche i **tuoi** script dal vederlo. Se un evento di analytics o di pixel si attiva ovunque tranne che sull'icona del carrello, questo è il motivo.

Imposta questa opzione a `true` per smettere di silenziare il clic:

```js theme={"theme":{"light":"snazzy-light","dark":"github-dark"}}
window.aftersell.cart.configure({ skip_open_cart_interceptor: true });
```

I tuoi listener vengono quindi eseguiti, e il drawer si apre comunque esattamente come prima. Il clic inoltre continua a non navigare verso `/cart`.

<Warning>
  **Fa meno di quanto il nome suggerisca.** Non salta l'interceptor dell'icona del carrello. Impedisce solo che silenzi altri listener. Aftersell continua a gestire il clic e continua ad aprire il tuo carrello. Per un controllo che Aftersell debba ignorare completamente, usa invece la classe `aftersell-cart-wont-open-cart`; vedi [Intercettazione dell'add-to-cart](/it/aftersell/cart/add-to-cart-interception#the-cart-icon-is-separate).
</Warning>

A differenza di [`skip_add_to_cart_interceptor`](#skip_add_to_cart_interceptor), questa viene letta **a ogni clic**, quindi puoi impostarla in qualunque momento e ha effetto immediatamente: da `ready()`, da un handler di evento o in modo condizionale per pagina.

<Note>
  Alcuni temi rispondono da soli anche al clic sull'icona del carrello. Una volta che Aftersell smette di silenziarlo, un tema che apre il proprio drawer lo farà accanto al tuo. Se vedi due carrelli dopo aver attivato questa opzione, aggiungi la classe `aftersell-cart-wont-open-cart` all'icona del tema e apri il carrello dal tuo handler con [`actions.open()`](/it/aftersell/cart/sdk-actions#open-and-close).
</Note>

<div id="money_format">
  ## money\_format
</div>

Sovrascrive il [formato monetario di Shopify](https://shopify.dev/docs/api/liquid/filters/money) che [`formatMoney`](/it/aftersell/cart/sdk-actions#formatmoneycents) usa. Per impostazione predefinita è il formato del tuo store; se non è disponibile, i prezzi ripiegano su `$X.XX`.

```js theme={"theme":{"light":"snazzy-light","dark":"github-dark"}}
window.aftersell.cart.configure({ money_format: '${{amount}} USD' });

// Later:
window.aftersell.cart.actions.formatMoney(5779); // "$57.79 USD"
```

Poiché `configure` fonde i valori e `formatMoney` legge il valore corrente, puoi cambiare il formato a runtime, per esempio quando scatta un cambio di valuta:

```js theme={"theme":{"light":"snazzy-light","dark":"github-dark"}}
window.myTheme.onCurrencyChange((currency) => {
  window.aftersell.cart.configure({ money_format: FORMATS[currency] });
  window.aftersell.cart.actions.visualRefresh(); // repaint prices already on screen
});
```

<Note>
  Questo cambia il modo in cui l'SDK e il carrello *mostrano* i prezzi. Non cambia la valuta addebitata all'acquirente; quella è Shopify Markets.
</Note>

<div id="where-to-go-next">
  ## Dove andare adesso
</div>

* **[Azioni](/it/aftersell/cart/sdk-actions)**: leggi e modifica il carrello.
* **[Hook](/it/aftersell/cart/sdk-hooks)**: controllo per singolo form e per singola riga, dove `configure` è troppo generico.
* **[Casi d'uso](/it/aftersell/cart/sdk-use-cases)**: soluzioni complete alle richieste più comuni.