@splitsoftware/splitio-commons 2.4.2-rc.2 → 2.5.0-rc.0

package/cjs/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -6,22 +6,25 @@ var AbstractSplitsCacheSync_1 = require("../AbstractSplitsCacheSync");
 var lang_1 = require("../../utils/lang");
 var constants_1 = require("./constants");
 var sets_1 = require("../../utils/lang/sets");
+/**
+ * ISplitsCacheSync implementation that stores split definitions in browser LocalStorage.
+ */
 var SplitsCacheInLocal = /** @class */ (function (_super) {
     (0, tslib_1.__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 = (0, lang_1.toNumber)(this.storage.getItem(key)) - 1;
+        var count = (0, lang_1.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 {
@@ -39,10 +42,12 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
     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) + '');
+            // @ts-expect-error
+            localStorage.setItem(ttKey, (0, lang_1.toNumber)(localStorage.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) + '');
+                // @ts-expect-error
+                localStorage.setItem(segmentsCountKey, (0, lang_1.toNumber)(localStorage.getItem(segmentsCountKey)) + 1);
             }
         }
         catch (e) {
@@ -54,18 +59,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;
     };
@@ -73,13 +77,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;
@@ -94,7 +98,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;
@@ -105,14 +109,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;
         }
@@ -123,7 +127,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 (0, lang_1.isNaNNumber)(value) ? n : value;
@@ -131,11 +135,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++;
@@ -143,14 +147,14 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         return accum;
     };
     SplitsCacheInLocal.prototype.trafficTypeExists = function (trafficType) {
-        var ttCount = (0, lang_1.toNumber)(this.storage.getItem(this.keys.buildTrafficTypeKey(trafficType)));
+        var ttCount = (0, lang_1.toNumber)(localStorage.getItem(this.keys.buildTrafficTypeKey(trafficType)));
         return (0, lang_1.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 : (0, lang_1.toNumber)(storedCount);
         return (0, lang_1.isFiniteNumber)(splitsWithSegmentsCount) ?
             splitsWithSegmentsCount > 0 :
@@ -160,8 +164,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) {
@@ -172,10 +176,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((0, sets_1.setToArray)(flagSetCache)));
+            localStorage.setItem(flagSetKey, JSON.stringify((0, sets_1.setToArray)(flagSetCache)));
         });
     };
     SplitsCacheInLocal.prototype.removeFromFlagSets = function (featureFlagName, flagSets) {
@@ -188,16 +192,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((0, sets_1.setToArray)(flagSetCache)));
+        localStorage.setItem(flagSetKey, JSON.stringify((0, sets_1.setToArray)(flagSetCache)));
     };
     return SplitsCacheInLocal;
 }(AbstractSplitsCacheSync_1.AbstractSplitsCacheSync));

package/cjs/storages/inLocalStorage/index.js

@@ -17,20 +17,6 @@ var TelemetryCacheInMemory_1 = require("../inMemory/TelemetryCacheInMemory");
 var UniqueKeysCacheInMemoryCS_1 = require("../inMemory/UniqueKeysCacheInMemoryCS");
 var key_1 = require("../../utils/key");
 var validateCache_1 = require("./validateCache");
-var storageAdapter_1 = require("./storageAdapter");
-function validateStorage(log, prefix, wrapper) {
-    if (wrapper) {
-        if ((0, isLocalStorageAvailable_1.isValidStorageWrapper)(wrapper)) {
-            return (0, isLocalStorageAvailable_1.isWebStorage)(wrapper) ?
-                wrapper : // localStorage and sessionStorage don't need adapter
-                (0, storageAdapter_1.storageAdapter)(log, prefix, wrapper);
-        }
-        log.warn(constants_1.LOG_PREFIX + 'Invalid storage provided. Falling back to LocalStorage API');
-    }
-    if ((0, isLocalStorageAvailable_1.isLocalStorageAvailable)())
-        return localStorage;
-    log.warn(constants_1.LOG_PREFIX + 'LocalStorage API is unavailable. Falling back to default MEMORY storage');
-}
 /**
  * InLocal storage factory for standalone client-side SplitFactory
  */
@@ -38,17 +24,18 @@ function InLocalStorage(options) {
     if (options === void 0) { options = {}; }
     var prefix = (0, KeyBuilder_1.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 (!(0, isLocalStorageAvailable_1.isLocalStorageAvailable)()) {
+            params.settings.log.warn(constants_1.LOG_PREFIX + 'LocalStorage API is unavailable. Falling back to default MEMORY storage');
             return (0, InMemoryStorageCS_1.InMemoryStorageCSFactory)(params);
+        }
+        var settings = params.settings, _a = params.settings, log = _a.log, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize;
         var matchingKey = (0, key_1.getMatching)(settings.core.key);
         var keys = new KeyBuilderCS_1.KeyBuilderCS(prefix, matchingKey);
-        var splits = new SplitsCacheInLocal_1.SplitsCacheInLocal(settings, keys, storage);
-        var rbSegments = new RBSegmentsCacheInLocal_1.RBSegmentsCacheInLocal(settings, keys, storage);
-        var segments = new MySegmentsCacheInLocal_1.MySegmentsCacheInLocal(log, keys, storage);
-        var largeSegments = new MySegmentsCacheInLocal_1.MySegmentsCacheInLocal(log, (0, KeyBuilderCS_1.myLargeSegmentsKeyBuilder)(prefix, matchingKey), storage);
-        var validateCachePromise;
+        var splits = new SplitsCacheInLocal_1.SplitsCacheInLocal(settings, keys);
+        var rbSegments = new RBSegmentsCacheInLocal_1.RBSegmentsCacheInLocal(settings, keys);
+        var segments = new MySegmentsCacheInLocal_1.MySegmentsCacheInLocal(log, keys);
+        var largeSegments = new MySegmentsCacheInLocal_1.MySegmentsCacheInLocal(log, (0, KeyBuilderCS_1.myLargeSegmentsKeyBuilder)(prefix, matchingKey));
         return {
             splits: splits,
             rbSegments: rbSegments,
@@ -60,18 +47,16 @@ function InLocalStorage(options) {
             telemetry: (0, TelemetryCacheInMemory_1.shouldRecordTelemetry)(params) ? new TelemetryCacheInMemory_1.TelemetryCacheInMemory(splits, segments) : undefined,
             uniqueKeys: new UniqueKeysCacheInMemoryCS_1.UniqueKeysCacheInMemoryCS(),
             validateCache: function () {
-                return validateCachePromise || (validateCachePromise = (0, validateCache_1.validateCache)(options, storage, settings, keys, splits, rbSegments, segments, largeSegments));
-            },
-            destroy: function () {
-                return storage.save && storage.save();
+                return (0, validateCache_1.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_1.MySegmentsCacheInLocal(log, new KeyBuilderCS_1.KeyBuilderCS(prefix, matchingKey), storage),
-                    largeSegments: new MySegmentsCacheInLocal_1.MySegmentsCacheInLocal(log, (0, KeyBuilderCS_1.myLargeSegmentsKeyBuilder)(prefix, matchingKey), storage),
+                    segments: new MySegmentsCacheInLocal_1.MySegmentsCacheInLocal(log, new KeyBuilderCS_1.KeyBuilderCS(prefix, matchingKey)),
+                    largeSegments: new MySegmentsCacheInLocal_1.MySegmentsCacheInLocal(log, (0, KeyBuilderCS_1.myLargeSegmentsKeyBuilder)(prefix, matchingKey)),
                     impressions: this.impressions,
                     impressionCounts: this.impressionCounts,
                     events: this.events,

package/cjs/storages/inLocalStorage/validateCache.js

@@ -11,10 +11,10 @@ var MILLIS_IN_A_DAY = 86400000;
  *
  * @returns `true` if cache should be cleared, `false` otherwise
  */
-function validateExpiration(options, storage, settings, keys, currentTimestamp, isThereCache) {
+function validateExpiration(options, settings, keys, currentTimestamp, isThereCache) {
     var log = settings.log;
     // Check expiration
-    var lastUpdatedTimestamp = parseInt(storage.getItem(keys.buildLastUpdatedKey()), 10);
+    var lastUpdatedTimestamp = parseInt(localStorage.getItem(keys.buildLastUpdatedKey()), 10);
     if (!(0, lang_1.isNaNNumber)(lastUpdatedTimestamp)) {
         var cacheExpirationInDays = (0, lang_1.isFiniteNumber)(options.expirationDays) && options.expirationDays >= 1 ? options.expirationDays : DEFAULT_CACHE_EXPIRATION_IN_DAYS;
         var expirationTimestamp = currentTimestamp - MILLIS_IN_A_DAY * cacheExpirationInDays;
@@ -25,11 +25,11 @@ 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 = (0, KeyBuilder_1.getStorageHash)(settings);
     if (storageHash !== currentStorageHash) {
         try {
-            storage.setItem(storageHashKey, currentStorageHash);
+            localStorage.setItem(storageHashKey, currentStorageHash);
         }
         catch (e) {
             log.error(constants_1.LOG_PREFIX + e);
@@ -42,7 +42,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 ((0, lang_1.isNaNNumber)(lastClearTimestamp) || lastClearTimestamp < currentTimestamp - MILLIS_IN_A_DAY) {
             log.info(constants_1.LOG_PREFIX + 'clearOnInit was set and cache was not cleared in the last 24 hours. Cleaning up cache');
             return true;
@@ -57,26 +57,24 @@ 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)
  */
-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(constants_1.LOG_PREFIX + e);
-            }
-            return false;
+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(constants_1.LOG_PREFIX + e);
         }
-        // Check if ready from cache
-        return isThereCache;
-    });
+        return false;
+    }
+    // Check if ready from cache
+    return isThereCache;
 }
 exports.validateCache = validateCache;

package/cjs/storages/inMemory/InMemoryStorageCS.js

@@ -9,6 +9,8 @@ var ImpressionCountsCacheInMemory_1 = require("./ImpressionCountsCacheInMemory")
 var constants_1 = require("../../utils/constants");
 var TelemetryCacheInMemory_1 = require("./TelemetryCacheInMemory");
 var UniqueKeysCacheInMemoryCS_1 = require("./UniqueKeysCacheInMemoryCS");
+var key_1 = require("../../utils/key");
+var dataLoader_1 = require("../dataLoader");
 var RBSegmentsCacheInMemory_1 = require("./RBSegmentsCacheInMemory");
 /**
  * InMemory storage factory for standalone client-side SplitFactory
@@ -16,7 +18,8 @@ var RBSegmentsCacheInMemory_1 = require("./RBSegmentsCacheInMemory");
  * @param params - parameters required by EventsCacheSync
  */
 function InMemoryStorageCSFactory(params) {
-    var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, __splitFiltersValidation = _a.sync.__splitFiltersValidation;
+    var _a = params.settings, log = _a.log, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, __splitFiltersValidation = _a.sync.__splitFiltersValidation, preloadedData = _a.preloadedData, onReadyFromCacheCb = params.onReadyFromCacheCb;
+    var storages = {};
     var splits = new SplitsCacheInMemory_1.SplitsCacheInMemory(__splitFiltersValidation);
     var rbSegments = new RBSegmentsCacheInMemory_1.RBSegmentsCacheInMemory();
     var segments = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
@@ -33,19 +36,27 @@ function InMemoryStorageCSFactory(params) {
         uniqueKeys: new UniqueKeysCacheInMemoryCS_1.UniqueKeysCacheInMemoryCS(),
         destroy: function () { },
         // When using shared instantiation with MEMORY we reuse everything but segments (they are unique per key)
-        shared: function () {
-            return {
-                splits: this.splits,
-                rbSegments: this.rbSegments,
-                segments: new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory(),
-                largeSegments: new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory(),
-                impressions: this.impressions,
-                impressionCounts: this.impressionCounts,
-                events: this.events,
-                telemetry: this.telemetry,
-                uniqueKeys: this.uniqueKeys,
-                destroy: function () { }
-            };
+        shared: function (matchingKey) {
+            if (!storages[matchingKey]) {
+                var segments_1 = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
+                var largeSegments_1 = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
+                if (preloadedData) {
+                    (0, dataLoader_1.setCache)(log, preloadedData, { segments: segments_1, largeSegments: largeSegments_1 }, matchingKey);
+                }
+                storages[matchingKey] = {
+                    splits: this.splits,
+                    rbSegments: this.rbSegments,
+                    segments: segments_1,
+                    largeSegments: largeSegments_1,
+                    impressions: this.impressions,
+                    impressionCounts: this.impressionCounts,
+                    events: this.events,
+                    telemetry: this.telemetry,
+                    uniqueKeys: this.uniqueKeys,
+                    destroy: function () { }
+                };
+            }
+            return storages[matchingKey];
         },
     };
     // @TODO revisit storage logic in localhost mode
@@ -57,6 +68,13 @@ function InMemoryStorageCSFactory(params) {
         storage.impressionCounts.track = noopTrack;
         storage.uniqueKeys.track = noopTrack;
     }
+    var matchingKey = (0, key_1.getMatching)(params.settings.core.key);
+    storages[matchingKey] = storage;
+    if (preloadedData) {
+        (0, dataLoader_1.setCache)(log, preloadedData, storage, matchingKey);
+        if (splits.getChangeNumber() > -1)
+            onReadyFromCacheCb();
+    }
     return storage;
 }
 exports.InMemoryStorageCSFactory = InMemoryStorageCSFactory;

package/cjs/storages/inMemory/RBSegmentsCacheInMemory.js

@@ -45,6 +45,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 = (0, sets_1.setToArray)(names);
         var namesInStorage = this.getNames();

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

@@ -45,9 +45,10 @@ function fromObjectUpdaterFactory(splitsParser, storage, readiness, settings) {
                 readiness.splits.emit(constants_2.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(constants_2.SDK_SPLITS_CACHE_LOADED);
                         // Emits SDK_READY
                         readiness.segments.emit(constants_2.SDK_SEGMENTS_ARRIVED);

package/cjs/sync/syncManagerOnline.js

@@ -69,39 +69,35 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
              */
             start: function () {
                 running = true;
-                // @TODO once event, impression and telemetry storages support persistence, call when `validateCache` promise is resolved
-                submitterManager.start(!(0, consent_1.isConsentGranted)(settings));
-                return Promise.resolve(storage.validateCache ? storage.validateCache() : false).then(function (isCacheLoaded) {
-                    if (!running)
-                        return;
-                    if (startFirstTime) {
-                        // Emits SDK_READY_FROM_CACHE
-                        if (isCacheLoaded)
-                            readiness.splits.emit(constants_4.SDK_SPLITS_CACHE_LOADED);
-                    }
-                    // start syncing splits and segments
-                    if (pollingManager) {
-                        // If synchronization is disabled pushManager and pollingManager should not start
-                        if (syncEnabled) {
-                            if (pushManager) {
-                                // Doesn't call `syncAll` when the syncManager is resuming
-                                if (startFirstTime) {
-                                    pollingManager.syncAll();
-                                }
-                                pushManager.start();
-                            }
-                            else {
-                                pollingManager.start();
-                            }
-                        }
-                        else {
+                if (startFirstTime) {
+                    var isCacheLoaded = storage.validateCache ? storage.validateCache() : false;
+                    if (isCacheLoaded)
+                        Promise.resolve().then(function () { readiness.splits.emit(constants_4.SDK_SPLITS_CACHE_LOADED); });
+                }
+                // start syncing splits and segments
+                if (pollingManager) {
+                    // If synchronization is disabled pushManager and pollingManager should not start
+                    if (syncEnabled) {
+                        if (pushManager) {
+                            // Doesn't call `syncAll` when the syncManager is resuming
                             if (startFirstTime) {
                                 pollingManager.syncAll();
                             }
+                            pushManager.start();
+                        }
+                        else {
+                            pollingManager.start();
+                        }
+                    }
+                    else {
+                        if (startFirstTime) {
+                            pollingManager.syncAll();
                         }
                     }
-                    startFirstTime = false;
-                });
+                }
+                // start periodic data recording (events, impressions, telemetry).
+                submitterManager.start(!(0, consent_1.isConsentGranted)(settings));
+                startFirstTime = false;
             },
             /**
              * Method used to stop/pause the syncManager.

package/cjs/utils/env/isLocalStorageAvailable.js

@@ -1,39 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isWebStorage = exports.isValidStorageWrapper = exports.isLocalStorageAvailable = void 0;
+exports.isLocalStorageAvailable = void 0;
+/* eslint-disable no-undef */
 function isLocalStorageAvailable() {
-    try {
-        // eslint-disable-next-line no-undef
-        return isValidStorageWrapper(localStorage);
-    }
-    catch (e) {
-        return false;
-    }
-}
-exports.isLocalStorageAvailable = isLocalStorageAvailable;
-function isValidStorageWrapper(wrapper) {
     var mod = '__SPLITSOFTWARE__';
     try {
-        wrapper.setItem(mod, mod);
-        wrapper.getItem(mod);
-        wrapper.removeItem(mod);
+        localStorage.setItem(mod, mod);
+        localStorage.removeItem(mod);
         return true;
     }
     catch (e) {
         return false;
     }
 }
-exports.isValidStorageWrapper = isValidStorageWrapper;
-function isWebStorage(wrapper) {
-    if (typeof wrapper.length === 'number') {
-        try {
-            wrapper.key(0);
-            return true;
-        }
-        catch (e) {
-            return false;
-        }
-    }
-    return false;
-}
-exports.isWebStorage = isWebStorage;
+exports.isLocalStorageAvailable = isLocalStorageAvailable;

package/cjs/utils/settingsValidation/storage/storageCS.js

@@ -6,7 +6,7 @@ var constants_1 = require("../../../logger/constants");
 var constants_2 = require("../../../utils/constants");
 function __InLocalStorageMockFactory(params) {
     var result = (0, InMemoryStorageCS_1.InMemoryStorageCSFactory)(params);
-    result.validateCache = function () { return Promise.resolve(true); }; // to emit SDK_READY_FROM_CACHE
+    result.validateCache = function () { return true; }; // to emit SDK_READY_FROM_CACHE
     return result;
 }
 exports.__InLocalStorageMockFactory = __InLocalStorageMockFactory;

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;
 }());