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

package/esm/sdkClient/client.js

@@ -15,6 +15,14 @@ function treatmentsNotReady(featureFlagNames) {
     });
     return evaluations;
 }
+function stringify(options) {
+    if (options && options.properties) {
+        try {
+            return JSON.stringify(options.properties);
+        }
+        catch ( /* JSON.stringify should never throw with validated options, but handling just in case */_a) { /* JSON.stringify should never throw with validated options, but handling just in case */ }
+    }
+}
 /**
  * Creator of base client with getTreatments and track methods.
  */
@@ -22,13 +30,13 @@ export function clientFactory(params) {
     var readinessManager = params.sdkReadinessManager.readinessManager, storage = params.storage, settings = params.settings, impressionsTracker = params.impressionsTracker, eventTracker = params.eventTracker, telemetryTracker = params.telemetryTracker;
     var log = settings.log, mode = settings.mode;
     var isAsync = isConsumerMode(mode);
-    function getTreatment(key, featureFlagName, attributes, withConfig, methodName) {
+    function getTreatment(key, featureFlagName, attributes, options, withConfig, methodName) {
         if (withConfig === void 0) { withConfig = false; }
         if (methodName === void 0) { methodName = GET_TREATMENT; }
         var stopTelemetryTracker = telemetryTracker.trackEval(withConfig ? TREATMENT_WITH_CONFIG : TREATMENT);
         var wrapUp = function (evaluationResult) {
             var queue = [];
-            var treatment = processEvaluation(evaluationResult, featureFlagName, key, attributes, withConfig, methodName, queue);
+            var treatment = processEvaluation(evaluationResult, featureFlagName, key, stringify(options), withConfig, methodName, queue);
             impressionsTracker.track(queue, attributes);
             stopTelemetryTracker(queue[0] && queue[0].imp.label);
             return treatment;
@@ -40,18 +48,19 @@ export function clientFactory(params) {
                 treatmentNotReady;
         return thenable(evaluation) ? evaluation.then(function (res) { return wrapUp(res); }) : wrapUp(evaluation);
     }
-    function getTreatmentWithConfig(key, featureFlagName, attributes) {
-        return getTreatment(key, featureFlagName, attributes, true, GET_TREATMENT_WITH_CONFIG);
+    function getTreatmentWithConfig(key, featureFlagName, attributes, options) {
+        return getTreatment(key, featureFlagName, attributes, options, true, GET_TREATMENT_WITH_CONFIG);
     }
-    function getTreatments(key, featureFlagNames, attributes, withConfig, methodName) {
+    function getTreatments(key, featureFlagNames, attributes, options, withConfig, methodName) {
         if (withConfig === void 0) { withConfig = false; }
         if (methodName === void 0) { methodName = GET_TREATMENTS; }
         var stopTelemetryTracker = telemetryTracker.trackEval(withConfig ? TREATMENTS_WITH_CONFIG : TREATMENTS);
         var wrapUp = function (evaluationResults) {
             var queue = [];
             var treatments = {};
+            var properties = stringify(options);
             Object.keys(evaluationResults).forEach(function (featureFlagName) {
-                treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, attributes, withConfig, methodName, queue);
+                treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, properties, withConfig, methodName, queue);
             });
             impressionsTracker.track(queue, attributes);
             stopTelemetryTracker(queue[0] && queue[0].imp.label);
@@ -64,10 +73,10 @@ export function clientFactory(params) {
                 treatmentsNotReady(featureFlagNames);
         return thenable(evaluations) ? evaluations.then(function (res) { return wrapUp(res); }) : wrapUp(evaluations);
     }
-    function getTreatmentsWithConfig(key, featureFlagNames, attributes) {
-        return getTreatments(key, featureFlagNames, attributes, true, GET_TREATMENTS_WITH_CONFIG);
+    function getTreatmentsWithConfig(key, featureFlagNames, attributes, options) {
+        return getTreatments(key, featureFlagNames, attributes, options, true, GET_TREATMENTS_WITH_CONFIG);
     }
-    function getTreatmentsByFlagSets(key, flagSetNames, attributes, withConfig, method, methodName) {
+    function getTreatmentsByFlagSets(key, flagSetNames, attributes, options, withConfig, method, methodName) {
         if (withConfig === void 0) { withConfig = false; }
         if (method === void 0) { method = TREATMENTS_BY_FLAGSETS; }
         if (methodName === void 0) { methodName = GET_TREATMENTS_BY_FLAG_SETS; }
@@ -75,9 +84,9 @@ export function clientFactory(params) {
         var wrapUp = function (evaluationResults) {
             var queue = [];
             var treatments = {};
-            var evaluations = evaluationResults;
-            Object.keys(evaluations).forEach(function (featureFlagName) {
-                treatments[featureFlagName] = processEvaluation(evaluations[featureFlagName], featureFlagName, key, attributes, withConfig, methodName, queue);
+            var properties = stringify(options);
+            Object.keys(evaluationResults).forEach(function (featureFlagName) {
+                treatments[featureFlagName] = processEvaluation(evaluationResults[featureFlagName], featureFlagName, key, properties, withConfig, methodName, queue);
             });
             impressionsTracker.track(queue, attributes);
             stopTelemetryTracker(queue[0] && queue[0].imp.label);
@@ -90,17 +99,17 @@ export function clientFactory(params) {
                 {};
         return thenable(evaluations) ? evaluations.then(function (res) { return wrapUp(res); }) : wrapUp(evaluations);
     }
-    function getTreatmentsWithConfigByFlagSets(key, flagSetNames, attributes) {
-        return getTreatmentsByFlagSets(key, flagSetNames, attributes, true, TREATMENTS_WITH_CONFIG_BY_FLAGSETS, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS);
+    function getTreatmentsWithConfigByFlagSets(key, flagSetNames, attributes, options) {
+        return getTreatmentsByFlagSets(key, flagSetNames, attributes, options, true, TREATMENTS_WITH_CONFIG_BY_FLAGSETS, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS);
     }
-    function getTreatmentsByFlagSet(key, flagSetName, attributes) {
-        return getTreatmentsByFlagSets(key, [flagSetName], attributes, false, TREATMENTS_BY_FLAGSET, GET_TREATMENTS_BY_FLAG_SET);
+    function getTreatmentsByFlagSet(key, flagSetName, attributes, options) {
+        return getTreatmentsByFlagSets(key, [flagSetName], attributes, options, false, TREATMENTS_BY_FLAGSET, GET_TREATMENTS_BY_FLAG_SET);
     }
-    function getTreatmentsWithConfigByFlagSet(key, flagSetName, attributes) {
-        return getTreatmentsByFlagSets(key, [flagSetName], attributes, true, TREATMENTS_WITH_CONFIG_BY_FLAGSET, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET);
+    function getTreatmentsWithConfigByFlagSet(key, flagSetName, attributes, options) {
+        return getTreatmentsByFlagSets(key, [flagSetName], attributes, options, true, TREATMENTS_WITH_CONFIG_BY_FLAGSET, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET);
     }
     // Internal function
-    function processEvaluation(evaluation, featureFlagName, key, attributes, withConfig, invokingMethodName, queue) {
+    function processEvaluation(evaluation, featureFlagName, key, properties, withConfig, invokingMethodName, queue) {
         var matchingKey = getMatching(key);
         var bucketingKey = getBucketing(key);
         var treatment = evaluation.treatment, label = evaluation.label, changeNumber = evaluation.changeNumber, _a = evaluation.config, config = _a === void 0 ? null : _a, impressionsDisabled = evaluation.impressionsDisabled;
@@ -116,6 +125,7 @@ export function clientFactory(params) {
                     bucketingKey: bucketingKey,
                     label: label,
                     changeNumber: changeNumber,
+                    properties: properties
                 },
                 disabled: impressionsDisabled
             });

package/esm/sdkClient/clientAttributesDecoration.js

@@ -15,40 +15,35 @@ export function clientAttributesDecoration(log, client) {
     var clientGetTreatmentsWithConfigByFlagSets = client.getTreatmentsWithConfigByFlagSets;
     var clientGetTreatmentsByFlagSet = client.getTreatmentsByFlagSet;
     var clientGetTreatmentsWithConfigByFlagSet = client.getTreatmentsWithConfigByFlagSet;
-    var clientTrack = client.track;
-    function getTreatment(maybeKey, maybeFeatureFlagName, maybeAttributes) {
-        return clientGetTreatment(maybeKey, maybeFeatureFlagName, combineAttributes(maybeAttributes));
+    function getTreatment(maybeKey, maybeFeatureFlagName, maybeAttributes, maybeOptions) {
+        return clientGetTreatment(maybeKey, maybeFeatureFlagName, combineAttributes(maybeAttributes), maybeOptions);
     }
-    function getTreatmentWithConfig(maybeKey, maybeFeatureFlagName, maybeAttributes) {
-        return clientGetTreatmentWithConfig(maybeKey, maybeFeatureFlagName, combineAttributes(maybeAttributes));
+    function getTreatmentWithConfig(maybeKey, maybeFeatureFlagName, maybeAttributes, maybeOptions) {
+        return clientGetTreatmentWithConfig(maybeKey, maybeFeatureFlagName, combineAttributes(maybeAttributes), maybeOptions);
     }
-    function getTreatments(maybeKey, maybeFeatureFlagNames, maybeAttributes) {
-        return clientGetTreatments(maybeKey, maybeFeatureFlagNames, combineAttributes(maybeAttributes));
+    function getTreatments(maybeKey, maybeFeatureFlagNames, maybeAttributes, maybeOptions) {
+        return clientGetTreatments(maybeKey, maybeFeatureFlagNames, combineAttributes(maybeAttributes), maybeOptions);
     }
-    function getTreatmentsWithConfig(maybeKey, maybeFeatureFlagNames, maybeAttributes) {
-        return clientGetTreatmentsWithConfig(maybeKey, maybeFeatureFlagNames, combineAttributes(maybeAttributes));
+    function getTreatmentsWithConfig(maybeKey, maybeFeatureFlagNames, maybeAttributes, maybeOptions) {
+        return clientGetTreatmentsWithConfig(maybeKey, maybeFeatureFlagNames, combineAttributes(maybeAttributes), maybeOptions);
     }
-    function getTreatmentsByFlagSets(maybeKey, maybeFlagSets, maybeAttributes) {
-        return clientGetTreatmentsByFlagSets(maybeKey, maybeFlagSets, combineAttributes(maybeAttributes));
+    function getTreatmentsByFlagSets(maybeKey, maybeFlagSets, maybeAttributes, maybeOptions) {
+        return clientGetTreatmentsByFlagSets(maybeKey, maybeFlagSets, combineAttributes(maybeAttributes), maybeOptions);
     }
-    function getTreatmentsWithConfigByFlagSets(maybeKey, maybeFlagSets, maybeAttributes) {
-        return clientGetTreatmentsWithConfigByFlagSets(maybeKey, maybeFlagSets, combineAttributes(maybeAttributes));
+    function getTreatmentsWithConfigByFlagSets(maybeKey, maybeFlagSets, maybeAttributes, maybeOptions) {
+        return clientGetTreatmentsWithConfigByFlagSets(maybeKey, maybeFlagSets, combineAttributes(maybeAttributes), maybeOptions);
     }
-    function getTreatmentsByFlagSet(maybeKey, maybeFlagSet, maybeAttributes) {
-        return clientGetTreatmentsByFlagSet(maybeKey, maybeFlagSet, combineAttributes(maybeAttributes));
+    function getTreatmentsByFlagSet(maybeKey, maybeFlagSet, maybeAttributes, maybeOptions) {
+        return clientGetTreatmentsByFlagSet(maybeKey, maybeFlagSet, combineAttributes(maybeAttributes), maybeOptions);
     }
-    function getTreatmentsWithConfigByFlagSet(maybeKey, maybeFlagSet, maybeAttributes) {
-        return clientGetTreatmentsWithConfigByFlagSet(maybeKey, maybeFlagSet, combineAttributes(maybeAttributes));
-    }
-    function track(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties) {
-        return clientTrack(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties);
+    function getTreatmentsWithConfigByFlagSet(maybeKey, maybeFlagSet, maybeAttributes, maybeOptions) {
+        return clientGetTreatmentsWithConfigByFlagSet(maybeKey, maybeFlagSet, combineAttributes(maybeAttributes), maybeOptions);
     }
     function combineAttributes(maybeAttributes) {
         var storedAttributes = attributeStorage.getAll();
-        if (Object.keys(storedAttributes).length > 0) {
-            return objectAssign({}, storedAttributes, maybeAttributes);
-        }
-        return maybeAttributes;
+        return Object.keys(storedAttributes).length > 0 ?
+            objectAssign({}, storedAttributes, maybeAttributes) :
+            maybeAttributes;
     }
     return objectAssign(client, {
         getTreatment: getTreatment,
@@ -59,7 +54,6 @@ export function clientAttributesDecoration(log, client) {
         getTreatmentsWithConfigByFlagSets: getTreatmentsWithConfigByFlagSets,
         getTreatmentsByFlagSet: getTreatmentsByFlagSet,
         getTreatmentsWithConfigByFlagSet: getTreatmentsWithConfigByFlagSet,
-        track: track,
         /**
          * Add an attribute to client's in memory attributes storage
          *

package/esm/sdkClient/clientInputValidation.js

@@ -1,5 +1,5 @@
 import { objectAssign } from '../utils/lang/objectAssign';
-import { validateAttributes, validateEvent, validateEventValue, validateEventProperties, validateKey, validateSplit, validateSplits, validateTrafficType, validateIfNotDestroyed, validateIfOperational } from '../utils/inputValidation';
+import { validateAttributes, validateEvent, validateEventValue, validateEventProperties, validateKey, validateSplit, validateSplits, validateTrafficType, validateIfNotDestroyed, validateIfOperational, validateEvaluationOptions } from '../utils/inputValidation';
 import { startsWith } from '../utils/lang';
 import { CONTROL, CONTROL_WITH_CONFIG, 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';
@@ -14,7 +14,7 @@ export function clientInputValidationDecorator(settings, client, readinessManage
     /**
      * Avoid repeating this validations code
      */
-    function validateEvaluationParams(maybeKey, maybeNameOrNames, maybeAttributes, methodName) {
+    function validateEvaluationParams(methodName, maybeKey, maybeNameOrNames, maybeAttributes, maybeOptions) {
         var key = validateKey(log, maybeKey, methodName);
         var nameOrNames = methodName.indexOf('ByFlagSet') > -1 ?
             validateFlagSets(log, methodName, maybeNameOrNames, settings.sync.__splitFiltersValidation.groupedFilters.bySet) :
@@ -23,40 +23,42 @@ export function clientInputValidationDecorator(settings, client, readinessManage
                 validateSplit(log, maybeNameOrNames, methodName);
         var attributes = validateAttributes(log, maybeAttributes, methodName);
         var isNotDestroyed = validateIfNotDestroyed(log, readinessManager, methodName);
+        var options = validateEvaluationOptions(log, maybeOptions, methodName);
         validateIfOperational(log, readinessManager, methodName, nameOrNames);
         var valid = isNotDestroyed && key && nameOrNames && attributes !== false;
         return {
             valid: valid,
             key: key,
             nameOrNames: nameOrNames,
-            attributes: attributes
+            attributes: attributes,
+            options: options
         };
     }
     function wrapResult(value) {
         return isAsync ? Promise.resolve(value) : value;
     }
-    function getTreatment(maybeKey, maybeFeatureFlagName, maybeAttributes) {
-        var params = validateEvaluationParams(maybeKey, maybeFeatureFlagName, maybeAttributes, GET_TREATMENT);
+    function getTreatment(maybeKey, maybeFeatureFlagName, maybeAttributes, maybeOptions) {
+        var params = validateEvaluationParams(GET_TREATMENT, maybeKey, maybeFeatureFlagName, maybeAttributes, maybeOptions);
         if (params.valid) {
-            return client.getTreatment(params.key, params.nameOrNames, params.attributes);
+            return client.getTreatment(params.key, params.nameOrNames, params.attributes, params.options);
         }
         else {
             return wrapResult(CONTROL);
         }
     }
-    function getTreatmentWithConfig(maybeKey, maybeFeatureFlagName, maybeAttributes) {
-        var params = validateEvaluationParams(maybeKey, maybeFeatureFlagName, maybeAttributes, GET_TREATMENT_WITH_CONFIG);
+    function getTreatmentWithConfig(maybeKey, maybeFeatureFlagName, maybeAttributes, maybeOptions) {
+        var params = validateEvaluationParams(GET_TREATMENT_WITH_CONFIG, maybeKey, maybeFeatureFlagName, maybeAttributes, maybeOptions);
         if (params.valid) {
-            return client.getTreatmentWithConfig(params.key, params.nameOrNames, params.attributes);
+            return client.getTreatmentWithConfig(params.key, params.nameOrNames, params.attributes, params.options);
         }
         else {
             return wrapResult(objectAssign({}, CONTROL_WITH_CONFIG));
         }
     }
-    function getTreatments(maybeKey, maybeFeatureFlagNames, maybeAttributes) {
-        var params = validateEvaluationParams(maybeKey, maybeFeatureFlagNames, maybeAttributes, GET_TREATMENTS);
+    function getTreatments(maybeKey, maybeFeatureFlagNames, maybeAttributes, maybeOptions) {
+        var params = validateEvaluationParams(GET_TREATMENTS, maybeKey, maybeFeatureFlagNames, maybeAttributes, maybeOptions);
         if (params.valid) {
-            return client.getTreatments(params.key, params.nameOrNames, params.attributes);
+            return client.getTreatments(params.key, params.nameOrNames, params.attributes, params.options);
         }
         else {
             var res_1 = {};
@@ -65,10 +67,10 @@ export function clientInputValidationDecorator(settings, client, readinessManage
             return wrapResult(res_1);
         }
     }
-    function getTreatmentsWithConfig(maybeKey, maybeFeatureFlagNames, maybeAttributes) {
-        var params = validateEvaluationParams(maybeKey, maybeFeatureFlagNames, maybeAttributes, GET_TREATMENTS_WITH_CONFIG);
+    function getTreatmentsWithConfig(maybeKey, maybeFeatureFlagNames, maybeAttributes, maybeOptions) {
+        var params = validateEvaluationParams(GET_TREATMENTS_WITH_CONFIG, maybeKey, maybeFeatureFlagNames, maybeAttributes, maybeOptions);
         if (params.valid) {
-            return client.getTreatmentsWithConfig(params.key, params.nameOrNames, params.attributes);
+            return client.getTreatmentsWithConfig(params.key, params.nameOrNames, params.attributes, params.options);
         }
         else {
             var res_2 = {};
@@ -77,37 +79,37 @@ export function clientInputValidationDecorator(settings, client, readinessManage
             return wrapResult(res_2);
         }
     }
-    function getTreatmentsByFlagSets(maybeKey, maybeFlagSets, maybeAttributes) {
-        var params = validateEvaluationParams(maybeKey, maybeFlagSets, maybeAttributes, GET_TREATMENTS_BY_FLAG_SETS);
+    function getTreatmentsByFlagSets(maybeKey, maybeFlagSets, maybeAttributes, maybeOptions) {
+        var params = validateEvaluationParams(GET_TREATMENTS_BY_FLAG_SETS, maybeKey, maybeFlagSets, maybeAttributes, maybeOptions);
         if (params.valid) {
-            return client.getTreatmentsByFlagSets(params.key, params.nameOrNames, params.attributes);
+            return client.getTreatmentsByFlagSets(params.key, params.nameOrNames, params.attributes, params.options);
         }
         else {
             return wrapResult({});
         }
     }
-    function getTreatmentsWithConfigByFlagSets(maybeKey, maybeFlagSets, maybeAttributes) {
-        var params = validateEvaluationParams(maybeKey, maybeFlagSets, maybeAttributes, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS);
+    function getTreatmentsWithConfigByFlagSets(maybeKey, maybeFlagSets, maybeAttributes, maybeOptions) {
+        var params = validateEvaluationParams(GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, maybeKey, maybeFlagSets, maybeAttributes, maybeOptions);
         if (params.valid) {
-            return client.getTreatmentsWithConfigByFlagSets(params.key, params.nameOrNames, params.attributes);
+            return client.getTreatmentsWithConfigByFlagSets(params.key, params.nameOrNames, params.attributes, params.options);
         }
         else {
             return wrapResult({});
         }
     }
-    function getTreatmentsByFlagSet(maybeKey, maybeFlagSet, maybeAttributes) {
-        var params = validateEvaluationParams(maybeKey, [maybeFlagSet], maybeAttributes, GET_TREATMENTS_BY_FLAG_SET);
+    function getTreatmentsByFlagSet(maybeKey, maybeFlagSet, maybeAttributes, maybeOptions) {
+        var params = validateEvaluationParams(GET_TREATMENTS_BY_FLAG_SET, maybeKey, [maybeFlagSet], maybeAttributes, maybeOptions);
         if (params.valid) {
-            return client.getTreatmentsByFlagSet(params.key, params.nameOrNames[0], params.attributes);
+            return client.getTreatmentsByFlagSet(params.key, params.nameOrNames[0], params.attributes, params.options);
         }
         else {
             return wrapResult({});
         }
     }
-    function getTreatmentsWithConfigByFlagSet(maybeKey, maybeFlagSet, maybeAttributes) {
-        var params = validateEvaluationParams(maybeKey, [maybeFlagSet], maybeAttributes, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET);
+    function getTreatmentsWithConfigByFlagSet(maybeKey, maybeFlagSet, maybeAttributes, maybeOptions) {
+        var params = validateEvaluationParams(GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, maybeKey, [maybeFlagSet], maybeAttributes, maybeOptions);
         if (params.valid) {
-            return client.getTreatmentsWithConfigByFlagSet(params.key, params.nameOrNames[0], params.attributes);
+            return client.getTreatmentsWithConfigByFlagSet(params.key, params.nameOrNames[0], params.attributes, params.options);
         }
         else {
             return wrapResult({});

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, rbSince) {
-            var url = urls.sdk + "/splitChanges?s=" + flagSpecVersion + "&since=" + since + (rbSince ? '&rbSince=' + rbSince : '') + (filterQueryString || '') + (till ? '&till=' + till : '');
+        fetchSplitChanges: function (since, noCache, till) {
+            var url = urls.sdk + "/splitChanges?s=" + flagSpecVersion + "&since=" + since + (filterQueryString || '') + (till ? '&till=' + till : '');
             return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SPLITS))
                 .catch(function (err) {
                 if (err.statusCode === 414)

package/esm/storages/AbstractSplitsCacheSync.js

@@ -57,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(ruleEntity) {
-    var conditions = ruleEntity.conditions || [];
+export function usesSegments(split) {
+    var conditions = split.conditions || [];
     for (var i = 0; i < conditions.length; i++) {
         var matchers = conditions[i].matcherGroup.matchers;
         for (var j = 0; j < matchers.length; j++) {
@@ -67,8 +67,5 @@ export function usesSegments(ruleEntity) {
                 return true;
         }
     }
-    var excluded = ruleEntity.excluded;
-    if (excluded && excluded.segments && excluded.segments.length > 0)
-        return true;
     return false;
 }

package/esm/storages/KeyBuilder.js

@@ -24,15 +24,6 @@ var KeyBuilder = /** @class */ (function () {
     KeyBuilder.prototype.buildSplitKeyPrefix = function () {
         return this.prefix + ".split.";
     };
-    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;
     };

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|rbsegment)\\.");
+        _this.regexSplitsCacheKey = new RegExp("^" + prefix + "\\.(splits?|trafficType|flagSet)\\.");
         return _this;
     }
     /**
@@ -32,9 +32,6 @@ var KeyBuilderCS = /** @class */ (function (_super) {
     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";
     };

package/esm/storages/KeyBuilderSS.js

@@ -39,9 +39,6 @@ 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/inLocalStorage/SplitsCacheInLocal.js

@@ -44,13 +44,15 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
     };
     SplitsCacheInLocal.prototype._incrementCounts = function (split) {
         try {
-            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();
+            if (split) {
+                var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
                 // @ts-expect-error
-                localStorage.setItem(segmentsCountKey, toNumber(localStorage.getItem(segmentsCountKey)) + 1);
+                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);
+                }
             }
         }
         catch (e) {
@@ -172,9 +174,12 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
             return true;
         var storedCount = localStorage.getItem(this.keys.buildSplitsWithSegmentCountKey());
         var splitsWithSegmentsCount = storedCount === null ? 0 : toNumber(storedCount);
-        return isFiniteNumber(splitsWithSegmentsCount) ?
-            splitsWithSegmentsCount > 0 :
-            true;
+        if (isFiniteNumber(splitsWithSegmentsCount)) {
+            return splitsWithSegmentsCount > 0;
+        }
+        else {
+            return true;
+        }
     };
     /**
      * Check if the splits information is already stored in browser LocalStorage.

package/esm/storages/inLocalStorage/index.js

@@ -13,7 +13,6 @@ 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
  */
@@ -31,12 +30,10 @@ 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),
@@ -49,7 +46,6 @@ 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,7 +6,6 @@ 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
  *
@@ -15,11 +14,9 @@ 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 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,7 +6,6 @@ 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
  *
@@ -15,12 +14,10 @@ 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 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),
@@ -33,7 +30,6 @@ 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/inRedis/index.js

@@ -9,7 +9,6 @@ import { TelemetryCacheInRedis } from './TelemetryCacheInRedis';
 import { UniqueKeysCacheInRedis } from './UniqueKeysCacheInRedis';
 import { ImpressionCountsCacheInRedis } from './ImpressionCountsCacheInRedis';
 import { metadataBuilder } from '../utils';
-import { RBSegmentsCacheInRedis } from './RBSegmentsCacheInRedis';
 /**
  * InRedis storage factory for consumer server-side SplitFactory, that uses `Ioredis` Redis client for Node.js
  * @see {@link https://www.npmjs.com/package/ioredis}
@@ -38,7 +37,6 @@ export function InRedisStorage(options) {
         });
         return {
             splits: new SplitsCacheInRedis(log, keys, redisClient, settings.sync.__splitFiltersValidation),
-            rbSegments: new RBSegmentsCacheInRedis(log, keys, redisClient),
             segments: new SegmentsCacheInRedis(log, keys, redisClient),
             impressions: new ImpressionsCacheInRedis(log, keys.buildImpressionsKey(), redisClient, metadata),
             impressionCounts: impressionCountsCache,

package/esm/storages/pluggable/index.js

@@ -19,7 +19,6 @@ import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
 import { UniqueKeysCacheInMemoryCS } from '../inMemory/UniqueKeysCacheInMemoryCS';
 import { metadataBuilder } from '../utils';
 import { LOG_PREFIX } from '../pluggable/constants';
-import { RBSegmentsCachePluggable } from './RBSegmentsCachePluggable';
 var NO_VALID_WRAPPER = 'Expecting pluggable storage `wrapper` in options, but no valid wrapper instance was provided.';
 var NO_VALID_WRAPPER_INTERFACE = 'The provided wrapper instance doesn’t follow the expected interface. Check our docs.';
 /**
@@ -102,7 +101,6 @@ export function PluggableStorage(options) {
         });
         return {
             splits: new SplitsCachePluggable(log, keys, wrapper, settings.sync.__splitFiltersValidation),
-            rbSegments: new RBSegmentsCachePluggable(log, keys, wrapper),
             segments: new SegmentsCachePluggable(log, keys, wrapper),
             impressions: isPartialConsumer ? new ImpressionsCacheInMemory(impressionsQueueSize) : new ImpressionsCachePluggable(log, keys.buildImpressionsKey(), wrapper, metadata),
             impressionCounts: impressionCountsCache,

package/esm/storages/utils.js

@@ -23,6 +23,7 @@ export function impressionsToJSON(impressions, metadata) {
                 c: impression.changeNumber,
                 m: impression.time,
                 pt: impression.pt,
+                properties: impression.properties
             }
         };
         return JSON.stringify(impressionWithMetadata);

package/esm/sync/polling/fetchers/splitChangesFetcher.js

@@ -3,10 +3,10 @@
  * SplitChanges fetcher is a wrapper around `splitChanges` API service that parses the response and handle errors.
  */
 export function splitChangesFetcherFactory(fetchSplitChanges) {
-    return function splitChangesFetcher(since, noCache, till, rbSince, 
+    return function splitChangesFetcher(since, noCache, till, 
     // Optional decorator for `fetchSplitChanges` promise, such as timeout or time tracker
     decorator) {
-        var splitsPromise = fetchSplitChanges(since, noCache, till, rbSince);
+        var splitsPromise = fetchSplitChanges(since, noCache, till);
         if (decorator)
             splitsPromise = decorator(splitsPromise);
         return splitsPromise.then(function (resp) { return resp.json(); });

package/esm/sync/polling/pollingManagerCS.js

@@ -31,10 +31,10 @@ export function pollingManagerCSFactory(params) {
     readiness.splits.on(SDK_SPLITS_ARRIVED, function () {
         if (!splitsSyncTask.isRunning())
             return; // noop if not doing polling
-        var usingSegments = storage.splits.usesSegments() || storage.rbSegments.usesSegments();
-        if (usingSegments !== mySegmentsSyncTask.isRunning()) {
-            log.info(POLLING_SMART_PAUSING, [usingSegments ? 'ON' : 'OFF']);
-            if (usingSegments) {
+        var splitsHaveSegments = storage.splits.usesSegments();
+        if (splitsHaveSegments !== mySegmentsSyncTask.isRunning()) {
+            log.info(POLLING_SMART_PAUSING, [splitsHaveSegments ? 'ON' : 'OFF']);
+            if (splitsHaveSegments) {
                 startMySegmentsSyncTasks();
             }
             else {
@@ -46,10 +46,10 @@ export function pollingManagerCSFactory(params) {
         var mySegmentsSyncTask = mySegmentsSyncTaskFactory(splitApi.fetchMemberships, storage, readiness, settings, matchingKey);
         // smart ready
         function smartReady() {
-            if (!readiness.isReady() && !storage.splits.usesSegments() && !storage.rbSegments.usesSegments())
+            if (!readiness.isReady() && !storage.splits.usesSegments())
                 readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
         }
-        if (!storage.splits.usesSegments() && !storage.rbSegments.usesSegments())
+        if (!storage.splits.usesSegments())
             setTimeout(smartReady, 0);
         else
             readiness.splits.once(SDK_SPLITS_ARRIVED, smartReady);
@@ -63,7 +63,7 @@ export function pollingManagerCSFactory(params) {
         start: function () {
             log.info(POLLING_START);
             splitsSyncTask.start();
-            if (storage.splits.usesSegments() || storage.rbSegments.usesSegments())
+            if (storage.splits.usesSegments())
                 startMySegmentsSyncTasks();
         },
         // Stop periodic fetching (polling)

package/esm/sync/polling/updaters/mySegmentsUpdater.js

@@ -9,7 +9,7 @@ import { MEMBERSHIPS_LS_UPDATE } from '../../streaming/constants';
  *  - uses `segmentsEventEmitter` to emit events related to segments data updates
  */
 export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, storage, segmentsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, matchingKey) {
-    var splits = storage.splits, rbSegments = storage.rbSegments, segments = storage.segments, largeSegments = storage.largeSegments;
+    var splits = storage.splits, segments = storage.segments, largeSegments = storage.largeSegments;
     var readyOnAlreadyExistentState = true;
     var startingUp = true;
     /** timeout and telemetry decorator for `splitChangesFetcher` promise  */
@@ -31,7 +31,7 @@ export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, storage, segmen
             shouldNotifyUpdate = largeSegments.resetSegments(segmentsData.ls || {}) || shouldNotifyUpdate;
         }
         // Notify update if required
-        if ((splits.usesSegments() || rbSegments.usesSegments()) && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
+        if (splits.usesSegments() && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
             readyOnAlreadyExistentState = false;
             segmentsEventEmitter.emit(SDK_SEGMENTS_ARRIVED);
         }