
# InnerBlocks

I blocchi interni consentono di inserire altri blocchi nei vostri blocchi. Dietro le quinte, Blockstudio usa il componente
[InnerBlocks](https://developer.wordpress.org/block-editor/how-to-guides/block-tutorial/nested-blocks-inner-blocks/).
Tenete presente che è possibile usare un solo componente InnerBlocks per blocco: si tratta di una limitazione di WordPress.

## Utilizzo di base

Per usare InnerBlocks, aggiungete il componente `<InnerBlocks />` al template del blocco:

```php title="index.php"
<InnerBlocks />
```

La composizione dipende da voi. Potete annidare il componente `InnerBlocks` quanto volete oppure usarlo da solo.

## Proprietà

### allowedBlocks

La proprietà `allowedBlocks` consente di definire quali blocchi possono essere inseriti nel componente `InnerBlocks`.


#### PHP

```php title="index.php"
<InnerBlocks allowedBlocks="<?php echo esc_attr(wp_json_encode(['core/heading', 'core/paragraph'])); ?>" />
```

#### Twig

```twig title="index.twig"
<InnerBlocks allowedBlocks="{{ ['core/heading', 'core/paragraph']|json_encode|escape('html_attr') }}" />
```

`allowedBlocks` accetta anche token espansi lato server. I token vengono espansi prima che l'editor riceva il template, mentre i nomi letterali dei blocchi rimangono invariati.

| Token | Descrizione |
|-------|-------------|
| `namespace/*` | Ogni blocco registrato in quel namespace |
| `category:<slug>` | Ogni blocco registrato nella categoria WordPress dei blocchi |
| `@theme` | Ogni blocco Blockstudio registrato dal tema attivo |

Le voci espanse vengono deduplicate mantenendo l'ordine definito dall'autore:

```php title="index.php"
<InnerBlocks allowedBlocks="<?php echo esc_attr(wp_json_encode([
  'core/paragraph',
  'category:content',
  'bsui/field',
])); ?>" />
```

I token che non corrispondono ad alcun blocco vengono ignorati. L'output del frontend rimane invariato, perché `allowedBlocks` viene usato solo dall'editor.

### tag

Per impostazione predefinita, il componente `InnerBlocks` viene renderizzato come elemento `div`. Potete modificarlo usando la proprietà `tag`.

```php title="index.php"
<InnerBlocks tag="section" />
```

### template

La proprietà `template` consente di definire un template per il componente `InnerBlocks`.


#### PHP

```php title="index.php"
<InnerBlocks template="<?php echo esc_attr(wp_json_encode([
  ['core/heading', ['placeholder' => 'Book Title']],
  ['core/paragraph', ['placeholder' => 'Summary']]
])); ?>" />
```

#### Twig

```twig title="index.twig"
<InnerBlocks template="{{ [
  ['core/heading', { placeholder: 'Book Title' }],
  ['core/paragraph', { placeholder: 'Summary' }]
]|json_encode|escape('html_attr') }}" />
```

### templateLock

La proprietà `templateLock` consente di definire se il template può essere modificato.

| Valore | Descrizione |
|-------|-------------|
| `contentOnly` | Impedisce tutte le operazioni. I tipi di blocco senza contenuto sono nascosti nella vista elenco. I blocchi figli non possono sovrascrivere questa impostazione. |
| `all` | Impedisce tutte le operazioni. Non è possibile inserire, spostare o eliminare blocchi. |
| `insert` | Impedisce l'inserimento o la rimozione dei blocchi, ma consente di spostare quelli esistenti. |
| `false` | Impedisce l'applicazione del blocco, anche se un blocco genitore prevede un blocco. |

### renderAppender

La proprietà `renderAppender` consente di definire il tipo di inseritore di blocchi.

| Valore | Descrizione |
|-------|-------------|
| `default` | Mostra l’inseritore predefinito del blocco (l’inseritore in stile paragrafo quando è consentito il blocco paragrafo) |
| `button` | Mostra un pulsante con l’icona + come inseritore |

### useBlockProps

`useBlockProps` rimuoverà il wrapper esterno del componente `InnerBlocks`
all’interno dell’editor. Consultate [useBlockProps](https://blockstudio.dev/it/docs/blocks/react-components/useblockprops/) per ulteriori informazioni.

## Contesto

### Registrazione

Blockstudio supporta il contesto per il componente `InnerBlocks`. Questo consente di
passare dati dal blocco genitore ai blocchi figli. Sebbene utilizzi internamente
il WordPressmeccanismo di contesto[ core ](https://developer.wordpress.org/block-editor/reference-guides/block-api/block-context/),
Blockstudio offre un API più pratico.

Invece di dover definire separatamente tutti gli attributi da passare nel contesto,
potete semplicemente iscrivervi a tutti gli attributi di un blocco genitore.

Ogni figlio riceve i valori del proprio genitore, anche durante il primo rendering precaricato nell’editor. Aggiornando i campi di un provider si aggiornano i relativi figli nell’editor, anche mentre è ancora in caricamento un rendering precedente. I blocchi figli identici sotto provider diversi mantengono rendering memorizzati nella cache separati e consapevoli del contesto.

Supponiamo di avere una configurazione di blocchi contenitore come questa:

```json title="container/block.json"
{
  "$schema": "https://blockstudio.dev/schema/block",
  "name": "blockstudio/container",
  "title": "Container",
  "category": "design",
  "icon": "star-filled",
  "description": "Container block.",
  "blockstudio": {
    "attributes": [
      {
        "id": "full-width",
        "type": "toggle",
        "label": "Makes section full width"
      }
    ]
  }
}
```

Nel blocco figlio, usate semplicemente la proprietà `usesContext` con il nome
del blocco genitore per accedere a tutti gli attributi del genitore nel template del blocco.

```json title="element/block.json"
{
  "$schema": "https://blockstudio.dev/schema/block",
  "name": "blockstudio/element",
  "title": "Element",
  "category": "design",
  "icon": "star-filled",
  "description": "Element block.",
  "usesContext": ["blockstudio/container"],
  "parent": ["blockstudio/container"],
  "blockstudio": true
}
```

### Template

Le variabili `$context` e `$c` sono disponibili nei template dei blocchi per
accedere a tutti gli attributi del genitore. I blocchi figli verranno ricaricati
automaticamente nell’editor se i dati del genitore cambiano.


#### PHP

```php title="index.php"
<?php $container = $context['blockstudio/container']; ?>

<h1>
  <?php echo $container['full-width']
      ? 'is full width'
      : 'no full width'; ?>
</h1>
```

#### Twig

```twig title="index.twig"
{% set container = context['blockstudio/container'] %}

<h1>
  {{ container['full-width']
      ? 'is full width'
      : 'no full width' }}
</h1>
```

## Wrapper del frontend

`InnerBlocks` deve renderizzare un elemento wrapper attorno ai suoi figli
nell’editor; tuttavia, è possibile rimuoverlo dal frontend utilizzando il
filtro `blockstudio/blocks/components/inner_blocks/frontend/wrap`.

```php title="functions.php"
add_filter('blockstudio/blocks/components/inner_blocks/frontend/wrap', function($wrap, $block) {
  return false; // Remove wrapper
}, 10, 2);
```

## Restituzione anticipata

Se volete terminare in anticipo il metodo `render` del vostro blocco, potete
verificare se la variabile `$innerBlocks` è vuota. È utile quando non volete
renderizzare nulla se non sono presenti blocchi interni.

```php title="index.php"
<?php if (strip_tags($innerBlocks) === '') {
  return;
} ?>
<InnerBlocks tag="section" />
```

Poiché `<InnerBlocks/>` renderizza sempre un tag paragrafo vuoto, potete usare
la funzione `strip_tags` per verificare se il contenuto è vuoto.

## Template dinamici

I tipi di campo [Selezione](https://blockstudio.dev/it/docs/blocks/attributes/field-types/#select) e
[Pulsante di opzione](https://blockstudio.dev/it/docs/blocks/attributes/field-types/#radio) supportano la generazione dinamica del
`InnerBlocks` template in base al valore del campo. È utile se volete consentire
all’utente di selezionare un template diverso per il componente `InnerBlocks`.

Per farlo, aggiungete semplicemente una chiave `innerBlocks` all’array delle opzioni con il template:

```json title="block.json"
{
  "$schema": "https://blockstudio.dev/schema/block",
  "name": "blockstudio/dynamic-layout",
  "title": "Dynamic Layout",
  "blockstudio": {
    "attributes": [
      {
        "id": "layout",
        "type": "select",
        "label": "Layout",
        "options": [
          {
            "value": "1",
            "label": "Two Columns",
            "innerBlocks": [
              {
                "name": "core/columns",
                "innerBlocks": [
                  {
                    "name": "core/column",
                    "innerBlocks": [
                      {
                        "name": "core/heading",
                        "attributes": {
                          "content": "Left Heading",
                          "level": 1
                        }
                      }
                    ]
                  },
                  {
                    "name": "core/column",
                    "innerBlocks": [
                      {
                        "name": "core/heading",
                        "attributes": {
                          "content": "Right Heading",
                          "level": 1
                        }
                      }
                    ]
                  }
                ]
              }
            ]
          },
          {
            "value": "2",
            "label": "Single Column",
            "innerBlocks": [
              {
                "name": "core/heading",
                "attributes": {
                  "content": "Main Heading",
                  "level": 1
                }
              },
              {
                "name": "core/paragraph",
                "attributes": {
                  "content": "Main content goes here."
                }
              }
            ]
          }
        ],
        "allowNull": "Select a layout"
      }
    ]
  }
}
```


> **[Contesto e comunicazione tra blocchi](https://blockstudio.dev/it/guides/block-context/)**
>
> Scoprite come i blocchi genitore e figlio condividono i dati tramite il contesto.
