@splitsoftware/splitio-commons 2.1.0 → 2.1.1-rc.0

package/esm/evaluator/matchers/index.js

@@ -21,6 +21,7 @@ import { greaterThanEqualToSemverMatcherContext } from './semver_gte';
 import { lessThanEqualToSemverMatcherContext } from './semver_lte';
 import { betweenSemverMatcherContext } from './semver_between';
 import { inListSemverMatcherContext } from './semver_inlist';
+import { ruleBasedSegmentMatcherContext } from './rbsegment';
 var matchers = [
     undefined,
     allMatcherContext,
@@ -45,7 +46,8 @@ var matchers = [
     lessThanEqualToSemverMatcherContext,
     betweenSemverMatcherContext,
     inListSemverMatcherContext,
-    largeSegmentMatcherContext, // IN_LARGE_SEGMENT: 23
+    largeSegmentMatcherContext,
+    ruleBasedSegmentMatcherContext // IN_RULE_BASED_SEGMENT: 24
 ];
 /**
  * Matcher factory.

package/esm/evaluator/matchers/matcherTypes.js

@@ -23,6 +23,7 @@ export var matcherTypes = {
     BETWEEN_SEMVER: 21,
     IN_LIST_SEMVER: 22,
     IN_LARGE_SEGMENT: 23,
+    IN_RULE_BASED_SEGMENT: 24,
 };
 export var matcherDataTypes = {
     BOOLEAN: 'BOOLEAN',

package/esm/evaluator/matchers/rbsegment.js

@@ -0,0 +1,39 @@
+import { thenable } from '../../utils/promise/thenable';
+import { getMatching, keyParser } from '../../utils/key';
+import { parser } from '../parser';
+export function ruleBasedSegmentMatcherContext(segmentName, storage, log) {
+    return function ruleBasedSegmentMatcher(_a, splitEvaluator) {
+        var key = _a.key, attributes = _a.attributes;
+        function matchConditions(rbsegment) {
+            var conditions = rbsegment.conditions;
+            var evaluator = parser(log, conditions, storage);
+            var evaluation = evaluator(keyParser(key), undefined, undefined, undefined, attributes, splitEvaluator);
+            return thenable(evaluation) ?
+                evaluation.then(function (evaluation) { return evaluation ? true : false; }) :
+                evaluation ? true : false;
+        }
+        function isExcluded(rbSegment) {
+            var matchingKey = getMatching(key);
+            if (rbSegment.excluded.keys.indexOf(matchingKey) !== -1)
+                return true;
+            var isInSegment = rbSegment.excluded.segments.map(function (segmentName) {
+                return storage.segments.isInSegment(segmentName, matchingKey);
+            });
+            return isInSegment.length && thenable(isInSegment[0]) ?
+                Promise.all(isInSegment).then(function (results) { return results.some(function (result) { return result; }); }) :
+                isInSegment.some(function (result) { return result; });
+        }
+        function isInSegment(rbSegment) {
+            if (!rbSegment)
+                return false;
+            var excluded = isExcluded(rbSegment);
+            return thenable(excluded) ?
+                excluded.then(function (excluded) { return excluded ? false : matchConditions(rbSegment); }) :
+                excluded ? false : matchConditions(rbSegment);
+        }
+        var rbSegment = storage.rbSegments.get(segmentName);
+        return thenable(rbSegment) ?
+            rbSegment.then(isInSegment) :
+            isInSegment(rbSegment);
+    };
+}

package/esm/evaluator/matchersTransform/index.js

@@ -78,6 +78,10 @@ export function matchersTransform(matchers) {
             type === matcherTypes.LESS_THAN_OR_EQUAL_TO_SEMVER) {
             value = stringMatcherData;
         }
+        else if (type === matcherTypes.IN_RULE_BASED_SEGMENT) {
+            value = segmentTransform(userDefinedSegmentMatcherData);
+            dataType = matcherDataTypes.NOT_SPECIFIED;
+        }
         return {
             attribute: attribute,
             negate: negate,

package/esm/evaluator/parser/index.js

@@ -50,8 +50,8 @@ export function parser(log, conditions, storage) {
             // and break the loop
             break;
         }
-        predicates.push(conditionContext(log, andCombinerContext(log, expressions), Treatments.parse(partitions), label, conditionType));
+        predicates.push(conditionContext(log, andCombinerContext(log, expressions), partitions && Treatments.parse(partitions), label, conditionType));
     }
-    // Instanciate evaluator given the set of conditions using if else if logic
+    // Instantiate evaluator given the set of conditions using if else if logic
     return ifElseIfCombinerContext(log, predicates);
 }

package/esm/evaluator/value/sanitize.js

@@ -49,6 +49,7 @@ function getProcessingFunction(matcherTypeID, dataType) {
         case matcherTypes.BETWEEN:
             return dataType === 'DATETIME' ? zeroSinceSS : undefined;
         case matcherTypes.IN_SPLIT_TREATMENT:
+        case matcherTypes.IN_RULE_BASED_SEGMENT:
             return dependencyProcessor;
         default:
             return undefined;

package/esm/logger/constants.js

@@ -20,9 +20,8 @@ export var RETRIEVE_CLIENT_EXISTING = 28;
 export var RETRIEVE_MANAGER = 29;
 export var SYNC_OFFLINE_DATA = 30;
 export var SYNC_SPLITS_FETCH = 31;
-export var SYNC_SPLITS_NEW = 32;
-export var SYNC_SPLITS_REMOVED = 33;
-export var SYNC_SPLITS_SEGMENTS = 34;
+export var SYNC_SPLITS_UPDATE = 32;
+export var SYNC_RBS_UPDATE = 33;
 export var STREAMING_NEW_MESSAGE = 35;
 export var SYNC_TASK_START = 36;
 export var SYNC_TASK_EXECUTE = 37;

package/esm/logger/messages/debug.js

@@ -19,10 +19,9 @@ export var codesDebug = codesInfo.concat([
     [c.RETRIEVE_MANAGER, 'Retrieving manager instance.'],
     // synchronizer
     [c.SYNC_OFFLINE_DATA, c.LOG_PREFIX_SYNC_OFFLINE + 'Feature flags data: \n%s'],
-    [c.SYNC_SPLITS_FETCH, c.LOG_PREFIX_SYNC_SPLITS + 'Spin up feature flags update using since = %s'],
-    [c.SYNC_SPLITS_NEW, c.LOG_PREFIX_SYNC_SPLITS + 'New feature flags %s'],
-    [c.SYNC_SPLITS_REMOVED, c.LOG_PREFIX_SYNC_SPLITS + 'Removed feature flags %s'],
-    [c.SYNC_SPLITS_SEGMENTS, c.LOG_PREFIX_SYNC_SPLITS + 'Segment names collected %s'],
+    [c.SYNC_SPLITS_FETCH, c.LOG_PREFIX_SYNC_SPLITS + 'Spin up feature flags update using since = %s and rbSince = %s.'],
+    [c.SYNC_SPLITS_UPDATE, c.LOG_PREFIX_SYNC_SPLITS + 'New feature flags %s. Removed feature flags %s.'],
+    [c.SYNC_RBS_UPDATE, c.LOG_PREFIX_SYNC_SPLITS + 'New rule-based segments %s. Removed rule-based segments %s.'],
     [c.STREAMING_NEW_MESSAGE, c.LOG_PREFIX_SYNC_STREAMING + 'New SSE message received, with data: %s.'],
     [c.SYNC_TASK_START, c.LOG_PREFIX_SYNC + ': Starting %s. Running each %s millis'],
     [c.SYNC_TASK_EXECUTE, c.LOG_PREFIX_SYNC + ': Running %s'],

package/esm/logger/messages/warn.js

@@ -31,7 +31,7 @@ export var codesWarn = codesError.concat([
     [c.WARN_SPLITS_FILTER_EMPTY, c.LOG_PREFIX_SETTINGS + ': feature flag filter configuration must be a non-empty array of filter objects.'],
     [c.WARN_SDK_KEY, c.LOG_PREFIX_SETTINGS + ': You already have %s. We recommend keeping only one instance of the factory at all times (Singleton pattern) and reusing it throughout your application'],
     [c.STREAMING_PARSING_MEMBERSHIPS_UPDATE, c.LOG_PREFIX_SYNC_STREAMING + 'Fetching Memberships due to an error processing %s notification: %s'],
-    [c.STREAMING_PARSING_SPLIT_UPDATE, c.LOG_PREFIX_SYNC_STREAMING + 'Fetching SplitChanges due to an error processing SPLIT_UPDATE notification: %s'],
+    [c.STREAMING_PARSING_SPLIT_UPDATE, c.LOG_PREFIX_SYNC_STREAMING + 'Fetching SplitChanges due to an error processing %s notification: %s'],
     [c.WARN_INVALID_FLAGSET, '%s: you passed %s, flag set must adhere to the regular expressions %s. This means a flag set must start with a letter or number, be in lowercase, alphanumeric and have a max length of 50 characters. %s was discarded.'],
     [c.WARN_LOWERCASE_FLAGSET, '%s: flag set %s should be all lowercase - converting string to lowercase.'],
     [c.WARN_FLAGSET_WITHOUT_FLAGS, '%s: you passed %s flag set that does not contain cached feature flag names. Please double check what flag sets are in use in the Split user interface.'],

package/esm/services/splitApi.js

@@ -38,8 +38,8 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
             }
             return splitHttpClient(url, undefined, telemetryTracker.trackHttp(TOKEN));
         },
-        fetchSplitChanges: function (since, noCache, till) {
-            var url = urls.sdk + "/splitChanges?s=" + flagSpecVersion + "&since=" + since + (filterQueryString || '') + (till ? '&till=' + till : '');
+        fetchSplitChanges: function (since, noCache, till, rbSince) {
+            var url = urls.sdk + "/splitChanges?s=" + flagSpecVersion + "&since=" + since + (rbSince ? '&rbSince=' + rbSince : '') + (filterQueryString || '') + (till ? '&till=' + till : '');
             return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SPLITS))
                 .catch(function (err) {
                 if (err.statusCode === 414)

package/esm/storages/AbstractSplitsCacheAsync.js

@@ -6,6 +6,17 @@ import { objectAssign } from '../utils/lang/objectAssign';
 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 () {
@@ -34,7 +45,7 @@ var AbstractSplitsCacheAsync = /** @class */ (function () {
                 newSplit.killed = true;
                 newSplit.defaultTreatment = defaultTreatment;
                 newSplit.changeNumber = changeNumber;
-                return _this.addSplit(name, newSplit);
+                return _this.addSplit(newSplit);
             }
             return false;
         }).catch(function () { return false; });

package/esm/storages/AbstractSplitsCacheSync.js

@@ -7,13 +7,11 @@ import { IN_SEGMENT, IN_LARGE_SEGMENT } from '../utils/constants';
 var AbstractSplitsCacheSync = /** @class */ (function () {
     function AbstractSplitsCacheSync() {
     }
-    AbstractSplitsCacheSync.prototype.addSplits = function (entries) {
+    AbstractSplitsCacheSync.prototype.update = function (toAdd, toRemove, changeNumber) {
         var _this = this;
-        return entries.map(function (keyValuePair) { return _this.addSplit(keyValuePair[0], keyValuePair[1]); });
-    };
-    AbstractSplitsCacheSync.prototype.removeSplits = function (names) {
-        var _this = this;
-        return names.map(function (name) { return _this.removeSplit(name); });
+        this.setChangeNumber(changeNumber);
+        var updated = toAdd.map(function (addedFF) { return _this.addSplit(addedFF); }).some(function (result) { return result; });
+        return toRemove.map(function (removedFF) { return _this.removeSplit(removedFF.name); }).some(function (result) { return result; }) || updated;
     };
     AbstractSplitsCacheSync.prototype.getSplits = function (names) {
         var _this = this;
@@ -48,7 +46,7 @@ var AbstractSplitsCacheSync = /** @class */ (function () {
             newSplit.killed = true;
             newSplit.defaultTreatment = defaultTreatment;
             newSplit.changeNumber = changeNumber;
-            return this.addSplit(name, newSplit);
+            return this.addSplit(newSplit);
         }
         return false;
     };
@@ -59,8 +57,8 @@ 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(split) {
-    var conditions = split.conditions || [];
+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++) {
@@ -69,5 +67,8 @@ export function usesSegments(split) {
                 return true;
         }
     }
+    var excluded = ruleEntity.excluded;
+    if (excluded && excluded.segments && excluded.segments.length > 0)
+        return true;
     return false;
 }

package/esm/storages/KeyBuilder.js

@@ -1,4 +1,3 @@
-import { startsWith } from '../utils/lang';
 import { hash } from '../utils/murmur3/murmur3';
 var everythingAtTheEnd = /[^.]+$/;
 var DEFAULT_PREFIX = 'SPLITIO';
@@ -22,19 +21,17 @@ var KeyBuilder = /** @class */ (function () {
     KeyBuilder.prototype.buildSplitsTillKey = function () {
         return this.prefix + ".splits.till";
     };
-    // NOT USED
-    // buildSplitsReady() {
-    //   return `${this.prefix}.splits.ready`;
-    // }
-    KeyBuilder.prototype.isSplitKey = function (key) {
-        return startsWith(key, this.prefix + ".split.");
-    };
     KeyBuilder.prototype.buildSplitKeyPrefix = function () {
         return this.prefix + ".split.";
     };
-    // Only used by InLocalStorage.
-    KeyBuilder.prototype.buildSplitsWithSegmentCountKey = function () {
-        return this.prefix + ".splits.usingSegments";
+    KeyBuilder.prototype.buildRBSegmentKey = function (rbsegmentName) {
+        return this.prefix + ".rbsegment." + rbsegmentName;
+    };
+    KeyBuilder.prototype.buildRBSegmentsTillKey = function () {
+        return this.prefix + ".rbsegments.till";
+    };
+    KeyBuilder.prototype.buildRBSegmentKeyPrefix = function () {
+        return this.prefix + ".rbsegment.";
     };
     KeyBuilder.prototype.buildSegmentNameKey = function (segmentName) {
         return this.prefix + ".segment." + segmentName;
@@ -42,10 +39,6 @@ var KeyBuilder = /** @class */ (function () {
     KeyBuilder.prototype.buildSegmentTillKey = function (segmentName) {
         return this.prefix + ".segment." + segmentName + ".till";
     };
-    // NOT USED
-    // buildSegmentsReady() {
-    //   return `${this.prefix}.segments.ready`;
-    // }
     KeyBuilder.prototype.extractKey = function (builtKey) {
         var s = builtKey.match(everythingAtTheEnd);
         if (s && s.length) {

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.regexSplitsCacheKey = new RegExp("^" + prefix + "\\.(splits?|trafficType|flagSet)\\.");
+        _this.regexSplitsCacheKey = new RegExp("^" + prefix + "\\.(splits?|trafficType|flagSet|rbsegment)\\.");
         return _this;
     }
     /**
@@ -18,7 +18,7 @@ var KeyBuilderCS = /** @class */ (function (_super) {
     KeyBuilderCS.prototype.extractSegmentName = function (builtSegmentKeyName) {
         var prefix = this.prefix + "." + this.matchingKey + ".segment.";
         if (startsWith(builtSegmentKeyName, prefix))
-            return builtSegmentKeyName.substr(prefix.length);
+            return builtSegmentKeyName.slice(prefix.length);
     };
     KeyBuilderCS.prototype.buildLastUpdatedKey = function () {
         return this.prefix + ".splits.lastUpdated";
@@ -29,6 +29,15 @@ var KeyBuilderCS = /** @class */ (function (_super) {
     KeyBuilderCS.prototype.buildTillKey = function () {
         return this.prefix + "." + this.matchingKey + ".segments.till";
     };
+    KeyBuilderCS.prototype.isSplitKey = function (key) {
+        return startsWith(key, this.prefix + ".split.");
+    };
+    KeyBuilderCS.prototype.isRBSegmentKey = function (key) {
+        return startsWith(key, this.prefix + ".rbsegment.");
+    };
+    KeyBuilderCS.prototype.buildSplitsWithSegmentCountKey = function () {
+        return this.prefix + ".splits.usingSegments";
+    };
     return KeyBuilderCS;
 }(KeyBuilder));
 export { KeyBuilderCS };
@@ -40,7 +49,7 @@ export function myLargeSegmentsKeyBuilder(prefix, matchingKey) {
         extractSegmentName: function (builtSegmentKeyName) {
             var p = prefix + "." + matchingKey + ".largeSegment.";
             if (startsWith(builtSegmentKeyName, p))
-                return builtSegmentKeyName.substr(p.length);
+                return builtSegmentKeyName.slice(p.length);
         },
         buildTillKey: function () {
             return prefix + "." + matchingKey + ".largeSegments.till";

package/esm/storages/KeyBuilderSS.js

@@ -39,6 +39,9 @@ var KeyBuilderSS = /** @class */ (function (_super) {
     KeyBuilderSS.prototype.searchPatternForSplitKeys = function () {
         return this.buildSplitKeyPrefix() + "*";
     };
+    KeyBuilderSS.prototype.searchPatternForRBSegmentKeys = function () {
+        return this.buildRBSegmentKeyPrefix() + "*";
+    };
     /* Telemetry keys */
     KeyBuilderSS.prototype.buildLatencyKey = function (method, bucket) {
         return this.latencyPrefix + "::" + this.versionablePrefix + "/" + METHOD_NAMES[method] + "/" + bucket;

package/esm/storages/dataLoader.js

@@ -29,9 +29,8 @@ export function dataLoaderFactory(preloadedData) {
             return;
         // cleaning up the localStorage data, since some cached splits might need be part of the preloaded data
         storage.splits.clear();
-        storage.splits.setChangeNumber(since);
         // splitsData in an object where the property is the split name and the pertaining value is a stringified json of its data
-        storage.splits.addSplits(Object.keys(splitsData).map(function (splitName) { return JSON.parse(splitsData[splitName]); }));
+        storage.splits.update(Object.keys(splitsData).map(function (splitName) { return JSON.parse(splitsData[splitName]); }), [], since);
         // add mySegments data
         var mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[userId];
         if (!mySegmentsData) {

package/esm/storages/inLocalStorage/RBSegmentsCacheInLocal.js

@@ -0,0 +1,114 @@
+import { isFiniteNumber, isNaNNumber, toNumber } from '../../utils/lang';
+import { setToArray } from '../../utils/lang/sets';
+import { usesSegments } from '../AbstractSplitsCacheSync';
+import { LOG_PREFIX } from './constants';
+var RBSegmentsCacheInLocal = /** @class */ (function () {
+    function RBSegmentsCacheInLocal(settings, keys) {
+        this.keys = keys;
+        this.log = settings.log;
+    }
+    RBSegmentsCacheInLocal.prototype.clear = function () {
+        var _this = this;
+        this.getNames().forEach(function (name) { return _this.remove(name); });
+        localStorage.removeItem(this.keys.buildRBSegmentsTillKey());
+    };
+    RBSegmentsCacheInLocal.prototype.update = function (toAdd, toRemove, changeNumber) {
+        var _this = this;
+        this.setChangeNumber(changeNumber);
+        var updated = toAdd.map(function (toAdd) { return _this.add(toAdd); }).some(function (result) { return result; });
+        return toRemove.map(function (toRemove) { return _this.remove(toRemove.name); }).some(function (result) { return result; }) || updated;
+    };
+    RBSegmentsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
+        try {
+            localStorage.setItem(this.keys.buildRBSegmentsTillKey(), changeNumber + '');
+            localStorage.setItem(this.keys.buildLastUpdatedKey(), Date.now() + '');
+        }
+        catch (e) {
+            this.log.error(LOG_PREFIX + e);
+        }
+    };
+    RBSegmentsCacheInLocal.prototype.updateSegmentCount = function (diff) {
+        var segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
+        var count = toNumber(localStorage.getItem(segmentsCountKey)) + diff;
+        // @ts-expect-error
+        if (count > 0)
+            localStorage.setItem(segmentsCountKey, count);
+        else
+            localStorage.removeItem(segmentsCountKey);
+    };
+    RBSegmentsCacheInLocal.prototype.add = function (rbSegment) {
+        try {
+            var name_1 = rbSegment.name;
+            var rbSegmentKey = this.keys.buildRBSegmentKey(name_1);
+            var rbSegmentFromLocalStorage = localStorage.getItem(rbSegmentKey);
+            var previous = rbSegmentFromLocalStorage ? JSON.parse(rbSegmentFromLocalStorage) : null;
+            localStorage.setItem(rbSegmentKey, JSON.stringify(rbSegment));
+            var usesSegmentsDiff = 0;
+            if (previous && usesSegments(previous))
+                usesSegmentsDiff--;
+            if (usesSegments(rbSegment))
+                usesSegmentsDiff++;
+            if (usesSegmentsDiff !== 0)
+                this.updateSegmentCount(usesSegmentsDiff);
+            return true;
+        }
+        catch (e) {
+            this.log.error(LOG_PREFIX + e);
+            return false;
+        }
+    };
+    RBSegmentsCacheInLocal.prototype.remove = function (name) {
+        try {
+            var rbSegment = this.get(name);
+            if (!rbSegment)
+                return false;
+            localStorage.removeItem(this.keys.buildRBSegmentKey(name));
+            if (usesSegments(rbSegment))
+                this.updateSegmentCount(-1);
+            return true;
+        }
+        catch (e) {
+            this.log.error(LOG_PREFIX + e);
+            return false;
+        }
+    };
+    RBSegmentsCacheInLocal.prototype.getNames = function () {
+        var len = localStorage.length;
+        var accum = [];
+        var cur = 0;
+        while (cur < len) {
+            var key = localStorage.key(cur);
+            if (key != null && this.keys.isRBSegmentKey(key))
+                accum.push(this.keys.extractKey(key));
+            cur++;
+        }
+        return accum;
+    };
+    RBSegmentsCacheInLocal.prototype.get = function (name) {
+        var item = localStorage.getItem(this.keys.buildRBSegmentKey(name));
+        return item && JSON.parse(item);
+    };
+    RBSegmentsCacheInLocal.prototype.contains = function (names) {
+        var namesArray = setToArray(names);
+        var namesInStorage = this.getNames();
+        return namesArray.every(function (name) { return namesInStorage.indexOf(name) !== -1; });
+    };
+    RBSegmentsCacheInLocal.prototype.getChangeNumber = function () {
+        var n = -1;
+        var value = localStorage.getItem(this.keys.buildRBSegmentsTillKey());
+        if (value !== null) {
+            value = parseInt(value, 10);
+            return isNaNNumber(value) ? n : value;
+        }
+        return n;
+    };
+    RBSegmentsCacheInLocal.prototype.usesSegments = function () {
+        var storedCount = localStorage.getItem(this.keys.buildSplitsWithSegmentCountKey());
+        var splitsWithSegmentsCount = storedCount === null ? 0 : toNumber(storedCount);
+        return isFiniteNumber(splitsWithSegmentsCount) ?
+            splitsWithSegmentsCount > 0 :
+            true;
+    };
+    return RBSegmentsCacheInLocal;
+}());
+export { RBSegmentsCacheInLocal };

package/esm/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -44,15 +44,13 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
     };
     SplitsCacheInLocal.prototype._incrementCounts = function (split) {
         try {
-            if (split) {
-                var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
+            var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
+            // @ts-expect-error
+            localStorage.setItem(ttKey, toNumber(localStorage.getItem(ttKey)) + 1);
+            if (usesSegments(split)) {
+                var segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
                 // @ts-expect-error
-                localStorage.setItem(ttKey, toNumber(localStorage.getItem(ttKey)) + 1);
-                if (usesSegments(split)) {
-                    var segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
-                    // @ts-expect-error
-                    localStorage.setItem(segmentsCountKey, toNumber(localStorage.getItem(segmentsCountKey)) + 1);
-                }
+                localStorage.setItem(segmentsCountKey, toNumber(localStorage.getItem(segmentsCountKey)) + 1);
             }
         }
         catch (e) {
@@ -79,9 +77,10 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         });
         this.hasSync = false;
     };
-    SplitsCacheInLocal.prototype.addSplit = function (name, split) {
+    SplitsCacheInLocal.prototype.addSplit = function (split) {
         try {
-            var splitKey = this.keys.buildSplitKey(name);
+            var name_1 = split.name;
+            var splitKey = this.keys.buildSplitKey(name_1);
             var splitFromLocalStorage = localStorage.getItem(splitKey);
             var previousSplit = splitFromLocalStorage ? JSON.parse(splitFromLocalStorage) : null;
             localStorage.setItem(splitKey, JSON.stringify(split));
@@ -100,6 +99,8 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
     SplitsCacheInLocal.prototype.removeSplit = function (name) {
         try {
             var split = this.getSplit(name);
+            if (!split)
+                return false;
             localStorage.removeItem(this.keys.buildSplitKey(name));
             this._decrementCounts(split);
             if (split)
@@ -171,12 +172,9 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
             return true;
         var storedCount = localStorage.getItem(this.keys.buildSplitsWithSegmentCountKey());
         var splitsWithSegmentsCount = storedCount === null ? 0 : toNumber(storedCount);
-        if (isFiniteNumber(splitsWithSegmentsCount)) {
-            return splitsWithSegmentsCount > 0;
-        }
-        else {
-            return true;
-        }
+        return isFiniteNumber(splitsWithSegmentsCount) ?
+            splitsWithSegmentsCount > 0 :
+            true;
     };
     /**
      * Check if the splits information is already stored in browser LocalStorage.

package/esm/storages/inLocalStorage/index.js

@@ -13,6 +13,7 @@ import { STORAGE_LOCALSTORAGE } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from '../inMemory/TelemetryCacheInMemory';
 import { UniqueKeysCacheInMemoryCS } from '../inMemory/UniqueKeysCacheInMemoryCS';
 import { getMatching } from '../../utils/key';
+import { RBSegmentsCacheInLocal } from './RBSegmentsCacheInLocal';
 /**
  * InLocal storage factory for standalone client-side SplitFactory
  */
@@ -30,10 +31,12 @@ export function InLocalStorage(options) {
         var keys = new KeyBuilderCS(prefix, matchingKey);
         var expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
         var splits = new SplitsCacheInLocal(settings, keys, expirationTimestamp);
+        var rbSegments = new RBSegmentsCacheInLocal(settings, keys);
         var segments = new MySegmentsCacheInLocal(log, keys);
         var largeSegments = new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey));
         return {
             splits: splits,
+            rbSegments: rbSegments,
             segments: segments,
             largeSegments: largeSegments,
             impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
@@ -46,6 +49,7 @@ export function InLocalStorage(options) {
             shared: function (matchingKey) {
                 return {
                     splits: this.splits,
+                    rbSegments: this.rbSegments,
                     segments: new MySegmentsCacheInLocal(log, new KeyBuilderCS(prefix, matchingKey)),
                     largeSegments: new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey)),
                     impressions: this.impressions,

package/esm/storages/inMemory/InMemoryStorage.js

@@ -6,6 +6,7 @@ import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
 import { LOCALHOST_MODE, STORAGE_MEMORY } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from './TelemetryCacheInMemory';
 import { UniqueKeysCacheInMemory } from './UniqueKeysCacheInMemory';
+import { RBSegmentsCacheInMemory } from './RBSegmentsCacheInMemory';
 /**
  * InMemory storage factory for standalone server-side SplitFactory
  *
@@ -14,9 +15,11 @@ import { UniqueKeysCacheInMemory } from './UniqueKeysCacheInMemory';
 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 rbSegments = new RBSegmentsCacheInMemory();
     var segments = new SegmentsCacheInMemory();
     var storage = {
         splits: splits,
+        rbSegments: rbSegments,
         segments: segments,
         impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
         impressionCounts: new ImpressionCountsCacheInMemory(),

package/esm/storages/inMemory/InMemoryStorageCS.js

@@ -6,6 +6,7 @@ import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
 import { LOCALHOST_MODE, STORAGE_MEMORY } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from './TelemetryCacheInMemory';
 import { UniqueKeysCacheInMemoryCS } from './UniqueKeysCacheInMemoryCS';
+import { RBSegmentsCacheInMemory } from './RBSegmentsCacheInMemory';
 /**
  * InMemory storage factory for standalone client-side SplitFactory
  *
@@ -14,10 +15,12 @@ import { UniqueKeysCacheInMemoryCS } from './UniqueKeysCacheInMemoryCS';
 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 rbSegments = new RBSegmentsCacheInMemory();
     var segments = new MySegmentsCacheInMemory();
     var largeSegments = new MySegmentsCacheInMemory();
     var storage = {
         splits: splits,
+        rbSegments: rbSegments,
         segments: segments,
         largeSegments: largeSegments,
         impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
@@ -30,6 +33,7 @@ export function InMemoryStorageCSFactory(params) {
         shared: function () {
             return {
                 splits: this.splits,
+                rbSegments: this.rbSegments,
                 segments: new MySegmentsCacheInMemory(),
                 largeSegments: new MySegmentsCacheInMemory(),
                 impressions: this.impressions,

package/esm/storages/inMemory/RBSegmentsCacheInMemory.js

@@ -0,0 +1,58 @@
+import { setToArray } from '../../utils/lang/sets';
+import { usesSegments } from '../AbstractSplitsCacheSync';
+var RBSegmentsCacheInMemory = /** @class */ (function () {
+    function RBSegmentsCacheInMemory() {
+        this.cache = {};
+        this.changeNumber = -1;
+        this.segmentsCount = 0;
+    }
+    RBSegmentsCacheInMemory.prototype.clear = function () {
+        this.cache = {};
+        this.changeNumber = -1;
+        this.segmentsCount = 0;
+    };
+    RBSegmentsCacheInMemory.prototype.update = function (toAdd, toRemove, changeNumber) {
+        var _this = this;
+        this.changeNumber = changeNumber;
+        var updated = toAdd.map(function (toAdd) { return _this.add(toAdd); }).some(function (result) { return result; });
+        return toRemove.map(function (toRemove) { return _this.remove(toRemove.name); }).some(function (result) { return result; }) || updated;
+    };
+    RBSegmentsCacheInMemory.prototype.add = function (rbSegment) {
+        var name = rbSegment.name;
+        var previous = this.get(name);
+        if (previous && usesSegments(previous))
+            this.segmentsCount--;
+        this.cache[name] = rbSegment;
+        if (usesSegments(rbSegment))
+            this.segmentsCount++;
+        return true;
+    };
+    RBSegmentsCacheInMemory.prototype.remove = function (name) {
+        var rbSegment = this.get(name);
+        if (!rbSegment)
+            return false;
+        delete this.cache[name];
+        if (usesSegments(rbSegment))
+            this.segmentsCount--;
+        return true;
+    };
+    RBSegmentsCacheInMemory.prototype.getNames = function () {
+        return Object.keys(this.cache);
+    };
+    RBSegmentsCacheInMemory.prototype.get = function (name) {
+        return this.cache[name] || null;
+    };
+    RBSegmentsCacheInMemory.prototype.contains = function (names) {
+        var namesArray = setToArray(names);
+        var namesInStorage = this.getNames();
+        return namesArray.every(function (name) { return namesInStorage.indexOf(name) !== -1; });
+    };
+    RBSegmentsCacheInMemory.prototype.getChangeNumber = function () {
+        return this.changeNumber;
+    };
+    RBSegmentsCacheInMemory.prototype.usesSegments = function () {
+        return this.segmentsCount > 0;
+    };
+    return RBSegmentsCacheInMemory;
+}());
+export { RBSegmentsCacheInMemory };