@kameleoon/javascript-sdk-core 5.15.0 → 5.16.0

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

@@ -5118,7 +5118,7 @@ class ConditionFactory {
             case TargetingType.HEAT_SLICE:
                 return buildExports.Ok(new ConversionLikelihood(data));
             default:
-                KameleoonLogger.error `Unsupported targeted condition type found: ${targetingType}`;
+                KameleoonLogger.info `Unsupported targeted condition type found: ${targetingType}`;
                 return buildExports.Err(new KameleoonError(KameleoonException.TargetingCondition, targetingType));
         }
     }
@@ -7767,7 +7767,7 @@ class BodyProvider {
         const identifier = isMappingIdentifier
             ? UrlParameter.MappingValue
             : UrlParameter.VisitorCode;
-        return identifier + visitorCode;
+        return identifier + encodeURIComponent(visitorCode);
     }
 }
 
@@ -8351,6 +8351,7 @@ class KameleoonClient {
             }
             const resultVariables = variables.map((variable) => Parser.parseFeatureVariable(variable).throw());
             resultFeatureList.set(variation.featureKey, {
+                name: '',
                 key: variationKey,
                 id: variationId,
                 experimentId,
@@ -8571,6 +8572,62 @@ class KameleoonClient {
         this.flush(visitorCode);
         KameleoonLogger.info `RETURN: KameleoonClient.evaluateAudiences(visitorCode: ${visitorCode})`;
     }
+    getDataFile() {
+        const dataFile = {
+            featureFlags: new Map(),
+        };
+        if (this.stubMode) {
+            return dataFile;
+        }
+        KameleoonLogger.debug `CALL: KameleoonClient.getDataFile()`;
+        this.clientConfiguration.featureFlags.forEach((featureFlag, key) => {
+            const variationsMap = new Map();
+            featureFlag.variations.forEach((sourceVariation) => {
+                var _a;
+                const variablesMap = new Map();
+                sourceVariation.variables.forEach((variable) => {
+                    try {
+                        const parsedVariable = Parser.parseFeatureVariable(variable).throw();
+                        variablesMap.set(variable.key, parsedVariable);
+                    }
+                    catch (err) {
+                        KameleoonLogger.error `Error parsing variable ${variable.key} of feature flag ${featureFlag.featureKey}: ${err}`;
+                    }
+                });
+                variationsMap.set(sourceVariation.key, {
+                    name: (_a = sourceVariation.name) !== null && _a !== void 0 ? _a : '',
+                    key: sourceVariation.key,
+                    id: null,
+                    experimentId: null,
+                    variables: variablesMap,
+                });
+            });
+            const rules = featureFlag.rules.map((rule) => {
+                const ruleVariations = new Map();
+                rule.variationByExposition.forEach((varByExp) => {
+                    const baseVariation = variationsMap.get(varByExp.variationKey);
+                    if (!baseVariation)
+                        return;
+                    ruleVariations.set(baseVariation.key, {
+                        name: baseVariation.name,
+                        key: baseVariation.key,
+                        id: varByExp.variationId,
+                        experimentId: rule.experimentId,
+                        variables: baseVariation.variables,
+                    });
+                });
+                return { variations: ruleVariations };
+            });
+            dataFile.featureFlags.set(key, {
+                variations: variationsMap,
+                environmentEnabled: featureFlag.environmentEnabled,
+                rules,
+                defaultVariationKey: featureFlag.defaultVariationKey,
+            });
+        });
+        KameleoonLogger.debug `RETURN: KameleoonClient.getDataFile() -> (dataFile: ${dataFile})`;
+        return dataFile;
+    }
     setUserConsent({ visitorCode, consent, setData, }) {
         if (this.stubMode) {
             return;
@@ -8757,6 +8814,7 @@ class KameleoonClient {
         return selected;
     }
     _getFeatureVariation({ visitorCode, featureKey, track, }) {
+        var _a, _b;
         KameleoonLogger.debug `CALL: KameleoonClient._getFeatureVariation(visitorCode: ${visitorCode}, featureKey: ${featureKey}, track: ${track})`;
         if (!this.initialized) {
             return buildExports.Err(new KameleoonError(KameleoonException.Initialization));
@@ -8807,7 +8865,9 @@ class KameleoonClient {
         if (track && !isSimulated) {
             this.tracker.scheduleVisitor(visitorCode, this._isConsentProvided(visitorCode));
         }
+        const variationName = (_b = (_a = featureFlag.variations.find((item) => item.key === variationKey)) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : '';
         const resultData = {
+            name: variationName,
             key: variationKey,
             id: variationId,
             experimentId,