@splitsoftware/splitio-commons 1.17.1-rc.3 → 2.0.0-rc.0

package/esm/sdkClient/clientCS.js

@@ -1,16 +1,15 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 import { clientAttributesDecoration } from './clientAttributesDecoration';
 /**
- * Decorator that binds a key and (optionally) a traffic type to client methods
+ * Decorator that binds a key to client methods
  *
  * @param client sync client instance
  * @param key validated split key
- * @param trafficType validated traffic type
  */
-export function clientCSDecorator(log, client, key, trafficType) {
+export function clientCSDecorator(log, client, key) {
     var clientCS = clientAttributesDecoration(log, client);
     return objectAssign(clientCS, {
-        // In the client-side API, we bind a key to the client `getTreatment*` methods
+        // In the client-side API, we bind a key to the client `getTreatment*` and `track` methods
         getTreatment: clientCS.getTreatment.bind(clientCS, key),
         getTreatmentWithConfig: clientCS.getTreatmentWithConfig.bind(clientCS, key),
         getTreatments: clientCS.getTreatments.bind(clientCS, key),
@@ -19,11 +18,9 @@ export function clientCSDecorator(log, client, key, trafficType) {
         getTreatmentsWithConfigByFlagSets: clientCS.getTreatmentsWithConfigByFlagSets.bind(clientCS, key),
         getTreatmentsByFlagSet: clientCS.getTreatmentsByFlagSet.bind(clientCS, key),
         getTreatmentsWithConfigByFlagSet: clientCS.getTreatmentsWithConfigByFlagSet.bind(clientCS, key),
-        // Key is bound to the `track` method. Same thing happens with trafficType but only if provided
-        track: trafficType ? clientCS.track.bind(clientCS, key, trafficType) : clientCS.track.bind(clientCS, key),
+        track: clientCS.track.bind(clientCS, key),
         // Not part of the public API. These properties are used to support other modules (e.g., Split Suite)
         isClientSide: true,
-        key: key,
-        trafficType: trafficType
+        key: key
     });
 }

package/esm/sdkClient/sdkClientMethodCS.js

@@ -11,7 +11,7 @@ import { buildInstanceId } from './identity';
  * 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, whenInit = params.whenInit;
+    var clients = params.clients, storage = params.storage, syncManager = params.syncManager, sdkReadinessManager = params.sdkReadinessManager, _a = params.settings, key = _a.core.key, log = _a.log;
     var mainClientInstance = clientCSDecorator(log, sdkClientFactory(params), key);
     var parsedDefaultKey = keyParser(key);
     var defaultInstanceId = buildInstanceId(parsedDefaultKey);
@@ -22,7 +22,7 @@ export function sdkClientMethodCSFactory(params) {
             log.debug(RETRIEVE_CLIENT_DEFAULT);
             return mainClientInstance;
         }
-        // Validate the key value. The trafficType (2nd argument) is ignored
+        // Validate the key value
         var validKey = validateKey(log, key, LOG_PREFIX_CLIENT_INSTANTIATION);
         if (validKey === false) {
             throw new Error('Shared Client needs a valid key.');
@@ -44,18 +44,15 @@ export function sdkClientMethodCSFactory(params) {
             // - Consumer mode: both syncManager and sharedSyncManager are undefined
             // - Consumer partial mode: syncManager is defined (only for submitters) but sharedSyncManager is undefined
             // @ts-ignore
-            var sharedSyncManager_1 = syncManager && sharedStorage && syncManager.shared(matchingKey, sharedSdkReadiness_1.readinessManager, sharedStorage);
+            var sharedSyncManager = syncManager && sharedStorage && syncManager.shared(matchingKey, sharedSdkReadiness_1.readinessManager, sharedStorage);
             // As shared clients reuse all the storage information, we don't need to check here if we
             // will use offline or online mode. We should stick with the original decision.
             clients[instanceId] = clientCSDecorator(log, sdkClientFactory(objectAssign({}, params, {
                 sdkReadinessManager: sharedSdkReadiness_1,
                 storage: sharedStorage || storage,
-                syncManager: sharedSyncManager_1,
+                syncManager: sharedSyncManager,
             }), true), validKey);
-            whenInit(function () {
-                sharedSdkReadiness_1.readinessManager.init();
-                sharedSyncManager_1 && sharedSyncManager_1.start();
-            });
+            sharedSyncManager && sharedSyncManager.start();
             log.info(NEW_SHARED_CLIENT);
         }
         else {

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, SDK_SPLITS_CACHE_LOADED } from '../readiness/constants';
+import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { strategyDebugFactory } from '../trackers/strategy/strategyDebug';
 import { strategyOptimizedFactory } from '../trackers/strategy/strategyOptimized';
@@ -16,19 +16,12 @@ import { NONE, OPTIMIZED } from '../utils/constants';
  * 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, isPure = params.isPure;
+    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;
     var log = settings.log, impressionsMode = settings.sync.impressionsMode;
     // @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
-    var isInit = false;
-    var initCallbacks = [];
-    function whenInit(cb) {
-        if (isInit)
-            cb();
-        else
-            initCallbacks.push(cb);
-    }
+    // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
+    validateAndTrackApiKey(log, settings.core.authorizationKey);
     var sdkReadinessManager = sdkReadinessManagerFactory(platform.EventEmitter, settings);
     var readiness = sdkReadinessManager.readinessManager;
     var storage = storageFactory({
@@ -42,10 +35,8 @@ 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 });
@@ -62,11 +53,11 @@ export function sdkFactory(params) {
         default:
             strategy = strategyDebugFactory(observer);
     }
-    var impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, strategy, whenInit, integrationsManager, storage.telemetry);
-    var eventTracker = eventTrackerFactory(settings, storage.events, whenInit, integrationsManager, storage.telemetry);
+    var impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, strategy, integrationsManager, storage.telemetry);
+    var eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager, storage.telemetry);
     // splitApi is used by SyncManager and Browser signal listener
     var splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);
-    var ctx = { clients: clients, splitApi: splitApi, eventTracker: eventTracker, impressionsTracker: impressionsTracker, telemetryTracker: telemetryTracker, uniqueKeysTracker: uniqueKeysTracker, sdkReadinessManager: sdkReadinessManager, readiness: readiness, settings: settings, storage: storage, platform: platform, whenInit: whenInit };
+    var ctx = { clients: clients, splitApi: splitApi, eventTracker: eventTracker, impressionsTracker: impressionsTracker, telemetryTracker: telemetryTracker, uniqueKeysTracker: uniqueKeysTracker, sdkReadinessManager: sdkReadinessManager, readiness: readiness, settings: settings, storage: storage, platform: platform };
     var syncManager = syncManagerFactory && syncManagerFactory(ctx);
     ctx.syncManager = syncManager;
     var signalListener = SignalListener && new SignalListener(syncManager, settings, storage, splitApi);
@@ -74,22 +65,8 @@ export function sdkFactory(params) {
     // SDK client and manager
     var clientMethod = sdkClientMethodFactory(ctx);
     var managerInstance = sdkManagerFactory(settings, storage.splits, sdkReadinessManager);
-    function init() {
-        if (isInit)
-            return;
-        isInit = true;
-        // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
-        validateAndTrackApiKey(log, settings.core.authorizationKey);
-        readiness.init();
-        storage.init && storage.init();
-        uniqueKeysTracker && uniqueKeysTracker.start();
-        syncManager && syncManager.start();
-        signalListener && signalListener.start();
-        initCallbacks.forEach(function (cb) { return cb(); });
-        initCallbacks.length = 0;
-    }
-    if (!isPure)
-        init();
+    syncManager && syncManager.start();
+    signalListener && signalListener.start();
     log.info(NEW_FACTORY);
     // @ts-ignore
     return objectAssign({
@@ -106,5 +83,5 @@ export function sdkFactory(params) {
         destroy: function () {
             return Promise.all(Object.keys(clients).map(function (key) { return clients[key].destroy(); })).then(function () { });
         }
-    }, extraProps && extraProps(ctx), isPure && { init: init });
+    }, extraProps && extraProps(ctx));
 }

package/esm/services/decorateHeaders.js

@@ -1,6 +1,5 @@
 import { objectAssign } from '../utils/lang/objectAssign';
-import { _Set } from '../utils/lang/sets';
-var FORBIDDEN_HEADERS = new _Set([
+var FORBIDDEN_HEADERS = new Set([
     'splitsdkclientkey',
     'splitsdkversion',
     'splitsdkmachineip',

package/esm/storages/AbstractSplitsCacheAsync.js

@@ -11,6 +11,13 @@ 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,6 +27,13 @@ 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/KeyBuilderCS.js

@@ -20,12 +20,6 @@ var KeyBuilderCS = /** @class */ (function (_super) {
         if (startsWith(builtSegmentKeyName, prefix))
             return builtSegmentKeyName.substr(prefix.length);
     };
-    // @BREAKING: The key used to start with the matching key instead of the prefix, this was changed on version 10.17.3
-    KeyBuilderCS.prototype.extractOldSegmentKey = function (builtSegmentKeyName) {
-        var prefix = this.matchingKey + "." + this.prefix + ".segment.";
-        if (startsWith(builtSegmentKeyName, prefix))
-            return builtSegmentKeyName.substr(prefix.length);
-    };
     KeyBuilderCS.prototype.buildLastUpdatedKey = function () {
         return this.prefix + ".splits.lastUpdated";
     };
@@ -48,9 +42,6 @@ export function myLargeSegmentsKeyBuilder(prefix, matchingKey) {
             if (startsWith(builtSegmentKeyName, p))
                 return builtSegmentKeyName.substr(p.length);
         },
-        extractOldSegmentKey: function () {
-            return undefined;
-        },
         buildTillKey: function () {
             return prefix + "." + matchingKey + ".largeSegments.till";
         }

package/esm/storages/dataLoader.js

@@ -1,78 +1,47 @@
-import { setToArray } from '../utils/lang/sets';
-import { getMatching } from '../utils/key';
+import { DEFAULT_CACHE_EXPIRATION_IN_MILLIS } from '../utils/constants/browser';
 /**
- * Storage-agnostic adaptation of `loadDataIntoLocalStorage` function
- * (https://github.com/godaddy/split-javascript-data-loader/blob/master/src/load-data.js)
+ * Factory of client-side storage loader
  *
- * @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
+ * @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
  */
-export function loadData(preloadedData, storage, matchingKey) {
-    // 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) {
+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;
         var storedSince = storage.splits.getChangeNumber();
-        // Do not load data if current data is more recent
-        if (storedSince > since)
+        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)
             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(splitsData.map(function (split) { return ([split.name, split]); }));
-    }
-    if (matchingKey) { // add mySegments data (client-side)
-        var mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[matchingKey];
+        storage.splits.addSplits(Object.keys(splitsData).map(function (splitName) { return JSON.parse(splitsData[splitName]); }));
+        // add mySegments data
+        var mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[userId];
         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 matchingKeys = segmentsData[segmentName];
-                return matchingKeys.indexOf(matchingKey) > -1;
+                var userIds = JSON.parse(segmentsData[segmentName]).added;
+                return Array.isArray(userIds) && userIds.indexOf(userId) > -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 matchingKeys = segmentsData[segmentName];
-            storage.segments.addToSegment(segmentName, matchingKeys);
-        });
-    }
-}
-export function getSnapshot(storage, userKeys) {
-    return {
-        // lastUpdated: Date.now(),
-        since: storage.splits.getChangeNumber(),
-        splitsData: storage.splits.getAll(),
-        segmentsData: userKeys ?
-            undefined : // @ts-ignore accessing private prop
-            Object.keys(storage.segments.segmentCache).reduce(function (prev, cur) {
-                prev[cur] = setToArray(storage.segments.segmentCache[cur]);
-                return prev;
-            }, {}),
-        mySegmentsData: userKeys ?
-            userKeys.reduce(function (prev, userKey) {
-                prev[getMatching(userKey)] = storage.shared ?
-                    // Client-side segments
-                    // @ts-ignore accessing private prop
-                    Object.keys(storage.shared(userKey).segments.segmentCache) :
-                    // Server-side segments
-                    // @ts-ignore accessing private prop
-                    Object.keys(storage.segments.segmentCache).reduce(function (prev, segmentName) {
-                        return storage.segments.segmentCache[segmentName].has(userKey) ?
-                            prev.concat(segmentName) :
-                            prev;
-                    }, []);
-                return prev;
-            }, {}) :
-            undefined
     };
 }

package/esm/storages/inLocalStorage/MySegmentsCacheInLocal.js

@@ -45,28 +45,8 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
         // Scan current values from localStorage
         return Object.keys(localStorage).reduce(function (accum, key) {
             var segmentName = _this.keys.extractSegmentName(key);
-            if (segmentName) {
+            if (segmentName)
                 accum.push(segmentName);
-            }
-            else {
-                // @TODO @BREAKING: This is only to clean up "old" keys. Remove this whole else code block
-                segmentName = _this.keys.extractOldSegmentKey(key);
-                if (segmentName) { // this was an old segment key, let's clean up.
-                    var newSegmentKey = _this.keys.buildSegmentNameKey(segmentName);
-                    try {
-                        // If the new format key is not there, create it.
-                        if (!localStorage.getItem(newSegmentKey)) {
-                            localStorage.setItem(newSegmentKey, DEFINED);
-                            // we are migrating a segment, let's track it.
-                            accum.push(segmentName);
-                        }
-                        localStorage.removeItem(key); // we migrated the current key, let's delete it.
-                    }
-                    catch (e) {
-                        _this.log.error(e);
-                    }
-                }
-            }
             return accum;
         }, []);
     };

package/esm/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -2,7 +2,6 @@ import { __extends } from "tslib";
 import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';
 import { isFiniteNumber, toNumber, isNaNNumber } from '../../utils/lang';
 import { LOG_PREFIX } from './constants';
-import { _Set, setToArray } from '../../utils/lang/sets';
 import { getStorageHash } from '../KeyBuilder';
 /**
  * ISplitsCacheSync implementation that stores split definitions in browser LocalStorage.
@@ -183,6 +182,14 @@ 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`,
      *
@@ -205,7 +212,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.getChangeNumber() > -1)
+                if (this.checkCache())
                     this.clear();
             }
             catch (e) {
@@ -219,7 +226,7 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         return flagSets.map(function (flagSet) {
             var flagSetKey = _this.keys.buildFlagSetKey(flagSet);
             var flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
-            return new _Set(flagSetFromLocalStorage ? JSON.parse(flagSetFromLocalStorage) : []);
+            return new Set(flagSetFromLocalStorage ? JSON.parse(flagSetFromLocalStorage) : []);
         });
     };
     SplitsCacheInLocal.prototype.addToFlagSets = function (featureFlag) {
@@ -231,9 +238,9 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
                 return;
             var flagSetKey = _this.keys.buildFlagSetKey(featureFlagSet);
             var flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
-            var flagSetCache = new _Set(flagSetFromLocalStorage ? JSON.parse(flagSetFromLocalStorage) : []);
+            var flagSetCache = new Set(flagSetFromLocalStorage ? JSON.parse(flagSetFromLocalStorage) : []);
             flagSetCache.add(featureFlag.name);
-            localStorage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
+            localStorage.setItem(flagSetKey, JSON.stringify(Array.from(flagSetCache)));
         });
     };
     SplitsCacheInLocal.prototype.removeFromFlagSets = function (featureFlagName, flagSets) {
@@ -249,13 +256,13 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
         var flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
         if (!flagSetFromLocalStorage)
             return;
-        var flagSetCache = new _Set(JSON.parse(flagSetFromLocalStorage));
+        var flagSetCache = new Set(JSON.parse(flagSetFromLocalStorage));
         flagSetCache.delete(featureFlagName);
         if (flagSetCache.size === 0) {
             localStorage.removeItem(flagSetKey);
             return;
         }
-        localStorage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
+        localStorage.setItem(flagSetKey, JSON.stringify(Array.from(flagSetCache)));
     };
     return SplitsCacheInLocal;
 }(AbstractSplitsCacheSync));

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, LOCALHOST_MODE, NONE, STORAGE_LOCALSTORAGE } from '../../utils/constants';
+import { DEBUG, NONE, STORAGE_LOCALSTORAGE } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from '../inMemory/TelemetryCacheInMemory';
 import { UniqueKeysCacheInMemoryCS } from '../inMemory/UniqueKeysCacheInMemoryCS';
 import { getMatching } from '../../utils/key';
@@ -27,7 +27,7 @@ export function InLocalStorage(options) {
             params.settings.log.warn(LOG_PREFIX + 'LocalStorage API is unavailable. Falling back to default MEMORY storage');
             return InMemoryStorageCSFactory(params);
         }
-        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 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;
@@ -43,11 +43,6 @@ export function InLocalStorage(options) {
             events: new EventsCacheInMemory(eventsQueueSize),
             telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
             uniqueKeys: impressionsMode === NONE ? new UniqueKeysCacheInMemoryCS() : undefined,
-            init: function () {
-                if (settings.mode === LOCALHOST_MODE || splits.getChangeNumber() > -1) {
-                    Promise.resolve().then(onReadyFromCacheCb);
-                }
-            },
             destroy: function () {
                 var _a;
                 this.splits = new SplitsCacheInMemory(__splitFiltersValidation);

package/esm/storages/inMemory/InMemoryStorageCS.js

@@ -6,15 +6,13 @@ 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, preloadedData = _a.preloadedData, onReadyFromCacheCb = params.onReadyFromCacheCb;
+    var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, _c = _a.sync, impressionsMode = _c.impressionsMode, __splitFiltersValidation = _c.__splitFiltersValidation;
     var splits = new SplitsCacheInMemory(__splitFiltersValidation);
     var segments = new MySegmentsCacheInMemory();
     var largeSegments = new MySegmentsCacheInMemory();
@@ -38,16 +36,11 @@ 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 (matchingKey) {
-            var segments = new MySegmentsCacheInMemory();
-            var largeSegments = new MySegmentsCacheInMemory();
-            if (preloadedData) {
-                loadData(preloadedData, { segments: segments, largeSegments: largeSegments }, matchingKey);
-            }
+        shared: function () {
             return {
                 splits: this.splits,
-                segments: segments,
-                largeSegments: largeSegments,
+                segments: new MySegmentsCacheInMemory(),
+                largeSegments: new MySegmentsCacheInMemory(),
                 impressions: this.impressions,
                 impressionCounts: this.impressionCounts,
                 events: this.events,
@@ -72,11 +65,6 @@ 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/storages/inMemory/SegmentsCacheInMemory.js

@@ -1,6 +1,5 @@
 import { __extends } from "tslib";
 import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
-import { _Set } from '../../utils/lang/sets';
 import { isIntegerNumber } from '../../utils/lang';
 /**
  * Default ISplitsCacheSync implementation that stores split definitions in memory.
@@ -16,14 +15,14 @@ var SegmentsCacheInMemory = /** @class */ (function (_super) {
     }
     SegmentsCacheInMemory.prototype.addToSegment = function (name, segmentKeys) {
         var values = this.segmentCache[name];
-        var keySet = values ? values : new _Set();
+        var keySet = values ? values : new Set();
         segmentKeys.forEach(function (k) { return keySet.add(k); });
         this.segmentCache[name] = keySet;
         return true;
     };
     SegmentsCacheInMemory.prototype.removeFromSegment = function (name, segmentKeys) {
         var values = this.segmentCache[name];
-        var keySet = values ? values : new _Set();
+        var keySet = values ? values : new Set();
         segmentKeys.forEach(function (k) { return keySet.delete(k); });
         this.segmentCache[name] = keySet;
         return true;
@@ -41,7 +40,7 @@ var SegmentsCacheInMemory = /** @class */ (function (_super) {
     };
     SegmentsCacheInMemory.prototype._registerSegment = function (name) {
         if (!this.segmentCache[name]) {
-            this.segmentCache[name] = new _Set();
+            this.segmentCache[name] = new Set();
         }
         return true;
     };

package/esm/storages/inMemory/SplitsCacheInMemory.js

@@ -1,7 +1,6 @@
 import { __extends } from "tslib";
 import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';
 import { isFiniteNumber } from '../../utils/lang';
-import { _Set } from '../../utils/lang/sets';
 /**
  * Default ISplitsCacheSync implementation that stores split definitions in memory.
  * Supported by all JS runtimes.
@@ -92,7 +91,7 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
     };
     SplitsCacheInMemory.prototype.getNamesByFlagSets = function (flagSets) {
         var _this = this;
-        return flagSets.map(function (flagSet) { return _this.flagSetsCache[flagSet] || new _Set(); });
+        return flagSets.map(function (flagSet) { return _this.flagSetsCache[flagSet] || new Set(); });
     };
     SplitsCacheInMemory.prototype.addToFlagSets = function (featureFlag) {
         var _this = this;
@@ -102,7 +101,7 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
             if (_this.flagSetsFilter.length > 0 && !_this.flagSetsFilter.some(function (filterFlagSet) { return filterFlagSet === featureFlagSet; }))
                 return;
             if (!_this.flagSetsCache[featureFlagSet])
-                _this.flagSetsCache[featureFlagSet] = new _Set([]);
+                _this.flagSetsCache[featureFlagSet] = new Set([]);
             _this.flagSetsCache[featureFlagSet].add(featureFlag.name);
         });
     };

package/esm/storages/inMemory/UniqueKeysCacheInMemory.js

@@ -1,4 +1,3 @@
-import { setToArray, _Set } from '../../utils/lang/sets';
 import { DEFAULT_CACHE_SIZE } from '../inRedis/constants';
 /**
  * Converts `uniqueKeys` data from cache into request payload for SS.
@@ -8,7 +7,7 @@ export function fromUniqueKeysCollector(uniqueKeys) {
     var featureNames = Object.keys(uniqueKeys);
     for (var i = 0; i < featureNames.length; i++) {
         var featureName = featureNames[i];
-        var userKeys = setToArray(uniqueKeys[featureName]);
+        var userKeys = Array.from(uniqueKeys[featureName]);
         var uniqueKeysPayload = {
             f: featureName,
             ks: userKeys
@@ -32,7 +31,7 @@ var UniqueKeysCacheInMemory = /** @class */ (function () {
      */
     UniqueKeysCacheInMemory.prototype.track = function (userKey, featureName) {
         if (!this.uniqueKeysTracker[featureName])
-            this.uniqueKeysTracker[featureName] = new _Set();
+            this.uniqueKeysTracker[featureName] = new Set();
         var tracker = this.uniqueKeysTracker[featureName];
         if (!tracker.has(userKey)) {
             tracker.add(userKey);

package/esm/storages/inMemory/UniqueKeysCacheInMemoryCS.js

@@ -1,4 +1,3 @@
-import { setToArray, _Set } from '../../utils/lang/sets';
 import { DEFAULT_CACHE_SIZE } from '../inRedis/constants';
 var UniqueKeysCacheInMemoryCS = /** @class */ (function () {
     /**
@@ -20,7 +19,7 @@ var UniqueKeysCacheInMemoryCS = /** @class */ (function () {
      */
     UniqueKeysCacheInMemoryCS.prototype.track = function (userKey, featureName) {
         if (!this.uniqueKeysTracker[userKey])
-            this.uniqueKeysTracker[userKey] = new _Set();
+            this.uniqueKeysTracker[userKey] = new Set();
         var tracker = this.uniqueKeysTracker[userKey];
         if (!tracker.has(featureName)) {
             tracker.add(featureName);
@@ -59,7 +58,7 @@ var UniqueKeysCacheInMemoryCS = /** @class */ (function () {
         var userKeys = Object.keys(uniqueKeys);
         for (var k = 0; k < userKeys.length; k++) {
             var userKey = userKeys[k];
-            var featureNames = setToArray(uniqueKeys[userKey]);
+            var featureNames = Array.from(uniqueKeys[userKey]);
             var uniqueKeysPayload = {
                 k: userKey,
                 fs: featureNames