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

package/CHANGES.txt

@@ -1,4 +1,5 @@
 2.0.0 (September XX, 2024)
+ - Updated internal storage factory to emit the SDK_READY_FROM_CACHE event when it corresponds, to clean up the initialization flow.
  - Added `factory.destroy()` method, which invokes the `destroy` method on all SDK clients created by the factory.
  - Added support for targeting rules based on large segments.
  - BREAKING CHANGES:

package/cjs/sdkFactory/index.js

@@ -38,8 +38,10 @@ function sdkFactory(params) {
             readiness.splits.emit(constants_2.SDK_SPLITS_ARRIVED);
             readiness.segments.emit(constants_2.SDK_SEGMENTS_ARRIVED);
         },
+        onReadyFromCacheCb: function () {
+            readiness.splits.emit(constants_2.SDK_SPLITS_CACHE_LOADED);
+        }
     });
-    // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
     var clients = {};
     var telemetryTracker = (0, telemetryTracker_1.telemetryTrackerFactory)(storage.telemetry, platform.now);
     var integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings: settings, storage: storage, telemetryTracker: telemetryTracker });

package/cjs/storages/AbstractSplitsCacheAsync.js

@@ -14,13 +14,6 @@ var AbstractSplitsCacheAsync = /** @class */ (function () {
     AbstractSplitsCacheAsync.prototype.usesSegments = function () {
         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.
-     */
-    AbstractSplitsCacheAsync.prototype.checkCache = function () {
-        return Promise.resolve(false);
-    };
     /**
      * Kill `name` split and set `defaultTreatment` and `changeNumber`.
      * Used for SPLIT_KILL push notifications.

package/cjs/storages/AbstractSplitsCacheSync.js

@@ -30,13 +30,6 @@ var AbstractSplitsCacheSync = /** @class */ (function () {
         var _this = this;
         return this.getSplitNames().map(function (key) { return _this.getSplit(key); });
     };
-    /**
-     * 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.
-     */
-    AbstractSplitsCacheSync.prototype.checkCache = function () {
-        return false;
-    };
     /**
      * Kill `name` split and set `defaultTreatment` and `changeNumber`.
      * Used for SPLIT_KILL push notifications.

package/cjs/storages/dataLoader.js

@@ -1,51 +1,84 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.dataLoaderFactory = void 0;
-var browser_1 = require("../utils/constants/browser");
+exports.getSnapshot = exports.loadData = void 0;
+var sets_1 = require("../utils/lang/sets");
 /**
- * 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
  */
-function dataLoaderFactory(preloadedData) {
-    /**
-     * Storage-agnostic adaptation of `loadDataIntoLocalStorage` function
-     * (https://github.com/godaddy/split-javascript-data-loader/blob/master/src/load-data.js)
-     *
-     * @param storage object containing `splits` and `segments` cache (client-side variant)
-     * @param userId user key string of the provided MySegmentsCache
-     *
-     * @TODO extend to support SegmentsCache (server-side variant) by making `userId` optional and adding the corresponding logic.
-     * @TODO extend to load data on shared mySegments storages. Be specific when emitting SDK_READY_FROM_CACHE on shared clients. Maybe the serializer should provide the `useSegments` flag.
-     */
-    return function loadData(storage, userId) {
-        // Do not load data if current preloadedData is empty
-        if (Object.keys(preloadedData).length === 0)
-            return;
-        var _a = preloadedData.lastUpdated, lastUpdated = _a === void 0 ? -1 : _a, _b = preloadedData.segmentsData, segmentsData = _b === void 0 ? {} : _b, _c = preloadedData.since, since = _c === void 0 ? -1 : _c, _d = preloadedData.splitsData, splitsData = _d === void 0 ? {} : _d;
+function loadData(preloadedData, storage, userKey) {
+    // Do not load data if current preloadedData is empty
+    if (Object.keys(preloadedData).length === 0)
+        return;
+    var _a = preloadedData.segmentsData, segmentsData = _a === void 0 ? {} : _a, _b = preloadedData.since, since = _b === void 0 ? -1 : _b, _c = preloadedData.splitsData, splitsData = _c === void 0 ? [] : _c;
+    if (storage.splits) {
         var storedSince = storage.splits.getChangeNumber();
-        var expirationTimestamp = Date.now() - browser_1.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)
+        // 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(function (splitName) { return JSON.parse(splitsData[splitName]); }));
-        // add mySegments data
-        var mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[userId];
+        storage.splits.addSplits(splitsData.map(function (split) { return ([split.name, split]); }));
+    }
+    if (userKey) { // add mySegments data (client-side)
+        var mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[userKey];
         if (!mySegmentsData) {
             // segmentsData in an object where the property is the segment name and the pertaining value is a stringified object that contains the `added` array of userIds
             mySegmentsData = Object.keys(segmentsData).filter(function (segmentName) {
-                var userIds = JSON.parse(segmentsData[segmentName]).added;
-                return Array.isArray(userIds) && userIds.indexOf(userId) > -1;
+                var userKeys = segmentsData[segmentName];
+                return userKeys.indexOf(userKey) > -1;
             });
         }
         storage.segments.resetSegments({ k: mySegmentsData.map(function (s) { return ({ n: s }); }) });
+    }
+    else { // add segments data (server-side)
+        Object.keys(segmentsData).filter(function (segmentName) {
+            var userKeys = segmentsData[segmentName];
+            storage.segments.addToSegment(segmentName, userKeys);
+        });
+    }
+}
+exports.loadData = loadData;
+function getSnapshot(storage, userKeys) {
+    return {
+        // lastUpdated: Date.now(),
+        // @ts-ignore accessing private prop
+        since: storage.splits.changeNumber,
+        splitsData: storage.splits.getAll(),
+        segmentsData: userKeys ?
+            undefined : // @ts-ignore accessing private prop
+            Object.keys(storage.segments.segmentCache).reduce(function (prev, cur) {
+                prev[cur] = (0, sets_1.setToArray)(storage.segments.segmentCache[cur]);
+                return prev;
+            }, {}),
+        mySegmentsData: userKeys ?
+            userKeys.reduce(function (prev, userKey) {
+                // @ts-ignore accessing private prop
+                prev[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(function (prev, segmentName) {
+                        return storage.segments.segmentCache[segmentName].has(userKey) ?
+                            prev.concat(segmentName) :
+                            prev;
+                    }, []);
+                return prev;
+            }, {}) :
+            undefined
     };
 }
-exports.dataLoaderFactory = dataLoaderFactory;
+exports.getSnapshot = getSnapshot;

package/cjs/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -186,14 +186,6 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
             return true;
         }
     };
-    /**
-     * 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
-     */
-    SplitsCacheInLocal.prototype.checkCache = function () {
-        return this.getChangeNumber() > -1;
-    };
     /**
      * Clean Splits cache if its `lastUpdated` timestamp is older than the given `expirationTimestamp`,
      *
@@ -216,7 +208,7 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
                 // mark cache to update the new query filter on first successful splits fetch
                 this.updateNewFilter = true;
                 // if there is cache, clear it
-                if (this.checkCache())
+                if (this.getChangeNumber() > -1)
                     this.clear();
             }
             catch (e) {

package/cjs/storages/inLocalStorage/index.js

@@ -30,13 +30,16 @@ function InLocalStorage(options) {
             params.settings.log.warn(constants_1.LOG_PREFIX + 'LocalStorage API is unavailable. Falling back to default MEMORY storage');
             return (0, InMemoryStorageCS_1.InMemoryStorageCSFactory)(params);
         }
-        var settings = params.settings, _a = params.settings, log = _a.log, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, _c = _a.sync, impressionsMode = _c.impressionsMode, __splitFiltersValidation = _c.__splitFiltersValidation;
+        var onReadyFromCacheCb = params.onReadyFromCacheCb, settings = params.settings, _a = params.settings, log = _a.log, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, _c = _a.sync, impressionsMode = _c.impressionsMode, __splitFiltersValidation = _c.__splitFiltersValidation;
         var matchingKey = (0, key_1.getMatching)(settings.core.key);
         var keys = new KeyBuilderCS_1.KeyBuilderCS(prefix, matchingKey);
         var expirationTimestamp = Date.now() - browser_1.DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
         var splits = new SplitsCacheInLocal_1.SplitsCacheInLocal(settings, keys, expirationTimestamp);
         var segments = new MySegmentsCacheInLocal_1.MySegmentsCacheInLocal(log, keys);
         var largeSegments = new MySegmentsCacheInLocal_1.MySegmentsCacheInLocal(log, (0, KeyBuilderCS_1.myLargeSegmentsKeyBuilder)(prefix, matchingKey));
+        if (settings.mode === constants_2.LOCALHOST_MODE || splits.getChangeNumber() > -1) {
+            Promise.resolve().then(onReadyFromCacheCb);
+        }
         return {
             splits: splits,
             segments: segments,

package/cjs/storages/inMemory/InMemoryStorageCS.js

@@ -9,13 +9,15 @@ var ImpressionCountsCacheInMemory_1 = require("./ImpressionCountsCacheInMemory")
 var constants_1 = require("../../utils/constants");
 var TelemetryCacheInMemory_1 = require("./TelemetryCacheInMemory");
 var UniqueKeysCacheInMemoryCS_1 = require("./UniqueKeysCacheInMemoryCS");
+var key_1 = require("../../utils/key");
+var dataLoader_1 = require("../dataLoader");
 /**
  * InMemory storage factory for standalone client-side SplitFactory
  *
  * @param params parameters required by EventsCacheSync
  */
 function InMemoryStorageCSFactory(params) {
-    var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, _c = _a.sync, impressionsMode = _c.impressionsMode, __splitFiltersValidation = _c.__splitFiltersValidation;
+    var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, _c = _a.sync, impressionsMode = _c.impressionsMode, __splitFiltersValidation = _c.__splitFiltersValidation, preloadedData = _a.preloadedData, onReadyFromCacheCb = params.onReadyFromCacheCb;
     var splits = new SplitsCacheInMemory_1.SplitsCacheInMemory(__splitFiltersValidation);
     var segments = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
     var largeSegments = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
@@ -39,11 +41,16 @@ function InMemoryStorageCSFactory(params) {
             this.uniqueKeys && this.uniqueKeys.clear();
         },
         // When using shared instanciation with MEMORY we reuse everything but segments (they are unique per key)
-        shared: function () {
+        shared: function (matchingKey) {
+            var segments = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
+            var largeSegments = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
+            if (preloadedData) {
+                (0, dataLoader_1.loadData)(preloadedData, { segments: segments, largeSegments: largeSegments }, matchingKey);
+            }
             return {
                 splits: this.splits,
-                segments: new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory(),
-                largeSegments: new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory(),
+                segments: segments,
+                largeSegments: largeSegments,
                 impressions: this.impressions,
                 impressionCounts: this.impressionCounts,
                 events: this.events,
@@ -68,6 +75,11 @@ function InMemoryStorageCSFactory(params) {
         if (storage.uniqueKeys)
             storage.uniqueKeys.track = noopTrack;
     }
+    if (preloadedData) {
+        (0, dataLoader_1.loadData)(preloadedData, storage, (0, key_1.getMatching)(params.settings.core.key));
+        if (splits.getChangeNumber() > -1)
+            onReadyFromCacheCb();
+    }
     return storage;
 }
 exports.InMemoryStorageCSFactory = InMemoryStorageCSFactory;

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

@@ -46,13 +46,8 @@ function fromObjectUpdaterFactory(splitsParser, storage, readiness, settings) {
                 readiness.splits.emit(constants_2.SDK_SPLITS_ARRIVED);
                 if (startingUp) {
                     startingUp = false;
-                    Promise.resolve(splitsCache.checkCache()).then(function (cacheReady) {
-                        // Emits SDK_READY_FROM_CACHE
-                        if (cacheReady)
-                            readiness.splits.emit(constants_2.SDK_SPLITS_CACHE_LOADED);
-                        // Emits SDK_READY
-                        readiness.segments.emit(constants_2.SDK_SEGMENTS_ARRIVED);
-                    });
+                    // Emits SDK_READY
+                    readiness.segments.emit(constants_2.SDK_SEGMENTS_ARRIVED);
                 }
                 return true;
             });

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

@@ -126,7 +126,7 @@ function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, segments,
         function _splitChangesUpdater(since, retry) {
             if (retry === void 0) { retry = 0; }
             log.debug(constants_2.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) {
@@ -170,15 +170,6 @@ function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, segments,
                 }
                 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(constants_1.SDK_SPLITS_CACHE_LOADED);
-                });
-            }
-            return fetcherPromise;
         }
         var sincePromise = Promise.resolve(splits.getChangeNumber()); // `getChangeNumber` never rejects or throws error
         return sincePromise.then(_splitChangesUpdater);

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

@@ -1,16 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateStorageCS = exports.__InLocalStorageMockFactory = void 0;
+exports.validateStorageCS = void 0;
 var InMemoryStorageCS_1 = require("../../../storages/inMemory/InMemoryStorageCS");
 var constants_1 = require("../../../logger/constants");
 var constants_2 = require("../../../utils/constants");
-function __InLocalStorageMockFactory(params) {
-    var result = (0, InMemoryStorageCS_1.InMemoryStorageCSFactory)(params);
-    result.splits.checkCache = function () { return true; }; // to emit SDK_READY_FROM_CACHE
-    return result;
-}
-exports.__InLocalStorageMockFactory = __InLocalStorageMockFactory;
-__InLocalStorageMockFactory.type = constants_2.STORAGE_MEMORY;
 /**
  * This function validates `settings.storage` object
  *
@@ -27,10 +20,6 @@ function validateStorageCS(settings) {
         storage = InMemoryStorageCS_1.InMemoryStorageCSFactory;
         log.error(constants_1.ERROR_STORAGE_INVALID);
     }
-    // In localhost mode with InLocalStorage, fallback to a mock InLocalStorage to emit SDK_READY_FROM_CACHE
-    if (mode === constants_2.LOCALHOST_MODE && storage.type === constants_2.STORAGE_LOCALSTORAGE) {
-        return __InLocalStorageMockFactory;
-    }
     if ([constants_2.LOCALHOST_MODE, constants_2.STANDALONE_MODE].indexOf(mode) === -1) {
         // Consumer modes require an async storage
         if (storage.type !== constants_2.STORAGE_PLUGGABLE)

package/esm/sdkFactory/index.js

@@ -5,7 +5,7 @@ import { telemetryTrackerFactory } from '../trackers/telemetryTracker';
 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';
@@ -35,8 +35,10 @@ export function sdkFactory(params) {
             readiness.splits.emit(SDK_SPLITS_ARRIVED);
             readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
         },
+        onReadyFromCacheCb: function () {
+            readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
+        }
     });
-    // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
     var clients = {};
     var telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
     var integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings: settings, storage: storage, telemetryTracker: telemetryTracker });

package/esm/storages/AbstractSplitsCacheAsync.js

@@ -11,13 +11,6 @@ var AbstractSplitsCacheAsync = /** @class */ (function () {
     AbstractSplitsCacheAsync.prototype.usesSegments = function () {
         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.
-     */
-    AbstractSplitsCacheAsync.prototype.checkCache = function () {
-        return Promise.resolve(false);
-    };
     /**
      * Kill `name` split and set `defaultTreatment` and `changeNumber`.
      * Used for SPLIT_KILL push notifications.

package/esm/storages/AbstractSplitsCacheSync.js

@@ -27,13 +27,6 @@ var AbstractSplitsCacheSync = /** @class */ (function () {
         var _this = this;
         return this.getSplitNames().map(function (key) { return _this.getSplit(key); });
     };
-    /**
-     * 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.
-     */
-    AbstractSplitsCacheSync.prototype.checkCache = function () {
-        return false;
-    };
     /**
      * Kill `name` split and set `defaultTreatment` and `changeNumber`.
      * Used for SPLIT_KILL push notifications.

package/esm/storages/dataLoader.js

@@ -1,47 +1,79 @@
-import { DEFAULT_CACHE_EXPIRATION_IN_MILLIS } from '../utils/constants/browser';
+import { setToArray } from '../utils/lang/sets';
 /**
- * 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) {
-    /**
-     * Storage-agnostic adaptation of `loadDataIntoLocalStorage` function
-     * (https://github.com/godaddy/split-javascript-data-loader/blob/master/src/load-data.js)
-     *
-     * @param storage object containing `splits` and `segments` cache (client-side variant)
-     * @param userId user key string of the provided MySegmentsCache
-     *
-     * @TODO extend to support SegmentsCache (server-side variant) by making `userId` optional and adding the corresponding logic.
-     * @TODO extend to load data on shared mySegments storages. Be specific when emitting SDK_READY_FROM_CACHE on shared clients. Maybe the serializer should provide the `useSegments` flag.
-     */
-    return function loadData(storage, userId) {
-        // Do not load data if current preloadedData is empty
-        if (Object.keys(preloadedData).length === 0)
-            return;
-        var _a = preloadedData.lastUpdated, lastUpdated = _a === void 0 ? -1 : _a, _b = preloadedData.segmentsData, segmentsData = _b === void 0 ? {} : _b, _c = preloadedData.since, since = _c === void 0 ? -1 : _c, _d = preloadedData.splitsData, splitsData = _d === void 0 ? {} : _d;
+export function loadData(preloadedData, storage, userKey) {
+    // Do not load data if current preloadedData is empty
+    if (Object.keys(preloadedData).length === 0)
+        return;
+    var _a = preloadedData.segmentsData, segmentsData = _a === void 0 ? {} : _a, _b = preloadedData.since, since = _b === void 0 ? -1 : _b, _c = preloadedData.splitsData, splitsData = _c === void 0 ? [] : _c;
+    if (storage.splits) {
         var storedSince = storage.splits.getChangeNumber();
-        var expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
-        // Do not load data if current localStorage data is more recent,
-        // or if its `lastUpdated` timestamp is older than the given `expirationTimestamp`,
-        if (storedSince > since || lastUpdated < expirationTimestamp)
+        // 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(function (splitName) { return JSON.parse(splitsData[splitName]); }));
-        // add mySegments data
-        var mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[userId];
+        storage.splits.addSplits(splitsData.map(function (split) { return ([split.name, split]); }));
+    }
+    if (userKey) { // add mySegments data (client-side)
+        var mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[userKey];
         if (!mySegmentsData) {
             // segmentsData in an object where the property is the segment name and the pertaining value is a stringified object that contains the `added` array of userIds
             mySegmentsData = Object.keys(segmentsData).filter(function (segmentName) {
-                var userIds = JSON.parse(segmentsData[segmentName]).added;
-                return Array.isArray(userIds) && userIds.indexOf(userId) > -1;
+                var userKeys = segmentsData[segmentName];
+                return userKeys.indexOf(userKey) > -1;
             });
         }
         storage.segments.resetSegments({ k: mySegmentsData.map(function (s) { return ({ n: s }); }) });
+    }
+    else { // add segments data (server-side)
+        Object.keys(segmentsData).filter(function (segmentName) {
+            var userKeys = segmentsData[segmentName];
+            storage.segments.addToSegment(segmentName, userKeys);
+        });
+    }
+}
+export function getSnapshot(storage, userKeys) {
+    return {
+        // lastUpdated: Date.now(),
+        // @ts-ignore accessing private prop
+        since: storage.splits.changeNumber,
+        splitsData: storage.splits.getAll(),
+        segmentsData: userKeys ?
+            undefined : // @ts-ignore accessing private prop
+            Object.keys(storage.segments.segmentCache).reduce(function (prev, cur) {
+                prev[cur] = setToArray(storage.segments.segmentCache[cur]);
+                return prev;
+            }, {}),
+        mySegmentsData: userKeys ?
+            userKeys.reduce(function (prev, userKey) {
+                // @ts-ignore accessing private prop
+                prev[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(function (prev, segmentName) {
+                        return storage.segments.segmentCache[segmentName].has(userKey) ?
+                            prev.concat(segmentName) :
+                            prev;
+                    }, []);
+                return prev;
+            }, {}) :
+            undefined
     };
 }

package/esm/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -183,14 +183,6 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
             return true;
         }
     };
-    /**
-     * 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
-     */
-    SplitsCacheInLocal.prototype.checkCache = function () {
-        return this.getChangeNumber() > -1;
-    };
     /**
      * Clean Splits cache if its `lastUpdated` timestamp is older than the given `expirationTimestamp`,
      *
@@ -213,7 +205,7 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
                 // mark cache to update the new query filter on first successful splits fetch
                 this.updateNewFilter = true;
                 // if there is cache, clear it
-                if (this.checkCache())
+                if (this.getChangeNumber() > -1)
                     this.clear();
             }
             catch (e) {

package/esm/storages/inLocalStorage/index.js

@@ -11,7 +11,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';
@@ -27,13 +27,16 @@ export function InLocalStorage(options) {
             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, _c = _a.sync, impressionsMode = _c.impressionsMode, __splitFiltersValidation = _c.__splitFiltersValidation;
+        var onReadyFromCacheCb = params.onReadyFromCacheCb, settings = params.settings, _a = params.settings, log = _a.log, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, _c = _a.sync, impressionsMode = _c.impressionsMode, __splitFiltersValidation = _c.__splitFiltersValidation;
         var matchingKey = getMatching(settings.core.key);
         var keys = new KeyBuilderCS(prefix, matchingKey);
         var expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
         var splits = new SplitsCacheInLocal(settings, keys, expirationTimestamp);
         var segments = new MySegmentsCacheInLocal(log, keys);
         var largeSegments = new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey));
+        if (settings.mode === LOCALHOST_MODE || splits.getChangeNumber() > -1) {
+            Promise.resolve().then(onReadyFromCacheCb);
+        }
         return {
             splits: splits,
             segments: segments,

package/esm/storages/inMemory/InMemoryStorageCS.js

@@ -6,13 +6,15 @@ import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
 import { DEBUG, LOCALHOST_MODE, NONE, STORAGE_MEMORY } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from './TelemetryCacheInMemory';
 import { UniqueKeysCacheInMemoryCS } from './UniqueKeysCacheInMemoryCS';
+import { getMatching } from '../../utils/key';
+import { loadData } from '../dataLoader';
 /**
  * InMemory storage factory for standalone client-side SplitFactory
  *
  * @param params parameters required by EventsCacheSync
  */
 export function InMemoryStorageCSFactory(params) {
-    var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, _c = _a.sync, impressionsMode = _c.impressionsMode, __splitFiltersValidation = _c.__splitFiltersValidation;
+    var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, _c = _a.sync, impressionsMode = _c.impressionsMode, __splitFiltersValidation = _c.__splitFiltersValidation, preloadedData = _a.preloadedData, onReadyFromCacheCb = params.onReadyFromCacheCb;
     var splits = new SplitsCacheInMemory(__splitFiltersValidation);
     var segments = new MySegmentsCacheInMemory();
     var largeSegments = new MySegmentsCacheInMemory();
@@ -36,11 +38,16 @@ export function InMemoryStorageCSFactory(params) {
             this.uniqueKeys && this.uniqueKeys.clear();
         },
         // When using shared instanciation with MEMORY we reuse everything but segments (they are unique per key)
-        shared: function () {
+        shared: function (matchingKey) {
+            var segments = new MySegmentsCacheInMemory();
+            var largeSegments = new MySegmentsCacheInMemory();
+            if (preloadedData) {
+                loadData(preloadedData, { segments: segments, largeSegments: largeSegments }, matchingKey);
+            }
             return {
                 splits: this.splits,
-                segments: new MySegmentsCacheInMemory(),
-                largeSegments: new MySegmentsCacheInMemory(),
+                segments: segments,
+                largeSegments: largeSegments,
                 impressions: this.impressions,
                 impressionCounts: this.impressionCounts,
                 events: this.events,
@@ -65,6 +72,11 @@ export function InMemoryStorageCSFactory(params) {
         if (storage.uniqueKeys)
             storage.uniqueKeys.track = noopTrack;
     }
+    if (preloadedData) {
+        loadData(preloadedData, storage, getMatching(params.settings.core.key));
+        if (splits.getChangeNumber() > -1)
+            onReadyFromCacheCb();
+    }
     return storage;
 }
 InMemoryStorageCSFactory.type = STORAGE_MEMORY;

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;
             });