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

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

@@ -31,8 +31,6 @@ 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,8 +149,6 @@ 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,39 +66,35 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
              */
             start: function () {
                 running = true;
-                // @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();
-                            }
-                        }
-                        else {
+                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();
                             }
+                            pushManager.start();
+                        }
+                        else {
+                            pollingManager.start();
+                        }
+                    }
+                    else {
+                        if (startFirstTime) {
+                            pollingManager.syncAll();
                         }
                     }
-                    startFirstTime = false;
-                });
+                }
+                // start periodic data recording (events, impressions, telemetry).
+                submitterManager.start(!isConsentGranted(settings));
+                startFirstTime = false;
             },
             /**
              * Method used to stop/pause the syncManager.

package/esm/utils/env/isLocalStorageAvailable.js

@@ -1,33 +1,12 @@
+/* eslint-disable no-undef */
 export function isLocalStorageAvailable() {
-    try {
-        // eslint-disable-next-line no-undef
-        return isValidStorageWrapper(localStorage);
-    }
-    catch (e) {
-        return false;
-    }
-}
-export 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;
     }
 }
-export function isWebStorage(wrapper) {
-    if (typeof wrapper.length === 'number') {
-        try {
-            wrapper.key(0);
-            return true;
-        }
-        catch (e) {
-            return false;
-        }
-    }
-    return false;
-}

package/esm/utils/inputValidation/index.js

@@ -10,5 +10,4 @@ export { validateTrafficType } from './trafficType';
 export { validateIfNotDestroyed, validateIfOperational } from './isOperational';
 export { validateSplitExistence } from './splitExistence';
 export { validateTrafficTypeExistence } from './trafficTypeExistence';
-export { validatePreloadedData } from './preloadedData';
 export { validateEvaluationOptions } from './eventProperties';

package/esm/utils/settingsValidation/index.js

@@ -5,6 +5,7 @@ import { STANDALONE_MODE, OPTIMIZED, LOCALHOST_MODE, DEBUG, FLAG_SPEC_VERSION }
 import { validImpressionsMode } from './impressionsMode';
 import { validateKey } from '../inputValidation/key';
 import { ERROR_MIN_CONFIG_PARAM, LOG_PREFIX_CLIENT_INSTANTIATION } from '../../logger/constants';
+import { validateRolloutPlan } from '../../storages/setRolloutPlan';
 // Exported for telemetry
 export var base = {
     // Define which kind of object you want to retrieve from SplitFactory
@@ -128,6 +129,9 @@ export function settingsValidation(config, validationParams) {
     // @ts-ignore, modify readonly prop
     if (storage)
         withDefaults.storage = storage(withDefaults);
+    // @ts-ignore, modify readonly prop
+    if (withDefaults.initialRolloutPlan)
+        withDefaults.initialRolloutPlan = validateRolloutPlan(log, withDefaults);
     // Validate key and TT (for client-side)
     var maybeKey = withDefaults.core.key;
     if (validationParams.acceptKey) {

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 Promise.resolve(true); }; // to emit SDK_READY_FROM_CACHE
+    result.validateCache = function () { return 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.4.2-rc.3",
+  "version": "2.5.0-rc.1",
   "description": "Split JavaScript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/evaluator/convertions/index.ts

@@ -1,3 +1,5 @@
+import { IBetweenMatcherData } from '../../dtos/types';
+
 export function zeroSinceHH(millisSinceEpoch: number): number {
   return new Date(millisSinceEpoch).setUTCHours(0, 0, 0, 0);
 }
@@ -5,3 +7,11 @@ export function zeroSinceHH(millisSinceEpoch: number): number {
 export function zeroSinceSS(millisSinceEpoch: number): number {
   return new Date(millisSinceEpoch).setUTCSeconds(0, 0);
 }
+
+export function betweenDateTimeTransform(betweenMatcherData: IBetweenMatcherData): IBetweenMatcherData {
+  return {
+    dataType: betweenMatcherData.dataType,
+    start: zeroSinceSS(betweenMatcherData.start),
+    end: zeroSinceSS(betweenMatcherData.end)
+  };
+}

package/src/evaluator/matchersTransform/index.ts

@@ -3,7 +3,7 @@ import { matcherTypes, matcherTypesMapper, matcherDataTypes } from '../matchers/
 import { segmentTransform } from './segment';
 import { whitelistTransform } from './whitelist';
 import { numericTransform } from './unaryNumeric';
-import { zeroSinceHH, zeroSinceSS } from '../convertions';
+import { zeroSinceHH, zeroSinceSS, betweenDateTimeTransform } from '../convertions';
 import { IBetweenMatcherData, IInLargeSegmentMatcherData, IInSegmentMatcherData, ISplitMatcher, IUnaryNumericMatcherData } from '../../dtos/types';
 import { IMatcherDto } from '../types';
 
@@ -32,7 +32,7 @@ export function matchersTransform(matchers: ISplitMatcher[]): IMatcherDto[] {
     let type = matcherTypesMapper(matcherType);
     // As default input data type we use string (even for ALL_KEYS)
     let dataType = matcherDataTypes.STRING;
-    let value = undefined;
+    let value;
 
     if (type === matcherTypes.IN_SEGMENT) {
       value = segmentTransform(userDefinedSegmentMatcherData as IInSegmentMatcherData);
@@ -60,8 +60,7 @@ export function matchersTransform(matchers: ISplitMatcher[]): IMatcherDto[] {
       dataType = matcherDataTypes.NUMBER;
 
       if (value.dataType === 'DATETIME') {
-        value.start = zeroSinceSS(value.start);
-        value.end = zeroSinceSS(value.end);
+        value = betweenDateTimeTransform(value);
         dataType = matcherDataTypes.DATETIME;
       }
     } else if (type === matcherTypes.BETWEEN_SEMVER) {

package/src/sdkClient/sdkClientMethodCS.ts

@@ -9,13 +9,15 @@ import { RETRIEVE_CLIENT_DEFAULT, NEW_SHARED_CLIENT, RETRIEVE_CLIENT_EXISTING, L
 import { SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
 import { ISdkFactoryContext } from '../sdkFactory/types';
 import { buildInstanceId } from './identity';
+import { setRolloutPlan } from '../storages/setRolloutPlan';
+import { ISegmentsCacheSync } from '../storages/types';
 
 /**
  * Factory of client method for the client-side API variant where TT is ignored.
  * Therefore, clients don't have a bound TT for the track method.
  */
 export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitIO.SplitKey) => SplitIO.IBrowserClient {
-  const { clients, storage, syncManager, sdkReadinessManager, settings: { core: { key }, log } } = params;
+  const { clients, storage, syncManager, sdkReadinessManager, settings: { core: { key }, log, initialRolloutPlan } } = params;
 
   const mainClientInstance = clientCSDecorator(
     log,
@@ -56,6 +58,10 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
         sharedSdkReadiness.readinessManager.segments.emit(SDK_SEGMENTS_ARRIVED);
       });
 
+      if (sharedStorage && initialRolloutPlan) {
+        setRolloutPlan(log, initialRolloutPlan, { segments: sharedStorage.segments as ISegmentsCacheSync, largeSegments: sharedStorage.largeSegments as ISegmentsCacheSync }, matchingKey);
+      }
+
       // 3 possibilities:
       // - Standalone mode: both syncManager and sharedSyncManager are defined
       // - Consumer mode: both syncManager and sharedSyncManager are undefined

package/src/sdkFactory/index.ts

@@ -14,6 +14,9 @@ import { strategyOptimizedFactory } from '../trackers/strategy/strategyOptimized
 import { strategyNoneFactory } from '../trackers/strategy/strategyNone';
 import { uniqueKeysTrackerFactory } from '../trackers/uniqueKeysTracker';
 import { DEBUG, OPTIMIZED } from '../utils/constants';
+import { setRolloutPlan } from '../storages/setRolloutPlan';
+import { IStorageSync } from '../storages/types';
+import { getMatching } from '../utils/key';
 
 /**
  * Modular SDK factory
@@ -24,7 +27,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
     syncManagerFactory, SignalListener, impressionsObserverFactory,
     integrationsManagerFactory, sdkManagerFactory, sdkClientMethodFactory,
     filterAdapterFactory, lazyInit } = params;
-  const { log, sync: { impressionsMode } } = settings;
+  const { log, sync: { impressionsMode }, initialRolloutPlan, core: { key } } = settings;
 
   // @TODO handle non-recoverable errors, such as, global `fetch` not available, invalid SDK Key, etc.
   // On non-recoverable errors, we should mark the SDK as destroyed and not start synchronization.
@@ -43,7 +46,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
 
   const storage = storageFactory({
     settings,
-    onReadyCb: (error) => {
+    onReadyCb(error) {
       if (error) {
         // If storage fails to connect, SDK_READY_TIMED_OUT event is emitted immediately. Review when timeout and non-recoverable errors are reworked
         readiness.timeout();
@@ -52,11 +55,16 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
       readiness.splits.emit(SDK_SPLITS_ARRIVED);
       readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
     },
-    onReadyFromCacheCb: () => {
+    onReadyFromCacheCb() {
       readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
     }
   });
-  // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
+
+  if (initialRolloutPlan) {
+    setRolloutPlan(log, initialRolloutPlan, storage as IStorageSync, key && getMatching(key));
+    if ((storage as IStorageSync).splits.getChangeNumber() > -1) readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
+  }
+
   const clients: Record<string, SplitIO.IBasicClient> = {};
   const telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
   const integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings, storage, telemetryTracker });

package/src/storages/getRolloutPlan.ts

@@ -0,0 +1,72 @@
+import SplitIO from '../../types/splitio';
+import { IStorageSync } from './types';
+import { setToArray } from '../utils/lang/sets';
+import { getMatching } from '../utils/key';
+import { ILogger } from '../logger/types';
+import { RolloutPlan } from './types';
+import { IMembershipsResponse, IMySegmentsResponse } from '../dtos/types';
+
+/**
+ * Gets the rollout plan snapshot from the given synchronous storage.
+ */
+export function getRolloutPlan(log: ILogger, storage: IStorageSync, options: SplitIO.RolloutPlanOptions = {}): RolloutPlan {
+
+  const { keys, exposeSegments } = options;
+  const { splits, segments, rbSegments } = storage;
+
+  log.debug(`storage: get feature flags${keys ? `, and memberships for keys ${keys}` : ''}${exposeSegments ? ', and segments' : ''}`);
+
+  return {
+    splitChanges: {
+      ff: {
+        t: splits.getChangeNumber(),
+        s: -1,
+        d: splits.getAll(),
+      },
+      rbs: {
+        t: rbSegments.getChangeNumber(),
+        s: -1,
+        d: rbSegments.getAll(),
+      }
+    },
+    segmentChanges: exposeSegments ? // @ts-ignore accessing private prop
+      Object.keys(segments.segmentCache).map(segmentName => ({
+        name: segmentName, // @ts-ignore
+        added: setToArray(segments.segmentCache[segmentName] as Set<string>),
+        removed: [],
+        since: -1,
+        till: segments.getChangeNumber(segmentName)!
+      })) :
+      undefined,
+    memberships: keys ?
+      keys.reduce<Record<string, IMembershipsResponse>>((prev, key) => {
+        const matchingKey = getMatching(key);
+        if (storage.shared) { // Client-side segments
+          const sharedStorage = storage.shared(matchingKey);
+          prev[matchingKey] = {
+            ms: { // @ts-ignore
+              k: Object.keys(sharedStorage.segments.segmentCache).map(segmentName => ({ n: segmentName })),
+            },
+            ls: sharedStorage.largeSegments ? { // @ts-ignore
+              k: Object.keys(sharedStorage.largeSegments.segmentCache).map(segmentName => ({ n: segmentName })),
+            } : undefined
+          };
+        } else { // Server-side segments
+          prev[matchingKey] = {
+            ms: { // @ts-ignore
+              k: Object.keys(storage.segments.segmentCache).reduce<IMySegmentsResponse['k']>((prev, segmentName) => { // @ts-ignore
+                return storage.segments.segmentCache[segmentName].has(matchingKey) ?
+                  prev!.concat({ n: segmentName }) :
+                  prev;
+              }, [])
+            },
+            ls: {
+              k: []
+            }
+          };
+        }
+        return prev;
+      }, {}) :
+      undefined
+  };
+}

package/src/storages/inLocalStorage/MySegmentsCacheInLocal.ts

@@ -3,19 +3,16 @@ 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, storage: StorageAdapter) {
+  constructor(log: ILogger, keys: MySegmentsKeyBuilder) {
     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
   }
 
@@ -23,8 +20,8 @@ export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
     const segmentKey = this.keys.buildSegmentNameKey(name);
 
     try {
-      if (this.storage.getItem(segmentKey) === DEFINED) return false;
-      this.storage.setItem(segmentKey, DEFINED);
+      if (localStorage.getItem(segmentKey) === DEFINED) return false;
+      localStorage.setItem(segmentKey, DEFINED);
       return true;
     } catch (e) {
       this.log.error(LOG_PREFIX + e);
@@ -36,8 +33,8 @@ export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
     const segmentKey = this.keys.buildSegmentNameKey(name);
 
     try {
-      if (this.storage.getItem(segmentKey) !== DEFINED) return false;
-      this.storage.removeItem(segmentKey);
+      if (localStorage.getItem(segmentKey) !== DEFINED) return false;
+      localStorage.removeItem(segmentKey);
       return true;
     } catch (e) {
       this.log.error(LOG_PREFIX + e);
@@ -46,16 +43,18 @@ export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
   }
 
   isInSegment(name: string): boolean {
-    return this.storage.getItem(this.keys.buildSegmentNameKey(name)) === DEFINED;
+    return localStorage.getItem(this.keys.buildSegmentNameKey(name)) === DEFINED;
   }
 
   getRegisteredSegments(): 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;
+    // 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[]);
   }
 
   getKeysCount() {
@@ -64,8 +63,8 @@ export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
 
   protected setChangeNumber(changeNumber?: number) {
     try {
-      if (changeNumber) this.storage.setItem(this.keys.buildTillKey(), changeNumber + '');
-      else this.storage.removeItem(this.keys.buildTillKey());
+      if (changeNumber) localStorage.setItem(this.keys.buildTillKey(), changeNumber + '');
+      else localStorage.removeItem(this.keys.buildTillKey());
     } catch (e) {
       this.log.error(e);
     }
@@ -73,7 +72,7 @@ export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
 
   getChangeNumber() {
     const n = -1;
-    let value: string | number | null = this.storage.getItem(this.keys.buildTillKey());
+    let value: string | number | null = localStorage.getItem(this.keys.buildTillKey());
 
     if (value !== null) {
       value = parseInt(value, 10);

package/src/storages/inLocalStorage/RBSegmentsCacheInLocal.ts

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