@splitsoftware/splitio-commons 2.12.0 → 3.0.0-rc.1

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.regexDefinitionsCacheKey = 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.isDefinitionsCacheKey = function (key) {
+        return this.regexDefinitionsCacheKey.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.");
+    KeyBuilderCS.prototype.isDefinitionKey = function (key) {
+        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";
+    KeyBuilderCS.prototype.buildDefinitionsWithSegmentCountKey = function () {
+        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() + "*";
+    KeyBuilderSS.prototype.searchPatternForDefinitionKeys = function () {
+        return "".concat(this.buildDefinitionKeyPrefix(), "*");
     };
     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

@@ -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 splits = storage.splits, segments = storage.segments, rbSegments = storage.rbSegments;
-    log.debug("storage: get feature flags" + (keys ? ", and memberships for keys: " + keys : '') + (exposeSegments ? ', and segments' : ''));
+    var definitions = storage.definitions, 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: splits.getChangeNumber(),
+                t: definitions.getChangeNumber(),
                 s: -1,
-                d: splits.getAll(),
+                d: definitions.getAll(),
             },
             rbs: {
                 t: rbSegments.getChangeNumber(),

package/esm/storages/inLocalStorage/DefinitionsCacheInLocal.js

@@ -0,0 +1,191 @@
+import { __extends } from "tslib";
+import { AbstractDefinitionsCacheSync, usesSegments } from '../AbstractDefinitionsCacheSync';
+import { isFiniteNumber, toNumber, isNaNNumber } from '../../utils/lang';
+import { LOG_PREFIX } from './constants';
+import { setToArray } from '../../utils/lang/sets';
+var DefinitionsCacheInLocal = /** @class */ (function (_super) {
+    __extends(DefinitionsCacheInLocal, _super);
+    function DefinitionsCacheInLocal(settings, keys, storage) {
+        var _this = _super.call(this) || this;
+        _this.keys = keys;
+        _this.log = settings.log;
+        _this.setsFilter = settings.sync.__splitFiltersValidation.groupedFilters.bySet;
+        _this.storage = storage;
+        return _this;
+    }
+    DefinitionsCacheInLocal.prototype._decrementCount = function (key) {
+        var count = toNumber(this.storage.getItem(key)) - 1;
+        if (count > 0)
+            this.storage.setItem(key, count + '');
+        else
+            this.storage.removeItem(key);
+    };
+    DefinitionsCacheInLocal.prototype._decrementCounts = function (definition) {
+        try {
+            var ttKey = this.keys.buildTrafficTypeKey(definition.trafficTypeName);
+            this._decrementCount(ttKey);
+            if (usesSegments(definition)) {
+                var segmentsCountKey = this.keys.buildDefinitionsWithSegmentCountKey();
+                this._decrementCount(segmentsCountKey);
+            }
+        }
+        catch (e) {
+            this.log.error(LOG_PREFIX + e);
+        }
+    };
+    DefinitionsCacheInLocal.prototype._incrementCounts = function (definition) {
+        try {
+            var ttKey = this.keys.buildTrafficTypeKey(definition.trafficTypeName);
+            this.storage.setItem(ttKey, (toNumber(this.storage.getItem(ttKey)) + 1) + '');
+            if (usesSegments(definition)) {
+                var segmentsCountKey = this.keys.buildDefinitionsWithSegmentCountKey();
+                this.storage.setItem(segmentsCountKey, (toNumber(this.storage.getItem(segmentsCountKey)) + 1) + '');
+            }
+        }
+        catch (e) {
+            this.log.error(LOG_PREFIX + e);
+        }
+    };
+    /**
+     * Removes all definitions related data from localStorage (splits, counters, changeNumber and lastUpdated).
+     * We cannot simply call `localStorage.clear()` since that implies removing user items from the storage.
+     */
+    DefinitionsCacheInLocal.prototype.clear = function () {
+        var _this = this;
+        // collect item keys
+        var len = this.storage.length;
+        var accum = [];
+        for (var cur = 0; cur < len; cur++) {
+            var key = this.storage.key(cur);
+            if (key != null && this.keys.isDefinitionsCacheKey(key))
+                accum.push(key);
+        }
+        // remove items
+        accum.forEach(function (key) {
+            _this.storage.removeItem(key);
+        });
+        this.hasSync = false;
+    };
+    DefinitionsCacheInLocal.prototype.add = function (definition) {
+        var name = definition.name;
+        var definitionKey = this.keys.buildDefinitionKey(name);
+        var definitionFromStorage = this.storage.getItem(definitionKey);
+        var previousDefinition = definitionFromStorage ? JSON.parse(definitionFromStorage) : null;
+        if (previousDefinition) {
+            this._decrementCounts(previousDefinition);
+            this.removeFromSets(previousDefinition.name, previousDefinition.sets);
+        }
+        this.storage.setItem(definitionKey, JSON.stringify(definition));
+        this._incrementCounts(definition);
+        this.addToSets(definition);
+        return true;
+    };
+    DefinitionsCacheInLocal.prototype.remove = function (name) {
+        var definition = this.get(name);
+        if (!definition)
+            return false;
+        this.storage.removeItem(this.keys.buildDefinitionKey(name));
+        this._decrementCounts(definition);
+        this.removeFromSets(definition.name, definition.sets);
+        return true;
+    };
+    DefinitionsCacheInLocal.prototype.get = function (name) {
+        var item = this.storage.getItem(this.keys.buildDefinitionKey(name));
+        return item && JSON.parse(item);
+    };
+    DefinitionsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
+        try {
+            this.storage.setItem(this.keys.buildDefinitionsTillKey(), changeNumber + '');
+            // update "last updated" timestamp with current time
+            this.storage.setItem(this.keys.buildLastUpdatedKey(), Date.now() + '');
+            this.hasSync = true;
+            return true;
+        }
+        catch (e) {
+            this.log.error(LOG_PREFIX + e);
+            return false;
+        }
+    };
+    DefinitionsCacheInLocal.prototype.getChangeNumber = function () {
+        var n = -1;
+        var value = this.storage.getItem(this.keys.buildDefinitionsTillKey());
+        if (value !== null) {
+            value = parseInt(value, 10);
+            return isNaNNumber(value) ? n : value;
+        }
+        return n;
+    };
+    DefinitionsCacheInLocal.prototype.getNames = function () {
+        var len = this.storage.length;
+        var accum = [];
+        var cur = 0;
+        while (cur < len) {
+            var key = this.storage.key(cur);
+            if (key != null && this.keys.isDefinitionKey(key))
+                accum.push(this.keys.extractKey(key));
+            cur++;
+        }
+        return accum;
+    };
+    DefinitionsCacheInLocal.prototype.trafficTypeExists = function (trafficType) {
+        var ttCount = toNumber(this.storage.getItem(this.keys.buildTrafficTypeKey(trafficType)));
+        return isFiniteNumber(ttCount) && ttCount > 0;
+    };
+    DefinitionsCacheInLocal.prototype.usesSegments = function () {
+        // If cache hasn't been synchronized with the cloud, assume we need them.
+        if (!this.hasSync)
+            return true;
+        var storedCount = this.storage.getItem(this.keys.buildDefinitionsWithSegmentCountKey());
+        var definitionsWithSegmentsCount = storedCount === null ? 0 : toNumber(storedCount);
+        return isFiniteNumber(definitionsWithSegmentsCount) ?
+            definitionsWithSegmentsCount > 0 :
+            true;
+    };
+    DefinitionsCacheInLocal.prototype.getNamesBySets = function (sets) {
+        var _this = this;
+        return sets.map(function (set) {
+            var setKey = _this.keys.buildSetKey(set);
+            var setFromStorage = _this.storage.getItem(setKey);
+            return new Set(setFromStorage ? JSON.parse(setFromStorage) : []);
+        });
+    };
+    DefinitionsCacheInLocal.prototype.addToSets = function (definition) {
+        var _this = this;
+        if (!definition.sets)
+            return;
+        definition.sets.forEach(function (set) {
+            if (_this.setsFilter.length > 0 && !_this.setsFilter.some(function (filterSet) { return filterSet === set; }))
+                return;
+            var setKey = _this.keys.buildSetKey(set);
+            var setFromStorage = _this.storage.getItem(setKey);
+            var setCache = new Set(setFromStorage ? JSON.parse(setFromStorage) : []);
+            if (setCache.has(definition.name))
+                return;
+            setCache.add(definition.name);
+            _this.storage.setItem(setKey, JSON.stringify(setToArray(setCache)));
+        });
+    };
+    DefinitionsCacheInLocal.prototype.removeFromSets = function (definitionName, sets) {
+        var _this = this;
+        if (!sets)
+            return;
+        sets.forEach(function (set) {
+            _this.removeNames(set, definitionName);
+        });
+    };
+    DefinitionsCacheInLocal.prototype.removeNames = function (setName, definitionName) {
+        var setKey = this.keys.buildSetKey(setName);
+        var setFromStorage = this.storage.getItem(setKey);
+        if (!setFromStorage)
+            return;
+        var setCache = new Set(JSON.parse(setFromStorage));
+        setCache.delete(definitionName);
+        if (setCache.size === 0) {
+            this.storage.removeItem(setKey);
+            return;
+        }
+        this.storage.setItem(setKey, JSON.stringify(setToArray(setCache)));
+    };
+    return DefinitionsCacheInLocal;
+}(AbstractDefinitionsCacheSync));
+export { DefinitionsCacheInLocal };

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 '../AbstractSplitsCacheSync';
+import { usesSegments } from '../AbstractDefinitionsCacheSync';
 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.name); }).some(function (result) { return result; }) || updated;
+        updated = toRemove.map(function (toRemove) { return _this.remove(toRemove); }).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.buildSplitsWithSegmentCountKey();
+        var segmentsCountKey = this.keys.buildDefinitionsWithSegmentCountKey();
         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.buildSplitsWithSegmentCountKey());
-        var splitsWithSegmentsCount = storedCount === null ? 0 : toNumber(storedCount);
-        return isFiniteNumber(splitsWithSegmentsCount) ?
-            splitsWithSegmentsCount > 0 :
+        var storedCount = this.storage.getItem(this.keys.buildDefinitionsWithSegmentCountKey());
+        var definitionsWithSegmentsCount = storedCount === null ? 0 : toNumber(storedCount);
+        return isFiniteNumber(definitionsWithSegmentsCount) ?
+            definitionsWithSegmentsCount > 0 :
             true;
     };
     return RBSegmentsCacheInLocal;

package/esm/storages/inLocalStorage/index.js

@@ -4,7 +4,7 @@ import { EventsCacheInMemory } from '../inMemory/EventsCacheInMemory';
 import { validatePrefix } from '../KeyBuilder';
 import { KeyBuilderCS, myLargeSegmentsKeyBuilder } from '../KeyBuilderCS';
 import { isLocalStorageAvailable, isValidStorageWrapper, isWebStorage } from '../../utils/env/isLocalStorageAvailable';
-import { SplitsCacheInLocal } from './SplitsCacheInLocal';
+import { DefinitionsCacheInLocal } from './DefinitionsCacheInLocal';
 import { RBSegmentsCacheInLocal } from './RBSegmentsCacheInLocal';
 import { MySegmentsCacheInLocal } from './MySegmentsCacheInLocal';
 import { InMemoryStorageCSFactory } from '../inMemory/InMemoryStorageCS';
@@ -41,24 +41,24 @@ export function InLocalStorage(options) {
             return InMemoryStorageCSFactory(params);
         var matchingKey = getMatching(settings.core.key);
         var keys = new KeyBuilderCS(prefix, matchingKey);
-        var splits = new SplitsCacheInLocal(settings, keys, storage);
+        var definitions = new DefinitionsCacheInLocal(settings, keys, storage);
         var rbSegments = new RBSegmentsCacheInLocal(settings, keys, storage);
         var segments = new MySegmentsCacheInLocal(log, keys, storage);
         var largeSegments = new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey), storage);
         var validateCachePromise;
         return {
-            splits: splits,
+            definitions: definitions,
             rbSegments: rbSegments,
             segments: segments,
             largeSegments: largeSegments,
             impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
             impressionCounts: new ImpressionCountsCacheInMemory(),
             events: new EventsCacheInMemory(eventsQueueSize),
-            telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
+            telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(definitions, segments) : undefined,
             uniqueKeys: new UniqueKeysCacheInMemoryCS(),
             validateCache: function () {
                 if (!validateCachePromise) {
-                    validateCachePromise = validateCache(options, storage, settings, keys, splits, rbSegments, segments, largeSegments);
+                    validateCachePromise = validateCache(options, storage, settings, keys, definitions, rbSegments, segments, largeSegments);
                 }
                 return validateCachePromise;
             },
@@ -71,7 +71,7 @@ export function InLocalStorage(options) {
             // When using shared instantiation with MEMORY we reuse everything but segments (they are customer per key).
             shared: function (matchingKey) {
                 return {
-                    splits: this.splits,
+                    definitions: this.definitions,
                     rbSegments: this.rbSegments,
                     segments: new MySegmentsCacheInLocal(log, new KeyBuilderCS(prefix, matchingKey), storage),
                     largeSegments: new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey), storage),

package/esm/storages/inLocalStorage/validateCache.js

@@ -54,16 +54,16 @@ function validateExpiration(options, storage, settings, keys, currentTimestamp,
  *
  * @returns Metadata object with `initialCacheLoad` (true if is fresh install, false if is ready from cache) and `lastUpdateTimestamp` (timestamp of last cache update or undefined)
  */
-export function validateCache(options, storage, settings, keys, splits, rbSegments, segments, largeSegments) {
+export function validateCache(options, storage, settings, keys, definitions, rbSegments, segments, largeSegments) {
     return Promise.resolve(storage.load && storage.load()).then(function () {
         var currentTimestamp = Date.now();
-        var isThereCache = splits.getChangeNumber() > -1;
+        var isThereCache = definitions.getChangeNumber() > -1;
         // Get lastUpdateTimestamp from storage
         var lastUpdatedTimestampStr = storage.getItem(keys.buildLastUpdatedKey());
         var lastUpdatedTimestamp = lastUpdatedTimestampStr ? parseInt(lastUpdatedTimestampStr, 10) : undefined;
         var lastUpdateTimestamp = (!isNaNNumber(lastUpdatedTimestamp) && lastUpdatedTimestamp !== undefined) ? lastUpdatedTimestamp : undefined;
         if (validateExpiration(options, storage, settings, keys, currentTimestamp, isThereCache)) {
-            splits.clear();
+            definitions.clear();
             rbSegments.clear();
             segments.clear();
             largeSegments.clear();

package/esm/storages/inMemory/DefinitionsCacheInMemory.js

@@ -0,0 +1,118 @@
+import { __extends } from "tslib";
+import { AbstractDefinitionsCacheSync, usesSegments } from '../AbstractDefinitionsCacheSync';
+import { isFiniteNumber } from '../../utils/lang';
+/**
+ * Default IDefinitionsCacheSync implementation that stores split definitions in memory.
+ */
+var DefinitionsCacheInMemory = /** @class */ (function (_super) {
+    __extends(DefinitionsCacheInMemory, _super);
+    function DefinitionsCacheInMemory(splitFiltersValidation) {
+        var _this = _super.call(this) || this;
+        _this.definitionsCache = {};
+        _this.ttCache = {};
+        _this.changeNumber = -1;
+        _this.segmentsCount = 0;
+        _this.setsCache = {};
+        _this.setsFilter = splitFiltersValidation ? splitFiltersValidation.groupedFilters.bySet : [];
+        return _this;
+    }
+    DefinitionsCacheInMemory.prototype.clear = function () {
+        this.definitionsCache = {};
+        this.ttCache = {};
+        this.changeNumber = -1;
+        this.segmentsCount = 0;
+        this.setsCache = {};
+    };
+    DefinitionsCacheInMemory.prototype.add = function (definition) {
+        var name = definition.name;
+        var previousDefinition = this.get(name);
+        if (previousDefinition) { // We had this Split already
+            var previousTtName = previousDefinition.trafficTypeName;
+            this.ttCache[previousTtName]--;
+            if (!this.ttCache[previousTtName])
+                delete this.ttCache[previousTtName];
+            this.removeFromFlagSets(previousDefinition.name, previousDefinition.sets);
+            // Subtract from segments count for the previous version of this Split
+            if (usesSegments(previousDefinition))
+                this.segmentsCount--;
+        }
+        // Store the Split.
+        this.definitionsCache[name] = definition;
+        // Update TT cache
+        var ttName = definition.trafficTypeName;
+        this.ttCache[ttName] = (this.ttCache[ttName] || 0) + 1;
+        this.addToFlagSets(definition);
+        // Add to segments count for the new version of the Split
+        if (usesSegments(definition))
+            this.segmentsCount++;
+        return true;
+    };
+    DefinitionsCacheInMemory.prototype.remove = function (name) {
+        var definition = this.get(name);
+        if (!definition)
+            return false;
+        // Delete the Split
+        delete this.definitionsCache[name];
+        var ttName = definition.trafficTypeName;
+        this.ttCache[ttName]--; // Update tt cache
+        if (!this.ttCache[ttName])
+            delete this.ttCache[ttName];
+        this.removeFromFlagSets(definition.name, definition.sets);
+        // Update the segments count.
+        if (usesSegments(definition))
+            this.segmentsCount--;
+        return true;
+    };
+    DefinitionsCacheInMemory.prototype.get = function (name) {
+        return this.definitionsCache[name] || null;
+    };
+    DefinitionsCacheInMemory.prototype.setChangeNumber = function (changeNumber) {
+        this.changeNumber = changeNumber;
+        return true;
+    };
+    DefinitionsCacheInMemory.prototype.getChangeNumber = function () {
+        return this.changeNumber;
+    };
+    DefinitionsCacheInMemory.prototype.getNames = function () {
+        return Object.keys(this.definitionsCache);
+    };
+    DefinitionsCacheInMemory.prototype.trafficTypeExists = function (trafficType) {
+        return isFiniteNumber(this.ttCache[trafficType]) && this.ttCache[trafficType] > 0;
+    };
+    DefinitionsCacheInMemory.prototype.usesSegments = function () {
+        return this.getChangeNumber() === -1 || this.segmentsCount > 0;
+    };
+    DefinitionsCacheInMemory.prototype.getNamesBySets = function (sets) {
+        var _this = this;
+        return sets.map(function (set) { return _this.setsCache[set] || new Set(); });
+    };
+    DefinitionsCacheInMemory.prototype.addToFlagSets = function (featureFlag) {
+        var _this = this;
+        if (!featureFlag.sets)
+            return;
+        featureFlag.sets.forEach(function (featureFlagSet) {
+            if (_this.setsFilter.length > 0 && !_this.setsFilter.some(function (filterFlagSet) { return filterFlagSet === featureFlagSet; }))
+                return;
+            if (!_this.setsCache[featureFlagSet])
+                _this.setsCache[featureFlagSet] = new Set([]);
+            _this.setsCache[featureFlagSet].add(featureFlag.name);
+        });
+    };
+    DefinitionsCacheInMemory.prototype.removeFromFlagSets = function (featureFlagName, sets) {
+        var _this = this;
+        if (!sets)
+            return;
+        sets.forEach(function (set) {
+            _this.removeNames(set, featureFlagName);
+        });
+    };
+    DefinitionsCacheInMemory.prototype.removeNames = function (setName, featureFlagName) {
+        if (!this.setsCache[setName])
+            return;
+        this.setsCache[setName].delete(featureFlagName);
+        if (this.setsCache[setName].size === 0)
+            delete this.setsCache[setName];
+    };
+    return DefinitionsCacheInMemory;
+}(AbstractDefinitionsCacheSync));
+export { DefinitionsCacheInMemory };

package/esm/storages/inMemory/ImpressionCountsCacheInMemory.js

@@ -12,7 +12,7 @@ var ImpressionCountsCacheInMemory = /** @class */ (function () {
     * Builds key to be stored in the cache with the featureName and the timeFrame truncated.
     */
     ImpressionCountsCacheInMemory.prototype._makeKey = function (featureName, timeFrame) {
-        return featureName + "::" + truncateTimeFrame(timeFrame);
+        return "".concat(featureName, "::").concat(truncateTimeFrame(timeFrame));
     };
     /**
     * Increments the quantity of impressions with the passed featureName and timeFrame.

package/esm/storages/inMemory/InMemoryStorage.js

@@ -1,4 +1,4 @@
-import { SplitsCacheInMemory } from './SplitsCacheInMemory';
+import { DefinitionsCacheInMemory } from './DefinitionsCacheInMemory';
 import { SegmentsCacheInMemory } from './SegmentsCacheInMemory';
 import { ImpressionsCacheInMemory } from './ImpressionsCacheInMemory';
 import { EventsCacheInMemory } from './EventsCacheInMemory';
@@ -14,17 +14,17 @@ import { RBSegmentsCacheInMemory } from './RBSegmentsCacheInMemory';
  */
 export function InMemoryStorageFactory(params) {
     var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, __splitFiltersValidation = _a.sync.__splitFiltersValidation;
-    var splits = new SplitsCacheInMemory(__splitFiltersValidation);
+    var definitions = new DefinitionsCacheInMemory(__splitFiltersValidation);
     var rbSegments = new RBSegmentsCacheInMemory();
     var segments = new SegmentsCacheInMemory();
     var storage = {
-        splits: splits,
+        definitions: definitions,
         rbSegments: rbSegments,
         segments: segments,
         impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
         impressionCounts: new ImpressionCountsCacheInMemory(),
         events: new EventsCacheInMemory(eventsQueueSize),
-        telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
+        telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(definitions, segments) : undefined,
         uniqueKeys: new UniqueKeysCacheInMemory(),
         destroy: function () { }
     };

package/esm/storages/inMemory/InMemoryStorageCS.js

@@ -1,4 +1,4 @@
-import { SplitsCacheInMemory } from './SplitsCacheInMemory';
+import { DefinitionsCacheInMemory } from './DefinitionsCacheInMemory';
 import { MySegmentsCacheInMemory } from './MySegmentsCacheInMemory';
 import { ImpressionsCacheInMemory } from './ImpressionsCacheInMemory';
 import { EventsCacheInMemory } from './EventsCacheInMemory';
@@ -14,25 +14,25 @@ import { RBSegmentsCacheInMemory } from './RBSegmentsCacheInMemory';
  */
 export function InMemoryStorageCSFactory(params) {
     var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, __splitFiltersValidation = _a.sync.__splitFiltersValidation;
-    var splits = new SplitsCacheInMemory(__splitFiltersValidation);
+    var definitions = new DefinitionsCacheInMemory(__splitFiltersValidation);
     var rbSegments = new RBSegmentsCacheInMemory();
     var segments = new MySegmentsCacheInMemory();
     var largeSegments = new MySegmentsCacheInMemory();
     var storage = {
-        splits: splits,
+        definitions: definitions,
         rbSegments: rbSegments,
         segments: segments,
         largeSegments: largeSegments,
         impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
         impressionCounts: new ImpressionCountsCacheInMemory(),
         events: new EventsCacheInMemory(eventsQueueSize),
-        telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
+        telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(definitions, segments) : undefined,
         uniqueKeys: new UniqueKeysCacheInMemoryCS(),
         destroy: function () { },
         // When using shared instantiation with MEMORY we reuse everything but segments (they are unique per key)
         shared: function () {
             return {
-                splits: this.splits,
+                definitions: this.definitions,
                 rbSegments: this.rbSegments,
                 segments: new MySegmentsCacheInMemory(),
                 largeSegments: new MySegmentsCacheInMemory(),