@splitsoftware/splitio-commons 2.5.0-rc.0 → 11.5.0-rc.0

package/src/storages/inLocalStorage/MySegmentsCacheInLocal.ts

@@ -1,86 +0,0 @@
-import { ILogger } from '../../logger/types';
-import { isNaNNumber } from '../../utils/lang';
-import { AbstractMySegmentsCacheSync } from '../AbstractMySegmentsCacheSync';
-import type { MySegmentsKeyBuilder } from '../KeyBuilderCS';
-import { LOG_PREFIX, DEFINED } from './constants';
-
-export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
-
-  private readonly keys: MySegmentsKeyBuilder;
-  private readonly log: ILogger;
-
-  constructor(log: ILogger, keys: MySegmentsKeyBuilder) {
-    super();
-    this.log = log;
-    this.keys = keys;
-    // There is not need to flush segments cache like splits cache, since resetSegments receives the up-to-date list of active segments
-  }
-
-  protected addSegment(name: string): boolean {
-    const segmentKey = this.keys.buildSegmentNameKey(name);
-
-    try {
-      if (localStorage.getItem(segmentKey) === DEFINED) return false;
-      localStorage.setItem(segmentKey, DEFINED);
-      return true;
-    } catch (e) {
-      this.log.error(LOG_PREFIX + e);
-      return false;
-    }
-  }
-
-  protected removeSegment(name: string): boolean {
-    const segmentKey = this.keys.buildSegmentNameKey(name);
-
-    try {
-      if (localStorage.getItem(segmentKey) !== DEFINED) return false;
-      localStorage.removeItem(segmentKey);
-      return true;
-    } catch (e) {
-      this.log.error(LOG_PREFIX + e);
-      return false;
-    }
-  }
-
-  isInSegment(name: string): boolean {
-    return localStorage.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[]);
-  }
-
-  getKeysCount() {
-    return 1;
-  }
-
-  protected setChangeNumber(changeNumber?: number) {
-    try {
-      if (changeNumber) localStorage.setItem(this.keys.buildTillKey(), changeNumber + '');
-      else localStorage.removeItem(this.keys.buildTillKey());
-    } catch (e) {
-      this.log.error(e);
-    }
-  }
-
-  getChangeNumber() {
-    const n = -1;
-    let value: string | number | null = localStorage.getItem(this.keys.buildTillKey());
-
-    if (value !== null) {
-      value = parseInt(value, 10);
-
-      return isNaNNumber(value) ? n : value;
-    }
-
-    return n;
-  }
-
-}

package/src/storages/inLocalStorage/RBSegmentsCacheInLocal.ts

@@ -1,140 +0,0 @@
-import { IRBSegment } from '../../dtos/types';
-import { ILogger } from '../../logger/types';
-import { ISettings } from '../../types';
-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 { LOG_PREFIX } from './constants';
-
-export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
-
-  private readonly keys: KeyBuilderCS;
-  private readonly log: ILogger;
-
-  constructor(settings: ISettings, keys: KeyBuilderCS) {
-    this.keys = keys;
-    this.log = settings.log;
-  }
-
-  clear() {
-    this.getNames().forEach(name => this.remove(name));
-    localStorage.removeItem(this.keys.buildRBSegmentsTillKey());
-  }
-
-  update(toAdd: IRBSegment[], toRemove: IRBSegment[], changeNumber: number): boolean {
-    this.setChangeNumber(changeNumber);
-    const updated = toAdd.map(toAdd => this.add(toAdd)).some(result => result);
-    return toRemove.map(toRemove => this.remove(toRemove.name)).some(result => result) || updated;
-  }
-
-  private setChangeNumber(changeNumber: number) {
-    try {
-      localStorage.setItem(this.keys.buildRBSegmentsTillKey(), changeNumber + '');
-      localStorage.setItem(this.keys.buildLastUpdatedKey(), Date.now() + '');
-    } catch (e) {
-      this.log.error(LOG_PREFIX + e);
-    }
-  }
-
-  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);
-  }
-
-  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;
-
-      localStorage.setItem(rbSegmentKey, JSON.stringify(rbSegment));
-
-      let usesSegmentsDiff = 0;
-      if (previous && usesSegments(previous)) usesSegmentsDiff--;
-      if (usesSegments(rbSegment)) usesSegmentsDiff++;
-      if (usesSegmentsDiff !== 0) this.updateSegmentCount(usesSegmentsDiff);
-
-      return true;
-    } catch (e) {
-      this.log.error(LOG_PREFIX + e);
-      return false;
-    }
-  }
-
-  private remove(name: string): boolean {
-    try {
-      const rbSegment = this.get(name);
-      if (!rbSegment) return false;
-
-      localStorage.removeItem(this.keys.buildRBSegmentKey(name));
-
-      if (usesSegments(rbSegment)) this.updateSegmentCount(-1);
-
-      return true;
-    } catch (e) {
-      this.log.error(LOG_PREFIX + e);
-      return false;
-    }
-  }
-
-  private getNames(): string[] {
-    const len = localStorage.length;
-    const accum = [];
-
-    let cur = 0;
-
-    while (cur < len) {
-      const key = localStorage.key(cur);
-
-      if (key != null && this.keys.isRBSegmentKey(key)) accum.push(this.keys.extractKey(key));
-
-      cur++;
-    }
-
-    return accum;
-  }
-
-  get(name: string): IRBSegment | null {
-    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();
-    return namesArray.every(name => namesInStorage.indexOf(name) !== -1);
-  }
-
-  getChangeNumber(): number {
-    const n = -1;
-    let value: string | number | null = localStorage.getItem(this.keys.buildRBSegmentsTillKey());
-
-    if (value !== null) {
-      value = parseInt(value, 10);
-
-      return isNaNNumber(value) ? n : value;
-    }
-
-    return n;
-  }
-
-  usesSegments(): boolean {
-    const storedCount = localStorage.getItem(this.keys.buildSplitsWithSegmentCountKey());
-    const splitsWithSegmentsCount = storedCount === null ? 0 : toNumber(storedCount);
-
-    return isFiniteNumber(splitsWithSegmentsCount) ?
-      splitsWithSegmentsCount > 0 :
-      true;
-  }
-
-}

package/src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -1,244 +0,0 @@
-import { ISplit } from '../../dtos/types';
-import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';
-import { isFiniteNumber, toNumber, isNaNNumber } from '../../utils/lang';
-import { KeyBuilderCS } from '../KeyBuilderCS';
-import { ILogger } from '../../logger/types';
-import { LOG_PREFIX } from './constants';
-import { ISettings } from '../../types';
-import { setToArray } from '../../utils/lang/sets';
-
-/**
- * ISplitsCacheSync implementation that stores split definitions in browser LocalStorage.
- */
-export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
-
-  private readonly keys: KeyBuilderCS;
-  private readonly log: ILogger;
-  private readonly flagSetsFilter: string[];
-  private hasSync?: boolean;
-
-  constructor(settings: ISettings, keys: KeyBuilderCS) {
-    super();
-    this.keys = keys;
-    this.log = settings.log;
-    this.flagSetsFilter = settings.sync.__splitFiltersValidation.groupedFilters.bySet;
-  }
-
-  private _decrementCount(key: string) {
-    const count = toNumber(localStorage.getItem(key)) - 1;
-    // @ts-expect-error
-    if (count > 0) localStorage.setItem(key, count);
-    else localStorage.removeItem(key);
-  }
-
-  private _decrementCounts(split: ISplit) {
-    try {
-      const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-      this._decrementCount(ttKey);
-
-      if (usesSegments(split)) {
-        const segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
-        this._decrementCount(segmentsCountKey);
-      }
-    } catch (e) {
-      this.log.error(LOG_PREFIX + e);
-    }
-  }
-
-  private _incrementCounts(split: ISplit) {
-    try {
-      const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-      // @ts-expect-error
-      localStorage.setItem(ttKey, toNumber(localStorage.getItem(ttKey)) + 1);
-
-      if (usesSegments(split)) {
-        const segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
-        // @ts-expect-error
-        localStorage.setItem(segmentsCountKey, toNumber(localStorage.getItem(segmentsCountKey)) + 1);
-      }
-    } catch (e) {
-      this.log.error(LOG_PREFIX + e);
-    }
-  }
-
-
-  /**
-   * Removes all splits cache related data from localStorage (splits, counters, changeNumber and lastUpdated).
-   * We cannot simply call `localStorage.clear()` since that implies removing user items from the storage.
-   */
-  clear() {
-    // collect item keys
-    const len = localStorage.length;
-    const accum = [];
-    for (let cur = 0; cur < len; cur++) {
-      const key = localStorage.key(cur);
-      if (key != null && this.keys.isSplitsCacheKey(key)) accum.push(key);
-    }
-    // remove items
-    accum.forEach(key => {
-      localStorage.removeItem(key);
-    });
-
-    this.hasSync = false;
-  }
-
-  addSplit(split: ISplit) {
-    try {
-      const name = split.name;
-      const splitKey = this.keys.buildSplitKey(name);
-      const splitFromLocalStorage = localStorage.getItem(splitKey);
-      const previousSplit = splitFromLocalStorage ? JSON.parse(splitFromLocalStorage) : null;
-
-      if (previousSplit) {
-        this._decrementCounts(previousSplit);
-        this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
-      }
-
-      localStorage.setItem(splitKey, JSON.stringify(split));
-
-      this._incrementCounts(split);
-      this.addToFlagSets(split);
-
-      return true;
-    } catch (e) {
-      this.log.error(LOG_PREFIX + e);
-      return false;
-    }
-  }
-
-  removeSplit(name: string): boolean {
-    try {
-      const split = this.getSplit(name);
-      if (!split) return false;
-
-      localStorage.removeItem(this.keys.buildSplitKey(name));
-
-      this._decrementCounts(split);
-      this.removeFromFlagSets(split.name, split.sets);
-
-      return true;
-    } catch (e) {
-      this.log.error(LOG_PREFIX + e);
-      return false;
-    }
-  }
-
-  getSplit(name: string): ISplit | null {
-    const item = localStorage.getItem(this.keys.buildSplitKey(name));
-    return item && JSON.parse(item);
-  }
-
-  setChangeNumber(changeNumber: number): boolean {
-    try {
-      localStorage.setItem(this.keys.buildSplitsTillKey(), changeNumber + '');
-      // update "last updated" timestamp with current time
-      localStorage.setItem(this.keys.buildLastUpdatedKey(), Date.now() + '');
-      this.hasSync = true;
-      return true;
-    } catch (e) {
-      this.log.error(LOG_PREFIX + e);
-      return false;
-    }
-  }
-
-  getChangeNumber(): number {
-    const n = -1;
-    let value: string | number | null = localStorage.getItem(this.keys.buildSplitsTillKey());
-
-    if (value !== null) {
-      value = parseInt(value, 10);
-
-      return isNaNNumber(value) ? n : value;
-    }
-
-    return n;
-  }
-
-  getSplitNames(): string[] {
-    const len = localStorage.length;
-    const accum = [];
-
-    let cur = 0;
-
-    while (cur < len) {
-      const key = localStorage.key(cur);
-
-      if (key != null && this.keys.isSplitKey(key)) accum.push(this.keys.extractKey(key));
-
-      cur++;
-    }
-
-    return accum;
-  }
-
-  trafficTypeExists(trafficType: string): boolean {
-    const ttCount = toNumber(localStorage.getItem(this.keys.buildTrafficTypeKey(trafficType)));
-    return isFiniteNumber(ttCount) && ttCount > 0;
-  }
-
-  usesSegments() {
-    // If cache hasn't been synchronized with the cloud, assume we need them.
-    if (!this.hasSync) return true;
-
-    const storedCount = localStorage.getItem(this.keys.buildSplitsWithSegmentCountKey());
-    const splitsWithSegmentsCount = storedCount === null ? 0 : toNumber(storedCount);
-
-    return isFiniteNumber(splitsWithSegmentsCount) ?
-      splitsWithSegmentsCount > 0 :
-      true;
-  }
-
-  getNamesByFlagSets(flagSets: string[]): Set<string>[] {
-    return flagSets.map(flagSet => {
-      const flagSetKey = this.keys.buildFlagSetKey(flagSet);
-      const flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
-
-      return new Set(flagSetFromLocalStorage ? JSON.parse(flagSetFromLocalStorage) : []);
-    });
-  }
-
-  private addToFlagSets(featureFlag: ISplit) {
-    if (!featureFlag.sets) return;
-
-    featureFlag.sets.forEach(featureFlagSet => {
-
-      if (this.flagSetsFilter.length > 0 && !this.flagSetsFilter.some(filterFlagSet => filterFlagSet === featureFlagSet)) return;
-
-      const flagSetKey = this.keys.buildFlagSetKey(featureFlagSet);
-
-      const flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
-
-      const flagSetCache = new Set(flagSetFromLocalStorage ? JSON.parse(flagSetFromLocalStorage) : []);
-      flagSetCache.add(featureFlag.name);
-
-      localStorage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
-    });
-  }
-
-  private removeFromFlagSets(featureFlagName: string, flagSets?: string[]) {
-    if (!flagSets) return;
-
-    flagSets.forEach(flagSet => {
-      this.removeNames(flagSet, featureFlagName);
-    });
-  }
-
-  private removeNames(flagSetName: string, featureFlagName: string) {
-    const flagSetKey = this.keys.buildFlagSetKey(flagSetName);
-
-    const flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
-
-    if (!flagSetFromLocalStorage) return;
-
-    const flagSetCache = new Set(JSON.parse(flagSetFromLocalStorage));
-    flagSetCache.delete(featureFlagName);
-
-    if (flagSetCache.size === 0) {
-      localStorage.removeItem(flagSetKey);
-      return;
-    }
-
-    localStorage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
-  }
-
-}

package/src/storages/inLocalStorage/constants.ts

@@ -1,2 +0,0 @@
-export const LOG_PREFIX = 'storage:localstorage: ';
-export const DEFINED = '1';

package/src/storages/inLocalStorage/index.ts

@@ -1,83 +0,0 @@
-import { ImpressionsCacheInMemory } from '../inMemory/ImpressionsCacheInMemory';
-import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
-import { EventsCacheInMemory } from '../inMemory/EventsCacheInMemory';
-import { IStorageFactoryParams, IStorageSync, IStorageSyncFactory } from '../types';
-import { validatePrefix } from '../KeyBuilder';
-import { KeyBuilderCS, myLargeSegmentsKeyBuilder } from '../KeyBuilderCS';
-import { isLocalStorageAvailable } from '../../utils/env/isLocalStorageAvailable';
-import { SplitsCacheInLocal } from './SplitsCacheInLocal';
-import { RBSegmentsCacheInLocal } from './RBSegmentsCacheInLocal';
-import { MySegmentsCacheInLocal } from './MySegmentsCacheInLocal';
-import { InMemoryStorageCSFactory } from '../inMemory/InMemoryStorageCS';
-import { LOG_PREFIX } from './constants';
-import { STORAGE_LOCALSTORAGE } from '../../utils/constants';
-import { shouldRecordTelemetry, TelemetryCacheInMemory } from '../inMemory/TelemetryCacheInMemory';
-import { UniqueKeysCacheInMemoryCS } from '../inMemory/UniqueKeysCacheInMemoryCS';
-import { getMatching } from '../../utils/key';
-import { validateCache } from './validateCache';
-import SplitIO from '../../../types/splitio';
-
-/**
- * InLocal storage factory for standalone client-side SplitFactory
- */
-export function InLocalStorage(options: SplitIO.InLocalStorageOptions = {}): IStorageSyncFactory {
-
-  const prefix = validatePrefix(options.prefix);
-
-  function InLocalStorageCSFactory(params: IStorageFactoryParams): IStorageSync {
-
-    // 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);
-    }
-
-    const { settings, settings: { log, scheduler: { impressionsQueueSize, eventsQueueSize } } } = params;
-    const matchingKey = getMatching(settings.core.key);
-    const keys = new KeyBuilderCS(prefix, matchingKey);
-
-    const splits = new SplitsCacheInLocal(settings, keys);
-    const rbSegments = new RBSegmentsCacheInLocal(settings, keys);
-    const segments = new MySegmentsCacheInLocal(log, keys);
-    const largeSegments = new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey));
-
-    return {
-      splits,
-      rbSegments,
-      segments,
-      largeSegments,
-      impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
-      impressionCounts: new ImpressionCountsCacheInMemory(),
-      events: new EventsCacheInMemory(eventsQueueSize),
-      telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
-      uniqueKeys: new UniqueKeysCacheInMemoryCS(),
-
-      validateCache() {
-        return validateCache(options, settings, keys, splits, rbSegments, segments, largeSegments);
-      },
-
-      destroy() { },
-
-      // When using shared instantiation with MEMORY we reuse everything but segments (they are customer per key).
-      shared(matchingKey: string) {
-
-        return {
-          splits: this.splits,
-          rbSegments: this.rbSegments,
-          segments: new MySegmentsCacheInLocal(log, new KeyBuilderCS(prefix, matchingKey)),
-          largeSegments: new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey)),
-          impressions: this.impressions,
-          impressionCounts: this.impressionCounts,
-          events: this.events,
-          telemetry: this.telemetry,
-          uniqueKeys: this.uniqueKeys,
-
-          destroy() { }
-        };
-      },
-    };
-  }
-
-  InLocalStorageCSFactory.type = STORAGE_LOCALSTORAGE;
-  return InLocalStorageCSFactory;
-}

package/src/storages/inLocalStorage/validateCache.ts

@@ -1,93 +0,0 @@
-import { ISettings } from '../../types';
-import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
-import { getStorageHash } from '../KeyBuilder';
-import { LOG_PREFIX } from './constants';
-import type { SplitsCacheInLocal } from './SplitsCacheInLocal';
-import type { RBSegmentsCacheInLocal } from './RBSegmentsCacheInLocal';
-import type { MySegmentsCacheInLocal } from './MySegmentsCacheInLocal';
-import { KeyBuilderCS } from '../KeyBuilderCS';
-import SplitIO from '../../../types/splitio';
-
-const DEFAULT_CACHE_EXPIRATION_IN_DAYS = 10;
-const MILLIS_IN_A_DAY = 86400000;
-
-/**
- * Validates if cache should be cleared and sets the cache `hash` if needed.
- *
- * @returns `true` if cache should be cleared, `false` otherwise
- */
-function validateExpiration(options: SplitIO.InLocalStorageOptions, settings: ISettings, keys: KeyBuilderCS, currentTimestamp: number, isThereCache: boolean) {
-  const { log } = settings;
-
-  // Check expiration
-  const lastUpdatedTimestamp = parseInt(localStorage.getItem(keys.buildLastUpdatedKey()) as string, 10);
-  if (!isNaNNumber(lastUpdatedTimestamp)) {
-    const cacheExpirationInDays = isFiniteNumber(options.expirationDays) && options.expirationDays >= 1 ? options.expirationDays : DEFAULT_CACHE_EXPIRATION_IN_DAYS;
-    const expirationTimestamp = currentTimestamp - MILLIS_IN_A_DAY * cacheExpirationInDays;
-    if (lastUpdatedTimestamp < expirationTimestamp) {
-      log.info(LOG_PREFIX + 'Cache expired more than ' + cacheExpirationInDays + ' days ago. Cleaning up cache');
-      return true;
-    }
-  }
-
-  // Check hash
-  const storageHashKey = keys.buildHashKey();
-  const storageHash = localStorage.getItem(storageHashKey);
-  const currentStorageHash = getStorageHash(settings);
-
-  if (storageHash !== currentStorageHash) {
-    try {
-      localStorage.setItem(storageHashKey, currentStorageHash);
-    } catch (e) {
-      log.error(LOG_PREFIX + e);
-    }
-    if (isThereCache) {
-      log.info(LOG_PREFIX + 'SDK key, flags filter criteria, or flags spec version has changed. Cleaning up cache');
-      return true;
-    }
-    return false; // No cache to clear
-  }
-
-  // Clear on init
-  if (options.clearOnInit) {
-    const lastClearTimestamp = parseInt(localStorage.getItem(keys.buildLastClear()) as string, 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;
-    }
-  }
-}
-
-/**
- * Clean cache if:
- * - it has expired, i.e., its `lastUpdated` timestamp is older than the given `expirationTimestamp`
- * - its hash has changed, i.e., the SDK key, flags filter criteria or flags spec version was modified
- * - `clearOnInit` was set and cache was not cleared in the last 24 hours
- *
- * @returns `true` if cache is ready to be used, `false` otherwise (cache was cleared or there is no cache)
- */
-export function validateCache(options: SplitIO.InLocalStorageOptions, settings: ISettings, keys: KeyBuilderCS, splits: SplitsCacheInLocal, rbSegments: RBSegmentsCacheInLocal, segments: MySegmentsCacheInLocal, largeSegments: MySegmentsCacheInLocal): boolean {
-
-  const currentTimestamp = Date.now();
-  const 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);
-    }
-
-    return false;
-  }
-
-  // Check if ready from cache
-  return isThereCache;
-}