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

package/cjs/storages/inLocalStorage/index.js

@@ -17,20 +17,6 @@ var TelemetryCacheInMemory_1 = require("../inMemory/TelemetryCacheInMemory");
 var UniqueKeysCacheInMemoryCS_1 = require("../inMemory/UniqueKeysCacheInMemoryCS");
 var key_1 = require("../../utils/key");
 var validateCache_1 = require("./validateCache");
-var storageAdapter_1 = require("./storageAdapter");
-function validateStorage(log, prefix, wrapper) {
-    if (wrapper) {
-        if ((0, isLocalStorageAvailable_1.isValidStorageWrapper)(wrapper)) {
-            return (0, isLocalStorageAvailable_1.isWebStorage)(wrapper) ?
-                wrapper : // localStorage and sessionStorage don't need adapter
-                (0, storageAdapter_1.storageAdapter)(log, prefix, wrapper);
-        }
-        log.warn(constants_1.LOG_PREFIX + 'Invalid storage provided. Falling back to LocalStorage API');
-    }
-    if ((0, isLocalStorageAvailable_1.isLocalStorageAvailable)())
-        return localStorage;
-    log.warn(constants_1.LOG_PREFIX + 'LocalStorage API is unavailable. Falling back to default MEMORY storage');
-}
 /**
  * InLocal storage factory for standalone client-side SplitFactory
  */
@@ -38,17 +24,18 @@ function InLocalStorage(options) {
     if (options === void 0) { options = {}; }
     var prefix = (0, KeyBuilder_1.validatePrefix)(options.prefix);
     function InLocalStorageCSFactory(params) {
-        var settings = params.settings, _a = params.settings, log = _a.log, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize;
-        var storage = validateStorage(log, prefix, options.wrapper);
-        if (!storage)
+        // Fallback to InMemoryStorage if LocalStorage API is not available
+        if (!(0, isLocalStorageAvailable_1.isLocalStorageAvailable)()) {
+            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;
         var matchingKey = (0, key_1.getMatching)(settings.core.key);
         var keys = new KeyBuilderCS_1.KeyBuilderCS(prefix, matchingKey);
-        var splits = new SplitsCacheInLocal_1.SplitsCacheInLocal(settings, keys, storage);
-        var rbSegments = new RBSegmentsCacheInLocal_1.RBSegmentsCacheInLocal(settings, keys, storage);
-        var segments = new MySegmentsCacheInLocal_1.MySegmentsCacheInLocal(log, keys, storage);
-        var largeSegments = new MySegmentsCacheInLocal_1.MySegmentsCacheInLocal(log, (0, KeyBuilderCS_1.myLargeSegmentsKeyBuilder)(prefix, matchingKey), storage);
-        var validateCachePromise;
+        var splits = new SplitsCacheInLocal_1.SplitsCacheInLocal(settings, keys);
+        var rbSegments = new RBSegmentsCacheInLocal_1.RBSegmentsCacheInLocal(settings, keys);
+        var segments = new MySegmentsCacheInLocal_1.MySegmentsCacheInLocal(log, keys);
+        var largeSegments = new MySegmentsCacheInLocal_1.MySegmentsCacheInLocal(log, (0, KeyBuilderCS_1.myLargeSegmentsKeyBuilder)(prefix, matchingKey));
         return {
             splits: splits,
             rbSegments: rbSegments,
@@ -60,21 +47,16 @@ function InLocalStorage(options) {
             telemetry: (0, TelemetryCacheInMemory_1.shouldRecordTelemetry)(params) ? new TelemetryCacheInMemory_1.TelemetryCacheInMemory(splits, segments) : undefined,
             uniqueKeys: new UniqueKeysCacheInMemoryCS_1.UniqueKeysCacheInMemoryCS(),
             validateCache: function () {
-                return validateCachePromise || (validateCachePromise = (0, validateCache_1.validateCache)(options, storage, settings, keys, splits, rbSegments, segments, largeSegments));
-            },
-            save: function () {
-                return storage.save && storage.save();
-            },
-            destroy: function () {
-                return storage.whenSaved && storage.whenSaved();
+                return (0, validateCache_1.validateCache)(options, settings, keys, splits, rbSegments, segments, largeSegments);
             },
+            destroy: function () { },
             // When using shared instantiation with MEMORY we reuse everything but segments (they are customer per key).
             shared: function (matchingKey) {
                 return {
                     splits: this.splits,
                     rbSegments: this.rbSegments,
-                    segments: new MySegmentsCacheInLocal_1.MySegmentsCacheInLocal(log, new KeyBuilderCS_1.KeyBuilderCS(prefix, matchingKey), storage),
-                    largeSegments: new MySegmentsCacheInLocal_1.MySegmentsCacheInLocal(log, (0, KeyBuilderCS_1.myLargeSegmentsKeyBuilder)(prefix, matchingKey), storage),
+                    segments: new MySegmentsCacheInLocal_1.MySegmentsCacheInLocal(log, new KeyBuilderCS_1.KeyBuilderCS(prefix, matchingKey)),
+                    largeSegments: new MySegmentsCacheInLocal_1.MySegmentsCacheInLocal(log, (0, KeyBuilderCS_1.myLargeSegmentsKeyBuilder)(prefix, matchingKey)),
                     impressions: this.impressions,
                     impressionCounts: this.impressionCounts,
                     events: this.events,

package/cjs/storages/inLocalStorage/validateCache.js

@@ -11,10 +11,10 @@ var MILLIS_IN_A_DAY = 86400000;
  *
  * @returns `true` if cache should be cleared, `false` otherwise
  */
-function validateExpiration(options, storage, settings, keys, currentTimestamp, isThereCache) {
-    var log = settings.log;
+function validateExpiration(options, settings, keys, currentTimestamp, isThereCache) {
+    var log = settings.log, initialRolloutPlan = settings.initialRolloutPlan;
     // Check expiration
-    var lastUpdatedTimestamp = parseInt(storage.getItem(keys.buildLastUpdatedKey()), 10);
+    var lastUpdatedTimestamp = parseInt(localStorage.getItem(keys.buildLastUpdatedKey()), 10);
     if (!(0, lang_1.isNaNNumber)(lastUpdatedTimestamp)) {
         var cacheExpirationInDays = (0, lang_1.isFiniteNumber)(options.expirationDays) && options.expirationDays >= 1 ? options.expirationDays : DEFAULT_CACHE_EXPIRATION_IN_DAYS;
         var expirationTimestamp = currentTimestamp - MILLIS_IN_A_DAY * cacheExpirationInDays;
@@ -25,16 +25,16 @@ function validateExpiration(options, storage, settings, keys, currentTimestamp,
     }
     // Check hash
     var storageHashKey = keys.buildHashKey();
-    var storageHash = storage.getItem(storageHashKey);
+    var storageHash = localStorage.getItem(storageHashKey);
     var currentStorageHash = (0, KeyBuilder_1.getStorageHash)(settings);
     if (storageHash !== currentStorageHash) {
         try {
-            storage.setItem(storageHashKey, currentStorageHash);
+            localStorage.setItem(storageHashKey, currentStorageHash);
         }
         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;
         }
@@ -42,7 +42,7 @@ function validateExpiration(options, storage, settings, keys, currentTimestamp,
     }
     // Clear on init
     if (options.clearOnInit) {
-        var lastClearTimestamp = parseInt(storage.getItem(keys.buildLastClear()), 10);
+        var lastClearTimestamp = parseInt(localStorage.getItem(keys.buildLastClear()), 10);
         if ((0, lang_1.isNaNNumber)(lastClearTimestamp) || lastClearTimestamp < currentTimestamp - MILLIS_IN_A_DAY) {
             log.info(constants_1.LOG_PREFIX + 'clearOnInit was set and cache was not cleared in the last 24 hours. Cleaning up cache');
             return true;
@@ -57,29 +57,24 @@ function validateExpiration(options, storage, settings, keys, currentTimestamp,
  *
  * @returns `true` if cache is ready to be used, `false` otherwise (cache was cleared or there is no cache)
  */
-function validateCache(options, storage, settings, keys, splits, rbSegments, segments, largeSegments) {
-    return Promise.resolve(storage.load && storage.load()).then(function () {
-        var currentTimestamp = Date.now();
-        var isThereCache = splits.getChangeNumber() > -1;
-        if (validateExpiration(options, storage, settings, keys, currentTimestamp, isThereCache)) {
-            splits.clear();
-            rbSegments.clear();
-            segments.clear();
-            largeSegments.clear();
-            // Update last clear timestamp
-            try {
-                storage.setItem(keys.buildLastClear(), currentTimestamp + '');
-            }
-            catch (e) {
-                settings.log.error(constants_1.LOG_PREFIX + e);
-            }
-            // Persist clear
-            if (storage.save)
-                storage.save();
-            return false;
+function validateCache(options, settings, keys, splits, rbSegments, segments, largeSegments) {
+    var currentTimestamp = Date.now();
+    var isThereCache = splits.getChangeNumber() > -1;
+    if (validateExpiration(options, settings, keys, currentTimestamp, isThereCache)) {
+        splits.clear();
+        rbSegments.clear();
+        segments.clear();
+        largeSegments.clear();
+        // Update last clear timestamp
+        try {
+            localStorage.setItem(keys.buildLastClear(), currentTimestamp + '');
+        }
+        catch (e) {
+            settings.log.error(constants_1.LOG_PREFIX + e);
         }
-        // Check if ready from cache
-        return isThereCache;
-    });
+        return false;
+    }
+    // Check if ready from cache
+    return isThereCache;
 }
 exports.validateCache = validateCache;

package/cjs/storages/inMemory/RBSegmentsCacheInMemory.js

@@ -45,6 +45,10 @@ var RBSegmentsCacheInMemory = /** @class */ (function () {
     RBSegmentsCacheInMemory.prototype.get = function (name) {
         return this.cache[name] || null;
     };
+    RBSegmentsCacheInMemory.prototype.getAll = function () {
+        var _this = this;
+        return this.getNames().map(function (key) { return _this.get(key); });
+    };
     RBSegmentsCacheInMemory.prototype.contains = function (names) {
         var namesArray = (0, sets_1.setToArray)(names);
         var namesInStorage = this.getNames();

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/sync/offline/syncTasks/fromObjectSyncTask.js

@@ -45,9 +45,10 @@ function fromObjectUpdaterFactory(splitsParser, storage, readiness, settings) {
                 readiness.splits.emit(constants_2.SDK_SPLITS_ARRIVED);
                 if (startingUp) {
                     startingUp = false;
-                    Promise.resolve(storage.validateCache ? storage.validateCache() : false).then(function (isCacheLoaded) {
+                    var isCacheLoaded_1 = storage.validateCache ? storage.validateCache() : false;
+                    Promise.resolve().then(function () {
                         // Emits SDK_READY_FROM_CACHE
-                        if (isCacheLoaded)
+                        if (isCacheLoaded_1)
                             readiness.splits.emit(constants_2.SDK_SPLITS_CACHE_LOADED);
                         // Emits SDK_READY
                         readiness.segments.emit(constants_2.SDK_SEGMENTS_ARRIVED);

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

@@ -34,8 +34,6 @@ function mySegmentsUpdaterFactory(log, mySegmentsFetcher, storage, segmentsEvent
             shouldNotifyUpdate = segments.resetSegments(segmentsData.ms || {});
             shouldNotifyUpdate = largeSegments.resetSegments(segmentsData.ls || {}) || shouldNotifyUpdate;
         }
-        if (storage.save)
-            storage.save();
         // Notify update if required
         if ((0, AbstractSplitsCacheSync_1.usesSegmentsSync)(storage) && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
             readyOnAlreadyExistentState = false;

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

@@ -154,8 +154,6 @@ function splitChangesUpdaterFactory(log, splitChangesFetcher, storage, splitFilt
                     segments.registerSegments((0, sets_1.setToArray)(usedSegments))
                 ]).then(function (_a) {
                     var ffChanged = _a[0], rbsChanged = _a[1];
-                    if (storage.save)
-                        storage.save();
                     if (splitsEventEmitter) {
                         // To emit SDK_SPLITS_ARRIVED for server-side SDK, we must check that all registered segments have been fetched
                         return Promise.resolve(!splitsEventEmitter.splitsArrived || ((ffChanged || rbsChanged) && (isClientSide || checkAllSegmentsExist(segments))))

package/cjs/sync/syncManagerOnline.js

@@ -69,39 +69,35 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
              */
             start: function () {
                 running = true;
-                // @TODO once event, impression and telemetry storages support persistence, call when `validateCache` promise is resolved
-                submitterManager.start(!(0, consent_1.isConsentGranted)(settings));
-                return Promise.resolve(storage.validateCache ? storage.validateCache() : false).then(function (isCacheLoaded) {
-                    if (!running)
-                        return;
-                    if (startFirstTime) {
-                        // Emits SDK_READY_FROM_CACHE
-                        if (isCacheLoaded)
-                            readiness.splits.emit(constants_4.SDK_SPLITS_CACHE_LOADED);
-                    }
-                    // start syncing splits and segments
-                    if (pollingManager) {
-                        // If synchronization is disabled pushManager and pollingManager should not start
-                        if (syncEnabled) {
-                            if (pushManager) {
-                                // Doesn't call `syncAll` when the syncManager is resuming
-                                if (startFirstTime) {
-                                    pollingManager.syncAll();
-                                }
-                                pushManager.start();
-                            }
-                            else {
-                                pollingManager.start();
-                            }
-                        }
-                        else {
+                if (startFirstTime) {
+                    var isCacheLoaded = storage.validateCache ? storage.validateCache() : false;
+                    if (isCacheLoaded)
+                        Promise.resolve().then(function () { readiness.splits.emit(constants_4.SDK_SPLITS_CACHE_LOADED); });
+                }
+                // start syncing splits and segments
+                if (pollingManager) {
+                    // If synchronization is disabled pushManager and pollingManager should not start
+                    if (syncEnabled) {
+                        if (pushManager) {
+                            // Doesn't call `syncAll` when the syncManager is resuming
                             if (startFirstTime) {
                                 pollingManager.syncAll();
                             }
+                            pushManager.start();
+                        }
+                        else {
+                            pollingManager.start();
+                        }
+                    }
+                    else {
+                        if (startFirstTime) {
+                            pollingManager.syncAll();
                         }
                     }
-                    startFirstTime = false;
-                });
+                }
+                // start periodic data recording (events, impressions, telemetry).
+                submitterManager.start(!(0, consent_1.isConsentGranted)(settings));
+                startFirstTime = false;
             },
             /**
              * Method used to stop/pause the syncManager.

package/cjs/utils/env/isLocalStorageAvailable.js

@@ -1,39 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isWebStorage = exports.isValidStorageWrapper = exports.isLocalStorageAvailable = void 0;
+exports.isLocalStorageAvailable = void 0;
+/* eslint-disable no-undef */
 function isLocalStorageAvailable() {
-    try {
-        // eslint-disable-next-line no-undef
-        return isValidStorageWrapper(localStorage);
-    }
-    catch (e) {
-        return false;
-    }
-}
-exports.isLocalStorageAvailable = isLocalStorageAvailable;
-function isValidStorageWrapper(wrapper) {
     var mod = '__SPLITSOFTWARE__';
     try {
-        wrapper.setItem(mod, mod);
-        wrapper.getItem(mod);
-        wrapper.removeItem(mod);
+        localStorage.setItem(mod, mod);
+        localStorage.removeItem(mod);
         return true;
     }
     catch (e) {
         return false;
     }
 }
-exports.isValidStorageWrapper = isValidStorageWrapper;
-function isWebStorage(wrapper) {
-    if (typeof wrapper.length === 'number') {
-        try {
-            wrapper.key(0);
-            return true;
-        }
-        catch (e) {
-            return false;
-        }
-    }
-    return false;
-}
-exports.isWebStorage = isWebStorage;
+exports.isLocalStorageAvailable = isLocalStorageAvailable;

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/cjs/utils/settingsValidation/storage/storageCS.js

@@ -6,7 +6,7 @@ var constants_1 = require("../../../logger/constants");
 var constants_2 = require("../../../utils/constants");
 function __InLocalStorageMockFactory(params) {
     var result = (0, InMemoryStorageCS_1.InMemoryStorageCSFactory)(params);
-    result.validateCache = function () { return Promise.resolve(true); }; // to emit SDK_READY_FROM_CACHE
+    result.validateCache = function () { return true; }; // to emit SDK_READY_FROM_CACHE
     return result;
 }
 exports.__InLocalStorageMockFactory = __InLocalStorageMockFactory;

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