> ## Documentation Index
> Fetch the complete documentation index at: https://docs.kameleoon.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Extension VS Code
> Écrivez et testez du code d'expérience Kameleoon directement dans Visual Studio Code avec injection en direct via l'extension Chrome Kameleoon.
À mesure que les expériences deviennent plus complexes, garantir leur bon fonctionnement et l'absence de bugs présente des défis. Auparavant, les développeurs avaient deux options :
* Écrire du code JavaScript directement dans Kameleoon et utiliser la fonctionnalité de prévisualisation pour le vérifier.
* Copier et coller le code dans la console développeur de Chrome.
Les deux méthodes étaient fastidieuses, réduisant la productivité des développeurs et ne reproduisant parfois pas les conditions de production ou montrant des différences lors de la simulation du comportement de l'expérience.
Les développeurs peuvent désormais écrire du code JavaScript ou TypeScript dans **Microsoft Visual Studio Code** en utilisant l'extension Kameleoon pour Visual Studio Code. L'extension détecte automatiquement les mises à jour et les envoie au navigateur via l'extension Chrome de Kameleoon. Chrome injecte alors le nouveau code dans le moteur Kameleoon et recharge automatiquement la page. Visual Studio Code est le premier environnement de développement à s'intégrer avec Kameleoon ; d'autres pourront suivre selon les demandes des clients.
## Installation
Vous pouvez désormais installer l'extension depuis le [marketplace Visual Studio](https://marketplace.visualstudio.com/items?itemName=Kameleoon.kameleoon).
[Visual Studio marketplace](https://storage.googleapis.com/kameleoon-storage-documentation/developers/images/VS-Code-Extension-1.png)
## Pour commencer
La première étape consiste à initialiser le projet VS Code. Pour l'initialiser, accédez à la palette de commandes et exécutez la commande **Kameleoon - Initialize**.
Appuyez sur *Ctrl+Shift+P* pour ouvrir la *Palette de commandes*, puis commencez à saisir "Kameleoon - Initialize" pour filtrer et afficher la commande *Kameleoon - Initialize*.
Fournissez les [identifiants de l'Automation API Kameleoon](/user-manual/account-and-team-management/users-and-teams/api-credentials) pour permettre au pont de s'authentifier et de communiquer avec la plateforme. Une fois que vous avez obtenu les identifiants depuis le [profil](/user-manual/account-and-team-management/users-and-teams/api-credentials), ajoutez-les au fichier **credentials.json** à la racine du dépôt :
```json theme={null}
{
"client_id": "YOUR_CLIENT_ID",
"client_secret": "YOUR_CLIENT_SECRET"
}
```
Enfin, installez les modules NodeJS requis en exécutant cette commande :
```shell theme={null}
npm install
```
### Importer depuis le compte Kameleoon
Importez tous les projets, expériences, personnalisations, variations, segments, objectifs et données personnalisées à l'aide de la commande **Kameleoon - Import all projects**.
Si le compte Kameleoon est trop volumineux pour tout charger en une seule fois, utilisez la commande **Kameleoon - Import project** pour sélectionner un seul projet à importer.
## Utilisation
### Importer des entités
Vous pouvez importer une entité à l'aide de l'une des commandes suivantes :
```shell theme={null}
Kameleoon - Import all projects
Kameleoon - Import project
Kameleoon - Import experiment
Kameleoon - Import personalization
Kameleoon - Import segment
Kameleoon - Import custom data
Kameleoon - Import goal
```
### Créer des entités
Vous pouvez créer une entité à l'aide de l'une des commandes suivantes :
```shell theme={null}
Kameleoon - Create experiment
Kameleoon - Create personalization
Kameleoon - Create variation
Kameleoon - Create goal
Kameleoon - Create segment
Kameleoon - Create custom data
```
### Dupliquer des entités
Vous pouvez dupliquer une entité à l'aide de l'une des commandes suivantes :
```shell theme={null}
Kameleoon - Duplicate experiment
Kameleoon - Duplicate personalization
Kameleoon - Duplicate variation
Kameleoon - Duplicate goal
Kameleoon - Duplicate segment
Kameleoon - Duplicate custom data
```
### Récupérer des entités
Vous pouvez mettre à jour votre entité locale à l'aide de l'une des commandes suivantes :
```
Kameleoon - Fetch projectKameleoon - Fetch experimentKameleoon - Fetch personalizationKameleoon - Fetch segmentKameleoon - Fetch custom dataKameleoon - Fetch goal
```
### Déployer des entités
Vous pouvez déployer votre entité locale à l'aide de l'une des commandes suivantes :
```shell theme={null}
Kameleoon - Fetch project
Kameleoon - Fetch experiment
Kameleoon - Fetch personalization
Kameleoon - Fetch segment
Kameleoon - Fetch custom data
Kameleoon - Fetch goal
```
### Synchroniser
```shell theme={null}
Kameleoon - Synchronize variation code to Chrome
Kameleoon - Synchronize common code to Chrome
Kameleoon - Synchronize global code to Chrome
Kameleoon - Remove synchronization
```
### Vue Campagnes Kameleoon
L'extension fournit une vue appelée **Kameleoon Campaigns**. Cette vue est disponible dans le panneau Explorer.
Elle vous permet de voir tous vos projets et campagnes, ainsi que leur état actuel et leurs variations associées.
[Kameleoon Campaigns view](https://storage.googleapis.com/kameleoon-storage-documentation/developers/images/VS-Code-Extension-2.gif)
## Référence technique
### Entités
Le tableau suivant fournit un aperçu de la gestion des entités à l'aide de l'extension VS Code :
| Projet | Expérience | Personnalisation | Variation | Segment | Objectif | Donnée personnalisée |
| --------------------- | ---------- | ---------------- | --------- | ------------------------------------------------------------------------------------ | -------- | -------------------- |
| \[entity].info.json | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| \[entity].config.json | X | ✓ | ✓ | ✓ | ✓ | ✓ |
| A son propre dossier | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| Peut être créé | X | ✓ | ✓ | ✓ | ✓ | ✓ |
| Peut être importé | ✓ | ✓ | ✓ | X | ✓ | ✓ |
| Peut être mis à jour | ✓ | ✓ | ✓ | Pas individuellement ; utilisez les commandes fetch pour expérience/personnalisation | ✓ | ✓ |
| Peut être supprimé | X | X | X | X | X | X |
### Projet
Le dossier /projects contient les projets au lieu de la racine, en raison du dossier /custom-data.
\[projects folder]\([https://storage.googleapis.com/kameleoon-storage-documentation/developers/images/VS-Code-Extension-3.png](https://storage.googleapis.com/kameleoon-storage-documentation/developers/images/VS-Code-Extension-3.png)
Chaque projet possède son propre fichier **proj.info.json** contenant les ID (**site ID** et **sitecode**). Un projet n'a pas de fichier **proj.config.json** car l'extension VS Code ne prend pas en charge la création de projet.
Chaque projet peut contenir des expériences, des personnalisations, des données personnalisées, des objectifs, des segments et le script global.
#### Script global
Le script global est contenu dans le dossier **/projects/\*/global**.
\[Global script]\([https://storage.googleapis.com/kameleoon-storage-documentation/developers/images/VS-Code-Extension-4.png](https://storage.googleapis.com/kameleoon-storage-documentation/developers/images/VS-Code-Extension-4.png)
Étant donné que chaque projet ne peut avoir qu'un seul script global, le dossier du script global ne contient aucun fichier **info.json** ou **config.json**. Il contient uniquement le script lui-même.
#### Expérience
Les expériences sont contenues dans le dossier **/projects/\*/experiments**.
[Experiments folder](https://storage.googleapis.com/kameleoon-storage-documentation/developers/images/VS-Code-Extension-4.png)
Chaque expérience possède son propre dossier.
Chaque expérience possède ses propres fichiers **exp.config.json** et **exp.info.json**.
Par défaut, l'extension crée le dossier de l'expérience en utilisant la même convention de dénomination que les versions précédentes, mais elle crée également les fichiers **exp.info.json** et **exp.config.json**. Le nom du dossier n'a pas d'importance car seuls les fichiers de configuration sont utilisés.
#### Personnalisation
Les personnalisations sont contenues dans le dossier **/projects/\*/personalizations**.
[Personalization folder](https://storage.googleapis.com/kameleoon-storage-documentation/developers/images/VS-Code-Extension-5.png)
Chaque personnalisation possède son propre dossier.
Chaque personnalisation possède ses propres fichiers **perso.config.json** et **perso.info.json**.
Par défaut, l'extension crée le dossier de la personnalisation en utilisant la même convention de dénomination que les versions précédentes, mais elle crée également les fichiers **perso.info.json** et **perso.config.json**. Le nom du dossier n'a pas d'importance car seuls les fichiers de configuration sont utilisés.
#### Variation
Les variations sont contenues dans le dossier de l'expérience ou de la personnalisation associée.
[Variation folder](https://storage.googleapis.com/kameleoon-storage-documentation/developers/images/VS-Code-Extension-6.png)
Chaque variation possède son propre dossier (**même dans une personnalisation**).
Chaque variation possède ses propres fichiers **var.config.json** et **var.info.json**.
Par défaut, l'extension crée le dossier de la variation en utilisant la même convention de dénomination que les versions précédentes, mais elle crée également les fichiers **var.info.json** et **var.config.json**. Le nom du dossier n'a pas d'importance car seuls les fichiers de configuration sont utilisés.
#### Segment
Les segments sont contenus dans le dossier **/projects/\*/segments**.
[Segments folder](https://storage.googleapis.com/kameleoon-storage-documentation/developers/images/VS-Code-Extension-7.png)
Chaque segment possède son propre dossier.
Chaque segment possède ses propres fichiers **segment.config.json** et **segment.info.json**.
Par défaut, l'extension crée le dossier du segment en utilisant la même convention de dénomination que les versions précédentes, mais elle crée également les fichiers **segment.info.json** et **segment.config.json**. Le nom du dossier n'a pas d'importance car seuls les fichiers de configuration sont utilisés.
#### Objectif
Les objectifs sont contenus dans le dossier **/projects/\*/goals**.
[Goals folder](https://storage.googleapis.com/kameleoon-storage-documentation/developers/images/VS-Code-Extension-8.png)
Chaque objectif possède son propre dossier.
Chaque objectif possède ses propres fichiers **goal.config.json** et **goal.info.json**.
Par défaut, l'extension crée le dossier de l'objectif en utilisant la même convention de dénomination que les versions précédentes, mais elle crée également les fichiers **goal.info.json** et **goal.config.json**. Le nom du dossier n'a pas d'importance car seuls les fichiers de configuration sont utilisés.
#### Donnée personnalisée
Les données personnalisées sont contenues dans le dossier **/projects/\*/custom-data**.
[Custom-data folder](https://storage.googleapis.com/kameleoon-storage-documentation/developers/images/VS-Code-Extension-9.png)
Chaque donnée personnalisée possède son propre dossier.
Chaque donnée personnalisée possède ses propres fichiers **custom.config.json** et **custom.info.json**.
Par défaut, l'extension crée le dossier de la donnée personnalisée en utilisant la même convention de dénomination que les versions précédentes, mais elle crée également les fichiers **custom.info.json** et **custom.config.json**. Le nom du dossier n'a pas d'importance car seuls les fichiers de configuration sont utilisés.
### Commandes
#### Commandes d'initialisation
##### Kameleoon - Initialize
**Kameleoon - Initialize** est la première commande à exécuter au début d'un nouveau projet VS Code.
Cette commande initialisera le projet Visual Studio Code en créant les fichiers suivants :
```
credentials.jsongulpfile.jspackage.jsonREADME.md
```
Après l'exécution de la commande, le fichier **credential.json** sera ouvert dans l'éditeur.
##### Accessibilité
| Commande | Menu contextuel | Palette de commandes |
| ---------------------- | --------------- | -------------------- |
| Kameleoon - Initialize | X | ✓ |
#### Commandes d'importation
Les commandes d'importation importent les entités manquantes. Si le dossier de l'entité existe déjà, la commande ne l'importera pas. Les commandes d'importation s'appliquent lors de l'importation d'une nouvelle entité. Utilisez les commandes fetch pour mettre à jour les entités vers les dernières versions.
##### Kameleoon - Import all projects
Cette commande crée le dossier /projects et importe tous les projets, créant chaque dossier de projet, sous-dossier et fichier.
##### Accessibilité
| Commande | Menu contextuel | Palette de commandes |
| ------------------------------- | ----------------------------------- | -------------------- |
| Kameleoon - Import all projects | Clic droit sur le dossier /projects | ✓ |
##### Kameleoon - Import project
Cette commande importera un projet spécifique sous le dossier **/projects** et créera ainsi les dossiers et fichiers pour chaque entité qui lui est associée.
##### Accessibilité
| Commande | Menu contextuel | Palette de commandes |
| -------------------------- | --------------- | ------------------------------------------ |
| Kameleoon - Import project | ✕ | Exécutez la commande et choisissez un site |
##### Kameleoon - Import experiment
Cette commande importera une expérience spécifique sous le projet et créera ainsi les dossiers et fichiers de l'expérience (y compris les fichiers **exp.info.json** et **exp.config.json** et les variations).
##### Accessibilité
| Commande | Menu contextuel | Palette de commandes |
| ----------------------------- | --------------- | ------------------------------------ |
| Kameleoon - Import experiment | ✕ | Exécutez la commande et entrez un ID |
##### Kameleoon - Import personalization
Cette commande importera une personnalisation spécifique sous le projet et créera ainsi les dossiers et fichiers de la personnalisation (y compris les fichiers **perso.info.json** et **perso.config.json** et la variation unique).
##### Accessibilité
| Commande | Menu contextuel | Palette de commandes |
| ---------------------------------- | --------------- | ------------------------------------ |
| Kameleoon - Import personalization | ✕ | Exécutez la commande et entrez un ID |
##### Kameleoon - Import goal
Cette commande importera un objectif spécifique sous le projet et créera ainsi les dossiers et fichiers de l'objectif (**goal.config.json** et **goal.info.json**).
##### Accessibilité
| Commande | Menu contextuel | Palette de commandes |
| ----------------------- | --------------- | ------------------------------------ |
| Kameleoon - Import goal | ✕ | Exécutez la commande et entrez un ID |
##### Kameleoon - Import segment
Cette commande importera un objectif spécifique sous le projet et créera ainsi les dossiers et fichiers du segment (**segment.config.json** et **segment.info.json**).
##### Accessibilité
| Commande | Menu contextuel | Palette de commandes |
| -------------------------- | --------------- | ------------------------------------ |
| Kameleoon - Import segment | ✕ | Exécutez la commande et entrez un ID |
##### Kameleoon - Import custom data
Cette commande importera une donnée personnalisée spécifique sous le projet et créera ainsi les dossiers et fichiers de la donnée personnalisée (**custom.config.json** et **custom.info.json**).
##### Accessibilité
| Commande | Menu contextuel | Palette de commandes |
| ------------------------------ | --------------- | ------------------------------------ |
| Kameleoon - Import custom data | ✕ | Exécutez la commande et entrez un ID |
Les commandes fetch sont disponibles via le menu contextuel sur un dossier d'entité contenant un fichier **\[entity-prefix].info.json** valide avec un ID, imbriqué dans le dossier d'entité commun respectif. Les commandes fetch écrasent complètement les fichiers d'entité en utilisant la réponse de l'API.
| Commande | Menu contextuel | Palette de commandes | Dossier de commande | Fichier info |
| --------------------------------- | ------------------------------------------------- | -------------------- | ----------------------------- | ----------------- |
| Kameleoon - Fetch project | Clic droit sur un dossier de projet | ✕ | /projects | proj.info.json |
| Kameleoon - Fetch experiment | Clic droit sur un dossier d'expérience | ✕ | /projects/\*/experiments | exp.info.json |
| Kameleoon - Fetch personalization | Clic droit sur un dossier d'expérience | ✕ | /projects/\*/personalizations | perso.info.json |
| Kameleoon - Fetch segment | Clic droit sur un dossier de segment | ✕ | /projects/\*/segments | segment.info.json |
| Kameleoon - Fetch goal | Clic droit sur un dossier d'objectif | ✕ | /projects/\*/goals | goal.info.json |
| Kameleoon - Fetch custom data | Clic droit sur un dossier de donnée personnalisée | ✕ | /projects/\*/custom-data | custom.info.json |
##### Kameleoon - Fetch project
Cette commande écrase les fichiers et dossiers de projet (y compris les expériences, les personnalisations, les variations, les segments, les données personnalisées et le script global) avec la dernière version. Cette commande crée également des fichiers et des dossiers pour les expériences, les personnalisations, les variations, les segments, les données personnalisées et les scripts globaux si des entités ou des fichiers sont manquants.
##### Accessibilité
| Commande | Menu contextuel | Palette de commandes |
| ------------------------- | ----------------------------------- | -------------------- |
| Kameleoon - Fetch project | Clic droit sur un dossier de projet | ✕ |
##### Kameleoon - Fetch experiment
Cette commande écrase les fichiers et dossiers d'expérience (y compris les variations) avec la dernière version. Cette commande crée également des dossiers et fichiers de variation si des variations ou des fichiers sont manquants.
##### Accessibilité
| Commande | Menu contextuel | Palette de commandes |
| ---------------------------- | -------------------------------------- | -------------------- |
| Kameleoon - Fetch experiment | Clic droit sur un dossier d'expérience | ✕ |
##### Kameleoon - Fetch personalization
Cette commande écrase les fichiers et dossiers de personnalisation (y compris la variation unique) avec la dernière version. Cette commande crée également des fichiers et dossiers de variation s'ils sont manquants.
##### Accessibilité
| Commande | Menu contextuel | Palette de commandes |
| --------------------------------- | --------------------------------------------- | -------------------- |
| Kameleoon - Fetch personalization | Clic droit sur un dossier de personnalisation | ✕ |
##### Kameleoon - Fetch segment
Cette commande écrasera vos fichiers et dossiers de segment vers la dernière version.
##### Accessibilité
| Commande | Menu contextuel | Palette de commandes |
| ------------------------- | ------------------------------------ | -------------------- |
| Kameleoon - Fetch segment | Clic droit sur un dossier de segment | ✕ |
##### Kameleoon - Fetch goal
Cette commande écrasera vos fichiers et dossiers d'objectif vers la dernière version.
##### Accessibilité
| Commande | Menu contextuel | Palette de commandes |
| ---------------------- | ------------------------------------ | -------------------- |
| Kameleoon - Fetch goal | Clic droit sur un dossier d'objectif | ✕ |
##### Kameleoon - Fetch custom data
Cette commande écrasera vos fichiers et dossiers de données personnalisées vers la dernière version.
##### Accessibilité
| Commande | Menu contextuel | Palette de commandes |
| ----------------------------- | ------------------------------------------------- | -------------------- |
| Kameleoon - Fetch custom data | Clic droit sur un dossier de donnée personnalisée | ✕ |
#### Commandes de création
##### Kameleoon - Create experiment
Cette commande créera une nouvelle expérience sous le projet, ainsi que les dossiers et fichiers de l'expérience (y compris les fichiers **exp.info.json** et **exp.config.json** et la première variation) tels que décrits dans ce document.
##### Accessibilité
| Commande | Menu contextuel | Palette de commandes |
| ----------------------------- | -------------------------------------- | -------------------- |
| Kameleoon - Create experiment | Clic droit sur le dossier /experiments | ✓ |
##### Kameleoon - Create variation
Cette commande créera une nouvelle variation sous l'expérience ainsi que le dossier et les fichiers de la variation (y compris les fichiers **var.info.json** et **var.config.json**) tels que décrits dans ce document.
##### Accessibilité
| Commande | Menu contextuel | Palette de commandes |
| ---------------------------- | -------------------------------------- | -------------------- |
| Kameleoon - Create variation | Clic droit sur un dossier d'expérience | ✕ |
##### Kameleoon - Create personalization
Cette commande créera une nouvelle personnalisation sous le projet, ainsi que les dossiers et fichiers de la personnalisation (y compris les fichiers **perso.info.json** et **perso.config.json** et la variation unique) tels que décrits dans ce document.
##### Accessibilité
| Commande | Menu contextuel | Palette de commandes |
| ---------------------------------- | ------------------------------------------- | -------------------- |
| Kameleoon - Create personalization | Clic droit sur le dossier /personalizations | ✓ |
##### Kameleoon - Create goal
Cette commande créera un nouvel objectif sous le projet, ainsi que le dossier et les fichiers de l'objectif (y compris les fichiers **goal.info.json** et **goal.config.json**) tels que décrits dans ce document.
##### Accessibilité
| Commande | Menu contextuel | Palette de commandes |
| ----------------------- | -------------------------------- | -------------------- |
| Kameleoon - Create goal | Clic droit sur le dossier /goals | ✓ |
##### Kameleoon - Create segment
Cette commande créera un nouveau segment sous le projet, ainsi que le dossier et les fichiers du segment (y compris les fichiers **seg.info.json** et **seg.config.json**) tels que décrits dans ce document.
##### Accessibilité
| Commande | Menu contextuel | Palette de commandes |
| -------------------------- | ----------------------------------- | -------------------- |
| Kameleoon - Create segment | Clic droit sur le dossier /segments | ✓ |
##### Kameleoon - Create custom data
Cette commande créera une nouvelle donnée personnalisée dans le compte Kameleoon et dans le dossier **/custom-data**, y compris le dossier et les fichiers de la donnée personnalisée (y compris les fichiers **custom.info.json** et **custom.config.json**) tels que décrits dans ce document.
##### Accessibilité
| Commande | Menu contextuel | Palette de commandes |
| ------------------------------ | -------------------------------------- | -------------------- |
| Kameleoon - Create custom data | Clic droit sur le dossier /custom-data | ✓ |
#### Commandes de duplication
##### Kameleoon - Duplicate experiment
Cette commande dupliquera une expérience sous le même projet. Elle duplique les dossiers et fichiers de l'expérience mais avec un id et un nom différents.
##### Accessibilité
| Commande | Menu contextuel | Palette de commandes |
| -------------------------------- | ------------------------------------------------- | -------------------- |
| Kameleoon - Duplicate experiment | Clic droit sur un dossier d'expérience spécifique | ✕ |
##### Kameleoon - Duplicate variation
Cette commande dupliquera une variation sous la même expérience. Elle duplique les dossiers et fichiers de la variation mais avec un id et un nom différents.
##### Accessibilité
| Commande | Menu contextuel | Palette de commandes |
| ------------------------------- | ------------------------------------------------- | -------------------- |
| Kameleoon - Duplicate variation | Clic droit sur un dossier de variation spécifique | ✕ |
##### Kameleoon - Duplicate personalization
Cette commande dupliquera une personnalisation sous le même projet. Elle duplique les dossiers et fichiers de la personnalisation mais avec un id et un nom différents.
##### Accessibilité
| Commande | Menu contextuel | Palette de commandes |
| ------------------------------------- | -------------------------------------------------------- | -------------------- |
| Kameleoon - Duplicate personalization | Clic droit sur un dossier de personnalisation spécifique | ✕ |
##### Kameleoon - Duplicate segment
Cette commande dupliquera un segment sous le même projet. Elle duplique les dossiers et fichiers du segment mais avec un id et un nom différents.
##### Accessibilité
| Commande | Menu contextuel | Palette de commandes |
| ----------------------------- | ----------------------------------------------- | -------------------- |
| Kameleoon - Duplicate segment | Clic droit sur un dossier de segment spécifique | ✕ |
##### Kameleoon - Duplicate goal
Cette commande dupliquera un objectif sous le même projet. Elle duplique les dossiers et fichiers de l'objectif mais avec un id et un nom différents.
##### Accessibilité
| Commande | Menu contextuel | Palette de commandes |
| -------------------------- | ----------------------------------------------- | -------------------- |
| Kameleoon - Duplicate goal | Clic droit sur un dossier d'objectif spécifique | ✕ |
##### Kameleoon - Duplicate custom data
Cette commande dupliquera une donnée personnalisée sous le même projet. Elle duplique les dossiers et fichiers de la donnée personnalisée mais avec un id et un nom différents.
##### Accessibilité
| Commande | Menu contextuel | Palette de commandes |
| --------------------------------- | ------------------------------------------------------------ | -------------------- |
| Kameleoon - Duplicate custom data | Clic droit sur un dossier de donnée personnalisée spécifique | ✕ |
Les commandes de déploiement poussent les changements vers la production. Le déploiement ou la synchronisation de tout fichier de script (JS, TS, CSS, SCSS) invite l'extension à compiler et à enregistrer le code compilé dans le dossier **\_build**.
##### Kameleoon - Deploy global code
Cette commande mettra à jour le code global en production. Le déploiement du code global est basé sur le fichier **proj.info.json** du projet.
##### Accessibilité
| Commande | Menu contextuel | Palette de commandes |
| ------------------------------ | ------------------------------------------------------------ | -------------------- |
| Kameleoon - Deploy global code | Clic droit sur un dossier global ou sur son fichier index.js | ✕ |
##### Kameleoon - Deploy experiment
Cette commande mettra à jour l'expérience en production, basée sur **exp.config.json**, **exp.info.json**, **common.js**, **common.css** et chaque dossier de variation imbriqué.
##### Accessibilité
| Commande | Menu contextuel | Palette de commandes |
| ----------------------------- | ------------------------------------------------- | -------------------- |
| Kameleoon - Deploy experiment | Clic droit sur un dossier d'expérience spécifique | ✕ |
##### Kameleoon - Deploy variation
Cette commande mettra à jour la variation en production, basée sur les fichiers de la variation, y compris **var.config.json** et **var.info.json**.
##### Accessibilité
| Commande | Menu contextuel | Palette de commandes |
| ---------------------------- | ------------------------------------------------- | -------------------- |
| Kameleoon - Deploy variation | Clic droit sur un dossier de variation spécifique | ✕ |
##### Kameleoon - Deploy personalization
Cette commande mettra à jour la personnalisation en production, basée sur perso.config.json, perso.info.json et le dossier imbriqué avec les fichiers js et css.
##### Accessibilité
| Commande | Menu contextuel | Palette de commandes |
| ---------------------------------- | -------------------------------------------------------- | -------------------- |
| Kameleoon - Deploy personalization | Clic droit sur un dossier de personnalisation spécifique | ✕ |
##### Kameleoon - Deploy goal
Cette commande mettra à jour les informations de l'objectif en production, basée sur les fichiers **goal.config.json** et **goal.info.json**.
##### Accessibilité
| Commande | Menu contextuel | Palette de commandes |
| ----------------------- | ----------------------------------------------- | -------------------- |
| Kameleoon - Deploy goal | Clic droit sur un dossier d'objectif spécifique | ✕ |
##### Kameleoon - Deploy segment
Cette commande mettra à jour les informations du segment en production, basée sur les fichiers **segment.config.json** et **segment.info.json**.
##### Accessibilité
| Commande | Menu contextuel | Palette de commandes |
| -------------------------- | ----------------------------------------------- | -------------------- |
| Kameleoon - Deploy segment | Clic droit sur un dossier de segment spécifique | ✕ |
##### Kameleoon - Deploy custom data
Cette commande mettra à jour les informations du segment en production, basée sur les fichiers **custom.config.json** et **custom.info.json**.
##### Accessibilité
| Commande | Menu contextuel | Palette de commandes |
| ------------------------------ | ------------------------------------------------------------ | -------------------- |
| Kameleoon - Deploy custom data | Clic droit sur un dossier de donnée personnalisée spécifique | ✕ |
#### Commandes de synchronisation
L'enregistrement du fichier synchronisé déclenche la synchronisation. Une seule entité peut être synchronisée à la fois.
##### Kameleoon - Synchronize variation code to Chrome
Cette commande synchronisera les fichiers js et css avec l'extension chrome, injectant le code dans la page web. Elle accepte également les fichiers TS et SCSS.
##### Accessibilité
| Commande | Menu contextuel | Palette de commandes |
| ------------------------------------------------ | ----------------------------------------------------------------------------------- | -------------------- |
| Kameleoon - Synchronize variation code to Chrome | Clic droit sur un fichier de script de variation spécifique (.css, .scss, .js, .ts) | ✕ |
##### Kameleoon - Synchronize common code to Chrome
Cette commande synchronisera les fichiers **common.js** et **common.css** avec l'extension chrome, injectant le code dans la page web. Elle accepte également les fichiers TS et SCSS.
##### Accessibilité
| Commande | Menu contextuel | Palette de commandes |
| --------------------------------------------- | ------------------------------------------------------------------------------------------ | -------------------- |
| Kameleoon - Synchronize common code to Chrome | Clic droit sur un fichier de script commun d'expérience spécifique (.css, .scss, .js, .ts) | ✕ |
##### Kameleoon - Synchronize global code to Chrome
Cette commande synchronisera le fichier index.js avec l'extension chrome, injectant le code dans la page web.
##### Accessibilité
| Commande | Menu contextuel | Palette de commandes |
| --------------------------------------------- | ------------------------------------------------------------------------------------- | -------------------- |
| Kameleoon - Synchronize global code to Chrome | Clic droit sur un fichier de script de code global spécifique (.css, .scss, .js, .ts) | ✕ |
##### Kameleoon - Remove synchronization
Cette commande supprimera la synchronisation.
##### Accessibilité
| Commande | Menu contextuel | Palette de commandes |
| ---------------------------------- | --------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------ |
| Kameleoon - Remove synchronization | Clic droit sur un fichier de script spécifique (.css, .scss, .js, .ts) utilisable avec la synchronisation | Depuis la Palette de commandes, vous pouvez accéder à une commande Remove synchronization dédiée pour chaque type de synchronisation |
## Foire aux questions
Le mot "entité" désigne les différents objets avec lesquels l'extension interagit, tels que les expériences, personnalisations, projets, variations, segments, données personnalisées ou objectifs.
Kameleoon n'utilise plus les conventions de dénomination de fichiers et de dossiers. Créez des entités (expériences, variations, etc.) à l'aide de fichiers de configuration JSON.
Cette extension utilise une convention basée sur des fichiers de configuration appelée **architecture basée sur les fichiers**. L'architecture basée sur les fichiers élimine les conventions de dénomination de fichiers et de dossiers utilisées dans les versions précédentes. Au lieu de cela, elle utilise plusieurs fichiers JSON contenant les informations de l'entité.
Il existe deux types de fichiers :
* **`[entity].info.json`** — Ce fichier contient l'ID et d'autres informations liées au compte.
* **`[entity].config.json`** — Ce fichier contient la configuration de l'entité et peut être utilisé pour recréer la même entité sur un autre compte.
### Les commandes d'import écrasent-elles les fichiers et dossiers ?
Non, les commandes d'import n'écrasent pas les fichiers et dossiers, mais une commande d'import peut créer les fichiers et dossiers s'ils n'existent pas.
### Les commandes fetch écrasent-elles les fichiers et dossiers ?
Oui, les commandes fetch écraseront les fichiers et dossiers. À l'avenir, Kameleoon fournira des capacités de fusion pour gérer les différents changements entre la version distante et la version locale.
### Les commandes d'importation génèrent-elles un nouveau script `engine.js` (anciennement nommé `kameleoon.js`) après leur exécution ?
Non, les [commandes d'importation](https://docs.google.com/document/d/1ALR2xs7FXv55JmG3ytSFZsvUnHrdavldJ6oUG-iumkY/edit#heading=h.wcwvfrwnscwe) ne génèrent pas de nouveau script `engine.js` après l'exécution.
### Les commandes de création génèrent-elles un nouveau script `engine.js` après leur exécution ?
Oui, les [commandes de création](https://docs.google.com/document/d/1ALR2xs7FXv55JmG3ytSFZsvUnHrdavldJ6oUG-iumkY/edit#heading=h.3ujr0l9zgbgd) génèrent un nouveau script `engine.js` après l'exécution.
### Les commandes de déploiement génèrent-elles un nouveau script `engine.js` après leur exécution ?
Oui, les [commandes de déploiement](https://docs.google.com/document/d/1ALR2xs7FXv55JmG3ytSFZsvUnHrdavldJ6oUG-iumkY/edit#heading=h.5t82fjid356v) génèrent un nouveau script `engine.js` après l'exécution.
### Comment revenir en arrière et installer une version spécifique de l'extension ?
Désinstallez l'extension Kameleoon actuelle si elle est installée. Veillez à recharger votre fenêtre Visual Studio Code pour appliquer les modifications.
Accédez à [https://marketplace.visualstudio.com/items?itemName=Kameleoon.kameleoon](https://marketplace.visualstudio.com/items?itemName=Kameleoon.kameleoon)
Cliquez sur **Version history**.
[Version history](https://storage.googleapis.com/kameleoon-storage-documentation/developers/images/VS-Code-Extension-10.gif)
Téléchargez la version que vous souhaitez installer. Vous devriez avoir un fichier VSIX.
Importez le fichier VSIX dans VS Code.
1. Accédez à l'onglet des extensions.
2. Cliquez sur les trois points dans le coin supérieur droit du panneau "Extensions".
3. Cliquez sur "*Install from VSIX…*"
### Comment migrer de V3 vers V4 ?
Pour migrer de V3 vers V4, Kameleoon recommande de pousser les changements vers la production (optionnel), de supprimer tous les fichiers et dossiers et de démarrer un nouvel environnement. La section [Pour commencer](https://docs.google.com/document/d/1ALR2xs7FXv55JmG3ytSFZsvUnHrdavldJ6oUG-iumkY/edit#heading=h.ysyu20smapmp) explique les étapes pour configurer un nouvel environnement.
### Comment désactiver l'option minimize dans Visual Studio Code ?
Vous pouvez désactiver l'option minimize ou "minify" pour Kameleoon dans VS Code en suivant ces étapes :
1. Ouvrez l'onglet Extensions dans VS Code.
2. Depuis **Kameleoon** dans la liste des extensions installées, cliquez sur **Settings**.
3. Sélectionnez l'option intitulée **Enable JS minification for deploying and synchronization**.
