@kameleoon/javascript-sdk-core 5.17.3 → 5.18.0

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Change Log
 
+## 5.18.0 (2026-02-13)
+
+### Features
+
+- Updated the allowed range for the [`trackingInterval`][configurationParameters]. The new range is from **`1000` ms** (default) to **`5000` ms**, allowing a reduction in the number of tracking requests.
+- Introduced a new `track` parameter for [`addData`][addData]. When set to `false`, the data is stored locally and used only for targeting evaluation; it is not sent to the Data API, helping to prevent duplicate data from being recorded. The default value is `true`. This behavior is consistent with the `track` parameter used in evaluation methods such as [`getVariation`][getVariation].
+
+[configurationParameters](https://developers.kameleoon.com/feature-management-and-experimentation/web-sdks/nodejs-sdk/#configuration-parameters)
+
 ## 5.17.3 (2026-02-09)
 
 ### Patch Changes

package/dist/browser.d.ts

@@ -13,7 +13,7 @@ export { SdkLanguageType } from './constants';
 export { JSONType, ConfigurationDataType } from './clientConfiguration';
 export { TrackingStatus, VariableType, InternalsType, FeatureFlagType, FlushParamsType, JSONVariableType, SDKCoreParameters, NumberVariableType, StringVariableType, BooleanVariableType, SDKConfigurationType, KameleoonVariableType, KameleoonVariationType, FeatureFlagVariableType, TrackConversionParamsType, FeatureVariableResultType, RemoteVisitorDataParamsType, InternalSDKConfigurationType, IsFeatureFlagActiveParamsType, SetDataCallbackParametersType, GetFeatureFlagVariableParamsType, GetVisitorWarehouseAudienceParamsType, SimulateRequestDataType, GetVariationParamsType, GetVariationsParamsType, VariationType, Milliseconds, SetForcedVariationParametersType, } from './types';
 export { Environment, ExternalPackageInfoType } from './sdkInfoTypes';
-export { ApplicationVersion, CustomData, Conversion, Device, Cookie, Browser, UserAgent, DeviceType, CookieType, GeolocationData, GeolocationInfoType, OperatingSystemType, OperatingSystem, BrowserType, PageView, StaticData, KameleoonData, UniqueIdentifier, KameleoonDataType, PageViewParametersType, ConversionParametersType, ApplicationVersionDataType, IDataManager, DataManager, DataProcessor, } from './kameleoonData';
+export { ApplicationVersion, CustomData, Conversion, Device, Cookie, Browser, UserAgent, DeviceType, CookieType, GeolocationData, GeolocationInfoType, OperatingSystemType, OperatingSystem, BrowserType, PageView, StaticData, KameleoonData, UniqueIdentifier, KameleoonDataType, PageViewParametersType, ConversionParametersType, ApplicationVersionDataType, IDataManager, DataManager, DataProcessor, AddDataParamsType, } from './kameleoonData';
 export { IExternalEventSource, EventSourceOpenParametersType, } from './eventSource';
 export { Header, HeadersType, HttpMethod, IExternalRequester, RequestParametersType, RequestType, RetryCountType, KameleoonResponseType, SendRequestParametersType, NUMBER_OF_RETRIES, } from './requester';
 export { ITracker } from './tracking';

package/dist/cacheManager/cacheManager.d.ts

@@ -18,9 +18,9 @@ interface ICacheManager<T> {
  * CacheManager - a class for managing cache
  */
 export declare class CacheManager<T> implements ICacheManager<T> {
-    private cacheMap;
+    private readonly cacheMap;
     private intervalId;
-    private cleanupTimeout;
+    private readonly cleanupTimeout;
     /**
      * @param {number} cleanupTimeout - timeout for cleaning cache in seconds
      * generic type `T` is a type of data that will be stored in cache

package/dist/clientConfiguration/clientConfiguration.d.ts

@@ -22,20 +22,20 @@ export declare class ClientConfiguration implements IClientConfiguration {
     private segmentsData;
     private holdoutData;
     private meGroupsData;
-    private updateInterval;
+    private readonly updateInterval;
     private lastUpdate;
-    private storage;
-    private requester;
-    private eventSource;
+    private readonly storage;
+    private readonly requester;
+    private readonly eventSource;
     private mappedRules;
     private mappedExperiments;
-    private dataManager;
-    private visitorCodeManager;
-    private eventManager;
-    private urlProvider;
+    private readonly dataManager;
+    private readonly visitorCodeManager;
+    private readonly eventManager;
+    private readonly urlProvider;
     private lastModified?;
     private requestTime?;
-    private externalPackageInfo;
+    private readonly externalPackageInfo;
     private usedDefaultDataFile;
     private defaultDataFile?;
     private blockingBehaviourMode;

package/dist/clientSettings/clientSettings.d.ts

@@ -4,14 +4,17 @@ export interface IClientSettings {
     readonly settings: ClientSettingsType;
 }
 export declare class ClientSettings implements IClientSettings {
-    private updateInterval;
-    private environment;
-    private networkDomain;
-    private requestTimeout;
-    private siteCode;
-    private cleanupInterval;
-    private trackRetryDelay;
-    private trackingInterval;
+    static readonly DEFAULT_TRACKING_INTERVAL_MS = 1000;
+    static readonly MIN_TRACKING_INTERVAL_MS = 1000;
+    static readonly MAX_TRACKING_INTERVAL_MS = 5000;
+    private readonly updateInterval;
+    private readonly environment;
+    private readonly networkDomain;
+    private readonly requestTimeout;
+    private readonly siteCode;
+    private readonly cleanupInterval;
+    private readonly trackRetryDelay;
+    private readonly trackingInterval;
     constructor(siteCode: string, configuration?: Partial<SDKConfigurationType>);
     private getTrackingInterval;
     private getEnvironment;

package/dist/index.d.ts

@@ -13,7 +13,7 @@ export { SdkLanguageType } from './constants';
 export { JSONType, ConfigurationDataType } from './clientConfiguration';
 export { TrackingStatus, VariableType, InternalsType, FeatureFlagType, FlushParamsType, JSONVariableType, SDKCoreParameters, NumberVariableType, StringVariableType, BooleanVariableType, SDKConfigurationType, KameleoonVariableType, KameleoonVariationType, FeatureFlagVariableType, TrackConversionParamsType, FeatureVariableResultType, RemoteVisitorDataParamsType, InternalSDKConfigurationType, IsFeatureFlagActiveParamsType, SetDataCallbackParametersType, GetFeatureFlagVariableParamsType, GetVisitorWarehouseAudienceParamsType, SimulateRequestDataType, GetVariationParamsType, GetVariationsParamsType, VariationType, Milliseconds, SetForcedVariationParametersType, } from './types';
 export { Environment, ExternalPackageInfoType } from './sdkInfoTypes';
-export { ApplicationVersion, CustomData, Conversion, Device, Cookie, Browser, UserAgent, DeviceType, CookieType, GeolocationData, GeolocationInfoType, OperatingSystemType, OperatingSystem, BrowserType, PageView, StaticData, KameleoonData, UniqueIdentifier, KameleoonDataType, PageViewParametersType, ConversionParametersType, ApplicationVersionDataType, IDataManager, DataManager, DataProcessor, } from './kameleoonData';
+export { ApplicationVersion, CustomData, Conversion, Device, Cookie, Browser, UserAgent, DeviceType, CookieType, GeolocationData, GeolocationInfoType, OperatingSystemType, OperatingSystem, BrowserType, PageView, StaticData, KameleoonData, UniqueIdentifier, KameleoonDataType, PageViewParametersType, ConversionParametersType, ApplicationVersionDataType, IDataManager, DataManager, DataProcessor, AddDataParamsType, } from './kameleoonData';
 export { IExternalEventSource, EventSourceOpenParametersType, } from './eventSource';
 export { Header, HeadersType, HttpMethod, IExternalRequester, RequestParametersType, RequestType, RetryCountType, KameleoonResponseType, SendRequestParametersType, NUMBER_OF_RETRIES, } from './requester';
 export { ITracker } from './tracking';

package/dist/javascript-sdk-core.browser.cjs.js

@@ -3395,6 +3395,7 @@ class Parser {
     }
 }
 
+var _a;
 class ClientSettings {
     constructor(siteCode, configuration) {
         KameleoonLogger.debug `CALL: new ClientSettings(siteCode: ${siteCode}, configuration: ${configuration})`;
@@ -3409,18 +3410,19 @@ class ClientSettings {
         KameleoonLogger.debug `RETURN: new ClientSettings(siteCode: ${siteCode}, configuration: ${configuration})`;
     }
     getTrackingInterval(configuration) {
+        const { MIN_TRACKING_INTERVAL_MS, MAX_TRACKING_INTERVAL_MS, DEFAULT_TRACKING_INTERVAL_MS, } = ClientSettings;
         if (typeof (configuration === null || configuration === void 0 ? void 0 : configuration.trackingInterval) === 'number') {
-            if (configuration.trackingInterval < 100) {
-                KameleoonLogger.warning('Tracking interval must not be shorter than 100 ms. Minimum possible interval was applied.');
-                return 100;
+            if (configuration.trackingInterval < MIN_TRACKING_INTERVAL_MS) {
+                KameleoonLogger.warning(`Tracking interval must not be shorter than ${MIN_TRACKING_INTERVAL_MS} ms. Minimum possible interval was applied.`);
+                return MIN_TRACKING_INTERVAL_MS;
             }
-            if (configuration.trackingInterval > 1000) {
-                KameleoonLogger.warning('Tracking interval must not be longer than 1000 ms. Maximum possible interval was applied.');
-                return 1000;
+            if (configuration.trackingInterval > MAX_TRACKING_INTERVAL_MS) {
+                KameleoonLogger.warning(`Tracking interval must not be longer than ${MAX_TRACKING_INTERVAL_MS} ms. Maximum possible interval was applied.`);
+                return MAX_TRACKING_INTERVAL_MS;
             }
             return configuration.trackingInterval;
         }
-        return 1000;
+        return DEFAULT_TRACKING_INTERVAL_MS;
     }
     getEnvironment(configuration) {
         if (configuration === null || configuration === void 0 ? void 0 : configuration.environment) {
@@ -3474,6 +3476,10 @@ class ClientSettings {
         };
     }
 }
+_a = ClientSettings;
+ClientSettings.DEFAULT_TRACKING_INTERVAL_MS = 1000;
+ClientSettings.MIN_TRACKING_INTERVAL_MS = _a.DEFAULT_TRACKING_INTERVAL_MS;
+ClientSettings.MAX_TRACKING_INTERVAL_MS = 5000;
 
 /**
  * @class
@@ -5468,7 +5474,6 @@ class StorageCleanupManager {
                         break;
                     default:
                         // check if all cases are handled
-                        const exhaustiveCheck = storageKey;
                         KameleoonLogger.error `Unknown storage key: ${storageKey} for initCleanupInterval.`;
                 }
             }
@@ -5763,7 +5768,7 @@ class DataManager {
         return resultData;
     }
     storeTrackedData(data) {
-        this.storeData(data, false);
+        this.storeDataForVisitors(data, false);
         const infoResult = this.infoStorage.read();
         if (!infoResult.ok) {
             return;
@@ -5797,30 +5802,31 @@ class DataManager {
         }
         this.infoStorage.write(infoResult.data);
     }
-    storeData(firstParameter, ...secondParameter) {
-        KameleoonLogger.debug `CALL: DataManager.storeData(visitorCode: ${firstParameter}, data: ${secondParameter})`;
-        const result = this.dataStorage.read();
-        const infoResult = this.infoStorage.read();
-        if (!result.ok) {
-            return result;
-        }
-        if (!infoResult.ok) {
-            return infoResult;
-        }
-        const targetingData = result.data;
-        const infoData = infoResult.data;
-        if (typeof firstParameter === 'string') {
+    /**
+     * Store data for a single visitor
+     */
+    storeData({ visitorCode, data, track, }) {
+        KameleoonLogger.debug `CALL: DataManager.storeDataForVisitor(vc: ${visitorCode}, track: ${track}, data: ${data})`;
+        const result = this.storeDataInternal((infoData, targetingData) => {
             this.mutUpdateTargetingData({
                 infoData,
                 targetingData,
-                visitorCode: firstParameter,
-                kameleoonData: secondParameter,
+                visitorCode,
+                kameleoonData: data,
                 extendTtl: true,
+                track,
             });
-        }
-        else {
-            for (const [visitorCode, kameleoonData] of Object.entries(firstParameter)) {
-                const extendTtl = typeof secondParameter[0] === 'boolean' ? secondParameter[0] : true;
+        });
+        KameleoonLogger.debug `RETURN: DataManager.storeDataForVisitor(vc: ${visitorCode}, track: ${track}, data: ${data}) -> ${result}`;
+        return result;
+    }
+    /**
+     * Store data for multiple visitors
+     */
+    storeDataForVisitors(data, extendTtl) {
+        KameleoonLogger.debug `CALL: DataManager.storeDataForVisitors(data: ${data}, extendTtl: ${extendTtl})`;
+        const result = this.storeDataInternal((infoData, targetingData) => {
+            for (const [visitorCode, kameleoonData] of Object.entries(data)) {
                 this.mutUpdateTargetingData({
                     infoData,
                     targetingData,
@@ -5829,12 +5835,26 @@ class DataManager {
                     extendTtl,
                 });
             }
+        });
+        KameleoonLogger.debug `RETURN: DataManager.storeDataForVisitors(data: ${data}, extendTtl: ${extendTtl}) -> ${result}`;
+        return result;
+    }
+    // ========= Internal shared logic =========
+    storeDataInternal(updater) {
+        const dataResult = this.dataStorage.read();
+        if (!dataResult.ok) {
+            return dataResult;
         }
+        const infoResult = this.infoStorage.read();
+        if (!infoResult.ok) {
+            return infoResult;
+        }
+        const targetingData = dataResult.data;
+        const infoData = infoResult.data;
+        updater(infoData, targetingData);
         this.cleanupData();
-        this.infoStorage.write(infoResult.data);
-        const writeResult = this.dataStorage.write(targetingData);
-        KameleoonLogger.debug `RETURN: DataManager.storeData(visitorCode: ${firstParameter}, data: ${secondParameter}) -> (writeResult: ${writeResult})`;
-        return writeResult;
+        this.infoStorage.write(infoData);
+        return this.dataStorage.write(targetingData);
     }
     getTree(segment) {
         if (this.targetingTrees.has(segment.id)) {
@@ -5923,29 +5943,31 @@ class DataManager {
         return new Set(Object.keys(targetingData));
     }
     getLinkedVisitor(visitorCode) {
+        var _a, _b, _c;
         const storageData = this.dataStorage.read();
         if (!storageData.ok) {
             return null;
         }
-        if (typeof storageData.data[visitorCode] === 'string') {
-            return storageData.data[visitorCode];
+        const visitorDataOrRef = storageData.data[visitorCode];
+        // Direct reference case
+        if (typeof visitorDataOrRef === 'string') {
+            return visitorDataOrRef;
         }
-        if (this.mappingIdentifierCustomDataIndex === null) {
+        // No mapping index or no visitor data
+        if (visitorDataOrRef == null ||
+            this.mappingIdentifierCustomDataIndex == null) {
             return null;
         }
-        const visitorData = storageData.data[visitorCode];
-        if (!visitorData) {
-            return null;
-        }
-        const customData = visitorData[exports.KameleoonData.CustomData];
-        if (customData && customData[this.mappingIdentifierCustomDataIndex]) {
-            return customData[this.mappingIdentifierCustomDataIndex].value[0];
-        }
-        return null;
+        const value = (_c = (_b = (_a = visitorDataOrRef[exports.KameleoonData.CustomData]) === null || _a === void 0 ? void 0 : _a[this.mappingIdentifierCustomDataIndex]) === null || _b === void 0 ? void 0 : _b.value) === null || _c === void 0 ? void 0 : _c[0];
+        return value !== null && value !== void 0 ? value : null;
     }
-    mutUpdateTargetingData({ infoData, visitorCode, kameleoonData, targetingData, extendTtl, }) {
+    mutUpdateTargetingData({ infoData, visitorCode, kameleoonData, targetingData, extendTtl, track, }) {
         var _a, _b, _c;
         for (const dataItem of kameleoonData) {
+            // prcoess track status
+            if (track === false) {
+                dataItem.status = exports.TrackingStatus.Sent;
+            }
             // process custom data
             if (dataItem.data.type === exports.KameleoonData.CustomData) {
                 const customDataIsValid = this.processCustomData({
@@ -6103,6 +6125,135 @@ class DataManager {
     }
 }
 
+const VISITOR_CODE_LENGTH = 16;
+const VISITOR_CODE_MAX_LENGTH = 255;
+const DEFAULT_MAX_AGE = 60 * 60 * 24 * 365;
+const PATH = '/';
+
+/**
+ * VisitorCodeManager - a class which manages visitor codes using cookies, offering functions to generate, retrieve,
+ * and handle these codes while considering user consent.
+ **/
+class VisitorCodeManager {
+    constructor() {
+        this.isConsentRequired = false;
+    }
+    set consentRequired(isRequired) {
+        this.isConsentRequired = isRequired;
+    }
+    get consentRequired() {
+        return this.isConsentRequired;
+    }
+    set getData(callback) {
+        this.getDataCallback = callback;
+    }
+    set setData(callback) {
+        this.setDataCallback = callback;
+    }
+    get setData() {
+        if (this.setDataCallback) {
+            return this.setDataCallback;
+        }
+        throw new Error('Missing setDataCallback!');
+    }
+    validateVisitorCode(visitorCode) {
+        if (visitorCode.length === 0) {
+            return buildExports.Err(new KameleoonError(exports.KameleoonException.VisitorCodeEmpty));
+        }
+        if (visitorCode.length > VISITOR_CODE_MAX_LENGTH) {
+            return buildExports.Err(new KameleoonError(exports.KameleoonException.VisitorCodeMaxLength));
+        }
+        return buildExports.Ok();
+    }
+    getVisitorCode(defaultVisitorCode) {
+        KameleoonLogger.debug `CALL: VisitorCodeManager.getVisitorCode(defaultVisitorCode: ${defaultVisitorCode})`;
+        if (!this.getDataCallback || !this.setDataCallback) {
+            throw new Error('Missing getDataCallback or setDataCallback methods in getVisitorCode!');
+        }
+        let visitorCode;
+        const existingVisitorCode = this.getDataCallback(exports.KameleoonStorageKey.VisitorCode);
+        if (existingVisitorCode) {
+            visitorCode = existingVisitorCode;
+        }
+        if (!visitorCode) {
+            if (defaultVisitorCode) {
+                this.validateVisitorCode(defaultVisitorCode).throw();
+                visitorCode = defaultVisitorCode;
+                KameleoonLogger.debug `Used default visitor code: ${visitorCode}`;
+            }
+            else {
+                visitorCode = this.generateVisitorCode();
+                KameleoonLogger.debug `Generated new visitor code: ${visitorCode}`;
+            }
+        }
+        this.processSimulatedVariations(visitorCode);
+        if (!this.isConsentRequired) {
+            this.setDataCallback({
+                visitorCode,
+                key: exports.KameleoonStorageKey.VisitorCode,
+                maxAge: DEFAULT_MAX_AGE,
+                path: PATH,
+            });
+        }
+        KameleoonLogger.debug `RETURN: VisitorCodeManager.getVisitorCode(defaultVisitorCode: ${defaultVisitorCode}) -> (visitorCode: ${visitorCode})`;
+        return visitorCode;
+    }
+    processSimulatedVariations(visitorCode) {
+        if (this.variationConfiguration) {
+            const simulatedVariationsData = this.getSimulatedVariations(visitorCode);
+            try {
+                this.variationConfiguration.clearSimulatedVariations(visitorCode).throw();
+                if (simulatedVariationsData !== null && simulatedVariationsData.length > 0) {
+                    this.variationConfiguration.updateForcedFeatureVariations(visitorCode, simulatedVariationsData).throw();
+                }
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    KameleoonLogger.error `Failed to process simulated variations: ${error.message}`;
+                }
+            }
+        }
+    }
+    getSimulatedVariations(visitorCode) {
+        KameleoonLogger.debug `CALL: VisitorCodeManager.getSimulatedVariations(visitorCode: ${visitorCode})`;
+        const simulatedVariationsData = this.getDataCallback(exports.KameleoonStorageKey.KameleoonSimulationFFData);
+        let variations = null;
+        if (typeof simulatedVariationsData === 'string' &&
+            simulatedVariationsData.length > 0) {
+            try {
+                const parsed = JSON.parse(decodeURIComponent(simulatedVariationsData));
+                if (parsed && typeof parsed === 'object') {
+                    variations = Object.entries(parsed)
+                        .map(([key, value]) => {
+                        return this.variationConfiguration.simulatedVariationFromJson(key, value);
+                    })
+                        .filter((variation) => variation !== null);
+                }
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    KameleoonLogger.error `Failed to parse simulated variations: ${error.message}`;
+                }
+            }
+        }
+        KameleoonLogger.debug `RETURN: VisitorCodeManager.getSimulatedVariations(visitorCode: ${visitorCode}) -> (variations: ${variations})`;
+        return variations;
+    }
+    generateVisitorCode() {
+        const characters = 'abcdefghijklmnopqrstuvwxyz0123456789';
+        const randomCharacterArray = [];
+        for (let i = 0; i < VISITOR_CODE_LENGTH; i++) {
+            randomCharacterArray.push(characters[Math.floor(Math.random() * characters.length)]);
+        }
+        return randomCharacterArray.join('');
+    }
+    setVariationConfiguration(variationConfiguration) {
+        if (!this.variationConfiguration) {
+            this.variationConfiguration = variationConfiguration;
+        }
+    }
+}
+
 var sha256$2 = {exports: {}};
 
 function commonjsRequire(path) {
@@ -7637,135 +7788,6 @@ class KameleoonEventSource {
     }
 }
 
-const VISITOR_CODE_LENGTH = 16;
-const VISITOR_CODE_MAX_LENGTH = 255;
-const DEFAULT_MAX_AGE = 60 * 60 * 24 * 365;
-const PATH = '/';
-
-/**
- * VisitorCodeManager - a class which manages visitor codes using cookies, offering functions to generate, retrieve,
- * and handle these codes while considering user consent.
- **/
-class VisitorCodeManager {
-    constructor() {
-        this.isConsentRequired = false;
-    }
-    set consentRequired(isRequired) {
-        this.isConsentRequired = isRequired;
-    }
-    get consentRequired() {
-        return this.isConsentRequired;
-    }
-    set getData(callback) {
-        this.getDataCallback = callback;
-    }
-    set setData(callback) {
-        this.setDataCallback = callback;
-    }
-    get setData() {
-        if (this.setDataCallback) {
-            return this.setDataCallback;
-        }
-        throw new Error('Missing setDataCallback!');
-    }
-    validateVisitorCode(visitorCode) {
-        if (visitorCode.length === 0) {
-            return buildExports.Err(new KameleoonError(exports.KameleoonException.VisitorCodeEmpty));
-        }
-        if (visitorCode.length > VISITOR_CODE_MAX_LENGTH) {
-            return buildExports.Err(new KameleoonError(exports.KameleoonException.VisitorCodeMaxLength));
-        }
-        return buildExports.Ok();
-    }
-    getVisitorCode(defaultVisitorCode) {
-        KameleoonLogger.debug `CALL: VisitorCodeManager.getVisitorCode(defaultVisitorCode: ${defaultVisitorCode})`;
-        if (!this.getDataCallback || !this.setDataCallback) {
-            throw new Error('Missing getDataCallback or setDataCallback methods in getVisitorCode!');
-        }
-        let visitorCode;
-        const existingVisitorCode = this.getDataCallback(exports.KameleoonStorageKey.VisitorCode);
-        if (existingVisitorCode) {
-            visitorCode = existingVisitorCode;
-        }
-        if (!visitorCode) {
-            if (defaultVisitorCode) {
-                this.validateVisitorCode(defaultVisitorCode).throw();
-                visitorCode = defaultVisitorCode;
-                KameleoonLogger.debug `Used default visitor code: ${visitorCode}`;
-            }
-            else {
-                visitorCode = this.generateVisitorCode();
-                KameleoonLogger.debug `Generated new visitor code: ${visitorCode}`;
-            }
-        }
-        this.processSimulatedVariations(visitorCode);
-        if (!this.isConsentRequired) {
-            this.setDataCallback({
-                visitorCode,
-                key: exports.KameleoonStorageKey.VisitorCode,
-                maxAge: DEFAULT_MAX_AGE,
-                path: PATH,
-            });
-        }
-        KameleoonLogger.debug `RETURN: VisitorCodeManager.getVisitorCode(defaultVisitorCode: ${defaultVisitorCode}) -> (visitorCode: ${visitorCode})`;
-        return visitorCode;
-    }
-    processSimulatedVariations(visitorCode) {
-        if (this.variationConfiguration) {
-            const simulatedVariationsData = this.getSimulatedVariations(visitorCode);
-            try {
-                this.variationConfiguration.clearSimulatedVariations(visitorCode).throw();
-                if (simulatedVariationsData !== null && simulatedVariationsData.length > 0) {
-                    this.variationConfiguration.updateForcedFeatureVariations(visitorCode, simulatedVariationsData).throw();
-                }
-            }
-            catch (error) {
-                if (error instanceof Error) {
-                    KameleoonLogger.error `Failed to process simulated variations: ${error.message}`;
-                }
-            }
-        }
-    }
-    getSimulatedVariations(visitorCode) {
-        KameleoonLogger.debug `CALL: VisitorCodeManager.getSimulatedVariations(visitorCode: ${visitorCode})`;
-        const simulatedVariationsData = this.getDataCallback(exports.KameleoonStorageKey.KameleoonSimulationFFData);
-        let variations = null;
-        if (typeof simulatedVariationsData === 'string' &&
-            simulatedVariationsData.length > 0) {
-            try {
-                const parsed = JSON.parse(decodeURIComponent(simulatedVariationsData));
-                if (parsed && typeof parsed === 'object') {
-                    variations = Object.entries(parsed)
-                        .map(([key, value]) => {
-                        return this.variationConfiguration.simulatedVariationFromJson(key, value);
-                    })
-                        .filter((variation) => variation !== null);
-                }
-            }
-            catch (error) {
-                if (error instanceof Error) {
-                    KameleoonLogger.error `Failed to parse simulated variations: ${error.message}`;
-                }
-            }
-        }
-        KameleoonLogger.debug `RETURN: VisitorCodeManager.getSimulatedVariations(visitorCode: ${visitorCode}) -> (variations: ${variations})`;
-        return variations;
-    }
-    generateVisitorCode() {
-        const characters = 'abcdefghijklmnopqrstuvwxyz0123456789';
-        const randomCharacterArray = [];
-        for (let i = 0; i < VISITOR_CODE_LENGTH; i++) {
-            randomCharacterArray.push(characters[Math.floor(Math.random() * characters.length)]);
-        }
-        return randomCharacterArray.join('');
-    }
-    setVariationConfiguration(variationConfiguration) {
-        if (!this.variationConfiguration) {
-            this.variationConfiguration = variationConfiguration;
-        }
-    }
-}
-
 var Byte;
 (function (Byte) {
     Byte[Byte["Kb"] = 1000] = "Kb";
@@ -7958,7 +7980,10 @@ class Tracker {
             const linkedVisitor = this.dataManager.getLinkedVisitor(visitorCode);
             const index = this.dataManager.identifierCustomDataIndex;
             if (!linkedVisitor && typeof index === 'number') {
-                this.dataManager.storeData(visitorCode, new CustomData$1(index, visitorCode));
+                this.dataManager.storeData({
+                    visitorCode,
+                    data: [new CustomData$1(index, visitorCode)],
+                });
             }
             else {
                 isMappingIdentifier = true;
@@ -8107,7 +8132,7 @@ class Tracker {
             this.dataManager.storeTrackedData(updatedData);
         }
         else {
-            this.dataManager.storeData(updatedData, false);
+            this.dataManager.storeDataForVisitors(updatedData, false);
         }
     }
     getUnsentVisitorData(visitorCode, isConsentProvided) {
@@ -8290,16 +8315,21 @@ class KameleoonClient {
             return result.ok;
         });
     }
-    addData(visitorCode, ...data) {
+    addData(visitorCodeOrParams, ...dataRest) {
         if (this.stubMode) {
             throw new KameleoonError(exports.KameleoonException.Initialization);
         }
+        const params = typeof visitorCodeOrParams === 'string'
+            ? { visitorCode: visitorCodeOrParams, data: dataRest }
+            : visitorCodeOrParams;
+        const { visitorCode, data, track = true } = params;
         KameleoonLogger.info `CALL: KameleoonClient.addData(visitorCode: ${visitorCode}, data: ${data})`;
         this.visitorCodeManager.validateVisitorCode(visitorCode).throw();
         if (!this.initialized) {
             throw new KameleoonError(exports.KameleoonException.Initialization);
         }
-        this.dataManager.storeData(visitorCode, ...data).throw();
+        // assuming DataManager.storeData supports `track` (boolean) as discussed
+        this.dataManager.storeData({ visitorCode, track, data }).throw();
         KameleoonLogger.info `RETURN: KameleoonClient.addData(visitorCode: ${visitorCode}, data: ${data})`;
     }
     getRemoteVisitorData({ visitorCode, shouldAddData = true, filters = DEFAULT_VISITOR_DATA_FILTERS, }) {
@@ -8643,7 +8673,11 @@ class KameleoonClient {
                 return null;
             }
             const customData = new CustomData$1(customDataIndex, ...Object.keys(data[WAREHOUSE_AUDIENCE_KEY]));
-            this.dataManager.storeData(visitorCode, customData);
+            this.dataManager.storeData({
+                visitorCode,
+                track: true,
+                data: [customData],
+            });
             KameleoonLogger.info `RETURN: KameleoonClient.getVisitorWarehouseAudience(visitorCode: ${visitorCode}, customDataIndex: ${customDataIndex}, warehouseKey: ${warehouseKey}) -> (customData: ${customData})`;
             return customData;
         });
@@ -8719,7 +8753,7 @@ class KameleoonClient {
             }
         }
         if (targetedSegments.length !== 0) {
-            this.dataManager.storeData(visitorCode, ...targetedSegments);
+            this.dataManager.storeData({ visitorCode, data: targetedSegments });
         }
         this.flush(visitorCode);
         KameleoonLogger.info `RETURN: KameleoonClient.evaluateAudiences(visitorCode: ${visitorCode})`;