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

package/esm/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -3,25 +3,22 @@ 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) {
+    function SplitsCacheInLocal(settings, keys, storage) {
         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(localStorage.getItem(key)) - 1;
-        // @ts-expect-error
+        var count = toNumber(this.storage.getItem(key)) - 1;
         if (count > 0)
-            localStorage.setItem(key, count);
+            this.storage.setItem(key, count + '');
         else
-            localStorage.removeItem(key);
+            this.storage.removeItem(key);
     };
     SplitsCacheInLocal.prototype._decrementCounts = function (split) {
         try {
@@ -39,12 +36,10 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
     SplitsCacheInLocal.prototype._incrementCounts = function (split) {
         try {
             var ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-            // @ts-expect-error
-            localStorage.setItem(ttKey, toNumber(localStorage.getItem(ttKey)) + 1);
+            this.storage.setItem(ttKey, (toNumber(this.storage.getItem(ttKey)) + 1) + '');
             if (usesSegments(split)) {
                 var segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
-                // @ts-expect-error
-                localStorage.setItem(segmentsCountKey, toNumber(localStorage.getItem(segmentsCountKey)) + 1);
+                this.storage.setItem(segmentsCountKey, (toNumber(this.storage.getItem(segmentsCountKey)) + 1) + '');
             }
         }
         catch (e) {
@@ -56,17 +51,18 @@ 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 = localStorage.length;
+        var len = this.storage.length;
         var accum = [];
         for (var cur = 0; cur < len; cur++) {
-            var key = localStorage.key(cur);
+            var key = this.storage.key(cur);
             if (key != null && this.keys.isSplitsCacheKey(key))
                 accum.push(key);
         }
         // remove items
         accum.forEach(function (key) {
-            localStorage.removeItem(key);
+            _this.storage.removeItem(key);
         });
         this.hasSync = false;
     };
@@ -74,13 +70,13 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         try {
             var name_1 = split.name;
             var splitKey = this.keys.buildSplitKey(name_1);
-            var splitFromLocalStorage = localStorage.getItem(splitKey);
-            var previousSplit = splitFromLocalStorage ? JSON.parse(splitFromLocalStorage) : null;
+            var splitFromStorage = this.storage.getItem(splitKey);
+            var previousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : null;
             if (previousSplit) {
                 this._decrementCounts(previousSplit);
                 this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
             }
-            localStorage.setItem(splitKey, JSON.stringify(split));
+            this.storage.setItem(splitKey, JSON.stringify(split));
             this._incrementCounts(split);
             this.addToFlagSets(split);
             return true;
@@ -95,7 +91,7 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
             var split = this.getSplit(name);
             if (!split)
                 return false;
-            localStorage.removeItem(this.keys.buildSplitKey(name));
+            this.storage.removeItem(this.keys.buildSplitKey(name));
             this._decrementCounts(split);
             this.removeFromFlagSets(split.name, split.sets);
             return true;
@@ -106,14 +102,14 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         }
     };
     SplitsCacheInLocal.prototype.getSplit = function (name) {
-        var item = localStorage.getItem(this.keys.buildSplitKey(name));
+        var item = this.storage.getItem(this.keys.buildSplitKey(name));
         return item && JSON.parse(item);
     };
     SplitsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
         try {
-            localStorage.setItem(this.keys.buildSplitsTillKey(), changeNumber + '');
+            this.storage.setItem(this.keys.buildSplitsTillKey(), changeNumber + '');
             // update "last updated" timestamp with current time
-            localStorage.setItem(this.keys.buildLastUpdatedKey(), Date.now() + '');
+            this.storage.setItem(this.keys.buildLastUpdatedKey(), Date.now() + '');
             this.hasSync = true;
             return true;
         }
@@ -124,7 +120,7 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
     };
     SplitsCacheInLocal.prototype.getChangeNumber = function () {
         var n = -1;
-        var value = localStorage.getItem(this.keys.buildSplitsTillKey());
+        var value = this.storage.getItem(this.keys.buildSplitsTillKey());
         if (value !== null) {
             value = parseInt(value, 10);
             return isNaNNumber(value) ? n : value;
@@ -132,11 +128,11 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         return n;
     };
     SplitsCacheInLocal.prototype.getSplitNames = function () {
-        var len = localStorage.length;
+        var len = this.storage.length;
         var accum = [];
         var cur = 0;
         while (cur < len) {
-            var key = localStorage.key(cur);
+            var key = this.storage.key(cur);
             if (key != null && this.keys.isSplitKey(key))
                 accum.push(this.keys.extractKey(key));
             cur++;
@@ -144,14 +140,14 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         return accum;
     };
     SplitsCacheInLocal.prototype.trafficTypeExists = function (trafficType) {
-        var ttCount = toNumber(localStorage.getItem(this.keys.buildTrafficTypeKey(trafficType)));
+        var ttCount = toNumber(this.storage.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 = localStorage.getItem(this.keys.buildSplitsWithSegmentCountKey());
+        var storedCount = this.storage.getItem(this.keys.buildSplitsWithSegmentCountKey());
         var splitsWithSegmentsCount = storedCount === null ? 0 : toNumber(storedCount);
         return isFiniteNumber(splitsWithSegmentsCount) ?
             splitsWithSegmentsCount > 0 :
@@ -161,8 +157,8 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         var _this = this;
         return flagSets.map(function (flagSet) {
             var flagSetKey = _this.keys.buildFlagSetKey(flagSet);
-            var flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
-            return new Set(flagSetFromLocalStorage ? JSON.parse(flagSetFromLocalStorage) : []);
+            var flagSetFromStorage = _this.storage.getItem(flagSetKey);
+            return new Set(flagSetFromStorage ? JSON.parse(flagSetFromStorage) : []);
         });
     };
     SplitsCacheInLocal.prototype.addToFlagSets = function (featureFlag) {
@@ -173,10 +169,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 flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
-            var flagSetCache = new Set(flagSetFromLocalStorage ? JSON.parse(flagSetFromLocalStorage) : []);
+            var flagSetFromStorage = _this.storage.getItem(flagSetKey);
+            var flagSetCache = new Set(flagSetFromStorage ? JSON.parse(flagSetFromStorage) : []);
             flagSetCache.add(featureFlag.name);
-            localStorage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
+            _this.storage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
         });
     };
     SplitsCacheInLocal.prototype.removeFromFlagSets = function (featureFlagName, flagSets) {
@@ -189,16 +185,16 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
     };
     SplitsCacheInLocal.prototype.removeNames = function (flagSetName, featureFlagName) {
         var flagSetKey = this.keys.buildFlagSetKey(flagSetName);
-        var flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
-        if (!flagSetFromLocalStorage)
+        var flagSetFromStorage = this.storage.getItem(flagSetKey);
+        if (!flagSetFromStorage)
             return;
-        var flagSetCache = new Set(JSON.parse(flagSetFromLocalStorage));
+        var flagSetCache = new Set(JSON.parse(flagSetFromStorage));
         flagSetCache.delete(featureFlagName);
         if (flagSetCache.size === 0) {
-            localStorage.removeItem(flagSetKey);
+            this.storage.removeItem(flagSetKey);
             return;
         }
-        localStorage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
+        this.storage.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 } from '../../utils/env/isLocalStorageAvailable';
+import { isLocalStorageAvailable, isValidStorageWrapper, isWebStorage } from '../../utils/env/isLocalStorageAvailable';
 import { SplitsCacheInLocal } from './SplitsCacheInLocal';
 import { RBSegmentsCacheInLocal } from './RBSegmentsCacheInLocal';
 import { MySegmentsCacheInLocal } from './MySegmentsCacheInLocal';
@@ -14,6 +14,20 @@ 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
  */
@@ -21,18 +35,17 @@ export function InLocalStorage(options) {
     if (options === void 0) { options = {}; }
     var prefix = validatePrefix(options.prefix);
     function InLocalStorageCSFactory(params) {
-        // 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 storage = validateStorage(log, prefix, options.wrapper);
+        if (!storage)
+            return InMemoryStorageCSFactory(params);
         var matchingKey = getMatching(settings.core.key);
         var keys = new KeyBuilderCS(prefix, matchingKey);
-        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));
+        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;
         return {
             splits: splits,
             rbSegments: rbSegments,
@@ -44,16 +57,21 @@ export function InLocalStorage(options) {
             telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
             uniqueKeys: new UniqueKeysCacheInMemoryCS(),
             validateCache: function () {
-                return validateCache(options, settings, keys, splits, rbSegments, segments, largeSegments);
+                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();
             },
-            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)),
-                    largeSegments: new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey)),
+                    segments: new MySegmentsCacheInLocal(log, new KeyBuilderCS(prefix, matchingKey), storage),
+                    largeSegments: new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey), storage),
                     impressions: this.impressions,
                     impressionCounts: this.impressionCounts,
                     events: this.events,

package/esm/storages/inLocalStorage/storageAdapter.js

@@ -0,0 +1,50 @@
+import { LOG_PREFIX } from './constants';
+export function storageAdapter(log, prefix, wrapper) {
+    var keys = [];
+    var cache = {};
+    var loadPromise;
+    var savePromise = Promise.resolve();
+    return {
+        load: function () {
+            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 wrapper `getItem` method, with error: ' + e);
+            }));
+        },
+        save: function () {
+            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 keys.length;
+        },
+        getItem: function (key) {
+            return cache[key] || null;
+        },
+        key: function (index) {
+            return keys[index] || null;
+        },
+        removeItem: function (key) {
+            var index = keys.indexOf(key);
+            if (index === -1)
+                return;
+            keys.splice(index, 1);
+            delete cache[key];
+        },
+        setItem: function (key, value) {
+            if (keys.indexOf(key) === -1)
+                keys.push(key);
+            cache[key] = value;
+        }
+    };
+}

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, settings, keys, currentTimestamp, isThereCache) {
+function validateExpiration(options, storage, settings, keys, currentTimestamp, isThereCache) {
     var log = settings.log;
     // Check expiration
-    var lastUpdatedTimestamp = parseInt(localStorage.getItem(keys.buildLastUpdatedKey()), 10);
+    var lastUpdatedTimestamp = parseInt(storage.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,11 +22,11 @@ function validateExpiration(options, settings, keys, currentTimestamp, isThereCa
     }
     // Check hash
     var storageHashKey = keys.buildHashKey();
-    var storageHash = localStorage.getItem(storageHashKey);
+    var storageHash = storage.getItem(storageHashKey);
     var currentStorageHash = getStorageHash(settings);
     if (storageHash !== currentStorageHash) {
         try {
-            localStorage.setItem(storageHashKey, currentStorageHash);
+            storage.setItem(storageHashKey, currentStorageHash);
         }
         catch (e) {
             log.error(LOG_PREFIX + e);
@@ -39,7 +39,7 @@ function validateExpiration(options, settings, keys, currentTimestamp, isThereCa
     }
     // Clear on init
     if (options.clearOnInit) {
-        var lastClearTimestamp = parseInt(localStorage.getItem(keys.buildLastClear()), 10);
+        var lastClearTimestamp = parseInt(storage.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,23 +54,28 @@ function validateExpiration(options, settings, keys, currentTimestamp, isThereCa
  *
  * @returns `true` if cache is ready to be used, `false` otherwise (cache was cleared or there is no cache)
  */
-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);
+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;
         }
-        return false;
-    }
-    // Check if ready from cache
-    return isThereCache;
+        // Check if ready from cache
+        return isThereCache;
+    });
 }

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

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

package/esm/sync/polling/pollingManagerCS.js

@@ -4,6 +4,7 @@ import { splitsSyncTaskFactory } from './syncTasks/splitsSyncTask';
 import { getMatching } from '../../utils/key';
 import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../../readiness/constants';
 import { POLLING_SMART_PAUSING, POLLING_START, POLLING_STOP } from '../../logger/constants';
+import { usesSegmentsSync } from '../../storages/AbstractSplitsCacheSync';
 /**
  * Expose start / stop mechanism for polling data from services.
  * For client-side API with multiple clients.
@@ -31,7 +32,7 @@ export function pollingManagerCSFactory(params) {
     readiness.splits.on(SDK_SPLITS_ARRIVED, function () {
         if (!splitsSyncTask.isRunning())
             return; // noop if not doing polling
-        var usingSegments = storage.splits.usesSegments() || storage.rbSegments.usesSegments();
+        var usingSegments = usesSegmentsSync(storage);
         if (usingSegments !== mySegmentsSyncTask.isRunning()) {
             log.info(POLLING_SMART_PAUSING, [usingSegments ? 'ON' : 'OFF']);
             if (usingSegments) {
@@ -46,10 +47,10 @@ export function pollingManagerCSFactory(params) {
         var mySegmentsSyncTask = mySegmentsSyncTaskFactory(splitApi.fetchMemberships, storage, readiness, settings, matchingKey);
         // smart ready
         function smartReady() {
-            if (!readiness.isReady() && !storage.splits.usesSegments() && !storage.rbSegments.usesSegments())
+            if (!readiness.isReady() && !usesSegmentsSync(storage))
                 readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
         }
-        if (!storage.splits.usesSegments() && !storage.rbSegments.usesSegments())
+        if (!usesSegmentsSync(storage))
             setTimeout(smartReady, 0);
         else
             readiness.splits.once(SDK_SPLITS_ARRIVED, smartReady);
@@ -63,7 +64,7 @@ export function pollingManagerCSFactory(params) {
         start: function () {
             log.info(POLLING_START);
             splitsSyncTask.start();
-            if (storage.splits.usesSegments() || storage.rbSegments.usesSegments())
+            if (usesSegmentsSync(storage))
                 startMySegmentsSyncTasks();
         },
         // Stop periodic fetching (polling)

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

@@ -2,6 +2,7 @@ import { timeout } from '../../../utils/promise/timeout';
 import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
 import { SYNC_MYSEGMENTS_FETCH_RETRY } from '../../../logger/constants';
 import { MEMBERSHIPS_LS_UPDATE } from '../../streaming/constants';
+import { usesSegmentsSync } from '../../../storages/AbstractSplitsCacheSync';
 /**
  * factory of MySegments updater, a task that:
  *  - fetches mySegments using `mySegmentsFetcher`
@@ -9,7 +10,7 @@ import { MEMBERSHIPS_LS_UPDATE } from '../../streaming/constants';
  *  - uses `segmentsEventEmitter` to emit events related to segments data updates
  */
 export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, storage, segmentsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, matchingKey) {
-    var splits = storage.splits, rbSegments = storage.rbSegments, segments = storage.segments, largeSegments = storage.largeSegments;
+    var segments = storage.segments, largeSegments = storage.largeSegments;
     var readyOnAlreadyExistentState = true;
     var startingUp = true;
     /** timeout and telemetry decorator for `splitChangesFetcher` promise  */
@@ -30,8 +31,10 @@ 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 ((splits.usesSegments() || rbSegments.usesSegments()) && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
+        if (usesSegmentsSync(storage) && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
             readyOnAlreadyExistentState = false;
             segmentsEventEmitter.emit(SDK_SEGMENTS_ARRIVED);
         }

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

@@ -42,7 +42,7 @@ export function parseSegments(ruleEntity, matcherType) {
 }
 /**
  * If there are defined filters and one feature flag doesn't match with them, its status is changed to 'ARCHIVE' to avoid storing it
- * If there are set filter defined, names filter is ignored
+ * If there is `bySet` filter, `byName` and `byPrefix` filters are ignored
  *
  * @param featureFlag - feature flag to be evaluated
  * @param filters - splitFiltersValidation bySet | byName
@@ -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/esm/sync/syncManagerOnline.js

@@ -4,6 +4,7 @@ import { SYNC_START_POLLING, SYNC_CONTINUE_POLLING, SYNC_STOP_POLLING } from '..
 import { isConsentGranted } from '../consent';
 import { POLLING, STREAMING, SYNC_MODE_UPDATE } from '../utils/constants';
 import { SDK_SPLITS_CACHE_LOADED } from '../readiness/constants';
+import { usesSegmentsSync } from '../storages/AbstractSplitsCacheSync';
 /**
  * Online SyncManager factory.
  * Can be used for server-side API, and client-side API with or without multiple clients.
@@ -65,35 +66,39 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
              */
             start: function () {
                 running = true;
-                if (startFirstTime) {
-                    var isCacheLoaded = storage.validateCache ? storage.validateCache() : false;
-                    if (isCacheLoaded)
-                        Promise.resolve().then(function () { readiness.splits.emit(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();
+                // @TODO once event, impression and telemetry storages support persistence, call when `validateCache` promise is resolved
+                submitterManager.start(!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(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();
                             }
-                            pushManager.start();
                         }
                         else {
-                            pollingManager.start();
-                        }
-                    }
-                    else {
-                        if (startFirstTime) {
-                            pollingManager.syncAll();
+                            if (startFirstTime) {
+                                pollingManager.syncAll();
+                            }
                         }
                     }
-                }
-                // start periodic data recording (events, impressions, telemetry).
-                submitterManager.start(!isConsentGranted(settings));
-                startFirstTime = false;
+                    startFirstTime = false;
+                });
             },
             /**
              * Method used to stop/pause the syncManager.
@@ -127,7 +132,7 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
                         if (pushManager) {
                             if (pollingManager.isRunning()) {
                                 // if doing polling, we must start the periodic fetch of data
-                                if (storage.splits.usesSegments() || storage.rbSegments.usesSegments())
+                                if (usesSegmentsSync(storage))
                                     mySegmentsSyncTask.start();
                             }
                             else {
@@ -137,7 +142,7 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
                             }
                         }
                         else {
-                            if (storage.splits.usesSegments() || storage.rbSegments.usesSegments())
+                            if (usesSegmentsSync(storage))
                                 mySegmentsSyncTask.start();
                         }
                     }

package/esm/trackers/impressionsTracker.js

@@ -6,7 +6,7 @@ import { CONSENT_DECLINED, DEDUPED, QUEUED } from '../utils/constants';
  * Impressions tracker stores impressions in cache and pass them to the listener and integrations manager if provided.
  */
 export function impressionsTrackerFactory(settings, impressionsCache, noneStrategy, strategy, whenInit, integrationsManager, telemetryCache) {
-    var log = settings.log, _a = settings.runtime, ip = _a.ip, hostname = _a.hostname, version = settings.version;
+    var log = settings.log, impressionListener = settings.impressionListener, _a = settings.runtime, ip = _a.ip, hostname = _a.hostname, version = settings.version;
     return {
         track: function (impressions, attributes) {
             if (settings.userConsent === CONSENT_DECLINED)
@@ -39,7 +39,7 @@ export function impressionsTrackerFactory(settings, impressionsCache, noneStrate
                 }
             }
             // @TODO next block might be handled by the integration manager. In that case, the metadata object doesn't need to be passed in the constructor
-            if (settings.impressionListener || integrationsManager) {
+            if (impressionListener || integrationsManager) {
                 var _loop_1 = function (i) {
                     var impressionData = {
                         // copy of impression, to avoid unexpected behavior if modified by integrations or impressionListener
@@ -56,8 +56,8 @@ export function impressionsTrackerFactory(settings, impressionsCache, noneStrate
                             if (integrationsManager)
                                 integrationsManager.handleImpression(impressionData);
                             try { // @ts-ignore. An exception on the listeners should not break the SDK.
-                                if (settings.impressionListener)
-                                    settings.impressionListener.logImpression(impressionData);
+                                if (impressionListener)
+                                    impressionListener.logImpression(impressionData);
                             }
                             catch (err) {
                                 log.error(ERROR_IMPRESSIONS_LISTENER, [err]);