@splitsoftware/splitio-commons 3.1.1-rc.1 → 3.1.1-rc.10

package/esm/sdkClient/clientInputValidation.js

@@ -1,13 +1,13 @@
-import { validateAttributes, validateKey, validateDefinition, validateDefinitions, validateIfNotDestroyed, validateIfReadyFromCache, validateEvaluationOptions } from '../utils/inputValidation';
+import { validateAttributes, validateEvent, validateEventValue, validateEventProperties, validateKey, validateSplit, validateSplits, validateTrafficType, validateIfNotDestroyed, validateIfReadyFromCache, validateEvaluationOptions } from '../utils/inputValidation';
 import { startsWith } from '../utils/lang';
-import { GET_TREATMENT, GET_TREATMENTS, GET_TREATMENTS_BY_FLAG_SET, GET_TREATMENTS_BY_FLAG_SETS, GET_TREATMENTS_WITH_CONFIG, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, GET_TREATMENT_WITH_CONFIG } from '../utils/constants';
+import { GET_TREATMENT, GET_TREATMENTS, GET_TREATMENTS_BY_FLAG_SET, GET_TREATMENTS_BY_FLAG_SETS, GET_TREATMENTS_WITH_CONFIG, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, GET_TREATMENT_WITH_CONFIG, TRACK_FN_LABEL } from '../utils/constants';
 import { isConsumerMode } from '../utils/settingsValidation/mode';
 import { validateFlagSets } from '../utils/settingsValidation/splitFilters';
 /**
  * Decorator that validates the input before actually executing the client methods.
  * We should "guard" the client here, while not polluting the "real" implementation of those methods.
  */
-export function clientInputValidationDecorator(settings, client, readinessManager, fallbackCalculator) {
+export function clientInputValidationDecorator(settings, client, readinessManager, fallbackTreatmentsCalculator) {
     var log = settings.log, mode = settings.mode;
     var isAsync = isConsumerMode(mode);
     /**
@@ -18,12 +18,12 @@ export function clientInputValidationDecorator(settings, client, readinessManage
         var nameOrNames = methodName.indexOf('ByFlagSet') > -1 ?
             validateFlagSets(log, methodName, maybeNameOrNames, settings.sync.__splitFiltersValidation.groupedFilters.bySet) :
             startsWith(methodName, GET_TREATMENTS) ?
-                validateDefinitions(log, maybeNameOrNames, methodName) :
-                validateDefinition(log, maybeNameOrNames, methodName);
+                validateSplits(log, maybeNameOrNames, methodName) :
+                validateSplit(log, maybeNameOrNames, methodName);
         var attributes = validateAttributes(log, maybeAttributes, methodName);
         var isNotDestroyed = validateIfNotDestroyed(log, readinessManager, methodName);
         var options = validateEvaluationOptions(log, maybeOptions, methodName);
-        validateIfReadyFromCache(log, readinessManager, methodName);
+        validateIfReadyFromCache(log, readinessManager, methodName, nameOrNames);
         var valid = isNotDestroyed && key && nameOrNames && attributes !== false;
         return {
             valid: valid,
@@ -39,7 +39,7 @@ export function clientInputValidationDecorator(settings, client, readinessManage
             featureFlagName.forEach(function (split) { return res_1[split] = evaluateFallBackTreatment(split, withConfig); });
             return res_1;
         }
-        var _a = fallbackCalculator(featureFlagName), treatment = _a.treatment, config = _a.config;
+        var _a = fallbackTreatmentsCalculator(featureFlagName), treatment = _a.treatment, config = _a.config;
         return withConfig ?
             {
                 treatment: treatment,
@@ -97,6 +97,17 @@ export function clientInputValidationDecorator(settings, client, readinessManage
             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);
+        var tt = validateTrafficType(log, maybeTT, TRACK_FN_LABEL);
+        var event = validateEvent(log, maybeEvent, TRACK_FN_LABEL);
+        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);
+        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,
         getTreatmentWithConfig: getTreatmentWithConfig,
@@ -106,6 +117,6 @@ export function clientInputValidationDecorator(settings, client, readinessManage
         getTreatmentsWithConfigByFlagSets: getTreatmentsWithConfigByFlagSets,
         getTreatmentsByFlagSet: getTreatmentsByFlagSet,
         getTreatmentsWithConfigByFlagSet: getTreatmentsWithConfigByFlagSet,
-        track: client.track,
+        track: track
     };
 }

package/esm/sdkClient/sdkClient.js

@@ -1,15 +1,72 @@
 import { objectAssign } from '../utils/lang/objectAssign';
+import { releaseApiKey, validateAndTrackApiKey } from '../utils/inputValidation/apiKey';
 import { clientFactory } from './client';
 import { clientInputValidationDecorator } from './clientInputValidation';
-import { sdkLifecycleFactory } from './sdkLifecycle';
+var COOLDOWN_TIME_IN_MILLIS = 1000;
 /**
  * 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, settings = params.settings;
+    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();
+        //get the actual time elapsed in ms
+        var timeElapsed = now - lastActionTime;
+        //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 ".concat((time - timeElapsed) / 1000, " seconds"));
+            return Promise.resolve();
+        }
+        else {
+            //Do the requested action and re-assign the lastActionTime
+            lastActionTime = now;
+            return func();
+        }
+    }
+    function __flush() {
+        return syncManager ? syncManager.flush() : Promise.resolve();
+    }
     return objectAssign(
     // Proto-linkage of the readiness Event Emitter
     Object.create(sdkReadinessManager.sdkStatus), 
     // Client API (getTreatment* & track methods)
-    clientInputValidationDecorator(settings, clientFactory(params), sdkReadinessManager.readinessManager, params.fallbackCalculator), sdkLifecycleFactory(params, isSharedClient));
+    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
+            if (!isSharedClient) {
+                releaseApiKey(settings.core.authorizationKey);
+                telemetryTracker.sessionLength();
+                signalListener && signalListener.stop();
+                impressionsTracker.stop();
+            }
+            // Stop background jobs
+            syncManager && syncManager.stop();
+            return __flush().then(function () {
+                // Cleanup storage
+                return storage.destroy();
+            });
+        }
+    });
 }

package/esm/sdkFactory/index.js

@@ -4,7 +4,7 @@ import { eventTrackerFactory } from '../trackers/eventTracker';
 import { telemetryTrackerFactory } from '../trackers/telemetryTracker';
 import { createLoggerAPI } from '../logger/sdkLogger';
 import { NEW_FACTORY, RETRIEVE_MANAGER } from '../logger/constants';
-import { SDK_DEFINITIONS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_DEFINITIONS_CACHE_LOADED } from '../readiness/constants';
+import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../readiness/constants';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { setRolloutPlan } from '../storages/setRolloutPlan';
 import { getMatching } from '../utils/key';
@@ -13,7 +13,7 @@ import { FallbackTreatmentsCalculator } from '../evaluator/fallbackTreatmentsCal
  * Modular SDK factory
  */
 export function sdkFactory(params) {
-    var settings = params.settings, platform = params.platform, storageFactory = params.storageFactory, serviceApiFactory = params.serviceApiFactory, extraProps = params.extraProps, syncManagerFactory = params.syncManagerFactory, integrationsManagerFactory = params.integrationsManagerFactory, sdkManagerFactory = params.sdkManagerFactory, sdkClientMethodFactory = params.sdkClientMethodFactory, lazyInit = params.lazyInit;
+    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.
@@ -27,31 +27,35 @@ export function sdkFactory(params) {
                 readiness.timeout();
                 return;
             }
-            readiness.definitions.emit(SDK_DEFINITIONS_ARRIVED);
+            readiness.splits.emit(SDK_SPLITS_ARRIVED);
             readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
         },
         onReadyFromCacheCb: function () {
-            readiness.definitions.emit(SDK_DEFINITIONS_CACHE_LOADED);
+            readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
         }
     });
-    var fallbackCalculator = FallbackTreatmentsCalculator(settings.fallbackTreatments);
+    var fallbackTreatmentsCalculator = FallbackTreatmentsCalculator(settings.fallbackTreatments);
     if (initialRolloutPlan) {
         setRolloutPlan(log, initialRolloutPlan, storage, key && getMatching(key));
-        if (storage.definitions.getChangeNumber() > -1)
-            readiness.definitions.emit(SDK_DEFINITIONS_CACHE_LOADED, { initialCacheLoad: false /* Not an initial load, cache exists */ });
+        if (storage.splits.getChangeNumber() > -1)
+            readiness.splits.emit(SDK_SPLITS_CACHE_LOADED, { initialCacheLoad: false /* Not an initial load, cache exists */ });
     }
     var clients = {};
     var telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
     var integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings: settings, storage: storage, telemetryTracker: telemetryTracker });
     var impressionsTracker = impressionsTrackerFactory(params, storage, integrationsManager);
     var eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager, storage.telemetry);
-    // serviceApi is used by SyncManager and Browser signal listener
-    var serviceApi = serviceApiFactory && serviceApiFactory(settings, platform, telemetryTracker);
-    var ctx = { clients: clients, serviceApi: serviceApi, eventTracker: eventTracker, impressionsTracker: impressionsTracker, telemetryTracker: telemetryTracker, sdkReadinessManager: sdkReadinessManager, readiness: readiness, settings: settings, storage: storage, platform: platform, fallbackCalculator: fallbackCalculator };
-    ctx.syncManager = syncManagerFactory && syncManagerFactory(ctx);
+    // 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, 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.definitions, sdkReadinessManager);
+    var managerInstance = sdkManagerFactory(settings, storage.splits, sdkReadinessManager);
     function init() {
         Object.keys(clients).map(function (key) { return clients[key].init(); });
     }

package/esm/sdkManager/index.js

@@ -1,7 +1,7 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
 import { find } from '../utils/lang';
-import { validateDefinition, validateDefinitionExistence, validateIfOperational } from '../utils/inputValidation';
+import { validateSplit, validateSplitExistence, validateIfOperational } from '../utils/inputValidation';
 import { isConsumerMode } from '../utils/settingsValidation/mode';
 import { SPLIT_FN_LABEL, SPLITS_FN_LABEL, NAMES_FN_LABEL } from '../utils/constants';
 function collectTreatments(splitObject) {
@@ -50,18 +50,18 @@ export function sdkManagerFactory(settings, splits, _a) {
          * Get the feature flag object corresponding to the given feature flag name if valid
          */
         split: function (featureFlagName) {
-            var splitName = validateDefinition(log, featureFlagName, SPLIT_FN_LABEL);
+            var splitName = validateSplit(log, featureFlagName, SPLIT_FN_LABEL);
             if (!validateIfOperational(log, readinessManager, SPLIT_FN_LABEL) || !splitName) {
                 return isAsync ? Promise.resolve(null) : null;
             }
-            var split = splits.get(splitName);
+            var split = splits.getSplit(splitName);
             if (thenable(split)) {
                 return split.catch(function () { return null; }).then(function (result) {
-                    validateDefinitionExistence(log, readinessManager, splitName, result, SPLIT_FN_LABEL);
+                    validateSplitExistence(log, readinessManager, splitName, result, SPLIT_FN_LABEL);
                     return objectToView(result);
                 });
             }
-            validateDefinitionExistence(log, readinessManager, splitName, split, SPLIT_FN_LABEL);
+            validateSplitExistence(log, readinessManager, splitName, split, SPLIT_FN_LABEL);
             return objectToView(split);
         },
         /**
@@ -83,7 +83,7 @@ export function sdkManagerFactory(settings, splits, _a) {
             if (!validateIfOperational(log, readinessManager, NAMES_FN_LABEL)) {
                 return isAsync ? Promise.resolve([]) : [];
             }
-            var splitNames = splits.getNames();
+            var splitNames = splits.getSplitNames();
             return thenable(splitNames) ?
                 splitNames.catch(function () { return []; }) : // handle possible rejections when using pluggable storage
                 splitNames;

package/esm/services/decorateHeaders.js

@@ -12,8 +12,7 @@ var FORBIDDEN_HEADERS = new Set([
     'content-encoding',
     'accept',
     'keep-alive',
-    'x-fastly-debug',
-    'x-harness-fme-sdk-version'
+    'x-fastly-debug'
 ]);
 export function decorateHeaders(settings, headers) {
     var _a;

package/esm/services/splitApi.js

@@ -6,9 +6,8 @@ var noCacheHeaderOptions = { headers: { 'Cache-Control': 'no-cache' } };
 function userKeyToQueryParam(userKey) {
     return 'users=' + encodeURIComponent(userKey); // no need to check availability of `encodeURIComponent`, since it is a global highly supported.
 }
-// @TODO remove when migrating to the new `urls` defaults.
 /**
- * Factory of ServiceApi objects, which group the collection of Split HTTP endpoints used by the SDK
+ * Factory of SplitApi objects, which group the collection of Split HTTP endpoints used by the SDK
  *
  * @param settings - validated settings object
  * @param platform - object containing environment-specific dependencies
@@ -123,18 +122,6 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
         postMetricsUsage: function (body, headers) {
             var url = "".concat(urls.telemetry, "/v1/metrics/usage");
             return splitHttpClient(url, { method: 'POST', body: body, headers: headers }, telemetryTracker.trackHttp(TELEMETRY), true);
-        },
-        // Not used. Just here to satisfy the IServiceApi interface.
-        fetchConfigs: function (since, noCache, till, rbSince) {
-            var url = "".concat(urls.configs, "/v1/configs?since=").concat(since).concat(rbSince ? '&rbSince=' + rbSince : '').concat(filterQueryString || '').concat(till ? '&till=' + till : '');
-            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined);
-        },
-        fetchConfigsSegmentChanges: function (since, segmentName, noCache, till) {
-            var url = "".concat(urls.configs, "/v1/segmentChanges/").concat(segmentName, "?since=").concat(since).concat(till ? '&till=' + till : '');
-            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined);
-        },
-        stop: function () {
-            // no-op
         }
     };
 }

package/esm/services/splitHttpClient.js

@@ -21,17 +21,19 @@ export function splitHttpClientFactory(settings, _a) {
     var commonHeaders = {
         'Accept': 'application/json',
         'Content-Type': 'application/json',
-        'Authorization': "Bearer ".concat(authorizationKey)
+        'Authorization': "Bearer ".concat(authorizationKey),
+        'SplitSDKVersion': version
     };
     if (ip)
         commonHeaders['SplitSDKMachineIP'] = ip;
     if (hostname)
         commonHeaders['SplitSDKMachineName'] = removeNonISO88591(hostname);
-    return function httpClient(url, reqOpts, latencyTracker, logErrorsAsInfo, newVersionHeader) {
+    return function httpClient(url, reqOpts, latencyTracker, logErrorsAsInfo) {
         if (reqOpts === void 0) { reqOpts = {}; }
         if (latencyTracker === void 0) { latencyTracker = function () { }; }
+        if (logErrorsAsInfo === void 0) { logErrorsAsInfo = false; }
         var request = objectAssign({
-            headers: decorateHeaders(settings, objectAssign(newVersionHeader ? { 'X-Harness-FME-SDK-Version': version } : { 'SplitSDKVersion': version }, commonHeaders, reqOpts.headers || {})),
+            headers: decorateHeaders(settings, objectAssign({}, commonHeaders, reqOpts.headers || {})),
             method: reqOpts.method || 'GET',
             body: reqOpts.body
         }, options);

package/esm/storages/AbstractSplitsCacheAsync.js

@@ -0,0 +1,48 @@
+import { objectAssign } from '../utils/lang/objectAssign';
+/**
+ * This class provides a skeletal implementation of the ISplitsCacheAsync interface
+ * to minimize the effort required to implement this interface.
+ */
+var AbstractSplitsCacheAsync = /** @class */ (function () {
+    function AbstractSplitsCacheAsync() {
+    }
+    AbstractSplitsCacheAsync.prototype.update = function (toAdd, toRemove, changeNumber) {
+        var _this = this;
+        return Promise.all([
+            this.setChangeNumber(changeNumber),
+            Promise.all(toAdd.map(function (addedFF) { return _this.addSplit(addedFF); })),
+            Promise.all(toRemove.map(function (removedFF) { return _this.removeSplit(removedFF.name); }))
+        ]).then(function (_a) {
+            var added = _a[1], removed = _a[2];
+            return added.some(function (result) { return result; }) || removed.some(function (result) { return result; });
+        });
+    };
+    // @TODO revisit segment-related methods ('usesSegments', 'getRegisteredSegments', 'registerSegments')
+    // noop, just keeping the interface. This is used by standalone client-side API only, and so only implemented by InMemory and InLocalStorage.
+    AbstractSplitsCacheAsync.prototype.usesSegments = function () {
+        return Promise.resolve(true);
+    };
+    /**
+     * Kill `name` split and set `defaultTreatment` and `changeNumber`.
+     * Used for SPLIT_KILL push notifications.
+     *
+     * @returns a promise that is resolved once the split kill operation is performed. The fulfillment value is a boolean: `true` if the operation successed updating the split or `false` if no split is updated,
+     * for instance, if the `changeNumber` is old, or if the split is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
+     * The promise will never be rejected.
+     */
+    AbstractSplitsCacheAsync.prototype.killLocally = function (name, defaultTreatment, changeNumber) {
+        var _this = this;
+        return this.getSplit(name).then(function (split) {
+            if (split && (!split.changeNumber || split.changeNumber < changeNumber)) {
+                var newSplit = objectAssign({}, split);
+                newSplit.killed = true;
+                newSplit.defaultTreatment = defaultTreatment;
+                newSplit.changeNumber = changeNumber;
+                return _this.addSplit(newSplit);
+            }
+            return false;
+        }).catch(function () { return false; });
+    };
+    return AbstractSplitsCacheAsync;
+}());
+export { AbstractSplitsCacheAsync };

package/esm/storages/AbstractSplitsCacheSync.js

@@ -0,0 +1,71 @@
+import { objectAssign } from '../utils/lang/objectAssign';
+import { IN_SEGMENT, IN_LARGE_SEGMENT } from '../utils/constants';
+/**
+ * This class provides a skeletal implementation of the ISplitsCacheSync interface
+ * to minimize the effort required to implement this interface.
+ */
+var AbstractSplitsCacheSync = /** @class */ (function () {
+    function AbstractSplitsCacheSync() {
+    }
+    AbstractSplitsCacheSync.prototype.update = function (toAdd, toRemove, changeNumber) {
+        var _this = this;
+        var updated = toAdd.map(function (addedFF) { return _this.addSplit(addedFF); }).some(function (result) { return result; });
+        updated = toRemove.map(function (removedFF) { return _this.removeSplit(removedFF.name); }).some(function (result) { return result; }) || updated;
+        this.setChangeNumber(changeNumber);
+        return updated;
+    };
+    AbstractSplitsCacheSync.prototype.getSplits = function (names) {
+        var _this = this;
+        var splits = {};
+        names.forEach(function (name) {
+            splits[name] = _this.getSplit(name);
+        });
+        return splits;
+    };
+    AbstractSplitsCacheSync.prototype.getAll = function () {
+        var _this = this;
+        return this.getSplitNames().map(function (key) { return _this.getSplit(key); });
+    };
+    /**
+     * Kill `name` split and set `defaultTreatment` and `changeNumber`.
+     * Used for SPLIT_KILL push notifications.
+     *
+     * @returns `true` if the operation successed updating the split, or `false` if no split is updated,
+     * for instance, if the `changeNumber` is old, or if the split is not found (e.g., `/splitchanges` hasn't been fetched yet), or if the storage fails to apply the update.
+     */
+    AbstractSplitsCacheSync.prototype.killLocally = function (name, defaultTreatment, changeNumber) {
+        var split = this.getSplit(name);
+        if (split && (!split.changeNumber || split.changeNumber < changeNumber)) {
+            var newSplit = objectAssign({}, split);
+            newSplit.killed = true;
+            newSplit.defaultTreatment = defaultTreatment;
+            newSplit.changeNumber = changeNumber;
+            return this.addSplit(newSplit);
+        }
+        return false;
+    };
+    return AbstractSplitsCacheSync;
+}());
+export { AbstractSplitsCacheSync };
+/**
+ * Given a parsed split, it returns a boolean flagging if its conditions use segments matchers (rules & whitelists).
+ * This util is intended to simplify the implementation of `splitsCache::usesSegments` method
+ */
+export function usesSegments(ruleEntity) {
+    var conditions = ruleEntity.conditions || [];
+    for (var i = 0; i < conditions.length; i++) {
+        var matchers = conditions[i].matcherGroup.matchers;
+        for (var j = 0; j < matchers.length; j++) {
+            var matcher = matchers[j].matcherType;
+            if (matcher === IN_SEGMENT || matcher === IN_LARGE_SEGMENT)
+                return true;
+        }
+    }
+    var excluded = ruleEntity.excluded;
+    if (excluded && excluded.segments && excluded.segments.length > 0)
+        return true;
+    return false;
+}
+export function usesSegmentsSync(storage) {
+    return storage.splits.usesSegments() || storage.rbSegments.usesSegments();
+}

package/esm/storages/KeyBuilder.js

@@ -12,16 +12,16 @@ var KeyBuilder = /** @class */ (function () {
     KeyBuilder.prototype.buildTrafficTypeKey = function (trafficType) {
         return "".concat(this.prefix, ".trafficType.").concat(trafficType);
     };
-    KeyBuilder.prototype.buildSetKey = function (set) {
-        return "".concat(this.prefix, ".flagSet.").concat(set);
+    KeyBuilder.prototype.buildFlagSetKey = function (flagSet) {
+        return "".concat(this.prefix, ".flagSet.").concat(flagSet);
     };
-    KeyBuilder.prototype.buildDefinitionKey = function (definitionName) {
-        return "".concat(this.prefix, ".split.").concat(definitionName);
+    KeyBuilder.prototype.buildSplitKey = function (splitName) {
+        return "".concat(this.prefix, ".split.").concat(splitName);
     };
-    KeyBuilder.prototype.buildDefinitionsTillKey = function () {
+    KeyBuilder.prototype.buildSplitsTillKey = function () {
         return "".concat(this.prefix, ".splits.till");
     };
-    KeyBuilder.prototype.buildDefinitionKeyPrefix = function () {
+    KeyBuilder.prototype.buildSplitKeyPrefix = function () {
         return "".concat(this.prefix, ".split.");
     };
     KeyBuilder.prototype.buildRBSegmentKey = function (rbsegmentName) {

package/esm/storages/KeyBuilderCS.js

@@ -6,7 +6,7 @@ var KeyBuilderCS = /** @class */ (function (_super) {
     function KeyBuilderCS(prefix, matchingKey) {
         var _this = _super.call(this, prefix) || this;
         _this.matchingKey = matchingKey;
-        _this.regexDefinitionsCacheKey = new RegExp("^".concat(prefix, "\\.(splits?|trafficType|flagSet)\\."));
+        _this.regexSplitsCacheKey = new RegExp("^".concat(prefix, "\\.(splits?|trafficType|flagSet)\\."));
         return _this;
     }
     /**
@@ -23,19 +23,19 @@ var KeyBuilderCS = /** @class */ (function (_super) {
     KeyBuilderCS.prototype.buildLastUpdatedKey = function () {
         return "".concat(this.prefix, ".splits.lastUpdated");
     };
-    KeyBuilderCS.prototype.isDefinitionsCacheKey = function (key) {
-        return this.regexDefinitionsCacheKey.test(key);
+    KeyBuilderCS.prototype.isSplitsCacheKey = function (key) {
+        return this.regexSplitsCacheKey.test(key);
     };
     KeyBuilderCS.prototype.buildTillKey = function () {
         return "".concat(this.prefix, ".").concat(this.matchingKey, ".segments.till");
     };
-    KeyBuilderCS.prototype.isDefinitionKey = function (key) {
+    KeyBuilderCS.prototype.isSplitKey = function (key) {
         return startsWith(key, "".concat(this.prefix, ".split."));
     };
     KeyBuilderCS.prototype.isRBSegmentKey = function (key) {
         return startsWith(key, "".concat(this.prefix, ".rbsegment."));
     };
-    KeyBuilderCS.prototype.buildDefinitionsWithSegmentCountKey = function () {
+    KeyBuilderCS.prototype.buildSplitsWithSegmentCountKey = function () {
         return "".concat(this.prefix, ".splits.usingSegments");
     };
     KeyBuilderCS.prototype.buildLastClear = function () {

package/esm/storages/KeyBuilderSS.js

@@ -36,8 +36,8 @@ var KeyBuilderSS = /** @class */ (function (_super) {
     KeyBuilderSS.prototype.buildEventsKey = function () {
         return "".concat(this.prefix, ".events");
     };
-    KeyBuilderSS.prototype.searchPatternForDefinitionKeys = function () {
-        return "".concat(this.buildDefinitionKeyPrefix(), "*");
+    KeyBuilderSS.prototype.searchPatternForSplitKeys = function () {
+        return "".concat(this.buildSplitKeyPrefix(), "*");
     };
     KeyBuilderSS.prototype.searchPatternForRBSegmentKeys = function () {
         return "".concat(this.buildRBSegmentKeyPrefix(), "*");

package/esm/storages/getRolloutPlan.js

@@ -6,14 +6,14 @@ import { getMatching } from '../utils/key';
 export function getRolloutPlan(log, storage, options) {
     if (options === void 0) { options = {}; }
     var keys = options.keys, exposeSegments = options.exposeSegments;
-    var definitions = storage.definitions, segments = storage.segments, rbSegments = storage.rbSegments;
+    var splits = storage.splits, segments = storage.segments, rbSegments = storage.rbSegments;
     log.debug("storage: get feature flags".concat(keys ? ", and memberships for keys: ".concat(keys) : '').concat(exposeSegments ? ', and segments' : ''));
     return {
         splitChanges: {
             ff: {
-                t: definitions.getChangeNumber(),
+                t: splits.getChangeNumber(),
                 s: -1,
-                d: definitions.getAll(),
+                d: splits.getAll(),
             },
             rbs: {
                 t: rbSegments.getChangeNumber(),

package/esm/storages/inLocalStorage/MySegmentsCacheInLocal.js

@@ -4,8 +4,9 @@ import { AbstractMySegmentsCacheSync } from '../AbstractMySegmentsCacheSync';
 import { DEFINED } from './constants';
 var MySegmentsCacheInLocal = /** @class */ (function (_super) {
     __extends(MySegmentsCacheInLocal, _super);
-    function MySegmentsCacheInLocal(_log, keys, storage) {
+    function MySegmentsCacheInLocal(log, keys, storage) {
         var _this = _super.call(this) || this;
+        _this.log = log;
         _this.keys = keys;
         _this.storage = storage;
         return _this;

package/esm/storages/inLocalStorage/RBSegmentsCacheInLocal.js

@@ -1,6 +1,6 @@
 import { isFiniteNumber, isNaNNumber, toNumber } from '../../utils/lang';
 import { setToArray } from '../../utils/lang/sets';
-import { usesSegments } from '../AbstractDefinitionsCacheSync';
+import { usesSegments } from '../AbstractSplitsCacheSync';
 import { LOG_PREFIX } from './constants';
 var RBSegmentsCacheInLocal = /** @class */ (function () {
     function RBSegmentsCacheInLocal(settings, keys, storage) {
@@ -16,7 +16,7 @@ var RBSegmentsCacheInLocal = /** @class */ (function () {
     RBSegmentsCacheInLocal.prototype.update = function (toAdd, toRemove, changeNumber) {
         var _this = this;
         var updated = toAdd.map(function (toAdd) { return _this.add(toAdd); }).some(function (result) { return result; });
-        updated = toRemove.map(function (toRemove) { return _this.remove(toRemove); }).some(function (result) { return result; }) || updated;
+        updated = toRemove.map(function (toRemove) { return _this.remove(toRemove.name); }).some(function (result) { return result; }) || updated;
         this.setChangeNumber(changeNumber);
         return updated;
     };
@@ -30,7 +30,7 @@ var RBSegmentsCacheInLocal = /** @class */ (function () {
         }
     };
     RBSegmentsCacheInLocal.prototype.updateSegmentCount = function (diff) {
-        var segmentsCountKey = this.keys.buildDefinitionsWithSegmentCountKey();
+        var segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
         var count = toNumber(this.storage.getItem(segmentsCountKey)) + diff;
         if (count > 0)
             this.storage.setItem(segmentsCountKey, count + '');
@@ -96,10 +96,10 @@ var RBSegmentsCacheInLocal = /** @class */ (function () {
         return n;
     };
     RBSegmentsCacheInLocal.prototype.usesSegments = function () {
-        var storedCount = this.storage.getItem(this.keys.buildDefinitionsWithSegmentCountKey());
-        var definitionsWithSegmentsCount = storedCount === null ? 0 : toNumber(storedCount);
-        return isFiniteNumber(definitionsWithSegmentsCount) ?
-            definitionsWithSegmentsCount > 0 :
+        var storedCount = this.storage.getItem(this.keys.buildSplitsWithSegmentCountKey());
+        var splitsWithSegmentsCount = storedCount === null ? 0 : toNumber(storedCount);
+        return isFiniteNumber(splitsWithSegmentsCount) ?
+            splitsWithSegmentsCount > 0 :
             true;
     };
     return RBSegmentsCacheInLocal;