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

# Présentation du package Blaze

> Comment accélérer le rendu des composants Blade grâce à Blaze, le package officiel de Livewire. Critères de choix entre compile / memo / fold, installation, limitations et fonctionnement interne.

<Info>
  Cet article s'appuie sur le README de [livewire/blaze](https://github.com/livewire/blaze) comme source primaire. À l'heure actuelle, il n'existe pas de documentation dédiée à Blaze sur laravel.com.
</Info>

## Qu'est-ce que Blaze ?

[Blaze](https://github.com/livewire/blaze) est un package officiel de Livewire qui accélère le rendu des composants Blade. Il s'applique non seulement aux composants Livewire, mais aussi aux composants Blade anonymes classiques.

Le README présente, pour un benchmark de 25 000 rendus d'un composant anonyme, un passage de **500 ms → 13 ms** (soit une réduction d'environ **97,4 %**). Selon les scénarios, des réductions de 91 à 97 % sont également signalées.

## Trois stratégies d'optimisation

Blaze propose trois stratégies : `compile` (par défaut), `memo` et `fold`.

```mermaid theme={null}
flowchart LR
    A["Appel du composant"] --> B["compile<br>Compilation en fonction"]
    A --> C["memo<br>Mémoïsation des mêmes props"]
    A --> D["fold<br>HTML généré à la compilation"]
    B --> E["Grande compatibilité et forte amélioration"]
    C --> F["Efficace pour les rendus répétés"]
    D --> G["Performance maximale mais à manier avec soin"]
```

### Laquelle choisir ?

| Stratégie | Quand la choisir                                                 | Avantages                                                           | Précautions                                                                      |
| --------- | ---------------------------------------------------------------- | ------------------------------------------------------------------- | -------------------------------------------------------------------------------- |
| `compile` | Stratégie standard à choisir en premier                          | Grande compatibilité, gain de performance facile sans configuration | Vérifier les limitations communes                                                |
| `memo`    | Icônes, badges, etc. rendus plusieurs fois avec les mêmes props  | Réduit le coût des rendus après le premier                          | Inutilisable pour les composants avec slot                                       |
| `fold`    | UI statiquement déterminable, pour viser la performance maximale | Élimine presque toute la surcharge d'exécution                      | Gérer avec soin l'état global et les valeurs dynamiques sous peine d'incohérence |

En cas de doute, **commencer par `compile`** puis appliquer `memo` / `fold` uniquement aux points où un goulot d'étranglement a été identifié est la démarche la plus sûre.

## Installation et activation

```bash theme={null}
composer require livewire/blaze:^1.0
```

Il existe deux méthodes d'activation.

### 1) Ajouter `@blaze` à un composant individuel

```blade theme={null}
@blaze

<button {{ $attributes }}>
    {{ $slot }}
</button>
```

Vous pouvez changer de stratégie au besoin.

```blade theme={null}
@blaze(memo: true)
@blaze(fold: true)
```

### 2) Activer par répertoire avec `Blaze::optimize()`

```php theme={null}
use Livewire\Blaze\Blaze;

public function boot(): void
{
    Blaze::optimize()
        ->in(resource_path('views/components'));
}
```

Après activation, videz les vues compilées.

```bash theme={null}
php artisan view:clear
```

<Tip>
  `@blaze` convient à un usage « pour commencer », tandis que `Blaze::optimize()` est adapté à une application large en production. Le README recommande également une application progressive en démarrant par un répertoire limité.
</Tip>

## Limitations

Voici les limitations explicitement mentionnées dans le README.

* Les composants basés sur des classes ne sont pas pris en charge
* La variable `$component` n'est pas utilisable
* Les View composers / creators / lifecycle events ne sont pas déclenchés
* L'injection automatique des variables de `View::share()` n'est pas prise en charge (utilisez explicitement `$__env->shared('key')` si nécessaire)
* `@aware` entre Blade et Blaze a des limitations (parent et enfant doivent tous deux être côté Blaze)
* Il n'est pas possible d'effectuer le rendu direct d'un composant Blaze avec `view()` (uniquement via une balise de composant)

## Compatibilité avec Flux UI

Le README de Blaze indique que si vous utilisez [Flux UI](https://fluxui.dev/docs/installation), **il suffit d'installer Blaze pour l'utiliser, sans configuration supplémentaire**.

## Fonctionnement en résumé

Le Blade classique passe à chaque fois par une pipeline de rendu qui inclut la résolution des composants et le traitement des attributs. La stratégie `compile` de Blaze compile cette pipeline en une fonction PHP optimisée appelée directement, ce qui réduit considérablement la surcharge de la pipeline.

Comme l'explique le README, la différence conceptuelle est la suivante.

* Standard : exécution du rendu Blade à chaque fois
* Blaze `compile` : appel direct d'une fonction compilée
* Blaze `fold` : intégration du HTML à la compilation, réduisant encore les calculs à l'exécution

`fold` est le plus rapide, mais tout élément rompant le caractère statique (état d'authentification, valeurs dépendantes de la requête, de la session ou du temps, etc.) peut être source de dysfonctionnements. Ne l'appliquez qu'aux zones à forte charge, en vérifiant le comportement au fur et à mesure.


## Related topics

- [Présentation de Laravel Wayfinder](/fr/blog/wayfinder-introduction.md)
- [Laravel Agent Detector — package de détection d'agents IA](/fr/blog/agent-detector-introduction.md)
- [Construire une SPA avec Inertia.js](/fr/blog/inertia-introduction.md)
- [Se lancer dans les tests Laravel avec Pest PHP](/fr/blog/pest-introduction.md)
- [VOICEVOX for Laravel](/fr/packages/laravel-voicevox/index.md)