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

package/cjs/storages/inMemory/SplitsCacheInMemory.js

@@ -6,7 +6,6 @@ var AbstractSplitsCacheSync_1 = require("../AbstractSplitsCacheSync");
 var lang_1 = require("../../utils/lang");
 /**
  * Default ISplitsCacheSync implementation that stores split definitions in memory.
- * Supported by all JS runtimes.
  */
 var SplitsCacheInMemory = /** @class */ (function (_super) {
     (0, tslib_1.__extends)(SplitsCacheInMemory, _super);

package/cjs/storages/inMemory/UniqueKeysCacheInMemory.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UniqueKeysCacheInMemory = exports.fromUniqueKeysCollector = void 0;
 var constants_1 = require("../inRedis/constants");
+var sets_1 = require("../../utils/lang/sets");
 /**
  * Converts `uniqueKeys` data from cache into request payload for SS.
  */
@@ -10,7 +11,7 @@ function fromUniqueKeysCollector(uniqueKeys) {
     var featureNames = Object.keys(uniqueKeys);
     for (var i = 0; i < featureNames.length; i++) {
         var featureName = featureNames[i];
-        var userKeys = Array.from(uniqueKeys[featureName]);
+        var userKeys = (0, sets_1.setToArray)(uniqueKeys[featureName]);
         var uniqueKeysPayload = {
             f: featureName,
             ks: userKeys

package/cjs/storages/inMemory/UniqueKeysCacheInMemoryCS.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UniqueKeysCacheInMemoryCS = void 0;
 var constants_1 = require("../inRedis/constants");
+var sets_1 = require("../../utils/lang/sets");
 var UniqueKeysCacheInMemoryCS = /** @class */ (function () {
     /**
      *
@@ -61,7 +62,7 @@ var UniqueKeysCacheInMemoryCS = /** @class */ (function () {
         var userKeys = Object.keys(uniqueKeys);
         for (var k = 0; k < userKeys.length; k++) {
             var userKey = userKeys[k];
-            var featureNames = Array.from(uniqueKeys[userKey]);
+            var featureNames = (0, sets_1.setToArray)(uniqueKeys[userKey]);
             var uniqueKeysPayload = {
                 k: userKey,
                 fs: featureNames

package/cjs/storages/inRedis/RedisAdapter.js

@@ -6,6 +6,7 @@ var ioredis_1 = (0, tslib_1.__importDefault)(require("ioredis"));
 var lang_1 = require("../../utils/lang");
 var thenable_1 = require("../../utils/promise/thenable");
 var timeout_1 = require("../../utils/promise/timeout");
+var sets_1 = require("../../utils/lang/sets");
 var LOG_PREFIX = 'storage:redis-adapter: ';
 // If we ever decide to fully wrap every method, there's a Commander.getBuiltinCommands from ioredis.
 var METHODS_TO_PROMISE_WRAP = ['set', 'exec', 'del', 'get', 'keys', 'sadd', 'srem', 'sismember', 'smembers', 'incr', 'rpush', 'expire', 'mget', 'lrange', 'ltrim', 'hset', 'hincrby', 'popNRaw'];
@@ -128,7 +129,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(Array.from(instance._runningCommands))
+                    Promise.all((0, sets_1.setToArray)(instance._runningCommands))
                         .then(function () {
                         instance.log.debug(LOG_PREFIX + 'Pending commands finished successfully, disconnecting.');
                         originalMethod.apply(instance, params);

package/cjs/storages/inRedis/SegmentsCacheInRedis.js

@@ -9,30 +9,24 @@ var SegmentsCacheInRedis = /** @class */ (function () {
         this.redis = redis;
         this.keys = keys;
     }
-    SegmentsCacheInRedis.prototype.addToSegment = function (name, segmentKeys) {
+    /**
+     * Update the given segment `name` with the lists of `addedKeys`, `removedKeys` and `changeNumber`.
+     * The returned promise is resolved if the operation success, with `true` if the segment was updated (i.e., some key was added or removed),
+     * or rejected if it fails (e.g., Redis operation fails).
+     */
+    SegmentsCacheInRedis.prototype.update = function (name, addedKeys, removedKeys, changeNumber) {
         var segmentKey = this.keys.buildSegmentNameKey(name);
-        if (segmentKeys.length) {
-            return this.redis.sadd(segmentKey, segmentKeys).then(function () { return true; });
-        }
-        else {
-            return Promise.resolve(true);
-        }
-    };
-    SegmentsCacheInRedis.prototype.removeFromSegment = function (name, segmentKeys) {
-        var segmentKey = this.keys.buildSegmentNameKey(name);
-        if (segmentKeys.length) {
-            return this.redis.srem(segmentKey, segmentKeys).then(function () { return true; });
-        }
-        else {
-            return Promise.resolve(true);
-        }
+        return Promise.all([
+            addedKeys.length && this.redis.sadd(segmentKey, addedKeys),
+            removedKeys.length && this.redis.srem(segmentKey, removedKeys),
+            this.redis.set(this.keys.buildSegmentTillKey(name), changeNumber + '')
+        ]).then(function () {
+            return addedKeys.length > 0 || removedKeys.length > 0;
+        });
     };
     SegmentsCacheInRedis.prototype.isInSegment = function (name, key) {
         return this.redis.sismember(this.keys.buildSegmentNameKey(name), key).then(function (matches) { return matches !== 0; });
     };
-    SegmentsCacheInRedis.prototype.setChangeNumber = function (name, changeNumber) {
-        return this.redis.set(this.keys.buildSegmentTillKey(name), changeNumber + '').then(function (status) { return status === 'OK'; });
-    };
     SegmentsCacheInRedis.prototype.getChangeNumber = function (name) {
         var _this = this;
         return this.redis.get(this.keys.buildSegmentTillKey(name)).then(function (value) {

package/cjs/storages/inRedis/UniqueKeysCacheInRedis.js

@@ -5,6 +5,7 @@ var tslib_1 = require("tslib");
 var UniqueKeysCacheInMemory_1 = require("../inMemory/UniqueKeysCacheInMemory");
 var constants_1 = require("./constants");
 var constants_2 = require("./constants");
+var sets_1 = require("../../utils/lang/sets");
 var UniqueKeysCacheInRedis = /** @class */ (function (_super) {
     (0, tslib_1.__extends)(UniqueKeysCacheInRedis, _super);
     function UniqueKeysCacheInRedis(log, key, redis, uniqueKeysQueueSize, refreshRate) {
@@ -24,7 +25,7 @@ var UniqueKeysCacheInRedis = /** @class */ (function (_super) {
         if (!featureNames.length)
             return Promise.resolve(false);
         var uniqueKeysArray = featureNames.map(function (featureName) {
-            var featureKeys = Array.from(_this.uniqueKeysTracker[featureName]);
+            var featureKeys = (0, sets_1.setToArray)(_this.uniqueKeysTracker[featureName]);
             var uniqueKeysPayload = {
                 f: featureName,
                 ks: featureKeys

package/cjs/storages/pluggable/SegmentsCachePluggable.js

@@ -15,32 +15,19 @@ var SegmentsCachePluggable = /** @class */ (function () {
         this.wrapper = wrapper;
     }
     /**
-     * Add a list of `segmentKeys` to the given segment `name`.
-     * The returned promise is resolved when the operation success
-     * or rejected if wrapper operation fails.
-     */
-    SegmentsCachePluggable.prototype.addToSegment = function (name, segmentKeys) {
-        var segmentKey = this.keys.buildSegmentNameKey(name);
-        if (segmentKeys.length) {
-            return this.wrapper.addItems(segmentKey, segmentKeys);
-        }
-        else {
-            return Promise.resolve();
-        }
-    };
-    /**
-     * Remove a list of `segmentKeys` from the given segment `name`.
-     * The returned promise is resolved when the operation success
-     * or rejected if wrapper operation fails.
+     * Update the given segment `name` with the lists of `addedKeys`, `removedKeys` and `changeNumber`.
+     * The returned promise is resolved if the operation success, with `true` if the segment was updated (i.e., some key was added or removed),
+     * or rejected if it fails (e.g., wrapper operation fails).
      */
-    SegmentsCachePluggable.prototype.removeFromSegment = function (name, segmentKeys) {
+    SegmentsCachePluggable.prototype.update = function (name, addedKeys, removedKeys, changeNumber) {
         var segmentKey = this.keys.buildSegmentNameKey(name);
-        if (segmentKeys.length) {
-            return this.wrapper.removeItems(segmentKey, segmentKeys);
-        }
-        else {
-            return Promise.resolve();
-        }
+        return Promise.all([
+            addedKeys.length && this.wrapper.addItems(segmentKey, addedKeys),
+            removedKeys.length && this.wrapper.removeItems(segmentKey, removedKeys),
+            this.wrapper.set(this.keys.buildSegmentTillKey(name), changeNumber + '')
+        ]).then(function () {
+            return addedKeys.length > 0 || removedKeys.length > 0;
+        });
     };
     /**
      * Returns a promise that resolves with a boolean value indicating if `key` is part of `name` segment.
@@ -49,14 +36,6 @@ var SegmentsCachePluggable = /** @class */ (function () {
     SegmentsCachePluggable.prototype.isInSegment = function (name, key) {
         return this.wrapper.itemContains(this.keys.buildSegmentNameKey(name), key);
     };
-    /**
-     * Set till number for the given segment `name`.
-     * The returned promise is resolved when the operation success,
-     * or rejected if it fails (e.g., wrapper operation fails).
-     */
-    SegmentsCachePluggable.prototype.setChangeNumber = function (name, changeNumber) {
-        return this.wrapper.set(this.keys.buildSegmentTillKey(name), changeNumber + '');
-    };
     /**
      * Get till number or -1 if it's not defined.
      * The returned promise is resolved with the changeNumber or -1 if it doesn't exist or a wrapper operation fails.

package/cjs/storages/pluggable/UniqueKeysCachePluggable.js

@@ -5,6 +5,7 @@ var tslib_1 = require("tslib");
 var UniqueKeysCacheInMemory_1 = require("../inMemory/UniqueKeysCacheInMemory");
 var constants_1 = require("../inRedis/constants");
 var constants_2 = require("./constants");
+var sets_1 = require("../../utils/lang/sets");
 var UniqueKeysCachePluggable = /** @class */ (function (_super) {
     (0, tslib_1.__extends)(UniqueKeysCachePluggable, _super);
     function UniqueKeysCachePluggable(log, key, wrapper, uniqueKeysQueueSize, refreshRate) {
@@ -24,7 +25,7 @@ var UniqueKeysCachePluggable = /** @class */ (function (_super) {
         if (!featureNames.length)
             return Promise.resolve(false);
         var uniqueKeysArray = featureNames.map(function (featureName) {
-            var featureKeys = Array.from(_this.uniqueKeysTracker[featureName]);
+            var featureKeys = (0, sets_1.setToArray)(_this.uniqueKeysTracker[featureName]);
             var uniqueKeysPayload = {
                 f: featureName,
                 ks: featureKeys

package/cjs/storages/pluggable/inMemoryWrapper.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.inMemoryWrapperFactory = void 0;
 var lang_1 = require("../../utils/lang");
+var sets_1 = require("../../utils/lang/sets");
 /**
  * Creates a IPluggableStorageWrapper implementation that stores items in memory.
  * The `_cache` property is the object were items are stored.
@@ -118,7 +119,7 @@ function inMemoryWrapperFactory(connDelay) {
             if (!set)
                 return Promise.resolve([]);
             if (set instanceof Set)
-                return Promise.resolve(Array.from(set));
+                return Promise.resolve((0, sets_1.setToArray)(set));
             return Promise.reject('key is not a set');
         },
         // always connects and disconnects

package/cjs/sync/offline/syncManagerOffline.js

@@ -19,23 +19,30 @@ function syncManagerOfflineFactory(splitsParserFactory) {
      */
     return function (_a) {
         var settings = _a.settings, readiness = _a.readiness, storage = _a.storage;
-        return (0, objectAssign_1.objectAssign)((0, fromObjectSyncTask_1.fromObjectSyncTaskFactory)(splitsParserFactory(), storage, readiness, settings), {
+        var mainSyncManager = (0, fromObjectSyncTask_1.fromObjectSyncTaskFactory)(splitsParserFactory(), storage, readiness, settings);
+        var mainStart = mainSyncManager.start;
+        var sharedStarts = [];
+        return (0, objectAssign_1.objectAssign)(mainSyncManager, {
+            start: function () {
+                mainStart();
+                sharedStarts.forEach(function (cb) { return cb(); });
+                sharedStarts.length = 0;
+            },
             // fake flush, that resolves immediately
             flush: flush,
             // [Only used for client-side]
             shared: function (matchingKey, readinessManager) {
+                // In LOCALHOST mode, shared clients are ready in the next event-loop cycle than created
+                // SDK_READY cannot be emitted directly because this will not update the readiness status
+                function emitSdkReady() {
+                    readinessManager.segments.emit(constants_1.SDK_SEGMENTS_ARRIVED); // SDK_SPLITS_ARRIVED emitted by main SyncManager
+                }
+                if (mainSyncManager.isRunning())
+                    setTimeout(emitSdkReady);
+                else
+                    sharedStarts.push(emitSdkReady);
                 return {
-                    start: function () {
-                        // In LOCALHOST mode, shared clients are ready in the next event-loop cycle than created
-                        // SDK_READY cannot be emitted directly because this will not update the readiness status
-                        setTimeout(function () {
-                            readinessManager.segments.emit(constants_1.SDK_SEGMENTS_ARRIVED); // SDK_SPLITS_ARRIVED emitted by main SyncManager
-                        }, 0);
-                    },
                     stop: function () { },
-                    isRunning: function () {
-                        return true;
-                    },
                     flush: flush,
                 };
             }

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

@@ -1,10 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.segmentChangesUpdaterFactory = void 0;
-var lang_1 = require("../../../utils/lang");
 var constants_1 = require("../../../readiness/constants");
 var constants_2 = require("../../../logger/constants");
-var thenable_1 = require("../../../utils/promise/thenable");
 /**
  * Factory of SegmentChanges updater, a task that:
  *  - fetches segment changes using `segmentChangesFetcher`
@@ -23,27 +21,16 @@ function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segments, read
         var sincePromise = Promise.resolve(segments.getChangeNumber(segmentName));
         return sincePromise.then(function (since) {
             // if fetchOnlyNew flag, avoid processing already fetched segments
-            if (fetchOnlyNew && since !== -1)
-                return -1;
-            return segmentChangesFetcher(since, segmentName, noCache, till).then(function (changes) {
-                var changeNumber = -1;
-                var results = [];
-                changes.forEach(function (x) {
-                    if (x.added.length > 0)
-                        results.push(segments.addToSegment(segmentName, x.added));
-                    if (x.removed.length > 0)
-                        results.push(segments.removeFromSegment(segmentName, x.removed));
-                    if (x.added.length > 0 || x.removed.length > 0) {
-                        results.push(segments.setChangeNumber(segmentName, x.till));
-                        changeNumber = x.till;
-                    }
-                    log.debug(constants_2.LOG_PREFIX_SYNC_SEGMENTS + "Processed " + segmentName + " with till = " + x.till + ". Added: " + x.added.length + ". Removed: " + x.removed.length);
+            return fetchOnlyNew && since !== -1 ?
+                false :
+                segmentChangesFetcher(since, segmentName, noCache, till).then(function (changes) {
+                    return Promise.all(changes.map(function (x) {
+                        log.debug(constants_2.LOG_PREFIX_SYNC_SEGMENTS + "Processing " + segmentName + " with till = " + x.till + ". Added: " + x.added.length + ". Removed: " + x.removed.length);
+                        return segments.update(segmentName, x.added, x.removed, x.till);
+                    })).then(function (updates) {
+                        return updates.some(function (update) { return update; });
+                    });
                 });
-                // If at least one storage operation result is a promise, join all in a single promise.
-                if (results.some(function (result) { return (0, thenable_1.thenable)(result); }))
-                    return Promise.all(results).then(function () { return changeNumber; });
-                return changeNumber;
-            });
         });
     }
     /**
@@ -62,14 +49,11 @@ function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segments, read
         // If not a segment name provided, read list of available segments names to be updated.
         var segmentsPromise = Promise.resolve(segmentName ? [segmentName] : segments.getRegisteredSegments());
         return segmentsPromise.then(function (segmentNames) {
-            // Async fetchers are collected here.
-            var updaters = [];
-            for (var index = 0; index < segmentNames.length; index++) {
-                updaters.push(updateSegment(segmentNames[index], noCache, till, fetchOnlyNew));
-            }
+            // Async fetchers
+            var updaters = segmentNames.map(function (segmentName) { return updateSegment(segmentName, noCache, till, fetchOnlyNew); });
             return Promise.all(updaters).then(function (shouldUpdateFlags) {
                 // if at least one segment fetch succeeded, mark segments ready
-                if ((0, lang_1.findIndex)(shouldUpdateFlags, function (v) { return v !== -1; }) !== -1 || readyOnAlreadyExistentState) {
+                if (shouldUpdateFlags.some(function (update) { return update; }) || readyOnAlreadyExistentState) {
                     readyOnAlreadyExistentState = false;
                     if (readiness)
                         readiness.segments.emit(constants_1.SDK_SEGMENTS_ARRIVED);

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

@@ -6,6 +6,7 @@ var constants_1 = require("../../../readiness/constants");
 var constants_2 = require("../../../logger/constants");
 var lang_1 = require("../../../utils/lang");
 var constants_3 = require("../../../utils/constants");
+var sets_1 = require("../../../utils/lang/sets");
 // Checks that all registered segments have been fetched (changeNumber !== -1 for every segment).
 // Returns a promise that could be rejected.
 // @TODO review together with Segments and MySegments storage APIs
@@ -71,7 +72,7 @@ function computeSplitsMutation(entries, filters) {
         }
         return accum;
     }, { added: [], removed: [], segments: [] });
-    computed.segments = Array.from(segments);
+    computed.segments = (0, sets_1.setToArray)(segments);
     return computed;
 }
 exports.computeSplitsMutation = computeSplitsMutation;

package/cjs/sync/syncManagerOnline.js

@@ -118,33 +118,32 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
                 if (!pollingManager)
                     return;
                 var mySegmentsSyncTask = pollingManager.add(matchingKey, readinessManager, storage);
-                return {
-                    isRunning: mySegmentsSyncTask.isRunning,
-                    start: function () {
-                        if (syncEnabled) {
-                            if (pushManager) {
-                                if (pollingManager.isRunning()) {
-                                    // if doing polling, we must start the periodic fetch of data
-                                    if (storage.splits.usesSegments())
-                                        mySegmentsSyncTask.start();
-                                }
-                                else {
-                                    // if not polling, we must execute the sync task for the initial fetch
-                                    // of segments since `syncAll` was already executed when starting the main client
-                                    mySegmentsSyncTask.execute();
-                                }
-                                pushManager.add(matchingKey, mySegmentsSyncTask);
-                            }
-                            else {
+                if (running) {
+                    if (syncEnabled) {
+                        if (pushManager) {
+                            if (pollingManager.isRunning()) {
+                                // if doing polling, we must start the periodic fetch of data
                                 if (storage.splits.usesSegments())
                                     mySegmentsSyncTask.start();
                             }
+                            else {
+                                // if not polling, we must execute the sync task for the initial fetch
+                                // of segments since `syncAll` was already executed when starting the main client
+                                mySegmentsSyncTask.execute();
+                            }
+                            pushManager.add(matchingKey, mySegmentsSyncTask);
                         }
                         else {
-                            if (!readinessManager.isReady())
-                                mySegmentsSyncTask.execute();
+                            if (storage.splits.usesSegments())
+                                mySegmentsSyncTask.start();
                         }
-                    },
+                    }
+                    else {
+                        if (!readinessManager.isReady())
+                            mySegmentsSyncTask.execute();
+                    }
+                }
+                return {
                     stop: function () {
                         // check in case `client.destroy()` has been invoked more than once for the same client
                         var mySegmentsSyncTask = pollingManager.get(matchingKey);

package/cjs/trackers/eventTracker.js

@@ -12,7 +12,7 @@ var mode_1 = require("../utils/settingsValidation/mode");
  * @param eventsCache cache to save events
  * @param integrationsManager optional event handler used for integrations
  */
-function eventTrackerFactory(settings, eventsCache, integrationsManager, telemetryCache) {
+function eventTrackerFactory(settings, eventsCache, whenInit, integrationsManager, telemetryCache) {
     var log = settings.log, mode = settings.mode;
     var isAsync = (0, mode_1.isConsumerMode)(mode);
     function queueEventsCallback(eventData, tracked) {
@@ -22,15 +22,17 @@ function eventTrackerFactory(settings, eventsCache, integrationsManager, telemet
         if (tracked) {
             log.info(constants_1.EVENTS_TRACKER_SUCCESS, [msg]);
             if (integrationsManager) {
-                // Wrap in a timeout because we don't want it to be blocking.
-                setTimeout(function () {
-                    // copy of event, to avoid unexpected behaviour if modified by integrations
-                    var eventDataCopy = (0, objectAssign_1.objectAssign)({}, eventData);
-                    if (properties)
-                        eventDataCopy.properties = (0, objectAssign_1.objectAssign)({}, properties);
-                    // integrationsManager does not throw errors (they are internally handled by each integration module)
-                    integrationsManager.handleEvent(eventDataCopy);
-                }, 0);
+                whenInit(function () {
+                    // Wrap in a timeout because we don't want it to be blocking.
+                    setTimeout(function () {
+                        // copy of event, to avoid unexpected behaviour if modified by integrations
+                        var eventDataCopy = (0, objectAssign_1.objectAssign)({}, eventData);
+                        if (properties)
+                            eventDataCopy.properties = (0, objectAssign_1.objectAssign)({}, properties);
+                        // integrationsManager does not throw errors (they are internally handled by each integration module)
+                        integrationsManager.handleEvent(eventDataCopy);
+                    });
+                });
             }
         }
         else {

package/cjs/trackers/impressionsTracker.js

@@ -14,7 +14,7 @@ var constants_2 = require("../utils/constants");
  * @param integrationsManager optional integrations manager
  * @param strategy strategy for impressions tracking.
  */
-function impressionsTrackerFactory(settings, impressionsCache, strategy, integrationsManager, telemetryCache) {
+function impressionsTrackerFactory(settings, impressionsCache, strategy, whenInit, integrationsManager, telemetryCache) {
     var log = settings.log, impressionListener = settings.impressionListener, _a = settings.runtime, ip = _a.ip, hostname = _a.hostname, version = settings.version;
     return {
         track: function (impressions, attributes) {
@@ -53,19 +53,21 @@ function impressionsTrackerFactory(settings, impressionsCache, strategy, integra
                         hostname: hostname,
                         sdkLanguageVersion: version
                     };
-                    // Wrap in a timeout because we don't want it to be blocking.
-                    setTimeout(function () {
-                        // integrationsManager.handleImpression does not throw errors
-                        if (integrationsManager)
-                            integrationsManager.handleImpression(impressionData);
-                        try { // @ts-ignore. An exception on the listeners should not break the SDK.
-                            if (impressionListener)
-                                impressionListener.logImpression(impressionData);
-                        }
-                        catch (err) {
-                            log.error(constants_1.ERROR_IMPRESSIONS_LISTENER, [err]);
-                        }
-                    }, 0);
+                    whenInit(function () {
+                        // Wrap in a timeout because we don't want it to be blocking.
+                        setTimeout(function () {
+                            // integrationsManager.handleImpression does not throw errors
+                            if (integrationsManager)
+                                integrationsManager.handleImpression(impressionData);
+                            try { // @ts-ignore. An exception on the listeners should not break the SDK.
+                                if (impressionListener)
+                                    impressionListener.logImpression(impressionData);
+                            }
+                            catch (err) {
+                                log.error(constants_1.ERROR_IMPRESSIONS_LISTENER, [err]);
+                            }
+                        });
+                    });
                 };
                 for (var i = 0; i < impressionsToListenerCount; i++) {
                     _loop_1(i);

package/cjs/trackers/uniqueKeysTracker.js

@@ -19,9 +19,6 @@ var noopFilterAdapter = {
 function uniqueKeysTrackerFactory(log, uniqueKeysCache, filterAdapter) {
     if (filterAdapter === void 0) { filterAdapter = noopFilterAdapter; }
     var intervalId;
-    if (filterAdapter.refreshRate) {
-        intervalId = setInterval(filterAdapter.clear, filterAdapter.refreshRate);
-    }
     return {
         track: function (key, featureName) {
             if (!filterAdapter.add(key, featureName)) {
@@ -30,6 +27,11 @@ function uniqueKeysTrackerFactory(log, uniqueKeysCache, filterAdapter) {
             }
             uniqueKeysCache.track(key, featureName);
         },
+        start: function () {
+            if (filterAdapter.refreshRate) {
+                intervalId = setInterval(filterAdapter.clear, filterAdapter.refreshRate);
+            }
+        },
         stop: function () {
             clearInterval(intervalId);
         }

package/cjs/utils/lang/sets.js

@@ -1,8 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.returnDifference = exports.returnSetsUnion = void 0;
+exports.returnDifference = exports.returnSetsUnion = exports.setToArray = void 0;
+function setToArray(set) {
+    if (Array.from)
+        return Array.from(set);
+    var array = [];
+    set.forEach(function (value) {
+        array.push(value);
+    });
+    return array;
+}
+exports.setToArray = setToArray;
 function returnSetsUnion(set, set2) {
-    return new Set(Array.from(set).concat(Array.from(set2)));
+    return new Set(setToArray(set).concat(setToArray(set2)));
 }
 exports.returnSetsUnion = returnSetsUnion;
 function returnDifference(list, list2) {

package/esm/evaluator/Engine.js

@@ -14,7 +14,7 @@ var Engine = /** @class */ (function () {
     function Engine(baseInfo, evaluator) {
         this.baseInfo = baseInfo;
         this.evaluator = evaluator;
-        // in case we don't have a default treatment in the instanciation, use 'control'
+        // in case we don't have a default treatment in the instantiation, use 'control'
         if (typeof this.baseInfo.defaultTreatment !== 'string') {
             this.baseInfo.defaultTreatment = CONTROL;
         }

package/esm/evaluator/index.js

@@ -2,7 +2,7 @@ import { Engine } from './Engine';
 import { thenable } from '../utils/promise/thenable';
 import { EXCEPTION, SPLIT_NOT_FOUND } from '../utils/labels';
 import { CONTROL } from '../utils/constants';
-import { returnSetsUnion } from '../utils/lang/sets';
+import { returnSetsUnion, setToArray } from '../utils/lang/sets';
 import { WARN_FLAGSET_WITHOUT_FLAGS } from '../logger/constants';
 var treatmentException = {
     treatment: CONTROL,
@@ -65,7 +65,7 @@ export function evaluateFeaturesByFlagSets(log, key, flagSets, attributes, stora
             }
         }
         return featureFlags.size ?
-            evaluateFeatures(log, key, Array.from(featureFlags), attributes, storage) :
+            evaluateFeatures(log, key, setToArray(featureFlags), attributes, storage) :
             {};
     }
     // get features by flag sets

package/esm/readiness/readinessManager.js

@@ -4,6 +4,8 @@ function splitsEventEmitterFactory(EventEmitter) {
     var splitsEventEmitter = objectAssign(new EventEmitter(), {
         splitsArrived: false,
         splitsCacheLoaded: false,
+        initialized: false,
+        initCallbacks: []
     });
     // `isSplitKill` condition avoids an edge-case of wrongly emitting SDK_READY if:
     // - `/memberships` fetch and SPLIT_KILL occurs before `/splitChanges` fetch, and
@@ -43,7 +45,7 @@ export function readinessManagerFactory(EventEmitter, settings, splits) {
     // emit SDK_READY_TIMED_OUT
     var hasTimedout = false;
     function timeout() {
-        if (hasTimedout)
+        if (hasTimedout || isReady)
             return;
         hasTimedout = true;
         syncLastUpdate();
@@ -51,7 +53,10 @@ export function readinessManagerFactory(EventEmitter, settings, splits) {
     }
     var readyTimeoutId;
     if (readyTimeout > 0) {
-        readyTimeoutId = setTimeout(timeout, readyTimeout);
+        if (splits.initialized)
+            readyTimeoutId = setTimeout(timeout, readyTimeout);
+        else
+            splits.initCallbacks.push(function () { readyTimeoutId = setTimeout(timeout, readyTimeout); });
     }
     // emit SDK_READY and SDK_UPDATE
     var isReady = false;
@@ -113,6 +118,12 @@ export function readinessManagerFactory(EventEmitter, settings, splits) {
         // Called on 403 error (client-side SDK key on server-side), to set the SDK as destroyed for
         // tracking and evaluations, while keeping event listeners to emit SDK_READY_TIMED_OUT event
         setDestroyed: function () { isDestroyed = true; },
+        init: function () {
+            if (splits.initialized)
+                return;
+            splits.initialized = true;
+            splits.initCallbacks.forEach(function (cb) { return cb(); });
+        },
         destroy: function () {
             isDestroyed = true;
             syncLastUpdate();

package/esm/sdkClient/sdkClientMethodCS.js

@@ -52,7 +52,6 @@ export function sdkClientMethodCSFactory(params) {
                 storage: sharedStorage || storage,
                 syncManager: sharedSyncManager,
             }), true), validKey);
-            sharedSyncManager && sharedSyncManager.start();
             log.info(NEW_SHARED_CLIENT);
         }
         else {