> For the complete documentation index, see [llms.txt](https://doc.commandersact.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://doc.commandersact.com/fr/fonctionnalites/sources/sources-catalog/web/containers/setup-guides-for-developers/spa-implementation-guide.md).

# Guide d'implémentation SPA

### 1. Qu’est-ce**qu’un environnement SPA**? <a href="#id-1.-what-is-an-spa-environment" id="id-1.-what-is-an-spa-environment"></a>

Une SPA (Single Page Application) est un site web ou une application web qui charge des éléments de manière dynamique en fonction des actions de l’utilisateur, au lieu de charger de nouvelles pages après chaque interaction. Le conteneur web Commanders Act propose des fonctions permettant de charger tout ou partie du conteneur dans un environnement SPA, afin de déclencher les tags souhaités à chaque action effectuée par un utilisateur. Ces fonctions doivent être implémentées dans le code source de votre site par votre partenaire technique ou par votre propre équipe technique.

### 2.**Comment implémenter le conteneur web Commanders Act dans un environnement SPA**? <a href="#id-2.how-to-implement-tagcommander-in-an-spa-environment" id="id-2.how-to-implement-tagcommander-in-an-spa-environment"></a>

#### 2.1 Chargement des conteneurs <a href="#id-2.1-loading-containers" id="id-2.1-loading-containers"></a>

Les conteneurs web Commanders Act sont chargés une seule fois au chargement de la page dans un environnement Single Page Application. Pour recharger les conteneurs à la suite d’actions de l’utilisateur, vous pouvez utiliser les fonctionnalités suivantes :

* tC.container.reload() : cette fonction permet de recharger tous les conteneurs d’une page. Les éléments partagés par les conteneurs (calcul de la déduplication, initialisation des variables externes, calcul des variables internes, calcul des cookies déposés avec le stockage des données et initialisation du cookie Privacy) ne sont chargés qu’une seule fois afin d’optimiser les performances.

```
tC.container.reload({ exclusions: ["datastorage","deduplication","internalvars","privacy"], events: {label1: [{targeted_element},{event_variables}], label2: [{},{}]}})
```

Cette fonction permet de recharger tous les conteneurs d’une page tout en excluant certains de leurs éléments. Les éléments à exclure doivent être indiqués dans le tableau « exclusions ».\
\
Ex. : si vous souhaitez recharger le conteneur sans recalculer les variables internes, vous devez appeler cette fonction : tC.container.reload({exclusions:\["internalvars"]})\
\
Cette fonction permet également d’appeler la fonction tC.event, qui charge les tags sélectionnés à la suite d’une action de l’utilisateur. La fonction tC.event est exécutée après le rechargement des éléments du conteneur. label : indiquez le nom que vous souhaitez donner à votre fonction (ex. : « click », « add\_to\_cart »…). targeted\_element : éléments DOM auxquels l’événement s’applique. {} si nécessaire.\
\
event\_variables : variables propres à l’événement. {} si nécessaire. Ex. :

`tC.container.reload({events: {label1: [{target: document.getElementById('targeted_element'}, {"page_name":"", "product_id":""}]}})`

* tC.container\_IDS\_IDC.reload() : cette fonction permet de charger un seul conteneur (pour ce faire, vous devez préciser l’ID du site et celui du conteneur) sur une page qui en contient plusieurs.

IDS : ID du site Commanders Act\
IDC : ID du conteneur Commanders Act

* `tC.container_IDS_IDC.reload({ exclusions: ["datastorage","deduplication","internalvars","privacy"], events: {label1: [{targeted_element},{event_variables}], label2: [{},{}]} })`

Cette fonction permet de charger un seul conteneur (pour ce faire, vous devez préciser l’ID du site et celui du conteneur) sur une page qui en contient plusieurs, tout en excluant certains de ses éléments. Les éléments à exclure doivent être indiqués dans le tableau « exclusions » et les fonctions d’événement doivent être indiquées dans l’objet « events », comme pour la fonction `tC.container.reload({exclusions:["datastorage","deduplication","internalvars","privacy"]})`  .

#### 2.2 Chargement des tags <a href="#id-2.2-loading-tags" id="id-2.2-loading-tags"></a>

Pour charger les tags sélectionnés à la suite d’une action de l’utilisateur, vous devez implémenter cette fonction :

* `tC.event.label()`  : cette fonction permet de charger les tags sélectionnés à la suite d’une action de l’utilisateur.

label : indiquez le nom que vous souhaitez donner à votre fonction.\
\
Ex. : implémentez la fonction tC.event.step2\_basket si vous souhaitez appeler des tags spécifiques à la deuxième étape du panier d’achat.\
\
Vous pouvez également configurer une fonction « générique », comme tC.event.all, sur toutes vos pages virtuelles pour appeler les tags sur tous vos sites SPA (les tags Analytics, par exemple). Vous utiliserez ensuite les périmètres et les contraintes de l’interface Commanders Act pour contrôler l’exécution des autres tags.

* `tC.event.label(this, {"page_name":"", "product_id":""})`  : cette fonction permet de charger les tags sélectionnés en fonction de l’action de l’utilisateur et de définir des variables propres à cette action (ex. : le nom d’une page virtuelle, un ID de produit spécifique…).

#### 2.3 Pour aller plus loin : structure d’un conteneur web Commanders Act <a href="#id-2.3-going-further-structure-of-a-tagcommander-container" id="id-2.3-going-further-structure-of-a-tagcommander-container"></a>

Vous trouverez ci-dessous la liste de tous les éléments chargés dans le conteneur web Commanders Act lors du premier chargement, ainsi que les fonctions tC.container.reload, (tC.container\_IDS\_IDC.reload()) et tC.event.XXX() appelées.

| Élément du conteneur                                                                             | Définition                                                                                                                                                         | Premier chargement du conteneur | Fonction tC.container.reload() | Fonction tC.container\_IDS\_IDC.reload() | Fonction tC.event.XXX() |
| ------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------- | ------------------------------ | ---------------------------------------- | ----------------------- |
| Fonctions de déduplication                                                                       | Elles identifient la source du trafic du visiteur                                                                                                                  | oui                             | Oui (une fois chargé)          | oui                                      | non                     |
| Initialisation des variables externes                                                            | Elles définissent toutes les variables externes qui n’existent pas déjà                                                                                            | oui                             | oui                            | oui                                      | non                     |
| Dynamic JS 1                                                                                     | Appelle un fichier JavaScript externe avant la déclaration des variables internes                                                                                  | oui                             | non                            | non                                      | non                     |
| Static JS 1                                                                                      | Appelle du code JavaScript personnalisé avant la déclaration des variables internes                                                                                | oui                             | non                            | non                                      | non                     |
| Variables internes                                                                               | Calcule les variables internes                                                                                                                                     | oui                             | oui                            | oui                                      | non                     |
| Dynamic JS 2                                                                                     | Appelle un fichier JavaScript externe après la déclaration des variables externes                                                                                  | oui                             | non                            | non                                      | non                     |
| Static JS 2                                                                                      | Appelle un fichier JavaScript externe après la déclaration des variables internes                                                                                  | oui                             | non                            | non                                      | non                     |
| Stockage des données                                                                             | Calcule la valeur des cookies créés avec le module « data storage »                                                                                                | oui                             | oui                            | oui                                      | non                     |
| Tags + règles « Container loaded », « DOM ready », « Clicks », « Form submission » et « Scroll » | Exécute les tags appelés par les déclencheurs « Container loaded », « DOMready », « Clicks », « Form submission » et « Scroll », ainsi que les règles associées au | oui                             | non                            | non                                      | non                     |
| ​                                                                                                | premier chargement du conteneur.                                                                                                                                   | ​                               | ​                              | ​                                        | ​                       |
| Tags + règles « Custom »                                                                         | Exécute les tags appelés par les déclencheurs « Custom », ainsi que les règles associées au chargement ou au rechargement du conteneur.                            | oui                             | oui                            | oui                                      | oui                     |
| Événements + règles                                                                              | Exécute les événements déclenchés par la fonction tc\_events précédente                                                                                            | oui                             | non                            | non                                      | non                     |
| Confidentialité                                                                                  | Réinitialise le cookie Privacy afin de prendre en compte les choix des utilisateurs.                                                                               | oui                             | oui                            | oui                                      | Non                     |
| Hiérarchie des tags                                                                              | Identifie les tags piggybackés (tags chargés en cascade par d’autres tags dans le module « TagPerformanc e »)                                                      | oui                             | non                            | non                                      | non                     |
| Écouteur d’événements                                                                            | Recharge les écouteurs d’événements (qui permettent de suivre les actions effectuées par tout utilisateur qui navigue sur le site : clics, défilements, etc.)      | oui                             | non                            | non                                      | non                     |


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://doc.commandersact.com/fr/fonctionnalites/sources/sources-catalog/web/containers/setup-guides-for-developers/spa-implementation-guide.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
