@splitsoftware/splitio-commons 2.12.0 → 2.12.2

package/esm/sdkClient/clientInputValidation.js

@@ -34,97 +34,68 @@ export function clientInputValidationDecorator(settings, client, readinessManage
         };
     }
     function evaluateFallBackTreatment(featureFlagName, withConfig) {
-        var _a = fallbackTreatmentsCalculator.resolve(featureFlagName, ''), treatment = _a.treatment, config = _a.config;
-        if (withConfig) {
-            return {
+        if (Array.isArray(featureFlagName)) {
+            var res_1 = {};
+            featureFlagName.forEach(function (split) { return res_1[split] = evaluateFallBackTreatment(split, withConfig); });
+            return res_1;
+        }
+        var _a = fallbackTreatmentsCalculator(featureFlagName), treatment = _a.treatment, config = _a.config;
+        return withConfig ?
+            {
                 treatment: treatment,
                 config: config
-            };
-        }
-        return treatment;
+            } : treatment;
     }
     function wrapResult(value) {
         return isAsync ? Promise.resolve(value) : value;
     }
     function getTreatment(maybeKey, maybeFeatureFlagName, maybeAttributes, maybeOptions) {
         var params = validateEvaluationParams(GET_TREATMENT, maybeKey, maybeFeatureFlagName, maybeAttributes, maybeOptions);
-        if (params.valid) {
-            return client.getTreatment(params.key, params.nameOrNames, params.attributes, params.options);
-        }
-        else {
-            var result = evaluateFallBackTreatment(params.nameOrNames, false);
-            return wrapResult(result);
-        }
+        return params.valid ?
+            client.getTreatment(params.key, params.nameOrNames, params.attributes, params.options) :
+            wrapResult(evaluateFallBackTreatment(params.nameOrNames, false));
     }
     function getTreatmentWithConfig(maybeKey, maybeFeatureFlagName, maybeAttributes, maybeOptions) {
         var params = validateEvaluationParams(GET_TREATMENT_WITH_CONFIG, maybeKey, maybeFeatureFlagName, maybeAttributes, maybeOptions);
-        if (params.valid) {
-            return client.getTreatmentWithConfig(params.key, params.nameOrNames, params.attributes, params.options);
-        }
-        else {
-            var result = evaluateFallBackTreatment(params.nameOrNames, true);
-            return wrapResult(result);
-        }
+        return params.valid ?
+            client.getTreatmentWithConfig(params.key, params.nameOrNames, params.attributes, params.options) :
+            wrapResult(evaluateFallBackTreatment(params.nameOrNames, true));
     }
     function getTreatments(maybeKey, maybeFeatureFlagNames, maybeAttributes, maybeOptions) {
         var params = validateEvaluationParams(GET_TREATMENTS, maybeKey, maybeFeatureFlagNames, maybeAttributes, maybeOptions);
-        if (params.valid) {
-            return client.getTreatments(params.key, params.nameOrNames, params.attributes, params.options);
-        }
-        else {
-            var res_1 = {};
-            if (params.nameOrNames)
-                params.nameOrNames.forEach(function (split) { return res_1[split] = evaluateFallBackTreatment(split, false); });
-            return wrapResult(res_1);
-        }
+        return params.valid ?
+            client.getTreatments(params.key, params.nameOrNames, params.attributes, params.options) :
+            wrapResult(evaluateFallBackTreatment(params.nameOrNames || [], false));
     }
     function getTreatmentsWithConfig(maybeKey, maybeFeatureFlagNames, maybeAttributes, maybeOptions) {
         var params = validateEvaluationParams(GET_TREATMENTS_WITH_CONFIG, maybeKey, maybeFeatureFlagNames, maybeAttributes, maybeOptions);
-        if (params.valid) {
-            return client.getTreatmentsWithConfig(params.key, params.nameOrNames, params.attributes, params.options);
-        }
-        else {
-            var res_2 = {};
-            if (params.nameOrNames)
-                params.nameOrNames.forEach(function (split) { return res_2[split] = evaluateFallBackTreatment(split, true); });
-            return wrapResult(res_2);
-        }
+        return params.valid ?
+            client.getTreatmentsWithConfig(params.key, params.nameOrNames, params.attributes, params.options) :
+            wrapResult(evaluateFallBackTreatment(params.nameOrNames || [], true));
     }
     function getTreatmentsByFlagSets(maybeKey, maybeFlagSets, maybeAttributes, maybeOptions) {
         var params = validateEvaluationParams(GET_TREATMENTS_BY_FLAG_SETS, maybeKey, maybeFlagSets, maybeAttributes, maybeOptions);
-        if (params.valid) {
-            return client.getTreatmentsByFlagSets(params.key, params.nameOrNames, params.attributes, params.options);
-        }
-        else {
-            return wrapResult({});
-        }
+        return params.valid ?
+            client.getTreatmentsByFlagSets(params.key, params.nameOrNames, params.attributes, params.options) :
+            wrapResult({});
     }
     function getTreatmentsWithConfigByFlagSets(maybeKey, maybeFlagSets, maybeAttributes, maybeOptions) {
         var params = validateEvaluationParams(GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, maybeKey, maybeFlagSets, maybeAttributes, maybeOptions);
-        if (params.valid) {
-            return client.getTreatmentsWithConfigByFlagSets(params.key, params.nameOrNames, params.attributes, params.options);
-        }
-        else {
-            return wrapResult({});
-        }
+        return params.valid ?
+            client.getTreatmentsWithConfigByFlagSets(params.key, params.nameOrNames, params.attributes, params.options) :
+            wrapResult({});
     }
     function getTreatmentsByFlagSet(maybeKey, maybeFlagSet, maybeAttributes, maybeOptions) {
         var params = validateEvaluationParams(GET_TREATMENTS_BY_FLAG_SET, maybeKey, [maybeFlagSet], maybeAttributes, maybeOptions);
-        if (params.valid) {
-            return client.getTreatmentsByFlagSet(params.key, params.nameOrNames[0], params.attributes, params.options);
-        }
-        else {
-            return wrapResult({});
-        }
+        return params.valid ?
+            client.getTreatmentsByFlagSet(params.key, params.nameOrNames[0], params.attributes, params.options) :
+            wrapResult({});
     }
     function getTreatmentsWithConfigByFlagSet(maybeKey, maybeFlagSet, maybeAttributes, maybeOptions) {
         var params = validateEvaluationParams(GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, maybeKey, [maybeFlagSet], maybeAttributes, maybeOptions);
-        if (params.valid) {
-            return client.getTreatmentsWithConfigByFlagSet(params.key, params.nameOrNames[0], params.attributes, params.options);
-        }
-        else {
-            return wrapResult({});
-        }
+        return params.valid ?
+            client.getTreatmentsWithConfigByFlagSet(params.key, params.nameOrNames[0], params.attributes, params.options) :
+            wrapResult({});
     }
     function track(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties) {
         var key = validateKey(log, maybeKey, TRACK_FN_LABEL);
@@ -133,12 +104,9 @@ export function clientInputValidationDecorator(settings, client, readinessManage
         var eventValue = validateEventValue(log, maybeEventValue, TRACK_FN_LABEL);
         var _a = validateEventProperties(log, maybeProperties, TRACK_FN_LABEL), properties = _a.properties, size = _a.size;
         var isNotDestroyed = validateIfNotDestroyed(log, readinessManager, TRACK_FN_LABEL);
-        if (isNotDestroyed && key && tt && event && eventValue !== false && properties !== false) { // @ts-expect-error
-            return client.track(key, tt, event, eventValue, properties, size);
-        }
-        else {
-            return isAsync ? Promise.resolve(false) : false;
-        }
+        return isNotDestroyed && key && tt && event && eventValue !== false && properties !== false ? // @ts-expect-error
+            client.track(key, tt, event, eventValue, properties, size) :
+            wrapResult(false);
     }
     return {
         getTreatment: getTreatment,

package/esm/sdkClient/identity.js

@@ -1,3 +1,3 @@
 export function buildInstanceId(key, trafficType) {
-    return (key.matchingKey ? key.matchingKey : key) + "-" + (key.bucketingKey ? key.bucketingKey : key) + "-" + (trafficType ? trafficType : '');
+    return "".concat(key.matchingKey ? key.matchingKey : key, "-").concat(key.bucketingKey ? key.bucketingKey : key, "-").concat(trafficType ? trafficType : '');
 }

package/esm/sdkClient/sdkClient.js

@@ -1,13 +1,14 @@
 import { objectAssign } from '../utils/lang/objectAssign';
-import { releaseApiKey } from '../utils/inputValidation/apiKey';
+import { releaseApiKey, validateAndTrackApiKey } from '../utils/inputValidation/apiKey';
 import { clientFactory } from './client';
 import { clientInputValidationDecorator } from './clientInputValidation';
 var COOLDOWN_TIME_IN_MILLIS = 1000;
 /**
- * Creates an Sdk client, i.e., a base client with status and destroy interface
+ * Creates an Sdk client, i.e., a base client with status, init, flush and destroy interface
  */
 export function sdkClientFactory(params, isSharedClient) {
-    var sdkReadinessManager = params.sdkReadinessManager, syncManager = params.syncManager, storage = params.storage, signalListener = params.signalListener, settings = params.settings, telemetryTracker = params.telemetryTracker, uniqueKeysTracker = params.uniqueKeysTracker;
+    var sdkReadinessManager = params.sdkReadinessManager, syncManager = params.syncManager, storage = params.storage, signalListener = params.signalListener, settings = params.settings, telemetryTracker = params.telemetryTracker, impressionsTracker = params.impressionsTracker;
+    var hasInit = false;
     var lastActionTime = 0;
     function __cooldown(func, time) {
         var now = Date.now();
@@ -16,7 +17,7 @@ export function sdkClientFactory(params, isSharedClient) {
         //check if the time elapsed is less than desired cooldown
         if (timeElapsed < time) {
             //if yes, return message with remaining time in seconds
-            settings.log.warn("Flush cooldown, remaining time " + (time - timeElapsed) / 1000 + " seconds");
+            settings.log.warn("Flush cooldown, remaining time ".concat((time - timeElapsed) / 1000, " seconds"));
             return Promise.resolve();
         }
         else {
@@ -32,14 +33,25 @@ export function sdkClientFactory(params, isSharedClient) {
     // Proto-linkage of the readiness Event Emitter
     Object.create(sdkReadinessManager.sdkStatus), 
     // Client API (getTreatment* & track methods)
-    clientInputValidationDecorator(settings, clientFactory(params), sdkReadinessManager.readinessManager, params.fallbackTreatmentsCalculator), 
-    // Sdk destroy
-    {
+    clientInputValidationDecorator(settings, clientFactory(params), sdkReadinessManager.readinessManager, params.fallbackTreatmentsCalculator), {
+        init: function () {
+            if (hasInit)
+                return;
+            hasInit = true;
+            if (!isSharedClient) {
+                validateAndTrackApiKey(settings.log, settings.core.authorizationKey);
+                sdkReadinessManager.readinessManager.init();
+                impressionsTracker.start();
+                syncManager && syncManager.start();
+                signalListener && signalListener.start();
+            }
+        },
         flush: function () {
             // @TODO define cooldown time
             return __cooldown(__flush, COOLDOWN_TIME_IN_MILLIS);
         },
         destroy: function () {
+            hasInit = false;
             // Mark the SDK as destroyed immediately
             sdkReadinessManager.readinessManager.destroy();
             // For main client, cleanup the SDK Key, listeners and scheduled jobs, and record stat before flushing data
@@ -47,7 +59,7 @@ export function sdkClientFactory(params, isSharedClient) {
                 releaseApiKey(settings.core.authorizationKey);
                 telemetryTracker.sessionLength();
                 signalListener && signalListener.stop();
-                uniqueKeysTracker.stop();
+                impressionsTracker.stop();
             }
             // Stop background jobs
             syncManager && syncManager.stop();

package/esm/sdkFactory/index.js

@@ -2,16 +2,10 @@ import { sdkReadinessManagerFactory } from '../readiness/sdkReadinessManager';
 import { impressionsTrackerFactory } from '../trackers/impressionsTracker';
 import { eventTrackerFactory } from '../trackers/eventTracker';
 import { telemetryTrackerFactory } from '../trackers/telemetryTracker';
-import { validateAndTrackApiKey } from '../utils/inputValidation/apiKey';
 import { createLoggerAPI } from '../logger/sdkLogger';
 import { NEW_FACTORY, RETRIEVE_MANAGER } from '../logger/constants';
 import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../readiness/constants';
 import { objectAssign } from '../utils/lang/objectAssign';
-import { strategyDebugFactory } from '../trackers/strategy/strategyDebug';
-import { strategyOptimizedFactory } from '../trackers/strategy/strategyOptimized';
-import { strategyNoneFactory } from '../trackers/strategy/strategyNone';
-import { uniqueKeysTrackerFactory } from '../trackers/uniqueKeysTracker';
-import { DEBUG, OPTIMIZED } from '../utils/constants';
 import { setRolloutPlan } from '../storages/setRolloutPlan';
 import { getMatching } from '../utils/key';
 import { FallbackTreatmentsCalculator } from '../evaluator/fallbackTreatmentsCalculator';
@@ -19,19 +13,10 @@ import { FallbackTreatmentsCalculator } from '../evaluator/fallbackTreatmentsCal
  * Modular SDK factory
  */
 export function sdkFactory(params) {
-    var settings = params.settings, platform = params.platform, storageFactory = params.storageFactory, splitApiFactory = params.splitApiFactory, extraProps = params.extraProps, syncManagerFactory = params.syncManagerFactory, SignalListener = params.SignalListener, impressionsObserverFactory = params.impressionsObserverFactory, integrationsManagerFactory = params.integrationsManagerFactory, sdkManagerFactory = params.sdkManagerFactory, sdkClientMethodFactory = params.sdkClientMethodFactory, filterAdapterFactory = params.filterAdapterFactory, lazyInit = params.lazyInit;
-    var log = settings.log, impressionsMode = settings.sync.impressionsMode, initialRolloutPlan = settings.initialRolloutPlan, key = settings.core.key;
+    var settings = params.settings, platform = params.platform, storageFactory = params.storageFactory, splitApiFactory = params.splitApiFactory, extraProps = params.extraProps, syncManagerFactory = params.syncManagerFactory, SignalListener = params.SignalListener, integrationsManagerFactory = params.integrationsManagerFactory, sdkManagerFactory = params.sdkManagerFactory, sdkClientMethodFactory = params.sdkClientMethodFactory, lazyInit = params.lazyInit;
+    var log = settings.log, initialRolloutPlan = settings.initialRolloutPlan, key = settings.core.key;
     // @TODO handle non-recoverable errors, such as, global `fetch` not available, invalid SDK Key, etc.
     // On non-recoverable errors, we should mark the SDK as destroyed and not start synchronization.
-    // initialization
-    var hasInit = false;
-    var initCallbacks = [];
-    function whenInit(cb) {
-        if (hasInit)
-            cb();
-        else
-            initCallbacks.push(cb);
-    }
     var sdkReadinessManager = sdkReadinessManagerFactory(platform.EventEmitter, settings);
     var readiness = sdkReadinessManager.readinessManager;
     var storage = storageFactory({
@@ -49,7 +34,7 @@ export function sdkFactory(params) {
             readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
         }
     });
-    var fallbackTreatmentsCalculator = new FallbackTreatmentsCalculator(settings.fallbackTreatments);
+    var fallbackTreatmentsCalculator = FallbackTreatmentsCalculator(settings.fallbackTreatments);
     if (initialRolloutPlan) {
         setRolloutPlan(log, initialRolloutPlan, storage, key && getMatching(key));
         if (storage.splits.getChangeNumber() > -1)
@@ -58,38 +43,21 @@ export function sdkFactory(params) {
     var clients = {};
     var telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
     var integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings: settings, storage: storage, telemetryTracker: telemetryTracker });
-    var observer = impressionsObserverFactory();
-    var uniqueKeysTracker = uniqueKeysTrackerFactory(log, storage.uniqueKeys, filterAdapterFactory && filterAdapterFactory());
-    var noneStrategy = strategyNoneFactory(storage.impressionCounts, uniqueKeysTracker);
-    var strategy = impressionsMode === OPTIMIZED ?
-        strategyOptimizedFactory(observer, storage.impressionCounts) :
-        impressionsMode === DEBUG ?
-            strategyDebugFactory(observer) :
-            noneStrategy;
-    var impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, noneStrategy, strategy, whenInit, integrationsManager, storage.telemetry);
-    var eventTracker = eventTrackerFactory(settings, storage.events, whenInit, integrationsManager, storage.telemetry);
+    var impressionsTracker = impressionsTrackerFactory(params, storage, integrationsManager);
+    var eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager, storage.telemetry);
     // splitApi is used by SyncManager and Browser signal listener
     var splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);
-    var ctx = { clients: clients, splitApi: splitApi, eventTracker: eventTracker, impressionsTracker: impressionsTracker, telemetryTracker: telemetryTracker, uniqueKeysTracker: uniqueKeysTracker, sdkReadinessManager: sdkReadinessManager, readiness: readiness, settings: settings, storage: storage, platform: platform, fallbackTreatmentsCalculator: fallbackTreatmentsCalculator };
+    var ctx = { clients: clients, splitApi: splitApi, eventTracker: eventTracker, impressionsTracker: impressionsTracker, telemetryTracker: telemetryTracker, sdkReadinessManager: sdkReadinessManager, readiness: readiness, settings: settings, storage: storage, platform: platform, fallbackTreatmentsCalculator: fallbackTreatmentsCalculator };
     var syncManager = syncManagerFactory && syncManagerFactory(ctx);
     ctx.syncManager = syncManager;
+    // @TODO: move into platform, and call inside sdkClientFactory (if it's used only there)
     var signalListener = SignalListener && new SignalListener(syncManager, settings, storage, splitApi);
     ctx.signalListener = signalListener;
     // SDK client and manager
     var clientMethod = sdkClientMethodFactory(ctx);
     var managerInstance = sdkManagerFactory(settings, storage.splits, sdkReadinessManager);
     function init() {
-        if (hasInit)
-            return;
-        hasInit = true;
-        // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
-        validateAndTrackApiKey(log, settings.core.authorizationKey);
-        readiness.init();
-        uniqueKeysTracker.start();
-        syncManager && syncManager.start();
-        signalListener && signalListener.start();
-        initCallbacks.forEach(function (cb) { return cb(); });
-        initCallbacks.length = 0;
+        Object.keys(clients).map(function (key) { return clients[key].init(); });
     }
     log.info(NEW_FACTORY, [settings.version]);
     // @ts-ignore
@@ -105,7 +73,6 @@ export function sdkFactory(params) {
         Logger: createLoggerAPI(log),
         settings: settings,
         destroy: function () {
-            hasInit = false;
             return Promise.all(Object.keys(clients).map(function (key) { return clients[key].destroy(); })).then(function () { });
         }
     }, extraProps && extraProps(ctx), lazyInit ? { init: init } : init());

package/esm/services/splitApi.js

@@ -21,15 +21,15 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
     return {
         // @TODO throw errors if health check requests fail, to log them in the Synchronizer
         getSdkAPIHealthCheck: function () {
-            var url = urls.sdk + "/version";
+            var url = "".concat(urls.sdk, "/version");
             return splitHttpClient(url).then(function () { return true; }).catch(function () { return false; });
         },
         getEventsAPIHealthCheck: function () {
-            var url = urls.events + "/version";
+            var url = "".concat(urls.events, "/version");
             return splitHttpClient(url).then(function () { return true; }).catch(function () { return false; });
         },
         fetchAuth: function (userMatchingKeys) {
-            var url = urls.auth + "/v2/auth?s=" + settings.sync.flagSpecVersion;
+            var url = "".concat(urls.auth, "/v2/auth?s=").concat(settings.sync.flagSpecVersion);
             if (userMatchingKeys) { // `userMatchingKeys` is undefined in server-side
                 var queryParams = userMatchingKeys.map(userKeyToQueryParam).join('&');
                 if (queryParams)
@@ -38,7 +38,7 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
             return splitHttpClient(url, undefined, telemetryTracker.trackHttp(TOKEN));
         },
         fetchSplitChanges: function (since, noCache, till, rbSince) {
-            var url = urls.sdk + "/splitChanges?s=" + settings.sync.flagSpecVersion + "&since=" + since + (rbSince ? '&rbSince=' + rbSince : '') + (filterQueryString || '') + (till ? '&till=' + till : '');
+            var url = "".concat(urls.sdk, "/splitChanges?s=").concat(settings.sync.flagSpecVersion, "&since=").concat(since).concat(rbSince ? '&rbSince=' + rbSince : '').concat(filterQueryString || '').concat(till ? '&till=' + till : '');
             return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SPLITS))
                 .catch(function (err) {
                 if (err.statusCode === 414)
@@ -47,7 +47,7 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
             });
         },
         fetchSegmentChanges: function (since, segmentName, noCache, till) {
-            var url = urls.sdk + "/segmentChanges/" + segmentName + "?since=" + since + (till ? '&till=' + till : '');
+            var url = "".concat(urls.sdk, "/segmentChanges/").concat(segmentName, "?since=").concat(since).concat(till ? '&till=' + till : '');
             return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SEGMENT));
         },
         fetchMemberships: function (userMatchingKey, noCache, till) {
@@ -57,7 +57,7 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
              *  - avoid 404 responses. E.g.: '/api/memberships/foo/bar'
              *  - match user keys with special characters. E.g.: 'foo%bar', 'foo/bar'
              */
-            var url = urls.sdk + "/memberships/" + encodeURIComponent(userMatchingKey) + (till ? '?till=' + till : '');
+            var url = "".concat(urls.sdk, "/memberships/").concat(encodeURIComponent(userMatchingKey)).concat(till ? '?till=' + till : '');
             return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(MEMBERSHIPS));
         },
         /**
@@ -67,7 +67,7 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
          * @param headers -  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.
          */
         postEventsBulk: function (body, headers) {
-            var url = urls.events + "/events/bulk";
+            var url = "".concat(urls.events, "/events/bulk");
             return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(EVENTS));
         },
         /**
@@ -77,7 +77,7 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
          * @param headers -  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.
          */
         postTestImpressionsBulk: function (body, headers) {
-            var url = urls.events + "/testImpressions/bulk";
+            var url = "".concat(urls.events, "/testImpressions/bulk");
             return splitHttpClient(url, {
                 // Adding extra headers to send impressions in OPTIMIZED or DEBUG modes.
                 method: 'POST',
@@ -92,7 +92,7 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
          * @param headers -  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.
          */
         postTestImpressionsCount: function (body, headers) {
-            var url = urls.events + "/testImpressions/count";
+            var url = "".concat(urls.events, "/testImpressions/count");
             return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(IMPRESSIONS_COUNT));
         },
         /**
@@ -102,7 +102,7 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
          * @param headers -  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.
          */
         postUniqueKeysBulkCs: function (body, headers) {
-            var url = urls.telemetry + "/v1/keys/cs";
+            var url = "".concat(urls.telemetry, "/v1/keys/cs");
             return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY));
         },
         /**
@@ -112,15 +112,15 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
          * @param headers -  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.
          */
         postUniqueKeysBulkSs: function (body, headers) {
-            var url = urls.telemetry + "/v1/keys/ss";
+            var url = "".concat(urls.telemetry, "/v1/keys/ss");
             return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY));
         },
         postMetricsConfig: function (body, headers) {
-            var url = urls.telemetry + "/v1/metrics/config";
+            var url = "".concat(urls.telemetry, "/v1/metrics/config");
             return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY), true);
         },
         postMetricsUsage: function (body, headers) {
-            var url = urls.telemetry + "/v1/metrics/usage";
+            var url = "".concat(urls.telemetry, "/v1/metrics/usage");
             return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY), true);
         }
     };

package/esm/services/splitHttpClient.js

@@ -21,7 +21,7 @@ export function splitHttpClientFactory(settings, _a) {
     var commonHeaders = {
         'Accept': 'application/json',
         'Content-Type': 'application/json',
-        'Authorization': "Bearer " + authorizationKey,
+        'Authorization': "Bearer ".concat(authorizationKey),
         'SplitSDKVersion': version
     };
     if (ip)

package/esm/storages/KeyBuilder.js

@@ -10,34 +10,34 @@ var KeyBuilder = /** @class */ (function () {
         this.prefix = prefix;
     }
     KeyBuilder.prototype.buildTrafficTypeKey = function (trafficType) {
-        return this.prefix + ".trafficType." + trafficType;
+        return "".concat(this.prefix, ".trafficType.").concat(trafficType);
     };
     KeyBuilder.prototype.buildFlagSetKey = function (flagSet) {
-        return this.prefix + ".flagSet." + flagSet;
+        return "".concat(this.prefix, ".flagSet.").concat(flagSet);
     };
     KeyBuilder.prototype.buildSplitKey = function (splitName) {
-        return this.prefix + ".split." + splitName;
+        return "".concat(this.prefix, ".split.").concat(splitName);
     };
     KeyBuilder.prototype.buildSplitsTillKey = function () {
-        return this.prefix + ".splits.till";
+        return "".concat(this.prefix, ".splits.till");
     };
     KeyBuilder.prototype.buildSplitKeyPrefix = function () {
-        return this.prefix + ".split.";
+        return "".concat(this.prefix, ".split.");
     };
     KeyBuilder.prototype.buildRBSegmentKey = function (rbsegmentName) {
-        return this.prefix + ".rbsegment." + rbsegmentName;
+        return "".concat(this.prefix, ".rbsegment.").concat(rbsegmentName);
     };
     KeyBuilder.prototype.buildRBSegmentsTillKey = function () {
-        return this.prefix + ".rbsegments.till";
+        return "".concat(this.prefix, ".rbsegments.till");
     };
     KeyBuilder.prototype.buildRBSegmentKeyPrefix = function () {
-        return this.prefix + ".rbsegment.";
+        return "".concat(this.prefix, ".rbsegment.");
     };
     KeyBuilder.prototype.buildSegmentNameKey = function (segmentName) {
-        return this.prefix + ".segment." + segmentName;
+        return "".concat(this.prefix, ".segment.").concat(segmentName);
     };
     KeyBuilder.prototype.buildSegmentTillKey = function (segmentName) {
-        return this.prefix + ".segment." + segmentName + ".till";
+        return "".concat(this.prefix, ".segment.").concat(segmentName, ".till");
     };
     KeyBuilder.prototype.extractKey = function (builtKey) {
         var s = builtKey.match(everythingAtTheEnd);
@@ -49,7 +49,7 @@ var KeyBuilder = /** @class */ (function () {
         }
     };
     KeyBuilder.prototype.buildHashKey = function () {
-        return this.prefix + ".hash";
+        return "".concat(this.prefix, ".hash");
     };
     return KeyBuilder;
 }());
@@ -59,5 +59,5 @@ export { KeyBuilder };
  * The hash is in hexadecimal format (8 characters max, 32 bits).
  */
 export function getStorageHash(settings) {
-    return hash(settings.core.authorizationKey + "::" + settings.sync.__splitFiltersValidation.queryString + "::" + settings.sync.flagSpecVersion).toString(16);
+    return hash("".concat(settings.core.authorizationKey, "::").concat(settings.sync.__splitFiltersValidation.queryString, "::").concat(settings.sync.flagSpecVersion)).toString(16);
 }

package/esm/storages/KeyBuilderCS.js

@@ -6,40 +6,40 @@ var KeyBuilderCS = /** @class */ (function (_super) {
     function KeyBuilderCS(prefix, matchingKey) {
         var _this = _super.call(this, prefix) || this;
         _this.matchingKey = matchingKey;
-        _this.regexSplitsCacheKey = new RegExp("^" + prefix + "\\.(splits?|trafficType|flagSet)\\.");
+        _this.regexSplitsCacheKey = new RegExp("^".concat(prefix, "\\.(splits?|trafficType|flagSet)\\."));
         return _this;
     }
     /**
      * @override
      */
     KeyBuilderCS.prototype.buildSegmentNameKey = function (segmentName) {
-        return this.prefix + "." + this.matchingKey + ".segment." + segmentName;
+        return "".concat(this.prefix, ".").concat(this.matchingKey, ".segment.").concat(segmentName);
     };
     KeyBuilderCS.prototype.extractSegmentName = function (builtSegmentKeyName) {
-        var prefix = this.prefix + "." + this.matchingKey + ".segment.";
+        var prefix = "".concat(this.prefix, ".").concat(this.matchingKey, ".segment.");
         if (startsWith(builtSegmentKeyName, prefix))
             return builtSegmentKeyName.slice(prefix.length);
     };
     KeyBuilderCS.prototype.buildLastUpdatedKey = function () {
-        return this.prefix + ".splits.lastUpdated";
+        return "".concat(this.prefix, ".splits.lastUpdated");
     };
     KeyBuilderCS.prototype.isSplitsCacheKey = function (key) {
         return this.regexSplitsCacheKey.test(key);
     };
     KeyBuilderCS.prototype.buildTillKey = function () {
-        return this.prefix + "." + this.matchingKey + ".segments.till";
+        return "".concat(this.prefix, ".").concat(this.matchingKey, ".segments.till");
     };
     KeyBuilderCS.prototype.isSplitKey = function (key) {
-        return startsWith(key, this.prefix + ".split.");
+        return startsWith(key, "".concat(this.prefix, ".split."));
     };
     KeyBuilderCS.prototype.isRBSegmentKey = function (key) {
-        return startsWith(key, this.prefix + ".rbsegment.");
+        return startsWith(key, "".concat(this.prefix, ".rbsegment."));
     };
     KeyBuilderCS.prototype.buildSplitsWithSegmentCountKey = function () {
-        return this.prefix + ".splits.usingSegments";
+        return "".concat(this.prefix, ".splits.usingSegments");
     };
     KeyBuilderCS.prototype.buildLastClear = function () {
-        return this.prefix + ".lastClear";
+        return "".concat(this.prefix, ".lastClear");
     };
     return KeyBuilderCS;
 }(KeyBuilder));
@@ -47,15 +47,15 @@ export { KeyBuilderCS };
 export function myLargeSegmentsKeyBuilder(prefix, matchingKey) {
     return {
         buildSegmentNameKey: function (segmentName) {
-            return prefix + "." + matchingKey + ".largeSegment." + segmentName;
+            return "".concat(prefix, ".").concat(matchingKey, ".largeSegment.").concat(segmentName);
         },
         extractSegmentName: function (builtSegmentKeyName) {
-            var p = prefix + "." + matchingKey + ".largeSegment.";
+            var p = "".concat(prefix, ".").concat(matchingKey, ".largeSegment.");
             if (startsWith(builtSegmentKeyName, p))
                 return builtSegmentKeyName.slice(p.length);
         },
         buildTillKey: function () {
-            return prefix + "." + matchingKey + ".largeSegments.till";
+            return "".concat(prefix, ".").concat(matchingKey, ".largeSegments.till");
         }
     };
 }

package/esm/storages/KeyBuilderSS.js

@@ -15,42 +15,42 @@ var KeyBuilderSS = /** @class */ (function (_super) {
     __extends(KeyBuilderSS, _super);
     function KeyBuilderSS(prefix, metadata) {
         var _this = _super.call(this, prefix) || this;
-        _this.latencyPrefix = _this.prefix + ".telemetry.latencies";
-        _this.exceptionPrefix = _this.prefix + ".telemetry.exceptions";
-        _this.initPrefix = _this.prefix + ".telemetry.init";
-        _this.versionablePrefix = metadata.s + "/" + metadata.n + "/" + metadata.i;
+        _this.latencyPrefix = "".concat(_this.prefix, ".telemetry.latencies");
+        _this.exceptionPrefix = "".concat(_this.prefix, ".telemetry.exceptions");
+        _this.initPrefix = "".concat(_this.prefix, ".telemetry.init");
+        _this.versionablePrefix = "".concat(metadata.s, "/").concat(metadata.n, "/").concat(metadata.i);
         return _this;
     }
     KeyBuilderSS.prototype.buildRegisteredSegmentsKey = function () {
-        return this.prefix + ".segments.registered";
+        return "".concat(this.prefix, ".segments.registered");
     };
     KeyBuilderSS.prototype.buildImpressionsKey = function () {
-        return this.prefix + ".impressions";
+        return "".concat(this.prefix, ".impressions");
     };
     KeyBuilderSS.prototype.buildImpressionsCountKey = function () {
-        return this.prefix + ".impressions.count";
+        return "".concat(this.prefix, ".impressions.count");
     };
     KeyBuilderSS.prototype.buildUniqueKeysKey = function () {
-        return this.prefix + ".uniquekeys";
+        return "".concat(this.prefix, ".uniquekeys");
     };
     KeyBuilderSS.prototype.buildEventsKey = function () {
-        return this.prefix + ".events";
+        return "".concat(this.prefix, ".events");
     };
     KeyBuilderSS.prototype.searchPatternForSplitKeys = function () {
-        return this.buildSplitKeyPrefix() + "*";
+        return "".concat(this.buildSplitKeyPrefix(), "*");
     };
     KeyBuilderSS.prototype.searchPatternForRBSegmentKeys = function () {
-        return this.buildRBSegmentKeyPrefix() + "*";
+        return "".concat(this.buildRBSegmentKeyPrefix(), "*");
     };
     /* Telemetry keys */
     KeyBuilderSS.prototype.buildLatencyKey = function (method, bucket) {
-        return this.latencyPrefix + "::" + this.versionablePrefix + "/" + METHOD_NAMES[method] + "/" + bucket;
+        return "".concat(this.latencyPrefix, "::").concat(this.versionablePrefix, "/").concat(METHOD_NAMES[method], "/").concat(bucket);
     };
     KeyBuilderSS.prototype.buildExceptionKey = function (method) {
-        return this.exceptionPrefix + "::" + this.versionablePrefix + "/" + METHOD_NAMES[method];
+        return "".concat(this.exceptionPrefix, "::").concat(this.versionablePrefix, "/").concat(METHOD_NAMES[method]);
     };
     KeyBuilderSS.prototype.buildInitKey = function () {
-        return this.initPrefix + "::" + this.versionablePrefix;
+        return "".concat(this.initPrefix, "::").concat(this.versionablePrefix);
     };
     return KeyBuilderSS;
 }(KeyBuilder));

package/esm/storages/getRolloutPlan.js

@@ -7,7 +7,7 @@ export function getRolloutPlan(log, storage, options) {
     if (options === void 0) { options = {}; }
     var keys = options.keys, exposeSegments = options.exposeSegments;
     var splits = storage.splits, segments = storage.segments, rbSegments = storage.rbSegments;
-    log.debug("storage: get feature flags" + (keys ? ", and memberships for keys: " + keys : '') + (exposeSegments ? ', and segments' : ''));
+    log.debug("storage: get feature flags".concat(keys ? ", and memberships for keys: ".concat(keys) : '').concat(exposeSegments ? ', and segments' : ''));
     return {
         splitChanges: {
             ff: {