@splitsoftware/splitio-commons 2.5.0 → 2.5.1-rc.1

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 + 'Error calling wrapper `getItem` method: ' + e);
+            }));
+        },
+        save: function () {
+            return savePromise = savePromise.then(function () {
+                return Promise.resolve(wrapper.setItem(prefix, JSON.stringify(cache)));
+            }).catch(function (e) {
+                log.error(LOG_PREFIX + 'Error calling wrapper `setItem` method: ' + 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, initialRolloutPlan = settings.initialRolloutPlan;
     // 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/updaters/mySegmentsUpdater.js

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

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

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

package/esm/sync/syncManagerOnline.js

@@ -66,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.

package/esm/utils/env/isLocalStorageAvailable.js

@@ -10,3 +10,22 @@ export function isLocalStorageAvailable() {
         return false;
     }
 }
+export function isValidStorageWrapper(wrapper) {
+    return wrapper !== null &&
+        typeof wrapper === 'object' &&
+        typeof wrapper.setItem === 'function' &&
+        typeof wrapper.getItem === 'function' &&
+        typeof wrapper.removeItem === 'function';
+}
+export function isWebStorage(wrapper) {
+    if (typeof wrapper.length === 'number') {
+        try {
+            wrapper.key(0);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    return false;
+}

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

@@ -3,7 +3,7 @@ import { ERROR_STORAGE_INVALID } from '../../../logger/constants';
 import { LOCALHOST_MODE, STANDALONE_MODE, STORAGE_PLUGGABLE, STORAGE_LOCALSTORAGE, STORAGE_MEMORY } from '../../../utils/constants';
 export function __InLocalStorageMockFactory(params) {
     var result = InMemoryStorageCSFactory(params);
-    result.validateCache = function () { return true; }; // to emit SDK_READY_FROM_CACHE
+    result.validateCache = function () { return Promise.resolve(true); }; // to emit SDK_READY_FROM_CACHE
     return result;
 }
 __InLocalStorageMockFactory.type = STORAGE_MEMORY;

package/package.json

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

package/src/logger/messages/info.ts

@@ -11,7 +11,7 @@ export const codesInfo: [number, string][] = codesWarn.concat([
   [c.IMPRESSION, c.LOG_PREFIX_IMPRESSIONS_TRACKER +'Feature flag: %s. Key: %s. Evaluation: %s. Label: %s'],
   [c.IMPRESSION_QUEUEING, c.LOG_PREFIX_IMPRESSIONS_TRACKER +'Queueing corresponding impression.'],
   [c.NEW_SHARED_CLIENT, 'New shared client instance created.'],
-  [c.NEW_FACTORY, 'New Split SDK instance created.'],
+  [c.NEW_FACTORY, 'New Split SDK instance created. %s'],
   [c.EVENTS_TRACKER_SUCCESS, c.LOG_PREFIX_EVENTS_TRACKER + 'Successfully queued %s'],
   [c.IMPRESSIONS_TRACKER_SUCCESS, c.LOG_PREFIX_IMPRESSIONS_TRACKER + 'Successfully stored %s impression(s).'],
   [c.USER_CONSENT_UPDATED, 'UserConsent: consent status changed from %s to %s.'],

package/src/sdkFactory/index.ts

@@ -113,7 +113,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
     initCallbacks.length = 0;
   }
 
-  log.info(NEW_FACTORY);
+  log.info(NEW_FACTORY, [settings.version]);
 
   // @ts-ignore
   return objectAssign({

package/src/storages/inLocalStorage/MySegmentsCacheInLocal.ts

@@ -3,16 +3,19 @@ import { isNaNNumber } from '../../utils/lang';
 import { AbstractMySegmentsCacheSync } from '../AbstractMySegmentsCacheSync';
 import type { MySegmentsKeyBuilder } from '../KeyBuilderCS';
 import { LOG_PREFIX, DEFINED } from './constants';
+import { StorageAdapter } from '../types';
 
 export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
 
   private readonly keys: MySegmentsKeyBuilder;
   private readonly log: ILogger;
+  private readonly storage: StorageAdapter;
 
-  constructor(log: ILogger, keys: MySegmentsKeyBuilder) {
+  constructor(log: ILogger, keys: MySegmentsKeyBuilder, storage: StorageAdapter) {
     super();
     this.log = log;
     this.keys = keys;
+    this.storage = storage;
     // There is not need to flush segments cache like splits cache, since resetSegments receives the up-to-date list of active segments
   }
 
@@ -20,8 +23,8 @@ export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
     const segmentKey = this.keys.buildSegmentNameKey(name);
 
     try {
-      if (localStorage.getItem(segmentKey) === DEFINED) return false;
-      localStorage.setItem(segmentKey, DEFINED);
+      if (this.storage.getItem(segmentKey) === DEFINED) return false;
+      this.storage.setItem(segmentKey, DEFINED);
       return true;
     } catch (e) {
       this.log.error(LOG_PREFIX + e);
@@ -33,8 +36,8 @@ export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
     const segmentKey = this.keys.buildSegmentNameKey(name);
 
     try {
-      if (localStorage.getItem(segmentKey) !== DEFINED) return false;
-      localStorage.removeItem(segmentKey);
+      if (this.storage.getItem(segmentKey) !== DEFINED) return false;
+      this.storage.removeItem(segmentKey);
       return true;
     } catch (e) {
       this.log.error(LOG_PREFIX + e);
@@ -43,18 +46,16 @@ export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
   }
 
   isInSegment(name: string): boolean {
-    return localStorage.getItem(this.keys.buildSegmentNameKey(name)) === DEFINED;
+    return this.storage.getItem(this.keys.buildSegmentNameKey(name)) === DEFINED;
   }
 
   getRegisteredSegments(): string[] {
-    // Scan current values from localStorage
-    return Object.keys(localStorage).reduce((accum, key) => {
-      let segmentName = this.keys.extractSegmentName(key);
-
-      if (segmentName) accum.push(segmentName);
-
-      return accum;
-    }, [] as string[]);
+    const registeredSegments: string[] = [];
+    for (let i = 0, len = this.storage.length; i < len; i++) {
+      const segmentName = this.keys.extractSegmentName(this.storage.key(i)!);
+      if (segmentName) registeredSegments.push(segmentName);
+    }
+    return registeredSegments;
   }
 
   getKeysCount() {
@@ -63,8 +64,8 @@ export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
 
   protected setChangeNumber(changeNumber?: number) {
     try {
-      if (changeNumber) localStorage.setItem(this.keys.buildTillKey(), changeNumber + '');
-      else localStorage.removeItem(this.keys.buildTillKey());
+      if (changeNumber) this.storage.setItem(this.keys.buildTillKey(), changeNumber + '');
+      else this.storage.removeItem(this.keys.buildTillKey());
     } catch (e) {
       this.log.error(e);
     }
@@ -72,7 +73,7 @@ export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
 
   getChangeNumber() {
     const n = -1;
-    let value: string | number | null = localStorage.getItem(this.keys.buildTillKey());
+    let value: string | number | null = this.storage.getItem(this.keys.buildTillKey());
 
     if (value !== null) {
       value = parseInt(value, 10);

package/src/storages/inLocalStorage/RBSegmentsCacheInLocal.ts

@@ -5,22 +5,24 @@ import { isFiniteNumber, isNaNNumber, toNumber } from '../../utils/lang';
 import { setToArray } from '../../utils/lang/sets';
 import { usesSegments } from '../AbstractSplitsCacheSync';
 import { KeyBuilderCS } from '../KeyBuilderCS';
-import { IRBSegmentsCacheSync } from '../types';
+import { IRBSegmentsCacheSync, StorageAdapter } from '../types';
 import { LOG_PREFIX } from './constants';
 
 export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
 
   private readonly keys: KeyBuilderCS;
   private readonly log: ILogger;
+  private readonly storage: StorageAdapter;
 
-  constructor(settings: ISettings, keys: KeyBuilderCS) {
+  constructor(settings: ISettings, keys: KeyBuilderCS, storage: StorageAdapter) {
     this.keys = keys;
     this.log = settings.log;
+    this.storage = storage;
   }
 
   clear() {
     this.getNames().forEach(name => this.remove(name));
-    localStorage.removeItem(this.keys.buildRBSegmentsTillKey());
+    this.storage.removeItem(this.keys.buildRBSegmentsTillKey());
   }
 
   update(toAdd: IRBSegment[], toRemove: IRBSegment[], changeNumber: number): boolean {
@@ -31,8 +33,8 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
 
   private setChangeNumber(changeNumber: number) {
     try {
-      localStorage.setItem(this.keys.buildRBSegmentsTillKey(), changeNumber + '');
-      localStorage.setItem(this.keys.buildLastUpdatedKey(), Date.now() + '');
+      this.storage.setItem(this.keys.buildRBSegmentsTillKey(), changeNumber + '');
+      this.storage.setItem(this.keys.buildLastUpdatedKey(), Date.now() + '');
     } catch (e) {
       this.log.error(LOG_PREFIX + e);
     }
@@ -40,20 +42,19 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
 
   private updateSegmentCount(diff: number) {
     const segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
-    const count = toNumber(localStorage.getItem(segmentsCountKey)) + diff;
-    // @ts-expect-error
-    if (count > 0) localStorage.setItem(segmentsCountKey, count);
-    else localStorage.removeItem(segmentsCountKey);
+    const count = toNumber(this.storage.getItem(segmentsCountKey)) + diff;
+    if (count > 0) this.storage.setItem(segmentsCountKey, count + '');
+    else this.storage.removeItem(segmentsCountKey);
   }
 
   private add(rbSegment: IRBSegment): boolean {
     try {
       const name = rbSegment.name;
       const rbSegmentKey = this.keys.buildRBSegmentKey(name);
-      const rbSegmentFromLocalStorage = localStorage.getItem(rbSegmentKey);
-      const previous = rbSegmentFromLocalStorage ? JSON.parse(rbSegmentFromLocalStorage) : null;
+      const rbSegmentFromStorage = this.storage.getItem(rbSegmentKey);
+      const previous = rbSegmentFromStorage ? JSON.parse(rbSegmentFromStorage) : null;
 
-      localStorage.setItem(rbSegmentKey, JSON.stringify(rbSegment));
+      this.storage.setItem(rbSegmentKey, JSON.stringify(rbSegment));
 
       let usesSegmentsDiff = 0;
       if (previous && usesSegments(previous)) usesSegmentsDiff--;
@@ -72,7 +73,7 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
       const rbSegment = this.get(name);
       if (!rbSegment) return false;
 
-      localStorage.removeItem(this.keys.buildRBSegmentKey(name));
+      this.storage.removeItem(this.keys.buildRBSegmentKey(name));
 
       if (usesSegments(rbSegment)) this.updateSegmentCount(-1);
 
@@ -84,13 +85,13 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
   }
 
   private getNames(): string[] {
-    const len = localStorage.length;
+    const len = this.storage.length;
     const accum = [];
 
     let cur = 0;
 
     while (cur < len) {
-      const key = localStorage.key(cur);
+      const key = this.storage.key(cur);
 
       if (key != null && this.keys.isRBSegmentKey(key)) accum.push(this.keys.extractKey(key));
 
@@ -101,7 +102,7 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
   }
 
   get(name: string): IRBSegment | null {
-    const item = localStorage.getItem(this.keys.buildRBSegmentKey(name));
+    const item = this.storage.getItem(this.keys.buildRBSegmentKey(name));
     return item && JSON.parse(item);
   }
 
@@ -117,7 +118,7 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
 
   getChangeNumber(): number {
     const n = -1;
-    let value: string | number | null = localStorage.getItem(this.keys.buildRBSegmentsTillKey());
+    let value: string | number | null = this.storage.getItem(this.keys.buildRBSegmentsTillKey());
 
     if (value !== null) {
       value = parseInt(value, 10);
@@ -129,7 +130,7 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
   }
 
   usesSegments(): boolean {
-    const storedCount = localStorage.getItem(this.keys.buildSplitsWithSegmentCountKey());
+    const storedCount = this.storage.getItem(this.keys.buildSplitsWithSegmentCountKey());
     const splitsWithSegmentsCount = storedCount === null ? 0 : toNumber(storedCount);
 
     return isFiniteNumber(splitsWithSegmentsCount) ?