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

package/CHANGES.txt

@@ -1,6 +1,6 @@
-2.5.0 (August XX, 2025)
- - Added `factory.getCache()` method for standalone server-side SDKs, which returns the rollout plan snapshot from the storage.
- - Added `preloadedData` configuration option for standalone client-side SDKs, which allows preloading the SDK storage with a snapshot of the rollout plan.
+2.5.0 (September 10, 2025)
+ - Added `factory.getRolloutPlan()` method for standalone server-side SDKs, which returns the rollout plan snapshot from the storage.
+ - Added `initialRolloutPlan` configuration option for standalone client-side SDKs, which allows preloading the SDK storage with a snapshot of the rollout plan.
 
 2.4.1 (June 3, 2025)
  - Bugfix - Improved the Proxy fallback to flag spec version 1.2 to handle cases where the Proxy does not return an end-of-stream marker in 400 status code responses.

package/cjs/evaluator/convertions/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.zeroSinceSS = exports.zeroSinceHH = void 0;
+exports.betweenDateTimeTransform = exports.zeroSinceSS = exports.zeroSinceHH = void 0;
 function zeroSinceHH(millisSinceEpoch) {
     return new Date(millisSinceEpoch).setUTCHours(0, 0, 0, 0);
 }
@@ -9,3 +9,11 @@ function zeroSinceSS(millisSinceEpoch) {
     return new Date(millisSinceEpoch).setUTCSeconds(0, 0);
 }
 exports.zeroSinceSS = zeroSinceSS;
+function betweenDateTimeTransform(betweenMatcherData) {
+    return {
+        dataType: betweenMatcherData.dataType,
+        start: zeroSinceSS(betweenMatcherData.start),
+        end: zeroSinceSS(betweenMatcherData.end)
+    };
+}
+exports.betweenDateTimeTransform = betweenDateTimeTransform;

package/cjs/evaluator/matchersTransform/index.js

@@ -17,7 +17,7 @@ function matchersTransform(matchers) {
         var type = (0, matcherTypes_1.matcherTypesMapper)(matcherType);
         // As default input data type we use string (even for ALL_KEYS)
         var dataType = matcherTypes_1.matcherDataTypes.STRING;
-        var value = undefined;
+        var value;
         if (type === matcherTypes_1.matcherTypes.IN_SEGMENT) {
             value = (0, segment_1.segmentTransform)(userDefinedSegmentMatcherData);
         }
@@ -45,8 +45,7 @@ function matchersTransform(matchers) {
             value = betweenMatcherData;
             dataType = matcherTypes_1.matcherDataTypes.NUMBER;
             if (value.dataType === 'DATETIME') {
-                value.start = (0, convertions_1.zeroSinceSS)(value.start);
-                value.end = (0, convertions_1.zeroSinceSS)(value.end);
+                value = (0, convertions_1.betweenDateTimeTransform)(value);
                 dataType = matcherTypes_1.matcherDataTypes.DATETIME;
             }
         }

package/cjs/sdkClient/sdkClientMethodCS.js

@@ -9,12 +9,13 @@ var objectAssign_1 = require("../utils/lang/objectAssign");
 var constants_1 = require("../logger/constants");
 var constants_2 = require("../readiness/constants");
 var identity_1 = require("./identity");
+var setRolloutPlan_1 = require("../storages/setRolloutPlan");
 /**
  * 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.
  */
 function sdkClientMethodCSFactory(params) {
-    var clients = params.clients, storage = params.storage, syncManager = params.syncManager, sdkReadinessManager = params.sdkReadinessManager, _a = params.settings, key = _a.core.key, log = _a.log;
+    var clients = params.clients, storage = params.storage, syncManager = params.syncManager, sdkReadinessManager = params.sdkReadinessManager, _a = params.settings, key = _a.core.key, log = _a.log, initialRolloutPlan = _a.initialRolloutPlan;
     var mainClientInstance = (0, clientCS_1.clientCSDecorator)(log, (0, sdkClient_1.sdkClientFactory)(params), key);
     var parsedDefaultKey = (0, key_2.keyParser)(key);
     var defaultInstanceId = (0, identity_1.buildInstanceId)(parsedDefaultKey);
@@ -42,6 +43,9 @@ function sdkClientMethodCSFactory(params) {
                 // Emit SDK_READY in consumer mode for shared clients
                 sharedSdkReadiness_1.readinessManager.segments.emit(constants_2.SDK_SEGMENTS_ARRIVED);
             });
+            if (sharedStorage && initialRolloutPlan) {
+                (0, setRolloutPlan_1.setRolloutPlan)(log, initialRolloutPlan, { segments: sharedStorage.segments, largeSegments: sharedStorage.largeSegments }, matchingKey);
+            }
             // 3 possibilities:
             // - Standalone mode: both syncManager and sharedSyncManager are defined
             // - Consumer mode: both syncManager and sharedSyncManager are undefined

package/cjs/sdkFactory/index.js

@@ -15,12 +15,14 @@ var strategyOptimized_1 = require("../trackers/strategy/strategyOptimized");
 var strategyNone_1 = require("../trackers/strategy/strategyNone");
 var uniqueKeysTracker_1 = require("../trackers/uniqueKeysTracker");
 var constants_3 = require("../utils/constants");
+var setRolloutPlan_1 = require("../storages/setRolloutPlan");
+var key_1 = require("../utils/key");
 /**
  * Modular SDK factory
  */
 function sdkFactory(params) {
     var settings = params.settings, platform = params.platform, storageFactory = params.storageFactory, splitApiFactory = params.splitApiFactory, extraProps = params.extraProps, syncManagerFactory = params.syncManagerFactory, SignalListener = params.SignalListener, impressionsObserverFactory = params.impressionsObserverFactory, integrationsManagerFactory = params.integrationsManagerFactory, sdkManagerFactory = params.sdkManagerFactory, sdkClientMethodFactory = params.sdkClientMethodFactory, filterAdapterFactory = params.filterAdapterFactory, lazyInit = params.lazyInit;
-    var log = settings.log, impressionsMode = settings.sync.impressionsMode;
+    var log = settings.log, impressionsMode = settings.sync.impressionsMode, initialRolloutPlan = settings.initialRolloutPlan, key = settings.core.key;
     // @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.
     // initialization
@@ -49,7 +51,11 @@ function sdkFactory(params) {
             readiness.splits.emit(constants_2.SDK_SPLITS_CACHE_LOADED);
         }
     });
-    // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
+    if (initialRolloutPlan) {
+        (0, setRolloutPlan_1.setRolloutPlan)(log, initialRolloutPlan, storage, key && (0, key_1.getMatching)(key));
+        if (storage.splits.getChangeNumber() > -1)
+            readiness.splits.emit(constants_2.SDK_SPLITS_CACHE_LOADED);
+    }
     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/getRolloutPlan.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRolloutPlan = void 0;
+var sets_1 = require("../utils/lang/sets");
+var key_1 = require("../utils/key");
+/**
+ * Gets the rollout plan snapshot from the given synchronous storage.
+ */
+function getRolloutPlan(log, storage, options) {
+    if (options === void 0) { options = {}; }
+    var keys = options.keys, exposeSegments = options.exposeSegments;
+    var splits = storage.splits, segments = storage.segments, rbSegments = storage.rbSegments;
+    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(function (segmentName) { return ({
+                name: segmentName,
+                added: (0, sets_1.setToArray)(segments.segmentCache[segmentName]),
+                removed: [],
+                since: -1,
+                till: segments.getChangeNumber(segmentName)
+            }); }) :
+            undefined,
+        memberships: keys ?
+            keys.reduce(function (prev, key) {
+                var matchingKey = (0, key_1.getMatching)(key);
+                if (storage.shared) { // Client-side segments
+                    var sharedStorage = storage.shared(matchingKey);
+                    prev[matchingKey] = {
+                        ms: {
+                            k: Object.keys(sharedStorage.segments.segmentCache).map(function (segmentName) { return ({ n: segmentName }); }),
+                        },
+                        ls: sharedStorage.largeSegments ? {
+                            k: Object.keys(sharedStorage.largeSegments.segmentCache).map(function (segmentName) { return ({ n: segmentName }); }),
+                        } : undefined
+                    };
+                }
+                else { // Server-side segments
+                    prev[matchingKey] = {
+                        ms: {
+                            k: Object.keys(storage.segments.segmentCache).reduce(function (prev, segmentName) {
+                                return storage.segments.segmentCache[segmentName].has(matchingKey) ?
+                                    prev.concat({ n: segmentName }) :
+                                    prev;
+                            }, [])
+                        },
+                        ls: {
+                            k: []
+                        }
+                    };
+                }
+                return prev;
+            }, {}) :
+            undefined
+    };
+}
+exports.getRolloutPlan = getRolloutPlan;

package/cjs/storages/inLocalStorage/validateCache.js

@@ -12,7 +12,7 @@ var MILLIS_IN_A_DAY = 86400000;
  * @returns `true` if cache should be cleared, `false` otherwise
  */
 function validateExpiration(options, settings, keys, currentTimestamp, isThereCache) {
-    var log = settings.log;
+    var log = settings.log, initialRolloutPlan = settings.initialRolloutPlan;
     // Check expiration
     var lastUpdatedTimestamp = parseInt(localStorage.getItem(keys.buildLastUpdatedKey()), 10);
     if (!(0, lang_1.isNaNNumber)(lastUpdatedTimestamp)) {
@@ -34,7 +34,7 @@ function validateExpiration(options, settings, keys, currentTimestamp, isThereCa
         catch (e) {
             log.error(constants_1.LOG_PREFIX + e);
         }
-        if (isThereCache) {
+        if (isThereCache && !initialRolloutPlan) {
             log.info(constants_1.LOG_PREFIX + 'SDK key, flags filter criteria, or flags spec version has changed. Cleaning up cache');
             return true;
         }

package/cjs/storages/inMemory/InMemoryStorageCS.js

@@ -9,8 +9,6 @@ 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");
 var RBSegmentsCacheInMemory_1 = require("./RBSegmentsCacheInMemory");
 /**
  * InMemory storage factory for standalone client-side SplitFactory
@@ -18,8 +16,7 @@ var RBSegmentsCacheInMemory_1 = require("./RBSegmentsCacheInMemory");
  * @param params - parameters required by EventsCacheSync
  */
 function InMemoryStorageCSFactory(params) {
-    var _a = params.settings, log = _a.log, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, __splitFiltersValidation = _a.sync.__splitFiltersValidation, preloadedData = _a.preloadedData, onReadyFromCacheCb = params.onReadyFromCacheCb;
-    var storages = {};
+    var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, __splitFiltersValidation = _a.sync.__splitFiltersValidation;
     var splits = new SplitsCacheInMemory_1.SplitsCacheInMemory(__splitFiltersValidation);
     var rbSegments = new RBSegmentsCacheInMemory_1.RBSegmentsCacheInMemory();
     var segments = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
@@ -36,27 +33,19 @@ function InMemoryStorageCSFactory(params) {
         uniqueKeys: new UniqueKeysCacheInMemoryCS_1.UniqueKeysCacheInMemoryCS(),
         destroy: function () { },
         // When using shared instantiation with MEMORY we reuse everything but segments (they are unique per key)
-        shared: function (matchingKey) {
-            if (!storages[matchingKey]) {
-                var segments_1 = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
-                var largeSegments_1 = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
-                if (preloadedData) {
-                    (0, dataLoader_1.setCache)(log, preloadedData, { segments: segments_1, largeSegments: largeSegments_1 }, matchingKey);
-                }
-                storages[matchingKey] = {
-                    splits: this.splits,
-                    rbSegments: this.rbSegments,
-                    segments: segments_1,
-                    largeSegments: largeSegments_1,
-                    impressions: this.impressions,
-                    impressionCounts: this.impressionCounts,
-                    events: this.events,
-                    telemetry: this.telemetry,
-                    uniqueKeys: this.uniqueKeys,
-                    destroy: function () { }
-                };
-            }
-            return storages[matchingKey];
+        shared: function () {
+            return {
+                splits: this.splits,
+                rbSegments: this.rbSegments,
+                segments: new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory(),
+                largeSegments: new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory(),
+                impressions: this.impressions,
+                impressionCounts: this.impressionCounts,
+                events: this.events,
+                telemetry: this.telemetry,
+                uniqueKeys: this.uniqueKeys,
+                destroy: function () { }
+            };
         },
     };
     // @TODO revisit storage logic in localhost mode
@@ -68,13 +57,6 @@ function InMemoryStorageCSFactory(params) {
         storage.impressionCounts.track = noopTrack;
         storage.uniqueKeys.track = noopTrack;
     }
-    var matchingKey = (0, key_1.getMatching)(params.settings.core.key);
-    storages[matchingKey] = storage;
-    if (preloadedData) {
-        (0, dataLoader_1.setCache)(log, preloadedData, storage, matchingKey);
-        if (splits.getChangeNumber() > -1)
-            onReadyFromCacheCb();
-    }
     return storage;
 }
 exports.InMemoryStorageCSFactory = InMemoryStorageCSFactory;

package/cjs/storages/setRolloutPlan.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setRolloutPlan = exports.validateRolloutPlan = void 0;
+var lang_1 = require("../utils/lang");
+var mode_1 = require("../utils/settingsValidation/mode");
+/**
+ * Validates if the given rollout plan is valid.
+ */
+function validateRolloutPlan(log, settings) {
+    var mode = settings.mode, initialRolloutPlan = settings.initialRolloutPlan;
+    if ((0, mode_1.isConsumerMode)(mode)) {
+        log.warn('storage: initial rollout plan is ignored in consumer mode');
+        return;
+    }
+    if ((0, lang_1.isObject)(initialRolloutPlan) && (0, lang_1.isObject)(initialRolloutPlan.splitChanges))
+        return initialRolloutPlan;
+    log.error('storage: invalid rollout plan provided');
+    return;
+}
+exports.validateRolloutPlan = validateRolloutPlan;
+/**
+ * Sets the given synchronous storage with the provided rollout plan snapshot.
+ * If `matchingKey` is provided, the storage is handled as a client-side storage (segments and largeSegments are instances of MySegmentsCache).
+ * Otherwise, the storage is handled as a server-side storage (segments is an instance of SegmentsCache).
+ */
+function setRolloutPlan(log, rolloutPlan, storage, matchingKey) {
+    var splits = storage.splits, rbSegments = storage.rbSegments, segments = storage.segments, largeSegments = storage.largeSegments;
+    var _a = rolloutPlan.splitChanges, ff = _a.ff, rbs = _a.rbs;
+    log.debug("storage: set feature flags and segments" + (matchingKey ? " for key " + matchingKey : ''));
+    if (splits && ff) {
+        splits.clear();
+        splits.update(ff.d, [], ff.t);
+    }
+    if (rbSegments && rbs) {
+        rbSegments.clear();
+        rbSegments.update(rbs.d, [], rbs.t);
+    }
+    var segmentChanges = rolloutPlan.segmentChanges;
+    if (matchingKey) { // add memberships data (client-side)
+        var memberships = rolloutPlan.memberships && rolloutPlan.memberships[matchingKey];
+        if (!memberships && segmentChanges) {
+            memberships = {
+                ms: {
+                    k: segmentChanges.filter(function (segment) {
+                        return segment.added.indexOf(matchingKey) > -1;
+                    }).map(function (segment) { return ({ n: segment.name }); })
+                }
+            };
+        }
+        if (memberships) {
+            if (memberships.ms)
+                segments.resetSegments(memberships.ms);
+            if (memberships.ls && largeSegments)
+                largeSegments.resetSegments(memberships.ls);
+        }
+    }
+    else { // add segments data (server-side)
+        if (segmentChanges) {
+            segments.clear();
+            segmentChanges.forEach(function (segment) {
+                segments.update(segment.name, segment.added, segment.removed, segment.till);
+            });
+        }
+    }
+}
+exports.setRolloutPlan = setRolloutPlan;

package/cjs/utils/inputValidation/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateEvaluationOptions = exports.validatePreloadedData = exports.validateTrafficTypeExistence = exports.validateSplitExistence = exports.validateIfOperational = exports.validateIfNotDestroyed = exports.validateTrafficType = exports.validateSplits = exports.validateSplit = exports.validateKey = exports.validateEventProperties = exports.validateEventValue = exports.validateEvent = exports.validateAttributes = exports.releaseApiKey = exports.validateAndTrackApiKey = exports.validateApiKey = void 0;
+exports.validateEvaluationOptions = exports.validateTrafficTypeExistence = exports.validateSplitExistence = exports.validateIfOperational = exports.validateIfNotDestroyed = exports.validateTrafficType = exports.validateSplits = exports.validateSplit = exports.validateKey = exports.validateEventProperties = exports.validateEventValue = exports.validateEvent = exports.validateAttributes = exports.releaseApiKey = exports.validateAndTrackApiKey = exports.validateApiKey = void 0;
 var apiKey_1 = require("./apiKey");
 Object.defineProperty(exports, "validateApiKey", { enumerable: true, get: function () { return apiKey_1.validateApiKey; } });
 Object.defineProperty(exports, "validateAndTrackApiKey", { enumerable: true, get: function () { return apiKey_1.validateAndTrackApiKey; } });
@@ -28,7 +28,5 @@ var splitExistence_1 = require("./splitExistence");
 Object.defineProperty(exports, "validateSplitExistence", { enumerable: true, get: function () { return splitExistence_1.validateSplitExistence; } });
 var trafficTypeExistence_1 = require("./trafficTypeExistence");
 Object.defineProperty(exports, "validateTrafficTypeExistence", { enumerable: true, get: function () { return trafficTypeExistence_1.validateTrafficTypeExistence; } });
-var preloadedData_1 = require("./preloadedData");
-Object.defineProperty(exports, "validatePreloadedData", { enumerable: true, get: function () { return preloadedData_1.validatePreloadedData; } });
 var eventProperties_2 = require("./eventProperties");
 Object.defineProperty(exports, "validateEvaluationOptions", { enumerable: true, get: function () { return eventProperties_2.validateEvaluationOptions; } });

package/cjs/utils/settingsValidation/index.js

@@ -8,6 +8,7 @@ var constants_1 = require("../constants");
 var impressionsMode_1 = require("./impressionsMode");
 var key_1 = require("../inputValidation/key");
 var constants_2 = require("../../logger/constants");
+var setRolloutPlan_1 = require("../../storages/setRolloutPlan");
 // Exported for telemetry
 exports.base = {
     // Define which kind of object you want to retrieve from SplitFactory
@@ -131,6 +132,9 @@ 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 = (0, setRolloutPlan_1.validateRolloutPlan)(log, withDefaults);
     // Validate key and TT (for client-side)
     var maybeKey = withDefaults.core.key;
     if (validationParams.acceptKey) {

package/esm/evaluator/convertions/index.js

@@ -4,3 +4,10 @@ export function zeroSinceHH(millisSinceEpoch) {
 export function zeroSinceSS(millisSinceEpoch) {
     return new Date(millisSinceEpoch).setUTCSeconds(0, 0);
 }
+export function betweenDateTimeTransform(betweenMatcherData) {
+    return {
+        dataType: betweenMatcherData.dataType,
+        start: zeroSinceSS(betweenMatcherData.start),
+        end: zeroSinceSS(betweenMatcherData.end)
+    };
+}

package/esm/evaluator/matchersTransform/index.js

@@ -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';
 /**
  * Flat the complex matcherGroup structure into something handy.
  */
@@ -14,7 +14,7 @@ export function matchersTransform(matchers) {
         var type = matcherTypesMapper(matcherType);
         // As default input data type we use string (even for ALL_KEYS)
         var dataType = matcherDataTypes.STRING;
-        var value = undefined;
+        var value;
         if (type === matcherTypes.IN_SEGMENT) {
             value = segmentTransform(userDefinedSegmentMatcherData);
         }
@@ -42,8 +42,7 @@ export function matchersTransform(matchers) {
             value = betweenMatcherData;
             dataType = matcherDataTypes.NUMBER;
             if (value.dataType === 'DATETIME') {
-                value.start = zeroSinceSS(value.start);
-                value.end = zeroSinceSS(value.end);
+                value = betweenDateTimeTransform(value);
                 dataType = matcherDataTypes.DATETIME;
             }
         }

package/esm/sdkClient/sdkClientMethodCS.js

@@ -6,12 +6,13 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { RETRIEVE_CLIENT_DEFAULT, NEW_SHARED_CLIENT, RETRIEVE_CLIENT_EXISTING, LOG_PREFIX_CLIENT_INSTANTIATION } from '../logger/constants';
 import { SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
 import { buildInstanceId } from './identity';
+import { setRolloutPlan } from '../storages/setRolloutPlan';
 /**
  * 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) {
-    var clients = params.clients, storage = params.storage, syncManager = params.syncManager, sdkReadinessManager = params.sdkReadinessManager, _a = params.settings, key = _a.core.key, log = _a.log;
+    var clients = params.clients, storage = params.storage, syncManager = params.syncManager, sdkReadinessManager = params.sdkReadinessManager, _a = params.settings, key = _a.core.key, log = _a.log, initialRolloutPlan = _a.initialRolloutPlan;
     var mainClientInstance = clientCSDecorator(log, sdkClientFactory(params), key);
     var parsedDefaultKey = keyParser(key);
     var defaultInstanceId = buildInstanceId(parsedDefaultKey);
@@ -39,6 +40,9 @@ export function sdkClientMethodCSFactory(params) {
                 // Emit SDK_READY in consumer mode for shared clients
                 sharedSdkReadiness_1.readinessManager.segments.emit(SDK_SEGMENTS_ARRIVED);
             });
+            if (sharedStorage && initialRolloutPlan) {
+                setRolloutPlan(log, initialRolloutPlan, { segments: sharedStorage.segments, largeSegments: sharedStorage.largeSegments }, matchingKey);
+            }
             // 3 possibilities:
             // - Standalone mode: both syncManager and sharedSyncManager are defined
             // - Consumer mode: both syncManager and sharedSyncManager are undefined

package/esm/sdkFactory/index.js

@@ -12,12 +12,14 @@ 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 { getMatching } from '../utils/key';
 /**
  * Modular SDK factory
  */
 export function sdkFactory(params) {
     var settings = params.settings, platform = params.platform, storageFactory = params.storageFactory, splitApiFactory = params.splitApiFactory, extraProps = params.extraProps, syncManagerFactory = params.syncManagerFactory, SignalListener = params.SignalListener, impressionsObserverFactory = params.impressionsObserverFactory, integrationsManagerFactory = params.integrationsManagerFactory, sdkManagerFactory = params.sdkManagerFactory, sdkClientMethodFactory = params.sdkClientMethodFactory, filterAdapterFactory = params.filterAdapterFactory, lazyInit = params.lazyInit;
-    var log = settings.log, impressionsMode = settings.sync.impressionsMode;
+    var log = settings.log, impressionsMode = settings.sync.impressionsMode, initialRolloutPlan = settings.initialRolloutPlan, key = settings.core.key;
     // @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.
     // initialization
@@ -46,7 +48,11 @@ export function sdkFactory(params) {
             readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
         }
     });
-    // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
+    if (initialRolloutPlan) {
+        setRolloutPlan(log, initialRolloutPlan, storage, key && getMatching(key));
+        if (storage.splits.getChangeNumber() > -1)
+            readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
+    }
     var clients = {};
     var telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
     var integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings: settings, storage: storage, telemetryTracker: telemetryTracker });

package/esm/storages/getRolloutPlan.js

@@ -0,0 +1,65 @@
+import { setToArray } from '../utils/lang/sets';
+import { getMatching } from '../utils/key';
+/**
+ * Gets the rollout plan snapshot from the given synchronous storage.
+ */
+export function getRolloutPlan(log, storage, options) {
+    if (options === void 0) { options = {}; }
+    var keys = options.keys, exposeSegments = options.exposeSegments;
+    var splits = storage.splits, segments = storage.segments, rbSegments = storage.rbSegments;
+    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(function (segmentName) { return ({
+                name: segmentName,
+                added: setToArray(segments.segmentCache[segmentName]),
+                removed: [],
+                since: -1,
+                till: segments.getChangeNumber(segmentName)
+            }); }) :
+            undefined,
+        memberships: keys ?
+            keys.reduce(function (prev, key) {
+                var matchingKey = getMatching(key);
+                if (storage.shared) { // Client-side segments
+                    var sharedStorage = storage.shared(matchingKey);
+                    prev[matchingKey] = {
+                        ms: {
+                            k: Object.keys(sharedStorage.segments.segmentCache).map(function (segmentName) { return ({ n: segmentName }); }),
+                        },
+                        ls: sharedStorage.largeSegments ? {
+                            k: Object.keys(sharedStorage.largeSegments.segmentCache).map(function (segmentName) { return ({ n: segmentName }); }),
+                        } : undefined
+                    };
+                }
+                else { // Server-side segments
+                    prev[matchingKey] = {
+                        ms: {
+                            k: Object.keys(storage.segments.segmentCache).reduce(function (prev, segmentName) {
+                                return storage.segments.segmentCache[segmentName].has(matchingKey) ?
+                                    prev.concat({ n: segmentName }) :
+                                    prev;
+                            }, [])
+                        },
+                        ls: {
+                            k: []
+                        }
+                    };
+                }
+                return prev;
+            }, {}) :
+            undefined
+    };
+}

package/esm/storages/inLocalStorage/validateCache.js

@@ -9,7 +9,7 @@ var MILLIS_IN_A_DAY = 86400000;
  * @returns `true` if cache should be cleared, `false` otherwise
  */
 function validateExpiration(options, settings, keys, currentTimestamp, isThereCache) {
-    var log = settings.log;
+    var log = settings.log, initialRolloutPlan = settings.initialRolloutPlan;
     // Check expiration
     var lastUpdatedTimestamp = parseInt(localStorage.getItem(keys.buildLastUpdatedKey()), 10);
     if (!isNaNNumber(lastUpdatedTimestamp)) {
@@ -31,7 +31,7 @@ function validateExpiration(options, settings, keys, currentTimestamp, isThereCa
         catch (e) {
             log.error(LOG_PREFIX + e);
         }
-        if (isThereCache) {
+        if (isThereCache && !initialRolloutPlan) {
             log.info(LOG_PREFIX + 'SDK key, flags filter criteria, or flags spec version has changed. Cleaning up cache');
             return true;
         }

package/esm/storages/inMemory/InMemoryStorageCS.js

@@ -6,8 +6,6 @@ import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
 import { LOCALHOST_MODE, STORAGE_MEMORY } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from './TelemetryCacheInMemory';
 import { UniqueKeysCacheInMemoryCS } from './UniqueKeysCacheInMemoryCS';
-import { getMatching } from '../../utils/key';
-import { setCache } from '../dataLoader';
 import { RBSegmentsCacheInMemory } from './RBSegmentsCacheInMemory';
 /**
  * InMemory storage factory for standalone client-side SplitFactory
@@ -15,8 +13,7 @@ import { RBSegmentsCacheInMemory } from './RBSegmentsCacheInMemory';
  * @param params - parameters required by EventsCacheSync
  */
 export function InMemoryStorageCSFactory(params) {
-    var _a = params.settings, log = _a.log, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, __splitFiltersValidation = _a.sync.__splitFiltersValidation, preloadedData = _a.preloadedData, onReadyFromCacheCb = params.onReadyFromCacheCb;
-    var storages = {};
+    var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, __splitFiltersValidation = _a.sync.__splitFiltersValidation;
     var splits = new SplitsCacheInMemory(__splitFiltersValidation);
     var rbSegments = new RBSegmentsCacheInMemory();
     var segments = new MySegmentsCacheInMemory();
@@ -33,27 +30,19 @@ export function InMemoryStorageCSFactory(params) {
         uniqueKeys: new UniqueKeysCacheInMemoryCS(),
         destroy: function () { },
         // When using shared instantiation with MEMORY we reuse everything but segments (they are unique per key)
-        shared: function (matchingKey) {
-            if (!storages[matchingKey]) {
-                var segments_1 = new MySegmentsCacheInMemory();
-                var largeSegments_1 = new MySegmentsCacheInMemory();
-                if (preloadedData) {
-                    setCache(log, preloadedData, { segments: segments_1, largeSegments: largeSegments_1 }, matchingKey);
-                }
-                storages[matchingKey] = {
-                    splits: this.splits,
-                    rbSegments: this.rbSegments,
-                    segments: segments_1,
-                    largeSegments: largeSegments_1,
-                    impressions: this.impressions,
-                    impressionCounts: this.impressionCounts,
-                    events: this.events,
-                    telemetry: this.telemetry,
-                    uniqueKeys: this.uniqueKeys,
-                    destroy: function () { }
-                };
-            }
-            return storages[matchingKey];
+        shared: function () {
+            return {
+                splits: this.splits,
+                rbSegments: this.rbSegments,
+                segments: new MySegmentsCacheInMemory(),
+                largeSegments: new MySegmentsCacheInMemory(),
+                impressions: this.impressions,
+                impressionCounts: this.impressionCounts,
+                events: this.events,
+                telemetry: this.telemetry,
+                uniqueKeys: this.uniqueKeys,
+                destroy: function () { }
+            };
         },
     };
     // @TODO revisit storage logic in localhost mode
@@ -65,13 +54,6 @@ export function InMemoryStorageCSFactory(params) {
         storage.impressionCounts.track = noopTrack;
         storage.uniqueKeys.track = noopTrack;
     }
-    var matchingKey = getMatching(params.settings.core.key);
-    storages[matchingKey] = storage;
-    if (preloadedData) {
-        setCache(log, preloadedData, storage, matchingKey);
-        if (splits.getChangeNumber() > -1)
-            onReadyFromCacheCb();
-    }
     return storage;
 }
 InMemoryStorageCSFactory.type = STORAGE_MEMORY;