@splitsoftware/splitio-commons 2.4.2-rc.3 → 2.5.0-rc.1

package/esm/storages/inLocalStorage/MySegmentsCacheInLocal.js

@@ -4,20 +4,19 @@ import { AbstractMySegmentsCacheSync } from '../AbstractMySegmentsCacheSync';
 import { LOG_PREFIX, DEFINED } from './constants';
 var MySegmentsCacheInLocal = /** @class */ (function (_super) {
     __extends(MySegmentsCacheInLocal, _super);
-    function MySegmentsCacheInLocal(log, keys, storage) {
+    function MySegmentsCacheInLocal(log, keys) {
         var _this = _super.call(this) || this;
         _this.log = log;
         _this.keys = keys;
-        _this.storage = storage;
         return _this;
         // There is not need to flush segments cache like splits cache, since resetSegments receives the up-to-date list of active segments
     }
     MySegmentsCacheInLocal.prototype.addSegment = function (name) {
         var segmentKey = this.keys.buildSegmentNameKey(name);
         try {
-            if (this.storage.getItem(segmentKey) === DEFINED)
+            if (localStorage.getItem(segmentKey) === DEFINED)
                 return false;
-            this.storage.setItem(segmentKey, DEFINED);
+            localStorage.setItem(segmentKey, DEFINED);
             return true;
         }
         catch (e) {
@@ -28,9 +27,9 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
     MySegmentsCacheInLocal.prototype.removeSegment = function (name) {
         var segmentKey = this.keys.buildSegmentNameKey(name);
         try {
-            if (this.storage.getItem(segmentKey) !== DEFINED)
+            if (localStorage.getItem(segmentKey) !== DEFINED)
                 return false;
-            this.storage.removeItem(segmentKey);
+            localStorage.removeItem(segmentKey);
             return true;
         }
         catch (e) {
@@ -39,16 +38,17 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
         }
     };
     MySegmentsCacheInLocal.prototype.isInSegment = function (name) {
-        return this.storage.getItem(this.keys.buildSegmentNameKey(name)) === DEFINED;
+        return localStorage.getItem(this.keys.buildSegmentNameKey(name)) === DEFINED;
     };
     MySegmentsCacheInLocal.prototype.getRegisteredSegments = function () {
-        var registeredSegments = [];
-        for (var i = 0, len = this.storage.length; i < len; i++) {
-            var segmentName = this.keys.extractSegmentName(this.storage.key(i));
+        var _this = this;
+        // Scan current values from localStorage
+        return Object.keys(localStorage).reduce(function (accum, key) {
+            var segmentName = _this.keys.extractSegmentName(key);
             if (segmentName)
-                registeredSegments.push(segmentName);
-        }
-        return registeredSegments;
+                accum.push(segmentName);
+            return accum;
+        }, []);
     };
     MySegmentsCacheInLocal.prototype.getKeysCount = function () {
         return 1;
@@ -56,9 +56,9 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
     MySegmentsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
         try {
             if (changeNumber)
-                this.storage.setItem(this.keys.buildTillKey(), changeNumber + '');
+                localStorage.setItem(this.keys.buildTillKey(), changeNumber + '');
             else
-                this.storage.removeItem(this.keys.buildTillKey());
+                localStorage.removeItem(this.keys.buildTillKey());
         }
         catch (e) {
             this.log.error(e);
@@ -66,7 +66,7 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
     };
     MySegmentsCacheInLocal.prototype.getChangeNumber = function () {
         var n = -1;
-        var value = this.storage.getItem(this.keys.buildTillKey());
+        var value = localStorage.getItem(this.keys.buildTillKey());
         if (value !== null) {
             value = parseInt(value, 10);
             return isNaNNumber(value) ? n : value;

package/esm/storages/inLocalStorage/RBSegmentsCacheInLocal.js

@@ -3,15 +3,14 @@ import { setToArray } from '../../utils/lang/sets';
 import { usesSegments } from '../AbstractSplitsCacheSync';
 import { LOG_PREFIX } from './constants';
 var RBSegmentsCacheInLocal = /** @class */ (function () {
-    function RBSegmentsCacheInLocal(settings, keys, storage) {
+    function RBSegmentsCacheInLocal(settings, keys) {
         this.keys = keys;
         this.log = settings.log;
-        this.storage = storage;
     }
     RBSegmentsCacheInLocal.prototype.clear = function () {
         var _this = this;
         this.getNames().forEach(function (name) { return _this.remove(name); });
-        this.storage.removeItem(this.keys.buildRBSegmentsTillKey());
+        localStorage.removeItem(this.keys.buildRBSegmentsTillKey());
     };
     RBSegmentsCacheInLocal.prototype.update = function (toAdd, toRemove, changeNumber) {
         var _this = this;
@@ -21,8 +20,8 @@ var RBSegmentsCacheInLocal = /** @class */ (function () {
     };
     RBSegmentsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
         try {
-            this.storage.setItem(this.keys.buildRBSegmentsTillKey(), changeNumber + '');
-            this.storage.setItem(this.keys.buildLastUpdatedKey(), Date.now() + '');
+            localStorage.setItem(this.keys.buildRBSegmentsTillKey(), changeNumber + '');
+            localStorage.setItem(this.keys.buildLastUpdatedKey(), Date.now() + '');
         }
         catch (e) {
             this.log.error(LOG_PREFIX + e);
@@ -30,19 +29,20 @@ var RBSegmentsCacheInLocal = /** @class */ (function () {
     };
     RBSegmentsCacheInLocal.prototype.updateSegmentCount = function (diff) {
         var segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
-        var count = toNumber(this.storage.getItem(segmentsCountKey)) + diff;
+        var count = toNumber(localStorage.getItem(segmentsCountKey)) + diff;
+        // @ts-expect-error
         if (count > 0)
-            this.storage.setItem(segmentsCountKey, count + '');
+            localStorage.setItem(segmentsCountKey, count);
         else
-            this.storage.removeItem(segmentsCountKey);
+            localStorage.removeItem(segmentsCountKey);
     };
     RBSegmentsCacheInLocal.prototype.add = function (rbSegment) {
         try {
             var name_1 = rbSegment.name;
             var rbSegmentKey = this.keys.buildRBSegmentKey(name_1);
-            var rbSegmentFromStorage = this.storage.getItem(rbSegmentKey);
-            var previous = rbSegmentFromStorage ? JSON.parse(rbSegmentFromStorage) : null;
-            this.storage.setItem(rbSegmentKey, JSON.stringify(rbSegment));
+            var rbSegmentFromLocalStorage = localStorage.getItem(rbSegmentKey);
+            var previous = rbSegmentFromLocalStorage ? JSON.parse(rbSegmentFromLocalStorage) : null;
+            localStorage.setItem(rbSegmentKey, JSON.stringify(rbSegment));
             var usesSegmentsDiff = 0;
             if (previous && usesSegments(previous))
                 usesSegmentsDiff--;
@@ -62,7 +62,7 @@ var RBSegmentsCacheInLocal = /** @class */ (function () {
             var rbSegment = this.get(name);
             if (!rbSegment)
                 return false;
-            this.storage.removeItem(this.keys.buildRBSegmentKey(name));
+            localStorage.removeItem(this.keys.buildRBSegmentKey(name));
             if (usesSegments(rbSegment))
                 this.updateSegmentCount(-1);
             return true;
@@ -73,11 +73,11 @@ var RBSegmentsCacheInLocal = /** @class */ (function () {
         }
     };
     RBSegmentsCacheInLocal.prototype.getNames = function () {
-        var len = this.storage.length;
+        var len = localStorage.length;
         var accum = [];
         var cur = 0;
         while (cur < len) {
-            var key = this.storage.key(cur);
+            var key = localStorage.key(cur);
             if (key != null && this.keys.isRBSegmentKey(key))
                 accum.push(this.keys.extractKey(key));
             cur++;
@@ -85,9 +85,13 @@ var RBSegmentsCacheInLocal = /** @class */ (function () {
         return accum;
     };
     RBSegmentsCacheInLocal.prototype.get = function (name) {
-        var item = this.storage.getItem(this.keys.buildRBSegmentKey(name));
+        var item = localStorage.getItem(this.keys.buildRBSegmentKey(name));
         return item && JSON.parse(item);
     };
+    RBSegmentsCacheInLocal.prototype.getAll = function () {
+        var _this = this;
+        return this.getNames().map(function (key) { return _this.get(key); });
+    };
     RBSegmentsCacheInLocal.prototype.contains = function (names) {
         var namesArray = setToArray(names);
         var namesInStorage = this.getNames();
@@ -95,7 +99,7 @@ var RBSegmentsCacheInLocal = /** @class */ (function () {
     };
     RBSegmentsCacheInLocal.prototype.getChangeNumber = function () {
         var n = -1;
-        var value = this.storage.getItem(this.keys.buildRBSegmentsTillKey());
+        var value = localStorage.getItem(this.keys.buildRBSegmentsTillKey());
         if (value !== null) {
             value = parseInt(value, 10);
             return isNaNNumber(value) ? n : value;
@@ -103,7 +107,7 @@ var RBSegmentsCacheInLocal = /** @class */ (function () {
         return n;
     };
     RBSegmentsCacheInLocal.prototype.usesSegments = function () {
-        var storedCount = this.storage.getItem(this.keys.buildSplitsWithSegmentCountKey());
+        var storedCount = localStorage.getItem(this.keys.buildSplitsWithSegmentCountKey());
         var splitsWithSegmentsCount = storedCount === null ? 0 : toNumber(storedCount);
         return isFiniteNumber(splitsWithSegmentsCount) ?
             splitsWithSegmentsCount > 0 :

package/esm/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -3,22 +3,25 @@ import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSyn
 import { isFiniteNumber, toNumber, isNaNNumber } from '../../utils/lang';
 import { LOG_PREFIX } from './constants';
 import { setToArray } from '../../utils/lang/sets';
+/**
+ * ISplitsCacheSync implementation that stores split definitions in browser LocalStorage.
+ */
 var SplitsCacheInLocal = /** @class */ (function (_super) {
     __extends(SplitsCacheInLocal, _super);
-    function SplitsCacheInLocal(settings, keys, storage) {
+    function SplitsCacheInLocal(settings, keys) {
         var _this = _super.call(this) || this;
         _this.keys = keys;
         _this.log = settings.log;
         _this.flagSetsFilter = settings.sync.__splitFiltersValidation.groupedFilters.bySet;
-        _this.storage = storage;
         return _this;
     }
     SplitsCacheInLocal.prototype._decrementCount = function (key) {
-        var count = toNumber(this.storage.getItem(key)) - 1;
+        var count = toNumber(localStorage.getItem(key)) - 1;
+        // @ts-expect-error
         if (count > 0)
-            this.storage.setItem(key, count + '');
+            localStorage.setItem(key, count);
         else
-            this.storage.removeItem(key);
+            localStorage.removeItem(key);
     };
     SplitsCacheInLocal.prototype._decrementCounts = function (split) {
         try {
@@ -36,10 +39,12 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
     SplitsCacheInLocal.prototype._incrementCounts = function (split) {
         try {
             var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-            this.storage.setItem(ttKey, (toNumber(this.storage.getItem(ttKey)) + 1) + '');
+            // @ts-expect-error
+            localStorage.setItem(ttKey, toNumber(localStorage.getItem(ttKey)) + 1);
             if (usesSegments(split)) {
                 var segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
-                this.storage.setItem(segmentsCountKey, (toNumber(this.storage.getItem(segmentsCountKey)) + 1) + '');
+                // @ts-expect-error
+                localStorage.setItem(segmentsCountKey, toNumber(localStorage.getItem(segmentsCountKey)) + 1);
             }
         }
         catch (e) {
@@ -51,18 +56,17 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
      * We cannot simply call `localStorage.clear()` since that implies removing user items from the storage.
      */
     SplitsCacheInLocal.prototype.clear = function () {
-        var _this = this;
         // collect item keys
-        var len = this.storage.length;
+        var len = localStorage.length;
         var accum = [];
         for (var cur = 0; cur < len; cur++) {
-            var key = this.storage.key(cur);
+            var key = localStorage.key(cur);
             if (key != null && this.keys.isSplitsCacheKey(key))
                 accum.push(key);
         }
         // remove items
         accum.forEach(function (key) {
-            _this.storage.removeItem(key);
+            localStorage.removeItem(key);
         });
         this.hasSync = false;
     };
@@ -70,13 +74,13 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         try {
             var name_1 = split.name;
             var splitKey = this.keys.buildSplitKey(name_1);
-            var splitFromStorage = this.storage.getItem(splitKey);
-            var previousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : null;
+            var splitFromLocalStorage = localStorage.getItem(splitKey);
+            var previousSplit = splitFromLocalStorage ? JSON.parse(splitFromLocalStorage) : null;
             if (previousSplit) {
                 this._decrementCounts(previousSplit);
                 this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
             }
-            this.storage.setItem(splitKey, JSON.stringify(split));
+            localStorage.setItem(splitKey, JSON.stringify(split));
             this._incrementCounts(split);
             this.addToFlagSets(split);
             return true;
@@ -91,7 +95,7 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
             var split = this.getSplit(name);
             if (!split)
                 return false;
-            this.storage.removeItem(this.keys.buildSplitKey(name));
+            localStorage.removeItem(this.keys.buildSplitKey(name));
             this._decrementCounts(split);
             this.removeFromFlagSets(split.name, split.sets);
             return true;
@@ -102,14 +106,14 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         }
     };
     SplitsCacheInLocal.prototype.getSplit = function (name) {
-        var item = this.storage.getItem(this.keys.buildSplitKey(name));
+        var item = localStorage.getItem(this.keys.buildSplitKey(name));
         return item && JSON.parse(item);
     };
     SplitsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
         try {
-            this.storage.setItem(this.keys.buildSplitsTillKey(), changeNumber + '');
+            localStorage.setItem(this.keys.buildSplitsTillKey(), changeNumber + '');
             // update "last updated" timestamp with current time
-            this.storage.setItem(this.keys.buildLastUpdatedKey(), Date.now() + '');
+            localStorage.setItem(this.keys.buildLastUpdatedKey(), Date.now() + '');
             this.hasSync = true;
             return true;
         }
@@ -120,7 +124,7 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
     };
     SplitsCacheInLocal.prototype.getChangeNumber = function () {
         var n = -1;
-        var value = this.storage.getItem(this.keys.buildSplitsTillKey());
+        var value = localStorage.getItem(this.keys.buildSplitsTillKey());
         if (value !== null) {
             value = parseInt(value, 10);
             return isNaNNumber(value) ? n : value;
@@ -128,11 +132,11 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         return n;
     };
     SplitsCacheInLocal.prototype.getSplitNames = function () {
-        var len = this.storage.length;
+        var len = localStorage.length;
         var accum = [];
         var cur = 0;
         while (cur < len) {
-            var key = this.storage.key(cur);
+            var key = localStorage.key(cur);
             if (key != null && this.keys.isSplitKey(key))
                 accum.push(this.keys.extractKey(key));
             cur++;
@@ -140,14 +144,14 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         return accum;
     };
     SplitsCacheInLocal.prototype.trafficTypeExists = function (trafficType) {
-        var ttCount = toNumber(this.storage.getItem(this.keys.buildTrafficTypeKey(trafficType)));
+        var ttCount = toNumber(localStorage.getItem(this.keys.buildTrafficTypeKey(trafficType)));
         return isFiniteNumber(ttCount) && ttCount > 0;
     };
     SplitsCacheInLocal.prototype.usesSegments = function () {
         // If cache hasn't been synchronized with the cloud, assume we need them.
         if (!this.hasSync)
             return true;
-        var storedCount = this.storage.getItem(this.keys.buildSplitsWithSegmentCountKey());
+        var storedCount = localStorage.getItem(this.keys.buildSplitsWithSegmentCountKey());
         var splitsWithSegmentsCount = storedCount === null ? 0 : toNumber(storedCount);
         return isFiniteNumber(splitsWithSegmentsCount) ?
             splitsWithSegmentsCount > 0 :
@@ -157,8 +161,8 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         var _this = this;
         return flagSets.map(function (flagSet) {
             var flagSetKey = _this.keys.buildFlagSetKey(flagSet);
-            var flagSetFromStorage = _this.storage.getItem(flagSetKey);
-            return new Set(flagSetFromStorage ? JSON.parse(flagSetFromStorage) : []);
+            var flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
+            return new Set(flagSetFromLocalStorage ? JSON.parse(flagSetFromLocalStorage) : []);
         });
     };
     SplitsCacheInLocal.prototype.addToFlagSets = function (featureFlag) {
@@ -169,10 +173,10 @@ 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) : []);
+            var flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
+            var flagSetCache = new Set(flagSetFromLocalStorage ? JSON.parse(flagSetFromLocalStorage) : []);
             flagSetCache.add(featureFlag.name);
-            _this.storage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
+            localStorage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
         });
     };
     SplitsCacheInLocal.prototype.removeFromFlagSets = function (featureFlagName, flagSets) {
@@ -185,16 +189,16 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
     };
     SplitsCacheInLocal.prototype.removeNames = function (flagSetName, featureFlagName) {
         var flagSetKey = this.keys.buildFlagSetKey(flagSetName);
-        var flagSetFromStorage = this.storage.getItem(flagSetKey);
-        if (!flagSetFromStorage)
+        var flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
+        if (!flagSetFromLocalStorage)
             return;
-        var flagSetCache = new Set(JSON.parse(flagSetFromStorage));
+        var flagSetCache = new Set(JSON.parse(flagSetFromLocalStorage));
         flagSetCache.delete(featureFlagName);
         if (flagSetCache.size === 0) {
-            this.storage.removeItem(flagSetKey);
+            localStorage.removeItem(flagSetKey);
             return;
         }
-        this.storage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
+        localStorage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
     };
     return SplitsCacheInLocal;
 }(AbstractSplitsCacheSync));

package/esm/storages/inLocalStorage/index.js

@@ -3,7 +3,7 @@ import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCache
 import { EventsCacheInMemory } from '../inMemory/EventsCacheInMemory';
 import { validatePrefix } from '../KeyBuilder';
 import { KeyBuilderCS, myLargeSegmentsKeyBuilder } from '../KeyBuilderCS';
-import { isLocalStorageAvailable, isValidStorageWrapper, isWebStorage } from '../../utils/env/isLocalStorageAvailable';
+import { isLocalStorageAvailable } from '../../utils/env/isLocalStorageAvailable';
 import { SplitsCacheInLocal } from './SplitsCacheInLocal';
 import { RBSegmentsCacheInLocal } from './RBSegmentsCacheInLocal';
 import { MySegmentsCacheInLocal } from './MySegmentsCacheInLocal';
@@ -14,20 +14,6 @@ import { shouldRecordTelemetry, TelemetryCacheInMemory } from '../inMemory/Telem
 import { UniqueKeysCacheInMemoryCS } from '../inMemory/UniqueKeysCacheInMemoryCS';
 import { getMatching } from '../../utils/key';
 import { validateCache } from './validateCache';
-import { storageAdapter } from './storageAdapter';
-function validateStorage(log, prefix, wrapper) {
-    if (wrapper) {
-        if (isValidStorageWrapper(wrapper)) {
-            return isWebStorage(wrapper) ?
-                wrapper : // localStorage and sessionStorage don't need adapter
-                storageAdapter(log, prefix, wrapper);
-        }
-        log.warn(LOG_PREFIX + 'Invalid storage provided. Falling back to LocalStorage API');
-    }
-    if (isLocalStorageAvailable())
-        return localStorage;
-    log.warn(LOG_PREFIX + 'LocalStorage API is unavailable. Falling back to default MEMORY storage');
-}
 /**
  * InLocal storage factory for standalone client-side SplitFactory
  */
@@ -35,17 +21,18 @@ export function InLocalStorage(options) {
     if (options === void 0) { options = {}; }
     var prefix = validatePrefix(options.prefix);
     function InLocalStorageCSFactory(params) {
-        var settings = params.settings, _a = params.settings, log = _a.log, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize;
-        var storage = validateStorage(log, prefix, options.wrapper);
-        if (!storage)
+        // Fallback to InMemoryStorage if LocalStorage API is not available
+        if (!isLocalStorageAvailable()) {
+            params.settings.log.warn(LOG_PREFIX + 'LocalStorage API is unavailable. Falling back to default MEMORY storage');
             return InMemoryStorageCSFactory(params);
+        }
+        var settings = params.settings, _a = params.settings, log = _a.log, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize;
         var matchingKey = getMatching(settings.core.key);
         var keys = new KeyBuilderCS(prefix, matchingKey);
-        var splits = new SplitsCacheInLocal(settings, keys, storage);
-        var rbSegments = new RBSegmentsCacheInLocal(settings, keys, storage);
-        var segments = new MySegmentsCacheInLocal(log, keys, storage);
-        var largeSegments = new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey), storage);
-        var validateCachePromise;
+        var splits = new SplitsCacheInLocal(settings, keys);
+        var rbSegments = new RBSegmentsCacheInLocal(settings, keys);
+        var segments = new MySegmentsCacheInLocal(log, keys);
+        var largeSegments = new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey));
         return {
             splits: splits,
             rbSegments: rbSegments,
@@ -57,21 +44,16 @@ export function InLocalStorage(options) {
             telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
             uniqueKeys: new UniqueKeysCacheInMemoryCS(),
             validateCache: function () {
-                return validateCachePromise || (validateCachePromise = validateCache(options, storage, settings, keys, splits, rbSegments, segments, largeSegments));
-            },
-            save: function () {
-                return storage.save && storage.save();
-            },
-            destroy: function () {
-                return storage.whenSaved && storage.whenSaved();
+                return validateCache(options, settings, keys, splits, rbSegments, segments, largeSegments);
             },
+            destroy: function () { },
             // When using shared instantiation with MEMORY we reuse everything but segments (they are customer per key).
             shared: function (matchingKey) {
                 return {
                     splits: this.splits,
                     rbSegments: this.rbSegments,
-                    segments: new MySegmentsCacheInLocal(log, new KeyBuilderCS(prefix, matchingKey), storage),
-                    largeSegments: new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey), storage),
+                    segments: new MySegmentsCacheInLocal(log, new KeyBuilderCS(prefix, matchingKey)),
+                    largeSegments: new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey)),
                     impressions: this.impressions,
                     impressionCounts: this.impressionCounts,
                     events: this.events,

package/esm/storages/inLocalStorage/validateCache.js

@@ -8,10 +8,10 @@ var MILLIS_IN_A_DAY = 86400000;
  *
  * @returns `true` if cache should be cleared, `false` otherwise
  */
-function validateExpiration(options, storage, settings, keys, currentTimestamp, isThereCache) {
-    var log = settings.log;
+function validateExpiration(options, settings, keys, currentTimestamp, isThereCache) {
+    var log = settings.log, initialRolloutPlan = settings.initialRolloutPlan;
     // Check expiration
-    var lastUpdatedTimestamp = parseInt(storage.getItem(keys.buildLastUpdatedKey()), 10);
+    var lastUpdatedTimestamp = parseInt(localStorage.getItem(keys.buildLastUpdatedKey()), 10);
     if (!isNaNNumber(lastUpdatedTimestamp)) {
         var cacheExpirationInDays = isFiniteNumber(options.expirationDays) && options.expirationDays >= 1 ? options.expirationDays : DEFAULT_CACHE_EXPIRATION_IN_DAYS;
         var expirationTimestamp = currentTimestamp - MILLIS_IN_A_DAY * cacheExpirationInDays;
@@ -22,16 +22,16 @@ function validateExpiration(options, storage, settings, keys, currentTimestamp,
     }
     // Check hash
     var storageHashKey = keys.buildHashKey();
-    var storageHash = storage.getItem(storageHashKey);
+    var storageHash = localStorage.getItem(storageHashKey);
     var currentStorageHash = getStorageHash(settings);
     if (storageHash !== currentStorageHash) {
         try {
-            storage.setItem(storageHashKey, currentStorageHash);
+            localStorage.setItem(storageHashKey, currentStorageHash);
         }
         catch (e) {
             log.error(LOG_PREFIX + e);
         }
-        if (isThereCache) {
+        if (isThereCache && !initialRolloutPlan) {
             log.info(LOG_PREFIX + 'SDK key, flags filter criteria, or flags spec version has changed. Cleaning up cache');
             return true;
         }
@@ -39,7 +39,7 @@ function validateExpiration(options, storage, settings, keys, currentTimestamp,
     }
     // Clear on init
     if (options.clearOnInit) {
-        var lastClearTimestamp = parseInt(storage.getItem(keys.buildLastClear()), 10);
+        var lastClearTimestamp = parseInt(localStorage.getItem(keys.buildLastClear()), 10);
         if (isNaNNumber(lastClearTimestamp) || lastClearTimestamp < currentTimestamp - MILLIS_IN_A_DAY) {
             log.info(LOG_PREFIX + 'clearOnInit was set and cache was not cleared in the last 24 hours. Cleaning up cache');
             return true;
@@ -54,28 +54,23 @@ function validateExpiration(options, storage, settings, keys, currentTimestamp,
  *
  * @returns `true` if cache is ready to be used, `false` otherwise (cache was cleared or there is no cache)
  */
-export function validateCache(options, storage, settings, keys, splits, rbSegments, segments, largeSegments) {
-    return Promise.resolve(storage.load && storage.load()).then(function () {
-        var currentTimestamp = Date.now();
-        var isThereCache = splits.getChangeNumber() > -1;
-        if (validateExpiration(options, storage, settings, keys, currentTimestamp, isThereCache)) {
-            splits.clear();
-            rbSegments.clear();
-            segments.clear();
-            largeSegments.clear();
-            // Update last clear timestamp
-            try {
-                storage.setItem(keys.buildLastClear(), currentTimestamp + '');
-            }
-            catch (e) {
-                settings.log.error(LOG_PREFIX + e);
-            }
-            // Persist clear
-            if (storage.save)
-                storage.save();
-            return false;
+export function validateCache(options, settings, keys, splits, rbSegments, segments, largeSegments) {
+    var currentTimestamp = Date.now();
+    var isThereCache = splits.getChangeNumber() > -1;
+    if (validateExpiration(options, settings, keys, currentTimestamp, isThereCache)) {
+        splits.clear();
+        rbSegments.clear();
+        segments.clear();
+        largeSegments.clear();
+        // Update last clear timestamp
+        try {
+            localStorage.setItem(keys.buildLastClear(), currentTimestamp + '');
+        }
+        catch (e) {
+            settings.log.error(LOG_PREFIX + e);
         }
-        // Check if ready from cache
-        return isThereCache;
-    });
+        return false;
+    }
+    // Check if ready from cache
+    return isThereCache;
 }

package/esm/storages/inMemory/RBSegmentsCacheInMemory.js

@@ -42,6 +42,10 @@ var RBSegmentsCacheInMemory = /** @class */ (function () {
     RBSegmentsCacheInMemory.prototype.get = function (name) {
         return this.cache[name] || null;
     };
+    RBSegmentsCacheInMemory.prototype.getAll = function () {
+        var _this = this;
+        return this.getNames().map(function (key) { return _this.get(key); });
+    };
     RBSegmentsCacheInMemory.prototype.contains = function (names) {
         var namesArray = setToArray(names);
         var namesInStorage = this.getNames();

package/esm/storages/setRolloutPlan.js

@@ -0,0 +1,61 @@
+import { isObject } from '../utils/lang';
+import { isConsumerMode } from '../utils/settingsValidation/mode';
+/**
+ * Validates if the given rollout plan is valid.
+ */
+export function validateRolloutPlan(log, settings) {
+    var mode = settings.mode, initialRolloutPlan = settings.initialRolloutPlan;
+    if (isConsumerMode(mode)) {
+        log.warn('storage: initial rollout plan is ignored in consumer mode');
+        return;
+    }
+    if (isObject(initialRolloutPlan) && isObject(initialRolloutPlan.splitChanges))
+        return initialRolloutPlan;
+    log.error('storage: invalid rollout plan provided');
+    return;
+}
+/**
+ * Sets the given synchronous storage with the provided rollout plan snapshot.
+ * If `matchingKey` is provided, the storage is handled as a client-side storage (segments and largeSegments are instances of MySegmentsCache).
+ * Otherwise, the storage is handled as a server-side storage (segments is an instance of SegmentsCache).
+ */
+export function setRolloutPlan(log, rolloutPlan, storage, matchingKey) {
+    var splits = storage.splits, rbSegments = storage.rbSegments, segments = storage.segments, largeSegments = storage.largeSegments;
+    var _a = rolloutPlan.splitChanges, ff = _a.ff, rbs = _a.rbs;
+    log.debug("storage: set feature flags and segments" + (matchingKey ? " for key " + matchingKey : ''));
+    if (splits && ff) {
+        splits.clear();
+        splits.update(ff.d, [], ff.t);
+    }
+    if (rbSegments && rbs) {
+        rbSegments.clear();
+        rbSegments.update(rbs.d, [], rbs.t);
+    }
+    var segmentChanges = rolloutPlan.segmentChanges;
+    if (matchingKey) { // add memberships data (client-side)
+        var memberships = rolloutPlan.memberships && rolloutPlan.memberships[matchingKey];
+        if (!memberships && segmentChanges) {
+            memberships = {
+                ms: {
+                    k: segmentChanges.filter(function (segment) {
+                        return segment.added.indexOf(matchingKey) > -1;
+                    }).map(function (segment) { return ({ n: segment.name }); })
+                }
+            };
+        }
+        if (memberships) {
+            if (memberships.ms)
+                segments.resetSegments(memberships.ms);
+            if (memberships.ls && largeSegments)
+                largeSegments.resetSegments(memberships.ls);
+        }
+    }
+    else { // add segments data (server-side)
+        if (segmentChanges) {
+            segments.clear();
+            segmentChanges.forEach(function (segment) {
+                segments.update(segment.name, segment.added, segment.removed, segment.till);
+            });
+        }
+    }
+}

package/esm/sync/offline/syncTasks/fromObjectSyncTask.js

@@ -42,9 +42,10 @@ export function fromObjectUpdaterFactory(splitsParser, storage, readiness, setti
                 readiness.splits.emit(SDK_SPLITS_ARRIVED);
                 if (startingUp) {
                     startingUp = false;
-                    Promise.resolve(storage.validateCache ? storage.validateCache() : false).then(function (isCacheLoaded) {
+                    var isCacheLoaded_1 = storage.validateCache ? storage.validateCache() : false;
+                    Promise.resolve().then(function () {
                         // Emits SDK_READY_FROM_CACHE
-                        if (isCacheLoaded)
+                        if (isCacheLoaded_1)
                             readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
                         // Emits SDK_READY
                         readiness.segments.emit(SDK_SEGMENTS_ARRIVED);