> ## 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.
# Extensión de VS Code
> Escriba y pruebe código de experimentos de Kameleoon directamente en Visual Studio Code con inyección en vivo a través de la extensión Kameleoon para Chrome.
A medida que los experimentos se vuelven más complejos, asegurar que funcionen eficazmente y permanezcan libres de errores supone un reto. Anteriormente, los desarrolladores tenían dos opciones:
* Escribir código JavaScript directamente en Kameleoon y usar la funcionalidad Previsualización para comprobarlo.
* Copiar y pegar código en la consola de desarrollador de Chrome.
Ambos métodos eran engorrosos, reducían la productividad de los desarrolladores y, en ocasiones, no se ajustaban a las condiciones de producción o mostraban diferencias al simular el comportamiento del experimento.
Los desarrolladores ahora pueden escribir código JavaScript o TypeScript en **Microsoft Visual Studio Code** usando la extensión de Kameleoon para Visual Studio Code. La extensión detecta automáticamente las actualizaciones y las envía al navegador a través de la extensión de Kameleoon para Chrome. Chrome inyecta entonces el nuevo código en el motor de Kameleoon y recarga automáticamente la página. Visual Studio Code es el primer entorno de desarrollo integrado con Kameleoon; podrían sumarse otros según las solicitudes de los clientes.
## Instalación
Ya puede instalar la extensión desde el [marketplace de Visual Studio](https://marketplace.visualstudio.com/items?itemName=Kameleoon.kameleoon).
[Marketplace de Visual Studio](https://storage.googleapis.com/kameleoon-storage-documentation/developers/images/VS-Code-Extension-1.png)
## Primeros pasos
El primer paso consiste en inicializar el proyecto de VS Code. Para inicializarlo, vaya a la paleta de comandos y ejecute el comando **Kameleoon - Initialize**.
Pulse *Ctrl+Shift+P* para abrir la *Paleta de comandos* y comience a escribir "Kameleoon - Initialize" para filtrar y mostrar el comando *Kameleoon - Initialize*.
Proporcione [las credenciales de la Automation API de Kameleoon](/user-manual/account-and-team-management/users-and-teams/api-credentials) para permitir que el puente se autentique y se comunique con la plataforma. Una vez obtenidas las credenciales desde el [perfil](/user-manual/account-and-team-management/users-and-teams/api-credentials), añádalas al archivo **credentials.json** en la raíz del repositorio:
```json theme={null}
{
"client_id": "YOUR_CLIENT_ID",
"client_secret": "YOUR_CLIENT_SECRET"
}
```
Por último, instale los módulos de NodeJS necesarios ejecutando este comando:
```shell theme={null}
npm install
```
### Importar desde la cuenta de Kameleoon
Importe todos los proyectos, experimentos, personalizaciones, variaciones, segmentos, objetivos y custom data utilizando el comando **Kameleoon - Import all projects**.
Si la cuenta de Kameleoon es demasiado grande para cargarlo todo de una vez, utilice el comando **Kameleoon - Import project** para seleccionar un único proyecto para importar.
## Uso
### Importar entidades
Puede importar una entidad utilizando uno de los siguientes comandos:
```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
```
### Crear entidades
Puede crear una entidad utilizando uno de los siguientes comandos:
```shell theme={null}
Kameleoon - Create experiment
Kameleoon - Create personalization
Kameleoon - Create variation
Kameleoon - Create goal
Kameleoon - Create segment
Kameleoon - Create custom data
```
### Duplicar entidades
Puede duplicar una entidad utilizando uno de los siguientes comandos:
```shell theme={null}
Kameleoon - Duplicate experiment
Kameleoon - Duplicate personalization
Kameleoon - Duplicate variation
Kameleoon - Duplicate goal
Kameleoon - Duplicate segment
Kameleoon - Duplicate custom data
```
### Recuperar entidades
Puede actualizar su entidad local utilizando uno de los siguientes comandos:
```
Kameleoon - Fetch projectKameleoon - Fetch experimentKameleoon - Fetch personalizationKameleoon - Fetch segmentKameleoon - Fetch custom dataKameleoon - Fetch goal
```
### Desplegar entidades
Puede desplegar su entidad local utilizando uno de los siguientes comandos:
```shell theme={null}
Kameleoon - Fetch project
Kameleoon - Fetch experiment
Kameleoon - Fetch personalization
Kameleoon - Fetch segment
Kameleoon - Fetch custom data
Kameleoon - Fetch goal
```
### Sincronizar
```shell theme={null}
Kameleoon - Synchronize variation code to Chrome
Kameleoon - Synchronize common code to Chrome
Kameleoon - Synchronize global code to Chrome
Kameleoon - Remove synchronization
```
### Vista Kameleoon Campaigns
La extensión ofrece una vista llamada **Kameleoon Campaigns**. Esta vista está disponible en el panel Explorer.
Le permite ver todos sus proyectos y campañas, junto con su estado actual y las variaciones asociadas.
[Vista Kameleoon Campaigns](https://storage.googleapis.com/kameleoon-storage-documentation/developers/images/VS-Code-Extension-2.gif)
## Referencia técnica
### Entidades
La siguiente tabla ofrece una visión general de la gestión de entidades mediante la extensión de VS Code:
| Proyecto | Experimento | Personalización | Variación | Segmento | Objetivo | Custom data |
| ----------------------- | ----------- | --------------- | --------- | ----------------------------------------------------------------------------- | -------- | ----------- |
| \[entity].info.json | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| \[entity].config.json | X | ✓ | ✓ | ✓ | ✓ | ✓ |
| Tiene su propia carpeta | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| Se puede crear | X | ✓ | ✓ | ✓ | ✓ | ✓ |
| Se puede importar | ✓ | ✓ | ✓ | X | ✓ | ✓ |
| Se puede actualizar | ✓ | ✓ | ✓ | No individualmente; utilice los comandos fetch de experimento/personalización | ✓ | ✓ |
| Se puede eliminar | X | X | X | X | X | X |
### Proyecto
La carpeta /projects contiene los proyectos en lugar de la raíz, debido a la carpeta /custom-data.
\[Carpeta projects]\([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)
Cada proyecto tiene su propio archivo **proj.info.json** que contiene los IDs (**site ID** y **sitecode**). Un proyecto no tiene un archivo **proj.config.json** porque la extensión de VS Code no admite la creación de proyectos.
Cada proyecto puede contener experimentos, personalizaciones, custom data, objetivos, segmentos y el script global.
#### Script global
El script global se incluye en la carpeta **/projects/\*/global**.
\[Script global]\([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)
Dado que cada proyecto solo puede tener un script global, la carpeta del script global no contiene ningún archivo **info.json** o **config.json**. Solo contiene el script en sí.
#### Experimento
Los experimentos se incluyen en la carpeta **/projects/\*/experiments**.
[Carpeta experiments](https://storage.googleapis.com/kameleoon-storage-documentation/developers/images/VS-Code-Extension-4.png)
Cada experimento tiene su propia carpeta.
Cada experimento tiene sus propios archivos **exp.config.json** y **exp.info.json**.
Por defecto, la extensión crea la carpeta del experimento utilizando la misma convención de nombres de las versiones anteriores, pero también crea los archivos **exp.info.json** y **exp.config.json**. El nombre de la carpeta no es importante, ya que solo se utilizan los archivos de configuración.
#### Personalización
Las personalizaciones se incluyen en la carpeta **/projects/\*/personalizations**.
[Carpeta de personalización](https://storage.googleapis.com/kameleoon-storage-documentation/developers/images/VS-Code-Extension-5.png)
Cada personalización tiene su propia carpeta.
Cada personalización tiene sus propios archivos **perso.config.json** y **perso.info.json**.
Por defecto, la extensión crea la carpeta de personalización utilizando la misma convención de nombres de las versiones anteriores, pero también crea los archivos **perso.info.json** y **perso.config.json**. El nombre de la carpeta no es importante, ya que solo se utilizan los archivos de configuración.
#### Variación
Las variaciones se incluyen en la carpeta del experimento o de la personalización asociada.
[Carpeta de variación](https://storage.googleapis.com/kameleoon-storage-documentation/developers/images/VS-Code-Extension-6.png)
Cada variación tiene su propia carpeta (**incluso en una personalización**).
Cada variación tiene sus propios archivos **var.config.json** y **var.info.json**.
Por defecto, la extensión crea la carpeta de la variación utilizando la misma convención de nombres de las versiones anteriores, pero también crea los archivos **var.info.json** y **var.config.json**. El nombre de la carpeta no es importante, ya que solo se utilizan los archivos de configuración.
#### Segmento
Los segmentos se incluyen en la carpeta **/projects/\*/segments**.
[Carpeta de segmentos](https://storage.googleapis.com/kameleoon-storage-documentation/developers/images/VS-Code-Extension-7.png)
Cada segmento tiene su propia carpeta.
Cada segmento tiene sus propios archivos **segment.config.json** y **segment.info.json**.
Por defecto, la extensión crea la carpeta del segmento utilizando la misma convención de nombres de las versiones anteriores, pero también crea los archivos **segment.info.json** y **segment.config.json**. El nombre de la carpeta no es importante, ya que solo se utilizan los archivos de configuración.
#### Objetivo
Los objetivos se incluyen en la carpeta **/projects/\*/goals**.
[Carpeta de objetivos](https://storage.googleapis.com/kameleoon-storage-documentation/developers/images/VS-Code-Extension-8.png)
Cada objetivo tiene su propia carpeta.
Cada objetivo tiene sus propios archivos **goal.config.json** y **goal.info.json**.
Por defecto, la extensión crea la carpeta del objetivo utilizando la misma convención de nombres de las versiones anteriores, pero también crea los archivos **goal.info.json** y **goal.config.json**. El nombre de la carpeta no es importante, ya que solo se utilizan los archivos de configuración.
#### Custom data
Los custom data se incluyen en la carpeta **/projects/\*/custom-data**.
[Carpeta custom-data](https://storage.googleapis.com/kameleoon-storage-documentation/developers/images/VS-Code-Extension-9.png)
Cada custom data tiene su propia carpeta.
Cada custom data tiene sus propios archivos **custom.config.json** y **custom.info.json**.
Por defecto, la extensión crea la carpeta del custom data utilizando la misma convención de nombres de las versiones anteriores, pero también crea los archivos **custom.info.json** y **custom.config.json**. El nombre de la carpeta no es importante, ya que solo se utilizan los archivos de configuración.
### Comandos
#### Comandos de inicialización
##### Kameleoon - Initialize
**Kameleoon - Initialize** es el primer comando a ejecutar al inicio de un nuevo proyecto de VS Code.
Este comando inicializará el proyecto de Visual Studio Code creando los siguientes archivos:
```
credentials.jsongulpfile.jspackage.jsonREADME.md
```
Tras ejecutar el comando, el archivo **credential.json** se abrirá en el editor.
##### Accesibilidad
| Comando | Menú contextual | Paleta de comandos |
| ---------------------- | --------------- | ------------------ |
| Kameleoon - Initialize | X | ✓ |
#### Comandos de importación
Los comandos de importación importan entidades que faltan. Si la carpeta de la entidad ya existe, el comando no la importará. Los comandos de importación se aplican al importar una nueva entidad. Utilice los comandos fetch para actualizar entidades a sus últimas versiones.
##### Kameleoon - Import all projects
Este comando crea la carpeta /projects e importa todos los proyectos, creando la carpeta, subcarpetas y archivos de cada proyecto.
##### Accesibilidad
| Comando | Menú contextual | Paleta de comandos |
| ------------------------------- | --------------------------------------- | ------------------ |
| Kameleoon - Import all projects | Clic derecho sobre la carpeta /projects | ✓ |
##### Kameleoon - Import project
Este comando importará un proyecto específico bajo la carpeta **/projects** y, por tanto, creará las carpetas y archivos de cada entidad asociada.
##### Accesibilidad
| Comando | Menú contextual | Paleta de comandos |
| -------------------------- | --------------- | ---------------------------------------- |
| Kameleoon - Import project | ✕ | Ejecute el comando y seleccione un sitio |
##### Kameleoon - Import experiment
Este comando importará un experimento específico bajo el proyecto y, por tanto, creará las carpetas y archivos del experimento (incluidos los archivos **exp.info.json** y **exp.config.json** y las variaciones).
##### Accesibilidad
| Comando | Menú contextual | Paleta de comandos |
| ----------------------------- | --------------- | ------------------------------------- |
| Kameleoon - Import experiment | ✕ | Ejecute el comando e introduzca un ID |
##### Kameleoon - Import personalization
Este comando importará una personalización específica bajo el proyecto y, por tanto, creará las carpetas y archivos de la personalización (incluidos los archivos **perso.info.json** y **perso.config.json** y la variación única).
##### Accesibilidad
| Comando | Menú contextual | Paleta de comandos |
| ---------------------------------- | --------------- | ------------------------------------- |
| Kameleoon - Import personalization | ✕ | Ejecute el comando e introduzca un ID |
##### Kameleoon - Import goal
Este comando importará un objetivo específico bajo el proyecto y, por tanto, creará las carpetas y archivos del objetivo (**goal.config.json** y **goal.info.json**).
##### Accesibilidad
| Comando | Menú contextual | Paleta de comandos |
| ----------------------- | --------------- | ------------------------------------- |
| Kameleoon - Import goal | ✕ | Ejecute el comando e introduzca un ID |
##### Kameleoon - Import segment
Este comando importará un segmento específico bajo el proyecto y, por tanto, creará las carpetas y archivos del segmento (**segment.config.json** y **segment.info.json**).
##### Accesibilidad
| Comando | Menú contextual | Paleta de comandos |
| -------------------------- | --------------- | ------------------------------------- |
| Kameleoon - Import segment | ✕ | Ejecute el comando e introduzca un ID |
##### Kameleoon - Import custom data
Este comando importará un custom data específico bajo el proyecto y, por tanto, creará las carpetas y archivos del custom data (**custom.config.json** y **custom.info.json**).
##### Accesibilidad
| Comando | Menú contextual | Paleta de comandos |
| ------------------------------ | --------------- | ------------------------------------- |
| Kameleoon - Import custom data | ✕ | Ejecute el comando e introduzca un ID |
Los comandos fetch están disponibles a través del menú contextual sobre una carpeta de entidad que contenga un archivo **\[entity-prefix].info.json** válido con un ID, anidado en la carpeta común de la entidad correspondiente. Los comandos fetch sobrescriben totalmente los archivos de entidad utilizando la respuesta de la API.
| Comando | Menú contextual | Paleta de comandos | Carpeta del comando | Archivo info |
| --------------------------------- | ----------------------------------------------- | ------------------ | ----------------------------- | ----------------- |
| Kameleoon - Fetch project | Clic derecho sobre una carpeta de proyecto | ✕ | /projects | proj.info.json |
| Kameleoon - Fetch experiment | Clic derecho sobre la carpeta de un experimento | ✕ | /projects/\*/experiments | exp.info.json |
| Kameleoon - Fetch personalization | Clic derecho sobre la carpeta de un experimento | ✕ | /projects/\*/personalizations | perso.info.json |
| Kameleoon - Fetch segment | Clic derecho sobre una carpeta de segmento | ✕ | /projects/\*/segments | segment.info.json |
| Kameleoon - Fetch goal | Clic derecho sobre una carpeta de objetivo | ✕ | /projects/\*/goals | goal.info.json |
| Kameleoon - Fetch custom data | Clic derecho sobre una carpeta de custom data | ✕ | /projects/\*/custom-data | custom.info.json |
##### Kameleoon - Fetch project
Este comando sobrescribe los archivos y carpetas del proyecto (incluidos experimentos, personalizaciones, variaciones, segmentos, custom data y script global) con la última versión. Este comando también crea archivos y carpetas para experimentos, personalizaciones, variaciones, segmentos, custom data y scripts globales si faltan entidades o archivos.
##### Accesibilidad
| Comando | Menú contextual | Paleta de comandos |
| ------------------------- | ------------------------------------------ | ------------------ |
| Kameleoon - Fetch project | Clic derecho sobre una carpeta de proyecto | ✕ |
##### Kameleoon - Fetch experiment
Este comando sobrescribe los archivos y carpetas del experimento (incluidas las variaciones) con la última versión. Este comando también crea carpetas y archivos de variación si faltan variaciones o archivos.
##### Accesibilidad
| Comando | Menú contextual | Paleta de comandos |
| ---------------------------- | --------------------------------------------- | ------------------ |
| Kameleoon - Fetch experiment | Clic derecho sobre una carpeta de experimento | ✕ |
##### Kameleoon - Fetch personalization
Este comando sobrescribe los archivos y carpetas de personalización (incluida la variación única) con la última versión. Este comando también crea los archivos y carpetas de variación si faltan.
##### Accesibilidad
| Comando | Menú contextual | Paleta de comandos |
| --------------------------------- | ------------------------------------------------- | ------------------ |
| Kameleoon - Fetch personalization | Clic derecho sobre una carpeta de personalización | ✕ |
##### Kameleoon - Fetch segment
Este comando sobrescribirá los archivos y carpetas de su segmento con la última versión.
##### Accesibilidad
| Comando | Menú contextual | Paleta de comandos |
| ------------------------- | ------------------------------------------ | ------------------ |
| Kameleoon - Fetch segment | Clic derecho sobre una carpeta de segmento | ✕ |
##### Kameleoon - Fetch goal
Este comando sobrescribirá los archivos y carpetas de su objetivo con la última versión.
##### Accesibilidad
| Comando | Menú contextual | Paleta de comandos |
| ---------------------- | ------------------------------------------ | ------------------ |
| Kameleoon - Fetch goal | Clic derecho sobre una carpeta de objetivo | ✕ |
##### Kameleoon - Fetch custom data
Este comando sobrescribirá los archivos y carpetas de su custom data con la última versión.
##### Accesibilidad
| Comando | Menú contextual | Paleta de comandos |
| ----------------------------- | --------------------------------------------- | ------------------ |
| Kameleoon - Fetch custom data | Clic derecho sobre una carpeta de custom data | ✕ |
#### Comandos de creación
##### Kameleoon - Create experiment
Este comando creará un nuevo experimento en el proyecto, junto con las carpetas y archivos del experimento (incluidos los archivos **exp.info.json** y **exp.config.json** y la primera variación) tal y como se describe en este documento.
##### Accesibilidad
| Comando | Menú contextual | Paleta de comandos |
| ----------------------------- | ------------------------------------------ | ------------------ |
| Kameleoon - Create experiment | Clic derecho sobre la carpeta /experiments | ✓ |
##### Kameleoon - Create variation
Este comando creará una nueva variación bajo el experimento junto con la carpeta y los archivos de la variación (incluidos los archivos **var.info.json** y **var.config.json**) tal y como se describe en este documento.
##### Accesibilidad
| Comando | Menú contextual | Paleta de comandos |
| ---------------------------- | --------------------------------------------- | ------------------ |
| Kameleoon - Create variation | Clic derecho sobre una carpeta de experimento | ✕ |
##### Kameleoon - Create personalization
Este comando creará una nueva personalización en el proyecto, junto con las carpetas y archivos de la personalización (incluidos los archivos **perso.info.json** y **perso.config.json** y la variación única) tal y como se describe en este documento.
##### Accesibilidad
| Comando | Menú contextual | Paleta de comandos |
| ---------------------------------- | ----------------------------------------------- | ------------------ |
| Kameleoon - Create personalization | Clic derecho sobre la carpeta /personalizations | ✓ |
##### Kameleoon - Create goal
Este comando creará un nuevo objetivo en el proyecto, junto con la carpeta y los archivos del objetivo (incluidos los archivos **goal.info.json** y **goal.config.json**) tal y como se describe en este documento.
##### Accesibilidad
| Comando | Menú contextual | Paleta de comandos |
| ----------------------- | ------------------------------------ | ------------------ |
| Kameleoon - Create goal | Clic derecho sobre la carpeta /goals | ✓ |
##### Kameleoon - Create segment
Este comando creará un nuevo segmento en el proyecto, junto con la carpeta y los archivos del segmento (incluidos los archivos **seg.info.json** y **seg.config.json**) tal y como se describe en este documento.
##### Accesibilidad
| Comando | Menú contextual | Paleta de comandos |
| -------------------------- | --------------------------------------- | ------------------ |
| Kameleoon - Create segment | Clic derecho sobre la carpeta /segments | ✓ |
##### Kameleoon - Create custom data
Este comando creará un nuevo custom data en la cuenta de Kameleoon y en la carpeta **/custom-data**, incluida la carpeta y los archivos del custom data (incluidos los archivos **custom.info.json** y **custom.config.json**) tal y como se describe en este documento.
##### Accesibilidad
| Comando | Menú contextual | Paleta de comandos |
| ------------------------------ | ------------------------------------------ | ------------------ |
| Kameleoon - Create custom data | Clic derecho sobre la carpeta /custom-data | ✓ |
#### Comandos de duplicación
##### Kameleoon - Duplicate experiment
Este comando duplicará un experimento dentro del mismo proyecto. Duplica las carpetas y archivos del experimento pero con un id y nombre diferentes.
##### Accesibilidad
| Comando | Menú contextual | Paleta de comandos |
| -------------------------------- | -------------------------------------------------------- | ------------------ |
| Kameleoon - Duplicate experiment | Clic derecho sobre una carpeta de experimento específica | ✕ |
##### Kameleoon - Duplicate variation
Este comando duplicará una variación dentro del mismo experimento. Duplica las carpetas y archivos de la variación pero con un id y nombre diferentes.
##### Accesibilidad
| Comando | Menú contextual | Paleta de comandos |
| ------------------------------- | ------------------------------------------------------ | ------------------ |
| Kameleoon - Duplicate variation | Clic derecho sobre una carpeta de variación específica | ✕ |
##### Kameleoon - Duplicate personalization
Este comando duplicará una personalización dentro del mismo proyecto. Duplica las carpetas y archivos de la personalización pero con un id y nombre diferentes.
##### Accesibilidad
| Comando | Menú contextual | Paleta de comandos |
| ------------------------------------- | ------------------------------------------------------------ | ------------------ |
| Kameleoon - Duplicate personalization | Clic derecho sobre una carpeta de personalización específica | ✕ |
##### Kameleoon - Duplicate segment
Este comando duplicará un segmento dentro del mismo proyecto. Duplica las carpetas y archivos del segmento pero con un id y nombre diferentes.
##### Accesibilidad
| Comando | Menú contextual | Paleta de comandos |
| ----------------------------- | ----------------------------------------------------- | ------------------ |
| Kameleoon - Duplicate segment | Clic derecho sobre una carpeta de segmento específica | ✕ |
##### Kameleoon - Duplicate goal
Este comando duplicará un objetivo dentro del mismo proyecto. Duplica las carpetas y archivos del objetivo pero con un id y nombre diferentes.
##### Accesibilidad
| Comando | Menú contextual | Paleta de comandos |
| -------------------------- | ----------------------------------------------------- | ------------------ |
| Kameleoon - Duplicate goal | Clic derecho sobre una carpeta de objetivo específica | ✕ |
##### Kameleoon - Duplicate custom data
Este comando duplicará un custom data dentro del mismo proyecto. Duplica las carpetas y archivos del custom data pero con un id y nombre diferentes.
##### Accesibilidad
| Comando | Menú contextual | Paleta de comandos |
| --------------------------------- | -------------------------------------------------------- | ------------------ |
| Kameleoon - Duplicate custom data | Clic derecho sobre una carpeta de custom data específica | ✕ |
Los comandos de despliegue envían los cambios a producción. Desplegar o sincronizar cualquier archivo de script (JS, TS, CSS, SCSS) hace que la extensión compile y guarde el código resultante en la carpeta **\_build**.
##### Kameleoon - Deploy global code
Este comando actualizará el código global en producción. El despliegue del código global se basa en el archivo **proj.info.json** del proyecto.
##### Accesibilidad
| Comando | Menú contextual | Paleta de comandos |
| ------------------------------ | ---------------------------------------------------------- | ------------------ |
| Kameleoon - Deploy global code | Clic derecho sobre la carpeta global o su archivo index.js | ✕ |
##### Kameleoon - Deploy experiment
Este comando actualizará el experimento en producción, basándose en **exp.config.json**, **exp.info.json**, **common.js**, **common.css** y cada carpeta de variación anidada.
##### Accesibilidad
| Comando | Menú contextual | Paleta de comandos |
| ----------------------------- | -------------------------------------------------------- | ------------------ |
| Kameleoon - Deploy experiment | Clic derecho sobre una carpeta de experimento específica | ✕ |
##### Kameleoon - Deploy variation
Este comando actualizará la variación en producción, basándose en los archivos de la variación, incluidos **var.config.json** y **var.info.json**.
##### Accesibilidad
| Comando | Menú contextual | Paleta de comandos |
| ---------------------------- | ------------------------------------------------------ | ------------------ |
| Kameleoon - Deploy variation | Clic derecho sobre una carpeta de variación específica | ✕ |
##### Kameleoon - Deploy personalization
Este comando actualizará la personalización en producción, basándose en perso.config.json, perso.info.json y la carpeta anidada con los archivos js y css.
##### Accesibilidad
| Comando | Menú contextual | Paleta de comandos |
| ---------------------------------- | ------------------------------------------------------------ | ------------------ |
| Kameleoon - Deploy personalization | Clic derecho sobre una carpeta de personalización específica | ✕ |
##### Kameleoon - Deploy goal
Este comando actualizará la información del objetivo en producción, basándose en los archivos **goal.config.json** y **goal.info.json**.
##### Accesibilidad
| Comando | Menú contextual | Paleta de comandos |
| ----------------------- | ----------------------------------------------------- | ------------------ |
| Kameleoon - Deploy goal | Clic derecho sobre una carpeta de objetivo específica | ✕ |
##### Kameleoon - Deploy segment
Este comando actualizará la información del segmento en producción, basándose en los archivos **segment.config.json** y **segment.info.json**.
##### Accesibilidad
| Comando | Menú contextual | Paleta de comandos |
| -------------------------- | ----------------------------------------------------- | ------------------ |
| Kameleoon - Deploy segment | Clic derecho sobre una carpeta de segmento específica | ✕ |
##### Kameleoon - Deploy custom data
Este comando actualizará la información del segmento en producción, basándose en los archivos **custom.config.json** y **custom.info.json**.
##### Accesibilidad
| Comando | Menú contextual | Paleta de comandos |
| ------------------------------ | -------------------------------------------------------- | ------------------ |
| Kameleoon - Deploy custom data | Clic derecho sobre una carpeta de custom data específica | ✕ |
#### Comandos de sincronización
Guardar el archivo sincronizado dispara la sincronización. Solo se puede sincronizar una entidad a la vez.
##### Kameleoon - Synchronize variation code to Chrome
Este comando sincronizará tanto los archivos js como css con la extensión de Chrome, inyectando el código en la página web. También acepta archivos TS y SCSS.
##### Accesibilidad
| Comando | Menú contextual | Paleta de comandos |
| ------------------------------------------------ | --------------------------------------------------------------------------------------- | ------------------ |
| Kameleoon - Synchronize variation code to Chrome | Clic derecho sobre un archivo de script específico de variación (.css, .scss, .js, .ts) | ✕ |
##### Kameleoon - Synchronize common code to Chrome
Este comando sincronizará tanto los archivos **common.js** como **common.css** con la extensión de Chrome, inyectando el código en la página web. También acepta archivos TS y SCSS.
##### Accesibilidad
| Comando | Menú contextual | Paleta de comandos |
| --------------------------------------------- | ------------------------------------------------------------------------------------------------- | ------------------ |
| Kameleoon - Synchronize common code to Chrome | Clic derecho sobre un archivo de script common específico del experimento (.css, .scss, .js, .ts) | ✕ |
##### Kameleoon - Synchronize global code to Chrome
Este comando sincronizará el archivo index.js con la extensión de Chrome, inyectando el código en la página web.
##### Accesibilidad
| Comando | Menú contextual | Paleta de comandos |
| --------------------------------------------- | ------------------------------------------------------------------------------------------- | ------------------ |
| Kameleoon - Synchronize global code to Chrome | Clic derecho sobre un archivo de script de código global específico (.css, .scss, .js, .ts) | ✕ |
##### Kameleoon - Remove synchronization
Este comando eliminará la sincronización.
##### Accesibilidad
| Comando | Menú contextual | Paleta de comandos |
| ---------------------------------- | ------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------- |
| Kameleoon - Remove synchronization | Clic derecho sobre un archivo de script específico (.css, .scss, .js, .ts) que pueda usar con sincronización | Desde la Paleta de comandos puede acceder a un comando Remove synchronization dedicado para cada tipo de sincronización |
## Preguntas frecuentes
La palabra "entidad" hace referencia a los diferentes objetos con los que interactúa la extensión, como experimentos, personalizaciones, proyectos, variaciones, segmentos, custom data u objetivos.
Kameleoon ya no utiliza convenciones de nombres de archivos y carpetas. Cree entidades (experimentos, variaciones y otras) utilizando archivos de configuración JSON.
Esta extensión utiliza una convención basada en archivos de configuración llamada **arquitectura basada en archivos**. La arquitectura basada en archivos elimina las convenciones de nombres de archivos y carpetas utilizadas en versiones anteriores. En su lugar, utiliza varios archivos JSON que contienen la información de la entidad.
Hay dos tipos de archivos:
* **`[entity].info.json`** — Este archivo contiene el ID y otra información relacionada con la cuenta.
* **`[entity].config.json`** — Este archivo contiene la configuración de la entidad y puede utilizarse para recrear la misma entidad en otra cuenta.
### ¿Los comandos de importación sobrescriben los archivos y carpetas?
No, los comandos de importación no sobrescriben los archivos y carpetas, pero un comando de importación puede crear los archivos y carpetas si no existen.
### ¿Los comandos fetch sobrescriben los archivos y carpetas?
Sí, los comandos fetch sobrescribirán los archivos y carpetas. En el futuro, Kameleoon ofrecerá capacidades de fusión para gestionar los distintos cambios entre la versión remota y la local.
### ¿Los comandos de importación generan un nuevo script `engine.js` (anteriormente llamado `kameleoon.js`) tras ejecutarse?
No, los [comandos de importación](https://docs.google.com/document/d/1ALR2xs7FXv55JmG3ytSFZsvUnHrdavldJ6oUG-iumkY/edit#heading=h.wcwvfrwnscwe) no generan un nuevo script `engine.js` tras su ejecución.
### ¿Los comandos de creación generan un nuevo script `engine.js` tras ejecutarse?
Sí, los [comandos de creación](https://docs.google.com/document/d/1ALR2xs7FXv55JmG3ytSFZsvUnHrdavldJ6oUG-iumkY/edit#heading=h.3ujr0l9zgbgd) generan un nuevo script `engine.js` tras su ejecución.
### ¿Los comandos de despliegue generan un nuevo script `engine.js` tras ejecutarse?
Sí, los [comandos de despliegue](https://docs.google.com/document/d/1ALR2xs7FXv55JmG3ytSFZsvUnHrdavldJ6oUG-iumkY/edit#heading=h.5t82fjid356v) generan un nuevo script `engine.js` tras su ejecución.
### ¿Cómo hacer rollback e instalar una versión específica de la extensión?
Desinstale la extensión Kameleoon actual si la tiene instalada. Asegúrese de recargar la ventana de Visual Studio Code para aplicar los cambios.
Vaya a [https://marketplace.visualstudio.com/items?itemName=Kameleoon.kameleoon](https://marketplace.visualstudio.com/items?itemName=Kameleoon.kameleoon)
Haga clic en **Version history**.
[Version history](https://storage.googleapis.com/kameleoon-storage-documentation/developers/images/VS-Code-Extension-10.gif)
Descargue la versión que desea instalar. Debería obtener un archivo VSIX.
Importe el archivo VSIX en VS Code.
1. Vaya a la pestaña de extensiones.
2. Haga clic en los tres puntos de la esquina superior derecha del panel "Extensions".
3. Haga clic en "*Install from VSIX…*".
### ¿Cómo migrar de V3 a V4?
Para migrar de V3 a V4, Kameleoon recomienda enviar los cambios a producción (opcional), eliminar todos los archivos y carpetas e iniciar un entorno nuevo. La sección [Primeros pasos](https://docs.google.com/document/d/1ALR2xs7FXv55JmG3ytSFZsvUnHrdavldJ6oUG-iumkY/edit#heading=h.ysyu20smapmp) explica los pasos para configurar un nuevo entorno.
### ¿Cómo deshabilitar la opción de minimización en Visual Studio Code?
Puede deshabilitar la opción de minimización o "minify" para Kameleoon en VS Code siguiendo estos pasos:
1. Abra la pestaña Extensions en VS Code.
2. En **Kameleoon** dentro de la lista de extensiones instaladas, haga clic en **Settings**.
3. Seleccione la opción etiquetada como **Enable JS minification for deploying and synchronization**.
