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

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

@@ -1,7 +1,7 @@
 import { forOwn } from '../../../utils/lang';
 import { syncTaskFactory } from '../../syncTask';
 import { CONTROL } from '../../../utils/constants';
-import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/constants';
+import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
 import { SYNC_OFFLINE_DATA, ERROR_SYNC_OFFLINE_LOADING } from '../../../logger/constants';
 /**
  * Offline equivalent of `splitChangesUpdaterFactory`
@@ -43,13 +43,8 @@ export function fromObjectUpdaterFactory(splitsParser, storage, readiness, setti
                 readiness.splits.emit(SDK_SPLITS_ARRIVED);
                 if (startingUp) {
                     startingUp = false;
-                    Promise.resolve(splitsCache.checkCache()).then(function (cacheReady) {
-                        // Emits SDK_READY_FROM_CACHE
-                        if (cacheReady)
-                            readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
-                        // Emits SDK_READY
-                        readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
-                    });
+                    // Emits SDK_READY
+                    readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
                 }
                 return true;
             });

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

@@ -1,6 +1,6 @@
 import { _Set, setToArray } from '../../../utils/lang/sets';
 import { timeout } from '../../../utils/promise/timeout';
-import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/constants';
+import { SDK_SPLITS_ARRIVED } from '../../../readiness/constants';
 import { SYNC_SPLITS_FETCH, SYNC_SPLITS_NEW, SYNC_SPLITS_REMOVED, SYNC_SPLITS_SEGMENTS, SYNC_SPLITS_FETCH_FAILS, SYNC_SPLITS_FETCH_RETRY } from '../../../logger/constants';
 import { startsWith } from '../../../utils/lang';
 import { IN_SEGMENT } from '../../../utils/constants';
@@ -121,7 +121,7 @@ export function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, seg
         function _splitChangesUpdater(since, retry) {
             if (retry === void 0) { retry = 0; }
             log.debug(SYNC_SPLITS_FETCH, [since]);
-            var fetcherPromise = Promise.resolve(splitUpdateNotification ?
+            return Promise.resolve(splitUpdateNotification ?
                 { splits: [splitUpdateNotification.payload], till: splitUpdateNotification.changeNumber } :
                 splitChangesFetcher(since, noCache, till, _promiseDecorator))
                 .then(function (splitChanges) {
@@ -165,15 +165,6 @@ export function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, seg
                 }
                 return false;
             });
-            // After triggering the requests, if we have cached splits information let's notify that to emit SDK_READY_FROM_CACHE.
-            // Wrapping in a promise since checkCache can be async.
-            if (splitsEventEmitter && startingUp) {
-                Promise.resolve(splits.checkCache()).then(function (isCacheReady) {
-                    if (isCacheReady)
-                        splitsEventEmitter.emit(SDK_SPLITS_CACHE_LOADED);
-                });
-            }
-            return fetcherPromise;
         }
         var sincePromise = Promise.resolve(splits.getChangeNumber()); // `getChangeNumber` never rejects or throws error
         return sincePromise.then(_splitChangesUpdater);

package/esm/trackers/eventTracker.js

@@ -9,7 +9,7 @@ import { isConsumerMode } from '../utils/settingsValidation/mode';
  * @param eventsCache cache to save events
  * @param integrationsManager optional event handler used for integrations
  */
-export function eventTrackerFactory(settings, eventsCache, integrationsManager, telemetryCache) {
+export function eventTrackerFactory(settings, eventsCache, whenInit, integrationsManager, telemetryCache) {
     var log = settings.log, mode = settings.mode;
     var isAsync = isConsumerMode(mode);
     function queueEventsCallback(eventData, tracked) {
@@ -20,14 +20,16 @@ export function eventTrackerFactory(settings, eventsCache, integrationsManager,
             log.info(EVENTS_TRACKER_SUCCESS, [msg]);
             if (integrationsManager) {
                 // Wrap in a timeout because we don't want it to be blocking.
-                setTimeout(function () {
-                    // copy of event, to avoid unexpected behaviour if modified by integrations
-                    var eventDataCopy = objectAssign({}, eventData);
-                    if (properties)
-                        eventDataCopy.properties = objectAssign({}, properties);
-                    // integrationsManager does not throw errors (they are internally handled by each integration module)
-                    integrationsManager.handleEvent(eventDataCopy);
-                }, 0);
+                whenInit(function () {
+                    setTimeout(function () {
+                        // copy of event, to avoid unexpected behaviour if modified by integrations
+                        var eventDataCopy = objectAssign({}, eventData);
+                        if (properties)
+                            eventDataCopy.properties = objectAssign({}, properties);
+                        // integrationsManager does not throw errors (they are internally handled by each integration module)
+                        integrationsManager.handleEvent(eventDataCopy);
+                    });
+                });
             }
         }
         else {

package/esm/trackers/impressionsTracker.js

@@ -11,7 +11,7 @@ import { CONSENT_DECLINED, DEDUPED, QUEUED } from '../utils/constants';
  * @param integrationsManager optional integrations manager
  * @param strategy strategy for impressions tracking.
  */
-export function impressionsTrackerFactory(settings, impressionsCache, strategy, integrationsManager, telemetryCache) {
+export function impressionsTrackerFactory(settings, impressionsCache, strategy, whenInit, integrationsManager, telemetryCache) {
     var log = settings.log, impressionListener = settings.impressionListener, _a = settings.runtime, ip = _a.ip, hostname = _a.hostname, version = settings.version;
     return {
         track: function (impressions, attributes) {
@@ -51,18 +51,20 @@ export function impressionsTrackerFactory(settings, impressionsCache, strategy,
                         sdkLanguageVersion: version
                     };
                     // Wrap in a timeout because we don't want it to be blocking.
-                    setTimeout(function () {
-                        // integrationsManager.handleImpression does not throw errors
-                        if (integrationsManager)
-                            integrationsManager.handleImpression(impressionData);
-                        try { // @ts-ignore. An exception on the listeners should not break the SDK.
-                            if (impressionListener)
-                                impressionListener.logImpression(impressionData);
-                        }
-                        catch (err) {
-                            log.error(ERROR_IMPRESSIONS_LISTENER, [err]);
-                        }
-                    }, 0);
+                    whenInit(function () {
+                        setTimeout(function () {
+                            // integrationsManager.handleImpression does not throw errors
+                            if (integrationsManager)
+                                integrationsManager.handleImpression(impressionData);
+                            try { // @ts-ignore. An exception on the listeners should not break the SDK.
+                                if (impressionListener)
+                                    impressionListener.logImpression(impressionData);
+                            }
+                            catch (err) {
+                                log.error(ERROR_IMPRESSIONS_LISTENER, [err]);
+                            }
+                        });
+                    });
                 };
                 for (var i = 0; i < impressionsToListenerCount; i++) {
                     _loop_1(i);

package/esm/trackers/uniqueKeysTracker.js

@@ -16,9 +16,6 @@ var noopFilterAdapter = {
 export function uniqueKeysTrackerFactory(log, uniqueKeysCache, filterAdapter) {
     if (filterAdapter === void 0) { filterAdapter = noopFilterAdapter; }
     var intervalId;
-    if (filterAdapter.refreshRate) {
-        intervalId = setInterval(filterAdapter.clear, filterAdapter.refreshRate);
-    }
     return {
         track: function (key, featureName) {
             if (!filterAdapter.add(key, featureName)) {
@@ -27,6 +24,11 @@ export function uniqueKeysTrackerFactory(log, uniqueKeysCache, filterAdapter) {
             }
             uniqueKeysCache.track(key, featureName);
         },
+        start: function () {
+            if (filterAdapter.refreshRate) {
+                intervalId = setInterval(filterAdapter.clear, filterAdapter.refreshRate);
+            }
+        },
         stop: function () {
             clearInterval(intervalId);
         }

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

@@ -1,12 +1,6 @@
 import { InMemoryStorageCSFactory } from '../../../storages/inMemory/InMemoryStorageCS';
 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.splits.checkCache = function () { return true; }; // to emit SDK_READY_FROM_CACHE
-    return result;
-}
-__InLocalStorageMockFactory.type = STORAGE_MEMORY;
 /**
  * This function validates `settings.storage` object
  *
@@ -23,10 +17,6 @@ export function validateStorageCS(settings) {
         storage = InMemoryStorageCSFactory;
         log.error(ERROR_STORAGE_INVALID);
     }
-    // In localhost mode with InLocalStorage, fallback to a mock InLocalStorage to emit SDK_READY_FROM_CACHE
-    if (mode === LOCALHOST_MODE && storage.type === STORAGE_LOCALSTORAGE) {
-        return __InLocalStorageMockFactory;
-    }
     if ([LOCALHOST_MODE, STANDALONE_MODE].indexOf(mode) === -1) {
         // Consumer modes require an async storage
         if (storage.type !== STORAGE_PLUGGABLE)

package/package.json

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

package/src/readiness/readinessManager.ts

@@ -55,19 +55,15 @@ export function readinessManagerFactory(
 
   // emit SDK_READY_TIMED_OUT
   let hasTimedout = false;
+  let readyTimeoutId: ReturnType<typeof setTimeout>;
 
-  function timeout() {
-    if (hasTimedout) return;
+  function timeout() { // eslint-disable-next-line no-use-before-define
+    if (hasTimedout || isReady) return;
     hasTimedout = true;
     syncLastUpdate();
     gate.emit(SDK_READY_TIMED_OUT, 'Split SDK emitted SDK_READY_TIMED_OUT event.');
   }
 
-  let readyTimeoutId: ReturnType<typeof setTimeout>;
-  if (readyTimeout > 0) {
-    readyTimeoutId = setTimeout(timeout, readyTimeout);
-  }
-
   // emit SDK_READY and SDK_UPDATE
   let isReady = false;
   splits.on(SDK_SPLITS_ARRIVED, checkIsReadyOrUpdate);
@@ -132,6 +128,12 @@ export function readinessManagerFactory(
     // tracking and evaluations, while keeping event listeners to emit SDK_READY_TIMED_OUT event
     setDestroyed() { isDestroyed = true; },
 
+    init() {
+      if (readyTimeout > 0) {
+        readyTimeoutId = setTimeout(timeout, readyTimeout);
+      }
+    },
+
     destroy() {
       isDestroyed = true;
       syncLastUpdate();

package/src/readiness/types.ts

@@ -59,6 +59,7 @@ export interface IReadinessManager {
   timeout(): void,
   setDestroyed(): void,
   destroy(): void,
+  init(): void,
 
   /** for client-side */
   shared(): IReadinessManager,

package/src/sdkClient/sdkClientMethodCS.ts

@@ -15,7 +15,7 @@ import { buildInstanceId } from './identity';
  * Therefore, clients don't have a bound TT for the track method.
  */
 export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitIO.SplitKey) => SplitIO.ICsClient {
-  const { clients, storage, syncManager, sdkReadinessManager, settings: { core: { key }, log } } = params;
+  const { clients, storage, syncManager, sdkReadinessManager, settings: { core: { key }, log }, whenInit } = params;
 
   const mainClientInstance = clientCSDecorator(
     log,
@@ -75,7 +75,10 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
         validKey
       );
 
-      sharedSyncManager && sharedSyncManager.start();
+      whenInit(() => {
+        sharedSdkReadiness.readinessManager.init();
+        sharedSyncManager && sharedSyncManager.start();
+      });
 
       log.info(NEW_SHARED_CLIENT);
     } else {

package/src/sdkClient/sdkClientMethodCSWithTT.ts

@@ -17,7 +17,7 @@ import { buildInstanceId } from './identity';
  * (default client) or the client method (shared clients).
  */
 export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitIO.SplitKey, trafficType?: string) => SplitIO.ICsClient {
-  const { clients, storage, syncManager, sdkReadinessManager, settings: { core: { key, trafficType }, log } } = params;
+  const { clients, storage, syncManager, sdkReadinessManager, settings: { core: { key, trafficType }, log }, whenInit } = params;
 
   const mainClientInstance = clientCSDecorator(
     log,
@@ -86,7 +86,10 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
         validTrafficType
       );
 
-      sharedSyncManager && sharedSyncManager.start();
+      whenInit(() => {
+        sharedSdkReadiness.readinessManager.init();
+        sharedSyncManager && sharedSyncManager.start();
+      });
 
       log.info(NEW_SHARED_CLIENT);
     } else {

package/src/sdkFactory/index.ts

@@ -7,7 +7,7 @@ import { IBasicClient, SplitIO } from '../types';
 import { validateAndTrackApiKey } from '../utils/inputValidation/apiKey';
 import { createLoggerAPI } from '../logger/sdkLogger';
 import { NEW_FACTORY, RETRIEVE_MANAGER } from '../logger/constants';
-import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
+import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../readiness/constants';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { strategyDebugFactory } from '../trackers/strategy/strategyDebug';
 import { strategyOptimizedFactory } from '../trackers/strategy/strategyOptimized';
@@ -23,14 +23,20 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
   const { settings, platform, storageFactory, splitApiFactory, extraProps,
     syncManagerFactory, SignalListener, impressionsObserverFactory,
     integrationsManagerFactory, sdkManagerFactory, sdkClientMethodFactory,
-    filterAdapterFactory } = params;
+    filterAdapterFactory, isPure } = params;
   const { log, sync: { impressionsMode } } = 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.
 
-  // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
-  validateAndTrackApiKey(log, settings.core.authorizationKey);
+  // initialization
+  let isInit = false;
+  const initCallbacks: (() => void)[] = [];
+
+  function whenInit(cb: () => void) {
+    if (isInit) cb();
+    else initCallbacks.push(cb);
+  }
 
   const sdkReadinessManager = sdkReadinessManagerFactory(platform.EventEmitter, settings);
   const readiness = sdkReadinessManager.readinessManager;
@@ -46,8 +52,11 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
       readiness.splits.emit(SDK_SPLITS_ARRIVED);
       readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
     },
+    onReadyFromCacheCb: () => {
+      readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
+    }
   });
-  // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
+
   const clients: Record<string, IBasicClient> = {};
   const telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
   const integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings, storage, telemetryTracker });
@@ -67,13 +76,13 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
       strategy = strategyDebugFactory(observer);
   }
 
-  const impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, strategy, integrationsManager, storage.telemetry);
-  const eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager, storage.telemetry);
+  const impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, strategy, whenInit, integrationsManager, storage.telemetry);
+  const eventTracker = eventTrackerFactory(settings, storage.events, whenInit, integrationsManager, storage.telemetry);
 
   // splitApi is used by SyncManager and Browser signal listener
   const splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);
 
-  const ctx: ISdkFactoryContext = { clients, splitApi, eventTracker, impressionsTracker, telemetryTracker, uniqueKeysTracker, sdkReadinessManager, readiness, settings, storage, platform };
+  const ctx: ISdkFactoryContext = { clients, splitApi, eventTracker, impressionsTracker, telemetryTracker, uniqueKeysTracker, sdkReadinessManager, readiness, settings, storage, platform, whenInit };
 
   const syncManager = syncManagerFactory && syncManagerFactory(ctx as ISdkFactoryContextSync);
   ctx.syncManager = syncManager;
@@ -85,8 +94,24 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
   const clientMethod = sdkClientMethodFactory(ctx);
   const managerInstance = sdkManagerFactory(settings, storage.splits, sdkReadinessManager);
 
-  syncManager && syncManager.start();
-  signalListener && signalListener.start();
+
+  function init() {
+    if (isInit) return;
+    isInit = true;
+
+    // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
+    validateAndTrackApiKey(log, settings.core.authorizationKey);
+    readiness.init();
+    storage.init && storage.init();
+    uniqueKeysTracker && uniqueKeysTracker.start();
+    syncManager && syncManager.start();
+    signalListener && signalListener.start();
+
+    initCallbacks.forEach((cb) => cb());
+    initCallbacks.length = 0;
+  }
+
+  if (!isPure) init();
 
   log.info(NEW_FACTORY);
 
@@ -107,7 +132,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
     settings,
 
     destroy() {
-      return Promise.all(Object.keys(clients).map(key => clients[key].destroy())).then(() => {});
+      return Promise.all(Object.keys(clients).map(key => clients[key].destroy())).then(() => { });
     }
-  }, extraProps && extraProps(ctx));
+  }, extraProps && extraProps(ctx), isPure && { init });
 }

package/src/sdkFactory/types.ts

@@ -50,6 +50,7 @@ export interface ISdkFactoryContext {
   splitApi?: ISplitApi
   syncManager?: ISyncManager,
   clients: Record<string, IBasicClient>,
+  whenInit(cb: () => void): void
 }
 
 export interface ISdkFactoryContextSync extends ISdkFactoryContext {
@@ -68,6 +69,8 @@ export interface ISdkFactoryContextAsync extends ISdkFactoryContext {
  * Object parameter with the modules required to create an SDK factory instance
  */
 export interface ISdkFactoryParams {
+  // If true, the `sdkFactory` is pure (no side effects), and the SDK instance includes a `init` method to run initialization side effects
+  isPure?: boolean,
 
   // The settings must be already validated
   settings: ISettings,

package/src/storages/AbstractSplitsCacheAsync.ts

@@ -28,14 +28,6 @@ export abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
     return Promise.resolve(true);
   }
 
-  /**
-   * Check if the splits information is already stored in cache.
-   * Noop, just keeping the interface. This is used by client-side implementations only.
-   */
-  checkCache(): Promise<boolean> {
-    return Promise.resolve(false);
-  }
-
   /**
    * Kill `name` split and set `defaultTreatment` and `changeNumber`.
    * Used for SPLIT_KILL push notifications.

package/src/storages/AbstractSplitsCacheSync.ts

@@ -48,14 +48,6 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
 
   abstract clear(): void
 
-  /**
-   * Check if the splits information is already stored in cache. This data can be preloaded.
-   * It is used as condition to emit SDK_SPLITS_CACHE_LOADED, and then SDK_READY_FROM_CACHE.
-   */
-  checkCache(): boolean {
-    return false;
-  }
-
   /**
    * Kill `name` split and set `defaultTreatment` and `changeNumber`.
    * Used for SPLIT_KILL push notifications.

package/src/storages/dataLoader.ts

@@ -1,55 +1,85 @@
 import { SplitIO } from '../types';
-import { DEFAULT_CACHE_EXPIRATION_IN_MILLIS } from '../utils/constants/browser';
-import { DataLoader, ISegmentsCacheSync, ISplitsCacheSync } from './types';
+import { ISegmentsCacheSync, ISplitsCacheSync, IStorageSync } from './types';
+import { setToArray, ISet } from '../utils/lang/sets';
+import { getMatching } from '../utils/key';
 
 /**
- * Factory of client-side storage loader
+ * Storage-agnostic adaptation of `loadDataIntoLocalStorage` function
+ * (https://github.com/godaddy/split-javascript-data-loader/blob/master/src/load-data.js)
  *
- * @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
+ * @param preloadedData validated data following the format proposed in https://github.com/godaddy/split-javascript-data-loader and extended with a `mySegmentsData` property.
+ * @param storage object containing `splits` and `segments` cache (client-side variant)
+ * @param userKey user key (matching key) of the provided MySegmentsCache
+ *
+ * @TODO extend to load largeSegments
+ * @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.
+ * @TODO add logs, and input validation in this module, in favor of size reduction.
+ * @TODO unit tests
  */
-export function dataLoaderFactory(preloadedData: SplitIO.PreloadedData): DataLoader {
-
-  /**
-   * 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: { splits: ISplitsCacheSync, segments: ISegmentsCacheSync }, userId: string) {
-    // Do not load data if current preloadedData is empty
-    if (Object.keys(preloadedData).length === 0) return;
-
-    const { lastUpdated = -1, segmentsData = {}, since = -1, splitsData = {} } = preloadedData;
+export function loadData(preloadedData: SplitIO.PreloadedData, storage: { splits?: ISplitsCacheSync, segments: ISegmentsCacheSync, largeSegments?: ISegmentsCacheSync }, matchingKey?: string) {
+  // Do not load data if current preloadedData is empty
+  if (Object.keys(preloadedData).length === 0) return;
+
+  const { segmentsData = {}, since = -1, splitsData = [] } = preloadedData;
 
+  if (storage.splits) {
     const storedSince = storage.splits.getChangeNumber();
-    const 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;
+    // Do not load data if current data is more recent
+    if (storedSince > since) return;
 
     // cleaning up the localStorage data, since some cached splits might need be part of the preloaded data
     storage.splits.clear();
     storage.splits.setChangeNumber(since);
 
     // splitsData in an object where the property is the split name and the pertaining value is a stringified json of its data
-    storage.splits.addSplits(Object.keys(splitsData).map(splitName => JSON.parse(splitsData[splitName])));
+    storage.splits.addSplits(splitsData.map(split => ([split.name, split])));
+  }
 
-    // add mySegments data
-    let mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[userId];
+  if (matchingKey) { // add mySegments data (client-side)
+    let mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[matchingKey];
     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(segmentName => {
-        const userIds = JSON.parse(segmentsData[segmentName]).added;
-        return Array.isArray(userIds) && userIds.indexOf(userId) > -1;
+        const matchingKeys = segmentsData[segmentName];
+        return matchingKeys.indexOf(matchingKey) > -1;
       });
     }
     storage.segments.resetSegments({ k: mySegmentsData.map(s => ({ n: s })) });
+  } else { // add segments data (server-side)
+    Object.keys(segmentsData).filter(segmentName => {
+      const matchingKeys = segmentsData[segmentName];
+      storage.segments.addToSegment(segmentName, matchingKeys);
+    });
+  }
+}
+
+export function getSnapshot(storage: IStorageSync, userKeys?: SplitIO.SplitKey[]): SplitIO.PreloadedData {
+  return {
+    // lastUpdated: Date.now(),
+    since: storage.splits.getChangeNumber(),
+    splitsData: storage.splits.getAll(),
+    segmentsData: userKeys ?
+      undefined : // @ts-ignore accessing private prop
+      Object.keys(storage.segments.segmentCache).reduce((prev, cur) => { // @ts-ignore accessing private prop
+        prev[cur] = setToArray(storage.segments.segmentCache[cur] as ISet<string>);
+        return prev;
+      }, {}),
+    mySegmentsData: userKeys ?
+      userKeys.reduce<Record<string, string[]>>((prev, userKey) => {
+        prev[getMatching(userKey)] = storage.shared ?
+          // Client-side segments
+          // @ts-ignore accessing private prop
+          Object.keys(storage.shared(userKey).segments.segmentCache) :
+          // Server-side segments
+          // @ts-ignore accessing private prop
+          Object.keys(storage.segments.segmentCache).reduce<string[]>((prev, segmentName) => { // @ts-ignore accessing private prop
+            return storage.segments.segmentCache[segmentName].has(userKey) ?
+              prev.concat(segmentName) :
+              prev;
+          }, []);
+        return prev;
+      }, {}) :
+      undefined
   };
 }

package/src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -217,15 +217,6 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     }
   }
 
-  /**
-   * Check if the splits information is already stored in browser LocalStorage.
-   * In this function we could add more code to check if the data is valid.
-   * @override
-   */
-  checkCache(): boolean {
-    return this.getChangeNumber() > -1;
-  }
-
   /**
    * Clean Splits cache if its `lastUpdated` timestamp is older than the given `expirationTimestamp`,
    *
@@ -250,7 +241,7 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
         this.updateNewFilter = true;
 
         // if there is cache, clear it
-        if (this.checkCache()) this.clear();
+        if (this.getChangeNumber() > -1) this.clear();
 
       } catch (e) {
         this.log.error(LOG_PREFIX + e);

package/src/storages/inLocalStorage/index.ts

@@ -12,7 +12,7 @@ import { SplitsCacheInMemory } from '../inMemory/SplitsCacheInMemory';
 import { DEFAULT_CACHE_EXPIRATION_IN_MILLIS } from '../../utils/constants/browser';
 import { InMemoryStorageCSFactory } from '../inMemory/InMemoryStorageCS';
 import { LOG_PREFIX } from './constants';
-import { DEBUG, NONE, STORAGE_LOCALSTORAGE } from '../../utils/constants';
+import { DEBUG, LOCALHOST_MODE, NONE, STORAGE_LOCALSTORAGE } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from '../inMemory/TelemetryCacheInMemory';
 import { UniqueKeysCacheInMemoryCS } from '../inMemory/UniqueKeysCacheInMemoryCS';
 import { getMatching } from '../../utils/key';
@@ -36,7 +36,7 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
       return InMemoryStorageCSFactory(params);
     }
 
-    const { settings, settings: { log, scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode, __splitFiltersValidation } } } = params;
+    const { onReadyFromCacheCb, settings, settings: { log, scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode, __splitFiltersValidation } } } = params;
     const matchingKey = getMatching(settings.core.key);
     const keys = new KeyBuilderCS(prefix, matchingKey);
     const expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
@@ -55,6 +55,12 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
       telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
       uniqueKeys: impressionsMode === NONE ? new UniqueKeysCacheInMemoryCS() : undefined,
 
+      init() {
+        if (settings.mode === LOCALHOST_MODE || splits.getChangeNumber() > -1) {
+          Promise.resolve().then(onReadyFromCacheCb);
+        }
+      },
+
       destroy() {
         this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
         this.segments = new MySegmentsCacheInMemory();