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

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,29 +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);
-            }
-            // Persist clear
-            if (storage.save)
-                storage.save();
-            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/polling/updaters/mySegmentsUpdater.js

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

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

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

package/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/dataLoader.js

@@ -1,46 +1,104 @@
-// This value might be eventually set via a config parameter
-var DEFAULT_CACHE_EXPIRATION_IN_MILLIS = 864000000; // 10 days
+import { setToArray } from '../utils/lang/sets';
+import { getMatching } from '../utils/key';
 /**
- * Factory of client-side storage loader
- *
- * @param preloadedData - validated data following the format proposed in https://github.com/godaddy/split-javascript-data-loader
- * and extended with a `mySegmentsData` property.
- * @returns function to preload the storage
+ * Sets the given synchronous storage with the provided preloaded data 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 dataLoaderFactory(preloadedData) {
-    /**
-     * Storage-agnostic adaptation of `loadDataIntoLocalStorage` function
-     * (https://github.com/godaddy/split-javascript-data-loader/blob/master/src/load-data.js)
-     *
-     * @param storage - object containing `splits` and `segments` cache (client-side variant)
-     * @param userId - user key string of the provided MySegmentsCache
-     */
-    // @TODO extend to support SegmentsCache (server-side variant) by making `userId` optional and adding the corresponding logic.
-    // @TODO extend to load data on shared mySegments storages. Be specific when emitting SDK_READY_FROM_CACHE on shared clients. Maybe the serializer should provide the `useSegments` flag.
-    return function loadData(storage, userId) {
-        // Do not load data if current preloadedData is empty
-        if (Object.keys(preloadedData).length === 0)
-            return;
-        var _a = preloadedData.lastUpdated, lastUpdated = _a === void 0 ? -1 : _a, _b = preloadedData.segmentsData, segmentsData = _b === void 0 ? {} : _b, _c = preloadedData.since, since = _c === void 0 ? -1 : _c, _d = preloadedData.splitsData, splitsData = _d === void 0 ? {} : _d;
-        var storedSince = storage.splits.getChangeNumber();
-        var expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
-        // Do not load data if current localStorage data is more recent,
-        // or if its `lastUpdated` timestamp is older than the given `expirationTimestamp`,
-        if (storedSince > since || lastUpdated < expirationTimestamp)
-            return;
-        // cleaning up the localStorage data, since some cached splits might need be part of the preloaded data
-        storage.splits.clear();
-        // splitsData in an object where the property is the split name and the pertaining value is a stringified json of its data
-        storage.splits.update(Object.keys(splitsData).map(function (splitName) { return JSON.parse(splitsData[splitName]); }), [], since);
-        // add mySegments data
-        var mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[userId];
-        if (!mySegmentsData) {
-            // segmentsData in an object where the property is the segment name and the pertaining value is a stringified object that contains the `added` array of userIds
-            mySegmentsData = Object.keys(segmentsData).filter(function (segmentName) {
-                var userIds = JSON.parse(segmentsData[segmentName]).added;
-                return Array.isArray(userIds) && userIds.indexOf(userId) > -1;
-            });
+export function setCache(log, preloadedData, storage, matchingKey) {
+    // Do not load data if current preloadedData is empty
+    if (Object.keys(preloadedData).length === 0)
+        return;
+    var splits = storage.splits, rbSegments = storage.rbSegments, segments = storage.segments, largeSegments = storage.largeSegments;
+    log.debug("set cache" + (matchingKey ? " for key " + matchingKey : ''));
+    if (splits) {
+        splits.clear();
+        splits.update(preloadedData.flags || [], [], preloadedData.since || -1);
+    }
+    if (rbSegments) {
+        rbSegments.clear();
+        rbSegments.update(preloadedData.rbSegments || [], [], preloadedData.rbSince || -1);
+    }
+    var segmentsData = preloadedData.segments || {};
+    if (matchingKey) { // add memberships data (client-side)
+        var memberships = preloadedData.memberships && preloadedData.memberships[matchingKey];
+        if (!memberships && segmentsData) {
+            memberships = {
+                ms: {
+                    k: Object.keys(segmentsData).filter(function (segmentName) {
+                        var segmentKeys = segmentsData[segmentName];
+                        return segmentKeys.indexOf(matchingKey) > -1;
+                    }).map(function (segmentName) { return ({ n: segmentName }); })
+                }
+            };
         }
-        storage.segments.resetSegments({ k: mySegmentsData.map(function (s) { return ({ n: s }); }) });
+        if (memberships) {
+            if (memberships.ms)
+                segments.resetSegments(memberships.ms);
+            if (memberships.ls && largeSegments)
+                largeSegments.resetSegments(memberships.ls);
+        }
+    }
+    else { // add segments data (server-side)
+        Object.keys(segmentsData).forEach(function (segmentName) {
+            var segmentKeys = segmentsData[segmentName];
+            segments.update(segmentName, segmentKeys, [], -1);
+        });
+    }
+}
+/**
+ * Gets the preloaded data snapshot from the given synchronous storage.
+ * If `keys` are provided, the memberships for those keys is returned, to protect segments data.
+ * Otherwise, the segments data is returned.
+ */
+export function getCache(log, storage, keys) {
+    log.debug("get cache" + (keys ? " for keys " + keys : ''));
+    return {
+        since: storage.splits.getChangeNumber(),
+        flags: storage.splits.getAll(),
+        rbSince: storage.rbSegments.getChangeNumber(),
+        rbSegments: storage.rbSegments.getAll(),
+        segments: keys ?
+            undefined : // @ts-ignore accessing private prop
+            Object.keys(storage.segments.segmentCache).reduce(function (prev, cur) {
+                prev[cur] = setToArray(storage.segments.segmentCache[cur]);
+                return prev;
+            }, {}),
+        memberships: keys ?
+            keys.reduce(function (prev, key) {
+                if (storage.shared) {
+                    // Client-side segments
+                    // @ts-ignore accessing private prop
+                    var sharedStorage = storage.shared(key);
+                    prev[getMatching(key)] = {
+                        ms: {
+                            // @ts-ignore accessing private prop
+                            k: Object.keys(sharedStorage.segments.segmentCache).map(function (segmentName) { return ({ n: segmentName }); }),
+                        },
+                        ls: sharedStorage.largeSegments ? {
+                            // @ts-ignore accessing private prop
+                            k: Object.keys(sharedStorage.largeSegments.segmentCache).map(function (segmentName) { return ({ n: segmentName }); }),
+                        } : undefined
+                    };
+                }
+                else {
+                    prev[getMatching(key)] = {
+                        ms: {
+                            // Server-side segments
+                            // @ts-ignore accessing private prop
+                            k: Object.keys(storage.segments.segmentCache).reduce(function (prev, segmentName) {
+                                return storage.segments.segmentCache[segmentName].has(key) ?
+                                    prev.concat({ n: segmentName }) :
+                                    prev;
+                            }, [])
+                        },
+                        ls: {
+                            k: []
+                        }
+                    };
+                }
+                return prev;
+            }, {}) :
+            undefined
     };
 }

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;