@kameleoon/javascript-sdk-core 5.17.3 → 5.18.0

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

@@ -3366,6 +3366,7 @@ class Parser {
     }
 }
 
+var _a;
 class ClientSettings {
     constructor(siteCode, configuration) {
         KameleoonLogger.debug `CALL: new ClientSettings(siteCode: ${siteCode}, configuration: ${configuration})`;
@@ -3380,18 +3381,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) {
@@ -3445,6 +3447,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
@@ -5439,7 +5445,6 @@ class StorageCleanupManager {
                         break;
                     default:
                         // check if all cases are handled
-                        const exhaustiveCheck = storageKey;
                         KameleoonLogger.error `Unknown storage key: ${storageKey} for initCleanupInterval.`;
                 }
             }
@@ -5734,7 +5739,7 @@ class DataManager {
         return resultData;
     }
     storeTrackedData(data) {
-        this.storeData(data, false);
+        this.storeDataForVisitors(data, false);
         const infoResult = this.infoStorage.read();
         if (!infoResult.ok) {
             return;
@@ -5768,30 +5773,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,
@@ -5800,12 +5806,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)) {
@@ -5894,29 +5914,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({
@@ -6074,6 +6096,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) {
@@ -7599,135 +7750,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";
@@ -7920,7 +7942,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;
@@ -8069,7 +8094,7 @@ class Tracker {
             this.dataManager.storeTrackedData(updatedData);
         }
         else {
-            this.dataManager.storeData(updatedData, false);
+            this.dataManager.storeDataForVisitors(updatedData, false);
         }
     }
     getUnsentVisitorData(visitorCode, isConsentProvided) {
@@ -8252,16 +8277,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, }) {
@@ -8605,7 +8635,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;
         });
@@ -8681,7 +8715,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})`;