@splitsoftware/splitio-commons 2.3.0 → 2.3.1-rc.0

package/esm/evaluator/combiners/ifelseif.js

@@ -1,4 +1,4 @@
-import { findIndex } from '../../utils/lang';
+import { findIndex, isBoolean } from '../../utils/lang';
 import { thenable } from '../../utils/promise/thenable';
 import { UNSUPPORTED_MATCHER_TYPE } from '../../utils/labels';
 import { CONTROL } from '../../utils/constants';
@@ -11,12 +11,12 @@ export function ifElseIfCombinerContext(log, predicates) {
             label: UNSUPPORTED_MATCHER_TYPE
         };
     }
-    function computeTreatment(predicateResults) {
-        var len = predicateResults.length;
-        for (var i = 0; i < len; i++) {
+    function computeEvaluation(predicateResults) {
+        for (var i = 0, len = predicateResults.length; i < len; i++) {
             var evaluation = predicateResults[i];
             if (evaluation !== undefined) {
-                log.debug(ENGINE_COMBINER_IFELSEIF, [evaluation.treatment]);
+                if (!isBoolean(evaluation))
+                    log.debug(ENGINE_COMBINER_IFELSEIF, [evaluation.treatment]);
                 return evaluation;
             }
         }
@@ -30,9 +30,9 @@ export function ifElseIfCombinerContext(log, predicates) {
         var predicateResults = predicates.map(function (evaluator) { return evaluator(key, seed, trafficAllocation, trafficAllocationSeed, attributes, splitEvaluator); });
         // if we find a thenable
         if (findIndex(predicateResults, thenable) !== -1) {
-            return Promise.all(predicateResults).then(function (results) { return computeTreatment(results); });
+            return Promise.all(predicateResults).then(function (results) { return computeEvaluation(results); });
         }
-        return computeTreatment(predicateResults);
+        return computeEvaluation(predicateResults);
     }
     // if there is none predicates, then there was an error in parsing phase
     if (!Array.isArray(predicates) || predicates.length === 0) {

package/esm/evaluator/condition/index.js

@@ -4,11 +4,12 @@ import { NOT_IN_SPLIT } from '../../utils/labels';
 // Build Evaluation object if and only if matchingResult is true
 function match(log, matchingResult, bucketingKey, seed, treatments, label) {
     if (matchingResult) {
-        var treatment = getTreatment(log, bucketingKey, seed, treatments);
-        return {
-            treatment: treatment,
-            label: label
-        };
+        return treatments ? // Feature flag
+            {
+                treatment: getTreatment(log, bucketingKey, seed, treatments),
+                label: label
+            } : // Rule-based segment
+            true;
     }
     // else we should notify the engine to continue evaluating
     return undefined;

package/esm/evaluator/index.js

@@ -1,4 +1,4 @@
-import { Engine } from './Engine';
+import { engineParser } from './Engine';
 import { thenable } from '../utils/promise/thenable';
 import { EXCEPTION, SPLIT_NOT_FOUND } from '../utils/labels';
 import { CONTROL } from '../utils/constants';
@@ -26,12 +26,12 @@ export function evaluateFeature(log, key, splitName, attributes, storage) {
         return treatmentException;
     }
     if (thenable(parsedSplit)) {
-        return parsedSplit.then(function (split) { return getEvaluation(log, split, key, attributes, storage); }).catch(
+        return parsedSplit.then(function (split) { return getEvaluation(log, key, split, attributes, storage); }).catch(
         // Exception on async `getSplit` storage. For example, when the storage is redis or
         // pluggable and there is a connection issue and we can't retrieve the split to be evaluated
         function () { return treatmentException; });
     }
-    return getEvaluation(log, parsedSplit, key, attributes, storage);
+    return getEvaluation(log, key, parsedSplit, attributes, storage);
 }
 export function evaluateFeatures(log, key, splitNames, attributes, storage) {
     var parsedSplits;
@@ -43,13 +43,13 @@ export function evaluateFeatures(log, key, splitNames, attributes, storage) {
         return treatmentsException(splitNames);
     }
     return thenable(parsedSplits) ?
-        parsedSplits.then(function (splits) { return getEvaluations(log, splitNames, splits, key, attributes, storage); })
+        parsedSplits.then(function (splits) { return getEvaluations(log, key, splitNames, splits, attributes, storage); })
             .catch(function () {
             // Exception on async `getSplits` storage. For example, when the storage is redis or
             // pluggable and there is a connection issue and we can't retrieve the split to be evaluated
             return treatmentsException(splitNames);
         }) :
-        getEvaluations(log, splitNames, parsedSplits, key, attributes, storage);
+        getEvaluations(log, key, splitNames, parsedSplits, attributes, storage);
 }
 export function evaluateFeaturesByFlagSets(log, key, flagSets, attributes, storage, method) {
     var storedFlagNames;
@@ -84,37 +84,37 @@ export function evaluateFeaturesByFlagSets(log, key, flagSets, attributes, stora
         }) :
         evaluate(storedFlagNames);
 }
-function getEvaluation(log, splitJSON, key, attributes, storage) {
+function getEvaluation(log, key, splitJSON, attributes, storage) {
     var evaluation = {
         treatment: CONTROL,
         label: SPLIT_NOT_FOUND,
         config: null
     };
     if (splitJSON) {
-        var split_1 = Engine.parse(log, splitJSON, storage);
-        evaluation = split_1.getTreatment(key, attributes, evaluateFeature);
+        var split = engineParser(log, splitJSON, storage);
+        evaluation = split.getTreatment(key, attributes, evaluateFeature);
         // If the storage is async and the evaluated flag uses segments or dependencies, evaluation is thenable
         if (thenable(evaluation)) {
             return evaluation.then(function (result) {
-                result.changeNumber = split_1.getChangeNumber();
+                result.changeNumber = splitJSON.changeNumber;
                 result.config = splitJSON.configurations && splitJSON.configurations[result.treatment] || null;
                 result.impressionsDisabled = splitJSON.impressionsDisabled;
                 return result;
             });
         }
         else {
-            evaluation.changeNumber = split_1.getChangeNumber(); // Always sync and optional
+            evaluation.changeNumber = splitJSON.changeNumber;
             evaluation.config = splitJSON.configurations && splitJSON.configurations[evaluation.treatment] || null;
             evaluation.impressionsDisabled = splitJSON.impressionsDisabled;
         }
     }
     return evaluation;
 }
-function getEvaluations(log, splitNames, splits, key, attributes, storage) {
+function getEvaluations(log, key, splitNames, splits, attributes, storage) {
     var result = {};
     var thenables = [];
     splitNames.forEach(function (splitName) {
-        var evaluation = getEvaluation(log, splits[splitName], key, attributes, storage);
+        var evaluation = getEvaluation(log, key, splits[splitName], attributes, storage);
         if (thenable(evaluation)) {
             thenables.push(evaluation.then(function (res) {
                 result[splitName] = res;

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/prerequisites.js

@@ -0,0 +1,18 @@
+import { thenable } from '../../utils/promise/thenable';
+export function prerequisitesMatcherContext(prerequisites, storage, log) {
+    if (prerequisites === void 0) { prerequisites = []; }
+    return function prerequisitesMatcher(_a, splitEvaluator) {
+        var key = _a.key, attributes = _a.attributes;
+        function evaluatePrerequisite(prerequisite) {
+            var evaluation = splitEvaluator(log, key, prerequisite.n, attributes, storage);
+            return thenable(evaluation) ?
+                evaluation.then(function (evaluation) { return prerequisite.ts.indexOf(evaluation.treatment) !== -1; }) :
+                prerequisite.ts.indexOf(evaluation.treatment) !== -1;
+        }
+        return prerequisites.reduce(function (prerequisitesMet, prerequisite) {
+            return thenable(prerequisitesMet) ?
+                prerequisitesMet.then(function (prerequisitesMet) { return prerequisitesMet ? evaluatePrerequisite(prerequisite) : false; }) :
+                prerequisitesMet ? evaluatePrerequisite(prerequisite) : false;
+        }, true);
+    };
+}

package/esm/evaluator/matchers/rbsegment.js

@@ -0,0 +1,52 @@
+import { thenable } from '../../utils/promise/thenable';
+import { getMatching, keyParser } from '../../utils/key';
+import { parser } from '../parser';
+import { STANDARD_SEGMENT, RULE_BASED_SEGMENT, LARGE_SEGMENT } from '../../utils/constants';
+export function ruleBasedSegmentMatcherContext(segmentName, storage, log) {
+    return function ruleBasedSegmentMatcher(_a, splitEvaluator) {
+        var key = _a.key, attributes = _a.attributes;
+        var matchingKey = getMatching(key);
+        function matchConditions(rbsegment) {
+            var conditions = rbsegment.conditions || [];
+            if (!conditions.length)
+                return false;
+            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 isInExcludedSegment(_a) {
+            var type = _a.type, name = _a.name;
+            return type === STANDARD_SEGMENT ?
+                storage.segments.isInSegment(name, matchingKey) :
+                type === RULE_BASED_SEGMENT ?
+                    ruleBasedSegmentMatcherContext(name, storage, log)({ key: key, attributes: attributes }, splitEvaluator) :
+                    type === LARGE_SEGMENT && storage.largeSegments ?
+                        storage.largeSegments.isInSegment(name, matchingKey) :
+                        false;
+        }
+        function isExcluded(rbSegment) {
+            var excluded = rbSegment.excluded || {};
+            if (excluded.keys && excluded.keys.indexOf(matchingKey) !== -1)
+                return true;
+            return (excluded.segments || []).reduce(function (result, excludedSegment) {
+                return thenable(result) ?
+                    result.then(function (result) { return result || isInExcludedSegment(excludedSegment); }) :
+                    result || isInExcludedSegment(excludedSegment);
+            }, false);
+        }
+        function isInRBSegment(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(isInRBSegment) :
+            isInRBSegment(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

@@ -21,12 +21,14 @@ export var RETRIEVE_MANAGER = 29;
 export var SYNC_OFFLINE_DATA = 30;
 export var SYNC_SPLITS_FETCH = 31;
 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;
 export var SYNC_TASK_STOP = 38;
 export var SETTINGS_SPLITS_FILTER = 39;
 export var ENGINE_MATCHER_RESULT = 40;
+export var ENGINE_DEFAULT = 41;
 export var CLIENT_READY_FROM_CACHE = 100;
 export var CLIENT_READY = 101;
 export var IMPRESSION = 102;

package/esm/logger/messages/debug.js

@@ -11,6 +11,7 @@ export var codesDebug = codesInfo.concat([
     [c.ENGINE_VALUE, c.LOG_PREFIX_ENGINE_VALUE + 'Extracted attribute `%s`. %s will be used for matching.'],
     [c.ENGINE_SANITIZE, c.LOG_PREFIX_ENGINE + ':sanitize: Attempted to sanitize %s which should be of type %s. Sanitized and processed value => %s'],
     [c.ENGINE_MATCHER_RESULT, c.LOG_PREFIX_ENGINE_MATCHER + '[%s] Result: %s. Rule value: %s. Evaluation value: %s'],
+    [c.ENGINE_DEFAULT, c.LOG_PREFIX_ENGINE + 'Evaluates to default treatment. %s'],
     // SDK
     [c.CLEANUP_REGISTERING, c.LOG_PREFIX_CLEANUP + 'Registering cleanup handler %s'],
     [c.CLEANUP_DEREGISTERING, c.LOG_PREFIX_CLEANUP + 'Deregistering cleanup handler %s'],
@@ -19,8 +20,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_UPDATE, c.LOG_PREFIX_SYNC_SPLITS + 'New feature flags %s. Removed feature flags %s. 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/sdkManager/index.js

@@ -26,7 +26,8 @@ function objectToView(splitObject) {
         configs: splitObject.configurations || {},
         sets: splitObject.sets || [],
         defaultTreatment: splitObject.defaultTreatment,
-        impressionsDisabled: splitObject.impressionsDisabled === true
+        impressionsDisabled: splitObject.impressionsDisabled === true,
+        prerequisites: (splitObject.prerequisites || []).map(function (p) { return ({ flagName: p.n, treatments: p.ts }); }),
     };
 }
 function objectsToViews(splitObjects) {

package/esm/services/splitApi.js

@@ -17,7 +17,6 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
     var urls = settings.urls;
     var filterQueryString = settings.sync.__splitFiltersValidation && settings.sync.__splitFiltersValidation.queryString;
     var SplitSDKImpressionsMode = settings.sync.impressionsMode;
-    var flagSpecVersion = settings.sync.flagSpecVersion;
     var splitHttpClient = splitHttpClientFactory(settings, platform);
     return {
         // @TODO throw errors if health check requests fail, to log them in the Synchronizer
@@ -30,7 +29,7 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
             return splitHttpClient(url).then(function () { return true; }).catch(function () { return false; });
         },
         fetchAuth: function (userMatchingKeys) {
-            var url = urls.auth + "/v2/auth?s=" + flagSpecVersion;
+            var url = urls.auth + "/v2/auth?s=" + settings.sync.flagSpecVersion;
             if (userMatchingKeys) { // `userMatchingKeys` is undefined in server-side
                 var queryParams = userMatchingKeys.map(userKeyToQueryParam).join('&');
                 if (queryParams)
@@ -38,8 +37,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=" + settings.sync.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/services/splitHttpClient.js

@@ -42,7 +42,7 @@ export function splitHttpClientFactory(settings, _a) {
             // https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch#Checking_that_the_fetch_was_successful
             .then(function (response) {
             if (!response.ok) {
-                // `text()` promise might not settle in some fetch implementations and cases (e.g. no content)
+                // timeout since `text()` promise might not settle in some fetch implementations and cases (e.g. no content)
                 return timeout(PENDING_FETCH_ERROR_TIMEOUT, response.text()).then(function (message) { return Promise.reject({ response: response, message: message }); }, function () { return Promise.reject({ response: response }); });
             }
             latencyTracker();

package/esm/storages/AbstractSplitsCacheSync.js

@@ -50,8 +50,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++) {
@@ -60,5 +60,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

@@ -24,6 +24,15 @@ 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

@@ -32,6 +32,9 @@ 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,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/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

@@ -38,15 +38,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) {
@@ -155,12 +153,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;
     };
     SplitsCacheInLocal.prototype.getNamesByFlagSets = function (flagSets) {
         var _this = this;

package/esm/storages/inLocalStorage/index.js

@@ -5,6 +5,7 @@ import { validatePrefix } from '../KeyBuilder';
 import { KeyBuilderCS, myLargeSegmentsKeyBuilder } from '../KeyBuilderCS';
 import { isLocalStorageAvailable } from '../../utils/env/isLocalStorageAvailable';
 import { SplitsCacheInLocal } from './SplitsCacheInLocal';
+import { RBSegmentsCacheInLocal } from './RBSegmentsCacheInLocal';
 import { MySegmentsCacheInLocal } from './MySegmentsCacheInLocal';
 import { InMemoryStorageCSFactory } from '../inMemory/InMemoryStorageCS';
 import { LOG_PREFIX } from './constants';
@@ -29,10 +30,12 @@ export function InLocalStorage(options) {
         var matchingKey = getMatching(settings.core.key);
         var keys = new KeyBuilderCS(prefix, matchingKey);
         var splits = new SplitsCacheInLocal(settings, keys);
+        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),
@@ -41,13 +44,14 @@ export function InLocalStorage(options) {
             telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
             uniqueKeys: new UniqueKeysCacheInMemoryCS(),
             validateCache: function () {
-                return validateCache(options, settings, keys, splits, segments, largeSegments);
+                return validateCache(options, settings, keys, splits, rbSegments, segments, largeSegments);
             },
             destroy: function () { },
             // When using shared instantiation with MEMORY we reuse everything but segments (they are customer per key).
             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/inLocalStorage/validateCache.js

@@ -54,11 +54,12 @@ function validateExpiration(options, settings, keys, currentTimestamp, isThereCa
  *
  * @returns `true` if cache is ready to be used, `false` otherwise (cache was cleared or there is no cache)
  */
-export function validateCache(options, settings, keys, splits, segments, largeSegments) {
+export function validateCache(options, settings, keys, splits, rbSegments, segments, largeSegments) {
     var currentTimestamp = Date.now();
     var isThereCache = splits.getChangeNumber() > -1;
     if (validateExpiration(options, settings, keys, currentTimestamp, isThereCache)) {
         splits.clear();
+        rbSegments.clear();
         segments.clear();
         largeSegments.clear();
         // Update last clear timestamp