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

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,16 +27,13 @@ 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;
         var splits = new SplitsCacheInLocal(settings, keys, expirationTimestamp);
         var segments = new MySegmentsCacheInLocal(log, keys);
         var largeSegments = new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey));
-        if (settings.mode === LOCALHOST_MODE || splits.getChangeNumber() > -1) {
-            Promise.resolve().then(onReadyFromCacheCb);
-        }
         return {
             splits: splits,
             segments: segments,

package/esm/storages/inMemory/InMemoryStorageCS.js

@@ -6,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

package/esm/storages/inRedis/RedisAdapter.js

@@ -1,7 +1,6 @@
 import { __extends } from "tslib";
 import ioredis from 'ioredis';
 import { merge, isString } from '../../utils/lang';
-import { _Set, setToArray } from '../../utils/lang/sets';
 import { thenable } from '../../utils/promise/thenable';
 import { timeout } from '../../utils/promise/timeout';
 var LOG_PREFIX = 'storage:redis-adapter: ';
@@ -33,7 +32,7 @@ var RedisAdapter = /** @class */ (function (_super) {
         _this.log = log;
         _this._options = options;
         _this._notReadyCommandsQueue = [];
-        _this._runningCommands = new _Set();
+        _this._runningCommands = new Set();
         _this._listenToEvents();
         _this._setTimeoutWrappers();
         _this._setDisconnectWrapper();
@@ -126,7 +125,7 @@ var RedisAdapter = /** @class */ (function (_super) {
             setTimeout(function deferredDisconnect() {
                 if (instance._runningCommands.size > 0) {
                     instance.log.info(LOG_PREFIX + ("Attempting to disconnect but there are " + instance._runningCommands.size + " commands still waiting for resolution. Defering disconnection until those finish."));
-                    Promise.all(setToArray(instance._runningCommands))
+                    Promise.all(Array.from(instance._runningCommands))
                         .then(function () {
                         instance.log.debug(LOG_PREFIX + 'Pending commands finished successfully, disconnecting.');
                         originalMethod.apply(instance, params);

package/esm/storages/inRedis/SplitsCacheInRedis.js

@@ -2,7 +2,7 @@ import { __extends, __spreadArray } from "tslib";
 import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
 import { LOG_PREFIX } from './constants';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
-import { _Set, returnDifference } from '../../utils/lang/sets';
+import { returnDifference } from '../../utils/lang/sets';
 /**
  * Discard errors for an answer of multiple operations.
  */
@@ -197,7 +197,7 @@ var SplitsCacheInRedis = /** @class */ (function (_super) {
                 return value;
             _this.log.error(LOG_PREFIX + ("Could not read result from get members of flag set " + flagSets[index] + " due to an error: " + e));
         }); })
-            .then(function (namesByFlagSets) { return namesByFlagSets.map(function (namesByFlagSet) { return new _Set(namesByFlagSet); }); });
+            .then(function (namesByFlagSets) { return namesByFlagSets.map(function (namesByFlagSet) { return new Set(namesByFlagSet); }); });
     };
     /**
      * Check traffic type existence.

package/esm/storages/inRedis/TelemetryCacheInRedis.js

@@ -2,7 +2,6 @@ import { findLatencyIndex } from '../findLatencyIndex';
 import { getTelemetryConfigStats } from '../../sync/submitters/telemetrySubmitter';
 import { CONSUMER_MODE, STORAGE_REDIS } from '../../utils/constants';
 import { isNaNNumber, isString } from '../../utils/lang';
-import { _Map } from '../../utils/lang/maps';
 import { MAX_LATENCY_BUCKET_COUNT, newBuckets } from '../inMemory/TelemetryCacheInMemory';
 import { parseLatencyField, parseExceptionField, parseMetadata } from '../utils';
 var TelemetryCacheInRedis = /** @class */ (function () {
@@ -39,7 +38,7 @@ var TelemetryCacheInRedis = /** @class */ (function () {
     TelemetryCacheInRedis.prototype.popLatencies = function () {
         var _this = this;
         return this.redis.hgetall(this.keys.latencyPrefix).then(function (latencies) {
-            var result = new _Map();
+            var result = new Map();
             Object.keys(latencies).forEach(function (field) {
                 var parsedField = parseLatencyField(field);
                 if (isString(parsedField)) {
@@ -71,7 +70,7 @@ var TelemetryCacheInRedis = /** @class */ (function () {
     TelemetryCacheInRedis.prototype.popExceptions = function () {
         var _this = this;
         return this.redis.hgetall(this.keys.exceptionPrefix).then(function (exceptions) {
-            var result = new _Map();
+            var result = new Map();
             Object.keys(exceptions).forEach(function (field) {
                 var parsedField = parseExceptionField(field);
                 if (isString(parsedField)) {
@@ -98,7 +97,7 @@ var TelemetryCacheInRedis = /** @class */ (function () {
     TelemetryCacheInRedis.prototype.popConfigs = function () {
         var _this = this;
         return this.redis.hgetall(this.keys.initPrefix).then(function (configs) {
-            var result = new _Map();
+            var result = new Map();
             Object.keys(configs).forEach(function (field) {
                 var parsedField = parseMetadata(field);
                 if (isString(parsedField)) {

package/esm/storages/inRedis/UniqueKeysCacheInRedis.js

@@ -1,6 +1,5 @@
 import { __extends } from "tslib";
 import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
-import { setToArray } from '../../utils/lang/sets';
 import { DEFAULT_CACHE_SIZE, REFRESH_RATE, TTL_REFRESH } from './constants';
 import { LOG_PREFIX } from './constants';
 var UniqueKeysCacheInRedis = /** @class */ (function (_super) {
@@ -22,7 +21,7 @@ var UniqueKeysCacheInRedis = /** @class */ (function (_super) {
         if (!featureNames.length)
             return Promise.resolve(false);
         var uniqueKeysArray = featureNames.map(function (featureName) {
-            var featureKeys = setToArray(_this.uniqueKeysTracker[featureName]);
+            var featureKeys = Array.from(_this.uniqueKeysTracker[featureName]);
             var uniqueKeysPayload = {
                 f: featureName,
                 ks: featureKeys

package/esm/storages/pluggable/SplitsCachePluggable.js

@@ -2,7 +2,7 @@ import { __extends, __spreadArray } from "tslib";
 import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
 import { LOG_PREFIX } from './constants';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
-import { _Set, returnDifference } from '../../utils/lang/sets';
+import { returnDifference } from '../../utils/lang/sets';
 /**
  * ISplitsCacheAsync implementation for pluggable storages.
  */
@@ -167,7 +167,7 @@ var SplitsCachePluggable = /** @class */ (function (_super) {
         return Promise.all(flagSets.map(function (flagSet) {
             var flagSetKey = _this.keys.buildFlagSetKey(flagSet);
             return _this.wrapper.getItems(flagSetKey).catch(function () { return []; });
-        })).then(function (namesByFlagSets) { return namesByFlagSets.map(function (namesByFlagSet) { return new _Set(namesByFlagSet); }); });
+        })).then(function (namesByFlagSets) { return namesByFlagSets.map(function (namesByFlagSet) { return new Set(namesByFlagSet); }); });
     };
     /**
      * Check traffic type existence.

package/esm/storages/pluggable/TelemetryCachePluggable.js

@@ -2,7 +2,6 @@ import { findLatencyIndex } from '../findLatencyIndex';
 import { getTelemetryConfigStats } from '../../sync/submitters/telemetrySubmitter';
 import { CONSUMER_MODE, STORAGE_PLUGGABLE } from '../../utils/constants';
 import { isString, isNaNNumber } from '../../utils/lang';
-import { _Map } from '../../utils/lang/maps';
 import { MAX_LATENCY_BUCKET_COUNT, newBuckets } from '../inMemory/TelemetryCacheInMemory';
 import { parseLatencyField, parseExceptionField, parseMetadata } from '../utils';
 var TelemetryCachePluggable = /** @class */ (function () {
@@ -38,7 +37,7 @@ var TelemetryCachePluggable = /** @class */ (function () {
         return this.wrapper.getKeysByPrefix(this.keys.latencyPrefix).then(function (latencyKeys) {
             return latencyKeys.length ?
                 _this.wrapper.getMany(latencyKeys).then(function (latencies) {
-                    var result = new _Map();
+                    var result = new Map();
                     for (var i = 0; i < latencyKeys.length; i++) {
                         var field = latencyKeys[i].split('::')[1];
                         var parsedField = parseLatencyField(field);
@@ -65,7 +64,7 @@ var TelemetryCachePluggable = /** @class */ (function () {
                     return Promise.all(latencyKeys.map(function (latencyKey) { return _this.wrapper.del(latencyKey); })).then(function () { return result; });
                 }) :
                 // If latencyKeys is empty, return an empty map.
-                new _Map();
+                new Map();
         });
     };
     /**
@@ -77,7 +76,7 @@ var TelemetryCachePluggable = /** @class */ (function () {
         return this.wrapper.getKeysByPrefix(this.keys.exceptionPrefix).then(function (exceptionKeys) {
             return exceptionKeys.length ?
                 _this.wrapper.getMany(exceptionKeys).then(function (exceptions) {
-                    var result = new _Map();
+                    var result = new Map();
                     for (var i = 0; i < exceptionKeys.length; i++) {
                         var field = exceptionKeys[i].split('::')[1];
                         var parsedField = parseExceptionField(field);
@@ -99,7 +98,7 @@ var TelemetryCachePluggable = /** @class */ (function () {
                     return Promise.all(exceptionKeys.map(function (exceptionKey) { return _this.wrapper.del(exceptionKey); })).then(function () { return result; });
                 }) :
                 // If exceptionKeys is empty, return an empty map.
-                new _Map();
+                new Map();
         });
     };
     /**
@@ -111,7 +110,7 @@ var TelemetryCachePluggable = /** @class */ (function () {
         return this.wrapper.getKeysByPrefix(this.keys.initPrefix).then(function (configKeys) {
             return configKeys.length ?
                 _this.wrapper.getMany(configKeys).then(function (configs) {
-                    var result = new _Map();
+                    var result = new Map();
                     for (var i = 0; i < configKeys.length; i++) {
                         var field = configKeys[i].split('::')[1];
                         var parsedField = parseMetadata(field);
@@ -131,7 +130,7 @@ var TelemetryCachePluggable = /** @class */ (function () {
                     return Promise.all(configKeys.map(function (configKey) { return _this.wrapper.del(configKey); })).then(function () { return result; });
                 }) :
                 // If configKeys is empty, return an empty map.
-                new _Map();
+                new Map();
         });
     };
     return TelemetryCachePluggable;

package/esm/storages/pluggable/UniqueKeysCachePluggable.js

@@ -1,6 +1,5 @@
 import { __extends } from "tslib";
 import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
-import { setToArray } from '../../utils/lang/sets';
 import { DEFAULT_CACHE_SIZE, REFRESH_RATE } from '../inRedis/constants';
 import { LOG_PREFIX } from './constants';
 var UniqueKeysCachePluggable = /** @class */ (function (_super) {
@@ -22,7 +21,7 @@ var UniqueKeysCachePluggable = /** @class */ (function (_super) {
         if (!featureNames.length)
             return Promise.resolve(false);
         var uniqueKeysArray = featureNames.map(function (featureName) {
-            var featureKeys = setToArray(_this.uniqueKeysTracker[featureName]);
+            var featureKeys = Array.from(_this.uniqueKeysTracker[featureName]);
             var uniqueKeysPayload = {
                 f: featureName,
                 ks: featureKeys

package/esm/storages/pluggable/inMemoryWrapper.js

@@ -1,5 +1,4 @@
 import { startsWith, toNumber } from '../../utils/lang';
-import { setToArray, _Set } from '../../utils/lang/sets';
 /**
  * Creates a IPluggableStorageWrapper implementation that stores items in memory.
  * The `_cache` property is the object were items are stored.
@@ -87,15 +86,15 @@ export function inMemoryWrapperFactory(connDelay) {
             var set = _cache[key];
             if (!set)
                 return Promise.resolve(false);
-            if (set instanceof _Set)
+            if (set instanceof Set)
                 return Promise.resolve(set.has(item));
             return Promise.reject('key is not a set');
         },
         addItems: function (key, items) {
             if (!(key in _cache))
-                _cache[key] = new _Set();
+                _cache[key] = new Set();
             var set = _cache[key];
-            if (set instanceof _Set) {
+            if (set instanceof Set) {
                 items.forEach(function (item) { return set.add(item); });
                 return Promise.resolve();
             }
@@ -103,9 +102,9 @@ export function inMemoryWrapperFactory(connDelay) {
         },
         removeItems: function (key, items) {
             if (!(key in _cache))
-                _cache[key] = new _Set();
+                _cache[key] = new Set();
             var set = _cache[key];
-            if (set instanceof _Set) {
+            if (set instanceof Set) {
                 items.forEach(function (item) { return set.delete(item); });
                 return Promise.resolve();
             }
@@ -115,8 +114,8 @@ export function inMemoryWrapperFactory(connDelay) {
             var set = _cache[key];
             if (!set)
                 return Promise.resolve([]);
-            if (set instanceof _Set)
-                return Promise.resolve(setToArray(set));
+            if (set instanceof Set)
+                return Promise.resolve(Array.from(set));
             return Promise.reject('key is not a set');
         },
         // always connects and disconnects

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

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

package/esm/sync/polling/pollingManagerSS.js

@@ -1,6 +1,5 @@
 import { splitsSyncTaskFactory } from './syncTasks/splitsSyncTask';
 import { segmentsSyncTaskFactory } from './syncTasks/segmentsSyncTask';
-import { thenable } from '../../utils/promise/thenable';
 import { POLLING_START, POLLING_STOP, LOG_PREFIX_SYNC_POLLING } from '../../logger/constants';
 /**
  * Expose start / stop mechanism for pulling data from services.
@@ -19,9 +18,10 @@ export function pollingManagerSSFactory(params) {
             log.debug(LOG_PREFIX_SYNC_POLLING + ("Splits will be refreshed each " + settings.scheduler.featuresRefreshRate + " millis"));
             log.debug(LOG_PREFIX_SYNC_POLLING + ("Segments will be refreshed each " + settings.scheduler.segmentsRefreshRate + " millis"));
             var startingUp = splitsSyncTask.start();
-            if (thenable(startingUp)) {
+            if (startingUp) {
                 startingUp.then(function () {
-                    segmentsSyncTask.start();
+                    if (splitsSyncTask.isRunning())
+                        segmentsSyncTask.start();
                 });
             }
         },

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

@@ -1,6 +1,5 @@
-import { _Set, setToArray } from '../../../utils/lang/sets';
 import { timeout } from '../../../utils/promise/timeout';
-import { SDK_SPLITS_ARRIVED } from '../../../readiness/constants';
+import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/constants';
 import { SYNC_SPLITS_FETCH, SYNC_SPLITS_NEW, SYNC_SPLITS_REMOVED, SYNC_SPLITS_SEGMENTS, SYNC_SPLITS_FETCH_FAILS, SYNC_SPLITS_FETCH_RETRY } from '../../../logger/constants';
 import { startsWith } from '../../../utils/lang';
 import { IN_SEGMENT } from '../../../utils/constants';
@@ -20,7 +19,7 @@ function checkAllSegmentsExist(segments) {
  */
 export function parseSegments(_a) {
     var conditions = _a.conditions;
-    var segments = new _Set();
+    var segments = new Set();
     for (var i = 0; i < conditions.length; i++) {
         var matchers = conditions[i].matcherGroup.matchers;
         matchers.forEach(function (matcher) {
@@ -55,7 +54,7 @@ function matchFilters(featureFlag, filters) {
  * Exported for testing purposes.
  */
 export function computeSplitsMutation(entries, filters) {
-    var segments = new _Set();
+    var segments = new Set();
     var computed = entries.reduce(function (accum, split) {
         if (split.status === 'ACTIVE' && matchFilters(split, filters)) {
             accum.added.push([split.name, split]);
@@ -68,7 +67,7 @@ export function computeSplitsMutation(entries, filters) {
         }
         return accum;
     }, { added: [], removed: [], segments: [] });
-    computed.segments = setToArray(segments);
+    computed.segments = Array.from(segments);
     return computed;
 }
 /**
@@ -121,7 +120,7 @@ export function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, seg
         function _splitChangesUpdater(since, retry) {
             if (retry === void 0) { retry = 0; }
             log.debug(SYNC_SPLITS_FETCH, [since]);
-            return Promise.resolve(splitUpdateNotification ?
+            var fetcherPromise = Promise.resolve(splitUpdateNotification ?
                 { splits: [splitUpdateNotification.payload], till: splitUpdateNotification.changeNumber } :
                 splitChangesFetcher(since, noCache, till, _promiseDecorator))
                 .then(function (splitChanges) {
@@ -165,6 +164,15 @@ export function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, seg
                 }
                 return false;
             });
+            // After triggering the requests, if we have cached splits information let's notify that to emit SDK_READY_FROM_CACHE.
+            // Wrapping in a promise since checkCache can be async.
+            if (splitsEventEmitter && startingUp) {
+                Promise.resolve(splits.checkCache()).then(function (isCacheReady) {
+                    if (isCacheReady)
+                        splitsEventEmitter.emit(SDK_SPLITS_CACHE_LOADED);
+                });
+            }
+            return fetcherPromise;
         }
         var sincePromise = Promise.resolve(splits.getChangeNumber()); // `getChangeNumber` never rejects or throws error
         return sincePromise.then(_splitChangesUpdater);

package/esm/sync/streaming/parseUtils.js

@@ -8,7 +8,6 @@ function Uint8ArrayToString(myUint8Arr) {
 }
 function StringToUint8Array(myString) {
     var charCodes = myString.split('').map(function (e) { return e.charCodeAt(0); });
-    // eslint-disable-next-line compat/compat
     return new Uint8Array(charCodes);
 }
 /**

package/esm/sync/streaming/pushManager.js

@@ -12,7 +12,6 @@ import { MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, PUSH_NONRETRYABLE_ERROR,
 import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT, STREAMING_PARSING_MEMBERSHIPS_UPDATE, STREAMING_PARSING_SPLIT_UPDATE } from '../../logger/constants';
 import { UpdateStrategy } from './SSEHandler/types';
 import { getDelay, isInBitmap, parseBitmap, parseFFUpdatePayload, parseKeyList } from './parseUtils';
-import { _Set } from '../../utils/lang/sets';
 import { hash64 } from '../../utils/murmur3/murmur3_64';
 import { TOKEN_REFRESH, AUTH_REJECTION } from '../../utils/constants';
 /**
@@ -218,8 +217,8 @@ export function pushManagerFactory(params, pollingManager) {
                 var keyList = void 0, added_1, removed_1;
                 try {
                     keyList = parseKeyList(parsedData.d, parsedData.c);
-                    added_1 = new _Set(keyList.a);
-                    removed_1 = new _Set(keyList.r);
+                    added_1 = new Set(keyList.a);
+                    removed_1 = new Set(keyList.r);
                 }
                 catch (e) {
                     log.warn(STREAMING_PARSING_MEMBERSHIPS_UPDATE, ['KeyList', e]);

package/esm/utils/LRUCache/index.js

@@ -1,9 +1,8 @@
-import { _Map } from '../lang/maps';
 import { LinkedList, Node } from './LinkedList';
 var LRUCache = /** @class */ (function () {
     function LRUCache(maxSize) {
         this.maxLen = maxSize || 1;
-        this.items = new _Map();
+        this.items = new Map();
         this.lru = new LinkedList();
     }
     LRUCache.prototype.get = function (key) {