> ## 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

> Todas as opções de configure do SDK do Aftersell Cart: abertura do drawer, interceptação de adição ao carrinho, validação de formulário e formatação de valores.

`configure(config)` define como o carrinho se comporta. É uma **chamada de configuração**, então é segura logo no topo do seu script, antes de o carrinho carregar.

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

Você pode chamá-la mais de uma vez e os valores são mesclados. Uma chamada posterior sobrescreve apenas as chaves que nomeia, deixando o restante intacto.

<Warning>
  **Passar `undefined` limpa uma chave em vez de ignorá-la.** `configure({ open_on_add_to_cart: undefined })` redefine essa opção para o padrão, descartando o que uma chamada anterior definiu. Para deixar uma opção intocada, omita a chave por completo.
</Warning>

<div id="options">
  ## Opções
</div>

| Opção                                                           | Valores                            | Padrão          | Propósito                                                                   |
| --------------------------------------------------------------- | ---------------------------------- | --------------- | --------------------------------------------------------------------------- |
| [`open_on_add_to_cart`](#open_on_add_to_cart)                   | `'always'`, `'never'`, `'default'` | `'default'`     | Se o drawer abre quando um item é adicionado.                               |
| [`open_on_background_add`](#open_on_background_add)             | `boolean`                          | `false`         | Também abrir quando *outra coisa* adiciona ao carrinho.                     |
| [`validate_form_on_add_to_cart`](#validate_form_on_add_to_cart) | `boolean`                          | `false`         | Bloquear a adição se o formulário do produto for inválido.                  |
| [`skip_add_to_cart_interceptor`](#skip_add_to_cart_interceptor) | `boolean`                          | `false`         | Desativar completamente a interceptação de adição ao carrinho do Aftersell. |
| [`skip_open_cart_interceptor`](#skip_open_cart_interceptor)     | `boolean`                          | `false`         | Deixar um clique no ícone do carrinho chegar aos seus outros scripts.       |
| [`money_format`](#money_format)                                 | string                             | formato da loja | Substituir o formato usado por `formatMoney`.                               |

***

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

Controla se o drawer abre quando um comprador adiciona um produto.

| Valor       | Comportamento                                                                   |
| ----------- | ------------------------------------------------------------------------------- |
| `'always'`  | Sempre abre o drawer na adição.                                                 |
| `'never'`   | Nunca abre; o item é adicionado silenciosamente.                                |
| `'default'` | Segue a configuração **Open cart when an item is added** no editor de carrinho. |

```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' });
```

Um uso comum é manter o drawer fechado em uma página específica, deixando a configuração do lojista intacta em todos os outros lugares:

```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 você só quer isso ativado para a loja inteira, já existe uma configuração: **Cart settings → Content → Behavior → Open cart when an item is added**. Use `configure` quando a resposta depende da página, do comprador ou de algo que só o seu código sabe.
</Note>

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

Defina como `true` para também abrir o drawer em adições em **segundo plano** — aquelas que o Aftersell detectou mas não tratou por conta própria.

Uma adição conta como em segundo plano quando:

* ela chegou pelos [eventos padrão de carrinho do Shopify](https://shopify.dev/docs/storefronts/themes/best-practices/standard-events) (sempre tratada como segundo plano, seja qual for o gatilho), ou
* o Aftersell viu a requisição de carrinho na rede **sem** nenhum clique ou tecla confiável nos \~3 segundos anteriores — outro app ou script escrevendo no carrinho, por exemplo.

Uma adição que o Aftersell viu na rede e que *seguiu* um clique do comprador não é uma adição em segundo plano: ela já abre o drawer conforme `open_on_add_to_cart`, sem precisar desta opção.

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

Isto é um **portão adicional, não uma sobrescrita**: uma adição em segundo plano abre o drawer apenas se `open_on_add_to_cart` também a teria permitido. Com `open_on_add_to_cart: 'never'`, esta opção não faz nada.

<Tip>
  Recorra a isto quando um botão de adicionar de terceiros adiciona o item corretamente, mas deixa o drawer fechado. Se o item nunca chega ao carrinho, isso é um problema de interceptação. Veja [`skip_add_to_cart_interceptor`](#skip_add_to_cart_interceptor) e o [caso de uso de page builder](/pt/aftersell/cart/sdk-use-case-page-builder).
</Tip>

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

Executa a validação de formulário nativa do navegador (`reportValidity()`) antes de adicionar, e cancela a adição se o formulário for inválido. Use quando o seu formulário de produto tem campos obrigatórios (uma mensagem de gravação, uma nota de presente, um checkbox obrigatório) que os compradores atualmente conseguem pular.

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

O navegador mostra a própria mensagem de validação no campo problemático. Desativado por padrão, porque um tema com um atributo `required` esquecido em algum lugar do formulário de produto começaria a bloquear silenciosamente a adição ao carrinho.

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

Desativa completamente a interceptação de adição ao carrinho do Aftersell. Para saber o que a interceptação faz e todas as formas de sair dela, veja [Interceptação do adicionar ao carrinho](/pt/aftersell/cart/add-to-cart-interception).

O tema então realiza a adição por conta própria, e todo script escutando aquele submit volta a rodar. O Aftersell ainda observa a requisição de carrinho na rede, então o drawer abre como de costume. Você não perde isso ao optar por sair. Em temas que o Aftersell reconhece, o próprio carrinho do tema permanece inerte, então você não fica com dois carrinhos. Em um tema que ele não reconhece, o tema pode abrir o próprio carrinho ao lado do seu; veja [O carrinho do tema também vai abrir?](/pt/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>
  Esta opção é lida **uma vez, na inicialização**. Só funciona a partir de uma chamada de configuração que roda antes de o carrinho carregar: o script de **Initialization** do seu carrinho. Defini-la depois (dentro de `ready()` ou em um handler de evento) não tem efeito e falha silenciosamente.
</Warning>

Este é um instrumento bruto que desativa a interceptação para todos os formulários da página. Para isentar apenas um formulário, use o hook [`registerSkipAddToCartRule`](/pt/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>

Clicar no ícone do carrinho abre o drawer do Aftersell. Para fazer isso de forma confiável, o Aftersell interrompe o clique para que nada mais na página o trate, o que também impede que os **seus** scripts o vejam. Se um evento de analytics ou de pixel dispara em toda parte, menos no ícone do carrinho, é por isso.

Defina como `true` para parar de silenciar o clique:

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

Seus listeners então rodam, e o drawer ainda abre exatamente como antes. O clique também continua sem navegar para `/cart`.

<Warning>
  **Isto faz menos do que o nome sugere.** Não pula o interceptor do ícone do carrinho. Só o impede de silenciar outros listeners. O Aftersell ainda trata o clique e ainda abre o seu carrinho. Para um controle que o Aftersell deve ignorar completamente, use a classe `aftersell-cart-wont-open-cart` no lugar; veja [Interceptação do adicionar ao carrinho](/pt/aftersell/cart/add-to-cart-interception#the-cart-icon-is-separate).
</Warning>

Ao contrário de [`skip_add_to_cart_interceptor`](#skip_add_to_cart_interceptor), esta é lida **a cada clique**, então você pode defini-la em qualquer ponto e ela passa a valer imediatamente: a partir de `ready()`, de um handler de evento ou condicionalmente por página.

<Note>
  Alguns temas também respondem ao clique no ícone do carrinho por conta própria. Uma vez que o Aftersell deixa de silenciá-lo, um tema que abre o próprio drawer vai fazê-lo ao lado do seu. Se você vir dois carrinhos depois de ativar isso, adicione a classe `aftersell-cart-wont-open-cart` ao ícone do tema e abra o carrinho a partir do seu próprio handler com [`actions.open()`](/pt/aftersell/cart/sdk-actions#open-and-close).
</Note>

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

Substitui o [formato de moeda do Shopify](https://shopify.dev/docs/api/liquid/filters/money) que [`formatMoney`](/pt/aftersell/cart/sdk-actions#formatmoneycents) usa. O padrão é o formato da sua loja; se ele estiver indisponível, os preços recorrem a `$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"
```

Como `configure` mescla e `formatMoney` lê o valor atual, você pode alterar o formato em tempo de execução, por exemplo quando um seletor de moeda dispara:

```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>
  Isto altera como o SDK e o carrinho *exibem* preços. Não altera a moeda cobrada do comprador; isso é o Shopify Markets.
</Note>

<div id="where-to-go-next">
  ## Para onde ir agora
</div>

* **[Ações](/pt/aftersell/cart/sdk-actions)**: leia e altere o carrinho.
* **[Hooks](/pt/aftersell/cart/sdk-hooks)**: controle por formulário e por linha, quando `configure` é amplo demais.
* **[Casos de uso](/pt/aftersell/cart/sdk-use-cases)**: soluções completas para pedidos comuns.