@splitsoftware/splitio-commons 1.2.0 → 1.2.1-rc.10

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/SSEClient/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SSEClient = void 0;
+var lang_1 = require("../../../utils/lang");
 var VERSION = '1.1';
 var CONTROL_CHANNEL_REGEX = /^control_/;
 /**
@@ -11,7 +12,7 @@ var CONTROL_CHANNEL_REGEX = /^control_/;
  */
 function buildSSEHeaders(settings) {
     var headers = {
-        SplitSDKClientKey: settings.core.authorizationKey.slice(-4),
+        SplitSDKClientKey: (0, lang_1.isString)(settings.core.authorizationKey) ? settings.core.authorizationKey.slice(-4) : '',
         SplitSDKVersion: settings.version,
     };
     // ip and hostname are false if IPAddressesEnabled is false

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,17 +52,13 @@ 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.
     // It is used to halt the `connectPush` process if it was in progress.
     var disconnected;
     // flag that indicates a PUSH_NONRETRYABLE_ERROR, condition with which starting pushManager again is ignored.
+    // true if STREAMING_DISABLED control event, or 'pushEnabled: false', or non-recoverable SSE or Auth errors.
     var disabled; // `disabled` implies `disconnected === true`
     /** PushManager functions related to initialization */
     var connectPushRetryBackoff = new Backoff_1.Backoff(connectPush, settings.scheduler.pushRetryBackoffBase);
@@ -141,7 +139,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 +195,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 +212,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 +220,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 +237,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 +247,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 +256,53 @@ 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.
+        // It doesn't emit events. Neither PUSH_SUBSYSTEM_DOWN to start polling.
+        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.
+        // It eventually emits PUSH_SUBSYSTEM_DOWN, that starts polling, or PUSH_SUBSYSTEM_UP, that executes a syncAll
         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
+        },
+        // true/false if start or stop was called last respectively
+        isRunning: function () {
+            return disconnected === false;
         },
         // [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

@@ -3,29 +3,41 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.eventsSyncTaskFactory = void 0;
 var submitterSyncTask_1 = require("./submitterSyncTask");
 var constants_1 = require("../../logger/constants");
+var DATA_NAME = 'events';
 /**
  * Sync task that periodically posts tracked events
  */
 function eventsSyncTaskFactory(log, postEventsBulk, eventsCache, eventsPushRate, eventsFirstPushWindow, latencyTracker) {
     // don't retry events.
-    var syncTask = submitterSyncTask_1.submitterSyncTaskFactory(log, postEventsBulk, eventsCache, eventsPushRate, 'queued events', latencyTracker);
-    // Set a timer for the first push of events,
+    var syncTask = (0, submitterSyncTask_1.submitterSyncTaskFactory)(log, postEventsBulk, eventsCache, eventsPushRate, DATA_NAME, latencyTracker);
+    // Set a timer for the first push window of events.
+    // Not implemented in the base submitter or sync task, since this feature is only used by the events submitter.
     if (eventsFirstPushWindow > 0) {
+        var running_1 = false;
         var stopEventPublisherTimeout_1;
         var originalStart_1 = syncTask.start;
         syncTask.start = function () {
+            running_1 = true;
             stopEventPublisherTimeout_1 = setTimeout(originalStart_1, eventsFirstPushWindow);
         };
         var originalStop_1 = syncTask.stop;
         syncTask.stop = function () {
+            running_1 = false;
             clearTimeout(stopEventPublisherTimeout_1);
             originalStop_1();
         };
+        syncTask.isRunning = function () {
+            return running_1;
+        };
     }
-    // register eventsSubmitter to be executed when events cache is full
+    // register events submitter to be executed when events cache is full
     eventsCache.setOnFullQueueCb(function () {
-        log.info(constants_1.SUBMITTERS_PUSH_FULL_EVENTS_QUEUE);
-        syncTask.execute();
+        if (syncTask.isRunning()) {
+            log.info(constants_1.SUBMITTERS_PUSH_FULL_QUEUE, [DATA_NAME]);
+            syncTask.execute();
+        }
+        // If submitter is stopped (e.g., user consent declined or unknown, or app state offline), we don't send the data.
+        // Data will be sent when submitter is resumed.
     });
     return syncTask;
 }

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

@@ -3,14 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.impressionsSyncTaskFactory = exports.fromImpressionsCollector = void 0;
 var lang_1 = require("../../utils/lang");
 var submitterSyncTask_1 = require("./submitterSyncTask");
+var constants_1 = require("../../logger/constants");
+var DATA_NAME = 'impressions';
 /**
  * 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 +38,16 @@ 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);
+    var syncTask = (0, submitterSyncTask_1.submitterSyncTaskFactory)(log, postTestImpressionsBulk, impressionsCache, impressionsRefreshRate, DATA_NAME, latencyTracker, fromImpressionsCollector.bind(undefined, sendLabels), 1);
+    // register impressions submitter to be executed when impressions cache is full
+    impressionsCache.setOnFullQueueCb(function () {
+        if (syncTask.isRunning()) {
+            log.info(constants_1.SUBMITTERS_PUSH_FULL_QUEUE, [DATA_NAME]);
+            syncTask.execute();
+        }
+        // If submitter is stopped (e.g., user consent declined or unknown, or app state offline), we don't send the data.
+        // Data will be sent when submitter is resumed.
+    });
+    return syncTask;
 }
 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

@@ -4,6 +4,7 @@ exports.syncManagerOnlineFactory = void 0;
 var submitterManager_1 = require("./submitters/submitterManager");
 var constants_1 = require("./streaming/constants");
 var constants_2 = require("../logger/constants");
+var consent_1 = require("../utils/consent");
 /**
  * Online SyncManager factory.
  * Can be used for server-side API, and client-side API with or without multiple clients.
@@ -16,26 +17,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 settings = params.settings, _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() {
@@ -53,11 +53,16 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
         var running = false; // flag that indicates whether the syncManager has been started (true) or stopped (false)
         var startFirstTime = true; // flag to distinguish calling the `start` method for the first time, to support pausing and resuming the synchronization
         return {
+            // Exposed for fine-grained control of synchronization.
+            // E.g.: user consent, app state changes (Page hide, Foreground/Background, Online/Offline).
+            pollingManager: pollingManager,
             pushManager: pushManager,
+            submitter: submitter,
             /**
              * Method used to start the syncManager for the first time, or resume it after being stopped.
              */
             start: function () {
+                running = true;
                 // start syncing splits and segments
                 if (pollingManager) {
                     if (pushManager) {
@@ -73,28 +78,27 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
                     }
                 }
                 // start periodic data recording (events, impressions, telemetry).
-                submitter && submitter.start();
-                running = true;
+                if ((0, consent_1.isConsentGranted)(settings))
+                    submitter.start();
             },
             /**
              * Method used to stop/pause the syncManager.
              */
             stop: function () {
+                running = false;
                 // stop syncing
                 if (pushManager)
                     pushManager.stop();
                 if (pollingManager && pollingManager.isRunning())
                     pollingManager.stop();
                 // stop periodic data recording (events, impressions, telemetry).
-                if (submitter)
-                    submitter.stop();
-                running = false;
+                submitter.stop();
             },
             isRunning: function () {
                 return running;
             },
             flush: function () {
-                if (submitter)
+                if ((0, consent_1.isConsentGranted)(settings))
                     return submitter.execute();
                 else
                     return Promise.resolve();

package/cjs/trackers/eventTracker.js

@@ -4,13 +4,17 @@ exports.eventTrackerFactory = void 0;
 var objectAssign_1 = require("../utils/lang/objectAssign");
 var thenable_1 = require("../utils/promise/thenable");
 var constants_1 = require("../logger/constants");
+var constants_2 = require("../utils/constants");
+var utils_1 = require("./impressionObserver/utils");
 /**
  * Event tracker stores events in cache and pass them to the integrations manager if provided.
  *
  * @param eventsCache cache to save events
  * @param integrationsManager optional event handler used for integrations
  */
-function eventTrackerFactory(log, eventsCache, integrationsManager) {
+function eventTrackerFactory(settings, eventsCache, integrationsManager) {
+    var log = settings.log;
+    var isSync = (0, utils_1.isStorageSync)(settings);
     function queueEventsCallback(eventData, tracked) {
         var eventTypeId = eventData.eventTypeId, trafficTypeName = eventData.trafficTypeName, key = eventData.key, value = eventData.value, timestamp = eventData.timestamp, properties = eventData.properties;
         // Logging every prop would be too much.
@@ -21,9 +25,9 @@ function eventTrackerFactory(log, eventsCache, 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 = objectAssign_1.objectAssign({}, eventData);
+                    var eventDataCopy = (0, objectAssign_1.objectAssign)({}, eventData);
                     if (eventData.properties)
-                        eventDataCopy.properties = objectAssign_1.objectAssign({}, eventData.properties);
+                        eventDataCopy.properties = (0, objectAssign_1.objectAssign)({}, eventData.properties);
                     // integrationsManager does not throw errors (they are internally handled by each integration module)
                     integrationsManager.handleEvent(eventDataCopy);
                 }, 0);
@@ -36,8 +40,11 @@ function eventTrackerFactory(log, eventsCache, integrationsManager) {
     }
     return {
         track: function (eventData, size) {
+            if (settings.userConsent === constants_2.CONSENT_DECLINED) {
+                return isSync ? false : Promise.resolve(false);
+            }
             var tracked = eventsCache.track(eventData, size);
-            if (thenable_1.thenable(tracked)) {
+            if ((0, thenable_1.thenable)(tracked)) {
                 return tracked.then(queueEventsCallback.bind(null, eventData));
             }
             else {

package/cjs/trackers/impressionObserver/impressionObserverCS.js

@@ -5,7 +5,7 @@ var ImpressionObserver_1 = require("./ImpressionObserver");
 var murmur3_1 = require("../../utils/murmur3/murmur3");
 var buildKey_1 = require("./buildKey");
 function hashImpression32(impression) {
-    return murmur3_1.hash(buildKey_1.buildKey(impression));
+    return (0, murmur3_1.hash)((0, buildKey_1.buildKey)(impression));
 }
 exports.hashImpression32 = hashImpression32;
 var LAST_SEEN_CACHE_SIZE = 500; // cache up to 500 impression hashes