@kameleoon/javascript-sdk-core 1.1.1 → 2.1.0

package/dist/kameleoonClient.js

@@ -1,263 +1,381 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.KameleoonClient = void 0;
-const ts_res_1 = require("ts-res");
-const campaignConfiguration_1 = require("./campaignConfiguration");
-const clientSettings_1 = require("./clientSettings");
-const constants_1 = require("./constants");
-const kameleoonData_1 = require("./kameleoonData");
-const kameleoonError_1 = require("./kameleoonError");
-const requester_1 = require("./requester");
-const storage_1 = require("./storage");
-const externalStorage_1 = require("./storage/externalStorage");
-const utilities_1 = require("./utilities");
-const variationConfiguration_1 = require("./variationConfiguration");
+var _tsRes = require("ts-res");
+var _cacheManager = require("./cacheManager");
+var _campaignConfiguration = require("./campaignConfiguration");
+var _clientSettings = require("./clientSettings");
+var _constants = require("./constants");
+var _kameleoonData = require("./kameleoonData");
+var _kameleoonError = require("./kameleoonError");
+var _requester = require("./requester");
+var _storage = require("./storage");
+var _externalStorage = require("./storage/externalStorage");
+var _utilities = require("./utilities");
+var _variationConfiguration = require("./variationConfiguration");
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
 /**
  * @class
  * KameleoonClient - a class for creating kameleoon client instance
  * for communicating with Kameleoon JavaScript SDK Core, when new instance is created
- * */
+ */
 class KameleoonClient {
-    /**
-     * @param {SDKCoreParameters} sdkCoreParameters - parameters for initializing sdk core
-     */
-    constructor({ siteCode, configuration, internalConfiguration, }) {
-        const { settings: clientSettings } = new clientSettings_1.ClientSettings(siteCode, configuration);
-        const requester = new requester_1.Requester(siteCode, clientSettings.environment);
-        this.requester = requester;
-        this.settings = clientSettings;
-        this.internalConfiguration = internalConfiguration;
-    }
-    initialize() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { externalStorage, externalEventSource } = this.internalConfiguration;
-            const clientDataStorage = new externalStorage_1.ExternalStorage(externalStorage.initialize(storage_1.KameleoonStorageKey.ClientData));
-            const variationDataStorage = new externalStorage_1.ExternalStorage(externalStorage.initialize(storage_1.KameleoonStorageKey.VariationData));
-            const campaignConfiguration = new campaignConfiguration_1.CampaignConfiguration({
-                settings: this.settings,
-                storage: clientDataStorage,
-                requester: this.requester,
-            });
-            const result = yield campaignConfiguration.initialize(externalEventSource);
-            result.throw();
-            const variationConfiguration = new variationConfiguration_1.VariationConfiguration(campaignConfiguration.experiments, variationDataStorage);
-            this.variationConfiguration = variationConfiguration;
-            this.campaignConfiguration = campaignConfiguration;
-            return result.ok;
-        });
+  /**
+   * @param {SDKCoreParameters} sdkCoreParameters - parameters for initializing sdk core
+   */
+  constructor({
+    siteCode,
+    configuration,
+    internalConfiguration
+  }) {
+    _defineProperty(this, "internalConfiguration", void 0);
+    _defineProperty(this, "variationConfiguration", void 0);
+    _defineProperty(this, "campaignConfiguration", void 0);
+    _defineProperty(this, "settings", void 0);
+    _defineProperty(this, "trackingCache", void 0);
+    _defineProperty(this, "requester", void 0);
+    const {
+      settings: clientSettings
+    } = new _clientSettings.ClientSettings(siteCode, configuration);
+    const {
+      externalPackageInfo,
+      externalRequestDispatcher
+    } = internalConfiguration;
+    const requester = new _requester.Requester({
+      siteCode,
+      environment: clientSettings.environment,
+      packageInfo: externalPackageInfo,
+      requestDispatcher: externalRequestDispatcher
+    });
+    const trackingCache = new _cacheManager.CacheManager(_constants.CACHE_CLEANUP_TIMEOUT);
+    this.requester = requester;
+    this.settings = clientSettings;
+    this.trackingCache = trackingCache;
+    this.internalConfiguration = internalConfiguration;
+  }
+  async initialize() {
+    const {
+      externalStorage,
+      externalEventSource,
+      externalClientConfiguration,
+      targetingDataCleanupInterval
+    } = this.internalConfiguration;
+    const clientDataStorage = new _externalStorage.ExternalStorage(externalStorage.initialize(_storage.KameleoonStorageKey.ClientData));
+    const variationDataStorage = new _externalStorage.ExternalStorage(externalStorage.initialize(_storage.KameleoonStorageKey.VariationData));
+    const campaignConfiguration = new _campaignConfiguration.CampaignConfiguration({
+      settings: this.settings,
+      storage: clientDataStorage,
+      requester: this.requester,
+      externalClientConfiguration,
+      targetingCleanupInterval: targetingDataCleanupInterval
+    });
+    const result = await campaignConfiguration.initialize(externalEventSource);
+    result.throw();
+    const variationConfiguration = new _variationConfiguration.VariationConfiguration(campaignConfiguration.experiments, variationDataStorage);
+    this.variationConfiguration = variationConfiguration;
+    this.campaignConfiguration = campaignConfiguration;
+    return result.ok;
+  }
+  addData(visitorCode, ...data) {
+    _utilities.Utilities.validateVisitorCode(visitorCode).throw();
+    if (!this.campaignConfiguration) {
+      throw new _kameleoonError.KameleoonError(_kameleoonError.KameleoonException.Initialization);
     }
-    addData(visitorCode, ...data) {
-        utilities_1.Utilities.validateVisitorCode(visitorCode).throw();
-        if (!this.campaignConfiguration) {
-            throw new kameleoonError_1.KameleoonError(kameleoonError_1.KameleoonException.Initialization);
-        }
-        this.campaignConfiguration.addTargetingData(visitorCode, ...data).throw();
+    this.campaignConfiguration.addTargetingData(visitorCode, ...data).throw();
+  }
+  triggerExperiment(visitorCode, experimentId) {
+    _utilities.Utilities.validateVisitorCode(visitorCode).throw();
+    if (!this.campaignConfiguration || !this.variationConfiguration) {
+      throw new _kameleoonError.KameleoonError(_kameleoonError.KameleoonException.Initialization);
     }
-    triggerExperiment(visitorCode, experimentId) {
-        utilities_1.Utilities.validateVisitorCode(visitorCode).throw();
-        if (!this.campaignConfiguration || !this.variationConfiguration) {
-            throw new kameleoonError_1.KameleoonError(kameleoonError_1.KameleoonException.Initialization);
-        }
-        const experiment = this.campaignConfiguration.experiments.find((item) => item.id === String(experimentId));
-        if (!experiment) {
-            throw new kameleoonError_1.KameleoonError(kameleoonError_1.KameleoonException.ExperimentConfigurationNotFound, experimentId, visitorCode);
-        }
-        const targetingData = this.campaignConfiguration.storedTargetingData[visitorCode];
-        const targetingResult = utilities_1.Utilities.checkTargeting({
-            visitorCode,
-            experimentId,
-            targetingData,
-            segment: experiment.segment,
-            variationConfiguration: this.variationConfiguration,
-        }).throw();
-        if (!targetingResult) {
-            throw new kameleoonError_1.KameleoonError(kameleoonError_1.KameleoonException.NotTargeted, visitorCode);
-        }
-        const dataUrl = utilities_1.Utilities.getDataUrl(visitorCode, this.campaignConfiguration);
-        const trackingParameters = {
-            body: dataUrl,
-            visitorCode,
-            experimentId,
-        };
-        const userAgent = utilities_1.Utilities.getUserAgent(visitorCode, this.campaignConfiguration);
-        const variationId = this.variationConfiguration
-            .getAssociatedVariationId(visitorCode, experimentId)
-            .else((error) => {
-            if (error.type === kameleoonError_1.KameleoonException.NotAllocated) {
-                this.requester.trackExperiment(Object.assign({ variationId: constants_1.UNALLOCATED_VARIATION_ID, isUnallocated: true, userAgent }, trackingParameters));
-                return constants_1.UNALLOCATED_VARIATION_ID;
-            }
-            throw error;
-        });
-        this.requester.trackExperiment(Object.assign({ variationId, isUnallocated: false, userAgent }, trackingParameters));
-        return variationId;
+    const experiment = this.campaignConfiguration.experiments.find(item => item.id === String(experimentId));
+    if (!experiment) {
+      throw new _kameleoonError.KameleoonError(_kameleoonError.KameleoonException.ExperimentConfigurationNotFound, experimentId, visitorCode);
     }
-    trackConversion({ visitorCode, goalId, revenue, }) {
-        this.addData(visitorCode, new kameleoonData_1.Conversion({ goalId, revenue }));
-        this.flushData(visitorCode);
+    const targetingData = this.campaignConfiguration.storedTargetingData[visitorCode];
+    const targetingResult = _utilities.Utilities.checkTargeting({
+      visitorCode,
+      experimentId,
+      targetingData,
+      segment: experiment.segment,
+      variationConfiguration: this.variationConfiguration
+    }).throw();
+    if (!targetingResult) {
+      throw new _kameleoonError.KameleoonError(_kameleoonError.KameleoonException.NotTargeted, visitorCode);
     }
-    flushData(visitorCode) {
-        if (!this.campaignConfiguration) {
-            throw new kameleoonError_1.KameleoonError(kameleoonError_1.KameleoonException.Initialization);
-        }
-        const dataUrl = utilities_1.Utilities.getDataUrl(visitorCode, this.campaignConfiguration);
-        const userAgent = utilities_1.Utilities.getUserAgent(visitorCode, this.campaignConfiguration);
-        this.requester.trackData({ visitorCode, body: dataUrl, userAgent });
+    const dataUrl = _utilities.Utilities.getDataUrl(visitorCode, this.campaignConfiguration);
+    const trackingParameters = {
+      body: dataUrl,
+      visitorCode,
+      experimentId
+    };
+    const userAgent = _utilities.Utilities.getUserAgent(visitorCode, this.campaignConfiguration);
+    const variationId = this.variationConfiguration.getAssociatedVariationId(visitorCode, experimentId).else(error => {
+      if (error.type === _kameleoonError.KameleoonException.NotAllocated) {
+        this.requester.trackExperiment(_objectSpread({
+          variationId: _constants.UNALLOCATED_VARIATION_ID,
+          isUnallocated: true,
+          userAgent
+        }, trackingParameters));
+        return _constants.UNALLOCATED_VARIATION_ID;
+      }
+      throw error;
+    });
+    this.requester.trackExperiment(_objectSpread({
+      variationId,
+      isUnallocated: false,
+      userAgent
+    }, trackingParameters));
+    if (this.internalConfiguration.externalPackageInfo.type === _constants.SDKType.NodeJS) {
+      _utilities.Utilities.updateCache({
+        cacheManager: this.trackingCache,
+        visitorCode,
+        experimentId,
+        variationId
+      });
     }
-    getExperiments() {
-        if (!this.campaignConfiguration) {
-            throw new kameleoonError_1.KameleoonError(kameleoonError_1.KameleoonException.Initialization);
-        }
-        return this.campaignConfiguration.experiments.map(({ id, name }) => ({
-            id: Number(id),
-            name,
-        }));
+    return variationId;
+  }
+  trackConversion({
+    visitorCode,
+    goalId,
+    revenue
+  }) {
+    this.addData(visitorCode, new _kameleoonData.Conversion({
+      goalId,
+      revenue
+    }));
+    this.flushData(visitorCode);
+  }
+  flushData(visitorCode) {
+    if (!this.campaignConfiguration) {
+      throw new _kameleoonError.KameleoonError(_kameleoonError.KameleoonException.Initialization);
     }
-    getVisitorExperiments(visitorCode, isActive = true) {
-        if (!this.variationConfiguration || !this.campaignConfiguration) {
-            throw new kameleoonError_1.KameleoonError(kameleoonError_1.KameleoonException.Initialization);
-        }
-        utilities_1.Utilities.validateVisitorCode(visitorCode).throw();
-        const experiments = this.campaignConfiguration.experiments;
-        const result = [];
-        const targetingData = this.campaignConfiguration.storedTargetingData[visitorCode];
-        for (const experiment of experiments) {
-            const { id, name, segment } = experiment;
-            const targetingResult = utilities_1.Utilities.checkTargeting({
-                targetingData,
-                visitorCode,
-                segment,
-                variationConfiguration: this.variationConfiguration,
-                experimentId: Number(id),
-            }).throw();
-            if (!targetingResult) {
-                continue;
-            }
-            // -- If `isActive=false` then return every experiment
-            if (!isActive) {
-                result.push({ id: Number(id), name });
-                continue;
-            }
-            // -- Else first check if there are saved variations for the experiment
-            // if there is at least one than it's active
-            const experimentVariations = this.variationConfiguration.getAssignedVariations(visitorCode);
-            if (experimentVariations.ok) {
-                const experimentVariation = experimentVariations.data[experiment.id];
-                if (experimentVariation) {
-                    result.push({ id: Number(id), name });
-                    continue;
-                }
-            }
-            // -- Second check if the experiment will have an allocated variation upon triggering
-            // if yes than it's active
-            const variationResult = this.variationConfiguration.getExperimentVariation(visitorCode, experiment);
-            if (variationResult.ok) {
-                result.push({ id: Number(id), name });
-            }
-        }
-        return result;
+    const dataUrl = _utilities.Utilities.getDataUrl(visitorCode, this.campaignConfiguration);
+    const userAgent = _utilities.Utilities.getUserAgent(visitorCode, this.campaignConfiguration);
+    this.requester.trackData({
+      visitorCode,
+      body: dataUrl,
+      userAgent
+    });
+  }
+  getExperiments() {
+    if (!this.campaignConfiguration) {
+      throw new _kameleoonError.KameleoonError(_kameleoonError.KameleoonException.Initialization);
     }
-    getFeatureFlags() {
-        if (!this.campaignConfiguration) {
-            throw new kameleoonError_1.KameleoonError(kameleoonError_1.KameleoonException.Initialization);
-        }
-        return this.campaignConfiguration.featureFlags.map(({ id, featureKey }) => ({ id, key: featureKey }));
+    return this.campaignConfiguration.experiments.map(({
+      id,
+      name
+    }) => ({
+      id: Number(id),
+      name
+    }));
+  }
+  getVisitorExperiments(visitorCode, isActive = true) {
+    if (!this.variationConfiguration || !this.campaignConfiguration) {
+      throw new _kameleoonError.KameleoonError(_kameleoonError.KameleoonException.Initialization);
     }
-    getVisitorFeatureFlags(visitorCode) {
-        if (!this.variationConfiguration || !this.campaignConfiguration) {
-            throw new kameleoonError_1.KameleoonError(kameleoonError_1.KameleoonException.Initialization);
-        }
-        const featureFlags = this.campaignConfiguration.featureFlags;
-        const resultFeatureFlags = [];
-        for (const featureFlag of featureFlags) {
-            const variationData = this.variationConfiguration
-                .getFeatureFlagVariation({
-                visitorCode,
-                featureFlag,
-            })
-                .throw();
-            if (variationData.variationKey !== constants_1.OFF_VARIATION_KEY) {
-                const { featureFlagId, featureKey } = variationData;
-                resultFeatureFlags.push({ id: featureFlagId, key: featureKey });
-            }
+    _utilities.Utilities.validateVisitorCode(visitorCode).throw();
+    const experiments = this.campaignConfiguration.experiments;
+    const result = [];
+    const targetingData = this.campaignConfiguration.storedTargetingData[visitorCode];
+    for (const experiment of experiments) {
+      const {
+        id,
+        name,
+        segment
+      } = experiment;
+      const targetingResult = _utilities.Utilities.checkTargeting({
+        targetingData,
+        visitorCode,
+        segment,
+        variationConfiguration: this.variationConfiguration,
+        experimentId: Number(id)
+      }).throw();
+      if (!targetingResult) {
+        continue;
+      }
+
+      // -- If `isActive=false` then return every experiment
+      if (!isActive) {
+        result.push({
+          id: Number(id),
+          name
+        });
+        continue;
+      }
+
+      // -- Else first check if there are saved variations for the experiment
+      // if there is at least one than it's active
+      const experimentVariations = this.variationConfiguration.getAssignedVariations(visitorCode);
+      if (experimentVariations.ok) {
+        const experimentVariation = experimentVariations.data[experiment.id];
+        if (experimentVariation) {
+          result.push({
+            id: Number(id),
+            name
+          });
+          continue;
         }
-        return resultFeatureFlags;
+      }
+
+      // -- Second check if the experiment will have an allocated variation upon triggering
+      // if yes than it's active
+      const variationResult = this.variationConfiguration.getExperimentVariation(visitorCode, experiment);
+      if (variationResult.ok) {
+        result.push({
+          id: Number(id),
+          name
+        });
+      }
     }
-    getFeatureFlagVariationKey(visitorCode, featureKey) {
-        const { variationKey } = this._getFeatureFlagVariation(visitorCode, featureKey).throw();
-        return variationKey;
+    return result;
+  }
+  getExperimentVariationData(variationId) {
+    if (!this.campaignConfiguration) {
+      throw new _kameleoonError.KameleoonError(_kameleoonError.KameleoonException.Initialization);
     }
-    getFeatureFlagVariable({ visitorCode, featureKey, variableKey, }) {
-        var _a, _b;
-        const { variationKey } = this._getFeatureFlagVariation(visitorCode, featureKey).throw();
-        // --- Note ---
-        // `_getFeatureFlagVariation` already checks `campaignConfiguration` initialization
-        const featureFlags = this.campaignConfiguration
-            .featureFlags;
-        const variable = (_b = (_a = featureFlags
-            .find((item) => item.featureKey === featureKey)) === null || _a === void 0 ? void 0 : _a.variations.find((item) => item.key === variationKey)) === null || _b === void 0 ? void 0 : _b.variables.find((item) => item.key === variableKey);
-        if (!variable) {
-            throw new kameleoonError_1.KameleoonError(kameleoonError_1.KameleoonException.FeatureFlagConfigurationNotFound, featureKey, visitorCode);
+    const experiments = this.campaignConfiguration.experiments;
+    for (const experiment of experiments) {
+      const variation = experiment.variations.find(item => item.id === String(variationId));
+      if (variation) {
+        try {
+          return JSON.parse(variation.customJson);
+        } catch (err) {
+          throw new _kameleoonError.KameleoonError(_kameleoonError.KameleoonException.JSONParse, err);
         }
-        const featureVariable = utilities_1.Utilities.parseFeatureVariable(variable).throw();
-        return featureVariable;
+      }
     }
-    isFeatureFlagActive(visitorCode, featureKey) {
-        const variationKey = this.getFeatureFlagVariationKey(visitorCode, featureKey);
-        return variationKey !== constants_1.OFF_VARIATION_KEY;
+    throw new _kameleoonError.KameleoonError(_kameleoonError.KameleoonException.VariationNotFound);
+  }
+  getFeatureFlags() {
+    if (!this.campaignConfiguration) {
+      throw new _kameleoonError.KameleoonError(_kameleoonError.KameleoonException.Initialization);
     }
-    getRemoteData(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const remoteData = yield this.requester.getRemoteData(key);
-            return remoteData.throw();
+    return this.campaignConfiguration.featureFlags.map(({
+      id,
+      featureKey
+    }) => ({
+      id,
+      key: featureKey
+    }));
+  }
+  getVisitorFeatureFlags(visitorCode) {
+    if (!this.variationConfiguration || !this.campaignConfiguration) {
+      throw new _kameleoonError.KameleoonError(_kameleoonError.KameleoonException.Initialization);
+    }
+    const featureFlags = this.campaignConfiguration.featureFlags;
+    const resultFeatureFlags = [];
+    const targetingData = this.campaignConfiguration.storedTargetingData[visitorCode];
+    for (const featureFlag of featureFlags) {
+      const variationData = this.variationConfiguration.getFeatureFlagVariation({
+        visitorCode,
+        targetingData,
+        featureFlag
+      }).throw();
+      if (variationData.variationKey !== _constants.OFF_VARIATION_KEY) {
+        const {
+          featureFlagId,
+          featureKey
+        } = variationData;
+        resultFeatureFlags.push({
+          id: featureFlagId,
+          key: featureKey
         });
+      }
     }
-    onConfigurationUpdate(callback) {
-        if (!this.campaignConfiguration) {
-            throw new kameleoonError_1.KameleoonError(kameleoonError_1.KameleoonException.Initialization);
-        }
-        this.campaignConfiguration.onConfigurationUpdate(callback);
+    return resultFeatureFlags;
+  }
+  getFeatureFlagVariationKey(visitorCode, featureKey) {
+    const {
+      variationKey
+    } = this._getFeatureFlagVariation(visitorCode, featureKey).throw();
+    return variationKey;
+  }
+  getFeatureFlagVariable({
+    visitorCode,
+    featureKey,
+    variableKey
+  }) {
+    const {
+      variationKey
+    } = this._getFeatureFlagVariation(visitorCode, featureKey).throw();
+
+    // --- Note ---
+    // `_getFeatureFlagVariation` already checks `campaignConfiguration` initialization
+    const featureFlags = this.campaignConfiguration.featureFlags;
+    const variable = featureFlags.find(item => item.featureKey === featureKey)?.variations.find(item => item.key === variationKey)?.variables.find(item => item.key === variableKey);
+    if (!variable) {
+      throw new _kameleoonError.KameleoonError(_kameleoonError.KameleoonException.FeatureFlagConfigurationNotFound, featureKey, visitorCode);
     }
-    _getFeatureFlagVariation(visitorCode, featureKey) {
-        var _a;
-        if (!this.variationConfiguration || !this.campaignConfiguration) {
-            return (0, ts_res_1.Err)(new kameleoonError_1.KameleoonError(kameleoonError_1.KameleoonException.Initialization));
-        }
-        const featureFlags = this.campaignConfiguration.featureFlags;
-        const featureFlag = featureFlags.find((item) => item.featureKey === featureKey);
-        if (!featureFlag) {
-            return (0, ts_res_1.Err)(new kameleoonError_1.KameleoonError(kameleoonError_1.KameleoonException.FeatureFlagConfigurationNotFound, featureKey, visitorCode));
-        }
-        const targetingData = this.campaignConfiguration.storedTargetingData[visitorCode];
-        const variationData = this.variationConfiguration
-            .getFeatureFlagVariation({
-            visitorCode,
-            featureFlag,
-            targetingData,
-            withAssignment: true,
-        })
-            .throw();
-        if (((_a = variationData.rule) === null || _a === void 0 ? void 0 : _a.type) === campaignConfiguration_1.RuleType.EXPERIMENTATION) {
-            const userAgent = utilities_1.Utilities.getUserAgent(visitorCode, this.campaignConfiguration);
-            utilities_1.Utilities.trackExperimentationRule({
-                visitorCode,
-                requester: this.requester,
-                featureFlagVariation: variationData,
-                campaignConfiguration: this.campaignConfiguration,
-                userAgent,
-            });
-        }
-        return (0, ts_res_1.Ok)(variationData);
+    const featureVariable = _utilities.Utilities.parseFeatureVariable(variable).throw();
+    return featureVariable;
+  }
+  isFeatureFlagActive(visitorCode, featureKey) {
+    const variationKey = this.getFeatureFlagVariationKey(visitorCode, featureKey);
+    return variationKey !== _constants.OFF_VARIATION_KEY;
+  }
+  async getRemoteData(key) {
+    const remoteData = await this.requester.getRemoteData(key);
+    return remoteData.throw();
+  }
+  onConfigurationUpdate(callback) {
+    if (!this.campaignConfiguration) {
+      throw new _kameleoonError.KameleoonError(_kameleoonError.KameleoonException.Initialization);
+    }
+    this.campaignConfiguration.onConfigurationUpdate(callback);
+  }
+  _getEngineTrackingCode(visitorCode) {
+    return _utilities.Utilities.getTrackingCode(this.trackingCache, visitorCode);
+  }
+  _getFeatureFlagVariation(visitorCode, featureKey) {
+    if (!this.variationConfiguration || !this.campaignConfiguration) {
+      return (0, _tsRes.Err)(new _kameleoonError.KameleoonError(_kameleoonError.KameleoonException.Initialization));
+    }
+    const featureFlags = this.campaignConfiguration.featureFlags;
+    const featureFlag = featureFlags.find(item => item.featureKey === featureKey);
+    if (!featureFlag) {
+      return (0, _tsRes.Err)(new _kameleoonError.KameleoonError(_kameleoonError.KameleoonException.FeatureFlagConfigurationNotFound, featureKey, visitorCode));
+    }
+    const targetingData = this.campaignConfiguration.storedTargetingData[visitorCode];
+    const variationData = this.variationConfiguration.getFeatureFlagVariation({
+      visitorCode,
+      featureFlag,
+      targetingData,
+      withAssignment: true
+    }).throw();
+    const {
+      experimentId,
+      variationId,
+      rule
+    } = variationData;
+    if (this.internalConfiguration.externalPackageInfo.type === _constants.SDKType.NodeJS && typeof variationId === 'number' && typeof experimentId === 'number') {
+      _utilities.Utilities.updateCache({
+        cacheManager: this.trackingCache,
+        visitorCode,
+        experimentId,
+        variationId
+      });
+    }
+    const userAgent = _utilities.Utilities.getUserAgent(visitorCode, this.campaignConfiguration);
+    if (rule) {
+      _utilities.Utilities.trackRule({
+        visitorCode,
+        requester: this.requester,
+        featureFlagVariation: variationData,
+        campaignConfiguration: this.campaignConfiguration,
+        userAgent
+      });
     }
+    return (0, _tsRes.Ok)(variationData);
+  }
 }
 exports.KameleoonClient = KameleoonClient;
 //# sourceMappingURL=kameleoonClient.js.map