@kameleoon/javascript-sdk-core 1.1.0 → 2.0.0

package/dist/hasher/constants.js.map

@@ -1 +1 @@
-{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/hasher/constants.ts"],"names":[],"mappings":";;;AAAa,QAAA,gBAAgB,GAAG,WAAW,CAAC"}
+{"version":3,"file":"constants.js","names":["RESHUFFLE_SUFFIX","exports"],"sources":["../../src/hasher/constants.ts"],"sourcesContent":["export const RESHUFFLE_SUFFIX = 'variation';\n"],"mappings":";;;;;;AAAO,MAAMA,gBAAgB,GAAG,WAAW;AAACC,OAAA,CAAAD,gBAAA,GAAAA,gBAAA"}

package/dist/hasher/hasher.js

@@ -1,34 +1,45 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.Hasher = void 0;
-const crypto_js_1 = require("crypto-js");
-const constants_1 = require("./constants");
+var _cryptoJs = require("crypto-js");
+var _constants = require("./constants");
 class Hasher {
-    static obtainExperimentHashDouble({ visitorCode, campaignId, respoolTime, }) {
-        let respoolTimeString = '';
-        if (respoolTime.length) {
-            respoolTime.forEach((respoolObject) => {
-                respoolTimeString += String(respoolObject.value);
-            });
-        }
-        return this.calculateHash(visitorCode + campaignId + respoolTimeString);
+  static obtainExperimentHashDouble({
+    visitorCode,
+    campaignId,
+    respoolTime
+  }) {
+    let respoolTimeString = '';
+    if (respoolTime.length) {
+      respoolTime.forEach(respoolObject => {
+        respoolTimeString += String(respoolObject.value);
+      });
     }
-    static obtainFeatureFlagHashDouble({ visitorCode, campaignId, 
+    return this.calculateHash(visitorCode + campaignId + respoolTimeString);
+  }
+  static obtainFeatureFlagHashDouble({
+    visitorCode,
+    campaignId,
     // --- Note ---
     // For some cases of feature flag rules we need to obtain `hashDouble` twice
     // in a row, but the second `hashDouble` should be different (yet still predictable)
-    reShuffle = false, }) {
-        return this.calculateHash(visitorCode + campaignId + (reShuffle ? constants_1.RESHUFFLE_SUFFIX : ''));
-    }
-    // --- Note ---
-    // `hashDouble` is a seeded pseudo-random number between 0 and 1
-    // used for deciding what variation to assign
-    // `calculateHash` algorythm is consistent between every SDK
-    // and will always provide same pseudo-random value for the same input parameters
-    static calculateHash(seed) {
-        const hashDigest = (0, crypto_js_1.SHA256)(seed).toString();
-        return parseInt(hashDigest, 16) / Math.pow(2, 256);
-    }
+    reShuffle = false
+  }) {
+    return this.calculateHash(visitorCode + campaignId + (reShuffle ? _constants.RESHUFFLE_SUFFIX : ''));
+  }
+
+  // --- Note ---
+  // `hashDouble` is a seeded pseudo-random number between 0 and 1
+  // used for deciding what variation to assign
+  // `calculateHash` algorythm is consistent between every SDK
+  // and will always provide same pseudo-random value for the same input parameters
+  static calculateHash(seed) {
+    const hashDigest = (0, _cryptoJs.SHA256)(seed).toString();
+    return parseInt(hashDigest, 16) / Math.pow(2, 256);
+  }
 }
 exports.Hasher = Hasher;
 //# sourceMappingURL=hasher.js.map

package/dist/hasher/hasher.js.map

@@ -1 +1 @@
-{"version":3,"file":"hasher.js","sourceRoot":"","sources":["../../src/hasher/hasher.ts"],"names":[],"mappings":";;;AAAA,yCAAmC;AACnC,2CAA+C;AAM/C,MAAa,MAAM;IACjB,MAAM,CAAC,0BAA0B,CAAC,EAChC,WAAW,EACX,UAAU,EACV,WAAW,GAC0B;QACrC,IAAI,iBAAiB,GAAG,EAAE,CAAC;QAE3B,IAAI,WAAW,CAAC,MAAM,EAAE;YACtB,WAAW,CAAC,OAAO,CAAC,CAAC,aAAa,EAAE,EAAE;gBACpC,iBAAiB,IAAI,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;YACnD,CAAC,CAAC,CAAC;SACJ;QAED,OAAO,IAAI,CAAC,aAAa,CAAC,WAAW,GAAG,UAAU,GAAG,iBAAiB,CAAC,CAAC;IAC1E,CAAC;IAED,MAAM,CAAC,2BAA2B,CAAC,EACjC,WAAW,EACX,UAAU;IACV,eAAe;IACf,4EAA4E;IAC5E,oFAAoF;IACpF,SAAS,GAAG,KAAK,GACqB;QACtC,OAAO,IAAI,CAAC,aAAa,CACvB,WAAW,GAAG,UAAU,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,4BAAgB,CAAC,CAAC,CAAC,EAAE,CAAC,CAC/D,CAAC;IACJ,CAAC;IAED,eAAe;IACf,gEAAgE;IAChE,6CAA6C;IAC7C,4DAA4D;IAC5D,iFAAiF;IACjF,MAAM,CAAC,aAAa,CAAC,IAAY;QAC/B,MAAM,UAAU,GAAG,IAAA,kBAAM,EAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,CAAC;QAE3C,OAAO,QAAQ,CAAC,UAAU,EAAE,EAAE,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;IACrD,CAAC;CACF;AAxCD,wBAwCC"}
+{"version":3,"file":"hasher.js","names":["_cryptoJs","require","_constants","Hasher","obtainExperimentHashDouble","visitorCode","campaignId","respoolTime","respoolTimeString","length","forEach","respoolObject","String","value","calculateHash","obtainFeatureFlagHashDouble","reShuffle","RESHUFFLE_SUFFIX","seed","hashDigest","SHA256","toString","parseInt","Math","pow","exports"],"sources":["../../src/hasher/hasher.ts"],"sourcesContent":["import { SHA256 } from 'crypto-js';\nimport { RESHUFFLE_SUFFIX } from './constants';\nimport {\n  ObtainExperimentHashDoubleParamsType,\n  ObtainFeatureFlagHashDoubleParamsType,\n} from './types';\n\nexport class Hasher {\n  static obtainExperimentHashDouble({\n    visitorCode,\n    campaignId,\n    respoolTime,\n  }: ObtainExperimentHashDoubleParamsType): number {\n    let respoolTimeString = '';\n\n    if (respoolTime.length) {\n      respoolTime.forEach((respoolObject) => {\n        respoolTimeString += String(respoolObject.value);\n      });\n    }\n\n    return this.calculateHash(visitorCode + campaignId + respoolTimeString);\n  }\n\n  static obtainFeatureFlagHashDouble({\n    visitorCode,\n    campaignId,\n    // --- Note ---\n    // For some cases of feature flag rules we need to obtain `hashDouble` twice\n    // in a row, but the second `hashDouble` should be different (yet still predictable)\n    reShuffle = false,\n  }: ObtainFeatureFlagHashDoubleParamsType): number {\n    return this.calculateHash(\n      visitorCode + campaignId + (reShuffle ? RESHUFFLE_SUFFIX : ''),\n    );\n  }\n\n  // --- Note ---\n  // `hashDouble` is a seeded pseudo-random number between 0 and 1\n  // used for deciding what variation to assign\n  // `calculateHash` algorythm is consistent between every SDK\n  // and will always provide same pseudo-random value for the same input parameters\n  static calculateHash(seed: string): number {\n    const hashDigest = SHA256(seed).toString();\n\n    return parseInt(hashDigest, 16) / Math.pow(2, 256);\n  }\n}\n"],"mappings":";;;;;;AAAA,IAAAA,SAAA,GAAAC,OAAA;AACA,IAAAC,UAAA,GAAAD,OAAA;AAMO,MAAME,MAAM,CAAC;EAClB,OAAOC,0BAA0BA,CAAC;IAChCC,WAAW;IACXC,UAAU;IACVC;EACoC,CAAC,EAAU;IAC/C,IAAIC,iBAAiB,GAAG,EAAE;IAE1B,IAAID,WAAW,CAACE,MAAM,EAAE;MACtBF,WAAW,CAACG,OAAO,CAAEC,aAAa,IAAK;QACrCH,iBAAiB,IAAII,MAAM,CAACD,aAAa,CAACE,KAAK,CAAC;MAClD,CAAC,CAAC;IACJ;IAEA,OAAO,IAAI,CAACC,aAAa,CAACT,WAAW,GAAGC,UAAU,GAAGE,iBAAiB,CAAC;EACzE;EAEA,OAAOO,2BAA2BA,CAAC;IACjCV,WAAW;IACXC,UAAU;IACV;IACA;IACA;IACAU,SAAS,GAAG;EACyB,CAAC,EAAU;IAChD,OAAO,IAAI,CAACF,aAAa,CACvBT,WAAW,GAAGC,UAAU,IAAIU,SAAS,GAAGC,2BAAgB,GAAG,EAAE,CAAC,CAC/D;EACH;;EAEA;EACA;EACA;EACA;EACA;EACA,OAAOH,aAAaA,CAACI,IAAY,EAAU;IACzC,MAAMC,UAAU,GAAG,IAAAC,gBAAM,EAACF,IAAI,CAAC,CAACG,QAAQ,EAAE;IAE1C,OAAOC,QAAQ,CAACH,UAAU,EAAE,EAAE,CAAC,GAAGI,IAAI,CAACC,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC;EACpD;AACF;AAACC,OAAA,CAAAtB,MAAA,GAAAA,MAAA"}

package/dist/hasher/index.js

@@ -1,6 +1,13 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Hasher = void 0;
-var hasher_1 = require("./hasher");
-Object.defineProperty(exports, "Hasher", { enumerable: true, get: function () { return hasher_1.Hasher; } });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Hasher", {
+  enumerable: true,
+  get: function () {
+    return _hasher.Hasher;
+  }
+});
+var _hasher = require("./hasher");
 //# sourceMappingURL=index.js.map

package/dist/hasher/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/hasher/index.ts"],"names":[],"mappings":";;;AAAA,mCAAkC;AAAzB,gGAAA,MAAM,OAAA"}
+{"version":3,"file":"index.js","names":["_hasher","require"],"sources":["../../src/hasher/index.ts"],"sourcesContent":["export { Hasher } from './hasher';\n"],"mappings":";;;;;;;;;;;AAAA,IAAAA,OAAA,GAAAC,OAAA"}

package/dist/hasher/types.js

@@ -1,3 +1,6 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 //# sourceMappingURL=types.js.map

package/dist/hasher/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/hasher/types.ts"],"names":[],"mappings":""}
+{"version":3,"file":"types.js","names":[],"sources":["../../src/hasher/types.ts"],"sourcesContent":["import { RespoolTimeType } from '../campaignConfiguration/types';\n\ntype ObtainHashDoubleParamsType = {\n  visitorCode: string;\n  campaignId: string;\n};\n\nexport type ObtainExperimentHashDoubleParamsType =\n  ObtainHashDoubleParamsType & {\n    respoolTime: RespoolTimeType[];\n  };\n\nexport type ObtainFeatureFlagHashDoubleParamsType =\n  ObtainHashDoubleParamsType & {\n    reShuffle?: boolean;\n  };\n"],"mappings":""}

package/dist/index.d.ts

@@ -5,6 +5,7 @@ export { KameleoonStorageKey, IExternalStorage, IExternalStorageConstructor, } f
 export { Cookie, VISITOR_CODE_LENGTH } from './constants';
 export { JSONType } from './campaignConfiguration';
 export { Ok, Result, Err } from 'ts-res';
-export { Environment, ExperimentType, FeatureFlagType, SDKCoreParameters, SDKConfigurationType, TrackConversionParamsType, FeatureVariableResultType, InternalSDKConfigurationType, GetFeatureFlagVariableParamsType, ServerGetVisitorCodeParametersType, ClientGetVisitorCodeParametersType, MobileGetVisitorCodeParametersType, } from './types';
+export { Environment, VariableType, ExperimentType, FeatureFlagType, SDKCoreParameters, SDKConfigurationType, ExternalPackageInfoType, TrackConversionParamsType, FeatureVariableResultType, InternalSDKConfigurationType, GetFeatureFlagVariableParamsType, ServerGetVisitorCodeParametersType, ClientGetVisitorCodeParametersType, MobileGetVisitorCodeParametersType, } from './types';
 export { CustomData, Conversion, Device, Browser, DeviceType, BrowserType, PageView, KameleoonDataType, PageViewParametersType, ConversionParametersType, } from './kameleoonData';
 export { RealTimeEventType, IExternalEventSource, EventSourceOpenParametersType, IExternalEventSourceConstructor, } from './eventSource';
+export { Header, HttpMethod, TrackParametersType, IExternalRequestDispatcher, GetClientConfigurationResultType, } from './requester';

package/dist/index.js

@@ -1,29 +1,299 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PageView = exports.BrowserType = exports.DeviceType = exports.Browser = exports.Device = exports.Conversion = exports.CustomData = exports.Environment = exports.Err = exports.Ok = exports.VISITOR_CODE_LENGTH = exports.Cookie = exports.KameleoonStorageKey = exports.KameleoonError = exports.KameleoonException = exports.KameleoonCoreUtils = exports.KameleoonCore = void 0;
-var kameleoonClient_1 = require("./kameleoonClient");
-Object.defineProperty(exports, "KameleoonCore", { enumerable: true, get: function () { return kameleoonClient_1.KameleoonClient; } });
-var kameleoonUtils_1 = require("./kameleoonUtils");
-Object.defineProperty(exports, "KameleoonCoreUtils", { enumerable: true, get: function () { return kameleoonUtils_1.KameleoonUtils; } });
-var kameleoonError_1 = require("./kameleoonError");
-Object.defineProperty(exports, "KameleoonException", { enumerable: true, get: function () { return kameleoonError_1.KameleoonException; } });
-Object.defineProperty(exports, "KameleoonError", { enumerable: true, get: function () { return kameleoonError_1.KameleoonError; } });
-var storage_1 = require("./storage");
-Object.defineProperty(exports, "KameleoonStorageKey", { enumerable: true, get: function () { return storage_1.KameleoonStorageKey; } });
-var constants_1 = require("./constants");
-Object.defineProperty(exports, "Cookie", { enumerable: true, get: function () { return constants_1.Cookie; } });
-Object.defineProperty(exports, "VISITOR_CODE_LENGTH", { enumerable: true, get: function () { return constants_1.VISITOR_CODE_LENGTH; } });
-var ts_res_1 = require("ts-res");
-Object.defineProperty(exports, "Ok", { enumerable: true, get: function () { return ts_res_1.Ok; } });
-Object.defineProperty(exports, "Err", { enumerable: true, get: function () { return ts_res_1.Err; } });
-var types_1 = require("./types");
-Object.defineProperty(exports, "Environment", { enumerable: true, get: function () { return types_1.Environment; } });
-var kameleoonData_1 = require("./kameleoonData");
-Object.defineProperty(exports, "CustomData", { enumerable: true, get: function () { return kameleoonData_1.CustomData; } });
-Object.defineProperty(exports, "Conversion", { enumerable: true, get: function () { return kameleoonData_1.Conversion; } });
-Object.defineProperty(exports, "Device", { enumerable: true, get: function () { return kameleoonData_1.Device; } });
-Object.defineProperty(exports, "Browser", { enumerable: true, get: function () { return kameleoonData_1.Browser; } });
-Object.defineProperty(exports, "DeviceType", { enumerable: true, get: function () { return kameleoonData_1.DeviceType; } });
-Object.defineProperty(exports, "BrowserType", { enumerable: true, get: function () { return kameleoonData_1.BrowserType; } });
-Object.defineProperty(exports, "PageView", { enumerable: true, get: function () { return kameleoonData_1.PageView; } });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Browser", {
+  enumerable: true,
+  get: function () {
+    return _kameleoonData.Browser;
+  }
+});
+Object.defineProperty(exports, "BrowserType", {
+  enumerable: true,
+  get: function () {
+    return _kameleoonData.BrowserType;
+  }
+});
+Object.defineProperty(exports, "ClientGetVisitorCodeParametersType", {
+  enumerable: true,
+  get: function () {
+    return _types.ClientGetVisitorCodeParametersType;
+  }
+});
+Object.defineProperty(exports, "Conversion", {
+  enumerable: true,
+  get: function () {
+    return _kameleoonData.Conversion;
+  }
+});
+Object.defineProperty(exports, "ConversionParametersType", {
+  enumerable: true,
+  get: function () {
+    return _kameleoonData.ConversionParametersType;
+  }
+});
+Object.defineProperty(exports, "Cookie", {
+  enumerable: true,
+  get: function () {
+    return _constants.Cookie;
+  }
+});
+Object.defineProperty(exports, "CustomData", {
+  enumerable: true,
+  get: function () {
+    return _kameleoonData.CustomData;
+  }
+});
+Object.defineProperty(exports, "Device", {
+  enumerable: true,
+  get: function () {
+    return _kameleoonData.Device;
+  }
+});
+Object.defineProperty(exports, "DeviceType", {
+  enumerable: true,
+  get: function () {
+    return _kameleoonData.DeviceType;
+  }
+});
+Object.defineProperty(exports, "Environment", {
+  enumerable: true,
+  get: function () {
+    return _types.Environment;
+  }
+});
+Object.defineProperty(exports, "Err", {
+  enumerable: true,
+  get: function () {
+    return _tsRes.Err;
+  }
+});
+Object.defineProperty(exports, "EventSourceOpenParametersType", {
+  enumerable: true,
+  get: function () {
+    return _eventSource.EventSourceOpenParametersType;
+  }
+});
+Object.defineProperty(exports, "ExperimentType", {
+  enumerable: true,
+  get: function () {
+    return _types.ExperimentType;
+  }
+});
+Object.defineProperty(exports, "ExternalPackageInfoType", {
+  enumerable: true,
+  get: function () {
+    return _types.ExternalPackageInfoType;
+  }
+});
+Object.defineProperty(exports, "FeatureFlagType", {
+  enumerable: true,
+  get: function () {
+    return _types.FeatureFlagType;
+  }
+});
+Object.defineProperty(exports, "FeatureVariableResultType", {
+  enumerable: true,
+  get: function () {
+    return _types.FeatureVariableResultType;
+  }
+});
+Object.defineProperty(exports, "GetClientConfigurationResultType", {
+  enumerable: true,
+  get: function () {
+    return _requester.GetClientConfigurationResultType;
+  }
+});
+Object.defineProperty(exports, "GetFeatureFlagVariableParamsType", {
+  enumerable: true,
+  get: function () {
+    return _types.GetFeatureFlagVariableParamsType;
+  }
+});
+Object.defineProperty(exports, "Header", {
+  enumerable: true,
+  get: function () {
+    return _requester.Header;
+  }
+});
+Object.defineProperty(exports, "HttpMethod", {
+  enumerable: true,
+  get: function () {
+    return _requester.HttpMethod;
+  }
+});
+Object.defineProperty(exports, "IExternalEventSource", {
+  enumerable: true,
+  get: function () {
+    return _eventSource.IExternalEventSource;
+  }
+});
+Object.defineProperty(exports, "IExternalEventSourceConstructor", {
+  enumerable: true,
+  get: function () {
+    return _eventSource.IExternalEventSourceConstructor;
+  }
+});
+Object.defineProperty(exports, "IExternalRequestDispatcher", {
+  enumerable: true,
+  get: function () {
+    return _requester.IExternalRequestDispatcher;
+  }
+});
+Object.defineProperty(exports, "IExternalStorage", {
+  enumerable: true,
+  get: function () {
+    return _storage.IExternalStorage;
+  }
+});
+Object.defineProperty(exports, "IExternalStorageConstructor", {
+  enumerable: true,
+  get: function () {
+    return _storage.IExternalStorageConstructor;
+  }
+});
+Object.defineProperty(exports, "IKameleoonCore", {
+  enumerable: true,
+  get: function () {
+    return _kameleoonClient.IKameleoonClient;
+  }
+});
+Object.defineProperty(exports, "InternalSDKConfigurationType", {
+  enumerable: true,
+  get: function () {
+    return _types.InternalSDKConfigurationType;
+  }
+});
+Object.defineProperty(exports, "JSONType", {
+  enumerable: true,
+  get: function () {
+    return _campaignConfiguration.JSONType;
+  }
+});
+Object.defineProperty(exports, "KameleoonCore", {
+  enumerable: true,
+  get: function () {
+    return _kameleoonClient.KameleoonClient;
+  }
+});
+Object.defineProperty(exports, "KameleoonCoreUtils", {
+  enumerable: true,
+  get: function () {
+    return _kameleoonUtils.KameleoonUtils;
+  }
+});
+Object.defineProperty(exports, "KameleoonDataType", {
+  enumerable: true,
+  get: function () {
+    return _kameleoonData.KameleoonDataType;
+  }
+});
+Object.defineProperty(exports, "KameleoonError", {
+  enumerable: true,
+  get: function () {
+    return _kameleoonError.KameleoonError;
+  }
+});
+Object.defineProperty(exports, "KameleoonException", {
+  enumerable: true,
+  get: function () {
+    return _kameleoonError.KameleoonException;
+  }
+});
+Object.defineProperty(exports, "KameleoonStorageKey", {
+  enumerable: true,
+  get: function () {
+    return _storage.KameleoonStorageKey;
+  }
+});
+Object.defineProperty(exports, "MobileGetVisitorCodeParametersType", {
+  enumerable: true,
+  get: function () {
+    return _types.MobileGetVisitorCodeParametersType;
+  }
+});
+Object.defineProperty(exports, "Ok", {
+  enumerable: true,
+  get: function () {
+    return _tsRes.Ok;
+  }
+});
+Object.defineProperty(exports, "PageView", {
+  enumerable: true,
+  get: function () {
+    return _kameleoonData.PageView;
+  }
+});
+Object.defineProperty(exports, "PageViewParametersType", {
+  enumerable: true,
+  get: function () {
+    return _kameleoonData.PageViewParametersType;
+  }
+});
+Object.defineProperty(exports, "RealTimeEventType", {
+  enumerable: true,
+  get: function () {
+    return _eventSource.RealTimeEventType;
+  }
+});
+Object.defineProperty(exports, "Result", {
+  enumerable: true,
+  get: function () {
+    return _tsRes.Result;
+  }
+});
+Object.defineProperty(exports, "SDKConfigurationType", {
+  enumerable: true,
+  get: function () {
+    return _types.SDKConfigurationType;
+  }
+});
+Object.defineProperty(exports, "SDKCoreParameters", {
+  enumerable: true,
+  get: function () {
+    return _types.SDKCoreParameters;
+  }
+});
+Object.defineProperty(exports, "ServerGetVisitorCodeParametersType", {
+  enumerable: true,
+  get: function () {
+    return _types.ServerGetVisitorCodeParametersType;
+  }
+});
+Object.defineProperty(exports, "TrackConversionParamsType", {
+  enumerable: true,
+  get: function () {
+    return _types.TrackConversionParamsType;
+  }
+});
+Object.defineProperty(exports, "TrackParametersType", {
+  enumerable: true,
+  get: function () {
+    return _requester.TrackParametersType;
+  }
+});
+Object.defineProperty(exports, "VISITOR_CODE_LENGTH", {
+  enumerable: true,
+  get: function () {
+    return _constants.VISITOR_CODE_LENGTH;
+  }
+});
+Object.defineProperty(exports, "VariableType", {
+  enumerable: true,
+  get: function () {
+    return _types.VariableType;
+  }
+});
+var _kameleoonClient = require("./kameleoonClient");
+var _kameleoonUtils = require("./kameleoonUtils");
+var _kameleoonError = require("./kameleoonError");
+var _storage = require("./storage");
+var _constants = require("./constants");
+var _campaignConfiguration = require("./campaignConfiguration");
+var _tsRes = require("ts-res");
+var _types = require("./types");
+var _kameleoonData = require("./kameleoonData");
+var _eventSource = require("./eventSource");
+var _requester = require("./requester");
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,qDAG2B;AAFzB,gHAAA,eAAe,OAAiB;AAGlC,mDAAwE;AAA/D,oHAAA,cAAc,OAAsB;AAC7C,mDAAsE;AAA7D,oHAAA,kBAAkB,OAAA;AAAE,gHAAA,cAAc,OAAA;AAC3C,qCAImB;AAHjB,8GAAA,mBAAmB,OAAA;AAIrB,yCAA0D;AAAjD,mGAAA,MAAM,OAAA;AAAE,gHAAA,mBAAmB,OAAA;AAEpC,iCAAyC;AAAhC,4FAAA,EAAE,OAAA;AAAU,6FAAA,GAAG,OAAA;AACxB,iCAaiB;AAZf,oGAAA,WAAW,OAAA;AAab,iDAWyB;AAVvB,2GAAA,UAAU,OAAA;AACV,2GAAA,UAAU,OAAA;AACV,uGAAA,MAAM,OAAA;AACN,wGAAA,OAAO,OAAA;AACP,2GAAA,UAAU,OAAA;AACV,4GAAA,WAAW,OAAA;AACX,yGAAA,QAAQ,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 } 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"}

package/dist/kameleoonClient.d.ts

@@ -3,7 +3,7 @@ import { KameleoonDataType } from './kameleoonData';
 import { TrackConversionParamsType, ExperimentType, FeatureFlagType, GetFeatureFlagVariableParamsType, FeatureVariableResultType, SDKCoreParameters } from './types';
 /**
  * @interface an interface of KameleoonClient instance
- * */
+ */
 export interface IKameleoonClient {
     /**
      * @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
@@ -12,7 +12,7 @@ export interface IKameleoonClient {
      *
      * - `KameleoonException.StorageWrite` Couldn't update storage data
      * - `KameleoonException.ClientConfiguration` Couldn't retrieve client configuration from Kameleoon Api
-     * */
+     */
     initialize: () => Promise<boolean>;
     /**
      * @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.
@@ -24,7 +24,7 @@ export interface IKameleoonClient {
      * - `KameleoonException.VisitorCodeMaxLength` The visitor code length was exceeded
      * - `KameleoonException.StorageWrite` Couldn't update storage data
      * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`
-     * */
+     */
     addData: (visitorCode: string, ...data: KameleoonDataType[]) => void;
     /**
      * @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.
@@ -38,7 +38,7 @@ export interface IKameleoonClient {
      * - `KameleoonException.StorageRead` Couldn't find associated experiment by provided `experimentId` and `visitorCode` inside the storage
      * - `KameleoonException.NotTargeted` Current visitor is not targeted
      * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`
-     * */
+     */
     triggerExperiment: (visitorCode: string, experimentId: number) => number;
     /**
      * @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
@@ -48,7 +48,7 @@ export interface IKameleoonClient {
      *
      * - `KameleoonException.VisitorCodeMaxLength` The visitor code length was exceeded
      * - `KameleoonException.StorageWrite` Couldn't update storage data
-     * */
+     */
     trackConversion: ({ visitorCode, goalId, revenue, }: TrackConversionParamsType) => void;
     /**
      * @method flushData - takes visitor associated kameleoon data and sends the data tracking request with collected data
@@ -58,7 +58,7 @@ export interface IKameleoonClient {
      * @throws `KameleoonError` with one of the following `type` s:
      *
      * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`
-     * */
+     */
     flushData: (visitorCode: string) => void;
     /**
      * @method getExperiments - returns a list of experiments stored in the client configuration
@@ -66,7 +66,7 @@ export interface IKameleoonClient {
      * @throws `KameleoonError` with one of the following `type` s:
      *
      * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`
-     * */
+     */
     getExperiments: () => ExperimentType[];
     /**
      * @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).
@@ -77,7 +77,7 @@ export interface IKameleoonClient {
      *
      * - `KameleoonException.VisitorCodeMaxLength` - The visitor code length was exceeded
      * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`
-     * */
+     */
     getVisitorExperiments: (visitorCode: string, isAllocated?: boolean) => ExperimentType[];
     /**
      * @method getFeatureFlags - returns a list of feature flags stored in the client configuration
@@ -85,7 +85,7 @@ export interface IKameleoonClient {
      * @throws `KameleoonError` with one of the following `type` s:
      *
      * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`
-     * */
+     */
     getFeatureFlags: () => FeatureFlagType[];
     /**
      * @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).
@@ -96,7 +96,7 @@ export interface IKameleoonClient {
      * - `KameleoonException.VisitorCodeMaxLength` - The visitor code length was exceeded
      * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`
      * - `KameleoonException.NotTargeted` - Current visitor is not targeted
-     * */
+     */
     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`
@@ -110,7 +110,7 @@ export interface IKameleoonClient {
      * - `KameleoonException.FeatureFlagConfigurationNotFound` - No feature flag was found for provided `visitorCode` and `featureKey`
      * - `KameleoonException.DataInconsistency` - Allocated variation was found but there is no feature flag with according `featureKey`.
      * - `KameleoonException.NotTargeted` - Current visitor is not targeted
-     * */
+     */
     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`
@@ -123,7 +123,7 @@ export interface IKameleoonClient {
      * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`
      * - `KameleoonException.FeatureFlagConfigurationNotFound` - No feature flag was found for provided `visitorCode` and `featureKey`
      * - `KameleoonException.NotTargeted` - Current visitor is not targeted
-     * */
+     */
     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`
@@ -137,7 +137,7 @@ export interface IKameleoonClient {
      * - `KameleoonException.NotTargeted` - Current visitor is not targeted
      * - `KameleoonException.JSONParse` - Couldn't pass JSON value
      * - `KameleoonException.NumberParse` - Couldn't pass Number value
-     * */
+     */
     getFeatureFlagVariable: ({ visitorCode, featureKey, variableKey, }: GetFeatureFlagVariableParamsType) => FeatureVariableResultType;
     /**
      * @method getRemoteData - returns a data which is stored for specified siteCode on a remote Kameleoon server.
@@ -146,7 +146,7 @@ export interface IKameleoonClient {
      * @throws `KameleoonError` with one of the following `type` s:
      *
      * - `KameleoonException.RemoteData` - Couldn't retrieve data from Kameleoon server
-     * */
+     */
     getRemoteData: (key: string) => Promise<JSONType>;
     /**
      * @method onConfigurationUpdate - fires a callback on client configuration update. Note: this method only works for server sent events of real time update.
@@ -155,14 +155,14 @@ export interface IKameleoonClient {
      * @throws `KameleoonError` with one of the following `type` s:
      *
      * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`
-     * */
+     */
     onConfigurationUpdate: (callback: () => void) => void;
 }
 /**
  * @class
  * KameleoonClient - a class for creating kameleoon client instance
  * for communicating with Kameleoon JavaScript SDK Core, when new instance is created
- * */
+ */
 export declare class KameleoonClient implements IKameleoonClient {
     private internalConfiguration;
     private variationConfiguration?;