@kameleoon/javascript-sdk-core 2.0.0 → 2.1.0

package/dist/index.d.ts

@@ -2,7 +2,8 @@ export { KameleoonClient as KameleoonCore, IKameleoonClient as IKameleoonCore, }
 export { KameleoonUtils as KameleoonCoreUtils } from './kameleoonUtils';
 export { KameleoonException, KameleoonError } from './kameleoonError';
 export { KameleoonStorageKey, IExternalStorage, IExternalStorageConstructor, } from './storage';
-export { Cookie, VISITOR_CODE_LENGTH } from './constants';
+export { Cookie, VISITOR_CODE_LENGTH, SDKType } from './constants';
+export { CLEANUP_TARGETING_DATA_INTERVAL } from './campaignConfiguration';
 export { JSONType } from './campaignConfiguration';
 export { Ok, Result, Err } from 'ts-res';
 export { Environment, VariableType, ExperimentType, FeatureFlagType, SDKCoreParameters, SDKConfigurationType, ExternalPackageInfoType, TrackConversionParamsType, FeatureVariableResultType, InternalSDKConfigurationType, GetFeatureFlagVariableParamsType, ServerGetVisitorCodeParametersType, ClientGetVisitorCodeParametersType, MobileGetVisitorCodeParametersType, } from './types';

package/dist/index.js

@@ -15,6 +15,12 @@ Object.defineProperty(exports, "BrowserType", {
     return _kameleoonData.BrowserType;
   }
 });
+Object.defineProperty(exports, "CLEANUP_TARGETING_DATA_INTERVAL", {
+  enumerable: true,
+  get: function () {
+    return _campaignConfiguration.CLEANUP_TARGETING_DATA_INTERVAL;
+  }
+});
 Object.defineProperty(exports, "ClientGetVisitorCodeParametersType", {
   enumerable: true,
   get: function () {
@@ -255,6 +261,12 @@ Object.defineProperty(exports, "SDKCoreParameters", {
     return _types.SDKCoreParameters;
   }
 });
+Object.defineProperty(exports, "SDKType", {
+  enumerable: true,
+  get: function () {
+    return _constants.SDKType;
+  }
+});
 Object.defineProperty(exports, "ServerGetVisitorCodeParametersType", {
   enumerable: true,
   get: function () {

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["_kameleoonClient","require","_kameleoonUtils","_kameleoonError","_storage","_constants","_campaignConfiguration","_tsRes","_types","_kameleoonData","_eventSource","_requester"],"sources":["../src/index.ts"],"sourcesContent":["export {\n  KameleoonClient as KameleoonCore,\n  IKameleoonClient as IKameleoonCore,\n} from './kameleoonClient';\nexport { KameleoonUtils as KameleoonCoreUtils } from './kameleoonUtils';\nexport { KameleoonException, KameleoonError } from './kameleoonError';\nexport {\n  KameleoonStorageKey,\n  IExternalStorage,\n  IExternalStorageConstructor,\n} from './storage';\nexport { Cookie, VISITOR_CODE_LENGTH } from './constants';\nexport { JSONType } from './campaignConfiguration';\nexport { Ok, Result, Err } from 'ts-res';\nexport {\n  Environment,\n  VariableType,\n  ExperimentType,\n  FeatureFlagType,\n  SDKCoreParameters,\n  SDKConfigurationType,\n  ExternalPackageInfoType,\n  TrackConversionParamsType,\n  FeatureVariableResultType,\n  InternalSDKConfigurationType,\n  GetFeatureFlagVariableParamsType,\n  ServerGetVisitorCodeParametersType,\n  ClientGetVisitorCodeParametersType,\n  MobileGetVisitorCodeParametersType,\n} from './types';\nexport {\n  CustomData,\n  Conversion,\n  Device,\n  Browser,\n  DeviceType,\n  BrowserType,\n  PageView,\n  KameleoonDataType,\n  PageViewParametersType,\n  ConversionParametersType,\n} from './kameleoonData';\nexport {\n  RealTimeEventType,\n  IExternalEventSource,\n  EventSourceOpenParametersType,\n  IExternalEventSourceConstructor,\n} from './eventSource';\nexport {\n  Header,\n  HttpMethod,\n  TrackParametersType,\n  IExternalRequestDispatcher,\n  GetClientConfigurationResultType,\n} from './requester';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,gBAAA,GAAAC,OAAA;AAIA,IAAAC,eAAA,GAAAD,OAAA;AACA,IAAAE,eAAA,GAAAF,OAAA;AACA,IAAAG,QAAA,GAAAH,OAAA;AAKA,IAAAI,UAAA,GAAAJ,OAAA;AACA,IAAAK,sBAAA,GAAAL,OAAA;AACA,IAAAM,MAAA,GAAAN,OAAA;AACA,IAAAO,MAAA,GAAAP,OAAA;AAgBA,IAAAQ,cAAA,GAAAR,OAAA;AAYA,IAAAS,YAAA,GAAAT,OAAA;AAMA,IAAAU,UAAA,GAAAV,OAAA"}
+{"version":3,"file":"index.js","names":["_kameleoonClient","require","_kameleoonUtils","_kameleoonError","_storage","_constants","_campaignConfiguration","_tsRes","_types","_kameleoonData","_eventSource","_requester"],"sources":["../src/index.ts"],"sourcesContent":["export {\n  KameleoonClient as KameleoonCore,\n  IKameleoonClient as IKameleoonCore,\n} from './kameleoonClient';\nexport { KameleoonUtils as KameleoonCoreUtils } from './kameleoonUtils';\nexport { KameleoonException, KameleoonError } from './kameleoonError';\nexport {\n  KameleoonStorageKey,\n  IExternalStorage,\n  IExternalStorageConstructor,\n} from './storage';\nexport { Cookie, VISITOR_CODE_LENGTH, SDKType } from './constants';\nexport { CLEANUP_TARGETING_DATA_INTERVAL } from './campaignConfiguration';\nexport { JSONType } from './campaignConfiguration';\nexport { Ok, Result, Err } from 'ts-res';\nexport {\n  Environment,\n  VariableType,\n  ExperimentType,\n  FeatureFlagType,\n  SDKCoreParameters,\n  SDKConfigurationType,\n  ExternalPackageInfoType,\n  TrackConversionParamsType,\n  FeatureVariableResultType,\n  InternalSDKConfigurationType,\n  GetFeatureFlagVariableParamsType,\n  ServerGetVisitorCodeParametersType,\n  ClientGetVisitorCodeParametersType,\n  MobileGetVisitorCodeParametersType,\n} from './types';\nexport {\n  CustomData,\n  Conversion,\n  Device,\n  Browser,\n  DeviceType,\n  BrowserType,\n  PageView,\n  KameleoonDataType,\n  PageViewParametersType,\n  ConversionParametersType,\n} from './kameleoonData';\nexport {\n  RealTimeEventType,\n  IExternalEventSource,\n  EventSourceOpenParametersType,\n  IExternalEventSourceConstructor,\n} from './eventSource';\nexport {\n  Header,\n  HttpMethod,\n  TrackParametersType,\n  IExternalRequestDispatcher,\n  GetClientConfigurationResultType,\n} from './requester';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,gBAAA,GAAAC,OAAA;AAIA,IAAAC,eAAA,GAAAD,OAAA;AACA,IAAAE,eAAA,GAAAF,OAAA;AACA,IAAAG,QAAA,GAAAH,OAAA;AAKA,IAAAI,UAAA,GAAAJ,OAAA;AACA,IAAAK,sBAAA,GAAAL,OAAA;AAEA,IAAAM,MAAA,GAAAN,OAAA;AACA,IAAAO,MAAA,GAAAP,OAAA;AAgBA,IAAAQ,cAAA,GAAAR,OAAA;AAYA,IAAAS,YAAA,GAAAT,OAAA;AAMA,IAAAU,UAAA,GAAAV,OAAA"}

package/dist/kameleoonClient.d.ts

@@ -79,6 +79,16 @@ export interface IKameleoonClient {
      * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`
      */
     getVisitorExperiments: (visitorCode: string, isAllocated?: boolean) => ExperimentType[];
+    /**
+     * @method getExperimentVariationData - returns variation data in JSON format for the variation with `variationId`
+     * @param {number} variationId - id of variation
+     * @returns {JSONType} variation data in JSON format
+     * @throws `KameleoonError` with one of the following `type` s:
+     * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`
+     * - `KameleoonException.JSONParse` - Couldn't pass JSON value
+     * - `KameleoonException.VariationNotFound` - No variation found for provided `variationId`
+     */
+    getExperimentVariationData: (variationId: number) => JSONType | null;
     /**
      * @method getFeatureFlags - returns a list of feature flags stored in the client configuration
      * @returns {FeatureFlagType[]} a list of all feature flags items with `id` and `key` fields
@@ -99,7 +109,7 @@ export interface IKameleoonClient {
      */
     getVisitorFeatureFlags: (visitorCode: string) => FeatureFlagType[];
     /**
-     * @method isFeatureFlagActive - returns a boolean indicating whether the visitor with `visitorCode` has `featureKey` active for him, this method includes targeting check, finding the according variation exposed to the visitor and saving it to storage along with sending tracking request if the feature rollout rule was of type of `Experimentation`
+     * @method isFeatureFlagActive - returns a boolean indicating whether the visitor with `visitorCode` has `featureKey` active for him, this method includes targeting check, finding the according variation exposed to the visitor and saving it to storage along with sending tracking request
      * @param {string} visitorCode - unique visitor identification string, can't exceed 255 characters length
      * @param {string} featureKey - a unique key for feature flag
      * @returns {boolean} a boolean indicator of whether the feature flag with `featureKey` is active for visitor with `visitorCode`
@@ -113,7 +123,7 @@ export interface IKameleoonClient {
      */
     isFeatureFlagActive: (visitorCode: string, featureKey: string) => boolean;
     /**
-     * @method getFeatureFlagVariationKey - returns variation key for the visitor under `visitorCode` in the found feature flag, this method includes targeting check, finding the according variation exposed to the visitor and saving it to storage along with sending tracking request if the feature rollout rule was of type of `Experimentation`
+     * @method getFeatureFlagVariationKey - returns variation key for the visitor under `visitorCode` in the found feature flag, this method includes targeting check, finding the according variation exposed to the visitor and saving it to storage along with sending tracking request
      * @param {string} visitorCode - unique visitor identification string, can't exceed 255 characters length
      * @param {string} featureKey - a unique key for feature flag
      * @returns {string} a string containing variable key for the allocated feature flag variation for the provided visitor
@@ -126,7 +136,7 @@ export interface IKameleoonClient {
      */
     getFeatureFlagVariationKey: (visitorCode: string, featureKey: string) => string;
     /**
-     * @method getFeatureFlagVariable - returns a variable for the visitor under `visitorCode` in the found feature flag, this method includes targeting check, finding the according variation exposed to the visitor and saving it to storage along with sending tracking request if the feature rollout rule was of type of `Experimentation`
+     * @method getFeatureFlagVariable - returns a variable for the visitor under `visitorCode` in the found feature flag, this method includes targeting check, finding the according variation exposed to the visitor and saving it to storage along with sending tracking request
      * @param {GetFeatureFlagVariableParamsType} parameters - an object with parameters of a type `GetFeatureFlagVariableParamsType`, see the type for details.
      * @returns {FeatureVariableResultType} a variable object containing `type` and `value` fields, `type` can be checked against `FeatureVariableType` enum, if the `type` is `FeatureVariableType.BOOLEAN` then the `value` type will be `boolean` and so on.
      * @throws `KameleoonError` with one of the following `type` s:
@@ -168,6 +178,7 @@ export declare class KameleoonClient implements IKameleoonClient {
     private variationConfiguration?;
     private campaignConfiguration?;
     private settings;
+    private trackingCache;
     private requester;
     /**
      * @param {SDKCoreParameters} sdkCoreParameters - parameters for initializing sdk core
@@ -180,6 +191,7 @@ export declare class KameleoonClient implements IKameleoonClient {
     flushData(visitorCode: string): void;
     getExperiments(): ExperimentType[];
     getVisitorExperiments(visitorCode: string, isActive?: boolean): ExperimentType[];
+    getExperimentVariationData(variationId: number): JSONType;
     getFeatureFlags(): FeatureFlagType[];
     getVisitorFeatureFlags(visitorCode: string): FeatureFlagType[];
     getFeatureFlagVariationKey(visitorCode: string, featureKey: string): string;
@@ -187,5 +199,6 @@ export declare class KameleoonClient implements IKameleoonClient {
     isFeatureFlagActive(visitorCode: string, featureKey: string): boolean;
     getRemoteData(key: string): Promise<JSONType>;
     onConfigurationUpdate(callback: () => void): void;
+    protected _getEngineTrackingCode(visitorCode: string): string;
     private _getFeatureFlagVariation;
 }

package/dist/kameleoonClient.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.KameleoonClient = void 0;
 var _tsRes = require("ts-res");
+var _cacheManager = require("./cacheManager");
 var _campaignConfiguration = require("./campaignConfiguration");
 var _clientSettings = require("./clientSettings");
 var _constants = require("./constants");
@@ -38,6 +39,7 @@ class KameleoonClient {
     _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
@@ -52,15 +54,18 @@ class KameleoonClient {
       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
+      externalClientConfiguration,
+      targetingDataCleanupInterval
     } = this.internalConfiguration;
     const clientDataStorage = new _externalStorage.ExternalStorage(externalStorage.initialize(_storage.KameleoonStorageKey.ClientData));
     const variationDataStorage = new _externalStorage.ExternalStorage(externalStorage.initialize(_storage.KameleoonStorageKey.VariationData));
@@ -68,7 +73,8 @@ class KameleoonClient {
       settings: this.settings,
       storage: clientDataStorage,
       requester: this.requester,
-      externalClientConfiguration
+      externalClientConfiguration,
+      targetingCleanupInterval: targetingDataCleanupInterval
     });
     const result = await campaignConfiguration.initialize(externalEventSource);
     result.throw();
@@ -127,6 +133,14 @@ class KameleoonClient {
       isUnallocated: false,
       userAgent
     }, trackingParameters));
+    if (this.internalConfiguration.externalPackageInfo.type === _constants.SDKType.NodeJS) {
+      _utilities.Utilities.updateCache({
+        cacheManager: this.trackingCache,
+        visitorCode,
+        experimentId,
+        variationId
+      });
+    }
     return variationId;
   }
   trackConversion({
@@ -224,6 +238,23 @@ class KameleoonClient {
     }
     return result;
   }
+  getExperimentVariationData(variationId) {
+    if (!this.campaignConfiguration) {
+      throw new _kameleoonError.KameleoonError(_kameleoonError.KameleoonException.Initialization);
+    }
+    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);
+        }
+      }
+    }
+    throw new _kameleoonError.KameleoonError(_kameleoonError.KameleoonException.VariationNotFound);
+  }
   getFeatureFlags() {
     if (!this.campaignConfiguration) {
       throw new _kameleoonError.KameleoonError(_kameleoonError.KameleoonException.Initialization);
@@ -301,6 +332,9 @@ class KameleoonClient {
     }
     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));
@@ -317,8 +351,21 @@ class KameleoonClient {
       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 (variationData.rule) {
+    if (rule) {
       _utilities.Utilities.trackRule({
         visitorCode,
         requester: this.requester,

package/dist/kameleoonClient.js.map

@@ -1 +1 @@
-{"version":3,"file":"kameleoonClient.js","names":["_tsRes","require","_campaignConfiguration","_clientSettings","_constants","_kameleoonData","_kameleoonError","_requester","_storage","_externalStorage","_utilities","_variationConfiguration","ownKeys","object","enumerableOnly","keys","Object","getOwnPropertySymbols","symbols","filter","sym","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","target","i","arguments","length","source","forEach","key","_defineProperty","getOwnPropertyDescriptors","defineProperties","defineProperty","obj","value","_toPropertyKey","configurable","writable","arg","_toPrimitive","String","input","hint","prim","Symbol","toPrimitive","undefined","res","call","TypeError","Number","KameleoonClient","constructor","siteCode","configuration","internalConfiguration","settings","clientSettings","ClientSettings","externalPackageInfo","externalRequestDispatcher","requester","Requester","environment","packageInfo","requestDispatcher","initialize","externalStorage","externalEventSource","externalClientConfiguration","clientDataStorage","ExternalStorage","KameleoonStorageKey","ClientData","variationDataStorage","VariationData","campaignConfiguration","CampaignConfiguration","storage","result","throw","variationConfiguration","VariationConfiguration","experiments","ok","addData","visitorCode","data","Utilities","validateVisitorCode","KameleoonError","KameleoonException","Initialization","addTargetingData","triggerExperiment","experimentId","experiment","find","item","id","ExperimentConfigurationNotFound","targetingData","storedTargetingData","targetingResult","checkTargeting","segment","NotTargeted","dataUrl","getDataUrl","trackingParameters","body","userAgent","getUserAgent","variationId","getAssociatedVariationId","else","error","type","NotAllocated","trackExperiment","UNALLOCATED_VARIATION_ID","isUnallocated","trackConversion","goalId","revenue","Conversion","flushData","trackData","getExperiments","map","name","getVisitorExperiments","isActive","experimentVariations","getAssignedVariations","experimentVariation","variationResult","getExperimentVariation","getFeatureFlags","featureFlags","featureKey","getVisitorFeatureFlags","resultFeatureFlags","featureFlag","variationData","getFeatureFlagVariation","variationKey","OFF_VARIATION_KEY","featureFlagId","getFeatureFlagVariationKey","_getFeatureFlagVariation","getFeatureFlagVariable","variableKey","variable","variations","variables","FeatureFlagConfigurationNotFound","featureVariable","parseFeatureVariable","isFeatureFlagActive","getRemoteData","remoteData","onConfigurationUpdate","callback","Err","withAssignment","rule","trackRule","featureFlagVariation","Ok","exports"],"sources":["../src/kameleoonClient.ts"],"sourcesContent":["import { Err, Ok, Result } from 'ts-res';\nimport { CampaignConfiguration, JSONType } from './campaignConfiguration';\nimport { ClientSettings, ClientSettingsType } from './clientSettings';\nimport { OFF_VARIATION_KEY, UNALLOCATED_VARIATION_ID } from './constants';\nimport { Conversion, KameleoonDataType } from './kameleoonData';\nimport { KameleoonError, KameleoonException } from './kameleoonError';\nimport { Requester, TrackExperimentParamsType } from './requester';\nimport {\n  ClientDataType,\n  KameleoonStorageKey,\n  VariationDataType,\n} from './storage';\nimport { ExternalStorage } from './storage/externalStorage';\nimport {\n  TrackConversionParamsType,\n  ExperimentType,\n  FeatureFlagType,\n  GetFeatureFlagVariableParamsType,\n  FeatureVariableResultType,\n  InternalSDKConfigurationType,\n  SDKCoreParameters,\n} from './types';\nimport { Utilities } from './utilities';\nimport {\n  FeatureFlagVariationType,\n  VariationConfiguration,\n} from './variationConfiguration';\n\n/**\n * @interface an interface of KameleoonClient instance\n */\nexport interface IKameleoonClient {\n  /**\n   * @method initialize - an asynchronous method for KameleoonClient initialization by fetching Kameleoon SDK related data from server or by retrieving data from local source if data is up-to-date or update interval has not been reached\n   * @returns {Promise<boolean>} Promise resolved into boolean field indicating success or fail\n   * @throws `KameleoonError` with one of the following `type` s:\n   *\n   * - `KameleoonException.StorageWrite` Couldn't update storage data\n   * - `KameleoonException.ClientConfiguration` Couldn't retrieve client configuration from Kameleoon Api\n   */\n  initialize: () => Promise<boolean>;\n  /**\n   * @method addData - method for adding targeting data to the storage so that other methods could decide whether the current visitor is targeted or not. Note: userAgent data will not be stored in storage like other data, and it will be sent with every tracking request for bot filtration.\n   * @param {string} visitorCode - unique visitor identification string, can't exceed 255 characters length\n   * @param {KameleoonDataType[]} kameleoonData - number of instances of any type of `KameleoonData`, can be added solely in array or as a sequential arguments\n   * @returns {void}\n   * @throws `KameleoonError` with one of the following `type` s:\n   *\n   * - `KameleoonException.VisitorCodeMaxLength` The visitor code length was exceeded\n   * - `KameleoonException.StorageWrite` Couldn't update storage data\n   * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`\n   */\n  addData: (visitorCode: string, ...data: KameleoonDataType[]) => void;\n  /**\n   * @method triggerExperiment - triggers experiment by assigning the variation to the user with `visitorCode`, if the variation is already assigned just returns it's id. Note: returned id `0` indicates default variation.  At the same time executes `flushData` without sending extra request.\n   * @param {string} visitorCode - unique visitor identification string, can't exceed 255 characters length\n   * @param {number} experimentId - id of experiment running for the current visitor\n   * @returns {number} associated variationId which is successfully searched/assigned\n   * @throws `KameleoonError` with one of the following `type` s:\n   *\n   * - `KameleoonException.ExperimentConfigurationNotFound` No configuration found for provided `experimentId`\n   * - `KameleoonException.VisitorCodeMaxLength` The visitor code length was exceeded\n   * - `KameleoonException.StorageRead` Couldn't find associated experiment by provided `experimentId` and `visitorCode` inside the storage\n   * - `KameleoonException.NotTargeted` Current visitor is not targeted\n   * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`\n   */\n  triggerExperiment: (visitorCode: string, experimentId: number) => number;\n  /**\n   * @method trackConversion - creates and adds `Conversion` data to the visitor with specified parameters and executes `flushData`. Note: it's a helper method for the quick and convenient conversion tracking, however creating and adding `Conversion` manually allows more flexible `Conversion` with `negative` parameter\n   * @param {TrackConversionParamsType} conversionParameters - `visitorCode`, `goalId` and `revenue` parameters for data tracking\n   * @returns {void}\n   * @throws `KameleoonError` with one of the following `type` s:\n   *\n   * - `KameleoonException.VisitorCodeMaxLength` The visitor code length was exceeded\n   * - `KameleoonException.StorageWrite` Couldn't update storage data\n   */\n  trackConversion: ({\n    visitorCode,\n    goalId,\n    revenue,\n  }: TrackConversionParamsType) => void;\n  /**\n   * @method flushData - takes visitor associated kameleoon data and sends the data tracking request with collected data\n   * sent data is removed from `KameleoonClient` instance but not from the storage for correct targeting checks\n   * @param {string} visitorCode - unique visitor identification string, can't exceed 255 characters length\n   * @returns {void}\n   * @throws `KameleoonError` with one of the following `type` s:\n   *\n   * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`\n   */\n  flushData: (visitorCode: string) => void;\n  /**\n   * @method getExperiments - returns a list of experiments stored in the client configuration\n   * @returns {ExperimentType[]} a list of all experiments items with `id` and `name` fields\n   * @throws `KameleoonError` with one of the following `type` s:\n   *\n   * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`\n   */\n  getExperiments: () => ExperimentType[];\n  /**\n   * @method getVisitorExperiments - returns a list of experiments that the visitor with `visitorCode` is targeted by and that are *active* for the visitor (visitor will have one of the variations allocated if the experiment will be triggered).\n   * @param {string} visitorCode - unique visitor identification string, can't exceed 255 characters length\n   * @param {boolean | undefined} isAllocated - boolean value indicating that only experiments *allocated* for visitor will be returned. Default value is `true`\n   * @returns {ExperimentType[]} a list of all experiments items with `id` and `name` fields\n   * @throws `KameleoonError` with one of the following `type` s:\n   *\n   * - `KameleoonException.VisitorCodeMaxLength` - The visitor code length was exceeded\n   * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`\n   */\n  getVisitorExperiments: (\n    visitorCode: string,\n    isAllocated?: boolean,\n  ) => ExperimentType[];\n  /**\n   * @method getFeatureFlags - returns a list of feature flags stored in the client configuration\n   * @returns {FeatureFlagType[]} a list of all feature flags items with `id` and `key` fields\n   * @throws `KameleoonError` with one of the following `type` s:\n   *\n   * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`\n   */\n  getFeatureFlags: () => FeatureFlagType[];\n  /**\n   * @method getVisitorFeatureFlags - returns a list of feature flags that the visitor with `visitorCode` that is targeted by and that are *active* for the visitor (visitor will have one of the variations allocated).\n   * @param {string} visitorCode - unique visitor identification string, can't exceed 255 characters length\n   * @returns {FeatureFlagType[]} a list of all feature flags items with `id` and `key` fields\n   * @throws `KameleoonError` with one of the following `type` s:\n   *\n   * - `KameleoonException.VisitorCodeMaxLength` - The visitor code length was exceeded\n   * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`\n   * - `KameleoonException.NotTargeted` - Current visitor is not targeted\n   */\n  getVisitorFeatureFlags: (visitorCode: string) => FeatureFlagType[];\n  /**\n   * @method isFeatureFlagActive - returns a boolean indicating whether the visitor with `visitorCode` has `featureKey` active for him, this method includes targeting check, finding the according variation exposed to the visitor and saving it to storage along with sending tracking request if the feature rollout rule was of type of `Experimentation`\n   * @param {string} visitorCode - unique visitor identification string, can't exceed 255 characters length\n   * @param {string} featureKey - a unique key for feature flag\n   * @returns {boolean} a boolean indicator of whether the feature flag with `featureKey` is active for visitor with `visitorCode`\n   * @throws `KameleoonError` with one of the following `type` s:\n   *\n   * - `KameleoonException.VisitorCodeMaxLength` - The visitor code length was exceeded\n   * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`\n   * - `KameleoonException.FeatureFlagConfigurationNotFound` - No feature flag was found for provided `visitorCode` and `featureKey`\n   * - `KameleoonException.DataInconsistency` - Allocated variation was found but there is no feature flag with according `featureKey`.\n   * - `KameleoonException.NotTargeted` - Current visitor is not targeted\n   */\n  isFeatureFlagActive: (visitorCode: string, featureKey: string) => boolean;\n  /**\n   * @method getFeatureFlagVariationKey - returns variation key for the visitor under `visitorCode` in the found feature flag, this method includes targeting check, finding the according variation exposed to the visitor and saving it to storage along with sending tracking request if the feature rollout rule was of type of `Experimentation`\n   * @param {string} visitorCode - unique visitor identification string, can't exceed 255 characters length\n   * @param {string} featureKey - a unique key for feature flag\n   * @returns {string} a string containing variable key for the allocated feature flag variation for the provided visitor\n   * @throws `KameleoonError` with one of the following `type` s:\n   *\n   * - `KameleoonException.VisitorCodeMaxLength` - The visitor code length was exceeded\n   * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`\n   * - `KameleoonException.FeatureFlagConfigurationNotFound` - No feature flag was found for provided `visitorCode` and `featureKey`\n   * - `KameleoonException.NotTargeted` - Current visitor is not targeted\n   */\n  getFeatureFlagVariationKey: (\n    visitorCode: string,\n    featureKey: string,\n  ) => string;\n  /**\n   * @method getFeatureFlagVariable - returns a variable for the visitor under `visitorCode` in the found feature flag, this method includes targeting check, finding the according variation exposed to the visitor and saving it to storage along with sending tracking request if the feature rollout rule was of type of `Experimentation`\n   * @param {GetFeatureFlagVariableParamsType} parameters - an object with parameters of a type `GetFeatureFlagVariableParamsType`, see the type for details.\n   * @returns {FeatureVariableResultType} a variable object containing `type` and `value` fields, `type` can be checked against `FeatureVariableType` enum, if the `type` is `FeatureVariableType.BOOLEAN` then the `value` type will be `boolean` and so on.\n   * @throws `KameleoonError` with one of the following `type` s:\n   *\n   * - `KameleoonException.VisitorCodeMaxLength` - The visitor code length was exceeded\n   * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`\n   * - `KameleoonException.FeatureFlagConfigurationNotFound` - No feature flag was found for provided `visitorCode` and `featureKey`\n   * - `KameleoonException.NotTargeted` - Current visitor is not targeted\n   * - `KameleoonException.JSONParse` - Couldn't pass JSON value\n   * - `KameleoonException.NumberParse` - Couldn't pass Number value\n   */\n  getFeatureFlagVariable: ({\n    visitorCode,\n    featureKey,\n    variableKey,\n  }: GetFeatureFlagVariableParamsType) => FeatureVariableResultType;\n  /**\n   * @method getRemoteData - returns a data which is stored for specified siteCode on a remote Kameleoon server.\n   * @param {string} key - unique key that the data you try to get is associated with.\n   * @returns {JSONType} - promise with retrieving data for specific key.\n   * @throws `KameleoonError` with one of the following `type` s:\n   *\n   * - `KameleoonException.RemoteData` - Couldn't retrieve data from Kameleoon server\n   */\n  getRemoteData: (key: string) => Promise<JSONType>;\n  /**\n   * @method onConfigurationUpdate - fires a callback on client configuration update. Note: this method only works for server sent events of real time update.\n   * @param {() => void} callback - callback function with no parameters that will be called upon configuration update\n   * @returns {void}\n   * @throws `KameleoonError` with one of the following `type` s:\n   *\n   * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`\n   */\n  onConfigurationUpdate: (callback: () => void) => void;\n}\n\n/**\n * @class\n * KameleoonClient - a class for creating kameleoon client instance\n * for communicating with Kameleoon JavaScript SDK Core, when new instance is created\n */\nexport class KameleoonClient implements IKameleoonClient {\n  private internalConfiguration: InternalSDKConfigurationType;\n  private variationConfiguration?: VariationConfiguration;\n  private campaignConfiguration?: CampaignConfiguration;\n  private settings: ClientSettingsType;\n  private requester: Requester;\n\n  /**\n   * @param {SDKCoreParameters} sdkCoreParameters - parameters for initializing sdk core\n   */\n  constructor({\n    siteCode,\n    configuration,\n    internalConfiguration,\n  }: SDKCoreParameters) {\n    const { settings: clientSettings } = new ClientSettings(\n      siteCode,\n      configuration,\n    );\n    const { externalPackageInfo, externalRequestDispatcher } =\n      internalConfiguration;\n    const requester = new Requester({\n      siteCode,\n      environment: clientSettings.environment,\n      packageInfo: externalPackageInfo,\n      requestDispatcher: externalRequestDispatcher,\n    });\n\n    this.requester = requester;\n    this.settings = clientSettings;\n    this.internalConfiguration = internalConfiguration;\n  }\n\n  public async initialize(): Promise<boolean> {\n    const { externalStorage, externalEventSource, externalClientConfiguration } =\n      this.internalConfiguration;\n\n    const clientDataStorage = new ExternalStorage<ClientDataType>(\n      externalStorage.initialize(KameleoonStorageKey.ClientData),\n    );\n    const variationDataStorage = new ExternalStorage<VariationDataType>(\n      externalStorage.initialize(KameleoonStorageKey.VariationData),\n    );\n\n    const campaignConfiguration = new CampaignConfiguration({\n      settings: this.settings,\n      storage: clientDataStorage,\n      requester: this.requester,\n      externalClientConfiguration,\n    });\n\n    const result = await campaignConfiguration.initialize(externalEventSource);\n    result.throw();\n\n    const variationConfiguration = new VariationConfiguration(\n      campaignConfiguration.experiments,\n      variationDataStorage,\n    );\n\n    this.variationConfiguration = variationConfiguration;\n    this.campaignConfiguration = campaignConfiguration;\n\n    return result.ok;\n  }\n\n  public addData(visitorCode: string, ...data: KameleoonDataType[]): void {\n    Utilities.validateVisitorCode(visitorCode).throw();\n\n    if (!this.campaignConfiguration) {\n      throw new KameleoonError(KameleoonException.Initialization);\n    }\n\n    this.campaignConfiguration.addTargetingData(visitorCode, ...data).throw();\n  }\n\n  public triggerExperiment(visitorCode: string, experimentId: number): number {\n    Utilities.validateVisitorCode(visitorCode).throw();\n\n    if (!this.campaignConfiguration || !this.variationConfiguration) {\n      throw new KameleoonError(KameleoonException.Initialization);\n    }\n\n    const experiment = this.campaignConfiguration.experiments.find(\n      (item) => item.id === String(experimentId),\n    );\n\n    if (!experiment) {\n      throw new KameleoonError(\n        KameleoonException.ExperimentConfigurationNotFound,\n        experimentId,\n        visitorCode,\n      );\n    }\n\n    const targetingData =\n      this.campaignConfiguration.storedTargetingData[visitorCode];\n\n    const targetingResult = Utilities.checkTargeting({\n      visitorCode,\n      experimentId,\n      targetingData,\n      segment: experiment.segment,\n      variationConfiguration: this.variationConfiguration,\n    }).throw();\n\n    if (!targetingResult) {\n      throw new KameleoonError(KameleoonException.NotTargeted, visitorCode);\n    }\n\n    const dataUrl = Utilities.getDataUrl(\n      visitorCode,\n      this.campaignConfiguration,\n    );\n\n    const trackingParameters: Omit<\n      TrackExperimentParamsType,\n      'variationId' | 'isUnallocated'\n    > = {\n      body: dataUrl,\n      visitorCode,\n      experimentId,\n    };\n\n    const userAgent = Utilities.getUserAgent(\n      visitorCode,\n      this.campaignConfiguration,\n    );\n\n    const variationId = this.variationConfiguration\n      .getAssociatedVariationId(visitorCode, experimentId)\n      .else((error) => {\n        if (error.type === KameleoonException.NotAllocated) {\n          this.requester.trackExperiment({\n            variationId: UNALLOCATED_VARIATION_ID,\n            isUnallocated: true,\n            userAgent,\n            ...trackingParameters,\n          });\n\n          return UNALLOCATED_VARIATION_ID;\n        }\n\n        throw error;\n      });\n\n    this.requester.trackExperiment({\n      variationId,\n      isUnallocated: false,\n      userAgent,\n      ...trackingParameters,\n    });\n\n    return variationId;\n  }\n\n  public trackConversion({\n    visitorCode,\n    goalId,\n    revenue,\n  }: TrackConversionParamsType): void {\n    this.addData(visitorCode, new Conversion({ goalId, revenue }));\n    this.flushData(visitorCode);\n  }\n\n  public flushData(visitorCode: string): void {\n    if (!this.campaignConfiguration) {\n      throw new KameleoonError(KameleoonException.Initialization);\n    }\n\n    const dataUrl = Utilities.getDataUrl(\n      visitorCode,\n      this.campaignConfiguration,\n    );\n\n    const userAgent = Utilities.getUserAgent(\n      visitorCode,\n      this.campaignConfiguration,\n    );\n\n    this.requester.trackData({ visitorCode, body: dataUrl, userAgent });\n  }\n\n  public getExperiments(): ExperimentType[] {\n    if (!this.campaignConfiguration) {\n      throw new KameleoonError(KameleoonException.Initialization);\n    }\n\n    return this.campaignConfiguration.experiments.map(({ id, name }) => ({\n      id: Number(id),\n      name,\n    }));\n  }\n\n  public getVisitorExperiments(\n    visitorCode: string,\n    isActive = true,\n  ): ExperimentType[] {\n    if (!this.variationConfiguration || !this.campaignConfiguration) {\n      throw new KameleoonError(KameleoonException.Initialization);\n    }\n\n    Utilities.validateVisitorCode(visitorCode).throw();\n\n    const experiments = this.campaignConfiguration.experiments;\n    const result: ExperimentType[] = [];\n\n    const targetingData =\n      this.campaignConfiguration.storedTargetingData[visitorCode];\n\n    for (const experiment of experiments) {\n      const { id, name, segment } = experiment;\n\n      const targetingResult = Utilities.checkTargeting({\n        targetingData,\n        visitorCode,\n        segment,\n        variationConfiguration: this.variationConfiguration,\n        experimentId: Number(id),\n      }).throw();\n\n      if (!targetingResult) {\n        continue;\n      }\n\n      // -- If `isActive=false` then return every experiment\n      if (!isActive) {\n        result.push({ id: Number(id), name });\n        continue;\n      }\n\n      // -- Else first check if there are saved variations for the experiment\n      // if there is at least one than it's active\n      const experimentVariations =\n        this.variationConfiguration.getAssignedVariations(visitorCode);\n\n      if (experimentVariations.ok) {\n        const experimentVariation = experimentVariations.data[experiment.id];\n\n        if (experimentVariation) {\n          result.push({ id: Number(id), name });\n          continue;\n        }\n      }\n\n      // -- Second check if the experiment will have an allocated variation upon triggering\n      // if yes than it's active\n      const variationResult =\n        this.variationConfiguration.getExperimentVariation(\n          visitorCode,\n          experiment,\n        );\n\n      if (variationResult.ok) {\n        result.push({ id: Number(id), name });\n      }\n    }\n\n    return result;\n  }\n\n  public getFeatureFlags(): FeatureFlagType[] {\n    if (!this.campaignConfiguration) {\n      throw new KameleoonError(KameleoonException.Initialization);\n    }\n\n    return this.campaignConfiguration.featureFlags.map(\n      ({ id, featureKey }) => ({ id, key: featureKey }),\n    );\n  }\n\n  public getVisitorFeatureFlags(visitorCode: string): FeatureFlagType[] {\n    if (!this.variationConfiguration || !this.campaignConfiguration) {\n      throw new KameleoonError(KameleoonException.Initialization);\n    }\n\n    const featureFlags = this.campaignConfiguration.featureFlags;\n    const resultFeatureFlags: FeatureFlagType[] = [];\n\n    const targetingData =\n      this.campaignConfiguration.storedTargetingData[visitorCode];\n\n    for (const featureFlag of featureFlags) {\n      const variationData = this.variationConfiguration\n        .getFeatureFlagVariation({\n          visitorCode,\n          targetingData,\n          featureFlag,\n        })\n        .throw();\n\n      if (variationData.variationKey !== OFF_VARIATION_KEY) {\n        const { featureFlagId, featureKey } = variationData;\n\n        resultFeatureFlags.push({ id: featureFlagId, key: featureKey });\n      }\n    }\n\n    return resultFeatureFlags;\n  }\n\n  public getFeatureFlagVariationKey(\n    visitorCode: string,\n    featureKey: string,\n  ): string {\n    const { variationKey } = this._getFeatureFlagVariation(\n      visitorCode,\n      featureKey,\n    ).throw();\n\n    return variationKey;\n  }\n\n  public getFeatureFlagVariable({\n    visitorCode,\n    featureKey,\n    variableKey,\n  }: GetFeatureFlagVariableParamsType): FeatureVariableResultType {\n    const { variationKey } = this._getFeatureFlagVariation(\n      visitorCode,\n      featureKey,\n    ).throw();\n\n    // --- Note ---\n    // `_getFeatureFlagVariation` already checks `campaignConfiguration` initialization\n    const featureFlags = (this.campaignConfiguration as CampaignConfiguration)\n      .featureFlags;\n\n    const variable = featureFlags\n      .find((item) => item.featureKey === featureKey)\n      ?.variations.find((item) => item.key === variationKey)\n      ?.variables.find((item) => item.key === variableKey);\n\n    if (!variable) {\n      throw new KameleoonError(\n        KameleoonException.FeatureFlagConfigurationNotFound,\n        featureKey,\n        visitorCode,\n      );\n    }\n\n    const featureVariable = Utilities.parseFeatureVariable(variable).throw();\n\n    return featureVariable;\n  }\n\n  public isFeatureFlagActive(visitorCode: string, featureKey: string): boolean {\n    const variationKey = this.getFeatureFlagVariationKey(\n      visitorCode,\n      featureKey,\n    );\n\n    return variationKey !== OFF_VARIATION_KEY;\n  }\n\n  public async getRemoteData(key: string): Promise<JSONType> {\n    const remoteData = await this.requester.getRemoteData(key);\n\n    return remoteData.throw();\n  }\n\n  public onConfigurationUpdate(callback: () => void): void {\n    if (!this.campaignConfiguration) {\n      throw new KameleoonError(KameleoonException.Initialization);\n    }\n\n    this.campaignConfiguration.onConfigurationUpdate(callback);\n  }\n\n  private _getFeatureFlagVariation(\n    visitorCode: string,\n    featureKey: string,\n  ): Result<FeatureFlagVariationType, KameleoonError> {\n    if (!this.variationConfiguration || !this.campaignConfiguration) {\n      return Err(new KameleoonError(KameleoonException.Initialization));\n    }\n\n    const featureFlags = this.campaignConfiguration.featureFlags;\n    const featureFlag = featureFlags.find(\n      (item) => item.featureKey === featureKey,\n    );\n\n    if (!featureFlag) {\n      return Err(\n        new KameleoonError(\n          KameleoonException.FeatureFlagConfigurationNotFound,\n          featureKey,\n          visitorCode,\n        ),\n      );\n    }\n\n    const targetingData =\n      this.campaignConfiguration.storedTargetingData[visitorCode];\n\n    const variationData = this.variationConfiguration\n      .getFeatureFlagVariation({\n        visitorCode,\n        featureFlag,\n        targetingData,\n        withAssignment: true,\n      })\n      .throw();\n\n    const userAgent = Utilities.getUserAgent(\n      visitorCode,\n      this.campaignConfiguration,\n    );\n\n    if (variationData.rule) {\n      Utilities.trackRule({\n        visitorCode,\n        requester: this.requester,\n        featureFlagVariation: variationData,\n        campaignConfiguration: this.campaignConfiguration,\n        userAgent,\n      });\n    }\n\n    return Ok(variationData);\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"kameleoonClient.js","names":["_tsRes","require","_cacheManager","_campaignConfiguration","_clientSettings","_constants","_kameleoonData","_kameleoonError","_requester","_storage","_externalStorage","_utilities","_variationConfiguration","ownKeys","object","enumerableOnly","keys","Object","getOwnPropertySymbols","symbols","filter","sym","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","target","i","arguments","length","source","forEach","key","_defineProperty","getOwnPropertyDescriptors","defineProperties","defineProperty","obj","value","_toPropertyKey","configurable","writable","arg","_toPrimitive","String","input","hint","prim","Symbol","toPrimitive","undefined","res","call","TypeError","Number","KameleoonClient","constructor","siteCode","configuration","internalConfiguration","settings","clientSettings","ClientSettings","externalPackageInfo","externalRequestDispatcher","requester","Requester","environment","packageInfo","requestDispatcher","trackingCache","CacheManager","CACHE_CLEANUP_TIMEOUT","initialize","externalStorage","externalEventSource","externalClientConfiguration","targetingDataCleanupInterval","clientDataStorage","ExternalStorage","KameleoonStorageKey","ClientData","variationDataStorage","VariationData","campaignConfiguration","CampaignConfiguration","storage","targetingCleanupInterval","result","throw","variationConfiguration","VariationConfiguration","experiments","ok","addData","visitorCode","data","Utilities","validateVisitorCode","KameleoonError","KameleoonException","Initialization","addTargetingData","triggerExperiment","experimentId","experiment","find","item","id","ExperimentConfigurationNotFound","targetingData","storedTargetingData","targetingResult","checkTargeting","segment","NotTargeted","dataUrl","getDataUrl","trackingParameters","body","userAgent","getUserAgent","variationId","getAssociatedVariationId","else","error","type","NotAllocated","trackExperiment","UNALLOCATED_VARIATION_ID","isUnallocated","SDKType","NodeJS","updateCache","cacheManager","trackConversion","goalId","revenue","Conversion","flushData","trackData","getExperiments","map","name","getVisitorExperiments","isActive","experimentVariations","getAssignedVariations","experimentVariation","variationResult","getExperimentVariation","getExperimentVariationData","variation","variations","JSON","parse","customJson","err","JSONParse","VariationNotFound","getFeatureFlags","featureFlags","featureKey","getVisitorFeatureFlags","resultFeatureFlags","featureFlag","variationData","getFeatureFlagVariation","variationKey","OFF_VARIATION_KEY","featureFlagId","getFeatureFlagVariationKey","_getFeatureFlagVariation","getFeatureFlagVariable","variableKey","variable","variables","FeatureFlagConfigurationNotFound","featureVariable","parseFeatureVariable","isFeatureFlagActive","getRemoteData","remoteData","onConfigurationUpdate","callback","_getEngineTrackingCode","getTrackingCode","Err","withAssignment","rule","trackRule","featureFlagVariation","Ok","exports"],"sources":["../src/kameleoonClient.ts"],"sourcesContent":["import { Err, Ok, Result } from 'ts-res';\nimport { CacheManager } from './cacheManager';\nimport { CampaignConfiguration, JSONType } from './campaignConfiguration';\nimport { ClientSettings, ClientSettingsType } from './clientSettings';\nimport {\n  CACHE_CLEANUP_TIMEOUT,\n  OFF_VARIATION_KEY,\n  SDKType,\n  UNALLOCATED_VARIATION_ID,\n} from './constants';\nimport { Conversion, KameleoonDataType } from './kameleoonData';\nimport { KameleoonError, KameleoonException } from './kameleoonError';\nimport { Requester, TrackExperimentParamsType } from './requester';\nimport {\n  ClientDataType,\n  KameleoonStorageKey,\n  VariationDataType,\n} from './storage';\nimport { ExternalStorage } from './storage/externalStorage';\nimport {\n  TrackConversionParamsType,\n  ExperimentType,\n  FeatureFlagType,\n  GetFeatureFlagVariableParamsType,\n  FeatureVariableResultType,\n  InternalSDKConfigurationType,\n  SDKCoreParameters,\n  TrackingCacheItemType,\n} from './types';\nimport { Utilities } from './utilities';\nimport {\n  FeatureFlagVariationType,\n  VariationConfiguration,\n} from './variationConfiguration';\n\n/**\n * @interface an interface of KameleoonClient instance\n */\nexport interface IKameleoonClient {\n  /**\n   * @method initialize - an asynchronous method for KameleoonClient initialization by fetching Kameleoon SDK related data from server or by retrieving data from local source if data is up-to-date or update interval has not been reached\n   * @returns {Promise<boolean>} Promise resolved into boolean field indicating success or fail\n   * @throws `KameleoonError` with one of the following `type` s:\n   *\n   * - `KameleoonException.StorageWrite` Couldn't update storage data\n   * - `KameleoonException.ClientConfiguration` Couldn't retrieve client configuration from Kameleoon Api\n   */\n  initialize: () => Promise<boolean>;\n  /**\n   * @method addData - method for adding targeting data to the storage so that other methods could decide whether the current visitor is targeted or not. Note: userAgent data will not be stored in storage like other data, and it will be sent with every tracking request for bot filtration.\n   * @param {string} visitorCode - unique visitor identification string, can't exceed 255 characters length\n   * @param {KameleoonDataType[]} kameleoonData - number of instances of any type of `KameleoonData`, can be added solely in array or as a sequential arguments\n   * @returns {void}\n   * @throws `KameleoonError` with one of the following `type` s:\n   *\n   * - `KameleoonException.VisitorCodeMaxLength` The visitor code length was exceeded\n   * - `KameleoonException.StorageWrite` Couldn't update storage data\n   * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`\n   */\n  addData: (visitorCode: string, ...data: KameleoonDataType[]) => void;\n  /**\n   * @method triggerExperiment - triggers experiment by assigning the variation to the user with `visitorCode`, if the variation is already assigned just returns it's id. Note: returned id `0` indicates default variation.  At the same time executes `flushData` without sending extra request.\n   * @param {string} visitorCode - unique visitor identification string, can't exceed 255 characters length\n   * @param {number} experimentId - id of experiment running for the current visitor\n   * @returns {number} associated variationId which is successfully searched/assigned\n   * @throws `KameleoonError` with one of the following `type` s:\n   *\n   * - `KameleoonException.ExperimentConfigurationNotFound` No configuration found for provided `experimentId`\n   * - `KameleoonException.VisitorCodeMaxLength` The visitor code length was exceeded\n   * - `KameleoonException.StorageRead` Couldn't find associated experiment by provided `experimentId` and `visitorCode` inside the storage\n   * - `KameleoonException.NotTargeted` Current visitor is not targeted\n   * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`\n   */\n  triggerExperiment: (visitorCode: string, experimentId: number) => number;\n  /**\n   * @method trackConversion - creates and adds `Conversion` data to the visitor with specified parameters and executes `flushData`. Note: it's a helper method for the quick and convenient conversion tracking, however creating and adding `Conversion` manually allows more flexible `Conversion` with `negative` parameter\n   * @param {TrackConversionParamsType} conversionParameters - `visitorCode`, `goalId` and `revenue` parameters for data tracking\n   * @returns {void}\n   * @throws `KameleoonError` with one of the following `type` s:\n   *\n   * - `KameleoonException.VisitorCodeMaxLength` The visitor code length was exceeded\n   * - `KameleoonException.StorageWrite` Couldn't update storage data\n   */\n  trackConversion: ({\n    visitorCode,\n    goalId,\n    revenue,\n  }: TrackConversionParamsType) => void;\n  /**\n   * @method flushData - takes visitor associated kameleoon data and sends the data tracking request with collected data\n   * sent data is removed from `KameleoonClient` instance but not from the storage for correct targeting checks\n   * @param {string} visitorCode - unique visitor identification string, can't exceed 255 characters length\n   * @returns {void}\n   * @throws `KameleoonError` with one of the following `type` s:\n   *\n   * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`\n   */\n  flushData: (visitorCode: string) => void;\n  /**\n   * @method getExperiments - returns a list of experiments stored in the client configuration\n   * @returns {ExperimentType[]} a list of all experiments items with `id` and `name` fields\n   * @throws `KameleoonError` with one of the following `type` s:\n   *\n   * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`\n   */\n  getExperiments: () => ExperimentType[];\n  /**\n   * @method getVisitorExperiments - returns a list of experiments that the visitor with `visitorCode` is targeted by and that are *active* for the visitor (visitor will have one of the variations allocated if the experiment will be triggered).\n   * @param {string} visitorCode - unique visitor identification string, can't exceed 255 characters length\n   * @param {boolean | undefined} isAllocated - boolean value indicating that only experiments *allocated* for visitor will be returned. Default value is `true`\n   * @returns {ExperimentType[]} a list of all experiments items with `id` and `name` fields\n   * @throws `KameleoonError` with one of the following `type` s:\n   *\n   * - `KameleoonException.VisitorCodeMaxLength` - The visitor code length was exceeded\n   * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`\n   */\n  getVisitorExperiments: (\n    visitorCode: string,\n    isAllocated?: boolean,\n  ) => ExperimentType[];\n  /**\n   * @method getExperimentVariationData - returns variation data in JSON format for the variation with `variationId`\n   * @param {number} variationId - id of variation\n   * @returns {JSONType} variation data in JSON format\n   * @throws `KameleoonError` with one of the following `type` s:\n   * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`\n   * - `KameleoonException.JSONParse` - Couldn't pass JSON value\n   * - `KameleoonException.VariationNotFound` - No variation found for provided `variationId`\n   */\n  getExperimentVariationData: (variationId: number) => JSONType | null;\n  /**\n   * @method getFeatureFlags - returns a list of feature flags stored in the client configuration\n   * @returns {FeatureFlagType[]} a list of all feature flags items with `id` and `key` fields\n   * @throws `KameleoonError` with one of the following `type` s:\n   *\n   * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`\n   */\n  getFeatureFlags: () => FeatureFlagType[];\n  /**\n   * @method getVisitorFeatureFlags - returns a list of feature flags that the visitor with `visitorCode` that is targeted by and that are *active* for the visitor (visitor will have one of the variations allocated).\n   * @param {string} visitorCode - unique visitor identification string, can't exceed 255 characters length\n   * @returns {FeatureFlagType[]} a list of all feature flags items with `id` and `key` fields\n   * @throws `KameleoonError` with one of the following `type` s:\n   *\n   * - `KameleoonException.VisitorCodeMaxLength` - The visitor code length was exceeded\n   * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`\n   * - `KameleoonException.NotTargeted` - Current visitor is not targeted\n   */\n  getVisitorFeatureFlags: (visitorCode: string) => FeatureFlagType[];\n  /**\n   * @method isFeatureFlagActive - returns a boolean indicating whether the visitor with `visitorCode` has `featureKey` active for him, this method includes targeting check, finding the according variation exposed to the visitor and saving it to storage along with sending tracking request\n   * @param {string} visitorCode - unique visitor identification string, can't exceed 255 characters length\n   * @param {string} featureKey - a unique key for feature flag\n   * @returns {boolean} a boolean indicator of whether the feature flag with `featureKey` is active for visitor with `visitorCode`\n   * @throws `KameleoonError` with one of the following `type` s:\n   *\n   * - `KameleoonException.VisitorCodeMaxLength` - The visitor code length was exceeded\n   * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`\n   * - `KameleoonException.FeatureFlagConfigurationNotFound` - No feature flag was found for provided `visitorCode` and `featureKey`\n   * - `KameleoonException.DataInconsistency` - Allocated variation was found but there is no feature flag with according `featureKey`.\n   * - `KameleoonException.NotTargeted` - Current visitor is not targeted\n   */\n  isFeatureFlagActive: (visitorCode: string, featureKey: string) => boolean;\n  /**\n   * @method getFeatureFlagVariationKey - returns variation key for the visitor under `visitorCode` in the found feature flag, this method includes targeting check, finding the according variation exposed to the visitor and saving it to storage along with sending tracking request\n   * @param {string} visitorCode - unique visitor identification string, can't exceed 255 characters length\n   * @param {string} featureKey - a unique key for feature flag\n   * @returns {string} a string containing variable key for the allocated feature flag variation for the provided visitor\n   * @throws `KameleoonError` with one of the following `type` s:\n   *\n   * - `KameleoonException.VisitorCodeMaxLength` - The visitor code length was exceeded\n   * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`\n   * - `KameleoonException.FeatureFlagConfigurationNotFound` - No feature flag was found for provided `visitorCode` and `featureKey`\n   * - `KameleoonException.NotTargeted` - Current visitor is not targeted\n   */\n  getFeatureFlagVariationKey: (\n    visitorCode: string,\n    featureKey: string,\n  ) => string;\n  /**\n   * @method getFeatureFlagVariable - returns a variable for the visitor under `visitorCode` in the found feature flag, this method includes targeting check, finding the according variation exposed to the visitor and saving it to storage along with sending tracking request\n   * @param {GetFeatureFlagVariableParamsType} parameters - an object with parameters of a type `GetFeatureFlagVariableParamsType`, see the type for details.\n   * @returns {FeatureVariableResultType} a variable object containing `type` and `value` fields, `type` can be checked against `FeatureVariableType` enum, if the `type` is `FeatureVariableType.BOOLEAN` then the `value` type will be `boolean` and so on.\n   * @throws `KameleoonError` with one of the following `type` s:\n   *\n   * - `KameleoonException.VisitorCodeMaxLength` - The visitor code length was exceeded\n   * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`\n   * - `KameleoonException.FeatureFlagConfigurationNotFound` - No feature flag was found for provided `visitorCode` and `featureKey`\n   * - `KameleoonException.NotTargeted` - Current visitor is not targeted\n   * - `KameleoonException.JSONParse` - Couldn't pass JSON value\n   * - `KameleoonException.NumberParse` - Couldn't pass Number value\n   */\n  getFeatureFlagVariable: ({\n    visitorCode,\n    featureKey,\n    variableKey,\n  }: GetFeatureFlagVariableParamsType) => FeatureVariableResultType;\n  /**\n   * @method getRemoteData - returns a data which is stored for specified siteCode on a remote Kameleoon server.\n   * @param {string} key - unique key that the data you try to get is associated with.\n   * @returns {JSONType} - promise with retrieving data for specific key.\n   * @throws `KameleoonError` with one of the following `type` s:\n   *\n   * - `KameleoonException.RemoteData` - Couldn't retrieve data from Kameleoon server\n   */\n  getRemoteData: (key: string) => Promise<JSONType>;\n  /**\n   * @method onConfigurationUpdate - fires a callback on client configuration update. Note: this method only works for server sent events of real time update.\n   * @param {() => void} callback - callback function with no parameters that will be called upon configuration update\n   * @returns {void}\n   * @throws `KameleoonError` with one of the following `type` s:\n   *\n   * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`\n   */\n  onConfigurationUpdate: (callback: () => void) => void;\n}\n\n/**\n * @class\n * KameleoonClient - a class for creating kameleoon client instance\n * for communicating with Kameleoon JavaScript SDK Core, when new instance is created\n */\nexport class KameleoonClient implements IKameleoonClient {\n  private internalConfiguration: InternalSDKConfigurationType;\n  private variationConfiguration?: VariationConfiguration;\n  private campaignConfiguration?: CampaignConfiguration;\n  private settings: ClientSettingsType;\n  private trackingCache: CacheManager<TrackingCacheItemType>;\n  private requester: Requester;\n\n  /**\n   * @param {SDKCoreParameters} sdkCoreParameters - parameters for initializing sdk core\n   */\n  constructor({\n    siteCode,\n    configuration,\n    internalConfiguration,\n  }: SDKCoreParameters) {\n    const { settings: clientSettings } = new ClientSettings(\n      siteCode,\n      configuration,\n    );\n    const { externalPackageInfo, externalRequestDispatcher } =\n      internalConfiguration;\n    const requester = new Requester({\n      siteCode,\n      environment: clientSettings.environment,\n      packageInfo: externalPackageInfo,\n      requestDispatcher: externalRequestDispatcher,\n    });\n    const trackingCache = new CacheManager<TrackingCacheItemType>(\n      CACHE_CLEANUP_TIMEOUT,\n    );\n\n    this.requester = requester;\n    this.settings = clientSettings;\n    this.trackingCache = trackingCache;\n    this.internalConfiguration = internalConfiguration;\n  }\n\n  public async initialize(): Promise<boolean> {\n    const {\n      externalStorage,\n      externalEventSource,\n      externalClientConfiguration,\n      targetingDataCleanupInterval,\n    } = this.internalConfiguration;\n\n    const clientDataStorage = new ExternalStorage<ClientDataType>(\n      externalStorage.initialize(KameleoonStorageKey.ClientData),\n    );\n    const variationDataStorage = new ExternalStorage<VariationDataType>(\n      externalStorage.initialize(KameleoonStorageKey.VariationData),\n    );\n\n    const campaignConfiguration = new CampaignConfiguration({\n      settings: this.settings,\n      storage: clientDataStorage,\n      requester: this.requester,\n      externalClientConfiguration,\n      targetingCleanupInterval: targetingDataCleanupInterval,\n    });\n\n    const result = await campaignConfiguration.initialize(externalEventSource);\n    result.throw();\n\n    const variationConfiguration = new VariationConfiguration(\n      campaignConfiguration.experiments,\n      variationDataStorage,\n    );\n\n    this.variationConfiguration = variationConfiguration;\n    this.campaignConfiguration = campaignConfiguration;\n\n    return result.ok;\n  }\n\n  public addData(visitorCode: string, ...data: KameleoonDataType[]): void {\n    Utilities.validateVisitorCode(visitorCode).throw();\n\n    if (!this.campaignConfiguration) {\n      throw new KameleoonError(KameleoonException.Initialization);\n    }\n\n    this.campaignConfiguration.addTargetingData(visitorCode, ...data).throw();\n  }\n\n  public triggerExperiment(visitorCode: string, experimentId: number): number {\n    Utilities.validateVisitorCode(visitorCode).throw();\n\n    if (!this.campaignConfiguration || !this.variationConfiguration) {\n      throw new KameleoonError(KameleoonException.Initialization);\n    }\n\n    const experiment = this.campaignConfiguration.experiments.find(\n      (item) => item.id === String(experimentId),\n    );\n\n    if (!experiment) {\n      throw new KameleoonError(\n        KameleoonException.ExperimentConfigurationNotFound,\n        experimentId,\n        visitorCode,\n      );\n    }\n\n    const targetingData =\n      this.campaignConfiguration.storedTargetingData[visitorCode];\n\n    const targetingResult = Utilities.checkTargeting({\n      visitorCode,\n      experimentId,\n      targetingData,\n      segment: experiment.segment,\n      variationConfiguration: this.variationConfiguration,\n    }).throw();\n\n    if (!targetingResult) {\n      throw new KameleoonError(KameleoonException.NotTargeted, visitorCode);\n    }\n\n    const dataUrl = Utilities.getDataUrl(\n      visitorCode,\n      this.campaignConfiguration,\n    );\n\n    const trackingParameters: Omit<\n      TrackExperimentParamsType,\n      'variationId' | 'isUnallocated'\n    > = {\n      body: dataUrl,\n      visitorCode,\n      experimentId,\n    };\n\n    const userAgent = Utilities.getUserAgent(\n      visitorCode,\n      this.campaignConfiguration,\n    );\n\n    const variationId = this.variationConfiguration\n      .getAssociatedVariationId(visitorCode, experimentId)\n      .else((error) => {\n        if (error.type === KameleoonException.NotAllocated) {\n          this.requester.trackExperiment({\n            variationId: UNALLOCATED_VARIATION_ID,\n            isUnallocated: true,\n            userAgent,\n            ...trackingParameters,\n          });\n\n          return UNALLOCATED_VARIATION_ID;\n        }\n\n        throw error;\n      });\n\n    this.requester.trackExperiment({\n      variationId,\n      isUnallocated: false,\n      userAgent,\n      ...trackingParameters,\n    });\n\n    if (\n      this.internalConfiguration.externalPackageInfo.type === SDKType.NodeJS\n    ) {\n      Utilities.updateCache({\n        cacheManager: this.trackingCache,\n        visitorCode,\n        experimentId,\n        variationId,\n      });\n    }\n\n    return variationId;\n  }\n\n  public trackConversion({\n    visitorCode,\n    goalId,\n    revenue,\n  }: TrackConversionParamsType): void {\n    this.addData(visitorCode, new Conversion({ goalId, revenue }));\n    this.flushData(visitorCode);\n  }\n\n  public flushData(visitorCode: string): void {\n    if (!this.campaignConfiguration) {\n      throw new KameleoonError(KameleoonException.Initialization);\n    }\n\n    const dataUrl = Utilities.getDataUrl(\n      visitorCode,\n      this.campaignConfiguration,\n    );\n\n    const userAgent = Utilities.getUserAgent(\n      visitorCode,\n      this.campaignConfiguration,\n    );\n\n    this.requester.trackData({ visitorCode, body: dataUrl, userAgent });\n  }\n\n  public getExperiments(): ExperimentType[] {\n    if (!this.campaignConfiguration) {\n      throw new KameleoonError(KameleoonException.Initialization);\n    }\n\n    return this.campaignConfiguration.experiments.map(({ id, name }) => ({\n      id: Number(id),\n      name,\n    }));\n  }\n\n  public getVisitorExperiments(\n    visitorCode: string,\n    isActive = true,\n  ): ExperimentType[] {\n    if (!this.variationConfiguration || !this.campaignConfiguration) {\n      throw new KameleoonError(KameleoonException.Initialization);\n    }\n\n    Utilities.validateVisitorCode(visitorCode).throw();\n\n    const experiments = this.campaignConfiguration.experiments;\n    const result: ExperimentType[] = [];\n\n    const targetingData =\n      this.campaignConfiguration.storedTargetingData[visitorCode];\n\n    for (const experiment of experiments) {\n      const { id, name, segment } = experiment;\n\n      const targetingResult = Utilities.checkTargeting({\n        targetingData,\n        visitorCode,\n        segment,\n        variationConfiguration: this.variationConfiguration,\n        experimentId: Number(id),\n      }).throw();\n\n      if (!targetingResult) {\n        continue;\n      }\n\n      // -- If `isActive=false` then return every experiment\n      if (!isActive) {\n        result.push({ id: Number(id), name });\n        continue;\n      }\n\n      // -- Else first check if there are saved variations for the experiment\n      // if there is at least one than it's active\n      const experimentVariations =\n        this.variationConfiguration.getAssignedVariations(visitorCode);\n\n      if (experimentVariations.ok) {\n        const experimentVariation = experimentVariations.data[experiment.id];\n\n        if (experimentVariation) {\n          result.push({ id: Number(id), name });\n          continue;\n        }\n      }\n\n      // -- Second check if the experiment will have an allocated variation upon triggering\n      // if yes than it's active\n      const variationResult =\n        this.variationConfiguration.getExperimentVariation(\n          visitorCode,\n          experiment,\n        );\n\n      if (variationResult.ok) {\n        result.push({ id: Number(id), name });\n      }\n    }\n\n    return result;\n  }\n\n  public getExperimentVariationData(variationId: number): JSONType {\n    if (!this.campaignConfiguration) {\n      throw new KameleoonError(KameleoonException.Initialization);\n    }\n\n    const experiments = this.campaignConfiguration.experiments;\n\n    for (const experiment of experiments) {\n      const variation = experiment.variations.find(\n        (item) => item.id === String(variationId),\n      );\n\n      if (variation) {\n        try {\n          return JSON.parse(variation.customJson);\n        } catch (err) {\n          throw new KameleoonError(KameleoonException.JSONParse, err);\n        }\n      }\n    }\n\n    throw new KameleoonError(KameleoonException.VariationNotFound);\n  }\n\n  public getFeatureFlags(): FeatureFlagType[] {\n    if (!this.campaignConfiguration) {\n      throw new KameleoonError(KameleoonException.Initialization);\n    }\n\n    return this.campaignConfiguration.featureFlags.map(\n      ({ id, featureKey }) => ({ id, key: featureKey }),\n    );\n  }\n\n  public getVisitorFeatureFlags(visitorCode: string): FeatureFlagType[] {\n    if (!this.variationConfiguration || !this.campaignConfiguration) {\n      throw new KameleoonError(KameleoonException.Initialization);\n    }\n\n    const featureFlags = this.campaignConfiguration.featureFlags;\n    const resultFeatureFlags: FeatureFlagType[] = [];\n\n    const targetingData =\n      this.campaignConfiguration.storedTargetingData[visitorCode];\n\n    for (const featureFlag of featureFlags) {\n      const variationData = this.variationConfiguration\n        .getFeatureFlagVariation({\n          visitorCode,\n          targetingData,\n          featureFlag,\n        })\n        .throw();\n\n      if (variationData.variationKey !== OFF_VARIATION_KEY) {\n        const { featureFlagId, featureKey } = variationData;\n\n        resultFeatureFlags.push({ id: featureFlagId, key: featureKey });\n      }\n    }\n\n    return resultFeatureFlags;\n  }\n\n  public getFeatureFlagVariationKey(\n    visitorCode: string,\n    featureKey: string,\n  ): string {\n    const { variationKey } = this._getFeatureFlagVariation(\n      visitorCode,\n      featureKey,\n    ).throw();\n\n    return variationKey;\n  }\n\n  public getFeatureFlagVariable({\n    visitorCode,\n    featureKey,\n    variableKey,\n  }: GetFeatureFlagVariableParamsType): FeatureVariableResultType {\n    const { variationKey } = this._getFeatureFlagVariation(\n      visitorCode,\n      featureKey,\n    ).throw();\n\n    // --- Note ---\n    // `_getFeatureFlagVariation` already checks `campaignConfiguration` initialization\n    const featureFlags = (this.campaignConfiguration as CampaignConfiguration)\n      .featureFlags;\n\n    const variable = featureFlags\n      .find((item) => item.featureKey === featureKey)\n      ?.variations.find((item) => item.key === variationKey)\n      ?.variables.find((item) => item.key === variableKey);\n\n    if (!variable) {\n      throw new KameleoonError(\n        KameleoonException.FeatureFlagConfigurationNotFound,\n        featureKey,\n        visitorCode,\n      );\n    }\n\n    const featureVariable = Utilities.parseFeatureVariable(variable).throw();\n\n    return featureVariable;\n  }\n\n  public isFeatureFlagActive(visitorCode: string, featureKey: string): boolean {\n    const variationKey = this.getFeatureFlagVariationKey(\n      visitorCode,\n      featureKey,\n    );\n\n    return variationKey !== OFF_VARIATION_KEY;\n  }\n\n  public async getRemoteData(key: string): Promise<JSONType> {\n    const remoteData = await this.requester.getRemoteData(key);\n\n    return remoteData.throw();\n  }\n\n  public onConfigurationUpdate(callback: () => void): void {\n    if (!this.campaignConfiguration) {\n      throw new KameleoonError(KameleoonException.Initialization);\n    }\n\n    this.campaignConfiguration.onConfigurationUpdate(callback);\n  }\n\n  protected _getEngineTrackingCode(visitorCode: string): string {\n    return Utilities.getTrackingCode(this.trackingCache, visitorCode);\n  }\n\n  private _getFeatureFlagVariation(\n    visitorCode: string,\n    featureKey: string,\n  ): Result<FeatureFlagVariationType, KameleoonError> {\n    if (!this.variationConfiguration || !this.campaignConfiguration) {\n      return Err(new KameleoonError(KameleoonException.Initialization));\n    }\n\n    const featureFlags = this.campaignConfiguration.featureFlags;\n    const featureFlag = featureFlags.find(\n      (item) => item.featureKey === featureKey,\n    );\n\n    if (!featureFlag) {\n      return Err(\n        new KameleoonError(\n          KameleoonException.FeatureFlagConfigurationNotFound,\n          featureKey,\n          visitorCode,\n        ),\n      );\n    }\n\n    const targetingData =\n      this.campaignConfiguration.storedTargetingData[visitorCode];\n\n    const variationData = this.variationConfiguration\n      .getFeatureFlagVariation({\n        visitorCode,\n        featureFlag,\n        targetingData,\n        withAssignment: true,\n      })\n      .throw();\n\n    const { experimentId, variationId, rule } = variationData;\n\n    if (\n      this.internalConfiguration.externalPackageInfo.type === SDKType.NodeJS &&\n      typeof variationId === 'number' &&\n      typeof experimentId === 'number'\n    ) {\n      Utilities.updateCache({\n        cacheManager: this.trackingCache,\n        visitorCode,\n        experimentId,\n        variationId,\n      });\n    }\n\n    const userAgent = Utilities.getUserAgent(\n      visitorCode,\n      this.campaignConfiguration,\n    );\n\n    if (rule) {\n      Utilities.trackRule({\n        visitorCode,\n        requester: this.requester,\n        featureFlagVariation: variationData,\n        campaignConfiguration: this.campaignConfiguration,\n        userAgent,\n      });\n    }\n\n    return Ok(variationData);\n  }\n}\n"],"mappings":"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"}

package/dist/kameleoonError/constants.d.ts

@@ -6,7 +6,7 @@ export declare const ERROR_MESSAGES: {
     Initialization: () => string;
     StorageInitialization: () => string;
     EventSourceInitialization: () => string;
-    DataInconsistency: () => string;
+    VariationNotFound: () => string;
     FeatureFlagConfigurationNotFound: (featureKey: string, visitorCode: string) => string;
     ExperimentConfigurationNotFound: (experimentId: number, visitorCode: string) => string;
     NotTargeted: (visitorCode: string) => string;

package/dist/kameleoonError/constants.js

@@ -11,7 +11,7 @@ const ERROR_MESSAGES = {
   [_types.KameleoonException.Initialization]: () => "It seems that the client wasn't properly initialized, make sure to run `initialize` method before invoking other methods",
   [_types.KameleoonException.StorageInitialization]: () => "There was an error while initializing React Native SDK storage, it seems that the storage library dependency wasn't installed",
   [_types.KameleoonException.EventSourceInitialization]: () => "There was an error while initializing Real Time Update service, it seems that the event source library dependency wasn't installed",
-  [_types.KameleoonException.DataInconsistency]: () => "Variation was found in the storage, but the server data doesn't contain corresponding variation, try to reload the client",
+  [_types.KameleoonException.VariationNotFound]: () => "Couldn't find experiment variation",
   [_types.KameleoonException.FeatureFlagConfigurationNotFound]: (featureKey, visitorCode) => `No feature flag with key ${featureKey} was found for ${visitorCode} visitorCode.`,
   [_types.KameleoonException.ExperimentConfigurationNotFound]: (experimentId, visitorCode) => `No experiment with id ${experimentId} was found for ${visitorCode} visitorCode.`,
   [_types.KameleoonException.NotTargeted]: visitorCode => `Visitor code ${visitorCode} is not targeted`,

package/dist/kameleoonError/constants.js.map

@@ -1 +1 @@
-{"version":3,"file":"constants.js","names":["_types","require","ERROR_MESSAGES","KameleoonException","JSONParse","err","NumberParse","value","Initialization","StorageInitialization","EventSourceInitialization","DataInconsistency","FeatureFlagConfigurationNotFound","featureKey","visitorCode","ExperimentConfigurationNotFound","experimentId","NotTargeted","NotAllocated","VisitorCodeMaxLength","StorageWrite","StorageRead","key","StorageParse","ClientConfiguration","TargetingCondition","targetingType","AmongValuesCheck","RemoteData","exports"],"sources":["../../src/kameleoonError/constants.ts"],"sourcesContent":["import { KameleoonStorageKey } from '../storage';\nimport { TargetingType } from '../targeting';\nimport { KameleoonException } from './types';\n\nexport const ERROR_MESSAGES = {\n  [KameleoonException.JSONParse]: (err: unknown) =>\n    `Couldn't parse JSON variable: ${err}`,\n  [KameleoonException.NumberParse]: (value: string) =>\n    `It's not possible to parse value ${value} to Number`,\n  [KameleoonException.Initialization]: () =>\n    \"It seems that the client wasn't properly initialized, make sure to run `initialize` method before invoking other methods\",\n  [KameleoonException.StorageInitialization]: () =>\n    \"There was an error while initializing React Native SDK storage, it seems that the storage library dependency wasn't installed\",\n  [KameleoonException.EventSourceInitialization]: () =>\n    \"There was an error while initializing Real Time Update service, it seems that the event source library dependency wasn't installed\",\n  [KameleoonException.DataInconsistency]: () =>\n    \"Variation was found in the storage, but the server data doesn't contain corresponding variation, try to reload the client\",\n  [KameleoonException.FeatureFlagConfigurationNotFound]: (\n    featureKey: string,\n    visitorCode: string,\n  ) =>\n    `No feature flag with key ${featureKey} was found for ${visitorCode} visitorCode.`,\n  [KameleoonException.ExperimentConfigurationNotFound]: (\n    experimentId: number,\n    visitorCode: string,\n  ) =>\n    `No experiment with id ${experimentId} was found for ${visitorCode} visitorCode.`,\n  [KameleoonException.NotTargeted]: (visitorCode: string) =>\n    `Visitor code ${visitorCode} is not targeted`,\n  [KameleoonException.NotAllocated]: (visitorCode: string) =>\n    `Visitor with visitor code ${visitorCode} is in unallocated traffic, there is no variation id to be assigned to the visitor.`,\n  [KameleoonException.VisitorCodeMaxLength]: () =>\n    'Visitor code can not be more than 255 characters long',\n  [KameleoonException.StorageWrite]: (err: unknown) =>\n    `Couldn't update storage for kameleoonClient: ${err}`,\n  [KameleoonException.StorageRead]: (key: KameleoonStorageKey) =>\n    `No data found in storage under ${key} key`,\n  [KameleoonException.StorageParse]: (err: unknown, key: KameleoonStorageKey) =>\n    `Couldn't parse ${key} storage data, the data may be corrupted. Error: ${err}`,\n  [KameleoonException.ClientConfiguration]: () =>\n    \"Couldn't retrieve client configuration from Kameleoon Api\",\n  [KameleoonException.TargetingCondition]: (targetingType: TargetingType) =>\n    `${targetingType} targeting condition is not yet supported.`,\n  [KameleoonException.AmongValuesCheck]: (err: unknown, value: string) =>\n    `Couldn't parse value \"${value}\": ${err}`,\n  [KameleoonException.RemoteData]: () =>\n    `Couldn't retrieve data from Kameleoon server`,\n};\n"],"mappings":";;;;;;AAEA,IAAAA,MAAA,GAAAC,OAAA;AAEO,MAAMC,cAAc,GAAG;EAC5B,CAACC,yBAAkB,CAACC,SAAS,GAAIC,GAAY,IAC1C,iCAAgCA,GAAI,EAAC;EACxC,CAACF,yBAAkB,CAACG,WAAW,GAAIC,KAAa,IAC7C,oCAAmCA,KAAM,YAAW;EACvD,CAACJ,yBAAkB,CAACK,cAAc,GAAG,MACnC,0HAA0H;EAC5H,CAACL,yBAAkB,CAACM,qBAAqB,GAAG,MAC1C,+HAA+H;EACjI,CAACN,yBAAkB,CAACO,yBAAyB,GAAG,MAC9C,oIAAoI;EACtI,CAACP,yBAAkB,CAACQ,iBAAiB,GAAG,MACtC,2HAA2H;EAC7H,CAACR,yBAAkB,CAACS,gCAAgC,GAAG,CACrDC,UAAkB,EAClBC,WAAmB,KAElB,4BAA2BD,UAAW,kBAAiBC,WAAY,eAAc;EACpF,CAACX,yBAAkB,CAACY,+BAA+B,GAAG,CACpDC,YAAoB,EACpBF,WAAmB,KAElB,yBAAwBE,YAAa,kBAAiBF,WAAY,eAAc;EACnF,CAACX,yBAAkB,CAACc,WAAW,GAAIH,WAAmB,IACnD,gBAAeA,WAAY,kBAAiB;EAC/C,CAACX,yBAAkB,CAACe,YAAY,GAAIJ,WAAmB,IACpD,6BAA4BA,WAAY,qFAAoF;EAC/H,CAACX,yBAAkB,CAACgB,oBAAoB,GAAG,MACzC,uDAAuD;EACzD,CAAChB,yBAAkB,CAACiB,YAAY,GAAIf,GAAY,IAC7C,gDAA+CA,GAAI,EAAC;EACvD,CAACF,yBAAkB,CAACkB,WAAW,GAAIC,GAAwB,IACxD,kCAAiCA,GAAI,MAAK;EAC7C,CAACnB,yBAAkB,CAACoB,YAAY,GAAG,CAAClB,GAAY,EAAEiB,GAAwB,KACvE,kBAAiBA,GAAI,oDAAmDjB,GAAI,EAAC;EAChF,CAACF,yBAAkB,CAACqB,mBAAmB,GAAG,MACxC,2DAA2D;EAC7D,CAACrB,yBAAkB,CAACsB,kBAAkB,GAAIC,aAA4B,IACnE,GAAEA,aAAc,4CAA2C;EAC9D,CAACvB,yBAAkB,CAACwB,gBAAgB,GAAG,CAACtB,GAAY,EAAEE,KAAa,KAChE,yBAAwBA,KAAM,MAAKF,GAAI,EAAC;EAC3C,CAACF,yBAAkB,CAACyB,UAAU,GAAG,MAC9B;AACL,CAAC;AAACC,OAAA,CAAA3B,cAAA,GAAAA,cAAA"}
+{"version":3,"file":"constants.js","names":["_types","require","ERROR_MESSAGES","KameleoonException","JSONParse","err","NumberParse","value","Initialization","StorageInitialization","EventSourceInitialization","VariationNotFound","FeatureFlagConfigurationNotFound","featureKey","visitorCode","ExperimentConfigurationNotFound","experimentId","NotTargeted","NotAllocated","VisitorCodeMaxLength","StorageWrite","StorageRead","key","StorageParse","ClientConfiguration","TargetingCondition","targetingType","AmongValuesCheck","RemoteData","exports"],"sources":["../../src/kameleoonError/constants.ts"],"sourcesContent":["import { KameleoonStorageKey } from '../storage';\nimport { TargetingType } from '../targeting';\nimport { KameleoonException } from './types';\n\nexport const ERROR_MESSAGES = {\n  [KameleoonException.JSONParse]: (err: unknown) =>\n    `Couldn't parse JSON variable: ${err}`,\n  [KameleoonException.NumberParse]: (value: string) =>\n    `It's not possible to parse value ${value} to Number`,\n  [KameleoonException.Initialization]: () =>\n    \"It seems that the client wasn't properly initialized, make sure to run `initialize` method before invoking other methods\",\n  [KameleoonException.StorageInitialization]: () =>\n    \"There was an error while initializing React Native SDK storage, it seems that the storage library dependency wasn't installed\",\n  [KameleoonException.EventSourceInitialization]: () =>\n    \"There was an error while initializing Real Time Update service, it seems that the event source library dependency wasn't installed\",\n  [KameleoonException.VariationNotFound]: () =>\n    \"Couldn't find experiment variation\",\n  [KameleoonException.FeatureFlagConfigurationNotFound]: (\n    featureKey: string,\n    visitorCode: string,\n  ) =>\n    `No feature flag with key ${featureKey} was found for ${visitorCode} visitorCode.`,\n  [KameleoonException.ExperimentConfigurationNotFound]: (\n    experimentId: number,\n    visitorCode: string,\n  ) =>\n    `No experiment with id ${experimentId} was found for ${visitorCode} visitorCode.`,\n  [KameleoonException.NotTargeted]: (visitorCode: string) =>\n    `Visitor code ${visitorCode} is not targeted`,\n  [KameleoonException.NotAllocated]: (visitorCode: string) =>\n    `Visitor with visitor code ${visitorCode} is in unallocated traffic, there is no variation id to be assigned to the visitor.`,\n  [KameleoonException.VisitorCodeMaxLength]: () =>\n    'Visitor code can not be more than 255 characters long',\n  [KameleoonException.StorageWrite]: (err: unknown) =>\n    `Couldn't update storage for kameleoonClient: ${err}`,\n  [KameleoonException.StorageRead]: (key: KameleoonStorageKey) =>\n    `No data found in storage under ${key} key`,\n  [KameleoonException.StorageParse]: (err: unknown, key: KameleoonStorageKey) =>\n    `Couldn't parse ${key} storage data, the data may be corrupted. Error: ${err}`,\n  [KameleoonException.ClientConfiguration]: () =>\n    \"Couldn't retrieve client configuration from Kameleoon Api\",\n  [KameleoonException.TargetingCondition]: (targetingType: TargetingType) =>\n    `${targetingType} targeting condition is not yet supported.`,\n  [KameleoonException.AmongValuesCheck]: (err: unknown, value: string) =>\n    `Couldn't parse value \"${value}\": ${err}`,\n  [KameleoonException.RemoteData]: () =>\n    `Couldn't retrieve data from Kameleoon server`,\n};\n"],"mappings":";;;;;;AAEA,IAAAA,MAAA,GAAAC,OAAA;AAEO,MAAMC,cAAc,GAAG;EAC5B,CAACC,yBAAkB,CAACC,SAAS,GAAIC,GAAY,IAC1C,iCAAgCA,GAAI,EAAC;EACxC,CAACF,yBAAkB,CAACG,WAAW,GAAIC,KAAa,IAC7C,oCAAmCA,KAAM,YAAW;EACvD,CAACJ,yBAAkB,CAACK,cAAc,GAAG,MACnC,0HAA0H;EAC5H,CAACL,yBAAkB,CAACM,qBAAqB,GAAG,MAC1C,+HAA+H;EACjI,CAACN,yBAAkB,CAACO,yBAAyB,GAAG,MAC9C,oIAAoI;EACtI,CAACP,yBAAkB,CAACQ,iBAAiB,GAAG,MACtC,oCAAoC;EACtC,CAACR,yBAAkB,CAACS,gCAAgC,GAAG,CACrDC,UAAkB,EAClBC,WAAmB,KAElB,4BAA2BD,UAAW,kBAAiBC,WAAY,eAAc;EACpF,CAACX,yBAAkB,CAACY,+BAA+B,GAAG,CACpDC,YAAoB,EACpBF,WAAmB,KAElB,yBAAwBE,YAAa,kBAAiBF,WAAY,eAAc;EACnF,CAACX,yBAAkB,CAACc,WAAW,GAAIH,WAAmB,IACnD,gBAAeA,WAAY,kBAAiB;EAC/C,CAACX,yBAAkB,CAACe,YAAY,GAAIJ,WAAmB,IACpD,6BAA4BA,WAAY,qFAAoF;EAC/H,CAACX,yBAAkB,CAACgB,oBAAoB,GAAG,MACzC,uDAAuD;EACzD,CAAChB,yBAAkB,CAACiB,YAAY,GAAIf,GAAY,IAC7C,gDAA+CA,GAAI,EAAC;EACvD,CAACF,yBAAkB,CAACkB,WAAW,GAAIC,GAAwB,IACxD,kCAAiCA,GAAI,MAAK;EAC7C,CAACnB,yBAAkB,CAACoB,YAAY,GAAG,CAAClB,GAAY,EAAEiB,GAAwB,KACvE,kBAAiBA,GAAI,oDAAmDjB,GAAI,EAAC;EAChF,CAACF,yBAAkB,CAACqB,mBAAmB,GAAG,MACxC,2DAA2D;EAC7D,CAACrB,yBAAkB,CAACsB,kBAAkB,GAAIC,aAA4B,IACnE,GAAEA,aAAc,4CAA2C;EAC9D,CAACvB,yBAAkB,CAACwB,gBAAgB,GAAG,CAACtB,GAAY,EAAEE,KAAa,KAChE,yBAAwBA,KAAM,MAAKF,GAAI,EAAC;EAC3C,CAACF,yBAAkB,CAACyB,UAAU,GAAG,MAC9B;AACL,CAAC;AAACC,OAAA,CAAA3B,cAAA,GAAAA,cAAA"}

package/dist/kameleoonError/kameleoonError.d.ts

@@ -10,7 +10,7 @@ export declare class KameleoonError extends Error {
     /**
      * @param {KameleoonException} type - type of KameleoonError represented by `KameleoonException` enum
      * */
-    constructor(type: KameleoonException.Initialization | KameleoonException.ClientConfiguration | KameleoonException.VisitorCodeMaxLength | KameleoonException.DataInconsistency | KameleoonException.StorageInitialization | KameleoonException.EventSourceInitialization | KameleoonException.RemoteData);
+    constructor(type: KameleoonException.Initialization | KameleoonException.ClientConfiguration | KameleoonException.VisitorCodeMaxLength | KameleoonException.StorageInitialization | KameleoonException.EventSourceInitialization | KameleoonException.VariationNotFound | KameleoonException.RemoteData);
     constructor(type: KameleoonException.FeatureFlagConfigurationNotFound, featureKey: string, visitorCode: string);
     constructor(type: KameleoonException.NotTargeted | KameleoonException.NotAllocated, visitorCode: string);
     constructor(type: KameleoonException.ExperimentConfigurationNotFound, experimentId: number, visitorCode: string);

package/dist/kameleoonError/kameleoonError.js

@@ -28,8 +28,8 @@ class KameleoonError extends Error {
       case _types.KameleoonException.Initialization:
       case _types.KameleoonException.ClientConfiguration:
       case _types.KameleoonException.VisitorCodeMaxLength:
-      case _types.KameleoonException.DataInconsistency:
       case _types.KameleoonException.StorageInitialization:
+      case _types.KameleoonException.VariationNotFound:
       case _types.KameleoonException.EventSourceInitialization:
       case _types.KameleoonException.RemoteData:
         this.message = _constants.ERROR_MESSAGES[type]();

package/dist/kameleoonError/kameleoonError.js.map

@@ -1 +1 @@
-{"version":3,"file":"kameleoonError.js","names":["_constants","require","_helpers","_types","_defineProperty","obj","key","value","_toPropertyKey","Object","defineProperty","enumerable","configurable","writable","arg","_toPrimitive","String","input","hint","prim","Symbol","toPrimitive","undefined","res","call","TypeError","Number","KameleoonError","Error","constructor","type","secondParam","thirdParam","name","errorType","KameleoonException","Initialization","ClientConfiguration","VisitorCodeMaxLength","DataInconsistency","StorageInitialization","EventSourceInitialization","RemoteData","message","ERROR_MESSAGES","NotAllocated","NotTargeted","ExperimentConfigurationNotFound","FeatureFlagConfigurationNotFound","StorageWrite","JSONParse","StorageRead","StorageParse","TargetingCondition","NumberParse","AmongValuesCheck","exhaustCheck","exports"],"sources":["../../src/kameleoonError/kameleoonError.ts"],"sourcesContent":["import { KameleoonStorageKey } from '../storage';\nimport { TargetingType } from '../targeting';\nimport { ERROR_MESSAGES } from './constants';\nimport { exhaustCheck } from './helpers';\nimport { KameleoonException } from './types';\n\n/**\n * @class\n * KameleoonError - extends standard `Error` by adding custom `type` property with the type of `KameleoonException`\n * */\nexport class KameleoonError extends Error {\n  private errorType: KameleoonException;\n\n  /**\n   * @param {KameleoonException} type - type of KameleoonError represented by `KameleoonException` enum\n   * */\n  constructor(\n    type:\n      | KameleoonException.Initialization\n      | KameleoonException.ClientConfiguration\n      | KameleoonException.VisitorCodeMaxLength\n      | KameleoonException.DataInconsistency\n      | KameleoonException.StorageInitialization\n      | KameleoonException.EventSourceInitialization\n      | KameleoonException.RemoteData,\n  );\n  constructor(\n    type: KameleoonException.FeatureFlagConfigurationNotFound,\n    featureKey: string,\n    visitorCode: string,\n  );\n  constructor(\n    type: KameleoonException.NotTargeted | KameleoonException.NotAllocated,\n    visitorCode: string,\n  );\n  constructor(\n    type: KameleoonException.ExperimentConfigurationNotFound,\n    experimentId: number,\n    visitorCode: string,\n  );\n  constructor(\n    type: KameleoonException.StorageWrite | KameleoonException.JSONParse,\n    err: unknown,\n  );\n  constructor(type: KameleoonException.StorageRead, storageKey: string);\n  constructor(\n    type: KameleoonException.StorageParse,\n    err: unknown,\n    key: KameleoonStorageKey,\n  );\n  constructor(\n    type: KameleoonException.TargetingCondition,\n    targetingType: TargetingType,\n  );\n  constructor(\n    type: KameleoonException.AmongValuesCheck,\n    err: unknown,\n    value: string,\n  );\n  constructor(type: KameleoonException.NumberParse, value: string);\n  constructor(\n    type: KameleoonException,\n    secondParam?:\n      | number\n      | string\n      | unknown\n      | KameleoonStorageKey\n      | TargetingType,\n    thirdParam?: string | KameleoonStorageKey,\n  ) {\n    super(`Error: ${type}`);\n\n    this.name = 'KameleoonError';\n    this.errorType = type;\n\n    switch (type) {\n      case KameleoonException.Initialization:\n      case KameleoonException.ClientConfiguration:\n      case KameleoonException.VisitorCodeMaxLength:\n      case KameleoonException.DataInconsistency:\n      case KameleoonException.StorageInitialization:\n      case KameleoonException.EventSourceInitialization:\n      case KameleoonException.RemoteData:\n        this.message = ERROR_MESSAGES[type]();\n        break;\n      case KameleoonException.NotAllocated:\n      case KameleoonException.NotTargeted:\n        this.message = ERROR_MESSAGES[type](secondParam as string);\n        break;\n      case KameleoonException.ExperimentConfigurationNotFound:\n        this.message = ERROR_MESSAGES[type](\n          secondParam as number,\n          thirdParam as string,\n        );\n        break;\n      case KameleoonException.FeatureFlagConfigurationNotFound:\n        this.message = ERROR_MESSAGES[type](\n          secondParam as string,\n          thirdParam as string,\n        );\n        break;\n      case KameleoonException.StorageWrite:\n      case KameleoonException.JSONParse:\n        this.message = ERROR_MESSAGES[type](secondParam);\n        break;\n      case KameleoonException.StorageRead:\n        this.message = ERROR_MESSAGES[type](secondParam as KameleoonStorageKey);\n        break;\n      case KameleoonException.StorageParse:\n        this.message = ERROR_MESSAGES[type](\n          secondParam,\n          thirdParam as KameleoonStorageKey,\n        );\n        break;\n      case KameleoonException.TargetingCondition:\n        this.message = ERROR_MESSAGES[type](secondParam as TargetingType);\n        break;\n      case KameleoonException.NumberParse:\n        this.message = ERROR_MESSAGES[type](secondParam as string);\n        break;\n      case KameleoonException.AmongValuesCheck:\n        this.message = ERROR_MESSAGES[type](secondParam, thirdParam as string);\n        break;\n      default:\n        exhaustCheck(type);\n    }\n  }\n\n  get type(): KameleoonException {\n    return this.errorType;\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"kameleoonError.js","names":["_constants","require","_helpers","_types","_defineProperty","obj","key","value","_toPropertyKey","Object","defineProperty","enumerable","configurable","writable","arg","_toPrimitive","String","input","hint","prim","Symbol","toPrimitive","undefined","res","call","TypeError","Number","KameleoonError","Error","constructor","type","secondParam","thirdParam","name","errorType","KameleoonException","Initialization","ClientConfiguration","VisitorCodeMaxLength","StorageInitialization","VariationNotFound","EventSourceInitialization","RemoteData","message","ERROR_MESSAGES","NotAllocated","NotTargeted","ExperimentConfigurationNotFound","FeatureFlagConfigurationNotFound","StorageWrite","JSONParse","StorageRead","StorageParse","TargetingCondition","NumberParse","AmongValuesCheck","exhaustCheck","exports"],"sources":["../../src/kameleoonError/kameleoonError.ts"],"sourcesContent":["import { KameleoonStorageKey } from '../storage';\nimport { TargetingType } from '../targeting';\nimport { ERROR_MESSAGES } from './constants';\nimport { exhaustCheck } from './helpers';\nimport { KameleoonException } from './types';\n\n/**\n * @class\n * KameleoonError - extends standard `Error` by adding custom `type` property with the type of `KameleoonException`\n * */\nexport class KameleoonError extends Error {\n  private errorType: KameleoonException;\n\n  /**\n   * @param {KameleoonException} type - type of KameleoonError represented by `KameleoonException` enum\n   * */\n  constructor(\n    type:\n      | KameleoonException.Initialization\n      | KameleoonException.ClientConfiguration\n      | KameleoonException.VisitorCodeMaxLength\n      | KameleoonException.StorageInitialization\n      | KameleoonException.EventSourceInitialization\n      | KameleoonException.VariationNotFound\n      | KameleoonException.RemoteData,\n  );\n  constructor(\n    type: KameleoonException.FeatureFlagConfigurationNotFound,\n    featureKey: string,\n    visitorCode: string,\n  );\n  constructor(\n    type: KameleoonException.NotTargeted | KameleoonException.NotAllocated,\n    visitorCode: string,\n  );\n  constructor(\n    type: KameleoonException.ExperimentConfigurationNotFound,\n    experimentId: number,\n    visitorCode: string,\n  );\n  constructor(\n    type: KameleoonException.StorageWrite | KameleoonException.JSONParse,\n    err: unknown,\n  );\n  constructor(type: KameleoonException.StorageRead, storageKey: string);\n  constructor(\n    type: KameleoonException.StorageParse,\n    err: unknown,\n    key: KameleoonStorageKey,\n  );\n  constructor(\n    type: KameleoonException.TargetingCondition,\n    targetingType: TargetingType,\n  );\n  constructor(\n    type: KameleoonException.AmongValuesCheck,\n    err: unknown,\n    value: string,\n  );\n  constructor(type: KameleoonException.NumberParse, value: string);\n  constructor(\n    type: KameleoonException,\n    secondParam?:\n      | number\n      | string\n      | unknown\n      | KameleoonStorageKey\n      | TargetingType,\n    thirdParam?: string | KameleoonStorageKey,\n  ) {\n    super(`Error: ${type}`);\n\n    this.name = 'KameleoonError';\n    this.errorType = type;\n\n    switch (type) {\n      case KameleoonException.Initialization:\n      case KameleoonException.ClientConfiguration:\n      case KameleoonException.VisitorCodeMaxLength:\n      case KameleoonException.StorageInitialization:\n      case KameleoonException.VariationNotFound:\n      case KameleoonException.EventSourceInitialization:\n      case KameleoonException.RemoteData:\n        this.message = ERROR_MESSAGES[type]();\n        break;\n      case KameleoonException.NotAllocated:\n      case KameleoonException.NotTargeted:\n        this.message = ERROR_MESSAGES[type](secondParam as string);\n        break;\n      case KameleoonException.ExperimentConfigurationNotFound:\n        this.message = ERROR_MESSAGES[type](\n          secondParam as number,\n          thirdParam as string,\n        );\n        break;\n      case KameleoonException.FeatureFlagConfigurationNotFound:\n        this.message = ERROR_MESSAGES[type](\n          secondParam as string,\n          thirdParam as string,\n        );\n        break;\n      case KameleoonException.StorageWrite:\n      case KameleoonException.JSONParse:\n        this.message = ERROR_MESSAGES[type](secondParam);\n        break;\n      case KameleoonException.StorageRead:\n        this.message = ERROR_MESSAGES[type](secondParam as KameleoonStorageKey);\n        break;\n      case KameleoonException.StorageParse:\n        this.message = ERROR_MESSAGES[type](\n          secondParam,\n          thirdParam as KameleoonStorageKey,\n        );\n        break;\n      case KameleoonException.TargetingCondition:\n        this.message = ERROR_MESSAGES[type](secondParam as TargetingType);\n        break;\n      case KameleoonException.NumberParse:\n        this.message = ERROR_MESSAGES[type](secondParam as string);\n        break;\n      case KameleoonException.AmongValuesCheck:\n        this.message = ERROR_MESSAGES[type](secondParam, thirdParam as string);\n        break;\n      default:\n        exhaustCheck(type);\n    }\n  }\n\n  get type(): KameleoonException {\n    return this.errorType;\n  }\n}\n"],"mappings":"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"}

package/dist/kameleoonError/types.d.ts

@@ -1,6 +1,7 @@
 export declare enum KameleoonException {
     ExperimentConfigurationNotFound = "ExperimentConfigurationNotFound",
     EventSourceInitialization = "EventSourceInitialization",
+    VariationNotFound = "VariationNotFound",
     FeatureFlagConfigurationNotFound = "FeatureFlagConfigurationNotFound",
     NotTargeted = "NotTargeted",
     NotAllocated = "NotAllocated",
@@ -13,7 +14,6 @@ export declare enum KameleoonException {
     TargetingCondition = "TargetingCondition",
     AmongValuesCheck = "AmongValuesCheck",
     Initialization = "Initialization",
-    DataInconsistency = "DataInconsistency",
     JSONParse = "JSONParse",
     NumberParse = "NumberParse",
     RemoteData = "RemoteData"

package/dist/kameleoonError/types.js

@@ -7,6 +7,7 @@ exports.KameleoonException = void 0;
 let KameleoonException = /*#__PURE__*/function (KameleoonException) {
   KameleoonException["ExperimentConfigurationNotFound"] = "ExperimentConfigurationNotFound";
   KameleoonException["EventSourceInitialization"] = "EventSourceInitialization";
+  KameleoonException["VariationNotFound"] = "VariationNotFound";
   KameleoonException["FeatureFlagConfigurationNotFound"] = "FeatureFlagConfigurationNotFound";
   KameleoonException["NotTargeted"] = "NotTargeted";
   KameleoonException["NotAllocated"] = "NotAllocated";
@@ -19,7 +20,6 @@ let KameleoonException = /*#__PURE__*/function (KameleoonException) {
   KameleoonException["TargetingCondition"] = "TargetingCondition";
   KameleoonException["AmongValuesCheck"] = "AmongValuesCheck";
   KameleoonException["Initialization"] = "Initialization";
-  KameleoonException["DataInconsistency"] = "DataInconsistency";
   KameleoonException["JSONParse"] = "JSONParse";
   KameleoonException["NumberParse"] = "NumberParse";
   KameleoonException["RemoteData"] = "RemoteData";

package/dist/kameleoonError/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","names":["KameleoonException","exports"],"sources":["../../src/kameleoonError/types.ts"],"sourcesContent":["export enum KameleoonException {\n  ExperimentConfigurationNotFound = 'ExperimentConfigurationNotFound',\n  EventSourceInitialization = 'EventSourceInitialization',\n  FeatureFlagConfigurationNotFound = 'FeatureFlagConfigurationNotFound',\n  NotTargeted = 'NotTargeted',\n  NotAllocated = 'NotAllocated',\n  VisitorCodeMaxLength = 'VisitorCodeMaxLength',\n  StorageInitialization = 'StorageInitialization',\n  StorageWrite = 'StorageWrite',\n  StorageRead = 'StorageRead',\n  StorageParse = 'StorageParse',\n  ClientConfiguration = 'ClientConfiguration',\n  TargetingCondition = 'TargetingCondition',\n  AmongValuesCheck = 'AmongValuesCheck',\n  Initialization = 'Initialization',\n  DataInconsistency = 'DataInconsistency',\n  JSONParse = 'JSONParse',\n  NumberParse = 'NumberParse',\n  RemoteData = 'RemoteData',\n}\n"],"mappings":";;;;;;IAAYA,kBAAkB,0BAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAA,OAAlBA,kBAAkB;AAAA;AAAAC,OAAA,CAAAD,kBAAA,GAAAA,kBAAA"}
+{"version":3,"file":"types.js","names":["KameleoonException","exports"],"sources":["../../src/kameleoonError/types.ts"],"sourcesContent":["export enum KameleoonException {\n  ExperimentConfigurationNotFound = 'ExperimentConfigurationNotFound',\n  EventSourceInitialization = 'EventSourceInitialization',\n  VariationNotFound = 'VariationNotFound',\n  FeatureFlagConfigurationNotFound = 'FeatureFlagConfigurationNotFound',\n  NotTargeted = 'NotTargeted',\n  NotAllocated = 'NotAllocated',\n  VisitorCodeMaxLength = 'VisitorCodeMaxLength',\n  StorageInitialization = 'StorageInitialization',\n  StorageWrite = 'StorageWrite',\n  StorageRead = 'StorageRead',\n  StorageParse = 'StorageParse',\n  ClientConfiguration = 'ClientConfiguration',\n  TargetingCondition = 'TargetingCondition',\n  AmongValuesCheck = 'AmongValuesCheck',\n  Initialization = 'Initialization',\n  JSONParse = 'JSONParse',\n  NumberParse = 'NumberParse',\n  RemoteData = 'RemoteData',\n}\n"],"mappings":";;;;;;IAAYA,kBAAkB,0BAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAA,OAAlBA,kBAAkB;AAAA;AAAAC,OAAA,CAAAD,kBAAA,GAAAA,kBAAA"}