@splitsoftware/splitio-commons 2.13.0 → 2.13.1

package/CHANGES.txt

@@ -1,3 +1,6 @@
+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 the time of cold initializations.
+
 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/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -6,6 +6,9 @@ var AbstractSplitsCacheSync_1 = require("../AbstractSplitsCacheSync");
 var lang_1 = require("../../utils/lang");
 var constants_1 = require("./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) {
@@ -16,38 +19,13 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         _this.storage = storage;
         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 +47,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) {
@@ -152,7 +167,7 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
             return new Set(flagSetFromStorage ? JSON.parse(flagSetFromStorage) : []);
         });
     };
-    SplitsCacheInLocal.prototype.addToFlagSets = function (featureFlag) {
+    SplitsCacheInLocal.prototype.addToFlagSets = function (featureFlag, batch) {
         var _this = this;
         if (!featureFlag.sets)
             return;
@@ -160,34 +175,65 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
             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)
             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/esm/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -3,6 +3,9 @@ import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSyn
 import { isFiniteNumber, toNumber, isNaNNumber } from '../../utils/lang';
 import { LOG_PREFIX } from './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) {
@@ -13,38 +16,13 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         _this.storage = storage;
         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 +44,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) {
@@ -149,7 +164,7 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
             return new Set(flagSetFromStorage ? JSON.parse(flagSetFromStorage) : []);
         });
     };
-    SplitsCacheInLocal.prototype.addToFlagSets = function (featureFlag) {
+    SplitsCacheInLocal.prototype.addToFlagSets = function (featureFlag, batch) {
         var _this = this;
         if (!featureFlag.sets)
             return;
@@ -157,34 +172,65 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
             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)
             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/package.json

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

package/src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -8,6 +8,18 @@ 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;
@@ -24,41 +36,15 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     this.storage = storage;
   }
 
-  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 _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);
-    }
+  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);
   }
 
-
   /**
    * 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 +65,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;
   }
@@ -184,7 +206,7 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     });
   }
 
-  private addToFlagSets(featureFlag: ISplit) {
+  private addToFlagSets(featureFlag: ISplit, batch: UpdateBatch) {
     if (!featureFlag.sets) return;
 
     featureFlag.sets.forEach(featureFlagSet => {
@@ -193,42 +215,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) {
+  private removeFromFlagSets(featureFlagName: string, flagSets: string[] | null | undefined, batch: UpdateBatch) {
     if (!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);
-
-    if (!flagSetFromStorage) return;
+    // 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;
 
-    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);
+      }
+    });
   }
 
 }