@splitsoftware/splitio-commons 2.4.2-rc.2 → 2.4.2-rc.3

package/cjs/storages/AbstractMySegmentsCacheSync.js

@@ -23,45 +23,37 @@ var AbstractMySegmentsCacheSync = /** @class */ (function () {
      */
     AbstractMySegmentsCacheSync.prototype.resetSegments = function (segmentsData) {
         var _this = this;
+        this.setChangeNumber(segmentsData.cn);
         var _a = segmentsData, added = _a.added, removed = _a.removed;
-        var isDiff = false;
         if (added && removed) {
+            var isDiff_1 = false;
             added.forEach(function (segment) {
-                isDiff = _this.addSegment(segment) || isDiff;
+                isDiff_1 = _this.addSegment(segment) || isDiff_1;
             });
             removed.forEach(function (segment) {
-                isDiff = _this.removeSegment(segment) || isDiff;
+                isDiff_1 = _this.removeSegment(segment) || isDiff_1;
             });
+            return isDiff_1;
         }
-        else {
-            var names = (segmentsData.k || []).map(function (s) { return s.n; }).sort();
-            var storedSegmentKeys = this.getRegisteredSegments().sort();
-            // Extreme fast => everything is empty
-            if (!names.length && !storedSegmentKeys.length) {
-                isDiff = false;
-            }
-            else {
-                var index = 0;
-                while (index < names.length && index < storedSegmentKeys.length && names[index] === storedSegmentKeys[index])
-                    index++;
-                // Quick path => no changes
-                if (index === names.length && index === storedSegmentKeys.length) {
-                    isDiff = false;
-                }
-                else {
-                    // Slowest path => add and/or remove segments
-                    for (var removeIndex = index; removeIndex < storedSegmentKeys.length; removeIndex++) {
-                        this.removeSegment(storedSegmentKeys[removeIndex]);
-                    }
-                    for (var addIndex = index; addIndex < names.length; addIndex++) {
-                        this.addSegment(names[addIndex]);
-                    }
-                    isDiff = true;
-                }
-            }
+        var names = (segmentsData.k || []).map(function (s) { return s.n; }).sort();
+        var storedSegmentKeys = this.getRegisteredSegments().sort();
+        // Extreme fast => everything is empty
+        if (!names.length && !storedSegmentKeys.length)
+            return false;
+        var index = 0;
+        while (index < names.length && index < storedSegmentKeys.length && names[index] === storedSegmentKeys[index])
+            index++;
+        // Quick path => no changes
+        if (index === names.length && index === storedSegmentKeys.length)
+            return false;
+        // Slowest path => add and/or remove segments
+        for (var removeIndex = index; removeIndex < storedSegmentKeys.length; removeIndex++) {
+            this.removeSegment(storedSegmentKeys[removeIndex]);
         }
-        this.setChangeNumber(segmentsData.cn);
-        return isDiff;
+        for (var addIndex = index; addIndex < names.length; addIndex++) {
+            this.addSegment(names[addIndex]);
+        }
+        return true;
     };
     return AbstractMySegmentsCacheSync;
 }());

package/cjs/storages/AbstractSplitsCacheSync.js

@@ -12,10 +12,9 @@ var AbstractSplitsCacheSync = /** @class */ (function () {
     }
     AbstractSplitsCacheSync.prototype.update = function (toAdd, toRemove, changeNumber) {
         var _this = this;
-        var updated = toAdd.map(function (addedFF) { return _this.addSplit(addedFF); }).some(function (result) { return result; });
-        updated = toRemove.map(function (removedFF) { return _this.removeSplit(removedFF.name); }).some(function (result) { return result; }) || updated;
         this.setChangeNumber(changeNumber);
-        return updated;
+        var updated = toAdd.map(function (addedFF) { return _this.addSplit(addedFF); }).some(function (result) { return result; });
+        return toRemove.map(function (removedFF) { return _this.removeSplit(removedFF.name); }).some(function (result) { return result; }) || updated;
     };
     AbstractSplitsCacheSync.prototype.getSplits = function (names) {
         var _this = this;

package/cjs/storages/inLocalStorage/MySegmentsCacheInLocal.js

@@ -46,7 +46,7 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
     };
     MySegmentsCacheInLocal.prototype.getRegisteredSegments = function () {
         var registeredSegments = [];
-        for (var i = 0; i < this.storage.length; i++) {
+        for (var i = 0, len = this.storage.length; i < len; i++) {
             var segmentName = this.keys.extractSegmentName(this.storage.key(i));
             if (segmentName)
                 registeredSegments.push(segmentName);

package/cjs/storages/inLocalStorage/RBSegmentsCacheInLocal.js

@@ -18,10 +18,9 @@ var RBSegmentsCacheInLocal = /** @class */ (function () {
     };
     RBSegmentsCacheInLocal.prototype.update = function (toAdd, toRemove, changeNumber) {
         var _this = this;
-        var updated = toAdd.map(function (toAdd) { return _this.add(toAdd); }).some(function (result) { return result; });
-        updated = toRemove.map(function (toRemove) { return _this.remove(toRemove.name); }).some(function (result) { return result; }) || updated;
         this.setChangeNumber(changeNumber);
-        return updated;
+        var updated = toAdd.map(function (toAdd) { return _this.add(toAdd); }).some(function (result) { return result; });
+        return toRemove.map(function (toRemove) { return _this.remove(toRemove.name); }).some(function (result) { return result; }) || updated;
     };
     RBSegmentsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
         try {

package/cjs/storages/inLocalStorage/index.js

@@ -62,9 +62,12 @@ function InLocalStorage(options) {
             validateCache: function () {
                 return validateCachePromise || (validateCachePromise = (0, validateCache_1.validateCache)(options, storage, settings, keys, splits, rbSegments, segments, largeSegments));
             },
-            destroy: function () {
+            save: function () {
                 return storage.save && storage.save();
             },
+            destroy: function () {
+                return storage.whenSaved && storage.whenSaved();
+            },
             // When using shared instantiation with MEMORY we reuse everything but segments (they are customer per key).
             shared: function (matchingKey) {
                 return {

package/cjs/storages/inLocalStorage/storageAdapter.js

@@ -2,46 +2,52 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.storageAdapter = void 0;
 var constants_1 = require("./constants");
-function isTillKey(key) {
-    return key.endsWith('.till');
-}
 function storageAdapter(log, prefix, wrapper) {
+    var keys = [];
     var cache = {};
-    var connectPromise;
-    var disconnectPromise = Promise.resolve();
+    var loadPromise;
+    var savePromise = Promise.resolve();
     return {
         load: function () {
-            return connectPromise || (connectPromise = Promise.resolve(wrapper.getItem(prefix)).then(function (storedCache) {
+            return loadPromise || (loadPromise = Promise.resolve().then(function () {
+                return wrapper.getItem(prefix);
+            }).then(function (storedCache) {
                 cache = JSON.parse(storedCache || '{}');
+                keys = Object.keys(cache);
             }).catch(function (e) {
-                log.error(constants_1.LOG_PREFIX + 'Rejected promise calling storage getItem, with error: ' + e);
+                log.error(constants_1.LOG_PREFIX + 'Rejected promise calling wrapper `getItem` method, with error: ' + e);
             }));
         },
         save: function () {
-            return disconnectPromise = disconnectPromise.then(function () {
-                return Promise.resolve(wrapper.setItem(prefix, JSON.stringify(cache))).catch(function (e) {
-                    log.error(constants_1.LOG_PREFIX + 'Rejected promise calling storage setItem, with error: ' + e);
-                });
+            return savePromise = savePromise.then(function () {
+                return Promise.resolve(wrapper.setItem(prefix, JSON.stringify(cache)));
+            }).catch(function (e) {
+                log.error(constants_1.LOG_PREFIX + 'Rejected promise calling wrapper `setItem` method, with error: ' + e);
             });
         },
+        whenSaved: function () {
+            return savePromise;
+        },
         get length() {
-            return Object.keys(cache).length;
+            return keys.length;
         },
         getItem: function (key) {
             return cache[key] || null;
         },
         key: function (index) {
-            return Object.keys(cache)[index] || null;
+            return keys[index] || null;
         },
         removeItem: function (key) {
+            var index = keys.indexOf(key);
+            if (index === -1)
+                return;
+            keys.splice(index, 1);
             delete cache[key];
-            if (isTillKey(key))
-                this.save();
         },
         setItem: function (key, value) {
+            if (keys.indexOf(key) === -1)
+                keys.push(key);
             cache[key] = value;
-            if (isTillKey(key))
-                this.save();
         }
     };
 }

package/cjs/storages/inLocalStorage/validateCache.js

@@ -73,6 +73,9 @@ function validateCache(options, storage, settings, keys, splits, rbSegments, seg
             catch (e) {
                 settings.log.error(constants_1.LOG_PREFIX + e);
             }
+            // Persist clear
+            if (storage.save)
+                storage.save();
             return false;
         }
         // Check if ready from cache

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

@@ -34,6 +34,8 @@ function mySegmentsUpdaterFactory(log, mySegmentsFetcher, storage, segmentsEvent
             shouldNotifyUpdate = segments.resetSegments(segmentsData.ms || {});
             shouldNotifyUpdate = largeSegments.resetSegments(segmentsData.ls || {}) || shouldNotifyUpdate;
         }
+        if (storage.save)
+            storage.save();
         // Notify update if required
         if ((0, AbstractSplitsCacheSync_1.usesSegmentsSync)(storage) && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
             readyOnAlreadyExistentState = false;

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

@@ -154,6 +154,8 @@ function splitChangesUpdaterFactory(log, splitChangesFetcher, storage, splitFilt
                     segments.registerSegments((0, sets_1.setToArray)(usedSegments))
                 ]).then(function (_a) {
                     var ffChanged = _a[0], rbsChanged = _a[1];
+                    if (storage.save)
+                        storage.save();
                     if (splitsEventEmitter) {
                         // To emit SDK_SPLITS_ARRIVED for server-side SDK, we must check that all registered segments have been fetched
                         return Promise.resolve(!splitsEventEmitter.splitsArrived || ((ffChanged || rbsChanged) && (isClientSide || checkAllSegmentsExist(segments))))

package/esm/storages/AbstractMySegmentsCacheSync.js

@@ -20,45 +20,37 @@ var AbstractMySegmentsCacheSync = /** @class */ (function () {
      */
     AbstractMySegmentsCacheSync.prototype.resetSegments = function (segmentsData) {
         var _this = this;
+        this.setChangeNumber(segmentsData.cn);
         var _a = segmentsData, added = _a.added, removed = _a.removed;
-        var isDiff = false;
         if (added && removed) {
+            var isDiff_1 = false;
             added.forEach(function (segment) {
-                isDiff = _this.addSegment(segment) || isDiff;
+                isDiff_1 = _this.addSegment(segment) || isDiff_1;
             });
             removed.forEach(function (segment) {
-                isDiff = _this.removeSegment(segment) || isDiff;
+                isDiff_1 = _this.removeSegment(segment) || isDiff_1;
             });
+            return isDiff_1;
         }
-        else {
-            var names = (segmentsData.k || []).map(function (s) { return s.n; }).sort();
-            var storedSegmentKeys = this.getRegisteredSegments().sort();
-            // Extreme fast => everything is empty
-            if (!names.length && !storedSegmentKeys.length) {
-                isDiff = false;
-            }
-            else {
-                var index = 0;
-                while (index < names.length && index < storedSegmentKeys.length && names[index] === storedSegmentKeys[index])
-                    index++;
-                // Quick path => no changes
-                if (index === names.length && index === storedSegmentKeys.length) {
-                    isDiff = false;
-                }
-                else {
-                    // Slowest path => add and/or remove segments
-                    for (var removeIndex = index; removeIndex < storedSegmentKeys.length; removeIndex++) {
-                        this.removeSegment(storedSegmentKeys[removeIndex]);
-                    }
-                    for (var addIndex = index; addIndex < names.length; addIndex++) {
-                        this.addSegment(names[addIndex]);
-                    }
-                    isDiff = true;
-                }
-            }
+        var names = (segmentsData.k || []).map(function (s) { return s.n; }).sort();
+        var storedSegmentKeys = this.getRegisteredSegments().sort();
+        // Extreme fast => everything is empty
+        if (!names.length && !storedSegmentKeys.length)
+            return false;
+        var index = 0;
+        while (index < names.length && index < storedSegmentKeys.length && names[index] === storedSegmentKeys[index])
+            index++;
+        // Quick path => no changes
+        if (index === names.length && index === storedSegmentKeys.length)
+            return false;
+        // Slowest path => add and/or remove segments
+        for (var removeIndex = index; removeIndex < storedSegmentKeys.length; removeIndex++) {
+            this.removeSegment(storedSegmentKeys[removeIndex]);
         }
-        this.setChangeNumber(segmentsData.cn);
-        return isDiff;
+        for (var addIndex = index; addIndex < names.length; addIndex++) {
+            this.addSegment(names[addIndex]);
+        }
+        return true;
     };
     return AbstractMySegmentsCacheSync;
 }());

package/esm/storages/AbstractSplitsCacheSync.js

@@ -9,10 +9,9 @@ var AbstractSplitsCacheSync = /** @class */ (function () {
     }
     AbstractSplitsCacheSync.prototype.update = function (toAdd, toRemove, changeNumber) {
         var _this = this;
-        var updated = toAdd.map(function (addedFF) { return _this.addSplit(addedFF); }).some(function (result) { return result; });
-        updated = toRemove.map(function (removedFF) { return _this.removeSplit(removedFF.name); }).some(function (result) { return result; }) || updated;
         this.setChangeNumber(changeNumber);
-        return updated;
+        var updated = toAdd.map(function (addedFF) { return _this.addSplit(addedFF); }).some(function (result) { return result; });
+        return toRemove.map(function (removedFF) { return _this.removeSplit(removedFF.name); }).some(function (result) { return result; }) || updated;
     };
     AbstractSplitsCacheSync.prototype.getSplits = function (names) {
         var _this = this;

package/esm/storages/inLocalStorage/MySegmentsCacheInLocal.js

@@ -43,7 +43,7 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
     };
     MySegmentsCacheInLocal.prototype.getRegisteredSegments = function () {
         var registeredSegments = [];
-        for (var i = 0; i < this.storage.length; i++) {
+        for (var i = 0, len = this.storage.length; i < len; i++) {
             var segmentName = this.keys.extractSegmentName(this.storage.key(i));
             if (segmentName)
                 registeredSegments.push(segmentName);

package/esm/storages/inLocalStorage/RBSegmentsCacheInLocal.js

@@ -15,10 +15,9 @@ var RBSegmentsCacheInLocal = /** @class */ (function () {
     };
     RBSegmentsCacheInLocal.prototype.update = function (toAdd, toRemove, changeNumber) {
         var _this = this;
-        var updated = toAdd.map(function (toAdd) { return _this.add(toAdd); }).some(function (result) { return result; });
-        updated = toRemove.map(function (toRemove) { return _this.remove(toRemove.name); }).some(function (result) { return result; }) || updated;
         this.setChangeNumber(changeNumber);
-        return updated;
+        var updated = toAdd.map(function (toAdd) { return _this.add(toAdd); }).some(function (result) { return result; });
+        return toRemove.map(function (toRemove) { return _this.remove(toRemove.name); }).some(function (result) { return result; }) || updated;
     };
     RBSegmentsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
         try {

package/esm/storages/inLocalStorage/index.js

@@ -59,9 +59,12 @@ export function InLocalStorage(options) {
             validateCache: function () {
                 return validateCachePromise || (validateCachePromise = validateCache(options, storage, settings, keys, splits, rbSegments, segments, largeSegments));
             },
-            destroy: function () {
+            save: function () {
                 return storage.save && storage.save();
             },
+            destroy: function () {
+                return storage.whenSaved && storage.whenSaved();
+            },
             // When using shared instantiation with MEMORY we reuse everything but segments (they are customer per key).
             shared: function (matchingKey) {
                 return {

package/esm/storages/inLocalStorage/storageAdapter.js

@@ -1,44 +1,50 @@
 import { LOG_PREFIX } from './constants';
-function isTillKey(key) {
-    return key.endsWith('.till');
-}
 export function storageAdapter(log, prefix, wrapper) {
+    var keys = [];
     var cache = {};
-    var connectPromise;
-    var disconnectPromise = Promise.resolve();
+    var loadPromise;
+    var savePromise = Promise.resolve();
     return {
         load: function () {
-            return connectPromise || (connectPromise = Promise.resolve(wrapper.getItem(prefix)).then(function (storedCache) {
+            return loadPromise || (loadPromise = Promise.resolve().then(function () {
+                return wrapper.getItem(prefix);
+            }).then(function (storedCache) {
                 cache = JSON.parse(storedCache || '{}');
+                keys = Object.keys(cache);
             }).catch(function (e) {
-                log.error(LOG_PREFIX + 'Rejected promise calling storage getItem, with error: ' + e);
+                log.error(LOG_PREFIX + 'Rejected promise calling wrapper `getItem` method, with error: ' + e);
             }));
         },
         save: function () {
-            return disconnectPromise = disconnectPromise.then(function () {
-                return Promise.resolve(wrapper.setItem(prefix, JSON.stringify(cache))).catch(function (e) {
-                    log.error(LOG_PREFIX + 'Rejected promise calling storage setItem, with error: ' + e);
-                });
+            return savePromise = savePromise.then(function () {
+                return Promise.resolve(wrapper.setItem(prefix, JSON.stringify(cache)));
+            }).catch(function (e) {
+                log.error(LOG_PREFIX + 'Rejected promise calling wrapper `setItem` method, with error: ' + e);
             });
         },
+        whenSaved: function () {
+            return savePromise;
+        },
         get length() {
-            return Object.keys(cache).length;
+            return keys.length;
         },
         getItem: function (key) {
             return cache[key] || null;
         },
         key: function (index) {
-            return Object.keys(cache)[index] || null;
+            return keys[index] || null;
         },
         removeItem: function (key) {
+            var index = keys.indexOf(key);
+            if (index === -1)
+                return;
+            keys.splice(index, 1);
             delete cache[key];
-            if (isTillKey(key))
-                this.save();
         },
         setItem: function (key, value) {
+            if (keys.indexOf(key) === -1)
+                keys.push(key);
             cache[key] = value;
-            if (isTillKey(key))
-                this.save();
         }
     };
 }

package/esm/storages/inLocalStorage/validateCache.js

@@ -70,6 +70,9 @@ export function validateCache(options, storage, settings, keys, splits, rbSegmen
             catch (e) {
                 settings.log.error(LOG_PREFIX + e);
             }
+            // Persist clear
+            if (storage.save)
+                storage.save();
             return false;
         }
         // Check if ready from cache

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

@@ -31,6 +31,8 @@ export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, storage, segmen
             shouldNotifyUpdate = segments.resetSegments(segmentsData.ms || {});
             shouldNotifyUpdate = largeSegments.resetSegments(segmentsData.ls || {}) || shouldNotifyUpdate;
         }
+        if (storage.save)
+            storage.save();
         // Notify update if required
         if (usesSegmentsSync(storage) && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
             readyOnAlreadyExistentState = false;

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

@@ -149,6 +149,8 @@ export function splitChangesUpdaterFactory(log, splitChangesFetcher, storage, sp
                     segments.registerSegments(setToArray(usedSegments))
                 ]).then(function (_a) {
                     var ffChanged = _a[0], rbsChanged = _a[1];
+                    if (storage.save)
+                        storage.save();
                     if (splitsEventEmitter) {
                         // To emit SDK_SPLITS_ARRIVED for server-side SDK, we must check that all registered segments have been fetched
                         return Promise.resolve(!splitsEventEmitter.splitsArrived || ((ffChanged || rbsChanged) && (isClientSide || checkAllSegmentsExist(segments))))

package/package.json

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

package/src/storages/AbstractMySegmentsCacheSync.ts

@@ -49,10 +49,12 @@ export abstract class AbstractMySegmentsCacheSync implements ISegmentsCacheSync
    * For client-side synchronizer: it resets or updates the cache.
    */
   resetSegments(segmentsData: MySegmentsData | IMySegmentsResponse): boolean {
+    this.setChangeNumber(segmentsData.cn);
+
     const { added, removed } = segmentsData as MySegmentsData;
-    let isDiff = false;
 
     if (added && removed) {
+      let isDiff = false;
 
       added.forEach(segment => {
         isDiff = this.addSegment(segment) || isDiff;
@@ -61,40 +63,32 @@ export abstract class AbstractMySegmentsCacheSync implements ISegmentsCacheSync
       removed.forEach(segment => {
         isDiff = this.removeSegment(segment) || isDiff;
       });
-    } else {
 
-      const names = ((segmentsData as IMySegmentsResponse).k || []).map(s => s.n).sort();
-      const storedSegmentKeys = this.getRegisteredSegments().sort();
+      return isDiff;
+    }
 
-      // Extreme fast => everything is empty
-      if (!names.length && !storedSegmentKeys.length) {
-        isDiff = false;
-      } else {
+    const names = ((segmentsData as IMySegmentsResponse).k || []).map(s => s.n).sort();
+    const storedSegmentKeys = this.getRegisteredSegments().sort();
 
-        let index = 0;
+    // Extreme fast => everything is empty
+    if (!names.length && !storedSegmentKeys.length) return false;
 
-        while (index < names.length && index < storedSegmentKeys.length && names[index] === storedSegmentKeys[index]) index++;
+    let index = 0;
 
-        // Quick path => no changes
-        if (index === names.length && index === storedSegmentKeys.length) {
-          isDiff = false;
-        } else {
+    while (index < names.length && index < storedSegmentKeys.length && names[index] === storedSegmentKeys[index]) index++;
 
-          // Slowest path => add and/or remove segments
-          for (let removeIndex = index; removeIndex < storedSegmentKeys.length; removeIndex++) {
-            this.removeSegment(storedSegmentKeys[removeIndex]);
-          }
+    // Quick path => no changes
+    if (index === names.length && index === storedSegmentKeys.length) return false;
 
-          for (let addIndex = index; addIndex < names.length; addIndex++) {
-            this.addSegment(names[addIndex]);
-          }
+    // Slowest path => add and/or remove segments
+    for (let removeIndex = index; removeIndex < storedSegmentKeys.length; removeIndex++) {
+      this.removeSegment(storedSegmentKeys[removeIndex]);
+    }
 
-          isDiff = true;
-        }
-      }
+    for (let addIndex = index; addIndex < names.length; addIndex++) {
+      this.addSegment(names[addIndex]);
     }
 
-    this.setChangeNumber(segmentsData.cn);
-    return isDiff;
+    return true;
   }
 }

package/src/storages/AbstractSplitsCacheSync.ts

@@ -14,10 +14,9 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
   protected abstract setChangeNumber(changeNumber: number): boolean | void
 
   update(toAdd: ISplit[], toRemove: ISplit[], changeNumber: number): boolean {
-    let updated = toAdd.map(addedFF => this.addSplit(addedFF)).some(result => result);
-    updated = toRemove.map(removedFF => this.removeSplit(removedFF.name)).some(result => result) || updated;
     this.setChangeNumber(changeNumber);
-    return updated;
+    const updated = toAdd.map(addedFF => this.addSplit(addedFF)).some(result => result);
+    return toRemove.map(removedFF => this.removeSplit(removedFF.name)).some(result => result) || updated;
   }
 
   abstract getSplit(name: string): ISplit | null

package/src/storages/inLocalStorage/MySegmentsCacheInLocal.ts

@@ -51,7 +51,7 @@ export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
 
   getRegisteredSegments(): string[] {
     const registeredSegments: string[] = [];
-    for (let i = 0; i < this.storage.length; i++) {
+    for (let i = 0, len = this.storage.length; i < len; i++) {
       const segmentName = this.keys.extractSegmentName(this.storage.key(i)!);
       if (segmentName) registeredSegments.push(segmentName);
     }

package/src/storages/inLocalStorage/RBSegmentsCacheInLocal.ts

@@ -26,10 +26,9 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
   }
 
   update(toAdd: IRBSegment[], toRemove: IRBSegment[], changeNumber: number): boolean {
-    let updated = toAdd.map(toAdd => this.add(toAdd)).some(result => result);
-    updated = toRemove.map(toRemove => this.remove(toRemove.name)).some(result => result) || updated;
     this.setChangeNumber(changeNumber);
-    return updated;
+    const updated = toAdd.map(toAdd => this.add(toAdd)).some(result => result);
+    return toRemove.map(toRemove => this.remove(toRemove.name)).some(result => result) || updated;
   }
 
   private setChangeNumber(changeNumber: number) {

package/src/storages/inLocalStorage/index.ts

@@ -19,7 +19,7 @@ import { ILogger } from '../../logger/types';
 import SplitIO from '../../../types/splitio';
 import { storageAdapter } from './storageAdapter';
 
-function validateStorage(log: ILogger, prefix: string, wrapper?: SplitIO.StorageWrapper): StorageAdapter | undefined {
+function validateStorage(log: ILogger, prefix: string, wrapper?: SplitIO.SyncStorageWrapper | SplitIO.AsyncStorageWrapper): StorageAdapter | undefined {
   if (wrapper) {
     if (isValidStorageWrapper(wrapper)) {
       return isWebStorage(wrapper) ?
@@ -71,10 +71,14 @@ export function InLocalStorage(options: SplitIO.InLocalStorageOptions = {}): ISt
         return validateCachePromise || (validateCachePromise = validateCache(options, storage, settings, keys, splits, rbSegments, segments, largeSegments));
       },
 
-      destroy() {
+      save() {
         return storage.save && storage.save();
       },
 
+      destroy() {
+        return storage.whenSaved && storage.whenSaved();
+      },
+
       // When using shared instantiation with MEMORY we reuse everything but segments (they are customer per key).
       shared(matchingKey: string) {
 

package/src/storages/inLocalStorage/storageAdapter.ts

@@ -3,48 +3,60 @@ import SplitIO from '../../../types/splitio';
 import { LOG_PREFIX } from './constants';
 import { StorageAdapter } from '../types';
 
-function isTillKey(key: string) {
-  return key.endsWith('.till');
-}
 
-export function storageAdapter(log: ILogger, prefix: string, wrapper: SplitIO.StorageWrapper): StorageAdapter {
+export function storageAdapter(log: ILogger, prefix: string, wrapper: SplitIO.SyncStorageWrapper | SplitIO.AsyncStorageWrapper): Required<StorageAdapter> {
+  let keys: string[] = [];
   let cache: Record<string, string> = {};
 
-  let connectPromise: Promise<void> | undefined;
-  let disconnectPromise = Promise.resolve();
+  let loadPromise: Promise<void> | undefined;
+  let savePromise = Promise.resolve();
 
   return {
     load() {
-      return connectPromise || (connectPromise = Promise.resolve(wrapper.getItem(prefix)).then((storedCache) => {
+      return loadPromise || (loadPromise = Promise.resolve().then(() => {
+        return wrapper.getItem(prefix);
+      }).then((storedCache) => {
         cache = JSON.parse(storedCache || '{}');
+        keys = Object.keys(cache);
       }).catch((e) => {
-        log.error(LOG_PREFIX + 'Rejected promise calling storage getItem, with error: ' + e);
+        log.error(LOG_PREFIX + 'Rejected promise calling wrapper `getItem` method, with error: ' + e);
       }));
     },
+
     save() {
-      return disconnectPromise = disconnectPromise.then(() => {
-        return Promise.resolve(wrapper.setItem(prefix, JSON.stringify(cache))).catch((e) => {
-          log.error(LOG_PREFIX + 'Rejected promise calling storage setItem, with error: ' + e);
-        });
+      return savePromise = savePromise.then(() => {
+        return Promise.resolve(wrapper.setItem(prefix, JSON.stringify(cache)));
+      }).catch((e) => {
+        log.error(LOG_PREFIX + 'Rejected promise calling wrapper `setItem` method, with error: ' + e);
       });
     },
 
+    whenSaved() {
+      return savePromise;
+    },
+
     get length() {
-      return Object.keys(cache).length;
+      return keys.length;
     },
+
     getItem(key: string) {
       return cache[key] || null;
     },
+
     key(index: number) {
-      return Object.keys(cache)[index] || null;
+      return keys[index] || null;
     },
+
     removeItem(key: string) {
+      const index = keys.indexOf(key);
+      if (index === -1) return;
+      keys.splice(index, 1);
       delete cache[key];
-      if (isTillKey(key)) this.save!();
     },
+
     setItem(key: string, value: string) {
+      if (keys.indexOf(key) === -1) keys.push(key);
       cache[key] = value;
-      if (isTillKey(key)) this.save!();
     }
   };
 }

package/src/storages/inLocalStorage/validateCache.ts

@@ -87,6 +87,9 @@ export function validateCache(options: SplitIO.InLocalStorageOptions, storage: S
         settings.log.error(LOG_PREFIX + e);
       }
 
+      // Persist clear
+      if (storage.save) storage.save();
+
       return false;
     }
 

package/src/storages/types.ts

@@ -12,10 +12,11 @@ export interface StorageAdapter {
   // Methods to support async storages
   load?: () => Promise<void>;
   save?: () => Promise<void>;
+  whenSaved?: () => Promise<void>;
   // Methods based on https://developer.mozilla.org/en-US/docs/Web/API/Storage
   readonly length: number;
-  getItem(key: string): string | null;
   key(index: number): string | null;
+  getItem(key: string): string | null;
   removeItem(key: string): void;
   setItem(key: string, value: string): void;
 }
@@ -482,6 +483,7 @@ export interface IStorageBase<
   uniqueKeys: TUniqueKeysCache,
   destroy(): void | Promise<void>,
   shared?: (matchingKey: string, onReadyCb: (error?: any) => void) => this
+  save?: () => void | Promise<void>,
 }
 
 export interface IStorageSync extends IStorageBase<

package/src/sync/polling/updaters/mySegmentsUpdater.ts

@@ -51,6 +51,8 @@ export function mySegmentsUpdaterFactory(
       shouldNotifyUpdate = largeSegments!.resetSegments((segmentsData as IMembershipsResponse).ls || {}) || shouldNotifyUpdate;
     }
 
+    if (storage.save) storage.save();
+
     // Notify update if required
     if (usesSegmentsSync(storage) && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
       readyOnAlreadyExistentState = false;

package/src/sync/polling/updaters/splitChangesUpdater.ts

@@ -117,7 +117,7 @@ export function computeMutation<T extends ISplit | IRBSegment>(rules: Array<T>,
 export function splitChangesUpdaterFactory(
   log: ILogger,
   splitChangesFetcher: ISplitChangesFetcher,
-  storage: Pick<IStorageBase, 'splits' | 'rbSegments' | 'segments'>,
+  storage: Pick<IStorageBase, 'splits' | 'rbSegments' | 'segments' | 'save'>,
   splitFiltersValidation: ISplitFiltersValidation,
   splitsEventEmitter?: ISplitsEventEmitter,
   requestTimeoutBeforeReady: number = 0,
@@ -185,6 +185,8 @@ export function splitChangesUpdaterFactory(
             // @TODO if at least 1 segment fetch fails due to 404 and other segments are updated in the storage, SDK_UPDATE is not emitted
             segments.registerSegments(setToArray(usedSegments))
           ]).then(([ffChanged, rbsChanged]) => {
+            if (storage.save) storage.save();
+
             if (splitsEventEmitter) {
               // To emit SDK_SPLITS_ARRIVED for server-side SDK, we must check that all registered segments have been fetched
               return Promise.resolve(!splitsEventEmitter.splitsArrived || ((ffChanged || rbsChanged) && (isClientSide || checkAllSegmentsExist(segments))))

package/types/splitio.d.ts

@@ -458,19 +458,34 @@ interface IClientSideSyncSharedSettings extends IClientSideSharedSettings, ISync
  */
 declare namespace SplitIO {
 
-  interface StorageWrapper {
+  interface SyncStorageWrapper {
     /**
-     * Returns a promise that resolves to the current value associated with the given key, or null if the given key does not exist.
+     * Returns the value associated with the given key, or null if the key does not exist.
      */
-    getItem(key: string): Promise<string | null> | string | null;
+    getItem(key: string): string | null;
     /**
-     * Returns a promise that resolves when the value of the pair identified by key is set to value, creating a new key/value pair if none existed for key previously.
+     * Sets the value for the given key, creating a new key/value pair if key does not exist.
      */
-    setItem(key: string, value: string): Promise<void> | void;
+    setItem(key: string, value: string): void;
     /**
-     * Returns a promise that resolves when the key/value pair with the given key is removed, if a key/value pair with the given key exists.
+     * Removes the key/value pair for the given key, if the key exists.
      */
-    removeItem(key: string): Promise<void> | void;
+    removeItem(key: string): void;
+  }
+
+  interface AsyncStorageWrapper {
+    /**
+     * Returns a promise that resolves to the value associated with the given key, or null if the key does not exist.
+     */
+    getItem(key: string): Promise<string | null>;
+    /**
+     * Returns a promise that resolves when the value of the pair identified by key is set to value, creating a new key/value pair if key does not exist.
+     */
+    setItem(key: string, value: string): Promise<void>;
+    /**
+     * Returns a promise that resolves when the key/value pair for the given key is removed, if the key exists.
+     */
+    removeItem(key: string): Promise<void>;
   }
 
   /**
@@ -992,7 +1007,7 @@ declare namespace SplitIO {
      *
      * @defaultValue `window.localStorage`
      */
-    wrapper?: StorageWrapper;
+    wrapper?: SyncStorageWrapper | AsyncStorageWrapper;
   }
   /**
    * Storage for asynchronous (consumer) SDK.
@@ -1338,7 +1353,7 @@ declare namespace SplitIO {
        *
        * @defaultValue `window.localStorage`
        */
-      wrapper?: StorageWrapper;
+      wrapper?: SyncStorageWrapper | AsyncStorageWrapper;
     };
   }
   /**