> ## 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. # Referencia de la API > Documentación de referencia de los métodos de la Activation API JavaScript de Kameleoon. ## Kameleoon.API.Core Este módulo contiene funciones para implementar variaciones de A/B testing en el front-end sin parpadeos. Use estos métodos en el orden indicado para obtener resultados óptimos. El módulo también incluye métodos de inicialización del motor, incluidos los relacionados con las leyes de privacidad y la recopilación del consentimiento legal. Antes de llamar al objeto JavaScript de la Activation API, verifique que el motor de Kameleoon se haya cargado. Use la Kameleoon Command Queue para la ejecución diferida de comandos cuando envíe datos de seguimiento, dispare experimentos o actualice atributos del visitante. Si el motor está cargado, los comandos y funciones que se pasen se ejecutarán inmediatamente; de lo contrario, entrarán en una cola para su posterior ejecución. Para más información, consulte la documentación de [Command queue](./command-queue). ### enableLegalConsent ```javascript theme={null} var agreedButton = Kameleoon.API.Utils.querySelectorAll("#agreed")[0]; Kameleoon.API.Utils.addEventListener(agreedButton, "mousedown", function (event) { Kameleoon.API.Core.enableLegalConsent(); }); ``` Llame al método `enableLegalConsent()` después de obtener el consentimiento legal del visitante para activar Kameleoon. Este método activa el modo de funcionamiento normal de Kameleoon. Para más información, consulte el artículo [Gestión del consentimiento](../../../privacy-and-compliance/consent-management). ##### Argumentos | Nombre | Tipo | Descripción | | ------ | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | module | String | Nombre del módulo que se va a habilitar: "PRODUCT\_RECOMMENDATION", "AB\_TESTING", "PERSONALIZATION" o "BOTH". Por ejemplo, `PRODUCT_RECOMMENDATION` ejecuta el punto de entrada **exclusivamente** con funcionalidades de recomendación de productos. `AB_TESTING` habilita el A/B testing **y** la recomendación de productos (a menos que esté activa la opción personalizada para diferenciar el consentimiento). `BOTH` habilita todas las funcionalidades. Si se omite, el método activa el consentimiento legal para todos los módulos (`BOTH`) de forma predeterminada. | También hay disponible una opción personalizada que permite gestionar por separado el consentimiento para Product Recommendation. Cuando esta opción está activa, llame explícitamente a `enableLegalConsent("PRODUCT_RECOMMENDATION")` para activar el módulo. Contacte con el Customer Success Manager para habilitar esta funcionalidad. ### disableLegalConsent ```javascript theme={null} var disableButton = Kameleoon.API.Utils.querySelectorAll("#disable")[0]; Kameleoon.API.Utils.addEventListener(disableButton, "mousedown", function (event) { Kameleoon.API.Core.disableLegalConsent(); }); ``` Llame al método `disableLegalConsent()` cuando un visitante rechace el uso de Kameleoon. Este método desactiva el modo de funcionamiento normal. Para más información, consulte el [artículo sobre Gestión del consentimiento](../../../privacy-and-compliance/consent-management). ##### Argumentos | Nombre | Tipo | Descripción | | ------ | ------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | module | String | Nombre del módulo que se va a deshabilitar: "AB\_TESTING", "PERSONALIZATION" o "BOTH". Si se omite, el método desactiva el consentimiento legal para todos los módulos (`BOTH`). | También hay disponible una opción personalizada que permite gestionar por separado el consentimiento para Product Recommendation. Cuando esta opción está activa, llame explícitamente a `disableLegalConsent("PRODUCT_RECOMMENDATION")` para deshabilitar el módulo. Contacte con el Customer Success Manager para habilitar esta funcionalidad. ### enableSinglePageSupport ```javascript theme={null} if (location.href.indexOf("mySPAWebsitePart") != -1) { Kameleoon.API.Core.enableSinglePageSupport(); } ``` El método `enableSinglePageSupport()` recarga el motor de Kameleoon cuando cambia la URL activa, con independencia de las cargas de página del navegador. Use este método para Single Page Applications (SPA) con varias URL y una única carga inicial. Kameleoon trata cada cambio de URL como una nueva página, lo que habilita la segmentación por URL y un seguimiento preciso de métricas como las páginas vistas. Kameleoon también eliminará automáticamente todos los elementos añadidos a la página que utilicen IDs HTML que empiecen por "kameleoonElement" o "kameleoonStyleSheet" cuando la SPA se recargue. ### enableDynamicRefresh ```javascript theme={null} if (location.href.indexOf("cart") != -1) { Kameleoon.API.Core.enableDynamicRefresh(); } ``` El método `enableDynamicRefresh()` detecta cambios en los elementos y reaplica las modificaciones del Graphic Editor. Este método admite SPAs que modifican el DOM dinámicamente sin cambios de URL ni recargas de página, evitando que las actualizaciones dinámicas eliminen los experimentos. Consulte `enableSinglePageSupport()` para otros tipos de SPA. ### getConfiguration ```javascript theme={null} var configuration = Kameleoon.API.Core.getConfiguration(); if (configuration.siteCode == "abcde12345") { document.cookie = "MyMainSite=true;"; } else if (configuration.siteCode == "12345abcdef") { document.cookie = "MySubSite=true;"; } ``` El método `getConfiguration()` devuelve una referencia al objeto Configuration, que contiene los valores constantes globales de la configuración de Kameleoon del sitio. ##### Valor de retorno | Nombre | Tipo | Descripción | | ------------- | ------ | --------------------- | | configuration | Object | Objeto Configuration. | ### load ```javascript theme={null} var href = location.href; var intervalId = Kameleoon.API.Utils.setInterval(function () { if (location.href != href) { Kameleoon.API.Core.load(); } }, 2000); ``` El método `load()` inicializa el motor de Kameleoon. Aunque la inicialización suele producirse automáticamente al cargar el archivo de la aplicación, es posible que sea necesario realizar llamadas manuales. El ejemplo muestra cómo implementar recargas tras cada cambio de URL, de forma similar a `enableSinglePageSupport()`. Kameleoon también eliminará automáticamente todos los elementos añadidos a la página que utilicen IDs HTML que empiecen por "kameleoonElement" o "kameleoonStyleSheet" cuando la SPA se recargue. ### processRedirect ```javascript theme={null} var experiment = Kameleoon.API.Experiments.getByName("RedirectExperiment"); if (experiment.associatedVariation.id == 123456) { Kameleoon.API.Core.processRedirect("https://www.mywebsite.com?variation=A"); } ``` El método `processRedirect()` redirige el navegador a otra URL, normalmente para experimentos A/B de tipo split. Use este método en lugar de `window.location.href = redirectionURL;` para garantizar un seguimiento preciso en segundo plano. Si la URL de redirección está en un dominio distinto al de la URL base y la instalación de Kameleoon no incluye los [datos de sesión unificados](../../../web-experimentation/technical-concepts/unify-session-data-storage-across-subdomains), el motor añade un parámetro `kameleoonRedirect-{experimentID}` a la URL de destino para garantizar un seguimiento preciso. ##### Argumentos | Nombre | Tipo | Descripción | | -------------- | ------ | ---------------------------------------------- | | redirectionURL | String | URL de redirección. Este campo es obligatorio. | ### runWhenConditionTrue ```javascript theme={null} Kameleoon.API.Core.runWhenConditionTrue(function () { return typeof jQuery != "undefined"; }, function () { jQuery("#bloc-2345").text("Mon nouveau texte"); }, 200); ``` El método `runWhenConditionTrue()` ejecuta la función callback cuando la función `conditionFunction` devuelve true. El método utiliza un mecanismo de polling, lo que puede causar parpadeos. Use `runWhenElementPresent()` en su lugar para obtener un mejor rendimiento. Consulte la [descripción de `runWhenElementPresent()`](#runwhenelementpresent) para más detalles. ##### Argumentos | Nombre | Tipo | Descripción | | ----------------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | conditionFunction | Function | Función JavaScript que devuelve **true** o **false**. Este campo es obligatorio. | | callback | Function | Función JavaScript que se ejecuta cuando **conditionFunction** devuelve **true**. Este campo es obligatorio. | | pollingInterval | Number | El motor ejecuta **conditionFunction** periódicamente con este intervalo. Cuando `runWhenElementPresent()` no esté disponible, un **pollingInterval** menor reduce el parpadeo pero aumenta el uso de CPU. Si se omite, el método utiliza **200 milisegundos** por defecto. | ### runWhenElementPresent ```javascript theme={null} // Con gestión de mutation observers. Kameleoon.API.Core.runWhenElementPresent("#bloc-2345", function (elements) { elements[0].innerText = "My new Text"; }); // Con múltiples selectores CSS. Se ejecuta si está presente cualquiera de los elementos. Kameleoon.API.Core.runWhenElementPresent("#bloc-567, .cta-button, #bloc-789", function (elements) { elements[0].innerText = "More new text"; }); // Sin gestión de mutation observers, Kameleoon hace polling cada 200 ms para comprobar si el elemento está en la página. Kameleoon.API.Core.runWhenElementPresent("#MyPopup.showed", function (elements) { Kameleoon.API.Events.trigger("popup displayed"); }, 200); // Con gestión de mutation observers y soporte para Single Page App, Kameleoon aplica las modificaciones cada vez que se añaden nuevos elementos al DOM o cuando hay un refresco dinámico de la Single Page App que elimina modificaciones anteriores. Kameleoon.API.Core.runWhenElementPresent(".product-button", function (elements) { elements.forEach(element => { element.innerText = "Add To Cart"; }); }, null, true); ``` El método `runWhenElementPresent()` ejecuta la función callback cuando aparece un elemento específico en el DOM. Este método utiliza mutation observers para impulsar la tecnología anti-parpadeo. Identifique los elementos clave de una variación y llame a `runWhenElementPresent()` con el elemento como primer argumento y el código de implementación como callback. Esto garantiza que las modificaciones se ejecuten en cuanto aparezca el elemento, antes de que el navegador inicie un ciclo de refresco de visualización. Para actuar sobre varios elementos, llame a `runWhenElementPresent()` por separado para cada elemento en lugar de apuntar únicamente al elemento final esperado. Una sola llamada puede provocar parpadeos si se produce un ciclo de refresco entre la aparición de los distintos elementos. Proporcionar este valor **desactiva** los Mutation Observers y el anti-parpadeo, y se vuelve al polling tradicional. Use este argumento solo en casos específicos, como consultas de selectores complejas con un alto impacto en CPU. ##### Argumentos | Nombre | Tipo | Descripción | | ---------------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | selector | String | Selector CSS del elemento. Para especificar varios selectores CSS, proporcione una sola cadena separada por comas. El callback se ejecuta cuando exista uno o más elementos. Este campo es obligatorio. | | callback | Function | Función JavaScript que se ejecuta cuando el elemento aparece en el DOM. Este campo es obligatorio. | | pollingInterval | Number | Proporcionar este valor desactiva los Mutation Observers y hace que el motor vuelva al polling tradicional, lo que puede causar parpadeos. Este campo es opcional. | | isDynamicElement | Boolean | Cuando está activo, Kameleoon hace seguimiento del selector si no se encuentra de inmediato al cargar la página y ejecuta el callback a medida que aparecen los elementos. El callback se vuelve a disparar para cada nuevo elemento que coincida con el selector. Esta opción admite menús dinámicos, scroll infinito y pop-ups. Este campo es opcional. | ### runWhenShadowRootElementPresent ```javascript theme={null} const wrapper = document.querySelector(".shadow-wrapper"); const shadow = wrapper.attachShadow({ mode: "open" }); const span = document.createElement("span"); span.classList.add("selector-inside-wrapper"); span.textContent = "I'm in the shadow DOM"; shadow.appendChild(span); Kameleoon.API.Core.runWhenShadowRootElementPresent('.shadow-wrapper', '.selector-inside-wrapper', (elements) => { elements[0].innerText = "New text" }); ``` El método `runWhenShadowRootElementPresent()` ejecuta la función **callback** cuando aparece un elemento específico dentro de un shadow DOM con `mode: open`. #### Argumentos | Nombre | Tipo | Descripción | | ------------------------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | parentSelector | String | Selector CSS del elemento padre. Este campo es obligatorio. | | shadowRootElementSelector | String | Selector CSS dentro del shadow DOM. Este campo es obligatorio. | | callback | Function | Función JavaScript que se ejecuta cuando el elemento aparece en el shadow DOM. Este campo es obligatorio. | | isDynamicElement | Boolean | Cuando está activo, Kameleoon hace seguimiento del selector si no se encuentra de inmediato y ejecuta el callback a medida que aparecen los elementos. El callback se vuelve a disparar para cada nuevo elemento que coincida con el selector. Esta opción admite menús dinámicos, scroll infinito y pop-ups. | ## Kameleoon.API.Goals Este módulo gestiona el disparo de objetivos y los datos de conversión, incluidas las confirmaciones de compra y el registro de ingresos. ### cancelConversion ```javascript theme={null} var buttons = Kameleoon.API.Utils.querySelectorAll(".btnRemoveFromCart"); buttons.forEach(function (button) { Kameleoon.API.Utils.addEventListener(button, "mousedown", function (event) { Kameleoon.API.Goals.cancelConversion(event.target.id); }); }); ``` El método `cancelConversion()` cancela una conversión que disparó durante la visita actual. Este método no puede cancelar conversiones de visitas anteriores. ##### Argumentos | Nombre | Tipo | Descripción | | ------------ | --------------- | -------------------------------------------------------------------------------------------------- | | goalNameOrID | String o Number | Nombre o ID del objetivo tal como está definido en la app de Kameleoon. Este campo es obligatorio. | ### processConversion Antes de implementar processConversion, revise la funcionalidad de [Custom Code for Custom Goal](#triggergoal-custom-code-for-custom-goal), que simplifica la personalización al eliminar la necesidad de un ID de objetivo. ```javascript theme={null} //Conversión para el objetivo "Add to cart" (goal id 123456) Kameleoon.API.Core.runWhenElementPresent("#buyButton", ([buyButton]) => { Kameleoon.API.Utils.addEventListener(buyButton, "click", () => { Kameleoon.API.Goals.processConversion(123456); //Add to cart }); }); //Conversión para el objetivo "Add to cart" (goal id 123456) con argumento opcional de ingreso Kameleoon.API.Core.runWhenElementPresent("#buyButton", ([buyButton]) => { Kameleoon.API.Utils.addEventListener(buyButton, "click", () => { Kameleoon.API.Goals.processConversion(123456, 19.99); //Add to cart }); }); ``` El método `processConversion()` dispara una conversión. Los metadatos deben estar [configurados en la app de Kameleoon](/es/user-manual/assets/goals/create-a-goal#metadatos) antes de establecerlos con `processConversion()`. Si inicia las conversiones desde un Tag Management System, como Google Tag Manager, use la [Kameleoon Command Queue](./command-queue) para retrasar la ejecución hasta que el motor se cargue. El motor procesa los comandos en cola en orden tras la inicialización. Ejemplo: ```javascript theme={null} window.kameleoonQueue = window.kameleoonQueue || []; kameleoonQueue.push(['Kameleoon.API.Goals.processConversion', 'GOAL_ID']); ``` ##### Argumentos | Nombre | Tipo | Descripción | | ------------ | --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | goalNameOrID | String o Number | Nombre o ID del objetivo tal como está definido en la app de Kameleoon. Los nombres de objetivo deben ser únicos. Este campo es obligatorio. | | revenue | Number | Importe de la transacción. Proporcionar este valor permite a Kameleoon hacer seguimiento de métricas de compra, como ingresos e importe medio del carrito. Este campo es opcional. | | metadata | Object | Establece valores específicos para los datos personalizados definidos como metadatos del objetivo en la app de Kameleoon. [Deben definirse previamente en la app de Kameleoon](/es/user-manual/assets/goals/create-a-goal#metadatos). Las claves del objeto son los **índices de los datos personalizados** (valores numéricos que se encuentran en la columna `INDEX` del [panel de Datos personalizados](/user-manual/assets/custom-data/manage-custom-data#encontrar-el-indice-de-un-dato-personalizado)). Este campo es opcional. | Los valores de metadatos son accesibles mediante [exportaciones de datos en bruto](/user-manual/experiment-analytics/analyze-results/results-page/results-page-actions#Export) y [la página de resultados](/user-manual/experiment-analytics/analyze-results/data-and-metrics/goal-metadata). Si proporciona el parámetro `metadata`, Kameleoon usa esos valores para la conversión actual en lugar de los valores que hubiera recopilado previamente mediante `setCustomData()`. Si omite el parámetro, Kameleoon usa los últimos valores de `customData` registrados antes de la conversión en la misma visita. Kameleoon solo tiene en cuenta los valores de metadatos que se pasan directamente al método `processConversion()`; ignora los datos personalizados previamente establecidos. En el siguiente ejemplo, la conversión se asocia únicamente con los metadatos proporcionados (por ejemplo, índice 5 con 'Amex Credit Card'). ```javascript theme={null} Kameleoon.API.Data.setCustomData(5, 'Credit Card'); Kameleoon.API.Data.setCustomData(9, 'Express Delivery'); Kameleoon.API.Goals.processConversion("GoalIDorName", revenue, { 5: ["Amex Credit Card", "PayPal"], // PaymentMode Custom Data 4: 1234567, // OrderID CustomData 3: "1q2w3e4r" // PayPalID CustomData }) ``` ### triggerGoal (Custom Code for Custom Goal) Para disparar **custom goals**, inyecte código personalizado creando un nuevo objetivo y añadiendo el código al panel **Trigger my goal**. ![](https://storage.googleapis.com/kameleoon-storage-documentation/developers/images/api-tutorial/custom-code-for-custom-goals.gif) La función `triggerGoal()` dispara el objetivo desde el panel de código sin necesidad de un ID de objetivo. ```javascript theme={null} //Sin parámetros triggerGoal(); //Con revenue triggerGoal(49.99); //Con revenue y metadata triggerGoal(49.99, {5: "Gold"}); ``` ##### Argumentos | Nombre | Tipo | Descripción | | -------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | revenue | Number | Importe de la transacción. Proporcionar este valor permite a Kameleoon hacer seguimiento de métricas de compra, como ingresos e importe medio del carrito. Este campo es opcional. | | metadata | Object | Establece valores específicos para los datos personalizados definidos como metadatos del objetivo en la app de Kameleoon. Las claves del objeto son los **índices de los datos personalizados** (valores numéricos que se encuentran en la columna `INDEX` del [panel de Datos personalizados](/user-manual/assets/custom-data/manage-custom-data#encontrar-el-indice-de-un-dato-personalizado)). Este campo es opcional. | Los valores de metadatos son accesibles mediante [exportaciones de datos en bruto](/user-manual/experiment-analytics/analyze-results/results-page/results-page-actions#Export) y [la página de resultados](/user-manual/experiment-analytics/analyze-results/data-and-metrics/goal-metadata). Si proporciona el parámetro `metadata`, Kameleoon usa esos valores para la conversión actual en lugar de los valores que hubiera recopilado previamente mediante `setCustomData()`. Si omite el parámetro, Kameleoon usa los últimos valores de `customData` registrados antes de la conversión en la misma visita. Kameleoon solo tiene en cuenta los valores de metadatos que se pasan directamente al método `triggerGoal()`; ignora los datos personalizados previamente establecidos. En el siguiente ejemplo, la conversión se asocia únicamente con los metadatos proporcionados (por ejemplo, índice 5 con 'Amex Credit Card'). ```javascript theme={null} Kameleoon.API.Data.setCustomData(5, 'Credit Card'); Kameleoon.API.Data.setCustomData(9, 'Express Delivery'); triggerGoal( revenue, { 5: ["Amex Credit Card", "PayPal"], // PaymentMode Custom Data 4: 1234567 // OrderID CustomData, 3: "1q2w3e4r" // PayPalID CustomData }) ``` ## Kameleoon.API.Data Este módulo proporciona métodos para establecer **datos personalizados** que permiten hacer seguimiento de las características del cliente o de la visita. También incluye métodos de gestión de datos para recuperar y escribir datos en el LocalStorage unificado de Kameleoon. ### readLocalData ```javascript theme={null} var userId = Kameleoon.API.Data.readLocalData("myUserId"); if (userId) { Kameleoon.API.Data.retrieveDataFromRemoteSource(userId, function (data) { console.log(data.returningVisitor); }); } ``` El método `readLocalData()` lee los datos locales que haya almacenado previamente mediante `writeLocalData()`. El motor recupera estos datos del Local Storage unificado, evitando las limitaciones estándar de almacenamiento. ##### Argumentos | Nombre | Tipo | Descripción | | ------ | ------ | ----------------------------------------------------------------------- | | key | String | Clave de los datos que se quieren recuperar. Este campo es obligatorio. | ##### Valor de retorno | Nombre | Tipo | Descripción | | ------ | ------ | --------------- | | value | String | Valor del dato. | ### performRemoteSynchronization ```javascript theme={null} Kameleoon.API.Data.performRemoteSynchronization("customDataName", "customDataValue", false); ``` El método `performRemoteSynchronization()` dispara una Server Synchronization Call (SSC) a la Data API. Esta llamada recupera el historial de visitas almacenado en los servidores backend de Kameleoon para el visitante actual y lo escribe en LocalStorage. Esto garantiza que los datos sean accesibles a través de la Activation API y estén disponibles para la segmentación. Este método se ejecuta normalmente de forma automática para la reconciliación entre dispositivos o para Safari ITP; no requiere invocación manual. ##### Argumentos | Nombre | Tipo | Descripción | | ---------------- | ------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | key | String | Clave del dato personalizado que sirve como identificador de mapeo (por ejemplo, ID de cuenta o correo electrónico). Si se omite, el método usa el identificador predeterminado configurado para la reconciliación entre dispositivos en la app de Kameleoon. | | value | String | Valor del identificador del visitante actual utilizado para la llamada a la Data API. Si se omite, el método usa el valor actual del dato personalizado proporcionado en el primer argumento. | | currentVisitOnly | Boolean | Cuando está activo, la SSC solicita datos únicamente para la visita actual. Use esta optimización para refrescar valores de datos personalizados adquiridos mediante la Data API o una integración Server-to-Server. Si se omite, el método utiliza **false** por defecto. | ### resetCustomData ```javascript theme={null} Kameleoon.API.Data.resetCustomData("MyCustomDataName"); ``` El método `resetCustomData()` restablece el valor de un dato personalizado. ##### Argumentos | Nombre | Tipo | Descripción | | ------ | ------ | ------------------------------------------------------------------------------------------------------- | | name | String | Nombre del dato personalizado tal como está definido en la app de Kameleoon. Este campo es obligatorio. | ### retrieveDataFromRemoteSource ```javascript theme={null} if (location.href.indexOf("loginPage") != -1) { Kameleoon.API.Core.runWhenConditionTrue(function () { return typeof dataLayer != null; }, function () { dataLayer.forEach(function (map) { if (map.userId) { Kameleoon.API.Data.retrieveDataFromRemoteSource(userId, function (data) { Kameleoon.API.Data.setCustomData("known_user", data.knownUser); }); } }); }, 200); } ``` El método `retrieveDataFromRemoteSource()` recupera datos almacenados en un servidor remoto de Kameleoon con la **key** especificada. Este método permite recuperar datos almacenados previamente mediante la Data API. Úselo para almacenar y recuperar rápidamente grandes volúmenes de datos de visitantes. Este mecanismo asincrónico requiere una función **callback** cuando se complete la llamada al servidor. ##### Argumentos | Nombre | Tipo | Descripción | | -------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------- | | key | String | La clave de búsqueda. Este campo es obligatorio. | | callback | Function | Función que se llama cuando se han recuperado los datos. Se invoca con un argumento **data** que es un objeto JS. Este campo es obligatorio. | ### setCustomData ```javascript theme={null} // Custom Data de tipo Single Kameleoon.API.Data.setCustomData("mySingleCustomDataName", "myNewValue"); --> "myNewValue" // Custom Data de tipo List Kameleoon.API.Data.setCustomData("myListCustomDataName", "myFirstValue"); --> ["myFirstValue"] Kameleoon.API.Data.setCustomData("myListCustomDataName", "mySecondValue"); --> ["myFirstValue", "mySecondValue"] Kameleoon.API.Data.setCustomData("myListCustomDataName", ["myThirdValue", "myFourthValue"]); --> ["myFirstValue", "mySecondValue", "myThirdValue", "myFourthValue"] Kameleoon.API.Data.setCustomData("myListCustomDataName", ["myThirdValue", "myFourthValue"], true); --> ["myThirdValue", "myFourthValue"] // Custom Data de tipo Count List Kameleoon.API.Data.setCustomData("myCountListCustomDataName", "myFirstValue"); --> {value: 'myFirstValue', count: 1} Kameleoon.API.Data.setCustomData("myCountListCustomDataName", "myFirstValue"); --> {value: 'myFirstValue', count: 2} Kameleoon.API.Data.setCustomData("myCountListCustomDataName", "mySecondValue"); --> --> {value: 'myFirstValue', count: 2}, {value: 'mySecondValue', count: 1} ``` El método `setCustomData()` establece el valor de un dato personalizado. ##### Argumentos | Nombre | Tipo | Descripción | | --------------------- | ------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | CustomDataNameOrIndex | String o Number | Nombre o Índice del dato personalizado tal como está definido en la app de Kameleoon (el índice aparece en la columna 'INDEX' del dashboard de Custom Data). Este campo es obligatorio. | | value | String, Number, Boolean, Array | Valor del dato personalizado. El argumento debe coincidir con el tipo declarado para este dato personalizado en la app de Kameleoon. Este campo es obligatorio. **Tenga en cuenta que `setCustomData()` acepta String, Number y Boolean cuando `Type` está establecido en `Single`. Si `Type` está establecido en `List` o `Count List`, aceptará un array de String o Number.** | | overwrite | Boolean | **Booleano opcional**. Cuando es `true`, el nuevo valor sobrescribe los datos personalizados existentes. Cuando es `false` o se omite: **Lists/Count Lists** añaden valores (todos los valores aparecen en los informes); los **tipos Single** sobrescriben (solo aparece el último valor); los **Custom Data con ámbito de página** (todos los tipos) añaden valores. | ### writeLocalData ```javascript theme={null} Kameleoon.API.Data.writeLocalData("myData", "myDataValue", true); ``` El método `writeLocalData()` registra datos locales en el navegador del visitante para su posterior recuperación mediante `readLocalData()`. El motor los almacena como datos de sesión unificados en Local Storage, evitando las limitaciones estándar de almacenamiento. Los datos quedan disponibles inmediatamente para su recuperación en la misma pestaña a través de caché en RAM, mientras que la escritura física se realiza de forma asincrónica. ##### Argumentos | Nombre | Tipo | Descripción | | ---------- | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | key | String | Clave (nombre) del dato que se va a escribir. Este campo es obligatorio. | | value | String | Valor del dato que se va a escribir. Este campo es obligatorio. | | persistent | Boolean | Activa/desactiva la persistencia del dato. Los datos no persistentes expiran tras 1 hora, mientras que los persistentes permanecen durante 30 días. Si se omite, el método utiliza **false** por defecto. | ## Kameleoon.API.Events Este módulo dispara eventos personalizados para la segmentación de experimentos y personalizaciones. Consulte la [documentación de eventos de la Activation API](./activation-api-events) para conocer los eventos DOM estándar. ### trigger ```javascript theme={null} Kameleoon.API.Events.trigger("myTriggerEventName"); ``` El método `trigger()` dispara un evento personalizado para los segmentos de segmentación. ##### Argumentos | Nombre | Tipo | Descripción | | --------- | ------ | ------------------------------------------------------------------ | | eventName | String | Nombre del evento que se va a disparar. Este campo es obligatorio. | ## Kameleoon.API.Tracking Este módulo integra los resultados de Kameleoon con plataformas externas de seguimiento y analítica, como Adobe Analytics (Omniture). ### processOmniture ```javascript theme={null} function s_doPlugins(s) { /* Kameleoon Integration */ window.kameleoonQueue = window.kameleoonQueue || []; kameleoonQueue.push(['Tracking.processOmniture', s]); window.kameleoonOmnitureCallSent = true; // Añada aquí abajo el resto del código doPlugins } s.doPlugins = s_doPlugins; ``` Kameleoon proporciona una integración nativa con Adobe Analytics (Omniture). Siga el ejemplo para modificar el archivo que contiene el código `s_doPlugins()`. Realice estos pasos dentro de la función: * Añada una llamada a `Kameleoon.API.Tracking.processOmniture()`. * Establezca la variable global `window.kameleoonOmnitureCallSent` en `true` para hacer seguimiento de la transmisión de la llamada inicial. Aunque puede establecer esta variable en otro lugar, debería hacerlo dentro de `s_doPlugins()`. La integración minimiza el número de hits de Adobe Analytics para ayudarle a gestionar los costes. Kameleoon envía un hit adicional solo si un experimento o personalización se dispara después de la llamada principal de seguimiento. Esto puede ocurrir por la carga asincrónica (en la que Kameleoon se carga después del código de analítica) o por disparos "tardíos", como los que ocurren después de la carga de la página (por ejemplo, clics en botones). Si Kameleoon se carga primero e identifica experimentos activos al cargar la página, la llamada global de seguimiento incluye todos los datos adicionales. ##### Argumentos | Nombre | Tipo | Descripción | | -------------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | omnitureObject | Object | Referencia a su objeto Omniture. Normalmente, la variable global "s" (**window\.s**) representa el objeto Omniture. También se pasa como argumento (llamado también "s") al método `s_doPlugins()`. Este campo es obligatorio. | ## Kameleoon.API.Products Este módulo proporciona acceso al catálogo de productos. Úselo para registrar vistas de producto o compras, añadir productos a un carrito, recuperar recomendaciones u obtener estadísticas de producto, como vistas y compras por hora o por día. Este módulo está disponible al suscribirse al módulo Product Recommendation o al add-on Product Targeting. ### obtainRecommendedProducts ```javascript theme={null} Kameleoon.API.Products.obtainRecommendedProducts( "1a2b3c4d", { item: 123500, exclude: [3, 14, 159, 26535], category: 146, search_query: "To be or not to be", limit: 15, brands: ["Alas", "poor", "Yorick", 'kameleooner'], categories: [1, 146, 123500] }, function (response) { // funcionalidad para renderizar un bloque de recomendaciones de producto }, function (error) { // cuando algo ha ido mal } ); ``` El método `obtainRecommendedProducts()` recupera los productos recomendados calculados por el algoritmo especificado mediante una llamada asincrónica al servidor. Este método requiere un seguimiento de producto correcto, como `trackProductView()` o `trackCategoryView()`, para devolver resultados significativos. ##### Argumentos | Nombre | Tipo | Descripción | | --------------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- | | code | String | Código único del bloque de recomendaciones. | | params | Object | [Parámetros para controlar los datos devueltos por la plataforma de recomendaciones.](#parameters-to-control-the-data-returned-by-the-recommendation-platform) | | successCallback | Function | Función callback que recibe el objeto de respuesta de la API. Este campo es obligatorio. | | errorCallback | Function | Función callback que se ejecuta si se produce un error. Este campo es opcional. | #### Parámetros para controlar los datos devueltos por la plataforma de recomendaciones | Nombre | Tipo | Descripción | | --------------- | ------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | | item | String | ID del producto actual. Obligatorio para los algoritmos "Similar" y "They also bought this product". | | exclude | Array | Lista separada por comas de identificadores de producto que se van a excluir. | | extended | Number | Cuando es "1", el método devuelve los detalles completos del producto. Si se omite, solo devuelve los IDs de producto. | | category | Number | Obligatorio para los algoritmos en páginas de categoría. Limita las recomendaciones a la categoría especificada. | | categories | Array | Este campo es opcional. Si se utiliza, devuelve productos recomendados únicamente de las categorías especificadas (lista separada por comas de IDs de categoría). | | brands | Array | Este campo es opcional. Si se utiliza, devuelve productos recomendados únicamente de las marcas especificadas (lista separada por comas de marcas). | | locations | Array | Este campo es opcional. Si se utiliza, devuelve productos recomendados disponibles en las ubicaciones indicadas (lista separada por comas de IDs de ubicación). | | limit | Number | Este campo es opcional. Número máximo de productos recomendados. | | exclude\_brands | Number | Este campo es opcional. Lista separada por comas de marcas que deben excluirse de la recomendación. | #### Respuesta de la API La función callback recibe el objeto de respuesta de la API con los siguientes valores. | Nombre | Tipo | Descripción | | -------- | ------ | ----------------------------------------------------------------------------------------------------------------------- | | html | String | El código HTML del bloque. Personalice la plantilla HTML en la cuenta personal de Kameleoon. | | title | String | Título del bloque. Corresponde al valor del elemento "Action" en las reglas del bloque. | | products | Array | Lista de IDs de producto. | | id | Number | Identificador único del bloque. Corresponde al ID del bloque en la lista de bloques de la cuenta personal de Kameleoon. | ### trackAddToCart ```javascript theme={null} var buyButton = Kameleoon.API.Utils.querySelectorAll("#buyButton")[0]; Kameleoon.API.Utils.addEventListener(buyButton, "mousedown", function () { Kameleoon.API.Products.trackAddToCart("myProductId", 19.99, 1, { stock: true, recommended_code: 'some-unique-code' //consulte la tabla de argumentos para más información recommended_by: 'dynamic'//consulte la tabla de argumentos para más información }); }); ``` El método `trackAddToCart()` se dispara cuando un visitante añade un producto al carrito de la compra. ##### Argumentos | Nombre | Tipo | Descripción | | ---------- | ------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | productID | String | Identificador único del producto. Este campo es obligatorio. | | unitPrice | Number | Precio de una sola unidad del producto referenciado por **productID**. Este campo es opcional; si no se especifica, se utiliza el precio por defecto del producto del feed de productos importado. | | amount | Number | Cantidad total del producto tras la actualización del carrito. Use valores no incrementales. Por ejemplo, si el carrito contiene dos artículos con el mismo `productID` y añade otro, indique 3. Si elimina dos artículos de un carrito que contiene 20, indique 18. | | parameters | Object | [Parámetros para la plataforma de recomendaciones.](#parameters-for-the-recommendation-platform) Este campo es opcional. | #### Parámetros para la plataforma de recomendaciones | Nombre | Tipo | Descripción | | ----------------- | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------- | | recommended\_by | String | Para SPAs o pop-ups, establezca este valor en "dynamic". Este campo es obligatorio en escenarios específicos. | | recommended\_code | String | Para SPAs o pop-ups, proporcione el código único del widget que se encuentra en el atributo "data-recommender-code" de su cuenta. | | stock | Boolean | Disponibilidad del producto. Este valor sobrescribe los datos de los feeds de productos o de las importaciones de catálogo. Este campo es opcional. | ### trackAddToWishList ```javascript theme={null} Kameleoon.API.Products.trackAddToWishList("myProductId"); // para añadir a la wish list Kameleoon.API.Products.trackAddToWishList("myProductId", -1); // para eliminar de la wish list ``` El método `trackAddToWishList()` se ejecuta cuando un visitante añade o elimina un producto de la wish list o de favoritos. | Nombre | Tipo | Descripción | | --------- | ------ | ---------------------------------------------------------------------------------------------------------------------------------------------------- | | productId | String | Identificador único del producto añadido a la wishlist. Este campo es obligatorio. | | quantity | Number | Cantidad que se va a actualizar. Use valores negativos (por ejemplo, -1) para indicar eliminación. Si se omite, el método utiliza **1** por defecto. | ### trackCategoryView ```javascript theme={null} if (location.href.indexOf("productPage") != -1) { Kameleoon.API.Core.runWhenConditionTrue(function () { return typeof dataLayer != null; }, function () { dataLayer.forEach(function (map) { if (map.categoryID) { Kameleoon.API.Products.trackCategoryView(5); } }); }, 200); } ``` El método `trackCategoryView()` se ejecuta para cada vista de página de categoría durante una sesión. ##### Argumentos | Nombre | Tipo | Descripción | | ---------- | ------ | --------------------------------------------------------------- | | categoryID | String | Identificador único de la categoría. Este campo es obligatorio. | ### trackProductView ```javascript theme={null} Kameleoon.API.Products.trackProductView("myProductID", { "name": "productName", "categories": [{ "id": "13", "name": "productCategory", "parent": null, "url": "website.com/category/2" }], "imageURL": "https://www.mywebsite/productImage.jpg", "price": 19.99, "oldPrice": 23.99, "accessories": ['productID1', 'productID2'], "available": true, "availableQuantity": 15, "brand": "productBrand", "groupId": "groupID1", "sku": "productSKU", "description": "This is a short description", "rating": 4, "model": "phone 14 128GB", "leftovers": "one", "tags": ["shirt", "red"], "typePrefix": "mobile phone", "seasonality": [1, 2, 3, 10, 11, 12], "priceMargin": 100, "isChild": false, "isNew": false, "isFashion": true, "auto": { "vds": ["BP8AN5", "HH5820"], "compatibility": [ { "brand": "BMW" }, { "brand": "Mini", "model": "Cooper S" } ] }, "fashion": { "gender": "f", "type": "shoe", "sizes": ["37", "42"], "feature": "adult", "colors": [ { "color": "red" }, { "color": "green", "picture": "https://example.com/items/395532-green.jpg" } ] }, "params": [ { "name": "connectivity", "value": ["bluetooth", "wi-fi"] }, { "name": "lengths", "value": ["4", "6", "8"], "unit": "cm" } ] }); ``` El método `trackProductView()` se ejecuta para cada vista de producto durante una sesión. Este método permite a Kameleoon construir un catálogo de productos automatizado sin una integración de feed XML, lo que simplifica la configuración de proyectos de recomendación de productos. ##### Argumentos | Nombre | Tipo | Descripción | | ----------- | ------ | --------------------------------------------------------------------------------------------------------------------------------- | | productID | String | Identificador del producto. Puede ser cualquier identificador único para este producto en particular. Este campo es obligatorio. | | productData | Object | [Objeto Product](#product). Este campo es obligatorio para importar feeds de producto a través del add-on Product Recommendation. | ### trackSearchQuery ```javascript theme={null} Kameleoon.API.Products.trackSearchQuery("Example search request"); ``` El método `trackSearchQuery()` registra las consultas de búsqueda del usuario. ##### Argumentos | Nombre | Tipo | Descripción | | ------------- | ------ | ------------------------------------------------------------ | | search\_query | String | Valor de la consulta de búsqueda. Este campo es obligatorio. | ### trackTransaction ```javascript theme={null} Kameleoon.API.Products.trackTransaction( [ { "productID": "myProductID1", "quantity": 4 }, { "productID": "myProductID4564", "quantity": 1 } ], { "order": "N318", "order_price": 29999 } ); ``` El método `trackTransaction()` se ejecuta cuando se produce una transacción o compra. ##### Argumentos | Nombre | Tipo | Descripción | | -------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------ | | products | Array | Lista de objetos que contienen `productID` y `quantity` para cada producto de la transacción. Este campo es obligatorio. | | params | Object | [Parámetros adicionales para la plataforma de recomendaciones.](#additional-parameters-for-tracktransaction) Este campo es opcional. | ##### Parámetros adicionales para trackTransaction | Nombre | Tipo | Descripción | | --------------- | ------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | order | string | Número de pedido de la tienda. Si lo omite, el motor utiliza un sistema interno de numeración, lo que impide la sincronización del estado del pedido. Consulte las descripciones de parámetros a continuación. | | order\_price | Number | Coste final del pedido, incluyendo descuentos, bonificaciones y servicios adicionales. Si lo omite, el motor calcula el coste a partir de la base de datos de productos sin descuentos ni servicios. | | email | string | Correo electrónico del cliente. | | phone | string | Número de teléfono del cliente. | | promocode | string | Código promocional de la transacción. | | order\_cash | number | Importe pagado en efectivo. | | order\_bonuses | number | Importe pagado con bonificaciones. | | order\_delivery | number | Coste de envío. | | order\_discount | number | Importe del descuento del pedido. | | delivery\_type | string | Método de envío. | | payment\_type | string | Tipo de pago (por ejemplo, "cash", "card", "wire"). | | tax\_free | boolean | Estado de exención de impuestos. | ### obtainInstantSearchProducts ```javascript theme={null} Kameleoon.API.Products.obtainInstantSearchProducts( { search_query: "To be or not to be" }, function (response) { // funcionalidad para renderizar un bloque desde instant search }, function (error) { // para gestionar cuándo algo va mal } ); ``` El método `obtainInstantSearchProducts()` recupera resultados de búsqueda instantánea personalizados de Kameleoon Search mediante una llamada asincrónica al servidor. ##### Argumentos | Nombre | Tipo | Descripción | | --------------- | -------- | ---------------------------------------------------------------------------------------- | | search\_query | String | Consulta de búsqueda proporcionada por el usuario. Este campo es obligatorio. | | successCallback | Function | Función callback que recibe el objeto de respuesta de la API. Este campo es obligatorio. | | errorCallback | Function | Función callback que se ejecuta si se produce un error. Este campo es opcional. | #### Respuesta de la API La función callback recibe el objeto de respuesta de la API con los siguientes valores. | Nombre | Tipo | Descripción | | ------------------------ | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | search\_query | String | Consulta de búsqueda | | categories | Array | Array con información sobre categorías. Cada objeto tiene las siguientes propiedades: | | filters | Array | Array con información sobre filtros. Cada objeto tiene las siguientes propiedades: | | html | String | Código HTML del bloque con productos. La plantilla se personaliza en la cuenta personal de Kameleoon. | | price\_range | Object | Precio mínimo y máximo de los productos. Tiene las siguientes propiedades: | | products | Array | Array con información sobre productos. Cada objeto tiene las siguientes propiedades: | | search\_query\_redirects | array | Array con información sobre redirecciones. Cada objeto tiene las siguientes propiedades: | | products\_tota | Number | Número total de productos | ### obtainFullSearchProducts ```javascript theme={null} Kameleoon.API.Products.obtainFullSearchProducts( { search_query: "To be or not to be", limit: 15, brands: ["Alas", "poor", "Yorick"], categories: [1, 146, 100500], filters: { key: ["value"], key: ["value"] }, sort_by: "price", order: "asc" }, function (response) { // funcionalidad para renderizar un bloque desde full search }, function (error) { // cuando algo ha ido mal } ); ``` Use el método `obtainFullSearchProducts()` para recuperar resultados de búsqueda completos de la solución Kameleoon Search con opciones de filtrado. ##### Argumentos | Nombre | Tipo | Descripción | | --------------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | search\_query | Object | Consulta de búsqueda proporcionada por el usuario y parámetros opcionales de filtro. Revise los parámetros de filtrado en la siguiente sección. Este campo es obligatorio. | | successCallback | Function | Función callback que recibe el objeto de respuesta de la API. Este campo es obligatorio. | | errorCallback | Function | Función callback que se ejecuta si se produce un error. Este campo es opcional. | ##### Parámetros para filtrar resultados | Nombre | Tipo | Descripción | | ------------------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- | | search\_query | String | Consulta de búsqueda. Este campo es obligatorio. | | limit | Number | Límite de resultados. Este campo es opcional. | | offset | Number | Offset de resultados. Este campo es opcional. | | category\_limit | Number | Cuántas categorías devolver para el filtro lateral. Este campo es opcional. | | categories | Array | Lista separada por comas de categorías para filtrar. Este campo es opcional. | | extended | Number | Establezca en `true` para obtener resultados de búsqueda completos. | | sort\_by | String | Parámetro de ordenación: `popular`, `price`, `discount`, `sales_rate`, `date`. Este campo es opcional. | | order | String | Dirección de ordenación: asc o desc (por defecto). Este campo es opcional. | | locations | Array | Lista separada por comas de IDs de ubicaciones. Este campo es opcional. | | brands | Array | Lista separada por comas de marcas para filtrar. Este campo es opcional. | | filters | String | Cadena JSON escapada opcional con parámetros de filtro. Por ejemplo: `{"bluetooth":["yes"],"offers":["15% cashback"],"weight":["1.6"]}`. Este campo es opcional. | | price\_min | Number | Precio mínimo. Este campo es opcional. | | price\_max | Number | Precio máximo. Este campo es opcional. | | colors false | Array | Lista separada por comas de colores. Este campo es opcional. | | fashion\_sizes | Array | Lista separada por comas de tallas. Este campo es opcional. | | exclude | Array | Lista separada por comas de IDs de producto que se excluirán de los resultados. Este campo es opcional. | | email | String | Solo para integración S2S, cuando el servicio no dispone de la sesión del usuario. El SDK móvil no lo usa. Este campo es opcional. | | no\_clarification | Boolean | Desactiva la búsqueda clarificada. Por defecto **false**. No use este parámetro a menos que se lo indique el soporte de Kameleoon. | | merchants | Array | Lista separada por comas de comerciantes. Este campo es opcional. | | filters\_search\_by | String | Opciones disponibles para el filtro: `name`, `quantity`, `popularity`. Este campo es opcional. | #### Respuesta de la API La función callback recibe el objeto de respuesta de la API con los siguientes valores. | Nombre | Tipo | Descripción | | --------------- | ------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | brands | Array | Array con información sobre marcas. Cada objeto tiene las siguientes propiedades: | | categories | Array | Array con información sobre categorías. Cada objeto tiene las siguientes propiedades: | | filters | Array | Array con información sobre filtros. Cada objeto tiene las siguientes propiedades: | | html | String | Código HTML del bloque con productos. La plantilla se personaliza en la cuenta personal de Kameleoon. | | price\_range | Object | Precio mínimo y máximo de los productos. Tiene las siguientes propiedades: | | products | Array | Array con información sobre productos. Cada objeto tiene las siguientes propiedades: | | products\_total | Number | Número total de productos | | search\_query | String | Consulta de búsqueda introducida por el usuario. | ### obtainProductInteractions ```javascript theme={null} Kameleoon.API.Products.obtainProductInteractions("123456", product => { console.log("product", product); // {123456: {views: 1, cartQuantities: 0, boughtQuantities: 0}} }); Kameleoon.API.Products.obtainProductInteractions(["123456", "654321"], products => { console.log("products", products); }); Kameleoon.API.Products.obtainProductInteractions( "123456", callback, new Date().getTime() - 1000 * 60 * 60 * 24, // timeBegin new Date().getTime() // timeEnd ); ``` El método `obtainProductInteractions()` recupera métricas de interacción de productos rastreados mediante `trackProductView()`, `trackTransaction()` o `trackAddToCart()`. ##### Argumentos | Nombre | Tipo | Descripción | | --------- | -------- | ------------------------------------------------------------------------------ | | eans | Array | IDs de producto (como Strings). Este campo es obligatorio. | | callback | Function | Función callback que recibe los datos del producto. Este campo es obligatorio. | | timeBegin | Number | Inicio del rango de fechas (timestamp UNIX en milisegundos). | | timeEnd | Number | Fin del rango de fechas (timestamp UNIX en milisegundos). | ##### Respuesta de la API | Nombre | Tipo | Descripción | | ---------------- | ------- | ----------------------------------------------------------------------------------------------------------------- | | eans | Array | Identificador único del producto. Cada ID de producto se asigna a un objeto que contiene métricas de interacción. | | views | integer | Número de veces que el producto ha sido visto. | | cartQuantities | integer | Número total de veces que el producto ha sido añadido a los carritos de los visitantes. | | boughtQuantities | integer | Número total de veces que el producto ha sido comprado. | ### obtainProductData ```javascript theme={null} Kameleoon.API.Products.obtainProductData("123456", product => { console.log("product", product); }); Kameleoon.API.Products.obtainProductData(["123456", "654321"], products => { console.log("products", products); }); Kameleoon.API.Products.obtainProductData("123456", callback, { name: true, categoryId: true }); // {123456: {name: '', categoryId: '' }} ``` El método `obtainProductData()` recupera la información de los productos enviados mediante `trackProductView()`. ##### Argumentos | Nombre | Tipo | Descripción | | ---------- | -------- | ------------------------------------------------------------------------------------- | | eans | Array | IDs de producto (como Strings). Este campo es obligatorio. | | callback | Function | Función callback que recibe los datos del producto. Este campo es obligatorio. | | parameters | Object | Parámetros opcionales para recuperar campos específicos. Por defecto `{ all: true }`. | ##### Respuesta de la API | Nombre | Tipo | Descripción | | ----------- | ------ | ----------------------------------------------------------------------------------------------------------------- | | eans | Array | Identificador único del producto. Cada ID de producto se asigna a un objeto que contiene métricas de interacción. | | productData | Object | [Objeto Product](#product). Se recibirá en este campo el mismo objeto que se envió mediante `trackProductView`. | ### obtainRecommendedCollections ```javascript theme={null} Kameleoon.API.Products.obtainRecommendedCollections("123456", collections => { /* Funcionalidad para renderizar un bloque de colección de productos */ console.log("collections", collections); }, error => { /* Lógica de gestión de errores si algo va mal */ }); ``` El método `obtainRecommendedCollections()` recupera los productos de la colección especificada. ##### Argumentos | Nombre | Tipo | Descripción | | --------------- | -------- | ----------------------------------------------------------------------------------------------- | | collectionId | String | ID de la colección de productos, disponible en la sección del dashboard de Product Collections. | | successCallback | Function | Función callback que recibe el objeto de respuesta de la API. Este campo es obligatorio. | | errorCallback | Function | Función callback que se ejecuta si se produce un error. Este campo es opcional. | #### Respuesta de la API ##### Products La API devuelve un array de objetos. Cada objeto del array `products` contiene lo siguiente: | **Parámetro** | **Tipo** | **Descripción** | | ---------------------- | ---------------- | ---------------------------------------------------------------------------------- | | name | String | Nombre del producto | | url | String (URL) | URL de la página del producto | | description | String | Descripción del producto | | category\_ids | Array of Strings | Lista de IDs de categorías a las que pertenece el producto | | brand | String | Marca del producto | | fashion\_feature | String | Característica fashion (por ejemplo, `"adult"`) | | fashion\_gender | String | Género al que se destina el producto | | sales\_rate | Integer | Tasa de ventas del producto | | relative\_sales\_rate | Float | Tasa de ventas relativa a otros productos | | picture | String (URL) | URL de la imagen principal del producto | | categories | Array of Objects | Lista de objetos de categoría (estructura definida por el sistema) | | price\_formatted | String | Precio formateado del producto (por ejemplo, `$29.99`) | | price\_full\_formatted | String | Precio completo/original formateado | | price | Float | Precio actual del producto | | price\_full | Float | Precio original/completo antes de descuentos | | image\_url | String (URL) | URL de la imagen redimensionada del producto | | image\_url\_handle | String (URL) | URL procesada de la imagen (basada en handle) | | image\_url\_resized | String (URL) | URL redimensionada de la imagen | | url\_handle | String | URL handle utilizada para acceder al producto dentro de la colección | | currency | String | Código de moneda utilizado para el precio del producto (por ejemplo, `USD`, `EUR`) | | id | String | ID del producto (numérico o string según el sistema) | | html | String (HTML) | La plantilla HTML seleccionada cuando se creó la colección | ## Kameleoon.API.Experiments Este módulo proporciona métodos para acceder a los experimentos en directo. Este módulo solo está disponible con la solución Kameleoon Web Experimentation. ### assignVariation ```javascript theme={null} var experimentID = 2468; var variationID; if (Kameleoon.API.CurrentVisit.device.type == "Desktop") { variationID = 123456; } else if (Kameleoon.API.CurrentVisit.device.type == "Tablet") { variationID = 654321; } else { variationID = 987654; } Kameleoon.API.Experiments.assignVariation(experimentID, variationID); ``` El método `assignVariation()` fuerza la asociación de una variación específica a un experimento, lo que anula el algoritmo de asignación estándar. Si lo llama antes de que el experimento se dispare, el motor preasigna la variación para su activación posterior. Si el experimento ya se ha disparado, establezca el argumento **override** en **true** para reemplazar la asociación existente. ##### Argumentos | Nombre | Tipo | Descripción | | ------------ | ------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | experimentID | Number | ID del experimento. Este campo es obligatorio. | | variationID | Number | ID de la variación. Este campo es obligatorio. | | override | Boolean | Cuando es **true**, el motor reemplaza cualquier asociación de variación existente por el valor proporcionado. Si se omite, el método utiliza **false** por defecto. | ### block ```javascript theme={null} // El experimento se bloqueará para la página actual Kameleoon.API.Experiments.block(12345); // El experimento se bloqueará para toda la visita Kameleoon.API.Experiments.block(54321, true); ``` El método `block()` evita que un experimento se dispare o se active, incluidas las llamadas manuales a `trigger()`. El bloqueo se aplica a la página actual por defecto hasta la próxima llamada a `Kameleoon.API.Core.load()`. Establezca el argumento **visit** en **true** para bloquear el experimento durante toda la visita. ##### Argumentos | Nombre | Tipo | Descripción | | ------------ | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- | | experimentID | Number | ID del experimento. Este campo es obligatorio. | | visit | Boolean | Cuando es **true**, el motor bloquea el experimento durante toda la visita. Si se omite, el bloqueo solo se aplica a la página actual (por defecto: **false**). | ### getAll ```javascript theme={null} Kameleoon.API.Experiments.getAll().forEach(function (experiment) { if (experiment.id == 123456 && experiment.active) { console.log(experiment.name); } }); ``` El método `getAll()` devuelve todos los experimentos en directo (en ejecución; no en borrador/pausados/detenidos). ##### Valor de retorno | Nombre | Tipo | Descripción | | ----------- | ----- | ------------------------------------------- | | experiments | Array | Lista de [objetos Experiment](#experiment). | ### getActive ```javascript theme={null} if (Kameleoon.API.Experiments.getActive().length == 0) { Kameleoon.API.Events.trigger("No Experiments Events"); } ``` El método `getActive()` devuelve los experimentos activos para la visita y página actuales. Un experimento está activo si su código de variación se ha ejecutado en el contexto de la sesión actual. Para recuperar experimentos que activó en otras URL durante la visita, use `getActivatedInVisit()`. ##### Valor de retorno | Nombre | Tipo | Descripción | | ----------- | ----- | ------------------------------------------- | | experiments | Array | Lista de [objetos Experiment](#experiment). | ### getById ```javascript theme={null} var experiment = Kameleoon.API.Experiments.getById(123456); if (experiment && experiment.active) { console.log(experiment.name); } ``` El método `getById()` devuelve el experimento con el ID especificado. ##### Argumentos | Nombre | Tipo | Descripción | | ------ | ------ | ---------------------------------------------- | | id | Number | ID del experimento. Este campo es obligatorio. | ##### Valor de retorno | Nombre | Tipo | Descripción | | ---------- | ------ | --------------------------------- | | experiment | Object | [Objeto Experiment](#experiment). | ### getByName ```javascript theme={null} var experiment = Kameleoon.API.Experiments.getByName("MyExperimentName"); if (experiment && experiment.active) { console.log(experiment.id); } ``` El método `getByName()` devuelve el experimento con el nombre especificado. ##### Argumentos | Nombre | Tipo | Descripción | | ------ | ------ | -------------------------------------------------- | | name | String | Nombre del experimento. Este campo es obligatorio. | ##### Valor de retorno | Nombre | Tipo | Descripción | | ---------- | ------ | ---------------------------------- | | experiment | Object | [Objetos Experiment](#experiment). | ### getTriggeredInVisit ```javascript theme={null} Kameleoon.API.Experiments.getTriggeredInVisit().forEach(function (experiment) { if (experiment.id == 123456) { console.log(experiment.name); } }); ``` El método `getTriggeredInVisit()` devuelve todos los experimentos disparados durante la visita actual. ##### Valor de retorno | Nombre | Tipo | Descripción | | ----------- | ----- | ------------------------------------------- | | experiments | Array | Lista de [objetos Experiment](#experiment). | ### getActivatedInVisit ```javascript theme={null} Kameleoon.API.Experiments.getActivatedInVisit().forEach(function (experiment) { if (experiment.id == 123456) { console.log(experiment.name); } }); ``` El método `getActivatedInVisit()` devuelve todos los experimentos activados durante la visita actual. ##### Valor de retorno | Nombre | Tipo | Descripción | | ----------- | ----- | ------------------------------------------- | | experiments | Array | Lista de [objetos Experiment](#experiment). | ### trigger ```javascript theme={null} let experimentID = 123456; Kameleoon.API.Experiments.trigger(experimentID, true); ``` El método `trigger()` fuerza el disparo de un experimento, omitiendo las condiciones de segmentación. Esta acción inicia el experimento pero puede no activarlo. ##### Argumentos | Nombre | Tipo | Descripción | | ------------ | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | experimentID | Number | ID del experimento. Este campo es obligatorio. | | trackingOnly | Boolean | Establezca en **true** para experimentos híbridos (implementación en backend con tracking en frontend) para realizar solo acciones de tracking sin ejecutar los assets de la variación (JS, CSS, redirecciones). Si se omite, el método utiliza **false** por defecto. | ## Kameleoon.API.Personalizations Este módulo proporciona métodos para acceder a las personalizaciones en directo. ### disable ```javascript theme={null} let personalizationID = 12345; Kameleoon.API.Personalizations.disable(personalizationID); ``` El método `disable()` marca una personalización como desactivada. Úselo para elementos interactivos como pop-ins. Cuando un usuario cierre el elemento, llame a `disable()` para actualizar el estado de la personalización. Kameleoon implementa automáticamente esta llamada para elementos nativos de la interfaz no personalizados. ##### Argumentos | Nombre | Tipo | Descripción | | ------ | ------ | ---------------------------------------------------- | | id | Number | Id de la personalización. Este campo es obligatorio. | ### getActive ```javascript theme={null} if (Kameleoon.API.Personalizations.getActive().length == 0) { Kameleoon.API.Events.trigger("No Personalizations Events"); } ``` El método `getActive()` devuelve las personalizaciones activas para la visita y página actuales. Una personalización está activa si su código de variación se ha ejecutado y la acción asociada sigue visible. Para recuperar personalizaciones disparadas en otras URL o que ahora están cerradas, como los pop-ins, use `getTriggeredInVisit()`. ##### Valor de retorno | Nombre | Tipo | Descripción | | ---------------- | ----- | ----------------------------------------------------- | | personalizations | Array | Lista de [objetos Personalization](#personalization). | ### getAll ```javascript theme={null} Kameleoon.API.Personalizations.getAll().forEach(function (personalization) { if (personalization.id == 123456 && personalization.active) { console.log(personalization.name); } }); ``` El método `getAll()` devuelve todas las personalizaciones en directo (en ejecución; no en borrador/pausadas/detenidas). ##### Valor de retorno | Nombre | Tipo | Descripción | | ---------------- | ----- | ----------------------------------------------------- | | personalizations | Array | Lista de [objetos Personalization](#personalization). | ### getById ```javascript theme={null} var personalization = Kameleoon.API.Personalizations.getById(123456); if (personalization && personalization.active) { console.log(personalization.name); } ``` El método `getById()` devuelve la personalización con el ID especificado. ##### Argumentos | Nombre | Tipo | Descripción | | ------ | ------ | ---------------------------------------------------- | | id | Number | Id de la personalización. Este campo es obligatorio. | ##### Valor de retorno | Nombre | Tipo | Descripción | | --------------- | ------ | ------------------------------------------- | | personalization | Object | [Objeto Personalization](#personalization). | ### getByName ```javascript theme={null} var personalization = Kameleoon.API.Personalizations.getByName("MyPersonalizationName"); if (personalization && personalization.active) { console.log(personalization.id); } ``` El método `getByName()` devuelve la personalización con el nombre especificado. ##### Argumentos | Nombre | Tipo | Descripción | | ------ | ------ | -------------------------------------------------------- | | name | String | Nombre de la personalización. Este campo es obligatorio. | ##### Valor de retorno | Nombre | Tipo | Descripción | | --------------- | ------ | ------------------------------------------- | | personalization | Object | [Objeto Personalization](#personalization). | ### getTriggeredInVisit ```javascript theme={null} Kameleoon.API.Personalizations.getTriggeredInVisit().forEach(function (personalization) { if (personalization.id == 123456) { console.log(personalization.name); } }); ``` El método `getTriggeredInVisit()` devuelve todas las personalizaciones disparadas durante la visita actual. ##### Valor de retorno | Nombre | Tipo | Descripción | | ---------------- | ----- | ----------------------------------------------------- | | personalizations | Array | Lista de [objetos Personalization](#personalization). | ### getActivatedInVisit ```javascript theme={null} Kameleoon.API.Personalizations.getActivatedInVisit().forEach(function (personalization) { if (personalization.id == 123456) { console.log(personalization.name); } }); ``` El método `getActivatedInVisit()` devuelve todas las personalizaciones activadas durante la visita actual. ##### Valor de retorno | Nombre | Tipo | Descripción | | ---------------- | ----- | ----------------------------------------------------- | | personalizations | Array | Lista de [objetos Personalization](#personalization). | ### trigger ```javascript theme={null} let personalizationID = 123456; Kameleoon.API.Personalizations.trigger(personalizationID, true); ``` El método `trigger()` fuerza el disparo de una personalización, omitiendo las condiciones de segmentación. Esta acción inicia la personalización pero puede no activarla. ##### Argumentos | Nombre | Tipo | Descripción | | ----------------- | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | personalizationID | Number | ID de la personalización. Este campo es obligatorio. | | trackingOnly | Boolean | Establezca en **true** para personalizaciones externas (segmentación o seguimiento gestionados por Kameleoon) para realizar solo acciones de tracking sin ejecutar los assets de la variación (JS, CSS, redirecciones). Si se omite, el método utiliza **false** por defecto. | ## Kameleoon.API.Variations Este módulo proporciona métodos para gestionar variaciones. ### execute ```javascript theme={null} if (Kameleoon.API.Utils.querySelectorAll("#KameleoonPopin").length == 0) { Kameleoon.API.Experiments.getById(123456).variations.forEach(function (variation) { if (variation.name == "MyVariation") { Kameleoon.API.Variations.execute(variation.id); } }); } ``` El método `execute()` ejecuta el JavaScript y aplica el CSS de la variación con el ID especificado. ## Kameleoon.API.Segments Este módulo proporciona métodos para gestionar segmentos y segmentación. ### getAll ```javascript theme={null} let segments = Kameleoon.API.Segments.getAll(); ``` El método `getAll()` devuelve todos los segmentos en directo, incluidos los asociados a experimentos, personalizaciones o al seguimiento de Audiences. ##### Valor de retorno | Nombre | Tipo | Descripción | | -------- | ----- | ------------------------------------- | | segments | Array | Lista de [objetos Segment](#segment). | ### getById ```javascript theme={null} let segment = Kameleoon.API.Segments.getById(123456); ``` El método `getById()` devuelve el segmento con el ID especificado. ##### Argumentos | Nombre | Tipo | Descripción | | ------ | ------ | ------------------------------------------- | | id | Number | ID del segmento. Este campo es obligatorio. | ##### Valor de retorno | Nombre | Tipo | Descripción | | ------- | ------ | --------------------------- | | segment | Object | [Objeto Segment](#segment). | ### getByName ```javascript theme={null} let segment = Kameleoon.API.Segments.getByName("My segment"); ``` El método `getByName()` devuelve el segmento con el nombre especificado. ##### Argumentos | Nombre | Tipo | Descripción | | ------ | ------ | ----------------------------------------------- | | name | String | Nombre del segmento. Este campo es obligatorio. | ##### Valor de retorno | Nombre | Tipo | Descripción | | ------- | ------ | --------------------------- | | segment | Object | [Objeto Segment](#segment). | ### reevaluate ```javascript theme={null} Kameleoon.API.Utils.addEventListener(document.body, "mouseleave", function (event) { if (event.clientY < 0) { Kameleoon.API.Segments.reevaluate(123456); } }); ``` El método `reevaluate()` fuerza una nueva evaluación inmediata de las condiciones de segmentación del segmento especificado. La evaluación se produce normalmente al cargar la página, dando como resultado estados **true**, **false** o **undefined**. Este método reinicia el proceso de evaluación como si el motor acabara de inicializarse. ##### Argumentos | Nombre | Tipo | Descripción | | ------ | ------ | ------------------------------------------- | | id | Number | ID del segmento. Este campo es obligatorio. | ### trigger ```javascript theme={null} Kameleoon.API.Segments.trigger(12345); ``` El método `trigger()` fuerza el disparo de un segmento para el visitante actual y omite las condiciones de segmentación. ##### Argumentos | Nombre | Tipo | Descripción | | ------ | ------ | ------------------------------------------- | | id | Number | ID del segmento. Este campo es obligatorio. | ## Kameleoon.API.Triggers Este módulo proporciona métodos para gestionar triggers y segmentación. ### getAll ```javascript theme={null} let triggers = Kameleoon.API.Triggers.getAll(); ``` El método `getAll()` devuelve todos los triggers en directo, incluidos los asociados a experimentos, personalizaciones o al seguimiento de Audiences. ##### Valor de retorno | Nombre | Tipo | Descripción | | -------- | ----- | ------------------------------------- | | triggers | Array | Lista de [objetos Trigger](#trigger). | ### getById ```javascript theme={null} let trigger = Kameleoon.API.Triggers.getById(123456); ``` El método `getById()` devuelve el trigger con el ID especificado. ##### Argumentos | Nombre | Tipo | Descripción | | ------ | ------ | ------------------------------------------ | | id | Number | ID del trigger. Este campo es obligatorio. | ##### Valor de retorno | Nombre | Tipo | Descripción | | ------- | ------ | --------------------------- | | trigger | Object | [Objeto Trigger](#trigger). | ### getByName ```javascript theme={null} let trigger = Kameleoon.API.Triggers.getByName("My trigger"); ``` El método `getByName()` devuelve el trigger con el nombre especificado. ##### Argumentos | Nombre | Tipo | Descripción | | ------ | ------ | ---------------------------------------------- | | name | String | Nombre del trigger. Este campo es obligatorio. | ##### Valor de retorno | Nombre | Tipo | Descripción | | ------- | ------ | --------------------------- | | trigger | Object | [Objeto Trigger](#trigger). | ### reevaluate ```javascript theme={null} Kameleoon.API.Utils.addEventListener(document.body, "mouseleave", function (event) { if (event.clientY < 0) { Kameleoon.API.Triggers.reevaluate(123456); } }); ``` El método `reevaluate()` fuerza una nueva evaluación inmediata de las condiciones de segmentación del trigger especificado. La evaluación se produce normalmente al cargar la página, dando como resultado estados **true**, **false** o **undefined**. Este método reinicia el proceso de evaluación como si el motor acabara de inicializarse. ##### Argumentos | Nombre | Tipo | Descripción | | ------ | ------ | ------------------------------------------ | | id | Number | ID del trigger. Este campo es obligatorio. | ### trigger ```javascript theme={null} Kameleoon.API.Triggers.trigger(12345); ``` El método `trigger()` fuerza el disparo de un trigger para el visitante actual y omite las condiciones de segmentación. ##### Argumentos | Nombre | Tipo | Descripción | | ------ | ------ | ------------------------------------------ | | id | Number | ID del trigger. Este campo es obligatorio. | ## Kameleoon.API.Utils Este módulo proporciona métodos de utilidad para operaciones comunes. ### addEventListener ```javascript theme={null} var popin = document.createElement("div"); popin.id = "kameleoonPopin"; popin.innerHTML = ""; document.body.appendChild(popin); Kameleoon.API.Utils.addEventListener(popin, "mousedown", function (event) { document.body.removeChild(popin); }); ``` El método `addEventListener()` asocia un manejador de eventos al elemento especificado. Kameleoon reinicia todos los event listeners creados a través de esta API durante las recargas del motor. Use este método para añadir listeners en SPAs y garantizar una limpieza adecuada. ##### Argumentos | Nombre | Tipo | Descripción | | --------- | -------- | ------------------------------------------------------------------------------ | | element | Object | Elemento objetivo del listener. Este campo es obligatorio. | | eventType | String | Nombre del evento. Este campo es obligatorio. | | callback | Function | Función que se ejecuta cuando se dispara el evento. Este campo es obligatorio. | ### addUniversalClickListener ```javascript theme={null} let btn = document.querySelector("#MyButton"); Kameleoon.API.Utils.addUniversalClickListener(btn, function (event) { let goalID = 1234; Kameleoon.API.Goals.processConversion(goalID); }); ``` El método `addUniversalClickListener()` asocia un manejador de clic que escucha clics de ratón en escritorio y eventos de touchdown en dispositivos móviles y tablets. En dispositivos móviles, se produce un touchdown si el motor detecta un evento `touchstart` seguido de un evento `touchend` sin un `touchmove` intermedio. Kameleoon reinicia todos los listeners creados a través de esta API durante las recargas del motor, lo que facilita la limpieza en SPAs. En dispositivos de escritorio, los clics derechos también disparan este método (por ejemplo, al abrir un enlace en una nueva pestaña). ##### Argumentos | Nombre | Tipo | Descripción | | -------- | -------- | -------------------------------------------------------------------------------------- | | element | Object | Elemento objetivo del listener. Este campo es obligatorio. | | callback | Function | Función que se ejecuta cuando se dispara el evento de clic. Este campo es obligatorio. | ### clearInterval ```javascript theme={null} var myInterval = Kameleoon.API.Utils.setInterval(function () { if (window.dataLayer != null) { Kameleoon.API.Utils.clearInterval(myInterval); } }, 1000); ``` El método `clearInterval()` cancela un temporizador que estableció mediante `setInterval()`. ##### Argumentos | Nombre | Tipo | Descripción | | ---------- | ------ | -------------------------------------------------------------------------------------- | | intervalId | Number | ID del temporizador devuelto por el método `setInterval()`. Este campo es obligatorio. | ### clearTimeout ```javascript theme={null} var myTimeout = Kameleoon.API.Utils.setTimeout(function () { var popin = document.createElement("div"); popin.id = "kameleoonPopin"; popin.innerHTML = ""; document.body.appendChild(popin); }, 5000); Kameleoon.API.Utils.addEventListener(document.body, "mousedown", function () { Kameleoon.API.Utils.clearTimeout(myTimeout); }); ``` El método `clearTimeout()` cancela un temporizador que estableció mediante `setTimeout()`. ##### Argumentos | Nombre | Tipo | Descripción | | --------- | ------ | ------------------------------------------------ | | timeoutId | Number | ID del temporizador devuelto por `setTimeout()`. | ### computeHash ```javascript theme={null} var emailId = Kameleoon.API.Utils.createHash("myemail@mail.com"); Kameleoon.API.Data.setCustomData("VisitorEmail", emailId); ``` El método `computeHash()` calcula un hash a partir de una cadena. Úselo para procesar datos únicos sin manipular directamente información personal sensible. ##### Argumentos | Nombre | Tipo | Descripción | | ------ | ------ | --------------------------------------------------------- | | string | String | La cadena de origen a partir de la cual calcular el hash. | ##### Valor de retorno | Nombre | Tipo | Descripción | | ------ | ------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | hash | String | Hash resultante. El algoritmo utilizado es el mismo que la [implementación de `hashCode()` para java.lang.String](https://www.w3schools.com/java/ref_string_hashcode.asp). | ### getURLParameters ```javascript theme={null} var parameters = Kameleoon.API.Utils.getURLParameters(); if (parameters.productID != null) { Kameleoon.API.Events.trigger("ProductPage"); } ``` El método `getURLParameters()` analiza la URL actual y devuelve todos los parámetros detectados. Este método admite tanto los parámetros de búsqueda (?) como los de hash (#). ##### Valor de retorno | Nombre | Tipo | Descripción | | ---------- | ------ | -------------------------------------------------------------------------------- | | parameters | Object | Objeto con los nombres de los parámetros como claves y los valores como valores. | ### performRequest ```javascript theme={null} Kameleoon.API.Utils.performRequest( "https://www.my_web_server_url.com", function () { if (this.readyState == 4 && this.status == 200) { eval(this.responseText); } }, function() { console.log("Request cancelled"); }, 2000 ); ``` El método `performRequest()` inicia una llamada a un servidor web remoto. ##### Argumentos | Nombre | Tipo | Descripción | | ----------------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | url | String | La URL del servidor remoto. Este campo es obligatorio. | | readyStateHandler | Function | Una función callback que se ejecutará cuando se reciba una respuesta del servidor. El argumento del evento se pasa a esta función ([load event](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/load_event)) y el objeto XMLHttpRequest subyacente se vincula al callback. Por lo tanto, todas las [propiedades de XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest#Properties) están disponibles dentro del callback a través de **this**. Este campo es opcional. | | errorHandler | Function | Una función callback que se llamará en caso de que se produzca un error. El argumento del evento se pasa a esta función ([error event](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequestEventTarget/onerror) o [timeout event](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/timeout)) y el objeto XMLHttpRequest subyacente se vincula al callback. Por lo tanto, todas las [propiedades de XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest#Properties) están disponibles dentro del callback a través de **this**. Este campo es opcional. | | timeout | Number | Tiempo de espera en milisegundos antes de cancelar la solicitud. Por defecto 5000 milisegundos. | ### querySelectorAll ```javascript theme={null} var foundElements = Kameleoon.API.Utils.querySelectorAll(".kameleoonClassName"); foundElements.forEach(function (element) { element.style.display = "none"; }); ``` El método `querySelectorAll()` devuelve todos los elementos del documento que coincidan con los selectores CSS especificados como un objeto `NodeList` estático. Este método admite selectores con **:contains** y **:eq**. ##### Argumentos | Nombre | Tipo | Descripción | | -------- | ------ | ---------------------------------------------------- | | selector | String | Uno o más selectores CSS. Este campo es obligatorio. | ##### Valor de retorno | Nombre | Tipo | Descripción | | -------- | ----- | ------------------------------------------------- | | elements | Array | Lista de elementos que coinciden con la consulta. | ### setInterval ```javascript theme={null} var countdown = 10; var timer = document.createElement("div"); timer.innerHTML = countdown.toString(); document.body.appendChild(timer); var myInterval = Kameleoon.API.Utils.setInterval(function () { countdown--; timer.innerHTML = countdown.toString(); if (countdown == 0) { Kameleoon.API.Utils.clearInterval(myInterval); } }, 1000); ``` El método `setInterval()` ejecuta una función o expresión en el intervalo especificado en milisegundos. Kameleoon reinicia todos los intervalos creados a través de esta API durante las recargas del motor. Use este método en SPAs para garantizar una limpieza adecuada. ##### Argumentos | Nombre | Tipo | Descripción | | ------------ | -------- | ------------------------------------------------------------------------------ | | function | Function | Función JavaScript que se ejecutará periódicamente. Este campo es obligatorio. | | milliseconds | Number | Duración del intervalo en milisegundos. Por defecto 200 milisegundos. | ##### Valor de retorno | Nombre | Tipo | Descripción | | ---------- | ------ | ---------------------------------------------------- | | intervalId | Number | ID del temporizador para usar con `clearInterval()`. | ### setTimeout ```javascript theme={null} var myTimeout = Kameleoon.API.Utils.setTimeout(function () { Kameleoon.API.Events.Trigger("5 seconds elapsed"); }, 5000); ``` El método `setTimeout()` ejecuta una función o expresión tras el número de milisegundos especificado. Kameleoon reinicia todos los timeouts creados a través de esta API durante las recargas del motor. Use este método en SPAs para garantizar una limpieza adecuada. ##### Argumentos | Nombre | Tipo | Descripción | | ------------ | -------- | -------------------------------------------------------------------------------------------- | | function | Function | Función JavaScript que se ejecutará periódicamente. Este campo es obligatorio. | | milliseconds | Number | Tiempo de espera en milisegundos antes de ejecutar la función. Por defecto 200 milisegundos. | ##### Valor de retorno | Nombre | Tipo | Descripción | | --------- | ------ | --------------------------------------------------- | | timeoutId | Number | ID del temporizador para usar con `clearTimeout()`. | ## Kameleoon.API.Visitor Este módulo proporciona un acceso directo para obtener una referencia al [objeto Visitor](#visitor) actual. La Activation API contiene un único objeto Visitor. Este módulo también permite anular el código de visitante. ### setVisitorCode ```javascript theme={null} // Configuración del override del VisitorCode de Kameleoon // Inicializa la KameleoonQueue si no existe window.kameleoonQueue = window.kameleoonQueue || []; // Añade el comando para establecer el VisitorCode con su propio ID window.kameleoonQueue.push({ level: "IMMEDIATE", command: () => Kameleoon.API.Visitor.setVisitorCode("") }); ``` El método `setVisitorCode()` anula el VisitorCode de Kameleoon, que es un identificador único generado aleatoriamente para cada visitante. Asegúrese de que su ID sea único y no supere los 255 caracteres. Llame a este método lo antes posible, concretamente antes de que Kameleoon dispare cualquier experimento. Si actualiza el VisitorCode después de que el motor asigne una variación, el motor reasignará la variación. ## Kameleoon.API.CurrentVisit Este módulo proporciona un acceso directo para obtener una referencia al [objeto Visit](#visit) actual en curso. Hace referencia al mismo objeto que `Kameleoon.API.Visitor.visits[Kameleoon.API.Visitor.visits.length - 1]`. ## Configuration Un objeto Configuration contiene valores constantes globales relacionados con la configuración actual de Kameleoon en este sitio. ### Propiedades | Nombre | Tipo | Descripción | | ----------------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | siteCode | String | Código único del sitio que corresponde al archivo de la aplicación de Kameleoon instalado en el sitio web. Es una cadena de 10 caracteres aleatorios (letras minúsculas y números). | | singlePageSupport | Boolean | Establecido en **true** si Single Page Support está configurado. La configuración se realiza globalmente desde la app de Kameleoon o mediante `Kameleoon.API.Core.enableSinglePageSupport()`. Single Page Support garantiza que los cambios de URL disparen `Kameleoon.API.Core.load()` sin necesidad de recargar la página del navegador. | | goals | Array | Lista de [objetos Goal](#goal) que representan todos los objetivos activos (configurados) para este sitio. | | generationTime | Number | Hora de la última generación del archivo de la aplicación de Kameleoon (formato UTC, ms desde el 1 de enero de 1970). | ## Visitor Un objeto Visitor contiene datos a nivel de visitante independientes de visitas específicas. Este objeto incluye una lista de todos los [objetos Visit](#visit) del visitante. ### Propiedades | Nombre | Tipo | Descripción | | --------------------------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | code | String | El código de visitante generado aleatoriamente. A menos que se haya establecido un valor personalizado específicamente en el servidor (a través de un SDK server-side de Kameleoon), es una cadena de 16 caracteres aleatorios (letras minúsculas y números). | | numberOfVisits | Number | Total de visitas del visitante. Este valor puede ser superior a `visits.length`, ya que la Activation API retiene solo las 25 últimas visitas. | | firstVisitStartDate | Number | Fecha de inicio (UNIX en milisegundos) de la primera visita. Este valor puede no coincidir con `visits[0].startDate`, ya que la Activation API retiene solo las 25 últimas visitas. | | visits | Array | Lista de todos los [objetos Visit](#visit) realizados por este visitante en su sitio web, con un máximo de 25 visitas. Si este visitante hizo más de 25 visitas, solo las 25 últimas están disponibles a través de esta propiedad. | | currentVisit | Object | [Objeto Visit](#visit) correspondiente a la visita en curso actual. Es una referencia al mismo objeto que **Kameleoon.API.CurrentVisit**. | | previousVisit | Object | [Objeto Visit](#visit) correspondiente a la visita anterior. Si no hubo una visita anterior (es decir, la visita actual es la primera), esta propiedad es **null**. | | customData | Object | Mapa de todos los datos personalizados con ámbito **VISITOR**. Las claves del mapa son los nombres definidos de los datos personalizados. Este mapa solo incluye los datos personalizados que definió en la app de Kameleoon con ámbito **VISITOR**. Puede acceder a otros datos personalizados desde un objeto Visit. | | experimentLegalConsent | Boolean | Cuando es **true**, el motor obtuvo el consentimiento legal (o no es necesario) del visitante para activar los experimentos. Esta propiedad es **null** si el visitante no ha otorgado ni rechazado el consentimiento. | | personalizationLegalConsent | Boolean | Cuando es **true**, el motor obtuvo el consentimiento legal (o no es necesario) del visitante para activar las personalizaciones. Esta propiedad es **null** si el visitante no ha otorgado ni rechazado el consentimiento. | ## Visit Un objeto Visit representa una sola visita y contiene información en tiempo real que recopila Kameleoon. Los puntos de datos incluyen el contexto de la visita (dispositivo, ubicación), el comportamiento observado (duración, páginas vistas) y las operaciones de Kameleoon, como los experimentos o personalizaciones disparados. ### Propiedades | Nombre | Tipo | Descripción | | ---------------------------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | index | Number | Índice de la visita. La primera visita de un visitante dado tiene un índice de 0. Como la Activation API retiene solo las 25 últimas visitas, `Kameleoon.API.Visitor.visits[0].index` puede no ser igual a 0. | | startDate | Number | Fecha (formato UTC, ms desde el 1 de enero de 1970) del inicio de la visita. | | duration | Number | Duración de esta visita en ms. Si esta visita es la actual, este valor siempre está actualizado (se recalcula cada vez que se accede a él). | | pageViews | Number | Número de páginas vistas durante la visita. En SPAs, llamar a `Kameleoon.API.Core.load()` incrementa este número. Los cambios de URL disparan automáticamente esta llamada si Single Page Support está habilitado. | | locale | String | Idioma del navegador del visitante. | | device | Object | [Objeto Device](#device) correspondiente al dispositivo del visitante para esta visita. | | geolocation | Object | [Objeto Geolocation](#geolocation) correspondiente a la ubicación del visitante para esta visita. | | weather | Object | [Objeto Weather](#weather) correspondiente al clima del visitante para esta visita. | | activatedExperiments | Array | Lista de [objetos ExperimentActivation](#experimentactivation), correspondientes a todos los experimentos que se activaron en esta visita. | | activatedPersonalizations | Array | Lista de [objetos PersonalizationActivation](#personalizationactivation), correspondientes a todas las personalizaciones que se activaron en esta visita. | | conversions | Object | Mapa de las conversiones realizadas en esta visita. Las claves del mapa son los IDs de objetivo definidos. Los valores son objetos con dos claves: **count** (número de veces que este objetivo se convirtió en esta visita) y **revenue** (ingreso total de este objetivo en esta visita). | | customData | Object | Mapa de todos los datos personalizados con ámbito **PAGE** o **VISIT**. Las claves del mapa son los nombres definidos de los datos personalizados. Este mapa solo incluye los datos personalizados que definió en la app de Kameleoon con ámbito **PAGE** o **VISIT**. Puede acceder a otros datos personalizados desde el objeto Visitor. | | currentProduct | Object | [Objeto Product](#product) correspondiente al producto mostrado en la página de producto actual. Si el visitante no está en una página de producto, esta propiedad es **null**. | | products | Array | Lista de [objetos Product](#product), correspondientes a todas las páginas de producto vistas en esta visita (incluido **currentProduct** si procede). | | acquisitionChannel | String | Nombre del canal de adquisición de la visita. La lista de canales de adquisición, junto con sus características (principalmente cómo pueden deducirse, por ejemplo, mediante un parámetro de URL), se define en la app de Kameleoon. | | landingPageURL | String | URL de la primera página de la visita, normalmente llamada landing page. | | initialConversionPredictions | Object | Mapa de Kameleoon Conversion Scores (KCS). Las claves del mapa son los nombres definidos de los momentos clave. Los valores van de 0 a 100, representando el KCS del momento clave designado. (Nota: Kameleoon ha cambiado recientemente "key moment" por "triggers" en la app de Kameleoon). | La propiedad `kameleoonConversionScores` solo está disponible con el add-on AI Predictive Targeting. ## Device Un objeto Device contiene datos sobre el dispositivo de una visita determinada. ### Propiedades | Nombre | Tipo | Descripción | | -------------- | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | browser | String | Nombre del navegador. Los valores posibles son: **Chrome**, **Chromium**, **Firefox**, **Safari**, **Microsoft Edge**, **Internet Explorer**, **Opera**, **Android**, **iPhone**, **iPad**, **iPod**, **Samsung Internet for Android**, **Opera Coast**, **Yandex Browser**, **UC Browser**, **Maxthon**, **Epiphany**, **Puffin**, **Sleipnir**, **K-Meleon**, **Windows Phone**, **Vivaldi**, **Sailfish**, **SeaMonkey**, **Amazon Silk**, **PhantomJS**, **SlimerJS**, **BlackBerry**, **WebOS**, **Bada**, **Tizen**, **QupZilla**, **Googlebot**, **Blink**, **Gecko**, **Webkit**. | | browserVersion | String | Versión del navegador. | | os | String | Nombre del SO. Los valores posibles son: **Windows**, **Mac**, **Linux**, **Android**, **iOS**, **Chrome OS**, **Windows Phone**. | | type | String | Tipo de dispositivo. Los valores posibles son: **Desktop**, **Tablet**, **Phone**. | | screenHeight | Number | Altura de la pantalla del dispositivo (en píxeles). | | screenWidth | String | Anchura de la pantalla del dispositivo (en píxeles). | | windowHeight | Number | Altura de la ventana del navegador (en píxeles). | | windowWidth | String | Anchura de la ventana del navegador (en píxeles). | | adBlocker | Boolean | Booleano igual a **true** si este dispositivo tiene un ad blocker activo; en caso contrario, **false**. | | timeZone | String | Zona horaria del navegador. El valor es una cadena (por ejemplo, "Europe/Paris") que corresponde a la [base de datos TZ de zonas horarias.](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones) | ## Geolocation Un objeto Geolocation contiene datos sobre la ubicación física del visitante para una visita determinada. ### Propiedades | Nombre | Tipo | Descripción | | ---------- | ------ | ----------------------------------------------------- | | country | String | Nombre del país, en inglés. | | region | String | Nombre de la región, en el idioma preferido del país. | | city | String | Nombre de la ciudad, en el idioma preferido del país. | | postalCode | String | Código postal. | | latitude | Number | Latitud (en grados). | | longitude | Number | Longitud (en grados). | ## Weather Un objeto Weather contiene datos sobre las condiciones meteorológicas en el momento de la visita. ### Propiedades | Nombre | Tipo | Descripción | | -------------------- | ------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | temperature | String | Temperatura en grados Kelvin. | | humidity | String | Humedad en porcentaje (de 0 a 100). | | pressure | String | Presión atmosférica en hPa. | | windSpeed | String | Velocidad del viento en metros/seg. | | cloudiness | Number | Nubosidad en porcentaje (de 0 a 100). | | sunrise | Number | Hora del amanecer (formato UTC, ms desde el 1 de enero de 1970). | | sunset | Number | Hora del atardecer (formato UTC, ms desde el 1 de enero de 1970). | | conditionCode | Number | ID del código de la condición meteorológica. [Lista de referencia completa disponible aquí.](https://openweathermap.org/weather-conditions) | | conditionDescription | String | Descripción de la condición meteorológica correspondiente a `conditionCode`. Por ejemplo, un `conditionCode` de **800** tiene una `conditionDescription` de **clear sky**. | ## Experiment Un objeto Experiment representa un A/B test de Kameleoon. Las propiedades principales incluyen el segmento y las variaciones asociadas. Las variaciones contienen el código JavaScript y CSS que implementa los cambios. ### Propiedades | Nombre | Tipo | Descripción | | -------------------------------- | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | id | Number | ID del experimento. | | name | String | Nombre del experimento. | | dateLaunched | Number | Hora del primer lanzamiento del experimento (formato UTC, ms desde el 1 de enero de 1970). | | dateModified | Number | Hora de la última modificación del experimento (formato UTC, ms desde el 1 de enero de 1970). | | targetSegment | Object | [Objeto Segment](#segment) asociado al experimento. | | variations | Array | Lista de [objetos Variation](#variation) para este experimento. | | trafficDeviation | Object | Mapa de la desviación actual del tráfico del experimento. Las claves son los IDs de variación (el ID **0** es la referencia). Los valores son porcentajes (0-100). La suma puede no ser igual a 100 si una porción del tráfico no está asignada. | | untrackedTrafficReallocationTime | Number | Hora de la última reasignación realizada para tráfico no rastreado (formato UTC, ms desde el 1 de enero de 1970). Si nunca se ha realizado una reasignación, el valor será **null**. | | goals | Array | Lista de [objetos Goal](#goal) rastreados para el experimento. | | mainGoal | Object | [Objeto Goal](#goal) que representa el objetivo principal del experimento. | | triggered | Boolean | Booleano igual a **true** si el experimento se disparó en la página; en caso contrario, **false**. | | active | Boolean | Booleano igual a **true** si el experimento está actualmente activo en la página; en caso contrario, **false**. | | triggeredInVisit | Boolean | Booleano igual a **true** si el experimento se disparó en la visita actual; en caso contrario, **false**. Esto significa que la visita cumplió las condiciones del segmento del experimento en algún momento. | | activatedInVisit | Boolean | Cuando es **true**, el motor activó el experimento durante la visita actual. Que un experimento se dispare no garantiza su activación; factores como la exclusión de tráfico o el capping pueden impedir la activación. | | nonExpositionReason | String | Si el motor disparó pero no activó el experimento, este campo representa el motivo. Valores posibles: `EXPERIMENT_EXCLUSION` (el visitante pertenece a la población excluida del experimento, es decir, no cuenta para los resultados) y `VISITOR_CAPPING` (el visitante alcanzó un límite de capping que impide la activación). Esta propiedad está disponible si el motor disparó el experimento en la página actual y `active` es **false**. | | associatedVariation | Object | [Objeto Variation](#variation) asociado al experimento para el visitante dado. Si el experimento aún no está activado, normalmente esto será **null**, salvo que se haya realizado una preasignación. | | redirectProcessed | Boolean | Cuando es **true**, se produjo una redirección de URL para este experimento en la página anterior. Esta propiedad se establece mediante [processRedirect()](#processredirect) o configuración manual. En integraciones basadas en JavaScript, las redirecciones pueden cancelar la ejecución posterior del código; compruebe esta propiedad para reenviar las solicitudes de red en la landing page si es necesario. | ## Personalization Un objeto Personalization representa una acción de personalización de Kameleoon para un segmento específico. Las propiedades principales incluyen el segmento y la única variación asociada. El objeto Variation contiene el código JavaScript y CSS que implementa la acción de personalización. ### Propiedades | Nombre | Tipo | Descripción | | ------------------- | ------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | id | Number | ID de la personalización. | | name | String | Nombre de la personalización. | | dateLaunched | Number | Hora del primer lanzamiento de la personalización (formato UTC, ms desde el 1 de enero de 1970). | | dateModified | Number | Hora de la última modificación de la personalización (formato UTC, ms desde el 1 de enero de 1970). | | targetSegment | Object | [Objeto Segment](#segment) asociado a la personalización. | | goals | Array | Lista de [objetos Goal](#goal) rastreados para la personalización. | | mainGoal | Object | [Objeto Goal](#goal) que representa el objetivo principal de la personalización. | | triggered | Boolean | Cuando es **true**, la personalización se disparó en la página. | | active | Boolean | Cuando es **true**, la personalización está activa (mostrada) en la página. | | triggeredInVisit | Boolean | Cuando es **true**, la personalización se disparó durante la visita actual. Esto indica que la visita cumplió las condiciones del segmento de la personalización. | | activatedInVisit | Boolean | Cuando es **true**, el motor mostró la acción de la personalización durante la visita actual. Disparar una personalización no garantiza que el motor muestre la acción; por ejemplo, las opciones de capping o la pertenencia a un grupo de control pueden impedir la visualización. | | nonExpositionReason | String | Razón de la no exposición si la personalización se disparó pero no se mostró. Valores posibles: `GLOBAL_EXCLUSION`, `PERSONALIZATION_EXCLUSION`, `PRIORITY`, `SCHEDULE`, `PERSONALIZATION_CAPPING`, `VISITOR_CAPPING`, `SCENARIO` y `SIMULATION`. Esta propiedad está disponible si la personalización se disparó en la página actual y `active` es **false**. | | associatedVariation | Object | [Objeto Variation](#variation) asociado. Esta propiedad siempre hace referencia a un objeto válido para las personalizaciones. | ## ExperimentActivation Un objeto `ExperimentActivation` representa un experimento activado durante una visita específica. Como las visitas pueden ser históricas, el experimento asociado puede haberse detenido. En tal caso, el motor no inyecta los metadatos del experimento (nombre, fecha de lanzamiento, segmento) en el archivo de la aplicación, lo que los hace inaccesibles a través de la API. Sin embargo, los IDs siguen disponibles. ### Propiedades | Nombre | Tipo | Descripción | | --------------------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------ | | experimentID | Number | ID del experimento. | | associatedVariationID | Number | ID de la variación asociada. Si la variación asociada es la referencia (control), el ID es igual a 0. | | associatedVariation | Object | [Objeto Variation](#variation) asociado. Esta propiedad es **null** si el experimento o la variación ya no están activos (detenidos o pausados). | | times | Array | Lista de tiempos de activación de este experimento en esta visita (formato UTC, ms desde el 1 de enero de 1970). | ## PersonalizationActivation Un objeto `PersonalizationActivation` representa una personalización activada durante una visita específica. Al igual que con los experimentos, los metadatos no están disponibles si la personalización se ha detenido, aunque los IDs siguen siendo accesibles. ### Propiedades | Nombre | Tipo | Descripción | | --------------------- | ------ | ---------------------------------------------------------------------------------------------------------------------------------------------------- | | personalizationID | Number | ID de la personalización. | | associatedVariationID | Number | ID de la variación asociada. | | personalization | Object | [Objeto Personalization](#personalization) asociado. Esta propiedad es **null** si la personalización ya no está activa (detenida o pausada). | | associatedVariation | Object | [Objeto Variation](#variation) asociado. Esta propiedad es **null** si la personalización o la variación ya no están activas (detenidas o pausadas). | | times | Array | Lista de tiempos de activación de esta personalización en esta visita (formato UTC, ms desde el 1 de enero de 1970). | ## Variation Un objeto `Variation` representa un componente de un `Experiment`. Un A/B test contiene varias variaciones, como un A/B test con una variación más la referencia o un A/B/C test con dos más la referencia. Las personalizaciones se asocian con un único [objeto Variation](#variation). Durante la ejecución del código de la variación, la palabra clave `this` hace referencia al objeto `Variation` correspondiente. Use esta referencia para navegar por la jerarquía de objetos (por ejemplo, a través de la propiedad `associatedCampaign`). ### Propiedades | Nombre | Tipo | Descripción | | -------------------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | id | Number | Id único de la variación. Si la variación representa la referencia (control), el ID es igual a **0**. | | name | String | Nombre de la variación. Si la variación representa la referencia (control), el nombre es igual a "Reference". | | associatedCampaign | Object | El objeto [Experiment](#experiment) o [Personalization](#personalization) vinculado a esta variación. | | instantiatedTemplate | Object | [Objeto Template instanciado](#template) a partir del cual se construyó esta variación, si procede. Si la variación no se construyó a partir de una plantilla, esta propiedad es **null**. | | reallocationTime | Number | Hora de la última reasignación de tráfico realizada para la variación (formato UTC, ms desde el 1 de enero de 1970). Si nunca se ha realizado una reasignación, el valor será **null**. | ## Template Un objeto `Template` representa una plantilla de Widget instanciada. Use plantillas para generar variaciones desde una base de código común mediante la interfaz de la app de Kameleoon. Un objeto `Template` contiene campos predefinidos y sus valores para la variación asociada. ### Propiedades | Nombre | Tipo | Descripción | | ------------ | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | name | String | Nombre de la plantilla base. | | customFields | Object | Mapa correspondiente a los datos de la plantilla. Las claves son los nombres de los campos definidos en la plantilla base. Los valores son los valores instanciados que introdujo para la variación asociada. Por ejemplo, si creó una plantilla con un único campo de texto "currentDiscount", `customFields` podría ser igual a `{"currentDiscount": "-10% on all orders today!"}`. | ## Goal Un objeto `Goal` representa un Key Performance Indicator (KPI) definido en la app de Kameleoon. ### Propiedades | Nombre | Tipo | Descripción | | ------ | ------ | --------------------------------------------------------------------------------------------------------- | | id | Number | ID del objetivo. | | name | String | Nombre del objetivo. | | type | String | Tipo del objetivo. Los valores posibles son: **CLICK**, **SCROLL**, **URL**, **ENGAGEMENT** y **CUSTOM**. | ## Segment Un objeto `Segment` contiene criterios que una visita debe cumplir para pertenecer al segmento. En la plataforma Kameleoon, los segmentos incluyen condiciones constantes, como la edad o la ubicación, y condiciones de disparo, como el tiempo en página o el contenido del carrito. ### Propiedades | Nombre | Tipo | Descripción | | ------ | ------ | -------------------- | | id | Number | ID del segmento. | | name | String | Nombre del segmento. | ## Trigger Un objeto Trigger contiene criterios que una visita debe cumplir para disparar el trigger. En la plataforma Kameleoon, los triggers incluyen condiciones constantes, como la edad o la ubicación, y condiciones de disparo, como el tiempo en página o el contenido del carrito. ### Propiedades | Nombre | Tipo | Descripción | | ------ | ------ | ------------------- | | id | Number | ID del trigger. | | name | String | Nombre del trigger. | ## Product Un objeto `Product` describe los artículos de un catálogo. La mayoría de las propiedades son opcionales y pueden ser **null**. ### Propiedades | Nombre | Tipo | Obligatorio | Descripción | | ----------------- | ------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | id | String | True | ID único del producto. | | name | String | False | Nombre del producto. | | sku | String | False | Stock Keeping Unit (SKU) del producto. | | categories | Array | False | Lista de [objetos Category](#category) | | imageURL | String | False | URL de la imagen principal de este producto. | | price | Number | False | Precio actual del producto. | | oldPrice | Number | False | Precio original del producto, normalmente antes de descuentos o promociones. | | brand | String | False | Nombre de la marca del producto. | | description | String | False | Descripción textual del producto. | | available | Boolean | False | Indica si el producto está en stock. | | availableQuantity | Number | False | Stock actual del producto. | | rating | Number | False | Valoración (normalmente de 0 a 5, aunque puede ser cualquier número) atribuida al producto. | | tags | Array | False | Lista de etiquetas (como Strings) para este producto. | | typePrefix | String | False | Tipo de producto, como "mobile phone" o "washing machine". Lo usan los algoritmos de búsqueda. | | merchantID | String | False | ID del vendedor/comerciante de este producto si su sitio web opera como un marketplace. | | groupId | String | False | Use este campo para combinar variantes de producto en un único grupo. | | model | String | False | Modelo del producto. | | leftovers | String | False | Inventario para un producto en particular. Use uno de los siguientes valores: `one` (una copia disponible), `few` (cantidades limitadas, hasta 10 unidades) o `lot` (10 o más unidades disponibles). | | priceMargin | Number | False | Factor de ponderación del margen de precio del producto, entre 0 y 100. | | isFashion | Boolean | False | Establezca en `true` para productos de ropa. | | isChild | Boolean | False | Use este campo si es un producto infantil. | | isNew | Boolean | False | Use este campo si es un producto nuevo. | | accessories | Array | False | Array de IDs de producto que pueden ser complementarios o equivalentes al producto actual. | | seasonality | Array | False | Array de enteros (meses: 1-12). | | params | Array | False | Lista de [objetos Param](#param) | | fashion | Object | False | [Objeto Fashion](#fashion) | | auto | Object | False | [Objeto Auto](#auto) | ## Category ### Propiedades | Nombre | Tipo | Obligatorio | Descripción | | ------ | ------ | ----------- | ------------------------------- | | id | String | True | ID único de la categoría. | | name | String | False | Nombre de la categoría. | | parent | String | False | ID único de la categoría padre. | | url | String | False | URL de la categoría. | ## Param Un campo genérico opcional que permite cargar información personalizada sobre un producto que no encaja en otros campos. Por ejemplo, esta información podría ser el estado de membresía necesario para comprar un producto o las fechas de salida y vuelta de un circuito turístico. ### Propiedades | Nombre | Tipo | Obligatorio | Descripción | | ------ | ------ | ----------- | --------------------------------------------------------------------------------------------------------- | | name | String | True | Nombre del param. | | value | Array | True | Lista de valores (como Strings). | | unit | String | False | Use abreviaturas de dos caracteres para unidades del SI, como cm (centímetros), wt (watts) o gr (gramos). | ## Fashion Un campo genérico opcional que permite cargar información personalizada sobre el producto. ### Propiedades | Nombre | Tipo | Descripción | | ------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------------ | | gender | String | Debe ser "f" (femenino) o "m" (masculino). | | type | String | Tipo de producto. Valores posibles: `shoe`, `shirt`, `tshirt`, `underwear`, `trouser`, `jacket`, `blazer`, `sock`, `belt`, `hat`, `glove`. | | feature | String | Use este campo para indicar si el producto es para adultos o solo para niños. Debe tomar el valor "child" o "adult". | | colors | Array | Lista de [objetos Color](#color). | ## Color ### Propiedades | Nombre | Tipo | Descripción | | ------- | ------ | --------------------- | | color | String | Colores del producto. | | picture | String | URL de la imagen. | ## Auto Un campo genérico opcional que permite cargar información personalizada sobre el producto. ### Propiedades | Nombre | Tipo | Descripción | | ------------- | ----- | --------------------------------------------------------------------------------------------- | | vds | Array | Array que contiene los Vehicle Identification Numbers (VIN) que sirven como huella del coche. | | compatibility | Array | Contiene una lista de [objetos Compatible](#compatible) | ## Compatible ### Propiedades | Nombre | Tipo | Obligatorio | Descripción | | ------ | ------ | ----------- | ----------------------------- | | brand | String | True | Nombre de la marca del coche. | | model | String | False | Nombre del modelo del coche. |