# Symfony 8.2 : AssetMapper, import maps ciblées et JavaScript sans bundler

> Symfony 8.2 améliore AssetMapper : import maps ciblées, SRI, mises à jour npm différées et métadonnées hors public. Tutoriel, limites et migration.

Développement web · Symfony 8.2 et AssetMapper

## Symfony 8.2 : AssetMapper, import maps ciblées et JavaScript sans bundler

Symfony 8.2 modernise AssetMapper : import maps plus ciblées, intégrité SRI, mises à jour maîtrisées et nouveaux réglages de production. Exemples PHP, Twig et méthode de test.

![Symfony-8-2-AssetMapper-Infographic.webp](https://sdx-development.com/media/News/Symfony-8-2-AssetMapper-Infographic.webp?v=1794343843)

[Développement web](https://sdx-development.com/actualites/developpement-web)Publié le 10 novembre 2026 à 21:47

Faut-il vraiment installer et maintenir une chaîne de compilation JavaScript pour chaque application Symfony ? AssetMapper permet déjà de servir du CSS et des modules JavaScript modernes sans bundler. Avec **Symfony 8.2**, il devient plus intéressant sur les sites professionnels et les logiciels métier possédant plusieurs points d’entrée : **import maps ciblées, intégrité des ressources, mises à jour des packages mieux contrôlées et déploiement plus souple**.

 

Ces nouveautés ont été détaillées par Symfony le **10 novembre 2026**. Il ne s’agit pas encore de la sortie stable de Symfony 8.2 : **Symfony 8.2.0-BETA1 est disponible depuis le 4 novembre** et la version finale est annoncée pour novembre 2026. Le moment est donc idéal pour tester leur impact sans confondre une fonction en bêta avec un changement déjà déployé sur tous les sites Symfony.

 

Voici les six évolutions officielles, un exemple concret associant vitrine et administration, une méthode de mesure dans le navigateur et les cas où Vite ou Webpack Encore demeurent de meilleurs choix.

 

À retenir 

## Moins de configuration, mais des performances à mesurer

 

Symfony 8.2 introduit le filtrage ` importmap_entries: reachable `, les empreintes SRI et l’option ` minimum_release_age `. Il permet aussi de télécharger un fichier de package brut, d’éviter les métadonnées compilées en mode debug et de stocker ces métadonnées hors du répertoire public. **Une import map plus courte ne signifie pas automatiquement moins de JavaScript téléchargé.**

 

**Dans cet article** 

[État de sortie](https://sdx-development.com/actualites/developpement-web/symfony-8-2-assetmapper-importmaps-javascript-sans-bundler#etat)[AssetMapper](https://sdx-development.com/actualites/developpement-web/symfony-8-2-assetmapper-importmaps-javascript-sans-bundler#rappel)[6 nouveautés](https://sdx-development.com/actualites/developpement-web/symfony-8-2-assetmapper-importmaps-javascript-sans-bundler#nouveautes)[Tutoriel](https://sdx-development.com/actualites/developpement-web/symfony-8-2-assetmapper-importmaps-javascript-sans-bundler#tutoriel)[Mesurer](https://sdx-development.com/actualites/developpement-web/symfony-8-2-assetmapper-importmaps-javascript-sans-bundler#mesurer)[Migration](https://sdx-development.com/actualites/developpement-web/symfony-8-2-assetmapper-importmaps-javascript-sans-bundler#deploiement)[AssetMapper ou Vite ?](https://sdx-development.com/actualites/developpement-web/symfony-8-2-assetmapper-importmaps-javascript-sans-bundler#choix)[FAQ](https://sdx-development.com/actualites/developpement-web/symfony-8-2-assetmapper-importmaps-javascript-sans-bundler#faq)[Sources](https://sdx-development.com/actualites/developpement-web/symfony-8-2-assetmapper-importmaps-javascript-sans-bundler#sources)

 

## Symfony 8.2 : une bêta disponible, une sortie stable encore attendue

 

La publication du **10 novembre 2026** concerne la présentation des améliorations d’AssetMapper. Celles-ci figurent déjà dans le changelog de **Symfony 8.2.0-BETA1** publié le 4 novembre. Le calendrier Symfony annonce une sortie stable en novembre 2026, sans date précise confirmée dans les pages officielles consultées.

 

Symfony 8.2 demande **PHP 8.4 ou plus récent**. Au 10 novembre, Symfony 8.1 reste la branche stable courante ; Symfony 7.4 est une branche LTS maintenue. Une équipe utilisant Symfony 7.4 ou PHP 8.2/8.3 ne doit donc pas copier cette configuration sur son serveur actuel en supposant qu’elle y sera reconnue.

 

Statut de version 

## Préparer les tests, puis confirmer sur la stable

 

Ce guide décrit des options annoncées et présentes dans la bêta Symfony 8.2. La validation finale des comportements, des compatibilités et des coûts d’exploitation doit être réalisée sur les versions réellement déployées.

 

## À quoi sert AssetMapper dans un projet Symfony ?

 

AssetMapper associe des chemins logiques à des fichiers CSS, JavaScript, images et autres ressources, génère des URL versionnées et s’appuie sur les **import maps natives du navigateur** pour résoudre les imports de modules. Dans un template Twig, ` {{ importmap('app') }} ` produit les éléments nécessaires au chargement du point d’entrée ` app `.

 

Il ne faut pas confondre **l’absence de bundler dans la chaîne de livraison des modules JavaScript standards** avec l’absence totale d’outillage. Un projet TypeScript peut encore nécessiter une étape de transformation, et les applications React/Vue complexes utilisent souvent leurs outils frontend dédiés. AssetMapper ne concatène ni ne minifie automatiquement les fichiers comme le ferait une configuration de build traditionnelle.

 

Projet adapté 

### Symfony, Twig, Stimulus, modules natifs

 

Une application orientée serveur, avec plusieurs pages, un espace client et une administration, peut gérer des scripts ciblés et des dépendances maîtrisées sans bundler généraliste.

 

Projet à évaluer 

### SPA lourde, Vue SFC, nombreux imports transformés

 

Un frontend riche nécessitant transformations complexes, JSX ou composants ` .vue ` peut rester plus simple à exploiter avec Vite, Encore ou l’outillage du framework choisi.

 

## Les six améliorations d’AssetMapper annoncées dans Symfony 8.2

 

| Nouveauté | Utilité | Vigilance |
| --- | --- | --- |
| ` importmap_entries: reachable ` | Ne rendre que les entrées accessibles depuis la page | Imports dynamiques à nom calculé |
| ` importmap_integrity_algorithms ` | Ajouter des empreintes d’intégrité aux ressources | Ne remplace pas audit et CSP |
| ` minimum_release_age ` | Retarder certaines mises à jour de packages | Ne s’applique pas à ` importmap:require ` |
| ` --no-esm ` | Télécharger le fichier fourni par le package | Imports nus à résoudre et format du fichier à vérifier |
| Debug sans métadonnées compilées | Retrouver les fichiers source sans nettoyage manuel | Comportement lié au mode debug |
| ` metadata_dir ` | Déplacer les métadonnées PHP hors du public | Adapter l’artefact de déploiement |

 

### 1. Import maps ciblées : la nouveauté la plus visible pour un site multipage

 

Jusqu’ici, l’appel Twig ` importmap() ` rendait toutes les entrées de ` importmap.php ` même lorsque la page ne lançait qu’un seul point d’entrée. Un formulaire public pouvait ainsi contenir dans son HTML des définitions de modules réservés à la partie administration. **Ces définitions n’impliquaient pas forcément le téléchargement des modules**, mais elles augmentaient la taille de la carte rendue et exposaient des noms d’entrées inutiles sur cette page.

 

Avec ` importmap_entries: reachable `, Symfony garde les entrées atteignables depuis les points d’entrée passés à ` importmap() `. Le calcul inclut les imports statiques et les imports dynamiques dont le chemin est connu. En revanche, un ` import(nomCalcule) ` ne peut pas être suivi statiquement : il faut tester ou adapter ce cas. **La valeur par défaut reste ` all `**, précisément pour éviter des ruptures inattendues.

 

### 2. Subresource Integrity : vérifier les fichiers que reçoit le navigateur

 

L’option ` importmap_integrity_algorithms ` génère des empreintes cryptographiques, par exemple en ` sha384 `. Lorsqu’elle est activée, ` importmap() ` ajoute une entrée d’intégrité à l’import map et un attribut ` integrity ` aux liens ` modulepreload ` et aux feuilles de style correspondantes. Les algorithmes pris en charge sont ` sha256 `, ` sha384 ` et ` sha512 `.

 

Cette vérification apporte une protection contre l’altération des fichiers chargés, mais elle **ne démontre pas que le package est sain** : un fichier compromis au moment où son empreinte est calculée reste un fichier compromis. Elle ne remplace ni Content Security Policy, ni revue des dépendances, ni contrôles applicatifs.

 

### 3. Un âge minimal avant certaines mises à jour de packages

 

L’option ` minimum_release_age ` s’exprime en secondes. Une valeur de ` 604800 ` impose un délai de sept jours pour les versions éligibles lors de ` importmap:update `. Symfony ignore également les préversions et certaines versions au-delà de l’étiquette ` latest `. La commande ` importmap:outdated ` affiche une colonne *Withheld* pour les versions mises en attente.

 

Cette précaution n’est pas un correctif universel contre les attaques de chaîne d’approvisionnement : elle sert à éviter d’adopter immédiatement toutes les versions publiées. Surtout, **` importmap:require ` n’est pas soumis à ce délai**. Les vérifications téléchargent désormais des métadonnées npm complètes afin de connaître les dates de publication, ce qui peut alourdir cette étape.

 

### 4. Charger le fichier brut d’un package avec ` --no-esm `

 

Par défaut, AssetMapper utilise la transformation ESM fournie par jsDelivr pour les dépendances récupérées. Si cette transformation pose problème, la nouvelle option ` --no-esm ` demande le fichier publié par le package lui-même. Elle exige de fournir le chemin précis du fichier à importer.

 

Symfony prend alors en charge les imports relatifs du type ` ./chunk.js `, mais ne résout pas automatiquement les imports nus tels que ` import { h } from 'preact' ` : les packages correspondants doivent être ajoutés explicitement. **Télécharger un fichier brut ne garantit pas qu’il soit compatible avec un import ESM natif** ; il faut vérifier le format publié par l’auteur.

 

### 5. Les assets compilés ne masquent plus les modifications en debug

 

Dans les versions précédentes, exécuter ` asset-map:compile ` sur sa machine pouvait laisser des métadonnées compilées qui prenaient le dessus sur les sources en développement. Les changements JavaScript/CSS semblaient alors ne plus s’afficher tant que l’on n’effaçait pas ` public/assets/ `. En Symfony 8.2, quand **le mode debug est activé**, ces métadonnées sont ignorées au profit des sources. Cela simplifie les allers-retours entre tests de build et développement.

 

### 6. Déplacer les métadonnées compilées hors de ` public/ `

 

` asset-map:compile ` génère notamment ` manifest.json `, ` importmap.json ` et des fichiers ` entrypoint.*.json `. Ces métadonnées sont lues par PHP mais leur emplacement par défaut, dans les assets publics, les rend accessibles via HTTP. Le nouveau paramètre ` metadata_dir ` permet de les placer, par exemple, dans ` var/assets `.

 

Ce déplacement facilite l’organisation des artefacts. Il faut néanmoins vérifier que le processus PHP peut lire ce répertoire et que la procédure de déploiement le conserve ou le régénère. Cela **ne transforme pas les métadonnées en coffre à secrets** : aucune donnée confidentielle ne devrait y être stockée.

 

## Tutoriel : des import maps plus ciblées entre vitrine et administration

 

Prenons une application Symfony qui possède une partie publique légère et une administration avec tableaux et composants interactifs. Nous voulons éviter de rendre les définitions JavaScript propres à l’administration dans l’import map d’une page publique. Les extraits suivants illustrent le principe ; ils doivent être adaptés aux noms d’assets et dépendances du projet.

 

### 1. Vérifier l’installation et les points d’entrée

 

Pour un projet ne disposant pas encore d’AssetMapper, l’installation documentée est :

 

```
composer require symfony/asset-mapper symfony/asset symfony/twig-pack
php bin/console debug:asset-map
```

 

Avec Symfony Flex, on obtient notamment ` assets/app.js `, ` importmap.php ` et un appel ` importmap('app') ` dans le template. Pour notre scénario, ajoutons le fichier ` assets/admin.js ` et déclarons deux points d’entrée :

 

```
<?php
// importmap.php
return [
    'app' => [
        'path' => './assets/app.js',
        'entrypoint' => true,
    ],
    'admin' => [
        'path' => './assets/admin.js',
        'entrypoint' => true,
    ],
];
```

 

Dans l’application réelle, conservez aussi les entrées de dépendances déjà présentes dans ` importmap.php ` : cet extrait ne représente volontairement que les points d’entrée.

 

### 2. Définir une seule import map par page Twig

 

Le template de base charge ` app `. Pour l’administration, on charge les deux points d’entrée par un seul appel à ` importmap() ` :

 

```
{# templates/base.html.twig #}
{% block javascripts %}
    {% block importmap %}
        {{ importmap('app') }}
    {% endblock %}
{% endblock %}

{# templates/admin/dashboard.html.twig #}
{% extends 'base.html.twig' %}
{% block importmap %}
    {{ importmap(['app', 'admin']) }}
{% endblock %}
```

 

**N’appelez pas ` parent() ` dans ce bloc Twig** : l’import map doit être rendue une seule fois dans la page. Les imports du point d’entrée ` admin ` ne seront pas exécutés dans une page qui ne charge que ` app `.

 

### 3. Activer les entrées atteignables et l’intégrité

 

Sur une branche de test utilisant Symfony 8.2, les réglages peuvent être regroupés dans ` config/packages/asset_mapper.yaml ` :

 

```
# config/packages/asset_mapper.yaml
framework:
    asset_mapper:
        importmap_entries: reachable
        importmap_integrity_algorithms: ['sha384']
        minimum_release_age: 604800
        metadata_dir: '%kernel.project_dir%/var/assets'
```

 

Ces quatre options ont des buts différents : ` reachable ` modifie le contenu de l’import map de la page ; ` sha384 ` ajoute les empreintes ; ` minimum_release_age ` agit lors des mises à jour ; ` metadata_dir ` concerne la localisation des métadonnées compilées. **Elles ne constituent pas un interrupteur unique « plus de performances ».**

 

### 4. Contrôler les imports dynamiques avant activation

 

Les modules importés via un chemin littéral sont suivis :

 

```
// assets/app.js
document.querySelector('#open-help')?.addEventListener('click', async () => {
    const module = await import('./help-panel.js');
    module.openHelp();
});
```

 

En revanche, le cas suivant repose sur une expression calculée dont Symfony ne peut pas déterminer toutes les valeurs potentielles pendant l’analyse :

 

```
// À auditer avant de choisir importmap_entries: reachable
const name = window.currentWidgetName;
const widget = await import(name);
```

 

Si l’application contient des imports calculés ou des plugins chargés à partir d’une configuration dynamique, testez explicitement tous les chemins concernés, ou conservez temporairement le comportement ` all ` dans l’attente d’une adaptation.

 

### 5. Contrôler les packages tiers

 

La revue d’une dépendance peut commencer par :

 

```
php bin/console importmap:outdated
php bin/console importmap:audit
# Mettre à jour seulement après validation
php bin/console importmap:update
```

 

À partir de Symfony 8.2, la commande ` importmap:outdated ` permet de voir les versions retenues temporairement par le délai minimal. Pour un package dont la transformation ESM générée par jsDelivr échoue, Symfony donne cet exemple :

 

```
php bin/console importmap:require "fullcalendar/index.global.js=fullcalendar" --no-esm
```

 

Vérifiez ensuite la compatibilité réelle du fichier fourni, notamment s’il s’agit d’un build global et non d’un module ES. La possibilité de récupérer un fichier n’assure pas que son API sera importable comme un export JavaScript natif.

 

### 6. Préparer le build de production

 

L’étape de compilation continue de produire les assets versionnés destinés au serveur web :

 

```
APP_ENV=prod APP_DEBUG=0 php bin/console asset-map:compile
```

 

Si les métadonnées sont déplacées vers ` var/assets `, vérifiez le chemin sur le serveur final, les permissions de lecture de PHP et la présence des fichiers dans l’artefact livré. Le comportement de développement ne remplace pas le besoin de compiler ou d’exposer correctement les ressources en production.

 

## Quel impact réel sur les performances et le SEO technique ?

 

La première mesure à réaliser n’est pas un score Lighthouse : c’est **la différence de contenu entre les import maps** avec l’option par défaut ` all ` puis avec ` reachable `. On compare ensuite les ressources préchargées, le JavaScript réellement transféré et l’expérience utilisateur.

 

## Protocole de test sur un site représentatif

 
1. **Choisir deux pages.** Une page publique légère et une page administrative qui utilise des composants supplémentaires.
2. **Relever la configuration initiale.** Garder les mêmes versions de PHP, Symfony, packages, serveur et navigateur pendant les deux mesures.
3. **Comparer les import maps.** Mesurer la taille du script ` type="importmap" ` et compter les entrées présentes.
4. **Observer Network.** Identifier les requêtes réellement lancées, les préchargements et la quantité de JavaScript transférée.
5. **Tester les fonctionnalités.** Menus, contrôleurs Stimulus, imports différés, formulaires et interactions de l’administration.
6. **Mesurer plusieurs fois.** Conserver des résultats avec cache froid et chaud, puis comparer LCP et INP seulement si les parcours et la charge s’y prêtent.

 

On peut inspecter la carte dans la console du navigateur, sans installer de librairie supplémentaire :

 

```
const element = document.querySelector('script[type="importmap"]');
if (element) {
    const map = JSON.parse(element.textContent);
    console.table({
        imports: Object.keys(map.imports ?? {}).length,
        htmlCharacters: element.textContent.length
    });
}
```

 

Ce petit diagnostic montre le nombre de définitions de modules et le volume textuel de la carte, **pas le poids total des fichiers téléchargés**. Une import map peut contenir 100 entrées alors qu’une page n’exécute qu’un module. Pour affirmer un gain réseau ou Core Web Vitals, il faut constater une modification des requêtes ou du travail navigateur, pas seulement compter les lignes HTML en moins.

 

SEO technique 

## Une amélioration d’architecture n’est pas un bonus Google automatique

 

Réduire du code inutile, améliorer le chargement et simplifier les dépendances peut contribuer à une meilleure expérience utilisateur. Mais aucun changement AssetMapper n’assure à lui seul un meilleur classement SEO. La mesure doit partir de données terrain et des parcours réellement utilisés.

 

## Migration : comment préparer Symfony 8.2 sans casser les assets ?

 

Une mise à niveau vers Symfony 8.2 doit commencer par le socle technique : **PHP 8.4 minimum**, version des bundles, recettes Flex, configuration AssetMapper et tests automatisés. Le passage de Symfony 8.1 à 8.2 est différent d’une migration depuis une branche LTS plus ancienne, qui peut nécessiter des étapes intermédiaires.

 

Symfony fournit la procédure de préversion suivante pour un projet dont les contraintes de dépendances s’y prêtent :

 

```
# Uniquement sur une branche de test dédiée
composer config minimum-stability beta
composer config extra.symfony.require "8.2.*"
composer update
```

 

**Prudence :** ces commandes modifient la résolution des dépendances Composer et ne doivent pas être lancées telles quelles sur une production. L’annonce bêta précise qu’elles supposent des contraintes Symfony compatibles dans ` composer.json ` ; sinon il faut adapter ces contraintes. Vérifiez également ` composer.lock `, les tests et le plan de retour arrière.

 

## Checklist avant déploiement

 
1. **Auditer les versions.** Contrôler PHP, Symfony, AssetMapper, UX, Twig et les dépendances frontend.
2. **Conserver une base.** Capturer les import maps, logs, requêtes réseau et temps de chargement avant modification.
3. **Tester ` reachable ` séparément.** Valider chaque point d’entrée et les imports dynamiques, y compris ceux des contrôleurs Stimulus.
4. **Vérifier les empreintes.** Contrôler les attributs ` integrity `, l’absence d’erreurs de chargement et les règles CSP existantes.
5. **Préparer les mises à jour.** Examiner les packages retenus par ` minimum_release_age `, les vulnérabilités connues et les exceptions urgentes.
6. **Valider l’artefact.** Recompiler les assets en production, vérifier la présence et les permissions des métadonnées, puis tester les retours arrière.

 

Il est souvent plus utile de **tester une option à la fois** que d’activer simultanément tous les réglages : on identifie alors les effets mesurables et les régressions éventuelles.

 

## AssetMapper ou Vite / Webpack Encore : que choisir pour son projet ?

 

| Critère | AssetMapper | Vite ou Encore |
| --- | --- | --- |
| Site Symfony/Twig avec JS modéré | Souvent simple à maintenir | Possible mais peut ajouter une étape de build |
| Import maps et ES modules natifs | Au cœur de l’approche | Pas nécessairement utilisés en production |
| TypeScript | Transformation via outil/bundle dédié | Intégré à la chaîne frontend selon configuration |
| Vue SFC, JSX, transformations complexes | Moins direct | Souvent mieux adapté |
| Contrôle fin du bundling | Pas de bundling natif | Regroupement et optimisation configurables |
| Maintenance à long terme | Moins de chaîne Node à exploiter selon le projet | Écosystème riche, mais dépendances de build à suivre |

 

Pour un outil métier essentiellement rendu côté serveur, AssetMapper peut réduire le nombre de briques à gérer. Pour un tableau de bord construit comme une SPA ou nécessitant des transformations frontend avancées, **l’absence de bundler n’est pas une fin en soi** : Vite ou Encore peuvent rendre le projet plus compréhensible.

 

**Le choix SDX :** partir des usages, de l’équipe et du coût de maintenance. Les nouveautés Symfony 8.2 rendent AssetMapper plus flexible pour les applications multipages, mais elles ne rendent pas obsolètes les autres outils frontend.

 

## FAQ — Symfony 8.2 et AssetMapper

 

AssetMapper est-il nouveau dans Symfony 8.2 ?

 

Non. Il existe déjà et fonctionne en production dans des versions précédentes. La nouveauté du 10 novembre 2026 est l’annonce détaillée de six améliorations prévues pour Symfony 8.2.

 

La version Symfony 8.2 est-elle déjà stable ?

 

Non au 10 novembre 2026. Symfony 8.2.0-BETA1 est sortie le 4 novembre ; la version stable est prévue en novembre et requiert PHP 8.4 minimum.

 

Une import map ciblée charge-t-elle automatiquement moins de JS ?

 

Pas forcément. Elle réduit les définitions de modules rendues pour une page. Les modules réellement chargés dépendent des imports exécutés et des préchargements. Il faut vérifier les requêtes réseau.

 

` minimum_release_age ` bloque-t-il toutes les nouvelles dépendances ?

 

Non. Il limite certaines mises à jour réalisées par ` importmap:update `. Il n’est pas appliqué à ` importmap:require `, et ne remplace pas un audit des dépendances.

 

Peut-on utiliser TypeScript avec AssetMapper sans Node.js ?

 

AssetMapper sert les modules JavaScript. Pour du TypeScript, une transformation est nécessaire. Symfony renvoie notamment vers un bundle dédié ; il faut donc évaluer l’outillage requis selon le projet.

 

La nouvelle option SRI suffit-elle à sécuriser les packages ?

 

Non. Elle permet de vérifier l’intégrité de ressources servies au navigateur, mais pas leur innocuité au moment de la publication. Conservez les contrôles de versions, les audits, la CSP et la revue de code.

 

Consulter les sources officielles 6 références

 

- [Symfony — New in Symfony 8.2: AssetMapper Improvements](https://symfony.com/blog/new-in-symfony-8-2-assetmapper-improvements), annonce officielle du 10 novembre 2026 et exemples des six fonctionnalités.
- [Symfony — 8.2.0-BETA1 released](https://symfony.com/blog/symfony-8-2-0-beta1-released), annonce du 4 novembre 2026 et changelog.
- [Symfony — Fiche de la version 8.2](https://symfony.com/releases/8.2), statut, PHP minimum et calendrier.
- [Symfony Docs — AssetMapper](https://symfony.com/doc/current/frontend/asset_mapper.html), import maps, templates Twig, mises à jour, production et intégrations.
- [Symfony GitHub — Import map entries reachable (#65622)](https://github.com/symfony/symfony/pull/65622), implémentation et suivi du changement.
- [Symfony GitHub — Integrity metadata (#65078)](https://github.com/symfony/symfony/pull/65078), suivi de l’intégrité des ressources.

DÉVELOPPEMENT WEB

## Préparez les évolutions de votre application web.

Migration PHP, mise à jour de CMS ou évolution de framework : identifiez les points de compatibilité et validez les parcours essentiels avant la mise en ligne.

- Compatibilité des dépendances vérifiée
- Parcours essentiels testés en préproduction
- Mise en ligne avec possibilité de retour arrière

[Préparer votre évolution](https://sdx-development.com/contact)[Voir les expertises](https://sdx-development.com/expertises)

---

[Consulter la page HTML](https://sdx-development.com/actualites/developpement-web/symfony-8-2-assetmapper-importmaps-javascript-sans-bundler)
