@splitsoftware/splitio-commons 1.9.2-rc.0 → 1.9.2-rc.2

package/esm/sdkClient/clientInputValidation.js

@@ -3,7 +3,6 @@ import { validateAttributes, validateEvent, validateEventValue, validateEventPro
 import { startsWith } from '../utils/lang';
 import { CONTROL, CONTROL_WITH_CONFIG } from '../utils/constants';
 import { isStorageSync } from '../trackers/impressionObserver/utils';
-import { flagSetsAreValid } from '../utils/settingsValidation/splitFilters';
 /**
  * Decorator that validates the input before actually executing the client methods.
  * We should "guard" the client here, while not polluting the "real" implementation of those methods.
@@ -14,26 +13,18 @@ export function clientInputValidationDecorator(settings, client, readinessManage
     /**
      * Avoid repeating this validations code
      */
-    function validateEvaluationParams(maybeKey, maybeFeatureFlagNameOrNames, maybeAttributes, methodName, maybeFlagSetNameOrNames) {
+    function validateEvaluationParams(maybeKey, maybeFeatureFlagNameOrNames, maybeAttributes, methodName) {
         var multi = startsWith(methodName, 'getTreatments');
         var key = validateKey(log, maybeKey, methodName);
-        var splitOrSplits = false;
-        var flagSetOrFlagSets = [];
-        if (maybeFeatureFlagNameOrNames) {
-            splitOrSplits = multi ? validateSplits(log, maybeFeatureFlagNameOrNames, methodName) : validateSplit(log, maybeFeatureFlagNameOrNames, methodName);
-        }
+        var splitOrSplits = multi ? validateSplits(log, maybeFeatureFlagNameOrNames, methodName) : validateSplit(log, maybeFeatureFlagNameOrNames, methodName);
         var attributes = validateAttributes(log, maybeAttributes, methodName);
         var isNotDestroyed = validateIfNotDestroyed(log, readinessManager, methodName);
-        if (maybeFlagSetNameOrNames) {
-            flagSetOrFlagSets = flagSetsAreValid(log, methodName, maybeFlagSetNameOrNames, settings.sync.__splitFiltersValidation.groupedFilters.bySet);
-        }
         validateIfOperational(log, readinessManager, methodName);
-        var valid = isNotDestroyed && key && (splitOrSplits || flagSetOrFlagSets.length > 0) && attributes !== false;
+        var valid = isNotDestroyed && key && splitOrSplits && attributes !== false;
         return {
             valid: valid,
             key: key,
             splitOrSplits: splitOrSplits,
-            flagSetOrFlagSets: flagSetOrFlagSets,
             attributes: attributes
         };
     }
@@ -82,42 +73,6 @@ export function clientInputValidationDecorator(settings, client, readinessManage
             return wrapResult(res_2);
         }
     }
-    function getTreatmentsByFlagSets(maybeKey, maybeFlagSets, maybeAttributes) {
-        var params = validateEvaluationParams(maybeKey, undefined, maybeAttributes, 'getTreatmentsByFlagSets', maybeFlagSets);
-        if (params.valid) {
-            return client.getTreatmentsByFlagSets(params.key, params.flagSetOrFlagSets, params.attributes);
-        }
-        else {
-            return wrapResult({});
-        }
-    }
-    function getTreatmentsWithConfigByFlagSets(maybeKey, maybeFlagSets, maybeAttributes) {
-        var params = validateEvaluationParams(maybeKey, undefined, maybeAttributes, 'getTreatmentsWithConfigByFlagSets', maybeFlagSets);
-        if (params.valid) {
-            return client.getTreatmentsWithConfigByFlagSets(params.key, params.flagSetOrFlagSets, params.attributes);
-        }
-        else {
-            return wrapResult({});
-        }
-    }
-    function getTreatmentsByFlagSet(maybeKey, maybeFlagSet, maybeAttributes) {
-        var params = validateEvaluationParams(maybeKey, undefined, maybeAttributes, 'getTreatmentsByFlagSet', [maybeFlagSet]);
-        if (params.valid) {
-            return client.getTreatmentsByFlagSet(params.key, params.flagSetOrFlagSets[0], params.attributes);
-        }
-        else {
-            return wrapResult({});
-        }
-    }
-    function getTreatmentsWithConfigByFlagSet(maybeKey, maybeFlagSet, maybeAttributes) {
-        var params = validateEvaluationParams(maybeKey, undefined, maybeAttributes, 'getTreatmentsWithConfigByFlagSet', [maybeFlagSet]);
-        if (params.valid) {
-            return client.getTreatmentsWithConfigByFlagSet(params.key, params.flagSetOrFlagSets[0], params.attributes);
-        }
-        else {
-            return wrapResult({});
-        }
-    }
     function track(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties) {
         var key = validateKey(log, maybeKey, 'track');
         var tt = validateTrafficType(log, maybeTT, 'track');
@@ -137,10 +92,6 @@ export function clientInputValidationDecorator(settings, client, readinessManage
         getTreatmentWithConfig: getTreatmentWithConfig,
         getTreatments: getTreatments,
         getTreatmentsWithConfig: getTreatmentsWithConfig,
-        getTreatmentsByFlagSets: getTreatmentsByFlagSets,
-        getTreatmentsWithConfigByFlagSets: getTreatmentsWithConfigByFlagSets,
-        getTreatmentsByFlagSet: getTreatmentsByFlagSet,
-        getTreatmentsWithConfigByFlagSet: getTreatmentsWithConfigByFlagSet,
         track: track
     };
 }

package/esm/sdkManager/index.js

@@ -24,8 +24,7 @@ function objectToView(splitObject) {
         killed: splitObject.killed,
         changeNumber: splitObject.changeNumber || 0,
         treatments: collectTreatments(splitObject),
-        configs: splitObject.configurations || {},
-        sets: splitObject.sets || []
+        configs: splitObject.configurations || {}
     };
 }
 function objectsToViews(splitObjects) {

package/esm/services/splitApi.js

@@ -1,7 +1,6 @@
 import { splitHttpClientFactory } from './splitHttpClient';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MY_SEGMENT } from '../utils/constants';
-import { ERROR_TOO_MANY_SETS } from '../logger/constants';
 var noCacheHeaderOptions = { headers: { 'Cache-Control': 'no-cache' } };
 function userKeyToQueryParam(userKey) {
     return 'users=' + encodeURIComponent(userKey); // no need to check availability of `encodeURIComponent`, since it is a global highly supported.
@@ -38,12 +37,7 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
         },
         fetchSplitChanges: function (since, noCache, till) {
             var url = urls.sdk + "/splitChanges?since=" + since + (till ? '&till=' + till : '') + (filterQueryString || '');
-            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SPLITS))
-                .catch(function (err) {
-                if (err.statusCode === 414)
-                    settings.log.error(ERROR_TOO_MANY_SETS);
-                throw err;
-            });
+            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SPLITS));
         },
         fetchSegmentChanges: function (since, segmentName, noCache, till) {
             var url = urls.sdk + "/segmentChanges/" + segmentName + "?since=" + since + (till ? '&till=' + till : '');

package/esm/storages/KeyBuilder.js

@@ -12,9 +12,6 @@ var KeyBuilder = /** @class */ (function () {
     KeyBuilder.prototype.buildTrafficTypeKey = function (trafficType) {
         return this.prefix + ".trafficType." + trafficType;
     };
-    KeyBuilder.prototype.buildFlagSetKey = function (flagSet) {
-        return this.prefix + ".flagset." + flagSet;
-    };
     KeyBuilder.prototype.buildSplitKey = function (splitName) {
         return this.prefix + ".split." + splitName;
     };

package/esm/storages/KeyBuilderSS.js

@@ -5,10 +5,6 @@ export var METHOD_NAMES = {
     ts: 'treatments',
     tc: 'treatmentWithConfig',
     tcs: 'treatmentsWithConfig',
-    tf: 'treatmentsByFlagSet',
-    tfs: 'treatmentsByFlagSets',
-    tcf: 'treatmentsWithConfigByFlagSet',
-    tcfs: 'treatmentsWithConfigByFlagSets',
     tr: 'track'
 };
 var KeyBuilderSS = /** @class */ (function (_super) {

package/esm/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -2,7 +2,6 @@ import { __extends } from "tslib";
 import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';
 import { isFiniteNumber, toNumber, isNaNNumber } from '../../utils/lang';
 import { LOG_PREFIX } from './constants';
-import { _Set, returnSetsUnion, setToArray } from '../../utils/lang/sets';
 /**
  * ISplitsCacheSync implementation that stores split definitions in browser LocalStorage.
  */
@@ -14,12 +13,12 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
      * @param {ISplitFiltersValidation} splitFiltersValidation
      */
     function SplitsCacheInLocal(log, keys, expirationTimestamp, splitFiltersValidation) {
-        if (splitFiltersValidation === void 0) { splitFiltersValidation = { queryString: null, groupedFilters: { bySet: [], byName: [], byPrefix: [] }, validFilters: [] }; }
+        if (splitFiltersValidation === void 0) { splitFiltersValidation = { queryString: null, groupedFilters: { byName: [], byPrefix: [] }, validFilters: [] }; }
         var _this = _super.call(this) || this;
         _this.log = log;
+        _this.cacheReadyButNeedsToFlush = false;
         _this.keys = keys;
         _this.splitFiltersValidation = splitFiltersValidation;
-        _this.flagSetsFilter = _this.splitFiltersValidation.groupedFilters.bySet;
         _this._checkExpiration(expirationTimestamp);
         _this._checkFilterQuery();
         return _this;
@@ -92,9 +91,6 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
             localStorage.setItem(splitKey, JSON.stringify(split));
             this._incrementCounts(split);
             this._decrementCounts(previousSplit);
-            if (previousSplit)
-                this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
-            this.addToFlagSets(split);
             return true;
         }
         catch (e) {
@@ -107,8 +103,6 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
             var split = this.getSplit(name);
             localStorage.removeItem(this.keys.buildSplitKey(name));
             this._decrementCounts(split);
-            if (split)
-                this.removeFromFlagSets(split.name, split.sets);
             return true;
         }
         catch (e) {
@@ -121,6 +115,11 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         return item && JSON.parse(item);
     };
     SplitsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
+        // when cache is ready but using a new split query, we must clear all split data
+        if (this.cacheReadyButNeedsToFlush) {
+            this.clear();
+            this.cacheReadyButNeedsToFlush = false;
+        }
         // when using a new split query, we must update it at the store
         if (this.updateNewFilter) {
             this.log.info(LOG_PREFIX + 'Split filter query was modified. Updating cache.');
@@ -193,7 +192,7 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
      * @override
      */
     SplitsCacheInLocal.prototype.checkCache = function () {
-        return this.getChangeNumber() > -1;
+        return this.getChangeNumber() > -1 || this.cacheReadyButNeedsToFlush;
     };
     /**
      * Clean Splits cache if its `lastUpdated` timestamp is older than the given `expirationTimestamp`,
@@ -209,16 +208,31 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         }
     };
     SplitsCacheInLocal.prototype._checkFilterQuery = function () {
-        var queryString = this.splitFiltersValidation.queryString;
+        var _this = this;
+        var _a = this.splitFiltersValidation, queryString = _a.queryString, groupedFilters = _a.groupedFilters;
         var queryKey = this.keys.buildSplitsFilterQueryKey();
         var currentQueryString = localStorage.getItem(queryKey);
         if (currentQueryString !== queryString) {
             try {
                 // mark cache to update the new query filter on first successful splits fetch
                 this.updateNewFilter = true;
-                // if there is cache, clear it
-                if (this.checkCache())
-                    this.clear();
+                // if cache is ready:
+                if (this.checkCache()) {
+                    // * set change number to -1, to fetch splits with -1 `since` value.
+                    localStorage.setItem(this.keys.buildSplitsTillKey(), '-1');
+                    // * remove from cache splits that doesn't match with the new filters
+                    this.getSplitNames().forEach(function (splitName) {
+                        if (queryString && (
+                        // @TODO consider redefining `groupedFilters` to expose a method like `groupedFilters::filter(splitName): boolean`
+                        groupedFilters.byName.indexOf(splitName) > -1 ||
+                            groupedFilters.byPrefix.some(function (prefix) { return splitName.startsWith(prefix + '__'); }))) {
+                            // * set `cacheReadyButNeedsToFlush` so that `checkCache` returns true (the storage is ready to be used) and the data is cleared before updating on first successful splits fetch
+                            _this.cacheReadyButNeedsToFlush = true;
+                            return;
+                        }
+                        _this.removeSplit(splitName);
+                    });
+                }
             }
             catch (e) {
                 this.log.error(LOG_PREFIX + e);
@@ -226,56 +240,6 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         }
         // if the filter didn't change, nothing is done
     };
-    SplitsCacheInLocal.prototype.getNamesByFlagSets = function (flagSets) {
-        var _this = this;
-        var toReturn = new _Set([]);
-        flagSets.forEach(function (flagSet) {
-            var flagSetKey = _this.keys.buildFlagSetKey(flagSet);
-            var flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
-            if (flagSetFromLocalStorage) {
-                var flagSetCache = new _Set(JSON.parse(flagSetFromLocalStorage));
-                toReturn = returnSetsUnion(toReturn, flagSetCache);
-            }
-        });
-        return toReturn;
-    };
-    SplitsCacheInLocal.prototype.addToFlagSets = function (featureFlag) {
-        var _this = this;
-        if (!featureFlag.sets)
-            return;
-        featureFlag.sets.forEach(function (featureFlagSet) {
-            if (_this.flagSetsFilter.length > 0 && !_this.flagSetsFilter.some(function (filterFlagSet) { return filterFlagSet === featureFlagSet; }))
-                return;
-            var flagSetKey = _this.keys.buildFlagSetKey(featureFlagSet);
-            var flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
-            if (!flagSetFromLocalStorage)
-                flagSetFromLocalStorage = '[]';
-            var flagSetCache = new _Set(JSON.parse(flagSetFromLocalStorage));
-            flagSetCache.add(featureFlag.name);
-            localStorage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
-        });
-    };
-    SplitsCacheInLocal.prototype.removeFromFlagSets = function (featureFlagName, flagSets) {
-        var _this = this;
-        if (!flagSets)
-            return;
-        flagSets.forEach(function (flagSet) {
-            _this.removeNames(flagSet, featureFlagName);
-        });
-    };
-    SplitsCacheInLocal.prototype.removeNames = function (flagSetName, featureFlagName) {
-        var flagSetKey = this.keys.buildFlagSetKey(flagSetName);
-        var flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
-        if (!flagSetFromLocalStorage)
-            return;
-        var flagSetCache = new _Set(JSON.parse(flagSetFromLocalStorage));
-        flagSetCache.delete(featureFlagName);
-        if (flagSetCache.size === 0) {
-            localStorage.removeItem(flagSetKey);
-            return;
-        }
-        localStorage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
-    };
     return SplitsCacheInLocal;
 }(AbstractSplitsCacheSync));
 export { SplitsCacheInLocal };

package/esm/storages/inLocalStorage/index.js

@@ -43,7 +43,7 @@ export function InLocalStorage(options) {
             uniqueKeys: impressionsMode === NONE ? new UniqueKeysCacheInMemoryCS() : undefined,
             destroy: function () {
                 var _a;
-                this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
+                this.splits = new SplitsCacheInMemory();
                 this.segments = new MySegmentsCacheInMemory();
                 this.impressions.clear();
                 this.impressionCounts && this.impressionCounts.clear();
@@ -61,7 +61,7 @@ export function InLocalStorage(options) {
                     events: this.events,
                     telemetry: this.telemetry,
                     destroy: function () {
-                        this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
+                        this.splits = new SplitsCacheInMemory();
                         this.segments = new MySegmentsCacheInMemory();
                     }
                 };

package/esm/storages/inMemory/InMemoryStorage.js

@@ -12,8 +12,8 @@ import { UniqueKeysCacheInMemory } from './UniqueKeysCacheInMemory';
  * @param params parameters required by EventsCacheSync
  */
 export function InMemoryStorageFactory(params) {
-    var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, _c = _a.sync, impressionsMode = _c.impressionsMode, __splitFiltersValidation = _c.__splitFiltersValidation;
-    var splits = new SplitsCacheInMemory(__splitFiltersValidation);
+    var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, impressionsMode = _a.sync.impressionsMode;
+    var splits = new SplitsCacheInMemory();
     var segments = new SegmentsCacheInMemory();
     var storage = {
         splits: splits,

package/esm/storages/inMemory/InMemoryStorageCS.js

@@ -12,8 +12,8 @@ import { UniqueKeysCacheInMemoryCS } from './UniqueKeysCacheInMemoryCS';
  * @param params parameters required by EventsCacheSync
  */
 export function InMemoryStorageCSFactory(params) {
-    var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, _c = _a.sync, impressionsMode = _c.impressionsMode, __splitFiltersValidation = _c.__splitFiltersValidation;
-    var splits = new SplitsCacheInMemory(__splitFiltersValidation);
+    var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, impressionsMode = _a.sync.impressionsMode;
+    var splits = new SplitsCacheInMemory();
     var segments = new MySegmentsCacheInMemory();
     var storage = {
         splits: splits,
@@ -43,7 +43,7 @@ export function InMemoryStorageCSFactory(params) {
                 telemetry: this.telemetry,
                 // Set a new splits cache to clean it for the client without affecting other clients
                 destroy: function () {
-                    this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
+                    this.splits = new SplitsCacheInMemory();
                     this.segments.clear();
                 }
             };

package/esm/storages/inMemory/SplitsCacheInMemory.js

@@ -1,22 +1,18 @@
 import { __extends } from "tslib";
 import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';
 import { isFiniteNumber } from '../../utils/lang';
-import { _Set, returnSetsUnion } from '../../utils/lang/sets';
 /**
  * Default ISplitsCacheSync implementation that stores split definitions in memory.
  * Supported by all JS runtimes.
  */
 var SplitsCacheInMemory = /** @class */ (function (_super) {
     __extends(SplitsCacheInMemory, _super);
-    function SplitsCacheInMemory(splitFiltersValidation) {
-        if (splitFiltersValidation === void 0) { splitFiltersValidation = { queryString: null, groupedFilters: { bySet: [], byName: [], byPrefix: [] }, validFilters: [] }; }
-        var _this = _super.call(this) || this;
+    function SplitsCacheInMemory() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
         _this.splitsCache = {};
         _this.ttCache = {};
         _this.changeNumber = -1;
         _this.splitsWithSegmentsCount = 0;
-        _this.flagSetsCache = {};
-        _this.flagSetsFilter = splitFiltersValidation.groupedFilters.bySet;
         return _this;
     }
     SplitsCacheInMemory.prototype.clear = function () {
@@ -32,7 +28,6 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
             this.ttCache[previousTtName]--;
             if (!this.ttCache[previousTtName])
                 delete this.ttCache[previousTtName];
-            this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
             if (usesSegments(previousSplit)) { // Substract from segments count for the previous version of this Split.
                 this.splitsWithSegmentsCount--;
             }
@@ -43,7 +38,6 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
             // Update TT cache
             var ttName = split.trafficTypeName;
             this.ttCache[ttName] = (this.ttCache[ttName] || 0) + 1;
-            this.addToFlagSets(split);
             // Add to segments count for the new version of the Split
             if (usesSegments(split))
                 this.splitsWithSegmentsCount++;
@@ -62,7 +56,6 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
             this.ttCache[ttName]--; // Update tt cache
             if (!this.ttCache[ttName])
                 delete this.ttCache[ttName];
-            this.removeFromFlagSets(split.name, split.sets);
             // Update the segments count.
             if (usesSegments(split))
                 this.splitsWithSegmentsCount--;
@@ -91,44 +84,6 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
     SplitsCacheInMemory.prototype.usesSegments = function () {
         return this.getChangeNumber() === -1 || this.splitsWithSegmentsCount > 0;
     };
-    SplitsCacheInMemory.prototype.getNamesByFlagSets = function (flagSets) {
-        var _this = this;
-        var toReturn = new _Set([]);
-        flagSets.forEach(function (flagSet) {
-            var featureFlagNames = _this.flagSetsCache[flagSet];
-            if (featureFlagNames) {
-                toReturn = returnSetsUnion(toReturn, featureFlagNames);
-            }
-        });
-        return toReturn;
-    };
-    SplitsCacheInMemory.prototype.addToFlagSets = function (featureFlag) {
-        var _this = this;
-        if (!featureFlag.sets)
-            return;
-        featureFlag.sets.forEach(function (featureFlagSet) {
-            if (_this.flagSetsFilter.length > 0 && !_this.flagSetsFilter.some(function (filterFlagSet) { return filterFlagSet === featureFlagSet; }))
-                return;
-            if (!_this.flagSetsCache[featureFlagSet])
-                _this.flagSetsCache[featureFlagSet] = new _Set([]);
-            _this.flagSetsCache[featureFlagSet].add(featureFlag.name);
-        });
-    };
-    SplitsCacheInMemory.prototype.removeFromFlagSets = function (featureFlagName, flagSets) {
-        var _this = this;
-        if (!flagSets)
-            return;
-        flagSets.forEach(function (flagSet) {
-            _this.removeNames(flagSet, featureFlagName);
-        });
-    };
-    SplitsCacheInMemory.prototype.removeNames = function (flagSetName, featureFlagName) {
-        if (!this.flagSetsCache[flagSetName])
-            return;
-        this.flagSetsCache[flagSetName].delete(featureFlagName);
-        if (this.flagSetsCache[flagSetName].size === 0)
-            delete this.flagSetsCache[flagSetName];
-    };
     return SplitsCacheInMemory;
 }(AbstractSplitsCacheSync));
 export { SplitsCacheInMemory };

package/esm/storages/inRedis/SplitsCacheInRedis.js

@@ -2,7 +2,6 @@ import { __extends } from "tslib";
 import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
 import { LOG_PREFIX } from './constants';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
-import { _Set } from '../../utils/lang/sets';
 /**
  * Discard errors for an answer of multiple operations.
  */
@@ -169,16 +168,6 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
         var _this = this;
         return this.redis.keys(this.keys.searchPatternForSplitKeys()).then(function (listOfKeys) { return listOfKeys.map(_this.keys.extractKey); });
     };
-    /**
-     * Get list of split names related to a given flag set names list.
-     * The returned promise is resolved with the list of split names,
-     * or rejected if wrapper operation fails.
-     * @todo this is a no-op method to be implemented
-    */
-    SplitsCacheInRedis.prototype.getNamesByFlagSets = function () {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        return new Promise(function (flagSets) { return new _Set([]); });
-    };
     /**
      * Check traffic type existence.
      * The returned promise is resolved with a boolean indicating whether the TT exist or not.

package/esm/storages/pluggable/SplitsCachePluggable.js

@@ -2,7 +2,6 @@ import { __extends } from "tslib";
 import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
 import { LOG_PREFIX } from './constants';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
-import { _Set } from '../../utils/lang/sets';
 /**
  * ISplitsCacheAsync implementation for pluggable storages.
  */
@@ -143,16 +142,6 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
         var _this = this;
         return this.wrapper.getKeysByPrefix(this.keys.buildSplitKeyPrefix()).then(function (listOfKeys) { return listOfKeys.map(_this.keys.extractKey); });
     };
-    /**
-     * Get list of split names related to a given flag set names list.
-     * The returned promise is resolved with the list of split names,
-     * or rejected if wrapper operation fails.
-     * @todo this is a no-op method to be implemented
-    */
-    SplitsCachePluggable.prototype.getNamesByFlagSets = function () {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        return new Promise(function (flagSets) { return new _Set([]); });
-    };
     /**
      * Check traffic type existence.
      * The returned promise is resolved with a boolean indicating whether the TT exist or not.

package/esm/sync/polling/syncTasks/splitsSyncTask.js

@@ -5,5 +5,5 @@ import { splitChangesUpdaterFactory } from '../updaters/splitChangesUpdater';
  * Creates a sync task that periodically executes a `splitChangesUpdater` task
  */
 export function splitsSyncTaskFactory(fetchSplitChanges, storage, readiness, settings, isClientSide) {
-    return syncTaskFactory(settings.log, splitChangesUpdaterFactory(settings.log, splitChangesFetcherFactory(fetchSplitChanges), storage.splits, storage.segments, settings.sync.__splitFiltersValidation, readiness.splits, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, isClientSide), settings.scheduler.featuresRefreshRate, 'splitChangesUpdater');
+    return syncTaskFactory(settings.log, splitChangesUpdaterFactory(settings.log, splitChangesFetcherFactory(fetchSplitChanges), storage.splits, storage.segments, readiness.splits, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, isClientSide), settings.scheduler.featuresRefreshRate, 'splitChangesUpdater');
 }

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

@@ -2,7 +2,6 @@ import { _Set, setToArray } from '../../../utils/lang/sets';
 import { timeout } from '../../../utils/promise/timeout';
 import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/constants';
 import { SYNC_SPLITS_FETCH, SYNC_SPLITS_NEW, SYNC_SPLITS_REMOVED, SYNC_SPLITS_SEGMENTS, SYNC_SPLITS_FETCH_FAILS, SYNC_SPLITS_FETCH_RETRY } from '../../../logger/constants';
-import { startsWith } from '../../../utils/lang';
 // Checks that all registered segments have been fetched (changeNumber !== -1 for every segment).
 // Returns a promise that could be rejected.
 // @TODO review together with Segments and MySegments storage APIs
@@ -29,34 +28,15 @@ export function parseSegments(_a) {
     }
     return segments;
 }
-/**
- * If there are defined filters and one feature flag doesn't match with them, its status is changed to 'ARCHIVE' to avoid storing it
- * If there are set filter defined, names filter is ignored
- *
- * @param featureFlag feature flag to be evaluated
- * @param filters splitFiltersValidation bySet | byName
- */
-function matchFilters(featureFlag, filters) {
-    var _a = filters.groupedFilters, setsFilter = _a.bySet, namesFilter = _a.byName, prefixFilter = _a.byPrefix;
-    if (setsFilter.length > 0)
-        return featureFlag.sets && featureFlag.sets.some(function (featureFlagSet) { return setsFilter.indexOf(featureFlagSet) > -1; });
-    var namesFilterConfigured = namesFilter.length > 0;
-    var prefixFilterConfigured = prefixFilter.length > 0;
-    if (!namesFilterConfigured && !prefixFilterConfigured)
-        return true;
-    var matchNames = namesFilterConfigured && namesFilter.indexOf(featureFlag.name) > -1;
-    var matchPrefix = prefixFilterConfigured && prefixFilter.some(function (prefix) { return startsWith(featureFlag.name, prefix); });
-    return matchNames || matchPrefix;
-}
 /**
  * Given the list of splits from /splitChanges endpoint, it returns the mutations,
  * i.e., an object with added splits, removed splits and used segments.
  * Exported for testing purposes.
  */
-export function computeSplitsMutation(entries, filters) {
+export function computeSplitsMutation(entries) {
     var segments = new _Set();
     var computed = entries.reduce(function (accum, split) {
-        if (split.status === 'ACTIVE' && matchFilters(split, filters)) {
+        if (split.status === 'ACTIVE') {
             accum.added.push([split.name, split]);
             parseSegments(split).forEach(function (segmentName) {
                 segments.add(segmentName);
@@ -84,7 +64,7 @@ export function computeSplitsMutation(entries, filters) {
  * @param requestTimeoutBeforeReady  How long the updater will wait for the request to timeout. Default 0, i.e., never timeout.
  * @param retriesOnFailureBeforeReady  How many retries on `/splitChanges` we the updater do in case of failure or timeout. Default 0, i.e., no retries.
  */
-export function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, segments, splitFiltersValidation, splitsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, isClientSide) {
+export function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, segments, splitsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, isClientSide) {
     if (requestTimeoutBeforeReady === void 0) { requestTimeoutBeforeReady = 0; }
     if (retriesOnFailureBeforeReady === void 0) { retriesOnFailureBeforeReady = 0; }
     var startingUp = true;
@@ -114,7 +94,7 @@ export function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, seg
                 splitChangesFetcher(since, noCache, till, _promiseDecorator))
                 .then(function (splitChanges) {
                 startingUp = false;
-                var mutation = computeSplitsMutation(splitChanges.splits, splitFiltersValidation);
+                var mutation = computeSplitsMutation(splitChanges.splits);
                 log.debug(SYNC_SPLITS_NEW, [mutation.added.length]);
                 log.debug(SYNC_SPLITS_REMOVED, [mutation.removed.length]);
                 log.debug(SYNC_SPLITS_SEGMENTS, [mutation.segments.length]);

package/esm/sync/submitters/telemetrySubmitter.js

@@ -29,17 +29,6 @@ function getRedundantActiveFactories() {
         return acum + usedKeysMap[sdkKey] - 1;
     }, 0);
 }
-function getTelemetryFlagSetsStats(splitFiltersValidation) {
-    // Group every configured flag set in an unique array called originalSets
-    var flagSetsTotal = 0;
-    splitFiltersValidation.validFilters.forEach(function (filter) {
-        if (filter.type === 'bySet')
-            flagSetsTotal += filter.values.length;
-    });
-    var flagSetsValid = splitFiltersValidation.groupedFilters.bySet.length;
-    var flagSetsIgnored = flagSetsTotal - flagSetsValid;
-    return { flagSetsTotal: flagSetsTotal, flagSetsIgnored: flagSetsIgnored };
-}
 export function getTelemetryConfigStats(mode, storageType) {
     return {
         oM: OPERATION_MODE_MAP[mode],
@@ -58,7 +47,6 @@ export function telemetryCacheConfigAdapter(telemetry, settings) {
         pop: function () {
             var urls = settings.urls, scheduler = settings.scheduler;
             var isClientSide = settings.core.key !== undefined;
-            var _a = getTelemetryFlagSetsStats(settings.sync.__splitFiltersValidation), flagSetsTotal = _a.flagSetsTotal, flagSetsIgnored = _a.flagSetsIgnored;
             return objectAssign(getTelemetryConfigStats(settings.mode, settings.storage.type), {
                 sE: settings.streamingEnabled,
                 rR: {
@@ -86,9 +74,7 @@ export function telemetryCacheConfigAdapter(telemetry, settings) {
                 nR: telemetry.getNonReadyUsage(),
                 t: telemetry.popTags(),
                 i: settings.integrations && settings.integrations.map(function (int) { return int.type; }),
-                uC: settings.userConsent ? USER_CONSENT_MAP[settings.userConsent] : 0,
-                fsT: flagSetsTotal,
-                fsI: flagSetsIgnored
+                uC: settings.userConsent ? USER_CONSENT_MAP[settings.userConsent] : 0
             });
         }
     };

package/esm/utils/constants/index.js

@@ -51,10 +51,6 @@ export var TREATMENT = 't';
 export var TREATMENTS = 'ts';
 export var TREATMENT_WITH_CONFIG = 'tc';
 export var TREATMENTS_WITH_CONFIG = 'tcs';
-export var TREATMENTS_BY_FLAGSET = 'tf';
-export var TREATMENTS_BY_FLAGSETS = 'tfs';
-export var TREATMENTS_WITH_CONFIG_BY_FLAGSET = 'tcf';
-export var TREATMENTS_WITH_CONFIG_BY_FLAGSETS = 'tcfs';
 export var TRACK = 'tr';
 export var CONNECTION_ESTABLISHED = 0;
 export var OCCUPANCY_PRI = 10;

package/esm/utils/lang/sets.js

@@ -95,10 +95,3 @@ export function __getSetConstructor() {
     return SetPoly;
 }
 export var _Set = __getSetConstructor();
-export function returnSetsUnion(set, set2) {
-    var result = new _Set(setToArray(set));
-    set2.forEach(function (value) {
-        result.add(value);
-    });
-    return result;
-}