@kameleoon/javascript-sdk 0.0.1

package/dist/kameleoonClient.js

@@ -0,0 +1,652 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KameleoonException = exports.KameleoonData = exports.KameleoonClient = void 0;
+var configuration_1 = __importDefault(require("./configurations/configuration"));
+var data_1 = __importDefault(require("./data"));
+exports.KameleoonData = data_1.default;
+var kameleoonUtils_1 = __importStar(require("./kameleoonUtils"));
+var targetingData_1 = __importDefault(require("./targeting/targetingData"));
+var experimentConfigurationNotFound_1 = __importDefault(require("./exceptions/experimentConfigurationNotFound"));
+var featureConfigurationNotFound_1 = __importDefault(require("./exceptions/featureConfigurationNotFound"));
+var notActivated_1 = __importDefault(require("./exceptions/notActivated"));
+var notTargeted_1 = __importDefault(require("./exceptions/notTargeted"));
+var variationConfigurationNotFound_1 = __importDefault(require("./exceptions/variationConfigurationNotFound"));
+var credentialsNotFound_1 = __importDefault(require("./exceptions/credentialsNotFound"));
+var visitorCodeNotValid_1 = require("./exceptions/visitorCodeNotValid");
+var siteCodeDisabled_1 = require("./exceptions/siteCodeDisabled");
+var nonce_1 = require("./nonce");
+var realTimeConfigurationService_1 = require("./realTimeConfigurationService");
+var variationStorage_1 = require("./storage/variationStorage");
+var constants_1 = require("./constants");
+var targetingEngine_1 = require("./targeting/targetingEngine");
+var KameleoonClient = /** @class */ (function () {
+    function KameleoonClient(siteCode, configuration) {
+        var _this = this;
+        this.ready = false;
+        this.readyCallbacks = [];
+        this.minutesBetweenConfigurationUpdate = 30;
+        this.targetingData = {};
+        this.unsentData = {};
+        this.visitorDataMaximumSize = 1;
+        this.environment = null;
+        this.realTimeConfigurationService = null;
+        this.handlerUpdateConfiguration = null;
+        this.variationStorage = new variationStorage_1.VariationStorage();
+        this.updateCampaignConfiguration = function (timeStamp) {
+            var _a;
+            var data = localStorage.kameleoonJavaScriptClientData;
+            if (data) {
+                try {
+                    data = JSON.parse(data);
+                }
+                catch (e) {
+                    console.log(e);
+                }
+            }
+            if (!data) {
+                data = {
+                    kameleoonTargetingData: {},
+                    kameleoonConfiguration: {},
+                };
+            }
+            var savedTargetingData = data.kameleoonTargetingData;
+            if (savedTargetingData) {
+                try {
+                    _this.targetingData = savedTargetingData;
+                    _this.emptyTargetingData();
+                }
+                catch (e) {
+                    _this.targetingData = {};
+                }
+            }
+            var savedConfiguration = data.kameleoonConfiguration;
+            var needUpdate = false;
+            if (!savedConfiguration || timeStamp != null) {
+                // timeStamp != null means update by SSE event and requires force update
+                needUpdate = true;
+            }
+            else {
+                try {
+                    var parsedConfiguration = new configuration_1.default(_this.siteCode, {
+                        configuration: savedConfiguration.configuration,
+                        experiments: savedConfiguration.experiments,
+                        featureFlags: savedConfiguration.featureFlags,
+                        updateTime: savedConfiguration.updateTime,
+                    });
+                    if (parsedConfiguration.updateTime <
+                        new Date().getTime() -
+                            _this.minutesBetweenConfigurationUpdate * 1000 * 60 || //refresh by polling interval
+                        parsedConfiguration.settings.realTimeUpdate) {
+                        //streaming initial refresh, need to update to recent version of configuration
+                        needUpdate = true;
+                    }
+                    else {
+                        _this.configurations = parsedConfiguration;
+                    }
+                }
+                catch (e) {
+                    needUpdate = true;
+                }
+            }
+            if (needUpdate) {
+                var siteCodeStringUrl = "mobile?siteCode=".concat(_this.siteCode);
+                var environmentStringUrl = ((_a = _this.environment) === null || _a === void 0 ? void 0 : _a.length)
+                    ? "&environment=".concat(_this.environment)
+                    : '';
+                var timeStampStringUrl = timeStamp ? "&ts=".concat(timeStamp) : '';
+                var configurationUrl = constants_1.CONFIGURATION_URL +
+                    siteCodeStringUrl +
+                    environmentStringUrl +
+                    timeStampStringUrl;
+                kameleoonUtils_1.default.doRequest(configurationUrl, kameleoonUtils_1.HttpMethod.GET, null, function (response) {
+                    try {
+                        _this.configurations = new configuration_1.default(_this.siteCode, JSON.parse(response));
+                        _this.ready = true;
+                        _this.clearCallbacks(true);
+                        _this.saveConfiguration();
+                        _this.fireUpdateConfigurationHandler(Boolean(timeStamp)); //fire handler after configuration was updated with SSE event
+                        _this.manageConfiguraitonUpdate(_this.configurations.settings.realTimeUpdate);
+                    }
+                    catch (e) {
+                        console.log(e);
+                    }
+                }, false);
+            }
+            else {
+                _this.ready = true;
+                _this.clearCallbacks(true);
+            }
+        };
+        this.runWhenReady = function (successCallback, errorCallback, timeout) {
+            if (_this.ready) {
+                successCallback && successCallback();
+            }
+            else {
+                _this.readyCallbacks.push({
+                    error: errorCallback,
+                    success: successCallback,
+                    timeout: setTimeout(function () {
+                        _this.clearCallbacks(false, errorCallback);
+                    }, timeout),
+                });
+            }
+        };
+        this.clearCallbacks = function (success, errorCallback) {
+            var callbacksToKeep = [];
+            _this.readyCallbacks.forEach(function (c) {
+                if (success) {
+                    c.success && c.success();
+                    clearTimeout(c.timeout);
+                }
+                else {
+                    if (!success && errorCallback == c.error) {
+                        c.error && c.error();
+                    }
+                    else {
+                        callbacksToKeep.push(c);
+                    }
+                }
+            });
+            _this.readyCallbacks = callbacksToKeep;
+        };
+        this.trackConversion = function (visitorCode, goalId, revenue) {
+            _this.validateVisitorCode(visitorCode);
+            _this.addData(visitorCode, new data_1.default.Conversion(goalId, revenue, false));
+            _this.flush(visitorCode);
+        };
+        this.flush = function (visitorCode) {
+            if (visitorCode != null) {
+                var body = _this.getAndClearUnsentData(visitorCode);
+                kameleoonUtils_1.default.doRequest(constants_1.API_SSX_URL + _this.getDataTrackingURL(visitorCode), kameleoonUtils_1.HttpMethod.POST, body, null);
+            }
+            else {
+                _this.getUnsentUsers().forEach(function (vc) { return _this.flush(vc); });
+            }
+        };
+        this.triggerExperiment = function (visitorCode, experimentId) {
+            var _a;
+            _this.validateVisitorCode(visitorCode);
+            var xpConf = (_a = _this.configurations) === null || _a === void 0 ? void 0 : _a.experiments[experimentId];
+            _this.checkSiteEnabled(xpConf);
+            if (_this.checkTargeting(visitorCode, experimentId, false)) {
+                var variationId = 0;
+                var noneVariation = true;
+                var savedVariationId = _this.variationStorage.getVariationId(visitorCode, experimentId);
+                if (savedVariationId) {
+                    variationId = savedVariationId;
+                    noneVariation = false;
+                }
+                else {
+                    if (xpConf) {
+                        var hashDouble = _this.obtainHashDouble(experimentId, visitorCode, xpConf);
+                        var total = 0.0;
+                        for (var key in xpConf.variationConfigurations) {
+                            var variationConfiguration = xpConf.variationConfigurations[key];
+                            total += variationConfiguration.deviation;
+                            if (total >= hashDouble) {
+                                noneVariation = false;
+                                variationId = parseInt(key);
+                                _this.variationStorage.updateVariation(visitorCode, experimentId, variationConfiguration);
+                                break;
+                            }
+                        }
+                        var body = _this.getAndClearUnsentData(visitorCode);
+                        kameleoonUtils_1.default.doRequest(constants_1.API_SSX_URL +
+                            _this.getExperimentRegisterURL(visitorCode, experimentId, variationId, noneVariation), kameleoonUtils_1.HttpMethod.POST, body);
+                    }
+                    else {
+                        throw new experimentConfigurationNotFound_1.default('KameleoonException.ExperimentConfigurationNotFound');
+                    }
+                }
+                if (noneVariation) {
+                    throw new notActivated_1.default('KameleoonException.NotActivated');
+                }
+                return variationId;
+            }
+            else {
+                throw new notTargeted_1.default('KameleoonException.NotTargeted');
+            }
+        };
+        this.activateFeature = function (visitorCode, featureIdOrName) {
+            var _a, _b;
+            _this.checkFeatureKeyOrId(featureIdOrName);
+            _this.validateVisitorCode(visitorCode);
+            var featureFlag = null;
+            var featureId = -1;
+            for (var key in (_a = _this.configurations) === null || _a === void 0 ? void 0 : _a.featureFlags) {
+                var ff = (_b = _this.configurations) === null || _b === void 0 ? void 0 : _b.featureFlags[key];
+                if (key == featureIdOrName || (ff === null || ff === void 0 ? void 0 : ff.identificationKey) == featureIdOrName) {
+                    featureId = parseInt(key);
+                    featureFlag = ff;
+                }
+            }
+            _this.checkSiteEnabled(featureFlag);
+            if (_this.checkTargeting(visitorCode, featureId, true)) {
+                if (featureFlag && featureId) {
+                    var result = false;
+                    if (featureFlag.isScheduleActive()) {
+                        var hashDouble = _this.obtainHashDouble(featureId, visitorCode, featureFlag);
+                        var total = 0.0;
+                        var variationId = 0;
+                        var noneVariation = true;
+                        for (var key in featureFlag.variationConfigurations) {
+                            var variationConfiguration = featureFlag.variationConfigurations[key];
+                            total += variationConfiguration.deviation;
+                            if (total >= hashDouble) {
+                                noneVariation = false;
+                                variationId = parseInt(key);
+                                break;
+                            }
+                        }
+                        var body = _this.getAndClearUnsentData(visitorCode);
+                        kameleoonUtils_1.default.doRequest(constants_1.API_SSX_URL +
+                            _this.getExperimentRegisterURL(visitorCode, featureId, variationId, noneVariation), kameleoonUtils_1.HttpMethod.POST, body);
+                        result = variationId != 0;
+                    }
+                    return result;
+                }
+                else {
+                    throw new featureConfigurationNotFound_1.default('KameleoonException.FeatureConfigurationNotFound');
+                }
+            }
+            else {
+                throw new notTargeted_1.default('KameleoonException.NotTargeted');
+            }
+        };
+        this.generateRandomString = function () {
+            var alphabet = 'abcdefghijklmnopqrstuvwxyz0123456789';
+            var alphabetLength = alphabet.length;
+            var randomVisitorCode = '';
+            for (var i = 0; i < 16; ++i) {
+                var randomNumber = Math.floor(Math.random() * alphabetLength);
+                randomVisitorCode += alphabet[randomNumber];
+            }
+            return randomVisitorCode;
+        };
+        this.obtainVisitorCode = function (domain, defaultVisitorCode) {
+            var value;
+            var name = 'kameleoonVisitorCode';
+            var cookies = document.cookie.split(';');
+            for (var i = 0, cookiesLength = cookies.length; i < cookiesLength; ++i) {
+                var cookie = cookies[i];
+                var valuePos = cookie.indexOf('=');
+                if (cookie.substring(0, valuePos).trim() == name) {
+                    value = cookie.substring(valuePos + 1);
+                    break;
+                }
+            }
+            if (value) {
+                return value;
+            }
+            value = defaultVisitorCode || _this.generateRandomString();
+            document.cookie =
+                'kameleoonVisitorCode=' +
+                    value +
+                    '; Max-Age=32832000; Path=/; Domain=' +
+                    domain;
+            return value;
+        };
+        this.obtainHashDouble = function (containerId, visitorCode, xpConf) {
+            var joinedRespoolTime = '';
+            for (var variationId in xpConf.variationConfigurations) {
+                var variation = xpConf.variationConfigurations[variationId];
+                if (variation.respoolTime && variation.respoolTime != 0) {
+                    joinedRespoolTime += variation.respoolTime;
+                }
+            }
+            var identifier = visitorCode + containerId + joinedRespoolTime;
+            var buff = kameleoonUtils_1.default.computeStringSha256(identifier);
+            return parseInt(buff, 16) / Math.pow(2, 256);
+        };
+        this.getCommonSSXParameters = function (visitorCode) {
+            return ('&nonce=' +
+                (0, nonce_1.obtainNonce)() +
+                '&siteCode=' +
+                _this.siteCode +
+                '&visitorCode=' +
+                visitorCode);
+        };
+        this.getDataTrackingURL = function (visitorCode) {
+            return 'dataTracking?' + _this.getCommonSSXParameters(visitorCode);
+        };
+        this.getAPIDataRequestURL = function (key) {
+            return "".concat(constants_1.API_DATA_URL, "data?siteCode=").concat(_this.siteCode, "&key=").concat(key);
+        };
+        this.getEventsRequestURL = function (siteCode) {
+            return "".concat(constants_1.EVENTS_URL, "sse?siteCode=").concat(siteCode);
+        };
+        this.getExperimentRegisterURL = function (visitorCode, experimentId, variationId, noneVariation) {
+            var baseURL = 'experimentTracking?' +
+                _this.getCommonSSXParameters(visitorCode) +
+                '&experimentId=' +
+                experimentId;
+            if (variationId == null) {
+                return baseURL;
+            }
+            else {
+                return (baseURL +
+                    '&variationId=' +
+                    variationId +
+                    (noneVariation ? '&noneVariation=true' : ''));
+            }
+        };
+        this.getUnsentUsers = function () {
+            return Object.getOwnPropertyNames(_this.unsentData);
+        };
+        this.getUnsentData = function (visitorCode) {
+            if (!_this.unsentData[visitorCode]) {
+                _this.unsentData[visitorCode] = [];
+            }
+            return _this.unsentData[visitorCode];
+        };
+        this.getTargetingData = function (visitorCode) {
+            if (_this.targetingData[visitorCode] == null) {
+                _this.targetingData[visitorCode] = [];
+            }
+            return _this.targetingData[visitorCode];
+        };
+        this.emptyUnsentData = function (visitorCode) {
+            delete _this.unsentData[visitorCode];
+        };
+        this.emptyTargetingData = function () {
+            var currentTime = new Date().getTime();
+            for (var visitorCode in _this.targetingData) {
+                _this.targetingData[visitorCode] = _this.targetingData[visitorCode].reduce(function (arr, data) {
+                    if (data.lastActivityTime + constants_1.MINUTES_SESSION_DURATION > currentTime) {
+                        arr.push(data);
+                    }
+                    return arr;
+                }, []);
+            }
+            _this.saveConfiguration();
+        };
+        this.addData = function (visitorCode) {
+            var data = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                data[_i - 1] = arguments[_i];
+            }
+            _this.validateVisitorCode(visitorCode);
+            var listData = _this.getUnsentData(visitorCode);
+            var targetingDataList = _this.getTargetingData(visitorCode);
+            data.forEach(function (d) {
+                listData.push(d);
+                if (targetingDataList.length < _this.targetingDataNumberEntriesAuthorized) {
+                    targetingDataList.push(new targetingData_1.default(new Date().getTime(), d));
+                }
+                else {
+                    targetingDataList.splice(0, 1);
+                    targetingDataList.push(new targetingData_1.default(new Date().getTime(), d));
+                }
+                _this.saveConfiguration();
+            });
+        };
+        // Targeting Engine
+        // check targeting
+        this.checkTargeting = function (visitorCode, campaignId, isFF) {
+            var _a, _b;
+            var targeting = true;
+            var xpConf = null;
+            // performing targeting
+            if (isFF) {
+                xpConf = (_a = _this.configurations) === null || _a === void 0 ? void 0 : _a.featureFlags[campaignId];
+            }
+            else {
+                xpConf = (_b = _this.configurations) === null || _b === void 0 ? void 0 : _b.experiments[campaignId];
+            }
+            if (xpConf != null) {
+                if (true == xpConf.forceTargeting) {
+                    // assigning targeting to container
+                    targeting = true;
+                }
+                else {
+                    var targetingTree = void 0;
+                    if (null != xpConf.targetingSegment) {
+                        targetingTree = xpConf.targetingSegment.targetingTree;
+                    }
+                    // obtaining targeting checking result and assigning targeting to container
+                    targeting = targetingEngine_1.TargetingEngine.checkTargetingTree(targetingTree, function (type) {
+                        return _this.getConditionData(type, visitorCode, campaignId);
+                    });
+                }
+            }
+            return targeting;
+        };
+        this.getConditionData = function (type, visitorCode, campaignId) {
+            switch (type) {
+                case constants_1.ConditionTypes.CUSTOM_DATUM:
+                    return {
+                        targetingData: _this.getTargetingData(visitorCode),
+                    };
+                case constants_1.ConditionTypes.EXCLUSIVE_EXPERIMENT:
+                    return {
+                        currentExperimentId: campaignId,
+                        variationStorage: _this.variationStorage.getMapVariationId(visitorCode),
+                    };
+                case constants_1.ConditionTypes.TARGET_EXPERIMENT:
+                    return {
+                        variationStorage: _this.variationStorage.getMapVariationId(visitorCode),
+                    };
+                default:
+                    return null;
+            }
+        };
+        this.obtainVariationAssociatedData = function (variationId) {
+            var _a, _b, _c;
+            for (var vid in (_a = _this.configurations) === null || _a === void 0 ? void 0 : _a.experiments) {
+                var experiment = (_b = _this.configurations) === null || _b === void 0 ? void 0 : _b.experiments[vid];
+                if (experiment === null || experiment === void 0 ? void 0 : experiment.variationConfigurations[variationId]) {
+                    return ((_c = experiment === null || experiment === void 0 ? void 0 : experiment.variationConfigurations[variationId].customJson) !== null && _c !== void 0 ? _c : {});
+                }
+            }
+            throw new variationConfigurationNotFound_1.default('KameleoonException.VariationConfigurationNotFound');
+        };
+        this.obtainFeatureVariable = function (featureIdOrName, variable) {
+            var _a, _b, _c, _d;
+            _this.checkFeatureKeyOrId(featureIdOrName);
+            for (var ffid in (_a = _this.configurations) === null || _a === void 0 ? void 0 : _a.featureFlags) {
+                var ff = (_b = _this.configurations) === null || _b === void 0 ? void 0 : _b.featureFlags[ffid];
+                if (ffid == featureIdOrName ||
+                    (ff === null || ff === void 0 ? void 0 : ff.identificationKey) === featureIdOrName) {
+                    for (var vid in ff === null || ff === void 0 ? void 0 : ff.variationConfigurations) {
+                        if (vid !== '0') {
+                            return _this._parseJsonValue((_d = (_c = ff === null || ff === void 0 ? void 0 : ff.variationConfigurations[vid]) === null || _c === void 0 ? void 0 : _c.customJson) === null || _d === void 0 ? void 0 : _d[variable]);
+                        }
+                    }
+                }
+            }
+            throw new featureConfigurationNotFound_1.default('KameleoonExceptinpmon.FeatureConfigurationNotFound');
+        };
+        this.retrieveDataFromRemoteSource = function (key) { return __awaiter(_this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, new Promise(function (resolve) {
+                        kameleoonUtils_1.default.doRequest(_this.getAPIDataRequestURL(key), kameleoonUtils_1.HttpMethod.GET, null, function (response) {
+                            resolve(JSON.parse(response));
+                        });
+                    })];
+            });
+        }); };
+        this._parseJsonValue = function (obj) {
+            if (obj == null) {
+                throw new featureConfigurationNotFound_1.default('KameleoonException.FeatureConfigurationNotFound');
+            }
+            else {
+                switch (obj.type) {
+                    case 'Boolean':
+                        return obj.value == 'True';
+                    case 'Number':
+                        return parseInt(obj.value);
+                    case 'JSON':
+                        return JSON.parse(obj.value);
+                    default:
+                        return obj.value;
+                }
+            }
+        };
+        this.saveConfiguration = function () {
+            var _a, _b;
+            if (_this.configurations) {
+                var data = {
+                    kameleoonTargetingData: _this.targetingData,
+                    kameleoonConfiguration: {
+                        updateTime: _this.configurations.updateTime,
+                        experiments: (_a = _this.configurations.configuration) === null || _a === void 0 ? void 0 : _a.experiments,
+                        featureFlags: (_b = _this.configurations.configuration) === null || _b === void 0 ? void 0 : _b.featureFlags,
+                        configuration: _this.configurations.settings,
+                    },
+                };
+                try {
+                    localStorage.setItem('kameleoonJavaScriptClientData', JSON.stringify(data));
+                }
+                catch (e) {
+                    console.log(e);
+                }
+            }
+        };
+        this.validateVisitorCode = function (visitorCode) {
+            if (visitorCode == null || visitorCode.length == 0) {
+                throw new visitorCodeNotValid_1.VisitorCodeNotValid('Visitor code is empty');
+            }
+            else if (visitorCode.length > KameleoonClient.VISITOR_CODE_MAX_LENGTH) {
+                throw new visitorCodeNotValid_1.VisitorCodeNotValid('Visitor code max length is ' +
+                    KameleoonClient.VISITOR_CODE_MAX_LENGTH +
+                    ' characters');
+            }
+        };
+        this.onUpdateConfiguration = function (handler) {
+            _this.handlerUpdateConfiguration = handler;
+        };
+        this.siteCode = siteCode;
+        if (configuration) {
+            if (configuration.visitor_data_maximum_size) {
+                this.visitorDataMaximumSize = configuration.visitor_data_maximum_size;
+            }
+            if (configuration.actions_configuration_refresh_interval) {
+                this.minutesBetweenConfigurationUpdate =
+                    configuration.actions_configuration_refresh_interval;
+            }
+            if (configuration.environment) {
+                this.environment = configuration.environment;
+            }
+        }
+        this.targetingDataNumberEntriesAuthorized =
+            (this.visitorDataMaximumSize * 1000000) /
+                constants_1.TARGETING_DATA_MAXIMUM_SIZE_BYTES;
+        this.updateCampaignConfiguration();
+        setInterval(this.emptyTargetingData, constants_1.DEFAULT_MILLISECONDS_BETWEEN_TARGETING_DATA_UPDATE);
+    }
+    KameleoonClient.prototype.checkSiteEnabled = function (experimentOrFeatureFlag) {
+        if (experimentOrFeatureFlag != null &&
+            !experimentOrFeatureFlag.siteEnabled) {
+            throw new siteCodeDisabled_1.SiteCodeDisabled(this.siteCode);
+        }
+    };
+    KameleoonClient.prototype.checkFeatureKeyOrId = function (featureIdOrName) {
+        if (typeof featureIdOrName === 'string') {
+            console.log('Please use `featureIdOrName` with type of `string`. This is necessary to support multi-environment feature. Supporting of `number` type will be removed in next releases');
+        }
+    };
+    KameleoonClient.prototype.getAndClearUnsentData = function (visitorCode) {
+        var body = '';
+        this.getUnsentData(visitorCode).forEach(function (element) {
+            body += element.obtainFullPostTextLine() + '\n';
+        });
+        this.emptyUnsentData(visitorCode);
+        return body;
+    };
+    KameleoonClient.prototype.manageConfiguraitonUpdate = function (subsciptionRequired) {
+        var _this = this;
+        if (subsciptionRequired && !this.realTimeConfigurationService) {
+            this.realTimeConfigurationService = new realTimeConfigurationService_1.RealTimeConfigurationService(this.getEventsRequestURL(this.siteCode), function (event) {
+                _this.updateCampaignConfiguration(event.ts);
+            });
+        }
+        else if (!subsciptionRequired) {
+            if (this.realTimeConfigurationService) {
+                this.realTimeConfigurationService.disconnect();
+                this.realTimeConfigurationService = null;
+            }
+            setTimeout(this.updateCampaignConfiguration, this.minutesBetweenConfigurationUpdate * constants_1.Milliseconds.Minute);
+        }
+    };
+    KameleoonClient.prototype.fireUpdateConfigurationHandler = function (fire) {
+        fire &&
+            this.handlerUpdateConfiguration &&
+            this.handlerUpdateConfiguration();
+    };
+    KameleoonClient.VISITOR_CODE_MAX_LENGTH = 255;
+    return KameleoonClient;
+}());
+exports.KameleoonClient = KameleoonClient;
+var KameleoonException = {
+    ExperimentConfigurationNotFound: experimentConfigurationNotFound_1.default,
+    FeatureConfigurationNotFound: featureConfigurationNotFound_1.default,
+    VariationConfigurationNotFound: variationConfigurationNotFound_1.default,
+    NotTargeted: notTargeted_1.default,
+    NotActivated: notActivated_1.default,
+    CredentialsNotFound: credentialsNotFound_1.default,
+};
+exports.KameleoonException = KameleoonException;
+//# sourceMappingURL=kameleoonClient.js.map