@splitsoftware/splitio-commons 2.13.0 → 2.14.0-rc.0

package/CHANGES.txt

@@ -1,3 +1,9 @@
+2.14.0 (October XX, 2026)
+ - Added `storage.disableFlagSetCache` option (default `false`) for storage type `LOCALSTORAGE`. When set to `true`, the SDK skips building the internal flag set index, which speeds up initialization for large numbers of feature flags. The `getTreatments(WithConfig)ByFlagSet(s)` methods then return empty results and log an error.
+
+2.13.1 (October 7, 2026)
+ - Updated the 'LOCALSTORAGE' storage to batch the writes of flag sets and traffic type/segment counters when storing feature flags, reducing storage update times and the time to SDK_READY event.
+
 2.13.0 (September 24, 2026)
  - Added support for ioredis v6 (Related to issue https://github.com/splitio/javascript-client/issues/951). Note that ioredis v6 requires Node.js 20 or above; stay on ioredis v4 or v5 for older Node.js versions.
  - Removed the `@types/ioredis` dependency, which is no longer required since the public type definitions don't depend on ioredis types. The `@types/node` dependency, previously installed transitively by `@types/ioredis`, is now declared explicitly, since the public type definitions use Node.js types for the `agent` and `tls` options.

package/cjs/logger/constants.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ENGINE_VALUE_INVALID = exports.SUBMITTERS_PUSH_PAGE_HIDDEN = exports.USER_CONSENT_INITIAL = exports.USER_CONSENT_NOT_UPDATED = exports.USER_CONSENT_UPDATED = exports.IMPRESSIONS_TRACKER_SUCCESS = exports.EVENTS_TRACKER_SUCCESS = exports.SYNC_STOP_POLLING = exports.SYNC_CONTINUE_POLLING = exports.SYNC_START_POLLING = exports.SUBMITTERS_PUSH = exports.SUBMITTERS_PUSH_FULL_QUEUE = exports.STREAMING_DISCONNECTING = exports.STREAMING_DISABLED = exports.STREAMING_CONNECTING = exports.STREAMING_RECONNECT = exports.STREAMING_REFRESH_TOKEN = exports.SYNC_SPLITS_FETCH_RETRY = exports.POLLING_STOP = exports.POLLING_START = exports.POLLING_SMART_PAUSING = exports.NEW_FACTORY = exports.NEW_SHARED_CLIENT = exports.IMPRESSION_QUEUEING = exports.CLIENT_READY = exports.CLIENT_READY_FROM_CACHE = exports.ENGINE_DEFAULT = exports.ENGINE_MATCHER_RESULT = exports.SETTINGS_SPLITS_FILTER = exports.SYNC_TASK_STOP = exports.SYNC_TASK_EXECUTE = exports.SYNC_TASK_START = exports.STREAMING_NEW_MESSAGE = exports.SYNC_RBS_UPDATE = exports.SYNC_SPLITS_UPDATE = exports.SYNC_SPLITS_FETCH = exports.SYNC_OFFLINE_DATA = exports.RETRIEVE_MANAGER = exports.RETRIEVE_CLIENT_EXISTING = exports.RETRIEVE_CLIENT_DEFAULT = exports.CLEANUP_DEREGISTERING = exports.CLEANUP_REGISTERING = exports.ENGINE_SANITIZE = exports.ENGINE_VALUE = exports.ENGINE_MATCHER_DEPENDENCY_PRE = exports.ENGINE_MATCHER_DEPENDENCY = exports.ENGINE_BUCKET = exports.ENGINE_COMBINER_IFELSEIF_NO_TREATMENT = exports.ENGINE_COMBINER_IFELSEIF = exports.ENGINE_COMBINER_AND = void 0;
 exports.ERROR_INVALID_CONFIG_PARAM = exports.ERROR_EMPTY_ARRAY = exports.ERROR_EMPTY = exports.ERROR_INVALID = exports.ERROR_INVALID_KEY_OBJECT = exports.ERROR_TOO_LONG = exports.ERROR_NULL = exports.ERROR_CLIENT_DESTROYED = exports.ERROR_NOT_FINITE = exports.ERROR_SIZE_EXCEEDED = exports.ERROR_NOT_PLAIN_OBJECT = exports.ERROR_EVENT_TYPE_FORMAT = exports.ERROR_EVENTS_TRACKER = exports.ERROR_IMPRESSIONS_LISTENER = exports.ERROR_IMPRESSIONS_TRACKER = exports.ERROR_STREAMING_AUTH = exports.ERROR_STREAMING_SSE = exports.ERROR_SYNC_OFFLINE_LOADING = exports.ERROR_CLIENT_CANNOT_GET_READY = exports.ERROR_CLIENT_LISTENER = exports.ERROR_LOGLEVEL_INVALID = exports.ERROR_ENGINE_COMBINER_IFELSEIF = exports.WARN_FLAGSET_WITHOUT_FLAGS = exports.WARN_FLAGSET_NOT_CONFIGURED = exports.WARN_LOWERCASE_FLAGSET = exports.WARN_INVALID_FLAGSET = exports.STREAMING_PARSING_SPLIT_UPDATE = exports.STREAMING_PARSING_MEMBERSHIPS_UPDATE = exports.WARN_SDK_KEY = exports.WARN_SPLITS_FILTER_EMPTY = exports.WARN_SPLITS_FILTER_INVALID = exports.WARN_SPLITS_FILTER_IGNORED = exports.WARN_INTEGRATION_INVALID = exports.WARN_NOT_EXISTENT_TT = exports.WARN_LOWERCASE_TRAFFIC_TYPE = exports.WARN_NOT_EXISTENT_SPLIT = exports.WARN_TRIMMING = exports.WARN_CONVERTING = exports.WARN_TRIMMING_PROPERTIES = exports.WARN_SETTING_NULL = exports.SUBMITTERS_PUSH_RETRY = exports.SUBMITTERS_PUSH_FAILS = exports.STREAMING_FALLBACK = exports.STREAMING_PARSING_MESSAGE_FAILS = exports.STREAMING_PARSING_ERROR_FAILS = exports.SYNC_SPLITS_FETCH_FAILS = exports.SYNC_MYSEGMENTS_FETCH_RETRY = exports.CLIENT_NOT_READY_FROM_CACHE = exports.CLIENT_NO_LISTENER = exports.ENGINE_VALUE_NO_ATTRIBUTES = void 0;
-exports.LOG_PREFIX_CLEANUP = exports.LOG_PREFIX_UNIQUE_KEYS_TRACKER = exports.LOG_PREFIX_EVENTS_TRACKER = exports.LOG_PREFIX_IMPRESSIONS_TRACKER = exports.LOG_PREFIX_SYNC_SUBMITTERS = exports.LOG_PREFIX_SYNC_POLLING = exports.LOG_PREFIX_SYNC_MYSEGMENTS = exports.LOG_PREFIX_SYNC_SEGMENTS = exports.LOG_PREFIX_SYNC_SPLITS = exports.LOG_PREFIX_SYNC_STREAMING = exports.LOG_PREFIX_SYNC_OFFLINE = exports.LOG_PREFIX_SYNC_MANAGER = exports.LOG_PREFIX_SYNC = exports.LOG_PREFIX_ENGINE_VALUE = exports.LOG_PREFIX_ENGINE_MATCHER = exports.LOG_PREFIX_ENGINE_COMBINER = exports.LOG_PREFIX_ENGINE = exports.LOG_PREFIX_CLIENT_INSTANTIATION = exports.LOG_PREFIX_INSTANTIATION = exports.LOG_PREFIX_SETTINGS = exports.ENGINE_MATCHER_ERROR = exports.ERROR_SETS_FILTER_EXCLUSIVE = exports.ERROR_TOO_MANY_SETS = exports.ERROR_MIN_CONFIG_PARAM = exports.ERROR_NOT_BOOLEAN = exports.ERROR_STORAGE_INVALID = exports.ERROR_HTTP = void 0;
+exports.LOG_PREFIX_CLEANUP = exports.LOG_PREFIX_UNIQUE_KEYS_TRACKER = exports.LOG_PREFIX_EVENTS_TRACKER = exports.LOG_PREFIX_IMPRESSIONS_TRACKER = exports.LOG_PREFIX_SYNC_SUBMITTERS = exports.LOG_PREFIX_SYNC_POLLING = exports.LOG_PREFIX_SYNC_MYSEGMENTS = exports.LOG_PREFIX_SYNC_SEGMENTS = exports.LOG_PREFIX_SYNC_SPLITS = exports.LOG_PREFIX_SYNC_STREAMING = exports.LOG_PREFIX_SYNC_OFFLINE = exports.LOG_PREFIX_SYNC_MANAGER = exports.LOG_PREFIX_SYNC = exports.LOG_PREFIX_ENGINE_VALUE = exports.LOG_PREFIX_ENGINE_MATCHER = exports.LOG_PREFIX_ENGINE_COMBINER = exports.LOG_PREFIX_ENGINE = exports.LOG_PREFIX_CLIENT_INSTANTIATION = exports.LOG_PREFIX_INSTANTIATION = exports.LOG_PREFIX_SETTINGS = exports.ERROR_FLAGSET_CACHE_DISABLED = exports.ENGINE_MATCHER_ERROR = exports.ERROR_SETS_FILTER_EXCLUSIVE = exports.ERROR_TOO_MANY_SETS = exports.ERROR_MIN_CONFIG_PARAM = exports.ERROR_NOT_BOOLEAN = exports.ERROR_STORAGE_INVALID = exports.ERROR_HTTP = void 0;
 /**
  * Message codes used to trim string log messages from commons and client-side API modules,
  * in order to reduce the minimal SDK size for Browser and eventually other client-side environments.
@@ -117,6 +117,7 @@ exports.ERROR_MIN_CONFIG_PARAM = 326;
 exports.ERROR_TOO_MANY_SETS = 327;
 exports.ERROR_SETS_FILTER_EXCLUSIVE = 328;
 exports.ENGINE_MATCHER_ERROR = 329;
+exports.ERROR_FLAGSET_CACHE_DISABLED = 330;
 // Log prefixes (a.k.a. tags or categories)
 exports.LOG_PREFIX_SETTINGS = 'settings';
 exports.LOG_PREFIX_INSTANTIATION = 'Factory instantiation';

package/cjs/logger/messages/error.js

@@ -33,6 +33,7 @@ exports.codesError = [
     [c.ERROR_EMPTY, '%s: you passed an empty %s. It must be a non-empty string.'],
     [c.ERROR_EMPTY_ARRAY, '%s: %s must be a non-empty array.'],
     [c.ERROR_NOT_BOOLEAN, '%s: provided param must be a boolean value.'],
+    [c.ERROR_FLAGSET_CACHE_DISABLED, 'The flag set cache is disabled via the `disableFlagSetCache` setting, so `getTreatments(WithConfig)ByFlagSet(s)` methods always return empty objects. Remove the setting to use them.'],
     // initialization / settings validation
     [c.ERROR_INVALID_CONFIG_PARAM, c.LOG_PREFIX_SETTINGS + ': you passed an invalid "%s" config param. It should be one of the following values: %s. Defaulting to "%s".'],
     [c.ERROR_STORAGE_INVALID, c.LOG_PREFIX_SETTINGS + ': the provided storage is invalid.%s Falling back into default MEMORY storage'],

package/cjs/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -5,49 +5,29 @@ var tslib_1 = require("tslib");
 var AbstractSplitsCacheSync_1 = require("../AbstractSplitsCacheSync");
 var lang_1 = require("../../utils/lang");
 var constants_1 = require("./constants");
+var constants_2 = require("../../logger/constants");
 var sets_1 = require("../../utils/lang/sets");
+function newBatch() {
+    return { flagSets: new Map(), counts: new Map() };
+}
 var SplitsCacheInLocal = /** @class */ (function (_super) {
     tslib_1.__extends(SplitsCacheInLocal, _super);
-    function SplitsCacheInLocal(settings, keys, storage) {
+    function SplitsCacheInLocal(settings, keys, storage, disableFlagSetCache) {
         var _this = _super.call(this) || this;
         _this.keys = keys;
         _this.log = settings.log;
         _this.flagSetsFilter = settings.sync.__splitFiltersValidation.groupedFilters.bySet;
         _this.storage = storage;
+        _this.disableFlagSetCache = disableFlagSetCache;
         return _this;
     }
-    SplitsCacheInLocal.prototype._decrementCount = function (key) {
-        var count = (0, lang_1.toNumber)(this.storage.getItem(key)) - 1;
-        if (count > 0)
-            this.storage.setItem(key, count + '');
-        else
-            this.storage.removeItem(key);
-    };
-    SplitsCacheInLocal.prototype._decrementCounts = function (split) {
-        try {
-            var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-            this._decrementCount(ttKey);
-            if ((0, AbstractSplitsCacheSync_1.usesSegments)(split)) {
-                var segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
-                this._decrementCount(segmentsCountKey);
-            }
-        }
-        catch (e) {
-            this.log.error(constants_1.LOG_PREFIX + e);
-        }
+    SplitsCacheInLocal.prototype.updateCount = function (batch, key, diff) {
+        batch.counts.set(key, (batch.counts.get(key) || 0) + diff);
     };
-    SplitsCacheInLocal.prototype._incrementCounts = function (split) {
-        try {
-            var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-            this.storage.setItem(ttKey, ((0, lang_1.toNumber)(this.storage.getItem(ttKey)) + 1) + '');
-            if ((0, AbstractSplitsCacheSync_1.usesSegments)(split)) {
-                var segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
-                this.storage.setItem(segmentsCountKey, ((0, lang_1.toNumber)(this.storage.getItem(segmentsCountKey)) + 1) + '');
-            }
-        }
-        catch (e) {
-            this.log.error(constants_1.LOG_PREFIX + e);
-        }
+    SplitsCacheInLocal.prototype.updateCounts = function (split, batch, diff) {
+        this.updateCount(batch, this.keys.buildTrafficTypeKey(split.trafficTypeName), diff);
+        if ((0, AbstractSplitsCacheSync_1.usesSegments)(split))
+            this.updateCount(batch, this.keys.buildSplitsWithSegmentCountKey(), diff);
     };
     /**
      * Removes all splits cache related data from localStorage (splits, counters, changeNumber and lastUpdated).
@@ -69,27 +49,64 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         });
         this.hasSync = false;
     };
+    /**
+     * Overrides the default implementation to batch the flag set and counter writes: each flag set and each counter is read from
+     * storage once, updated in memory, and written once at the end, instead of once per feature flag.
+     * `update` is synchronous, so no other reader can observe the intermediate state.
+     */
+    SplitsCacheInLocal.prototype.update = function (toAdd, toRemove, changeNumber) {
+        var _this = this;
+        var batch = newBatch();
+        var updated;
+        try {
+            updated = toAdd.map(function (addedFF) { return _this.addSplitToBatch(addedFF, batch); }).some(function (result) { return result; });
+            updated = toRemove.map(function (removedFF) { return _this.removeSplitFromBatch(removedFF.name, batch); }).some(function (result) { return result; }) || updated;
+        }
+        finally {
+            this.flushBatch(batch);
+        }
+        this.setChangeNumber(changeNumber);
+        return updated;
+    };
     SplitsCacheInLocal.prototype.addSplit = function (split) {
+        var batch = newBatch();
+        try {
+            return this.addSplitToBatch(split, batch);
+        }
+        finally {
+            this.flushBatch(batch);
+        }
+    };
+    SplitsCacheInLocal.prototype.removeSplit = function (name) {
+        var batch = newBatch();
+        try {
+            return this.removeSplitFromBatch(name, batch);
+        }
+        finally {
+            this.flushBatch(batch);
+        }
+    };
+    SplitsCacheInLocal.prototype.addSplitToBatch = function (split, batch) {
         var name = split.name;
         var splitKey = this.keys.buildSplitKey(name);
         var splitFromStorage = this.storage.getItem(splitKey);
         var previousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : null;
         if (previousSplit) {
-            this._decrementCounts(previousSplit);
-            this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
+            this.updateCounts(previousSplit, batch, -1);
+            this.removeFromFlagSets(previousSplit.name, previousSplit.sets, batch);
         }
         this.storage.setItem(splitKey, JSON.stringify(split));
-        this._incrementCounts(split);
-        this.addToFlagSets(split);
+        this.updateCounts(split, batch, 1);
+        this.addToFlagSets(split, batch);
         return true;
     };
-    SplitsCacheInLocal.prototype.removeSplit = function (name) {
+    SplitsCacheInLocal.prototype.removeSplitFromBatch = function (name, batch) {
         var split = this.getSplit(name);
         if (!split)
             return false;
         this.storage.removeItem(this.keys.buildSplitKey(name));
-        this._decrementCounts(split);
-        this.removeFromFlagSets(split.name, split.sets);
+        this.updateCounts(split, batch, -1);
+        this.removeFromFlagSets(split.name, split.sets, batch);
         return true;
     };
     SplitsCacheInLocal.prototype.getSplit = function (name) {
@@ -146,48 +163,83 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
     };
     SplitsCacheInLocal.prototype.getNamesByFlagSets = function (flagSets) {
         var _this = this;
+        if (this.disableFlagSetCache) {
+            this.log.error(constants_2.ERROR_FLAGSET_CACHE_DISABLED);
+            return flagSets.map(function () { return new Set(); });
+        }
         return flagSets.map(function (flagSet) {
             var flagSetKey = _this.keys.buildFlagSetKey(flagSet);
             var flagSetFromStorage = _this.storage.getItem(flagSetKey);
             return new Set(flagSetFromStorage ? JSON.parse(flagSetFromStorage) : []);
         });
     };
-    SplitsCacheInLocal.prototype.addToFlagSets = function (featureFlag) {
+    SplitsCacheInLocal.prototype.addToFlagSets = function (featureFlag, batch) {
         var _this = this;
-        if (!featureFlag.sets)
+        if (this.disableFlagSetCache || !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 flagSetFromStorage = _this.storage.getItem(flagSetKey);
-            var flagSetCache = new Set(flagSetFromStorage ? JSON.parse(flagSetFromStorage) : []);
-            if (flagSetCache.has(featureFlag.name))
-                return;
-            flagSetCache.add(featureFlag.name);
-            _this.storage.setItem(flagSetKey, JSON.stringify((0, sets_1.setToArray)(flagSetCache)));
+            _this.getFlagSetFromBatch(flagSetKey, batch).add(featureFlag.name);
         });
     };
-    SplitsCacheInLocal.prototype.removeFromFlagSets = function (featureFlagName, flagSets) {
+    SplitsCacheInLocal.prototype.removeFromFlagSets = function (featureFlagName, flagSets, batch) {
         var _this = this;
-        if (!flagSets)
+        if (this.disableFlagSetCache || !flagSets)
             return;
         flagSets.forEach(function (flagSet) {
-            _this.removeNames(flagSet, featureFlagName);
+            _this.removeNames(flagSet, featureFlagName, batch);
         });
     };
-    SplitsCacheInLocal.prototype.removeNames = function (flagSetName, featureFlagName) {
+    SplitsCacheInLocal.prototype.removeNames = function (flagSetName, featureFlagName, batch) {
         var flagSetKey = this.keys.buildFlagSetKey(flagSetName);
-        var flagSetFromStorage = this.storage.getItem(flagSetKey);
-        if (!flagSetFromStorage)
-            return;
-        var flagSetCache = new Set(JSON.parse(flagSetFromStorage));
-        flagSetCache.delete(featureFlagName);
-        if (flagSetCache.size === 0) {
-            this.storage.removeItem(flagSetKey);
+        // nothing to remove from a flag set that is neither in storage nor in the batch
+        if (!batch.flagSets.has(flagSetKey) && !this.storage.getItem(flagSetKey))
             return;
+        this.getFlagSetFromBatch(flagSetKey, batch).delete(featureFlagName);
+    };
+    /**
+     * Returns the flag names of the given flag set, reading from storage only the first time
+     */
+    SplitsCacheInLocal.prototype.getFlagSetFromBatch = function (flagSetKey, batch) {
+        var flagSetCache = batch.flagSets.get(flagSetKey);
+        if (!flagSetCache) {
+            var flagSetFromStorage = this.storage.getItem(flagSetKey);
+            flagSetCache = new Set(flagSetFromStorage ? JSON.parse(flagSetFromStorage) : []);
+            batch.flagSets.set(flagSetKey, flagSetCache);
         }
-        this.storage.setItem(flagSetKey, JSON.stringify((0, sets_1.setToArray)(flagSetCache)));
+        return flagSetCache;
+    };
+    SplitsCacheInLocal.prototype.flushBatch = function (batch) {
+        var _this = this;
+        // flush counts
+        batch.counts.forEach(function (diff, key) {
+            try {
+                if (diff === 0)
+                    return;
+                var count = (0, lang_1.toNumber)(_this.storage.getItem(key)) + diff;
+                if (count > 0)
+                    _this.storage.setItem(key, count + '');
+                else
+                    _this.storage.removeItem(key);
+            }
+            catch (e) {
+                _this.log.error(constants_1.LOG_PREFIX + e);
+            }
+        });
+        // flush flag sets
+        batch.flagSets.forEach(function (flagSetCache, flagSetKey) {
+            try {
+                if (flagSetCache.size === 0)
+                    _this.storage.removeItem(flagSetKey);
+                else
+                    _this.storage.setItem(flagSetKey, JSON.stringify((0, sets_1.setToArray)(flagSetCache)));
+            }
+            catch (e) {
+                _this.log.error(constants_1.LOG_PREFIX + e);
+            }
+        });
     };
     return SplitsCacheInLocal;
 }(AbstractSplitsCacheSync_1.AbstractSplitsCacheSync));

package/cjs/storages/inLocalStorage/index.js

@@ -18,6 +18,8 @@ var UniqueKeysCacheInMemoryCS_1 = require("../inMemory/UniqueKeysCacheInMemoryCS
 var key_1 = require("../../utils/key");
 var validateCache_1 = require("./validateCache");
 var storageAdapter_1 = require("./storageAdapter");
+var lang_1 = require("../../utils/lang");
+var constants_3 = require("../../logger/constants");
 function validateStorage(log, prefix, wrapper) {
     if (wrapper) {
         if ((0, isLocalStorageAvailable_1.isValidStorageWrapper)(wrapper)) {
@@ -44,7 +46,10 @@ function InLocalStorage(options) {
             return (0, InMemoryStorageCS_1.InMemoryStorageCSFactory)(params);
         var matchingKey = (0, key_1.getMatching)(settings.core.key);
         var keys = new KeyBuilderCS_1.KeyBuilderCS(prefix, matchingKey);
-        var splits = new SplitsCacheInLocal_1.SplitsCacheInLocal(settings, keys, storage);
+        if (options.disableFlagSetCache !== undefined && !(0, lang_1.isBoolean)(options.disableFlagSetCache)) {
+            log.error(constants_3.ERROR_INVALID_CONFIG_PARAM, ['disableFlagSetCache', 'true, false', 'false']);
+        }
+        var splits = new SplitsCacheInLocal_1.SplitsCacheInLocal(settings, keys, storage, options.disableFlagSetCache === true);
         var rbSegments = new RBSegmentsCacheInLocal_1.RBSegmentsCacheInLocal(settings, keys, storage);
         var segments = new MySegmentsCacheInLocal_1.MySegmentsCacheInLocal(log, keys, storage);
         var largeSegments = new MySegmentsCacheInLocal_1.MySegmentsCacheInLocal(log, (0, KeyBuilderCS_1.myLargeSegmentsKeyBuilder)(prefix, matchingKey), storage);

package/esm/logger/constants.js

@@ -112,6 +112,7 @@ export var ERROR_MIN_CONFIG_PARAM = 326;
 export var ERROR_TOO_MANY_SETS = 327;
 export var ERROR_SETS_FILTER_EXCLUSIVE = 328;
 export var ENGINE_MATCHER_ERROR = 329;
+export var ERROR_FLAGSET_CACHE_DISABLED = 330;
 // Log prefixes (a.k.a. tags or categories)
 export var LOG_PREFIX_SETTINGS = 'settings';
 export var LOG_PREFIX_INSTANTIATION = 'Factory instantiation';

package/esm/logger/messages/error.js

@@ -29,6 +29,7 @@ export var codesError = [
     [c.ERROR_EMPTY, '%s: you passed an empty %s. It must be a non-empty string.'],
     [c.ERROR_EMPTY_ARRAY, '%s: %s must be a non-empty array.'],
     [c.ERROR_NOT_BOOLEAN, '%s: provided param must be a boolean value.'],
+    [c.ERROR_FLAGSET_CACHE_DISABLED, 'The flag set cache is disabled via the `disableFlagSetCache` setting, so `getTreatments(WithConfig)ByFlagSet(s)` methods always return empty objects. Remove the setting to use them.'],
     // initialization / settings validation
     [c.ERROR_INVALID_CONFIG_PARAM, c.LOG_PREFIX_SETTINGS + ': you passed an invalid "%s" config param. It should be one of the following values: %s. Defaulting to "%s".'],
     [c.ERROR_STORAGE_INVALID, c.LOG_PREFIX_SETTINGS + ': the provided storage is invalid.%s Falling back into default MEMORY storage'],

package/esm/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -2,49 +2,29 @@ import { __extends } from "tslib";
 import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';
 import { isFiniteNumber, toNumber, isNaNNumber } from '../../utils/lang';
 import { LOG_PREFIX } from './constants';
+import { ERROR_FLAGSET_CACHE_DISABLED } from '../../logger/constants';
 import { setToArray } from '../../utils/lang/sets';
+function newBatch() {
+    return { flagSets: new Map(), counts: new Map() };
+}
 var SplitsCacheInLocal = /** @class */ (function (_super) {
     __extends(SplitsCacheInLocal, _super);
-    function SplitsCacheInLocal(settings, keys, storage) {
+    function SplitsCacheInLocal(settings, keys, storage, disableFlagSetCache) {
         var _this = _super.call(this) || this;
         _this.keys = keys;
         _this.log = settings.log;
         _this.flagSetsFilter = settings.sync.__splitFiltersValidation.groupedFilters.bySet;
         _this.storage = storage;
+        _this.disableFlagSetCache = disableFlagSetCache;
         return _this;
     }
-    SplitsCacheInLocal.prototype._decrementCount = function (key) {
-        var count = toNumber(this.storage.getItem(key)) - 1;
-        if (count > 0)
-            this.storage.setItem(key, count + '');
-        else
-            this.storage.removeItem(key);
-    };
-    SplitsCacheInLocal.prototype._decrementCounts = function (split) {
-        try {
-            var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-            this._decrementCount(ttKey);
-            if (usesSegments(split)) {
-                var segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
-                this._decrementCount(segmentsCountKey);
-            }
-        }
-        catch (e) {
-            this.log.error(LOG_PREFIX + e);
-        }
+    SplitsCacheInLocal.prototype.updateCount = function (batch, key, diff) {
+        batch.counts.set(key, (batch.counts.get(key) || 0) + diff);
     };
-    SplitsCacheInLocal.prototype._incrementCounts = function (split) {
-        try {
-            var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-            this.storage.setItem(ttKey, (toNumber(this.storage.getItem(ttKey)) + 1) + '');
-            if (usesSegments(split)) {
-                var segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
-                this.storage.setItem(segmentsCountKey, (toNumber(this.storage.getItem(segmentsCountKey)) + 1) + '');
-            }
-        }
-        catch (e) {
-            this.log.error(LOG_PREFIX + e);
-        }
+    SplitsCacheInLocal.prototype.updateCounts = function (split, batch, diff) {
+        this.updateCount(batch, this.keys.buildTrafficTypeKey(split.trafficTypeName), diff);
+        if (usesSegments(split))
+            this.updateCount(batch, this.keys.buildSplitsWithSegmentCountKey(), diff);
     };
     /**
      * Removes all splits cache related data from localStorage (splits, counters, changeNumber and lastUpdated).
@@ -66,27 +46,64 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         });
         this.hasSync = false;
     };
+    /**
+     * Overrides the default implementation to batch the flag set and counter writes: each flag set and each counter is read from
+     * storage once, updated in memory, and written once at the end, instead of once per feature flag.
+     * `update` is synchronous, so no other reader can observe the intermediate state.
+     */
+    SplitsCacheInLocal.prototype.update = function (toAdd, toRemove, changeNumber) {
+        var _this = this;
+        var batch = newBatch();
+        var updated;
+        try {
+            updated = toAdd.map(function (addedFF) { return _this.addSplitToBatch(addedFF, batch); }).some(function (result) { return result; });
+            updated = toRemove.map(function (removedFF) { return _this.removeSplitFromBatch(removedFF.name, batch); }).some(function (result) { return result; }) || updated;
+        }
+        finally {
+            this.flushBatch(batch);
+        }
+        this.setChangeNumber(changeNumber);
+        return updated;
+    };
     SplitsCacheInLocal.prototype.addSplit = function (split) {
+        var batch = newBatch();
+        try {
+            return this.addSplitToBatch(split, batch);
+        }
+        finally {
+            this.flushBatch(batch);
+        }
+    };
+    SplitsCacheInLocal.prototype.removeSplit = function (name) {
+        var batch = newBatch();
+        try {
+            return this.removeSplitFromBatch(name, batch);
+        }
+        finally {
+            this.flushBatch(batch);
+        }
+    };
+    SplitsCacheInLocal.prototype.addSplitToBatch = function (split, batch) {
         var name = split.name;
         var splitKey = this.keys.buildSplitKey(name);
         var splitFromStorage = this.storage.getItem(splitKey);
         var previousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : null;
         if (previousSplit) {
-            this._decrementCounts(previousSplit);
-            this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
+            this.updateCounts(previousSplit, batch, -1);
+            this.removeFromFlagSets(previousSplit.name, previousSplit.sets, batch);
         }
         this.storage.setItem(splitKey, JSON.stringify(split));
-        this._incrementCounts(split);
-        this.addToFlagSets(split);
+        this.updateCounts(split, batch, 1);
+        this.addToFlagSets(split, batch);
         return true;
     };
-    SplitsCacheInLocal.prototype.removeSplit = function (name) {
+    SplitsCacheInLocal.prototype.removeSplitFromBatch = function (name, batch) {
         var split = this.getSplit(name);
         if (!split)
             return false;
         this.storage.removeItem(this.keys.buildSplitKey(name));
-        this._decrementCounts(split);
-        this.removeFromFlagSets(split.name, split.sets);
+        this.updateCounts(split, batch, -1);
+        this.removeFromFlagSets(split.name, split.sets, batch);
         return true;
     };
     SplitsCacheInLocal.prototype.getSplit = function (name) {
@@ -143,48 +160,83 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
     };
     SplitsCacheInLocal.prototype.getNamesByFlagSets = function (flagSets) {
         var _this = this;
+        if (this.disableFlagSetCache) {
+            this.log.error(ERROR_FLAGSET_CACHE_DISABLED);
+            return flagSets.map(function () { return new Set(); });
+        }
         return flagSets.map(function (flagSet) {
             var flagSetKey = _this.keys.buildFlagSetKey(flagSet);
             var flagSetFromStorage = _this.storage.getItem(flagSetKey);
             return new Set(flagSetFromStorage ? JSON.parse(flagSetFromStorage) : []);
         });
     };
-    SplitsCacheInLocal.prototype.addToFlagSets = function (featureFlag) {
+    SplitsCacheInLocal.prototype.addToFlagSets = function (featureFlag, batch) {
         var _this = this;
-        if (!featureFlag.sets)
+        if (this.disableFlagSetCache || !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 flagSetFromStorage = _this.storage.getItem(flagSetKey);
-            var flagSetCache = new Set(flagSetFromStorage ? JSON.parse(flagSetFromStorage) : []);
-            if (flagSetCache.has(featureFlag.name))
-                return;
-            flagSetCache.add(featureFlag.name);
-            _this.storage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
+            _this.getFlagSetFromBatch(flagSetKey, batch).add(featureFlag.name);
         });
     };
-    SplitsCacheInLocal.prototype.removeFromFlagSets = function (featureFlagName, flagSets) {
+    SplitsCacheInLocal.prototype.removeFromFlagSets = function (featureFlagName, flagSets, batch) {
         var _this = this;
-        if (!flagSets)
+        if (this.disableFlagSetCache || !flagSets)
             return;
         flagSets.forEach(function (flagSet) {
-            _this.removeNames(flagSet, featureFlagName);
+            _this.removeNames(flagSet, featureFlagName, batch);
         });
     };
-    SplitsCacheInLocal.prototype.removeNames = function (flagSetName, featureFlagName) {
+    SplitsCacheInLocal.prototype.removeNames = function (flagSetName, featureFlagName, batch) {
         var flagSetKey = this.keys.buildFlagSetKey(flagSetName);
-        var flagSetFromStorage = this.storage.getItem(flagSetKey);
-        if (!flagSetFromStorage)
-            return;
-        var flagSetCache = new Set(JSON.parse(flagSetFromStorage));
-        flagSetCache.delete(featureFlagName);
-        if (flagSetCache.size === 0) {
-            this.storage.removeItem(flagSetKey);
+        // nothing to remove from a flag set that is neither in storage nor in the batch
+        if (!batch.flagSets.has(flagSetKey) && !this.storage.getItem(flagSetKey))
             return;
+        this.getFlagSetFromBatch(flagSetKey, batch).delete(featureFlagName);
+    };
+    /**
+     * Returns the flag names of the given flag set, reading from storage only the first time
+     */
+    SplitsCacheInLocal.prototype.getFlagSetFromBatch = function (flagSetKey, batch) {
+        var flagSetCache = batch.flagSets.get(flagSetKey);
+        if (!flagSetCache) {
+            var flagSetFromStorage = this.storage.getItem(flagSetKey);
+            flagSetCache = new Set(flagSetFromStorage ? JSON.parse(flagSetFromStorage) : []);
+            batch.flagSets.set(flagSetKey, flagSetCache);
         }
-        this.storage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
+        return flagSetCache;
+    };
+    SplitsCacheInLocal.prototype.flushBatch = function (batch) {
+        var _this = this;
+        // flush counts
+        batch.counts.forEach(function (diff, key) {
+            try {
+                if (diff === 0)
+                    return;
+                var count = toNumber(_this.storage.getItem(key)) + diff;
+                if (count > 0)
+                    _this.storage.setItem(key, count + '');
+                else
+                    _this.storage.removeItem(key);
+            }
+            catch (e) {
+                _this.log.error(LOG_PREFIX + e);
+            }
+        });
+        // flush flag sets
+        batch.flagSets.forEach(function (flagSetCache, flagSetKey) {
+            try {
+                if (flagSetCache.size === 0)
+                    _this.storage.removeItem(flagSetKey);
+                else
+                    _this.storage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
+            }
+            catch (e) {
+                _this.log.error(LOG_PREFIX + e);
+            }
+        });
     };
     return SplitsCacheInLocal;
 }(AbstractSplitsCacheSync));

package/esm/storages/inLocalStorage/index.js

@@ -15,6 +15,8 @@ import { UniqueKeysCacheInMemoryCS } from '../inMemory/UniqueKeysCacheInMemoryCS
 import { getMatching } from '../../utils/key';
 import { validateCache } from './validateCache';
 import { storageAdapter } from './storageAdapter';
+import { isBoolean } from '../../utils/lang';
+import { ERROR_INVALID_CONFIG_PARAM } from '../../logger/constants';
 function validateStorage(log, prefix, wrapper) {
     if (wrapper) {
         if (isValidStorageWrapper(wrapper)) {
@@ -41,7 +43,10 @@ export function InLocalStorage(options) {
             return InMemoryStorageCSFactory(params);
         var matchingKey = getMatching(settings.core.key);
         var keys = new KeyBuilderCS(prefix, matchingKey);
-        var splits = new SplitsCacheInLocal(settings, keys, storage);
+        if (options.disableFlagSetCache !== undefined && !isBoolean(options.disableFlagSetCache)) {
+            log.error(ERROR_INVALID_CONFIG_PARAM, ['disableFlagSetCache', 'true, false', 'false']);
+        }
+        var splits = new SplitsCacheInLocal(settings, keys, storage, options.disableFlagSetCache === true);
         var rbSegments = new RBSegmentsCacheInLocal(settings, keys, storage);
         var segments = new MySegmentsCacheInLocal(log, keys, storage);
         var largeSegments = new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey), storage);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "2.13.0",
+  "version": "2.14.0-rc.0",
   "description": "Split JavaScript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/logger/constants.ts

@@ -115,6 +115,7 @@ export const ERROR_MIN_CONFIG_PARAM = 326;
 export const ERROR_TOO_MANY_SETS = 327;
 export const ERROR_SETS_FILTER_EXCLUSIVE = 328;
 export const ENGINE_MATCHER_ERROR = 329;
+export const ERROR_FLAGSET_CACHE_DISABLED = 330;
 
 // Log prefixes (a.k.a. tags or categories)
 export const LOG_PREFIX_SETTINGS = 'settings';

package/src/logger/messages/error.ts

@@ -30,6 +30,7 @@ export const codesError: [number, string][] = [
   [c.ERROR_EMPTY, '%s: you passed an empty %s. It must be a non-empty string.'],
   [c.ERROR_EMPTY_ARRAY, '%s: %s must be a non-empty array.'],
   [c.ERROR_NOT_BOOLEAN, '%s: provided param must be a boolean value.'],
+  [c.ERROR_FLAGSET_CACHE_DISABLED, 'The flag set cache is disabled via the `disableFlagSetCache` setting, so `getTreatments(WithConfig)ByFlagSet(s)` methods always return empty objects. Remove the setting to use them.'],
   // initialization / settings validation
   [c.ERROR_INVALID_CONFIG_PARAM, c.LOG_PREFIX_SETTINGS + ': you passed an invalid "%s" config param. It should be one of the following values: %s. Defaulting to "%s".'],
   [c.ERROR_STORAGE_INVALID, c.LOG_PREFIX_SETTINGS+': the provided storage is invalid.%s Falling back into default MEMORY storage'],

package/src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -4,61 +4,50 @@ import { isFiniteNumber, toNumber, isNaNNumber } from '../../utils/lang';
 import { KeyBuilderCS } from '../KeyBuilderCS';
 import { ILogger } from '../../logger/types';
 import { LOG_PREFIX } from './constants';
+import { ERROR_FLAGSET_CACHE_DISABLED } from '../../logger/constants';
 import { ISettings } from '../../types';
 import { setToArray } from '../../utils/lang/sets';
 import { StorageAdapter } from '../types';
 
+/**
+ * Changes accumulated in memory while applying an update, so that each flag set and counter delta is written once at the end of the update.
+ */
+interface UpdateBatch {
+  flagSets: Map<string, Set<string>>;
+  counts: Map<string, number>;
+}
+
+function newBatch(): UpdateBatch {
+  return { flagSets: new Map(), counts: new Map() };
+}
+
 export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
 
   private readonly keys: KeyBuilderCS;
   private readonly log: ILogger;
   private readonly flagSetsFilter: string[];
+  private readonly disableFlagSetCache?: boolean;
   private hasSync?: boolean;
   private readonly storage: StorageAdapter;
 
-  constructor(settings: ISettings, keys: KeyBuilderCS, storage: StorageAdapter) {
+  constructor(settings: ISettings, keys: KeyBuilderCS, storage: StorageAdapter, disableFlagSetCache?: boolean) {
     super();
     this.keys = keys;
     this.log = settings.log;
     this.flagSetsFilter = settings.sync.__splitFiltersValidation.groupedFilters.bySet;
     this.storage = storage;
+    this.disableFlagSetCache = disableFlagSetCache;
   }
 
-  private _decrementCount(key: string) {
-    const count = toNumber(this.storage.getItem(key)) - 1;
-    if (count > 0) this.storage.setItem(key, count + '');
-    else this.storage.removeItem(key);
+  private updateCount(batch: UpdateBatch, key: string, diff: number) {
+    batch.counts.set(key, (batch.counts.get(key) || 0) + diff);
   }
 
-  private _decrementCounts(split: ISplit) {
-    try {
-      const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-      this._decrementCount(ttKey);
-
-      if (usesSegments(split)) {
-        const segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
-        this._decrementCount(segmentsCountKey);
-      }
-    } catch (e) {
-      this.log.error(LOG_PREFIX + e);
-    }
+  private updateCounts(split: ISplit, batch: UpdateBatch, diff: number) {
+    this.updateCount(batch, this.keys.buildTrafficTypeKey(split.trafficTypeName), diff);
+    if (usesSegments(split)) this.updateCount(batch, this.keys.buildSplitsWithSegmentCountKey(), diff);
   }
 
-  private _incrementCounts(split: ISplit) {
-    try {
-      const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-      this.storage.setItem(ttKey, (toNumber(this.storage.getItem(ttKey)) + 1) + '');
-
-      if (usesSegments(split)) {
-        const segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
-        this.storage.setItem(segmentsCountKey, (toNumber(this.storage.getItem(segmentsCountKey)) + 1) + '');
-      }
-    } catch (e) {
-      this.log.error(LOG_PREFIX + e);
-    }
-  }
-
-
   /**
    * Removes all splits cache related data from localStorage (splits, counters, changeNumber and lastUpdated).
    * We cannot simply call `localStorage.clear()` since that implies removing user items from the storage.
@@ -79,33 +68,69 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     this.hasSync = false;
   }
 
+  /**
+   * Overrides the default implementation to batch the flag set and counter writes: each flag set and each counter is read from
+   * storage once, updated in memory, and written once at the end, instead of once per feature flag.
+   * `update` is synchronous, so no other reader can observe the intermediate state.
+   */
+  update(toAdd: ISplit[], toRemove: ISplit[], changeNumber: number): boolean {
+    const batch = newBatch();
+    let updated;
+    try {
+      updated = toAdd.map(addedFF => this.addSplitToBatch(addedFF, batch)).some(result => result);
+      updated = toRemove.map(removedFF => this.removeSplitFromBatch(removedFF.name, batch)).some(result => result) || updated;
+    } finally {
+      this.flushBatch(batch);
+    }
+    this.setChangeNumber(changeNumber);
+    return updated;
+  }
+
   addSplit(split: ISplit) {
+    const batch = newBatch();
+    try {
+      return this.addSplitToBatch(split, batch);
+    } finally {
+      this.flushBatch(batch);
+    }
+  }
+
+  removeSplit(name: string): boolean {
+    const batch = newBatch();
+    try {
+      return this.removeSplitFromBatch(name, batch);
+    } finally {
+      this.flushBatch(batch);
+    }
+  }
+
+  private addSplitToBatch(split: ISplit, batch: UpdateBatch) {
     const name = split.name;
     const splitKey = this.keys.buildSplitKey(name);
     const splitFromStorage = this.storage.getItem(splitKey);
     const previousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : null;
 
     if (previousSplit) {
-      this._decrementCounts(previousSplit);
-      this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
+      this.updateCounts(previousSplit, batch, -1);
+      this.removeFromFlagSets(previousSplit.name, previousSplit.sets, batch);
     }
 
     this.storage.setItem(splitKey, JSON.stringify(split));
 
-    this._incrementCounts(split);
-    this.addToFlagSets(split);
+    this.updateCounts(split, batch, 1);
+    this.addToFlagSets(split, batch);
 
     return true;
   }
 
-  removeSplit(name: string): boolean {
+  private removeSplitFromBatch(name: string, batch: UpdateBatch): boolean {
     const split = this.getSplit(name);
     if (!split) return false;
 
     this.storage.removeItem(this.keys.buildSplitKey(name));
 
-    this._decrementCounts(split);
-    this.removeFromFlagSets(split.name, split.sets);
+    this.updateCounts(split, batch, -1);
+    this.removeFromFlagSets(split.name, split.sets, batch);
 
     return true;
   }
@@ -176,6 +201,11 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
   }
 
   getNamesByFlagSets(flagSets: string[]): Set<string>[] {
+    if (this.disableFlagSetCache) {
+      this.log.error(ERROR_FLAGSET_CACHE_DISABLED);
+      return flagSets.map(() => new Set<string>());
+    }
+
     return flagSets.map(flagSet => {
       const flagSetKey = this.keys.buildFlagSetKey(flagSet);
       const flagSetFromStorage = this.storage.getItem(flagSetKey);
@@ -184,8 +214,8 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     });
   }
 
-  private addToFlagSets(featureFlag: ISplit) {
-    if (!featureFlag.sets) return;
+  private addToFlagSets(featureFlag: ISplit, batch: UpdateBatch) {
+    if (this.disableFlagSetCache || !featureFlag.sets) return;
 
     featureFlag.sets.forEach(featureFlagSet => {
 
@@ -193,42 +223,62 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
 
       const flagSetKey = this.keys.buildFlagSetKey(featureFlagSet);
 
-      const flagSetFromStorage = this.storage.getItem(flagSetKey);
-
-      const flagSetCache = new Set(flagSetFromStorage ? JSON.parse(flagSetFromStorage) : []);
-
-      if (flagSetCache.has(featureFlag.name)) return;
-
-      flagSetCache.add(featureFlag.name);
-
-      this.storage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
+      this.getFlagSetFromBatch(flagSetKey, batch).add(featureFlag.name);
     });
   }
 
-  private removeFromFlagSets(featureFlagName: string, flagSets?: string[] | null) {
-    if (!flagSets) return;
+  private removeFromFlagSets(featureFlagName: string, flagSets: string[] | null | undefined, batch: UpdateBatch) {
+    if (this.disableFlagSetCache || !flagSets) return;
 
     flagSets.forEach(flagSet => {
-      this.removeNames(flagSet, featureFlagName);
+      this.removeNames(flagSet, featureFlagName, batch);
     });
   }
 
-  private removeNames(flagSetName: string, featureFlagName: string) {
+  private removeNames(flagSetName: string, featureFlagName: string, batch: UpdateBatch) {
     const flagSetKey = this.keys.buildFlagSetKey(flagSetName);
 
-    const flagSetFromStorage = this.storage.getItem(flagSetKey);
+    // nothing to remove from a flag set that is neither in storage nor in the batch
+    if (!batch.flagSets.has(flagSetKey) && !this.storage.getItem(flagSetKey)) return;
 
-    if (!flagSetFromStorage) return;
-
-    const flagSetCache = new Set(JSON.parse(flagSetFromStorage));
-    flagSetCache.delete(featureFlagName);
+    this.getFlagSetFromBatch(flagSetKey, batch).delete(featureFlagName);
+  }
 
-    if (flagSetCache.size === 0) {
-      this.storage.removeItem(flagSetKey);
-      return;
+  /**
+   * Returns the flag names of the given flag set, reading from storage only the first time
+   */
+  private getFlagSetFromBatch(flagSetKey: string, batch: UpdateBatch): Set<string> {
+    let flagSetCache = batch.flagSets.get(flagSetKey);
+    if (!flagSetCache) {
+      const flagSetFromStorage = this.storage.getItem(flagSetKey);
+      flagSetCache = new Set(flagSetFromStorage ? JSON.parse(flagSetFromStorage) : []);
+      batch.flagSets.set(flagSetKey, flagSetCache);
     }
+    return flagSetCache;
+  }
+
+  private flushBatch(batch: UpdateBatch) {
+    // flush counts
+    batch.counts.forEach((diff, key) => {
+      try {
+        if (diff === 0) return;
+        const count = toNumber(this.storage.getItem(key)) + diff;
+        if (count > 0) this.storage.setItem(key, count + '');
+        else this.storage.removeItem(key);
+      } catch (e) {
+        this.log.error(LOG_PREFIX + e);
+      }
+    });
 
-    this.storage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
+    // flush flag sets
+    batch.flagSets.forEach((flagSetCache, flagSetKey) => {
+      try {
+        if (flagSetCache.size === 0) this.storage.removeItem(flagSetKey);
+        else this.storage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
+      } catch (e) {
+        this.log.error(LOG_PREFIX + e);
+      }
+    });
   }
 
 }

package/src/storages/inLocalStorage/index.ts

@@ -18,6 +18,8 @@ import { validateCache } from './validateCache';
 import { ILogger } from '../../logger/types';
 import SplitIO from '../../../types/splitio';
 import { storageAdapter } from './storageAdapter';
+import { isBoolean } from '../../utils/lang';
+import { ERROR_INVALID_CONFIG_PARAM } from '../../logger/constants';
 
 function validateStorage(log: ILogger, prefix: string, wrapper?: SplitIO.StorageWrapper): StorageAdapter | undefined {
   if (wrapper) {
@@ -50,7 +52,11 @@ export function InLocalStorage(options: SplitIO.InLocalStorageOptions = {}): ISt
     const matchingKey = getMatching(settings.core.key);
     const keys = new KeyBuilderCS(prefix, matchingKey);
 
-    const splits = new SplitsCacheInLocal(settings, keys, storage);
+    if (options.disableFlagSetCache !== undefined && !isBoolean(options.disableFlagSetCache)) {
+      log.error(ERROR_INVALID_CONFIG_PARAM, ['disableFlagSetCache', 'true, false', 'false']);
+    }
+
+    const splits = new SplitsCacheInLocal(settings, keys, storage, options.disableFlagSetCache === true);
     const rbSegments = new RBSegmentsCacheInLocal(settings, keys, storage);
     const segments = new MySegmentsCacheInLocal(log, keys, storage);
     const largeSegments = new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey), storage);

package/types/splitio.d.ts

@@ -1162,6 +1162,15 @@ declare namespace SplitIO {
      * @defaultValue `window.localStorage`
      */
     wrapper?: StorageWrapper;
+    /**
+     * If set to `true`, the SDK does not build the flag set index when it stores feature flag definitions, which speeds up the SDK initialization (SDK_READY event) and updates (SDK_UPDATE event).
+     *
+     * NOTE: when enabled, the `getTreatments(WithConfig)ByFlagSet(s)` methods return empty results.
+     * If you disable it afterwards, clear the cached data (e.g., with `storage.clearOnInit`) so the index is rebuilt.
+     *
+     * @defaultValue `false`
+     */
+    disableFlagSetCache?: boolean;
   }
   /**
    * Storage for asynchronous (consumer) SDK.
@@ -1542,6 +1551,15 @@ declare namespace SplitIO {
        * @defaultValue `window.localStorage`
        */
       wrapper?: StorageWrapper;
+      /**
+       * Optional settings for the 'LOCALSTORAGE' storage type. If set to `true`, the SDK does not build the flag set index when it stores feature flag definitions, which speeds up the SDK initialization (SDK_READY event) and updates (SDK_UPDATE event).
+       *
+       * NOTE: when enabled, the `getTreatments(WithConfig)ByFlagSet(s)` methods return empty results.
+       * If you disable it afterwards, clear the cached data (e.g., with `storage.clearOnInit`) so the index is rebuilt.
+       *
+       * @defaultValue `false`
+       */
+      disableFlagSetCache?: boolean;
     };
   }
   /**