@splitsoftware/splitio-commons 1.1.1-rc.0 → 1.2.1-rc.2

package/cjs/sync/offline/syncManagerOffline.js

@@ -19,7 +19,7 @@ function syncManagerOfflineFactory(splitsParserFactory) {
      */
     return function (_a) {
         var settings = _a.settings, readiness = _a.readiness, storage = _a.storage;
-        return objectAssign_1.objectAssign(fromObjectSyncTask_1.fromObjectSyncTaskFactory(splitsParserFactory(), storage, readiness, settings), {
+        return (0, objectAssign_1.objectAssign)((0, fromObjectSyncTask_1.fromObjectSyncTaskFactory)(splitsParserFactory(), storage, readiness, settings), {
             // fake flush, that resolves immediately
             flush: flush,
             // [Only used for client-side]

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

@@ -25,7 +25,7 @@ function fromObjectUpdaterFactory(splitsParser, storage, readiness, settings) {
         }
         if (!loadError && splitsMock) {
             log.debug(constants_3.SYNC_OFFLINE_DATA, [JSON.stringify(splitsMock)]);
-            lang_1.forOwn(splitsMock, function (val, name) {
+            (0, lang_1.forOwn)(splitsMock, function (val, name) {
                 splits.push([
                     name,
                     JSON.stringify({
@@ -68,6 +68,6 @@ exports.fromObjectUpdaterFactory = fromObjectUpdaterFactory;
  * PollingManager in Offline mode
  */
 function fromObjectSyncTaskFactory(splitsParser, storage, readiness, settings) {
-    return syncTask_1.syncTaskFactory(settings.log, fromObjectUpdaterFactory(splitsParser, storage, readiness, settings), settings.scheduler.offlineRefreshRate, 'offlineUpdater');
+    return (0, syncTask_1.syncTaskFactory)(settings.log, fromObjectUpdaterFactory(splitsParser, storage, readiness, settings), settings.scheduler.offlineRefreshRate, 'offlineUpdater');
 }
 exports.fromObjectSyncTaskFactory = fromObjectSyncTaskFactory;

package/cjs/sync/polling/fetchers/mySegmentsFetcher.js

@@ -5,8 +5,8 @@ exports.mySegmentsFetcherFactory = void 0;
  * Factory of MySegments fetcher.
  * MySegments fetcher is a wrapper around `mySegments` API service that parses the response and handle errors.
  */
-function mySegmentsFetcherFactory(fetchMySegments, userMatchingKey) {
-    return function mySegmentsFetcher(noCache, 
+function mySegmentsFetcherFactory(fetchMySegments) {
+    return function mySegmentsFetcher(userMatchingKey, noCache, 
     // Optional decorator for `fetchMySegments` promise, such as timeout or time tracker
     decorator) {
         var mySegmentsPromise = fetchMySegments(userMatchingKey, noCache);

package/cjs/sync/polling/fetchers/segmentChangesFetcher.js

@@ -12,7 +12,7 @@ function greedyFetch(fetchSegmentChanges, since, segmentName, noCache) {
         }
         else {
             return Promise.all([json, greedyFetch(fetchSegmentChanges, till, segmentName, noCache)]).then(function (flatMe) {
-                return tslib_1.__spreadArrays([flatMe[0]], flatMe[1]);
+                return (0, tslib_1.__spreadArray)([flatMe[0]], flatMe[1], true);
             });
         }
     });

package/cjs/sync/polling/pollingManagerCS.js

@@ -11,20 +11,21 @@ var constants_2 = require("../../logger/constants");
  * Expose start / stop mechanism for polling data from services.
  * For client-side API with multiple clients.
  */
-function pollingManagerCSFactory(splitApi, storage, readiness, settings) {
+function pollingManagerCSFactory(params) {
+    var splitApi = params.splitApi, storage = params.storage, readiness = params.readiness, settings = params.settings;
     var log = settings.log;
-    var splitsSyncTask = splitsSyncTask_1.splitsSyncTaskFactory(splitApi.fetchSplitChanges, storage, readiness, settings);
+    var splitsSyncTask = (0, splitsSyncTask_1.splitsSyncTaskFactory)(splitApi.fetchSplitChanges, storage, readiness, settings);
     // Map of matching keys to their corresponding MySegmentsSyncTask.
     var mySegmentsSyncTasks = {};
-    var matchingKey = key_1.getMatching(settings.core.key);
+    var matchingKey = (0, key_1.getMatching)(settings.core.key);
     var mySegmentsSyncTask = add(matchingKey, readiness, storage);
     function startMySegmentsSyncTasks() {
-        lang_1.forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
+        (0, lang_1.forOwn)(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
             mySegmentsSyncTask.start();
         });
     }
     function stopMySegmentsSyncTasks() {
-        lang_1.forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
+        (0, lang_1.forOwn)(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
             if (mySegmentsSyncTask.isRunning())
                 mySegmentsSyncTask.stop();
         });
@@ -45,7 +46,7 @@ function pollingManagerCSFactory(splitApi, storage, readiness, settings) {
         }
     });
     function add(matchingKey, readiness, storage) {
-        var mySegmentsSyncTask = mySegmentsSyncTask_1.mySegmentsSyncTaskFactory(splitApi.fetchMySegments, storage, readiness, settings, matchingKey);
+        var mySegmentsSyncTask = (0, mySegmentsSyncTask_1.mySegmentsSyncTaskFactory)(splitApi.fetchMySegments, storage, readiness, settings, matchingKey);
         // smart ready
         function smartReady() {
             if (!readiness.isReady() && !storage.splits.usesSegments())
@@ -80,7 +81,7 @@ function pollingManagerCSFactory(splitApi, storage, readiness, settings) {
         // fetch splits and segments
         syncAll: function () {
             var promises = [splitsSyncTask.execute()];
-            lang_1.forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
+            (0, lang_1.forOwn)(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
                 promises.push(mySegmentsSyncTask.execute());
             });
             return Promise.all(promises);

package/cjs/sync/polling/pollingManagerSS.js

@@ -8,10 +8,11 @@ var constants_1 = require("../../logger/constants");
 /**
  * Expose start / stop mechanism for pulling data from services.
  */
-function pollingManagerSSFactory(splitApi, storage, readiness, settings) {
+function pollingManagerSSFactory(params) {
+    var splitApi = params.splitApi, storage = params.storage, readiness = params.readiness, settings = params.settings;
     var log = settings.log;
-    var splitsSyncTask = splitsSyncTask_1.splitsSyncTaskFactory(splitApi.fetchSplitChanges, storage, readiness, settings);
-    var segmentsSyncTask = segmentsSyncTask_1.segmentsSyncTaskFactory(splitApi.fetchSegmentChanges, storage, readiness, settings);
+    var splitsSyncTask = (0, splitsSyncTask_1.splitsSyncTaskFactory)(splitApi.fetchSplitChanges, storage, readiness, settings);
+    var segmentsSyncTask = (0, segmentsSyncTask_1.segmentsSyncTaskFactory)(splitApi.fetchSegmentChanges, storage, readiness, settings);
     return {
         splitsSyncTask: splitsSyncTask,
         segmentsSyncTask: segmentsSyncTask,
@@ -21,7 +22,7 @@ function pollingManagerSSFactory(splitApi, storage, readiness, settings) {
             log.debug(constants_1.LOG_PREFIX_SYNC_POLLING + ("Splits will be refreshed each " + settings.scheduler.featuresRefreshRate + " millis"));
             log.debug(constants_1.LOG_PREFIX_SYNC_POLLING + ("Segments will be refreshed each " + settings.scheduler.segmentsRefreshRate + " millis"));
             var startingUp = splitsSyncTask.start();
-            if (thenable_1.thenable(startingUp)) {
+            if ((0, thenable_1.thenable)(startingUp)) {
                 startingUp.then(function () {
                     segmentsSyncTask.start();
                 });

package/cjs/sync/polling/syncTasks/mySegmentsSyncTask.js

@@ -8,6 +8,6 @@ var mySegmentsUpdater_1 = require("../updaters/mySegmentsUpdater");
  * Creates a sync task that periodically executes a `mySegmentsUpdater` task
  */
 function mySegmentsSyncTaskFactory(fetchMySegments, storage, readiness, settings, matchingKey) {
-    return syncTask_1.syncTaskFactory(settings.log, mySegmentsUpdater_1.mySegmentsUpdaterFactory(settings.log, mySegmentsFetcher_1.mySegmentsFetcherFactory(fetchMySegments, matchingKey), storage.splits, storage.segments, readiness.segments, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady), settings.scheduler.segmentsRefreshRate, 'mySegmentsUpdater');
+    return (0, syncTask_1.syncTaskFactory)(settings.log, (0, mySegmentsUpdater_1.mySegmentsUpdaterFactory)(settings.log, (0, mySegmentsFetcher_1.mySegmentsFetcherFactory)(fetchMySegments), storage.splits, storage.segments, readiness.segments, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, matchingKey), settings.scheduler.segmentsRefreshRate, 'mySegmentsUpdater');
 }
 exports.mySegmentsSyncTaskFactory = mySegmentsSyncTaskFactory;

package/cjs/sync/polling/syncTasks/segmentsSyncTask.js

@@ -8,6 +8,6 @@ var segmentChangesUpdater_1 = require("../updaters/segmentChangesUpdater");
  * Creates a sync task that periodically executes a `segmentChangesUpdater` task
  */
 function segmentsSyncTaskFactory(fetchSegmentChanges, storage, readiness, settings) {
-    return syncTask_1.syncTaskFactory(settings.log, segmentChangesUpdater_1.segmentChangesUpdaterFactory(settings.log, segmentChangesFetcher_1.segmentChangesFetcherFactory(fetchSegmentChanges), storage.segments, readiness), settings.scheduler.segmentsRefreshRate, 'segmentChangesUpdater');
+    return (0, syncTask_1.syncTaskFactory)(settings.log, (0, segmentChangesUpdater_1.segmentChangesUpdaterFactory)(settings.log, (0, segmentChangesFetcher_1.segmentChangesFetcherFactory)(fetchSegmentChanges), storage.segments, readiness), settings.scheduler.segmentsRefreshRate, 'segmentChangesUpdater');
 }
 exports.segmentsSyncTaskFactory = segmentsSyncTaskFactory;

package/cjs/sync/polling/syncTasks/splitsSyncTask.js

@@ -8,6 +8,6 @@ var splitChangesUpdater_1 = require("../updaters/splitChangesUpdater");
  * Creates a sync task that periodically executes a `splitChangesUpdater` task
  */
 function splitsSyncTaskFactory(fetchSplitChanges, storage, readiness, settings) {
-    return syncTask_1.syncTaskFactory(settings.log, splitChangesUpdater_1.splitChangesUpdaterFactory(settings.log, splitChangesFetcher_1.splitChangesFetcherFactory(fetchSplitChanges), storage.splits, storage.segments, readiness.splits, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady), settings.scheduler.featuresRefreshRate, 'splitChangesUpdater');
+    return (0, syncTask_1.syncTaskFactory)(settings.log, (0, splitChangesUpdater_1.splitChangesUpdaterFactory)(settings.log, (0, splitChangesFetcher_1.splitChangesFetcherFactory)(fetchSplitChanges), storage.splits, storage.segments, readiness.splits, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady), settings.scheduler.featuresRefreshRate, 'splitChangesUpdater');
 }
 exports.splitsSyncTaskFactory = splitsSyncTaskFactory;

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

@@ -10,13 +10,13 @@ var constants_2 = require("../../../logger/constants");
  *  - updates `mySegmentsCache`
  *  - uses `segmentsEventEmitter` to emit events related to segments data updates
  */
-function mySegmentsUpdaterFactory(log, mySegmentsFetcher, splitsCache, mySegmentsCache, segmentsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady) {
+function mySegmentsUpdaterFactory(log, mySegmentsFetcher, splitsCache, mySegmentsCache, segmentsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, matchingKey) {
     var readyOnAlreadyExistentState = true;
     var startingUp = true;
     /** timeout and telemetry decorator for `splitChangesFetcher` promise  */
     function _promiseDecorator(promise) {
         if (startingUp)
-            promise = timeout_1.timeout(requestTimeoutBeforeReady, promise);
+            promise = (0, timeout_1.timeout)(requestTimeoutBeforeReady, promise);
         return promise;
         // @TODO telemetry
         // NOTE: We only collect metrics on startup.
@@ -54,7 +54,7 @@ function mySegmentsUpdaterFactory(log, mySegmentsFetcher, splitsCache, mySegment
             // If segmentsData is provided, there is no need to fetch mySegments
             new Promise(function (res) { updateSegments(segmentsData); res(true); }) :
             // If not provided, fetch mySegments
-            mySegmentsFetcher(noCache, _promiseDecorator).then(function (segments) {
+            mySegmentsFetcher(matchingKey, noCache, _promiseDecorator).then(function (segments) {
                 // Only when we have downloaded segments completely, we should not keep retrying anymore
                 startingUp = false;
                 updateSegments(segments);

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

@@ -65,7 +65,7 @@ function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segments, read
                             log.debug(constants_2.LOG_PREFIX_SYNC_SEGMENTS + "Processed " + segmentName + " with till = " + x.till + ". Added: " + x.added.length + ". Removed: " + x.removed.length);
                         });
                         // If at least one storage operation result is a promise, join all in a single promise.
-                        if (results.some(function (result) { return thenable_1.thenable(result); }))
+                        if (results.some(function (result) { return (0, thenable_1.thenable)(result); }))
                             return Promise.all(results).then(function () { return changeNumber; });
                         return changeNumber;
                     });
@@ -76,7 +76,7 @@ function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segments, read
             }
             return Promise.all(updaters).then(function (shouldUpdateFlags) {
                 // if at least one segment fetch succeeded, mark segments ready
-                if (lang_1.findIndex(shouldUpdateFlags, function (v) { return v !== -1; }) !== -1 || readyOnAlreadyExistentState) {
+                if ((0, lang_1.findIndex)(shouldUpdateFlags, function (v) { return v !== -1; }) !== -1 || readyOnAlreadyExistentState) {
                     readyOnAlreadyExistentState = false;
                     if (readiness)
                         readiness.segments.emit(constants_1.SDK_SEGMENTS_ARRIVED);

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

@@ -51,7 +51,7 @@ function computeSplitsMutation(entries) {
         }
         return accum;
     }, { added: [], removed: [], segments: [] });
-    computed.segments = sets_1.setToArray(segments);
+    computed.segments = (0, sets_1.setToArray)(segments);
     return computed;
 }
 exports.computeSplitsMutation = computeSplitsMutation;
@@ -76,7 +76,7 @@ function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, segments,
     /** timeout and telemetry decorator for `splitChangesFetcher` promise  */
     function _promiseDecorator(promise) {
         if (startingUp && requestTimeoutBeforeReady)
-            promise = timeout_1.timeout(requestTimeoutBeforeReady, promise);
+            promise = (0, timeout_1.timeout)(requestTimeoutBeforeReady, promise);
         return promise;
         // @TODO telemetry
         // const collectMetrics = startingUp || isNode; // If we are on the browser, only collect this metric for first fetch. On node do it always.

package/cjs/sync/streaming/AuthClient/index.js

@@ -16,16 +16,15 @@ function authenticateFactory(fetchAuth) {
      * @param {string[] | undefined} userKeys set of user Keys to track MY_SEGMENTS_CHANGES. It is undefined for server-side API.
      */
     return function authenticate(userKeys) {
-        var authPromise = fetchAuth(userKeys); // errors handled by fetchAuth service
-        return authPromise
+        return fetchAuth(userKeys)
             .then(function (resp) { return resp.json(); })
             .then(function (json) {
             if (json.token) { // empty token when `"pushEnabled": false`
-                var decodedToken = jwt_1.decodeJWTtoken(json.token);
+                var decodedToken = (0, jwt_1.decodeJWTtoken)(json.token);
                 if (typeof decodedToken.iat !== 'number' || typeof decodedToken.exp !== 'number')
                     throw new Error('token properties "issuedAt" (iat) or "expiration" (exp) are missing or invalid');
                 var channels = JSON.parse(decodedToken['x-ably-capability']);
-                return objectAssign_1.objectAssign({
+                return (0, objectAssign_1.objectAssign)({
                     decodedToken: decodedToken,
                     channels: channels
                 }, json);
@@ -39,6 +38,6 @@ exports.authenticateFactory = authenticateFactory;
  * Returns the hash of a given user key
  */
 function hashUserKey(userKey) {
-    return base64_1.encodeToBase64(murmur3_1.hash(userKey, 0).toString());
+    return (0, base64_1.encodeToBase64)((0, murmur3_1.hash)(userKey, 0).toString());
 }
 exports.hashUserKey = hashUserKey;

package/cjs/sync/streaming/SSEHandler/NotificationParser.js

@@ -13,7 +13,7 @@ var lang_1 = require("../../../utils/lang");
  */
 function errorParser(error) {
     // @ts-ignore
-    if (lang_1.isString(error.data))
+    if ((0, lang_1.isString)(error.data))
         error.parsedData = JSON.parse(error.data); // cannot assign to read only property 'data'
     return error;
 }

package/cjs/sync/streaming/SSEHandler/index.js

@@ -25,7 +25,7 @@ function isRetryableError(error) {
  * @param pushEmitter emitter for events related to streaming support
  */
 function SSEHandlerFactory(log, pushEmitter) {
-    var notificationKeeper = NotificationKeeper_1.notificationKeeperFactory(pushEmitter);
+    var notificationKeeper = (0, NotificationKeeper_1.notificationKeeperFactory)(pushEmitter);
     return {
         handleOpen: function () {
             notificationKeeper.handleOpen();
@@ -34,7 +34,7 @@ function SSEHandlerFactory(log, pushEmitter) {
         handleError: function (error) {
             var errorWithParsedData = error;
             try {
-                errorWithParsedData = NotificationParser_1.errorParser(error);
+                errorWithParsedData = (0, NotificationParser_1.errorParser)(error);
             }
             catch (err) {
                 log.warn(constants_2.STREAMING_PARSING_ERROR_FAILS, [err]);
@@ -52,7 +52,7 @@ function SSEHandlerFactory(log, pushEmitter) {
         handleMessage: function (message) {
             var messageWithParsedData;
             try {
-                messageWithParsedData = NotificationParser_1.messageParser(message);
+                messageWithParsedData = (0, NotificationParser_1.messageParser)(message);
                 if (!messageWithParsedData)
                     return; // Messages with empty data are ignored
             }

package/cjs/sync/streaming/UpdateWorkers/SegmentsUpdateWorker.js

@@ -10,7 +10,7 @@ var SegmentsUpdateWorker = /** @class */ (function () {
      * @param {Object} segmentsCache segments data cache
      * @param {Object} segmentsSyncTask task for syncing segments data
      */
-    function SegmentsUpdateWorker(segmentsCache, segmentsSyncTask) {
+    function SegmentsUpdateWorker(segmentsSyncTask, segmentsCache) {
         this.segmentsCache = segmentsCache;
         this.segmentsSyncTask = segmentsSyncTask;
         this.maxChangeNumbers = {};

package/cjs/sync/streaming/mySegmentsV2utils.js

@@ -21,7 +21,7 @@ function StringToUint8Array(myString) {
  * @throws if data string cannot be decoded, decompressed or the provided compression value is invalid (not 1 or 2)
  */
 function decompress(data, compression) {
-    var compressData = base64_1.decodeFromBase64(data);
+    var compressData = (0, base64_1.decodeFromBase64)(data);
     var binData = StringToUint8Array(compressData);
     if (typeof decompress_1.algorithms === 'string')
         throw new Error(decompress_1.algorithms);

package/cjs/sync/streaming/pushManager.js

@@ -22,10 +22,11 @@ var murmur3_64_1 = require("../../utils/murmur3/murmur3_64");
  * - for server-side if key is not provided in settings.
  * - for client-side, with support for multiple clients, if key is provided in settings
  */
-function pushManagerFactory(pollingManager, storage, readiness, fetchAuth, platform, settings) {
+function pushManagerFactory(params, pollingManager) {
+    var settings = params.settings, storage = params.storage, splitApi = params.splitApi, readiness = params.readiness, platform = params.platform;
     // `userKey` is the matching key of main client in client-side SDK.
     // It can be used to check if running on client-side or server-side SDK.
-    var userKey = settings.core.key ? key_1.getMatching(settings.core.key) : undefined; //
+    var userKey = settings.core.key ? (0, key_1.getMatching)(settings.core.key) : undefined;
     var log = settings.log;
     var sseClient;
     try {
@@ -36,13 +37,14 @@ function pushManagerFactory(pollingManager, storage, readiness, fetchAuth, platf
         log.warn(constants_2.STREAMING_FALLBACK, [e]);
         return;
     }
-    var authenticate = AuthClient_1.authenticateFactory(fetchAuth);
+    var authenticate = (0, AuthClient_1.authenticateFactory)(splitApi.fetchAuth);
     // init feedback loop
     var pushEmitter = new platform.EventEmitter();
-    var sseHandler = SSEHandler_1.SSEHandlerFactory(log, pushEmitter);
+    var sseHandler = (0, SSEHandler_1.SSEHandlerFactory)(log, pushEmitter);
     sseClient.setEventHandler(sseHandler);
     // init workers
-    var segmentsUpdateWorker = userKey ? new MySegmentsUpdateWorker_1.MySegmentsUpdateWorker(pollingManager.segmentsSyncTask) : new SegmentsUpdateWorker_1.SegmentsUpdateWorker(storage.segments, pollingManager.segmentsSyncTask);
+    // MySegmentsUpdateWorker (client-side) are initiated in `add` method
+    var segmentsUpdateWorker = userKey ? undefined : new SegmentsUpdateWorker_1.SegmentsUpdateWorker(pollingManager.segmentsSyncTask, storage.segments);
     // For server-side we pass the segmentsSyncTask, used by SplitsUpdateWorker to fetch new segments
     var splitsUpdateWorker = new SplitsUpdateWorker_1.SplitsUpdateWorker(storage.splits, pollingManager.splitsSyncTask, readiness.splits, userKey ? undefined : pollingManager.segmentsSyncTask);
     // [Only for client-side] map of hashes to user keys, to dispatch MY_SEGMENTS_UPDATE events to the corresponding MySegmentsUpdateWorker
@@ -50,11 +52,6 @@ function pushManagerFactory(pollingManager, storage, readiness, fetchAuth, platf
     // [Only for client-side] map of user keys to their corresponding hash64 and MySegmentsUpdateWorkers.
     // Hash64 is used to process MY_SEGMENTS_UPDATE_V2 events and dispatch actions to the corresponding MySegmentsUpdateWorker.
     var clients = {};
-    if (userKey) {
-        var hash = AuthClient_1.hashUserKey(userKey);
-        userKeyHashes[hash] = userKey;
-        clients[userKey] = { hash64: murmur3_64_1.hash64(userKey), worker: segmentsUpdateWorker };
-    }
     // [Only for client-side] variable to flag that a new client was added. It is needed to reconnect streaming.
     var connectForNewClient = false;
     // flag that indicates if `stop/disconnectPush` was called, either by the SyncManager, when the client is destroyed, or due to a PUSH_NONRETRYABLE_ERROR error.
@@ -141,7 +138,7 @@ function pushManagerFactory(pollingManager, storage, readiness, fetchAuth, platf
     function stopWorkers() {
         splitsUpdateWorker.backoff.reset();
         if (userKey)
-            lang_1.forOwn(clients, function (_a) {
+            (0, lang_1.forOwn)(clients, function (_a) {
                 var worker = _a.worker;
                 return worker.backoff.reset();
             });
@@ -197,15 +194,15 @@ function pushManagerFactory(pollingManager, storage, readiness, fetchAuth, platf
                 case types_1.UpdateStrategy.BoundedFetchRequest: {
                     var bitmap_1;
                     try {
-                        bitmap_1 = mySegmentsV2utils_1.parseBitmap(parsedData.d, parsedData.c);
+                        bitmap_1 = (0, mySegmentsV2utils_1.parseBitmap)(parsedData.d, parsedData.c);
                     }
                     catch (e) {
                         log.warn(constants_2.STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['BoundedFetchRequest', e]);
                         break;
                     }
-                    lang_1.forOwn(clients, function (_a) {
+                    (0, lang_1.forOwn)(clients, function (_a) {
                         var hash64 = _a.hash64, worker = _a.worker;
-                        if (mySegmentsV2utils_1.isInBitmap(bitmap_1, hash64.hex)) {
+                        if ((0, mySegmentsV2utils_1.isInBitmap)(bitmap_1, hash64.hex)) {
                             worker.put(parsedData.changeNumber); // fetch mySegments
                         }
                     });
@@ -214,7 +211,7 @@ function pushManagerFactory(pollingManager, storage, readiness, fetchAuth, platf
                 case types_1.UpdateStrategy.KeyList: {
                     var keyList = void 0, added_1, removed_1;
                     try {
-                        keyList = mySegmentsV2utils_1.parseKeyList(parsedData.d, parsedData.c);
+                        keyList = (0, mySegmentsV2utils_1.parseKeyList)(parsedData.d, parsedData.c);
                         added_1 = new sets_1._Set(keyList.a);
                         removed_1 = new sets_1._Set(keyList.r);
                     }
@@ -222,7 +219,7 @@ function pushManagerFactory(pollingManager, storage, readiness, fetchAuth, platf
                         log.warn(constants_2.STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['KeyList', e]);
                         break;
                     }
-                    lang_1.forOwn(clients, function (_a) {
+                    (0, lang_1.forOwn)(clients, function (_a) {
                         var hash64 = _a.hash64, worker = _a.worker;
                         var add = added_1.has(hash64.dec) ? true : removed_1.has(hash64.dec) ? false : undefined;
                         if (add !== undefined) {
@@ -239,7 +236,7 @@ function pushManagerFactory(pollingManager, storage, readiness, fetchAuth, platf
                         log.warn(constants_2.STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, ['SegmentRemoval', 'No segment name was provided']);
                         break;
                     }
-                    lang_1.forOwn(clients, function (_a) {
+                    (0, lang_1.forOwn)(clients, function (_a) {
                         var worker = _a.worker;
                         return worker.put(parsedData.changeNumber, {
                             name: parsedData.segmentName,
@@ -249,7 +246,7 @@ function pushManagerFactory(pollingManager, storage, readiness, fetchAuth, platf
                     return;
             }
             // `UpdateStrategy.UnboundedFetchRequest` and fallbacks of other cases
-            lang_1.forOwn(clients, function (_a) {
+            (0, lang_1.forOwn)(clients, function (_a) {
                 var worker = _a.worker;
                 worker.put(parsedData.changeNumber);
             });
@@ -258,40 +255,47 @@ function pushManagerFactory(pollingManager, storage, readiness, fetchAuth, platf
     else {
         pushEmitter.on(constants_1.SEGMENT_UPDATE, segmentsUpdateWorker.put);
     }
-    return objectAssign_1.objectAssign(
+    return (0, objectAssign_1.objectAssign)(
     // Expose Event Emitter functionality and Event constants
     Object.create(pushEmitter), {
-        // Expose functionality for starting and stoping push mode:
-        stop: disconnectPush,
+        // Stop/pause push mode
+        stop: function () {
+            disconnectPush(); // `handleNonRetryableError` cannot be used as `stop`, because it emits PUSH_SUBSYSTEM_DOWN event, which starts polling.
+            if (userKey)
+                this.remove(userKey); // Necessary to properly resume streaming in client-side (e.g., RN SDK transition to foreground).
+        },
+        // Start/resume push mode
         start: function () {
             // Guard condition to avoid calling `connectPush` again if the `start` method is called multiple times or if push has been disabled.
             if (disabled || disconnected === false)
                 return;
             disconnected = false;
-            // Run in next event-loop cycle for optimization on client-side: if multiple clients are created in the same cycle than the factory, only one authentication is performed.
-            setTimeout(connectPush);
+            if (userKey)
+                this.add(userKey, pollingManager.segmentsSyncTask); // client-side
+            else
+                setTimeout(connectPush); // server-side runs in next cycle as in client-side, for consistency with client-side
         },
         // [Only for client-side]
         add: function (userKey, mySegmentsSyncTask) {
-            clients[userKey] = { hash64: murmur3_64_1.hash64(userKey), worker: new MySegmentsUpdateWorker_1.MySegmentsUpdateWorker(mySegmentsSyncTask) };
-            var hash = AuthClient_1.hashUserKey(userKey);
+            var hash = (0, AuthClient_1.hashUserKey)(userKey);
             if (!userKeyHashes[hash]) {
                 userKeyHashes[hash] = userKey;
+                clients[userKey] = { hash64: (0, murmur3_64_1.hash64)(userKey), worker: new MySegmentsUpdateWorker_1.MySegmentsUpdateWorker(mySegmentsSyncTask) };
                 connectForNewClient = true; // we must reconnect on start, to listen the channel for the new user key
+                // Reconnects in case of a new client.
+                // Run in next event-loop cycle to save authentication calls
+                // in case multiple clients are created in the current cycle.
+                setTimeout(function checkForReconnect() {
+                    if (connectForNewClient) {
+                        connectForNewClient = false;
+                        connectPush();
+                    }
+                }, 0);
             }
-            // Reconnects in case of a new client.
-            // Run in next event-loop cycle to save authentication calls
-            // in case the user is creating several clients in the current cycle.
-            setTimeout(function checkForReconnect() {
-                if (connectForNewClient) {
-                    connectForNewClient = false;
-                    connectPush();
-                }
-            }, 0);
         },
         // [Only for client-side]
         remove: function (userKey) {
-            var hash = AuthClient_1.hashUserKey(userKey);
+            var hash = (0, AuthClient_1.hashUserKey)(userKey);
             delete userKeyHashes[hash];
             delete clients[userKey];
         }

package/cjs/sync/submitters/eventsSyncTask.js

@@ -8,7 +8,7 @@ var constants_1 = require("../../logger/constants");
  */
 function eventsSyncTaskFactory(log, postEventsBulk, eventsCache, eventsPushRate, eventsFirstPushWindow, latencyTracker) {
     // don't retry events.
-    var syncTask = submitterSyncTask_1.submitterSyncTaskFactory(log, postEventsBulk, eventsCache, eventsPushRate, 'queued events', latencyTracker);
+    var syncTask = (0, submitterSyncTask_1.submitterSyncTaskFactory)(log, postEventsBulk, eventsCache, eventsPushRate, 'queued events', latencyTracker);
     // Set a timer for the first push of events,
     if (eventsFirstPushWindow > 0) {
         var stopEventPublisherTimeout_1;

package/cjs/sync/submitters/impressionCountsSyncTask.js

@@ -30,6 +30,6 @@ var IMPRESSIONS_COUNT_RATE = 1800000; // 30 minutes
  */
 function impressionCountsSyncTaskFactory(log, postTestImpressionsCount, impressionCountsCache, latencyTracker) {
     // retry impressions counts only once.
-    return submitterSyncTask_1.submitterSyncTaskFactory(log, postTestImpressionsCount, impressionCountsCache, IMPRESSIONS_COUNT_RATE, 'impression counts', latencyTracker, fromImpressionCountsCollector, 1);
+    return (0, submitterSyncTask_1.submitterSyncTaskFactory)(log, postTestImpressionsCount, impressionCountsCache, IMPRESSIONS_COUNT_RATE, 'impression counts', latencyTracker, fromImpressionCountsCollector, 1);
 }
 exports.impressionCountsSyncTaskFactory = impressionCountsSyncTaskFactory;

package/cjs/sync/submitters/impressionsSyncTask.js

@@ -7,10 +7,10 @@ var submitterSyncTask_1 = require("./submitterSyncTask");
  * Converts `impressions` data from cache into request payload.
  */
 function fromImpressionsCollector(sendLabels, data) {
-    var groupedByFeature = lang_1.groupBy(data, 'feature');
+    var groupedByFeature = (0, lang_1.groupBy)(data, 'feature');
     var dto = [];
     // using forOwn instead of for...in since the last also iterates over prototype enumerables
-    lang_1.forOwn(groupedByFeature, function (value, name) {
+    (0, lang_1.forOwn)(groupedByFeature, function (value, name) {
         dto.push({
             f: name,
             i: value.map(function (entry) {
@@ -36,6 +36,6 @@ exports.fromImpressionsCollector = fromImpressionsCollector;
 function impressionsSyncTaskFactory(log, postTestImpressionsBulk, impressionsCache, impressionsRefreshRate, sendLabels, latencyTracker) {
     if (sendLabels === void 0) { sendLabels = false; }
     // retry impressions only once.
-    return submitterSyncTask_1.submitterSyncTaskFactory(log, postTestImpressionsBulk, impressionsCache, impressionsRefreshRate, 'impressions', latencyTracker, fromImpressionsCollector.bind(undefined, sendLabels), 1);
+    return (0, submitterSyncTask_1.submitterSyncTaskFactory)(log, postTestImpressionsBulk, impressionsCache, impressionsRefreshRate, 'impressions', latencyTracker, fromImpressionsCollector.bind(undefined, sendLabels), 1);
 }
 exports.impressionsSyncTaskFactory = impressionsSyncTaskFactory;

package/cjs/sync/submitters/metricsSyncTask.js

@@ -7,7 +7,7 @@ var submitterSyncTask_1 = require("./submitterSyncTask");
 function fromCache(propertyName) {
     return function (data) {
         var result = [];
-        lang_1.forOwn(data, function (value, key) {
+        (0, lang_1.forOwn)(data, function (value, key) {
             var _a;
             result.push((_a = { name: key }, _a[propertyName] = value, _a));
         });
@@ -18,7 +18,7 @@ function fromCache(propertyName) {
  * Sync task that periodically posts telemetry counts
  */
 function countsSyncTaskFactory(log, postMetricsCounters, countsCache, metricsRefreshRate, latencyTracker) {
-    return submitterSyncTask_1.submitterSyncTaskFactory(log, postMetricsCounters, countsCache, metricsRefreshRate, 'count metrics', latencyTracker, fromCache('delta'));
+    return (0, submitterSyncTask_1.submitterSyncTaskFactory)(log, postMetricsCounters, countsCache, metricsRefreshRate, 'count metrics', latencyTracker, fromCache('delta'));
 }
 exports.countsSyncTaskFactory = countsSyncTaskFactory;
 /**
@@ -26,6 +26,6 @@ exports.countsSyncTaskFactory = countsSyncTaskFactory;
  */
 function latenciesSyncTaskFactory(log, postMetricsLatencies, latenciesCache, metricsRefreshRate, latencyTracker) {
     // don't retry metrics.
-    return submitterSyncTask_1.submitterSyncTaskFactory(log, postMetricsLatencies, latenciesCache, metricsRefreshRate, 'latency metrics', latencyTracker, fromCache('latencies'), 0, true);
+    return (0, submitterSyncTask_1.submitterSyncTaskFactory)(log, postMetricsLatencies, latenciesCache, metricsRefreshRate, 'latency metrics', latencyTracker, fromCache('latencies'), 0, true);
 }
 exports.latenciesSyncTaskFactory = latenciesSyncTaskFactory;

package/cjs/sync/submitters/submitterManager.js

@@ -5,15 +5,16 @@ var syncTaskComposite_1 = require("../syncTaskComposite");
 var eventsSyncTask_1 = require("./eventsSyncTask");
 var impressionsSyncTask_1 = require("./impressionsSyncTask");
 var impressionCountsSyncTask_1 = require("./impressionCountsSyncTask");
-function submitterManagerFactory(settings, storage, splitApi) {
+function submitterManagerFactory(params) {
+    var settings = params.settings, storage = params.storage, splitApi = params.splitApi;
     var log = settings.log;
     var submitters = [
-        impressionsSyncTask_1.impressionsSyncTaskFactory(log, splitApi.postTestImpressionsBulk, storage.impressions, settings.scheduler.impressionsRefreshRate, settings.core.labelsEnabled),
-        eventsSyncTask_1.eventsSyncTaskFactory(log, splitApi.postEventsBulk, storage.events, settings.scheduler.eventsPushRate, settings.startup.eventsFirstPushWindow)
+        (0, impressionsSyncTask_1.impressionsSyncTaskFactory)(log, splitApi.postTestImpressionsBulk, storage.impressions, settings.scheduler.impressionsRefreshRate, settings.core.labelsEnabled),
+        (0, eventsSyncTask_1.eventsSyncTaskFactory)(log, splitApi.postEventsBulk, storage.events, settings.scheduler.eventsPushRate, settings.startup.eventsFirstPushWindow)
         // @TODO add telemetry submitter
     ];
     if (storage.impressionCounts)
-        submitters.push(impressionCountsSyncTask_1.impressionCountsSyncTaskFactory(log, splitApi.postTestImpressionsCount, storage.impressionCounts));
-    return syncTaskComposite_1.syncTaskComposite(submitters);
+        submitters.push((0, impressionCountsSyncTask_1.impressionCountsSyncTaskFactory)(log, splitApi.postTestImpressionsCount, storage.impressionCounts));
+    return (0, syncTaskComposite_1.syncTaskComposite)(submitters);
 }
 exports.submitterManagerFactory = submitterManagerFactory;

package/cjs/sync/submitters/submitterSyncTask.js

@@ -39,6 +39,6 @@ function submitterSyncTaskFactory(log, postClient, sourceCache, postRate, dataNa
         // if latencyTracker provided, attach stop callback to postEventsPromise
         return latencyTrackerStop ? postPromise.then(latencyTrackerStop).catch(latencyTrackerStop) : postPromise;
     }
-    return syncTask_1.syncTaskFactory(log, postData, postRate, dataName + ' submitter');
+    return (0, syncTask_1.syncTaskFactory)(log, postData, postRate, dataName + ' submitter');
 }
 exports.submitterSyncTaskFactory = submitterSyncTaskFactory;

package/cjs/sync/syncManagerOnline.js

@@ -16,26 +16,25 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
     /**
      * SyncManager factory for modular SDK
      */
-    return function (_a) {
-        var settings = _a.settings, platform = _a.platform, splitApi = _a.splitApi, storage = _a.storage, readiness = _a.readiness;
-        var log = settings.log;
+    return function (params) {
+        var _a = params.settings, log = _a.log, streamingEnabled = _a.streamingEnabled;
         /** Polling Manager */
-        var pollingManager = pollingManagerFactory && pollingManagerFactory(splitApi, storage, readiness, settings);
+        var pollingManager = pollingManagerFactory && pollingManagerFactory(params);
         /** Push Manager */
-        var pushManager = settings.streamingEnabled && pollingManager && pushManagerFactory ?
-            pushManagerFactory(pollingManager, storage, readiness, splitApi.fetchAuth, platform, settings) :
+        var pushManager = streamingEnabled && pollingManager && pushManagerFactory ?
+            pushManagerFactory(params, pollingManager) :
             undefined;
         /** Submitter Manager */
         // It is not inyected as push and polling managers, because at the moment it is required
-        var submitter = submitterManager_1.submitterManagerFactory(settings, storage, splitApi);
+        var submitter = (0, submitterManager_1.submitterManagerFactory)(params);
         /** Sync Manager logic */
         function startPolling() {
-            if (!pollingManager.isRunning()) {
-                log.info(constants_2.SYNC_START_POLLING);
-                pollingManager.start();
+            if (pollingManager.isRunning()) {
+                log.info(constants_2.SYNC_CONTINUE_POLLING);
             }
             else {
-                log.info(constants_2.SYNC_CONTINUE_POLLING);
+                log.info(constants_2.SYNC_START_POLLING);
+                pollingManager.start();
             }
         }
         function stopPollingAndSyncAll() {
@@ -73,7 +72,8 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
                     }
                 }
                 // start periodic data recording (events, impressions, telemetry).
-                submitter && submitter.start();
+                if (submitter)
+                    submitter.start();
                 running = true;
             },
             /**